+2001-05-28 Joseph S. Myers <jsm28@cam.ac.uk>
+
+ * c-tree.texi, contrib.texi, cpp.texi, extend.texi, gcc.texi,
+ gcov.texi, install.texi, md.texi, objc.texi, rtl.texi, tm.texi:
+ Remove trailing whitespace.
+
2001-05-28 Gerald Pfeifer <pfeifer@dbai.tuwien.ac.at>
* doc/install.texi (Specific): http://reality.sgi.com/ariel/freeware/
@menu
* Deficiencies:: Topics net yet covered in this document.
* Tree overview:: All about @code{tree}s.
-* Types:: Fundamental and aggregate types.
+* Types:: Fundamental and aggregate types.
* Scopes:: Namespaces and classes.
* Functions:: Overloading, function bodies, and linkage.
* Declarations:: Type declarations and variables.
@item CP_TYPE_CONST_NON_VOLATILE_P
This predicate holds for a type that is @code{const}-qualified, but
@emph{not} @code{volatile}-qualified; other cv-qualifiers are ignored as
-well: only the @code{const}-ness is tested.
+well: only the @code{const}-ness is tested.
@item TYPE_MAIN_VARIANT
This macro returns the unqualified version of a type. It may be applied
@item CP_INTEGRAL_TYPE
This predicate holds if the type is an integral type. Notice that in
-C++, enumerations are @emph{not} integral types.
+C++, enumerations are @emph{not} integral types.
@item ARITHMETIC_TYPE_P
This predicate holds if the type is an integral type (in the C++ sense)
@item TYPE_PTR_P
This predicate holds if the type is a pointer type, and the pointee is
-not a data member.
+not a data member.
@item TYPE_PTRFN_P
This predicate holds for a pointer to function type.
is given by @code{TYPE_PRECISION}, as in the @code{INTEGER_TYPE} case.
@item COMPLEX_TYPE
-Used to represent GCC builtin @code{__complex__} data types. The
+Used to represent GCC builtin @code{__complex__} data types. The
@code{TREE_TYPE} is the type of the real and imaginary parts.
@item ENUMERAL_TYPE
@item TYPEOF_TYPE
Used to represent the @code{__typeof__} extension. The
@code{TYPE_FIELDS} is the expression the type of which is being
-represented.
+represented.
@item UNION_TYPE
Used to represent @code{union} types. For more information, @pxref{Classes}.
@item DECL_NAMESPACE_ALIAS
If this declaration is for a namespace alias, then
@code{DECL_NAMESPACE_ALIAS} is the namespace for which this one is an
-alias.
+alias.
Do not attempt to use @code{cp_namespace_decls} for a namespace which is
an alias. Instead, follow @code{DECL_NAMESPACE_ALIAS} links until you
@item DECL_NAMESPACE_STD_P
This predicate holds if the namespace is the special @code{::std}
-namespace.
+namespace.
@item cp_namespace_decls
This function will return the declarations contained in the namespace,
including types, overloaded functions, other namespaces, and so forth.
If there are no declarations, this function will return
@code{NULL_TREE}. The declarations are connected through their
-@code{TREE_CHAIN} fields.
+@code{TREE_CHAIN} fields.
Although most entries on this list will be declarations,
@code{TREE_LIST} nodes may also appear. In this case, the
FIXME: Talk about @code{TYPE_NONCOPIED_PARTS}.
-The following macros can be used on a tree node representing a class-type.
+The following macros can be used on a tree node representing a class-type.
@ftable @code
@item LOCAL_CLASS_P
@item CLASSTYPE_HAS_MUTABLE
@item TYPE_HAS_MUTABLE_P
-These predicates hold for a class-type having a mutable data member.
+These predicates hold for a class-type having a mutable data member.
@item CLASSTYPE_NON_POD_P
This predicate holds only for class-types that are not PODs.
@item TYPE_HAS_NEW_OPERATOR
-This predicate holds for a class-type that defines
+This predicate holds for a class-type that defines
@code{operator new}.
@item TYPE_HAS_ARRAY_NEW_OPERATOR
-This predicate holds for a class-type for which
+This predicate holds for a class-type for which
@code{operator new[]} is defined.
@item TYPE_OVERLOADS_CALL_EXPR
-This predicate holds for class-type for which the function call
+This predicate holds for class-type for which the function call
@code{operator()} is overloaded.
@item TYPE_OVERLOADS_ARRAY_REF
-This predicate holds for a class-type that overloads
+This predicate holds for a class-type that overloads
@code{operator[]}
@item TYPE_OVERLOADS_ARROW
This predicate holds for a class-type for which @code{operator->} is
-overloaded.
+overloaded.
@end ftable
This macro returns the line number at which the entity was declared, as
an @code{int}.
-@item DECL_ARTIFICIAL
+@item DECL_ARTIFICIAL
This predicate holds if the declaration was implicitly generated by the
compiler. For example, this predicate will hold of an implicitly
declared member function, or of the @code{TYPE_DECL} implicitly
@item DECL_FUNCTION_SCOPE_P
This predicate holds if the entity was declared inside a function
-body.
+body.
@end ftable
variable to give it a particular size and alignment. You may use the
predicates @code{DECL_THIS_STATIC} or @code{DECL_THIS_EXTERN} to test
whether the storage class specifiers @code{static} or @code{extern} were
-used to declare a variable.
+used to declare a variable.
If this variable is initialized (but does not require a constructor),
the @code{DECL_INITIAL} will be an expression for the initializer. The
@ftable @code
@item DECL_MAIN_P
This predicate holds for a function that is the program entry point
-@code{::code}.
+@code{::code}.
@item DECL_NAME
This macro returns the unqualified name of the function, as an
@item DECL_ANTICIPATED
This predicate holds if the function is a built-in function but its
-prototype is not yet explicitly declared.
+prototype is not yet explicitly declared.
@item DECL_EXTERN_C_FUNCTION_P
This predicate holds if the function is declared as an
returning to the thunk. The first parameter to the thunk is always the
@code{this} pointer; the thunk should add @code{THUNK_DELTA} to this
value. (The @code{THUNK_DELTA} is an @code{int}, not an
-@code{INTEGER_CST}.)
+@code{INTEGER_CST}.)
Then, if @code{THUNK_VCALL_OFFSET} (an @code{INTEGER_CST}) is non-zero
the adjusted @code{this} pointer must be adjusted again. The complete
access them. This documentation describes the use of these nodes in
non-template functions (including instantiations of template functions).
In template functions, the same nodes are used, but sometimes in
-slightly different ways.
+slightly different ways.
Many of the statements have substatements. For example, a @code{while}
loop will have a body, which is itself a statement. If the substatement
process_stmt (THEN_CLAUSE (stmt));
/* More processing here. */
break;
-
+
...
@}
asm ("mov x, y");
@end example
The @code{ASM_STRING} macro will return a @code{STRING_CST} node for
-@code{"mov x, y"}. If the original statement made use of the
+@code{"mov x, y"}. If the original statement made use of the
extended-assembly syntax, then @code{ASM_OUTPUTS},
@code{ASM_INPUTS}, and @code{ASM_CLOBBERS} will be the outputs, inputs,
and clobbers for the statement, represented as @code{STRING_CST} nodes.
@item IF_STMT
Used to represent an @code{if} statement. The @code{IF_COND} is the
-expression.
+expression.
If the condition is a @code{TREE_LIST}, then the @code{TREE_PURPOSE} is
a statement (usually a @code{DECL_STMT}). Each time the coondition is
@code{int}. In particular, @code{char} constants are represented with
@code{INTEGER_CST} nodes. The value of the integer constant @code{e} is
given by @example
-((TREE_INT_CST_HIGH (e) << HOST_BITS_PER_WIDE_INT)
+((TREE_INT_CST_HIGH (e) << HOST_BITS_PER_WIDE_INT)
+ TREE_INST_CST_LOW (e))
@end example
@noindent
@item COMPLEX_CST
These nodes are used to represent complex number constants, that is a
-@code{__complex__} whose parts are constant nodes. The
+@code{__complex__} whose parts are constant nodes. The
@code{TREE_REALPART} and @code{TREE_IMAGPART} return the real and the
imaginary parts respectively.
If the object addressed is not an lvalue, a temporary is created, and
the address of the temporary is used.
-@item INDIRECT_REF
+@item INDIRECT_REF
These nodes are used to represent the object pointed to by a pointer.
The operand is the pointer being dereferenced; it will always have
pointer or reference type.
@item FLOAT_EXPR
These nodes represent conversion of an integral (or boolean) value to a
floating-point value. The single operand will have integral type, while
-the complete expression will have a floating-point type.
+the complete expression will have a floating-point type.
FIXME: How is the operand supposed to be rounded? Is this dependent on
-mieee?
x ? : 3
@end example
@noindent
-which is equivalent to
+which is equivalent to
@example
x ? x : 3
that print a copy of their source.
@item
-Ulrich Drepper for his work on the C++ runtime libraries, glibc,
+Ulrich Drepper for his work on the C++ runtime libraries, glibc,
testing of GCC using glibc, ISO C99 support, CFG dumping support, etc.
@item
@item
Anthony Green for his -Os contributions and Java front end work.
-@item
+@item
Kaveh Ghazi for his direction via the steering committee and
amazing work to make -W -Wall useful.
and various C++ improvements including namespace support.
@item
-Dave Love for his ongoing work with the Fortran front end and
+Dave Love for his ongoing work with the Fortran front end and
runtime libraries.
@item
Holger Teutsch provided the support for the Clipper cpu.
@item
-Michael Tiemann for random bugfixes the first instruction scheduler,
-initial C++ support, function integration, NS32k, sparc and M88k
+Michael Tiemann for random bugfixes the first instruction scheduler,
+initial C++ support, function integration, NS32k, sparc and M88k
machine description work, delay slot scheduling.
@item
@author Richard M. Stallman
@page
@vskip 2pc
-This booklet is eventually intended to form the first chapter of a GNU
+This booklet is eventually intended to form the first chapter of a GNU
C Language manual.
@vskip 0pt plus 1filll
@dfn{Inheritance} is what happens when one object or file derives some
of its contents by virtual copying from another object or file. In
-the case of C header files, inheritance means that one header file
+the case of C header files, inheritance means that one header file
includes another header file and then replaces or adds something.
If the inheriting header file and the base header file have different
requires a change somewhere else.
@findex #include_next
-The clean way to solve this problem is to use
+The clean way to solve this problem is to use
@samp{#include_next}, which means, ``Include the @emph{next} file with
this name.'' This directive works like @samp{#include} except in
searching for the specified file: it starts searching the list of header
of the compiler (for example, if GCC 2.6.2 is known to contain a bug,
whereas GCC 2.6.3 contains a fix, and you have code which can workaround
the problem depending on whether the bug is fixed or not, you can test for
-@code{__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 6) ||
+@code{__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 6) ||
(__GNUC__ == 2 && __GNUC_MINOR__ == 6 && __GNUC_PATCHLEVEL__ >= 3)}).
@item __GNUG__
C++; use @samp{__GNUG__} to distinguish between GNU C and GNU
C++.
-@item __cplusplus
-@findex __cplusplus
+@item __cplusplus
+@findex __cplusplus
The ISO standard for C++ requires predefining this variable. You can
use @samp{__cplusplus} to test whether a header is compiled by a C
compiler or a C++ compiler. The compiler currently uses a value of
#define CPP_PREDEFINES "-Dmc68000 -Dsun -Dunix -Dm68k"
@end example
-@noindent
+@noindent
This macro is usually specified in @file{tm.h}.
@node Stringification, Concatenation, Predefined, Macros
#endif /* Not @var{expression} */
@end example
-If @var{expression} is nonzero, and thus the @var{text-if-true} is
+If @var{expression} is nonzero, and thus the @var{text-if-true} is
active, then @samp{#else} acts like a failing conditional and the
@var{text-if-false} is ignored. Conversely, if the @samp{#if}
conditional fails, the @var{text-if-false} is considered included.
a comma and a variable arguments parameter, and the variable argument is
omitted entirely, the comma will be removed from the expansion. If the
variable argument is empty, or the token before @samp{##} is not a
-comma, then @samp{##} behaves as a normal token paste.
+comma, then @samp{##} behaves as a normal token paste.
Portable code should avoid this extension at all costs.
touch foo.h; cpp -dM foo.h
@end example
-@noindent
+@noindent
will show the values of any predefined macros.
@item -dD
asm volatile ("eieio" : : );
@end example
-@noindent
+@noindent
Assume @code{addr} contains the address of a memory mapped device
register. The PowerPC @code{eieio} instruction (Enforce In-order
Execution of I/O) tells the cpu to make sure that the store to that
@c NOTE: checks/things to do:
@c
@c -have bob do a search in all seven files for "mew" (ideally --mew,
-@c but i may have forgotten the occasional "--"..).
+@c but i may have forgotten the occasional "--"..).
@c Just checked... all have `--'! Bob 22Jul96
@c Use this to search: grep -n '\-\-mew' *.texi
@c -item/itemx, text after all (sub/sub)section titles, etc..
@cindex Objective C
Several versions of the compiler (C, C++, Objective C, Fortran, Java
-and CHILL) are integrated; this is why we use the name
+and CHILL) are integrated; this is why we use the name
``GNU Compiler Collection''. GCC can compile programs written in any of these
-languages. The Fortran, CHILL, and Java compilers are described in
+languages. The Fortran, CHILL, and Java compilers are described in
separate manuals.
@cindex GCC
affecting the behavior of ``GCC'' or sometimes just ``the compiler''.
Front ends for other languages, such as Ada 95 and Pascal exist but
-have not yet been integrated into GCC. These front-ends, like that for C++,
+have not yet been integrated into GCC. These front-ends, like that for C++,
are built in subdirectories of GCC and link to it. The result is an
integrated compiler that can compile programs written in C, C++,
Objective C, or any of the languages for which you have installed front
@section Incompatibilities of GCC
@cindex incompatibilities of GCC
-There are several noteworthy incompatibilities between GNU C and K&R
+There are several noteworthy incompatibilities between GNU C and K&R
(non-ISO) versions of C. The @samp{-traditional} option
eliminates many of these incompatibilities, @emph{but not all}, by
telling GNU C to behave like a K&R C compiler.
string strfunc ();
void charfunc (const char *);
-void
+void
f ()
@{
const char *p = strfunc().c_str();
for traditional practice''.
@item
-If you are an experienced user of one of the languages GCC supports, your
+If you are an experienced user of one of the languages GCC supports, your
suggestions for improvement of GCC are welcome in any case.
@end itemize
The source files for parsing C++ are in @file{cp/}.
They are @file{parse.y},
@file{class.c},@*
-@file{cvt.c}, @file{decl.c}, @file{decl2.c},
+@file{cvt.c}, @file{decl.c}, @file{decl2.c},
@file{except.c},@*
@file{expr.c}, @file{init.c}, @file{lex.c},
@file{method.c}, @file{ptree.c},@*
-@file{search.c}, @file{tree.c},
+@file{search.c}, @file{tree.c},
@file{typeck2.c}, and
@file{typeck.c}, along with header files @file{cp-tree.def},
@file{cp-tree.h}, and @file{decl.h}.
@cindex global common subexpression elimination
@cindex constant propagation
@cindex copy propagation
-@item
+@item
Global common subexpression elimination. This pass performs GCSE
using Morel-Renvoise Partial Redundancy Elimination, with the exception
that it does not try to move invariants out of loops - that is left to
@cindex branch shortening
@item
Branch shortening. On many RISC machines, branch instructions have a
-limited range. Thus, longer sequences of instructions must be used for
+limited range. Thus, longer sequences of instructions must be used for
long branches. In this pass, the compiler figures out what how far each
instruction will be from each other instruction, and therefore whether
the usual instructions, or the longer sequences, must be used for each
-branch.
+branch.
@cindex register-to-stack conversion
@item
For example, if you set @code{MULTILIB_OPTIONS} to @samp{m68000/m68020
msoft-float}, @file{Makefile} will build special versions of
@file{libgcc.a} using the following sets of options: @samp{-m68000},
-@samp{-m68020}, @samp{-msoft-float}, @samp{-m68000 -msoft-float}, and
+@samp{-m68020}, @samp{-msoft-float}, @samp{-m68000 -msoft-float}, and
@samp{-m68020 -msoft-float}.
@findex MULTILIB_DIRNAMES
What they found was no accident---it was the GNU system. The available
free software added up to a complete system because the GNU Project
had been working since 1984 to make one. The GNU Manifesto
-had set forth the goal of developing a free Unix-like system, called
+had set forth the goal of developing a free Unix-like system, called
GNU. By the time Linux was written, the system was almost finished.
Most free software projects have the goal of developing a particular
each branch in your program was taken.
@item -c
-Write branch frequencies as the number of branches taken, rather than
+Write branch frequencies as the number of branches taken, rather than
the percentage of branches taken.
@item -v
Creating tmp.c.gcov.
@end smallexample
-The file @file{tmp.c.gcov} contains output from @code{gcov}.
+The file @file{tmp.c.gcov} contains output from @code{gcov}.
Here is a sample:
@smallexample
main()
@{
1 int i, total;
-
+
1 total = 0;
-
+
11 for (i = 0; i < 10; i++)
10 total += i;
-
+
1 if (total != 45)
###### printf ("Failure\n");
else
main()
@{
1 int i, total;
-
+
1 total = 0;
-
+
11 for (i = 0; i < 10; i++)
branch 0 taken = 91%
branch 1 taken = 100%
branch 2 taken = 100%
10 total += i;
-
+
1 if (total != 45)
branch 0 taken = 100%
###### printf ("Failure\n");
@itemx --disable-nls
The @samp{--enable-nls} option enables Native Language Support (NLS),
which lets GCC output diagnostics in languages other than American
-English. Native Language Support is enabled by default if not doing a
+English. Native Language Support is enabled by default if not doing a
canadian cross build. The @samp{--disable-nls} option disables NLS.
@cindex @code{gettext}
The MIL-STD-1750A cross configuration produces output for
@code{as1750}, an assembler/linker available under the GNU Public
-License for the 1750A. @code{as1750} can be obtained at
+License for the 1750A. @code{as1750} can be obtained at
@uref{ftp://ftp.fta-berlin.de/pub/crossgcc/1750gals/}.
A similarly licensed simulator for
the 1750A is available from same address.
@uref{ftp://ftp.varesearch.com/pub/support/hjl/binutils/}.
These two configurations differ only in the required version of GNU
-binutils. For binutils 2.9.1.0.x, use @samp{arm-*-linux-gnuoldld}. For
+binutils. For binutils 2.9.1.0.x, use @samp{arm-*-linux-gnuoldld}. For
newer versions of binutils, use @samp{arm-*-linux-gnu}.
@item arm-*-riscix
requires @samp{&} while others do not. See, for example, the
@samp{movdf} insn of the 68000.
-An input operand can be tied to an earlyclobber operand if its only
+An input operand can be tied to an earlyclobber operand if its only
use as an input occurs before the early result is written. Adding
alternatives of this form often allows GCC to produce better code
-when only some of the inputs can be affected by the earlyclobber.
+when only some of the inputs can be affected by the earlyclobber.
See, for example, the @samp{mulsi3} insn of the ARM.
@samp{&} does not obviate the need to write @samp{=}.
Signed 16-bit constant
@item J
-Unsigned 16-bit constant shifted left 16 bits (use @samp{L} instead for
+Unsigned 16-bit constant shifted left 16 bits (use @samp{L} instead for
@code{SImode} constants)
@item K
High 16-bit constant (32-bit constant with 16 LSBs zero)
@item Q
-Indirect memory reference with signed 8-bit or index register displacement
+Indirect memory reference with signed 8-bit or index register displacement
@item R
Indirect memory reference with unsigned 5-bit displacement
@item S
-Indirect memory reference with 1 bit or index register displacement
+Indirect memory reference with 1 bit or index register displacement
@item T
Direct memory reference
The pattern takes two arguments. The first is an offset to be applied
to the stack pointer. It will have been copied to some appropriate
location (typically @code{EH_RETURN_STACKADJ_RTX}) which will survive
-until after reload to when the normal epilogue is generated.
+until after reload to when the normal epilogue is generated.
The second argument is the address of the exception handler to which
the function should return. This will normally need to copied by the
pattern to some special register or memory location.
The @code{sibcall_epilogue} pattern must not clobber any arguments used for
parameter passing or any stack slots for arguments passed to the current
-function.
+function.
@cindex @code{trap} instruction pattern
@item @samp{trap}
@smallexample
(define_insn "conditional_trap"
- [(trap_if (match_operator 0 "trap_operator"
+ [(trap_if (match_operator 0 "trap_operator"
[(cc0) (const_int 0)])
(match_operand 1 "const_int_operand" "i"))]
""
The other two special looping patterns, @samp{doloop_begin} and
@samp{doloop_end}, are emitted by the loop optimiser for certain
well-behaved loops with a finite number of loop iterations using
-information collected during strength reduction.
+information collected during strength reduction.
The @samp{doloop_end} pattern describes the actual looping instruction
(or the implicit looping operation) and the @samp{doloop_begin} pattern
@end smallexample
-In this case, the actual split condition will be
+In this case, the actual split condition will be
"TARGET_ZERO_EXTEND_WITH_AND && !optimize_size && reload_completed."
The @code{define_insn_and_split} construction provides exactly the same
A newer @code{define_peephole2} matches insns and substitutes new
insns. The @code{peephole2} pass is run after register allocation
-but before scheduling, which may result in much better code for
+but before scheduling, which may result in much better code for
targets that do scheduling.
@menu
@findex define_peephole2
The @code{define_peephole2} definition tells the compiler how to
-substitute one sequence of instructions for another sequence,
+substitute one sequence of instructions for another sequence,
what additional scratch registers may be needed and what their
lifetimes must be.
@code{current_insn_predicate} that will contain the entire predicate
if the current insn is predicated, and will otherwise be @code{NULL}.
-When @code{define_cond_exec} is used, an implicit reference to
-the @code{predicable} instruction attribute is made.
+When @code{define_cond_exec} is used, an implicit reference to
+the @code{predicable} instruction attribute is made.
@xref{Insn Attributes}. This attribute must be boolean (i.e. have
exactly two elements in its @var{list-of-values}). Further, it must
not be used with complex expressions. That is, the default and all
-uses in the insns must be a simple constant, not dependent on the
+uses in the insns must be a simple constant, not dependent on the
alternative or anything else.
-For each @code{define_insn} for which the @code{predicable}
+For each @code{define_insn} for which the @code{predicable}
attribute is true, a new @code{define_insn} pattern will be
generated that matches a predicated version of the instruction.
For example,
@email{ovidiu@@cup.hp.com}.
@menu
-* Executing code before main::
-* Type encoding::
-* Garbage Collection::
-* Constant string objects::
+* Executing code before main::
+* Type encoding::
+* Garbage Collection::
+* Constant string objects::
* compatibility_alias::
@end menu
below:
@example
-
-FileStream *Stdin = nil;
-FileStream *Stdout = nil;
-FileStream *Stderr = nil;
-
-@@implementation FileStream
-
-+ (void)initialize
+
+FileStream *Stdin = nil;
+FileStream *Stdout = nil;
+FileStream *Stderr = nil;
+
+@@implementation FileStream
+
++ (void)initialize
@{
- Stdin = [[FileStream new] initWithFd:0];
- Stdout = [[FileStream new] initWithFd:1];
+ Stdin = [[FileStream new] initWithFd:0];
+ Stdout = [[FileStream new] initWithFd:1];
Stderr = [[FileStream new] initWithFd:2];
@}
-
+
/* Other methods here */
@@end
@example
-@@implementation FileStream
-
-+ (void)load
+@@implementation FileStream
+
++ (void)load
@{
Stdin = [[FileStream new] initWithFd:0];
Stdout = [[FileStream new] initWithFd:1];
Stderr = [[FileStream new] initWithFd:2];
@}
-
-/* Other methods here */
+
+/* Other methods here */
@@end
@end example
-
+
The @code{+load} is a method that is not overridden by categories. If a
class and a category of it both implement @code{+load}, both methods are
invoked. This allows some additional initializations to be performed in
a category.
-
+
This mechanism is not intended to be a replacement for @code{+initialize}.
You should be aware of its limitations when you decide to use it
instead of @code{+initialize}.
@menu
-* What you can and what you cannot do in +load::
+* What you can and what you cannot do in +load::
@end menu
You should make no assumptions about receiving @code{+load} in sibling
classes when you write @code{+load} of a class. The order in which
sibling classes receive @code{+load} is not guaranteed.
-
+
The order in which @code{+load} and @code{+initialize} are called could
be problematic if this matters. If you don't allocate objects inside
@code{+load}, it is guaranteed that @code{+load} is called before
@c @sp 1
@multitable @columnfractions .25 .75
-@item @code{char}
+@item @code{char}
@tab @code{c}
-@item @code{unsigned char}
+@item @code{unsigned char}
@tab @code{C}
-@item @code{short}
+@item @code{short}
@tab @code{s}
-@item @code{unsigned short}
+@item @code{unsigned short}
@tab @code{S}
-@item @code{int}
+@item @code{int}
@tab @code{i}
-@item @code{unsigned int}
+@item @code{unsigned int}
@tab @code{I}
-@item @code{long}
+@item @code{long}
@tab @code{l}
-@item @code{unsigned long}
+@item @code{unsigned long}
@tab @code{L}
-@item @code{long long}
+@item @code{long long}
@tab @code{q}
-@item @code{unsigned long long}
+@item @code{unsigned long long}
@tab @code{Q}
-@item @code{float}
+@item @code{float}
@tab @code{f}
-@item @code{double}
+@item @code{double}
@tab @code{d}
-@item @code{void}
+@item @code{void}
@tab @code{v}
-@item @code{id}
+@item @code{id}
@tab @code{@@}
-@item @code{Class}
+@item @code{Class}
@tab @code{#}
-@item @code{SEL}
+@item @code{SEL}
@tab @code{:}
-@item @code{char*}
+@item @code{char*}
@tab @code{*}
-@item unknown type
+@item unknown type
@tab @code{?}
-@item bitfields
+@item bitfields
@tab @code{b} followed by the starting position of the bitfield, the type of the bitfield and the size of the bitfield (the bitfields encoding was changed from the NeXT's compiler encoding, see below)
@end multitable
@c @sp 1
@multitable @columnfractions .2 .8
-@item pointers
+@item pointers
@tab @code{'^'} followed by the pointed type.
@item arrays
@tab @code{'['} followed by the number of elements in the array followed by the type of the elements followed by @code{']'}
@multitable @columnfractions .25 .75
@item Specifier
@tab Encoding
-@item @code{const}
+@item @code{const}
@tab @code{r}
-@item @code{in}
+@item @code{in}
@tab @code{n}
-@item @code{inout}
+@item @code{inout}
@tab @code{N}
-@item @code{out}
+@item @code{out}
@tab @code{o}
-@item @code{bycopy}
+@item @code{bycopy}
@tab @code{O}
-@item @code{oneway}
+@item @code{oneway}
@tab @code{V}
@end multitable
runtime, anyway since it is documented nowhere and its existence was
forgotten, we are documenting it here.
-The keyword @code{@@compatibility_alias} allows you to define a class name
-as equivalent to another class name. For example:
+The keyword @code{@@compatibility_alias} allows you to define a class name
+as equivalent to another class name. For example:
@example
@@compatibility_alias WOApplication GSWApplication;
@end example
-tells the compiler that each time it encounters @code{WOApplication} as
-a class name, it should replace it with @code{GSWApplication} (that is,
+tells the compiler that each time it encounters @code{WOApplication} as
+a class name, it should replace it with @code{GSWApplication} (that is,
@code{WOApplication} is just an alias for @code{GSWApplication}).
-There are some constraints on how this can be used -
+There are some constraints on how this can be used -
-@itemize @bullet
+@itemize @bullet
@item @code{WOApplication} (the alias) must not be an existing class;
than as a pointer to a null character. In certain contexts, these null
pointers instead of strings are valid. Within RTL code, strings are most
commonly found inside @code{symbol_ref} expressions, but they appear in
-other contexts in the RTL expressions that make up machine descriptions.
+other contexts in the RTL expressions that make up machine descriptions.
A vector contains an arbitrary number of pointers to expressions. The
number of elements in the vector is explicitly present in the vector.
contained in the exit test code for some loop. Stored in the
@code{in_struct} field and printed as @samp{/s}.
-@findex REG_USERVAR_P
+@findex REG_USERVAR_P
@cindex @code{reg} and @samp{/v}
@cindex @code{volatil}, in @code{reg}
@item REG_USERVAR_P (@var{x})
@samp{/v}.
@cindex @samp{/i} in RTL dump
-@findex REG_FUNCTION_VALUE_P
+@findex REG_FUNCTION_VALUE_P
@cindex @code{reg} and @samp{/i}
@cindex @code{integrated}, in @code{reg}
@item REG_FUNCTION_VALUE_P (@var{x})
is kept sign-extended. Stored in the @code{unchanging} field and
printed as @samp{/u}.
-@findex RTX_UNCHANGING_P
+@findex RTX_UNCHANGING_P
@cindex @code{reg} and @samp{/u}
@cindex @code{mem} and @samp{/u}
@cindex @code{unchanging}, in @code{reg} and @code{mem}
other functions or by aliasing.) Stored in the
@code{unchanging} field and printed as @samp{/u}.
-@findex RTX_INTEGRATED_P
+@findex RTX_INTEGRATED_P
@cindex @code{integrated}, in @code{insn}
@item RTX_INTEGRATED_P (@var{insn})
Nonzero in an insn if it resulted from an in-line function call.
label that is outside the innermost loop containing the reference to the
label. Stored in the @code{in_struct} field and printed as @samp{/s}.
-@findex INSN_DELETED_P
+@findex INSN_DELETED_P
@cindex @code{volatil}, in @code{insn}
@item INSN_DELETED_P (@var{insn})
In an insn, nonzero if the insn has been deleted. Stored in the
this insn will always be executed. Stored in the @code{in_struct}
field and printed as @samp{/s}.
-@findex CONSTANT_POOL_ADDRESS_P
+@findex CONSTANT_POOL_ADDRESS_P
@cindex @code{symbol_ref} and @samp{/u}
@cindex @code{unchanging}, in @code{symbol_ref}
@item CONSTANT_POOL_ADDRESS_P (@var{x})
In a @code{mem} expression, it is 1 if the memory reference is volatile.
Volatile memory references may not be deleted, reordered or combined.
-In a @code{symbol_ref} expression, it is used for machine-specific
+In a @code{symbol_ref} expression, it is used for machine-specific
purposes.
In a @code{reg} expression, it is 1 if the value is a user-level variable.
@findex SUBREG_REG
@findex SUBREG_BYTE
-The first operand of a @code{subreg} expression is customarily accessed
+The first operand of a @code{subreg} expression is customarily accessed
with the @code{SUBREG_REG} macro and the second operand is customarily
accessed with the @code{SUBREG_BYTE} macro.
@cindex RTL sum
@item (plus:@var{m} @var{x} @var{y})
Represents the sum of the values represented by @var{x} and @var{y}
-carried out in machine mode @var{m}.
+carried out in machine mode @var{m}.
@findex lo_sum
@item (lo_sum:@var{m} @var{x} @var{y})
be @code{VOIDmode}.
If one of the operands is a constant, it should be placed in the
-second operand and the comparison code adjusted as appropriate.
+second operand and the comparison code adjusted as appropriate.
A @code{compare} specifying two @code{VOIDmode} constants is not valid
since there is no way to know in what mode the comparison is to be
quotient.
Some machines have division instructions in which the operands and
-quotient widths are not all the same; you should represent
+quotient widths are not all the same; you should represent
such instructions using @code{truncate} and @code{sign_extend} as in,
@example
these two operations are distinct.
@findex rotate
-@cindex rotate
+@cindex rotate
@cindex left rotate
@findex rotatert
@cindex right rotate
@findex SET_DEST
@findex SET_SRC
-@var{lval} is customarily accessed with the @code{SET_DEST} macro and
+@var{lval} is customarily accessed with the @code{SET_DEST} macro and
@var{x} with the @code{SET_SRC} macro.
@findex return
This note indicates the place in a loop where the exit test begins for
those loops in which the exit test has been duplicated. This position
becomes another virtual start of the loop when considering loop
-invariants.
+invariants.
@findex NOTE_INSN_FUNCTION_END
@item NOTE_INSN_FUNCTION_END
@cindex @code{HImode}, in @code{insn}
@cindex @code{QImode}, in @code{insn}
The machine mode of an insn is normally @code{VOIDmode}, but some
-phases use the mode for various purposes.
+phases use the mode for various purposes.
The common subexpression elimination pass sets the mode of an insn to
@code{QImode} when it is the first insn in a block that has already
The second Haifa scheduling pass, for targets that can multiple issue,
sets the mode of an insn to @code{TImode} when it is believed that the
-instruction begins an issue group. That is, when the instruction
+instruction begins an issue group. That is, when the instruction
cannot issue simultaneously with the previous. This may be relied on
by later passes, in particular machine-dependant reorg.
These register notes annotate inputs to an insn:
@table @code
-@findex REG_DEAD
+@findex REG_DEAD
@item REG_DEAD
The value in @var{op} dies in this insn; that is to say, altering the
value immediately after this insn would not affect the future behavior
-of the program.
+of the program.
This does not necessarily mean that the register @var{op} has no useful
value after this insn since it may also be an output of the insn. In
output of the single @code{set} is a @code{strict_low_part} expression,
the note refers to the register that is contained in @code{SUBREG_REG}
of the @code{subreg} expression.
-
+
For @code{REG_EQUIV}, the register is equivalent to @var{op} throughout
the entire function, and could validly be replaced in all its
occurrences by @var{op}. (``Validly'' here refers to the data flow of
operation for code motion purposes and flow analysis uses this note to
delete such sequences whose results are dead.
-A @code{REG_EQUAL} note will also usually be attached to this insn to
+A @code{REG_EQUAL} note will also usually be attached to this insn to
provide the expression being computed by the sequence.
These notes will be deleted after reload, since they are no longer
This is the inverse of @code{REG_RETVAL}: it is placed on the first
insn of a multi-insn sequence, and it points to the last one.
-These notes are deleted after reload, since they are no longer useful or
+These notes are deleted after reload, since they are no longer useful or
accurate.
@findex REG_CC_SETTER
The macro should return a combination of the @code{DW_EH_PE_*} defines
as found in @file{dwarf2.h}.
-If this macro is not defined, pointers will not be encoded but
+If this macro is not defined, pointers will not be encoded but
represented directly.
@findex ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
@findex TARGET_ALLOWS_PROFILING_WITHOUT_FRAME_POINTER
@item TARGET_ALLOWS_PROFILING_WITHOUT_FRAME_POINTER
On some targets, it is impossible to use profiling when the frame
-pointer has been omitted. For example, on x86 GNU/Linux systems,
+pointer has been omitted. For example, on x86 GNU/Linux systems,
the @code{mcount} routine provided by the GNU C Library finds the
-address of the routine that called the routine that called @code{mcount}
+address of the routine that called the routine that called @code{mcount}
by looking in the immediate caller's stack frame. If the immediate
caller has no frame pointer, this lookup will fail.
projects / gcc.git / commitdiff