2.7.2 -> 2.8.1 cruft: unneeded texi output, obsolete/folded back to g++FAQ

files, renamed file.

6 files changed, 0 insertions, 2158 deletions

diff --git a/gnu/usr.bin/gcc/cp/gpcompare.texi b/gnu/usr.bin/gcc/cp/gpcompare.texi
deleted file mode 100644
index 7b0d573105b..00000000000
--- a/gnu/usr.bin/gcc/cp/gpcompare.texi
+++ /dev/null
@@ -1,236 +0,0 @@
-@node ANSI
-@chapter @sc{gnu} C++ Conformance to @sc{ansi} C++
-
-These changes in the @sc{gnu} C++ compiler were made to comply more
-closely with the @sc{ansi} base document, @cite{The Annotated C++
-Reference Manual} (the @sc{arm}).  Further reducing the divergences from
-@sc{ansi} C++ is a continued goal of the @sc{gnu} C++ Renovation
-Project.
-
-@b{Section 3.4}, @i{Start and Termination}.  It is now invalid to take
-the address of the function @samp{main()}.
-
-@b{Section 4.8}, @i{Pointers to Members}.  The compiler produces
-an error for trying to convert between a pointer to a member and the type
-@samp{void *}.
-
-@b{Section 5.2.5}, @i{Increment and Decrement}.  It is an error to use
-the increment and decrement operators on an enumerated type.
-
-@b{Section 5.3.2}, @i{Sizeof}.  Doing @code{sizeof} on a function is now
-an error.
-
-@b{Section 5.3.4}, @i{Delete}.  The syntax of a @i{cast-expression} is
-now more strictly controlled.
-
-@b{Section 7.1.1}, @i{Storage Class Specifiers}.  Using the
-@code{static} and @code{extern} specifiers can now only be applied to
-names of objects, functions, and anonymous unions.
-
-@b{Section 7.1.1}, @i{Storage Class Specifiers}.  The compiler no longer complains
-about taking the address of a variable which has been declared to have @code{register}
-storage.
-
-@b{Section 7.1.2}, @i{Function Specifiers}.  The compiler produces an
-error when the @code{inline} or @code{virtual} specifiers are
-used on anything other than a function.
-
-@b{Section 8.3}, @i{Function Definitions}.  It is now an error to shadow
-a parameter name with a local variable; in the past, the compiler only
-gave a warning in such a situation.
-
-@b{Section 8.4.1}, @i{Aggregates}.  The rules concerning declaration of
-an aggregate are now all checked in the @sc{gnu} C++ compiler; they
-include having no private or protected members and no base classes.
-
-@b{Section 8.4.3}, @i{References}.  Declaring an array of references is
-now forbidden.  Initializing a reference with an initializer list is
-also considered an error.
-
-@b{Section 9.5}, @i{Unions}.  Global anonymous unions must be declared
-@code{static}.
-
-@b{Section 11.4}, @i{Friends}.  Declaring a member to be a friend of a
-type that has not yet been defined is an error.
-
-@b{Section 12.1}, @i{Constructors}.  The compiler generates a
-default copy constructor for a class if no constructor has been declared.
-
-@ignore
-@b{Section 12.4}, @i{Destructors}.  In accordance with the @sc{ansi} C++
-draft standard working paper, a pure virtual destructor must now be
-defined.
-@end ignore
-
-@b{Section 12.6.2}, @i{Special Member Functions}.  When using a
-@i{mem-initializer} list, the compiler will now initialize class members
-in declaration order, not in the order in which you specify them.
-Also, the compiler enforces the rule that non-static @code{const}
-and reference members must be initialized with a @i{mem-initializer}
-list when their class does not have a constructor.
-
-@b{Section 12.8}, @i{Copying Class Objects}.  The compiler generates
-default copy constructors correctly, and supplies default assignment
-operators compatible with user-defined ones.
-
-@b{Section 13.4}, @i{Overloaded Operators}.  An overloaded operator may
-no longer have default arguments.
-
-@b{Section 13.4.4}, @i{Function Call}.  An overloaded @samp{operator ()}
-must be a non-static member function.
-
-@b{Section 13.4.5}, @i{Subscripting}.  An overloaded @samp{operator []}
-must be a non-static member function.
-
-@b{Section 13.4.6}, @i{Class Member Access}.  An overloaded @samp{operator ->}
-must be a non-static member function.
-
-@b{Section 13.4.7}, @i{Increment and Decrement}.  The compiler will now
-make sure a postfix @samp{@w{operator ++}} or @samp{@w{operator --}} has an
-@code{int} as its second argument.
-
-
-@node Encoding
-@chapter Name Encoding in @sc{gnu} C++
-
-@c FIXME!! rewrite name encoding section
-@c ...to give complete rules rather than diffs from ARM.
-@c To avoid plagiarism, invent some different way of structuring the
-@c description of the rules than what ARM uses.
-
-@cindex mangling
-@cindex name encoding
-@cindex encoding information in names
-In order to support its strong typing rules and the ability to provide
-function overloading, the C++ programming language @dfn{encodes}
-information about functions and objects, so that conflicts across object
-files can be detected during linking. @footnote{This encoding is also
-sometimes called, whimsically enough, @dfn{mangling}; the corresponding
-decoding is sometimes called @dfn{demangling}.} These rules tend to be
-unique to each individual implementation of C++.
-
-The scheme detailed in the commentary for 7.2.1 of @cite{The Annotated
-Reference Manual} offers a description of a possible implementation
-which happens to closely resemble the @code{cfront} compiler.  The
-design used in @sc{gnu} C++ differs from this model in a number of ways:
-
-@itemize @bullet
-@item
-In addition to the basic types @code{void}, @code{char}, @code{short},
-@code{int}, @code{long}, @code{float}, @code{double}, and @code{long
-double}, @sc{gnu} C++ supports two additional types: @code{wchar_t}, the wide
-character type, and @code{long long} (if the host supports it).  The
-encodings for these are @samp{w} and @samp{x} respectively.
-
-@item
-According to the @sc{arm}, qualified names (e.g., @samp{foo::bar::baz}) are
-encoded with a leading @samp{Q}.  Followed by the number of
-qualifications (in this case, three) and the respective names, this
-might be encoded as @samp{Q33foo3bar3baz}.  @sc{gnu} C++ adds a leading
-underscore to the list, producing @samp{_Q33foo3bar3baz}.
- 
-@item
-The operator @samp{*=} is encoded as @samp{__aml}, not @samp{__amu}, to
-match the normal @samp{*} operator, which is encoded as @samp{__ml}.
-
-@c XXX left out ->(), __wr
-@item
-In addition to the normal operators, @sc{gnu} C++ also offers the minimum and
-maximum operators @samp{>?} and @samp{<?}, encoded as @samp{__mx} and
-@samp{__mn}, and the conditional operator @samp{?:}, encoded as @samp{__cn}.
-
-@cindex destructors, encoding of
-@cindex constructors, encoding of
-@item
-Constructors are encoded as simply @samp{__@var{name}}, where @var{name}
-is the encoded name (e.g., @code{3foo} for the @code{foo} class
-constructor).  Destructors are encoded as two leading underscores
-separated by either a period or a dollar sign, depending on the
-capabilities of the local host, followed by the encoded name.  For
-example, the destructor @samp{foo::~foo} is encoded as @samp{_$_3foo}.
-
-@item
-Virtual tables are encoded with a prefix of @samp{_vt}, rather than
-@samp{__vtbl}.  The names of their classes are separated by dollar signs
-(or periods), and not encoded as normal: the virtual table for
-@code{foo} is @samp{__vt$foo}, and the table for @code{foo::bar} is
-named @samp{__vt$foo$bar}.
-
-@item
-Static members are encoded as a leading underscore, followed by the
-encoded name of the class in which they appear, a separating dollar sign
-or period, and finally the unencoded name of the variable.  For example,
-if the class @code{foo} contains a static member @samp{bar}, its
-encoding would be @samp{_3foo$bar}.
-
-@item
-@sc{gnu} C++ is not as aggressive as other compilers when it comes to always
-generating @samp{Fv} for functions with no arguments.  In particular,
-the compiler does not add the sequence to conversion operators.  The
-function @samp{foo::bar()} is encoded as @samp{bar__3foo}, not
-@samp{bar__3fooFv}.
-
-@item
-The argument list for methods is not prefixed by a leading @samp{F}; it
-is considered implied.
-
-@item
-@sc{gnu} C++ approaches the task of saving space in encodings
-differently from that noted in the @sc{arm}.  It does use the
-@samp{T@var{n}} and @samp{N@var{x}@var{y}} codes to signify copying the
-@var{n}th argument's type, and making the next @var{x} arguments be the
-type of the @var{y}th argument, respectively.  However, the values for
-@var{n} and @var{y} begin at zero with @sc{gnu} C++, whereas the
-@sc{arm} describes them as starting at one.  For the function @samp{foo
-(bartype, bartype)}, @sc{gnu} C++ uses @samp{foo__7bartypeT0}, while
-compilers following the @sc{arm} example generate @samp{foo__7bartypeT1}.
-
-@c Note it loses on `foo (int, int, int, int, int)'.
-@item
-@sc{gnu} C++ does not bother using the space-saving methods for types whose
-encoding is a single character (like an integer, encoded as @samp{i}).
-This is useful in the most common cases (two @code{int}s would result in
-using three letters, instead of just @samp{ii}).
-@end itemize
-
-@c @node Cfront
-@c @chapter @code{cfront} Compared to @sc{gnu} C++
-@c 
-@c 
-@c FIXME!! Fill in.  Consider points in the following:
-@c 
-@c @display
-@c Date: Thu, 2 Jan 92 21:35:20 EST
-@c From: raeburn@@cygnus.com
-@c Message-Id: <9201030235.AA10999@@cambridge.cygnus.com>
-@c To: mrs@@charlie.secs.csun.edu
-@c Cc: g++@@cygnus.com
-@c Subject: Re: ARM and GNU C++ incompatabilities
-@c 
-@c Along with that, we should probably describe how g++ differs from
-@c cfront, in ways that the users will notice.  (E.g., cfront supposedly
-@c allows "free (new char[10])"; does g++?  How do the template
-@c implementations differ?  "New" placement syntax?)
-@c @end display
-@c
-@c XXX For next revision.
-@c
-@c GNU C++:
-@c * supports expanding inline functions in many situations,
-@c   including those which have static objects, use `for' statements,
-@c   and other situations.  Part of this versatility is due to is
-@c   ability to not always generate temporaries for assignments.
-@c * deliberately allows divide by 0 and mod 0, since [according
-@c   to Wilson] there are actually situations where you'd like to allow
-@c   such things.  Note on most systems it will cause some sort of trap
-@c   or bus error.  Cfront considers it an error.
-@c * does [appear to] support nested classes within templates.
-@c * conversion functions among baseclasses are all usable by
-@c   a class that's derived from all of those bases.
-@c * sizeof works even when the class is defined within its ()'s
-@c * conditional expressions work with member fns and pointers to
-@c    members.
-@c * can handle non-trivial declarations of variables within switch
-@c   statements.
-@c
-@c Cfront:
diff --git a/gnu/usr.bin/gcc/cp/reno.texi b/gnu/usr.bin/gcc/cp/reno.texi
deleted file mode 100644
index 59c3448a039..00000000000
--- a/gnu/usr.bin/gcc/cp/reno.texi
+++ /dev/null
@@ -1,752 +0,0 @@
-\input texinfo       @c                    -*- Texinfo -*-
-@setfilename reno-1.info
-
-@ifinfo
-@format
-START-INFO-DIR-ENTRY
-* Reno 1: (reno-1).             The GNU C++ Renovation Project, Phase 1.
-END-INFO-DIR-ENTRY
-@end format
-@end ifinfo
-
-@ifinfo
-Copyright @copyright{} 1992, 1993, 1994 Free Software Foundation, Inc.
-
-Permission is granted to make and distribute verbatim copies of
-this manual provided the copyright notice and this permission notice
-are preserved on all copies.
-
-@ignore
-Permission is granted to process this file through TeX and print the
-results, provided the printed document carries a copying permission
-notice identical to this one except for the removal of this paragraph
-(this paragraph not being relevant to the printed manual).
-
-@end ignore
-
-Permission is granted to copy and distribute modified versions of this
-manual under the conditions for verbatim copying, provided also that
-the entire resulting derived work is distributed under the terms of a
-permission notice identical to this one.
-
-Permission is granted to copy and distribute translations of this manual
-into another language, under the above conditions for modified versions.
-@end ifinfo
-
-@setchapternewpage odd
-@settitle GNU C++ Renovation Project
-@c @smallbook
-
-@titlepage
-@finalout
-@title GNU C++ Renovation Project
-@subtitle Phase 1.3
-@author Brendan Kehoe, Jason Merrill,
-@author Mike Stump, Michael Tiemann
-@page
-
-Edited March, 1994 by Roland Pesch (@code{pesch@@cygnus.com})
-@vskip 0pt plus 1filll
-Copyright @copyright{} 1992, 1993, 1994 Free Software Foundation, Inc.
-
-Permission is granted to make and distribute verbatim copies of
-this manual provided the copyright notice and this permission notice
-are preserved on all copies.
-
-@ignore
-Permission is granted to process this file through Tex and print the
-results, provided the printed document carries copying permission
-notice identical to this one except for the removal of this paragraph
-(this paragraph not being relevant to the printed manual).
-@end ignore
-
-Permission is granted to copy and distribute modified versions of this
-manual under the conditions for verbatim copying, provided also that
-the entire resulting derived work is distributed under the terms of a
-permission notice identical to this one.
-
-Permission is granted to copy and distribute translations of this manual
-into another language, under the above conditions for modified versions.
-@end titlepage
-
-@ifinfo
-@node Top
-@top @sc{gnu} C++ Renovation Project
-
-This file describes the goals of the @sc{gnu} C++ Renovation Project,
-and its accomplishments to date (as of Phase 1.3).
-
-It also discusses the remaining divergences from @sc{gnu} C++, and how the
-name encoding in @sc{gnu} C++ differs from the sample encoding in
-@cite{The Annotated C++ Reference Manual}.
-@c This is not a good place to introduce the acronym ARM because it's
-@c info-only. 
-
-@menu
-* Introduction::	What is the GNU C++ Renovation Project?
-* Changes::		Summary of changes since previous GNU C++ releases.
-* Plans::		Plans for Reno-2.
-* Templates::		The template implementation.
-* ANSI::		GNU C++ conformance to ANSI C++.
-* Encoding::		Name encoding in GNU C++.
-@end menu
-
-@end ifinfo
-
-@node Introduction
-@chapter Introduction
-
-As you may remember, @sc{gnu} C++ was the first native-code C++
-compiler available under Unix (December 1987).  In November 1988, it was
-judged superior to the AT&T compiler in a Unix World review.  In 1990 it
-won a Sun Observer ``Best-Of'' award.  But now, with new requirements
-coming out of the @sc{ansi} C++ committee and a growing backlog of bugs, it's
-clear that @sc{gnu} C++ needs an overhaul.
-
-The C++ language has been under development since 1982.  It has
-evolved significantly since its original incarnation (C with Classes),
-addressing many commercial needs and incorporating many lessons
-learned as more and more people started using ``object-oriented''
-programming techniques.  In 1989, the first X3J16 committee meeting
-was held in Washington DC; in the interest of users, C++ was going to
-be standardized.
-
-As C++ has become more popular, more demands have been placed on its
-compilers.  Some compilers are up to the demands, others are not.
-@sc{gnu} C++ was used to prototype several features which have since
-been incorporated into the standard, most notably exception handling.
-While @sc{gnu} C++ has been an excellent experimental vehicle, it did
-not have the resources that AT&T, Borland, or Microsoft have at their
-disposal.
-
-We believe that @sc{gnu} C++ is an important compiler, providing users with
-many of the features that have made @sc{gnu} C so popular: fast compilation,
-good error messages, innovative features, and full sources that may be
-freely redistributed.  The purpose of this overhaul, dubbed the @var{@sc{gnu}
-C++ Renovation Project}, is to take advantage of the functionality that
-@sc{gnu} C++ offers today, to strengthen its base technology, and put it in a
-position to remain---as other @sc{gnu} software currently is---the technical
-leader in the field.
-
-This release represents the latest phase of work in strengthening the
-compiler on a variety of points.  It includes many months of
-work concentrated on fixing many of the more egregious bugs that
-presented themselves in the compiler recently.
-@ignore
-@c FIXME-- update?
-Nearly 85% of all bugs reported in the period of February to September
-of 1992 were fixed as part of the work in the first phase.
-@end ignore
-In the coming months, we hope to continue expanding and enhancing the
-quality and dependability of the industry's only freely redistributable
-C++ compiler.
-
-@node Changes
-@chapter Changes in Behavior in @sc{gnu} C++
-
-The @sc{gnu} C++ compiler continues to improve and change.  A major goal
-of our work has been to continue to bring the compiler into compliance
-with the draft @sc{ansi} C++ standard, and with @cite{The Annotated C++
-Reference Manual} (the @sc{arm}).  This section outlines most of the
-user-noticeable changes that might be encountered during the normal
-course of use.
-
-@menu
-* Summary of Phase 1.3::
-* Major changes::
-* New features::
-* Enhancements and bug fixes::
-* Problems with debugging::
-@end menu
-
-@node Summary of Phase 1.3
-@section Summary of Changes in Phase 1.3
-
-The bulk of this note discusses the cumulative effects of the @sc{gnu} C++
-Renovation Project to date.  The work during its most recent phase (1.3)
-had these major effects:
-
-@itemize @bullet
-@item The standard compiler driver @code{g++} is now the faster compiled
-version, rather than a shell script.
-
-@item Nested types work much better; notably, nesting is no longer
-restricted to nine levels.
-
-@item Better @sc{arm} conformance on member access control.
-
-@item The compiler now always generates default assignment operators
-(@samp{operator =}), copy constructors (@samp{X::X(X&)}), and default
-constructors (@samp{X::X()}) whenever they are required.
-
-@item The new draft @sc{ansi} standard keyword @code{mutable} is supported.
-
-@item @samp{-fansi-overloading} is the default, to comply better with
-the @sc{arm} (at some cost in compatibility to earlier versions of @sc{gnu} C++).
-
-@item More informative error messages.
-
-@item System include files are automatically treated as if they were
-wrapped in @samp{extern "C" @{ @}}.
-
-@item The new option @samp{-falt-external-templates} provides alternate
-template instantiation semantics.
-
-@item Operator declarations are now checked more strictly.
-
-@item You can now use template type arguments in the template parameter list.
-
-@item You can call the destructor for any type.
-
-@item The compiler source code is better organized.
-
-@item You can specify where to instantiate template definitions explicitly.
-@end itemize
-
-Much of the work in Phase 1.3 went to elimination of known bugs, as well
-as the major items above.
-
-During the span of Phase 1.3, there were also two changes associated
-with the compiler that, while not specifically part of the C++
-Renovation project, may be of interest:
-
-@itemize @bullet
-@item @code{gcov}, a code coverage tool for @sc{gnu cc}, is now available
-from Cygnus Support.  (@code{gcov} is free software, but the @sc{fsf} has not
-yet accepted it.)  @xref{Gcov,, @code{gcov}: a Test Coverage Program,
-gcc.info, Using GNU CC}, for more information (in Cygnus releases of
-that manual).
-
-@item @sc{gnu} C++ now supports @dfn{signatures}, a language extension to
-provide more flexibility in abstract type definitions.  @xref{C++
-Signatures,, Type Abstraction using Signatures, gcc.info, Using GNU CC}.
-@end itemize
-
-@node Major changes
-@section Major Changes
-
-This release includes four wholesale rewrites of certain areas of
-compiler functionality:
-
-@enumerate 1
-@item Argument matching.  @sc{gnu} C++ is more compliant with the rules
-described in Chapter 13, ``Overloading'', of the @sc{arm}.  This behavior is
-the default, though you can specify it explicitly with
-@samp{-fansi-overloading}.   For compatibility with earlier releases of
-@sc{gnu} C++, specify @samp{-fno-ansi-overloading}; this makes the compiler
-behave as it used to with respect to argument matching and name overloading.
-
-@item Default constructors/destructors.  Section 12.8 of the @sc{arm}, ``Copying
-Class Objects'', and Section 12.1, ``Constructors'', state that a
-compiler must declare such default functions if the user does not
-specify them.  @sc{gnu} C++ now declares, and generates when necessary,
-the defaults for constructors and destructors you might omit.  In
-particular, assignment operators (@samp{operator =}) behave the same way
-whether you define them, or whether the compiler generates them by
-default; taking the address of the default @samp{operator =} is now
-guaranteed to work.  Default copy constructors (@samp{X::X(X&)}) now
-function correctly, rather than calling the copy assignment operator for
-the base class.  Finally, constructors (@samp{X::X()}), as well as
-assignment operators and copy constructors, are now available whenever
-they are required.
-
-@c XXX This may be taken out eventually...
-@item Binary incompatibility.  There are no new binary incompatibilities
-in Phase 1.3, but Phase 1.2 introduced two binary incompatibilities with
-earlier releases.  First, the functionality of @samp{operator
-new} and @samp{operator delete} changed.  Name encoding
-(``mangling'') of virtual table names changed as well.  Libraries
-built with versions of the compiler earlier than Phase 1.2 must be
-compiled with the new compiler.  (This includes the Cygnus Q2
-progressive release and the FSF 2.4.5 release.)
-
-@item New @code{g++} driver.
-A new binary @code{g++} compiler driver replaces the shell script.
-The new driver executes faster.
-@end enumerate
-
-@node New features
-@section New features
-
-@itemize @bullet
-@item
-The compiler warns when a class contains only private constructors
-or destructors, and has no friends.  At the request of some of our
-customers, we have added a new option, @samp{-Wctor-dtor-privacy} (on by
-default), and its negation, @samp{-Wno-ctor-dtor-privacy}, to control
-the emission of this warning.  If, for example, you are working towards
-making your code compile warning-free, you can use @w{@samp{-Wall
--Wno-ctor-dtor-privacy}} to find the most common warnings.
-
-@item
-There is now a mechanism which controls exactly when templates are
-expanded, so that you can reduce memory usage and program size and also
-instantiate them exactly once.  You can control this mechanism with the
-option @samp{-fexternal-templates} and its corresponding negation
-@samp{-fno-external-templates}.  Without this feature, space consumed by
-template instantiations can grow unacceptably in large-scale projects
-with many different source files.  The default is
-@samp{-fno-external-templates}.
-
-You do not need to use the @samp{-fexternal-templates} option when
-compiling a file that does not define and instantiate templates used in
-other files, even if those files @emph{are} compiled with
-@samp{-fexternal-templates}.  The only side effect is an increase in
-object size for each file that was compiled without
-@samp{-fexternal-templates}.
-
-When your code is compiled with @samp{-fexternal-templates}, all
-template instantiations are external; this requires that the templates
-be under the control of @samp{#pragma interface} and @samp{#pragma
-implementation}.  All instantiations that will be needed should be in
-the implementation file; you can do this with a @code{typedef} that
-references the instantiation needed.  Conversely, when you compile using
-the option @samp{-fno-external-templates}, all template instantiations are
-explicitly internal.
-
-@samp{-fexternal-templates} also allows you to finally separate class
-template function definitions from their declarations, thus speeding up
-compilation times for every file that includes the template declaration.
-Now you can have tens or even hundreds of lines in template
-declarations, and thousands or tens of thousands of lines in template
-definitions, with the definitions only going through the compiler once
-instead of once for each source file.  It is important to note that you
-must remember to externally instantiate @emph{all} templates that are
-used from template declarations in interface files.  If you forget to do
-this, unresolved externals will occur.
-
-In the example below, the object file generated (@file{example.o}) will
-contain the global instantiation for @samp{Stack<int>}.  If other types
-of @samp{Stack} are needed, they can be added to @file{example.cc} or
-placed in a new file, in the same spirit as @file{example.cc}.
-
-@code{foo.h}:
-@smallexample
-@group
-#pragma interface "foo.h"
-template<class T>
-class Stack @{
-  static int statc;
-  static T statc2;
-  Stack() @{ @}
-  virtual ~Stack() @{ @}
-  int bar();
-@};
-@end group
-@end smallexample
-
-@code{example.cc}:
-@smallexample
-@group
-#pragma implementation "foo.h"
-#include "foo.h"
-
-typedef Stack<int> t;
-int Stack<int>::statc;
-int Stack<int>::statc2;
-int Stack<int>::bar() @{ @}
-@end group
-@end smallexample
-
-Note that using @samp{-fexternal-templates} does not reduce memory usage
-from completely different instantiations (@samp{Stack<Name>} vs.
-@samp{Stack<Net_Connection>}), but only collapses different occurrences
-of @samp{Stack<Name>} so that only one @samp{Stack<Name>} is generated.
-
-@samp{-falt-external-templates} selects a slight variation in the
-semantics described above (incidentally, you need not specify both
-options; @samp{-falt-external-templates} implies
-@samp{-fexternal-templates}).  
-
-With @samp{-fexternal-templates}, the compiler emits a definition in the
-implementation file that includes the header definition, @emph{even if}
-instantiation is triggered from a @emph{different} implementation file
-(e.g. with a template that uses another template).
-
-With @samp{-falt-external-templates}, the definition always goes in the
-implementation file that triggers instantiation.
-
-For instance, with these two header files---
-
-@example
-@exdent @file{a.h}:
-#pragma interface
-template <class T> class A @{ @dots{} @};
-
-@exdent @file{b.h}:
-#pragma interface
-class B @{ @dots{} @};
-void f (A<B>);
-@end example
-
-Under @samp{-fexternal-templates}, the definition of @samp{A<B>} ends up
-in the implementation file that includes @file{a.h}.  Under
-@samp{-falt-external-templates}, the same definition ends up in the
-implementation file that includes @file{b.h}.
-
-@item
-You can control explicitly where a template is instantiated, without
-having to @emph{use} the template to get an instantiation.  
-
-To instantiate a class template explicitly, write @samp{template
-class @var{name}<paramvals>}, where @var{paramvals} is a list of values
-for the template parameters.  For example, you might write
-
-@example
-template class A<int>
-@end example
-
-Similarly, to instantiate a function template explicitly, write
-@samp{template @var{fnsign}} where @var{fnsign} is the particular
-function signature you need.  For example, you might write
-
-@example
-template void foo (int, int)
-@end example
-
-This syntax for explicit template instantiation agrees with recent
-extensions to the draft @sc{ansi} standard.
-
-@item
-The compiler's actions on @sc{ansi}-related warnings and errors have
-been further enhanced.  The @samp{-pedantic-errors} option produces
-error messages in a number of new situations: using @code{return} in a
-non-@code{void} function (one returning a value); declaring a local
-variable that shadows a parameter (e.g., the function takes an argument
-@samp{a}, and has a local variable @samp{a}); and use of the @samp{asm}
-keyword.  Finally, the compiler by default now issues a warning when
-converting from an @code{int} to an enumerated type.  This is likely to
-cause many new warnings in code that hadn't triggered them before.  For
-example, when you compile this code,
-
-@smallexample
-@group
-enum boolean @{ false, true @};
-void
-f ()
-@{
-  boolean x;
-
-  x = 1; //@i{assigning an @code{int} to an @code{enum} now triggers a warning}
-@}
-@end group
-@end smallexample
-
-@noindent
-you should see the warning ``@code{anachronistic conversion from integer
-type to enumeral type `boolean'}''.  Instead of assigning the value 1,
-assign the original enumerated value @samp{true}.
-@end itemize
-
-@node Enhancements and bug fixes
-@section Enhancements and bug fixes
-
-@itemize @bullet
-@cindex nested types in template parameters
-@item
-You can now use nested types in a template parameter list, even if the nested
-type is defined within the same class that attempts to use the template.
-For example, given a template @code{list}, the following now works:
-
-@smallexample
-struct glyph @{
-  @dots{}
-  struct stroke @{ @dots{} @};
-  list<stroke> l;
-  @dots{}
-@}
-@end smallexample
-
-@cindex function pointers vs template parameters
-@item
-Function pointers now work in template parameter lists.  For
-example, you might want to instantiate a parameterized @code{list} class
-in terms of a pointer to a function like this:
-
-@smallexample
-list<int (*)(int, void *)> fnlist;
-@end smallexample
-
-@item
-@c FIXME!  Really no limit?  Jason said "deeper than 9" now OK...
-Nested types are now handled correctly.  In particular, there is no
-longer a limit to how deeply you can nest type definitions.
-
-@item
-@sc{gnu} C++ now conforms to the specifications in Chapter 11 of the
-@sc{arm}, ``Member Access Control''.
-
-@item
-The @sc{ansi} C++ committee has introduced a new keyword @code{mutable}.
-@sc{gnu} C++ supports it.  Use @code{mutable} to specify that some
-particular members of a @code{const} class are @emph{not} constant.  For
-example, you can use this to include a cache in a data structure that
-otherwise represents a read-only database.
-
-@item
-Error messages now explicitly specify the declaration, type, or
-expression that contains an error.
-
-@item
-To avoid copying and editing all system include files during @sc{gnu}
-C++ installation, the compiler now automatically recognizes system
-include files as C language definitions, as if they were wrapped in
-@samp{extern "C" @{ @dots{} @}}.
-
-@item
-The compiler checks operator declarations more strictly.  For example,
-you may no longer declare an @samp{operator +} with three arguments.
-
-@item
-You can now use template type arguments in the same template
-parameter list where the type argument is specified (as well as in the
-template body).  For example, you may write
-
-@example
-template <class T, T t> class A @{ @dots{} @};
-@end example
-
-@item
-Destructors are now available for all types, even built-in ones; for
-example, you can call @samp{int::~int}.  (Destructors for types like
-@code{int} do not actually do anything, but their existence provides a
-level of generality that permits smooth template expansion in more
-cases.)
-
-@item
-Enumerated types declared inside a class are now handled correctly.
-
-@item
-An argument list for a function may not use an initializer list for its default
-value.  For example, @w{@samp{void foo ( T x = @{ 1, 2 @} )}} is not permitted.
-
-@item
-A significant amount of work went into improving the ability of the
-compiler to act accurately on multiple inheritance and virtual
-functions.  Virtual function dispatch has been enhanced as well.
-
-@item
-The warning concerning a virtual inheritance environment with a
-non-virtual destructor has been disabled, since it is not clear that
-such a warning is warranted.
-
-@item
-Until exception handling is fully implemented in the Reno-2 release, use
-of the identifiers @samp{catch}, @samp{throw}, or @samp{try} results
-in the warning:
-
-@smallexample
-t.C:1: warning: `catch', `throw', and `try' 
-       are all C++ reserved words
-@end smallexample
-
-@item
-When giving a warning or error concerning initialization of a member in a
-class, the compiler gives the name of the member if it has one.
-
-@item
-Detecting friendship between classes is more accurately checked.
-
-@item
-The syntaxes of @w{@samp{#pragma implementation "file.h"}} and
-@samp{#pragma interface} are now more strictly controlled.  The compiler
-notices (and warns) when any text follows @file{file.h} in the
-implementation pragma, or follows the word @samp{interface}.  Any such
-text is otherwise ignored.
-
-@item
-Trying to declare a template on a variable or type is now considered an
-error, not an unimplemented feature.
-
-@item
-When an error occurs involving a template, the compiler attempts to
-tell you at which point of instantiation the error occurred, in
-addition to noting the line in the template declaration which had the
-actual error.
-
-@item
-The symbol names for function templates in the resulting assembly file
-are now encoded according to the arguments, rather than just being
-emitted as, for example, two definitions of a function @samp{foo}.
-
-@item
-Template member functions that are declared @code{static} no longer
-receive a @code{this} pointer.
-
-@item
-Case labels are no longer allowed to have commas to make up their
-expressions.
-
-@item
-Warnings concerning the shift count of a left or right shift now tell
-you if it was a @samp{left} or @samp{right} shift.
-
-@item
-The compiler now warns when a decimal constant is so large that it
-becomes @code{unsigned}.
-
-@item
-Union initializers which are raw constructors are now handled properly.
-
-@item
-The compiler no longer gives incorrect errors when initializing a
-union with an empty initializer list.
-
-@item
-Anonymous unions are now correctly used when nested inside a class.
-
-@item
-Anonymous unions declared as static class members are now handled
-properly.
-
-@item
-The compiler now notices when a field in a class is declared both as
-a type and a non-type.
-
-@item
-The compiler now warns when a user-defined function shadows a
-built-in function, rather than emitting an error.
-
-@item
-A conflict between two function declarations now produces an error
-regardless of their language context.
-
-@item
-Duplicate definitions of variables with @samp{extern "C"} linkage are no
-longer considered in error.  (Note in C++ linkage---the default---you may
-not have more than one definition of a variable.)
-
-@item
-Referencing a label that is not defined in any function is now an error.
-
-@item
-The syntax for pointers to methods has been improved; there are still
-some minor bugs, but a number of cases should now be accepted by the
-compiler.
-
-@item
-In error messages, arguments are now numbered starting at 1, instead of
-0.  Therefore, in the function @samp{void foo (int a, int b)}, the
-argument @samp{a} is argument 1, and @samp{b} is argument 2.  There is
-no longer an argument 0.
-
-@item
-The tag for an enumerator, rather than its value, used as a default
-argument is now shown in all error messages.  For example, @w{@samp{void
-foo (enum x (= true))}} is shown instead of @w{@samp{void foo (enum x (=
-1))}}.
-
-@item
-The @samp{__asm__} keyword is now accepted by the C++ front-end.
-
-@item
-Expressions of the form @samp{foo->~Class()} are now handled properly.
-
-@item
-The compiler now gives better warnings for situations which result in
-integer overflows (e.g., in storage sizes, enumerators, unary
-expressions, etc).
-
-@item
-@code{unsigned} bitfields are now promoted to @code{signed int} if the
-field isn't as wide as an @code{int}.
-
-@item
-Declaration and usage of prefix and postfix @samp{operator ++} and
-@samp{operator --} are now handled correctly.  For example,
-
-@smallexample
-@group
-class foo
-@{
-public:
-  operator ++ ();
-  operator ++ (int);
-  operator -- ();
-  operator -- (int);
-@};
-
-void
-f (foo *f)
-@{
-  f++;          // @i{call @code{f->operator++(int)}}
-  ++f;          // @i{call @code{f->operator++()}}
-  f--;          // @i{call @code{f->operator++(int)}}
-  --f;          // @i{call @code{f->operator++()}}
-@}
-@end group
-@end smallexample
-
-@item
-In accordance with @sc{arm} section 10.1.1, ambiguities and dominance are now
-handled properly.  The rules described in section 10.1.1 are now fully
-implemented. 
-
-@end itemize
-
-@node Problems with debugging
-@section Problems with debugging
-
-Two problems remain with regard to debugging:
-
-@itemize @bullet
-@item
-Debugging of anonymous structures on the IBM RS/6000 host is incorrect.
-
-@item
-Symbol table size is overly large due to redundant symbol information;
-this can make @code{gdb} coredump under certain circumstances.  This
-problem is not host-specific.
-@end itemize
-
-@node Plans
-@chapter Plans for Reno-2
-
-The overall goal for the second phase of the @sc{gnu} C++ Renovation
-Project is to bring @sc{gnu} C++ to a new level of reliability, quality,
-and competitiveness.  As particular elements of this strategy, we intend
-to:
-
-@enumerate 0
-@item
-Fully implement @sc{ansi} exception handling.
-
-@item
-With the exception handling, add Runtime Type Identification
-(@sc{rtti}), if the @sc{ansi} committee adopts it into the standard.
-
-@item
-Bring the compiler into closer compliance with the @sc{arm} and the draft
-@sc{ansi} standard, and document what points in the @sc{arm} we do not yet comply,
-or agree, with.
-
-@item
-Add further support for the @sc{dwarf} debugging format.
-
-@item
-Finish the work to make the compiler compliant with @sc{arm} Section 12.6.2,
-initializing base classes in declaration order, rather than in the order
-that you specify them in a @var{mem-initializer} list.
-
-@item
-Perform a full coverage analysis on the compiler, and weed out unused
-code, for a gain in performance and a reduction in the size of the compiler.
-
-@item
-Further improve the multiple inheritance implementation in the
-compiler to make it cleaner and more complete.
-@end enumerate
-
-@noindent
-As always, we encourage you to make suggestions and ask questions about
-@sc{gnu} C++ as a whole, so we can be sure that the end of this project
-will bring a compiler that everyone will find essential for C++ and will
-meet the needs of the world's C++ community.
-
-@include templates.texi
-
-@include gpcompare.texi
-
-@contents
-
-@bye
diff --git a/gnu/usr.bin/gcc/cp/templates.texi b/gnu/usr.bin/gcc/cp/templates.texi
deleted file mode 100644
index 2a6db07f42b..00000000000
--- a/gnu/usr.bin/gcc/cp/templates.texi
+++ /dev/null
@@ -1,235 +0,0 @@
-@node Templates
-@chapter The Template Implementation
-
-@cindex templates
-@cindex function templates
-@cindex class templates
-@cindex parameterized types
-@cindex types, parameterized
-The C++ template@footnote{Class templates are also known as
-@dfn{parameterized types}.} facility, which effectively allows use of
-variables for types in declarations, is one of the newest features of
-the language.
-
-@sc{gnu} C++ is one of the first compilers to implement many
-of the template facilities currently defined by the @sc{ansi} committee.
-
-Nevertheless, the template implementation is not yet complete.  This
-chapter maps the current limitations of the @sc{gnu} C++ template
-implementation.
-
-@menu
-* Template limitations:: Limitations for function and class templates
-* Function templates::   Limitations for function templates
-* Class templates::      Limitations for class templates
-* Template debugging::   Debugging information for templates
-@end menu
-
-@node Template limitations
-@section Limitations for function and class templates
-
-@cindex template limitations
-@cindex template bugs
-@cindex bugs, templates
-These limitations apply to any use of templates (function templates or
-class templates) with @sc{gnu} C++:
-
-@table @emph
-@item Template definitions must be visible
-When you compile code with templates, the template definitions must come
-first (before the compiler needs to expand them), and template
-definitions you use must be visible in the current scope.
-@c FIXME! Is this a defined property of templates, rather than a
-@c temporary limitation?
-@c ANSWER: It's a limitation, but it's hard to say why it's a limitation
-@c to someone.  We need an infinite link-cycle, in one camp, to
-@c accomplish things so you don't need the template definitions around.
-
-@cindex static data in template classes
-@cindex template classes, static data in
-@item Individual initializers needed for static data
-Templates for static data in template classes do not work.  @xref{Class
-templates,,Limitations for class templates}.
-@end table
-
-@node Function templates
-@section Limitations for function templates
-
-@cindex function template limitations
-Function templates are implemented for the most part.  The compiler can
-correctly determine template parameter values, and will delay
-instantiation of a function that uses templates until the requisite type
-information is available.
-
-@noindent
-The following limitations remain: 
-
-@itemize @bullet
-@cindex template vs declaration, functions
-@cindex declaration vs template, functions
-@cindex function declaration vs template
-@item
-Narrowed specification: function declarations should not prevent
-template expansion.  When you declare a function, @sc{gnu} C++
-interprets the declaration as an indication that you will provide a
-definition for that function.  Therefore, @sc{gnu} C++ does not use a
-template expansion if there is also an applicable declaration.  @sc{gnu}
-C++ only expands the template when there is no such declaration.
-
-The specification in Bjarne Stroustrup's @cite{The C++ Programming
-Language, Second Edition} is narrower, and the @sc{gnu} C++
-implementation is now clearly incorrect.  With this new specification, a
-declaration that corresponds to an instantiation of a function template
-only affects whether conversions are needed to use that version of the
-function.  It should no longer prevent expansion of the template
-definition.
-
-For example, this code fragment must be treated differently:
-
-@smallexample
-template <class X> X min (X& x1, X& x2) @{ @dots{} @}
-int min (int, int);
-@dots{}
-int i; short s;
-min (i, s); // @r{should call} min(int,int)
-            // @r{derived from template}
-@dots{}
-@end smallexample
-
-@item
-The compiler does not yet understand function signatures where types are
-nested within template parameters.  For example, a function like the
-following produces a syntax error on the closing @samp{)} of the
-definition of the function @code{f}:
-
-@smallexample
-template <class T> class A @{ public: T x; class Y @{@}; @};
-template <class X> int f (A<X>::Y y) @{ @dots{} @}
-@end smallexample
-
-@cindex @code{inline} and function templates
-@cindex function templates and @code{inline}
-@item
-If you declare an @code{inline} function using templates, the compiler
-can only inline the code @emph{after} the first time you use
-that function with whatever particular type signature the template
-was instantiated.
-
-Removing this limitation is akin to supporting nested function
-definitions in @sc{gnu} C++; the limitation will probably remain until the
-more general problem of nested functions is solved.
-
-@item
-All the @emph{method} templates (templates for member functions) for a
-class must be visible to the compiler when the class template is
-instantiated. 
-@end itemize
-
-@node Class templates
-@section Limitations for class templates
-
-@cindex class template limitations
-@ignore
-FIXME!!  Include a comprehensible version of this if someone can explain it.
-         (Queried Brendan and Raeburn w/full orig context, 26may1993---pesch)
-   - [RHP: I don't understand what the following fragment refers to.  If it's
-     the "BIG BUG" section in the original, why does it say "overriding class
-     declarations" here when the more detailed text refers to *function*
-     declarations?  Here's the fragment I don't understand:] 
-     there are problems with user-supplied overriding class declarations (see
-     below). 
-@end ignore
-
-@itemize @bullet
-@ignore
-@cindex static data, not working in templates
-@item
-Templates for static data in template classes do not work.
-Currently, you must initialize each case of such data
-individually. 
-@c FIXME!! Brendan to see if still true.
-@c ANSWER: This section presumes that it's incorrect to have to
-@c initialize for each type you instantiate with.  It's not, it's the
-@c right way to do it.
-@end ignore
-
-Unfortunately, individual initializations of this sort are likely to be
-considered errors eventually; since they're needed now, you might want to
-flag places where you use them with comments to mark the need for a
-future transition.
-
-@cindex nested type results vs templates
-@item
-Member functions in template classes may not have results of nested
-type; @sc{gnu} C++ signals a syntax error on the attempt.  The following
-example illustrates this problem with an @code{enum} type @code{alph}:
-
-@smallexample
-template <class T> class list @{
-  @dots{}
-  enum alph @{a,b,c@};
-  alph bar();
-  @dots{}
-@};
-
-template <class T>
-list<int>::alph list<int>::bar()  // @i{Syntax error here}
-@{
-@dots{}
-@}
-@end smallexample
-
-@cindex preprocessor conditionals in templates
-@cindex conditionals (preprocessor) in templates
-@item
-A parsing bug makes it difficult to use preprocessor conditionals within
-templates.  For example, in this code:
-
-@smallexample
-template <class T>
-class list @{
-  @dots{}
-#ifdef SYSWRONG
-  T x;
-#endif
-  @dots{}
-@}
-@end smallexample
-
-The preprocessor output leaves sourcefile line number information (lines
-like @samp{# 6 "foo.cc"} when it expands the @code{#ifdef} block.  These
-lines confuse the compiler while parsing templates, giving a syntax
-error.
-
-If you cannot avoid preprocessor conditionals in templates, you can
-suppress the line number information using the @samp{-P} preprocessor
-option (but this will make debugging more difficult), by compiling the
-affected modules like this:
-
-@smallexample
-g++ -P foo.cc -o foo
-@end smallexample
-
-@cindex parsing errors, templates
-@item
-Parsing errors are reported when templates are first
-@emph{instantiated}---not on the template definition itself.  In
-particular, if you do not instantiate a template definition at all, the
-compiler never reports any parsing errors that may be in the template
-definition.
-@end itemize
-
-@node Template debugging
-@section Debugging information for templates
-
-@cindex templates and debugging information
-@cindex debugging information and templates
-Debugging information for templates works for some object code formats,
-but not others.  It works for stabs@footnote{Except that insufficient
-debugging information for methods of template classes is generated in
-stabs.} (used primarily in @sc{a.out} object code, but also in the Solaris 2
-version of @sc{elf}), and the @sc{mips} version of @sc{coff} debugging
-format.
-
-@sc{dwarf} support is currently minimal, and requires further
-development.
diff --git a/gnu/usr.bin/gcc/cp/tree.def b/gnu/usr.bin/gcc/cp/tree.def
deleted file mode 100644
index 82b7954e29c..00000000000
--- a/gnu/usr.bin/gcc/cp/tree.def
+++ /dev/null
@@ -1,116 +0,0 @@
-/* This file contains the definitions and documentation for the
-   additional tree codes used in the GNU C++ compiler (see tree.def
-   for the standard codes).
-   Copyright (C) 1987, 1988, 1990, 1993 Free Software Foundation, Inc.
-   Hacked by Michael Tiemann (tiemann@cygnus.com)
-
-This file is part of GNU CC.
-
-GNU CC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
-
-GNU CC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING.  If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.  */
-
- 
-/* Reference to the contents of an offset
-   (a value whose type is an OFFSET_TYPE).
-   Operand 0 is the object within which the offset is taken.
-   Operand 1 is the offset.  The language independent OFFSET_REF
-   just won't work for us.  */
-DEFTREECODE (CP_OFFSET_REF, "cp_offset_ref", "r", 2)
-
-/* For DELETE_EXPR, operand 0 is the store to be destroyed.
-   Operand 1 is the value to pass to the destroying function
-   saying whether the store should be deallocated as well.  */
-DEFTREECODE (DELETE_EXPR, "dl_expr", "e", 2)
-DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", "e", 2)
-
-/* For a UNSAVE_EXPR, operand 0 is the value to unsave.  By unsave, we
-   mean that all _EXPRs such as TARGET_EXPRs, SAVE_EXPRs,
-   WITH_CLEANUP_EXPRs, CALL_EXPRs and RTL_EXPRs, that are protected
-   from being evaluated more than once should be reset so that a new
-   expand_expr call of this expr will cause those to be re-evaluated.
-   This is useful when we want to reuse a tree in different places,
-   but where we must re-expand.  */
-DEFTREECODE (UNSAVE_EXPR, "unsave_expr", "e", 1)
-
-/* Value is reference to particular overloaded class method.
-   Operand 0 is the class name (an IDENTIFIER_NODE);
-   operand 1 is the field (also an IDENTIFIER_NODE).
-   The COMPLEXITY field holds the class level (usually 0).  */
-DEFTREECODE (SCOPE_REF, "scope_ref", "r", 2)
-
-/* When composing an object with a member, this is the result.
-   Operand 0 is the object.  Operand 1 is the member (usually
-   a dereferenced pointer to member).  */
-DEFTREECODE (MEMBER_REF, "member_ref", "r", 2)
-
-/* Type conversion operator in C++.  TREE_TYPE is type that this
-   operator converts to.  Operand is expression to be converted.  */
-DEFTREECODE (TYPE_EXPR, "type_expr", "e", 1)
-
-/* For CPLUS_NEW_EXPR, operand 0 is function which performs initialization,
-   operand 1 is argument list to initialization function,
-   and operand 2 is the slot which was allocated for this expression.  */
-DEFTREECODE (NEW_EXPR, "nw_expr", "e", 3)
-DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", "e", 3)
-
-/* A throw expression.  operand 0 is the expression, if there was one,
-   else it is NULL_TREE.  */
-DEFTREECODE (THROW_EXPR, "throw_expr", "e", 1)
-
-/* Template definition.  The following fields have the specified uses,
-   although there are other macros in cp-tree.h that should be used for
-   accessing this data.
-        DECL_ARGUMENTS          template parm vector
-        DECL_TEMPLATE_INFO      template text &c
-	DECL_VINDEX		list of instantiations already produced;
-				only done for functions so far
-   For class template:
-        DECL_INITIAL            associated templates (methods &c)
-        DECL_RESULT             null
-   For non-class templates:
-	TREE_TYPE		type of object to be constructed
-        DECL_RESULT             decl for object to be created
-                                (e.g., FUNCTION_DECL with tmpl parms used)
- */
-DEFTREECODE (TEMPLATE_DECL, "template_decl", "d", 0)
-
-/* Index into a template parameter list.  This parameter must be a type.
-   Use TYPE_FIELDS to find parmlist and index.  */
-DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", "t", 0)
-
-/* Index into a template parameter list.  This parameter must not be a
-   type.  */
-DEFTREECODE (TEMPLATE_CONST_PARM, "template_const_parm", "c", 2)
-
-/* For uninstantiated parameterized types.
-        TYPE_VALUES     tree list:
-                TREE_PURPOSE    template decl
-                TREE_VALUE      parm vector
-                TREE_CHAIN      null
-   Other useful fields to be defined later.  */
-DEFTREECODE (UNINSTANTIATED_P_TYPE, "uninstantiated_p_type", "t", 0)
-
-/* A thunk is a stub function.
-
-   Thunks are used to implement multiple inheritance:
-   At run-time, such a thunk subtracts THUNK_DELTA (an int, not a tree)
-   from the this pointer, and then jumps to DECL_INITIAL
-   (which is an ADDR_EXPR whose operand is a FUNCTION_DECL).
-
-   Other kinds of thunks may be defined later. */
-DEFTREECODE (THUNK_DECL, "thunk_decl", "d", 0)
-
-/* A namespace declaration.  */
-DEFTREECODE (NAMESPACE_DECL, "namespace_decl", "d", 0)
diff --git a/gnu/usr.bin/gcc/cpp.aux b/gnu/usr.bin/gcc/cpp.aux
deleted file mode 100644
index be541303739..00000000000
--- a/gnu/usr.bin/gcc/cpp.aux
+++ /dev/null
@@ -1,132 +0,0 @@
-'xrdef {Top-title}{The C Preprocessor}
-'xrdef {Top-pg}{1}
-'xrdef {Top-snt}{Chapter'tie1}
-'xrdef {Global Actions-title}{Transformations Made Globally}
-'xrdef {Global Actions-pg}{1}
-'xrdef {Global Actions-snt}{Section'tie1.1}
-'xrdef {Commands-title}{Preprocessor Commands}
-'xrdef {Commands-pg}{3}
-'xrdef {Commands-snt}{Section'tie1.2}
-'xrdef {Header Files-title}{Header Files}
-'xrdef {Header Files-pg}{3}
-'xrdef {Header Files-snt}{Section'tie1.3}
-'xrdef {Header Uses-title}{Uses of Header Files}
-'xrdef {Header Uses-pg}{4}
-'xrdef {Header Uses-snt}{Section'tie1.3.1}
-'xrdef {Include Syntax-title}{The \samp {#include} Command}
-'xrdef {Include Syntax-pg}{4}
-'xrdef {Include Syntax-snt}{Section'tie1.3.2}
-'xrdef {Include Operation-title}{How \samp {#include} Works}
-'xrdef {Include Operation-pg}{5}
-'xrdef {Include Operation-snt}{Section'tie1.3.3}
-'xrdef {Once-Only-title}{Once-Only Include Files}
-'xrdef {Once-Only-pg}{6}
-'xrdef {Once-Only-snt}{Section'tie1.3.4}
-'xrdef {Inheritance-title}{Inheritance and Header Files}
-'xrdef {Inheritance-pg}{8}
-'xrdef {Inheritance-snt}{Section'tie1.3.5}
-'xrdef {Macros-title}{Macros}
-'xrdef {Macros-pg}{9}
-'xrdef {Macros-snt}{Section'tie1.4}
-'xrdef {Simple Macros-title}{Simple Macros}
-'xrdef {Simple Macros-pg}{9}
-'xrdef {Simple Macros-snt}{Section'tie1.4.1}
-'xrdef {Argument Macros-title}{Macros with Arguments}
-'xrdef {Argument Macros-pg}{10}
-'xrdef {Argument Macros-snt}{Section'tie1.4.2}
-'xrdef {Predefined-title}{Predefined Macros}
-'xrdef {Predefined-pg}{13}
-'xrdef {Predefined-snt}{Section'tie1.4.3}
-'xrdef {Standard Predefined-title}{Standard Predefined Macros}
-'xrdef {Standard Predefined-pg}{13}
-'xrdef {Standard Predefined-snt}{Section'tie1.4.3.1}
-'xrdef {Nonstandard Predefined-title}{Nonstandard Predefined Macros}
-'xrdef {Nonstandard Predefined-pg}{15}
-'xrdef {Nonstandard Predefined-snt}{Section'tie1.4.3.2}
-'xrdef {Stringification-title}{Stringification}
-'xrdef {Stringification-pg}{17}
-'xrdef {Stringification-snt}{Section'tie1.4.4}
-'xrdef {Concatenation-title}{Concatenation}
-'xrdef {Concatenation-pg}{18}
-'xrdef {Concatenation-snt}{Section'tie1.4.5}
-'xrdef {Undefining-title}{Undefining Macros}
-'xrdef {Undefining-pg}{20}
-'xrdef {Undefining-snt}{Section'tie1.4.6}
-'xrdef {Redefining-title}{Redefining Macros}
-'xrdef {Redefining-pg}{20}
-'xrdef {Redefining-snt}{Section'tie1.4.7}
-'xrdef {Macro Pitfalls-title}{Pitfalls and Subtleties of Macros}
-'xrdef {Macro Pitfalls-pg}{21}
-'xrdef {Macro Pitfalls-snt}{Section'tie1.4.8}
-'xrdef {Misnesting-title}{Improperly Nested Constructs}
-'xrdef {Misnesting-pg}{21}
-'xrdef {Misnesting-snt}{Section'tie1.4.8.1}
-'xrdef {Macro Parentheses-title}{Unintended Grouping of Arithmetic}
-'xrdef {Macro Parentheses-pg}{22}
-'xrdef {Macro Parentheses-snt}{Section'tie1.4.8.2}
-'xrdef {Swallow Semicolon-title}{Swallowing the Semicolon}
-'xrdef {Swallow Semicolon-pg}{23}
-'xrdef {Swallow Semicolon-snt}{Section'tie1.4.8.3}
-'xrdef {Side Effects-title}{Duplication of Side Effects}
-'xrdef {Side Effects-pg}{24}
-'xrdef {Side Effects-snt}{Section'tie1.4.8.4}
-'xrdef {Self-Reference-title}{Self-Referential Macros}
-'xrdef {Self-Reference-pg}{25}
-'xrdef {Self-Reference-snt}{Section'tie1.4.8.5}
-'xrdef {Argument Prescan-title}{Separate Expansion of Macro Arguments}
-'xrdef {Argument Prescan-pg}{26}
-'xrdef {Argument Prescan-snt}{Section'tie1.4.8.6}
-'xrdef {Cascaded Macros-title}{Cascaded Use of Macros}
-'xrdef {Cascaded Macros-pg}{29}
-'xrdef {Cascaded Macros-snt}{Section'tie1.4.8.7}
-'xrdef {Newlines in Args-title}{Newlines in Macro Arguments}
-'xrdef {Newlines in Args-pg}{30}
-'xrdef {Newlines in Args-snt}{Section'tie1.4.9}
-'xrdef {Conditionals-title}{Conditionals}
-'xrdef {Conditionals-pg}{30}
-'xrdef {Conditionals-snt}{Section'tie1.5}
-'xrdef {Conditional Uses-title}{Why Conditionals are Used}
-'xrdef {Conditional Uses-pg}{31}
-'xrdef {Conditional Uses-snt}{Section'tie1.5.1}
-'xrdef {Conditional Syntax-title}{Syntax of Conditionals}
-'xrdef {Conditional Syntax-pg}{31}
-'xrdef {Conditional Syntax-snt}{Section'tie1.5.2}
-'xrdef {#if Command-title}{The \samp {#if} Command}
-'xrdef {#if Command-pg}{31}
-'xrdef {#if Command-snt}{Section'tie1.5.2.1}
-'xrdef {#else Command-title}{The \samp {#else} Command}
-'xrdef {#else Command-pg}{32}
-'xrdef {#else Command-snt}{Section'tie1.5.2.2}
-'xrdef {#elif Command-title}{The \samp {#elif} Command}
-'xrdef {#elif Command-pg}{33}
-'xrdef {#elif Command-snt}{Section'tie1.5.2.3}
-'xrdef {Deleted Code-title}{Keeping Deleted Code for Future Reference}
-'xrdef {Deleted Code-pg}{34}
-'xrdef {Deleted Code-snt}{Section'tie1.5.3}
-'xrdef {Conditionals-Macros-title}{Conditionals and Macros}
-'xrdef {Conditionals-Macros-pg}{34}
-'xrdef {Conditionals-Macros-snt}{Section'tie1.5.4}
-'xrdef {Assertions-title}{Assertions}
-'xrdef {Assertions-pg}{36}
-'xrdef {Assertions-snt}{Section'tie1.5.5}
-'xrdef {#error Command-title}{The \samp {#error} and \samp {#warning} Commands}
-'xrdef {#error Command-pg}{38}
-'xrdef {#error Command-snt}{Section'tie1.5.6}
-'xrdef {Combining Sources-title}{Combining Source Files}
-'xrdef {Combining Sources-pg}{39}
-'xrdef {Combining Sources-snt}{Section'tie1.6}
-'xrdef {Other Commands-title}{Miscellaneous Preprocessor Commands}
-'xrdef {Other Commands-pg}{40}
-'xrdef {Other Commands-snt}{Section'tie1.7}
-'xrdef {Output-title}{C Preprocessor Output}
-'xrdef {Output-pg}{41}
-'xrdef {Output-snt}{Section'tie1.8}
-'xrdef {Invocation-title}{Invoking the C Preprocessor}
-'xrdef {Invocation-pg}{41}
-'xrdef {Invocation-snt}{Section'tie1.9}
-'xrdef {Concept Index-title}{Concept Index}
-'xrdef {Concept Index-pg}{47}
-'xrdef {Concept Index-snt}{}
-'xrdef {Index-title}{Index of Commands, Macros and Options}
-'xrdef {Index-pg}{49}
-'xrdef {Index-snt}{}
diff --git a/gnu/usr.bin/gcc/gcc.aux b/gnu/usr.bin/gcc/gcc.aux
deleted file mode 100644
index f3be753b249..00000000000
--- a/gnu/usr.bin/gcc/gcc.aux
+++ /dev/null
@@ -1,687 +0,0 @@
-'xrdef {Copying-title}{GNU GENERAL PUBLIC LICENSE}
-'xrdef {Copying-pg}{1}
-'xrdef {Copying-snt}{}
-'xrdef {Contributors-title}{Contributors to GNU CC}
-'xrdef {Contributors-pg}{9}
-'xrdef {Contributors-snt}{}
-'xrdef {Funding-title}{Funding Free Software}
-'xrdef {Funding-pg}{11}
-'xrdef {Funding-snt}{Chapter'tie1}
-'xrdef {Look and Feel-title}{Protect Your Freedom---Fight ``Look And Feel''}
-'xrdef {Look and Feel-pg}{13}
-'xrdef {Look and Feel-snt}{Chapter'tie2}
-'xrdef {G++ and GCC-title}{Compile C, C++, or Objective C}
-'xrdef {G++ and GCC-pg}{17}
-'xrdef {G++ and GCC-snt}{Chapter'tie3}
-'xrdef {Invoking GCC-title}{GNU CC Command Options}
-'xrdef {Invoking GCC-pg}{19}
-'xrdef {Invoking GCC-snt}{Chapter'tie4}
-'xrdef {Option Summary-title}{Option Summary}
-'xrdef {Option Summary-pg}{19}
-'xrdef {Option Summary-snt}{Section'tie4.1}
-'xrdef {Overall Options-title}{Options Controlling the Kind of Output}
-'xrdef {Overall Options-pg}{24}
-'xrdef {Overall Options-snt}{Section'tie4.2}
-'xrdef {Invoking G++-title}{Compiling C++ Programs}
-'xrdef {Invoking G++-pg}{26}
-'xrdef {Invoking G++-snt}{Section'tie4.3}
-'xrdef {C Dialect Options-title}{Options Controlling C Dialect}
-'xrdef {C Dialect Options-pg}{27}
-'xrdef {C Dialect Options-snt}{Section'tie4.4}
-'xrdef {C++ Dialect Options-title}{Options Controlling C++ Dialect}
-'xrdef {C++ Dialect Options-pg}{31}
-'xrdef {C++ Dialect Options-snt}{Section'tie4.5}
-'xrdef {Warning Options-title}{Options to Request or Suppress Warnings}
-'xrdef {Warning Options-pg}{35}
-'xrdef {Warning Options-snt}{Section'tie4.6}
-'xrdef {Debugging Options-title}{Options for Debugging Your Program or GNU CC}
-'xrdef {Debugging Options-pg}{41}
-'xrdef {Debugging Options-snt}{Section'tie4.7}
-'xrdef {Optimize Options-title}{Options That Control Optimization}
-'xrdef {Optimize Options-pg}{45}
-'xrdef {Optimize Options-snt}{Section'tie4.8}
-'xrdef {Preprocessor Options-title}{Options Controlling the Preprocessor}
-'xrdef {Preprocessor Options-pg}{49}
-'xrdef {Preprocessor Options-snt}{Section'tie4.9}
-'xrdef {Assembler Options-title}{Passing Options to the Assembler}
-'xrdef {Assembler Options-pg}{52}
-'xrdef {Assembler Options-snt}{Section'tie4.10}
-'xrdef {Link Options-title}{Options for Linking}
-'xrdef {Link Options-pg}{52}
-'xrdef {Link Options-snt}{Section'tie4.11}
-'xrdef {Directory Options-title}{Options for Directory Search}
-'xrdef {Directory Options-pg}{54}
-'xrdef {Directory Options-snt}{Section'tie4.12}
-'xrdef {Target Options-title}{Specifying Target Machine and Compiler Version}
-'xrdef {Target Options-pg}{55}
-'xrdef {Target Options-snt}{Section'tie4.13}
-'xrdef {Submodel Options-title}{Hardware Models and Configurations}
-'xrdef {Submodel Options-pg}{57}
-'xrdef {Submodel Options-snt}{Section'tie4.14}
-'xrdef {M680x0 Options-title}{M680x0 Options}
-'xrdef {M680x0 Options-pg}{57}
-'xrdef {M680x0 Options-snt}{Section'tie4.14.1}
-'xrdef {VAX Options-title}{VAX Options}
-'xrdef {VAX Options-pg}{59}
-'xrdef {VAX Options-snt}{Section'tie4.14.2}
-'xrdef {SPARC Options-title}{SPARC Options}
-'xrdef {SPARC Options-pg}{59}
-'xrdef {SPARC Options-snt}{Section'tie4.14.3}
-'xrdef {Convex Options-title}{Convex Options}
-'xrdef {Convex Options-pg}{62}
-'xrdef {Convex Options-snt}{Section'tie4.14.4}
-'xrdef {AMD29K Options-title}{AMD29K Options}
-'xrdef {AMD29K Options-pg}{63}
-'xrdef {AMD29K Options-snt}{Section'tie4.14.5}
-'xrdef {ARM Options-title}{ARM Options}
-'xrdef {ARM Options-pg}{64}
-'xrdef {ARM Options-snt}{Section'tie4.14.6}
-'xrdef {M88K Options-title}{M88K Options}
-'xrdef {M88K Options-pg}{65}
-'xrdef {M88K Options-snt}{Section'tie4.14.7}
-'xrdef {RS/6000 and PowerPC Options-title}{IBM RS/6000 and PowerPC Options}
-'xrdef {RS/6000 and PowerPC Options-pg}{68}
-'xrdef {RS/6000 and PowerPC Options-snt}{Section'tie4.14.8}
-'xrdef {RT Options-title}{IBM RT Options}
-'xrdef {RT Options-pg}{72}
-'xrdef {RT Options-snt}{Section'tie4.14.9}
-'xrdef {MIPS Options-title}{MIPS Options}
-'xrdef {MIPS Options-pg}{73}
-'xrdef {MIPS Options-snt}{Section'tie4.14.10}
-'xrdef {i386 Options-title}{Intel 386 Options}
-'xrdef {i386 Options-pg}{76}
-'xrdef {i386 Options-snt}{Section'tie4.14.11}
-'xrdef {HPPA Options-title}{HPPA Options}
-'xrdef {HPPA Options-pg}{78}
-'xrdef {HPPA Options-snt}{Section'tie4.14.12}
-'xrdef {Intel 960 Options-title}{Intel 960 Options}
-'xrdef {Intel 960 Options-pg}{80}
-'xrdef {Intel 960 Options-snt}{Section'tie4.14.13}
-'xrdef {DEC Alpha Options-title}{DEC Alpha Options}
-'xrdef {DEC Alpha Options-pg}{81}
-'xrdef {DEC Alpha Options-snt}{Section'tie4.14.14}
-'xrdef {Clipper Options-title}{Clipper Options}
-'xrdef {Clipper Options-pg}{82}
-'xrdef {Clipper Options-snt}{Section'tie4.14.15}
-'xrdef {H8/300 Options-title}{H8/300 Options}
-'xrdef {H8/300 Options-pg}{82}
-'xrdef {H8/300 Options-snt}{Section'tie4.14.16}
-'xrdef {System V Options-title}{Options for System V}
-'xrdef {System V Options-pg}{82}
-'xrdef {System V Options-snt}{Section'tie4.14.17}
-'xrdef {Code Gen Options-title}{Options for Code Generation Conventions}
-'xrdef {Code Gen Options-pg}{83}
-'xrdef {Code Gen Options-snt}{Section'tie4.15}
-'xrdef {Environment Variables-title}{Environment Variables Affecting GNU CC}
-'xrdef {Environment Variables-pg}{86}
-'xrdef {Environment Variables-snt}{Section'tie4.16}
-'xrdef {Running Protoize-title}{Running Protoize}
-'xrdef {Running Protoize-pg}{87}
-'xrdef {Running Protoize-snt}{Section'tie4.17}
-'xrdef {Installation-title}{Installing GNU CC}
-'xrdef {Installation-pg}{91}
-'xrdef {Installation-snt}{Chapter'tie5}
-'xrdef {Configurations-title}{Configurations Supported by GNU CC}
-'xrdef {Configurations-pg}{97}
-'xrdef {Configurations-snt}{Section'tie5.1}
-'xrdef {Other Dir-title}{Compilation in a Separate Directory}
-'xrdef {Other Dir-pg}{111}
-'xrdef {Other Dir-snt}{Section'tie5.2}
-'xrdef {Cross-Compiler-title}{Building and Installing a Cross-Compiler}
-'xrdef {Cross-Compiler-pg}{112}
-'xrdef {Cross-Compiler-snt}{Section'tie5.3}
-'xrdef {Steps of Cross-title}{Steps of Cross-Compilation}
-'xrdef {Steps of Cross-pg}{113}
-'xrdef {Steps of Cross-snt}{Section'tie5.3.1}
-'xrdef {Configure Cross-title}{Configuring a Cross-Compiler}
-'xrdef {Configure Cross-pg}{113}
-'xrdef {Configure Cross-snt}{Section'tie5.3.2}
-'xrdef {Tools and Libraries-title}{Tools and Libraries for a Cross-Compiler}
-'xrdef {Tools and Libraries-pg}{113}
-'xrdef {Tools and Libraries-snt}{Section'tie5.3.3}
-'xrdef {Cross Runtime-title}{\file {libgcc.a} and Cross-Compilers}
-'xrdef {Cross Runtime-pg}{115}
-'xrdef {Cross Runtime-snt}{Section'tie5.3.4}
-'xrdef {Cross Headers-title}{Cross-Compilers and Header Files}
-'xrdef {Cross Headers-pg}{116}
-'xrdef {Cross Headers-snt}{Section'tie5.3.5}
-'xrdef {Build Cross-title}{Actually Building the Cross-Compiler}
-'xrdef {Build Cross-pg}{117}
-'xrdef {Build Cross-snt}{Section'tie5.3.6}
-'xrdef {Sun Install-title}{Installing GNU CC on the Sun}
-'xrdef {Sun Install-pg}{118}
-'xrdef {Sun Install-snt}{Section'tie5.4}
-'xrdef {VMS Install-title}{Installing GNU CC on VMS}
-'xrdef {VMS Install-pg}{119}
-'xrdef {VMS Install-snt}{Section'tie5.5}
-'xrdef {Collect2-title}{\code {collect2}}
-'xrdef {Collect2-pg}{122}
-'xrdef {Collect2-snt}{Section'tie5.6}
-'xrdef {Header Dirs-title}{Standard Header File Directories}
-'xrdef {Header Dirs-pg}{123}
-'xrdef {Header Dirs-snt}{Section'tie5.7}
-'xrdef {C Extensions-title}{Extensions to the C Language Family}
-'xrdef {C Extensions-pg}{125}
-'xrdef {C Extensions-snt}{Chapter'tie6}
-'xrdef {Statement Exprs-title}{Statements and Declarations in Expressions}
-'xrdef {Statement Exprs-pg}{125}
-'xrdef {Statement Exprs-snt}{Section'tie6.1}
-'xrdef {Local Labels-title}{Locally Declared Labels}
-'xrdef {Local Labels-pg}{126}
-'xrdef {Local Labels-snt}{Section'tie6.2}
-'xrdef {Labels as Values-title}{Labels as Values}
-'xrdef {Labels as Values-pg}{127}
-'xrdef {Labels as Values-snt}{Section'tie6.3}
-'xrdef {Nested Functions-title}{Nested Functions}
-'xrdef {Nested Functions-pg}{128}
-'xrdef {Nested Functions-snt}{Section'tie6.4}
-'xrdef {Constructing Calls-title}{Constructing Function Calls}
-'xrdef {Constructing Calls-pg}{131}
-'xrdef {Constructing Calls-snt}{Section'tie6.5}
-'xrdef {Naming Types-title}{Naming an Expression's Type}
-'xrdef {Naming Types-pg}{131}
-'xrdef {Naming Types-snt}{Section'tie6.6}
-'xrdef {Typeof-title}{Referring to a Type with \code {typeof}}
-'xrdef {Typeof-pg}{132}
-'xrdef {Typeof-snt}{Section'tie6.7}
-'xrdef {Lvalues-title}{Generalized Lvalues}
-'xrdef {Lvalues-pg}{133}
-'xrdef {Lvalues-snt}{Section'tie6.8}
-'xrdef {Conditionals-title}{Conditionals with Omitted Operands}
-'xrdef {Conditionals-pg}{134}
-'xrdef {Conditionals-snt}{Section'tie6.9}
-'xrdef {Long Long-title}{Double-Word Integers}
-'xrdef {Long Long-pg}{135}
-'xrdef {Long Long-snt}{Section'tie6.10}
-'xrdef {Complex-title}{Complex Numbers}
-'xrdef {Complex-pg}{135}
-'xrdef {Complex-snt}{Section'tie6.11}
-'xrdef {Zero Length-title}{Arrays of Length Zero}
-'xrdef {Zero Length-pg}{136}
-'xrdef {Zero Length-snt}{Section'tie6.12}
-'xrdef {Variable Length-title}{Arrays of Variable Length}
-'xrdef {Variable Length-pg}{137}
-'xrdef {Variable Length-snt}{Section'tie6.13}
-'xrdef {Macro Varargs-title}{Macros with Variable Numbers of Arguments}
-'xrdef {Macro Varargs-pg}{138}
-'xrdef {Macro Varargs-snt}{Section'tie6.14}
-'xrdef {Subscripting-title}{Non-Lvalue Arrays May Have Subscripts}
-'xrdef {Subscripting-pg}{139}
-'xrdef {Subscripting-snt}{Section'tie6.15}
-'xrdef {Pointer Arith-title}{Arithmetic on \code {void}- and Function-Pointers}
-'xrdef {Pointer Arith-pg}{139}
-'xrdef {Pointer Arith-snt}{Section'tie6.16}
-'xrdef {Initializers-title}{Non-Constant Initializers}
-'xrdef {Initializers-pg}{140}
-'xrdef {Initializers-snt}{Section'tie6.17}
-'xrdef {Constructors-title}{Constructor Expressions}
-'xrdef {Constructors-pg}{140}
-'xrdef {Constructors-snt}{Section'tie6.18}
-'xrdef {Labeled Elements-title}{Labeled Elements in Initializers}
-'xrdef {Labeled Elements-pg}{141}
-'xrdef {Labeled Elements-snt}{Section'tie6.19}
-'xrdef {Case Ranges-title}{Case Ranges}
-'xrdef {Case Ranges-pg}{143}
-'xrdef {Case Ranges-snt}{Section'tie6.20}
-'xrdef {Cast to Union-title}{Cast to a Union Type}
-'xrdef {Cast to Union-pg}{143}
-'xrdef {Cast to Union-snt}{Section'tie6.21}
-'xrdef {Function Attributes-title}{Declaring Attributes of Functions}
-'xrdef {Function Attributes-pg}{144}
-'xrdef {Function Attributes-snt}{Section'tie6.22}
-'xrdef {Function Prototypes-title}{Prototypes and Old-Style Function Definitions}
-'xrdef {Function Prototypes-pg}{148}
-'xrdef {Function Prototypes-snt}{Section'tie6.23}
-'xrdef {Dollar Signs-title}{Dollar Signs in Identifier Names}
-'xrdef {Dollar Signs-pg}{149}
-'xrdef {Dollar Signs-snt}{Section'tie6.24}
-'xrdef {Character Escapes-title}{The Character \key {ESC} in Constants}
-'xrdef {Character Escapes-pg}{149}
-'xrdef {Character Escapes-snt}{Section'tie6.25}
-'xrdef {Alignment-title}{Inquiring on Alignment of Types or Variables}
-'xrdef {Alignment-pg}{150}
-'xrdef {Alignment-snt}{Section'tie6.26}
-'xrdef {Variable Attributes-title}{Specifying Attributes of Variables}
-'xrdef {Variable Attributes-pg}{150}
-'xrdef {Variable Attributes-snt}{Section'tie6.27}
-'xrdef {Type Attributes-title}{Specifying Attributes of Types}
-'xrdef {Type Attributes-pg}{153}
-'xrdef {Type Attributes-snt}{Section'tie6.28}
-'xrdef {Inline-title}{An Inline Function is As Fast As a Macro}
-'xrdef {Inline-pg}{156}
-'xrdef {Inline-snt}{Section'tie6.29}
-'xrdef {Extended Asm-title}{Assembler Instructions with C Expression Operands}
-'xrdef {Extended Asm-pg}{157}
-'xrdef {Extended Asm-snt}{Section'tie6.30}
-'xrdef {Asm Labels-title}{Controlling Names Used in Assembler Code}
-'xrdef {Asm Labels-pg}{161}
-'xrdef {Asm Labels-snt}{Section'tie6.31}
-'xrdef {Explicit Reg Vars-title}{Variables in Specified Registers}
-'xrdef {Explicit Reg Vars-pg}{162}
-'xrdef {Explicit Reg Vars-snt}{Section'tie6.32}
-'xrdef {Global Reg Vars-title}{Defining Global Register Variables}
-'xrdef {Global Reg Vars-pg}{163}
-'xrdef {Global Reg Vars-snt}{Section'tie6.32.1}
-'xrdef {Local Reg Vars-title}{Specifying Registers for Local Variables}
-'xrdef {Local Reg Vars-pg}{164}
-'xrdef {Local Reg Vars-snt}{Section'tie6.32.2}
-'xrdef {Alternate Keywords-title}{Alternate Keywords}
-'xrdef {Alternate Keywords-pg}{165}
-'xrdef {Alternate Keywords-snt}{Section'tie6.33}
-'xrdef {Incomplete Enums-title}{Incomplete \code {enum} Types}
-'xrdef {Incomplete Enums-pg}{166}
-'xrdef {Incomplete Enums-snt}{Section'tie6.34}
-'xrdef {Function Names-title}{Function Names as Strings}
-'xrdef {Function Names-pg}{166}
-'xrdef {Function Names-snt}{Section'tie6.35}
-'xrdef {C++ Extensions-title}{Extensions to the C++ Language}
-'xrdef {C++ Extensions-pg}{169}
-'xrdef {C++ Extensions-snt}{Chapter'tie7}
-'xrdef {Naming Results-title}{Named Return Values in C++}
-'xrdef {Naming Results-pg}{169}
-'xrdef {Naming Results-snt}{Section'tie7.1}
-'xrdef {Min and Max-title}{Minimum and Maximum Operators in C++}
-'xrdef {Min and Max-pg}{171}
-'xrdef {Min and Max-snt}{Section'tie7.2}
-'xrdef {Destructors and Goto-title}{\code {goto} and Destructors in GNU C++}
-'xrdef {Destructors and Goto-pg}{172}
-'xrdef {Destructors and Goto-snt}{Section'tie7.3}
-'xrdef {C++ Interface-title}{Declarations and Definitions in One Header}
-'xrdef {C++ Interface-pg}{172}
-'xrdef {C++ Interface-snt}{Section'tie7.4}
-'xrdef {Template Instantiation-title}{Where's the Template?}
-'xrdef {Template Instantiation-pg}{174}
-'xrdef {Template Instantiation-snt}{Section'tie7.5}
-'xrdef {C++ Signatures-title}{Type Abstraction using Signatures}
-'xrdef {C++ Signatures-pg}{176}
-'xrdef {C++ Signatures-snt}{Section'tie7.6}
-'xrdef {Trouble-title}{Known Causes of Trouble with GNU CC}
-'xrdef {Trouble-pg}{179}
-'xrdef {Trouble-snt}{Chapter'tie8}
-'xrdef {Actual Bugs-title}{Actual Bugs We Haven't Fixed Yet}
-'xrdef {Actual Bugs-pg}{179}
-'xrdef {Actual Bugs-snt}{Section'tie8.1}
-'xrdef {Installation Problems-title}{Installation Problems}
-'xrdef {Installation Problems-pg}{179}
-'xrdef {Installation Problems-snt}{Section'tie8.2}
-'xrdef {Cross-Compiler Problems-title}{Cross-Compiler Problems}
-'xrdef {Cross-Compiler Problems-pg}{184}
-'xrdef {Cross-Compiler Problems-snt}{Section'tie8.3}
-'xrdef {Interoperation-title}{Interoperation}
-'xrdef {Interoperation-pg}{185}
-'xrdef {Interoperation-snt}{Section'tie8.4}
-'xrdef {External Bugs-title}{Problems Compiling Certain Programs}
-'xrdef {External Bugs-pg}{189}
-'xrdef {External Bugs-snt}{Section'tie8.5}
-'xrdef {Incompatibilities-title}{Incompatibilities of GNU CC}
-'xrdef {Incompatibilities-pg}{190}
-'xrdef {Incompatibilities-snt}{Section'tie8.6}
-'xrdef {Fixed Headers-title}{Fixed Header Files}
-'xrdef {Fixed Headers-pg}{193}
-'xrdef {Fixed Headers-snt}{Section'tie8.7}
-'xrdef {Standard Libraries-title}{Standard Libraries}
-'xrdef {Standard Libraries-pg}{194}
-'xrdef {Standard Libraries-snt}{Section'tie8.8}
-'xrdef {Disappointments-title}{Disappointments and Misunderstandings}
-'xrdef {Disappointments-pg}{194}
-'xrdef {Disappointments-snt}{Section'tie8.9}
-'xrdef {C++ Misunderstandings-title}{Common Misunderstandings with GNU C++}
-'xrdef {C++ Misunderstandings-pg}{196}
-'xrdef {C++ Misunderstandings-snt}{Section'tie8.10}
-'xrdef {Static Definitions-title}{Declare \emph {and} Define Static Members}
-'xrdef {Static Definitions-pg}{196}
-'xrdef {Static Definitions-snt}{Section'tie8.10.1}
-'xrdef {Temporaries-title}{Temporaries May Vanish Before You Expect}
-'xrdef {Temporaries-pg}{197}
-'xrdef {Temporaries-snt}{Section'tie8.10.2}
-'xrdef {Protoize Caveats-title}{Caveats of using \code {protoize}}
-'xrdef {Protoize Caveats-pg}{198}
-'xrdef {Protoize Caveats-snt}{Section'tie8.11}
-'xrdef {Non-bugs-title}{Certain Changes We Don't Want to Make}
-'xrdef {Non-bugs-pg}{199}
-'xrdef {Non-bugs-snt}{Section'tie8.12}
-'xrdef {Warnings and Errors-title}{Warning Messages and Error Messages}
-'xrdef {Warnings and Errors-pg}{202}
-'xrdef {Warnings and Errors-snt}{Section'tie8.13}
-'xrdef {Bugs-title}{Reporting Bugs}
-'xrdef {Bugs-pg}{203}
-'xrdef {Bugs-snt}{Chapter'tie9}
-'xrdef {Bug Criteria-title}{Have You Found a Bug?}
-'xrdef {Bug Criteria-pg}{203}
-'xrdef {Bug Criteria-snt}{Section'tie9.1}
-'xrdef {Bug Lists-title}{Where to Report Bugs}
-'xrdef {Bug Lists-pg}{204}
-'xrdef {Bug Lists-snt}{Section'tie9.2}
-'xrdef {Bug Reporting-title}{How to Report Bugs}
-'xrdef {Bug Reporting-pg}{205}
-'xrdef {Bug Reporting-snt}{Section'tie9.3}
-'xrdef {Sending Patches-title}{Sending Patches for GNU CC}
-'xrdef {Sending Patches-pg}{209}
-'xrdef {Sending Patches-snt}{Section'tie9.4}
-'xrdef {Service-title}{How To Get Help with GNU CC}
-'xrdef {Service-pg}{213}
-'xrdef {Service-snt}{Chapter'tie10}
-'xrdef {VMS-title}{Using GNU CC on VMS}
-'xrdef {VMS-pg}{215}
-'xrdef {VMS-snt}{Chapter'tie11}
-'xrdef {Include Files and VMS-title}{Include Files and VMS}
-'xrdef {Include Files and VMS-pg}{215}
-'xrdef {Include Files and VMS-snt}{Section'tie11.1}
-'xrdef {Global Declarations-title}{Global Declarations and VMS}
-'xrdef {Global Declarations-pg}{216}
-'xrdef {Global Declarations-snt}{Section'tie11.2}
-'xrdef {VMS Misc-title}{Other VMS Issues}
-'xrdef {VMS Misc-pg}{219}
-'xrdef {VMS Misc-snt}{Section'tie11.3}
-'xrdef {Portability-title}{GNU CC and Portability}
-'xrdef {Portability-pg}{221}
-'xrdef {Portability-snt}{Chapter'tie12}
-'xrdef {Interface-title}{Interfacing to GNU CC Output}
-'xrdef {Interface-pg}{223}
-'xrdef {Interface-snt}{Chapter'tie13}
-'xrdef {Passes-title}{Passes and Files of the Compiler}
-'xrdef {Passes-pg}{225}
-'xrdef {Passes-snt}{Chapter'tie14}
-'xrdef {RTL-title}{RTL Representation}
-'xrdef {RTL-pg}{231}
-'xrdef {RTL-snt}{Chapter'tie15}
-'xrdef {RTL Objects-title}{RTL Object Types}
-'xrdef {RTL Objects-pg}{231}
-'xrdef {RTL Objects-snt}{Section'tie15.1}
-'xrdef {Accessors-title}{Access to Operands}
-'xrdef {Accessors-pg}{232}
-'xrdef {Accessors-snt}{Section'tie15.2}
-'xrdef {Flags-title}{Flags in an RTL Expression}
-'xrdef {Flags-pg}{235}
-'xrdef {Flags-snt}{Section'tie15.3}
-'xrdef {Machine Modes-title}{Machine Modes}
-'xrdef {Machine Modes-pg}{238}
-'xrdef {Machine Modes-snt}{Section'tie15.4}
-'xrdef {Constants-title}{Constant Expression Types}
-'xrdef {Constants-pg}{242}
-'xrdef {Constants-snt}{Section'tie15.5}
-'xrdef {Regs and Memory-title}{Registers and Memory}
-'xrdef {Regs and Memory-pg}{244}
-'xrdef {Regs and Memory-snt}{Section'tie15.6}
-'xrdef {Arithmetic-title}{RTL Expressions for Arithmetic}
-'xrdef {Arithmetic-pg}{248}
-'xrdef {Arithmetic-snt}{Section'tie15.7}
-'xrdef {Comparisons-title}{Comparison Operations}
-'xrdef {Comparisons-pg}{251}
-'xrdef {Comparisons-snt}{Section'tie15.8}
-'xrdef {Bit Fields-title}{Bit Fields}
-'xrdef {Bit Fields-pg}{253}
-'xrdef {Bit Fields-snt}{Section'tie15.9}
-'xrdef {Conversions-title}{Conversions}
-'xrdef {Conversions-pg}{253}
-'xrdef {Conversions-snt}{Section'tie15.10}
-'xrdef {RTL Declarations-title}{Declarations}
-'xrdef {RTL Declarations-pg}{254}
-'xrdef {RTL Declarations-snt}{Section'tie15.11}
-'xrdef {Side Effects-title}{Side Effect Expressions}
-'xrdef {Side Effects-pg}{255}
-'xrdef {Side Effects-snt}{Section'tie15.12}
-'xrdef {Incdec-title}{Embedded Side-Effects on Addresses}
-'xrdef {Incdec-pg}{259}
-'xrdef {Incdec-snt}{Section'tie15.13}
-'xrdef {Assembler-title}{Assembler Instructions as Expressions}
-'xrdef {Assembler-pg}{260}
-'xrdef {Assembler-snt}{Section'tie15.14}
-'xrdef {Insns-title}{Insns}
-'xrdef {Insns-pg}{261}
-'xrdef {Insns-snt}{Section'tie15.15}
-'xrdef {Calls-title}{RTL Representation of Function-Call Insns}
-'xrdef {Calls-pg}{269}
-'xrdef {Calls-snt}{Section'tie15.16}
-'xrdef {Sharing-title}{Structure Sharing Assumptions}
-'xrdef {Sharing-pg}{271}
-'xrdef {Sharing-snt}{Section'tie15.17}
-'xrdef {Reading RTL-title}{Reading RTL}
-'xrdef {Reading RTL-pg}{272}
-'xrdef {Reading RTL-snt}{Section'tie15.18}
-'xrdef {Machine Desc-title}{Machine Descriptions}
-'xrdef {Machine Desc-pg}{273}
-'xrdef {Machine Desc-snt}{Chapter'tie16}
-'xrdef {Patterns-title}{Everything about Instruction Patterns}
-'xrdef {Patterns-pg}{273}
-'xrdef {Patterns-snt}{Section'tie16.1}
-'xrdef {Example-title}{Example of \code {define_insn}}
-'xrdef {Example-pg}{274}
-'xrdef {Example-snt}{Section'tie16.2}
-'xrdef {RTL Template-title}{RTL Template}
-'xrdef {RTL Template-pg}{275}
-'xrdef {RTL Template-snt}{Section'tie16.3}
-'xrdef {Output Template-title}{Output Templates and Operand Substitution}
-'xrdef {Output Template-pg}{279}
-'xrdef {Output Template-snt}{Section'tie16.4}
-'xrdef {Output Statement-title}{C Statements for Assembler Output}
-'xrdef {Output Statement-pg}{281}
-'xrdef {Output Statement-snt}{Section'tie16.5}
-'xrdef {Constraints-title}{Operand Constraints}
-'xrdef {Constraints-pg}{283}
-'xrdef {Constraints-snt}{Section'tie16.6}
-'xrdef {Simple Constraints-title}{Simple Constraints}
-'xrdef {Simple Constraints-pg}{283}
-'xrdef {Simple Constraints-snt}{Section'tie16.6.1}
-'xrdef {Multi-Alternative-title}{Multiple Alternative Constraints}
-'xrdef {Multi-Alternative-pg}{287}
-'xrdef {Multi-Alternative-snt}{Section'tie16.6.2}
-'xrdef {Class Preferences-title}{Register Class Preferences}
-'xrdef {Class Preferences-pg}{288}
-'xrdef {Class Preferences-snt}{Section'tie16.6.3}
-'xrdef {Modifiers-title}{Constraint Modifier Characters}
-'xrdef {Modifiers-pg}{289}
-'xrdef {Modifiers-snt}{Section'tie16.6.4}
-'xrdef {Machine Constraints-title}{Constraints for Particular Machines}
-'xrdef {Machine Constraints-pg}{290}
-'xrdef {Machine Constraints-snt}{Section'tie16.6.5}
-'xrdef {No Constraints-title}{Not Using Constraints}
-'xrdef {No Constraints-pg}{295}
-'xrdef {No Constraints-snt}{Section'tie16.6.6}
-'xrdef {Standard Names-title}{Standard Pattern Names For Generation}
-'xrdef {Standard Names-pg}{296}
-'xrdef {Standard Names-snt}{Section'tie16.7}
-'xrdef {Pattern Ordering-title}{When the Order of Patterns Matters}
-'xrdef {Pattern Ordering-pg}{306}
-'xrdef {Pattern Ordering-snt}{Section'tie16.8}
-'xrdef {Dependent Patterns-title}{Interdependence of Patterns}
-'xrdef {Dependent Patterns-pg}{306}
-'xrdef {Dependent Patterns-snt}{Section'tie16.9}
-'xrdef {Jump Patterns-title}{Defining Jump Instruction Patterns}
-'xrdef {Jump Patterns-pg}{308}
-'xrdef {Jump Patterns-snt}{Section'tie16.10}
-'xrdef {Insn Canonicalizations-title}{Canonicalization of Instructions}
-'xrdef {Insn Canonicalizations-pg}{310}
-'xrdef {Insn Canonicalizations-snt}{Section'tie16.11}
-'xrdef {Peephole Definitions-title}{Machine-Specific Peephole Optimizers}
-'xrdef {Peephole Definitions-pg}{311}
-'xrdef {Peephole Definitions-snt}{Section'tie16.12}
-'xrdef {Expander Definitions-title}{Defining RTL Sequences for Code Generation}
-'xrdef {Expander Definitions-pg}{315}
-'xrdef {Expander Definitions-snt}{Section'tie16.13}
-'xrdef {Insn Splitting-title}{Defining How to Split Instructions}
-'xrdef {Insn Splitting-pg}{318}
-'xrdef {Insn Splitting-snt}{Section'tie16.14}
-'xrdef {Insn Attributes-title}{Instruction Attributes}
-'xrdef {Insn Attributes-pg}{321}
-'xrdef {Insn Attributes-snt}{Section'tie16.15}
-'xrdef {Defining Attributes-title}{Defining Attributes and their Values}
-'xrdef {Defining Attributes-pg}{321}
-'xrdef {Defining Attributes-snt}{Section'tie16.15.1}
-'xrdef {Expressions-title}{Attribute Expressions}
-'xrdef {Expressions-pg}{322}
-'xrdef {Expressions-snt}{Section'tie16.15.2}
-'xrdef {Tagging Insns-title}{Assigning Attribute Values to Insns}
-'xrdef {Tagging Insns-pg}{325}
-'xrdef {Tagging Insns-snt}{Section'tie16.15.3}
-'xrdef {Attr Example-title}{Example of Attribute Specifications}
-'xrdef {Attr Example-pg}{327}
-'xrdef {Attr Example-snt}{Section'tie16.15.4}
-'xrdef {Insn Lengths-title}{Computing the Length of an Insn}
-'xrdef {Insn Lengths-pg}{328}
-'xrdef {Insn Lengths-snt}{Section'tie16.15.5}
-'xrdef {Constant Attributes-title}{Constant Attributes}
-'xrdef {Constant Attributes-pg}{330}
-'xrdef {Constant Attributes-snt}{Section'tie16.15.6}
-'xrdef {Delay Slots-title}{Delay Slot Scheduling}
-'xrdef {Delay Slots-pg}{330}
-'xrdef {Delay Slots-snt}{Section'tie16.15.7}
-'xrdef {Function Units-title}{Specifying Function Units}
-'xrdef {Function Units-pg}{332}
-'xrdef {Function Units-snt}{Section'tie16.15.8}
-'xrdef {Target Macros-title}{Target Description Macros}
-'xrdef {Target Macros-pg}{335}
-'xrdef {Target Macros-snt}{Chapter'tie17}
-'xrdef {Driver-title}{Controlling the Compilation Driver, \file {gcc}}
-'xrdef {Driver-pg}{335}
-'xrdef {Driver-snt}{Section'tie17.1}
-'xrdef {Run-time Target-title}{Run-time Target Specification}
-'xrdef {Run-time Target-pg}{340}
-'xrdef {Run-time Target-snt}{Section'tie17.2}
-'xrdef {Storage Layout-title}{Storage Layout}
-'xrdef {Storage Layout-pg}{342}
-'xrdef {Storage Layout-snt}{Section'tie17.3}
-'xrdef {Type Layout-title}{Layout of Source Language Data Types}
-'xrdef {Type Layout-pg}{348}
-'xrdef {Type Layout-snt}{Section'tie17.4}
-'xrdef {Registers-title}{Register Usage}
-'xrdef {Registers-pg}{351}
-'xrdef {Registers-snt}{Section'tie17.5}
-'xrdef {Register Basics-title}{Basic Characteristics of Registers}
-'xrdef {Register Basics-pg}{351}
-'xrdef {Register Basics-snt}{Section'tie17.5.1}
-'xrdef {Allocation Order-title}{Order of Allocation of Registers}
-'xrdef {Allocation Order-pg}{352}
-'xrdef {Allocation Order-snt}{Section'tie17.5.2}
-'xrdef {Values in Registers-title}{How Values Fit in Registers}
-'xrdef {Values in Registers-pg}{353}
-'xrdef {Values in Registers-snt}{Section'tie17.5.3}
-'xrdef {Leaf Functions-title}{Handling Leaf Functions}
-'xrdef {Leaf Functions-pg}{355}
-'xrdef {Leaf Functions-snt}{Section'tie17.5.4}
-'xrdef {Stack Registers-title}{Registers That Form a Stack}
-'xrdef {Stack Registers-pg}{356}
-'xrdef {Stack Registers-snt}{Section'tie17.5.5}
-'xrdef {Obsolete Register Macros-title}{Obsolete Macros for Controlling Register Usage}
-'xrdef {Obsolete Register Macros-pg}{356}
-'xrdef {Obsolete Register Macros-snt}{Section'tie17.5.6}
-'xrdef {Register Classes-title}{Register Classes}
-'xrdef {Register Classes-pg}{357}
-'xrdef {Register Classes-snt}{Section'tie17.6}
-'xrdef {Stack and Calling-title}{Stack Layout and Calling Conventions}
-'xrdef {Stack and Calling-pg}{364}
-'xrdef {Stack and Calling-snt}{Section'tie17.7}
-'xrdef {Frame Layout-title}{Basic Stack Layout}
-'xrdef {Frame Layout-pg}{364}
-'xrdef {Frame Layout-snt}{Section'tie17.7.1}
-'xrdef {Frame Registers-title}{Registers That Address the Stack Frame}
-'xrdef {Frame Registers-pg}{366}
-'xrdef {Frame Registers-snt}{Section'tie17.7.2}
-'xrdef {Elimination-title}{Eliminating Frame Pointer and Arg Pointer}
-'xrdef {Elimination-pg}{367}
-'xrdef {Elimination-snt}{Section'tie17.7.3}
-'xrdef {Stack Arguments-title}{Passing Function Arguments on the Stack}
-'xrdef {Stack Arguments-pg}{369}
-'xrdef {Stack Arguments-snt}{Section'tie17.7.4}
-'xrdef {Register Arguments-title}{Passing Arguments in Registers}
-'xrdef {Register Arguments-pg}{371}
-'xrdef {Register Arguments-snt}{Section'tie17.7.5}
-'xrdef {Scalar Return-title}{How Scalar Function Values Are Returned}
-'xrdef {Scalar Return-pg}{374}
-'xrdef {Scalar Return-snt}{Section'tie17.7.6}
-'xrdef {Aggregate Return-title}{How Large Values Are Returned}
-'xrdef {Aggregate Return-pg}{376}
-'xrdef {Aggregate Return-snt}{Section'tie17.7.7}
-'xrdef {Caller Saves-title}{Caller-Saves Register Allocation}
-'xrdef {Caller Saves-pg}{377}
-'xrdef {Caller Saves-snt}{Section'tie17.7.8}
-'xrdef {Function Entry-title}{Function Entry and Exit}
-'xrdef {Function Entry-pg}{378}
-'xrdef {Function Entry-snt}{Section'tie17.7.9}
-'xrdef {Profiling-title}{Generating Code for Profiling}
-'xrdef {Profiling-pg}{381}
-'xrdef {Profiling-snt}{Section'tie17.7.10}
-'xrdef {Varargs-title}{Implementing the Varargs Macros}
-'xrdef {Varargs-pg}{382}
-'xrdef {Varargs-snt}{Section'tie17.8}
-'xrdef {Trampolines-title}{Trampolines for Nested Functions}
-'xrdef {Trampolines-pg}{385}
-'xrdef {Trampolines-snt}{Section'tie17.9}
-'xrdef {Library Calls-title}{Implicit Calls to Library Routines}
-'xrdef {Library Calls-pg}{387}
-'xrdef {Library Calls-snt}{Section'tie17.10}
-'xrdef {Addressing Modes-title}{Addressing Modes}
-'xrdef {Addressing Modes-pg}{391}
-'xrdef {Addressing Modes-snt}{Section'tie17.11}
-'xrdef {Condition Code-title}{Condition Code Status}
-'xrdef {Condition Code-pg}{393}
-'xrdef {Condition Code-snt}{Section'tie17.12}
-'xrdef {Costs-title}{Describing Relative Costs of Operations}
-'xrdef {Costs-pg}{396}
-'xrdef {Costs-snt}{Section'tie17.13}
-'xrdef {Sections-title}{Dividing the Output into Sections (Texts, Data, \dots{})}
-'xrdef {Sections-pg}{399}
-'xrdef {Sections-snt}{Section'tie17.14}
-'xrdef {PIC-title}{Position Independent Code}
-'xrdef {PIC-pg}{401}
-'xrdef {PIC-snt}{Section'tie17.15}
-'xrdef {Assembler Format-title}{Defining the Output Assembler Language}
-'xrdef {Assembler Format-pg}{402}
-'xrdef {Assembler Format-snt}{Section'tie17.16}
-'xrdef {File Framework-title}{The Overall Framework of an Assembler File}
-'xrdef {File Framework-pg}{402}
-'xrdef {File Framework-snt}{Section'tie17.16.1}
-'xrdef {Data Output-title}{Output of Data}
-'xrdef {Data Output-pg}{404}
-'xrdef {Data Output-snt}{Section'tie17.16.2}
-'xrdef {Uninitialized Data-title}{Output of Uninitialized Variables}
-'xrdef {Uninitialized Data-pg}{407}
-'xrdef {Uninitialized Data-snt}{Section'tie17.16.3}
-'xrdef {Label Output-title}{Output and Generation of Labels}
-'xrdef {Label Output-pg}{408}
-'xrdef {Label Output-snt}{Section'tie17.16.4}
-'xrdef {Initialization-title}{How Initialization Functions Are Handled}
-'xrdef {Initialization-pg}{411}
-'xrdef {Initialization-snt}{Section'tie17.16.5}
-'xrdef {Macros for Initialization-title}{Macros Controlling Initialization Routines}
-'xrdef {Macros for Initialization-pg}{414}
-'xrdef {Macros for Initialization-snt}{Section'tie17.16.6}
-'xrdef {Instruction Output-title}{Output of Assembler Instructions}
-'xrdef {Instruction Output-pg}{416}
-'xrdef {Instruction Output-snt}{Section'tie17.16.7}
-'xrdef {Dispatch Tables-title}{Output of Dispatch Tables}
-'xrdef {Dispatch Tables-pg}{419}
-'xrdef {Dispatch Tables-snt}{Section'tie17.16.8}
-'xrdef {Alignment Output-title}{Assembler Commands for Alignment}
-'xrdef {Alignment Output-pg}{420}
-'xrdef {Alignment Output-snt}{Section'tie17.16.9}
-'xrdef {Debugging Info-title}{Controlling Debugging Information Format}
-'xrdef {Debugging Info-pg}{421}
-'xrdef {Debugging Info-snt}{Section'tie17.17}
-'xrdef {All Debuggers-title}{Macros Affecting All Debugging Formats}
-'xrdef {All Debuggers-pg}{421}
-'xrdef {All Debuggers-snt}{Section'tie17.17.1}
-'xrdef {DBX Options-title}{Specific Options for DBX Output}
-'xrdef {DBX Options-pg}{422}
-'xrdef {DBX Options-snt}{Section'tie17.17.2}
-'xrdef {DBX Hooks-title}{Open-Ended Hooks for DBX Format}
-'xrdef {DBX Hooks-pg}{424}
-'xrdef {DBX Hooks-snt}{Section'tie17.17.3}
-'xrdef {File Names and DBX-title}{File Names in DBX Format}
-'xrdef {File Names and DBX-pg}{425}
-'xrdef {File Names and DBX-snt}{Section'tie17.17.4}
-'xrdef {SDB and DWARF-title}{Macros for SDB and DWARF Output}
-'xrdef {SDB and DWARF-pg}{426}
-'xrdef {SDB and DWARF-snt}{Section'tie17.17.5}
-'xrdef {Cross-compilation-title}{Cross Compilation and Floating Point}
-'xrdef {Cross-compilation-pg}{427}
-'xrdef {Cross-compilation-snt}{Section'tie17.18}
-'xrdef {Misc-title}{Miscellaneous Parameters}
-'xrdef {Misc-pg}{430}
-'xrdef {Misc-snt}{Section'tie17.19}
-'xrdef {Config-title}{The Configuration File}
-'xrdef {Config-pg}{437}
-'xrdef {Config-snt}{Chapter'tie18}
-'xrdef {Index-title}{Index}
-'xrdef {Index-pg}{441}
-'xrdef {Index-snt}{}