1 @c Copyright (C) 1988,89,92,93,94,96 Free Software Foundation, Inc.
2 @c This is part of the GCC manual.
3 @c For copying conditions, see the file gcc.texi.
6 @chapter Extensions to the C Language Family
7 @cindex extensions, C language
8 @cindex C language extensions
10 GNU C provides several language features not found in ANSI standard C.
11 (The @samp{-pedantic} option directs GNU CC to print a warning message if
12 any of these features is used.) To test for the availability of these
13 features in conditional compilation, check for a predefined macro
14 @code{__GNUC__}, which is always defined under GNU CC.
16 These extensions are available in C and Objective C. Most of them are
17 also available in C++. @xref{C++ Extensions,,Extensions to the
18 C++ Language}, for extensions that apply @emph{only} to C++.
20 @c The only difference between the two versions of this menu is that the
21 @c version for clear INTERNALS has an extra node, "Constraints" (which
22 @c appears in a separate chapter in the other version of the manual).
25 * Statement Exprs:: Putting statements and declarations inside expressions.
26 * Local Labels:: Labels local to a statement-expression.
27 * Labels as Values:: Getting pointers to labels, and computed gotos.
28 * Nested Functions:: As in Algol and Pascal, lexical scoping of functions.
29 * Constructing Calls:: Dispatching a call to another function.
30 * Naming Types:: Giving a name to the type of some expression.
31 * Typeof:: @code{typeof}: referring to the type of an expression.
32 * Lvalues:: Using @samp{?:}, @samp{,} and casts in lvalues.
33 * Conditionals:: Omitting the middle operand of a @samp{?:} expression.
34 * Long Long:: Double-word integers---@code{long long int}.
35 * Complex:: Data types for complex numbers.
36 * Hex Floats:: Hexadecimal floating-point constants.
37 * Zero Length:: Zero-length arrays.
38 * Variable Length:: Arrays whose length is computed at run time.
39 * Macro Varargs:: Macros with variable number of arguments.
40 * Subscripting:: Any array can be subscripted, even if not an lvalue.
41 * Pointer Arith:: Arithmetic on @code{void}-pointers and function pointers.
42 * Initializers:: Non-constant initializers.
43 * Constructors:: Constructor expressions give structures, unions
45 * Labeled Elements:: Labeling elements of initializers.
46 * Cast to Union:: Casting to union type from any member of the union.
47 * Case Ranges:: `case 1 ... 9' and such.
48 * Function Attributes:: Declaring that functions have no side effects,
49 or that they can never return.
50 * Function Prototypes:: Prototype declarations and old-style definitions.
51 * C++ Comments:: C++ comments are recognized.
52 * Dollar Signs:: Dollar sign is allowed in identifiers.
53 * Character Escapes:: @samp{\e} stands for the character @key{ESC}.
54 * Variable Attributes:: Specifying attributes of variables.
55 * Type Attributes:: Specifying attributes of types.
56 * Alignment:: Inquiring about the alignment of a type or variable.
57 * Inline:: Defining inline functions (as fast as macros).
58 * Extended Asm:: Assembler instructions with C expressions as operands.
59 (With them you can define ``built-in'' functions.)
60 * Asm Labels:: Specifying the assembler name to use for a C symbol.
61 * Explicit Reg Vars:: Defining variables residing in specified registers.
62 * Alternate Keywords:: @code{__const__}, @code{__asm__}, etc., for header files.
63 * Incomplete Enums:: @code{enum foo;}, with details to follow.
64 * Function Names:: Printable strings which are the name of the current
66 * Return Address:: Getting the return or frame address of a function.
71 * Statement Exprs:: Putting statements and declarations inside expressions.
72 * Local Labels:: Labels local to a statement-expression.
73 * Labels as Values:: Getting pointers to labels, and computed gotos.
74 * Nested Functions:: As in Algol and Pascal, lexical scoping of functions.
75 * Constructing Calls:: Dispatching a call to another function.
76 * Naming Types:: Giving a name to the type of some expression.
77 * Typeof:: @code{typeof}: referring to the type of an expression.
78 * Lvalues:: Using @samp{?:}, @samp{,} and casts in lvalues.
79 * Conditionals:: Omitting the middle operand of a @samp{?:} expression.
80 * Long Long:: Double-word integers---@code{long long int}.
81 * Complex:: Data types for complex numbers.
82 * Hex Floats:: Hexadecimal floating-point constants.
83 * Zero Length:: Zero-length arrays.
84 * Variable Length:: Arrays whose length is computed at run time.
85 * Macro Varargs:: Macros with variable number of arguments.
86 * Subscripting:: Any array can be subscripted, even if not an lvalue.
87 * Pointer Arith:: Arithmetic on @code{void}-pointers and function pointers.
88 * Initializers:: Non-constant initializers.
89 * Constructors:: Constructor expressions give structures, unions
91 * Labeled Elements:: Labeling elements of initializers.
92 * Cast to Union:: Casting to union type from any member of the union.
93 * Case Ranges:: `case 1 ... 9' and such.
94 * Function Attributes:: Declaring that functions have no side effects,
95 or that they can never return.
96 * Function Prototypes:: Prototype declarations and old-style definitions.
97 * C++ Comments:: C++ comments are recognized.
98 * Dollar Signs:: Dollar sign is allowed in identifiers.
99 * Character Escapes:: @samp{\e} stands for the character @key{ESC}.
100 * Variable Attributes:: Specifying attributes of variables.
101 * Type Attributes:: Specifying attributes of types.
102 * Alignment:: Inquiring about the alignment of a type or variable.
103 * Inline:: Defining inline functions (as fast as macros).
104 * Extended Asm:: Assembler instructions with C expressions as operands.
105 (With them you can define ``built-in'' functions.)
106 * Constraints:: Constraints for asm operands
107 * Asm Labels:: Specifying the assembler name to use for a C symbol.
108 * Explicit Reg Vars:: Defining variables residing in specified registers.
109 * Alternate Keywords:: @code{__const__}, @code{__asm__}, etc., for header files.
110 * Incomplete Enums:: @code{enum foo;}, with details to follow.
111 * Function Names:: Printable strings which are the name of the current
113 * Return Address:: Getting the return or frame address of a function.
117 @node Statement Exprs
118 @section Statements and Declarations in Expressions
119 @cindex statements inside expressions
120 @cindex declarations inside expressions
121 @cindex expressions containing statements
122 @cindex macros, statements in expressions
124 @c the above section title wrapped and causes an underfull hbox.. i
125 @c changed it from "within" to "in". --mew 4feb93
127 A compound statement enclosed in parentheses may appear as an expression
128 in GNU C. This allows you to use loops, switches, and local variables
129 within an expression.
131 Recall that a compound statement is a sequence of statements surrounded
132 by braces; in this construct, parentheses go around the braces. For
136 (@{ int y = foo (); int z;
143 is a valid (though slightly more complex than necessary) expression
144 for the absolute value of @code{foo ()}.
146 The last thing in the compound statement should be an expression
147 followed by a semicolon; the value of this subexpression serves as the
148 value of the entire construct. (If you use some other kind of statement
149 last within the braces, the construct has type @code{void}, and thus
150 effectively no value.)
152 This feature is especially useful in making macro definitions ``safe'' (so
153 that they evaluate each operand exactly once). For example, the
154 ``maximum'' function is commonly defined as a macro in standard C as
158 #define max(a,b) ((a) > (b) ? (a) : (b))
162 @cindex side effects, macro argument
163 But this definition computes either @var{a} or @var{b} twice, with bad
164 results if the operand has side effects. In GNU C, if you know the
165 type of the operands (here let's assume @code{int}), you can define
166 the macro safely as follows:
169 #define maxint(a,b) \
170 (@{int _a = (a), _b = (b); _a > _b ? _a : _b; @})
173 Embedded statements are not allowed in constant expressions, such as
174 the value of an enumeration constant, the width of a bit field, or
175 the initial value of a static variable.
177 If you don't know the type of the operand, you can still do this, but you
178 must use @code{typeof} (@pxref{Typeof}) or type naming (@pxref{Naming
182 @section Locally Declared Labels
184 @cindex macros, local labels
186 Each statement expression is a scope in which @dfn{local labels} can be
187 declared. A local label is simply an identifier; you can jump to it
188 with an ordinary @code{goto} statement, but only from within the
189 statement expression it belongs to.
191 A local label declaration looks like this:
194 __label__ @var{label};
201 __label__ @var{label1}, @var{label2}, @dots{};
204 Local label declarations must come at the beginning of the statement
205 expression, right after the @samp{(@{}, before any ordinary
208 The label declaration defines the label @emph{name}, but does not define
209 the label itself. You must do this in the usual way, with
210 @code{@var{label}:}, within the statements of the statement expression.
212 The local label feature is useful because statement expressions are
213 often used in macros. If the macro contains nested loops, a @code{goto}
214 can be useful for breaking out of them. However, an ordinary label
215 whose scope is the whole function cannot be used: if the macro can be
216 expanded several times in one function, the label will be multiply
217 defined in that function. A local label avoids this problem. For
221 #define SEARCH(array, target) \
224 typeof (target) _SEARCH_target = (target); \
225 typeof (*(array)) *_SEARCH_array = (array); \
228 for (i = 0; i < max; i++) \
229 for (j = 0; j < max; j++) \
230 if (_SEARCH_array[i][j] == _SEARCH_target) \
231 @{ value = i; goto found; @} \
238 @node Labels as Values
239 @section Labels as Values
240 @cindex labels as values
241 @cindex computed gotos
242 @cindex goto with computed label
243 @cindex address of a label
245 You can get the address of a label defined in the current function
246 (or a containing function) with the unary operator @samp{&&}. The
247 value has type @code{void *}. This value is a constant and can be used
248 wherever a constant of that type is valid. For example:
256 To use these values, you need to be able to jump to one. This is done
257 with the computed goto statement@footnote{The analogous feature in
258 Fortran is called an assigned goto, but that name seems inappropriate in
259 C, where one can do more than simply store label addresses in label
260 variables.}, @code{goto *@var{exp};}. For example,
267 Any expression of type @code{void *} is allowed.
269 One way of using these constants is in initializing a static array that
270 will serve as a jump table:
273 static void *array[] = @{ &&foo, &&bar, &&hack @};
276 Then you can select a label with indexing, like this:
283 Note that this does not check whether the subscript is in bounds---array
284 indexing in C never does that.
286 Such an array of label values serves a purpose much like that of the
287 @code{switch} statement. The @code{switch} statement is cleaner, so
288 use that rather than an array unless the problem does not fit a
289 @code{switch} statement very well.
291 Another use of label values is in an interpreter for threaded code.
292 The labels within the interpreter function can be stored in the
293 threaded code for super-fast dispatching.
295 You can use this mechanism to jump to code in a different function. If
296 you do that, totally unpredictable things will happen. The best way to
297 avoid this is to store the label address only in automatic variables and
298 never pass it as an argument.
300 @node Nested Functions
301 @section Nested Functions
302 @cindex nested functions
303 @cindex downward funargs
306 A @dfn{nested function} is a function defined inside another function.
307 (Nested functions are not supported for GNU C++.) The nested function's
308 name is local to the block where it is defined. For example, here we
309 define a nested function named @code{square}, and call it twice:
313 foo (double a, double b)
315 double square (double z) @{ return z * z; @}
317 return square (a) + square (b);
322 The nested function can access all the variables of the containing
323 function that are visible at the point of its definition. This is
324 called @dfn{lexical scoping}. For example, here we show a nested
325 function which uses an inherited variable named @code{offset}:
328 bar (int *array, int offset, int size)
330 int access (int *array, int index)
331 @{ return array[index + offset]; @}
334 for (i = 0; i < size; i++)
335 @dots{} access (array, i) @dots{}
339 Nested function definitions are permitted within functions in the places
340 where variable definitions are allowed; that is, in any block, before
341 the first statement in the block.
343 It is possible to call the nested function from outside the scope of its
344 name by storing its address or passing the address to another function:
347 hack (int *array, int size)
349 void store (int index, int value)
350 @{ array[index] = value; @}
352 intermediate (store, size);
356 Here, the function @code{intermediate} receives the address of
357 @code{store} as an argument. If @code{intermediate} calls @code{store},
358 the arguments given to @code{store} are used to store into @code{array}.
359 But this technique works only so long as the containing function
360 (@code{hack}, in this example) does not exit.
362 If you try to call the nested function through its address after the
363 containing function has exited, all hell will break loose. If you try
364 to call it after a containing scope level has exited, and if it refers
365 to some of the variables that are no longer in scope, you may be lucky,
366 but it's not wise to take the risk. If, however, the nested function
367 does not refer to anything that has gone out of scope, you should be
370 GNU CC implements taking the address of a nested function using a
371 technique called @dfn{trampolines}. A paper describing them is
372 available as @samp{http://master.debian.org/~karlheg/Usenix88-lexic.pdf}.
374 A nested function can jump to a label inherited from a containing
375 function, provided the label was explicitly declared in the containing
376 function (@pxref{Local Labels}). Such a jump returns instantly to the
377 containing function, exiting the nested function which did the
378 @code{goto} and any intermediate functions as well. Here is an example:
382 bar (int *array, int offset, int size)
385 int access (int *array, int index)
389 return array[index + offset];
393 for (i = 0; i < size; i++)
394 @dots{} access (array, i) @dots{}
398 /* @r{Control comes here from @code{access}
399 if it detects an error.} */
406 A nested function always has internal linkage. Declaring one with
407 @code{extern} is erroneous. If you need to declare the nested function
408 before its definition, use @code{auto} (which is otherwise meaningless
409 for function declarations).
412 bar (int *array, int offset, int size)
415 auto int access (int *, int);
417 int access (int *array, int index)
421 return array[index + offset];
427 @node Constructing Calls
428 @section Constructing Function Calls
429 @cindex constructing calls
430 @cindex forwarding calls
432 Using the built-in functions described below, you can record
433 the arguments a function received, and call another function
434 with the same arguments, without knowing the number or types
437 You can also record the return value of that function call,
438 and later return that value, without knowing what data type
439 the function tried to return (as long as your caller expects
443 @findex __builtin_apply_args
444 @item __builtin_apply_args ()
445 This built-in function returns a pointer of type @code{void *} to data
446 describing how to perform a call with the same arguments as were passed
447 to the current function.
449 The function saves the arg pointer register, structure value address,
450 and all registers that might be used to pass arguments to a function
451 into a block of memory allocated on the stack. Then it returns the
452 address of that block.
454 @findex __builtin_apply
455 @item __builtin_apply (@var{function}, @var{arguments}, @var{size})
456 This built-in function invokes @var{function} (type @code{void (*)()})
457 with a copy of the parameters described by @var{arguments} (type
458 @code{void *}) and @var{size} (type @code{int}).
460 The value of @var{arguments} should be the value returned by
461 @code{__builtin_apply_args}. The argument @var{size} specifies the size
462 of the stack argument data, in bytes.
464 This function returns a pointer of type @code{void *} to data describing
465 how to return whatever value was returned by @var{function}. The data
466 is saved in a block of memory allocated on the stack.
468 It is not always simple to compute the proper value for @var{size}. The
469 value is used by @code{__builtin_apply} to compute the amount of data
470 that should be pushed on the stack and copied from the incoming argument
473 @findex __builtin_return
474 @item __builtin_return (@var{result})
475 This built-in function returns the value described by @var{result} from
476 the containing function. You should specify, for @var{result}, a value
477 returned by @code{__builtin_apply}.
481 @section Naming an Expression's Type
484 You can give a name to the type of an expression using a @code{typedef}
485 declaration with an initializer. Here is how to define @var{name} as a
486 type name for the type of @var{exp}:
489 typedef @var{name} = @var{exp};
492 This is useful in conjunction with the statements-within-expressions
493 feature. Here is how the two together can be used to define a safe
494 ``maximum'' macro that operates on any arithmetic type:
498 (@{typedef _ta = (a), _tb = (b); \
499 _ta _a = (a); _tb _b = (b); \
500 _a > _b ? _a : _b; @})
503 @cindex underscores in variables in macros
504 @cindex @samp{_} in variables in macros
505 @cindex local variables in macros
506 @cindex variables, local, in macros
507 @cindex macros, local variables in
509 The reason for using names that start with underscores for the local
510 variables is to avoid conflicts with variable names that occur within the
511 expressions that are substituted for @code{a} and @code{b}. Eventually we
512 hope to design a new form of declaration syntax that allows you to declare
513 variables whose scopes start only after their initializers; this will be a
514 more reliable way to prevent such conflicts.
517 @section Referring to a Type with @code{typeof}
520 @cindex macros, types of arguments
522 Another way to refer to the type of an expression is with @code{typeof}.
523 The syntax of using of this keyword looks like @code{sizeof}, but the
524 construct acts semantically like a type name defined with @code{typedef}.
526 There are two ways of writing the argument to @code{typeof}: with an
527 expression or with a type. Here is an example with an expression:
534 This assumes that @code{x} is an array of functions; the type described
535 is that of the values of the functions.
537 Here is an example with a typename as the argument:
544 Here the type described is that of pointers to @code{int}.
546 If you are writing a header file that must work when included in ANSI C
547 programs, write @code{__typeof__} instead of @code{typeof}.
548 @xref{Alternate Keywords}.
550 A @code{typeof}-construct can be used anywhere a typedef name could be
551 used. For example, you can use it in a declaration, in a cast, or inside
552 of @code{sizeof} or @code{typeof}.
556 This declares @code{y} with the type of what @code{x} points to.
563 This declares @code{y} as an array of such values.
570 This declares @code{y} as an array of pointers to characters:
573 typeof (typeof (char *)[4]) y;
577 It is equivalent to the following traditional C declaration:
583 To see the meaning of the declaration using @code{typeof}, and why it
584 might be a useful way to write, let's rewrite it with these macros:
587 #define pointer(T) typeof(T *)
588 #define array(T, N) typeof(T [N])
592 Now the declaration can be rewritten this way:
595 array (pointer (char), 4) y;
599 Thus, @code{array (pointer (char), 4)} is the type of arrays of 4
600 pointers to @code{char}.
604 @section Generalized Lvalues
605 @cindex compound expressions as lvalues
606 @cindex expressions, compound, as lvalues
607 @cindex conditional expressions as lvalues
608 @cindex expressions, conditional, as lvalues
609 @cindex casts as lvalues
610 @cindex generalized lvalues
611 @cindex lvalues, generalized
612 @cindex extensions, @code{?:}
613 @cindex @code{?:} extensions
614 Compound expressions, conditional expressions and casts are allowed as
615 lvalues provided their operands are lvalues. This means that you can take
616 their addresses or store values into them.
618 Standard C++ allows compound expressions and conditional expressions as
619 lvalues, and permits casts to reference type, so use of this extension
620 is deprecated for C++ code.
622 For example, a compound expression can be assigned, provided the last
623 expression in the sequence is an lvalue. These two expressions are
631 Similarly, the address of the compound expression can be taken. These two
632 expressions are equivalent:
639 A conditional expression is a valid lvalue if its type is not void and the
640 true and false branches are both valid lvalues. For example, these two
641 expressions are equivalent:
645 (a ? b = 5 : (c = 5))
648 A cast is a valid lvalue if its operand is an lvalue. A simple
649 assignment whose left-hand side is a cast works by converting the
650 right-hand side first to the specified type, then to the type of the
651 inner left-hand side expression. After this is stored, the value is
652 converted back to the specified type to become the value of the
653 assignment. Thus, if @code{a} has type @code{char *}, the following two
654 expressions are equivalent:
658 (int)(a = (char *)(int)5)
661 An assignment-with-arithmetic operation such as @samp{+=} applied to a cast
662 performs the arithmetic using the type resulting from the cast, and then
663 continues as in the previous case. Therefore, these two expressions are
668 (int)(a = (char *)(int) ((int)a + 5))
671 You cannot take the address of an lvalue cast, because the use of its
672 address would not work out coherently. Suppose that @code{&(int)f} were
673 permitted, where @code{f} has type @code{float}. Then the following
674 statement would try to store an integer bit-pattern where a floating
675 point number belongs:
681 This is quite different from what @code{(int)f = 1} would do---that
682 would convert 1 to floating point and store it. Rather than cause this
683 inconsistency, we think it is better to prohibit use of @samp{&} on a cast.
685 If you really do want an @code{int *} pointer with the address of
686 @code{f}, you can simply write @code{(int *)&f}.
689 @section Conditionals with Omitted Operands
690 @cindex conditional expressions, extensions
691 @cindex omitted middle-operands
692 @cindex middle-operands, omitted
693 @cindex extensions, @code{?:}
694 @cindex @code{?:} extensions
696 The middle operand in a conditional expression may be omitted. Then
697 if the first operand is nonzero, its value is the value of the conditional
700 Therefore, the expression
707 has the value of @code{x} if that is nonzero; otherwise, the value of
710 This example is perfectly equivalent to
716 @cindex side effect in ?:
717 @cindex ?: side effect
719 In this simple case, the ability to omit the middle operand is not
720 especially useful. When it becomes useful is when the first operand does,
721 or may (if it is a macro argument), contain a side effect. Then repeating
722 the operand in the middle would perform the side effect twice. Omitting
723 the middle operand uses the value already computed without the undesirable
724 effects of recomputing it.
727 @section Double-Word Integers
728 @cindex @code{long long} data types
729 @cindex double-word arithmetic
730 @cindex multiprecision arithmetic
732 GNU C supports data types for integers that are twice as long as
733 @code{int}. Simply write @code{long long int} for a signed integer, or
734 @code{unsigned long long int} for an unsigned integer. To make an
735 integer constant of type @code{long long int}, add the suffix @code{LL}
736 to the integer. To make an integer constant of type @code{unsigned long
737 long int}, add the suffix @code{ULL} to the integer.
739 You can use these types in arithmetic like any other integer types.
740 Addition, subtraction, and bitwise boolean operations on these types
741 are open-coded on all types of machines. Multiplication is open-coded
742 if the machine supports fullword-to-doubleword a widening multiply
743 instruction. Division and shifts are open-coded only on machines that
744 provide special support. The operations that are not open-coded use
745 special library routines that come with GNU CC.
747 There may be pitfalls when you use @code{long long} types for function
748 arguments, unless you declare function prototypes. If a function
749 expects type @code{int} for its argument, and you pass a value of type
750 @code{long long int}, confusion will result because the caller and the
751 subroutine will disagree about the number of bytes for the argument.
752 Likewise, if the function expects @code{long long int} and you pass
753 @code{int}. The best way to avoid such problems is to use prototypes.
756 @section Complex Numbers
757 @cindex complex numbers
759 GNU C supports complex data types. You can declare both complex integer
760 types and complex floating types, using the keyword @code{__complex__}.
762 For example, @samp{__complex__ double x;} declares @code{x} as a
763 variable whose real part and imaginary part are both of type
764 @code{double}. @samp{__complex__ short int y;} declares @code{y} to
765 have real and imaginary parts of type @code{short int}; this is not
766 likely to be useful, but it shows that the set of complex types is
769 To write a constant with a complex data type, use the suffix @samp{i} or
770 @samp{j} (either one; they are equivalent). For example, @code{2.5fi}
771 has type @code{__complex__ float} and @code{3i} has type
772 @code{__complex__ int}. Such a constant always has a pure imaginary
773 value, but you can form any complex value you like by adding one to a
776 To extract the real part of a complex-valued expression @var{exp}, write
777 @code{__real__ @var{exp}}. Likewise, use @code{__imag__} to
778 extract the imaginary part.
780 The operator @samp{~} performs complex conjugation when used on a value
783 GNU CC can allocate complex automatic variables in a noncontiguous
784 fashion; it's even possible for the real part to be in a register while
785 the imaginary part is on the stack (or vice-versa). None of the
786 supported debugging info formats has a way to represent noncontiguous
787 allocation like this, so GNU CC describes a noncontiguous complex
788 variable as if it were two separate variables of noncomplex type.
789 If the variable's actual name is @code{foo}, the two fictitious
790 variables are named @code{foo$real} and @code{foo$imag}. You can
791 examine and set these two fictitious variables with your debugger.
793 A future version of GDB will know how to recognize such pairs and treat
794 them as a single variable with a complex type.
799 GNU CC recognizes floating-point numbers written not only in the usual
800 decimal notation, such as @code{1.55e1}, but also numbers such as
801 @code{0x1.fp3} written in hexadecimal format. In that format the
802 @code{0x} hex introducer and the @code{p} or @code{P} exponent field are
803 mandatory. The exponent is a decimal number that indicates the power of
804 2 by which the significand part will be multiplied. Thus @code{0x1.f} is
805 1 15/16, @code{p3} multiplies it by 8, and the value of @code{0x1.fp3}
806 is the same as @code{1.55e1}.
808 Unlike for floating-point numbers in the decimal notation the exponent
809 is always required in the hexadecimal notation. Otherwise the compiler
810 would not be able to resolve the ambiguity of, e.g., @code{0x1.f}. This
811 could mean @code{1.0f} or @code{1.9375} since @code{f} is also the
812 extension for floating-point constants of type @code{float}.
815 @section Arrays of Length Zero
816 @cindex arrays of length zero
817 @cindex zero-length arrays
818 @cindex length-zero arrays
820 Zero-length arrays are allowed in GNU C. They are very useful as the last
821 element of a structure which is really a header for a variable-length
831 struct line *thisline = (struct line *)
832 malloc (sizeof (struct line) + this_length);
833 thisline->length = this_length;
837 In standard C, you would have to give @code{contents} a length of 1, which
838 means either you waste space or complicate the argument to @code{malloc}.
840 @node Variable Length
841 @section Arrays of Variable Length
842 @cindex variable-length arrays
843 @cindex arrays of variable length
845 Variable-length automatic arrays are allowed in GNU C. These arrays are
846 declared like any other automatic arrays, but with a length that is not
847 a constant expression. The storage is allocated at the point of
848 declaration and deallocated when the brace-level is exited. For
853 concat_fopen (char *s1, char *s2, char *mode)
855 char str[strlen (s1) + strlen (s2) + 1];
858 return fopen (str, mode);
862 @cindex scope of a variable length array
863 @cindex variable-length array scope
864 @cindex deallocating variable length arrays
865 Jumping or breaking out of the scope of the array name deallocates the
866 storage. Jumping into the scope is not allowed; you get an error
869 @cindex @code{alloca} vs variable-length arrays
870 You can use the function @code{alloca} to get an effect much like
871 variable-length arrays. The function @code{alloca} is available in
872 many other C implementations (but not in all). On the other hand,
873 variable-length arrays are more elegant.
875 There are other differences between these two methods. Space allocated
876 with @code{alloca} exists until the containing @emph{function} returns.
877 The space for a variable-length array is deallocated as soon as the array
878 name's scope ends. (If you use both variable-length arrays and
879 @code{alloca} in the same function, deallocation of a variable-length array
880 will also deallocate anything more recently allocated with @code{alloca}.)
882 You can also use variable-length arrays as arguments to functions:
886 tester (int len, char data[len][len])
892 The length of an array is computed once when the storage is allocated
893 and is remembered for the scope of the array in case you access it with
896 If you want to pass the array first and the length afterward, you can
897 use a forward declaration in the parameter list---another GNU extension.
901 tester (int len; char data[len][len], int len)
907 @cindex parameter forward declaration
908 The @samp{int len} before the semicolon is a @dfn{parameter forward
909 declaration}, and it serves the purpose of making the name @code{len}
910 known when the declaration of @code{data} is parsed.
912 You can write any number of such parameter forward declarations in the
913 parameter list. They can be separated by commas or semicolons, but the
914 last one must end with a semicolon, which is followed by the ``real''
915 parameter declarations. Each forward declaration must match a ``real''
916 declaration in parameter name and data type.
919 @section Macros with Variable Numbers of Arguments
920 @cindex variable number of arguments
921 @cindex macro with variable arguments
922 @cindex rest argument (in macro)
924 In GNU C, a macro can accept a variable number of arguments, much as a
925 function can. The syntax for defining the macro looks much like that
926 used for a function. Here is an example:
929 #define eprintf(format, args...) \
930 fprintf (stderr, format , ## args)
933 Here @code{args} is a @dfn{rest argument}: it takes in zero or more
934 arguments, as many as the call contains. All of them plus the commas
935 between them form the value of @code{args}, which is substituted into
936 the macro body where @code{args} is used. Thus, we have this expansion:
939 eprintf ("%s:%d: ", input_file_name, line_number)
941 fprintf (stderr, "%s:%d: " , input_file_name, line_number)
945 Note that the comma after the string constant comes from the definition
946 of @code{eprintf}, whereas the last comma comes from the value of
949 The reason for using @samp{##} is to handle the case when @code{args}
950 matches no arguments at all. In this case, @code{args} has an empty
951 value. In this case, the second comma in the definition becomes an
952 embarrassment: if it got through to the expansion of the macro, we would
953 get something like this:
956 fprintf (stderr, "success!\n" , )
960 which is invalid C syntax. @samp{##} gets rid of the comma, so we get
961 the following instead:
964 fprintf (stderr, "success!\n")
967 This is a special feature of the GNU C preprocessor: @samp{##} before a
968 rest argument that is empty discards the preceding sequence of
969 non-whitespace characters from the macro definition. (If another macro
970 argument precedes, none of it is discarded.)
972 It might be better to discard the last preprocessor token instead of the
973 last preceding sequence of non-whitespace characters; in fact, we may
974 someday change this feature to do so. We advise you to write the macro
975 definition so that the preceding sequence of non-whitespace characters
976 is just a single token, so that the meaning will not change if we change
977 the definition of this feature.
980 @section Non-Lvalue Arrays May Have Subscripts
982 @cindex arrays, non-lvalue
984 @cindex subscripting and function values
985 Subscripting is allowed on arrays that are not lvalues, even though the
986 unary @samp{&} operator is not. For example, this is valid in GNU C though
987 not valid in other C dialects:
991 struct foo @{int a[4];@};
1003 @section Arithmetic on @code{void}- and Function-Pointers
1004 @cindex void pointers, arithmetic
1005 @cindex void, size of pointer to
1006 @cindex function pointers, arithmetic
1007 @cindex function, size of pointer to
1009 In GNU C, addition and subtraction operations are supported on pointers to
1010 @code{void} and on pointers to functions. This is done by treating the
1011 size of a @code{void} or of a function as 1.
1013 A consequence of this is that @code{sizeof} is also allowed on @code{void}
1014 and on function types, and returns 1.
1016 The option @samp{-Wpointer-arith} requests a warning if these extensions
1020 @section Non-Constant Initializers
1021 @cindex initializers, non-constant
1022 @cindex non-constant initializers
1024 As in standard C++, the elements of an aggregate initializer for an
1025 automatic variable are not required to be constant expressions in GNU C.
1026 Here is an example of an initializer with run-time varying elements:
1029 foo (float f, float g)
1031 float beat_freqs[2] = @{ f-g, f+g @};
1037 @section Constructor Expressions
1038 @cindex constructor expressions
1039 @cindex initializations in expressions
1040 @cindex structures, constructor expression
1041 @cindex expressions, constructor
1043 GNU C supports constructor expressions. A constructor looks like
1044 a cast containing an initializer. Its value is an object of the
1045 type specified in the cast, containing the elements specified in
1048 Usually, the specified type is a structure. Assume that
1049 @code{struct foo} and @code{structure} are declared as shown:
1052 struct foo @{int a; char b[2];@} structure;
1056 Here is an example of constructing a @code{struct foo} with a constructor:
1059 structure = ((struct foo) @{x + y, 'a', 0@});
1063 This is equivalent to writing the following:
1067 struct foo temp = @{x + y, 'a', 0@};
1072 You can also construct an array. If all the elements of the constructor
1073 are (made up of) simple constant expressions, suitable for use in
1074 initializers, then the constructor is an lvalue and can be coerced to a
1075 pointer to its first element, as shown here:
1078 char **foo = (char *[]) @{ "x", "y", "z" @};
1081 Array constructors whose elements are not simple constants are
1082 not very useful, because the constructor is not an lvalue. There
1083 are only two valid ways to use it: to subscript it, or initialize
1084 an array variable with it. The former is probably slower than a
1085 @code{switch} statement, while the latter does the same thing an
1086 ordinary C initializer would do. Here is an example of
1087 subscripting an array constructor:
1090 output = ((int[]) @{ 2, x, 28 @}) [input];
1093 Constructor expressions for scalar types and union types are is
1094 also allowed, but then the constructor expression is equivalent
1097 @node Labeled Elements
1098 @section Labeled Elements in Initializers
1099 @cindex initializers with labeled elements
1100 @cindex labeled elements in initializers
1101 @cindex case labels in initializers
1103 Standard C requires the elements of an initializer to appear in a fixed
1104 order, the same as the order of the elements in the array or structure
1107 In GNU C you can give the elements in any order, specifying the array
1108 indices or structure field names they apply to. This extension is not
1109 implemented in GNU C++.
1111 To specify an array index, write @samp{[@var{index}]} or
1112 @samp{[@var{index}] =} before the element value. For example,
1115 int a[6] = @{ [4] 29, [2] = 15 @};
1122 int a[6] = @{ 0, 0, 15, 0, 29, 0 @};
1126 The index values must be constant expressions, even if the array being
1127 initialized is automatic.
1129 To initialize a range of elements to the same value, write
1130 @samp{[@var{first} ... @var{last}] = @var{value}}. For example,
1133 int widths[] = @{ [0 ... 9] = 1, [10 ... 99] = 2, [100] = 3 @};
1137 Note that the length of the array is the highest value specified
1140 In a structure initializer, specify the name of a field to initialize
1141 with @samp{@var{fieldname}:} before the element value. For example,
1142 given the following structure,
1145 struct point @{ int x, y; @};
1149 the following initialization
1152 struct point p = @{ y: yvalue, x: xvalue @};
1159 struct point p = @{ xvalue, yvalue @};
1162 Another syntax which has the same meaning is @samp{.@var{fieldname} =}.,
1166 struct point p = @{ .y = yvalue, .x = xvalue @};
1169 You can also use an element label (with either the colon syntax or the
1170 period-equal syntax) when initializing a union, to specify which element
1171 of the union should be used. For example,
1174 union foo @{ int i; double d; @};
1176 union foo f = @{ d: 4 @};
1180 will convert 4 to a @code{double} to store it in the union using
1181 the second element. By contrast, casting 4 to type @code{union foo}
1182 would store it into the union as the integer @code{i}, since it is
1183 an integer. (@xref{Cast to Union}.)
1185 You can combine this technique of naming elements with ordinary C
1186 initialization of successive elements. Each initializer element that
1187 does not have a label applies to the next consecutive element of the
1188 array or structure. For example,
1191 int a[6] = @{ [1] = v1, v2, [4] = v4 @};
1198 int a[6] = @{ 0, v1, v2, 0, v4, 0 @};
1201 Labeling the elements of an array initializer is especially useful
1202 when the indices are characters or belong to an @code{enum} type.
1207 = @{ [' '] = 1, ['\t'] = 1, ['\h'] = 1,
1208 ['\f'] = 1, ['\n'] = 1, ['\r'] = 1 @};
1212 @section Case Ranges
1214 @cindex ranges in case statements
1216 You can specify a range of consecutive values in a single @code{case} label,
1220 case @var{low} ... @var{high}:
1224 This has the same effect as the proper number of individual @code{case}
1225 labels, one for each integer value from @var{low} to @var{high}, inclusive.
1227 This feature is especially useful for ranges of ASCII character codes:
1233 @strong{Be careful:} Write spaces around the @code{...}, for otherwise
1234 it may be parsed wrong when you use it with integer values. For example,
1249 @section Cast to a Union Type
1250 @cindex cast to a union
1251 @cindex union, casting to a
1253 A cast to union type is similar to other casts, except that the type
1254 specified is a union type. You can specify the type either with
1255 @code{union @var{tag}} or with a typedef name. A cast to union is actually
1256 a constructor though, not a cast, and hence does not yield an lvalue like
1257 normal casts. (@xref{Constructors}.)
1259 The types that may be cast to the union type are those of the members
1260 of the union. Thus, given the following union and variables:
1263 union foo @{ int i; double d; @};
1269 both @code{x} and @code{y} can be cast to type @code{union} foo.
1271 Using the cast as the right-hand side of an assignment to a variable of
1272 union type is equivalent to storing in a member of the union:
1277 u = (union foo) x @equiv{} u.i = x
1278 u = (union foo) y @equiv{} u.d = y
1281 You can also use the union cast as a function argument:
1284 void hack (union foo);
1286 hack ((union foo) x);
1289 @node Function Attributes
1290 @section Declaring Attributes of Functions
1291 @cindex function attributes
1292 @cindex declaring attributes of functions
1293 @cindex functions that never return
1294 @cindex functions that have no side effects
1295 @cindex functions in arbitrary sections
1296 @cindex @code{volatile} applied to function
1297 @cindex @code{const} applied to function
1298 @cindex functions with @code{printf}, @code{scanf} or @code{strftime} style arguments
1299 @cindex functions that are passed arguments in registers on the 386
1300 @cindex functions that pop the argument stack on the 386
1301 @cindex functions that do not pop the argument stack on the 386
1303 In GNU C, you declare certain things about functions called in your program
1304 which help the compiler optimize function calls and check your code more
1307 The keyword @code{__attribute__} allows you to specify special
1308 attributes when making a declaration. This keyword is followed by an
1309 attribute specification inside double parentheses. Nine attributes,
1310 @code{noreturn}, @code{const}, @code{format},
1311 @code{no_instrument_function}, @code{section},
1312 @code{constructor}, @code{destructor}, @code{unused} and @code{weak} are
1313 currently defined for functions. Other attributes, including
1314 @code{section} are supported for variables declarations (@pxref{Variable
1315 Attributes}) and for types (@pxref{Type Attributes}).
1317 You may also specify attributes with @samp{__} preceding and following
1318 each keyword. This allows you to use them in header files without
1319 being concerned about a possible macro of the same name. For example,
1320 you may use @code{__noreturn__} instead of @code{noreturn}.
1323 @cindex @code{noreturn} function attribute
1325 A few standard library functions, such as @code{abort} and @code{exit},
1326 cannot return. GNU CC knows this automatically. Some programs define
1327 their own functions that never return. You can declare them
1328 @code{noreturn} to tell the compiler this fact. For example,
1331 void fatal () __attribute__ ((noreturn));
1336 @dots{} /* @r{Print error message.} */ @dots{}
1341 The @code{noreturn} keyword tells the compiler to assume that
1342 @code{fatal} cannot return. It can then optimize without regard to what
1343 would happen if @code{fatal} ever did return. This makes slightly
1344 better code. More importantly, it helps avoid spurious warnings of
1345 uninitialized variables.
1347 Do not assume that registers saved by the calling function are
1348 restored before calling the @code{noreturn} function.
1350 It does not make sense for a @code{noreturn} function to have a return
1351 type other than @code{void}.
1353 The attribute @code{noreturn} is not implemented in GNU C versions
1354 earlier than 2.5. An alternative way to declare that a function does
1355 not return, which works in the current version and in some older
1356 versions, is as follows:
1359 typedef void voidfn ();
1361 volatile voidfn fatal;
1364 @cindex @code{const} function attribute
1366 Many functions do not examine any values except their arguments, and
1367 have no effects except the return value. Such a function can be subject
1368 to common subexpression elimination and loop optimization just as an
1369 arithmetic operator would be. These functions should be declared
1370 with the attribute @code{const}. For example,
1373 int square (int) __attribute__ ((const));
1377 says that the hypothetical function @code{square} is safe to call
1378 fewer times than the program says.
1380 The attribute @code{const} is not implemented in GNU C versions earlier
1381 than 2.5. An alternative way to declare that a function has no side
1382 effects, which works in the current version and in some older versions,
1386 typedef int intfn ();
1388 extern const intfn square;
1391 This approach does not work in GNU C++ from 2.6.0 on, since the language
1392 specifies that the @samp{const} must be attached to the return value.
1394 @cindex pointer arguments
1395 Note that a function that has pointer arguments and examines the data
1396 pointed to must @emph{not} be declared @code{const}. Likewise, a
1397 function that calls a non-@code{const} function usually must not be
1398 @code{const}. It does not make sense for a @code{const} function to
1401 @item format (@var{archetype}, @var{string-index}, @var{first-to-check})
1402 @cindex @code{format} function attribute
1403 The @code{format} attribute specifies that a function takes @code{printf},
1404 @code{scanf}, or @code{strftime} style arguments which should be type-checked
1405 against a format string. For example, the declaration:
1409 my_printf (void *my_object, const char *my_format, ...)
1410 __attribute__ ((format (printf, 2, 3)));
1414 causes the compiler to check the arguments in calls to @code{my_printf}
1415 for consistency with the @code{printf} style format string argument
1418 The parameter @var{archetype} determines how the format string is
1419 interpreted, and should be either @code{printf}, @code{scanf}, or
1420 @code{strftime}. The
1421 parameter @var{string-index} specifies which argument is the format
1422 string argument (starting from 1), while @var{first-to-check} is the
1423 number of the first argument to check against the format string. For
1424 functions where the arguments are not available to be checked (such as
1425 @code{vprintf}), specify the third parameter as zero. In this case the
1426 compiler only checks the format string for consistency.
1428 In the example above, the format string (@code{my_format}) is the second
1429 argument of the function @code{my_print}, and the arguments to check
1430 start with the third argument, so the correct parameters for the format
1431 attribute are 2 and 3.
1433 The @code{format} attribute allows you to identify your own functions
1434 which take format strings as arguments, so that GNU CC can check the
1435 calls to these functions for errors. The compiler always checks formats
1436 for the ANSI library functions @code{printf}, @code{fprintf},
1437 @code{sprintf}, @code{scanf}, @code{fscanf}, @code{sscanf}, @code{strftime},
1438 @code{vprintf}, @code{vfprintf} and @code{vsprintf} whenever such
1439 warnings are requested (using @samp{-Wformat}), so there is no need to
1440 modify the header file @file{stdio.h}.
1442 @item format_arg (@var{string-index})
1443 @cindex @code{format_arg} function attribute
1444 The @code{format_arg} attribute specifies that a function takes
1445 @code{printf} or @code{scanf} style arguments, modifies it (for example,
1446 to translate it into another language), and passes it to a @code{printf}
1447 or @code{scanf} style function. For example, the declaration:
1451 my_dgettext (char *my_domain, const char *my_format)
1452 __attribute__ ((format_arg (2)));
1456 causes the compiler to check the arguments in calls to
1457 @code{my_dgettext} whose result is passed to a @code{printf},
1458 @code{scanf}, or @code{strftime} type function for consistency with the
1459 @code{printf} style format string argument @code{my_format}.
1461 The parameter @var{string-index} specifies which argument is the format
1462 string argument (starting from 1).
1464 The @code{format-arg} attribute allows you to identify your own
1465 functions which modify format strings, so that GNU CC can check the
1466 calls to @code{printf}, @code{scanf}, or @code{strftime} function whose
1467 operands are a call to one of your own function. The compiler always
1468 treats @code{gettext}, @code{dgettext}, and @code{dcgettext} in this
1471 @item no_instrument_function
1472 @cindex @code{no_instrument_function} function attribute
1473 If @samp{-finstrument-functions} is given, profiling function calls will
1474 be generated at entry and exit of most user-compiled functions.
1475 Functions with this attribute will not be so instrumented.
1477 @item section ("section-name")
1478 @cindex @code{section} function attribute
1479 Normally, the compiler places the code it generates in the @code{text} section.
1480 Sometimes, however, you need additional sections, or you need certain
1481 particular functions to appear in special sections. The @code{section}
1482 attribute specifies that a function lives in a particular section.
1483 For example, the declaration:
1486 extern void foobar (void) __attribute__ ((section ("bar")));
1490 puts the function @code{foobar} in the @code{bar} section.
1492 Some file formats do not support arbitrary sections so the @code{section}
1493 attribute is not available on all platforms.
1494 If you need to map the entire contents of a module to a particular
1495 section, consider using the facilities of the linker instead.
1499 @cindex @code{constructor} function attribute
1500 @cindex @code{destructor} function attribute
1501 The @code{constructor} attribute causes the function to be called
1502 automatically before execution enters @code{main ()}. Similarly, the
1503 @code{destructor} attribute causes the function to be called
1504 automatically after @code{main ()} has completed or @code{exit ()} has
1505 been called. Functions with these attributes are useful for
1506 initializing data that will be used implicitly during the execution of
1509 These attributes are not currently implemented for Objective C.
1512 This attribute, attached to a function, means that the function is meant
1513 to be possibly unused. GNU CC will not produce a warning for this
1514 function. GNU C++ does not currently support this attribute as
1515 definitions without parameters are valid in C++.
1518 @cindex @code{weak} attribute
1519 The @code{weak} attribute causes the declaration to be emitted as a weak
1520 symbol rather than a global. This is primarily useful in defining
1521 library functions which can be overridden in user code, though it can
1522 also be used with non-function declarations. Weak symbols are supported
1523 for ELF targets, and also for a.out targets when using the GNU assembler
1526 @item alias ("target")
1527 @cindex @code{alias} attribute
1528 The @code{alias} attribute causes the declaration to be emitted as an
1529 alias for another symbol, which must be specified. For instance,
1532 void __f () @{ /* do something */; @}
1533 void f () __attribute__ ((weak, alias ("__f")));
1536 declares @samp{f} to be a weak alias for @samp{__f}. In C++, the
1537 mangled name for the target must be used.
1539 Not all target machines support this attribute.
1541 @item no_check_memory_usage
1542 @cindex @code{no_check_memory_usage} function attribute
1543 If @samp{-fcheck-memory-usage} is given, calls to support routines will
1544 be generated before most memory accesses, to permit support code to
1545 record usage and detect uses of uninitialized or unallocated storage.
1546 Since the compiler cannot handle them properly, @code{asm} statements
1547 are not allowed. Declaring a function with this attribute disables the
1548 memory checking code for that function, permitting the use of @code{asm}
1549 statements without requiring separate compilation with different
1550 options, and allowing you to write support routines of your own if you
1551 wish, without getting infinite recursion if they get compiled with this
1554 @item regparm (@var{number})
1555 @cindex functions that are passed arguments in registers on the 386
1556 On the Intel 386, the @code{regparm} attribute causes the compiler to
1557 pass up to @var{number} integer arguments in registers @var{EAX},
1558 @var{EDX}, and @var{ECX} instead of on the stack. Functions that take a
1559 variable number of arguments will continue to be passed all of their
1560 arguments on the stack.
1563 @cindex functions that pop the argument stack on the 386
1564 On the Intel 386, the @code{stdcall} attribute causes the compiler to
1565 assume that the called function will pop off the stack space used to
1566 pass arguments, unless it takes a variable number of arguments.
1568 The PowerPC compiler for Windows NT currently ignores the @code{stdcall}
1572 @cindex functions that do pop the argument stack on the 386
1573 On the Intel 386, the @code{cdecl} attribute causes the compiler to
1574 assume that the calling function will pop off the stack space used to
1575 pass arguments. This is
1576 useful to override the effects of the @samp{-mrtd} switch.
1578 The PowerPC compiler for Windows NT currently ignores the @code{cdecl}
1582 @cindex functions called via pointer on the RS/6000 and PowerPC
1583 On the RS/6000 and PowerPC, the @code{longcall} attribute causes the
1584 compiler to always call the function via a pointer, so that functions
1585 which reside further than 64 megabytes (67,108,864 bytes) from the
1586 current location can be called.
1589 @cindex functions which are imported from a dll on PowerPC Windows NT
1590 On the PowerPC running Windows NT, the @code{dllimport} attribute causes
1591 the compiler to call the function via a global pointer to the function
1592 pointer that is set up by the Windows NT dll library. The pointer name
1593 is formed by combining @code{__imp_} and the function name.
1596 @cindex functions which are exported from a dll on PowerPC Windows NT
1597 On the PowerPC running Windows NT, the @code{dllexport} attribute causes
1598 the compiler to provide a global pointer to the function pointer, so
1599 that it can be called with the @code{dllimport} attribute. The pointer
1600 name is formed by combining @code{__imp_} and the function name.
1602 @item exception (@var{except-func} [, @var{except-arg}])
1603 @cindex functions which specify exception handling on PowerPC Windows NT
1604 On the PowerPC running Windows NT, the @code{exception} attribute causes
1605 the compiler to modify the structured exception table entry it emits for
1606 the declared function. The string or identifier @var{except-func} is
1607 placed in the third entry of the structured exception table. It
1608 represents a function, which is called by the exception handling
1609 mechanism if an exception occurs. If it was specified, the string or
1610 identifier @var{except-arg} is placed in the fourth entry of the
1611 structured exception table.
1613 @item function_vector
1614 @cindex calling functions through the function vector on the H8/300 processors
1615 Use this option on the H8/300 and H8/300H to indicate that the specified
1616 function should be called through the function vector. Calling a
1617 function through the function vector will reduce code size, however;
1618 the function vector has a limited size (maximum 128 entries on the H8/300
1619 and 64 entries on the H8/300H) and shares space with the interrupt vector.
1621 You must use GAS and GLD from GNU binutils version 2.7 or later for
1622 this option to work correctly.
1624 @item interrupt_handler
1625 @cindex interrupt handler functions on the H8/300 processors
1626 Use this option on the H8/300 and H8/300H to indicate that the specified
1627 function is an interrupt handler. The compiler will generate function
1628 entry and exit sequences suitable for use in an interrupt handler when this
1629 attribute is present.
1632 @cindex eight bit data on the H8/300 and H8/300H
1633 Use this option on the H8/300 and H8/300H to indicate that the specified
1634 variable should be placed into the eight bit data section.
1635 The compiler will generate more efficient code for certain operations
1636 on data in the eight bit data area. Note the eight bit data area is limited to
1639 You must use GAS and GLD from GNU binutils version 2.7 or later for
1640 this option to work correctly.
1643 @cindex tiny data section on the H8/300H
1644 Use this option on the H8/300H to indicate that the specified
1645 variable should be placed into the tiny data section.
1646 The compiler will generate more efficient code for loads and stores
1647 on data in the tiny data section. Note the tiny data area is limited to
1648 slightly under 32kbytes of data.
1651 @cindex interrupt handlers on the M32R/D
1652 Use this option on the M32R/D to indicate that the specified
1653 function is an interrupt handler. The compiler will generate function
1654 entry and exit sequences suitable for use in an interrupt handler when this
1655 attribute is present.
1657 @item model (@var{model-name})
1658 @cindex function addressability on the M32R/D
1659 Use this attribute on the M32R/D to set the addressability of an object,
1660 and the code generated for a function.
1661 The identifier @var{model-name} is one of @code{small}, @code{medium},
1662 or @code{large}, representing each of the code models.
1664 Small model objects live in the lower 16MB of memory (so that their
1665 addresses can be loaded with the @code{ld24} instruction), and are
1666 callable with the @code{bl} instruction.
1668 Medium model objects may live anywhere in the 32 bit address space (the
1669 compiler will generate @code{seth/add3} instructions to load their addresses),
1670 and are callable with the @code{bl} instruction.
1672 Large model objects may live anywhere in the 32 bit address space (the
1673 compiler will generate @code{seth/add3} instructions to load their addresses),
1674 and may not be reachable with the @code{bl} instruction (the compiler will
1675 generate the much slower @code{seth/add3/jl} instruction sequence).
1679 You can specify multiple attributes in a declaration by separating them
1680 by commas within the double parentheses or by immediately following an
1681 attribute declaration with another attribute declaration.
1683 @cindex @code{#pragma}, reason for not using
1684 @cindex pragma, reason for not using
1685 Some people object to the @code{__attribute__} feature, suggesting that ANSI C's
1686 @code{#pragma} should be used instead. There are two reasons for not
1691 It is impossible to generate @code{#pragma} commands from a macro.
1694 There is no telling what the same @code{#pragma} might mean in another
1698 These two reasons apply to almost any application that might be proposed
1699 for @code{#pragma}. It is basically a mistake to use @code{#pragma} for
1702 @node Function Prototypes
1703 @section Prototypes and Old-Style Function Definitions
1704 @cindex function prototype declarations
1705 @cindex old-style function definitions
1706 @cindex promotion of formal parameters
1708 GNU C extends ANSI C to allow a function prototype to override a later
1709 old-style non-prototype definition. Consider the following example:
1712 /* @r{Use prototypes unless the compiler is old-fashioned.} */
1719 /* @r{Prototype function declaration.} */
1720 int isroot P((uid_t));
1722 /* @r{Old-style function definition.} */
1724 isroot (x) /* ??? lossage here ??? */
1731 Suppose the type @code{uid_t} happens to be @code{short}. ANSI C does
1732 not allow this example, because subword arguments in old-style
1733 non-prototype definitions are promoted. Therefore in this example the
1734 function definition's argument is really an @code{int}, which does not
1735 match the prototype argument type of @code{short}.
1737 This restriction of ANSI C makes it hard to write code that is portable
1738 to traditional C compilers, because the programmer does not know
1739 whether the @code{uid_t} type is @code{short}, @code{int}, or
1740 @code{long}. Therefore, in cases like these GNU C allows a prototype
1741 to override a later old-style definition. More precisely, in GNU C, a
1742 function prototype argument type overrides the argument type specified
1743 by a later old-style definition if the former type is the same as the
1744 latter type before promotion. Thus in GNU C the above example is
1745 equivalent to the following:
1757 GNU C++ does not support old-style function definitions, so this
1758 extension is irrelevant.
1761 @section C++ Style Comments
1763 @cindex C++ comments
1764 @cindex comments, C++ style
1766 In GNU C, you may use C++ style comments, which start with @samp{//} and
1767 continue until the end of the line. Many other C implementations allow
1768 such comments, and they are likely to be in a future C standard.
1769 However, C++ style comments are not recognized if you specify
1770 @w{@samp{-ansi}} or @w{@samp{-traditional}}, since they are incompatible
1771 with traditional constructs like @code{dividend//*comment*/divisor}.
1774 @section Dollar Signs in Identifier Names
1776 @cindex dollar signs in identifier names
1777 @cindex identifier names, dollar signs in
1779 In GNU C, you may normally use dollar signs in identifier names.
1780 This is because many traditional C implementations allow such identifiers.
1781 However, dollar signs in identifiers are not supported on a few target
1782 machines, typically because the target assembler does not allow them.
1784 @node Character Escapes
1785 @section The Character @key{ESC} in Constants
1787 You can use the sequence @samp{\e} in a string or character constant to
1788 stand for the ASCII character @key{ESC}.
1791 @section Inquiring on Alignment of Types or Variables
1793 @cindex type alignment
1794 @cindex variable alignment
1796 The keyword @code{__alignof__} allows you to inquire about how an object
1797 is aligned, or the minimum alignment usually required by a type. Its
1798 syntax is just like @code{sizeof}.
1800 For example, if the target machine requires a @code{double} value to be
1801 aligned on an 8-byte boundary, then @code{__alignof__ (double)} is 8.
1802 This is true on many RISC machines. On more traditional machine
1803 designs, @code{__alignof__ (double)} is 4 or even 2.
1805 Some machines never actually require alignment; they allow reference to any
1806 data type even at an odd addresses. For these machines, @code{__alignof__}
1807 reports the @emph{recommended} alignment of a type.
1809 When the operand of @code{__alignof__} is an lvalue rather than a type, the
1810 value is the largest alignment that the lvalue is known to have. It may
1811 have this alignment as a result of its data type, or because it is part of
1812 a structure and inherits alignment from that structure. For example, after
1816 struct foo @{ int x; char y; @} foo1;
1820 the value of @code{__alignof__ (foo1.y)} is probably 2 or 4, the same as
1821 @code{__alignof__ (int)}, even though the data type of @code{foo1.y}
1822 does not itself demand any alignment.@refill
1824 A related feature which lets you specify the alignment of an object is
1825 @code{__attribute__ ((aligned (@var{alignment})))}; see the following
1828 @node Variable Attributes
1829 @section Specifying Attributes of Variables
1830 @cindex attribute of variables
1831 @cindex variable attributes
1833 The keyword @code{__attribute__} allows you to specify special
1834 attributes of variables or structure fields. This keyword is followed
1835 by an attribute specification inside double parentheses. Eight
1836 attributes are currently defined for variables: @code{aligned},
1837 @code{mode}, @code{nocommon}, @code{packed}, @code{section},
1838 @code{transparent_union}, @code{unused}, and @code{weak}. Other
1839 attributes are available for functions (@pxref{Function Attributes}) and
1840 for types (@pxref{Type Attributes}).
1842 You may also specify attributes with @samp{__} preceding and following
1843 each keyword. This allows you to use them in header files without
1844 being concerned about a possible macro of the same name. For example,
1845 you may use @code{__aligned__} instead of @code{aligned}.
1848 @cindex @code{aligned} attribute
1849 @item aligned (@var{alignment})
1850 This attribute specifies a minimum alignment for the variable or
1851 structure field, measured in bytes. For example, the declaration:
1854 int x __attribute__ ((aligned (16))) = 0;
1858 causes the compiler to allocate the global variable @code{x} on a
1859 16-byte boundary. On a 68040, this could be used in conjunction with
1860 an @code{asm} expression to access the @code{move16} instruction which
1861 requires 16-byte aligned operands.
1863 You can also specify the alignment of structure fields. For example, to
1864 create a double-word aligned @code{int} pair, you could write:
1867 struct foo @{ int x[2] __attribute__ ((aligned (8))); @};
1871 This is an alternative to creating a union with a @code{double} member
1872 that forces the union to be double-word aligned.
1874 It is not possible to specify the alignment of functions; the alignment
1875 of functions is determined by the machine's requirements and cannot be
1876 changed. You cannot specify alignment for a typedef name because such a
1877 name is just an alias, not a distinct type.
1879 As in the preceding examples, you can explicitly specify the alignment
1880 (in bytes) that you wish the compiler to use for a given variable or
1881 structure field. Alternatively, you can leave out the alignment factor
1882 and just ask the compiler to align a variable or field to the maximum
1883 useful alignment for the target machine you are compiling for. For
1884 example, you could write:
1887 short array[3] __attribute__ ((aligned));
1890 Whenever you leave out the alignment factor in an @code{aligned} attribute
1891 specification, the compiler automatically sets the alignment for the declared
1892 variable or field to the largest alignment which is ever used for any data
1893 type on the target machine you are compiling for. Doing this can often make
1894 copy operations more efficient, because the compiler can use whatever
1895 instructions copy the biggest chunks of memory when performing copies to
1896 or from the variables or fields that you have aligned this way.
1898 The @code{aligned} attribute can only increase the alignment; but you
1899 can decrease it by specifying @code{packed} as well. See below.
1901 Note that the effectiveness of @code{aligned} attributes may be limited
1902 by inherent limitations in your linker. On many systems, the linker is
1903 only able to arrange for variables to be aligned up to a certain maximum
1904 alignment. (For some linkers, the maximum supported alignment may
1905 be very very small.) If your linker is only able to align variables
1906 up to a maximum of 8 byte alignment, then specifying @code{aligned(16)}
1907 in an @code{__attribute__} will still only provide you with 8 byte
1908 alignment. See your linker documentation for further information.
1910 @item mode (@var{mode})
1911 @cindex @code{mode} attribute
1912 This attribute specifies the data type for the declaration---whichever
1913 type corresponds to the mode @var{mode}. This in effect lets you
1914 request an integer or floating point type according to its width.
1916 You may also specify a mode of @samp{byte} or @samp{__byte__} to
1917 indicate the mode corresponding to a one-byte integer, @samp{word} or
1918 @samp{__word__} for the mode of a one-word integer, and @samp{pointer}
1919 or @samp{__pointer__} for the mode used to represent pointers.
1922 @cindex @code{nocommon} attribute
1923 This attribute specifies requests GNU CC not to place a variable
1924 ``common'' but instead to allocate space for it directly. If you
1925 specify the @samp{-fno-common} flag, GNU CC will do this for all
1928 Specifying the @code{nocommon} attribute for a variable provides an
1929 initialization of zeros. A variable may only be initialized in one
1933 @cindex @code{packed} attribute
1934 The @code{packed} attribute specifies that a variable or structure field
1935 should have the smallest possible alignment---one byte for a variable,
1936 and one bit for a field, unless you specify a larger value with the
1937 @code{aligned} attribute.
1939 Here is a structure in which the field @code{x} is packed, so that it
1940 immediately follows @code{a}:
1946 int x[2] __attribute__ ((packed));
1950 @item section ("section-name")
1951 @cindex @code{section} variable attribute
1952 Normally, the compiler places the objects it generates in sections like
1953 @code{data} and @code{bss}. Sometimes, however, you need additional sections,
1954 or you need certain particular variables to appear in special sections,
1955 for example to map to special hardware. The @code{section}
1956 attribute specifies that a variable (or function) lives in a particular
1957 section. For example, this small program uses several specific section names:
1960 struct duart a __attribute__ ((section ("DUART_A"))) = @{ 0 @};
1961 struct duart b __attribute__ ((section ("DUART_B"))) = @{ 0 @};
1962 char stack[10000] __attribute__ ((section ("STACK"))) = @{ 0 @};
1963 int init_data __attribute__ ((section ("INITDATA"))) = 0;
1967 /* Initialize stack pointer */
1968 init_sp (stack + sizeof (stack));
1970 /* Initialize initialized data */
1971 memcpy (&init_data, &data, &edata - &data);
1973 /* Turn on the serial ports */
1980 Use the @code{section} attribute with an @emph{initialized} definition
1981 of a @emph{global} variable, as shown in the example. GNU CC issues
1982 a warning and otherwise ignores the @code{section} attribute in
1983 uninitialized variable declarations.
1985 You may only use the @code{section} attribute with a fully initialized
1986 global definition because of the way linkers work. The linker requires
1987 each object be defined once, with the exception that uninitialized
1988 variables tentatively go in the @code{common} (or @code{bss}) section
1989 and can be multiply "defined". You can force a variable to be
1990 initialized with the @samp{-fno-common} flag or the @code{nocommon}
1993 Some file formats do not support arbitrary sections so the @code{section}
1994 attribute is not available on all platforms.
1995 If you need to map the entire contents of a module to a particular
1996 section, consider using the facilities of the linker instead.
1998 @item transparent_union
1999 This attribute, attached to a function parameter which is a union, means
2000 that the corresponding argument may have the type of any union member,
2001 but the argument is passed as if its type were that of the first union
2002 member. For more details see @xref{Type Attributes}. You can also use
2003 this attribute on a @code{typedef} for a union data type; then it
2004 applies to all function parameters with that type.
2007 This attribute, attached to a variable, means that the variable is meant
2008 to be possibly unused. GNU CC will not produce a warning for this
2012 The @code{weak} attribute is described in @xref{Function Attributes}.
2014 @item model (@var{model-name})
2015 @cindex variable addressability on the M32R/D
2016 Use this attribute on the M32R/D to set the addressability of an object.
2017 The identifier @var{model-name} is one of @code{small}, @code{medium},
2018 or @code{large}, representing each of the code models.
2020 Small model objects live in the lower 16MB of memory (so that their
2021 addresses can be loaded with the @code{ld24} instruction).
2023 Medium and large model objects may live anywhere in the 32 bit address space
2024 (the compiler will generate @code{seth/add3} instructions to load their
2029 To specify multiple attributes, separate them by commas within the
2030 double parentheses: for example, @samp{__attribute__ ((aligned (16),
2033 @node Type Attributes
2034 @section Specifying Attributes of Types
2035 @cindex attribute of types
2036 @cindex type attributes
2038 The keyword @code{__attribute__} allows you to specify special
2039 attributes of @code{struct} and @code{union} types when you define such
2040 types. This keyword is followed by an attribute specification inside
2041 double parentheses. Three attributes are currently defined for types:
2042 @code{aligned}, @code{packed}, and @code{transparent_union}. Other
2043 attributes are defined for functions (@pxref{Function Attributes}) and
2044 for variables (@pxref{Variable Attributes}).
2046 You may also specify any one of these attributes with @samp{__}
2047 preceding and following its keyword. This allows you to use these
2048 attributes in header files without being concerned about a possible
2049 macro of the same name. For example, you may use @code{__aligned__}
2050 instead of @code{aligned}.
2052 You may specify the @code{aligned} and @code{transparent_union}
2053 attributes either in a @code{typedef} declaration or just past the
2054 closing curly brace of a complete enum, struct or union type
2055 @emph{definition} and the @code{packed} attribute only past the closing
2056 brace of a definition.
2058 You may also specify attributes between the enum, struct or union
2059 tag and the name of the type rather than after the closing brace.
2062 @cindex @code{aligned} attribute
2063 @item aligned (@var{alignment})
2064 This attribute specifies a minimum alignment (in bytes) for variables
2065 of the specified type. For example, the declarations:
2068 struct S @{ short f[3]; @} __attribute__ ((aligned (8)));
2069 typedef int more_aligned_int __attribute__ ((aligned (8)));
2073 force the compiler to insure (as far as it can) that each variable whose
2074 type is @code{struct S} or @code{more_aligned_int} will be allocated and
2075 aligned @emph{at least} on a 8-byte boundary. On a Sparc, having all
2076 variables of type @code{struct S} aligned to 8-byte boundaries allows
2077 the compiler to use the @code{ldd} and @code{std} (doubleword load and
2078 store) instructions when copying one variable of type @code{struct S} to
2079 another, thus improving run-time efficiency.
2081 Note that the alignment of any given @code{struct} or @code{union} type
2082 is required by the ANSI C standard to be at least a perfect multiple of
2083 the lowest common multiple of the alignments of all of the members of
2084 the @code{struct} or @code{union} in question. This means that you @emph{can}
2085 effectively adjust the alignment of a @code{struct} or @code{union}
2086 type by attaching an @code{aligned} attribute to any one of the members
2087 of such a type, but the notation illustrated in the example above is a
2088 more obvious, intuitive, and readable way to request the compiler to
2089 adjust the alignment of an entire @code{struct} or @code{union} type.
2091 As in the preceding example, you can explicitly specify the alignment
2092 (in bytes) that you wish the compiler to use for a given @code{struct}
2093 or @code{union} type. Alternatively, you can leave out the alignment factor
2094 and just ask the compiler to align a type to the maximum
2095 useful alignment for the target machine you are compiling for. For
2096 example, you could write:
2099 struct S @{ short f[3]; @} __attribute__ ((aligned));
2102 Whenever you leave out the alignment factor in an @code{aligned}
2103 attribute specification, the compiler automatically sets the alignment
2104 for the type to the largest alignment which is ever used for any data
2105 type on the target machine you are compiling for. Doing this can often
2106 make copy operations more efficient, because the compiler can use
2107 whatever instructions copy the biggest chunks of memory when performing
2108 copies to or from the variables which have types that you have aligned
2111 In the example above, if the size of each @code{short} is 2 bytes, then
2112 the size of the entire @code{struct S} type is 6 bytes. The smallest
2113 power of two which is greater than or equal to that is 8, so the
2114 compiler sets the alignment for the entire @code{struct S} type to 8
2117 Note that although you can ask the compiler to select a time-efficient
2118 alignment for a given type and then declare only individual stand-alone
2119 objects of that type, the compiler's ability to select a time-efficient
2120 alignment is primarily useful only when you plan to create arrays of
2121 variables having the relevant (efficiently aligned) type. If you
2122 declare or use arrays of variables of an efficiently-aligned type, then
2123 it is likely that your program will also be doing pointer arithmetic (or
2124 subscripting, which amounts to the same thing) on pointers to the
2125 relevant type, and the code that the compiler generates for these
2126 pointer arithmetic operations will often be more efficient for
2127 efficiently-aligned types than for other types.
2129 The @code{aligned} attribute can only increase the alignment; but you
2130 can decrease it by specifying @code{packed} as well. See below.
2132 Note that the effectiveness of @code{aligned} attributes may be limited
2133 by inherent limitations in your linker. On many systems, the linker is
2134 only able to arrange for variables to be aligned up to a certain maximum
2135 alignment. (For some linkers, the maximum supported alignment may
2136 be very very small.) If your linker is only able to align variables
2137 up to a maximum of 8 byte alignment, then specifying @code{aligned(16)}
2138 in an @code{__attribute__} will still only provide you with 8 byte
2139 alignment. See your linker documentation for further information.
2142 This attribute, attached to an @code{enum}, @code{struct}, or
2143 @code{union} type definition, specified that the minimum required memory
2144 be used to represent the type.
2146 Specifying this attribute for @code{struct} and @code{union} types is
2147 equivalent to specifying the @code{packed} attribute on each of the
2148 structure or union members. Specifying the @samp{-fshort-enums}
2149 flag on the line is equivalent to specifying the @code{packed}
2150 attribute on all @code{enum} definitions.
2152 You may only specify this attribute after a closing curly brace on an
2153 @code{enum} definition, not in a @code{typedef} declaration, unless that
2154 declaration also contains the definition of the @code{enum}.
2156 @item transparent_union
2157 This attribute, attached to a @code{union} type definition, indicates
2158 that any function parameter having that union type causes calls to that
2159 function to be treated in a special way.
2161 First, the argument corresponding to a transparent union type can be of
2162 any type in the union; no cast is required. Also, if the union contains
2163 a pointer type, the corresponding argument can be a null pointer
2164 constant or a void pointer expression; and if the union contains a void
2165 pointer type, the corresponding argument can be any pointer expression.
2166 If the union member type is a pointer, qualifiers like @code{const} on
2167 the referenced type must be respected, just as with normal pointer
2170 Second, the argument is passed to the function using the calling
2171 conventions of first member of the transparent union, not the calling
2172 conventions of the union itself. All members of the union must have the
2173 same machine representation; this is necessary for this argument passing
2176 Transparent unions are designed for library functions that have multiple
2177 interfaces for compatibility reasons. For example, suppose the
2178 @code{wait} function must accept either a value of type @code{int *} to
2179 comply with Posix, or a value of type @code{union wait *} to comply with
2180 the 4.1BSD interface. If @code{wait}'s parameter were @code{void *},
2181 @code{wait} would accept both kinds of arguments, but it would also
2182 accept any other pointer type and this would make argument type checking
2183 less useful. Instead, @code{<sys/wait.h>} might define the interface
2191 @} wait_status_ptr_t __attribute__ ((__transparent_union__));
2193 pid_t wait (wait_status_ptr_t);
2196 This interface allows either @code{int *} or @code{union wait *}
2197 arguments to be passed, using the @code{int *} calling convention.
2198 The program can call @code{wait} with arguments of either type:
2201 int w1 () @{ int w; return wait (&w); @}
2202 int w2 () @{ union wait w; return wait (&w); @}
2205 With this interface, @code{wait}'s implementation might look like this:
2208 pid_t wait (wait_status_ptr_t p)
2210 return waitpid (-1, p.__ip, 0);
2215 When attached to a type (including a @code{union} or a @code{struct}),
2216 this attribute means that variables of that type are meant to appear
2217 possibly unused. GNU CC will not produce a warning for any variables of
2218 that type, even if the variable appears to do nothing. This is often
2219 the case with lock or thread classes, which are usually defined and then
2220 not referenced, but contain constructors and destructors that have
2221 nontrivial bookkeeping functions.
2225 To specify multiple attributes, separate them by commas within the
2226 double parentheses: for example, @samp{__attribute__ ((aligned (16),
2230 @section An Inline Function is As Fast As a Macro
2231 @cindex inline functions
2232 @cindex integrating function code
2234 @cindex macros, inline alternative
2236 By declaring a function @code{inline}, you can direct GNU CC to
2237 integrate that function's code into the code for its callers. This
2238 makes execution faster by eliminating the function-call overhead; in
2239 addition, if any of the actual argument values are constant, their known
2240 values may permit simplifications at compile time so that not all of the
2241 inline function's code needs to be included. The effect on code size is
2242 less predictable; object code may be larger or smaller with function
2243 inlining, depending on the particular case. Inlining of functions is an
2244 optimization and it really ``works'' only in optimizing compilation. If
2245 you don't use @samp{-O}, no function is really inline.
2247 To declare a function inline, use the @code{inline} keyword in its
2248 declaration, like this:
2258 (If you are writing a header file to be included in ANSI C programs, write
2259 @code{__inline__} instead of @code{inline}. @xref{Alternate Keywords}.)
2261 You can also make all ``simple enough'' functions inline with the option
2262 @samp{-finline-functions}. Note that certain usages in a function
2263 definition can make it unsuitable for inline substitution.
2265 Note that in C and Objective C, unlike C++, the @code{inline} keyword
2266 does not affect the linkage of the function.
2268 @cindex automatic @code{inline} for C++ member fns
2269 @cindex @code{inline} automatic for C++ member fns
2270 @cindex member fns, automatically @code{inline}
2271 @cindex C++ member fns, automatically @code{inline}
2272 GNU CC automatically inlines member functions defined within the class
2273 body of C++ programs even if they are not explicitly declared
2274 @code{inline}. (You can override this with @samp{-fno-default-inline};
2275 @pxref{C++ Dialect Options,,Options Controlling C++ Dialect}.)
2277 @cindex inline functions, omission of
2278 When a function is both inline and @code{static}, if all calls to the
2279 function are integrated into the caller, and the function's address is
2280 never used, then the function's own assembler code is never referenced.
2281 In this case, GNU CC does not actually output assembler code for the
2282 function, unless you specify the option @samp{-fkeep-inline-functions}.
2283 Some calls cannot be integrated for various reasons (in particular,
2284 calls that precede the function's definition cannot be integrated, and
2285 neither can recursive calls within the definition). If there is a
2286 nonintegrated call, then the function is compiled to assembler code as
2287 usual. The function must also be compiled as usual if the program
2288 refers to its address, because that can't be inlined.
2290 @cindex non-static inline function
2291 When an inline function is not @code{static}, then the compiler must assume
2292 that there may be calls from other source files; since a global symbol can
2293 be defined only once in any program, the function must not be defined in
2294 the other source files, so the calls therein cannot be integrated.
2295 Therefore, a non-@code{static} inline function is always compiled on its
2296 own in the usual fashion.
2298 If you specify both @code{inline} and @code{extern} in the function
2299 definition, then the definition is used only for inlining. In no case
2300 is the function compiled on its own, not even if you refer to its
2301 address explicitly. Such an address becomes an external reference, as
2302 if you had only declared the function, and had not defined it.
2304 This combination of @code{inline} and @code{extern} has almost the
2305 effect of a macro. The way to use it is to put a function definition in
2306 a header file with these keywords, and put another copy of the
2307 definition (lacking @code{inline} and @code{extern}) in a library file.
2308 The definition in the header file will cause most calls to the function
2309 to be inlined. If any uses of the function remain, they will refer to
2310 the single copy in the library.
2312 GNU C does not inline any functions when not optimizing. It is not
2313 clear whether it is better to inline or not, in this case, but we found
2314 that a correct implementation when not optimizing was difficult. So we
2315 did the easy thing, and turned it off.
2318 @section Assembler Instructions with C Expression Operands
2319 @cindex extended @code{asm}
2320 @cindex @code{asm} expressions
2321 @cindex assembler instructions
2324 In an assembler instruction using @code{asm}, you can specify the
2325 operands of the instruction using C expressions. This means you need not
2326 guess which registers or memory locations will contain the data you want
2329 You must specify an assembler instruction template much like what
2330 appears in a machine description, plus an operand constraint string for
2333 For example, here is how to use the 68881's @code{fsinx} instruction:
2336 asm ("fsinx %1,%0" : "=f" (result) : "f" (angle));
2340 Here @code{angle} is the C expression for the input operand while
2341 @code{result} is that of the output operand. Each has @samp{"f"} as its
2342 operand constraint, saying that a floating point register is required.
2343 The @samp{=} in @samp{=f} indicates that the operand is an output; all
2344 output operands' constraints must use @samp{=}. The constraints use the
2345 same language used in the machine description (@pxref{Constraints}).
2347 Each operand is described by an operand-constraint string followed by
2348 the C expression in parentheses. A colon separates the assembler
2349 template from the first output operand and another separates the last
2350 output operand from the first input, if any. Commas separate the
2351 operands within each group. The total number of operands is limited to
2352 ten or to the maximum number of operands in any instruction pattern in
2353 the machine description, whichever is greater.
2355 If there are no output operands but there are input operands, you must
2356 place two consecutive colons surrounding the place where the output
2359 Output operand expressions must be lvalues; the compiler can check this.
2360 The input operands need not be lvalues. The compiler cannot check
2361 whether the operands have data types that are reasonable for the
2362 instruction being executed. It does not parse the assembler instruction
2363 template and does not know what it means or even whether it is valid
2364 assembler input. The extended @code{asm} feature is most often used for
2365 machine instructions the compiler itself does not know exist. If
2366 the output expression cannot be directly addressed (for example, it is a
2367 bit field), your constraint must allow a register. In that case, GNU CC
2368 will use the register as the output of the @code{asm}, and then store
2369 that register into the output.
2371 The ordinary output operands must be write-only; GNU CC will assume that
2372 the values in these operands before the instruction are dead and need
2373 not be generated. Extended asm supports input-output or read-write
2374 operands. Use the constraint character @samp{+} to indicate such an
2375 operand and list it with the output operands.
2377 When the constraints for the read-write operand (or the operand in which
2378 only some of the bits are to be changed) allows a register, you may, as
2379 an alternative, logically split its function into two separate operands,
2380 one input operand and one write-only output operand. The connection
2381 between them is expressed by constraints which say they need to be in
2382 the same location when the instruction executes. You can use the same C
2383 expression for both operands, or different expressions. For example,
2384 here we write the (fictitious) @samp{combine} instruction with
2385 @code{bar} as its read-only source operand and @code{foo} as its
2386 read-write destination:
2389 asm ("combine %2,%0" : "=r" (foo) : "0" (foo), "g" (bar));
2393 The constraint @samp{"0"} for operand 1 says that it must occupy the
2394 same location as operand 0. A digit in constraint is allowed only in an
2395 input operand and it must refer to an output operand.
2397 Only a digit in the constraint can guarantee that one operand will be in
2398 the same place as another. The mere fact that @code{foo} is the value
2399 of both operands is not enough to guarantee that they will be in the
2400 same place in the generated assembler code. The following would not
2404 asm ("combine %2,%0" : "=r" (foo) : "r" (foo), "g" (bar));
2407 Various optimizations or reloading could cause operands 0 and 1 to be in
2408 different registers; GNU CC knows no reason not to do so. For example, the
2409 compiler might find a copy of the value of @code{foo} in one register and
2410 use it for operand 1, but generate the output operand 0 in a different
2411 register (copying it afterward to @code{foo}'s own address). Of course,
2412 since the register for operand 1 is not even mentioned in the assembler
2413 code, the result will not work, but GNU CC can't tell that.
2415 Some instructions clobber specific hard registers. To describe this,
2416 write a third colon after the input operands, followed by the names of
2417 the clobbered hard registers (given as strings). Here is a realistic
2418 example for the VAX:
2421 asm volatile ("movc3 %0,%1,%2"
2423 : "g" (from), "g" (to), "g" (count)
2424 : "r0", "r1", "r2", "r3", "r4", "r5");
2427 It is an error for a clobber description to overlap an input or output
2428 operand (for example, an operand describing a register class with one
2429 member, mentioned in the clobber list). Most notably, it is invalid to
2430 describe that an input operand is modified, but unused as output. It has
2431 to be specified as an input and output operand anyway. Note that if there
2432 are only unused output operands, you will then also need to specify
2433 @code{volatile} for the @code{asm} construct, as described below.
2435 If you refer to a particular hardware register from the assembler code,
2436 you will probably have to list the register after the third colon to
2437 tell the compiler the register's value is modified. In some assemblers,
2438 the register names begin with @samp{%}; to produce one @samp{%} in the
2439 assembler code, you must write @samp{%%} in the input.
2441 If your assembler instruction can alter the condition code register, add
2442 @samp{cc} to the list of clobbered registers. GNU CC on some machines
2443 represents the condition codes as a specific hardware register;
2444 @samp{cc} serves to name this register. On other machines, the
2445 condition code is handled differently, and specifying @samp{cc} has no
2446 effect. But it is valid no matter what the machine.
2448 If your assembler instruction modifies memory in an unpredictable
2449 fashion, add @samp{memory} to the list of clobbered registers. This
2450 will cause GNU CC to not keep memory values cached in registers across
2451 the assembler instruction.
2453 You can put multiple assembler instructions together in a single
2454 @code{asm} template, separated either with newlines (written as
2455 @samp{\n}) or with semicolons if the assembler allows such semicolons.
2456 The GNU assembler allows semicolons and most Unix assemblers seem to do
2457 so. The input operands are guaranteed not to use any of the clobbered
2458 registers, and neither will the output operands' addresses, so you can
2459 read and write the clobbered registers as many times as you like. Here
2460 is an example of multiple instructions in a template; it assumes the
2461 subroutine @code{_foo} accepts arguments in registers 9 and 10:
2464 asm ("movl %0,r9;movl %1,r10;call _foo"
2466 : "g" (from), "g" (to)
2470 Unless an output operand has the @samp{&} constraint modifier, GNU CC
2471 may allocate it in the same register as an unrelated input operand, on
2472 the assumption the inputs are consumed before the outputs are produced.
2473 This assumption may be false if the assembler code actually consists of
2474 more than one instruction. In such a case, use @samp{&} for each output
2475 operand that may not overlap an input. @xref{Modifiers}.
2477 If you want to test the condition code produced by an assembler
2478 instruction, you must include a branch and a label in the @code{asm}
2479 construct, as follows:
2482 asm ("clr %0;frob %1;beq 0f;mov #1,%0;0:"
2488 This assumes your assembler supports local labels, as the GNU assembler
2489 and most Unix assemblers do.
2491 Speaking of labels, jumps from one @code{asm} to another are not
2492 supported. The compiler's optimizers do not know about these jumps, and
2493 therefore they cannot take account of them when deciding how to
2496 @cindex macros containing @code{asm}
2497 Usually the most convenient way to use these @code{asm} instructions is to
2498 encapsulate them in macros that look like functions. For example,
2502 (@{ double __value, __arg = (x); \
2503 asm ("fsinx %1,%0": "=f" (__value): "f" (__arg)); \
2508 Here the variable @code{__arg} is used to make sure that the instruction
2509 operates on a proper @code{double} value, and to accept only those
2510 arguments @code{x} which can convert automatically to a @code{double}.
2512 Another way to make sure the instruction operates on the correct data
2513 type is to use a cast in the @code{asm}. This is different from using a
2514 variable @code{__arg} in that it converts more different types. For
2515 example, if the desired type were @code{int}, casting the argument to
2516 @code{int} would accept a pointer with no complaint, while assigning the
2517 argument to an @code{int} variable named @code{__arg} would warn about
2518 using a pointer unless the caller explicitly casts it.
2520 If an @code{asm} has output operands, GNU CC assumes for optimization
2521 purposes the instruction has no side effects except to change the output
2522 operands. This does not mean instructions with a side effect cannot be
2523 used, but you must be careful, because the compiler may eliminate them
2524 if the output operands aren't used, or move them out of loops, or
2525 replace two with one if they constitute a common subexpression. Also,
2526 if your instruction does have a side effect on a variable that otherwise
2527 appears not to change, the old value of the variable may be reused later
2528 if it happens to be found in a register.
2530 You can prevent an @code{asm} instruction from being deleted, moved
2531 significantly, or combined, by writing the keyword @code{volatile} after
2532 the @code{asm}. For example:
2535 #define get_and_set_priority(new) \
2537 asm volatile ("get_and_set_priority %0, %1": "=g" (__old) : "g" (new)); \
2542 If you write an @code{asm} instruction with no outputs, GNU CC will know
2543 the instruction has side-effects and will not delete the instruction or
2544 move it outside of loops. If the side-effects of your instruction are
2545 not purely external, but will affect variables in your program in ways
2546 other than reading the inputs and clobbering the specified registers or
2547 memory, you should write the @code{volatile} keyword to prevent future
2548 versions of GNU CC from moving the instruction around within a core
2551 An @code{asm} instruction without any operands or clobbers (and ``old
2552 style'' @code{asm}) will not be deleted or moved significantly,
2553 regardless, unless it is unreachable, the same wasy as if you had
2554 written a @code{volatile} keyword.
2556 Note that even a volatile @code{asm} instruction can be moved in ways
2557 that appear insignificant to the compiler, such as across jump
2558 instructions. You can't expect a sequence of volatile @code{asm}
2559 instructions to remain perfectly consecutive. If you want consecutive
2560 output, use a single @code{asm}.
2562 It is a natural idea to look for a way to give access to the condition
2563 code left by the assembler instruction. However, when we attempted to
2564 implement this, we found no way to make it work reliably. The problem
2565 is that output operands might need reloading, which would result in
2566 additional following ``store'' instructions. On most machines, these
2567 instructions would alter the condition code before there was time to
2568 test it. This problem doesn't arise for ordinary ``test'' and
2569 ``compare'' instructions because they don't have any output operands.
2571 If you are writing a header file that should be includable in ANSI C
2572 programs, write @code{__asm__} instead of @code{asm}. @xref{Alternate
2576 @c Show the details on constraints if they do not appear elsewhere in
2582 @section Controlling Names Used in Assembler Code
2583 @cindex assembler names for identifiers
2584 @cindex names used in assembler code
2585 @cindex identifiers, names in assembler code
2587 You can specify the name to be used in the assembler code for a C
2588 function or variable by writing the @code{asm} (or @code{__asm__})
2589 keyword after the declarator as follows:
2592 int foo asm ("myfoo") = 2;
2596 This specifies that the name to be used for the variable @code{foo} in
2597 the assembler code should be @samp{myfoo} rather than the usual
2600 On systems where an underscore is normally prepended to the name of a C
2601 function or variable, this feature allows you to define names for the
2602 linker that do not start with an underscore.
2604 You cannot use @code{asm} in this way in a function @emph{definition}; but
2605 you can get the same effect by writing a declaration for the function
2606 before its definition and putting @code{asm} there, like this:
2609 extern func () asm ("FUNC");
2616 It is up to you to make sure that the assembler names you choose do not
2617 conflict with any other assembler symbols. Also, you must not use a
2618 register name; that would produce completely invalid assembler code. GNU
2619 CC does not as yet have the ability to store static variables in registers.
2620 Perhaps that will be added.
2622 @node Explicit Reg Vars
2623 @section Variables in Specified Registers
2624 @cindex explicit register variables
2625 @cindex variables in specified registers
2626 @cindex specified registers
2627 @cindex registers, global allocation
2629 GNU C allows you to put a few global variables into specified hardware
2630 registers. You can also specify the register in which an ordinary
2631 register variable should be allocated.
2635 Global register variables reserve registers throughout the program.
2636 This may be useful in programs such as programming language
2637 interpreters which have a couple of global variables that are accessed
2641 Local register variables in specific registers do not reserve the
2642 registers. The compiler's data flow analysis is capable of determining
2643 where the specified registers contain live values, and where they are
2644 available for other uses. Stores into local register variables may be deleted
2645 when they appear to be dead according to dataflow analysis. References
2646 to local register variables may be deleted or moved or simplified.
2648 These local variables are sometimes convenient for use with the extended
2649 @code{asm} feature (@pxref{Extended Asm}), if you want to write one
2650 output of the assembler instruction directly into a particular register.
2651 (This will work provided the register you specify fits the constraints
2652 specified for that operand in the @code{asm}.)
2660 @node Global Reg Vars
2661 @subsection Defining Global Register Variables
2662 @cindex global register variables
2663 @cindex registers, global variables in
2665 You can define a global register variable in GNU C like this:
2668 register int *foo asm ("a5");
2672 Here @code{a5} is the name of the register which should be used. Choose a
2673 register which is normally saved and restored by function calls on your
2674 machine, so that library routines will not clobber it.
2676 Naturally the register name is cpu-dependent, so you would need to
2677 conditionalize your program according to cpu type. The register
2678 @code{a5} would be a good choice on a 68000 for a variable of pointer
2679 type. On machines with register windows, be sure to choose a ``global''
2680 register that is not affected magically by the function call mechanism.
2682 In addition, operating systems on one type of cpu may differ in how they
2683 name the registers; then you would need additional conditionals. For
2684 example, some 68000 operating systems call this register @code{%a5}.
2686 Eventually there may be a way of asking the compiler to choose a register
2687 automatically, but first we need to figure out how it should choose and
2688 how to enable you to guide the choice. No solution is evident.
2690 Defining a global register variable in a certain register reserves that
2691 register entirely for this use, at least within the current compilation.
2692 The register will not be allocated for any other purpose in the functions
2693 in the current compilation. The register will not be saved and restored by
2694 these functions. Stores into this register are never deleted even if they
2695 would appear to be dead, but references may be deleted or moved or
2698 It is not safe to access the global register variables from signal
2699 handlers, or from more than one thread of control, because the system
2700 library routines may temporarily use the register for other things (unless
2701 you recompile them specially for the task at hand).
2703 @cindex @code{qsort}, and global register variables
2704 It is not safe for one function that uses a global register variable to
2705 call another such function @code{foo} by way of a third function
2706 @code{lose} that was compiled without knowledge of this variable (i.e. in a
2707 different source file in which the variable wasn't declared). This is
2708 because @code{lose} might save the register and put some other value there.
2709 For example, you can't expect a global register variable to be available in
2710 the comparison-function that you pass to @code{qsort}, since @code{qsort}
2711 might have put something else in that register. (If you are prepared to
2712 recompile @code{qsort} with the same global register variable, you can
2713 solve this problem.)
2715 If you want to recompile @code{qsort} or other source files which do not
2716 actually use your global register variable, so that they will not use that
2717 register for any other purpose, then it suffices to specify the compiler
2718 option @samp{-ffixed-@var{reg}}. You need not actually add a global
2719 register declaration to their source code.
2721 A function which can alter the value of a global register variable cannot
2722 safely be called from a function compiled without this variable, because it
2723 could clobber the value the caller expects to find there on return.
2724 Therefore, the function which is the entry point into the part of the
2725 program that uses the global register variable must explicitly save and
2726 restore the value which belongs to its caller.
2728 @cindex register variable after @code{longjmp}
2729 @cindex global register after @code{longjmp}
2730 @cindex value after @code{longjmp}
2733 On most machines, @code{longjmp} will restore to each global register
2734 variable the value it had at the time of the @code{setjmp}. On some
2735 machines, however, @code{longjmp} will not change the value of global
2736 register variables. To be portable, the function that called @code{setjmp}
2737 should make other arrangements to save the values of the global register
2738 variables, and to restore them in a @code{longjmp}. This way, the same
2739 thing will happen regardless of what @code{longjmp} does.
2741 All global register variable declarations must precede all function
2742 definitions. If such a declaration could appear after function
2743 definitions, the declaration would be too late to prevent the register from
2744 being used for other purposes in the preceding functions.
2746 Global register variables may not have initial values, because an
2747 executable file has no means to supply initial contents for a register.
2749 On the Sparc, there are reports that g3 @dots{} g7 are suitable
2750 registers, but certain library functions, such as @code{getwd}, as well
2751 as the subroutines for division and remainder, modify g3 and g4. g1 and
2752 g2 are local temporaries.
2754 On the 68000, a2 @dots{} a5 should be suitable, as should d2 @dots{} d7.
2755 Of course, it will not do to use more than a few of those.
2757 @node Local Reg Vars
2758 @subsection Specifying Registers for Local Variables
2759 @cindex local variables, specifying registers
2760 @cindex specifying registers for local variables
2761 @cindex registers for local variables
2763 You can define a local register variable with a specified register
2767 register int *foo asm ("a5");
2771 Here @code{a5} is the name of the register which should be used. Note
2772 that this is the same syntax used for defining global register
2773 variables, but for a local variable it would appear within a function.
2775 Naturally the register name is cpu-dependent, but this is not a
2776 problem, since specific registers are most often useful with explicit
2777 assembler instructions (@pxref{Extended Asm}). Both of these things
2778 generally require that you conditionalize your program according to
2781 In addition, operating systems on one type of cpu may differ in how they
2782 name the registers; then you would need additional conditionals. For
2783 example, some 68000 operating systems call this register @code{%a5}.
2785 Defining such a register variable does not reserve the register; it
2786 remains available for other uses in places where flow control determines
2787 the variable's value is not live. However, these registers are made
2788 unavailable for use in the reload pass; excessive use of this feature
2789 leaves the compiler too few available registers to compile certain
2792 This option does not guarantee that GNU CC will generate code that has
2793 this variable in the register you specify at all times. You may not
2794 code an explicit reference to this register in an @code{asm} statement
2795 and assume it will always refer to this variable.
2797 Stores into local register variables may be deleted when they appear to be dead
2798 according to dataflow analysis. References to local register variables may
2799 be deleted or moved or simplified.
2801 @node Alternate Keywords
2802 @section Alternate Keywords
2803 @cindex alternate keywords
2804 @cindex keywords, alternate
2806 The option @samp{-traditional} disables certain keywords; @samp{-ansi}
2807 disables certain others. This causes trouble when you want to use GNU C
2808 extensions, or ANSI C features, in a general-purpose header file that
2809 should be usable by all programs, including ANSI C programs and traditional
2810 ones. The keywords @code{asm}, @code{typeof} and @code{inline} cannot be
2811 used since they won't work in a program compiled with @samp{-ansi}, while
2812 the keywords @code{const}, @code{volatile}, @code{signed}, @code{typeof}
2813 and @code{inline} won't work in a program compiled with
2814 @samp{-traditional}.@refill
2816 The way to solve these problems is to put @samp{__} at the beginning and
2817 end of each problematical keyword. For example, use @code{__asm__}
2818 instead of @code{asm}, @code{__const__} instead of @code{const}, and
2819 @code{__inline__} instead of @code{inline}.
2821 Other C compilers won't accept these alternative keywords; if you want to
2822 compile with another compiler, you can define the alternate keywords as
2823 macros to replace them with the customary keywords. It looks like this:
2831 @samp{-pedantic} causes warnings for many GNU C extensions. You can
2832 prevent such warnings within one expression by writing
2833 @code{__extension__} before the expression. @code{__extension__} has no
2834 effect aside from this.
2836 @node Incomplete Enums
2837 @section Incomplete @code{enum} Types
2839 You can define an @code{enum} tag without specifying its possible values.
2840 This results in an incomplete type, much like what you get if you write
2841 @code{struct foo} without describing the elements. A later declaration
2842 which does specify the possible values completes the type.
2844 You can't allocate variables or storage using the type while it is
2845 incomplete. However, you can work with pointers to that type.
2847 This extension may not be very useful, but it makes the handling of
2848 @code{enum} more consistent with the way @code{struct} and @code{union}
2851 This extension is not supported by GNU C++.
2853 @node Function Names
2854 @section Function Names as Strings
2856 GNU CC predefines two string variables to be the name of the current function.
2857 The variable @code{__FUNCTION__} is the name of the function as it appears
2858 in the source. The variable @code{__PRETTY_FUNCTION__} is the name of
2859 the function pretty printed in a language specific fashion.
2861 These names are always the same in a C function, but in a C++ function
2862 they may be different. For example, this program:
2866 extern int printf (char *, ...);
2873 printf ("__FUNCTION__ = %s\n", __FUNCTION__);
2874 printf ("__PRETTY_FUNCTION__ = %s\n", __PRETTY_FUNCTION__);
2892 __PRETTY_FUNCTION__ = int a::sub (int)
2895 These names are not macros: they are predefined string variables.
2896 For example, @samp{#ifdef __FUNCTION__} does not have any special
2897 meaning inside a function, since the preprocessor does not do anything
2898 special with the identifier @code{__FUNCTION__}.
2900 @node Return Address
2901 @section Getting the Return or Frame Address of a Function
2903 These functions may be used to get information about the callers of a
2907 @item __builtin_return_address (@var{level})
2908 This function returns the return address of the current function, or of
2909 one of its callers. The @var{level} argument is number of frames to
2910 scan up the call stack. A value of @code{0} yields the return address
2911 of the current function, a value of @code{1} yields the return address
2912 of the caller of the current function, and so forth.
2914 The @var{level} argument must be a constant integer.
2916 On some machines it may be impossible to determine the return address of
2917 any function other than the current one; in such cases, or when the top
2918 of the stack has been reached, this function will return @code{0}.
2920 This function should only be used with a non-zero argument for debugging
2923 @item __builtin_frame_address (@var{level})
2924 This function is similar to @code{__builtin_return_address}, but it
2925 returns the address of the function frame rather than the return address
2926 of the function. Calling @code{__builtin_frame_address} with a value of
2927 @code{0} yields the frame address of the current function, a value of
2928 @code{1} yields the frame address of the caller of the current function,
2931 The frame is the area on the stack which holds local variables and saved
2932 registers. The frame address is normally the address of the first word
2933 pushed on to the stack by the function. However, the exact definition
2934 depends upon the processor and the calling convention. If the processor
2935 has a dedicated frame pointer register, and the function has a frame,
2936 then @code{__builtin_frame_address} will return the value of the frame
2939 The caveats that apply to @code{__builtin_return_address} apply to this
2943 @node C++ Extensions
2944 @chapter Extensions to the C++ Language
2945 @cindex extensions, C++ language
2946 @cindex C++ language extensions
2948 The GNU compiler provides these extensions to the C++ language (and you
2949 can also use most of the C language extensions in your C++ programs). If you
2950 want to write code that checks whether these features are available, you can
2951 test for the GNU compiler the same way as for C programs: check for a
2952 predefined macro @code{__GNUC__}. You can also use @code{__GNUG__} to
2953 test specifically for GNU C++ (@pxref{Standard Predefined,,Standard
2954 Predefined Macros,cpp.info,The C Preprocessor}).
2957 * Naming Results:: Giving a name to C++ function return values.
2958 * Min and Max:: C++ Minimum and maximum operators.
2959 * Destructors and Goto:: Goto is safe to use in C++ even when destructors
2961 * C++ Interface:: You can use a single C++ header file for both
2962 declarations and definitions.
2963 * Template Instantiation:: Methods for ensuring that exactly one copy of
2964 each needed template instantiation is emitted.
2965 * C++ Signatures:: You can specify abstract types to get subtype
2966 polymorphism independent from inheritance.
2969 @node Naming Results
2970 @section Named Return Values in C++
2972 @cindex @code{return}, in C++ function header
2973 @cindex return value, named, in C++
2974 @cindex named return value in C++
2975 @cindex C++ named return value
2976 GNU C++ extends the function-definition syntax to allow you to specify a
2977 name for the result of a function outside the body of the definition, in
2983 @var{functionname} (@var{args}) return @var{resultname};
2992 You can use this feature to avoid an extra constructor call when
2993 a function result has a class type. For example, consider a function
2994 @code{m}, declared as @w{@samp{X v = m ();}}, whose result is of class
3007 @cindex implicit argument: return value
3008 Although @code{m} appears to have no arguments, in fact it has one implicit
3009 argument: the address of the return value. At invocation, the address
3010 of enough space to hold @code{v} is sent in as the implicit argument.
3011 Then @code{b} is constructed and its @code{a} field is set to the value
3012 23. Finally, a copy constructor (a constructor of the form @samp{X(X&)})
3013 is applied to @code{b}, with the (implicit) return value location as the
3014 target, so that @code{v} is now bound to the return value.
3016 But this is wasteful. The local @code{b} is declared just to hold
3017 something that will be copied right out. While a compiler that
3018 combined an ``elision'' algorithm with interprocedural data flow
3019 analysis could conceivably eliminate all of this, it is much more
3020 practical to allow you to assist the compiler in generating
3021 efficient code by manipulating the return value explicitly,
3022 thus avoiding the local variable and copy constructor altogether.
3024 Using the extended GNU C++ function-definition syntax, you can avoid the
3025 temporary allocation and copying by naming @code{r} as your return value
3026 at the outset, and assigning to its @code{a} field directly:
3037 The declaration of @code{r} is a standard, proper declaration, whose effects
3038 are executed @strong{before} any of the body of @code{m}.
3040 Functions of this type impose no additional restrictions; in particular,
3041 you can execute @code{return} statements, or return implicitly by
3042 reaching the end of the function body (``falling off the edge'').
3054 (or even @w{@samp{X m () return r (23); @{ @}}}) are unambiguous, since
3055 the return value @code{r} has been initialized in either case. The
3056 following code may be hard to read, but also works predictably:
3067 The return value slot denoted by @code{r} is initialized at the outset,
3068 but the statement @samp{return b;} overrides this value. The compiler
3069 deals with this by destroying @code{r} (calling the destructor if there
3070 is one, or doing nothing if there is not), and then reinitializing
3071 @code{r} with @code{b}.
3073 This extension is provided primarily to help people who use overloaded
3074 operators, where there is a great need to control not just the
3075 arguments, but the return values of functions. For classes where the
3076 copy constructor incurs a heavy performance penalty (especially in the
3077 common case where there is a quick default constructor), this is a major
3078 savings. The disadvantage of this extension is that you do not control
3079 when the default constructor for the return value is called: it is
3080 always called at the beginning.
3083 @section Minimum and Maximum Operators in C++
3085 It is very convenient to have operators which return the ``minimum'' or the
3086 ``maximum'' of two arguments. In GNU C++ (but not in GNU C),
3089 @item @var{a} <? @var{b}
3091 @cindex minimum operator
3092 is the @dfn{minimum}, returning the smaller of the numeric values
3093 @var{a} and @var{b};
3095 @item @var{a} >? @var{b}
3097 @cindex maximum operator
3098 is the @dfn{maximum}, returning the larger of the numeric values @var{a}
3102 These operations are not primitive in ordinary C++, since you can
3103 use a macro to return the minimum of two things in C++, as in the
3107 #define MIN(X,Y) ((X) < (Y) ? : (X) : (Y))
3111 You might then use @w{@samp{int min = MIN (i, j);}} to set @var{min} to
3112 the minimum value of variables @var{i} and @var{j}.
3114 However, side effects in @code{X} or @code{Y} may cause unintended
3115 behavior. For example, @code{MIN (i++, j++)} will fail, incrementing
3116 the smaller counter twice. A GNU C extension allows you to write safe
3117 macros that avoid this kind of problem (@pxref{Naming Types,,Naming an
3118 Expression's Type}). However, writing @code{MIN} and @code{MAX} as
3119 macros also forces you to use function-call notation for a
3120 fundamental arithmetic operation. Using GNU C++ extensions, you can
3121 write @w{@samp{int min = i <? j;}} instead.
3123 Since @code{<?} and @code{>?} are built into the compiler, they properly
3124 handle expressions with side-effects; @w{@samp{int min = i++ <? j++;}}
3127 @node Destructors and Goto
3128 @section @code{goto} and Destructors in GNU C++
3130 @cindex @code{goto} in C++
3131 @cindex destructors vs @code{goto}
3132 In C++ programs, you can safely use the @code{goto} statement. When you
3133 use it to exit a block which contains aggregates requiring destructors,
3134 the destructors will run before the @code{goto} transfers control.
3136 @cindex constructors vs @code{goto}
3137 The compiler still forbids using @code{goto} to @emph{enter} a scope
3138 that requires constructors.
3141 @section Declarations and Definitions in One Header
3143 @cindex interface and implementation headers, C++
3144 @cindex C++ interface and implementation headers
3145 C++ object definitions can be quite complex. In principle, your source
3146 code will need two kinds of things for each object that you use across
3147 more than one source file. First, you need an @dfn{interface}
3148 specification, describing its structure with type declarations and
3149 function prototypes. Second, you need the @dfn{implementation} itself.
3150 It can be tedious to maintain a separate interface description in a
3151 header file, in parallel to the actual implementation. It is also
3152 dangerous, since separate interface and implementation definitions may
3153 not remain parallel.
3155 @cindex pragmas, interface and implementation
3156 With GNU C++, you can use a single header file for both purposes.
3159 @emph{Warning:} The mechanism to specify this is in transition. For the
3160 nonce, you must use one of two @code{#pragma} commands; in a future
3161 release of GNU C++, an alternative mechanism will make these
3162 @code{#pragma} commands unnecessary.
3165 The header file contains the full definitions, but is marked with
3166 @samp{#pragma interface} in the source code. This allows the compiler
3167 to use the header file only as an interface specification when ordinary
3168 source files incorporate it with @code{#include}. In the single source
3169 file where the full implementation belongs, you can use either a naming
3170 convention or @samp{#pragma implementation} to indicate this alternate
3171 use of the header file.
3174 @item #pragma interface
3175 @itemx #pragma interface "@var{subdir}/@var{objects}.h"
3176 @kindex #pragma interface
3177 Use this directive in @emph{header files} that define object classes, to save
3178 space in most of the object files that use those classes. Normally,
3179 local copies of certain information (backup copies of inline member
3180 functions, debugging information, and the internal tables that implement
3181 virtual functions) must be kept in each object file that includes class
3182 definitions. You can use this pragma to avoid such duplication. When a
3183 header file containing @samp{#pragma interface} is included in a
3184 compilation, this auxiliary information will not be generated (unless
3185 the main input source file itself uses @samp{#pragma implementation}).
3186 Instead, the object files will contain references to be resolved at link
3189 The second form of this directive is useful for the case where you have
3190 multiple headers with the same name in different directories. If you
3191 use this form, you must specify the same string to @samp{#pragma
3194 @item #pragma implementation
3195 @itemx #pragma implementation "@var{objects}.h"
3196 @kindex #pragma implementation
3197 Use this pragma in a @emph{main input file}, when you want full output from
3198 included header files to be generated (and made globally visible). The
3199 included header file, in turn, should use @samp{#pragma interface}.
3200 Backup copies of inline member functions, debugging information, and the
3201 internal tables used to implement virtual functions are all generated in
3202 implementation files.
3204 @cindex implied @code{#pragma implementation}
3205 @cindex @code{#pragma implementation}, implied
3206 @cindex naming convention, implementation headers
3207 If you use @samp{#pragma implementation} with no argument, it applies to
3208 an include file with the same basename@footnote{A file's @dfn{basename}
3209 was the name stripped of all leading path information and of trailing
3210 suffixes, such as @samp{.h} or @samp{.C} or @samp{.cc}.} as your source
3211 file. For example, in @file{allclass.cc}, giving just
3212 @samp{#pragma implementation}
3213 by itself is equivalent to @samp{#pragma implementation "allclass.h"}.
3215 In versions of GNU C++ prior to 2.6.0 @file{allclass.h} was treated as
3216 an implementation file whenever you would include it from
3217 @file{allclass.cc} even if you never specified @samp{#pragma
3218 implementation}. This was deemed to be more trouble than it was worth,
3219 however, and disabled.
3221 If you use an explicit @samp{#pragma implementation}, it must appear in
3222 your source file @emph{before} you include the affected header files.
3224 Use the string argument if you want a single implementation file to
3225 include code from multiple header files. (You must also use
3226 @samp{#include} to include the header file; @samp{#pragma
3227 implementation} only specifies how to use the file---it doesn't actually
3230 There is no way to split up the contents of a single header file into
3231 multiple implementation files.
3234 @cindex inlining and C++ pragmas
3235 @cindex C++ pragmas, effect on inlining
3236 @cindex pragmas in C++, effect on inlining
3237 @samp{#pragma implementation} and @samp{#pragma interface} also have an
3238 effect on function inlining.
3240 If you define a class in a header file marked with @samp{#pragma
3241 interface}, the effect on a function defined in that class is similar to
3242 an explicit @code{extern} declaration---the compiler emits no code at
3243 all to define an independent version of the function. Its definition
3244 is used only for inlining with its callers.
3246 Conversely, when you include the same header file in a main source file
3247 that declares it as @samp{#pragma implementation}, the compiler emits
3248 code for the function itself; this defines a version of the function
3249 that can be found via pointers (or by callers compiled without
3250 inlining). If all calls to the function can be inlined, you can avoid
3251 emitting the function by compiling with @samp{-fno-implement-inlines}.
3252 If any calls were not inlined, you will get linker errors.
3254 @node Template Instantiation
3255 @section Where's the Template?
3257 @cindex template instantiation
3259 C++ templates are the first language feature to require more
3260 intelligence from the environment than one usually finds on a UNIX
3261 system. Somehow the compiler and linker have to make sure that each
3262 template instance occurs exactly once in the executable if it is needed,
3263 and not at all otherwise. There are two basic approaches to this
3264 problem, which I will refer to as the Borland model and the Cfront model.
3268 Borland C++ solved the template instantiation problem by adding the code
3269 equivalent of common blocks to their linker; the compiler emits template
3270 instances in each translation unit that uses them, and the linker
3271 collapses them together. The advantage of this model is that the linker
3272 only has to consider the object files themselves; there is no external
3273 complexity to worry about. This disadvantage is that compilation time
3274 is increased because the template code is being compiled repeatedly.
3275 Code written for this model tends to include definitions of all
3276 templates in the header file, since they must be seen to be
3280 The AT&T C++ translator, Cfront, solved the template instantiation
3281 problem by creating the notion of a template repository, an
3282 automatically maintained place where template instances are stored. A
3283 more modern version of the repository works as follows: As individual
3284 object files are built, the compiler places any template definitions and
3285 instantiations encountered in the repository. At link time, the link
3286 wrapper adds in the objects in the repository and compiles any needed
3287 instances that were not previously emitted. The advantages of this
3288 model are more optimal compilation speed and the ability to use the
3289 system linker; to implement the Borland model a compiler vendor also
3290 needs to replace the linker. The disadvantages are vastly increased
3291 complexity, and thus potential for error; for some code this can be
3292 just as transparent, but in practice it can been very difficult to build
3293 multiple programs in one directory and one program in multiple
3294 directories. Code written for this model tends to separate definitions
3295 of non-inline member templates into a separate file, which should be
3296 compiled separately.
3299 When used with GNU ld version 2.8 or later on an ELF system such as
3300 Linux/GNU or Solaris 2, or on Microsoft Windows, g++ supports the
3301 Borland model. On other systems, g++ implements neither automatic
3304 A future version of g++ will support a hybrid model whereby the compiler
3305 will emit any instantiations for which the template definition is
3306 included in the compile, and store template definitions and
3307 instantiation context information into the object file for the rest.
3308 The link wrapper will extract that information as necessary and invoke
3309 the compiler to produce the remaining instantiations. The linker will
3310 then combine duplicate instantiations.
3312 In the mean time, you have the following options for dealing with
3313 template instantiations:
3317 Compile your template-using code with @samp{-frepo}. The compiler will
3318 generate files with the extension @samp{.rpo} listing all of the
3319 template instantiations used in the corresponding object files which
3320 could be instantiated there; the link wrapper, @samp{collect2}, will
3321 then update the @samp{.rpo} files to tell the compiler where to place
3322 those instantiations and rebuild any affected object files. The
3323 link-time overhead is negligible after the first pass, as the compiler
3324 will continue to place the instantiations in the same files.
3326 This is your best option for application code written for the Borland
3327 model, as it will just work. Code written for the Cfront model will
3328 need to be modified so that the template definitions are available at
3329 one or more points of instantiation; usually this is as simple as adding
3330 @code{#include <tmethods.cc>} to the end of each template header.
3332 For library code, if you want the library to provide all of the template
3333 instantiations it needs, just try to link all of its object files
3334 together; the link will fail, but cause the instantiations to be
3335 generated as a side effect. Be warned, however, that this may cause
3336 conflicts if multiple libraries try to provide the same instantiations.
3337 For greater control, use explicit instantiation as described in the next
3341 Compile your code with @samp{-fno-implicit-templates} to disable the
3342 implicit generation of template instances, and explicitly instantiate
3343 all the ones you use. This approach requires more knowledge of exactly
3344 which instances you need than do the others, but it's less
3345 mysterious and allows greater control. You can scatter the explicit
3346 instantiations throughout your program, perhaps putting them in the
3347 translation units where the instances are used or the translation units
3348 that define the templates themselves; you can put all of the explicit
3349 instantiations you need into one big file; or you can create small files
3356 template class Foo<int>;
3357 template ostream& operator <<
3358 (ostream&, const Foo<int>&);
3361 for each of the instances you need, and create a template instantiation
3364 If you are using Cfront-model code, you can probably get away with not
3365 using @samp{-fno-implicit-templates} when compiling files that don't
3366 @samp{#include} the member template definitions.
3368 If you use one big file to do the instantiations, you may want to
3369 compile it without @samp{-fno-implicit-templates} so you get all of the
3370 instances required by your explicit instantiations (but not by any
3371 other files) without having to specify them as well.
3373 g++ has extended the template instantiation syntax outlined in the
3374 Working Paper to allow forward declaration of explicit instantiations
3375 and instantiation of the compiler support data for a template class
3376 (i.e. the vtable) without instantiating any of its members:
3379 extern template int max (int, int);
3380 inline template class Foo<int>;
3384 Do nothing. Pretend g++ does implement automatic instantiation
3385 management. Code written for the Borland model will work fine, but
3386 each translation unit will contain instances of each of the templates it
3387 uses. In a large program, this can lead to an unacceptable amount of code
3391 Add @samp{#pragma interface} to all files containing template
3392 definitions. For each of these files, add @samp{#pragma implementation
3393 "@var{filename}"} to the top of some @samp{.C} file which
3394 @samp{#include}s it. Then compile everything with
3395 @samp{-fexternal-templates}. The templates will then only be expanded
3396 in the translation unit which implements them (i.e. has a @samp{#pragma
3397 implementation} line for the file where they live); all other files will
3398 use external references. If you're lucky, everything should work
3399 properly. If you get undefined symbol errors, you need to make sure
3400 that each template instance which is used in the program is used in the
3401 file which implements that template. If you don't have any use for a
3402 particular instance in that file, you can just instantiate it
3403 explicitly, using the syntax from the latest C++ working paper:
3406 template class A<int>;
3407 template ostream& operator << (ostream&, const A<int>&);
3410 This strategy will work with code written for either model. If you are
3411 using code written for the Cfront model, the file containing a class
3412 template and the file containing its member templates should be
3413 implemented in the same translation unit.
3415 A slight variation on this approach is to instead use the flag
3416 @samp{-falt-external-templates}; this flag causes template
3417 instances to be emitted in the translation unit that implements the
3418 header where they are first instantiated, rather than the one which
3419 implements the file where the templates are defined. This header must
3420 be the same in all translation units, or things are likely to break.
3422 @xref{C++ Interface,,Declarations and Definitions in One Header}, for
3423 more discussion of these pragmas.
3426 @node C++ Signatures
3427 @section Type Abstraction using Signatures
3430 @cindex type abstraction, C++
3431 @cindex C++ type abstraction
3432 @cindex subtype polymorphism, C++
3433 @cindex C++ subtype polymorphism
3434 @cindex signatures, C++
3435 @cindex C++ signatures
3437 In GNU C++, you can use the keyword @code{signature} to define a
3438 completely abstract class interface as a datatype. You can connect this
3439 abstraction with actual classes using signature pointers. If you want
3440 to use signatures, run the GNU compiler with the
3441 @samp{-fhandle-signatures} command-line option. (With this option, the
3442 compiler reserves a second keyword @code{sigof} as well, for a future
3445 Roughly, signatures are type abstractions or interfaces of classes.
3446 Some other languages have similar facilities. C++ signatures are
3447 related to ML's signatures, Haskell's type classes, definition modules
3448 in Modula-2, interface modules in Modula-3, abstract types in Emerald,
3449 type modules in Trellis/Owl, categories in Scratchpad II, and types in
3450 POOL-I. For a more detailed discussion of signatures, see
3451 @cite{Signatures: A Language Extension for Improving Type Abstraction and
3452 Subtype Polymorphism in C++}
3453 by @w{Gerald} Baumgartner and Vincent F. Russo (Tech report
3454 CSD--TR--95--051, Dept. of Computer Sciences, Purdue University,
3455 August 1995, a slightly improved version appeared in
3456 @emph{Software---Practice & Experience}, @b{25}(8), pp. 863--889,
3457 August 1995). You can get the tech report by anonymous FTP from
3458 @code{ftp.cs.purdue.edu} in @file{pub/gb/Signature-design.ps.gz}.
3460 Syntactically, a signature declaration is a collection of
3461 member function declarations and nested type declarations.
3462 For example, this signature declaration defines a new abstract type
3463 @code{S} with member functions @samp{int foo ()} and @samp{int bar (int)}:
3473 Since signature types do not include implementation definitions, you
3474 cannot write an instance of a signature directly. Instead, you can
3475 define a pointer to any class that contains the required interfaces as a
3476 @dfn{signature pointer}. Such a class @dfn{implements} the signature
3478 @c Eventually signature references should work too.
3480 To use a class as an implementation of @code{S}, you must ensure that
3481 the class has public member functions @samp{int foo ()} and @samp{int
3482 bar (int)}. The class can have other member functions as well, public
3483 or not; as long as it offers what's declared in the signature, it is
3484 suitable as an implementation of that signature type.
3486 For example, suppose that @code{C} is a class that meets the
3487 requirements of signature @code{S} (@code{C} @dfn{conforms to}
3496 defines a signature pointer @code{p} and initializes it to point to an
3497 object of type @code{C}.
3498 The member function call @w{@samp{int i = p->foo ();}}
3499 executes @samp{obj.foo ()}.
3501 @cindex @code{signature} in C++, advantages
3502 Abstract virtual classes provide somewhat similar facilities in standard
3503 C++. There are two main advantages to using signatures instead:
3507 Subtyping becomes independent from inheritance. A class or signature
3508 type @code{T} is a subtype of a signature type @code{S} independent of
3509 any inheritance hierarchy as long as all the member functions declared
3510 in @code{S} are also found in @code{T}. So you can define a subtype
3511 hierarchy that is completely independent from any inheritance
3512 (implementation) hierarchy, instead of being forced to use types that
3513 mirror the class inheritance hierarchy.
3516 Signatures allow you to work with existing class hierarchies as
3517 implementations of a signature type. If those class hierarchies are
3518 only available in compiled form, you're out of luck with abstract virtual
3519 classes, since an abstract virtual class cannot be retrofitted on top of
3520 existing class hierarchies. So you would be required to write interface
3521 classes as subtypes of the abstract virtual class.
3524 @cindex default implementation, signature member function
3525 @cindex signature member function default implementation
3526 There is one more detail about signatures. A signature declaration can
3527 contain member function @emph{definitions} as well as member function
3528 declarations. A signature member function with a full definition is
3529 called a @emph{default implementation}; classes need not contain that
3530 particular interface in order to conform. For example, a
3531 class @code{C} can conform to the signature
3537 int f0 () @{ return f (0); @};
3542 whether or not @code{C} implements the member function @samp{int f0 ()}.
3543 If you define @code{C::f0}, that definition takes precedence;
3544 otherwise, the default implementation @code{S::f0} applies.
3547 There will be more support for signatures in the future.
3548 Add to this doc as the implementation grows.
3549 In particular, the following features are planned but not yet
3552 @item signature references,
3553 @item signature inheritance,
3554 @item the @code{sigof} construct for extracting the signature information
3556 @item views for renaming member functions when matching a class type
3557 with a signature type,
3558 @item specifying exceptions with signature member functions, and
3559 @item signature templates.
3561 This list is roughly in the order in which we intend to implement
3562 them. Watch this space for updates.