--- gcc/gcc.texinfo	2018/04/24 16:45:37	1.1
+++ gcc/gcc.texinfo	2018/04/24 16:51:45	1.1.1.7
@@ -6,7 +6,7 @@
 @ifinfo
 This file documents the use and the internals of the GNU compiler.
 
-Copyright (C) 1988 Free Software Foundation, Inc.
+Copyright (C) 1988, 1989 Free Software Foundation, Inc.
 
 Permission is granted to make and distribute verbatim copies of
 this manual provided the copyright notice and this permission notice
@@ -21,13 +21,13 @@ notice identical to this one except for
 @end ignore
 Permission is granted to copy and distribute modified versions of this
 manual under the conditions for verbatim copying, provided also that the
-section entitled ``GNU CC General Public License'' is included exactly as
+section entitled ``GNU General Public License'' is included exactly as
 in the original, and provided 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,
-except that the section entitled ``GNU CC General Public License'' and
+except that the section entitled ``GNU General Public License'' and
 this permission notice may be included in translations approved by the
 Free Software Foundation instead of in the original English.
 @end ifinfo
@@ -39,12 +39,12 @@ Free Software Foundation instead of in t
 @sp 2
 @center Richard M. Stallman
 @sp 3
-@center last updated 3 October 1988
+@center last updated 22 April 1989
 @sp 1
-@center for version 1.29
+@center for version 1.35
 @page
 @vskip 0pt plus 1filll
-Copyright @copyright{} 1988 Free Software Foundation, Inc.
+Copyright @copyright{} 1988, 1989 Free Software Foundation, Inc.
 
 Permission is granted to make and distribute verbatim copies of
 this manual provided the copyright notice and this permission notice
@@ -52,13 +52,13 @@ are preserved on all copies.
 
 Permission is granted to copy and distribute modified versions of this
 manual under the conditions for verbatim copying, provided also that the
-section entitled ``GNU CC General Public License'' is included exactly as
+section entitled ``GNU General Public License'' is included exactly as
 in the original, and provided 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,
-except that the section entitled ``GNU CC General Public License'' and
+<except that the section entitled ``GNU General Public License'' and
 this permission notice may be included in translations approved by the
 Free Software Foundation instead of in the original English.
 @end titlepage
@@ -73,7 +73,7 @@ well as its new features and incompatibi
 
 @end ifinfo
 @menu
-* Copying::         GNU CC General Public License says
+* Copying::         GNU General Public License says
                      how you can copy and share GNU CC.
 * Contributors::    People who have contributed to GNU CC.
 * Options::         Command options supported by @samp{gcc}.
@@ -91,84 +91,127 @@ well as its new features and incompatibi
 @end menu
 
 @node Copying, Contributors, Top, Top
-@unnumbered GNU CC GENERAL PUBLIC LICENSE
-@center (Clarified 11 Feb 1988)
+@unnumbered GNU GENERAL PUBLIC LICENSE
+@center Version 1, February 1989
 
-  The license agreements of most software companies keep you at the
-mercy of those companies.  By contrast, our general public license is
-intended to give everyone the right to share GNU CC.  To make sure that
-you get the rights we want you to have, we need to make restrictions
-that forbid anyone to deny you these rights or to ask you to surrender
-the rights.  Hence this license agreement.
-
-  Specifically, we want to make sure that you have the right to give
-away copies of GNU CC, that you receive source code or else can get it
-if you want it, that you can change GNU CC or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To make sure that everyone has such rights, we have to forbid you to
-deprive anyone else of these rights.  For example, if you distribute
-copies of GNU CC, you must give the recipients all the rights that you
-have.  You must make sure that they, too, receive or can get the
+@display
+Copyright @copyright{} 1989 Free Software Foundation, Inc.
+675 Mass Ave, Cambridge, MA 02139, USA
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+@end display
+
+@unnumberedsec Preamble
+
+  The license agreements of most software companies try to keep users
+at the mercy of those companies.  By contrast, our General Public
+License is intended to guarantee your freedom to share and change free
+software---to make sure the software is free for all its users.  The
+General Public License applies to the Free Software Foundation's
+software and to any other program whose authors commit to using it.
+You can use it for your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Specifically, the General Public License is designed to make
+sure that you have the freedom to give away or sell copies of free
+software, that you receive source code or can get it if you want it,
+that you can change the software or use pieces of it in new free
+programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of a such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
 source code.  And you must tell them their rights.
 
-  Also, for our own protection, we must make certain that everyone
-finds out that there is no warranty for GNU CC.  If GNU CC is modified by
-someone else and passed on, we want its recipients to know that what
-they have is not what we distributed, so that any problems introduced
-by others will not reflect on our reputation.
-
-  Therefore we (Richard Stallman and the Free Software Foundation,
-Inc.) make the following terms which say what you must do to be
-allowed to distribute or change GNU CC.
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
 
-@unnumberedsec COPYING POLICIES
+  The precise terms and conditions for copying, distribution and
+modification follow.
 
-@enumerate
-@item
-You may copy and distribute verbatim copies of GNU CC source code as
-you receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy a valid copyright notice
-``Copyright @copyright{} 1988 Free Software Foundation, Inc.'' (or
-with whatever year is appropriate); keep intact the notices on all
-files that refer to this License Agreement and to the absence of any
-warranty; and give any other recipients of the GNU CC program a copy
-of this License Agreement along with the program.  You may charge a
-distribution fee for the physical act of transferring a copy.
+@iftex
+@unnumberedsec TERMS AND CONDITIONS
+@end iftex
+@ifinfo
+@center TERMS AND CONDITIONS
+@end ifinfo
 
+@enumerate
 @item
-You may modify your copy or copies of GNU CC or any portion of it,
-and copy and distribute such modifications under the terms of
-Paragraph 1 above, provided that you also do the following:
+This License Agreement applies to any program or other work which
+contains a notice placed by the copyright holder saying it may be
+distributed under the terms of this General Public License.  The
+``Program'', below, refers to any such program or work, and a ``work based
+on the Program'' means either the Program or any work containing the
+Program or a portion of it, either verbatim or with modifications.  Each
+licensee is addressed as ``you''.
+
+@item
+You may copy and distribute verbatim copies of the Program's source
+code as you receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice and
+disclaimer of warranty; keep intact all the notices that refer to this
+General Public License and to the absence of any warranty; and give any
+other recipients of the Program a copy of this General Public License
+along with the Program.  You may charge a fee for the physical act of
+transferring a copy.
+
+@item
+You may modify your copy or copies of the Program or any portion of
+it, and copy and distribute such modifications under the terms of Paragraph
+1 above, provided that you also do the following:
 
 @itemize @bullet
 @item
-cause the modified files to carry prominent notices stating
-that you changed the files and the date of any change; and
+cause the modified files to carry prominent notices stating that
+you changed the files and the date of any change; and
 
 @item
 cause the whole of any work that you distribute or publish, that
-in whole or in part contains or is a derivative of GNU CC or any
-part thereof, to be licensed at no charge to all third parties on
-terms identical to those contained in this License Agreement
-(except that you may choose to grant more extensive warranty
-protection to some or all third parties, at your option).
-
-@item
-You may charge a distribution fee for the physical act of
-transferring a copy, and you may at your option offer warranty
-protection in exchange for a fee.
+in whole or in part contains the Program or any part thereof, either
+with or without modifications, to be licensed at no charge to all
+third parties under the terms of this General Public License (except
+that you may choose to grant warranty protection to some or all
+third parties, at your option).
+
+@item
+If the modified program normally reads commands interactively when
+run, you must cause it, when started running for such interactive use
+in the simplest and most usual way, to print or display an
+announcement including an appropriate copyright notice and a notice
+that there is no warranty (or else, saying that you provide a
+warranty) and that users may redistribute the program under these
+conditions, and telling the user how to view a copy of this General
+Public License.
+
+@item
+You may charge a fee for the physical act of transferring a
+copy, and you may at your option offer warranty protection in
+exchange for a fee.
 @end itemize
 
-Mere aggregation of another unrelated program with this program (or its
+Mere aggregation of another independent work with the Program (or its
 derivative) on a volume of a storage or distribution medium does not bring
-the other program under the scope of these terms.
+the other work under the scope of these terms.
 
 @item
-You may copy and distribute GNU CC (or a portion or derivative of it,
-under Paragraph 2) in object code or executable form under the terms
-of Paragraphs 1 and 2 above provided that you also do one of the
-following:
+You may copy and distribute the Program (or a portion or derivative of
+it, under Paragraph 2) in object code or executable form under the terms of
+Paragraphs 1 and 2 above provided that you also do one of the following:
 
 @itemize @bullet
 @item
@@ -178,8 +221,8 @@ Paragraphs 1 and 2 above; or,
 
 @item
 accompany it with a written offer, valid for at least three
-years, to give any third party free (except for a nominal
-shipping charge) a complete machine-readable copy of the
+years, to give any third party free (except for a nominal charge
+for the cost of distribution) a complete machine-readable copy of the
 corresponding source code, to be distributed under the terms of
 Paragraphs 1 and 2 above; or,
 
@@ -190,57 +233,160 @@ allowed only for noncommercial distribut
 received the program in object code or executable form alone.)
 @end itemize
 
-For an executable file, complete source code means all the source code
-for all modules it contains; but, as a special exception, it need not
-include source code for modules which are standard libraries that
-accompany the operating system on which the executable file runs.
-
-@item
-You may not copy, sublicense, distribute or transfer GNU CC except as
-expressly provided under this License Agreement.  Any attempt
-otherwise to copy, sublicense, distribute or transfer GNU CC is void
-and your rights to use the program under this License agreement shall
-be automatically terminated.  However, parties who have received
-computer software programs from you with this License Agreement will
-not have their licenses terminated so long as such parties remain in
-full compliance.
-
-@item
-If you wish to incorporate parts of GNU CC into other free programs
-whose distribution conditions are different, write to the Free Software
-Foundation at 675 Mass Ave, Cambridge, MA 02139.  We have not yet worked
-out a simple rule that can be stated here, but we will often permit this.
-We will be guided by the two goals of preserving the free status of all
-derivatives of our free software and of promoting the sharing and reuse of
-software.
+Source code for a work means the preferred form of the work for making
+modifications to it.  For an executable file, complete source code means
+all the source code for all modules it contains; but, as a special
+exception, it need not include source code for modules which are standard
+libraries that accompany the operating system on which the executable
+file runs, or for standard header files or definitions files that
+accompany that operating system.
+
+@item
+You may not copy, modify, sublicense, distribute or transfer the
+Program except as expressly provided under this General Public License.
+Any attempt otherwise to copy, modify, sublicense, distribute or transfer
+the Program is void, and will automatically terminate your rights to use
+the Program under this License.  However, parties who have received
+copies, or rights to use copies, from you under this General Public
+License will not have their licenses terminated so long as such parties
+remain in full compliance.
+
+@item
+By copying, distributing or modifying the Program (or any work based
+on the Program) you indicate your acceptance of this license to do so,
+and all its terms and conditions.
+
+@item
+Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the original
+licensor to copy, distribute or modify the Program subject to these
+terms and conditions.  You may not impose any further restrictions on the
+recipients' exercise of the rights granted herein.
+
+@item
+The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of the license which applies to it and ``any
+later version'', you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+the license, you may choose any version ever published by the Free Software
+Foundation.
+
+@item
+If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+@iftex
+@heading NO WARRANTY
+@end iftex
+@ifinfo
+@center NO WARRANTY
+@end ifinfo
+
+@item
+BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM ``AS IS'' WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+@item
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
+ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES
+ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT
+LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES
+SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE
+WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 @end enumerate
 
