diff options
Diffstat (limited to 'gcc/extend.texi')
| -rw-r--r-- | gcc/extend.texi | 97 |
1 files changed, 96 insertions, 1 deletions
diff --git a/gcc/extend.texi b/gcc/extend.texi index 7625f310952..138bb8699b1 100644 --- a/gcc/extend.texi +++ b/gcc/extend.texi @@ -1,4 +1,4 @@ -@c Copyright (C) 1988,89,92,93,94,96 Free Software Foundation, Inc. +@c Copyright (C) 1988, 89, 92, 93, 94, 96, 1998 Free Software Foundation, Inc. @c This is part of the GCC manual. @c For copying conditions, see the file gcc.texi. @@ -33,6 +33,7 @@ C++ Language}, for extensions that apply @emph{only} to C++. * Conditionals:: Omitting the middle operand of a @samp{?:} expression. * Long Long:: Double-word integers---@code{long long int}. * Complex:: Data types for complex numbers. +* Hex Floats:: Hexadecimal floating-point constants. * Zero Length:: Zero-length arrays. * Variable Length:: Arrays whose length is computed at run time. * Macro Varargs:: Macros with variable number of arguments. @@ -63,6 +64,7 @@ C++ Language}, for extensions that apply @emph{only} to C++. * Function Names:: Printable strings which are the name of the current function. * Return Address:: Getting the return or frame address of a function. +* Other Builtins:: Other built-in functions. @end menu @end ifset @ifclear INTERNALS @@ -78,6 +80,7 @@ C++ Language}, for extensions that apply @emph{only} to C++. * Conditionals:: Omitting the middle operand of a @samp{?:} expression. * Long Long:: Double-word integers---@code{long long int}. * Complex:: Data types for complex numbers. +* Hex Floats:: Hexadecimal floating-point constants. * Zero Length:: Zero-length arrays. * Variable Length:: Arrays whose length is computed at run time. * Macro Varargs:: Macros with variable number of arguments. @@ -109,6 +112,7 @@ C++ Language}, for extensions that apply @emph{only} to C++. * Function Names:: Printable strings which are the name of the current function. * Return Address:: Getting the return or frame address of a function. +* Other Builtins:: Other built-in functions. @end menu @end ifclear @@ -790,6 +794,19 @@ examine and set these two fictitious variables with your debugger. A future version of GDB will know how to recognize such pairs and treat them as a single variable with a complex type. +@node Hex Floats +@section Hex Floats +@cindex hex floats + +GNU CC recognizes floating-point numbers writen not only in the usual +decimal notation, such as @code{1.55e1}, but also numbers such as +@code{0x1.fp3} written in hexadecimal format. In that format the +@code{0x} hex introducer and the @code{p} or @code{P} exponent field are +mandatory. The exponent is a decimal number that indicates the power of +2 by which the significand part will be multiplied. Thus @code{0x1.f} is +1 15/16, @code{p3} multiplies it by 8, and the value of @code{0x1.fp3} +is the same as @code{1.55e1}. + @node Zero Length @section Arrays of Length Zero @cindex arrays of length zero @@ -1510,6 +1527,22 @@ mangled name for the target must be used. Not all target machines support this attribute. +@item no_check_memory_usage +@cindex @code{no_check_memory_usage} function attribute +The @code{no_check_memory_usage} attribute causes GNU CC to omit checks +of memory references when it generates code for that function. Normally +if you specify @samp{-fcheck-memory-usage} (see @pxref{Code Gen +Options}), GNU CC generates calls to support routines before most memory +accesses to permit support code to record usage and detect uses of +uninitialized or unallocated storage. Since GNU CC cannot handle +@code{asm} statements properly they are not allowed in such functions. +If you declare a function with this attribute, GNU CC will not generate +memory checking code for that function, permitting the use of @code{asm} +statements without having to compile that function with different +options. This also allows you to write support routines of your own if +you wish, without getting infinite recursion if they get compiled with +@code{-fcheck-memory-usage}. + @item regparm (@var{number}) @cindex functions that are passed arguments in registers on the 386 On the Intel 386, the @code{regparm} attribute causes the compiler to @@ -2380,6 +2413,16 @@ asm volatile ("movc3 %0,%1,%2" : "r0", "r1", "r2", "r3", "r4", "r5"); @end example +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. 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 +@code{volatile} for the @code{asm} construct, as described below, to +prevent GNU CC from deleting the @code{asm} statement as unused. + If 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. In some assemblers, @@ -2846,6 +2889,7 @@ These functions may be used to get information about the callers of a function. @table @code +@findex __builtin_return_address @item __builtin_return_address (@var{level}) This function returns the return address of the current function, or of one of its callers. The @var{level} argument is number of frames to @@ -2862,6 +2906,7 @@ of the stack has been reached, this function will return @code{0}. This function should only be used with a non-zero argument for debugging purposes. +@findex __builtin_frame_address @item __builtin_frame_address (@var{level}) This function is similar to @code{__builtin_return_address}, but it returns the address of the function frame rather than the return address @@ -2882,6 +2927,56 @@ The caveats that apply to @code{__builtin_return_address} apply to this function as well. @end table +@node Other Builtins +@section Other built-in functions provided by GNU CC + +GNU CC provides a large number of built-in functions other than the ones +mentioned above. 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. + +GNU CC includes builtin versions of many of the functions in the +standard C library. These will always be treated as having the same +meaning as the C library function even if you specify the +@samp{-fno-builtin} (@pxref{C Dialect Options}) option. These functions +correspond to the C library functions @code{alloca}, @code{ffs}, +@code{abs}, @code{fabsf}, @code{fabs}, @code{fabsl}, @code{labs}, +@code{memcpy}, @code{memcmp}, @code{strcmp}, @code{strcpy}, +@code{strlen}, @code{sqrtf}, @code{sqrt}, @code{sqrtl}, @code{sinf}, +@code{sin}, @code{sinl}, @code{cosf}, @code{cos}, and @code{cosl}. + +@findex __builtin_constant_p +You can use the builtin function @code{__builtin_constant_p} to +determine if a value is known to be constant at compile-time and hence +that GNU CC 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 @emph{not} a constant, +but merely that GNU CC cannot prove it is a constant with the specified +value of the @samp{-O} option. + +You would typically use this function in an embedded application where +memory was a critical resource. 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: + +@smallexample +#define Scale_Value(X) \ + (__builtin_constant_p (X) ? ((X) * SCALE + OFFSET) : Scale (X)) +@end smallexample + +You may use this builtin 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 builtin, GNU CC will +never return 1 when you call the inline function with a string constant +or constructor expression (@pxref{Constructors}) and will not return 1 +when you pass a constant numeric value to the inline function unless you +specify the @samp{-O} option. + @node C++ Extensions @chapter Extensions to the C++ Language @cindex extensions, C++ language |