This part of the documentation is a modified version of the C Extensions section of the GCC Manual.
Therefore it is licensed under the GNU Free Documentation License.
GCC4TI (like all GNU C compilers) provides several language features not found
in ISO standard C. To test for the availability of these
features in conditional compilation, check for a predefined macro
__GNUC__, which is always defined under GCC.
Some features that are in ISO C99 but not C89 are also, as
extensions, accepted by GCC in C89 mode.
Original author: Free Software Foundation, Inc.
Authors of the modifications: Zeljko Juric, Sebastian Reichelt, and Kevin Kofler
Published by the TIGCC Team, and now the GCC4TI project.
See the History section for details and copyright information.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1 or any
later version published by the Free Software Foundation; with the Invariant
Sections being "GNU General Public License" and "Funding Free Software", the
Front-Cover texts being (a) (see below), and with the Back-Cover Texts being
(b) (see below). A copy of the license is included in the section entitled
"GNU Free Documentation License".
(a) The FSF's Front-Cover Text is:
A GNU Manual
(b) The FSF's Back-Cover Text is:
You have freedom to copy and modify this GNU Manual, like GNU software.
Copies published by the Free Software Foundation raise funds for GNU
development.
A compound statement enclosed in parentheses may appear as an expression
in GNU C. This allows you to use loops, switches, and local variables
within an expression.
Recall that a compound statement is a sequence of statements surrounded
by braces; in this construct, parentheses go around the braces. For
example:
({ int y = foo (); int z;
if (y > 0) z = y;
else z = - y;
z; })
is a valid (though slightly more complex than necessary) expression
for the absolute value of foo ().
The last thing in the compound statement should be an expression
followed by a semicolon; the value of this subexpression serves as the
value of the entire construct. (If you use some other kind of statement
last within the braces, the construct has type void, and thus
effectively no value.)
This feature is especially useful in making macro definitions "safe" (so
that they evaluate each operand exactly once). For example, the
"maximum" function is commonly defined as a macro in standard C as
follows:
#define max(a,b) ((a) > (b) ? (a) : (b))
But this definition computes either a or b twice, with bad
results if the operand has side effects. In GNU C, if you know the
type of the operands (here let's assume int), you can define
the macro safely as follows:
#define maxint(a,b) \
({int _a = (a), _b = (b); _a > _b ? _a : _b; })
Embedded statements are not allowed in constant expressions, such as
the value of an enumeration constant, the width of a bit-field, or
the initial value of a static variable.
If you don't know the type of the operand, you can still do this, but you
must use typeof.
Each statement expression is a scope in which local labels can be
declared. A local label is simply an identifier; you can jump to it
with an ordinary goto statement, but only from within the
statement expression it belongs to.
A local label declaration looks like this:
__label__ label;
or
__label__ label1, label2, /* ... */;
Local label declarations must come at the beginning of the statement
expression, right after the ({, before any ordinary
declarations.
The label declaration defines the label name, but does not define
the label itself. You must do this in the usual way, with
label:, within the statements of the statement expression.
The local label feature is useful because statement expressions are
often used in macros. If the macro contains nested loops, a goto
can be useful for breaking out of them. However, an ordinary label
whose scope is the whole function cannot be used: if the macro can be
expanded several times in one function, the label will be multiply
defined in that function. A local label avoids this problem. For
example:
#define SEARCH(array, target) \
({ \
__label__ found; \
typeof (target) _SEARCH_target = (target); \
typeof (*(array)) *_SEARCH_array = (array); \
int i, j; \
int value; \
for (i = 0; i < max; i++) \
for (j = 0; j < max; j++) \
if (_SEARCH_array[i][j] == _SEARCH_target) \
{ value = i; goto found; } \
value = -1; \
found: \
value; \
})
You can get the address of a label defined in the current function
(or a containing function) with the unary operator &&. The
+ value has type void*. This value is a constant and can be used
wherever a constant of that type is valid. For example:
void *ptr; /* ... */ ptr = &&foo;
To use these values, you need to be able to jump to one. This is done
with the computed goto statement, goto *exp;. For example,
goto *ptr;
Any expression of type void* is allowed.
One way of using these constants is in initializing a static array that
will serve as a jump table:
static void *array[] = { &&foo, &&bar, &&hack };
Then you can select a label with indexing, like this:
goto *array[i];
Note that this does not check whether the subscript is in bounds - array
indexing in C never does that.
Such an array of label values serves a purpose much like that of the
switch statement. The switch statement is cleaner, so
use that rather than an array unless the problem does not fit a
switch statement very well.
You may not use this mechanism to jump to code in a different function.
If you do that, totally unpredictable things will happen. The best way to
avoid this is to store the label address only in automatic variables and
never pass it as an argument.
An alternate way to write the above example is
static const int array[] = { &&foo - &&foo, &&bar - &&foo,
&&hack - &&foo };
goto *(&&foo + array[i]);
This is more friendly to code living in shared libraries (DLLs), as it reduces the number of dynamic relocations that are needed (and, by consequence, would allow the data to be read-only).
A nested function is a function defined inside another function.
The nested function's
name is local to the block where it is defined. For example, here we
define a nested function named square, and call it twice:
double square_sum (double a, double b)
{
double square (double z)
{
return z * z;
}
return square (a) + square (b);
}
The nested function can access all the variables of the containing
function that are visible at the point of its definition. This is
called lexical scoping. For example, here we show a nested
function which uses an inherited variable named offset:
int foo (int *array, int offset, int size)
{
int access (int *array, int index)
{
return array[index + offset];
}
int i;
/* ... */
for (i = 0; i < size; i++)
/* ... */ access (array, i) /* ... */
}
Nested function definitions are permitted within functions in the places
where variable definitions are allowed; that is, in any block, before
the first statement in the block.
It is possible to call the nested function from outside the scope of its
name by storing its address or passing the address to another function:
int hack (int *array, int size)
{
void store (int index, int value)
{
array[index] = value;
}
intermediate (store, size);
}
Here, the function intermediate receives the address of
store as an argument. If intermediate calls store,
the arguments given to store are used to store into array.
But this technique works only so long as the containing function
(hack, in this example) does not exit.
If you try to call the nested function through its address after the
containing function has exited, all hell will break loose. If you try
to call it after a containing scope level has exited, and if it refers
to some of the variables that are no longer in scope, you may be lucky,
but it's not wise to take the risk. If, however, the nested function
does not refer to anything that has gone out of scope, you should be
safe.
GCC implements taking the address of a nested function using a technique
called trampolines. A paper describing them is available at
http://people.debian.org/~aaronl/Usenix88-lexic.pdf.
Note that trampolines are currently broken in GCC4TI; they create code on the
stack, which can make HW2 calculators crash.
A nested function can jump to a label inherited from a containing
function, provided the label was explicitly declared in the containing
function (see Local Labels). Such a jump returns instantly to the
containing function, exiting the nested function which did the
goto and any intermediate functions as well. Here is an example:
int bar (int *array, int offset, int size)
{
__label__ failure;
int access (int *array, int index)
{
if (index > size)
goto failure;
return array[index + offset];
}
int i;
/* ... */
for (i = 0; i < size; i++)
/* ... */ access (array, i) /* ... */
/* ... */
return 0;
/* Control comes here from 'access'
if it detects an error. */
failure:
return -1;
}
A nested function always has internal linkage. Declaring one with
extern is erroneous. If you need to declare the nested function
before its definition, use auto (which is otherwise meaningless
for function declarations).
int bar (int *array, int offset, int size)
{
__label__ failure;
auto int access (int *, int);
/* ... */
int access (int *array, int index)
{
if (index > size)
goto failure;
return array[index + offset];
}
/* ... */
}
Using the built-in functions described below, you can record
the arguments a function received, and call another function
with the same arguments, without knowing the number or types
of the arguments.
You can also record the return value of that function call,
and later return that value, without knowing what data type
the function tried to return (as long as your caller expects
that data type).
void *__builtin_apply_args (void);
This built-in function returns a pointer to data
describing how to perform a call with the same arguments as were passed
to the current function.
The function saves the arg pointer register, structure value address,
and all registers that might be used to pass arguments to a function
into a block of memory allocated on the stack. Then it returns the
address of that block.
void *__builtin_apply (void (*fnc)(), void *args, int size);
This built-in function invokes function
with a copy of the parameters described by arguments
and size.
The value of arguments should be the value returned by
__builtin_apply_args.
The argument size specifies the size
of the stack argument data, in bytes.
This function returns a pointer to data describing
how to return whatever value was returned by function. The data
is saved in a block of memory allocated on the stack.
It is not always simple to compute the proper value for size. The
value is used by __builtin_apply to compute the amount of data
that should be pushed on the stack and copied from the incoming argument
area.
void __builtin_return (void *result);
This built-in function returns the value described by result from
the containing function. You should specify, for result, a value
returned by __builtin_apply.
Another way to refer to the type of an expression is with typeof.
The syntax of using of this keyword looks like sizeof, but the
construct acts semantically like a type name defined with typedef.
There are two ways of writing the argument to typeof: with an
expression or with a type. Here is an example with an expression:
typeof (x[0](1))
This assumes that x is an array of pointers to functions;
the type described is that of the values of the functions.
Here is an example with a typename as the argument:
typeof (int *)
Here the type described is that of pointers to int.
An alternate keyword for typeof is __typeof__.
See Alternate Keywords.
A typeof-construct can be used anywhere a typedef name could be
used. For example, you can use it in a declaration, in a cast, or inside
of sizeof or typeof.
typeof is often useful in conjunction with the
statements-within-expressions feature. Here is how the two together can
be used to define a safe "maximum" macro that operates on any
arithmetic type and evaluates each of its arguments exactly once:
#define max(a,b) \
({ typeof (a) _a = (a); \
typeof (b) _b = (b); \
_a > _b ? _a : _b; })
The reason for using names that start with underscores for the local
variables is to avoid conflicts with variable names that occur within the
expressions that are substituted for a and b. Eventually we
hope to design a new form of declaration syntax that allows you to declare
variables whose scopes start only after their initializers; this will be a
more reliable way to prevent such conflicts.
Some more examples of the use of typeof:
This declares y with the type of what x points to.
typeof (*x) y;
This declares y as an array of such values.
typeof (*x) y[4];
This declares y as an array of pointers to characters:
typeof (typeof (char *)[4]) y;
It is equivalent to the following traditional C declaration:
char *y[4];
To see the meaning of the declaration using typeof, and why it
might be a useful way to write, let's rewrite it with these macros:
#define pointer(T) typeof(T *) #define array(T, N) typeof(T [N])
Now the declaration can be rewritten this way:
array (pointer (char), 4) y;
Thus, array (pointer (char), 4) is the type of arrays of 4
pointers to char.
Compatibility Note: In addition to typeof, GCC 2 supported
a more limited extension which permitted one to write
typedef T = expr;
with the effect of declaring T to have the type of the expression
expr. This extension does not work with GCC 3 (versions between
3.0 and 3.2 will crash; 3.2.1 and later give an error). Code which
relies on it should be rewritten to use typeof:
typedef typeof(expr) T;
This will work with all versions of GCC.
Compound expressions, conditional expressions and casts are allowed as
lvalues provided their operands are lvalues. This means that you can take
their addresses or store values into them.
For example, a compound expression can be assigned, provided the last
expression in the sequence is an lvalue. These two expressions are
equivalent:
(a, b) += 5 a, (b += 5)
Similarly, the address of the compound expression can be taken. These two expressions are equivalent:
&(a, b) a, &b
A conditional expression is a valid lvalue if its type is not void and the true and false branches are both valid lvalues. For example, these two expressions are equivalent:
(a ? b : c) = 5 (a ? b = 5 : (c = 5))
A cast is a valid lvalue if its operand is an lvalue. A simple
assignment whose left-hand side is a cast works by converting the
right-hand side first to the specified type, then to the type of the
inner left-hand side expression. After this is stored, the value is
converted back to the specified type to become the value of the
assignment. Thus, if a has type char*, the following two
expressions are equivalent:
(int)a = 5 (int)(a = (char *)(int)5)
An assignment-with-arithmetic operation such as += applied to a cast
performs the arithmetic using the type resulting from the cast, and then
continues as in the previous case. Therefore, these two expressions are
equivalent:
(int)a += 5 (int)(a = (char *)(int) ((int)a + 5))
You cannot take the address of an lvalue cast, because the use of its
address would not work out coherently. Suppose that &(int)f were
permitted, where f has type float. Then the following
statement would try to store an integer bit-pattern where a floating
point number belongs:
*&(int)f = 1;
This is quite different from what (int)f = 1 would do - that
would convert 1 to floating point and store it. Rather than cause this
inconsistency, the GNU team thinks it is better to prohibit use of & on a cast.
If you really do want an int* pointer with the address of
f, you can simply write (int*)&f.
The middle operand in a conditional expression may be omitted. Then
if the first operand is nonzero, its value is the value of the conditional
expression.
Therefore, the expression
x ? : y
has the value of x if that is nonzero; otherwise, the value of
y.
This example is perfectly equivalent to
x ? x : y
In this simple case, the ability to omit the middle operand is not especially useful. When it becomes useful is when the first operand does, or may (if it is a macro argument), contain a side effect. Then repeating the operand in the middle would perform the side effect twice. Omitting the middle operand uses the value already computed without the undesirable effects of recomputing it.
ISO C99 supports data types for integers that are at least 64 bits wide,
and as an extension GCC supports them in C89 mode.
Simply write long long int for a signed integer, or
unsigned long long int for an unsigned integer. To make an
integer constant of type long long int, add the suffix LL
to the integer. To make an integer constant of type unsigned long
long int, add the suffix ULL to the integer.
You can use these types in arithmetic like any other integer types.
Addition, subtraction, and bitwise boolean operations on these types
are open-coded on all types of machines, as well as shifts with a constant
value. Multiplication, division and shifts are not open-coded and use
special library routines.
There may be pitfalls when you use long long types for function
arguments, unless you declare function prototypes. If a function
expects type int for its argument, and you pass a value of type
long long int, confusion will result because the caller and the
subroutine will disagree about the number of bytes for the argument.
Likewise, if the function expects long long int and you pass
int. The best way to avoid such problems is to use prototypes.
ISO C99 supports complex floating data types, and as an extension GCC
supports them in C89 mode, and supports complex integer data
types which are not part of ISO C99. You can declare complex types
using the keyword _Complex. As an extension, the older GNU
keyword __complex__ is also supported.
For example, _Complex double x; declares x as a
variable whose real part and imaginary part are both of type
double. _Complex short int y; declares y to
have real and imaginary parts of type short int; this is not
likely to be useful, but it shows that the set of complex types is
complete.
To write a constant with a complex data type, use the suffix i or
j (either one; they are equivalent). For example, 2.5fi
has type _Complex float and 3i has type
_Complex int. Such a constant always has a pure imaginary
value, but you can form any complex value you like by adding one to a
real constant. This is a GNU extension; once GCC4TI supports this, you should include <complex.h> and
use the macros I or _Complex_I instead.
To extract the real part of a complex-valued expression exp, write
__real__ exp. Likewise, use __imag__ to
extract the imaginary part. This is a GNU extension; for values of
floating type, you should use the ISO C99 functions crealf,
creal, creall, cimagf, cimag and
cimagl, declared in <complex.h> (not yet available in GCC4TI) and also provided as
built-in functions by GCC.
The operator ~ performs complex conjugation when used on a value
with a complex type. This is a GNU extension; for values of
floating type, you should use the ISO C99 functions conjf,
conj and conjl, declared in <complex.h> and also
provided as built-in functions by GCC.
GCC can allocate complex automatic variables in a noncontiguous
fashion; it's even possible for the real part to be in a register while
the imaginary part is on the stack (or vice-versa).
ISO C99 supports floating-point numbers written not only in the usual
decimal notation, such as 1.55e1, but also numbers such as
0x1.fp3 written in hexadecimal format. As a GNU extension, GCC
supports this in C89 mode (except in some cases when strictly
conforming). In that format the
0x hex introducer and the p or P exponent field are
mandatory. The exponent is a decimal number that indicates the power of
2 by which the significant part will be multiplied. Thus 0x1.f is
1 15/16,
p3 multiplies it by 8, and the value of 0x1.fp3
is the same as 1.55e1.
Unlike for floating-point numbers in the decimal notation the exponent
is always required in the hexadecimal notation. Otherwise the compiler
would not be able to resolve the ambiguity of, e.g., 0x1.f. This
could mean 1.0f or 1.9375 since f is also the
extension for floating-point constants of type float.
GCC4TI allows you to specify binary numbers by using a 0b prefix. This can be handy
in many occasions, such as when trying to declare sprites in a way which actually allows you to see
the picture. For example, the following declaration defines a simple black and white 8x8 diagonal
cross:
unsigned char cross[8] =
{0b10000001,
0b01000010,
0b00100100,
0b00011000,
0b00011000,
0b00100100,
0b01000010,
0b10000001};
GCC permits a C structure to have no members:
struct empty {
};
The structure will have size zero. In C++, empty structures are part of the language, and the language standard says they have size 1.
Zero-length arrays are allowed in GNU C. They are very useful as the last element of a structure which is really a header for a variable-length object:
struct line {
int length;
char contents[0];
};
struct line *thisline = (struct line *)
malloc (sizeof (struct line) + this_length);
thisline->length = this_length;
In ISO C90, you would have to give contents a length of 1, which
means either you waste space or complicate the argument to malloc.
In ISO C99, you would use a flexible array member, which is
slightly different in syntax and semantics:
Flexible array members are written as contents[] without
the 0.
Flexible array members have incomplete type, and so the sizeof
operator may not be applied. As a quirk of the original implementation
of zero-length arrays, sizeof evaluates to zero.
Flexible array members may only appear as the last member of a
struct that is otherwise non-empty.
A structure containing a flexible array member, or a union containing such a structure (possibly recursively), may not be a member of a structure or an element of an array. (However, these uses are permitted by GCC as extensions.)
GCC versions before 3.0 allowed zero-length arrays to be statically
initialized, as if they were flexible arrays. In addition to those
cases that were useful, it also allowed initializations in situations
that would corrupt later data. Non-empty initialization of zero-length
arrays is now treated like any case where there are more initializer
elements than the array holds, in that a suitable warning about "excess
elements in array" is given, and the excess elements (all of them, in
this case) are ignored.
Instead GCC allows static initialization of flexible array members.
This is equivalent to defining a new structure containing the original
structure followed by an array of sufficient size to contain the data.
I.e. in the following, f1 is constructed as if it were declared
like f2.
struct f1 {
int x; int y[];
} f1 = { 1, { 2, 3, 4 } };
struct f2 {
struct f1 f1; int data[3];
} f2 = { { 1 }, { 2, 3, 4 } };
The convenience of this extension is that f1 has the desired
type, eliminating the need to consistently refer to f2.f1.
This has symmetry with normal static arrays, in that an array of
unknown size is also written with [].
Of course, this extension only makes sense if the extra data comes at
the end of a top-level object, as otherwise we would be overwriting
data at subsequent offsets. To avoid undue complication and confusion
with initialization of deeply nested arrays, we simply disallow any
non-empty initialization except when the structure is the top-level
object. For example:
struct foo { int x; int y[]; };
struct bar { struct foo z; };
struct foo a = { 1, { 2, 3, 4 } }; // Valid.
struct bar b = { { 1, { 2, 3, 4 } } }; // Invalid.
struct bar c = { { 1, { } } }; // Valid.
struct foo d[1] = { { 1, { 2, 3, 4 } } }; // Invalid.
Variable-length automatic arrays are allowed in ISO C99, and as an extension GCC accepts them in C89 mode. (However, GCC's implementation of variable-length arrays does not yet conform in detail to the ISO C99 standard.) These arrays are declared like any other automatic arrays, but with a length that is not a constant expression. The storage is allocated at the point of declaration and deallocated when the brace-level is exited. For example:
FILE *concat_fopen (const char *s1, const char *s2, const char *mode)
{
char str[strlen (s1) + strlen (s2) + 1];
strcpy (str, s1);
strcat (str, s2);
return fopen (str, mode);
}
Jumping or breaking out of the scope of the array name deallocates the
storage. Jumping into the scope is not allowed; you get an error
message for it.
You can use the function alloca to get an effect much like
variable-length arrays. The function alloca is available in
many other C implementations (but not in all). On the other hand,
variable-length arrays are more elegant.
There are other differences between these two methods. Space allocated
with alloca exists until the containing function returns.
The space for a variable-length array is deallocated as soon as the array
name's scope ends. (If you use both variable-length arrays and
alloca in the same function, deallocation of a variable-length array
will also deallocate anything more recently allocated with alloca.)
You can also use variable-length arrays as arguments to functions:
struct entry
tester (int len, char data[len][len])
{
/* ... */
}
The length of an array is computed once when the storage is allocated
and is remembered for the scope of the array in case you access it with
sizeof.
If you want to pass the array first and the length afterward, you can
use a forward declaration in the parameter list - another GNU extension.
struct entry
tester (int len; char data[len][len], int len)
{
/* ... */
}
The int len before the semicolon is a parameter forward
declaration, and it serves the purpose of making the name len
known when the declaration of data is parsed.
You can write any number of such parameter forward declarations in the
parameter list. They can be separated by commas or semicolons, but the
last one must end with a semicolon, which is followed by the "real"
parameter declarations. Each forward declaration must match a "real"
declaration in parameter name and data type. ISO C99 does not support
parameter forward declarations.
In the ISO C standard of 1999, a macro can be declared to accept a variable number of arguments much as a function can. The syntax for defining the macro is similar to that of a function. Here is an example:
#define lprintf(format, ...) fprintf (log, format, __VA_ARGS__)
Here ... is a variable argument. In the invocation of
such a macro, it represents the zero or more tokens until the closing
parenthesis that ends the invocation, including any commas. This set of
tokens replaces the identifier __VA_ARGS__ in the macro body
wherever it appears.
For more information, see Variadic Macros.
GCC has long supported variadic macros, and used a different syntax that
allowed you to give a name to the variable arguments just like any other
argument. Here is an example:
#define lprintf(format, args...) fprintf (stderr, format, args)
This is in all ways equivalent to the ISO C example above, but arguably
more readable and descriptive.
GNU CPP has two further variadic macro extensions, and permits them to
be used with either of the above forms of macro definition.
In standard C, you are not allowed to leave the variable argument out
entirely; but you are allowed to pass an empty argument. For example,
this invocation is invalid in ISO C, because there is no comma after
the string:
lprintf ("A message");
GNU CPP permits you to completely omit the variable arguments in this
way. In the above examples, the compiler would complain, though since
the expansion of the macro still has the extra comma after the format
string.
To help solve this problem, CPP behaves specially for variable arguments
used with the token paste operator, ##. If instead you write
#define lprintf(format, ...) fprintf (log, format, ## __VA_ARGS__)
and if the variable arguments are omitted or empty, the ##
operator causes the preprocessor to remove the comma before it. If you
do provide some variable arguments in your macro invocation, GNU CPP
does not complain about the paste operation and instead places the
variable arguments after the comma. Just like any other pasted macro
argument, these arguments are not macro expanded.
In ISO C99, arrays that are not lvalues still decay to pointers, and
may be subscripted, although they may not be modified or used after
the next sequence point and the unary & operator may not be
applied to them. As an extension, GCC allows such arrays to be
subscripted in C89 mode, though otherwise they do not decay to
pointers outside C99 mode. For example,
this is valid in GNU C though not valid in C89:
struct foo {int a[4];};
struct foo f();
bar (int index)
{
return f().a[index];
}
In GNU C, addition and subtraction operations are supported on pointers to
void and on pointers to functions. This is done by treating the
size of a void or of a function as 1.
A consequence of this is that sizeof is also allowed on void
and on function types, and returns 1.
The option '-Wpointer-arith' requests a warning if these extensions
are used.
As in standard C++ and ISO C99, the elements of an aggregate initializer for an automatic variable are not required to be constant expressions in GNU C. Here is an example of an initializer with run-time varying elements:
void foo (float f, float g)
{
float beat_freqs[2] = { f-g, f+g };
/* ... */
}
ISO C99 supports compound literals. A compound literal looks like
a cast containing an initializer. Its value is an object of the
type specified in the cast, containing the elements specified in
the initializer; it is an lvalue. As an extension, GCC supports
compound literals in C89 mode and in C++.
Usually, the specified type is a structure. Assume that
struct foo and structure are declared as shown:
struct foo {int a; char b[2];} structure;
Here is an example of constructing a struct foo with a compound literal:
structure = ((struct foo) {x + y, 'a', 0});
This is equivalent to writing the following:
{
struct foo temp = {x + y, 'a', 0};
structure = temp;
}
You can also construct an array. If all the elements of the compound literal are (made up of) simple constant expressions, suitable for use in initializers of objects of static storage duration, then the compound literal can be coerced to a pointer to its first element and used in such an initializer, as shown here:
char **foo = (char *[]) { "x", "y", "z" };
Compound literals for scalar types and union types are
also allowed, but then the compound literal is equivalent
to a cast.
As a GNU extension, GCC allows initialization of objects with static storage
duration by compound literals (which is not possible in ISO C99, because
the initializer is not a constant).
It is handled as if the object was initialized only with the bracket
enclosed list if compound literal's and object types match.
The initializer list of the compound literal must be constant.
If the object being initialized has array type of unknown size, the size is
determined by compound literal size.
static struct foo x = (struct foo) {1, 'a', 'b'};
static int y[] = (int []) {1, 2, 3};
static int z[] = (int [3]) {1};
The above lines are equivalent to the following:
static struct foo x = {1, 'a', 'b'};
static int y[] = {1, 2, 3};
static int z[] = {1, 0, 0};
Standard C89 requires the elements of an initializer to appear in a fixed
order, the same as the order of the elements in the array or structure
being initialized.
In ISO C99 you can give the elements in any order, specifying the array
indices or structure field names they apply to, and GNU C allows this as
an extension in C89 mode as well.
To specify an array index, write
[index] = before the element value. For example,
int a[6] = { [4] = 29, [2] = 15 };
is equivalent to
int a[6] = { 0, 0, 15, 0, 29, 0 };
The index values must be constant expressions, even if the array being
initialized is automatic.
An alternative syntax for this which has been obsolete since GCC 2.5 but
GCC still accepts is to write [index] before the element
value, with no =.
To initialize a range of elements to the same value, write
[first ... last] = value. This is a GNU
extension. For example,
int widths[] = { [0 ... 9] = 1, [10 ... 99] = 2, [100] = 3 };
If the value in it has side-effects, the side-effects will happen only once,
not for each initialized field by the range initializer.
Note that the length of the array is the highest value specified
plus one.
In a structure initializer, specify the name of a field to initialize
with .fieldname = before the element value. For example,
given the following structure,
struct point { int x, y; };
the following initialization
struct point p = { .y = yvalue, .x = xvalue };
is equivalent to
struct point p = { xvalue, yvalue };
Another syntax which has the same meaning, obsolete since GCC 2.5, is
fieldname:, as shown here:
struct point p = { y: yvalue, x: xvalue };
The [index] or .fieldname is known as a
designator. You can also use a designator (or the obsolete colon
syntax) when initializing a union, to specify which element of the union
should be used. For example,
union foo { int i; double d; };
union foo f = { .d = 4 };
will convert 4 to a double to store it in the union using
the second element. By contrast, casting 4 to type union foo
would store it into the union as the integer i, since it is
an integer (see Cast to Union).
You can combine this technique of naming elements with ordinary C
initialization of successive elements. Each initializer element that
does not have a designator applies to the next consecutive element of the
array or structure. For example,
int a[6] = { [1] = v1, v2, [4] = v4 };
is equivalent to
int a[6] = { 0, v1, v2, 0, v4, 0 };
Labeling the elements of an array initializer is especially useful
when the indices are characters or belong to an enum type.
For example:
int whitespace[256]
= { [' '] = 1, ['\t'] = 1, ['\h'] = 1,
['\f'] = 1, ['\n'] = 1, ['\r'] = 1 };
You can also write a series of .fieldname and
[index] designators before an = to specify a
nested subobject to initialize; the list is taken relative to the
subobject corresponding to the closest surrounding brace pair. For
example, with the struct point declaration above:
struct point ptarray[10] = { [2].y = yv2, [2].x = xv2, [0].x = xv0 };
If the same field is initialized multiple times, it will have value from the last initialization. If any such overridden initialization has side-effect, it is unspecified whether the side-effect happens or not. Currently, GCC will discard them and issue a warning.
A cast to union type is similar to other casts, except that the type
specified is a union type. You can specify the type either with
union tag or with a typedef name. A cast to union is actually
a constructor though, not a cast, and hence does not yield an lvalue like
normal casts (see Compound Literals).
The types that may be cast to the union type are those of the members
of the union. Thus, given the following union and variables:
union foo { int i; double d; };
int x;
double y;
both x and y can be cast to type union foo.
Using the cast as the right-hand side of an assignment to a variable of
union type is equivalent to storing in a member of the union:
union foo u; /* ... */ u = (union foo) x <=> u.i = x u = (union foo) y <=> u.d = y
You can also use the union cast as a function argument:
void hack (union foo); /* ... */ hack ((union foo) x);
You can specify a range of consecutive values in a single case label,
like this:
case low ... high:
This has the same effect as the proper number of individual case
labels, one for each integer value from low to high, inclusive.
This feature is especially useful for ranges of ASCII character codes:
case 'A' ... 'Z':
Note: Always write spaces around the ..., for otherwise
it may be parsed wrong when you use it with integer values. For example,
write this:
case 1 ... 5:
rather than this:
case 1...5:
In GNU C, you declare certain things about functions called in your program
which help the compiler optimize function calls and check your code more
carefully.
The keyword __attribute__ allows you to specify special
attributes when making a declaration. This keyword is followed by an
attribute specification inside double parentheses.
The following attributes are currently defined for functions:
Other attributes are supported for variable declarations (see Variable Attributes)
and for types (see Type Attributes).
GCC4TI also defines the macros CALLBACK, __ATTR_TIOS__, __ATTR_TIOS_NORETURN__, __ATTR_TIOS_CALLBACK__, __ATTR_GCC__, __ATTR_LIB_C__, __ATTR_LIB_ASM__, __ATTR_LIB_ASM_NORETURN__, __ATTR_LIB_CALLBACK_C__, and __ATTR_LIB_CALLBACK_ASM__.
They are useful for specifying default attributes for a specific class of functions.
You only need to use them when you define a callback function.
For example, the callback function type compare_t
needs the attributes specified by __ATTR_LIB_CALLBACK_C__,
i.e. the attributes required by a callback function for a library function
written in C. Since this is too inconvenient for the user, all three callback
attributes have been made equal, and we have defined a single CALLBACK
macro.
You may also specify attributes with __ preceding and following
each keyword. This allows you to use them in header files without
being concerned about a possible macro of the same name. For example,
you may use __noreturn__ instead of noreturn.
For example, as malloc is defined as a macro in the GCC4TI Library,
always use __malloc__ instead of malloc.
See Attribute Syntax for details of the exact syntax for using
attributes.
You can specify multiple attributes in a declaration by separating them
by commas within the double parentheses or by immediately following an
attribute declaration with another attribute declaration.
Some people object to the __attribute__ feature, suggesting that
ISO C's #pragma should be used instead. At the time
__attribute__ was designed, there were two reasons for not doing
this.
It is impossible to generate #pragma commands from a macro.
There is no telling what the same #pragma might mean in another
compiler.
These two reasons applied to almost any application that might have been
proposed for #pragma. It was basically a mistake to use
#pragma for anything.
The ISO C99 standard includes _Pragma, which now allows pragmas
to be generated from macros. In addition, a #pragma GCC
namespace is now in use for GCC-specific pragmas. However, it has been
found convenient to use __attribute__ to achieve a natural
attachment of attributes to their corresponding declarations, whereas
#pragma GCC is of use for constructs that do not naturally form
part of the grammar.
A few standard library functions, such as abort and exit,
cannot return. Some programs define
their own functions that never return. You can declare them
noreturn to tell the compiler this fact. For example:
void fatal () __attribute__ ((noreturn));
void
fatal (/* ... */)
{
/* ... */ /* Print error message. */ /* ... */
exit (1);
}
The noreturn keyword tells the compiler to assume that
fatal cannot return. It can then optimize without regard to what
would happen if fatal ever did return. This makes slightly
better code. More importantly, it helps avoid spurious warnings of
uninitialized variables.
Do not assume that registers saved by the calling function are
restored before calling the noreturn function.
It does not make sense for a noreturn function to have a return
type other than void.
Many functions have no effects except the return value and their
return value depends only on the parameters and/or global variables.
Such a function can be subject
to common subexpression elimination and loop optimization just as an
arithmetic operator would be. These functions should be declared
with the attribute pure. For example,
int square (int) __attribute__ ((pure));
says that the hypothetical function square is safe to call
fewer times than the program says.
Some common examples of pure functions are strlen or memcmp.
Interesting non-pure functions are functions with infinite loops or those
depending on volatile memory or other system resource, that may change between
two consecutive calls.
See also: const
Many functions do not examine any values except their arguments, and
have no effects except the return value. Basically this is just slightly
more strict class than the pure attribute, since the function is not
allowed to read global memory.
Note that a function that has pointer arguments and examines the data
pointed to must not be declared const. Likewise, a
function that calls a non-const function usually must not be
const. It does not make sense for a const function to
return void.
See also: pure
Syntax: format (archetype, string-index, first-to-check)
The format attribute specifies that a function takes printf
style arguments which
should be type-checked against a format string. For example, the
declaration:
extern int
my_printf (void *my_object, const char *my_format, ...)
__attribute__ ((format (printf, 2, 3)));
causes the compiler to check the arguments in calls to my_printf
for consistency with the printf style format string argument
my_format.
The parameter archetype determines how the format string is
interpreted, and should be printf, scanf, strftime
or strfmon (note that only the function printf is implemented in the GCC4TI Library).
(You can also use __printf__,
__scanf__, __strftime__ or __strfmon__.) The
parameter string-index specifies which argument is the format
string argument (starting from 1), while first-to-check is the
number of the first argument to check against the format string. For
functions where the arguments are not available to be checked (such as
vprintf), specify the third parameter as zero. In this case the
compiler only checks the format string for consistency. For
strftime formats, the third parameter is required to be zero.
In the example above, the format string (my_format) is the second
argument of the function my_print, and the arguments to check
start with the third argument, so the correct parameters for the format
attribute are 2 and 3.
The format attribute allows you to identify your own functions
which take format strings as arguments, so that GCC can check the
calls to these functions for errors. The compiler always (unless
'-ffreestanding' is used) checks formats
for the standard library functions.
See Options Controlling C Dialect.
Syntax: format_arg (string-index)
The format_arg attribute specifies that a function takes a format
string for a printf style function and modifies it (for example, to translate
it into another language), so the result can be passed to a
printf style
function (with the remaining arguments to the format function the same
as they would have been for the unmodified string). For example, the
declaration
extern char *
my_dgettext (char *my_domain, const char *my_format)
__attribute__ ((format_arg (2)));
causes the compiler to check the arguments in calls to a printf type function, whose
format string argument is the result of a call to the my_dgettext function, for
consistency with the format string argument my_format. If the
format_arg attribute had not been specified, all the compiler
could tell in such calls to format functions would be that the format
string argument is not constant; this would generate a warning when
'-Wformat-nonliteral' is used, but the calls could not be checked
without the attribute.
The parameter string-index specifies which argument is the format
string argument (starting from 1).
The format-arg attribute allows you to identify your own
functions which modify format strings, so that GCC can check the
calls to printf
type functions whose operands are calls to one of your own functions.
(The compiler always treats gettext, dgettext, and
dcgettext in this manner except when strict ISO C support is
requested by '-ansi' or an appropriate '-std' option, or
'-ffreestanding' is used. See Options
Controlling C Dialect.)
If '-finstrument-functions' is given, profiling function calls will be generated at entry and exit of most user-compiled functions. Functions with this attribute will not be so instrumented.
Syntax: section ("section-name")
Normally, the compiler places all code and data it generates in the .data section.
Sometimes, however, you need additional sections, or you need certain
particular functions to appear in special sections. The section
attribute specifies that a function lives in a particular section.
For example, the declaration:
extern void foobar (void) __attribute__ ((section ("bar")));
puts the function foobar in the bar section.
The use of this attribute is limited in GCC4TI, because its linker supports
only a few types of sections.
The section attribute can also be used for variables.
The constructor attribute causes the function to be called
automatically before execution enters _main. Similarly, the
destructor attribute causes the function to be called
automatically after _main has completed or exit has
been called. Functions with these attributes are useful for
initializing data that will be used implicitly during the execution of
the program.
This attribute, attached to a function, means that the function is meant
to be possibly unused. GCC will not produce a warning for this
function.
The unused attribute can also be used for variables and
types.
This attribute, attached to a function, means that code must be emitted for the function even if it appears that the function is not referenced. This is useful, for example, when the function is referenced only in inline assembly.
The malloc attribute is used to tell the compiler that a function
may be treated as if it were the malloc function. The compiler assumes
that calls to malloc result in a pointers that cannot alias anything.
This will often improve optimization.
Syntax: alias ("target")
The alias attribute causes the declaration to be emitted as an
alias for another symbol, which must be specified. For instance,
void __f () { /* Do something. */; }
void f () __attribute__ ((weak, alias ("__f")));
declares f to be a weak alias for __f.
Not all target machines support this attribute.
We haven't tested yet whether it is supported for the Motorola 68000.
Generally, functions are not inlined unless optimization is specified. For functions declared inline, this attribute inlines the function even if no optimization level was specified.
This function attribute prevents a function from being considered for inlining.
The deprecated attribute results in a warning if the function
is used anywhere in the source file. This is useful when identifying
functions that are expected to be removed in a future version of a
program. The warning also includes the location of the declaration
of the deprecated function, to enable users to easily find further
information about why the function is deprecated, or what they should
do instead. Note that the warnings only occurs for uses:
int old_fn () __attribute__ ((deprecated)); int old_fn (); int (*fn_ptr)() = old_fn;
results in a warning on line 3 but not line 2.
The deprecated attribute can also be used for variables and
types.
Syntax: regparm [(regcount)] / stkparm
The regparm attribute causes the function to use regcount
data registers and regcount address registers for parameters.
stkparm means the exact opposite, i.e. all parameters are passed
on the stack. The '-mregparm' switch specifies which one is the default,
and the default for regcount.
See also: Specifying Registers for Function Parameters
Syntax: nonnull [(param1[, param2[, ...]])]
The nonnull attribute specifies that some function parameters should
be non-null pointers. For instance, the declaration:
extern void * my_memcpy (void *dest, const void *src, size_t len) __attribute__((nonnull (1, 2)));
causes the compiler to check that, in calls to my_memcpy,
arguments dest and src are non-null. If the compiler
determines that a null pointer is passed in an argument slot marked
as non-null, and the '-Wnonnull' option is enabled, a warning
is issued. The compiler may also choose to make optimizations based
on the knowledge that certain function arguments will not be null.
If no argument index list is given to the nonnull attribute,
all pointer arguments are marked as non-null. To illustrate, the
following declaration is equivalent to the previous example:
extern void * my_memcpy (void *dest, const void *src, size_t len) __attribute__((nonnull));
The nothrow attribute is used to inform the compiler that a
function cannot throw an exception.
This is probably useless in GCC4TI, as it implements its own error-handling
mechanism.
The keyword __attribute__ allows you to specify special
attributes of variables or structure fields. This keyword is followed
by an attribute specification inside double parentheses.
The following attributes are currently defined for variables:
Other attributes are
available for functions (see Function Attributes) and for types
(see Type Attributes).
You may also specify attributes with __ preceding and following
each keyword. This allows you to use them in header files without
being concerned about a possible macro of the same name. For example,
you may use __aligned__ instead of aligned.
See Attribute Syntax for details of the exact syntax for using
attributes.
To specify multiple attributes, separate them by commas within the
double parentheses: for example, __attribute__ ((aligned (16),
packed)).
Syntax: aligned [(alignment)]
This attribute specifies a minimum alignment for the variable or
structure field, measured in bytes. For example, the declaration:
int x __attribute__ ((aligned (4))) = 0;
causes the compiler to allocate the global variable x on a
4-byte boundary.
You can also specify the alignment of structure fields. For example, to
create a 4-byte aligned int pair, you could write:
struct foo { int x[2] __attribute__ ((aligned (4))); };
As in the preceding examples, you can explicitly specify the alignment (in bytes) that you wish the compiler to use for a given variable or structure field. Alternatively, you can leave out the alignment factor and just ask the compiler to align a variable or field to the maximum useful alignment for the target machine you are compiling for. For example, you could write:
short array[3] __attribute__ ((aligned));
Whenever you leave out the alignment factor in an aligned attribute
specification, the compiler automatically sets the alignment for the declared
variable or field to the largest alignment which is ever used for any data
type on the target machine you are compiling for (useless in GCC4TI, since everything
is already aligned well enough with the default 2-byte alignment).
The aligned attribute can only increase the alignment; but you
can decrease it by specifying packed as well.
Syntax: mode (mode)
This attribute specifies the data type for the declaration - whichever
type corresponds to the mode mode. This in effect lets you
request an integer or floating point type according to its width.
You may also specify a mode of byte or __byte__ to
indicate the mode corresponding to a one-byte integer, word or
__word__ for the mode of a one-word integer, and pointer
or __pointer__ for the mode used to represent pointers.
This attribute requests GCC not to place a variable
"common" but instead to allocate space for it directly. If you
specify the '-fno-common' flag, GCC will do this for all
variables.
Specifying the nocommon attribute for a variable provides an
initialization of zeros. A variable may only be initialized in one
source file.
The packed attribute specifies that a variable or structure field
should have the smallest possible alignment - one byte for a variable,
and one bit for a field, unless you specify a larger value with the
aligned attribute.
Here is a structure in which the field x is packed, so that it
immediately follows a:
struct foo
{
char a;
int x[2] __attribute__ ((packed));
};
Syntax: section ("section-name")
Normally, the compiler places the objects it generates in sections like
.data and .bss. Sometimes, however, you need additional sections,
or you need certain particular variables to appear in special sections,
for example to map to special hardware. The section
attribute specifies that a variable (or function) lives in a particular
section. The use of this attribute is limited in GCC4TI, because its linker supports
only a few types of sections, but this may be improved in the future.
For example, this small hypothetical program uses several specific section names:
struct duart a __attribute__ ((section ("DUART_A"))) = { 0 };
struct duart b __attribute__ ((section ("DUART_B"))) = { 0 };
char stack[10000] __attribute__ ((section ("STACK"))) = { 0 };
int init_data __attribute__ ((section ("INITDATA"))) = 0;
main()
{
/* Initialize stack pointer */
init_sp (stack + sizeof (stack));
/* Initialize initialized data */
memcpy (&init_data, &data, &edata - &data);
/* Turn on the serial ports */
init_duart (&a);
init_duart (&b);
}
Use the section attribute with an initialized definition
of a global variable, as shown in the example. GCC issues
a warning and otherwise ignores the section attribute in
uninitialized variable declarations.
You may only use the section attribute with a fully initialized
global definition because of the way linkers work. The linker requires
each object be defined once, with the exception that uninitialized
variables tentatively go in the .bss section
and can be multiply "defined". You can force a variable to be
initialized with the '-fno-common' flag or the nocommon
attribute.
The section attribute can also be used for functions.
This attribute, attached to a function parameter which is a union, means
that the corresponding argument may have the type of any union member,
but the argument is passed as if its type were that of the first union
member. For more details, see the
transparent_union
type attribute. You can also use
this attribute on a typedef for a union data type; then it
applies to all function parameters with that type.
The cleanup attribute runs a function when the variable goes
out of scope. This attribute can only be applied to auto function
scope variables; it may not be applied to parameters or variables
with static storage duration. The function must take one parameter,
a pointer to a type compatible with the variable. The return value
of the function (if any) is ignored.
If '-fexceptions' is enabled, then cleanup_function
will be run during the stack unwinding that happens during the
processing of the exception. Note that the cleanup attribute
does not allow the exception to be caught, only to perform an action.
Note that GCC4TI defines its own error handling mechanism, so this attribute
will not work if used in this way.
It is undefined what happens if cleanup_function does not
return normally.
This attribute, attached to a variable, means that the variable is meant
to be possibly unused. GCC will not produce a warning for this
variable.
The unused attribute can also be used for functions and
types.
The deprecated attribute results in a warning if the variable
is used anywhere in the source file. This is useful when identifying
variables that are expected to be removed in a future version of a
program. The warning also includes the location of the declaration
of the deprecated variable, to enable users to easily find further
information about why the variable is deprecated, or what they should
do instead. Note that the warnings only occurs for uses:
extern int old_var __attribute__ ((deprecated));
extern int old_var;
int new_fn () { return old_var; }
results in a warning on line 3 but not line 2.
The deprecated attribute can also be used for functions and
types.
The keyword __attribute__ allows you to specify special
attributes of struct and union types when you define such
types. This keyword is followed by an attribute specification inside
double parentheses.
The following attributes are currently defined for types:
Other attributes are defined for
functions (see Function Attributes) and for variables
(see Variable Attributes).
You may also specify any one of these attributes with __
preceding and following its keyword. This allows you to use these
attributes in header files without being concerned about a possible
macro of the same name. For example, you may use __aligned__
instead of aligned.
You may specify the aligned and transparent_union
attributes either in a typedef declaration or just past the
closing curly brace of a complete enum, struct or union type
definition and the packed attribute only past the closing
brace of a definition.
You may also specify attributes between the enum, struct or union
tag and the name of the type rather than after the closing brace.
See Attribute Syntax for details of the exact syntax for using
attributes.
To specify multiple attributes, separate them by commas within the
double parentheses: for example, __attribute__ ((aligned (16),
packed)).
Syntax: aligned [(alignment)]
This attribute specifies a minimum alignment (in bytes) for variables
of the specified type. For example, the declarations:
struct S { short f[3]; } __attribute__ ((aligned (8)));
typedef int more_aligned_int __attribute__ ((aligned (8)));
force the compiler to insure (as far as it can) that each variable whose
type is struct S or more_aligned_int will be allocated and
aligned at least on a 8-byte boundary.
Note that the alignment of any given struct or union type
is required by the ISO C standard to be at least a perfect multiple of
the lowest common multiple of the alignments of all of the members of
the struct or union in question. This means that you can
effectively adjust the alignment of a struct or union
type by attaching an aligned attribute to any one of the members
of such a type, but the notation illustrated in the example above is a
more obvious, intuitive, and readable way to request the compiler to
adjust the alignment of an entire struct or union type.
As in the preceding example, you can explicitly specify the alignment
(in bytes) that you wish the compiler to use for a given struct
or union type. Alternatively, you can leave out the alignment factor
and just ask the compiler to align a type to the maximum
useful alignment for the target machine you are compiling for. For
example, you could write:
struct S { short f[3]; } __attribute__ ((aligned));
Whenever you leave out the alignment factor in an aligned
attribute specification, the compiler automatically sets the alignment
for the type to the largest alignment which is ever used for any data
type on the target machine you are compiling for (useless in GCC4TI, since everything
is already aligned well enough with the default 2-byte alignment).
The aligned attribute can only increase the alignment; but you
can decrease it by specifying packed as well.
This attribute, attached to an enum, struct, or
union type definition, specified that the minimum required memory
be used to represent the type.
Specifying this attribute for struct and union types is
equivalent to specifying the packed attribute on each of the
structure or union members. Specifying the '-fshort-enums'
flag on the line is equivalent to specifying the packed
attribute on all enum definitions.
You may only specify this attribute after a closing curly brace on an
enum definition, not in a typedef declaration, unless that
declaration also contains the definition of the enum.
This attribute, attached to a union type definition, indicates
that any function parameter having that union type causes calls to that
function to be treated in a special way.
First, the argument corresponding to a transparent union type can be of
any type in the union; no cast is required. Also, if the union contains
a pointer type, the corresponding argument can be a null pointer
constant or a void pointer expression; and if the union contains a void
pointer type, the corresponding argument can be any pointer expression.
If the union member type is a pointer, qualifiers like const on
the referenced type must be respected, just as with normal pointer
conversions.
Second, the argument is passed to the function using the calling
conventions of first member of the transparent union, not the calling
conventions of the union itself. All members of the union must have the
same machine representation; this is necessary for this argument passing
to work properly.
Transparent unions are designed for library functions that have multiple
interfaces for compatibility reasons, but they may be used for various
different purposes.
Accesses to objects with types with this attribute are not subjected to
type-based alias analysis, but are instead assumed to be able to alias
any other type of objects, just like the char type. See
'-fstrict-aliasing' for more information on aliasing issues.
Example of use:
typedef short __attribute__((__may_alias__)) short_a;
void _main (void)
{
long a = 0x12345678;
short_a *b = (short_a *) &a;
b[1] = 0;
if (a == 0x12345678)
abort();
/* ... */
}
If you replaced short_a with short in the variable
declaration, the above program would abort when compiled with
'-fstrict-aliasing', which is on by default at '-O2' or
above in recent GCC versions.
When attached to a type (including a union or a struct),
this attribute means that variables of that type are meant to appear
possibly unused. GCC will not produce a warning for any variables of
that type, even if the variable appears to do nothing.
The unused attribute can also be used for functions and
variables.
The deprecated attribute results in a warning if the type
is used anywhere in the source file. This is useful when identifying
types that are expected to be removed in a future version of a program.
If possible, the warning also includes the location of the declaration
of the deprecated type, to enable users to easily find further
information about why the type is deprecated, or what they should do
instead. Note that the warnings only occur for uses and then only
if the type is being applied to an identifier that itself is not being
declared as deprecated.
typedef int T1 __attribute__ ((deprecated)); T1 x; typedef T1 T2; T2 y; typedef T1 T3 __attribute__ ((deprecated)); T3 z __attribute__ ((deprecated));
results in a warning on line 2 and 3 but not lines 4, 5, or 6. No
warning is issued for line 4 because T2 is not explicitly
deprecated. Line 5 has no warning because T3 is explicitly
deprecated. Similarly for line 6.
The deprecated attribute can also be used for functions and
variables.
This section describes the syntax with which __attribute__ may be
used, and the constructs to which attribute specifiers bind, for the C
language. Because of
infelicities in the grammar for attributes, some forms described here
may not be successfully parsed in all cases.
See Function Attributes for details of the semantics of attributes
applying to functions. See Variable Attributes for details of the
semantics of attributes applying to variables. See Type Attributes
for details of the semantics of attributes applying to structure, union
and enumerated types.
An attribute specifier is of the form
__attribute__ ((attribute-list)). An attribute list
is a possibly empty comma-separated sequence of attributes, where
each attribute is one of the following:
Empty. Empty attributes are ignored.
A word (which may be an identifier such as unused, or a reserved
word such as const).
A word, followed by, in parentheses, parameters for the attribute. These parameters take one of the following forms:
An identifier. For example, mode attributes use this form.
An identifier followed by a comma and a non-empty comma-separated list
of expressions. For example, format attributes use this form.
A possibly empty comma-separated list of expressions. For example,
format_arg attributes use this form with the list being a single
integer constant expression, and alias attributes use this form
with the list being a single string constant.
An attribute specifier list is a sequence of one or more attribute
specifiers, not separated by any other tokens.
An attribute specifier list may appear after the colon following a
label, other than a case or default label. The only
attribute it makes sense to use after a label is unused. This
feature is intended for code generated by programs which contains labels
that may be unused but which is compiled with '-Wall'. It would
not normally be appropriate to use in it human-written code, though it
could be useful in cases where the code that jumps to the label is
contained within an #ifdef conditional.
An attribute specifier list may appear as part of a struct,
union or enum specifier. It may go either immediately
after the struct, union or enum keyword, or after
the closing brace. It is ignored if the content of the structure, union
or enumerated type is not defined in the specifier in which the
attribute specifier list is used - that is, in usages such as
struct __attribute__((foo)) bar with no following opening brace.
Where attribute specifiers follow the closing brace, they are considered
to relate to the structure, union or enumerated type defined, not to any
enclosing declaration the type specifier appears in, and the type
defined is not complete until after the attribute specifiers.
Otherwise, an attribute specifier appears as part of a declaration,
counting declarations of unnamed parameters and type names, and relates
to that declaration (which may be nested in another declaration, for
example in the case of a parameter declaration), or to a particular declarator
within a declaration. Where an
attribute specifier is applied to a parameter declared as a function or
an array, it should apply to the function or array rather than the
pointer to which the parameter is implicitly converted, but this is not
yet correctly implemented.
Any list of specifiers and qualifiers at the start of a declaration may
contain attribute specifiers, whether or not such a list may in that
context contain storage class specifiers. (Some attributes, however,
are essentially in the nature of storage class specifiers, and only make
sense where storage class specifiers may be used; for example,
section.) There is one necessary limitation to this syntax: the
first old-style parameter declaration in a function definition cannot
begin with an attribute specifier, because such an attribute applies to
the function instead by syntax described below (which, however, is not
yet implemented in this case). In some other cases, attribute
specifiers are permitted by this grammar but not yet supported by the
compiler. All attribute specifiers in this place relate to the
declaration as a whole. In the obsolescent usage where a type of
int is implied by the absence of type specifiers, such a list of
specifiers and qualifiers may be an attribute specifier list with no
other specifiers or qualifiers.
An attribute specifier list may appear immediately before a declarator
(other than the first) in a comma-separated list of declarators in a
declaration of more than one identifier using a single list of
specifiers and qualifiers. Such attribute specifiers apply
only to the identifier before whose declarator they appear. For
example, in
__attribute__((noreturn)) void d0 (void),
__attribute__((format(printf, 1, 2))) d1 (const char *, ...),
d2 (void)
the noreturn attribute applies to all the functions
declared; the format attribute only applies to d1.
An attribute specifier list may appear immediately before the comma,
= or semicolon terminating the declaration of an identifier other
than a function definition. At present, such attribute specifiers apply
to the declared object or function, but in future they may attach to the
outermost adjacent declarator. In simple cases there is no difference,
but, for example, in
void (****f)(void) __attribute__((noreturn));
at present the noreturn attribute applies to f, which
causes a warning since f is not a function, but in future it may
apply to the function ****f. The precise semantics of what
attributes in such cases will apply to are not yet specified. Where an
assembler name for an object or function is specified (see Asm
Labels), at present the attribute must follow the asm
specification; in future, attributes before the asm specification
may apply to the adjacent declarator, and those after it to the declared
object or function.
An attribute specifier list may, in future, be permitted to appear after
the declarator in a function definition (before any old-style parameter
declarations or the function body).
Attribute specifiers may be mixed with type qualifiers appearing inside
the [] of a parameter array declarator, in the C99 construct by
which such qualifiers are applied to the pointer to which the array is
implicitly converted. Such attribute specifiers apply to the pointer,
not to the array, but at present this is not implemented and they are
ignored.
An attribute specifier list may appear at the start of a nested
declarator. At present, there are some limitations in this usage: the
attributes correctly apply to the declarator, but for most individual
attributes the semantics this implies are not implemented.
When attribute specifiers follow the * of a pointer
declarator, they may be mixed with any type qualifiers present.
The following describes the formal semantics of this syntax. It will make the
most sense if you are familiar with the formal specification of
declarators in the ISO C standard.
Consider (as in C99 subclause 6.7.5 paragraph 4) a declaration T
D1, where T contains declaration specifiers that specify a type
Type (such as int) and D1 is a declarator that
contains an identifier ident. The type specified for ident
for derived declarators whose type does not include an attribute
specifier is as in the ISO C standard.
If D1 has the form ( attribute-specifier-list D ),
and the declaration T D specifies the type
"derived-declarator-type-list Type" for ident, then
T D1 specifies the type "derived-declarator-type-list
attribute-specifier-list Type" for ident.
If D1 has the form *
type-qualifier-and-attribute-specifier-list D, and the
declaration T D specifies the type
"derived-declarator-type-list Type" for ident, then
T D1 specifies the type "derived-declarator-type-list
type-qualifier-and-attribute-specifier-list Type" for
ident.
For example,
void (__attribute__((noreturn)) ****f) (void);
specifies the type "pointer to pointer to pointer to pointer to
non-returning function returning void". As another example,
char *__attribute__((aligned(8))) *f;
specifies the type "pointer to 8-byte-aligned pointer to char".
Note again that this does not work with most attributes; for example,
the usage of aligned and noreturn attributes given above
is not yet supported.
For compatibility with existing code written for compiler versions that
did not implement attributes on nested declarators, some laxity is
allowed in the placing of attributes. If an attribute that only applies
to types is applied to a declaration, it will be treated as applying to
the type of that declaration. If an attribute that only applies to
declarations is applied to the type of a declaration, it will be treated
as applying to that declaration; and, for compatibility with code
placing the attributes immediately before the identifier declared, such
an attribute applied to a function return type will be treated as
applying to the function type, and such an attribute applied to an array
element type will be treated as applying to the array type. If an
attribute that only applies to function types is applied to a
pointer-to-function type, it will be treated as applying to the pointer
target type; if such an attribute is applied to a function return type
that is not a pointer-to-function type, it will be treated as applying
to the function type.
GNU C extends ISO C to allow a function prototype to override a later old-style non-prototype definition. Consider the following example:
/* Use prototypes unless the compiler is old-fashioned. */
#ifdef __STDC__
#define P(x) x
#else
#define P(x) ()
#endif
/* Prototype function declaration. */
int isroot P((uid_t));
/* Old-style function definition. */
int
isroot (x) /* ??? lossage here ??? */
uid_t x;
{
return x == 0;
}
Suppose the type uid_t happens to be char. ISO C does
not allow this example, because subword arguments in old-style
non-prototype definitions are promoted. Therefore in this example the
function definition's argument is really an int, which does not
match the prototype argument type of char.
This restriction of ISO C makes it hard to write code that is portable
to traditional C compilers, because the programmer does not know
whether the uid_t type is short, int, or
long. Therefore, in cases like these GNU C allows a prototype
to override a later old-style definition. More precisely, in GNU C, a
function prototype argument type overrides the argument type specified
by a later old-style definition if the former type is the same as the
latter type before promotion. Thus in GNU C the above example is
equivalent to the following:
int isroot (uid_t);
int
isroot (uid_t x)
{
return x == 0;
}
In GNU C, you may use C++ style comments, which start with // and
continue until the end of the line. Many other C implementations allow
such comments, and they are included in the 1999 C standard. However,
C++ style comments are not recognized if you specify an '-std'
option specifying a version of ISO C before C99, or '-ansi'
(equivalent to '-std=c89').
In GNU C, you may normally use dollar signs in identifier names. This is because many traditional C implementations allow such identifiers.
You can use the sequence \e in a string or character constant to
stand for the ASCII character ESC (\x1B).
The keyword __alignof__ allows you to inquire about how an object
is aligned, or the minimum alignment usually required by a type. Its
syntax is just like sizeof.
In GCC4TI, __alignof__ (anything) is always 2, except for
char variables.
If the operand of __alignof__ is an lvalue rather than a type,
its value is the required alignment for its type, taking into account
any minimum alignment specified with GCC's aligned attribute. For example, after this
declaration:
struct foo { int x; char y; } foo1;
the value of __alignof__ (foo1.y) is 1, even though its actual
alignment is 2, the same as __alignof__ (int).
It is an error to ask for the alignment of an incomplete type.
By declaring a function inline, you can direct GCC to
integrate that function's code into the code for its callers. This
makes execution faster by eliminating the function-call overhead; in
addition, if any of the actual argument values are constant, their known
values may permit simplifications at compile time so that not all of the
inline function's code needs to be included. The effect on code size is
less predictable; object code may be larger or smaller with function
inlining, depending on the particular case. Inlining of functions is an
optimization and it really "works" only in optimizing compilation. If
you don't use '-O', no function is really inline.
Inline functions are included in the ISO C99 standard, but there are
currently substantial differences between what GCC implements and what
the ISO C99 standard requires.
To declare a function inline, use the inline keyword in its
declaration, like this:
inline int
inc (int *a)
{
(*a)++;
}
(If you are writing a header file to be included in ISO C programs, write
__inline__ instead of inline. See Alternate Keywords.)
You can also make all "simple enough" functions inline with the option
'-finline-functions'.
Note that certain usages in a function definition can make it unsuitable
for inline substitution. Among these usages are: use of a variable number of arguments, use of
alloca, use of variable sized data types (see Variable Length Arrays),
use of computed goto (see Labels as Values), use of nonlocal goto,
and nested functions (see Nested Functions). Using '-Winline'
will warn when a function marked inline could not be substituted,
and will give the reason for the failure.
Note that in C (unlike C++), the inline keyword
does not affect the linkage of the function.
When a function is both inline and static, if all calls to the
function are integrated into the caller, and the function's address is
never used, then the function's own assembler code is never referenced.
In this case, GCC does not actually output assembler code for the
function, unless you specify the option '-fkeep-inline-functions'.
Some calls cannot be integrated for various reasons (in particular,
calls that precede the function's definition cannot be integrated, and
neither can recursive calls within the definition). If there is a
nonintegrated call, then the function is compiled to assembler code as
usual. The function must also be compiled as usual if the program
refers to its address, because that can't be inlined.
When an inline function is not static, then the compiler must assume
that there may be calls from other source files; since a global symbol can
be defined only once in any program, the function must not be defined in
the other source files, so the calls therein cannot be integrated.
Therefore, a non-static inline function is always compiled on its
own in the usual fashion.
If you specify both inline and extern in the function
definition, then the definition is used only for inlining. In no case
is the function compiled on its own, not even if you refer to its
address explicitly. Such an address becomes an external reference, as
if you had only declared the function, and had not defined it.
This combination of inline and extern has almost the
effect of a macro. The way to use it is to put a function definition in
a header file with these keywords, and put another copy of the
definition (lacking inline and extern) in a library file.
The definition in the header file will cause most calls to the function
to be inlined. If any uses of the function remain, they will refer to
the single copy in the library.
For future compatibility with when GCC implements ISO C99 semantics for
inline functions, it is best to use static inline only. (The
existing semantics will remain available when '-std=gnu89' is
specified, but eventually the default will be '-std=gnu99' and
that will implement the C99 semantics, though it does not do so yet.)
GCC does not inline any functions when not optimizing unless you specify
the always_inline attribute for the function, like this:
/* Prototype. */ inline void foo (const char*) __attribute__((always_inline));
GCC introduces a special asm keyword to support assembler
instructions within C code. Roughly, its syntax is:
asm ("instructions" [:output:input]);
The asm keyword may appear between usual lines of code or at
the top level, outside of any function body. instructions may
contain labels and references to global C symbols; in fact, the contents
of the string are copied directly into the output file.
If you are writing a header file that should be includable in programs compiled
in GCC's strict ISO C mode, write __asm__ instead of asm.
See Alternate Keywords.
The simplest form the asm keyword is:
asm ("instructions");
where instructions contains one or more assembler instructions
separated by semicolons or newlines.
In GCC4TI, all register names must be preceded by a percent sign, to avoid
confusion with C variables named like one of the CPU registers. For example:
asm ("move.l 0xC8,%a0; move.l (%a0,1656),%a0; jsr (%a0)");
Hexadecimal constants must be written according to C syntax
(like 0xC8), not using the notation $C8 which is
common in various assemblers.
Note that something like
asm ("move.l 0xC8,a0");
will be interpreted quite differently: a0 will be regarded as a C language
variable, not a register! Read the documentation about the GNU Assembler
for more information about the exact syntax and directives which it accepts;
since inline assembler instructions are copied directly into the output of the
compiler, exactly the same features are available.
Newlines as separators are also accepted in instructions, so the following code is valid as well:
asm (" move.l 0xC8,%a0
move.l (%a0,1656),%a0
jsr (%a0)");
See Multi-line Strings for more information.
In an assembler instruction using asm, you can specify the
operands of the instruction using C expressions. This means you need not
guess which registers or memory locations will contain the data you want
to use.
You must specify an assembler instruction template much like what
appears in a machine description, plus an operand constraint string for
each operand.
For the beginning, you will be given here a very illustrative example on how to use the 68881's
fsinx instruction (note that this example is not applicable to TI calculators,
because the MC68000 processor which is built into the TI-89 and TI-92+ does not have this
instruction, but the example is illustrative anyway):
asm ("fsinx %1,%0" : "=f" (result) : "f" (angle));
Here angle is the C expression for the input operand while
result is that of the output operand. Each has "f" as its
operand constraint, saying that a floating point register is required.
The = in =f indicates that the operand is an output; all
output operands' constraints must use =. The constraints use the
same language used in the machine description (see the section Operand Constraints).
In this example,
the compiler will convert this instruction into a sequence of assembly instructions
which will ensure that the evaluated expression angle is really stored in
one of the 68881's floating point registers, and which will store the result of the fsinx
(which is in some other floating point register) into the expression result
(note that result need not be a variable; it can be any lvalue expression, for
example a dereferenced pointer).
Each operand is described by an operand-constraint string followed by
the C expression in parentheses. A colon separates the assembler
template from the first output operand and another separates the last
output operand from the first input, if any. Commas separate the
operands within each group. The total number of operands is currently
limited to 30; this limitation may be lifted in some future version of
GCC.
If there are no output operands but there are input operands, you must
place two consecutive colons surrounding the place where the output
operands would go.
As of GCC version 3.1, it is also possible to specify input and output
operands using symbolic names which can be referenced within the
assembler code. These names are specified inside square brackets
preceding the constraint string, and can be referenced inside the
assembler code using %[name] instead of a percentage sign
followed by the operand number. Using named operands the above example
could look like:
asm ("fsinx %[angle],%[output]"
: [output] "=f" (result)
: [angle] "f" (angle));
Note that the symbolic operand names have no relation whatsoever to
other C identifiers. You may use any name you like, even those of
existing C symbols, but must ensure that no two operands within the same
assembler construct use the same symbolic name.
Output operand expressions must be lvalues; the compiler can check this.
The input operands need not be lvalues. The compiler cannot check
whether the operands have data types that are reasonable for the
instruction being executed. It does not parse the assembler instruction
template and does not know what it means or even whether it is valid
assembler input. The extended asm feature is most often used for
machine instructions the compiler itself does not know exist. If
the output expression cannot be directly addressed (for example, it is a
bit-field), your constraint must allow a register. In that case, GCC
will use the register as the output of the asm, and then store
that register into the output.
Here is an another example, which is applicable to GCC4TI. Suppose that we
want to rotate the value of the expression input one bit to the left, and
to store the result into the expression output (which is an lvalue).
We can write the following code:
asm ("move.l %1,%%d0; rol #1,%%d0; move.l %%d0,%0" : "=g" (output) : "g" (input));
Note that when extended asm constructions are used, the percent sign before the register names must be doubled. It is important to say that in the above example input and output may be any valid expressions; in the simple case when both of them are just global variables, a simple asm construction like
asm ("move.l input,%d0; rol #1,%d0; move.l %d0,output");
would be quite enough. Extended asm constructions allow encapsulating them in macros
which look like functions, like in the following example, which defines a macro 'rotate'
which acts like a void function:
#define rotate(input, output) \
({ asm ("move.l %1,%%d0; rol #1,%%d0; move.l %%d0,%0" \
: "=g" (output) : "g" (input)); })
The ordinary output operands must be write-only; GCC will assume that
the values in these operands before the instruction are dead and need
not be generated. That's why the following version of 'rotate'
macro which accepts just one argument (and which rotates it one bit to the left)
is quite unreliable:
#define rotate(inout) ({ asm ("rol #1,%0" : "=d" (inout)); })
To solve such difficulties, extended asm supports input-output or read-write
operands. Use the constraint character + to indicate such an
operand and list it with the output operands.
When the constraints for the read-write operand (or the operand in which
only some of the bits are to be changed) allows a register, you may, as
an alternative, logically split its function into two separate operands,
one input operand and one write-only output operand. The connection
between them is expressed by constraints which say they need to be in
the same location when the instruction executes. You can use the same C
expression for both operands, or different expressions. For example,
here we write the (fictitious) combine instruction with
bar as its read-only source operand and foo as its
read-write destination:
asm ("combine %2,%0" : "=r" (foo) : "0" (foo), "g" (bar));
The constraint "0" for operand 1 says that it must occupy the
same location as operand 0. A number in constraint is allowed only in
an input operand and it must refer to an output operand.
Only a number in the constraint can guarantee that one operand will be in
the same place as another. The mere fact that foo is the value
of both operands is not enough to guarantee that they will be in the
same place in the generated assembler code. The following would not
work reliably:
asm ("combine %2,%0" : "=r" (foo) : "r" (foo), "g" (bar));
Various optimizations or reloading could cause operands 0 and 1 to be in
different registers; GCC knows no reason not to do so. For example, the
compiler might find a copy of the value of foo in one register and
use it for operand 1, but generate the output operand 0 in a different
register (copying it afterward to foo's own address). Of course,
since the register for operand 1 is not even mentioned in the assembler
code, the result will not work, but GCC can't tell that.
As of GCC version 3.1, one may write [name] instead of
the operand number for a matching constraint. For example:
asm ("cmoveq %1,%2,%[result]"
: [result] "=r"(result)
: "r" (test), "r"(new), "[result]"(old));
All the examples given above have a serious drawback: they clobber the register 'd0'.
If the compiler keeps something important in it (which is very likely), this may cause lots
of trouble. Of course,
you can save it on the stack at the beginning and restore it at the end, but there is a much better
solution which will save clobbered registers only when necessary. To describe clobbered registers,
write a third colon after the input operands, followed by the names of
the clobbered registers (given as strings), separated by commas:
#define rotate(input, output) \
({ asm ("move.l %1,%%d0; rol #1,%%d0; move.l %%d0,%0" \
: "=g" (output) : "g" (input) : "d0"); })
You may not write a clobber description in a way that overlaps with an
input or output operand. For example, you may not have an operand
describing a register class with one member if you mention that register
in the clobber list. Variables declared to live in specific registers
(see Explicit Reg Vars), and used as asm input or output operands must
have no part mentioned in the clobber description.
There is no way for you to specify that an input
operand is modified without also specifying it as an output
operand. Note that if all the output operands you specify are for this
purpose (and hence unused), you will then also need to specify
volatile for the asm construct, as described below, to
prevent GCC from deleting the asm statement as unused.
Whenever you refer to a particular hardware register from the assembler code,
you will probably have to list the register after the third colon to
tell the compiler the register's value is modified.
Alternatively, you can force the compiler to use any data register instead of
'd0', using the following trick:
#define rotate(input, output) \
({ register long __temp; \
asm ("move.l %1,%2; rol #1,%2; move.l %2,%0" \
: "=g" (output) : "g" (input), "d" (__temp)); })
Here, the "d" constraint ensures that '__temp' will be stored in
the data register (note that rol is applicable only to data registers).
In fact, there is no need for a temporary register if we forced the output to be in
a data register, which can be implemented as in the following example:
#define rotate(input, output) \
({ asm ("move.l %1,%0; rol #1,%0" : "=d" (output) : "g" (input)); })
If your assembler instruction can alter the condition code register, add
cc to the list of clobbered registers. GCC on some machines
represents the condition codes as a specific hardware register;
cc serves to name this register. On other machines, the
condition code is handled differently, and specifying cc has no
effect. But it is valid no matter what the machine.
If your assembler instruction modifies memory in an unpredictable
fashion, add memory to the list of clobbered registers. This
will cause GCC to not keep memory values cached in registers across
the assembler instruction. You will also want to add the
volatile keyword if the memory affected is not listed in the
inputs or outputs of the asm, as the memory clobber does
not count as a side-effect of the asm.
As already mentioned above, you can put multiple assembler instructions together in a single
asm template, separated either with newlines or with semicolons
(the GNU assembler allows semicolons as a line-breaking character).
The input operands are guaranteed not to use any of the clobbered
registers, and neither will the output operands' addresses, so you can
read and write the clobbered registers as many times as you like. Here
is an example of multiple instructions in a template; it assumes the
subroutine _foo accepts arguments in registers a0 and a1:
asm ("move.l %0,%%a0; move.l %1,%%a1; jsr _foo"
: /* no outputs */
: "g" (from), "g" (to)
: "a0", "a1");
Unless an output operand has the '&' constraint modifier, GCC
may allocate it in the same register as an unrelated input operand, on
the assumption the inputs are consumed before the outputs are produced.
This assumption may be false if the assembler code actually consists of
more than one instruction. In such a case, use '&' for each output
operand that may not overlap an input. See the section Constraint Modifier Characters.
If you want to test the condition code produced by an assembler
instruction, you must include a branch and a label in the asm
construct, as follows:
asm ("clr.l %0; test.l %1; beq 0f; moveq #1,%0; 0:"
: "g" (result) : "g" (input));
This assumes your assembler supports local labels, which is true for the
GNU Assembler (it uses the suffix 'f' for forward and 'b' for
backward local labels; see the section about Local Symbol Names).
Speaking of labels, jumps from one asm to another are not
supported. The compiler's optimizers do not know about these jumps, and
therefore they cannot take account of them when deciding how to
optimize.
As already mentioned, usually the most convenient way to use these
asm instructions is to encapsulate them in macros that look like
functions. Here is an example of how to define a function-looking macro with
a non-void return type:
#define rotate(x) \
({ unsigned long __result, __arg=(x); \
asm ("move.l %1,%0; rol #1,%0": "=d" (__result): "g" (__arg)); \
__result; })
This macro acts nearly exactly like a function which takes one unsigned long
argument, and which returns an unsigned long result.
Here the variable __arg is used to make sure that the instruction
operates on a proper unsigned long value, and to accept only those
arguments x which can convert automatically to an unsigned long.
Another way to make sure the instruction operates on the correct data
type is to use a cast in the asm. This is different from using a
variable __arg in that it converts more different types. For
example, if the desired type were int, casting the argument to
int would accept a pointer with no complaint, while assigning the
argument to an int variable named __arg would warn about
using a pointer unless the caller explicitly casts it.
If an asm has output operands, GCC assumes for optimization
purposes the instruction has no side effects except to change the output
operands. This does not mean instructions with a side effect cannot be
used, but you must be careful, because the compiler may eliminate them
if the output operands aren't used, or move them out of loops, or
replace two with one if they constitute a common subexpression. Also,
if your instruction does have a side effect on a variable that otherwise
appears not to change, the old value of the variable may be reused later
if it happens to be found in a register.
If you are not happy with this behavior,
you can prevent an asm instruction from being deleted, moved
significantly, or combined, by writing the keyword volatile after
the asm. For example:
#define get_and_set_priority(new) \
({ int __old; \
asm volatile ("get_and_set_priority %0, %1" \
: "=g" (__old) : "g" (new)); \
__old; })
If you write an asm instruction with no outputs, GCC will know
the instruction has side-effects and will not delete the instruction or
move it outside of loops.
The volatile keyword indicates that the instruction has
important side-effects. GCC will not delete a volatile asm if
it is reachable. (The instruction can still be deleted if GCC can
prove that control-flow will never reach the location of the
instruction.) In addition, GCC will not reschedule instructions
across a volatile asm instruction. For example:
#define inline_rowread(x) \
({*(short*)0x600018=(short)(x); \
asm volatile("nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop;nop":::"memory"); \
~(*(unsigned char*)0x60001b);})
Here, we can read the keyboard port at 0x60001b only 12 nops after setting
the keyboard mask at 0x600018. Therefore, we need to make sure that the
nops get scheduled between the write to 0x600018 and the read to 0x60001b.
The volatile keyword makes sure that the instructions get ordered
in the correct way.
Note that even a volatile asm instruction can be moved in ways
that appear insignificant to the compiler, such as across jump
instructions. You can't expect a sequence of volatile asm
instructions to remain perfectly consecutive. If you want consecutive
output, use a single asm. Also, GCC will perform some
optimizations across a volatile asm instruction; GCC does not
"forget everything" when it encounters a volatile asm
instruction the way some other compilers do.
An asm instruction without any operands or clobbers (an "old
style" asm) will be treated identically to a volatile
asm instruction.
It is a natural idea to look for a way to give access to the condition
code left by the assembler instruction. However, when we attempted to
implement this, we found no way to make it work reliably. The problem
is that output operands might need reloading, which would result in
additional following "store" instructions. On most machines, these
instructions would alter the condition code before there was time to
test it. This problem doesn't arise for ordinary "test" and
"compare" instructions because they don't have any output operands.
For reasons similar to those described above, it is not possible to give
an assembler instruction access to the condition code left by previous
instructions.
You can write write __asm__ instead of asm.
See section Alternate Keywords.
Each match operand in an instruction pattern can specify a constraint for the type of operands allowed. Constraints can say whether an operand may be in a register, and which kinds of register; whether the operand can be a memory reference, and which kinds of address; whether the operand may be an immediate constant, and which possible values it may have. Constraints can also require two operands to match. Here, only those operand constraints which are valid for the Motorola 68000 processor and the built-in inline assembly will be described (i.e. those which are applicable to GCC4TI).
The simplest kind of constraint is a string full of letters, each of which describes one kind of operand that is permitted. These are the letters that are allowed:
m
A memory operand is allowed, with any kind of address that the machine supports in general.
o
A memory operand is allowed, but only if the address is
offsettable. This means that adding a small integer (actually,
the width in bytes of the operand, as determined by its machine mode)
may be added to the address and the result is also a valid memory
address.
For example, an address which is constant is offsettable; so is an
address that is the sum of a register and a constant (as long as a
slightly larger constant is also within the range of address-offsets
supported by the machine); but an autoincrement or autodecrement
address is not offsettable. More complicated indirect/indexed
addresses may or may not be offsettable depending on the other
addressing modes that the machine supports.
Note that in an output operand which can be matched by another
operand, the constraint letter o is valid only when accompanied
by both < (if the target machine has predecrement addressing)
and > (if the target machine has preincrement addressing).
V
A memory operand that is not offsettable. In other words, anything that
would fit the m constraint but not the o constraint.
<
A memory operand with autodecrement addressing is allowed.
>
A memory operand with autoincrement addressing is allowed.
r
A register operand is allowed provided that it is in a general register.
d
A data register is allowed. This is a Motorola-specific constraint.
a
An address register is allowed. This is a Motorola-specific constraint.
f
A 68881 floating-point register is allowed, if available (of course, it is not available on the TI-89 and TI-92 Plus). This is a Motorola-specific constraint.
i
An immediate integer operand (one with constant value) is allowed. This includes symbolic constants whose values will be known only at assembly time.
n
An immediate integer operand with a known numeric value is allowed.
Many systems cannot support assembly-time constants for operands less
than a word wide. Constraints for these operands should use n
rather than i.
I
An integer in the range 1 to 8 is allowed. This is a Motorola-specific constraint, and this is for example the range permitted as a shift count in the shift instructions.
J
A 16 bit signed number is allowed. This is a Motorola-specific constraint.
K
A signed number whose magnitude is greater than 0x80 is allowed. This is a Motorola-specific constraint.
L
An integer in the range -8 to -1 is allowed. This is a Motorola-specific constraint.
M
A signed number whose magnitude is greater than 0x100 is allowed. This is a Motorola-specific constraint.
s
An immediate integer operand whose value is not an explicit integer is
allowed.
This might appear strange; if an instruction allows a constant operand with a
value not known at compile time, it certainly must allow any known
value. So why use s instead of i? Sometimes it allows
better code to be generated.
For example, on the 68000 in a fullword instruction it is possible to
use an immediate operand; but if the immediate value is between -128
and 127, better code results from loading the value into a register and
using the register. This is because the load into the register can be
done with a 'moveq' instruction. The GNU team arranges for this to happen
by defining the letter K to mean "any integer outside the
range -128 to 127", and then specifying Ks in the operand
constraints. (This constraint is very unlikely to be useful for inline assembly,
since you cannot use constraints to make GCC choose between 2 different
inline assembly statements.)
g
Any register, memory or immediate integer operand is allowed, except for registers that are not general registers.
X
Any operand whatsoever is allowed, even if it does not satisfy
general_operand. This is normally used in the constraint of
a match_scratch when certain alternatives will not actually
require a scratch register.
0, 1, 2, ... 9
An operand that matches the specified operand number is allowed. If a digit is used together with letters within the same alternative, the digit should come last. This is called a matching constraint and what it really means is that the assembler has only a single operand that fills two roles considered separate. More precisely, the two operands that match must include one input-only operand and one output-only operand. Moreover, the digit must be a smaller number than the number of the operand that uses it in the constraint.
p
An operand that is a valid memory address is allowed.
In order to have valid assembler code, each operand must satisfy its constraint. But a failure to do so does not prevent the pattern from applying to an instruction pattern. Instead, it directs the compiler to modify the code so that the constraint will be satisfied. Usually this is done by copying an operand into a register.
These are the constraint modifier characters which are meaningful for GCC4TI:
=
Means that this operand is write-only for this instruction: the previous value is discarded and replaced by output data.
+
Means that this operand is both read and written by the instruction.
When the compiler fixes up the operands to satisfy the constraints,
it needs to know which operands are inputs to the instruction and
which are outputs from it. = identifies an output; +
identifies an operand that is both input and output; all other operands
are assumed to be input only.
If you specify = or + in a constraint, you put it in the
first character of the constraint string.
&
Means (in a particular alternative) that this operand is an
earlyclobber operand, which is modified before the instruction is
finished using the input operands. Therefore, this operand may not lie
in a register that is used as an input operand or as part of any memory
address.
& does not obviate the need to write =.
You can specify the name to be used in the assembler code for a C
function or variable by writing the asm (or __asm__)
keyword after the declarator as follows:
int foo asm ("myfoo") = 2;
This specifies that the name to be used for the variable foo in
the assembler code should be myfoo rather than the usual
foo.
On systems where an underscore is normally prepended to the name of a C
function or variable, this feature allows you to define names for the
linker that do not start with an underscore.
It does not make sense to use this feature with a non-static local
variable since such variables do not have assembler names. If you are
trying to put the variable in a particular register, see Explicit
Reg Vars. GCC presently accepts such code with a warning, but will
probably be changed to issue an error, rather than a warning, in the
future.
You cannot use asm in this way in a function definition; but
you can get the same effect by writing a declaration for the function
before its definition and putting asm there, like this:
extern func () asm ("FUNC");
func (int x, int y)
/* ... */
It is up to you to make sure that the assembler names you choose do not conflict with any other assembler symbols. Also, you must not use a register name; that would produce completely invalid assembler code. GCC does not as yet have the ability to store static variables in registers. Perhaps that will be added.
GNU C allows you to put a few global variables into specified hardware registers. You can also specify the register in which an ordinary register variable should be allocated. GCC4TI also allows you to specify an explicit register for function parameters.
Global register variables reserve registers throughout the program. This may be useful in programs such as programming language interpreters which have a couple of global variables that are accessed very often.
Local register variables in specific registers do not reserve the registers. The compiler's data flow analysis is capable of determining where the specified registers contain live values, and where they are available for other uses. Stores into local register variables may be deleted when they appear to be dead according to dataflow analysis. References to local register variables may be deleted or moved or simplified.
In GCC4TI, it is possible to specify explictly where the parameters to a function a stored, in a syntax similar to global and local register variables.
Global register variables reserve registers throughout the program. This may be useful in programs such as programming language interpreters which have a couple of global variables that are accessed very often.
You can define a global register variable in GNU C like this:
register int *foo asm ("a3");
Here a3 is the name of the register which should be used. Choose a
register which is normally saved and restored by function calls on your
machine, so that library routines will not clobber it.
Naturally the register name is cpu-dependent, so you would need to
conditionalize your program according to cpu type. The register
a3 would be a good choice on a 68000 for a variable of pointer
type. On machines with register windows, be sure to choose a "global"
register that is not affected magically by the function call mechanism.
In addition, operating systems on one type of cpu may differ in how they
name the registers; then you would need additional conditionals. For
example, some 68000 operating systems call this register %a3.
Eventually there may be a way of asking the compiler to choose a register
automatically, but first we need to figure out how it should choose and
how to enable you to guide the choice. No solution is evident.
Defining a global register variable in a certain register reserves that
register entirely for this use, at least within the current compilation.
The register will not be allocated for any other purpose in the functions
in the current compilation. The register will not be saved and restored by
these functions. Stores into this register are never deleted even if they
would appear to be dead, but references may be deleted or moved or
simplified.
It is not safe to access the global register variables from interrupt
handlers, because the system
library routines may temporarily use the register for other things (unless
you recompile them specially for the task at hand).
It is not safe for one function that uses a global register variable to
call another such function foo by way of a third function
lose that was compiled without knowledge of this variable (i.e. in a
different source file in which the variable wasn't declared). This is
because lose might save the register and put some other value there.
For example, you can't expect a global register variable to be available in
the comparison-function that you pass to qsort, since it
might have put something else in that register. (If you are prepared to
recompile it with the same global register variable, you can
solve this problem.)
If you want to recompile qsort or other source files which do not
actually use your global register variable, so that they will not use that
register for any other purpose, then it suffices to specify the compiler
option '-ffixed-reg'. You need not actually add a global
register declaration to their source code.
A function which can alter the value of a global register variable cannot
safely be called from a function compiled without this variable, because it
could clobber the value the caller expects to find there on return.
Therefore, the function which is the entry point into the part of the
program that uses the global register variable must explicitly save and
restore the value which belongs to its caller.
Be careful if you use longjmp with global register
variables, because it will restore to each global register
variable the value it had at the time of the
setjmp.
All global register variable declarations must precede all function
definitions. If such a declaration could appear after function
definitions, the declaration would be too late to prevent the register from
being used for other purposes in the preceding functions.
Global register variables may not have initial values, because an
executable file has no means to supply initial contents for a register.
On the Motorola 68000, a2 ... a5 should be suitable for global register variables,
as should d3 ... d7.
Of course, it will not do to use more than a few of those.
Note that a5 is used by
OPTIMIZE_ROM_CALLS.
Local register variables in specific registers do not reserve the registers. The compiler's data flow analysis is capable of determining where the specified registers contain live values, and where they are available for other uses. Stores into local register variables may be deleted when they appear to be dead according to dataflow analysis. References to local register variables may be deleted or moved or simplified.
These local variables are sometimes convenient for use with the extended
asm feature (see the section Assembler
Instructions with C Expression Operands), if you want to write one
output of the assembler instruction directly into a particular register
(this will work provided the register you specify fits the constraints
specified for that operand in the asm block).
You can define a local register variable with a specified register
like this:
register int *foo asm ("a5");
Here a5 is the name of the register which should be used. Note
that this is the same syntax used for defining global register
variables, but for a local variable it would appear within a function.
Naturally the register name is cpu-dependent, but this is not a
problem, since specific registers are most often useful with explicit
assembler instructions (see the section Assembler Instructions with C
Expression Operands), which is CPU-specific as well, and since GCC4TI
only supports exactly one CPU (the Motorola 68000) anyway.
In addition, operating systems on one type of cpu may differ in how they
name the registers; then you would need additional conditionals. For
example, some 68000 operating systems call this register %a5.
Defining such a register variable does not reserve the register; it
remains available for other uses in places where flow control determines
the variable's value is not live. However, these registers are made
unavailable for use in the reload pass; excessive use of this feature
leaves the compiler too few available registers to compile certain
functions.
This option does not guarantee that GCC will generate code that has
this variable in the register you specify at all times. You may not
code an explicit reference to this register in an asm statement
and assume it will always refer to this variable.
Stores into local register variables may be deleted when they appear to be dead
according to dataflow analysis. References to local register variables may
be deleted or moved or simplified.
In GCC4TI, it is possible to specify explictly where the parameters to a function a stored, in a syntax similar to global and local register variables.
GCC4TI can pass function parameters either on the stack or through registers.
You can use the regparm attribute or the '-mregparm'
compiler switch to let the compiler automatically choose registers for the parameters, but you can
also tell GCC4TI to put a parameter into a specific register. This can be very handy when
interfacing with assembly code. For example, the following assembly function expects its 2
parameters in the d1 and d2 registers:
asm(".globl add
add:
move.l %d2,%d0
add.l %d1,%d0
rts");
Therefore, its prototype would be:
unsigned long add (unsigned long a asm("d1"), unsigned long b asm("d2"));
Explicit register specifications for function parameters are also supported in function headers (not only in prototypes). Therefore, the assembly function above could be replaced by the following C equivalent:
unsigned long add (unsigned long a asm("d1"), unsigned long b asm("d2"))
{
return a + b;
}
to pass a register parameter. The registers do not necessarily need to be call-clobbered. You can also use a2-a5/d3-d7 to pass a register parameter. But note that the called function still has to save and restore those registers, even if they are used as arguments! In C code, GCC4TI takes care of that automatically for you, but in assembly code, it is something you need to remember.
See also: regparm
'-ansi' and the various '-std' options disable certain
keywords. This causes trouble when you want to use GNU C extensions, or
a general-purpose header file that should be usable by all programs,
including ISO C programs. The keywords asm, typeof and
inline are not available in programs compiled with
'-ansi' or '-std' (although inline can be used in a
program compiled with '-std=c99'). The ISO C99 keyword
restrict is only available when '-std=gnu99' (which will
eventually be the default) or '-std=c99' (or the equivalent
'-std=iso9899:1999') is used.
The way to solve these problems is to put __ at the beginning and
end of each problematical keyword. For example, use __asm__
instead of asm, and __inline__ instead of inline.
Other C compilers won't accept these alternative keywords; if you want to
compile with another compiler, you can define the alternate keywords as
macros to replace them with the customary keywords. It looks like this:
#ifndef __GNUC__ #define __asm__ asm #endif
'-pedantic' and other options cause warnings for many GNU C extensions.
You can
prevent such warnings within one expression by writing
__extension__ before the expression. __extension__ has no
effect aside from this.
You can define an enum tag without specifying its possible values.
This results in an incomplete type, much like what you get if you write
struct foo without describing the elements. A later declaration
which does specify the possible values completes the type.
You can't allocate variables or storage using the type while it is
incomplete. However, you can work with pointers to that type.
This extension may not be very useful, but it makes the handling of
enum more consistent with the way struct and union
are handled.
GCC predefines two magic identifiers to hold the name of the current
function. The identifier __FUNCTION__ holds the name of the function
as it appears in the source. The identifier __PRETTY_FUNCTION__
holds the name of the function pretty printed in a language specific
fashion.
(These names are always the same in a C function, but in a C++ function
they may be different; don't care about this, because GCC4TI is not a C++ compiler.)
The compiler automatically replaces the identifiers with a string
literal containing the appropriate name. Thus, they are neither
preprocessor macros, like __FILE__ and __LINE__, nor
variables. This means that they catenate with other string literals, and
that they can be used to initialize char arrays. For example
char here[] = "Function " __FUNCTION__ " in " __FILE__;
On the other hand, #ifdef __FUNCTION__ does not have any special
meaning inside a function, since the preprocessor does not do anything
special with the identifier __FUNCTION__.
Note that these semantics are deprecated, and that GCC 3.2 will handle
__FUNCTION__ and __PRETTY_FUNCTION__ the same way as
__func__. __func__ is defined by the ISO standard C99:
The identifier __func__ is implicitly declared by the translator
as if, immediately following the opening brace of each function
definition, the declaration
static const char __func__[] = "function-name";
appeared, where function-name is the name of the lexically-enclosing
function. This name is the unadorned name of the function.
By this definition, __func__ is a variable, not a string literal.
In particular, __func__ does not catenate with other string
literals.
These functions may be used to get information about the callers of a function.
void *__builtin_return_address (int level);
This function returns the return address of the current function, or of
one of its callers. The level argument is number of frames to
scan up the call stack. A value of 0 yields the return address
of the current function, a value of 1 yields the return address
of the caller of the current function, and so forth. When inlining
the expected behavior is that the function will return the address of
the function that will be returned to. To work around this behavior use
the noinline function attribute.
The level argument must be a constant integer.
Sometimes (especially without a frame pointer)
it may be impossible to determine the return address of
any function other than the current one; in such cases, or when the top
of the stack has been reached, this function will return a
random value. In addition, __builtin_frame_address may be used
to determine if the top of the stack has been reached.
This function should be used with a nonzero argument only for debugging
purposes.
void *__builtin_frame_address (int level);
This function is similar to __builtin_return_address, but it
returns the address of the function frame rather than the return address
of the function. Calling __builtin_frame_address with a value of
0 yields the frame address of the current function, a value of
1 yields the frame address of the caller of the current function,
and so forth.
The frame is the area on the stack which holds local variables and saved
registers. The frame address is normally the address of the first word
pushed on to the stack by the function. However, the exact definition
depends upon the processor and the calling convention. On the Motorola
68000, if the function has a frame,
then __builtin_frame_address will return the value of the frame
pointer register a6 if level is 0.
This function should be used with a nonzero argument only for debugging
purposes.
GCC provides a large number of built-in functions. Some of these are for internal use in the processing
of exceptions or variable-length argument lists and will not be
documented here because they may change from time to time; we do not
recommend general use of these functions.
The remaining functions are provided for optimization purposes.
GCC includes built-in versions of many of the functions in the standard
C library. The versions prefixed with __builtin_ will always be
treated as having the same meaning as the C library function even if you
specify the '-fno-builtin' option (see C Dialect Options).
Many of these functions are only optimized in certain cases; if they are
not optimized in a particular case, a call to the library function will
be emitted
(but this does not make sense in GCC4TI, as the standard C library is not provided with it).
The functions abort, exit, _Exit and _exit
are recognized and presumed not to return, but otherwise are not built
in (GCC4TI defines them as macros anyway). _exit is not recognized in strict ISO C mode ('-ansi',
'-std=c89' or '-std=c99'). _Exit is not recognized in
strict C89 mode ('-ansi' or '-std=c89'). All these functions
have corresponding versions prefixed with __builtin_, which may be
used even in strict C89 mode.
Outside strict ISO C mode, the functions alloca, bcmp,
bzero, index, rindex, ffs, fputs_unlocked,
printf_unlocked and fprintf_unlocked may be handled as
built-in functions. All these functions have corresponding versions
prefixed with __builtin_, which may be used even in strict C89
mode
(in GCC4TI, alloca is built-in;
other than that only __builtin_bzero might be useful).
The ISO C99 functions conj, conjf, conjl,
creal, crealf, creall, cimag, cimagf,
cimagl, imaxabs, llabs, snprintf,
vscanf, vsnprintf and vsscanf are handled as built-in
functions except in strict ISO C90 mode. There are also built-in
versions of the ISO C99 functions cosf, cosl,
expf, expl, fabsf, fabsl,
logf, logl, sinf, sinl, sqrtf, and
sqrtl, that are recognized in any mode since ISO C90 reserves
these names for the purpose to which ISO C99 puts them. All these
functions have corresponding versions prefixed with __builtin_
(again, none of these are implemented in GCC4TI).
The ISO C90 functions abs, cos, exp, fabs,
fprintf, fputs, labs, log,
memcmp, memcpy,
memset, printf, putchar, puts, scanf,
sin, snprintf, sprintf, sqrt, sscanf,
strcat,
strchr, strcmp, strcpy, strcspn,
strlen, strncat, strncmp, strncpy,
strpbrk, strrchr, strspn, strstr,
vprintf and vsprintf are all
recognized as built-in functions unless '-fno-builtin' is
specified (or '-fno-builtin-function' is specified for an
individual function). All of these functions have corresponding
versions prefixed with __builtin_
(but most of these are defined as macros in GCC4TI).
GCC provides built-in versions of the ISO C99 floating point comparison
macros that avoid raising exceptions for unordered operands. They have
the same names as the standard macros (isgreater,
isgreaterequal, isless, islessequal,
islessgreater, and isunordered), with __builtin_
prefixed. The GNU team intends for a library implementor to be able to simply
#define each standard macro to its built-in equivalent.
int __builtin_constant_p (exp);
You can use the built-in function __builtin_constant_p to
determine if a value is known to be constant at compile-time and hence
that GCC can perform constant-folding on expressions involving that
value. The argument of the function is the value to test. The function
returns the integer 1 if the argument is known to be a compile-time
constant and 0 if it is not known to be a compile-time constant. A
return of 0 does not indicate that the value is not a constant,
but merely that GCC cannot prove it is a constant with the specified
value of the '-O' option.
If you have some complex calculation,
you may want it to be folded if it involves constants, but need to call
a function if it does not. For example:
#define Scale_Value(X) \ (__builtin_constant_p (X) \ ? ((X) * SCALE + OFFSET) : Scale (X))
You may use this built-in function in either a macro or an inline
function. However, if you use it in an inlined function and pass an
argument of the function as the argument to the built-in, GCC will
never return 1 when you call the inline function with a string constant
or compound literal (see Compound Literals) and will not return 1
when you pass a constant numeric value to the inline function unless you
specify the '-O' option.
You may also use __builtin_constant_p in initializers for static
data. For instance, you can write
static const int table[] = {
__builtin_constant_p (EXPRESSION) ? (EXPRESSION) : -1,
/* ... */
};
This is an acceptable initializer even if EXPRESSION is not a
constant expression. GCC must be more conservative about evaluating the
built-in in this case, because it has no opportunity to perform
optimization.
Previous versions of GCC did not accept this built-in in data
initializers. The earliest version where it is completely safe is
3.0.1.
int __builtin_types_compatible_p (type1, type2);
You can use the built-in function __builtin_types_compatible_p to
determine whether two types are the same.
This built-in function returns 1 if the unqualified versions of the
types type1 and type2 (which are types, not expressions) are
compatible, 0 otherwise. The result of this built-in function can be
used in integer constant expressions.
This built-in function ignores top level qualifiers (const,
volatile, etc.). For example, int is equivalent to const
int.
The type int[] and int[5] are compatible. On the other
hand, long int and char* are not compatible,
although their sizes are the same. Also, the
amount of pointer indirection is taken into account when determining
similarity. Consequently, short* is not similar to
short**. Furthermore, two types that are typedefed are
considered compatible if their underlying types are compatible.
An enum type is considered to be compatible with another
enum type. For example, enum {foo, bar} is similar to
enum {hot, dog}.
You would typically use this function in code whose execution varies
depending on the arguments' types. For example:
#define foo(x) \
({ \
typeof (x) tmp; \
if (__builtin_types_compatible_p (typeof (x), long double)) \
tmp = foo_long_double (tmp); \
else if (__builtin_types_compatible_p (typeof (x), double)) \
tmp = foo_double (tmp); \
else if (__builtin_types_compatible_p (typeof (x), float)) \
tmp = foo_float (tmp); \
else \
abort (); \
tmp; \
})
type __builtin_choose_expr (const_exp, exp1, exp2);
You can use the built-in function __builtin_choose_expr to
evaluate code depending on the value of a constant expression. This
built-in function returns exp1 if const_exp, which is a
constant expression that must be able to be determined at compile time,
is nonzero. Otherwise it returns 0.
This built-in function is analogous to the ? : operator in C,
except that the expression returned has its type unaltered by promotion
rules. Also, the built-in function does not evaluate the expression
that was not chosen. For example, if const_exp evaluates to true,
exp2 is not evaluated even if it has side-effects.
This built-in function can return an lvalue if the chosen argument is an
lvalue.
If exp1 is returned, the return type is the same as exp1's
type. Similarly, if exp2 is returned, its return type is the same
as exp2.
Example:
#define foo(x) \
__builtin_choose_expr ( \
__builtin_types_compatible_p (typeof (x), double), \
foo_double (x), \
__builtin_choose_expr ( \
__builtin_types_compatible_p (typeof (x), float), \
foo_float (x), \
/* The void expression results in a compile-time error \
when assigning the result to something. */ \
(void)0))
Note: The unused expression (exp1 or exp2 depending on the value of const_exp) may still generate syntax errors. This may change in future revisions.
long __builtin_expect (long exp, long c);
You may use __builtin_expect to provide the compiler with
branch prediction information.
The return value is the value of exp, which should be an
integral expression. The value of c must be a compile-time
constant. The semantics of the built-in are that it is expected
that exp == c. For example:
if (__builtin_expect (x, 0)) foo ();
would indicate that we do not expect to call foo, since
we expect x to be zero. Since you are limited to integral
expressions for exp, you should use constructions such as
if (__builtin_expect (ptr != NULL, 1)) error ();
when testing pointer or floating-point values.
void __builtin_prefetch (const void *addr, ...);
This function is used to minimize cache-miss latency by moving data into
a cache before it is accessed.
As the Motorola 68000 processor does not have any data prefetch instruction,
this function is not useful in GCC4TI.
Recently, the preprocessor has relaxed its treatment of escaped newlines. Previously, the newline had to immediately follow a backslash. The current implementation allows whitespace in the form of spaces, horizontal and vertical tabs, and form feeds between the backslash and the subsequent newline. The preprocessor issues a warning, but treats it as a valid escaped newline and combines the two lines to form a single logical line. This works within comments and tokens, including multi-line strings, as well as between tokens. Comments are not treated as whitespace for the purposes of this relaxation, since they have not yet been replaced with spaces.
As an extension, GNU CPP permits string literals to cross multiple lines
without escaping the embedded newlines. Each embedded newline is
replaced with a single \n character in the resulting string
literal, regardless of what form the newline took originally.
CPP currently allows such strings in directives as well (other than the
#include family).
ISO C99 and ISO C++ allow declarations and code to be freely mixed within compound statements. As an extension, GCC also allows this in C89 mode. For example, you could do:
int i; /* ... */ i++; int j = i + 2;
Each identifier is visible from where it is declared until the end of the enclosing block.
For compatibility with other compilers, GCC allows you to define a structure or union that contains, as fields, structures and unions without names. For example:
struct {
int a;
union {
int b;
float c;
};
int d;
} foo;
In this example, the user would be able to access members of the unnamed
union with code like foo.b. Note that only unnamed structs and
unions are allowed, you may not have, for example, an unnamed
int.
You must never create such structures that cause ambiguous field definitions.
For example, this structure:
struct {
int a;
struct {
int a;
};
} foo;
It is ambiguous which a is being referred to with foo.a.
Such constructs are not supported and must be avoided. In the future,
such constructs may be detected and treated as compilation errors.
Both the C and C++ standard have the concept of volatile objects. These
are normally accessed by pointers and used for accessing hardware. The
standards encourage compilers to refrain from optimizations
concerning accesses to volatile objects that it might perform on
non-volatile objects. The C standard leaves it implementation defined
as to what constitutes a volatile access. The C++ standard omits to
specify this, except to say that C++ should behave in a similar manner
to C with respect to volatiles, where possible. The minimum either
standard specifies is that at a sequence point all previous accesses to
volatile objects have stabilized and no subsequent accesses have
occurred. Thus an implementation is free to reorder and combine
volatile accesses which occur between sequence points, but cannot do so
for accesses across a sequence point. The use of volatiles does not
allow you to violate the restriction on updating objects multiple times
within a sequence point.
In most expressions, it is intuitively obvious what is a read and what is
a write. For instance
volatile int *dst = somevalue; volatile int *src = someothervalue; *dst = *src;
will cause a read of the volatile object pointed to by src and stores the
value into the volatile object pointed to by dst. There is no
guarantee that these reads and writes are atomic, especially for objects
larger than int.
Less obvious expressions are where something which looks like an access
is used in a void context. An example would be,
volatile int *src = somevalue; *src;
With C, such expressions are rvalues, and as rvalues cause a read of the object, GCC interprets this as a read of the volatile being pointed to.
Original Version: Extensions to the C Language Family
Published by the Free Software Foundation
59 Temple Place - Suite 330
Boston, MA 02111-1307 USA
Copyright © 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
2000, 2001, 2002 Free Software Foundation, Inc.
Modifications for TIGCC: GNU C Language Extensions
Published by the TIGCC Team
Copyright © 2000, 2001, 2002 Zeljko Juric, Sebastian Reichelt, Kevin Kofler
Modifications for GCC4TI: GNU C Language Extensions
Published by the GCC4TI Project
Copyright © 2009, 2010 Lionel Debroux