-Your comments and suggestions about our licensing policies and our
-software are welcome!  Please contact the Free Software Foundation, Inc.,
-675 Mass Ave, Cambridge, MA 02139, or call (617) 876-3296.
-
-@unnumberedsec NO WARRANTY
-
-  BECAUSE GNU CC IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY NO
-WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW.  EXCEPT
-WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
-RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE GNU CC "AS IS" WITHOUT
-WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND
-PERFORMANCE OF GNU CC IS WITH YOU.  SHOULD GNU CC PROVE DEFECTIVE, YOU
-ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
-STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
-WHO MAY MODIFY AND REDISTRIBUTE GNU CC AS PERMITTED ABOVE, BE LIABLE TO
-YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR OTHER
-SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
-INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
-BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR A
-FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) GNU CC, EVEN
-IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES, OR FOR
-ANY CLAIM BY ANY OTHER PARTY.
+@iftex
+@heading END OF TERMS AND CONDITIONS
+@end iftex
+@ifinfo
+@center END OF TERMS AND CONDITIONS
+@end ifinfo
+
+@page
+@unnumberedsec Appendix: How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to humanity, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these
+terms.
+
+  To do so, attach the following notices to the program.  It is safest to
+attach them to the start of each source file to most effectively convey
+the exclusion of warranty; and each file should have at least the
+``copyright'' line and a pointer to where the full notice is found.
+
+@smallexample
+@var{one line to give the program's name and a brief idea of what it does.}
+Copyright (C) 19@var{yy}  @var{name of author}
+
+This program 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 1, or (at your option)
+any later version.
+
+This program 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 this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+@end smallexample
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+@smallexample
+Gnomovision version 69, Copyright (C) 19@var{yy} @var{name of author}
+Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+This is free software, and you are welcome to redistribute it
+under certain conditions; type `show c' for details.
+@end smallexample
+
+The hypothetical commands `show w' and `show c' should show the
+appropriate parts of the General Public License.  Of course, the
+commands you use may be called something other than `show w' and `show
+c'; they could even be mouse-clicks or menu items---whatever suits your
+program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a ``copyright disclaimer'' for the program, if
+necessary.  Here a sample; alter the names:
+
+@example
+Yoyodyne, Inc., hereby disclaims all copyright interest in the
+program `Gnomovision' (a program to direct compilers to make passes
+at assemblers) written by James Hacker.
+
+@var{signature of Ty Coon}, 1 April 1989
+Ty Coon, President of Vice
+@end example
+
+That's all there is to it!
 
 @node Contributors, Options, Copying, Top
 @unnumbered Contributors to GNU CC
@@ -260,7 +406,7 @@ Optimization'', Software Practice and Ex
 Paul Rubin wrote most of the preprocessor.
 
 @item
-Leonard Tower wrote parts of the parser, RTL generator, RTL
+Leonard Tower wrote parts of the parser, RTL generator, and RTL
 definitions, and of the Vax machine description.
 
 @item
@@ -306,6 +452,15 @@ the 9000 series 300.
 
 @item
 William Schelter did most of the work on the Intel 80386 support.
+
+@item
+Christopher Smith did the port for Convex machines.
+
+@item
+Paul Petersen wrote the machine description for the Alliant FX/8.
+
+@item
+Alain Lichnewsky ported GNU CC to the MIPS cpu.
 @end itemize
 
 @node Options, Installation, Contributors, Top
@@ -318,19 +473,20 @@ very different from @samp{-d -r}.
 
 When you invoke GNU CC, it normally does preprocessing, compilation,
 assembly and linking.  File names which end in @samp{.c} are taken as C
-source to be preprocessed and compiled; compiler output files plus any
-input files with names ending in @samp{.s} are assembled; then the
-resulting object files, plus any other input files, are linked together to
-produce an executable.
+source to be preprocessed and compiled; file names ending in @samp{.i}
+are taken as preprocessor output to be compiled; compiler output files
+plus any input files with names ending in @samp{.s} are assembled; then
+the resulting object files, plus any other input files, are linked
+together to produce an executable.
 
 Command options allow you to stop this process at an intermediate stage.
 For example, the @samp{-c} option says not to run the linker.  Then the
 output consists of object files output by the assembler.
 
-Other command options are passed on to one stage.  Some options control
-the preprocessor and others the compiler itself.  Yet other options
-control the assembler and linker; these are not documented here because the
-GNU assembler and linker are not yet released.
+Other command options are passed on to one stage of processing.  Some
+options control the preprocessor and others the compiler itself.  Yet
+other options control the assembler and linker; these are not documented
+here, but you rarely need to use any of them.
 
 Here are the options to control the overall compilation process, including
 those that say whether to link, whether to assemble, and so on.
@@ -367,6 +523,12 @@ Compiler driver program prints the comma
 the preprocessor, compiler proper, assembler and linker.  Some of
 these are directed to print their own version numbers.
 
+@item -pipe
+Use pipes rather than temporary files for communication between the
+various stages of compilation.  This fails to work on some systems
+where the assembler is unable to read from a pipe; but the GNU
+assembler has no trouble.
+
 @item -B@var{prefix}
 Compiler driver program tries @var{prefix} as a prefix for each
 program it tries to run.  These programs are @file{cpp}, @file{cc1},
@@ -385,6 +547,12 @@ the @samp{-B} prefix, if needed.  If it
 standard prefixes above are tried, and that is all.  The file is left
 out of the link if it is not found by those means.  Most of the time,
 on most machines, you can do without it.
+
+You can get a similar result from the environment variable;
+@code{GCC_EXEC_PREFIX} if it is defined, its value is used as a prefix
+in the same way.  If both the @samp{-B} option and the
+@code{GCC_EXEC_PREFIX} variable are present, the @samp{-B} option is
+used first and the environment variable value second.
 @end table
 
 These options control the details of C compilation itself.
@@ -399,6 +567,13 @@ keywords, and predefined macros such as
 that identify the type of system you are using.  It also enables the
 undesirable and rarely used ANSI trigraph feature.
 
+The alternate keywords @code{__asm}, @code{__inline} and
+@code{__typeof} continue to work despite @samp{-ansi}.  You would not
+want to use them in an ANSI C program, of course, but it useful to put
+them in header files that might be included in compilations done with
+@samp{-ansi}.  Alternate predefined macros such as @code{__unix} and
+@code{__vax} are also available, with or without @samp{-ansi}.
+
 The @samp{-ansi} option does not cause non-ANSI programs to be
 rejected gratuitously.  For that, @samp{-pedantic} is required in
 addition to @samp{-ansi}.
@@ -406,8 +581,8 @@ addition to @samp{-ansi}.
 The macro @code{__STRICT_ANSI__} is predefined when the @samp{-ansi}
 option is used.  Some header files may notice this macro and refrain
 from declaring certain functions or defining certain macros that the
-ANSI standard doesn't call for; this is to avoid interfering with
-any programs that might use these names for other things.
+ANSI standard doesn't call for; this is to avoid interfering with any
+programs that might use these names for other things.
 
 @item -traditional
 Attempt to support some aspects of traditional C compilers.
@@ -434,6 +609,11 @@ to @code{unsigned int}.
 Out-of-range floating point literals are not an error.
 
 @item
+All automatic variables not declared @code{register} are preserved by
+@code{longjmp}.  Ordinarily, GNU C follows ANSI C: automatic variables
+not declared @code{volatile} may be clobbered.
+
+@item
 In the preprocessor, comments convert to nothing at all, rather than
 to a space.  This allows traditional token concatenation.
 
@@ -497,9 +677,9 @@ GNU assembler and linker in order to wor
 This feature will probably be eliminated.  It was intended to enable
 GDB to read the symbol table faster, but it doesn't result in enough
 of a speedup to be worth the larger object files and executables.  We
-are working on other ways of making GDB start faster, which work with
-DBX format debugging information and could be made to work with SDB
-format.
+are working on other ways of making GDB start even faster, which work
+with DBX format debugging information and could be made to work with
+SDB format.
 
 @item -w
 Inhibit all warning messages.
@@ -513,17 +693,19 @@ An automatic variable is used without fi
 
 These warnings are possible only in optimizing compilation,
 because they require data flow information that is computed only
-when optimizing.  They occur only for variables that are
-candidates for register allocation.  Therefore, they do not occur
-for a variable that is declared @code{volatile}, or whose address
-is taken, or whose size is other than 1, 2, 4 or 8 bytes.  Also,
-they do not occur for structures, unions or arrays, even when
-they are in registers.
-
-Note that there may be no warning about a variable that is used
-only to compute a value that itself is never used, because such
-computations may be deleted by the flow analysis pass before the
-warnings are printed.
+when optimizing.  If you don't specify @samp{-O}, you simply won't
+get these warnings.
+
+These warnings occur only for variables that are candidates for
+register allocation.  Therefore, they do not occur for a variable that
+is declared @code{volatile}, or whose address is taken, or whose size
+is other than 1, 2, 4 or 8 bytes.  Also, they do not occur for
+structures, unions or arrays, even when they are in registers.
+
+Note that there may be no warning about a variable that is used only
+to compute a value that itself is never used, because such
+computations may be deleted by data flow analysis before the warnings
+are printed.
 
 These warnings are made optional because GNU CC is not smart
 enough to see all the reasons why the code might be correct
@@ -562,6 +744,10 @@ another common case:
 @noindent
 This has no bug because @code{save_y} is used only if it is set.
 
+Some spurious warnings can be avoided if you declare as
+@code{volatile} all the functions you use that never return.
+@xref{Function Attributes}.
+
 @item
 A nonvolatile automatic variable might be changed by a call to
 @code{longjmp}.  These warnings as well are possible only in
@@ -576,7 +762,7 @@ in fact be called at the place which wou
 @item
 A function can return either with or without a value.  (Falling
 off the end of the function body is considered returning without
-a value.)  For example, this function would inspire such a
+a value.)  For example, this function would evoke such a
 warning:
 
 @example
@@ -590,6 +776,9 @@ foo (a)
 Spurious warnings can occur because GNU CC does not realize that
 certain functions (including @code{abort} and @code{longjmp})
 will never return.
+
+@item
+An expression-statement contains no side effects.
 @end itemize
 
 In the future, other useful warnings may also be enabled by this
@@ -604,14 +793,38 @@ to @code{int}.  Also warn about any @cod
 return-value in a function whose return-type is not @code{void}.
 
 @item -Wunused
-Warn whenever a local variable is unused aside from its declaration.
+Warn whenever a local variable is unused aside from its declaration,
+and whenever a function is declared static but never defined.
+
+@item -Wshadow
+Warn whenever a local variable shadows another local variable.
+
+@item -Wid-clash-@var{len}
+Warn whenever two distinct identifiers match in the first @var{len}
+characters.  This may help you prepare a program that will compile
+with certain obsolete, brain-damaged compilers.
+
+@item -Wswitch
+Warn whenever a @code{switch} statement has an index of enumeral type
+and lacks a @code{case} for one or more of the named codes of that
+enumeration.  (The presence of a @code{default} label prevents this
+warning.)  @code{case} labels outside the enumeration range also
+provoke warnings when this option is used.
 
 @item -Wcomment
 Warn whenever a comment-start sequence @samp{/*} appears in a comment.
 
+@item -Wtrigraphs
+Warn if any trigraphs are encountered (assuming they are enabled).
+
 @item -Wall
 All of the above @samp{-W} options combined.
 
+@item -Wcast-qual
+Warn whenever a pointer is cast so as to remove a type qualifier from
+the target type.  For example, warn if a @code{const char *} is cast
+to an ordinary @code{char *}.
+
 @item -Wwrite-strings
 Give string constants the type @code{const char[@var{length}]} so that
 copying the address of one into a non-@code{const} @code{char *}
@@ -629,6 +842,11 @@ analysis program @code{prof}.
 Generate extra code to write profile information suitable for the
 analysis program @code{gprof}.
 
+@item -a
+Generate extra code to write profile information for basic blocks,
+suitable for the analysis program @code{tcov}.  Eventually GNU
+@code{gprof} should be extended to process this data.
+
 @item -l@var{library}
 Search a standard list of directories for a library named
 @var{library}, which is actually a file named
@@ -737,10 +955,59 @@ will assemble with the GNU assembler.
 Output code for g-format floating point numbers instead of d-format.
 @end table
 
+These @samp{-m} switches are supported on the Sparc:
+
+@table @samp
+@item -mfpu
+Generate output containing floating point instructions.  This is the
+default if you use the unmodified sources.
+
+@item -msoft-float
+Generate output containing library calls for floating point.
+
+@item -mno-epilogue
+Generate separate return instructions for @code{return} statements.
+This has both advantages and disadvantages; I don't recall what they
+are.
+@end table
+
+These @samp{-m} options are defined in the Convex machine description:
+
+@table @samp
+@item -mc1
+Generate output for a C1.  This is the default when the compiler is
+configured for a C1.
+
+@item -mc2
+Generate output for a C2.  This is the default when the compiler is
+configured for a C2.
+
+@item -margcount
+Generate code which puts an argument count in the word preceding each
+argument list.  Some nonportable Convex and Vax programs need this
+word.  (Debuggers don't; this info is in the symbol table.)
+
+@item -mnoargcount
+Omit the argument count word.  This is the default if you use the
+unmodified sources.
+@end table
+
 @item -f@var{flag}
-Specify machine-independent flags.  These are the flags:
+Specify machine-independent flags.  Most flags have both positive and
+negative forms; the negative form of @samp{-ffoo} would be
+@samp{-fno-foo}.  In the table below, only one of the forms is
+listed---the one which is not the default.  You can figure out the
+other form by either removing @samp{no-} or adding it.
 
 @table @samp
+@item -fpcc-struct-return
+Use the same convention for returning @code{struct} and @code{union}
+values that is used by the usual C compiler on your system.  This
+convention is less efficient for small structures, and on many
+machines it fails to be reentrant; but it has the advantage of
+allowing intercallability between GCC-compiled code and PCC-compiled
+code.
+
 @item -ffloat-store
 Do not store floating-point variables in registers.  This
 prevents undesirable excess precision on machines such as the
@@ -753,7 +1020,8 @@ Use @samp{-ffloat-store} for such progra
 
 @item -fno-asm
 Do not recognize @code{asm}, @code{inline} or @code{typeof} as a
-keyword.  These words may then be used as identifiers.
+keyword.  These words may then be used as identifiers.  You can
+use @code{__asm}, @code{__inline} and @code{__typeof} instead.
 
 @item -fno-defer-pop
 Always pop the arguments to each function call as soon as that
@@ -807,6 +1075,15 @@ If all calls to a given function are int
 is declared @code{static}, then the function is normally not
 output as assembler code in its own right.
 
+@item -fcaller-saves
+Enable values to be allocated in registers that will be clobbered by
+function calls, by emitting extra instructions to save and restore the
+registers around such calls.  Such allocation is done only when it
+seems to result in better code than would otherwise be produced.
+
+This option is enabled by default on certain machines, usually those
+which have no call-preserved registers to use instead.
+
 @item -fkeep-inline-functions
 Even if all calls to a given function are integrated, and the
 function is declared @code{static}, nevertheless output a
@@ -818,6 +1095,10 @@ uniquize them.  This is for compatibilit
 assume they can write into string constants.  Writing into string
 constants is a very bad idea; ``constants'' should be constant.
 
+@item -fcond-mismatch
+Allow conditional expressions with mismatched types in the second and
+third arguments.  The value of such an expression is void.
+
 @item -fno-function-cse
 Do not put function addresses in registers; make each instruction
 that calls a constant function contain the function's address
@@ -830,9 +1111,15 @@ optimizations performed when this option
 @item -fvolatile
 Consider all memory references through pointers to be volatile.
 
+@item -fshared-data
+Requests that the data and non-@code{const} variables of this
+compilation be shared data rather than private data.  The distinction
+makes sense only on certain operating systems, where shared data is
+shared between processes running the same program, while private data
+exists in one copy per process.
+
 @item -funsigned-char
-Let the type @code{char} be the unsigned, like @code{unsigned
-char}.
+Let the type @code{char} be the unsigned, like @code{unsigned char}.
 
 Each kind of machine has a default for what @code{char} should
 be.  It is either like @code{unsigned char} by default or like
@@ -843,9 +1130,15 @@ The type @code{char} is always a distinc
 @code{signed char} or @code{unsigned char}, even though its
 behavior is always just like one of those two.
 
+Note that this is equivalent to @samp{-fno-signed-char}, which is the
+negative form of @samp{-fsigned-char}.
+
 @item -fsigned-char
 Let the type @code{char} be signed, like @code{signed char}.
 
+Note that this is equivalent to @samp{-fno-unsigned-char}, which is
+the negative form of @samp{-funsigned-char}.
+
 @item -ffixed-@var{reg}
 Treat the register named @var{reg} as a fixed register; generated
 code should never refer to it (except perhaps as a stack pointer,
@@ -856,6 +1149,9 @@ accepted are machine-specific and are de
 @code{REGISTER_NAMES} macro in the machine description macro
 file.
 
+This flag does not have a negative form, because it specifies a
+three-way choice.
+
 @item -fcall-used-@var{reg}
 Treat the register named @var{reg} as an allocatable register
 that is clobbered by function calls.  It may be allocated for
@@ -867,6 +1163,9 @@ Use of this flag for a register that has
 in the machine's execution model, such as the stack pointer or
 frame pointer, will produce disastrous results.
 
+This flag does not have a negative form, because it specifies a
+three-way choice.
+
 @item -fcall-saved-@var{reg}
 Treat the register named @var{reg} as an allocatable register
 saved by functions.  It may be allocated even for temporaries or
@@ -879,6 +1178,9 @@ frame pointer, will produce disastrous r
 
 A different sort of disaster will result from the use of this
 flag for a register in which function values may be returned.
+
+This flag does not have a negative form, because it specifies a
+three-way choice.
 @end table
 
 @item -d@var{letters}
@@ -918,6 +1220,10 @@ this option (though a rare few will requ
 without this option, certain GNU extensions and traditional C features
 are supported as well.  With this option, they are rejected.  There is
 no reason to @i{use} this option; it exists only to satisfy pedants.
+
+@item -static
+On Suns running version 4, this prevents linking with the shared
+libraries.  (@samp{-g} has the same effect.)
 @end table
 
 These options control the C preprocessor, which is run on each C source
@@ -986,7 +1292,7 @@ Define macro @var{macro} as @var{defn}.
 @item -U@var{macro}
 Undefine macro @var{macro}.
 
-@item -T
+@item -trigraphs
 Support ANSI C trigraphs.  You don't want to know about this
 brain-damage.  The @samp{-ansi} option also has this effect.
 @end table
@@ -1006,13 +1312,102 @@ Here is the procedure for installing GNU
 @item
 Edit @file{Makefile}.  If you are using HPUX, or any form of system V,
 you must make a few changes described in comments at the beginning of
-the file.
+the file.  Genix requires changes also.
 
 @item
 On a Sequent system, go to the Berkeley universe.
 
 @item
-Choose configuration files.
+Choose configuration files.  The easy way to do this is to run the
+command file @file{config.gcc} with a single argument, which is the
+name of the machine (and operating system, in some cases).
+
+Here is a list of the possible arguments:
+
+@table @samp
+@item vax
+Vaxes running BSD.
+@item vms
+Vaxes running VMS.
+@item vax-sysv
+Vaxes running system V.
+@item i386-sysv
+Intel 386 PCs running system V.
+@item i386-sysv-gas
+Intel 386 PCs running system V, using the GNU assembler and GNU
+linker.
+@item sequent-i386
+Sequent with Intel 386 processors.
+@item sun2
+Sun 2 running system version 2 or 3.
+@item sun3
+Sun 3 running system version 2 or 3, with 68881.
+
+Note there we do not provide a configuration file to use an FPA
+by default because programs that establish signal handlers for
+floating point traps inherently cannot work with the FPA.
+@item sun3-nfp
+Sun 3 running system version 2 or 3, without 68881.
+@item sun4
+Sun 4 running system version 2 or 3.
+@item sun2-os4
+Sun 2 running system version 4.
+@item sun3-os4
+Sun 3 running system version 4, with 68881.
+@item sun3-nfp-os4
+Sun 3 running system version 4, without 68881.
+@item sun4-os4
+Sun 4 running system version 4.
+@item sun386
+Sun 386 (``roadrunner'').
+@item alliant
+Alliant FX/8 computer.  Currently, there are bugs in the support
+for floating point.  Also note that Alliant's version of dbx does
+not manage to work with the output from GNU CC.
+@item mips
+Some variant of MIPS computer (but not the one from DEC).  Note
+that this machine description was written for GNU CC version 1.32
+and may require some updating to work with the current version.
+@item convex-c1
+Convex C1 computer.
+@item convex-c2
+Convex C2 computer.
+@item hp9k320
+HP 9000 series 300 using HPUX assembler.  Note there is no
+support in GNU CC for HP's debugger; thus, @samp{-g} is not
+available in this configuration.
+@item hp9k320g
+HP 9000 series 300 using GNU assembler, linker and debugger.
+This requires the HP-adapt package, which is available along with
+the GNU linker as part of the ``binutils'' distribution.
+This is on the GNU CC distribution tape.
+@item isi68
+ISI 68000 or 68020 system.
+@item news800
+Sony NEWS 68020 system.
+@item next
+NeXT system.
+@item altos
+Altos 3068.  Note that you must use the GNU assembler, linker and
+debugger, with COFF-encapsulation.  Also, you must fix a kernel
+bug.  Details in the file @file{ALTOS-README}.
+@item 3b1
+AT&T 3b1, a.k.a. 7300 PC.  Note that the current version of GNU
+CC cannot be compiled with the Unix compiler on this machine, due
+to bugs in the Unix comiler.  GNU CC does work correctly,
+however, if you can compile it with older version of GNU CC or
+cross-compile it.
+@item sequent-ns32k
+Sequent containing ns32000 processors.
+@item encore
+Encore ns32000 system.
+@item genix
+National Semiconductor ns32000 system.
+@item 88000
+Motorola 88000 processor.  This port is not finished.
+@end table
+
+Here we spell out what files need to be set up:
 
 @itemize @bullet
 @item
@@ -1021,21 +1416,24 @@ config file for the machine you are usin
 file is responsible for defining information about the host
 machine.  It includes @file{tm.h}.
 
-The file's name should be @file{config-@var{machine}.h}, with these
-exceptions:
+The file is located in the subdirectory @file{config}.  Its name
+should be @file{xm-@var{machine}.h}, with these exceptions:
 
 @table @file
-@item config-vms.h
+@item xm-vms.h
 for vaxen running VMS.
-@item config-vaxv.h
+@item xm-vaxv.h
 for vaxen running system V.
-@item config-i386v.h
+@item xm-i386v.h
 for Intel 80386's running system V.
-@item config-sun4.h
+@item xm-sunos4.h
 for Suns (model 2, 3 or 4) running @emph{operating system} version 4.
-@item config-hp9k3.h
+(Use @file{xm-m68k.h} or @file{xm-sparc.h} for version 3.)
+@item xm-sun386i.h
+for Sun roadrunner running any version of the operating system.
+@item xm-hp9k320.h
 for the HP 9000 series 300.
-@item config-gnx.h
+@item xm-genix.h
 for the ns32000 running Genix
 @end table
 
@@ -1045,21 +1443,24 @@ refers to the appropriate file.
 
 @item
 Make a symbolic link named @file{tm.h} to the machine-description
-macro file for your machine (its name should be
-@file{tm-@var{machine}.h}).
+macro file for your machine.  It should be in the subdirectory
+@file{config} and its name should be @file{tm-@var{machine}.h}.
 
 If your system is a 68000, don't use the file @file{tm-m68k.h}
 directly.  Instead, use one of these files:
 
 @table @file
 @item tm-sun3.h
-for Sun 3 machines.
+for Sun 3 machines with 68881.
+@item tm-sun3-nfp.h
+for Sun 3 machines with no hardware floating point.
 @item tm-sun2.h
 for Sun 2 machines.
 @item tm-3b1.h
 for AT&T 3b1 (aka 7300 Unix PC).
 @item tm-isi68.h
-for Integrated Solutions systems.
+for Integrated Solutions systems.  This file assumes you
+use the GNU assembler.
 @item tm-news800.h
 for SONY News systems.
 @item tm-hp9k320.h
@@ -1075,21 +1476,21 @@ instructions will appear here in the fut
 For the vax, use @file{tm-vax.h} on BSD Unix, @file{tm-vaxv.h} on
 system V, or @file{tm-vms.h} on VMS.@refill
 
-For the SPARC (Sun 4), use @file{tm-sparc.h}.
-
 For the Motorola 88000, use @file{tm-m88k.h}.  The support for the
 88000 has a few unfinished spots because there was no way to run the
-output.  Bugs are suspected in handling of branch-tables and in
-the function prologue and epilogue.
+output.  Bugs are suspected in handling of branch-tables and in the
+function prologue and epilogue.
 
 For the 80386, don't use @file{tm-i386.h} directly.  Use
 @file{tm-i386v.h} if the target machine is running system V,
-@file{tm-seq386.h} for a Sequent 386 system, or @file{tm-compaq.h} for
-a Compaq.
+@file{tm-i386gas.h} if it is running system V but you are using the
+GNU assembler and linker, @file{tm-seq386.h} for a Sequent 386 system,
+or @file{tm-compaq.h} for a Compaq, or @file{tm-sun386i.h} for a Sun
+386 system.
 
 For the 32000, use @file{tm-sequent.h} if you are using a Sequent
 machine, or @file{tm-encore.h} for an Encore machine, or
-@file{tm-gnx.h} if you are using Genix version 3; otherwise, perhaps
+@file{tm-genix.h} if you are using Genix version 3; otherwise, perhaps
 @file{tm-ns32k.h} will work for you.
 
 Note that Genix has bugs in @code{alloca} and @code{malloc}; you must
@@ -1098,14 +1499,20 @@ get the compiled versions of these from
 
 Note that Encore systems are supported only under BSD.
 
+For Sparc (Sun 4) machines, use @file{tm-sparc.h} with operating system
+version 4, and @file{tm-sun4os3.h} with system version 3.
+
 @item
 Make a symbolic link named @file{md} to the machine description
-pattern file (its name should be @file{@var{machine}.md}).
+pattern file.  It should be in the @file{config} subdirectory and its
+name should be @file{@var{machine}.md}; but @var{machine} is often not
+the same as the name used in the @file{tm.h} file because the
+@file{md} files are more general.
 
 @item
 Make a symbolic link named @file{aux-output.c} to the output
-subroutine file for your machine (its name should be
-@file{output-@var{machine}.c}).
+subroutine file for your machine.  It should be in the @file{config}
+subdirectory and its name should be @file{out-@var{machine}.c}.
 @end itemize
 
 @item
@@ -1127,6 +1534,23 @@ properly without special pains.
 @item
 Build the compiler.  Just type @samp{make} in the compiler directory.
 
+Ignore any warnings you may see about ``statement not reached'' in the
+@file{insn-emit.c}; they are normal.  Any other compilation errors may
+represent bugs in the port to your machine or operating system, and
+should be investigated and reported (@pxref{Bugs}).
+
+@item
+Optionally, install the library functions for 64-bit integer
+arithmetic.  You do this with the command @samp{make gnulib2}.  In the
+future this will happen automatically; for now, it is optional, until
+we are sure it works on all machines.
+
+@item
+If you are using COFF-encapsulation, you must convert @file{gnulib} to
+a GNU-format library at this point.  See the file @file{README-ENCAP}
+in the directory containing the GNU binary file utilities, for
+directions.
+
 @item
 Move the first-stage object files and executables into a subdirectory
 with this command:
@@ -1156,7 +1580,7 @@ make CC=stage1/gcc CFLAGS="-g -O -Bstage
 
 @item
 If you wish to test the compiler by compiling it with itself one more
-time, do this:
+time, do this (in C shell):
 
 @example
 make stage2
@@ -1166,15 +1590,29 @@ cmp $file stage2/$file
 end
 @end example
 
-This will notify you if any of these stage 3 object files differs from
-those of stage 2.  Any difference, no matter how innocuous, indicates
-that the stage 2 compiler has compiled GNU CC incorrectly, and is
-therefore a potentially serious bug which you should investigate and
-report (@pxref{Bugs}).
-
+@noindent
 Aside from the @samp{-B} option, the options should be the same as
 when you made stage 2.
 
+The @code{foreach} command (written in C shell) will notify you if any of
+these stage 3 object files differs from those of stage 2.  On BSD systems,
+any difference, no matter how innocuous, indicates that the stage 2
+compiler has compiled GNU CC incorrectly, and is therefore a potentially
+serious bug which you should investigate and report (@pxref{Bugs}).
+
+On systems that use COFF object files, bytes 5 to 8 will always be
+different, since it is a timestamp.  On these systems, you can do the
+comparison as follows (in Bourne shell):
+
+@example
+for file in *.o; do
+echo $file
+tail +10 $file > foo1
+tail +10 stage2/$file > foo2
+cmp foo1 foo2
+done
+@end example
+
 @item
 Install the compiler driver, the compiler's passes and run-time support.
 You can use the following command:
@@ -1188,7 +1626,7 @@ This copies the files @file{cc1}, @file{
 files @file{gcc-cc1}, @file{gcc-cpp} and @file{gcc-gnulib} in
 directory @file{/usr/local/lib}, which is where the compiler driver
 program looks for them.  It also copies the driver program @file{gcc}
-into the directory @file{/usr/local}, so that it appears in typical
+into the directory @file{/usr/local/bin}, so that it appears in typical
 execution search paths.@refill
 
 @strong{Warning: there is a bug in @code{alloca} in the Sun library.
@@ -1213,10 +1651,9 @@ Alternatively, on Sun systems and 4.3BSD
 include files by running the shell script @file{fixincludes}.  This
 installs modified, corrected copies of the files @file{ioctl.h},
 @file{ttychars.h} and many others, in a special directory where only
-GNU CC will normally look for them.
-
-See the file @file{fixincludes} for a list of all the files we know to
-require correction.
+GNU CC will normally look for them.  This script will work on various
+systems because it chooses the files by searching all the system
+headers for the problem cases that we know about.
 @end enumerate
 
 If you cannot install the compiler's passes and run-time support in
@@ -1232,27 +1669,28 @@ by setting the Make variable @code{libdi
 @node VMS Install,, Installation, Installation
 @section Installing GNU CC on VMS
 
-The VMS version of GNU CC is distributed in an unusual tape format which
-consists of several tape files.  The first is a command file; the second is
-an executable program which reads Unix tar format; the third is another
-command file which uses this program to read the remainder of the tape.
-
-To load the tape, it suffices to mount it @samp{/foreign} and then do
-@samp{@@mta0:} to execute the command file at the beginning of the tape.
-
-The tape contains executables and object files as well as sources, so no
-compilation is necessary unless you change the sources.  (This is a good
-thing, since you probably don't have any other C compiler.)  If you must
+The VMS version of GNU CC is distributed in a backup saveset containing
+both source code and precompiled binaries.
+
+Sometimes the binaries will be from an older version that the sources,
+because we don't always have time to update them.  In this case, you
+should use the binaries you get to recompile the sources.  If you must
 recompile, here is how:
 
 @enumerate
 @item
-Copy the file @file{tm-vms.h} to @file{tm.h}, @file{config-vms.h} to
+Copy the file @file{tm-vms.h} to @file{tm.h}, @file{xm-vms.h} to
 @file{config.h}, @file{vax.md} to @file{md.} and @file{output-vax.c}
 to @file{aux-output.c}.@refill
 
 @item
 Type @samp{@@make} to do recompile everything.
+
+If you are compiling with a version of GCC older than 1.33, specify
+@samp{/DEFINE=("inline=")} as an option in all the compilations.  This
+requires editing all the @code{gcc} commands in @file{make-cc1.com}.
+(The older versions had problems supporting @code{inline}.)  Once you
+have a working 1.33 or newer GCC, you can change this file back.
 @end enumerate
 
 To install the @samp{GCC} command so you can use the compiler easily, in
@@ -1283,12 +1721,29 @@ Install the @samp{GCC} command with the
 $ set command /table=sys$library:dcltables gnu_cc:gcc
 @end example
 
+@item
+To install the help file, do the following:
+
+@example
+$ lib/help sys$library:helplib.hlb gcc.hlp
+@end example
+
 @noindent
 Now you can invoke the compiler with a command like @samp{gcc /verbose
 file.c}, which is equivalent to the command @samp{gcc -v -c file.c} in
 Unix.
 @end enumerate
 
+There is a known problem on VMS: @code{const} global variables don't
+work compatibly with the VMS C compiler; we don't know a way to get
+them to the linker properly.
+
+Note that GNU CC on VMS does not generate debugging information to
+describe the program's symbols.  It is not straightforward to implement
+this, and we have no time to spend on it, but we might consent to
+install a very modular implementation if you write it.  You will
+probably have to modify GAS as well as GNU CC.
+
 @node Trouble, Incompatibilities, Installation, Top
 @chapter Known Causes of Trouble with GNU CC.
 
@@ -1312,16 +1767,69 @@ representation.  But this does not work
 a different machine with an incompatible floating point format, or
 even a different byte-ordering.
 
-It is possible to fix this by writing machine-independent code which
-understands the floating point representation of the target machine.
-I am not interested in doing that much work to compensate for bugs
-in assemblers.
+In addition, correct constant folding of floating point values
+requires representing them in the target machine's format.
+(The C standard does not quite require this, but in practice
+it is the only way to win.)
+
+It is now possible to overcome these problems by defining macros such
+as @code{REAL_VALUE_TYPE}.  But doing so is a substantial amount of
+work for each target machine.  @xref{Cross-compilation}.
 
 @item
 DBX rejects some files produced by GNU CC, though it accepts similar
 constructs in output from PCC.  Until someone can supply a coherent
 description of what is valid DBX input and what is not, there is
 nothing I can do about these problems.  You are on your own.
+
+@item
+Users often think it is a bug when GNU CC reports an error for code
+like this:
+
+@example
+int foo (short);
+
+int foo (x)
+     short x;
+@{@dots{}@}
+@end example
+
+The error message is correct: this code really is erroneous, because the
+old-style non-prototype definition passes subword integers in their
+promoted types.  In other words, the argument is really an @code{int},
+not a @code{short}.  The correct prototype is this:
+
+@example
+int foo (int);
+@end example
+
+@item
+Users often think it is a bug when GNU CC reports an error for code
+like this:
+
+@example
+int foo (struct mumble *);
+
+struct mumble @{ @dots{} @};
+
+int foo (struct mumble *x)
+@{ @dots{} @}
+@end example
+
+This code really is erroneous, because the scope of @code{struct
+mumble} the prototype is limited to the argument list containing it.
+It does not refer to the @code{struct mumble} defined with file scope
+immediately below---they are two unrelated types with similar names in
+different scopes.
+
+But in the definition of @code{foo}, the file-scope type is used
+because that is available to be inherited.  Thus, the definition and
+the prototype do not match, and you get an error.
+
+This behavior may seem silly, but it's what the ANSI standard
+specifies.  It is easy enough for you to make your code work by moving
+the definition of @code{struct mumble} above the prototype.  I don't
+think it's worth being incompatible for.
 @end itemize
 
 @node Incompatibilities, Extensions, Trouble, Top
@@ -1347,7 +1855,7 @@ string its argument points to.
 Another consequence is that @code{sscanf} does not work on some
 systems when passed a string constant as its format control string.
 This is because @code{sscanf} incorrectly tries to write into the
-string constant.
+string constant.  Likewise @code{fscanf} and @code{scanf}.
 
 The best solution to these problems is to change the program to use
 @code{char}-array variables with initialization strings for these
@@ -1400,6 +1908,11 @@ in it.
 If you use the @samp{-W} option with the @samp{-O} option, you will
 get a warning when GNU CC thinks such a problem might be possible.
 
+The @samp{-traditional} option directs GNU C to put variables in
+the stack by default, rather than in registers, in functions that
+call @code{setjmp}.  This results in the behavior found in
+traditional C compilers.
+
 @item
 Declarations of external variables and functions within a block apply
 only to the block containing the declaration.  In other words, they
@@ -1460,40 +1973,21 @@ with PCC compatibility, you should decla
 
 @item
 When compiling functions that return structures or unions, GNU CC
-output code uses a method different from that used on most versions of
-Unix.  As a result, code compiled with GNU CC cannot call a
-structure-returning function compiled with PCC, and vice versa.
+output code normally uses a method different from that used on most
+versions of Unix.  As a result, code compiled with GNU CC cannot call
+a structure-returning function compiled with PCC, and vice versa.
 
-The method used by GCC is as follows: a structure or union which is 1,
+The method used by GNU CC is as follows: a structure or union which is 1,
 2, 4 or 8 bytes long is returned like a scalar.  A structure or union
 with any other size is stored into an address supplied by the caller
 in a special, fixed register.
 
 PCC usually handles all sizes of structures and unions by returning
 the address of a block of static storage containing the value.  This
-method is not used in GCC because it is slower and nonreentrant.
-
-On systems where PCC works this way, you may be able to make GCC-compiled
-code call such functions that were compiled with PCC by declaring them
-to return a pointer to the structure or union instead of the structure
-or union itself.  For example, instead of this:
-
-@example
-struct foo nextfoo ();
-@end example
-
-@noindent
-write this:
+method is not used in GNU CC because it is slower and nonreentrant.
 
-@example
-struct foo *nextfoo ();
-#define nextfoo *nextfoo
-@end example
-
-@noindent
-(Note that this assumes you are using the GNU preprocessor and not
-@samp{-traditional}, so that the ANSI antirecursion rules for macro
-expansions are effective.)
+You can tell GNU CC to use the PCC convention with the option
+@samp{-fpcc-struct-return}.
 @end itemize
 
 @node Extensions, Bugs, Incompatibilities, Top
@@ -1515,14 +2009,19 @@ features in conditional compilation, che
 * Variable-Length::	Arrays whose length is computed at run time.
 * Subscripting::	Any array can be subscripted, even if not an lvalue.
 * Pointer Arith::	Arithmetic on @code{void}-pointers and function pointers.
+* Initializers::	Non-constant initializers.
 * Constructors::	Constructor expressions give structures, unions
 			 or arrays as values.
+* Function Attributes:: Declaring that functions have no side effects,
+			 or that they can never return.
 * Dollar Signs::        Dollar sign is allowed in identifiers.
 * Alignment::           Inquiring about the alignment of a type or variable.
 * Inline::              Defining inline functions (as fast as macros).
 * Extended Asm::	Assembler instructions with C expressions as operands.
 			 (With them you can define ``built-in'' functions.)
 * Asm Labels::		Specifying the assembler name to use for a C symbol.
+* Global Reg Vars::     Defining global variables which reside in registers.
+* Alternate Keywords::  @code{__const}, @code{__asm}, etc., for header files.
 @end menu
 
 @node Statement Exprs, Naming Types, Extensions, Extensions
@@ -1627,6 +2126,10 @@ typeof (int *)
 @noindent
 Here the type described is that of pointers to @code{int}.
 
+If you are writing a header file that must work when included in ANSI C
+programs, write @code{__typedef} instead of @code{typedef}.
+@xref{Alternate Keywords}.
+
 A @code{typeof}-construct can be used anywhere a typedef name could be
 used.  For example, you can use it in a declaration, in a cast, or inside
 of @code{sizeof} or @code{typeof}.
@@ -1818,32 +2321,16 @@ FILE *concat_fopen (char *s1, char *s2,
 @}
 @end example
 
-You can also define structure types containing variable-length arrays, and
-use them even for arguments or function values, as shown here:
+You can also use variable-length arrays as arguments to functions:
 
 @example
-int foo;
-
 struct entry
+tester (int len, char data[len])
 @{
-  char data[foo];
-@};
-
-struct entry
-tester (struct entry arg)
-@{
-  struct entry new;
-  int i;
-  for (i = 0; i < foo; i++)
-    new.data[i] = arg.data[i] + 1;
-  return new;
+  @dots{}
 @}
 @end example
 
-@noindent
-(Eventually there will be a way to say that the size of the array is
-another member of the same structure.)
-
 The length of an array is computed on entry to the brace-level where the
 array is declared and is remembered for the scope of the array in case you
 access it with @code{sizeof}.
@@ -1907,7 +2394,7 @@ foo (float f, float g)
 @}
 @end example
 
-@node Constructors, Dollar Signs, Initializers, Extensions
+@node Constructors, Function Attributes, Initializers, Extensions
 @section Constructor Expressions
 
 GNU C supports constructor expressions.  A constructor looks like a cast
@@ -1957,7 +2444,59 @@ latter does the same thing an ordinary C
 output = ((int[]) @{ 2, x, 28 @}) [input];
 @end example
 
-@node Dollar Signs, Alignment, Constructors, Extensions
+@node Function Attributes, Dollar Signs, Constructors
+@section Declaring Attributes of Functions
+
+In GNU C, you declare certain things about functions called in your program
+which help the compiler optimize function calls.
+
+A few functions, such as @code{abort} and @code{exit}, cannot return.
+These functions should be declared @code{volatile}.  For example,
+
+@example
+extern volatile void abort ();
+@end example
+
+@noindent
+tells the compiler that it can assume that @code{abort} will not return.
+This makes slightly better code, but more importantly it helps avoid
+spurious warnings of uninitialized variables.
+
+Many functions do not examine any values except their arguments, and
+have no effects except the return value.  Such a function can be subject
+to common subexpression elimination and loop optimization just as an
+arithmetic operator would be.  These functions should be declared
+@code{const}.  For example,
+
+@example
+extern const void square ();
+@end example
+
+@noindent
+says that the hypothetical function @code{square} is safe to call
+fewer times than the program says.
+
+Note that a function that has pointer arguments and examines the data
+pointed to must @emph{not} be declared @code{const}.  Likewise, a
+function that calls a non-@code{const} function must not be
+@code{const}.
+
+Some people object to this feature, claiming that ANSI C's @code{#pragma}
+should be used instead.  There are two reasons I did not do this.
+
+@enumerate
+@item
+It is impossible to generate @code{#pragma} commands from a macro.
+
+@item
+The @code{#pragma} command is just as likely as these keywords to mean
+something else in another compiler.
+@end enumerate
+
+These two reasons apply to @emph{any} application whatever: as far as
+I can see, @code{#pragma} is never useful.
+
+@node Dollar Signs, Alignment, Function Attributes, Extensions
 @section Dollar Signs in Identifier Names
 
 In GNU C, you may use dollar signs in identifier names.  This is because
@@ -2015,9 +2554,12 @@ inc (int *a)
 @}
 @end example
 
-You can also make all ``simple enough'' functions inline with the
-option @samp{-finline-functions}.  Note that certain usages in a
-function definition can make it unsuitable for inline substitution.
+(If you are writing a header file to be included in ANSI C programs, write
+@code{__inline} instead of @code{inline}.  @xref{Alternate Keywords}.)
+
+You can also make all ``simple enough'' functions inline with the option
+@samp{-finline-functions}.  Note that certain usages in a function
+definition can make it unsuitable for inline substitution.
 
 When a function is both inline and @code{static}, if all calls to the
 function are integrated into the caller, then the function's own assembler
@@ -2058,16 +2600,21 @@ asm ("fsinx %1,%0" : "=f" (result) : "f"
 Here @code{angle} is the C expression for the input operand while
 @code{result} is that of the output operand.  Each has @samp{"f"} as its
 operand constraint, saying that a floating-point register is required.  The
-constraints use the same language used in the machine description
-(@pxref{Constraints}).
+@samp{=} in @samp{=f} indicates that the operand is an output; all output
+operands' constraints must use @samp{=}.  The constraints use the same
+language used in the machine description (@pxref{Constraints}).
 
 Each operand is described by an operand-constraint string followed by the C
 expression in parentheses.  A colon separates the assembler template from
 the first output operand, and another separates the last output operand
 from the first input, if any.  Commas separate output operands and separate
-inputs.  The number of operands is limited to the maximum number of
+inputs.  The total number of operands is limited to the maximum number of
 operands in any instruction pattern in the machine description.
 
+If there are no output operands, and there are input operands, then there
+must be two consecutive colons surrounding the place where the output
+operands would go.
+
 Output operand expressions must be lvalues; the compiler can check this.
 The input operands need not be lvalues.  The compiler cannot check whether
 the operands have data types that are reasonable for the instruction being
@@ -2076,9 +2623,6 @@ not know what it means, or whether it is
 extended @code{asm} feature is most often used for machine instructions
 that the compiler itself does not know exist.
 
-If there are no output operands, and there are input operands, then you
-should write two colons in a row where the output operands would go.
-
 The output operands must be write-only; GNU CC will assume that the values
 in these operands before the instruction are dead and need not be
 generated.  For an operand that is read-write, or in which not all bits are
@@ -2097,7 +2641,8 @@ asm ("combine %2,%0" : "=r" (foo) : "0"
 
 @noindent
 The constraint @samp{"0"} for operand 1 says that it must occupy the same
-location as operand 0.
+location as operand 0.  A digit in constraint is allowed only in an input
+operand, and it must refer to an output operand.
 
 Only a digit in the constraint can guarantee that one operand will be in
 the same place as another.  The mere fact that @code{foo} is the value of
@@ -2123,9 +2668,10 @@ This assumption may be false if the asse
 more than one instruction.  In such a case, use @samp{&} for each output
 operand that may not overlap an input.  @xref{Modifiers}.
 
-Some instructions clobber specific hard registers.  To describe this,
-write a third colon after the input operands, followed by the names of
-the clobbered hard registers (given as strings).  For example, on the vax,
+Some instructions clobber specific hard registers.  To describe this, write
+a third colon after the input operands, followed by the names of the
+clobbered hard registers (given as strings).  Here is a realistic example
+for the vax:
 
 @example
 asm volatile ("movc3 %0,%1,%2"
@@ -2134,6 +2680,36 @@ asm volatile ("movc3 %0,%1,%2"
               : "r0", "r1", "r2", "r3", "r4", "r5");
 @end example
 
+You can put multiple assembler instructions together in a single @code{asm}
+template, separated either with newlines (written as @samp{\n}) or with
+semicolons if the assembler allows such semicolons.  The GNU assembler
+allows semicolons and all Unix assemblers seem to do so.  The input
+operands are guaranteed not to use any of the clobbered registers, and
+neither will the output operands' addresses, so you can read and write the
+clobbered registers as many times as you like.  Here is an example of
+multiple instructions in a template; it assumes that the subroutine
+@code{_foo} accepts arguments in registers 9 and 10:
+
+@example
+asm ("movl %0,r9;movl %1,r10;call _foo"
+     : /* no outputs */
+     : "g" (from), "g" (to)
+     : "r9", "r10");
+@end example
+
+If you want to test the condition code produced by an assembler instruction,
+you must include a branch and a label in the @code{asm} construct, as follows:
+
+@example
+asm ("clr %0;frob %1;beq 0f;mov #1,%0;0:"
+     : "g" (result)
+     : "g" (input));
+@end example
+
+@noindent
+This assumes your assembler supports local labels, as the GNU assembler
+and most Unix assemblers do.
+
 Usually the most convenient way to use these @code{asm} instructions is to
 encapsulate them in macros that look like functions.  For example,
 
@@ -2157,14 +2733,15 @@ example, if the desired type were @code{
 argument to an @code{int} variable named @code{__arg} would warn about
 using a pointer unless the caller explicitly casts it.
 
-GNU CC assumes for optimization purposes that these instructions have no
-side effects except to change the output operands.  This does not mean that
-instructions with a side effect cannot be used, but you must be careful,
-because the compiler may eliminate them if the output operands aren't used,
-or move them out of loops, or replace two with one if they constitute a
-common subexpression.  Also, if your instruction does have a side effect on
-a variable that otherwise appears not to change, the old value of the
-variable may be reused later if it happens to be found in a register.
+If an @code{asm} has output operands, GNU CC assumes for optimization
+purposes that the instruction has no side effects except to change the
+output operands.  This does not mean that instructions with a side effect
+cannot be used, but you must be careful, because the compiler may eliminate
+them if the output operands aren't used, or move them out of loops, or
+replace two with one if they constitute a common subexpression.  Also, if
+your instruction does have a side effect on a variable that otherwise
+appears not to change, the old value of the variable may be reused later if
+it happens to be found in a register.
 
 You can prevent an @code{asm} instruction from being deleted, moved or
 combined by writing the keyword @code{volatile} after the @code{asm}.  For
@@ -2175,6 +2752,10 @@ example:
 asm volatile ("set_priority %0": /* no outputs */ : "g" (x))
 @end example
 
+@noindent
+(However, an instruction without output operands will not be deleted
+or moved, regardless, unless it is unreachable.)
+
 It is a natural idea to look for a way to give access to the condition
 code left by the assembler instruction.  However, when we attempted to
 implement this, we found no way to make it work reliably.  The problem
@@ -2184,12 +2765,16 @@ instructions would alter the condition c
 test it.  This problem doesn't arise for ordinary ``test'' and
 ``compare'' instructions because they don't have any output operands.
 
-@node Asm Labels,,Extended Asm, Extensions
+If you are writing a header file that should be includable in ANSI C
+programs, write @code{__asm} instead of @code{asm}.  @xref{Alternate
+Keywords}.
+
+@node Asm Labels, Global Reg Vars, Extended Asm, Extensions
 @section Controlling Names Used in Assembler Code
 
 You can specify the name to be used in the assembler code for a C function
-or variable by writing the @code{asm} keyword after the declarator as
-follows:
+or variable by writing the @code{asm} (or @code{__asm}) keyword after the
+declarator as follows:
 
 @example
 int foo asm ("myfoo") = 2;
@@ -2222,6 +2807,119 @@ register name; that would produce comple
 CC does not as yet have the ability to store static variables in registers.
 Perhaps that will be added.
 
+@node Global Reg Vars, Alternate Keywords, Asm Labels, Extensions
+@section Global Variables in Registers
+
+A few programs, such as programming language interpreters, may have a
+couple of global variables that are accessed so often that it is worth
+while to reserve registers throughout the program just for them.
+
+You can define a global register variable in GNU C like this:
+
+@example
+register int *foo asm ("a5");
+@end example
+
+@noindent
+Here @code{a5} is the name of the register which should be used.  Choose a
+register which is normally saved and restored by function calls on your
+machine, so that library routines will not clobber it.
+
+Naturally the register name is cpu-dependent, so you would need to
+conditionalize your program according to cpu type.  The register
+@code{a5} would be a good choice on a 68000 for a variable of pointer
+type.  On machines with register windows, be sure to choose a ``global''
+register that is not affected by the function call mechanism.
+
+In addition, operating systems on one type of cpu may differ in how they
+name the registers; then you would need additional conditionals.  For
+example, some 68000 operating systems call this register @code{%a5}.
+
+Eventually there may be a way of asking the compiler to choose a register
+automatically, but first we need to figure out how it should choose and
+how to enable you to guide the choice.  No solution is evident.
+
+Defining a global register variable in a certain register reserves that
+register entirely for this use, at least within the current compilation.
+The register will not be allocated for any other purpose in the functions
+in the current compilation.  The register will not be saved and restored by
+these functions.  Stores into this register are never deleted even if they
+would appear to be dead, but references may be deleted or moved or
+simplified.
+
+It is not safe to access the global register variables from signal
+handlers, or from more than one thread of control, because the system
+library routines may temporarily use the register for other things (unless
+you recompile them specially for the task at hand).
+
+It is not safe for one function that uses a global register variable to
+call another such function @code{foo} by way of a third function
+@code{lose} that was compiled without knowledge of this variable (i.e. in a
+different source file in which the variable wasn't declared).  This is
+because @code{lose} might save the register and put some other value there.
+For example, you can't expect a global register variable to be available in
+the comparison-function that you pass to @code{qsort}, since @code{qsort}
+might have put something else in that register.  (If you are prepared to
+recompile @code{qsort} with the same global register variable, you can
+solve this problem.)
+
+If you want to recompile @code{qsort} or other source files which do not
+actually use your global register variable, so that they will not use that
+register for any other purpose, then it suffices to specify the compiler
+option @samp{-ffixed-@var{reg}}.  You need not actually add a global
+register declaration to their source code.
+
+A function which can alter the value of a global register variable cannot
+safely be called from a function compiled without this variable, because it
+could clobber the value the caller expects to find there on return.
+Therefore, the function which is the entry point into the part of the
+program that uses the global register variable must explicitly save and
+restore the value which belongs to its caller.
+
+On most machines, @code{longjmp} will restore to each global register
+variable the value it had at the time of the @code{setjmp}.  On some
+machines, however, @code{longjmp} will not change the value of global
+register variables.  To be portable, the function that called @code{setjmp}
+should make other arrangements to save the values of the global register
+variables, and to restore them if a @code{longjmp}.  This way, the the same
+thing will happen regardless of what @code{longjmp} does.
+
+All global register variable declarations must precede all function
+definitions.  If such a declaration could appear after function
+definitions, the declaration would be too late to prevent the register from
+being used for other purposes in the preceding functions.
+
+Global register variables may not have initial values, because an
+executable file has no means to supply initial contents for a register.
+
+@node Alternate Keywords,, Global Reg Vars, Extensions
+@section Alternate Keywords
+
+The option @samp{-traditional} disables certain keywords; @samp{-ansi}
+disables certain others.  This causes trouble when you want to use GNU C
+extensions, or ANSI C features, in a general-purpose header file that
+should be usable by all programs, including ANSI C programs and traditional
+ones.  The keywords @code{asm}, @code{typeof} and @code{inline} cannot be
+used since they won't work in a program compiled with @samp{-ansi}, while
+the keywords @code{const}, @code{volatile}, @code{signed}, @code{typeof}
+and @code{inline} won't work in a program compiled with
+@samp{-traditional}.@refill
+
+The way to solve these problems is to put @samp{__} in front of each
+problematical keyword.  For example, use @code{__asm} instead of @code{asm},
+@code{__const} instead of @code{const}, and @code{__inline} instead of
+@code{inline}.
+
+Other C compilers won't accept these alternative keywords; if you want to
+compile with another compiler, you can define the alternate keywords as
+macros to replace them with the customary keywords.  It looks like this:
+
+@example
+#ifndef __GNUC__
+#define __asm asm
+#endif
+@end example
+
 @node Bugs, Portability, Extensions, Top
 @chapter Reporting Bugs
 
@@ -2844,8 +3542,7 @@ the input file name.
 
 @item
 Jump optimization is repeated, this time including cross-jumping
-and deletion of no-op move instructions.  Machine-specific peephole
-optimizations are performed at the same time.
+and deletion of no-op move instructions.
 
 The option @samp{-dJ} causes a debugging dump of the RTL code after
 this pass.  This dump file's name is made by appending @samp{.jump2}
@@ -2854,7 +3551,8 @@ to the input file name.
 @item
 Final.  This pass outputs the assembler code for the function.  It is
 also responsible for identifying spurious test and compare
-instructions.  The function entry and exit sequences are generated
+instructions.  Machine-specific peephole optimizations are performed
+at the same time.  The function entry and exit sequences are generated
 directly as assembler code in this pass; they never exist as RTL.
 
 The source files are @file{final.c} plus @file{insn-output.c}; the
@@ -2993,7 +3691,7 @@ but when they appear in C code they are
 manual, they are shown as follows: @samp{const_int}.
 
 In a few contexts a null pointer is valid where an expression is normally
-wanted.  The written form of this is @samp{(nil)}.
+wanted.  The written form of this is @code{(nil)}.
 
 @node Accessors, Flags, RTL Objects, RTL
 @section Access to Operands
@@ -3217,9 +3915,19 @@ Here is a table of machine modes.
 @item HImode
 ``Half-Integer'' mode represents a two-byte integer.
 
+@item PSImode
+``Partial Single Integer'' mode represents an integer which occupies
+four bytes but which doesn't really use all four.  On some machines,
+this is the right mode to use for pointers.
+
 @item SImode
 ``Single Integer'' mode represents a four-byte integer.
 
+@item PDImode
+``Partial Double Integer'' mode represents an integer which occupies
+eight bytes but which doesn't really use all eight.  On some machines,
+this is the right mode to use for certain pointers.
+
 @item DImode
 ``Double Integer'' mode represents an eight-byte integer.
 
@@ -3234,6 +3942,11 @@ point number.
 ``Double Floating'' mode represents a double-precision (eight byte) floating
 point number.
 
+@item XFmode
+``Extended Floating'' mode represents a triple-precision (twelve byte)
+floating point number.  This mode is used for IEEE extended floating
+point.
+
 @item TFmode
 ``Tetra Floating'' mode represents a quadruple-precision (sixteen byte)
 floating point number.
@@ -3279,12 +3992,45 @@ into the machine mode used for addresses
 The only modes which a machine description @i{must} support are
 @code{QImode}, @code{SImode}, @code{SFmode} and @code{DFmode}.  The
 compiler will attempt to use @code{DImode} for two-word structures and
-unions, but it would not be hard to program it to avoid this.  Likewise,
-you can arrange for the C type @code{short int} to avoid using
-@code{HImode}.  In the long term it would be desirable to make the set of
-available machine modes machine-dependent and eliminate all assumptions
-about specific machine modes or their uses from the machine-independent
-code of the compiler.
+unions, but this can be prevented by overriding the definition of
+@code{MAX_FIXED_MODE_SIZE}.  Likewise, you can arrange for the C type
+@code{short int} to avoid using @code{HImode}.  In the long term it
+might be desirable to make the set of available machine modes
+machine-dependent and eliminate all assumptions about specific machine
+modes or their uses from the machine-independent code of the compiler.
+
+To help begin this process, the machine modes are divided into mode
+classes.  These are represented by the enumeration type @code{enum
+mode_class} defined in @file{rtl.h}.  The possible mode classes are:
+
+@table @code
+@item MODE_INT
+Integer modes.  By default these are @code{QImode}, @code{HImode},
+@code{SImode}, @code{DImode}, @code{TImode}, and also @code{BImode}.
+
+@item MODE_FLOAT
+Floating-point modes.  By default these are @code{QFmode},
+@code{HFmode}, @code{SFmode}, @code{DFmode} and @code{TFmode}, but the
+MC68881 also defines @code{XFmode} to be an 80-bit extended-precision
+floating-point mode.
+
+@item MODE_COMPLEX_INT
+Complex integer modes.  By default these are @code{CQImode},
+@code{CHImode}, @code{CSImode}, @code{CDImode} and @code{CTImode}.
+
+@item MODE_COMPLEX_FLOAT
+Complex floating-point modes.  By default these are @code{CQFmode},
+@code{CHFmode}, @code{CSFmode}, @code{CDFmode} and @code{CTFmode},
+
+@item MODE_FUNCTION
+Algol or Pascal function variables including a static chain.
+(These are not currently implemented).
+
+@item MODE_RANDOM
+This is a catchall mode class for modes which don't fit into the above
+classes.  Currently @code{VOIDmode}, @code{BLKmode} and @code{EPmode}
+are in @code{MODE_RANDOM}.
+@end table
 
 Here are some C macros that relate to machine modes:
 
@@ -3295,6 +4041,17 @@ Returns the machine mode of the RTX @var
 @item PUT_MODE (@var{x}, @var{newmode})
 Alters the machine mode of the RTX @var{x} to be @var{newmode}.
 
+@item NUM_MACHINE_MODES
+Stands for the number of machine modes available on the target
+machine.  This is one greater than the largest numeric value of any
+machine mode.
+
+@item GET_MODE_NAME (@var{m})
+Returns the name of mode @var{m} as a string.
+
+@item GET_MODE_CLASS (@var{m})
+Returns the mode class of mode @var{m}.
+
 @item GET_MODE_SIZE (@var{m})
 Returns the size in bytes of a datum of mode @var{m}.
 
@@ -3328,7 +4085,7 @@ value zero or one will return @code{cons
 as appropriate.
 
 @item (const_double:@var{m} @var{i0} @var{i1})
-Represents a 64-bit constant or mode @var{m}.  All floating point
+Represents a 64-bit constant of mode @var{m}.  All floating point
 constants are represented in this way, and so are 64-bit @code{DImode}
 integer constants.
 
@@ -3347,8 +4104,11 @@ u.i[1] = XINT (x, 1);
 and then refer to @code{u.d}.
 
 The global variables @code{dconst0_rtx} and @code{fconst0_rtx} hold
-@samp{const_double} expressions with value 0, in modes @code{DFmode} and
-@code{SFmode}, respectively.
+@samp{const_double} expressions with value 0, in modes @code{DFmode}
+and @code{SFmode}, respectively.  The macro @code{CONST0_RTX
+(@var{mode})} refers to a @samp{const_double} expression with value 0
+in mode @var{mode}.  The mode @var{mode} must be of mode class
+@code{MODE_FLOAT}.
 
 @item (symbol_ref @var{symbol})
 Represents the value of an assembler label for data.  @var{symbol} is
@@ -3424,7 +4184,7 @@ If in addition the register number speci
 it actually represents several consecutive hardware registers starting
 with the specified one.
 
-Such multi-word hardware register @samp{reg} expressions may not be live
+Such multi-word hardware register @samp{reg} expressions must not be live
 across the boundary of a basic block.  The lifetime analysis pass does not
 know how to record properly that several consecutive registers are
 actually live there, and therefore register allocation would be confused.
@@ -3515,10 +4275,10 @@ carried out in machine mode @var{m}.  Th
 @item (minus:@var{m} @var{x} @var{y})
 Like @samp{plus} but represents subtraction.
 
-@item (minus @var{x} @var{y})
+@item (compare @var{x} @var{y})
 Represents the result of subtracting @var{y} from @var{x}
 for purposes of comparison.  The absence of a machine mode
-in the @samp{minus} expression indicates that the result is
+in the @samp{compare} expression indicates that the result is
 computed without overflow, as if with infinite precision.
 
 Of course, machines can't really subtract with infinite precision.
@@ -3543,7 +4303,7 @@ Widening multiplication and same-size mu
 distinct and supported by different machine instructions; machines may
 support one but not the other.@refill
 
-@samp{mult} may be used for floating point division as well.
+@samp{mult} may be used for floating point multiplication as well.
 Then @var{m} is a floating point machine mode.
 
 @item (umult:@var{m} @var{x} @var{y})
@@ -3910,20 +4670,30 @@ Note that the machine description classi
 ``call-clobbered''.  All function call instructions are assumed by
 default to clobber these registers, so there is no need to use
 @samp{clobber} expressions to indicate this fact.  Also, each function
-call is assumed to have the potential to alter any memory location.
+call is assumed to have the potential to alter any memory location,
+unless the function is declared @code{const}.
+
+When a @samp{clobber} expression for a register appears inside a
+@samp{parallel} with other side effects, GNU CC guarantees that the
+register is unoccupied both before and after that insn.  Therefore, it
+is safe for the assembler code produced by the insn to use the
+register as a temporary.  You can clobber either a specific hard
+register or a pseudo register; in the latter case, GNU CC will
+allocate a hard register that is available there for use as a
+temporary.
 
 @item (use @var{x})
 Represents the use of the value of @var{x}.  It indicates that the
 value in @var{x} at this point in the program is needed, even though
 it may not be apparent why this is so.  Therefore, the compiler will
-not attempt to delete instructions whose only effect is to store a
-value in @var{x}.  @var{x} must be a @samp{reg} expression.
+not attempt to delete previous instructions whose only effect is to
+store a value in @var{x}.  @var{x} must be a @samp{reg} expression.
 
 @item (parallel [@var{x0} @var{x1} @dots{}])
 Represents several side effects performed in parallel.  The square
 brackets stand for a vector; the operand of @samp{parallel} is a
 vector of expressions.  @var{x0}, @var{x1} and so on are individual
-side effects---expressions of code @samp{set}, @samp{call},
+side effect expressions---expressions of code @samp{set}, @samp{call},
 @samp{return}, @samp{clobber} or @samp{use}.@refill
 
 ``In parallel'' means that first all the values used in the individual
@@ -3939,16 +4709,34 @@ performed.  For example,
 says unambiguously that the values of hard register 1 and the memory
 location addressed by it are interchanged.  In both places where
 @code{(reg:SI 1)} appears as a memory address it refers to the value
-in register 1 @emph{before} the execution of the instruction.
+in register 1 @emph{before} the execution of the insn.
+
+It follows that it is @emph{incorrect} to use @samp{parallel} and
+expect the result of one @samp{set} to be available for the next one.
+For example, people sometimes attempt to represent a jump-if-zero
+instruction this way:
+
+@example
+(parallel [(set (cc0) (reg:SI 34))
+	   (set (pc) (if_then_else
+			(eq (cc0) (const_int 0))
+			(label_ref @dots{})
+			(pc)))])
+@end example
 
-Peephole optimization, which takes place in the last jump-optimization
-pass, can produce insns whose patterns consist of a @samp{parallel}
+@noindent
+But this is incorrect, because it says that the jump condition depends
+on the condition code value @emph{before} this instruction, not on the
+new value that is set by this instruction.
+
+Peephole optimization, which takes place in together with final assembly
+code output, can produce insns whose patterns consist of a @samp{parallel}
 whose elements are the operands needed to output the resulting
 assembler code--often @samp{reg}, @samp{mem} or constant expressions.
 This would not be well-formed RTL at any other stage in compilation,
 but it is ok then because no further optimization remains to be done.
-However, the definition of the macro @code{NOTICE_UPDATE_CC} may need
-to deal with such insns.
+However, the definition of the macro @code{NOTICE_UPDATE_CC} must
+deal with such insns if you define any peephole optimizations.
 
 @item (sequence [@var{insns} @dots{}])
 Represents a sequence of insns.  Each of the @var{insns} that appears
@@ -4048,7 +4836,7 @@ an @code{asm} statement with arguments.
 a single output operand, like this:
 
 @example
-asm ("foo %1,%2,%0" : "a" (outputvar) : "g" (x + y), "di" (*z));
+asm ("foo %1,%2,%0" : "=a" (outputvar) : "g" (x + y), "di" (*z));
 @end example
 
 @noindent
@@ -4109,7 +4897,7 @@ If @var{i} is the last insn, this is a n
 @end table
 
 The @code{NEXT_INSN} and @code{PREV_INSN} pointers must always
-correspond: if @var{i} is not the first insn,
+correspond: if @var{insn} is not the first insn,
 
 @example
 NEXT_INSN (PREV_INSN (@var{insn})) == @var{insn}
@@ -4186,9 +4974,24 @@ of debugging information.
 These types of notes indicate the position of the beginning and end
 of a @code{while} or @code{for} loop.  They enable the loop optimizer
 to find loops quickly.
+@item NOTE_INSN_FUNCTION_END
+Appears near the end of the function body, just before the label that
+@code{return} statements jump to (on machine where a single instruction
+does not suffice for returning).  This note may be deleted by jump
+optimization.
+@item NOTE_INSN_SETJMP
+Appears following each call to @code{setjmp} or a related function.
+
+@item NOTE_INSN_LOOP_BEG
+Appears at the place in a loop that @code{continue} statements jump to.
 @end table
+
+These codes are printed symbolically when they appear in debugging dumps.
 @end table
 
+The machine mode of an insn is normally zero (@code{VOIDmode}), but the
+reload pass sets it to @code{QImode} if the insn needs reloading.
+
 Here is a table of the extra fields of @samp{insn}, @samp{jump_insn}
 and @samp{call_insn} insns:
 
@@ -4196,10 +4999,13 @@ and @samp{call_insn} insns:
 @item PATTERN (@var{i})
 An expression for the side effect performed by this insn.
 
-@item REG_NOTES (@var{i})
-A list (chain of @samp{expr_list} expressions) giving information
-about the usage of registers in this insn.  This list is set up by the
-flow analysis pass; it is a null pointer until then.
+@item INSN_CODE (@var{i})
+An integer that says which pattern in the machine description matches
+this insn, or -1 if the matching has not yet been attempted.
+
+Such matching is never attempted and this field is not used on an insn
+whose pattern consists of a single @samp{use}, @samp{clobber},
+@samp{asm}, @samp{addr_vec} or @samp{addr_diff_vec} expression.
 
 @item LOG_LINKS (@var{i})
 A list (chain of @samp{insn_list} expressions) of previous ``related''
@@ -4208,13 +5014,10 @@ first time in this insn.  (An additional
 jump nor a label may come between the related insns).  This list is
 set up by the flow analysis pass; it is a null pointer until then.
 
-@item INSN_CODE (@var{i})
-An integer that says which pattern in the machine description matches
-this insn, or -1 if the matching has not yet been attempted.
-
-Such matching is never attempted and this field is not used on an insn
-whose pattern consists of a single @samp{use}, @samp{clobber},
-@samp{asm}, @samp{addr_vec} or @samp{addr_diff_vec} expression.
+@item REG_NOTES (@var{i})
+A list (chain of @samp{expr_list} expressions) giving information
+about the usage of registers in this insn.  This list is set up by the
+flow analysis pass; it is a null pointer until then.
 @end table
 
 The @code{LOG_LINKS} field of an insn is a chain of @samp{insn_list}
@@ -4226,12 +5029,12 @@ insns appear in it (as first operands of
 expressions).  Their order is not significant.
 
 The @code{REG_NOTES} field of an insn is a similar chain but of
-@samp{expr_list} expressions instead of @samp{insn_list}.  There are four
-kinds of register notes, which are distinguished by the machine mode of the
-@samp{expr_list}, which a register note is really understood as being an
-@code{enum reg_note}.  The first operand @var{op} of the @samp{expr_list}
-is data whose meaning depends on the kind of note.  Here are the four
-kinds:
+@samp{expr_list} expressions instead of @samp{insn_list}.  There are
+several kinds of register notes, which are distinguished by the machine
+mode of the @samp{expr_list}, which in a register note is really
+understood as being an @code{enum reg_note}.  The first operand @var{op}
+of the @samp{expr_list} is data whose meaning depends on the kind of
+note.  Here are the kinds of register note:
 
 @table @code
 @item REG_DEAD
@@ -4298,11 +5101,14 @@ The register @var{op} is known to have n
 insn is reached.
 @end table
 
-(The only difference between the expression codes @samp{insn_list} and
+For convenience, the machine mode in an @samp{insn_list} or
+@samp{expr_list} is printed using these symbolic codes in debugging dumps.
+
+The only difference between the expression codes @samp{insn_list} and
 @samp{expr_list} is that the first operand of an @samp{insn_list} is
 assumed to be an insn and is printed in debugging dumps as the insn's
 unique id; the first operand of an @samp{expr_list} is printed in the
-ordinary way as an expression.)
+ordinary way as an expression.
 
 @node Calls, Sharing, Insns, RTL
 @section RTL Representation of Function-Call Insns
@@ -4314,7 +5120,7 @@ RTL expression code, @samp{call}.
 A @samp{call} expression has two operands, as follows:
 
 @example
-(call @var{nbytes} (mem:@var{fm} @var{addr}))
+(call (mem:@var{fm} @var{addr}) @var{nbytes})
 @end example
 
 @noindent
@@ -4419,6 +5225,14 @@ the places they appear.  However, separa
 variables are occasionally made.
 
 @item
+When a single @code{asm} statement has multiple output operands,
+a distinct @code{asm_operands} RTX is made for each output operand.
+However, these all share the vector which contains the sequence of
+input operands.  Because this sharing is used later on to test whether
+two @code{asm_operands} RTX's come from the same statement, the sharing
+must be guaranteed to be preserved.
+
+@item
 No RTL object appears in more than one place in the RTL structure
 except as described above.  Many passes of the compiler rely on this
 by assuming that they can modify RTL objects in place without unwanted
@@ -4637,6 +5451,73 @@ It assumes that operand number @var{n} h
 a @samp{match_operand} appearing earlier in the recognition template,
 and it matches only an identical-looking expression.
 
+@item (match_operator:@var{m} @var{n} "@var{predicate}" [@var{operands}@dots{}])
+This pattern is a kind of placeholder for a variable RTL expression
+code.
+
+When constructing an insn, it stands for an RTL expression whose
+expression code is taken from that of operand @var{n}, and whose
+operands are constructed from the patterns @var{operands}.
+
+When matching an expression, it matches an expression if the function
+@var{predicate} returns nonzero on that expression @emph{and} the
+patterns @var{operands} match the operands of the expression.
+
+Suppose that the function @code{commutative_operator} is defined as
+follows, to match any expression whose operator is one of the six
+commutative arithmetic operators of RTL and whose mode is @var{mode}:
+
+@example
+int
+commutative_operator (x, mode)
+     rtx x;
+     enum machine_mode mode;
+@{
+  enum rtx_code code = GET_CODE (x);
+  if (GET_MODE (x) != mode)
+    return 0;
+  return (code == PLUS || code == MULT || code == UMULT
+          || code == AND || code == IOR || code == XOR);
+@}
+@end example
+
+Then the following pattern will match any RTL expression consisting
+of a commutative operator applied to two general operands:
+
+@example
+(match_operator:SI 2 "commutative_operator"
+  [(match_operand:SI 3 "general_operand" "g")
+   (match_operand:SI 4 "general_operand" "g")])
+@end example
+
+Here the vector @code{[@var{operands}@dots{}]} contains two patterns
+because the expressions to be matched all contain two operands.
+
+When this pattern does match, the two operands of the commutative
+operator are recorded as operands 3 and 4 of the insn.  (This is done
+by the two instances of @samp{match_operand}.)  Operand 2 of the insn
+will be the entire commutative expression: use @code{GET_CODE
+(operands[2])} to see which commutative operator was used.
+
+The machine mode @var{m} of @samp{match_operator} works like that of
+@samp{match_operand}: it is passed as the second argument to the
+predicate function, and that function is solely responsible for
+deciding whether the expression to be matched ``has'' that mode.
+
+When constructing an insn, argument 2 of the gen-function will specify
+the operation (i.e. the expression code) for the expression to be
+made.  It should be an RTL expression, whose expression code is copied
+into a new expression whose operands are arguments 3 and 4 of the
+gen-function.  The subexpressions of argument 2 are not used;
+only its expression code matters.
+
+There is no way to specify constraints in @samp{match_operator}.  The
+operand of the insn which corresponds to the @samp{match_operator}
+never has any constraints because it is never reloaded as a whole.
+However, if parts of its @var{operands} are matched by
+@samp{match_operand} patterns, those parts may have constraints of
+their own.
+
 @item (address (match_operand:@var{m} @var{n} "address_operand" ""))
 This complex of expressions is a placeholder for an operand number
 @var{n} in a ``load address'' instruction: an operand which specifies
@@ -4664,11 +5545,11 @@ expression.
 @node Output Template, Output Statement, RTL Template, Machine Desc
 @section Output Templates and Operand Substitution
 
-The @dfn{output template} is a string which specifies how to output
-the assembler code for an instruction pattern.  Most of the template
-is a fixed string which is output literally.  The character @samp{%}
-is used to specify where to substitute an operand; it can also be
-used to identify places different variants of the assembler require
+The @dfn{output template} is a string which specifies how to output the
+assembler code for an instruction pattern.  Most of the template is a
+fixed string which is output literally.  The character @samp{%} is used
+to specify where to substitute an operand; it can also be used to
+identify places where different variants of the assembler require
 different syntax.
 
 In the simplest case, a @samp{%} followed by a digit @var{n} says to output
@@ -4703,7 +5584,7 @@ defined in the @code{PRINT_OPERAND} macr
 The template may generate multiple assembler instructions.  Write the text
 for the instructions, with @samp{\;} between them.
 
-When the RTL contains two operand which are required by constraint to match
+When the RTL contains two operands which are required by constraint to match
 each other, the output template must refer only to the lower-numbered operand.
 Matching operands are not always identical, and the rest of the compiler
 arranges to put the proper RTL expression for printing into the lower-numbered
@@ -4746,7 +5627,7 @@ vector may be @code{operands}, or it may
 that you declare locally and initialize yourself.
 
 When an insn pattern has multiple alternatives in its constraints, often
-the appearance of the assembler code determined mostly by which alternative
+the appearance of the assembler code is determined mostly by which alternative
 was matched.  When this is so, the C code can test the variable
 @code{which_alternative}, which is the ordinal number of the alternative
 that was actually satisfied (0 for the first, 1 for the second alternative,
@@ -4912,7 +5793,8 @@ input-output operand.
 Matching constraints work only in circumstances like that add insn.
 More precisely, the matching constraint must appear in an input-only
 operand and the operand that it matches must be an output-only operand
-with a lower number.
+with a lower number.  Thus, operand @var{n} must have @samp{=} in its
+constraint.
 
 For operands to match in a particular case usually means that they
 are identical-looking RTL expressions.  But in a few special cases
@@ -5009,7 +5891,7 @@ registers is safe provided its predicate
 An operand whose predicate accepts only constant values is safe
 provided its constraints include the letter @samp{i}.  If any possible
 constant value is accepted, then nothing less than @samp{i} will do;
-if the predicate is more selective, than the constraints may also be
+if the predicate is more selective, then the constraints may also be
 more selective.
 
 @item
@@ -5086,12 +5968,12 @@ When operands must be copied into regist
 never choose this alternative as the one to strive for.
 @end table
 
-When an insn pattern has multiple alternatives in its constraints,
-often the appearance of the assembler code determined mostly by which
+When an insn pattern has multiple alternatives in its constraints, often
+the appearance of the assembler code is determined mostly by which
 alternative was matched.  When this is so, the C code for writing the
 assembler code can use the variable @code{which_alternative}, which is
-the ordinal number of the alternative that was actually satisfied
-(0 for the first, 1 for the second alternative, etc.).  For example:
+the ordinal number of the alternative that was actually satisfied (0 for
+the first, 1 for the second alternative, etc.).  For example:
 
 @example
 (define_insn ""
@@ -5218,7 +6100,9 @@ Address operands are identified by writi
 around the @samp{match_operand}, not by their constraints.
 
 When the machine description has just empty constraints, certain parts
-of compilation are skipped, making the compiler faster.
+of compilation are skipped, making the compiler faster.  However,
+few machines actually do not need constraints; all machine descriptions
+now in existence use constraints.
 
 @node Standard Names, Pattern Ordering, Constraints, Machine Desc
 @section Standard Names for Patterns Used in Generation
@@ -5360,8 +6244,8 @@ Compare operand 0 and operand 1, and set
 The RTL pattern should look like this:
 
 @example
-(set (cc0) (minus (match_operand:@var{m} 0 @dots{})
-                  (match_operand:@var{m} 1 @dots{})))
+(set (cc0) (compare (match_operand:@var{m} 0 @dots{})
+                    (match_operand:@var{m} 1 @dots{})))
 @end example
 
 Each such definition in the machine description, for integer mode
@@ -5381,6 +6265,8 @@ The RTL pattern should look like this:
 Block move instruction.  The addresses of the destination and source
 strings are the first two operands, and both are in mode @code{Pmode}.
 The number of bytes to move is the third operand, in mode @var{m}.
+The fourth operand is the known shared alignment of the source and
+destination, in the form of a @code{const_int} rtx.
 
 @item @samp{cmpstr@var{m}}
 Block compare instruction, with operands like @samp{movstr@var{m}}
@@ -5519,7 +6405,8 @@ The index to dispatch on, which has mode
 The lower bound for indices in the table, an integer constant.
 
 @item
-The upper bound for indices in the table, an integer constant.
+The total range of indices in the table---the largest index
+minus the smallest one (both inclusive).
 
 @item
 A label to jump to if the index has a value outside the bounds.
@@ -5661,7 +6548,7 @@ instruction.
 A ``compare'' instruction whose RTL looks like this:
 
 @example
-(set (cc0) (minus @var{operand} (const_int 0)))
+(set (cc0) (compare @var{operand} (const_int 0)))
 @end example
 
 @noindent
@@ -5754,7 +6641,7 @@ output a compare-and-branch instruction
 
 It also works to define patterns for compare-and-branch instructions.
 In optimizing compilation, the pair of compare and branch instructions
-will be combined accoprding to these patterns.  But this does not happen
+will be combined according to these patterns.  But this does not happen
 if optimization is not requested.  So you must use one of the solutions
 above in addition to any special patterns you define.
 
@@ -5789,9 +6676,9 @@ machine-specific information in this mac
 it must obey the same rules as in a @samp{define_insn}.
 
 In this skeleton, @var{insn-pattern-1} and so on are patterns to match
-consecutive instructions.  The optimization applies to a sequence of
-instructions when @var{insn-pattern-1} matches the first one,
-@var{insn-pattern-2} matches the next, and so on.@refill
+consecutive insns.  The optimization applies to a sequence of insns when
+@var{insn-pattern-1} matches the first one, @var{insn-pattern-2} matches
+the next, and so on.@refill
 
 @var{insn-pattern-1} and so on look @emph{almost} like the second operand
 of @code{define_insn}.  There is one important difference: this pattern is
@@ -5801,11 +6688,11 @@ vector.  If the @code{define_insn} patte
 then the @var{insn-pattern} must place the vector inside an explicit
 @code{parallel} RTX.@refill
 
-The operands of the instructions are matched with @code{match_operands} and
-@code{match_dup}, as usual).  What is not usual is that the operand numbers
-apply to all the instruction patterns in the definition.  So, you can check
-for identical operands in two instructions by using @code{match_operand}
-in one instruction and @code{match_dup} in the other.
+The operands of the insns are matched with @code{match_operands} and
+@code{match_dup}, as usual.  What is not usual is that the operand numbers
+apply to all the insn patterns in the definition.  So, you can check for
+identical operands in two insns by using @code{match_operand} in one insn
+and @code{match_dup} in the other.
 
 The operand constraints used in @code{match_operand} patterns do not have
 any direct effect on the applicability of the optimization, but they will
@@ -5813,16 +6700,17 @@ be validated afterward, so write constra
 the optimization is applied.  It is safe to use @code{"g"} for each
 operand.
 
-Once a sequence of instructions matches the patterns, the @var{condition}
-is checked.  This is a C expression which makes the final decision whether
-to perform the optimization (do so if the expression is nonzero).  If
+Once a sequence of insns matches the patterns, the @var{condition} is
+checked.  This is a C expression which makes the final decision whether to
+perform the optimization (we do so if the expression is nonzero).  If
 @var{condition} is omitted (in other words, the string is empty) then the
-optimization is applied to every sequence of instructions that matches the
+optimization is applied to every sequence of insns that matches the
 patterns.
 
-The defined peephole optimizations are applied after register allocation is
-complete.  Therefore, the optimizer can check which operands have ended up
-in which kinds of registers, just by looking at the operands.
+The defined peephole optimizations are applied after register allocation
+is complete.  Therefore, the peephole definition can check which
+operands have ended up in which kinds of registers, just by looking at
+the operands.
 
 The way to refer to the operands in @var{condition} is to write
 @code{operands[@var{i}]} for operand number @var{i} (as matched by
@@ -5839,20 +6727,19 @@ be used for the last time (from the valu
 of @code{PREV_INSN}), and @var{op} is the intermediate value (from
 @code{operands[@var{i}]}).@refill
 
-Applying the optimization means replacing the sequence of instructions with
-one new instruction.  The @var{template} controls ultimate output of
-assembler code for this combined instruction.  It works exactly like the
-template of a @code{define_insn}.  Operand numbers in this template are the
-same ones used in matching the original sequence of instructions.
+Applying the optimization means replacing the sequence of insns with one
+new insn.  The @var{template} controls ultimate output of assembler code
+for this combined insn.  It works exactly like the template of a
+@code{define_insn}.  Operand numbers in this template are the same ones
+used in matching the original sequence of insns.
 
 The result of a defined peephole optimizer does not need to match any of
-the instruction patterns, and it does not have an opportunity to match
-them.  The peephole optimizer definition itself serves as the instruction
-pattern to control how the instruction is output.
-
-Defined peephole optimizers are run in the last jump optimization pass, so
-the instructions they produce are never combined or rearranged
-automatically in any way.
+the insn patterns in the machine description; it does not even have an
+opportunity to match them.  The peephole optimizer definition itself serves
+as the insn pattern to control how the insn is output.
+
+Defined peephole optimizers are run as assembler code is being output,
+so the insns they produce are never combined or rearranged in any way.
 
 Here is an example, taken from the 68000 machine description:
 
@@ -5899,6 +6786,18 @@ movel d0,sp@@-
 fmoved sp@@+,fp0
 @end example
 
+@ignore
+If a peephole matches a sequence including one or more jump insns, you must
+take account of the flags such as @code{CC_REVERSED} which specify that the
+condition codes are represented in an unusual manner.  The compiler
+automatically alters any ordinary conditional jumps which occur in such
+situations, but the compiler cannot alter jumps which have been replaced by
+peephole optimizations.  So it is up to you to alter the assembler code
+that the peephole produces.  Supply C code to write the assembler output,
+and in this C code check the condition code status flags and change the
+assembler code as appropriate.
+@end ignore
+
 @node Expander Definitions,, Peephole Definitions, Machine Desc
 @section Defining RTL Sequences for Code Generation
 
@@ -6074,6 +6973,7 @@ compiler source files include @file{conf
 * Addressing Modes::    Defining addressing modes valid for memory operands.
 * Condition Code::      Defining how insns update the condition code.
 * Assembler Format::    Defining how to write insns and pseudo-ops to output.
+* Cross-compilation::   Handling floating point for cross-compilers.
 * Misc::                Everything else.
 @end menu
 
@@ -6087,12 +6987,21 @@ define the predefined macros that identi
 These macros will be predefined unless the @samp{-ansi} option is
 specified.
 
-For example, on the Sun, one can use the value
+In addition, a parallel set of macros are predefined, whose names are
+made by appending @samp{__} at the beginning and at the end.  These
+@samp{__} macros are permitted by the ANSI standard, so they are
+predefined regardless of whether @samp{-ansi} is specified.
+
+For example, on the Sun, one can use the following value:
 
 @example
 "-Dmc68000 -Dsun -Dunix"
 @end example
 
+The result is to define the macros @samp{__mc68000__}, @samp{__sun__}
+and @samp{__unix__} unconditionally, and the macros @samp{mc68000},
+@samp{sun} and @samp{unix} provided @samp{-ansi} is not specified.
+
 @item CPP_SPEC
 A C string constant that tells the GNU CC driver program options to
 pass to CPP.  It can also specify how to translate options you
@@ -6204,7 +7113,19 @@ Width of a pointer, in bits.
 Alignment required for pointers stored in memory, in bits.
 
 @item PARM_BOUNDARY
-Alignment required for function parameters on the stack, in bits.
+Normal alignment required for function parameters on the stack, in
+bits.  All stack parameters receive least this much alignment
+regardless of data type.  On most machines, this is the same as the
+size of an integer.
+
+@item MAX_PARM_BOUNDARY
+Largest alignment required for any stack parameters, in bits.  If the
+data type of the parameter calls for more alignment than
+@code{PARM_BOUNDARY}, then it is given extra padding up to this limit.
+
+Don't define this macro if it would be equal to @code{PARM_BOUNDARY};
+in other words, if the alignment of a stack parameter should not
+depend on its data type (as is the case on most machines).
 
 @item STACK_BOUNDARY
 Define this macro if you wish to preserve a certain alignment for
@@ -6243,6 +7164,11 @@ Just what effect that is in GNU CC depen
 most machines it would force the structure's alignment and size to a
 multiple of 32 or @code{BIGGEST_ALIGNMENT} bits.
 
+@item MAX_FIXED_MODE_SIZE
+An integer expression for the largest integer machine mode that should
+actually be used.  All integer machine modes of this size or smaller
+can be used for structures and unions with the appropriate sizes.
+
 @item CHECK_FLOAT_VALUE (@var{mode}, @var{value})
 A C statement to validate the value @var{value} (or type
 @code{double}) for mode @var{mode}.  This means that you check whether
@@ -6299,6 +7225,13 @@ If a register has 0 in @code{CALL_USED_R
 automatically saves it on function entry and restores it on function
 exit, if the register is used within the function.
 
+@item DEFAULT_CALLER_SAVES
+Define this macro if the target machine if function calls do not preserve
+any registers; in other words, if @code{CALL_USED_REGISTERS} has 1
+for all registers.  This macro enables @samp{-fcaller-saves} by default.
+Eventually that option will be enabled by default on all machines and both
+the option and this macro will be eliminated.
+
 @item CONDITIONAL_REGISTER_USAGE
 Zero or more C statements that may conditionally modify two variables
 @code{fixed_regs} and @code{call_used_regs} (both of type @code{char
@@ -6310,9 +7243,9 @@ on target flags.
 You need not define this macro if it has no work to do.
 
 If the usage of an entire class of registers depends on the target
-flags, you may indicate this to gcc by using this macro to modify
+flags, you may indicate this to GCC by using this macro to modify
 @code{fixed_regs} and @code{call_used_regs} to 1 for each of the
-registers in the classes which should not be used by gcc.  Also define
+registers in the classes which should not be used by GCC.  Also define
 the macro @code{REG_CLASS_FROM_LETTER} to return @code{NO_REGS} if it
 is called with a letter for a class that shouldn't be used.
 
@@ -6322,15 +7255,15 @@ controlled by target switches, then GCC
 these registers when the target switches are opposed to them.)
 
 @item OVERLAPPING_REGNO_P (@var{regno})
-If defined, this is a C expression whose value is @var{regno} is
-nonzero if hard register number @var{regno} is an overlapping
-register.  This means a hard register which overlaps a hard register
-with a different number.  (Such overlap is undesirable, but
-occasionally it allows a machine to be supported which otherwise could
-not be.)  This macro must return nonzero for @emph{all} the registers
-which overlap each other.  GNU CC can use an overlapping register only
-in certain limited ways.  It can be used for allocation within a basic
-block, and may be spilled for reloading; that is all.
+If defined, this is a C expression whose value is nonzero if hard
+register number @var{regno} is an overlapping register.  This means a
+hard register which overlaps a hard register with a different number.
+(Such overlap is undesirable, but occasionally it allows a machine to
+be supported which otherwise could not be.)  This macro must return
+nonzero for @emph{all} the registers which overlap each other.  GNU CC
+can use an overlapping register only in certain limited ways.  It can
+be used for allocation within a basic block, and may be spilled for
+reloading; that is all.
 
 If this macro is not defined, it means that none of the hard registers
 overlap each other.  This is the usual situation.
@@ -6461,9 +7394,9 @@ machine allows code to be generated with
 so saves some time or space.  Use 1 when there is no possible
 advantage to avoiding a frame pointer.
 
-In certain cases, the compiler does not know how to do without a frame
-pointer.  The compiler recognizes those cases and automatically gives
-the function a frame pointer regardless of what
+In certain cases, the compiler does not know how to produce valid code
+without a frame pointer.  The compiler recognizes those cases and
+automatically gives the function a frame pointer regardless of what
 @code{FRAME_POINTER_REQUIRED} says.  You don't need to worry about
 them.@refill
 
@@ -6804,6 +7737,26 @@ of the first parameter's shadow location
 pointer value.  (That value is itself computed by adding the value of
 @code{STACK_POINTER_OFFSET} to the stack pointer register.)
 
+@item STACK_ARGS_ADJUST (@var{size})
+Define this macro if the machine requires padding on the stack for
+certain function calls.  This is padding on a per-function-call basis,
+not padding for individual arguments.
+
+The argument @var{size} will be a C variable of type @code{struct
+arg_data} which contains two fields, an integer named @code{constant}
+and an RTX named @code{var}.  These together represent a size measured
+in bytes which is the sum of the integer and the RTX.  Most of the
+time @code{var} is 0, which means that the size is simply the integer.
+
+The definition should be a C statement or compound statement
+which alters the variable supplied in whatever way you wish.
+
+Note that the value you leave in the variable @code{size} will
+ultimately be rounded up to a multiple of @code{STACK_BOUNDARY} bits.
+
+This macro is not fully implemented for machines which have push
+instructions (i.e., on which @code{PUSH_ROUNDING} is defined).
+
 @item RETURN_POPS_ARGS (@var{funtype})
 A C expression that should be 1 if a function pops its own arguments
 on returning, or 0 if the function pops no arguments and the caller
@@ -6860,6 +7813,19 @@ to tell the function where to put the va
 If @code{FUNCTION_OUTGOING_VALUE} is not defined,
 @code{FUNCTION_VALUE} serves both purposes.@refill
 
+@item RETURN_IN_MEMORY (@var{type})
+A C expression which can inhibit the returning of certain function
+values in registers, based on the type of value.  A nonzero value says
+to return the function value in memory, just as large structures are
+always returned.  Here @var{type} will be a C expression of type
+@code{tree}, representing the data type of the value.
+
+Note that values of mode @code{BLKmode} are returned in memory
+regardless of this macro.  Also, the option @samp{-fpcc-struct-return}
+takes effect regardless of this macro.  On most systems, it is
+possible to leave the macro undefined; this causes a default
+definition to be used, whose value is the constant 0.
+
 @item LIBCALL_VALUE (@var{mode})
 A C expression to create an RTX representing the place where a library
 function returns a value of mode @var{mode}.  If the precise function
@@ -6956,11 +7922,11 @@ for the data type of the function which
 if the args are to a compiler support library function.
 
 @item FUNCTION_ARG_ADVANCE (@var{cum}, @var{mode}, @var{type}, @var{named})
-Update the summarizer variable @var{cum} to advance past an argument
-in the argument list.  The values @var{mode}, @var{type} and
-@var{named} describe that argument.  Once this is done, the variable
-@var{cum} is suitable for analyzing the @emph{following} argument
-with @code{FUNCTION_ARG}, etc.@refill
+A C statement (sans semicolon) to update the summarizer variable
+@var{cum} to advance past an argument in the argument list.  The
+values @var{mode}, @var{type} and @var{named} describe that argument.
+Once this is done, the variable @var{cum} is suitable for analyzing
+the @emph{following} argument with @code{FUNCTION_ARG}, etc.@refill
 
 @item FUNCTION_ARG_REGNO_P (@var{regno})
 A C expression that is nonzero if @var{regno} is the number of a hard
@@ -7027,6 +7993,45 @@ figure them out, compile a small program
 system's installed C compiler and look at the assembler code that
 results.
 
+@item FUNCTION_BLOCK_PROFILER (@var{file}, @var{labelno})
+A C statement or compound statement to output to @var{file} some
+assembler code to initialize basic-block profiling for the current
+object module.  This code should call the subroutine
+@code{__bb_init_func} once per object module, passing it as its sole
+argument the address of a block allocated in the object module.
+
+The name of the block is a local symbol made with this statement:
+
+@example
+ASM_GENERATE_INTERNAL_LABEL (@var{buffer}, "LPBX", 0);
+@end example
+
+Of course, since you are writing the definition of
+@code{ASM_GENERATE_INTERNAL_LABEL} as well as that of this macro, you
+can take a short cut in the definition of this macro and use the name
+that you know will result.
+
+The first word of this block is a flag which will be nonzero if the
+object module has already been initialized.  So test this word first,
+and do not call @code{__bb_init_func} if the flag is nonzero.
+
+@item BLOCK_PROFILER (@var{file}, @var{blockno})
+A C statement or compound statement to increment the count associated
+with the basic block number @var{blockno}.  Basic blocks are numbered
+separately from zero within each compilation.  The count associated
+with block number @var{blockno} is at index @var{blockno} in a vector
+of words; the name of this array is a local symbol made with this
+statement:
+
+@example
+ASM_GENERATE_INTERNAL_LABEL (@var{buffer}, "LPBX", 2);
+@end example
+
+Of course, since you are writing the definition of
+@code{ASM_GENERATE_INTERNAL_LABEL} as well as that of this macro, you
+can take a short cut in the definition of this macro and use the name
+that you know will result.
+
 @item EXIT_IGNORES_STACK
 Define this macro as a C expression that is nonzero if the return
 instruction or the function epilogue ignores the value of the stack
@@ -7100,17 +8105,41 @@ executed at run time, so it may be empty
 @section Library Subroutine Names
 
 @table @code
+@item MULSI3_LIBCALL
+A C string constant giving the name of the function to call for
+multiplication of one signed full-word by another.  If you do not
+define this macro, the default name is used, which is @code{__mulsi3},
+a function defined in @file{gnulib}.
+
+@item UMULSI3_LIBCALL
+A C string constant giving the name of the function to call for
+multiplication of one unsigned full-word by another.  If you do not
+define this macro, the default name is used, which is
+@code{__umulsi3}, a function defined in @file{gnulib}.
+
+@item DIVSI3_LIBCALL
+A C string constant giving the name of the function to call for
+division of one signed full-word by another.  If you do not define
+this macro, the default name is used, which is @code{__divsi3}, a
+function defined in @file{gnulib}.
+
 @item UDIVSI3_LIBCALL
 A C string constant giving the name of the function to call for
-division of a full-word by a full-word.  If you do not define this
-macro, the default name is used, which is @code{_udivsi3}, a function
-defined in @file{gnulib}.
+division of one unsigned full-word by another.  If you do not define
+this macro, the default name is used, which is @code{__udivsi3}, a
+function defined in @file{gnulib}.
+
+@item MODSI3_LIBCALL
+A C string constant giving the name of the function to call for the
+remainder in division of one signed full-word by another.  If you do
+not define this macro, the default name is used, which is
+@code{__modsi3}, a function defined in @file{gnulib}.
 
 @item UMODSI3_LIBCALL
 A C string constant giving the name of the function to call for the
-remainder in division of a full-word by a full-word.  If you do not
-define this macro, the default name is used, which is @code{_umodsi3},
-a function defined in @file{gnulib}.
+remainder in division of one unsigned full-word by another.  If you do
+not define this macro, the default name is used, which is
+@code{__umodsi3}, a function defined in @file{gnulib}.
 
 @item TARGET_MEM_FUNCTIONS
 Define this macro if GNU CC should generate calls to the System V
@@ -7118,7 +8147,7 @@ Define this macro if GNU CC should gener
 rather than the BSD functions @code{bcopy} and @code{bzero}.
 @end table
 
-@node Addressing Modes, Misc, Library Names, Machine Macros
+@node Addressing Modes, Cross-compilation, Library Names, Machine Macros
 @section Addressing Modes
 
 @table @code
@@ -7177,7 +8206,7 @@ need have two variants; the higher level
 whether strict or not.@refill
 
 @item REG_OK_FOR_BASE_P (@var{x})
-A C expression that is nonzero if @var{x} (asumed to be a @code{reg}
+A C expression that is nonzero if @var{x} (assumed to be a @code{reg}
 RTX) is valid for use as a base register.  For hard registers, it
 should always accept those which the hardware permits and reject the
 others.  Whether the macro accepts or rejects pseudo registers must be
@@ -7186,7 +8215,7 @@ requires two variant definitions, of whi
 controls the one actually used.
 
 @item REG_OK_FOR_INDEX_P (@var{x})
-A C expression that is nonzero if @var{x} (asumed to be a @code{reg}
+A C expression that is nonzero if @var{x} (assumed to be a @code{reg}
 RTX) is valid for use as an index register.
 
 The difference between an index register and a base register is that
@@ -7245,7 +8274,106 @@ either @var{x} is a @samp{const_double}
 @samp{const_double} is valid and anything @code{CONSTANT_P} is valid.@refill
 @end table
 
-@node Misc, Condition Code, Addressing Modes, Machine Macros
+@node Cross-compilation, Misc, Addressing Modes, Machine Macros
+@section Cross Compilation and Floating-Point Format
+
+While all modern machines use 2's compliment representation for integers,
+there are a variety of representations for floating point numbers.  This
+means that in a cross-compiler the representation of floating point numbers
+in the compiled program may be different from that used in the machine
+doing the compilation.
+
+Because different representation systems may offer different amounts of
+range and precision, the cross compiler cannot safely use the host
+machine's floating point arithmetic.  Therefore, floating point constants
+must be represented in the target machine's format.  This means that the
+cross compiler cannot use @code{atof} to parse a floating point constant;
+it must have its own special routine to use instead.  Also, constant
+folding must emulate the target machine's arithmetic (or must not be done
+at all).
+
+The macros in the following table should be defined only if you are cross
+compiling between different floating point formats.
+
+Otherwise, don't define them. Then default definitions will be set up which
+use @code{double} as the data type, @code{==} to test for equality, etc.
+
+You don't need to worry about how many times you use an operand of any
+of these macros.  The compiler never uses operands which have side effects.
+
+@table @code
+@item REAL_VALUE_TYPE
+A macro for the C data type to be used to hold a floating point value
+in the target machine's format.  Typically this would be a
+@code{struct} containing an array of @code{int}.
+
+@item REAL_VALUES_EQUAL (@var{x}, @var{y})
+A macro for a C expression which compares for equality the two values,
+@var{x} and @var{y}, both of type @code{REAL_VALUE_TYPE}.
+
+@item REAL_VALUES_LESS (@var{x}, @var{y})
+A macro for a C expression which tests whether @var{x} is less than
+@var{y}, both values being of type @code{REAL_VALUE_TYPE} and
+interpreted as floating point numbers in the target machine's
+representation.
+
+@item REAL_VALUE_LDEXP (@var{x}, @var{scale})
+A macro for a C expression which performs the standard library
+function @code{ldexp}, but using the target machine's floating point
+representation.  Both @var{x} and the value of the expression have
+type @code{REAL_VALUE_TYPE}.  The second argument, @var{scale}, is an
+integer.
+
+@item REAL_VALUE_ATOF (@var{string})
+A macro for a C expression which converts @var{string}, an expression
+of type @code{char *}, into a floating point number in the target
+machine's representation.  The value has type @code{REAL_VALUE_TYPE}.
+@end table
+
+Define the following additional macros if you want to make floating
+point constant folding work while cross compiling.  If you don't
+define them, cross compilation is still possible, but constant folding
+will not happen for floating point values.
+
+@table @code
+@item REAL_ARITHMETIC (@var{output}, @var{code}, @var{x}, @var{y})
+A macro for a C statement which calculates an arithmetic operation of
+the two floating point values @var{x} and @var{y}, both of type
+@code{REAL_VALUE_TYPE} in the target machine's representation, to
+produce a result of the same type and representation which is stored
+in @var{output} (which will be a variable).
+
+The operation to be performed is specified by @var{code}, a tree code
+which will always be one of the following: @code{PLUS_EXPR},
+@code{MINUS_EXPR}, @code{MULT_EXPR}, @code{RDIV_EXPR},
+@code{MAX_EXPR}, @code{MIN_EXPR}.@refill
+
+The expansion of this macro is responsible for checking for overflow.
+If overflow happens, the macro expansion should execute the statement
+@code{return 0;}, which indicates the inability to perform the
+arithmetic operation requested.
+
+@item REAL_VALUE_NEGATE (@var{x})
+A macro for a C expression which returns the negative of the floating
+point value @var{x}.  Both @var{x} and the value of the expression
+have type @code{REAL_VALUE_TYPE} and are in the target machine's
+floating point representation.
+
+There is no way for this macro to report overflow, since overflow
+can't happen in the negation operation.
+
+@item REAL_VALUE_TO_INT (@var{low}, @var{high}, @var{x})
+A macro for a C expression which converts a floating point value
+@var{x} into a double-precision integer which is then stored into
+@var{low} and @var{high}, two variables of type @var{int}.
+
+@item REAL_VALUE_FROM_INT (@var{x}, @var{low}, @var{high})
+A macro for a C expression which converts a double-precision integer
+found in @var{low} and @var{high}, two variables of type @var{int},
+into a floating point value which is then stored into @var{x}.
+@end table
+
+@node Misc, Condition Code, Cross-compilation, Machine Macros
 @section Miscellaneous Parameters
 
 @table @code
@@ -7290,9 +8418,9 @@ and @samp{-funsigned-char}.
 Define this if the preprocessor should ignore @code{#sccs} directives
 and print no error message.
 
-@item IDENT_DIRECTIVE
-Define this if the preprocessor should ignore @code{#ident} directives
-and print no error message.
+@item HAVE_VPRINTF
+Define this if the library function @code{vprintf} is available on your
+system.
 
 @item MOVE_MAX
 The maximum number of bytes that a single instruction can move quickly
@@ -7392,6 +8520,31 @@ obtained with @code{GET_CODE (@var{x})}.
 @item DOLLARS_IN_IDENTIFIERS
 Define this to be nonzero if the character @samp{$} should be allowed
 by default in identifier names.
+
+@item USE_C_ALLOCA
+Define this macro to indicate that the compiler is running with the
+@code{alloca} implemented in C.  This version of @code{alloca} can be
+found in the file @file{alloca.c}; to use it, you must also edit the
+@file{Makefile}.
+
+This macro, unlike most, describes the machine that the compiler is
+running on, rather than the one the compiler is compiling for.
+Therefore, it should be set in the @file{xm-@var{machine}.h} file
+rather than in the @file{xm-@var{machine}.h} file.
+
+If you do define this macro, you should probably do it as follows:
+
+@example
+#ifndef __GNUC__
+#define USE_C_ALLOCA
+#else
+#deifne alloca __builtin_alloca
+#endif
+@end example
+
+@noindent
+so that when the compiler is compiled with GNU CC it uses the more
+efficient built-in @code{alloca} function.
 @end table
 
 @node Condition Code, Assembler Format, Misc, Machine Macros
@@ -7481,6 +8634,26 @@ the very beginning of the command given
 If this macro is not defined, a default is provided that loads the
 standard C startup file from the usual place.  See @file{gcc.c}.
 
+@item STANDARD_EXEC_PREFIX
+Define this macro as a C string constant if you wish to override the
+standard choice of @file{/usr/local/lib/gcc-} as the default prefix to
+try when searching for the executable files of the compiler.
+
+The prefix specified by the @samp{-B} option, if any, is tried before
+the default prefix.  After the default prefix, if the executable is
+not found that way, @file{/usr/lib/gcc-} is tried next; then the
+directories in your search path for shell commands are searched.
+
+@item STANDARD_STARTFILE_PREFIX
+Define this macro as a C string constant if you wish to override the
+standard choice of @file{/usr/local/lib/} as the default prefix to try
+when searching for startup files such as @file{crt0.o}.
+
+In this search, all the prefixes tried for executable files are tried
+first.  Then comes the default startfile prefix specified by this
+macro, followed by the prefixes @file{/lib/} and @file{/usr/lib/} as
+last resorts.
+
 @item ASM_FILE_START (@var{stream})
 A C expression which outputs to the stdio stream @var{stream}
 some appropriate text to go at the start of an assembler file.
@@ -7655,6 +8828,15 @@ insn, and @var{num} is the label-number
 If this macro is not defined, nothing special is output at the end of
 the jump-table.
 
+@item ASM_OUTPUT_ALIGN_CODE (@var{file})
+A C expression to output text to align the location counter in the way
+that is desirable at a point in the code that is reached only by
+jumping.
+
+This macro need not be defined if you don't want any special alignment
+to be done at such a time.  Most machine descriptions do not currently
+define the macro.
+
 @item ASM_FORMAT_PRIVATE_NAME (@var{outvar}, @var{name}, @var{number})
 A C expression to assign to @var{outvar} (which is a variable of type
 @code{char *}) a newly allocated string made from the string
@@ -7760,24 +8942,28 @@ A C statement to output to the stdio str
 instruction to advance the location counter to a multiple of 2 to the
 @var{power} bytes.  @var{power} will be a C expression of type @code{int}.
 
-@item ASM_OUTPUT_COMMON (@var{stream}, @var{name}, @var{size})
+@item ASM_OUTPUT_COMMON (@var{stream}, @var{name}, @var{size}, @var{rounded})
 A C statement (sans semicolon) to output to the stdio stream
-@var{stream} the assembler definition of a common-label named @var{name}
-whose size is @var{size} bytes.  Use the expression
-@code{assemble_name (@var{stream}, @var{name})} to output the name
-itself; before and after that, output the additional assembler syntax
-for defining the name, and a newline.
+@var{stream} the assembler definition of a common-label named
+@var{name} whose size is @var{size} bytes.  The variable @var{rounded}
+is the size rounded up to whatever alignment the caller wants.
+
+Use the expression @code{assemble_name (@var{stream}, @var{name})} to
+output the name itself; before and after that, output the additional
+assembler syntax for defining the name, and a newline.
 
 This macro controls how the assembler definitions of uninitialized
 global variables are output.
 
-@item ASM_OUTPUT_LOCAL (@var{stream}, @var{name}, @var{size})
+@item ASM_OUTPUT_LOCAL (@var{stream}, @var{name}, @var{size}, @var{rounded})
 A C statement (sans semicolon) to output to the stdio stream
 @var{stream} the assembler definition of a local-common-label named
-@var{name} whose size is @var{size} bytes.  Use the expression
-@code{assemble_name (@var{stream}, @var{name})} to output the name
-itself; before and after that, output the additional assembler syntax
-for defining the name, and a newline.
+@var{name} whose size is @var{size} bytes.  The variable @var{rounded}
+is the size rounded up to whatever alignment the caller wants.
+
+Use the expression @code{assemble_name (@var{stream}, @var{name})} to
+output the name itself; before and after that, output the additional
+assembler syntax for defining the name, and a newline.
 
 This macro controls how the assembler definitions of uninitialized
 static variables are output.
@@ -7793,10 +8979,7 @@ information for the debugger in use is a
 @item ASM_OUTPUT_IDENT (@var{stream}, @var{string})
 A C statement to output something to the assembler file to handle a
 @samp{#ident} directive containing the text @var{string}.  If this
-macro is not defined, the assembler code @samp{.ident "@var{string}"}
-will be output by default.
-
-This macro is significant only if @code{IDENT_DIRECTIVE} is defined.
+macro is not defined, nothing is output for a @samp{#ident} directive.
 
 @item TARGET_BELL
 A C constant expression for the integer value for escape sequence
@@ -7900,10 +9083,10 @@ definitions are correct for most assembl
 @node Config,, Machine Macros, Top
 @chapter The Configuration File
 
-The configuration file @file{config-@var{machine}.h} contains macro
-definitions that describe the machine and system on which the compiler is
-running.  Most of the values in it are actually the same on all machines
-that GNU CC runs on, so most all configuration files are identical.  But
+The configuration file @file{xm-@var{machine}.h} contains macro definitions
+that describe the machine and system on which the compiler is running.
+Most of the values in it are actually the same on all machines that GNU CC
+runs on, so large parts of all configuration files are identical.  But
 there are some macros that vary:
 
 @table @code
@@ -7916,5 +9099,10 @@ A C expression for the status code to be
 exits without serious errors.
 @end table
 
+In addition, configuration files for system V define @code{bcopy},
+@code{bzero} and @code{bcmp} as aliases.  Some files define @code{alloca}
+as a macro when compiled with GNU CC, in order to take advantage of the
+benefit of GNU CC's built-in @code{alloca}.
+
 @contents
 @bye