This commit was manufactured by cvs2svn to create tag

'gcc-2_8_1-RELEASE'.

From-SVN: r18395

gcc/COPYING

@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU 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.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), 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 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 show them these terms so they know their
+rights.
+
+  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.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License 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 derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. 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 License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+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.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary 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
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing 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 for copying, distributing or modifying
+the Program or works based on it.
+
+  6. 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.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. 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 this 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
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. 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.
+
+			    NO WARRANTY
+
+  11. 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.
+
+  12. 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 OF TERMS AND CONDITIONS
+
+	    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 the public, 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.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) 19yy  <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 2 of the License, 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+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:
+
+    Gnomovision version 69, Copyright (C) 19yy 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.
+
+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 is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

gcc/COPYING.LIB

@@ -0,0 +1,482 @@
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+ 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), 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 library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, so that any problems introduced by others will not reflect on
+the original authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete 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 License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  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.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the source code distributed need not include anything that is normally
+distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library 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 Library
+specifies a version number of this 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 Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+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.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "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
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. 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 LIBRARY 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
+LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+     Appendix: How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  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.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+    MA 02111-1307, USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!

gcc/NEWS

@@ -1,71 +1,256 @@
-Noteworthy changes in GCC version 2.8.0:
+Noteworthy changes in GCC version 2.8.1
+---------------------------------------
 
-The -specs=file switch allows you to override default specs used in invoking
-programs like cc1, as, etc.
+Numerous bugs have been fixed and some minor performance
+improvements (compilation speed) have been made.
 
-The following new targets are supported:
+Noteworthy changes in GCC version 2.8.0
+---------------------------------------
 
-    Solaris 2.5 running on UltraSPARC's.
-    The sparclet cpu (a.out file format).
-    Solaris 2.51 running on PowerPC's.
-    Linux running on PowerPC's.
+A major change in this release is the addition of a framework for
+exception handling, currently used by C++.  Many internal changes and
+optimization improvements have been made.  These increase the
+maintainability and portability of GCC.  GCC now uses autoconf to
+compute many host parameters.
 
-New features for the Hitachi H8/300(H).
+A new project, egcs (pronounced ``eggs''), is maintaining an
+experimental version of the GNU C compiler.  The egcs compiler
+contains features that are candidates for inclusion in future versions
+of GCC.  The standard GCC distribution is intended to contain a mature
+compiler that is stable and reliable; egcs aims at making experimental
+changes available to interested users at an earlier stage in their
+development process than would be appropriate for a production
+compiler.  Please see <http://www.cygnus.com/egcs/> for more
+information about egcs.  A major motivation for the egcs project was
+the long release cycle for GCC 2.8.0.  This was due to changes for
+exception handling that took a long time to complete.  In the future,
+changes of this nature can be developed in the egcs framework and not
+interfere with the frequent releases of the standard GCC distribution.
 
-    -malign-300
-    -ms
+Due to a bug fix related to exception handling, if you have previously
+built a sharable library with some recent unofficial versions of GCC
+on some systems and then rebuild the library with GCC 2.8.0, programs
+previously linked with that library may fail during initialization
+with a message about an undefined symbols __register_frame.  If that
+happens, you must either relink the application or rebuild the
+sharable library with "-Wl,-u,__register_frame" on the command line.
 
-The -ms switch generates code for the Hitachi H8/S processor.
+The following lists changes that add new features or targets.
+
+See cp/NEWS for new features of C++ in this release.
+
+New tools and features:
+
+    The Dwarf 2 debugging information format is supported on ELF systems, and
+    is the default for -ggdb where available.  It can also be used for C++.
+    The Dwarf version 1 debugging format is also permitted for C++, but
+    does not work well.
+
+    gcov.c is provided for test coverage analysis and branch profiling
+    analysis is also supported; see -fprofile-arcs, -ftest-coverage,
+    and -fbranch-probabilities.
+
+    Support for the Checker memory checking tool.
+
+    New switch, -fstack-check, to check for stack overflow on systems that
+    don't have such built into their ABI.
+
+    New switches, -Wundef and -Wno-undef to warn if an undefined identifier
+    is evaluated in an #if directive.
+
+    Options -Wall and -Wimplicit now cause GCC to warn about implicit int
+    in declarations (e.g. `register i;'), since the C Standard committee
+    has decided to disallow this in the next revision of the standard;
+    -Wimplicit-function-declarations and -Wimplicit-int are subsets of
+    this.
+
+    Option -Wsign-compare causes GCC to warn about comparison of signed and
+    unsigned values.
+
+    Add -dI option of cccp for cxref.
+
+New features in configuration, installation and specs file handling:
+
+    New option --enable-c-cpplib to configure script.
+
+    You can use --with-cpu on the configure command to specify the default
+    CPU that GCC should generate code for.
+
+    The -specs=file switch allows you to override default specs used in
+    invoking programs like cc1, as, etc.
+
+    Allow including one specs file from another and renaming a specs
+    variable.
+
+    You can now relocate all GCC files with a single environment variable
+    or a registry entry under Windows 95 and Windows NT.
+
+Changes in Objective-C:
+
+    The Objective-C Runtime Library has been made thread-safe.
+
+    The Objective-C Runtime Library contains an interface for creating
+    mutexes, condition mutexes, and threads; it requires a back-end
+    implementation for the specific platform and/or thread package.
+    Currently supported are DEC/OSF1, IRIX, Mach, OS/2, POSIX, PCThreads,
+    Solaris, and Windows32.  The --enable-threads parameter can be used
+    when configuring GCC to enable and select a thread back-end.
+
+    Objective-C is now configured as separate front-end language to GCC,
+    making it more convenient to conditionally build it.
+
+    The internal structures of the Objective-C Runtime Library have
+    changed sufficiently to warrant a new version number; now version 8.
+    Programs compiled with an older version must be recompiled.
+
+    The Objective-C Runtime Library can be built as a DLL on Windows 95
+    and Windows NT systems.
+    
+    The Objective-C Runtime Library implements +load.
+
+The following new targets are supported (see also list under each
+individual CPU below):
+
+    Embedded target m32r-elf.
+    Embedded Hitachi Super-H using ELF.
+    RTEMS real-time system on various CPU targets.
+    ARC processor.
+    NEC V850 processor.
+    Matsushita MN10200 processor.
+    Matsushita MN10300 processor.
+    Sparc and PowerPC running on VxWorks.
+    Support both glibc versions 1 and 2 on Linux-based GNU systems.
+
+New features for DEC Alpha systems:
+
+    Allow detailed specification of IEEE fp support:
+      -mieee, -mieee-with-inexact, and -mieee-conformant
+      -mfp-trap-mode=xxx, -mfp-round-mode=xxx, -mtrap-precision=xxx
+    -mcpu=xxx for CPU selection
+    Support scheduling parameters for EV5.
+    Add support for BWX, CIX, and MAX instruction set extensions.
+    Support Linux-based GNU systems.
+    Support VMS.
+
+Additional supported processors and systems for MIPS targets:
+
+    MIPS4 instruction set.
+    R4100, R4300 and R5000 processors.
+    N32 and N64 ABI.
+    IRIX 6.2.
+    SNI SINIX.
+    
+New features for Intel x86 family:
+
+    Add scheduling parameters for Pentium and Pentium Pro.
+    Support stabs on Solaris-x86.
+    Intel x86 processors running the SCO OpenServer 5 family.
+    Intel x86 processors running DG/UX.
+    Intel x86 using Cygwin32 or Mingw32 on Windows 95 and Windows NT.
+
+New features for Motorola 68k family:
+
+    Support for 68060 processor.
+    More consistent switches to specify processor.
+    Motorola 68k family running AUX.
+    68040 running pSOS, ELF object files, DBX debugging.
+    Coldfire variant of Motorola m68k family.
+
+New features for the HP PA RISC:
+
+    -mspace and m-no-space
+    -mlong-load-store and -mno-long-load-store
+    -mbig-switch -mno-big-switch
+
+    GCC on the PA requires either gas-2.7 or the HP assembler; for best
+    results using GAS is highly recommended.  GAS is required for -g and
+    exception handling support.
 
 New features for SPARC-based systems:
 
+    The ultrasparc cpu.
+    The sparclet cpu, supporting only a.out file format.
+    Sparc running SunOS 4 with the GNU assembler.
+    Sparc running the Linux-based GNU system.
+    Embedded Sparc processors running the ELF object file format.
     -mcpu=xxx
     -mtune=xxx
+    -malign-loops=xxx
+    -malign-jumps=xxx
+    -malign-functions=xxx
     -mimpure-text and -mno-impure-text
 
-New features for PowerPC-based systems running either System V, Linux, Solaris,
-or embedded systems:
+    Options -mno-v8 and -mno-sparclite are no longer supported on SPARC
+    targets.  Options -mcypress, -mv8, -msupersparc, -msparclite, -mf930,
+    and -mf934 are deprecated and will be deleted in GCC 2.9.  Use
+    -mcpu=xxx instead.
+
+New features for rs6000 and PowerPC systems:
+
+    Solaris 2.51 running on PowerPC's.
+    The Linux-based GNU system running on PowerPC's.
+    -mcpu=604e,602,603e,620,801,823,mpc505,821,860,power2
+    -mtune=xxx
+    -mrelocatable-lib, m-no-relocatable-lib
+    -msim, -mmve, -memb
+    -mupdate, -mno-update
+    -mfused-madd, -mno-fused-madd
 
     -mregnames
     -meabi
-    -mcall-linux
-    -mcall-solaris
-    -mcall-sysv-eabi
-    -mcall-sysv-noeabi
-    -msdata
-    -memb
-    -mtune=xxx
-    -msim
-    -mmvme
+    -mcall-linux, -mcall-solaris, -mcall-sysv-eabi, -mcall-sysv-noeabi
+    -msdata, -msdata=none, -msdata=default, -msdata=sysv, -msdata=eabi
+    -memb, -msim, -mmvme
+    -myellowknife, -mads
+    wchar_t is now of type long as per the ABI, not unsigned short.
+    -p/-pg support
+    -mcpu=403 now implies -mstrict-align.
+    Implement System V profiling.
 
-Options -mno-v8 and -mno-sparclite are no longer supported on SPARC
-targets.  Options -mcypress, -mv8, -msupersparc, -msparclite, -mf930,
-and -mf934 are deprecated and will be deleted in GCC 2.9.
-Use -mcpu=xxx instead.
+    Aix 4.1 GCC targets now default to -mcpu=common so that programs
+    compiled can be moved between rs6000 and powerpc based systems.  A
+    consequence of this is that -static won't work, and that some programs
+    may be slightly slower.
 
-GCC on the PA requires either gas-2.7 or the HP assembler; for best
-results using GAS is highly recommended.  GAS is required for -g
-and exception handling support.
+    You can select the default value to use for -mcpu=xxx on rs6000 and
+    powerpc targets by using the --with-cpu=xxx option when configuring the
+    compiler.  In addition, a new options, -mtune=xxx was added that
+    selects the machine to schedule for but does not select the
+    architecture level.
 
-Aix 4.1 GCC targets now default to -mcpu=common so that programs compiled can
-be moved between rs6000 and powerpc based systems.  A consequence of this is
-that -static won't work, and that some programs may be slightly slower.
+    Directory names used for storing the multilib libraries on System V
+    and embedded PowerPC systems have been shortened to work with commands
+    like tar that have fixed limits on pathname size.
 
-You can select the default value to use for -mcpu=xxx on rs6000 and powerpc
-targets by using the --with-cpu=xxx option when confiuring the compiler.  In
-addition, a new options, -mtune=xxx was added that selects the machine to
-schedule for but does not select the architecture level.
+New features for the Hitachi H8/300(H):
 
-Directory names used for storing the multilib libraries on System V and
-embedded PowerPC systems have been shortened to work with commands like tar
-that have fixed limits on pathname size.
+    -malign-300
+    -ms (for the Hitachi H8/S processor)
+    -mint32
 
-Noteworthy changes in GCC version 2.7.2:
+New features for the ARM:
+
+    -march=xxx, -mtune=xxx, -mcpu=xxx
+    Support interworking with Thumb code.
+    ARM processor with a.out object format, COFF, or AOF assembler.
+    ARM on "semi-hosted" platform.
+    ARM running NetBSD.
+    ARM running the Linux-based GNU system.
+
+New feature for Solaris systems:
+
+    GCC installation no longer makes a copy of system include files,
+    thus insulating GCC better from updates to the operating system.
+
+
+Noteworthy changes in GCC version 2.7.2
+---------------------------------------
 
 A few bugs have been fixed (most notably the generation of an
 invalid assembler opcode on some RS/6000 systems).
 
-Noteworthy changes in GCC version 2.7.1:
+Noteworthy changes in GCC version 2.7.1
+---------------------------------------
 
 This release fixes numerous bugs (mostly minor) in GCC 2.7.0, but
 also contains a few new features, mostly related to specific targets.
@@ -89,8 +274,9 @@ sequence used in GCC version 2.7.0.  That calling sequence was based on the AIX
 calling sequence without function descriptors.  To compile code for that older
 calling sequence, either configure the compiler for powerpc-*-eabiaix or use
 the -mcall-aix switch when compiling and linking.
-
-Noteworthy changes in GCC version 2.7.0:
+
+Noteworthy changes in GCC version 2.7.0
+---------------------------------------
 
 GCC now works better on systems that use ".obj" and ".exe" instead of
 ".o" and no extension.  This involved changes to the driver program,
@@ -342,7 +528,7 @@ The following new configurations are supported:
 	GNU on x86 (instead of treating it like MACH)
 	NetBSD on Sparc and Motorola 68k
 	AIX 4.1 on RS/6000 and PowerPC systems
-	Sequent DYNUX/ptx 1.x and 2.x.
+	Sequent DYNIX/ptx 1.x and 2.x.
 	Both COFF and ELF configurations on AViiON without using /bin/gcc
 	Windows/NT on x86 architecture; preliminary
 	AT&T DSP1610 digital signal processor chips

gcc/README

@@ -0,0 +1,26 @@
+This directory contains the version 2.8.1 release of the GNU C
+compiler.  It includes all of the support for compiling C++ and
+Objective C, including a run-time library for Objective C.
+
+The GNU C compiler is free software.  See the file COPYING for copying
+permission.
+
+See the file gcc.texi (together with other files that it includes) for
+installation and porting information.  The file INSTALL contains a
+copy of the installation information, as plain ASCII.
+
+Installing this package will create various files in subdirectories of
+/usr/local/lib, which are passes used by the compiler and a library
+named libgcc.a.  It will also create /usr/local/bin/gcc, which is
+the user-level command to do a compilation.
+
+See the Bugs chapter of the GCC Manual for how to report bugs
+usefully.  An online readable version of the manual is in the files
+gcc.info*.
+
+The files pself.c and pself1.c are not part of GCC.
+They are programs that print themselves on standard output.
+They were written by Dario Dariol and Giovanni Cozzi, and are
+included for your hacking pleasure.  Likewise pself2.c
+(Who is the author of that?) and pself3.c (by Vlad Taeerov and Rashit
+Fakhreyev).

gcc/README.RS6000

@@ -1,3 +1,80 @@
+			    AIX 4.3 assembler
+
+The AIX 4.3.0.0 assembler generates incorrect object files if the ".bs"
+pseudo-op references symbols in certain sections.  If GCC is invoked with
+the -g debugging option (including during bootstrapping), incorrect object
+files will be produced and the AIX linker will fail with a severe error.
+A fix for APAR IX74254 (64BIT DISASSEMBLED OUPUT FROM COMPILER FAILS TO
+ASSEMBLE/BIND) is available from IBM Customer Support and IBM's
+service.boulder.ibm.com website.
+
+
+			      AIX 4.1 binder
+
+Due to changes in the way that GCC invokes the binder (linker) for AIX 4.1,
+the link step now may produce warnings of duplicate symbols which were not
+reported before.  The assembly files generated by GCC for AIX always have
+included multiple symbol definitions for certain global variable and
+function declarations in the original program.  The warnings should not
+prevent the linker from producing a correct library or runnable executable.
+
+
+			     AIX NLS problems
+
+AIX on the RS/6000 provides support (NLS) for environments outside of
+the United States.  Compilers and assemblers use NLS to support
+locale-specific representations of various objects including
+floating-point numbers ("." vs "," for separating decimal fractions).
+There have been problems reported where the library linked with GCC does
+not produce the same floating-point formats that the assembler accepts.
+If you have this problem, set the LANG environment variable to "C" or
+"En_US".
+
+				     
+			 AIX 3.2.5 XLC-1.3 problems
+
+XLC version 1.3.0.0 distributed with AIX 3.2.5 will miscompile jump.c when
+building the stage1 compiler during the bootstrap process.  This will cause
+GCC to crash and the bootstrap to fail later while compiling libgcc2.c.  XLC
+version 1.3.0.1 or later fixes this problem.  XLC-1.3.0.19 also cannot
+bootstrap GCC so please avoid that release as well.  You can obtain
+XLC-1.3.0.24 by requesting PTF 432238 from IBM, or just ask for the latest
+release of XLC-1.3.
+
+There also have been reports of problems bootstrapping GCC with some older
+releases of xlc-1.2.1, including xlc-1.2.1.8.  Newer releases of xlc-1.2.1
+do not exhibit this problem: xlc-1.2.1.28 is known to bootstrap properly.
+
+
+		       AIX 3.2 common-mode support
+
+AIX common-mode providing transparent support of both the POWER and PowerPC
+architectures is usable in AIX 3.2.3 and above but an export file and
+support for hidden export via libc.a will not exist until AIX 4.1.  libgcc.a
+also must be compiled in common-mode.  Note that executables generated for
+the POWER (RIOS1 and RSC) architecture will run directly on systems using
+the MPC601 chip.  Common-mode only improves the performance of a single
+executable run on both POWER and PowerPC architecture platforms by not using
+POWER- or PowerPC-specific instructions and eliminating the need to trap to
+emulation (for POWER instructions run on PowerPC).
+
+To link a common-mode application prior to AIX 4.1 and run it on a system at
+AIX level 3.2.3 or above, use the text between the "<>" as an export file
+(e.g. milli.exp)
+
+<><><><><><><><><><><>
+#!
+__mulh          0x3100
+__mull          0x3180
+__divss         0x3200
+__divus         0x3280
+__quoss         0x3300
+__quous         0x3380
+<><><><><><><><><><><>
+
+and then link with -Wl,-bI:milli.exp.
+
+
 		     AIX 3.1 and 3.2 assembler problems
 
 Specifying the -g flag to GCC on the RS/6000 requires upgrading the
@@ -43,69 +120,3 @@ an assembler modified after October 16th, 1995 in order to build the GNU C
 compiler.  This is because the GNU C compiler wants to build a variant of its
 library, libgcc.a with the -mcpu=common switch to support building programs
 that can run on either the Power or PowerPC machines.
-
-
-			      AIX NLS problems
-
-AIX on the RS/6000 provides support (NLS) for environments outside of
-the United States.  Compilers and assemblers use NLS to support
-locale-specific representations of various objects including
-floating-point numbers ("." vs "," for separating decimal fractions).
-There have been problems reported where the library linked with GCC does
-not produce the same floating-point formats that the assembler accepts.
-If you have this problem, set the LANG environment variable to "C" or
-"En_US".
-
-
-			 AIX 3.2.5 XLC-1.3 problems
-
-XLC version 1.3.0.0 distributed with AIX 3.2.5 will miscompile jump.c when
-building the stage1 compiler during the bootstrap process.  This will cause
-GCC to crash and the bootstrap to fail later while compiling libgcc2.c.  XLC
-version 1.3.0.1 or later fixes this problem.  XLC-1.3.0.19 also cannot
-bootstrap GCC so please avoid that release as well.  You can obtain
-XLC-1.3.0.24 by requesting PTF 432238 from IBM, or just ask for the latest
-release of XLC-1.3.
-
-There also have been reports of problems bootstrapping GCC with some older
-releases of xlc-1.2.1, including xlc-1.2.1.8.  Newer releases of xlc-1.2.1
-do not exhibit this problem: xlc-1.2.1.28 is known to bootstrap properly.
-
-
-			AIX 3.2 common-mode support
-
-AIX common-mode providing transparent support of both the POWER and PowerPC
-architectures is usable in AIX 3.2.3 and above but an export file and
-support for hidden export via libc.a will not exist until AIX 4.1.  libgcc.a
-also must be compiled in common-mode.  Note that executables generated for
-the POWER (RIOS1 and RSC) architecture will run directly on systems using
-the MPC601 chip.  Common-mode only improves the performance of a single
-executable run on both POWER and PowerPC architecture platforms by not using
-POWER- or PowerPC-specific instructions and eliminating the need to trap to
-emulation (for POWER instructions run on PowerPC).
-
-To link a common-mode application prior to AIX 4.1 and run it on a system at
-AIX level 3.2.3 or above, use the text between the "<>" as an export file
-(e.g. milli.exp)
-
-<><><><><><><><><><><>
-#!
-__mulh          0x3100
-__mull          0x3180
-__divss         0x3200
-__divus         0x3280
-__quoss         0x3300
-__quous         0x3380
-<><><><><><><><><><><>
-
-and then link with -Wl,-bI:milli.exp.
-
-
-			       AIX 4.1 binder
-
-Due to changes in the way that GCC invokes the binder (linker) for AIX 4.1,
-the link step now may produce warnings of duplicate symbols which were not
-reported before.  The assembly files generated by GCC for AIX always have
-included multiple symbol definitions for certain global variable and
-function declarations in the original program.  The warnings should not
-prevent the linker from producing a correct library or runnable executable.

gcc/README.X11

@@ -20,7 +20,7 @@ IF YOU THINK YOU MIGHT COMPILE X FOR SOLARIS 2, then you really don't
 need this patch: get /contrib/R5.SunOS5.patch.tar.Z from
 export.lcs.mit.edu instead.  It has everything you need to do the
 build for Solaris 2, sets you up to everything with GCC, and is
-backward compatible with Sunos 4.*.  Get the the README
+backward compatible with SunOS 4.*.  Get the the README
 (/contrib/R5.SunOS5.patch.README at export) for more info.
 
 If you see undefined symbols _dlopen, _dlsym, or _dlclose when linking

gcc/TESTS.FLUNK

@@ -0,0 +1,39 @@
+This is a collection of things that test suites have
+said were "wrong" with GCC--but that I don't agree with.
+
+First, test suites sometimes test for compatibility with
+traditional C.  GCC with -traditional is not completely
+compatible with traditional C, and in some ways I think it
+should not be.
+
+* K&R C allowed \x to appear in a string literal (or character
+literal?)  even in cases where it is *not* followed by a sequence of
+hex digits.  I'm not convinced this is desirable.
+
+* K&R compilers allow comments to cross over an inclusion boundary (i.e.
+started in an include file and ended in the including file).
+I think this would be quite ugly and can't imagine it could
+be needed.
+
+Sometimes tests disagree with GCC's interpretation of the ANSI standard.
+
+* One test claims that this function should return 1.
+
+    enum {A, B} foo;
+
+    func (enum {B, A} arg)
+    {
+      return B;
+    }
+
+I think it should return 0, because the definition of B that
+applies is the one in func.
+
+* Some tests report failure when the compiler does not produce
+an error message for a certain program.
+
+ANSI C requires a "diagnostic" message for certain kinds of invalid
+programs, but a warning counts as a diagnostic.  If GCC produces
+a warning but not an error, that is correct ANSI support.
+When test suites call this "failure", the tests are broken.
+

gcc/acconfig.h

@@ -1,7 +1,5 @@
-
-/* Include the old config.h as config2.h to simplify the transition
-   to autoconf.  */
-#include "config2.h"
+/* Define if you have a working <inttypes.h> header file.  */
+#undef HAVE_INTTYPES_H
 
 /* Whether malloc must be declared even if <stdlib.h> is included.  */
 #undef NEED_DECLARATION_MALLOC
@@ -9,6 +7,21 @@
 /* Whether realloc must be declared even if <stdlib.h> is included.  */
 #undef NEED_DECLARATION_REALLOC
 
+/* Whether calloc must be declared even if <stdlib.h> is included.  */
+#undef NEED_DECLARATION_CALLOC
+
 /* Whether free must be declared even if <stdlib.h> is included.  */
 #undef NEED_DECLARATION_FREE
+
+/* Whether index must be declared even if <stdlib.h> is included.  */
+#undef NEED_DECLARATION_INDEX
+
+/* Whether rindex must be declared even if <stdlib.h> is included.  */
+#undef NEED_DECLARATION_RINDEX
+
+/* Whether getenv must be declared even if <stdlib.h> is included.  */
+#undef NEED_DECLARATION_GETENV
+
+/* Whether sbrk must be declared even if <stdlib.h> is included.  */
+#undef NEED_DECLARATION_SBRK
 @TOP@

gcc/aclocal.m4

@@ -16,6 +16,12 @@ AC_CACHE_VAL(gcc_cv_decl_needed_$1,
 #endif
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
+#endif
+#ifndef HAVE_RINDEX
+#define rindex strrchr
+#endif
+#ifndef HAVE_INDEX
+#define index strchr
 #endif],
 [char *(*pfn) = (char *(*)) $1],
 gcc_cv_decl_needed_$1=no, gcc_cv_decl_needed_$1=yes)])

gcc/basic-block.h

@@ -73,6 +73,12 @@ do {									\
 #define EXECUTE_IF_AND_COMPL_IN_REG_SET(REGSET1, REGSET2, MIN, REGNUM, CODE) \
   EXECUTE_IF_AND_COMPL_IN_BITMAP (REGSET1, REGSET2, MIN, REGNUM, CODE)
 
+/* Loop over all registers in REGSET1 and REGSET2, starting with MIN, setting
+   REGNUM to the register number and executing CODE for all registers that are
+   set in both regsets. */
+#define EXECUTE_IF_AND_IN_REG_SET(REGSET1, REGSET2, MIN, REGNUM, CODE) \
+  EXECUTE_IF_AND_IN_BITMAP (REGSET1, REGSET2, MIN, REGNUM, CODE)
+
 /* Allocate a register set with oballoc.  */
 #define OBSTACK_ALLOC_REG_SET(OBSTACK) BITMAP_OBSTACK_ALLOC (OBSTACK)
 

gcc/bc-emit.c

@@ -1,5 +1,5 @@
 /* Output bytecodes for GNU C-compiler.
-   Copyright (C) 1993, 1994, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1994, 1996, 1997 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -20,6 +20,7 @@ Boston, MA 02111-1307, USA.  */
 
 
 #include "config.h"
+#include <stdio.h>
 #ifdef __STDC__
 #include <stdarg.h>
 #else
@@ -38,8 +39,6 @@ Boston, MA 02111-1307, USA.  */
 #include "bc-typecd.h"
 #include "bi-run.h"
 
-#include <stdio.h>
-
 extern char *xmalloc (), *xrealloc ();
 
 extern struct obstack *rtl_obstack;

gcc/bc-optab.c

@@ -1,5 +1,5 @@
 /* Bytecode conversion definitions for GNU C-compiler.
-   Copyright (C) 1993, 1994 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1994, 1997 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -20,6 +20,10 @@ Boston, MA 02111-1307, USA.  */
 
 
 #include "config.h"
+#include <stdio.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
 #include "tree.h"
 #include "rtl.h"
 #include "machmode.h"

gcc/bitmap.c

@@ -18,20 +18,25 @@ along with GNU CC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
-#include <stdio.h>
 #include "config.h"
+#include <stdio.h>
 #include "rtl.h"
 #include "flags.h"
 #include "obstack.h"
 #include "regs.h"
 #include "basic-block.h"
 
-/* The contents of the current function definition are allocated
-   in this obstack, and all are freed at the end of the function.
-   For top-level functions, this is temporary_obstack.
-   Separate obstacks are made for nested functions.  */
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
 
-extern struct obstack *function_obstack;
+#ifdef NEED_DECLARATION_FREE
+extern void free PROTO((void *));
+#endif
+
+/* Obstack to allocate bitmap elements from.  */
+static struct obstack bitmap_obstack;
+static int bitmap_obstack_init = FALSE;
 
 
 #ifndef INLINE
@@ -95,8 +100,39 @@ bitmap_element_allocate (head)
       bitmap_free = element->next;
     }
   else
-    element = (bitmap_element *) obstack_alloc (function_obstack,
-						sizeof (bitmap_element));
+    {
+      /* We can't use gcc_obstack_init to initialize the obstack since
+	 print-rtl.c now calls bitmap functions, and bitmap is linked
+	 into the gen* functions.  */
+      if (!bitmap_obstack_init)
+	{
+	  bitmap_obstack_init = TRUE;
+
+	  /* Let particular systems override the size of a chunk.  */
+#ifndef OBSTACK_CHUNK_SIZE
+#define OBSTACK_CHUNK_SIZE 0
+#endif
+	  /* Let them override the alloc and free routines too.  */
+#ifndef OBSTACK_CHUNK_ALLOC
+#define OBSTACK_CHUNK_ALLOC xmalloc
+#endif
+#ifndef OBSTACK_CHUNK_FREE
+#define OBSTACK_CHUNK_FREE free
+#endif
+
+#if !defined(__GNUC__) || (__GNUC__ < 2)
+#define __alignof__(type) 0
+#endif
+
+	  obstack_specify_allocation (&bitmap_obstack, OBSTACK_CHUNK_SIZE,
+				      __alignof__ (bitmap_element),
+				      (void *(*) ()) OBSTACK_CHUNK_ALLOC,
+				      (void (*) ()) OBSTACK_CHUNK_FREE);
+	}
+
+      element = (bitmap_element *) obstack_alloc (&bitmap_obstack,
+						  sizeof (bitmap_element));
+    }
 
 #if BITMAP_ELEMENT_WORDS == 2
   element->bits[0] = element->bits[1] = 0;
@@ -573,11 +609,37 @@ debug_bitmap (head)
   bitmap_debug_file (stdout, head);
 }
 
-/* Release any memory allocated by bitmaps.  Since we allocate off of the
-   function_obstack, just zap the free list.  */
+/* Function to print out the contents of a bitmap.  Unlike bitmap_debug_file,
+   it does not print anything but the bits.  */
+
+void
+bitmap_print (file, head, prefix, suffix)
+     FILE *file;
+     bitmap head;
+     char *prefix;
+     char *suffix;
+{
+  char *comma = "";
+  int i;
+
+  fputs (prefix, file);
+  EXECUTE_IF_SET_IN_BITMAP (head, 0, i,
+			    {
+			      fprintf (file, "%s%d", comma, i);
+			      comma = ", ";
+			    });
+  fputs (suffix, file);
+}
+
+/* Release any memory allocated by bitmaps.  */
 
 void
 bitmap_release_memory ()
 {
   bitmap_free = 0;
+  if (bitmap_obstack_init)
+    {
+      bitmap_obstack_init = FALSE;
+      obstack_free (&bitmap_obstack, NULL_PTR);
+    }
 }

gcc/bitmap.h

@@ -86,7 +86,10 @@ extern int bitmap_bit_p PROTO((bitmap, int));
 
 /* Debug functions to print a bitmap linked list.  */
 extern void bitmap_debug PROTO((bitmap));
-extern void bitmap_debug_file STDIO_PROTO((FILE *, bitmap));
+extern void bitmap_debug_file PROTO((FILE *, bitmap));
+
+/* Print a bitmap */
+extern void bitmap_print PROTO((FILE *, bitmap, char *, char *));
 
 /* Initialize a bitmap header.  */
 extern bitmap bitmap_initialize PROTO((bitmap));
@@ -197,7 +200,7 @@ do {									\
   for (; ptr1_ != 0 ; ptr1_ = ptr1_->next)				\
     {									\
       /* Advance BITMAP2 to the equivalent link, using an all		\
-	 zero element if an equavialent link doesn't exist.  */		\
+	 zero element if an equivalent link doesn't exist.  */		\
       bitmap_element *tmp2_;						\
 									\
       while (ptr2_ != 0 && ptr2_->indx < ptr1_->indx)			\
@@ -237,3 +240,76 @@ do {									\
       word_num_ = 0;							\
     }									\
 } while (0)
+
+/* Loop over all bits in BITMAP1 and BITMAP2, starting with MIN, setting
+   BITNUM to the bit number and executing CODE for all bits that are set in
+   the both bitmaps. */
+
+#define EXECUTE_IF_AND_IN_BITMAP(BITMAP1, BITMAP2, MIN, BITNUM, CODE)	\
+do {									\
+  bitmap_element *ptr1_ = (BITMAP1)->first;				\
+  bitmap_element *ptr2_ = (BITMAP2)->first;				\
+  unsigned int indx_ = (MIN) / BITMAP_ELEMENT_ALL_BITS;			\
+  unsigned bit_num_ = (MIN) % ((unsigned) HOST_BITS_PER_WIDE_INT);	\
+  unsigned word_num_ = (((MIN) / ((unsigned) HOST_BITS_PER_WIDE_INT))	\
+			% BITMAP_ELEMENT_WORDS);			\
+									\
+  /* Find the block the minimum bit is in in the first bitmap.  */	\
+  while (ptr1_ != 0 && ptr1_->indx < indx_)				\
+    ptr1_ = ptr1_->next;						\
+									\
+  if (ptr1_ != 0 && ptr1_->indx != indx_)				\
+    {									\
+      bit_num_ = 0;							\
+      word_num_ = 0;							\
+    }									\
+									\
+  for (; ptr1_ != 0 ; ptr1_ = ptr1_->next)				\
+    {									\
+      /* Advance BITMAP2 to the equivalent link */			\
+      while (ptr2_ != 0 && ptr2_->indx < ptr1_->indx)			\
+	ptr2_ = ptr2_->next;						\
+									\
+      if (ptr2_ == 0)							\
+	{								\
+	  /* If there are no more elements in BITMAP2, exit loop now.*/	\
+	  ptr1_ = (bitmap_element *)0;					\
+	  break;							\
+	}								\
+      else if (ptr2_->indx > ptr1_->indx)				\
+	{								\
+	  bit_num_ = word_num_ = 0;					\
+	  continue;							\
+	}								\
+									\
+      for (; word_num_ < BITMAP_ELEMENT_WORDS; word_num_++)		\
+	{								\
+	  unsigned HOST_WIDE_INT word_ = (ptr1_->bits[word_num_]	\
+					  & ptr2_->bits[word_num_]);	\
+	  if (word_ != 0)						\
+	    {								\
+	      for (; bit_num_ < HOST_BITS_PER_WIDE_INT; bit_num_++)	\
+		{							\
+		  unsigned HOST_WIDE_INT mask_				\
+		    = ((unsigned HOST_WIDE_INT)1) << bit_num_;		\
+									\
+		  if ((word_ & mask_) != 0)				\
+		    {							\
+		      word_ &= ~ mask_;					\
+		      (BITNUM) = (ptr1_->indx * BITMAP_ELEMENT_ALL_BITS \
+				  + word_num_ * HOST_BITS_PER_WIDE_INT  \
+				  + bit_num_);				\
+									\
+		      CODE;						\
+		      if (word_ == 0)					\
+			break;						\
+		    }							\
+		}							\
+	    }								\
+									\
+	  bit_num_ = 0;							\
+	}								\
+									\
+      word_num_ = 0;							\
+    }									\
+} while (0)

gcc/c-aux-info.c

@@ -1,7 +1,7 @@
 /* Generate information regarding function declarations and definitions based
    on information stored in GCC's tree structure.  This code implements the
    -aux-info option.
-   Copyright (C) 1989, 1991, 1994, 1995 Free Software Foundation, Inc.
+   Copyright (C) 1989, 1991, 1994, 1995, 1997 Free Software Foundation, Inc.
    Contributed by Ron Guilmette (rfg@segfault.us.com).
 
 This file is part of GNU CC.
@@ -21,8 +21,8 @@ along with GNU CC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
-#include <stdio.h>
 #include "config.h"
+#include <stdio.h>
 #include "flags.h"
 #include "tree.h"
 #include "c-tree.h"
@@ -39,14 +39,14 @@ typedef enum formals_style_enum formals_style;
 
 static char *data_type;
 
-static char *concat ();
-static char *concat3 ();
-static char *gen_formal_list_for_type ();
-static int   deserves_ellipsis ();
-static char *gen_formal_list_for_func_def ();
-static char *gen_type ();
-static char *gen_decl ();
-void   gen_aux_info_record ();
+static char *concat			PROTO((char *, char *));
+static char *concat3			PROTO((char *, char *, char *));
+static char *affix_data_type		PROTO((char *));
+static char *gen_formal_list_for_type	PROTO((tree, formals_style));
+static int   deserves_ellipsis		PROTO((tree));
+static char *gen_formal_list_for_func_def PROTO((tree, formals_style));
+static char *gen_type			PROTO((char *, tree, formals_style));
+static char *gen_decl			PROTO((tree, int, formals_style));
 
 /*  Take two strings and mash them together into a newly allocated area.  */
 

gcc/c-common.c

@@ -1,5 +1,5 @@
 /* Subroutines shared by all languages that are variants of C.
-   Copyright (C) 1992, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1992, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -19,12 +19,12 @@ the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
 #include "config.h"
+#include <stdio.h>
 #include "tree.h"
 #include "c-lex.h"
 #include "c-tree.h"
 #include "flags.h"
 #include "obstack.h"
-#include <stdio.h>
 #include <ctype.h>
 
 #ifndef WCHAR_TYPE_SIZE
@@ -51,6 +51,61 @@ static void add_attribute		PROTO((enum attrs, char *,
 static void init_attributes		PROTO((void));
 static void record_international_format	PROTO((tree, tree, int));
 
+/* Keep a stack of if statements.  The value recorded is the number of
+   compound statements seen up to the if keyword.  */
+static int *if_stack;
+
+/* Amount of space in the if statement stack.  */
+static int if_stack_space = 0;
+
+/* Stack pointer.  */
+static int if_stack_pointer = 0;
+
+void
+c_expand_start_cond (cond, exitflag, compstmt_count)
+     tree cond;
+     int exitflag;
+     int compstmt_count;
+{
+  /* Make sure there is enough space on the stack.  */
+  if (if_stack_space == 0)
+    {
+      if_stack_space = 10;
+      if_stack = (int *)xmalloc (10 * sizeof (int));
+    }
+  else if (if_stack_space == if_stack_pointer)
+    {
+      if_stack_space += 10;
+      if_stack = (int *)xrealloc (if_stack, if_stack_space * sizeof (int));
+    }
+  
+  /* Record this if statement.  */
+  if_stack[if_stack_pointer++] = compstmt_count;
+
+  expand_start_cond (cond, exitflag);
+}
+
+void
+c_expand_end_cond ()
+{
+  if_stack_pointer--;
+  expand_end_cond ();
+}
+
+void
+c_expand_start_else ()
+{
+  if (warn_parentheses
+      && if_stack_pointer > 1
+      && if_stack[if_stack_pointer - 1] == if_stack[if_stack_pointer - 2])
+    warning ("suggest explicit braces to avoid ambiguous `else'");
+  
+  /* This if statement can no longer cause a dangling else.  */
+  if_stack[if_stack_pointer - 1]--;
+
+  expand_start_else ();
+}
+
 /* Make bindings for __FUNCTION__ and __PRETTY_FUNCTION__.  */
 
 void
@@ -268,7 +323,7 @@ init_attributes ()
   add_attribute (A_COMMON, "common", 0, 0, 1);
   add_attribute (A_NORETURN, "noreturn", 0, 0, 1);
   add_attribute (A_NORETURN, "volatile", 0, 0, 1);
-  add_attribute (A_UNUSED, "unused", 0, 0, 1);
+  add_attribute (A_UNUSED, "unused", 0, 0, 0);
   add_attribute (A_CONST, "const", 0, 0, 1);
   add_attribute (A_T_UNION, "transparent_union", 0, 0, 0);
   add_attribute (A_CONSTRUCTOR, "constructor", 0, 0, 1);
@@ -385,8 +440,11 @@ decl_attributes (node, attributes, prefix_attributes)
 	  break;
 
 	case A_UNUSED:
-	  if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == VAR_DECL
-	      || TREE_CODE (decl) == FUNCTION_DECL)
+	  if (is_type)
+	    TREE_USED (type) = 1;
+	  else if (TREE_CODE (decl) == PARM_DECL 
+		   || TREE_CODE (decl) == VAR_DECL
+		   || TREE_CODE (decl) == FUNCTION_DECL)
 	    TREE_USED (decl) = 1;
 	  else
 	    warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
@@ -860,37 +918,39 @@ typedef struct {
   /* Type of argument if length modifier `L' is used.
      If NULL, then this modifier is not allowed.  */
   tree *bigllen;
+  /* Type of argument if length modifier `Z' is used.
+     If NULL, then this modifier is not allowed.  */
+  tree *zlen;
   /* List of other modifier characters allowed with these options.  */
   char *flag_chars;
 } format_char_info;
 
 static format_char_info print_char_table[] = {
-  { "di",	0,	T_I,	T_I,	T_L,	T_LL,	T_LL,	"-wp0 +"	},
-  { "oxX",	0,	T_UI,	T_UI,	T_UL,	T_ULL,	T_ULL,	"-wp0#"		},
-  { "u",	0,	T_UI,	T_UI,	T_UL,	T_ULL,	T_ULL,	"-wp0"		},
-/* Two GNU extensions.  */
-  { "Z",	0,	T_ST,	NULL,	NULL,	NULL,	NULL,	"-wp0"		},
-  { "m",	0,	T_V,	NULL,	NULL,	NULL,	NULL,	"-wp"		},
-  { "feEgG",	0,	T_D,	NULL,	NULL,	NULL,	T_LD,	"-wp0 +#"	},
-  { "c",	0,	T_I,	NULL,	T_W,	NULL,	NULL,	"-w"		},
-  { "C",	0,	T_W,	NULL,	NULL,	NULL,	NULL,	"-w"		},
-  { "s",	1,	T_C,	NULL,	T_W,	NULL,	NULL,	"-wp"		},
-  { "S",	1,	T_W,	NULL,	NULL,	NULL,	NULL,	"-wp"		},
-  { "p",	1,	T_V,	NULL,	NULL,	NULL,	NULL,	"-w"		},
-  { "n",	1,	T_I,	T_S,	T_L,	T_LL,	NULL,	""		},
+  { "di",	0,	T_I,	T_I,	T_L,	T_LL,	T_LL,	T_ST,	"-wp0 +"	},
+  { "oxX",	0,	T_UI,	T_UI,	T_UL,	T_ULL,	T_ULL,	T_ST,	"-wp0#"		},
+  { "u",	0,	T_UI,	T_UI,	T_UL,	T_ULL,	T_ULL,	T_ST,	"-wp0"		},
+/* A GNU extension.  */
+  { "m",	0,	T_V,	NULL,	NULL,	NULL,	NULL,	NULL,	"-wp"		},
+  { "feEgGaA",	0,	T_D,	NULL,	NULL,	NULL,	T_LD,	NULL,	"-wp0 +#"	},
+  { "c",	0,	T_I,	NULL,	T_W,	NULL,	NULL,	NULL,	"-w"		},
+  { "C",	0,	T_W,	NULL,	NULL,	NULL,	NULL,	NULL,	"-w"		},
+  { "s",	1,	T_C,	NULL,	T_W,	NULL,	NULL,	NULL,	"-wp"		},
+  { "S",	1,	T_W,	NULL,	NULL,	NULL,	NULL,	NULL,	"-wp"		},
+  { "p",	1,	T_V,	NULL,	NULL,	NULL,	NULL,	NULL,	"-w"		},
+  { "n",	1,	T_I,	T_S,	T_L,	T_LL,	NULL,	NULL,	""		},
   { NULL }
 };
 
 static format_char_info scan_char_table[] = {
-  { "di",	1,	T_I,	T_S,	T_L,	T_LL,	T_LL,	"*"	},
-  { "ouxX",	1,	T_UI,	T_US,	T_UL,	T_ULL,	T_ULL,	"*"	},	
-  { "efgEG",	1,	T_F,	NULL,	T_D,	NULL,	T_LD,	"*"	},
-  { "sc",	1,	T_C,	NULL,	T_W,	NULL,	NULL,	"*a"	},
-  { "[",	1,	T_C,	NULL,	NULL,	NULL,	NULL,	"*a"	},
-  { "C",	1,	T_W,	NULL,	NULL,	NULL,	NULL,	"*"	},
-  { "S",	1,	T_W,	NULL,	NULL,	NULL,	NULL,	"*"	},
-  { "p",	2,	T_V,	NULL,	NULL,	NULL,	NULL,	"*"	},
-  { "n",	1,	T_I,	T_S,	T_L,	T_LL,	NULL,	""	},
+  { "di",	1,	T_I,	T_S,	T_L,	T_LL,	T_LL,	NULL,	"*"	},
+  { "ouxX",	1,	T_UI,	T_US,	T_UL,	T_ULL,	T_ULL,	NULL,	"*"	},	
+  { "efgEGaA",	1,	T_F,	NULL,	T_D,	NULL,	T_LD,	NULL,	"*"	},
+  { "sc",	1,	T_C,	NULL,	T_W,	NULL,	NULL,	NULL,	"*a"	},
+  { "[",	1,	T_C,	NULL,	NULL,	NULL,	NULL,	NULL,	"*a"	},
+  { "C",	1,	T_W,	NULL,	NULL,	NULL,	NULL,	NULL,	"*"	},
+  { "S",	1,	T_W,	NULL,	NULL,	NULL,	NULL,	NULL,	"*"	},
+  { "p",	2,	T_V,	NULL,	NULL,	NULL,	NULL,	NULL,	"*"	},
+  { "n",	1,	T_I,	T_S,	T_L,	T_LL,	NULL,	NULL,	""	},
   { NULL }
 };
 
@@ -1229,12 +1289,15 @@ check_format_info (info, params)
 	      if (index (flag_chars, *format_chars) != 0)
 		{
 		  sprintf (message, "repeated `%c' flag in format",
-			   *format_chars);
+			   *format_chars++);
 		  warning (message);
 		}
-	      i = strlen (flag_chars);
-	      flag_chars[i++] = *format_chars++;
-	      flag_chars[i] = 0;
+	      else
+		{
+		  i = strlen (flag_chars);
+		  flag_chars[i++] = *format_chars++;
+		  flag_chars[i] = 0;
+		}
 	    }
 	  /* "If the space and + flags both appear, 
 	     the space flag will be ignored."  */
@@ -1334,6 +1397,12 @@ check_format_info (info, params)
 	    pedwarn ("ANSI C does not support the `%c' length modifier",
 		     length_char);
 	}
+      else if (*format_chars == 'Z')
+	{
+	  length_char = *format_chars++;
+	  if (pedantic)
+	    pedwarn ("ANSI C does not support the `Z' length modifier");
+	}
       else
 	length_char = 0;
       if (length_char == 'l' && *format_chars == 'l')
@@ -1343,10 +1412,15 @@ check_format_info (info, params)
 	    pedwarn ("ANSI C does not support the `ll' length modifier");
 	}
       aflag = 0;
-      if (*format_chars == 'a')
+      if (*format_chars == 'a' && info->is_scan)
 	{
-	  aflag = 1;
-	  format_chars++;
+	  if (format_chars[1] == 's' || format_chars[1] == 'S'
+	      || format_chars[1] == '[')
+	    {
+	      /* `a' is used as a flag.  */
+	      aflag = 1;
+	      format_chars++;
+	    }
 	}
       if (suppressed && length_char != 0)
 	{
@@ -1451,6 +1525,7 @@ check_format_info (info, params)
 	case 'l': wanted_type = fci->llen ? *(fci->llen) : 0; break;
 	case 'q': wanted_type = fci->qlen ? *(fci->qlen) : 0; break;
 	case 'L': wanted_type = fci->bigllen ? *(fci->bigllen) : 0; break;
+	case 'Z': wanted_type = fci->zlen ? *fci->zlen : 0; break;
 	}
       if (wanted_type == 0)
 	{
@@ -1485,6 +1560,8 @@ check_format_info (info, params)
       ++arg_num;
       cur_type = TREE_TYPE (cur_param);
 
+      STRIP_NOPS (cur_param);
+
       /* Check the types of any additional pointer arguments
 	 that precede the "real" argument.  */
       for (i = 0; i < fci->pointer_count + aflag; ++i)
@@ -1492,6 +1569,12 @@ check_format_info (info, params)
 	  if (TREE_CODE (cur_type) == POINTER_TYPE)
 	    {
 	      cur_type = TREE_TYPE (cur_type);
+
+	      if (TREE_CODE (cur_param) == ADDR_EXPR)
+		cur_param = TREE_OPERAND (cur_param, 0);
+	      else
+		cur_param = 0;
+
 	      continue;
 	    }
 	  if (TREE_CODE (cur_type) != ERROR_MARK)
@@ -1506,6 +1589,21 @@ check_format_info (info, params)
 	  break;
 	}
 
+      /* See if this is an attempt to write into a const type with
+	 scanf.  */
+      if (info->is_scan && i == fci->pointer_count + aflag
+	  && wanted_type != 0
+	  && TREE_CODE (cur_type) != ERROR_MARK
+	  && (TYPE_READONLY (cur_type)
+	      || (cur_param != 0
+		  && (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'c'
+		      || (TREE_CODE_CLASS (TREE_CODE (cur_param)) == 'd'
+			  && TREE_READONLY (cur_param))))))
+	{
+	  sprintf (message, "writing into constant object (arg %d)", arg_num);
+	  warning (message);
+	}
+
       /* Check the type of the "real" argument, if there's a type we want.  */
       if (i == fci->pointer_count + aflag && wanted_type != 0
 	  && TREE_CODE (cur_type) != ERROR_MARK
@@ -1856,7 +1954,7 @@ void
 binary_op_error (code)
      enum tree_code code;
 {
-  register char *opname = "unknown";
+  register char *opname;
 
   switch (code)
     {
@@ -1909,6 +2007,8 @@ binary_op_error (code)
     case LROTATE_EXPR:
     case RROTATE_EXPR:
       opname = "rotate"; break;
+    default:
+      opname = "unknown"; break;
     }
   error ("invalid operands to binary %s", opname);
 }
@@ -1995,6 +2095,8 @@ shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
 	case GE_EXPR:
 	  code = LE_EXPR;
 	  break;
+	default:
+	  break;
 	}
       *rescode_ptr = code;
     }
@@ -2125,6 +2227,9 @@ shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
 		primop1 = TYPE_MAX_VALUE (type);
 		val = 0;
 		break;
+
+	      default:
+		break;
 	      }
 	  type = unsigned_type (type);
 	}
@@ -2222,6 +2327,10 @@ shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
 						     primop0))))
 		warning ("unsigned value < 0 is always 0");
 	      value = boolean_false_node;
+	      break;
+
+	    default:
+	      break;
 	    }
 
 	  if (value != 0)
@@ -2409,6 +2518,9 @@ truthvalue_conversion (expr)
       if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
 	warning ("suggest parentheses around assignment used as truth value");
       break;
+      
+    default:
+      break;
     }
 
   if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)

gcc/c-decl.c

@@ -1,5 +1,5 @@
 /* Process declarations and variables for C compiler.
-   Copyright (C) 1988, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1988, 92-97, 1998 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -27,12 +27,12 @@ Boston, MA 02111-1307, USA.  */
    line numbers.  For example, the CONST_DECLs for enum values.  */
 
 #include "config.h"
+#include <stdio.h>
 #include "tree.h"
 #include "flags.h"
 #include "output.h"
 #include "c-tree.h"
 #include "c-lex.h"
-#include <stdio.h>
 
 /* In grokdeclarator, distinguish syntactic contexts of declarators.  */
 enum decl_context
@@ -471,9 +471,14 @@ int explicit_flag_signed_bitfields = 0;
 
 int flag_no_ident = 0;
 
-/* Nonzero means warn about implicit declarations.  */
+/* Nonzero means warn about use of implicit int. */
 
-int warn_implicit;
+int warn_implicit_int;
+
+/* Nonzero means message about use of implicit function declarations;
+ 1 means warning; 2 means error. */
+
+int mesg_implicit_function_declaration;
 
 /* Nonzero means give string constants the type `const char *'
    to get extra warnings from them.  These warnings will be too numerous
@@ -553,9 +558,10 @@ int warn_missing_braces;
 
 int warn_main;
 
-/* Warn about comparison of signed and unsigned values.  */
+/* Warn about comparison of signed and unsigned values.
+   If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified.  */
 
-int warn_sign_compare;
+int warn_sign_compare = -1;
 
 /* Nonzero means `$' can be in an identifier.  */
 
@@ -647,10 +653,24 @@ c_decode_option (p)
     flag_no_ident = 0;
   else if (!strcmp (p, "-ansi"))
     flag_no_asm = 1, flag_no_nonansi_builtin = 1;
+  else if (!strcmp (p, "-Werror-implicit-function-declaration"))
+    mesg_implicit_function_declaration = 2;
+  else if (!strcmp (p, "-Wimplicit-function-declaration"))
+    mesg_implicit_function_declaration = 1;
+  else if (!strcmp (p, "-Wno-implicit-function-declaration"))
+    mesg_implicit_function_declaration = 0;
+  else if (!strcmp (p, "-Wimplicit-int"))
+    warn_implicit_int = 1;
+  else if (!strcmp (p, "-Wno-implicit-int"))
+    warn_implicit_int = 0;
   else if (!strcmp (p, "-Wimplicit"))
-    warn_implicit = 1;
+    {
+      warn_implicit_int = 1;
+      if (mesg_implicit_function_declaration != 2)
+        mesg_implicit_function_declaration = 1;
+    }
   else if (!strcmp (p, "-Wno-implicit"))
-    warn_implicit = 0;
+    warn_implicit_int = 0, mesg_implicit_function_declaration = 0;
   else if (!strcmp (p, "-Wwrite-strings"))
     warn_write_strings = 1;
   else if (!strcmp (p, "-Wno-write-strings"))
@@ -750,7 +770,8 @@ c_decode_option (p)
 	 warning about not using it without also specifying -O.  */
       if (warn_uninitialized != 1)
 	warn_uninitialized = 2;
-      warn_implicit = 1;
+      warn_implicit_int = 1;
+      mesg_implicit_function_declaration = 1;
       warn_return_type = 1;
       warn_unused = 1;
       warn_switch = 1;
@@ -758,7 +779,6 @@ c_decode_option (p)
       warn_char_subscripts = 1;
       warn_parentheses = 1;
       warn_missing_braces = 1;
-      warn_sign_compare = 1;
       /* We set this to 2 here, but 1 in -Wmain, so -ffreestanding can turn
 	 it off only if it's not explicit.  */
       warn_main = 2;
@@ -1738,7 +1758,7 @@ duplicate_decls (newdecl, olddecl, different_binding_level)
 
   /* Optionally warn about more than one declaration for the same name.  */
   if (errmsg == 0 && warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0
-      /* Dont warn about a function declaration
+      /* Don't warn about a function declaration
 	 followed by a definition.  */
       && !(TREE_CODE (newdecl) == FUNCTION_DECL && DECL_INITIAL (newdecl) != 0
 	   && DECL_INITIAL (olddecl) == 0)
@@ -1948,13 +1968,14 @@ duplicate_decls (newdecl, olddecl, different_binding_level)
     }
   if (different_binding_level)
     {
-      /* Don't output a duplicate symbol for this declaration.  */
-      TREE_ASM_WRITTEN (newdecl) = 1;
+      /* Don't output a duplicate symbol or debugging information for this
+	 declaration.  */
+      TREE_ASM_WRITTEN (newdecl) = DECL_IGNORED_P (newdecl) = 1;
       return 0;
     }
 
   /* Copy most of the decl-specific fields of NEWDECL into OLDDECL.
-     But preserve OLDdECL's DECL_UID.  */
+     But preserve OLDDECL's DECL_UID.  */
   {
     register unsigned olddecl_uid = DECL_UID (olddecl);
 
@@ -2112,7 +2133,8 @@ pushdecl (x)
 	      if (TYPE_NAME (TREE_TYPE (x)) == 0)
 	        TYPE_NAME (TREE_TYPE (x)) = x;
             }
-          else if (TREE_TYPE (x) != error_mark_node)
+          else if (TREE_TYPE (x) != error_mark_node
+		   && DECL_ORIGINAL_TYPE (x) == NULL_TREE)
             {
               tree tt = TREE_TYPE (x);
 	      DECL_ORIGINAL_TYPE (x) = tt;
@@ -2467,9 +2489,15 @@ implicitly_declare (functionid)
 
   rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
 
-  if (warn_implicit && implicit_warning)
-    warning ("implicit declaration of function `%s'",
-	     IDENTIFIER_POINTER (functionid));
+  if (mesg_implicit_function_declaration && implicit_warning)
+    {
+      if (mesg_implicit_function_declaration == 2)
+        error ("implicit declaration of function `%s'",
+                 IDENTIFIER_POINTER (functionid));
+      else
+        warning ("implicit declaration of function `%s'",
+                 IDENTIFIER_POINTER (functionid));
+    }
   else if (warn_traditional && traditional_warning)
     warning ("function `%s' was previously declared within a block",
 	     IDENTIFIER_POINTER (functionid));
@@ -2849,7 +2877,7 @@ init_decl_processing ()
   tree traditional_ptr_type_node;
   /* Data types of memcpy and strlen.  */
   tree memcpy_ftype, memset_ftype, strlen_ftype;
-  tree void_ftype_any;
+  tree void_ftype_any, ptr_ftype_void, ptr_ftype_ptr;
   int wchar_type_size;
   tree temp;
   tree array_domain_type;
@@ -3165,6 +3193,11 @@ init_decl_processing ()
 							    sizetype,
 							    endlink))));
 
+  ptr_ftype_void = build_function_type (ptr_type_node, endlink);
+  ptr_ftype_ptr
+    = build_function_type (ptr_type_node,
+			   tree_cons (NULL_TREE, ptr_type_node, endlink));
+
   builtin_function ("__builtin_constant_p", default_function_type,
 		    BUILT_IN_CONSTANT_P, NULL_PTR);
 
@@ -3186,6 +3219,38 @@ init_decl_processing ()
 		    build_function_type (ptr_type_node, NULL_TREE),
 		    BUILT_IN_AGGREGATE_INCOMING_ADDRESS, NULL_PTR);
 
+  /* Hooks for the DWARF 2 __throw routine.  */
+  builtin_function ("__builtin_unwind_init",
+		    build_function_type (void_type_node, endlink),
+		    BUILT_IN_UNWIND_INIT, NULL_PTR);
+  builtin_function ("__builtin_fp", ptr_ftype_void, BUILT_IN_FP, NULL_PTR);
+  builtin_function ("__builtin_sp", ptr_ftype_void, BUILT_IN_SP, NULL_PTR);
+  builtin_function ("__builtin_dwarf_fp_regnum",
+		    build_function_type (unsigned_type_node, endlink),
+		    BUILT_IN_DWARF_FP_REGNUM, NULL_PTR);
+  builtin_function ("__builtin_dwarf_reg_size", int_ftype_int,
+		    BUILT_IN_DWARF_REG_SIZE, NULL_PTR);		    
+  builtin_function ("__builtin_frob_return_addr", ptr_ftype_ptr,
+		    BUILT_IN_FROB_RETURN_ADDR, NULL_PTR);
+  builtin_function ("__builtin_extract_return_addr", ptr_ftype_ptr,
+		    BUILT_IN_EXTRACT_RETURN_ADDR, NULL_PTR);
+  builtin_function ("__builtin_set_return_addr_reg",
+		    build_function_type (void_type_node, 
+					 tree_cons (NULL_TREE,
+						    ptr_type_node,
+						    endlink)),
+		    BUILT_IN_SET_RETURN_ADDR_REG, NULL_PTR);
+  builtin_function ("__builtin_eh_stub", ptr_ftype_void,
+		    BUILT_IN_EH_STUB, NULL_PTR);
+  builtin_function
+    ("__builtin_set_eh_regs",
+     build_function_type (void_type_node,
+			  tree_cons (NULL_TREE, ptr_type_node,
+				     tree_cons (NULL_TREE,
+						type_for_mode (ptr_mode, 0),
+						endlink))),
+     BUILT_IN_SET_EH_REGS, NULL_PTR);
+
   builtin_function ("__builtin_alloca",
 		    build_function_type (ptr_type_node,
 					 tree_cons (NULL_TREE,
@@ -3843,6 +3908,9 @@ finish_decl (decl, init, asmspec_tree)
 	  else
 	    error_with_decl (decl, "storage size of `%s' isn't constant");
 	}
+
+      if (TREE_USED  (type))
+	TREE_USED (decl) = 1;
     }
 
   /* If this is a function and an assembler name is specified, it isn't
@@ -4324,9 +4392,9 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
 	     For now, issue a warning if -Wreturn-type and this is a function,
 	     or if -Wimplicit; prefer the former warning since it is more
 	     explicit.  */
-	  if ((warn_implicit || warn_return_type) && funcdef_flag)
+	  if ((warn_implicit_int || warn_return_type) && funcdef_flag)
 	    warn_about_return_type = 1;
-	  else if (warn_implicit)
+	  else if (warn_implicit_int)
 	    warning ("type defaults to `int' in declaration of `%s'", name);
 	}
 
@@ -4339,7 +4407,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
 
   /* Long double is a special combination.  */
 
-  if ((specbits & 1 << (int) RID_LONG)
+  if ((specbits & 1 << (int) RID_LONG) && ! longlong
       && TYPE_MAIN_VARIANT (type) == double_type_node)
     {
       specbits &= ~ (1 << (int) RID_LONG);
@@ -4353,11 +4421,9 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
     {
       int ok = 0;
 
-      if (TREE_CODE (type) != INTEGER_TYPE)
-	error ("long, short, signed or unsigned invalid for `%s'", name);
-      else if ((specbits & 1 << (int) RID_LONG)
-	       && (specbits & 1 << (int) RID_SHORT))
-	error ("long and short specified together for `%s'", name);
+      if ((specbits & 1 << (int) RID_LONG)
+	  && (specbits & 1 << (int) RID_SHORT))
+	error ("both long and short specified for `%s'", name);
       else if (((specbits & 1 << (int) RID_LONG)
 		|| (specbits & 1 << (int) RID_SHORT))
 	       && explicit_char)
@@ -4365,10 +4431,21 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
       else if (((specbits & 1 << (int) RID_LONG)
 		|| (specbits & 1 << (int) RID_SHORT))
 	       && TREE_CODE (type) == REAL_TYPE)
-	error ("long or short specified with floating type for `%s'", name);
+	{
+	  static int already = 0;
+
+	  error ("long or short specified with floating type for `%s'", name);
+	  if (! already && ! pedantic)
+	    {
+	      error ("the only valid combination is `long double'");
+	      already = 1;
+	    }
+	}
       else if ((specbits & 1 << (int) RID_SIGNED)
 	       && (specbits & 1 << (int) RID_UNSIGNED))
-	error ("signed and unsigned given together for `%s'", name);
+	error ("both signed and unsigned specified for `%s'", name);
+      else if (TREE_CODE (type) != INTEGER_TYPE)
+	error ("long, short, signed or unsigned invalid for `%s'", name);
       else
 	{
 	  ok = 1;
@@ -4663,6 +4740,18 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
 				   convert (index_type, size),
 				   convert (index_type, size_one_node)));
 
+	      /* If that overflowed, the array is too big.
+		 ??? While a size of INT_MAX+1 technically shouldn't cause
+		 an overflow (because we subtract 1), the overflow is recorded
+		 during the conversion to index_type, before the subtraction.
+		 Handling this case seems like an unnecessary complication.  */
+	      if (TREE_OVERFLOW (itype))
+		{
+		  error ("size of array `%s' is too large", name);
+		  type = error_mark_node;
+		  continue;
+		}
+
 	      if (size_varies)
 		itype = variable_size (itype);
 	      itype = build_index_type (itype);
@@ -4838,6 +4927,13 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
 
   /* Now TYPE has the actual type.  */
 
+  /* Did array size calculations overflow?  */
+
+  if (TREE_CODE (type) == ARRAY_TYPE
+      && TYPE_SIZE (type)
+      && TREE_OVERFLOW (TYPE_SIZE (type)))
+    error ("size of array `%s' is too large", name);
+
   /* If this is declaring a typedef name, return a TYPE_DECL.  */
 
   if (specbits & (1 << (int) RID_TYPEDEF))
@@ -5058,9 +5154,6 @@ grokdeclarator (declarator, declspecs, decl_context, initialized)
 
 	    if (! strcmp (IDENTIFIER_POINTER (declarator), "main"))
 	      warning ("cannot inline function `main'");
-	    else if (last && (TYPE_MAIN_VARIANT (TREE_VALUE (last))
-			      != void_type_node))
-	      warning ("inline declaration ignored for function with `...'");
 	    else
 	      /* Assume that otherwise the function can be inlined.  */
 	      DECL_INLINE (decl) = 1;
@@ -5483,6 +5576,7 @@ start_struct (code, name)
   if (ref && TREE_CODE (ref) == code)
     {
       C_TYPE_BEING_DEFINED (ref) = 1;
+      TYPE_PACKED (ref) = flag_pack_struct;
       if (TYPE_FIELDS (ref))
 	error ((code == UNION_TYPE ? "redefinition of `union %s'"
 		: "redefinition of `struct %s'"),
@@ -6164,7 +6258,10 @@ start_function (declspecs, declarator, prefix_attributes, attributes, nested)
   /* If the declarator is not suitable for a function definition,
      cause a syntax error.  */
   if (decl1 == 0)
-    return 0;
+    {
+      immediate_size_expand = old_immediate_size_expand;
+      return 0;
+    }
 
   decl_attributes (decl1, prefix_attributes, attributes);
 

gcc/c-gperf.h

@@ -0,0 +1,186 @@
+/* C code produced by gperf version 2.5 (GNU C++ version) */
+/* Command-line: gperf -p -j1 -i 1 -g -o -t -G -N is_reserved_word -k1,3,$ ./c-parse.gperf  */
+/* Command-line: gperf -p -j1 -i 1 -g -o -t -N is_reserved_word -k1,3,$ c-parse.gperf  */ 
+struct resword { char *name; short token; enum rid rid; };
+
+#define TOTAL_KEYWORDS 79
+#define MIN_WORD_LENGTH 2
+#define MAX_WORD_LENGTH 20
+#define MIN_HASH_VALUE 10
+#define MAX_HASH_VALUE 144
+/* maximum key range = 135, duplicates = 0 */
+
+#ifdef __GNUC__
+inline
+#endif
+static unsigned int
+hash (str, len)
+     register char *str;
+     register int unsigned len;
+{
+  static unsigned char asso_values[] =
+    {
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145,  25, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
+     145, 145, 145, 145, 145,   1, 145,  46,   8,  15,
+      61,   6,  36,  48,   3,   5, 145,  18,  63,  25,
+      29,  76,   1, 145,  13,   2,   1,  51,  37,   9,
+       9,   1,   3, 145, 145, 145, 145, 145,
+    };
+  register int hval = len;
+
+  switch (hval)
+    {
+      default:
+      case 3:
+        hval += asso_values[str[2]];
+      case 2:
+      case 1:
+        hval += asso_values[str[0]];
+        break;
+    }
+  return hval + asso_values[str[len - 1]];
+}
+
+static struct resword wordlist[] =
+{
+      {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
+      {"",}, 
+      {"int",  TYPESPEC, RID_INT},
+      {"",}, {"",}, 
+      {"__typeof__",  TYPEOF, NORID},
+      {"__signed__",  TYPESPEC, RID_SIGNED},
+      {"__imag__",  IMAGPART, NORID},
+      {"switch",  SWITCH, NORID},
+      {"__inline__",  SCSPEC, RID_INLINE},
+      {"else",  ELSE, NORID},
+      {"__iterator__",  SCSPEC, RID_ITERATOR},
+      {"__inline",  SCSPEC, RID_INLINE},
+      {"__extension__",  EXTENSION, NORID},
+      {"struct",  STRUCT, NORID},
+      {"__real__",  REALPART, NORID},
+      {"__const",  TYPE_QUAL, RID_CONST},
+      {"while",  WHILE, NORID},
+      {"__const__",  TYPE_QUAL, RID_CONST},
+      {"case",  CASE, NORID},
+      {"__complex__",  TYPESPEC, RID_COMPLEX},
+      {"__iterator",  SCSPEC, RID_ITERATOR},
+      {"bycopy",  TYPE_QUAL, RID_BYCOPY},
+      {"",}, {"",}, {"",}, 
+      {"__complex",  TYPESPEC, RID_COMPLEX},
+      {"",}, 
+      {"in",  TYPE_QUAL, RID_IN},
+      {"break",  BREAK, NORID},
+      {"@defs",  DEFS, NORID},
+      {"",}, {"",}, {"",}, 
+      {"extern",  SCSPEC, RID_EXTERN},
+      {"if",  IF, NORID},
+      {"typeof",  TYPEOF, NORID},
+      {"typedef",  SCSPEC, RID_TYPEDEF},
+      {"__typeof",  TYPEOF, NORID},
+      {"sizeof",  SIZEOF, NORID},
+      {"",}, 
+      {"return",  RETURN, NORID},
+      {"const",  TYPE_QUAL, RID_CONST},
+      {"__volatile__",  TYPE_QUAL, RID_VOLATILE},
+      {"@private",  PRIVATE, NORID},
+      {"@selector",  SELECTOR, NORID},
+      {"__volatile",  TYPE_QUAL, RID_VOLATILE},
+      {"__asm__",  ASM_KEYWORD, NORID},
+      {"",}, {"",}, 
+      {"continue",  CONTINUE, NORID},
+      {"__alignof__",  ALIGNOF, NORID},
+      {"__imag",  IMAGPART, NORID},
+      {"__attribute__",  ATTRIBUTE, NORID},
+      {"",}, {"",}, 
+      {"__attribute",  ATTRIBUTE, NORID},
+      {"for",  FOR, NORID},
+      {"",}, 
+      {"@encode",  ENCODE, NORID},
+      {"id",  OBJECTNAME, RID_ID},
+      {"static",  SCSPEC, RID_STATIC},
+      {"@interface",  INTERFACE, NORID},
+      {"",}, 
+      {"__signed",  TYPESPEC, RID_SIGNED},
+      {"",}, 
+      {"__label__",  LABEL, NORID},
+      {"",}, {"",}, 
+      {"__asm",  ASM_KEYWORD, NORID},
+      {"char",  TYPESPEC, RID_CHAR},
+      {"",}, 
+      {"inline",  SCSPEC, RID_INLINE},
+      {"out",  TYPE_QUAL, RID_OUT},
+      {"register",  SCSPEC, RID_REGISTER},
+      {"__real",  REALPART, NORID},
+      {"short",  TYPESPEC, RID_SHORT},
+      {"",}, 
+      {"enum",  ENUM, NORID},
+      {"inout",  TYPE_QUAL, RID_INOUT},
+      {"",}, 
+      {"oneway",  TYPE_QUAL, RID_ONEWAY},
+      {"union",  UNION, NORID},
+      {"",}, 
+      {"__alignof",  ALIGNOF, NORID},
+      {"",}, 
+      {"@implementation",  IMPLEMENTATION, NORID},
+      {"",}, 
+      {"@class",  CLASS, NORID},
+      {"",}, 
+      {"@public",  PUBLIC, NORID},
+      {"asm",  ASM_KEYWORD, NORID},
+      {"",}, {"",}, {"",}, {"",}, {"",}, 
+      {"default",  DEFAULT, NORID},
+      {"",}, 
+      {"void",  TYPESPEC, RID_VOID},
+      {"",}, 
+      {"@protected",  PROTECTED, NORID},
+      {"@protocol",  PROTOCOL, NORID},
+      {"",}, {"",}, {"",}, 
+      {"volatile",  TYPE_QUAL, RID_VOLATILE},
+      {"",}, {"",}, 
+      {"signed",  TYPESPEC, RID_SIGNED},
+      {"float",  TYPESPEC, RID_FLOAT},
+      {"@end",  END, NORID},
+      {"",}, {"",}, 
+      {"unsigned",  TYPESPEC, RID_UNSIGNED},
+      {"@compatibility_alias",  ALIAS, NORID},
+      {"double",  TYPESPEC, RID_DOUBLE},
+      {"",}, {"",}, 
+      {"auto",  SCSPEC, RID_AUTO},
+      {"",}, 
+      {"goto",  GOTO, NORID},
+      {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, 
+      {"do",  DO, NORID},
+      {"",}, {"",}, {"",}, {"",}, 
+      {"long",  TYPESPEC, RID_LONG},
+};
+
+#ifdef __GNUC__
+inline
+#endif
+struct resword *
+is_reserved_word (str, len)
+     register char *str;
+     register unsigned int len;
+{
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register int key = hash (str, len);
+
+      if (key <= MAX_HASH_VALUE && key >= 0)
+        {
+          register char *s = wordlist[key].name;
+
+          if (*s == *str && !strcmp (str + 1, s + 1))
+            return &wordlist[key];
+        }
+    }
+  return 0;
+}

gcc/c-iterate.c

@@ -1,5 +1,5 @@
 /* Build expressions with type checking for C compiler.
-   Copyright (C) 1987, 88, 89, 92, 93, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1987, 88, 89, 92, 93, 96, 1997 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -255,6 +255,8 @@ collect_iterators (exp, list)
 		break;
 	      case RTL_EXPR:
 		return list;
+	      default:
+		break;
 	      }
 		
 	    for (i = 0; i < num_args; i++)

gcc/c-lang.c

@@ -1,5 +1,5 @@
 /* Language-specific hook definitions for C front end.
-   Copyright (C) 1991, 1995 Free Software Foundation, Inc.
+   Copyright (C) 1991, 1995, 1997 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -137,7 +137,6 @@ void
 finish_file ()
 {
   extern tree static_ctors, static_dtors;
-  extern tree get_file_function_name ();
   extern tree build_function_call                 PROTO((tree, tree));
   tree void_list_node = build_tree_list (NULL_TREE, void_type_node);
 #ifndef ASM_OUTPUT_CONSTRUCTOR

gcc/c-lex.c

@@ -1,5 +1,5 @@
 /* Lexical analyzer for C and Objective C.
-   Copyright (C) 1987, 88, 89, 92, 94, 95, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1987, 88, 89, 92, 94-97, 1998 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -18,12 +18,12 @@ along with GNU CC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
+#include "config.h"
 
 #include <stdio.h>
 #include <errno.h>
 #include <setjmp.h>
 
-#include "config.h"
 #include "rtl.h"
 #include "tree.h"
 #include "input.h"
@@ -35,6 +35,13 @@ Boston, MA 02111-1307, USA.  */
 
 #include <ctype.h>
 
+/* MULTIBYTE_CHARS support only works for native compilers.
+   ??? Ideally what we want is to model widechar support after
+   the current floating point support.  */
+#ifdef CROSS_COMPILE
+#undef MULTIBYTE_CHARS
+#endif
+
 #ifdef MULTIBYTE_CHARS
 #include <stdlib.h>
 #include <locale.h>
@@ -118,6 +125,8 @@ char *token_buffer;	/* Pointer to token buffer.
 			   Actual allocated length is maxtoken + 2.
 			   This is not static because objc-parse.y uses it.  */
 
+static int indent_level = 0;        /* Number of { minus number of }. */
+
 /* Nonzero if end-of-file has been seen on input.  */
 static int end_of_file;
 
@@ -126,6 +135,9 @@ static int end_of_file;
 static int nextchar = -1;
 #endif
 
+static int skip_which_space		PROTO((int));
+static char *extend_token_buffer	PROTO((char *));
+static int readescape			PROTO((int *));
 int check_newline ();
 
 /* Do not insert generated code into the source, instead, include it.
@@ -321,7 +333,6 @@ yyprint (file, yychar, yylval)
       break;
     }
 }
-
 
 /* If C is not whitespace, return C.
    Otherwise skip whitespace and return first nonwhite char read.  */
@@ -413,7 +424,6 @@ extend_token_buffer (p)
 
   return token_buffer + offset;
 }
-
 
 #if !USE_CPPLIB
 #define GET_DIRECTIVE_LINE() get_directive_line (finput)
@@ -560,7 +570,7 @@ check_newline ()
 	      token = yylex ();
 	      if (token != IDENTIFIER)
 		goto skipline;
-	      if (HANDLE_PRAGMA (yylval.ttype))
+	      if (HANDLE_PRAGMA (finput, yylval.ttype))
 		{
 		  c = GETC ();
 		  return c;
@@ -747,6 +757,7 @@ linenum:
 	      input_file_stack->line = old_lineno;
 	      p->next = input_file_stack;
 	      p->name = input_filename;
+	      p->indent_level = indent_level;
 	      input_file_stack = p;
 	      input_file_stack_tick++;
 	      debug_start_source_file (input_filename);
@@ -758,6 +769,14 @@ linenum:
 	      if (input_file_stack->next)
 		{
 		  struct file_stack *p = input_file_stack;
+		  if (indent_level != p->indent_level)
+		    {
+		      warning_with_file_and_line 
+			(p->name, old_lineno,
+			 "This file contains more `%c's than `%c's.",
+			 indent_level > p->indent_level ? '{' : '}',
+			 indent_level > p->indent_level ? '}' : '{');
+		    }
 		  input_file_stack = p->next;
 		  free (p);
 		  input_file_stack_tick++;
@@ -816,6 +835,10 @@ linenum:
 
   /* skip the rest of this line.  */
  skipline:
+#if !USE_CPPLIB
+  if (c != '\n' && c != EOF && nextchar >= 0)
+    c = nextchar, nextchar = -1;
+#endif
   while (c != '\n' && c != EOF)
     c = GETC();
   return c;
@@ -1451,8 +1474,8 @@ yylex ()
 	if (floatflag != NOT_FLOAT)
 	  {
 	    tree type = double_type_node;
-	    int exceeds_double = 0;
 	    int imag = 0;
+	    int conversion_errno = 0;
 	    REAL_VALUE_TYPE value;
 	    jmp_buf handler;
 
@@ -1481,7 +1504,6 @@ yylex ()
 	      }
 
 	    *p = 0;
-	    errno = 0;
 
 	    /* Convert string to a double, checking for overflow.  */
 	    if (setjmp (handler))
@@ -1551,7 +1573,9 @@ yylex ()
 		      error ("both `f' and `l' in floating constant");
 
 		    type = float_type_node;
+		    errno = 0;
 		    value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
+		    conversion_errno = errno;
 		    /* A diagnostic is required here by some ANSI C testsuites.
 		       This is not pedwarn, become some people don't want
 		       an error for this.  */
@@ -1561,13 +1585,17 @@ yylex ()
 		else if (lflag)
 		  {
 		    type = long_double_type_node;
+		    errno = 0;
 		    value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
+		    conversion_errno = errno;
 		    if (REAL_VALUE_ISINF (value) && pedantic)
 		      warning ("floating point number exceeds range of `long double'");
 		  }
 		else
 		  {
+		    errno = 0;
 		    value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
+		    conversion_errno = errno;
 		    if (REAL_VALUE_ISINF (value) && pedantic)
 		      warning ("floating point number exceeds range of `double'");
 		  }
@@ -1575,17 +1603,12 @@ yylex ()
 		set_float_handler (NULL_PTR);
 	    }
 #ifdef ERANGE
-	    if (errno == ERANGE && !flag_traditional && pedantic)
-	      {
-  		/* ERANGE is also reported for underflow,
-  		   so test the value to distinguish overflow from that.  */
-		if (REAL_VALUES_LESS (dconst1, value)
-		    || REAL_VALUES_LESS (value, dconstm1))
-		  {
-		    warning ("floating point number exceeds range of `double'");
-		    exceeds_double = 1;
-		  }
-	      }
+	    /* ERANGE is also reported for underflow,
+	       so test the value to distinguish overflow from that.  */
+	    if (conversion_errno == ERANGE && !flag_traditional && pedantic
+		&& (REAL_VALUES_LESS (dconst1, value)
+		    || REAL_VALUES_LESS (value, dconstm1)))
+	      warning ("floating point number exceeds range of `double'");
 #endif
 
 	    /* If the result is not a number, assume it must have been
@@ -1648,20 +1671,15 @@ yylex ()
 		c = GETC();
 	      }
 
-	    /* If the constant is not long long and it won't fit in an
-	       unsigned long, or if the constant is long long and won't fit
-	       in an unsigned long long, then warn that the constant is out
-	       of range.  */
+	    /* If the constant won't fit in an unsigned long long,
+	       then warn that the constant is out of range.  */
 
 	    /* ??? This assumes that long long and long integer types are
 	       a multiple of 8 bits.  This better than the original code
 	       though which assumed that long was exactly 32 bits and long
 	       long was exactly 64 bits.  */
 
-	    if (spec_long_long)
-	      bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
-	    else
-	      bytes = TYPE_PRECISION (long_integer_type_node) / 8;
+	    bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
 
 	    warn = overflow;
 	    for (i = bytes; i < TOTAL_PARTS; i++)
@@ -1728,11 +1746,11 @@ yylex ()
 		else if (! spec_unsigned && !spec_long_long
 			 && int_fits_type_p (yylval.ttype, long_integer_type_node))
 		  ansi_type = long_integer_type_node;
-		else if (! spec_long_long)
+		else if (! spec_long_long
+			 && int_fits_type_p (yylval.ttype,
+					     long_unsigned_type_node))
 		  ansi_type = long_unsigned_type_node;
 		else if (! spec_unsigned
-			 /* Verify value does not overflow into sign bit.  */
-			 && TREE_INT_CST_HIGH (yylval.ttype) >= 0
 			 && int_fits_type_p (yylval.ttype,
 					     long_long_integer_type_node))
 		  ansi_type = long_long_integer_type_node;
@@ -1754,8 +1772,9 @@ yylex ()
 		  warning ("width of integer constant may change on other systems with -traditional");
 	      }
 
-	    if (!flag_traditional && !int_fits_type_p (yylval.ttype, type)
-		&& !warn)
+	    if (pedantic && !flag_traditional && !spec_long_long && !warn
+		&& (TYPE_PRECISION (long_integer_type_node)
+		    < TYPE_PRECISION (type)))
 	      pedwarn ("integer constant out of range");
 
 	    if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
@@ -1986,15 +2005,9 @@ yylex ()
 	    bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
 #else
 	    {
-	      union { long l; char c[sizeof (long)]; } u;
-	      int big_endian;
 	      char *wp, *cp;
 
-	      /* Determine whether host is little or big endian.  */
-	      u.l = 1;
-	      big_endian = u.c[sizeof (long) - 1];
-	      wp = widep + (big_endian ? WCHAR_BYTES - 1 : 0);
-
+	      wp = widep + (BYTES_BIG_ENDIAN ? WCHAR_BYTES - 1 : 0);
 	      bzero (widep, (p - token_buffer) * WCHAR_BYTES);
 	      for (cp = token_buffer + 1; cp < p; cp++)
 		*wp = *cp, wp += WCHAR_BYTES;
@@ -2122,13 +2135,13 @@ yylex ()
 	      break;
 	    case '<':
 	      if (c1 == '%')
-		{ value = '{'; goto done; }
+		{ value = '{'; indent_level++; goto done; }
 	      if (c1 == ':')
 		{ value = '['; goto done; }
 	      break;
 	    case '%':
 	      if (c1 == '>')
-		{ value = '}'; goto done; }
+		{ value = '}'; indent_level--; goto done; }
 	      break;
 	    }
 	UNGETC (c1);
@@ -2145,6 +2158,16 @@ yylex ()
       value = 1;
       break;
 
+    case '{':
+      indent_level++;
+      value = c;
+      break;
+
+    case '}':
+      indent_level--;
+      value = c;
+      break;
+
     default:
       value = c;
     }

gcc/c-parse.in

@@ -1,5 +1,5 @@
 /* YACC parser for C syntax and for Objective C.  -*-c-*-
-   Copyright (C) 1987, 88, 89, 92-6, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1987, 88, 89, 92-97, 1998 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -58,11 +58,12 @@ State 434 contains 2 shift/reduce conflicts.  (Four ways to parse this.)  */
 end ifc
 
 %{
+#include "config.h"
+
 #include <stdio.h>
 #include <errno.h>
 #include <setjmp.h>
 
-#include "config.h"
 #include "tree.h"
 #include "input.h"
 #include "c-lex.h"
@@ -232,9 +233,11 @@ ifobjc
 end ifobjc
 
 %{
-/* Number of statements (loosely speaking) seen so far.  */
+/* Number of statements (loosely speaking) and compound statements 
+   seen so far.  */
 static int stmt_count;
-
+static int compstmt_count;
+  
 /* Input file and line number of the end of the body of last simple_if;
    used by the stmt-rule immediately after simple_if returns.  */
 static char *if_stmt_file;
@@ -487,7 +490,7 @@ unary_expr:
 	| sizeof unary_expr  %prec UNARY
 		{ skip_evaluation--;
 		  if (TREE_CODE ($2) == COMPONENT_REF
-		      && DECL_BIT_FIELD (TREE_OPERAND ($2, 1)))
+		      && DECL_C_BIT_FIELD (TREE_OPERAND ($2, 1)))
 		    error ("`sizeof' applied to a bit-field");
 		  $$ = c_sizeof (TREE_TYPE ($2)); }
 	| sizeof '(' typename ')'  %prec HYPERUNARY
@@ -679,7 +682,7 @@ end ifobjc
 			      if (IDENTIFIER_GLOBAL_VALUE ($1) != error_mark_node
 				  || IDENTIFIER_ERROR_LOCUS ($1) != current_function_decl)
 				{
-				  error ("`%s' undeclared (first use this function)",
+				  error ("`%s' undeclared (first use in this function)",
 					 IDENTIFIER_POINTER ($1));
 
 				  if (! undeclared_variable_notice)
@@ -1735,9 +1738,11 @@ compstmt_or_error:
 	| error compstmt
 	;
 
-compstmt: '{' '}'
+compstmt_start: '{' { compstmt_count++; }
+
+compstmt: compstmt_start '}'
 		{ $$ = convert (void_type_node, integer_zero_node); }
-	| '{' pushlevel maybe_label_decls decls xstmts '}'
+	| compstmt_start pushlevel maybe_label_decls decls xstmts '}'
 		{ emit_line_note (input_filename, lineno);
 		  expand_end_bindings (getdecls (), 1, 0);
 		  $$ = poplevel (1, 1, 0);
@@ -1745,7 +1750,7 @@ compstmt: '{' '}'
 		    pop_momentary_nofree ();
 		  else
 		    pop_momentary (); }
-	| '{' pushlevel maybe_label_decls error '}'
+	| compstmt_start pushlevel maybe_label_decls error '}'
 		{ emit_line_note (input_filename, lineno);
 		  expand_end_bindings (getdecls (), kept_level_p (), 0);
 		  $$ = poplevel (kept_level_p (), 0, 0);
@@ -1753,7 +1758,7 @@ compstmt: '{' '}'
 		    pop_momentary_nofree ();
 		  else
 		    pop_momentary (); }
-	| '{' pushlevel maybe_label_decls stmts '}'
+	| compstmt_start pushlevel maybe_label_decls stmts '}'
 		{ emit_line_note (input_filename, lineno);
 		  expand_end_bindings (getdecls (), kept_level_p (), 0);
 		  $$ = poplevel (kept_level_p (), 0, 0);
@@ -1766,8 +1771,8 @@ compstmt: '{' '}'
 /* Value is number of statements counted as of the closeparen.  */
 simple_if:
 	  if_prefix lineno_labeled_stmt
-/* Make sure expand_end_cond is run once
-   for each call to expand_start_cond.
+/* Make sure c_expand_end_cond is run once
+   for each call to c_expand_start_cond.
    Otherwise a crash is likely.  */
 	| if_prefix error
 	;
@@ -1775,7 +1780,8 @@ simple_if:
 if_prefix:
 	  IF '(' expr ')'
 		{ emit_line_note ($<filename>-1, $<lineno>0);
-		  expand_start_cond (truthvalue_conversion ($3), 0);
+		  c_expand_start_cond (truthvalue_conversion ($3), 0, 
+				       compstmt_count);
 		  $<itype>$ = stmt_count;
 		  if_stmt_file = $<filename>-1;
 		  if_stmt_line = $<lineno>0;
@@ -1788,6 +1794,7 @@ if_prefix:
 do_stmt_start:
 	  DO
 		{ stmt_count++;
+		  compstmt_count++;
 		  emit_line_note ($<filename>-1, $<lineno>0);
 		  /* See comment in `while' alternative, above.  */
 		  emit_nop ();
@@ -1850,15 +1857,15 @@ stmt:
 		  iterator_expand ($1);
 		  clear_momentary (); }
 	| simple_if ELSE
-		{ expand_start_else ();
+		{ c_expand_start_else ();
 		  $<itype>1 = stmt_count;
 		  position_after_white_space (); }
 	  lineno_labeled_stmt
-		{ expand_end_cond ();
+		{ c_expand_end_cond ();
 		  if (extra_warnings && stmt_count == $<itype>1)
 		    warning ("empty body in an else-statement"); }
 	| simple_if %prec IF
-		{ expand_end_cond ();
+		{ c_expand_end_cond ();
 		  /* This warning is here instead of in simple_if, because we
 		     do not want a warning if an empty if is followed by an
 		     else statement.  Increment stmt_count so we don't
@@ -1866,11 +1873,11 @@ stmt:
 		  if (extra_warnings && stmt_count++ == $<itype>1)
 		    warning_with_file_and_line (if_stmt_file, if_stmt_line,
 						"empty body in an if-statement"); }
-/* Make sure expand_end_cond is run once
-   for each call to expand_start_cond.
+/* Make sure c_expand_end_cond is run once
+   for each call to c_expand_start_cond.
    Otherwise a crash is likely.  */
 	| simple_if ELSE error
-		{ expand_end_cond (); }
+		{ c_expand_end_cond (); }
 	| WHILE
 		{ stmt_count++;
 		  emit_line_note ($<filename>-1, $<lineno>0);

gcc/c-pragma.c

@@ -1,5 +1,5 @@
 /* Handle #pragma, system V.4 style.  Supports #pragma weak and #pragma pack.
-   Copyright (C) 1992 Free Software Foundation, Inc.
+   Copyright (C) 1992, 1997 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -18,8 +18,8 @@ along with GNU CC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
-#include <stdio.h>
 #include "config.h"
+#include <stdio.h>
 #include "tree.h"
 #include "except.h"
 #include "function.h"
@@ -65,7 +65,7 @@ handle_pragma_token (string, token)
 	  if (HANDLE_PRAGMA_WEAK)
 	    handle_pragma_weak (state, name, value);
 
-#endif /* HANDLE_PRAMA_WEAK */
+#endif /* HANDLE_PRAGMA_WEAK */
 	}
 
       type = state = ps_start;

gcc/c-tree.h

@@ -177,7 +177,7 @@ extern tree convert_and_check			PROTO((tree, tree));
 extern void overflow_warning			PROTO((tree));
 extern void unsigned_conversion_warning		PROTO((tree, tree));
 /* Read the rest of the current #-directive line.  */
-extern char *get_directive_line                 STDIO_PROTO((FILE *));
+extern char *get_directive_line                 PROTO((FILE *));
 /* Subroutine of build_binary_op, used for comparison operations.
    See if the operands have both been converted from subword integer types
    and, if so, perhaps change them both back to their original type.  */
@@ -288,12 +288,9 @@ extern void pending_xref_error                  PROTO((void));
 extern void pop_c_function_context              PROTO((void));
 extern void pop_label_level                     PROTO((void));
 extern tree poplevel                            PROTO((int, int, int));
-extern void print_lang_decl                     STDIO_PROTO((FILE *, tree,
-							     int));
-extern void print_lang_identifier               STDIO_PROTO((FILE *, tree,
-							     int));
-extern void print_lang_type                     STDIO_PROTO((FILE *, tree,
-							     int));
+extern void print_lang_decl                     PROTO((FILE *, tree, int));
+extern void print_lang_identifier               PROTO((FILE *, tree, int));
+extern void print_lang_type                     PROTO((FILE *, tree, int));
 extern void push_c_function_context             PROTO((void));
 extern void push_label_level                    PROTO((void));
 extern void push_parm_decl                      PROTO((tree));

gcc/c-typeck.c

@@ -1,5 +1,5 @@
 /* Build expressions with type checking for C compiler.
-   Copyright (C) 1987, 88, 91-6, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1987, 88, 91-7, 1998 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -35,12 +35,29 @@ Boston, MA 02111-1307, USA.  */
 #include "flags.h"
 #include "output.h"
 
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#endif
+
 /* Nonzero if we've already printed a "missing braces around initializer"
    message within this initializer.  */
 static int missing_braces_mentioned;
 
+#ifdef NEED_DECLARATION_INDEX
 extern char *index ();
+#endif
+
+#ifdef NEED_DECLARATION_RINDEX
 extern char *rindex ();
+#endif
 
 static tree qualify_type		PROTO((tree, tree));
 static int comp_target_types		PROTO((tree, tree));
@@ -261,6 +278,12 @@ common_type (t1, t2)
 	  return build_type_attribute_variant (t1, attributes);
 	}
 
+      /* Likewise, prefer long double to double even if same size.  */
+      if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
+	  || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
+	return build_type_attribute_variant (long_double_type_node,
+					     attributes);
+
       /* Otherwise prefer the unsigned one.  */
 
       if (TREE_UNSIGNED (t1))
@@ -507,6 +530,9 @@ comptypes (type1, type2)
       if (maybe_objc_comptypes (t1, t2, 0) == 1)
 	val = 1;
       break;
+
+    default:
+      break;
     }
   return attrval == 2 && val == 1 ? 2 : val;
 }
@@ -776,7 +802,7 @@ signed_or_unsigned_type (unsignedp, type)
      int unsignedp;
      tree type;
 {
-  if (! INTEGRAL_TYPE_P (type)
+  if ((! INTEGRAL_TYPE_P (type) && ! POINTER_TYPE_P (type))
       || TREE_UNSIGNED (type) == unsignedp)
     return type;
   if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
@@ -1008,13 +1034,14 @@ default_conversion (exp)
       type = type_for_size (MAX (TYPE_PRECISION (type),
 				 TYPE_PRECISION (integer_type_node)),
 			    ((flag_traditional
-			      || TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))
+			      || (TYPE_PRECISION (type)
+				  >= TYPE_PRECISION (integer_type_node)))
 			     && TREE_UNSIGNED (type)));
       return convert (type, exp);
     }
 
   if (TREE_CODE (exp) == COMPONENT_REF
-      && DECL_BIT_FIELD (TREE_OPERAND (exp, 1)))
+      && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)))
     {
       tree width = DECL_SIZE (TREE_OPERAND (exp, 1));
       HOST_WIDE_INT low = TREE_INT_CST_LOW (width);
@@ -1242,6 +1269,9 @@ build_component_ref (datum, component)
 	(TREE_OPERAND (datum, 0),
 	 build_component_ref (TREE_OPERAND (datum, 1), component),
 	 build_component_ref (TREE_OPERAND (datum, 2), component));
+
+    default:
+      break;
     }
 
   /* See if there is a field or component with name COMPONENT.  */
@@ -1573,6 +1603,8 @@ build_function_call (function, params)
 	if (coerced_params == 0)
 	  return integer_zero_node;
 	return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
+      default:
+	break;
       }
 
   {
@@ -2333,6 +2365,9 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
 	    pedwarn ("comparison between pointer and integer");
 	}
       break;
+      
+    default:
+      break;
     }
 
   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
@@ -2477,7 +2512,8 @@ build_binary_op (code, orig_op0, orig_op1, convert_p)
 	  converted = 1;
 	  resultcode = xresultcode;
 
-	  if (warn_sign_compare && skip_evaluation == 0)
+	  if ((warn_sign_compare < 0 ? extra_warnings : warn_sign_compare != 0)
+	      && skip_evaluation == 0)
 	    {
 	      int op0_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op0));
 	      int op1_signed = ! TREE_UNSIGNED (TREE_TYPE (orig_op1));
@@ -3111,6 +3147,9 @@ build_unary_op (code, xarg, noconvert)
 	  TREE_CONSTANT (addr) = 1;
 	return addr;
       }
+
+    default:
+      break;
     }
 
   if (!errstring)
@@ -3179,17 +3218,16 @@ lvalue_p (ref)
     case PARM_DECL:
     case RESULT_DECL:
     case ERROR_MARK:
-      if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
-	  && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE)
-	return 1;
-      break;
+      return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
+	      && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
 
     case BIND_EXPR:
     case RTL_EXPR:
-      if (TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE)
-	return 1;
+      return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
+
+    default:
+      return 0;
     }
-  return 0;
 }
 
 /* Return nonzero if REF is an lvalue valid for this language;
@@ -3221,7 +3259,12 @@ unary_complex_lvalue (code, arg)
   if (TREE_CODE (arg) == COMPOUND_EXPR)
     {
       tree real_result = build_unary_op (code, TREE_OPERAND (arg, 1), 0);
-      pedantic_lvalue_warning (COMPOUND_EXPR);
+
+      /* If this returns a function type, it isn't really being used as
+	 an lvalue, so don't issue a warning about it.  */
+      if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
+	pedantic_lvalue_warning (COMPOUND_EXPR);
+
       return build (COMPOUND_EXPR, TREE_TYPE (real_result),
 		    TREE_OPERAND (arg, 0), real_result);
     }
@@ -3230,6 +3273,9 @@ unary_complex_lvalue (code, arg)
   if (TREE_CODE (arg) == COND_EXPR)
     {
       pedantic_lvalue_warning (COND_EXPR);
+      if (TREE_CODE (TREE_TYPE (arg)) != FUNCTION_TYPE)
+	pedantic_lvalue_warning (COMPOUND_EXPR);
+
       return (build_conditional_expr
 	      (TREE_OPERAND (arg, 0),
 	       build_unary_op (code, TREE_OPERAND (arg, 1), 0),
@@ -3871,6 +3917,8 @@ build_modify_expr (lhs, modifycode, rhs)
 		      /* But cast it to void to avoid an "unused" error.  */
 		      convert (void_type_node, rhs), cond);
       }
+    default:
+      break;
     }
 
   /* If a binary op has been requested, combine the old LHS value with the RHS
@@ -3912,6 +3960,9 @@ build_modify_expr (lhs, modifycode, rhs)
 	pedantic_lvalue_warning (CONVERT_EXPR);
 	return convert (TREE_TYPE (lhs), result);
       }
+      
+    default:
+      break;
     }
 
   /* Now we have handled acceptable kinds of LHS that are not truly lvalues.
@@ -4425,9 +4476,10 @@ initializer_constant_valid_p (value, endtype)
 	  return null_pointer_node;
 	return 0;
       }
-    }
 
-  return 0;
+    default:
+      return 0;
+    }
 }
 
 /* If VALUE is a compound expr all of whose expressions are constant, then
@@ -6616,6 +6668,9 @@ c_expand_return (retval)
 		  && DECL_CONTEXT (inner) == current_function_decl)
 		warning ("function returns address of local variable");
 	      break;
+
+	    default:
+	      break;
 	    }
 
 	  break;

gcc/caller-save.c

@@ -19,6 +19,7 @@ the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
 #include "config.h"
+#include <stdio.h>
 #include "rtl.h"
 #include "insn-config.h"
 #include "flags.h"

gcc/calls.c

@@ -1,5 +1,5 @@
 /* Convert function calls to rtl insns, for GNU C compiler.
-   Copyright (C) 1989, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1989, 92-97, 1998 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -19,10 +19,12 @@ the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
 #include "config.h"
+#include <stdio.h>
 #include "rtl.h"
 #include "tree.h"
 #include "flags.h"
 #include "expr.h"
+#include "regs.h"
 #ifdef __STDC__
 #include <stdarg.h>
 #else
@@ -123,7 +125,8 @@ int stack_arg_under_construction;
 
 static int calls_function	PROTO((tree, int));
 static int calls_function_1	PROTO((tree, int));
-static void emit_call_1		PROTO((rtx, tree, tree, int, int, rtx, rtx,
+static void emit_call_1		PROTO((rtx, tree, tree, HOST_WIDE_INT,
+				       HOST_WIDE_INT, rtx, rtx,
 				       int, rtx, int));
 static void store_one_arg	PROTO ((struct arg_data *, rtx, int, int,
 					tree, int));
@@ -232,6 +235,9 @@ calls_function_1 (exp, which)
 
     case RTL_EXPR:
       return 0;
+      
+    default:
+      break;
     }
 
   for (i = 0; i < length; i++)
@@ -267,15 +273,11 @@ prepare_call_address (funexp, fndecl, call_fusage, reg_parm_seen)
   /* Make a valid memory address and copy constants thru pseudo-regs,
      but not for a constant address if -fno-function-cse.  */
   if (GET_CODE (funexp) != SYMBOL_REF)
-    funexp =
-#ifdef SMALL_REGISTER_CLASSES
     /* If we are using registers for parameters, force the
-	 function address into a register now.  */
-      (SMALL_REGISTER_CLASSES && reg_parm_seen)
-       ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
-       :
-#endif
-         memory_address (FUNCTION_MODE, funexp);
+       function address into a register now.  */
+    funexp = ((SMALL_REGISTER_CLASSES && reg_parm_seen)
+	      ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
+	      : memory_address (FUNCTION_MODE, funexp));
   else
     {
 #ifndef NO_FUNCTION_CSE
@@ -346,8 +348,8 @@ emit_call_1 (funexp, fndecl, funtype, stack_size, struct_value_size,
      rtx funexp;
      tree fndecl;
      tree funtype;
-     int stack_size;
-     int struct_value_size;
+     HOST_WIDE_INT stack_size;
+     HOST_WIDE_INT struct_value_size;
      rtx next_arg_reg;
      rtx valreg;
      int old_inhibit_defer_pop;
@@ -508,7 +510,7 @@ expand_call (exp, target, ignore)
   /* Size of aggregate value wanted, or zero if none wanted
      or if we are using the non-reentrant PCC calling convention
      or expecting the value in registers.  */
-  int struct_value_size = 0;
+  HOST_WIDE_INT struct_value_size = 0;
   /* Nonzero if called function returns an aggregate in memory PCC style,
      by returning the address of where to find it.  */
   int pcc_struct_value = 0;
@@ -693,7 +695,8 @@ expand_call (exp, target, ignore)
 	  structure_value_addr = XEXP (target, 0);
 	else
 	  {
-	    /* Assign a temporary on the stack to hold the value.  */
+	    /* Assign a temporary to hold the value.  */
+	    tree d;
 
 	    /* For variable-sized objects, we must be called with a target
 	       specified.  If we were to allocate space on the stack here,
@@ -702,10 +705,13 @@ expand_call (exp, target, ignore)
 	    if (struct_value_size < 0)
 	      abort ();
 
-	    structure_value_addr
-	      = XEXP (assign_stack_temp (BLKmode, struct_value_size, 1), 0);
-	    MEM_IN_STRUCT_P (structure_value_addr)
-	      = AGGREGATE_TYPE_P (TREE_TYPE (exp));
+	    /* This DECL is just something to feed to mark_addressable;
+	       it doesn't get pushed.  */
+	    d = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (exp));
+	    DECL_RTL (d) = assign_temp (TREE_TYPE (exp), 1, 0, 1);
+	    mark_addressable (d);
+	    structure_value_addr = XEXP (DECL_RTL (d), 0);
+	    TREE_USED (d) = 1;
 	    target = 0;
 	  }
       }
@@ -1666,13 +1672,8 @@ expand_call (exp, target, ignore)
 		    && GET_CODE (SUBREG_REG (args[i].value)) == REG)))
 	    && args[i].mode != BLKmode
 	    && rtx_cost (args[i].value, SET) > 2
-#ifdef SMALL_REGISTER_CLASSES
 	    && ((SMALL_REGISTER_CLASSES && reg_parm_seen)
-		|| preserve_subexpressions_p ())
-#else
-	    && preserve_subexpressions_p ()
-#endif
-	    )
+		|| preserve_subexpressions_p ()))
 	  args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
       }
 
@@ -1858,7 +1859,8 @@ expand_call (exp, target, ignore)
 			   VOIDmode, 3,
 			   structure_value_addr, ptr_mode, 
 			   GEN_INT (struct_value_size), TYPE_MODE (sizetype),
-			   GEN_INT (MEMORY_USE_WO), QImode);
+			   GEN_INT (MEMORY_USE_WO),
+			   TYPE_MODE (integer_type_node));
 
       if (GET_CODE (struct_value_rtx) == REG)
 	  use_reg (&call_fusage, struct_value_rtx);
@@ -1999,7 +2001,7 @@ expand_call (exp, target, ignore)
 
   /* If there are cleanups to be called, don't use a hard reg as target.
      We need to double check this and see if it matters anymore.  */
-  if (any_pending_cleanups ()
+  if (any_pending_cleanups (1)
       && target && REG_P (target)
       && REGNO (target) < FIRST_PSEUDO_REGISTER)
     target = 0;
@@ -2712,26 +2714,26 @@ emit_library_call VPROTO((rtx orgfun, int no_queue, enum machine_mode outmode,
 
 #ifdef ACCUMULATE_OUTGOING_ARGS
 #ifdef REG_PARM_STACK_SPACE
-      if (save_area)
-	{
-	  enum machine_mode save_mode = GET_MODE (save_area);
-	  rtx stack_area
-	    = gen_rtx (MEM, save_mode,
-		       memory_address (save_mode,
+  if (save_area)
+    {
+      enum machine_mode save_mode = GET_MODE (save_area);
+      rtx stack_area
+	= gen_rtx (MEM, save_mode,
+		   memory_address (save_mode,
 #ifdef ARGS_GROW_DOWNWARD
-				       plus_constant (argblock, - high_to_save)
+				   plus_constant (argblock, - high_to_save)
 #else
-				       plus_constant (argblock, low_to_save)
+				   plus_constant (argblock, low_to_save)
 #endif
-				       ));
+				   ));
 
-	  if (save_mode != BLKmode)
-	    emit_move_insn (stack_area, save_area);
-	  else
-	    emit_block_move (stack_area, validize_mem (save_area),
-			     GEN_INT (high_to_save - low_to_save + 1),
-			     PARM_BOUNDARY / BITS_PER_UNIT);
-	}
+      if (save_mode != BLKmode)
+	emit_move_insn (stack_area, save_area);
+      else
+	emit_block_move (stack_area, validize_mem (save_area),
+			 GEN_INT (high_to_save - low_to_save + 1),
+			 PARM_BOUNDARY / BITS_PER_UNIT);
+    }
 #endif
 	  
   /* If we saved any argument areas, restore them.  */
@@ -2750,7 +2752,6 @@ emit_library_call VPROTO((rtx orgfun, int no_queue, enum machine_mode outmode,
   highest_outgoing_arg_in_use = initial_highest_arg_in_use;
   stack_usage_map = initial_stack_usage_map;
 #endif
-
 }
 
 /* Like emit_library_call except that an extra argument, VALUE,
@@ -3306,26 +3307,26 @@ emit_library_call_value VPROTO((rtx orgfun, rtx value, int no_queue,
 
 #ifdef ACCUMULATE_OUTGOING_ARGS
 #ifdef REG_PARM_STACK_SPACE
-      if (save_area)
-	{
-	  enum machine_mode save_mode = GET_MODE (save_area);
-	  rtx stack_area
-	    = gen_rtx (MEM, save_mode,
-		       memory_address (save_mode,
+  if (save_area)
+    {
+      enum machine_mode save_mode = GET_MODE (save_area);
+      rtx stack_area
+	= gen_rtx (MEM, save_mode,
+		   memory_address (save_mode,
 #ifdef ARGS_GROW_DOWNWARD
-				       plus_constant (argblock, - high_to_save)
+				   plus_constant (argblock, - high_to_save)
 #else
-				       plus_constant (argblock, low_to_save)
+				   plus_constant (argblock, low_to_save)
 #endif
-				       ));
+				   ));
 
-	  if (save_mode != BLKmode)
-	    emit_move_insn (stack_area, save_area);
-	  else
-	    emit_block_move (stack_area, validize_mem (save_area),
-			     GEN_INT (high_to_save - low_to_save + 1),
+      if (save_mode != BLKmode)
+	emit_move_insn (stack_area, save_area);
+      else
+	emit_block_move (stack_area, validize_mem (save_area),
+			 GEN_INT (high_to_save - low_to_save + 1),
 			     PARM_BOUNDARY / BITS_PER_UNIT);
-	}
+    }
 #endif
 	  
   /* If we saved any argument areas, restore them.  */
@@ -3564,7 +3565,8 @@ store_one_arg (arg, argblock, may_be_alloca, variable_size, fndecl,
 			     XEXP (arg->stack, 0), ptr_mode, 
 			     GEN_INT (GET_MODE_SIZE (arg->mode)),
 			     TYPE_MODE (sizetype),
-			     GEN_INT (MEMORY_USE_RW), QImode);
+			     GEN_INT (MEMORY_USE_RW),
+			     TYPE_MODE (integer_type_node));
 	}
     }
   else if (arg->mode != BLKmode)

gcc/cccp.1

@@ -0,0 +1,674 @@
+.\" Copyright (c) 1991, 1992, 1993 Free Software Foundation       \-*-Text-*-
+.\" See section COPYING for conditions for redistribution
+.TH cpp 1 "30apr1993" "GNU Tools" "GNU Tools"
+.SH NAME
+cccp, cpp \- The GNU C-Compatible Compiler Preprocessor.
+.SH SYNOPSIS
+.hy 0
+.na
+.TP
+.B cccp
+.RB "[\|" \-$ "\|]"
+.RB "[\|" \-A \c
+.I predicate\c
+.RB [ (\c
+.I value\c
+.BR ) ]\|]
+.RB "[\|" \-C "\|]" 
+.RB "[\|" \-D \c
+.I name\c
+.RB [ =\c
+.I definition\c
+\&]\|]
+.RB "[\|" \-dD "\|]"
+.RB "[\|" \-dM "\|]"
+.RB "[\|" "\-I\ "\c
+.I directory\c
+\&\|]
+.RB "[\|" \-H "\|]"
+.RB "[\|" \-I\- "\|]" 
+.RB "[\|" "\-imacros\ "\c
+.I file\c
+\&\|]
+.RB "[\|" "\-include\ "\c
+.I file\c
+\&\|]
+.RB "[\|" "\-idirafter\ "\c
+.I dir\c
+\&\|]
+.RB "[\|" "\-iprefix\ "\c
+.I prefix\c
+\&\|]
+.RB "[\|" "\-iwithprefix\ "\c
+.I dir\c
+\&\|]
+.RB "[\|" \-lang\-c "\|]"
+.RB "[\|" \-lang\-c++ "\|]"
+.RB "[\|" \-lang\-objc "\|]"
+.RB "[\|" \-lang\-objc++ "\|]"
+.RB "[\|" \-lint "\|]"
+.RB "[\|" \-M\  [ \-MG "\|]]"
+.RB "[\|" \-MM\  [ \-MG "\|]]"
+.RB "[\|" \-MD\  \c
+.I file\ \c
+\&\|]
+.RB "[\|" \-MMD\  \c
+.I file\ \c
+\&\|]
+.RB "[\|" \-nostdinc "\|]" 
+.RB "[\|" \-nostdinc++ "\|]" 
+.RB "[\|" \-P "\|]" 
+.RB "[\|" \-pedantic "\|]"
+.RB "[\|" \-pedantic\-errors "\|]"
+.RB "[\|" \-traditional "\|]" 
+.RB "[\|" \-trigraphs "\|]" 
+.RB "[\|" \-U \c
+.I name\c
+\&\|]
+.RB "[\|" \-undef "\|]"
+.RB "[\|" \-Wtrigraphs "\|]"
+.RB "[\|" \-Wcomment "\|]"
+.RB "[\|" \-Wall "\|]"
+.RB "[\|" \-Wtraditional "\|]"
+.br
+.RB "[\|" \c
+.I infile\c
+.RB | \- "\|]" 
+.RB "[\|" \c
+.I outfile\c
+.RB | \- "\|]"  
+.ad b
+.hy 1
+.SH DESCRIPTION
+The C preprocessor is a \c
+.I macro processor\c
+\& that is used automatically by
+the C compiler to transform your program before actual compilation.  It is
+called a macro processor because it allows you to define \c
+.I macros\c
+\&,
+which are brief abbreviations for longer constructs.
+
+The C preprocessor provides four separate facilities that you can use as
+you see fit:
+.TP
+\(bu
+Inclusion of header files.  These are files of declarations that can be
+substituted into your program.
+.TP
+\(bu
+Macro expansion.  You can define \c
+.I macros\c
+\&, which are abbreviations
+for arbitrary fragments of C code, and then the C preprocessor will
+replace the macros with their definitions throughout the program.
+.TP
+\(bu
+Conditional compilation.  Using special preprocessing directives, you
+can include or exclude parts of the program according to various
+conditions.
+.TP
+\(bu
+Line control.  If you use a program to combine or rearrange source files into
+an intermediate file which is then compiled, you can use line control
+to inform the compiler of where each source line originally came from.
+.PP
+C preprocessors vary in some details.  For a full explanation of the
+GNU C preprocessor, see the
+.B info
+file `\|\c
+.B cpp.info\c
+\&\|', or the manual
+.I The C Preprocessor\c
+\&.  Both of these are built from the same documentation source file, `\|\c
+.B cpp.texinfo\c
+\&\|'.  The GNU C
+preprocessor provides a superset of the features of ANSI Standard C.
+
+ANSI Standard C requires the rejection of many harmless constructs commonly
+used by today's C programs.  Such incompatibility would be inconvenient for
+users, so the GNU C preprocessor is configured to accept these constructs
+by default.  Strictly speaking, to get ANSI Standard C, you must use the
+options `\|\c
+.B \-trigraphs\c
+\&\|', `\|\c
+.B \-undef\c
+\&\|' and `\|\c
+.B \-pedantic\c
+\&\|', but in
+practice the consequences of having strict ANSI Standard C make it
+undesirable to do this.  
+
+Most often when you use the C preprocessor you will not have to invoke it
+explicitly: the C compiler will do so automatically.  However, the
+preprocessor is sometimes useful individually.
+
+When you call the preprocessor individually, either name
+(\c
+.B cpp\c
+\& or \c
+.B cccp\c
+\&) will do\(em\&they are completely synonymous.
+
+The C preprocessor expects two file names as arguments, \c
+.I infile\c
+\& and
+\c
+.I outfile\c
+\&.  The preprocessor reads \c
+.I infile\c
+\& together with any other
+files it specifies with `\|\c
+.B #include\c
+\&\|'.  All the output generated by the
+combined input files is written in \c
+.I outfile\c
+\&.
+
+Either \c
+.I infile\c
+\& or \c
+.I outfile\c
+\& may be `\|\c
+.B \-\c
+\&\|', which as \c
+.I infile\c
+\&
+means to read from standard input and as \c
+.I outfile\c
+\& means to write to
+standard output.  Also, if \c
+.I outfile\c
+\& or both file names are omitted,
+the standard output and standard input are used for the omitted file names.
+.SH OPTIONS
+Here is a table of command options accepted by the C preprocessor.  
+These options can also be given when compiling a C program; they are
+passed along automatically to the preprocessor when it is invoked by
+the compiler. 
+.TP
+.B \-P
+Inhibit generation of `\|\c
+.B #\c
+\&\|'-lines with line-number information in
+the output from the preprocessor.  This might be
+useful when running the preprocessor on something that is not C code
+and will be sent to a program which might be confused by the
+`\|\c
+.B #\c
+\&\|'-lines.
+.TP
+.B \-C
+Do not discard comments: pass them through to the output file.
+Comments appearing in arguments of a macro call will be copied to the
+output before the expansion of the macro call.
+.TP
+.B \-traditional
+Try to imitate the behavior of old-fashioned C, as opposed to ANSI C.
+.TP
+.B \-trigraphs
+Process ANSI standard trigraph sequences.  These are three-character
+sequences, all starting with `\|\c
+.B ??\c
+\&\|', that are defined by ANSI C to
+stand for single characters.  For example, `\|\c
+.B ??/\c
+\&\|' stands for
+`\|\c
+.BR "\e" "\|',"
+so `\|\c
+.B '??/n'\c
+\&\|' is a character constant for a newline.
+Strictly speaking, the GNU C preprocessor does not support all
+programs in ANSI Standard C unless `\|\c
+.B \-trigraphs\c
+\&\|' is used, but if
+you ever notice the difference it will be with relief.
+
+You don't want to know any more about trigraphs.
+.TP
+.B \-pedantic
+Issue warnings required by the ANSI C standard in certain cases such
+as when text other than a comment follows `\|\c
+.B #else\c
+\&\|' or `\|\c
+.B #endif\c
+\&\|'.
+.TP
+.B \-pedantic\-errors
+Like `\|\c
+.B \-pedantic\c
+\&\|', except that errors are produced rather than
+warnings.
+.TP
+.B \-Wtrigraphs
+Warn if any trigraphs are encountered (assuming they are enabled).
+.TP
+.B \-Wcomment
+.TP
+.B \-Wcomments
+Warn whenever a comment-start sequence `\|\c
+.B /*\c
+\&\|' appears in a comment.
+(Both forms have the same effect).
+.TP
+.B \-Wall
+Requests both `\|\c
+.B \-Wtrigraphs\c
+\&\|' and `\|\c
+.B \-Wcomment\c
+\&\|' (but not
+`\|\c
+.B \-Wtraditional\c
+\&\|'). 
+.TP
+.B \-Wtraditional
+Warn about certain constructs that behave differently in traditional and
+ANSI C.
+.TP
+.BI "\-I " directory\c
+\&
+Add the directory \c
+.I directory\c
+\& to the end of the list of
+directories to be searched for header files.
+This can be used to override a system header file, substituting your
+own version, since these directories are searched before the system
+header file directories.  If you use more than one `\|\c
+.B \-I\c
+\&\|' option,
+the directories are scanned in left-to-right order; the standard
+system directories come after.
+.TP
+.B \-I\-
+Any directories specified with `\|\c
+.B \-I\c
+\&\|' options before the `\|\c
+.B \-I\-\c
+\&\|'
+option are searched only for the case of `\|\c
+.B #include "\c
+.I file\c
+\&"\c
+\&\|';
+they are not searched for `\|\c
+.B #include <\c
+.I file\c
+\&>\c
+\&\|'.
+
+If additional directories are specified with `\|\c
+.B \-I\c
+\&\|' options after
+the `\|\c
+.B \-I\-\c
+\&\|', these directories are searched for all `\|\c
+.B #include\c
+\&\|'
+directives.
+
+In addition, the `\|\c
+.B \-I\-\c
+\&\|' option inhibits the use of the current
+directory as the first search directory for `\|\c
+.B #include "\c
+.I file\c
+\&"\c
+\&\|'.
+Therefore, the current directory is searched only if it is requested
+explicitly with `\|\c
+.B \-I.\c
+\&\|'.  Specifying both `\|\c
+.B \-I\-\c
+\&\|' and `\|\c
+.B \-I.\c
+\&\|'
+allows you to control precisely which directories are searched before
+the current one and which are searched after.
+.TP
+.B \-nostdinc
+Do not search the standard system directories for header files.
+Only the directories you have specified with `\|\c
+.B \-I\c
+\&\|' options
+(and the current directory, if appropriate) are searched.
+.TP
+.B \-nostdinc++
+Do not search for header files in the C++ specific standard
+directories, but do still search the other standard directories.
+(This option is used when building libg++.)
+.TP
+.BI "\-D " "name"\c
+\&
+Predefine \c
+.I name\c
+\& as a macro, with definition `\|\c
+.B 1\c
+\&\|'.
+.TP
+.BI "\-D " "name" = definition
+\&
+Predefine \c
+.I name\c
+\& as a macro, with definition \c
+.I definition\c
+\&.
+There are no restrictions on the contents of \c
+.I definition\c
+\&, but if
+you are invoking the preprocessor from a shell or shell-like program
+you may need to use the shell's quoting syntax to protect characters
+such as spaces that have a meaning in the shell syntax.  If you use more than
+one `\|\c
+.B \-D\c
+\&\|' for the same
+.I name\c
+\&, the rightmost definition takes effect.
+.TP
+.BI "\-U " "name"\c
+\&
+Do not predefine \c
+.I name\c
+\&.  If both `\|\c
+.B \-U\c
+\&\|' and `\|\c
+.B \-D\c
+\&\|' are
+specified for one name, the `\|\c
+.B \-U\c
+\&\|' beats the `\|\c
+.B \-D\c
+\&\|' and the name
+is not predefined.
+.TP
+.B \-undef
+Do not predefine any nonstandard macros.
+.TP
+.BI "\-A " "name(" value )
+Assert (in the same way as the \c
+.B #assert\c
+\& directive)
+the predicate \c
+.I name\c
+\& with tokenlist \c
+.I value\c
+\&.  Remember to escape or quote the parentheses on
+shell command lines.
+
+You can use `\|\c
+.B \-A-\c
+\&\|' to disable all predefined assertions; it also
+undefines all predefined macros.
+.TP
+.B \-dM
+Instead of outputting the result of preprocessing, output a list of
+`\|\c
+.B #define\c
+\&\|' directives for all the macros defined during the
+execution of the preprocessor, including predefined macros.  This gives
+you a way of finding out what is predefined in your version of the
+preprocessor; assuming you have no file `\|\c
+.B foo.h\c
+\&\|', the command
+.sp
+.br
+touch\ foo.h;\ cpp\ \-dM\ foo.h
+.br
+.sp
+will show the values of any predefined macros.
+.TP
+.B \-dD
+Like `\|\c
+.B \-dM\c
+\&\|' except in two respects: it does \c
+.I not\c
+\& include the
+predefined macros, and it outputs \c
+.I both\c
+\& the `\|\c
+.B #define\c
+\&\|'
+directives and the result of preprocessing.  Both kinds of output go to
+the standard output file.
+.PP
+.TP
+.BR \-M\  [ \-MG ]
+Instead of outputting the result of preprocessing, output a rule
+suitable for \c
+.B make\c
+\& describing the dependencies of the main
+source file.  The preprocessor outputs one \c
+.B make\c
+\& rule containing
+the object file name for that source file, a colon, and the names of
+all the included files.  If there are many included files then the
+rule is split into several lines using `\|\c
+.B \\\\\c
+\&\|'-newline.
+
+`\|\c
+.B \-MG\c
+\&\|' says to treat missing header files as generated files and assume \c
+they live in the same directory as the source file.  It must be specified \c
+in addition to `\|\c
+.B \-M\c
+\&\|'.
+
+This feature is used in automatic updating of makefiles.
+.TP
+.BR \-MM\  [ \-MG ]
+Like `\|\c
+.B \-M\c
+\&\|' but mention only the files included with `\|\c
+.B #include
+"\c
+.I file\c
+\&"\c
+\&\|'.  System header files included with `\|\c
+.B #include
+<\c
+.I file\c
+\&>\c
+\&\|' are omitted.
+.TP
+.BI \-MD\  file
+Like `\|\c
+.B \-M\c
+\&\|' but the dependency information is written to `\|\c
+.I file\c
+\&\|'.  This is in addition to compiling the file as
+specified\(em\&`\|\c
+.B \-MD\c
+\&\|' does not inhibit ordinary compilation the way
+`\|\c
+.B \-M\c
+\&\|' does.
+
+When invoking gcc, do not specify the `\|\c
+.I file\c
+\&\|' argument.  Gcc will create file names made by replacing `\|\c
+.B .c\c
+\&\|' with `\|\c
+.B .d\c
+\&\|' at the end of the input file names.
+
+In Mach, you can use the utility \c
+.B md\c
+\& to merge multiple files
+into a single dependency file suitable for using with the `\|\c
+.B make\c
+\&\|'
+command.
+.TP
+.BI \-MMD\  file
+Like `\|\c
+.B \-MD\c
+\&\|' except mention only user header files, not system
+header files.
+.TP
+.B \-H
+Print the name of each header file used, in addition to other normal
+activities.
+.TP
+.BI "\-imacros " "file"\c
+\&
+Process \c
+.I file\c
+\& as input, discarding the resulting output, before
+processing the regular input file.  Because the output generated from
+\c
+.I file\c
+\& is discarded, the only effect of `\|\c
+.B \-imacros \c
+.I file\c
+\&\c
+\&\|' is to
+make the macros defined in \c
+.I file\c
+\& available for use in the main
+input.  The preprocessor evaluates any `\|\c
+.B \-D\c
+\&\|' and `\|\c
+.B \-U\c
+\&\|' options
+on the command line before processing `\|\c
+.B \-imacros \c
+.I file\c
+\&\|' \c
+\&.
+.TP
+.BI "\-include " "file"
+Process 
+.I file
+as input, and include all the resulting output,
+before processing the regular input file.  
+.TP
+.BI "-idirafter " "dir"\c
+\&
+Add the directory \c
+.I dir\c
+\& to the second include path.  The directories
+on the second include path are searched when a header file is not found
+in any of the directories in the main include path (the one that
+`\|\c
+.B \-I\c
+\&\|' adds to).
+.TP
+.BI "-iprefix " "prefix"\c
+\&
+Specify \c
+.I prefix\c
+\& as the prefix for subsequent `\|\c
+.B \-iwithprefix\c
+\&\|'
+options.
+.TP
+.BI "-iwithprefix " "dir"\c
+\&
+Add a directory to the second include path.  The directory's name is
+made by concatenating \c
+.I prefix\c
+\& and \c
+.I dir\c
+\&, where \c
+.I prefix\c
+\&
+was specified previously with `\|\c
+.B \-iprefix\c
+\&\|'.
+.TP
+.B \-lang-c
+.TP
+.B \-lang-c++
+.TP
+.B \-lang-objc
+.TP
+.B \-lang-objc++
+Specify the source language.  `\|\c
+.B \-lang-c++\c
+\&\|' makes the preprocessor
+handle C++ comment syntax, and includes extra default include
+directories for C++, and `\|\c
+.B \-lang-objc\c
+\&\|' enables the Objective C
+`\|\c
+.B #import\c
+\&\|' directive.  `\|\c
+.B \-lang-c\c
+\&\|' explicitly turns off both of
+these extensions, and `\|\c
+.B \-lang-objc++\c
+\&\|' enables both.
+
+These options are generated by the compiler driver \c
+.B gcc\c
+\&, but not
+passed from the `\|\c
+.B gcc\c
+\&\|' command line.
+.TP
+.B \-lint
+Look for commands to the program checker \c
+.B lint\c
+\& embedded in
+comments, and emit them preceded by `\|\c
+.B #pragma lint\c
+\&\|'.  For example,
+the comment `\|\c
+.B /* NOTREACHED */\c
+\&\|' becomes `\|\c
+.B #pragma lint
+NOTREACHED\c
+\&\|'.
+
+This option is available only when you call \c
+.B cpp\c
+\& directly;
+\c
+.B gcc\c
+\& will not pass it from its command line.
+.TP
+.B \-$
+Forbid the use of `\|\c
+.B $\c
+\&\|' in identifiers.  This was formerly required for strict conformance
+to the C Standard before the standard was corrected.  \c
+
+This option is available only when you call \c
+.B cpp\c
+\& directly;
+.B gcc\c
+\& will not pass it from its command line.
+.SH "SEE ALSO"
+.RB "`\|" Cpp "\|'"
+entry in
+.B info\c
+\&;
+.I The C Preprocessor\c
+, Richard M. Stallman.
+.br
+.BR gcc "(" 1 ");"
+.RB "`\|" Gcc "\|'"
+entry in 
+.B info\c
+\&;
+.I 
+Using and Porting GNU CC (for version 2.0)\c
+, Richard M. Stallman.
+.SH COPYING
+Copyright (c) 1991, 1992, 1993 Free Software Foundation, Inc.
+.PP
+Permission is granted to make and distribute verbatim copies of
+this manual provided the copyright notice and this permission notice
+are preserved on all copies.
+.PP
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided that the
+entire resulting derived work is distributed under the terms of a
+permission notice identical to this one.
+.PP
+Permission is granted to copy and distribute translations of this
+manual into another language, under the above conditions for modified
+versions, except that this permission notice may be included in
+translations approved by the Free Software Foundation instead of in
+the original English.

gcc/cexp.y

@@ -29,29 +29,19 @@ Boston, MA 02111-1307, USA.
 #include <setjmp.h>
 /* #define YYDEBUG 1 */
 
-/* The following symbols should be autoconfigured:
-	HAVE_STDLIB_H
-	STDC_HEADERS
-   In the mean time, we'll get by with approximations based
-   on existing GCC configuration symbols.  */
 
-#ifdef POSIX
-# ifndef HAVE_STDLIB_H
-# define HAVE_STDLIB_H 1
-# endif
-# ifndef STDC_HEADERS
-# define STDC_HEADERS 1
-# endif
-#endif /* defined (POSIX) */
-
-#if STDC_HEADERS
+#ifdef HAVE_STRING_H
 # include <string.h>
 #endif
 
-#if HAVE_STDLIB_H || defined (MULTIBYTE_CHARS)
+#ifdef HAVE_STDLIB_H
 # include <stdlib.h>
 #endif
 
+#ifdef HAVE_LIMITS_H
+# include <limits.h>
+#endif
+
 #ifdef MULTIBYTE_CHARS
 #include <locale.h>
 #endif
@@ -87,18 +77,36 @@ struct arglist {
 #endif
 
 /* Find the largest host integer type and set its size and type.
-   Don't blindly use `long'; on some crazy hosts it is shorter than `int'.  */
+   Watch out: on some crazy hosts `long' is shorter than `int'.  */
 
-#ifndef HOST_BITS_PER_WIDE_INT
-
-#if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
-#define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
-#define HOST_WIDE_INT long
-#else
-#define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
-#define HOST_WIDE_INT int
+#ifndef HOST_WIDE_INT
+# if HAVE_INTTYPES_H
+#  include <inttypes.h>
+#  define HOST_WIDE_INT intmax_t
+#  define unsigned_HOST_WIDE_INT uintmax_t
+# else
+#  if (HOST_BITS_PER_LONG <= HOST_BITS_PER_INT && HOST_BITS_PER_LONGLONG <= HOST_BITS_PER_INT)
+#   define HOST_WIDE_INT int
+#  else
+#  if (HOST_BITS_PER_LONGLONG <= HOST_BITS_PER_LONG || ! (defined LONG_LONG_MAX || defined LLONG_MAX))
+#   define HOST_WIDE_INT long
+#  else
+#   define HOST_WIDE_INT long long
+#  endif
+#  endif
+# endif
 #endif
 
+#ifndef unsigned_HOST_WIDE_INT
+#define unsigned_HOST_WIDE_INT unsigned HOST_WIDE_INT
+#endif
+
+#ifndef CHAR_BIT
+#define CHAR_BIT 8
+#endif
+
+#ifndef HOST_BITS_PER_WIDE_INT
+#define HOST_BITS_PER_WIDE_INT (CHAR_BIT * sizeof (HOST_WIDE_INT))
 #endif
 
 #if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 7)
@@ -137,11 +145,14 @@ struct arglist {
 
 #define PRINTF_PROTO_1(ARGS) PRINTF_PROTO(ARGS, 1, 2)
 
-HOST_WIDE_INT parse_c_expression PROTO((char *));
+HOST_WIDE_INT parse_c_expression PROTO((char *, int));
 
 static int yylex PROTO((void));
 static void yyerror PROTO((char *)) __attribute__ ((noreturn));
 static HOST_WIDE_INT expression_value;
+#ifdef TEST_EXP_READER
+static int expression_signedp;
+#endif
 
 static jmp_buf parse_return_error;
 
@@ -152,6 +163,9 @@ static int keyword_parsing = 0;
    This is a count, since unevaluated expressions can nest.  */
 static int skip_evaluation;
 
+/* Nonzero means warn if undefined identifiers are evaluated.  */
+static int warn_undef;
+
 /* some external tables of character types */
 extern unsigned char is_idstart[], is_idchar[], is_space[];
 
@@ -164,9 +178,6 @@ extern int traditional;
 /* Flag for -lang-c89.  */
 extern int c89;
 
-/* Flag for -Wundef.  */
-extern int warn_undef;
-
 #ifndef CHAR_TYPE_SIZE
 #define CHAR_TYPE_SIZE BITS_PER_UNIT
 #endif
@@ -199,17 +210,13 @@ extern int warn_undef;
 #define MAX_WCHAR_TYPE_SIZE WCHAR_TYPE_SIZE
 #endif
 
-#if MAX_CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT
-#define MAX_CHAR_TYPE_MASK (~ (~ (HOST_WIDE_INT) 0 << MAX_CHAR_TYPE_SIZE))
-#else
-#define MAX_CHAR_TYPE_MASK (~ (HOST_WIDE_INT) 0)
-#endif
+#define MAX_CHAR_TYPE_MASK (MAX_CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT \
+			    ? (~ (~ (HOST_WIDE_INT) 0 << MAX_CHAR_TYPE_SIZE)) \
+			    : ~ (HOST_WIDE_INT) 0)
 
-#if MAX_WCHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT
-#define MAX_WCHAR_TYPE_MASK (~ (~ (HOST_WIDE_INT) 0 << MAX_WCHAR_TYPE_SIZE))
-#else
-#define MAX_WCHAR_TYPE_MASK (~ (HOST_WIDE_INT) 0)
-#endif
+#define MAX_WCHAR_TYPE_MASK (MAX_WCHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT \
+			     ? ~ (~ (HOST_WIDE_INT) 0 << MAX_WCHAR_TYPE_SIZE) \
+			     : ~ (HOST_WIDE_INT) 0)
 
 /* Suppose A1 + B1 = SUM1, using 2's complement arithmetic ignoring overflow.
    Suppose A, B and SUM have the same respective signs as A1, B1, and SUM1.
@@ -232,8 +239,8 @@ void pedwarn PRINTF_PROTO_1((char *, ...));
 void warning PRINTF_PROTO_1((char *, ...));
 
 static int parse_number PROTO((int));
-static HOST_WIDE_INT left_shift PROTO((struct constant *, unsigned HOST_WIDE_INT));
-static HOST_WIDE_INT right_shift PROTO((struct constant *, unsigned HOST_WIDE_INT));
+static HOST_WIDE_INT left_shift PROTO((struct constant *, unsigned_HOST_WIDE_INT));
+static HOST_WIDE_INT right_shift PROTO((struct constant *, unsigned_HOST_WIDE_INT));
 static void integer_overflow PROTO((void));
 
 /* `signedp' values */
@@ -272,7 +279,12 @@ static void integer_overflow PROTO((void));
 %%
 
 start   :	exp1
-		{ expression_value = $1.value; }
+		{
+		  expression_value = $1.value;
+#ifdef TEST_EXP_READER
+		  expression_signedp = $1.signedp;
+#endif
+		}
 	;
 
 /* Expressions, including the comma operator.  */
@@ -324,7 +336,7 @@ exp	:	exp '*' exp
 				integer_overflow ();
 			    }
 			  else
-			    $$.value = ((unsigned HOST_WIDE_INT) $1.value
+			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
 					* $3.value); }
 	|	exp '/' exp
 			{ if ($3.value == 0)
@@ -341,7 +353,7 @@ exp	:	exp '*' exp
 				integer_overflow ();
 			    }
 			  else
-			    $$.value = ((unsigned HOST_WIDE_INT) $1.value
+			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
 					/ $3.value); }
 	|	exp '%' exp
 			{ if ($3.value == 0)
@@ -354,7 +366,7 @@ exp	:	exp '*' exp
 			  if ($$.signedp)
 			    $$.value = $1.value % $3.value;
 			  else
-			    $$.value = ((unsigned HOST_WIDE_INT) $1.value
+			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
 					% $3.value); }
 	|	exp '+' exp
 			{ $$.value = $1.value + $3.value;
@@ -391,28 +403,28 @@ exp	:	exp '*' exp
 			  if ($1.signedp & $3.signedp)
 			    $$.value = $1.value <= $3.value;
 			  else
-			    $$.value = ((unsigned HOST_WIDE_INT) $1.value
+			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
 					<= $3.value); }
 	|	exp GEQ exp
 			{ $$.signedp = SIGNED;
 			  if ($1.signedp & $3.signedp)
 			    $$.value = $1.value >= $3.value;
 			  else
-			    $$.value = ((unsigned HOST_WIDE_INT) $1.value
+			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
 					>= $3.value); }
 	|	exp '<' exp
 			{ $$.signedp = SIGNED;
 			  if ($1.signedp & $3.signedp)
 			    $$.value = $1.value < $3.value;
 			  else
-			    $$.value = ((unsigned HOST_WIDE_INT) $1.value
+			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
 					< $3.value); }
 	|	exp '>' exp
 			{ $$.signedp = SIGNED;
 			  if ($1.signedp & $3.signedp)
 			    $$.value = $1.value > $3.value;
 			  else
-			    $$.value = ((unsigned HOST_WIDE_INT) $1.value
+			    $$.value = ((unsigned_HOST_WIDE_INT) $1.value
 					> $3.value); }
 	|	exp '&' exp
 			{ $$.value = $1.value & $3.value;
@@ -495,7 +507,7 @@ parse_number (olen)
 {
   register char *p = lexptr;
   register int c;
-  register unsigned HOST_WIDE_INT n = 0, nd, max_over_base;
+  register unsigned_HOST_WIDE_INT n = 0, nd, max_over_base;
   register int base = 10;
   register int len = olen;
   register int overflow = 0;
@@ -513,7 +525,7 @@ parse_number (olen)
     }
   }
 
-  max_over_base = (unsigned HOST_WIDE_INT) -1 / base;
+  max_over_base = (unsigned_HOST_WIDE_INT) -1 / base;
 
   for (; len > 0; len--) {
     c = *p++;
@@ -684,7 +696,7 @@ yylex ()
        It is mostly copied from c-lex.c.  */
     {
       register HOST_WIDE_INT result = 0;
-      register num_chars = 0;
+      register int num_chars = 0;
       unsigned width = MAX_CHAR_TYPE_SIZE;
       int max_chars;
       char *token_buffer;
@@ -751,11 +763,11 @@ yylex ()
 		      sizeof ("__CHAR_UNSIGNED__") - 1, -1)
 	      || ((result >> (num_bits - 1)) & 1) == 0)
 	    yylval.integer.value
-	      = result & (~ (unsigned HOST_WIDE_INT) 0
+	      = result & (~ (unsigned_HOST_WIDE_INT) 0
 			  >> (HOST_BITS_PER_WIDE_INT - num_bits));
 	  else
 	    yylval.integer.value
-	      = result | ~(~ (unsigned HOST_WIDE_INT) 0
+	      = result | ~(~ (unsigned_HOST_WIDE_INT) 0
 			   >> (HOST_BITS_PER_WIDE_INT - num_bits));
 	}
       else
@@ -962,7 +974,7 @@ parse_escape (string_ptr, result_mask)
       }
     case 'x':
       {
-	register unsigned HOST_WIDE_INT i = 0, overflow = 0;
+	register unsigned_HOST_WIDE_INT i = 0, overflow = 0;
 	register int digits_found = 0, digit;
 	for (;;)
 	  {
@@ -1015,7 +1027,7 @@ integer_overflow ()
 static HOST_WIDE_INT
 left_shift (a, b)
      struct constant *a;
-     unsigned HOST_WIDE_INT b;
+     unsigned_HOST_WIDE_INT b;
 {
    /* It's unclear from the C standard whether shifts can overflow.
       The following code ignores overflow; perhaps a C standard
@@ -1023,36 +1035,39 @@ left_shift (a, b)
   if (b >= HOST_BITS_PER_WIDE_INT)
     return 0;
   else
-    return (unsigned HOST_WIDE_INT) a->value << b;
+    return (unsigned_HOST_WIDE_INT) a->value << b;
 }
 
 static HOST_WIDE_INT
 right_shift (a, b)
      struct constant *a;
-     unsigned HOST_WIDE_INT b;
+     unsigned_HOST_WIDE_INT b;
 {
   if (b >= HOST_BITS_PER_WIDE_INT)
     return a->signedp ? a->value >> (HOST_BITS_PER_WIDE_INT - 1) : 0;
   else if (a->signedp)
     return a->value >> b;
   else
-    return (unsigned HOST_WIDE_INT) a->value >> b;
+    return (unsigned_HOST_WIDE_INT) a->value >> b;
 }
 
 /* This page contains the entry point to this file.  */
 
 /* Parse STRING as an expression, and complain if this fails
-   to use up all of the contents of STRING.  */
-/* STRING may contain '\0' bytes; it is terminated by the first '\n'
-   outside a string constant, so that we can diagnose '\0' properly.  */
-/* We do not support C comments.  They should be removed before
+   to use up all of the contents of STRING.
+   STRING may contain '\0' bytes; it is terminated by the first '\n'
+   outside a string constant, so that we can diagnose '\0' properly.
+   If WARN_UNDEFINED is nonzero, warn if undefined identifiers are evaluated.
+   We do not support C comments.  They should be removed before
    this function is called.  */
 
 HOST_WIDE_INT
-parse_c_expression (string)
+parse_c_expression (string, warn_undefined)
      char *string;
+     int warn_undefined;
 {
   lexptr = string;
+  warn_undef = warn_undefined;
 
   /* if there is some sort of scanning error, just return 0 and assume
      the parsing routine has printed an error message somewhere.
@@ -1080,6 +1095,7 @@ int traditional;
 
 int main PROTO((int, char **));
 static void initialize_random_junk PROTO((void));
+static void print_unsigned_host_wide_int PROTO((unsigned_HOST_WIDE_INT));
 
 /* Main program for testing purposes.  */
 int
@@ -1089,6 +1105,7 @@ main (argc, argv)
 {
   int n, c;
   char buf[1024];
+  unsigned_HOST_WIDE_INT u;
 
   pedantic = 1 < argc;
   traditional = 2 < argc;
@@ -1104,12 +1121,35 @@ main (argc, argv)
       n++;
     if (c == EOF)
       break;
-    printf ("parser returned %ld\n", (long) parse_c_expression (buf));
+    parse_c_expression (buf, 1);
+    printf ("parser returned ");
+    u = (unsigned_HOST_WIDE_INT) expression_value;
+    if (expression_value < 0 && expression_signedp) {
+      u = -u;
+      printf ("-");
+    }
+    if (u == 0)
+      printf ("0");
+    else
+      print_unsigned_host_wide_int (u);
+    if (! expression_signedp)
+      printf("u");
+    printf ("\n");
   }
 
   return 0;
 }
 
+static void
+print_unsigned_host_wide_int (u)
+     unsigned_HOST_WIDE_INT u;
+{
+  if (u) {
+    print_unsigned_host_wide_int (u / 10);
+    putchar ('0' + (int) (u % 10));
+  }
+}
+
 /* table to tell if char can be part of a C identifier. */
 unsigned char is_idchar[256];
 /* table to tell if char can be first char of a c identifier. */

gcc/choose-temp.c

@@ -1,5 +1,5 @@
 /* Utility to pick a temporary filename prefix.
-   Copyright (C) 1996 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997 Free Software Foundation, Inc.
 
 This file is part of the libiberty library.
 Libiberty is free software; you can redistribute it and/or
@@ -22,7 +22,11 @@ Boston, MA 02111-1307, USA.  */
 /* This file lives in at least two places: libiberty and gcc.
    Don't change one without the other.  */
 
-#ifndef NO_SYS_FILE_H
+#ifdef IN_GCC
+#include "config.h"
+#endif
+
+#ifdef HAVE_SYS_FILE_H
 #include <sys/types.h>
 #include <sys/file.h>   /* May get R_OK, etc. on some systems.  */
 #endif
@@ -36,7 +40,6 @@ Boston, MA 02111-1307, USA.  */
 #include <stdio.h>	/* May get P_tmpdir.  */
 
 #ifdef IN_GCC
-#include "config.h"
 #include "gansidecl.h"
 extern char *xmalloc ();
 #else
@@ -54,7 +57,7 @@ extern char *xmalloc ();
 /* On MSDOS, write temp files in current dir
    because there's no place else we can expect to use.  */
 /* ??? Although the current directory is tried as a last resort,
-   this is left in so that on MSDOS it is prefered to /tmp on the
+   this is left in so that on MSDOS it is preferred to /tmp on the
    off chance that someone requires this, since that was the previous
    behaviour.  */
 #ifdef __MSDOS__
@@ -68,7 +71,7 @@ extern char *xmalloc ();
 #define TEMP_FILE "ccXXXXXX"
 
 /* Subroutine of choose_temp_base.
-   If BASE is non-NULL, returh it.
+   If BASE is non-NULL, return it.
    Otherwise it checks if DIR is a usable directory.
    If success, DIR is returned.
    Otherwise NULL is returned.  */
@@ -114,11 +117,7 @@ choose_temp_base ()
  
   /* If all else fails, use the current directory!  */
   if (base == 0)
-#ifdef VMS
-    base = "[";
-#else
     base = ".";
-#endif
 
 #else /* MPW */
   base = ":";

gcc/collect2.c

@@ -34,6 +34,18 @@ Boston, MA 02111-1307, USA.  */
 #include <sys/file.h>
 #include <sys/stat.h>
 
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#endif
+
 #define COLLECT
 
 #include "demangle.h"
@@ -45,11 +57,7 @@ extern int errno;
 #endif
 
 #ifndef HAVE_STRERROR
-#if defined(bsd4_4) 
-extern const char *const sys_errlist[];
-#else
 extern char *sys_errlist[];
-#endif
 extern int sys_nerr;
 #else
 char *strerror();
@@ -213,7 +221,7 @@ enum pass {
 };
 
 #ifndef NO_SYS_SIGLIST
-#ifndef DONT_DECLARE_SYS_SIGLIST
+#ifndef SYS_SIGLIST_DECLARED
 extern char *sys_siglist[];
 #endif
 #endif
@@ -243,6 +251,7 @@ static char *initname, *fininame;	/* names of init and fini funcs */
 static struct head constructors;	/* list of constructors found */
 static struct head destructors;		/* list of destructors found */
 static struct head exports;		/* list of exported symbols */
+static struct head frame_tables;	/* list of frame unwind info tables */
 
 struct obstack temporary_obstack;
 struct obstack permanent_obstack;
@@ -295,9 +304,17 @@ static void scan_libraries	PROTO((char *));
 char *xcalloc ();
 char *xmalloc ();
 
+#ifdef NEED_DECLARATION_INDEX
 extern char *index ();
+#endif
+
+#ifdef NEED_DECLARATION_RINDEX
 extern char *rindex ();
+#endif
+
+#ifdef NEED_DECLARATION_FREE
 extern void free ();
+#endif
 
 #ifdef NO_DUP2
 int
@@ -603,13 +620,16 @@ is_ctor_dtor (s)
 #ifdef NO_DOT_IN_LABEL
     { "GLOBAL__I_", sizeof ("GLOBAL__I_")-1, 1, 0 },
     { "GLOBAL__D_", sizeof ("GLOBAL__D_")-1, 2, 0 },
+    { "GLOBAL__F_", sizeof ("GLOBAL__F_")-1, 5, 0 },
 #else
     { "GLOBAL_.I.", sizeof ("GLOBAL_.I.")-1, 1, 0 },
     { "GLOBAL_.D.", sizeof ("GLOBAL_.D.")-1, 2, 0 },
+    { "GLOBAL_.F.", sizeof ("GLOBAL_.F.")-1, 5, 0 },
 #endif
 #else
     { "GLOBAL_$I$", sizeof ("GLOBAL_$I$")-1, 1, 0 },
     { "GLOBAL_$D$", sizeof ("GLOBAL_$D$")-1, 2, 0 },
+    { "GLOBAL_$F$", sizeof ("GLOBAL_$F$")-1, 5, 0 },
 #endif
     { "GLOBAL__FI_", sizeof ("GLOBAL__FI_")-1, 3, 0 },
     { "GLOBAL__FD_", sizeof ("GLOBAL__FD_")-1, 4, 0 },
@@ -997,6 +1017,7 @@ main (argc, argv)
 	num_c_args++;
     }
   obstack_free (&temporary_obstack, temporary_firstobj);
+  ++num_c_args;
 
   c_ptr = c_argv = (char **) xcalloc (sizeof (char *), num_c_args);
 
@@ -1292,6 +1313,7 @@ main (argc, argv)
 	shared_obj = 1;
     }
   obstack_free (&temporary_obstack, temporary_firstobj);
+  *c_ptr++ = "-fno-exceptions";
 
 #ifdef COLLECT_EXPORT_LIST
   /* The AIX linker will discard static constructors in object files if
@@ -1397,7 +1419,8 @@ main (argc, argv)
     }
 
   if (constructors.number == 0 && destructors.number == 0
-#ifdef LDD_SUFFIX
+      && frame_tables.number == 0
+#ifdef SCAN_LIBRARIES
       /* If we will be running these functions ourselves, we want to emit
 	 stubs into the shared library so that we don't have to relink
 	 dependent programs when we add static objects.  */
@@ -1586,9 +1609,9 @@ collect_execute (prog, argv, redir)
 	{
 	  unlink (redir);
 	  if (freopen (redir, "a", stdout) == NULL)
-	    fatal_perror ("redirecting stdout");
+	    fatal_perror ("redirecting stdout: %s", redir);
 	  if (freopen (redir, "a", stderr) == NULL)
-	    fatal_perror ("redirecting stderr");
+	    fatal_perror ("redirecting stderr: %s", redir);
 	}
 
       execvp (argv[0], argv);
@@ -1691,6 +1714,7 @@ write_c_file_stat (stream, name)
      char *name;
 {
   char *prefix, *p, *q;
+  int frames = (frame_tables.number > 0);
 
   /* Figure out name of output_file, stripping off .so version.  */
   p = rindex (output_file, '/');
@@ -1744,15 +1768,49 @@ write_c_file_stat (stream, name)
   fprintf (stream, "static int count;\n");
   fprintf (stream, "typedef void entry_pt();\n");
   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
+
+  if (frames)
+    {
+      write_list_with_asm (stream, "extern void *", frame_tables.first);
+
+      fprintf (stream, "\tstatic void *frame_table[] = {\n");
+      write_list (stream, "\t\t&", frame_tables.first);
+      fprintf (stream, "\t0\n};\n");
+
+      /* This must match what's in frame.h.  */
+      fprintf (stream, "struct object {\n");
+      fprintf (stream, "  void *pc_begin;\n");
+      fprintf (stream, "  void *pc_end;\n");
+      fprintf (stream, "  void *fde_begin;\n");
+      fprintf (stream, "  void *fde_array;\n");
+      fprintf (stream, "  __SIZE_TYPE__ count;\n");
+      fprintf (stream, "  struct object *next;\n");
+      fprintf (stream, "};\n");
+
+      fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
+      fprintf (stream, "extern void __deregister_frame_info (void *);\n");
+
+      fprintf (stream, "static void reg_frame () {\n");
+      fprintf (stream, "\tstatic struct object ob;\n");
+      fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
+      fprintf (stream, "\t}\n");
+
+      fprintf (stream, "static void dereg_frame () {\n");
+      fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
+      fprintf (stream, "\t}\n");
+    }
+
   fprintf (stream, "void %s() {\n", initname);
-  if (constructors.number > 0)
+  if (constructors.number > 0 || frames)
     {
       fprintf (stream, "\tstatic entry_pt *ctors[] = {\n");
       write_list (stream, "\t\t", constructors.first);
+      if (frames)
+	fprintf (stream, "\treg_frame,\n");
       fprintf (stream, "\t};\n");
       fprintf (stream, "\tentry_pt **p;\n");
       fprintf (stream, "\tif (count++ != 0) return;\n");
-      fprintf (stream, "\tp = ctors + %d;\n", constructors.number);
+      fprintf (stream, "\tp = ctors + %d;\n", constructors.number + frames);
       fprintf (stream, "\twhile (p > ctors) (*--p)();\n");
     }
   else
@@ -1760,16 +1818,18 @@ write_c_file_stat (stream, name)
   fprintf (stream, "}\n");
   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
   fprintf (stream, "void %s() {\n", fininame);
-  if (destructors.number > 0)
+  if (destructors.number > 0 || frames)
     {
       fprintf (stream, "\tstatic entry_pt *dtors[] = {\n");
       write_list (stream, "\t\t", destructors.first);
+      if (frames)
+	fprintf (stream, "\tdereg_frame,\n");
       fprintf (stream, "\t};\n");
       fprintf (stream, "\tentry_pt **p;\n");
       fprintf (stream, "\tif (--count != 0) return;\n");
       fprintf (stream, "\tp = dtors;\n");
       fprintf (stream, "\twhile (p < dtors + %d) (*p++)();\n",
-	       destructors.number);
+	       destructors.number + frames);
     }
   fprintf (stream, "}\n");
 
@@ -1789,20 +1849,57 @@ write_c_file_glob (stream, name)
 {
   /* Write the tables as C code  */
 
+  int frames = (frame_tables.number > 0);
+
   fprintf (stream, "typedef void entry_pt();\n\n");
     
   write_list_with_asm (stream, "extern entry_pt ", constructors.first);
-    
+
+  if (frames)
+    {
+      write_list_with_asm (stream, "extern void *", frame_tables.first);
+
+      fprintf (stream, "\tstatic void *frame_table[] = {\n");
+      write_list (stream, "\t\t&", frame_tables.first);
+      fprintf (stream, "\t0\n};\n");
+
+      /* This must match what's in frame.h.  */
+      fprintf (stream, "struct object {\n");
+      fprintf (stream, "  void *pc_begin;\n");
+      fprintf (stream, "  void *pc_end;\n");
+      fprintf (stream, "  void *fde_begin;\n");
+      fprintf (stream, "  void *fde_array;\n");
+      fprintf (stream, "  __SIZE_TYPE__ count;\n");
+      fprintf (stream, "  struct object *next;\n");
+      fprintf (stream, "};\n");
+
+      fprintf (stream, "extern void __register_frame_info_table (void *, struct object *);\n");
+      fprintf (stream, "extern void __deregister_frame_info (void *);\n");
+
+      fprintf (stream, "static void reg_frame () {\n");
+      fprintf (stream, "\tstatic struct object ob;\n");
+      fprintf (stream, "\t__register_frame_info_table (frame_table, &ob);\n");
+      fprintf (stream, "\t}\n");
+
+      fprintf (stream, "static void dereg_frame () {\n");
+      fprintf (stream, "\t__deregister_frame_info (frame_table);\n");
+      fprintf (stream, "\t}\n");
+    }
+
   fprintf (stream, "\nentry_pt * __CTOR_LIST__[] = {\n");
-  fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number);
+  fprintf (stream, "\t(entry_pt *) %d,\n", constructors.number + frames);
   write_list (stream, "\t", constructors.first);
+  if (frames)
+    fprintf (stream, "\treg_frame,\n");
   fprintf (stream, "\t0\n};\n\n");
 
   write_list_with_asm (stream, "extern entry_pt ", destructors.first);
 
   fprintf (stream, "\nentry_pt * __DTOR_LIST__[] = {\n");
-  fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number);
+  fprintf (stream, "\t(entry_pt *) %d,\n", destructors.number + frames);
   write_list (stream, "\t", destructors.first);
+  if (frames)
+    fprintf (stream, "\tdereg_frame,\n");
   fprintf (stream, "\t0\n};\n\n");
 
   fprintf (stream, "extern entry_pt %s;\n", NAME__MAIN);
@@ -1986,6 +2083,10 @@ scan_prog_file (prog_name, which_pass)
 #endif
 	  break;
 
+	case 5:
+	  if (which_pass != PASS_LIB)
+	    add_to_list (&frame_tables, name);
+
 	default:		/* not a constructor or destructor */
 	  continue;
 	}

gcc/combine.c

@@ -1,5 +1,5 @@
 /* Optimize by combining instructions for GNU compiler.
-   Copyright (C) 1987, 88, 92-96, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -970,13 +970,10 @@ can_combine_p (insn, i3, pred, succ, pdest, psrc)
 		 inputs.  */
 	      || (REGNO (src) < FIRST_PSEUDO_REGISTER
 		  && (! HARD_REGNO_MODE_OK (REGNO (src), GET_MODE (src))
-#ifdef SMALL_REGISTER_CLASSES
 		      || (SMALL_REGISTER_CLASSES
 			  && ((! all_adjacent && ! REG_USERVAR_P (src))
 			      || (FUNCTION_VALUE_REGNO_P (REGNO (src))
-				  && ! REG_USERVAR_P (src))))
-#endif
-		      ))))
+				  && ! REG_USERVAR_P (src))))))))
 	return 0;
     }
   else if (GET_CODE (dest) != CC0)
@@ -1051,6 +1048,43 @@ can_combine_p (insn, i3, pred, succ, pdest, psrc)
   return 1;
 }
 
+/* Check if PAT is an insn - or a part of it - used to set up an
+   argument for a function in a hard register.  */
+
+static int
+sets_function_arg_p (pat)
+     rtx pat;
+{
+  int i;
+  rtx inner_dest;
+
+  switch (GET_CODE (pat))
+    {
+    case INSN:
+      return sets_function_arg_p (PATTERN (pat));
+
+    case PARALLEL:
+      for (i = XVECLEN (pat, 0); --i >= 0;)
+	if (sets_function_arg_p (XVECEXP (pat, 0, i)))
+	  return 1;
+
+      break;
+
+    case SET:
+      inner_dest = SET_DEST (pat);
+      while (GET_CODE (inner_dest) == STRICT_LOW_PART
+	     || GET_CODE (inner_dest) == SUBREG
+	     || GET_CODE (inner_dest) == ZERO_EXTRACT)
+	inner_dest = XEXP (inner_dest, 0);
+
+      return (GET_CODE (inner_dest) == REG
+	      && REGNO (inner_dest) < FIRST_PSEUDO_REGISTER
+	      && FUNCTION_ARG_REGNO_P (REGNO (inner_dest)));
+    }
+
+  return 0;
+}
+
 /* LOC is the location within I3 that contains its pattern or the component
    of a PARALLEL of the pattern.  We validate that it is valid for combining.
 
@@ -1079,7 +1113,7 @@ can_combine_p (insn, i3, pred, succ, pdest, psrc)
    If I1_NOT_IN_SRC is non-zero, it means that finding I1 in the source
    of a SET must prevent combination from occurring.
 
-   On machines where SMALL_REGISTER_CLASSES is defined, we don't combine
+   On machines where SMALL_REGISTER_CLASSES is non-zero, we don't combine
    if the destination of a SET is a hard register that isn't a user
    variable.
 
@@ -1146,22 +1180,28 @@ combinable_i3pat (i3, loc, i2dest, i1dest, i1_not_in_src, pi3dest_killed)
       if ((inner_dest != dest
 	   && (reg_overlap_mentioned_p (i2dest, inner_dest)
 	       || (i1dest && reg_overlap_mentioned_p (i1dest, inner_dest))))
+
 	  /* This is the same test done in can_combine_p except that we
 	     allow a hard register with SMALL_REGISTER_CLASSES if SRC is a
-	     CALL operation.
-	     Moreover, we can't test all_adjacent; we don't have to, since
-	     this instruction will stay in place, thus we are not considering
-	     to increase the lifetime of INNER_DEST.  */
+	     CALL operation. Moreover, we can't test all_adjacent; we don't
+	     have to, since this instruction will stay in place, thus we are
+	     not considering increasing the lifetime of INNER_DEST.
+
+	     Also, if this insn sets a function argument, combining it with
+	     something that might need a spill could clobber a previous
+	     function argument; the all_adjacent test in can_combine_p also
+	     checks this; here, we do a more specific test for this case.  */
+	     
 	  || (GET_CODE (inner_dest) == REG
 	      && REGNO (inner_dest) < FIRST_PSEUDO_REGISTER
 	      && (! HARD_REGNO_MODE_OK (REGNO (inner_dest),
 					GET_MODE (inner_dest))
-#ifdef SMALL_REGISTER_CLASSES
-		 || (SMALL_REGISTER_CLASSES
-		     && GET_CODE (src) != CALL && ! REG_USERVAR_P (inner_dest)
-		     && FUNCTION_VALUE_REGNO_P (REGNO (inner_dest)))
-#endif
-		  ))
+		 || (SMALL_REGISTER_CLASSES && GET_CODE (src) != CALL
+		     && ! REG_USERVAR_P (inner_dest)
+		     && (FUNCTION_VALUE_REGNO_P (REGNO (inner_dest))
+			 || (FUNCTION_ARG_REGNO_P (REGNO (inner_dest))
+			     && i3 != 0
+			     && sets_function_arg_p (prev_nonnote_insn (i3)))))))
 	  || (i1_not_in_src && reg_overlap_mentioned_p (i1dest, src)))
 	return 0;
 
@@ -1301,12 +1341,10 @@ try_combine (i3, i2, i1)
   if (i1 == 0 && GET_CODE (i3) == INSN && GET_CODE (PATTERN (i3)) == SET
       && GET_CODE (SET_SRC (PATTERN (i3))) == REG
       && REGNO (SET_SRC (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
-#ifdef SMALL_REGISTER_CLASSES
       && (! SMALL_REGISTER_CLASSES
-	  || GET_CODE (SET_DEST (PATTERN (i3))) != REG
-	  || REGNO (SET_DEST (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
-	  || REG_USERVAR_P (SET_DEST (PATTERN (i3))))
-#endif
+	  || (GET_CODE (SET_DEST (PATTERN (i3))) != REG
+	      || REGNO (SET_DEST (PATTERN (i3))) >= FIRST_PSEUDO_REGISTER
+	      || REG_USERVAR_P (SET_DEST (PATTERN (i3)))))
       && find_reg_note (i3, REG_DEAD, SET_SRC (PATTERN (i3)))
       && GET_CODE (PATTERN (i2)) == PARALLEL
       && ! side_effects_p (SET_DEST (PATTERN (i3)))
@@ -1401,8 +1439,8 @@ try_combine (i3, i2, i1)
 	     as I2 will not cause a problem.  */
 
 	  subst_prev_insn = i1
-	    = gen_rtx (INSN, VOIDmode, INSN_UID (i2), 0, i2,
-		       XVECEXP (PATTERN (i2), 0, 1), -1, 0, 0);
+	    = gen_rtx (INSN, VOIDmode, INSN_UID (i2), NULL_RTX, i2,
+		       XVECEXP (PATTERN (i2), 0, 1), -1, NULL_RTX, NULL_RTX);
 
 	  SUBST (PATTERN (i2), XVECEXP (PATTERN (i2), 0, 0));
 	  SUBST (XEXP (SET_SRC (PATTERN (i2)), 0),
@@ -2059,8 +2097,21 @@ try_combine (i3, i2, i1)
 	   && ! reg_referenced_p (SET_DEST (XVECEXP (newpat, 0, 0)),
 				  XVECEXP (newpat, 0, 1)))
     {
-      newi2pat = XVECEXP (newpat, 0, 1);
-      newpat = XVECEXP (newpat, 0, 0);
+      /* Normally, it doesn't matter which of the two is done first,
+	 but it does if one references cc0.  In that case, it has to
+	 be first.  */
+#ifdef HAVE_cc0
+      if (reg_referenced_p (cc0_rtx, XVECEXP (newpat, 0, 0)))
+	{
+	  newi2pat = XVECEXP (newpat, 0, 0);
+	  newpat = XVECEXP (newpat, 0, 1);
+	}
+      else
+#endif
+	{
+	  newi2pat = XVECEXP (newpat, 0, 1);
+	  newpat = XVECEXP (newpat, 0, 0);
+	}
 
       i2_code_number
 	= recog_for_combine (&newi2pat, i2, &new_i2_notes, &i2_scratches);
@@ -2286,7 +2337,9 @@ try_combine (i3, i2, i1)
       }
 
     /* If I3DEST was used in I3SRC, it really died in I3.  We may need to
-       put a REG_DEAD note for it somewhere.  Similarly for I2 and I1.
+       put a REG_DEAD note for it somewhere.  If NEWI2PAT exists and sets
+       I3DEST, the death must be somewhere before I2, not I3.  If we passed I3
+       in that case, it might delete I2.  Similarly for I2 and I1.
        Show an additional death due to the REG_DEAD note we make here.  If
        we discard it in distribute_notes, we will decrement it again.  */
 
@@ -2295,16 +2348,17 @@ try_combine (i3, i2, i1)
 	if (GET_CODE (i3dest_killed) == REG)
 	  REG_N_DEATHS (REGNO (i3dest_killed))++;
 
-	distribute_notes (gen_rtx (EXPR_LIST, REG_DEAD, i3dest_killed,
-				   NULL_RTX),
-			  NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
-			  NULL_RTX, NULL_RTX);
+	if (newi2pat && reg_set_p (i3dest_killed, newi2pat))
+	  distribute_notes (gen_rtx (EXPR_LIST, REG_DEAD, i3dest_killed,
+				     NULL_RTX),
+			    NULL_RTX, i2, NULL_RTX, elim_i2, elim_i1);
+	else
+	  distribute_notes (gen_rtx (EXPR_LIST, REG_DEAD, i3dest_killed,
+				     NULL_RTX),
+			    NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
+			    elim_i2, elim_i1);
       }
 
-    /* For I2 and I1, we have to be careful.  If NEWI2PAT exists and sets
-       I2DEST or I1DEST, the death must be somewhere before I2, not I3.  If
-       we passed I3 in that case, it might delete I2.  */
-
     if (i2dest_in_i2src)
       {
 	if (GET_CODE (i2dest) == REG)
@@ -2723,6 +2777,9 @@ find_split_point (loc, insn)
 	      unsignedp = (code == ZERO_EXTRACT);
 	    }
 	  break;
+
+	default:
+	  break;
 	}
 
       if (len && pos >= 0 && pos + len <= GET_MODE_BITSIZE (GET_MODE (inner)))
@@ -2819,6 +2876,9 @@ find_split_point (loc, insn)
 	  SUBST (XEXP (x, 1), tem);
 	}
       break;
+
+    default:
+      break;
     }
 
   /* Otherwise, select our actions depending on our rtx class.  */
@@ -4020,11 +4080,16 @@ simplify_rtx (x, op0_mode, last, in_dest)
     case XOR:
       return simplify_logical (x, last);
 
-    case ABS:
+    case ABS:      
       /* (abs (neg <foo>)) -> (abs <foo>) */
       if (GET_CODE (XEXP (x, 0)) == NEG)
 	SUBST (XEXP (x, 0), XEXP (XEXP (x, 0), 0));
 
+      /* If the mode of the operand is VOIDmode (i.e. if it is ASM_OPERANDS),
+         do nothing.  */
+      if (GET_MODE (XEXP (x, 0)) == VOIDmode)
+	break;
+
       /* If operand is something known to be positive, ignore the ABS.  */
       if (GET_CODE (XEXP (x, 0)) == FFS || GET_CODE (XEXP (x, 0)) == ABS
 	  || ((GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
@@ -4076,6 +4141,9 @@ simplify_rtx (x, op0_mode, last, in_dest)
 #endif
 
       break;
+
+    default:
+      break;
     }
 
   return x;
@@ -4223,6 +4291,8 @@ simplify_if_then_else (x)
       case LT:
       case LE:
 	return gen_unary (NEG, mode, mode, gen_unary (ABS, mode, mode, true));
+    default:
+      break;
       }
 
   /* Look for MIN or MAX.  */
@@ -4246,6 +4316,8 @@ simplify_if_then_else (x)
       case LEU:
       case LTU:
 	return gen_binary (UMIN, mode, true, false);
+      default:
+	break;
       }
   
   /* If we have (if_then_else COND (OP Z C1) Z) and OP is an identity when its
@@ -4936,6 +5008,9 @@ simplify_logical (x, last)
 	return gen_rtx_combine (reverse_condition (GET_CODE (op0)),
 				mode, XEXP (op0, 0), XEXP (op0, 1));
       break;
+
+    default:
+      abort ();
     }
 
   return x;
@@ -5649,6 +5724,9 @@ extract_left_shift (x, count)
 			   GEN_INT (INTVAL (XEXP (x, 1)) >> count));
 
       break;
+      
+    default:
+      break;
     }
 
   return 0;
@@ -5890,6 +5968,10 @@ make_compound_operation (x, in_code)
 
 	  return newer;
 	}
+      break;
+      
+    default:
+      break;
     }
 
   if (new)
@@ -5970,8 +6052,11 @@ force_to_mode (x, mode, mask, reg, just_select)
 
   /* If this is a CALL or ASM_OPERANDS, don't do anything.  Some of the
      code below will do the wrong thing since the mode of such an
-     expression is VOIDmode.  */
-  if (code == CALL || code == ASM_OPERANDS)
+     expression is VOIDmode. 
+
+     Also do nothing if X is a CLOBBER; this can happen if X was
+     the return value from a call to gen_lowpart_for_combine.  */
+  if (code == CALL || code == ASM_OPERANDS || code == CLOBBER)
     return x;
 
   /* We want to perform the operation is its present mode unless we know
@@ -6459,6 +6544,9 @@ force_to_mode (x, mode, mask, reg, just_select)
 				      force_to_mode (XEXP (x, 2), mode,
 						     mask, reg,next_select)));
       break;
+      
+    default:
+      break;
     }
 
   /* Ensure we return a value of the proper mode.  */
@@ -6681,6 +6769,8 @@ known_cond (x, cond, reg, val)
       case LT:  case LE:
 	return gen_unary (NEG, GET_MODE (XEXP (x, 0)), GET_MODE (XEXP (x, 0)),
 			  XEXP (x, 0));
+      default:
+	break;
       }
 
   /* The only other cases we handle are MIN, MAX, and comparisons if the
@@ -6717,6 +6807,8 @@ known_cond (x, cond, reg, val)
 		  return unsignedp ? XEXP (x, 1) : x;
 		case LEU:  case LTU:
 		  return unsignedp ? XEXP (x, 0) : x;
+		default:
+		  break;
 		}
 	    }
 	}
@@ -7138,7 +7230,7 @@ simplify_and_const_int (x, mode, varop, constop)
 /* We let num_sign_bit_copies recur into nonzero_bits as that is useful.
    We don't let nonzero_bits recur into num_sign_bit_copies, because that
    is less useful.  We can't allow both, because that results in exponential
-   run time recusion.  There is a nullstone testcase that triggered
+   run time recursion.  There is a nullstone testcase that triggered
    this.  This macro avoids accidental uses of num_sign_bit_copies.  */
 #define num_sign_bit_copies()
 
@@ -7428,6 +7520,8 @@ nonzero_bits (x, mode)
 	    result_width = MIN (width0, width1);
 	    result_low = MIN (low0, low1);
 	    break;
+	  default:
+	    abort ();
 	  }
 
 	if (result_width < mode_width)
@@ -7530,6 +7624,9 @@ nonzero_bits (x, mode)
       nonzero &= (nonzero_bits (XEXP (x, 1), mode)
 		  | nonzero_bits (XEXP (x, 2), mode));
       break;
+      
+    default:
+      break;
     }
 
   return nonzero;
@@ -7571,13 +7668,25 @@ num_sign_bit_copies (x, mode)
     return MAX (1, (num_sign_bit_copies (x, GET_MODE (x))
 		    - (GET_MODE_BITSIZE (GET_MODE (x)) - bitwidth)));
      
+  if (GET_MODE (x) != VOIDmode && bitwidth > GET_MODE_BITSIZE (GET_MODE (x)))
+    {
 #ifndef WORD_REGISTER_OPERATIONS
   /* If this machine does not do all register operations on the entire
      register and MODE is wider than the mode of X, we can say nothing
      at all about the high-order bits.  */
-  if (GET_MODE (x) != VOIDmode && bitwidth > GET_MODE_BITSIZE (GET_MODE (x)))
-    return 1;
+      return 1;
+#else
+      /* Likewise on machines that do, if the mode of the object is smaller
+	 than a word and loads of that size don't sign extend, we can say
+	 nothing about the high order bits.  */
+      if (GET_MODE_BITSIZE (GET_MODE (x)) < BITS_PER_WORD
+#ifdef LOAD_EXTEND_OP
+	  && LOAD_EXTEND_OP (GET_MODE (x)) != SIGN_EXTEND
 #endif
+	  )
+	return 1;
+#endif
+    }
 
   switch (code)
     {
@@ -7817,6 +7926,10 @@ num_sign_bit_copies (x, mode)
     case GEU: case GTU: case LEU: case LTU:
       if (STORE_FLAG_VALUE == -1)
 	return bitwidth;
+      break;
+      
+    default:
+      break;
     }
 
   /* If we haven't been able to figure it out by one of the above rules,
@@ -7928,6 +8041,8 @@ merge_outer_ops (pop0, pconst0, op1, const1, mode, pcomp_p)
 	case NEG:
 	  op0 = NIL;
 	  break;
+	default:
+	  break;
 	}
     }
 
@@ -7969,6 +8084,8 @@ merge_outer_ops (pop0, pconst0, op1, const1, mode, pcomp_p)
 	  /* (a ^ b) & b) == (~a) & b */
 	  *pcomp_p = 1;
 	break;
+      default:
+	break;
       }
 
   /* Check for NO-OP cases.  */
@@ -8602,6 +8719,9 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	      continue;
 	    }
 	  break;
+	  
+	default:
+	  break;
 	}
 
       break;
@@ -9434,6 +9554,9 @@ simplify_comparison (code, pop0, pop1)
 	      code = LT;
 	    }
 	  break;
+
+	default:
+	  break;
 	}
 
       /* Compute some predicates to simplify code below.  */
@@ -9966,6 +10089,9 @@ simplify_comparison (code, pop0, pop1)
 	      continue;
 	    }
 	  break;
+	  
+	default:
+	  break;
 	}
 
       break;
@@ -10096,9 +10222,10 @@ reversible_comparison_p (x)
       x = get_last_value (XEXP (x, 0));
       return (x && GET_CODE (x) == COMPARE
 	      && ! FLOAT_MODE_P (GET_MODE (XEXP (x, 0))));
+      
+    default:
+      return 0;
     }
-
-  return 0;
 }
 
 /* Utility function for following routine.  Called when X is part of a value
@@ -10705,8 +10832,11 @@ mark_used_regs_combine (x)
 	  mark_used_regs_combine (XEXP (testreg, 0));
 
 	mark_used_regs_combine (SET_SRC (x));
-	return;
       }
+      return;
+
+    default:
+      break;
     }
 
   /* Recursively scan the operands of this expression.  */
@@ -11177,15 +11307,21 @@ distribute_notes (notes, from_insn, i3, i2, elim_i2, elim_i1)
 		  if (reg_set_p (XEXP (note, 0), PATTERN (tem)))
 		    {
 		      rtx set = single_set (tem);
+		      rtx inner_dest = 0;
+
+		      if (set != 0)
+			for (inner_dest = SET_DEST (set);
+			     GET_CODE (inner_dest) == STRICT_LOW_PART
+			     || GET_CODE (inner_dest) == SUBREG
+			     || GET_CODE (inner_dest) == ZERO_EXTRACT;
+			     inner_dest = XEXP (inner_dest, 0))
+			  ;
 
 		      /* Verify that it was the set, and not a clobber that
 			 modified the register.  */
 
 		      if (set != 0 && ! side_effects_p (SET_SRC (set))
-			  && (rtx_equal_p (XEXP (note, 0), SET_DEST (set))
-			      || (GET_CODE (SET_DEST (set)) == SUBREG
-				  && rtx_equal_p (XEXP (note, 0),
-						  XEXP (SET_DEST (set), 0)))))
+			  && rtx_equal_p (XEXP (note, 0), inner_dest))
 			{
 			  /* Move the notes and links of TEM elsewhere.
 			     This might delete other dead insns recursively. 
@@ -11202,6 +11338,20 @@ distribute_notes (notes, from_insn, i3, i2, elim_i2, elim_i1)
 			  NOTE_LINE_NUMBER (tem) = NOTE_INSN_DELETED;
 			  NOTE_SOURCE_FILE (tem) = 0;
 			}
+		      /* If the register is both set and used here, put the
+			 REG_DEAD note here, but place a REG_UNUSED note
+			 here too unless there already is one.  */
+		      else if (reg_referenced_p (XEXP (note, 0),
+						 PATTERN (tem)))
+			{
+			  place = tem;
+
+			  if (! find_regno_note (tem, REG_UNUSED,
+						 REGNO (XEXP (note, 0))))
+			    REG_NOTES (tem)
+			      = gen_rtx (EXPR_LIST, REG_UNUSED, XEXP (note, 0),
+					 REG_NOTES (tem));
+			}
 		      else
 			{
 			  PUT_REG_NOTE_KIND (note, REG_UNUSED);
@@ -11258,13 +11408,12 @@ distribute_notes (notes, from_insn, i3, i2, elim_i2, elim_i1)
 	    }
 
 	  /* If the register is set or already dead at PLACE, we needn't do
-	     anything with this note if it is still a REG_DEAD note.  
+	     anything with this note if it is still a REG_DEAD note.
+	     We can here if it is set at all, not if is it totally replace,
+	     which is what `dead_or_set_p' checks, so also check for it being
+	     set partially.  */
+
 
-	     Note that we cannot use just `dead_or_set_p' here since we can
-	     convert an assignment to a register into a bit-field assignment.
-	     Therefore, we must also omit the note if the register is the 
-	     target of a bitfield assignment.  */
-	     
 	  if (place && REG_NOTE_KIND (note) == REG_DEAD)
 	    {
 	      int regno = REGNO (XEXP (note, 0));

gcc/config.guess

@@ -1,6 +1,6 @@
 #! /bin/sh
 # Attempt to guess a canonical system name.
-#   Copyright (C) 1992, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+#   Copyright (C) 1992, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
 #
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
@@ -52,6 +52,9 @@ trap 'rm -f dummy.c dummy.o dummy; exit 1' 1 2 15
 
 case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
     alpha:OSF1:*:*)
+	if test $UNAME_RELEASE = "V4.0"; then
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+	fi
 	# A Vn.n version is a released version.
 	# A Tn.n version is a released field test version.
 	# A Xn.n version is an unreleased experimental baselevel.
@@ -62,9 +65,14 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
 main:
 	.frame \$30,0,\$26,0
 	.prologue 0
-	.long 0x47e03d84
-	cmoveq \$4,0,\$3
-	addl \$3,\$31,\$0
+	.long 0x47e03d80 # implver $0
+	lda \$2,259
+	.long 0x47e20c21 # amask $2,$1
+	srl \$1,8,\$2
+	sll \$2,2,\$2
+	sll \$0,3,\$0
+	addl \$1,\$0,\$0
+	addl \$2,\$0,\$0
 	ret \$31,(\$26),1
 	.end main
 EOF
@@ -72,16 +80,25 @@ EOF
 	if test "$?" = 0 ; then
 		./dummy
 		case "$?" in
-			1)
+			7)
+				UNAME_MACHINE="alpha"
+				;;
+			15)
 				UNAME_MACHINE="alphaev5"
 				;;
-			2)
+			14)
 				UNAME_MACHINE="alphaev56"
 				;;
+			10)
+				UNAME_MACHINE="alphapca56"
+				;;
+			16)
+				UNAME_MACHINE="alphaev6"
+				;;
 		esac
 	fi
 	rm -f dummy.s dummy
-	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[VTX]//'`
+	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[VTX]//' | tr [[A-Z]] [[a-z]]`
 	exit 0 ;;
     21064:Windows_NT:50:3)
 	echo alpha-dec-winnt3.5
@@ -461,10 +478,10 @@ EOF
 	echo ${UNAME_MACHINE}-unknown-openbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'`
 	exit 0 ;;
     i*:CYGWIN*:*)
-	echo i386-pc-cygwin32
+	echo ${UNAME_MACHINE}-pc-cygwin32
 	exit 0 ;;
     i*:MINGW*:*)
-	echo i386-pc-mingw32
+	echo ${UNAME_MACHINE}-pc-mingw32
 	exit 0 ;;
     p*:CYGWIN*:*)
 	echo powerpcle-unknown-cygwin32
@@ -476,6 +493,12 @@ EOF
 	echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
 	exit 0 ;;
     *:Linux:*:*)
+	# uname on the ARM produces all sorts of strangeness, and we need to
+	# filter it out.
+	case "$UNAME_MACHINE" in
+	  arm* | sa110*)	      UNAME_MACHINE="arm" ;;
+	esac
+
 	# The BFD linker knows what the default object file format is, so
 	# first see if it will tell us.
 	ld_help_string=`ld --help 2>&1`
@@ -489,6 +512,7 @@ EOF
 	  i?86linux)  echo "${UNAME_MACHINE}-pc-linux-gnuaout"      ; exit 0 ;;
 	  i?86coff)   echo "${UNAME_MACHINE}-pc-linux-gnucoff"      ; exit 0 ;;
 	  sparclinux) echo "${UNAME_MACHINE}-unknown-linux-gnuaout" ; exit 0 ;;
+	  armlinux)   echo "${UNAME_MACHINE}-unknown-linux-gnuaout" ; exit 0 ;;
 	  m68klinux)  echo "${UNAME_MACHINE}-unknown-linux-gnuaout" ; exit 0 ;;
 	  elf32ppc)   echo "powerpc-unknown-linux-gnu"              ; exit 0 ;;
 	esac
@@ -500,26 +524,47 @@ EOF
 	main:
 		.frame \$30,0,\$26,0
 		.prologue 0
-		.long 0x47e03d84
-		cmoveq \$4,0,\$3
-		addl \$3,\$31,\$0
+		.long 0x47e03d80 # implver $0
+		lda \$2,259
+		.long 0x47e20c21 # amask $2,$1
+		srl \$1,8,\$2
+		sll \$2,2,\$2
+		sll \$0,3,\$0
+		addl \$1,\$0,\$0
+		addl \$2,\$0,\$0
 		ret \$31,(\$26),1
 		.end main
 EOF
+		LIBC=""
 		${CC-cc} dummy.s -o dummy 2>/dev/null
 		if test "$?" = 0 ; then
 			./dummy
 			case "$?" in
-				1)
-					UNAME_MACHINE="alphaev5"
-				;;	
-			2)	
-					UNAME_MACHINE="alphaev56"
-				;;	
-		esac	
-	  fi	
-	  rm -f dummy.s dummy
-	  echo ${UNAME_MACHINE}-unknown-linux-gnu ; exit 0
+			7)
+				UNAME_MACHINE="alpha"
+				;;
+			15)
+				UNAME_MACHINE="alphaev5"
+				;;
+			14)
+				UNAME_MACHINE="alphaev56"
+				;;
+			10)
+				UNAME_MACHINE="alphapca56"
+				;;
+			16)
+				UNAME_MACHINE="alphaev6"
+				;;
+			esac	
+
+			objdump --private-headers dummy | \
+			  grep ld.so.1 > /dev/null
+			if test "$?" = 0 ; then
+				LIBC="libc1"
+			fi
+		fi	
+		rm -f dummy.s dummy
+		echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} ; exit 0
 	elif test "${UNAME_MACHINE}" = "mips" ; then
 	  cat >dummy.c <<EOF
 main(argc, argv)

gcc/config.sub

@@ -1,6 +1,6 @@
 #! /bin/sh
 # Configuration validation subroutine script, version 1.1.
-#   Copyright (C) 1991, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+#   Copyright (C) 1991, 92-97, 1998 Free Software Foundation, Inc.
 # This file is (in principle) common to ALL GNU software.
 # The presence of a machine in this file suggests that SOME GNU software
 # can handle that machine.  It does not imply ALL GNU software can.
@@ -149,19 +149,20 @@ esac
 case $basic_machine in
 	# Recognize the basic CPU types without company name.
 	# Some are omitted here because they have special meanings below.
-	tahoe | i860 | m32r | m68k | m68000 | m88k | ns32k | arm \
+	tahoe | i860 | m32r | m68k | m68000 | m88k | ns32k | arc | arm \
 		| arme[lb] | pyramid | mn10200 | mn10300 \
 		| tron | a29k | 580 | i960 | h8300 | hppa | hppa1.0 | hppa1.1 \
 		| alpha | alphaev5 | alphaev56 | we32k | ns16k | clipper \
 		| i370 | sh | powerpc | powerpcle | 1750a | dsp16xx | pdp11 \
 		| mips64 | mipsel | mips64el | mips64orion | mips64orionel \
-		| sparc | sparclet | sparclite | sparc64)
+		| mipstx39 | mipstx39el \
+		| sparc | sparclet | sparclite | sparc64 | v850)
 		basic_machine=$basic_machine-unknown
 		;;
 	# We use `pc' rather than `unknown'
 	# because (1) that's what they normally are, and
 	# (2) the word "unknown" tends to confuse beginning users.
-	i[3456]86)
+	i[34567]86)
 	  basic_machine=$basic_machine-pc
 	  ;;
 	# Object if more than one company name word.
@@ -170,8 +171,8 @@ case $basic_machine in
 		exit 1
 		;;
 	# Recognize the basic CPU types with company name.
-	vax-* | tahoe-* | i[3456]86-* | i860-* | m32r-* | m68k-* | m68000-* \
-	      | m88k-* | sparc-* | ns32k-* | fx80-* | arm-* | c[123]* \
+	vax-* | tahoe-* | i[34567]86-* | i860-* | m32r-* | m68k-* | m68000-* \
+	      | m88k-* | sparc-* | ns32k-* | fx80-* | arc-* | arm-* | c[123]* \
 	      | mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \
 	      | power-* | none-* | 580-* | cray2-* | h8300-* | i960-* \
 	      | xmp-* | ymp-* | hppa-* | hppa1.0-* | hppa1.1-* \
@@ -179,7 +180,9 @@ case $basic_machine in
 	      | ns16k-* | pn-* | np1-* | xps100-* | clipper-* | orion-* \
 	      | sparclite-* | pdp11-* | sh-* | powerpc-* | powerpcle-* \
 	      | sparc64-* | mips64-* | mipsel-* \
-	      | mips64el-* | mips64orion-* | mips64orionel-* | f301-*)
+	      | mips64el-* | mips64orion-* | mips64orionel-*  \
+	      | mipstx39-* | mipstx39el-* \
+	      | f301-*)
 		;;
 	# Recognize the various machine names and aliases which stand
 	# for a CPU type and a company and sometimes even an OS.
@@ -206,9 +209,9 @@ case $basic_machine in
 	amiga | amiga-*)
 		basic_machine=m68k-cbm
 		;;
-	amigados)
+	amigaos | amigados)
 		basic_machine=m68k-cbm
-		os=-amigados
+		os=-amigaos
 		;;
 	amigaunix | amix)
 		basic_machine=m68k-cbm
@@ -347,19 +350,19 @@ case $basic_machine in
 		os=-mvs
 		;;
 # I'm not sure what "Sysv32" means.  Should this be sysv3.2?
-	i[3456]86v32)
+	i[34567]86v32)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-sysv32
 		;;
-	i[3456]86v4*)
+	i[34567]86v4*)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-sysv4
 		;;
-	i[3456]86v)
+	i[34567]86v)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-sysv
 		;;
-	i[3456]86sol2)
+	i[34567]86sol2)
 		basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'`
 		os=-solaris2
 		;;
@@ -466,25 +469,23 @@ case $basic_machine in
         pc532 | pc532-*)
 		basic_machine=ns32k-pc532
 		;;
-	pentium | p5)
-		basic_machine=i586-intel
+	pentium | p5 | k5 | nexen)
+		basic_machine=i586-pc
 		;;
-	pentiumpro | p6)
-		basic_machine=i686-intel
+	pentiumpro | p6 | k6 | 6x86)
+		basic_machine=i686-pc
 		;;
-	pentium-* | p5-*)
+	pentiumii | pentium2)
+		basic_machine=i786-pc
+		;;
+	pentium-* | p5-* | k5-* | nexen-*)
 		basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
-	pentiumpro-* | p6-*)
+	pentiumpro-* | p6-* | k6-* | 6x86-*)
 		basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
-	k5)
-		# We don't have specific support for AMD's K5 yet, so just call it a Pentium
-		basic_machine=i586-amd
-		;;
-	nexen)
-		# We don't have specific support for Nexgen yet, so just call it a Pentium
-		basic_machine=i586-nexgen
+	pentiumii-* | pentium2-*)
+		basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'`
 		;;
 	pn)
 		basic_machine=pn-gould
@@ -568,6 +569,12 @@ case $basic_machine in
 		basic_machine=i386-sequent
 		os=-dynix
 		;;
+	tx39)
+		basic_machine=mipstx39-unknown
+		;;
+	tx39el)
+		basic_machine=mipstx39el-unknown
+		;;
 	tower | tower-32)
 		basic_machine=m68k-ncr
 		;;
@@ -698,7 +705,8 @@ case $os in
 	-gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
 	      | -*vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]*\
 	      | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \
-	      | -amigados* | -msdos* | -newsos* | -unicos* | -aof* | -aos* \
+	      | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \
+	      | -aos* \
 	      | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \
 	      | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \
 	      | -hiux* | -386bsd* | -netbsd* | -openbsd* | -freebsd* | -riscix* \
@@ -832,7 +840,7 @@ case $basic_machine in
 		os=-sysv
 		;;
 	*-cbm)
-		os=-amigados
+		os=-amigaos
 		;;
 	*-dg)
 		os=-dgux

gcc/config/1750a/1750a.c

@@ -19,13 +19,10 @@ along with GNU CC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
-#ifndef FILE
-#include <stdio.h>
-#endif
-#include <string.h>
-
 #define __datalbl
 #include "config.h"
+#include <stdio.h>
+#include <string.h>
 #include "rtl.h"
 #include "tree.h"
 #include "expr.h"

gcc/config/1750a/1750a.md

@@ -1105,7 +1105,7 @@
 ;********************
 
 ;; Bit field instructions, general cases.
-;; "o,d" constraint causes a nonoffsetable memref to match the "o"
+;; "o,d" constraint causes a nonoffsettable memref to match the "o"
 ;; so that its address is reloaded.
 
 ;; (define_insn "extv" ...

gcc/config/a29k/a29k.c

@@ -1,5 +1,5 @@
 /* Subroutines used for code generation on AMD Am29000.
-   Copyright (C) 1987, 88, 90-94, 1995 Free Software Foundation, Inc.
+   Copyright (C) 1987, 88, 90-94, 1995, 1997 Free Software Foundation, Inc.
    Contributed by Richard Kenner (kenner@nyu.edu)
 
 This file is part of GNU CC.
@@ -19,8 +19,8 @@ along with GNU CC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
-#include <stdio.h>
 #include "config.h"
+#include <stdio.h>
 #include "rtl.h"
 #include "regs.h"
 #include "hard-reg-set.h"

gcc/config/a29k/a29k.h

@@ -987,13 +987,18 @@ extern char *a29k_function_name;
 
    On the 29k, we must be able to place it in a delay slot, it must
    not use sp if the frame pointer cannot be eliminated, and it cannot
-   use local regs if we need to push the register stack.  */
+   use local regs if we need to push the register stack.
+   If this is a SET with a memory as source, it might load from
+   a stack slot, unless the address is constant.  */
 
 #define ELIGIBLE_FOR_EPILOGUE_DELAY(INSN,N)				\
   (get_attr_in_delay_slot (INSN) == IN_DELAY_SLOT_YES			\
    && ! (frame_pointer_needed						\
 	 && reg_mentioned_p (stack_pointer_rtx, PATTERN (INSN)))	\
-   && ! (needs_regstack_p () && uses_local_reg_p (PATTERN (INSN))))
+   && ! (needs_regstack_p () && uses_local_reg_p (PATTERN (INSN)))	\
+   && (GET_CODE (PATTERN (INSN)) != SET					\
+       || GET_CODE (SET_SRC (PATTERN (INSN))) != MEM			\
+       || ! rtx_varies_p (XEXP (SET_SRC (PATTERN (INSN)), 0))))
 
 /* Output assembler code for a block containing the constant parts
    of a trampoline, leaving space for the variable parts.

gcc/config/a29k/t-vx29k

@@ -6,7 +6,7 @@ LIBGCC1_TEST =
 
 # We don't want to put exit in libgcc.a for VxWorks, because VxWorks
 # does not have _exit.
-LIBGCC2_CFLAGS = -O2 $(GCC_CFLAGS) -g1 -Dexit=unused_exit
+TARGET_LIBGCC2_CFLAGS = -Dexit=unused_exit
 LIB2FUNCS_EXTRA = fp-bit.c dp-bit.c
 
 dp-bit.c: $(srcdir)/config/fp-bit.c

gcc/config/alpha/alpha.c

@@ -1,5 +1,5 @@
 /* Subroutines used for code generation on the DEC Alpha.
-   Copyright (C) 1992, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1992, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
    Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
 
 This file is part of GNU CC.
@@ -20,8 +20,8 @@ the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
 
-#include <stdio.h>
 #include "config.h"
+#include <stdio.h>
 #include "rtl.h"
 #include "regs.h"
 #include "hard-reg-set.h"
@@ -95,10 +95,13 @@ static void add_long_const	PROTO((FILE *, HOST_WIDE_INT, int, int, int));
 /* Compute the size of the save area in the stack.  */
 static void alpha_sa_mask	PROTO((unsigned long *imaskP,
 				       unsigned long *fmaskP));
-/* Strip type information.  */
-#define CURRENT_FUNCTION_ARGS_INFO  \
-(TARGET_OPEN_VMS ? current_function_args_info & 0xff \
- : current_function_args_info)
+
+/* Get the number of args of a function in one of two ways.  */
+#ifdef OPEN_VMS
+#define NUM_ARGS current_function_args_info.num_args
+#else
+#define NUM_ARGS current_function_args_info
+#endif
 
 /* Parse target option strings. */
 
@@ -106,21 +109,42 @@ void
 override_options ()
 {
   alpha_cpu
-    = TARGET_CPU_DEFAULT & MASK_CPU_EV5 ? PROCESSOR_EV5 : PROCESSOR_EV4;
+    = TARGET_CPU_DEFAULT & MASK_CPU_EV6 ? PROCESSOR_EV6
+      : (TARGET_CPU_DEFAULT & MASK_CPU_EV5 ? PROCESSOR_EV5 : PROCESSOR_EV4);
 
   if (alpha_cpu_string)
     {
       if (! strcmp (alpha_cpu_string, "ev4")
 	  || ! strcmp (alpha_cpu_string, "21064"))
-	alpha_cpu = PROCESSOR_EV4;
+	{
+	  alpha_cpu = PROCESSOR_EV4;
+	  target_flags &= ~ (MASK_BWX | MASK_CIX | MASK_MAX);
+	}
       else if (! strcmp (alpha_cpu_string, "ev5")
 	       || ! strcmp (alpha_cpu_string, "21164"))
-	alpha_cpu = PROCESSOR_EV5;
+	{
+	  alpha_cpu = PROCESSOR_EV5;
+	  target_flags &= ~ (MASK_BWX | MASK_CIX | MASK_MAX);
+	}
       else if (! strcmp (alpha_cpu_string, "ev56")
 	       || ! strcmp (alpha_cpu_string, "21164a"))
 	{
 	  alpha_cpu = PROCESSOR_EV5;
-	  target_flags |= MASK_BYTE_OPS;
+	  target_flags |= MASK_BWX;
+	  target_flags &= ~ (MASK_CIX | MASK_MAX);
+	}
+      else if (! strcmp (alpha_cpu_string, "pca56")
+	       || ! strcmp (alpha_cpu_string, "21164PC"))
+	{
+	  alpha_cpu = PROCESSOR_EV5;
+	  target_flags |= MASK_BWX | MASK_MAX;
+	  target_flags &= ~ MASK_CIX;
+	}
+      else if (! strcmp (alpha_cpu_string, "ev6")
+	       || ! strcmp (alpha_cpu_string, "21264"))
+	{
+	  alpha_cpu = PROCESSOR_EV6;
+	  target_flags |= MASK_BWX | MASK_CIX | MASK_MAX;
 	}
       else
 	error ("bad value `%s' for -mcpu switch", alpha_cpu_string);
@@ -476,7 +500,7 @@ input_operand (op, mode)
 	return 1;
       /* ... fall through ... */
     case MEM:
-      return ((TARGET_BYTE_OPS || (mode != HImode && mode != QImode))
+      return ((TARGET_BWX || (mode != HImode && mode != QImode))
 	      && general_operand (op, mode));
 
     case CONST_DOUBLE:
@@ -1162,7 +1186,7 @@ alpha_adjust_cost (insn, link, dep_insn, cost)
   /* EV5 costs are as given in alpha.md; exceptions are given here. */
   if (alpha_cpu == PROCESSOR_EV5)
     {
-      /* And the lord DEC sayeth:  "A special bypass provides an effective
+      /* And the lord DEC saith:  "A special bypass provides an effective
 	 latency of 0 cycles for an ICMP or ILOG insn producing the test
 	 operand of an IBR or CMOV insn." */
       if (recog_memoized (dep_insn) >= 0
@@ -1312,12 +1336,12 @@ print_operand (file, x, code)
 
     case ',':
       /* Generates single precision instruction suffix.  */
-      fprintf (file, "%c", (TARGET_FLOAT_VAX?'f':'s'));
+      fprintf (file, "%c", (TARGET_FLOAT_VAX ? 'f' : 's'));
       break;
 
     case '-':
       /* Generates double precision instruction suffix.  */
-      fprintf (file, "%c", (TARGET_FLOAT_VAX?'g':'t'));
+      fprintf (file, "%c", (TARGET_FLOAT_VAX ? 'g' : 't'));
       break;
 
     case 'r':
@@ -1544,9 +1568,9 @@ alpha_builtin_saveregs (arglist)
 
   /* Compute the current position into the args, taking into account
      both registers and memory.  Both of these are already included in
-     current_function_args_info.  */
+     NUM_ARGS.  */
 
-  argsize = GEN_INT (CURRENT_FUNCTION_ARGS_INFO * UNITS_PER_WORD);
+  argsize = GEN_INT (NUM_ARGS * UNITS_PER_WORD);
 
   /* For Unix, SETUP_INCOMING_VARARGS moves the starting address base up by 48,
      storing fp arg registers in the first 48 bytes, and the integer arg
@@ -1559,10 +1583,10 @@ alpha_builtin_saveregs (arglist)
 
   if (TARGET_OPEN_VMS)
     addr = plus_constant (virtual_incoming_args_rtx,
-			  CURRENT_FUNCTION_ARGS_INFO <= 5 + stdarg
+			  NUM_ARGS <= 5 + stdarg
 			  ? UNITS_PER_WORD : - 6 * UNITS_PER_WORD);
   else
-    addr = (CURRENT_FUNCTION_ARGS_INFO <= 5 + stdarg
+    addr = (NUM_ARGS <= 5 + stdarg
 	    ? plus_constant (virtual_incoming_args_rtx,
 			     6 * UNITS_PER_WORD)
 	    : plus_constant (virtual_incoming_args_rtx,
@@ -1595,10 +1619,12 @@ alpha_builtin_saveregs (arglist)
       emit_move_insn (dest, addr);
 
       if (flag_check_memory_usage)
-	emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3, dest,
-			   ptr_mode, GEN_INT (GET_MODE_SIZE (ptr_mode)),
+	emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
+			   dest, ptr_mode,
+			   GEN_INT (GET_MODE_SIZE (ptr_mode)),
 			   TYPE_MODE (sizetype),
-			   GEN_INT (MEMORY_USE_RW), QImode);
+			   GEN_INT (MEMORY_USE_RW), 
+			   TYPE_MODE (integer_type_node));
   
       /* Store the argsize as the __va_offset member.  */
       dest = change_address (block, TYPE_MODE (integer_type_node),
@@ -1607,12 +1633,13 @@ alpha_builtin_saveregs (arglist)
       emit_move_insn (dest, argsize);
 
       if (flag_check_memory_usage)
-	emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3, dest,
-			   ptr_mode,
+	emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
+			   dest, ptr_mode,
 			   GEN_INT (GET_MODE_SIZE
 				    (TYPE_MODE (integer_type_node))),
 			   TYPE_MODE (sizetype),
-			   GEN_INT (MEMORY_USE_RW), QImode);
+			   GEN_INT (MEMORY_USE_RW),
+			   TYPE_MODE (integer_type_node));
 
       /* Return the address of the va_list constructor, but don't put it in a
 	 register.  Doing so would fail when not optimizing and produce worse
@@ -1621,6 +1648,39 @@ alpha_builtin_saveregs (arglist)
     }
 }
 
+#if OPEN_VMS
+#define REG_PV 27
+#define REG_RA 26
+#else
+#define REG_RA 26
+#endif
+
+/* Find the current function's return address.
+
+   ??? It would be better to arrange things such that if we would ordinarily
+   have been a leaf function and we didn't spill the hard reg that we
+   wouldn't have to save the register in the prolog.  But it's not clear
+   how to get the right information at the right time.  */
+
+static rtx alpha_return_addr_rtx;
+
+rtx
+alpha_return_addr ()
+{
+  rtx ret;
+
+  if ((ret = alpha_return_addr_rtx) == NULL)
+    {
+      alpha_return_addr_rtx = ret = gen_reg_rtx (Pmode);
+
+      emit_insn_after (gen_rtx (SET, VOIDmode, ret,
+			        gen_rtx (REG, Pmode, REG_RA)),
+		       get_insns ());
+    }
+
+  return ret;
+}
+
 /* This page contains routines that are used to determine what the function
    prologue and epilogue code will do and write them out.  */
 
@@ -1628,9 +1688,6 @@ alpha_builtin_saveregs (arglist)
 
 #if OPEN_VMS
 
-#define REG_PV 27
-#define REG_RA 26
-
 /* These variables are used for communication between the following functions.
    They indicate various things about the current function being compiled
    that are used to tell what kind of prologue, epilogue and procedure
@@ -1861,150 +1918,6 @@ add_long_const (file, c, in_reg, out_reg, temp_reg)
 
 #if OPEN_VMS
 
-/* 
-   Quick and dirty vmskrunch routine to ensure symbols are within the
-   64 bytes limit imposed by VMS.
-
-   This is written specifically for GNAT, and may not work for C++.
-
-   This routine duplicates every symbol passed to it whether it is too
-   long or not, which is a waste of space, fix later.
-*/
-#include <string.h>
-char*
-vmskrunch (name)
-     char *name;
-{
-  char *foo;
-  int max = 60; /* Allow for the ..xx extension */
-  int len, tlen;
-
-  if (name[0] == '*')
-    return (&name[1]);
-
-  len = tlen = strlen (name);
-  foo = xstrdup (name);
-
-  /* Don't muck with the ..xx extenstion */
-  if ((foo [tlen-4] == '.') && (foo [tlen-3] == '.'))
-    {
-      max = max + 4;
-      if (tlen > max)
-	{
-	  foo [tlen-4] = 0;
-	  len = len - 4;
-	  max = max - 4;
-	}
-    }
-
-  if (len > max)
-    {
-      char *bar;
-      int i, j, slen, nlen, xlen, chopchar;
-
-      nlen = len;
-
-      /* Change all _ and . characters to spaces, if thats enough then quit.
-	 For example: "foobar__foo__bar" becomes "foobar  foo  bar" */
-
-      for (i = 0; bar = index (foo, '_'); i++)
-	*bar = ' ';
-      nlen = nlen - i;
-
-      for (i = 0; bar = index (foo, '.'); i++)
-	*bar = ' ';
-      nlen = nlen - i;
-
-      for (i = 0; bar = index (foo, '$'); i++)
-	*bar = ' ';
-      nlen = nlen - i;
-
-      /* Iteratively make blank the rightmost non-blank character on the
-	 longest leftmost substring delmited by blanks, until it's short
-	 enough. For example: "foobar  foo  bar" becomes, successively:
-	 "fooba   foo bar"
-	 "foob    foo bar"
-	 "foo     foo bar"
-	 "fo      foo bar"
-	 "fo      fo  bar"
-	 "fo      fo  ba "
-	 "f       fo  ba "
-	 "f       f   ba "
-	 "f       f   b  "
-	 etc.  */
-
-      while (nlen > max)
-	{
-	  j = 0;
-	  xlen = 0;
-
-	  while (foo[j])
-	    {
-	      /* Find first non-blank */
-	      if (foo[j])
-		for (i = j; foo[i]==' ' && foo[i]; i++)
-		  ;
-
-	      /* Find the first blank */
-	      j = i;
-	      if (foo[j])
-		for (i = j + 1; foo[i] != ' ' && foo[i]; i++)
-		  ;
-
-	      /* If this substring is the longest so far, remember the
-		 position of the character to chop off. */
-	      slen = i - j;
-	      if (slen > xlen)
-		{
-		  chopchar = i - 1;
-		  xlen = slen;
-		}
-
-	      j = i;
-	    }
-
-	  /* Try to avoid chopping uppercase suffix letters */
-	  if (isupper (foo [chopchar]))
-	    {
-	      for (i = chopchar;
-		   isupper (foo[i]) && foo[i] != ' ' && i >= 0;
-		   i--)
-		;
-	      if (islower (foo[i]))
-		chopchar = i;
-	    }
-	  foo [chopchar] = ' ';
-	  nlen--;
-	}
-
-      /* Put the ..xx extension back */
-      if (len != tlen)
-	{
-	  foo [len] = '.';
-	  len = len + 4;
-	}
-
-      /* Collapse all the blanks */
-      j = 0;
-      for (i = 0; foo[i]; i++)
-	if (foo[i] != ' ')
-	  foo[j++] = foo[i];
-      foo[j] = 0;
-
-      return foo;
-    }
-
-  /* Put back the ..xx extension */
-  if (len != tlen)
-    {
-      foo [len] = '.';
-      len = len + 4;
-    }
-
-  free (foo);
-  return name;
-}
-
 /* On vms we have two kinds of functions:
 
    - stack frame (PROC_STACK)
@@ -2035,7 +1948,7 @@ output_prolog (file, size)
   /* Offset during register save.  */
   int reg_offset;
   /* Label for the procedure entry.  */
-  char entry_label[70];
+  char *entry_label = (char *) alloca (strlen (alpha_function_name) + 5);
   int i;
 
   sa_size = alpha_sa_size ();
@@ -2048,7 +1961,7 @@ output_prolog (file, size)
   fprintf (file, "\t.ent ");
   assemble_name (file, alpha_function_name);
   fprintf (file, "\n");
-  sprintf (entry_label, "%.64s..en", alpha_function_name);
+  sprintf (entry_label, "%s..en", alpha_function_name);
   ASM_OUTPUT_LABEL (file, entry_label);
   inside_function = TRUE;
 
@@ -2170,8 +2083,18 @@ output_prolog (file, size)
 	     STACK_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM);
 
   /* Describe our frame.  */
-  fprintf (file, "\t.frame $%d,%d,$26,%d\n", 
-	   unwind_regno, frame_size, rsa_offset);
+  fprintf (file, "\t.frame $%d,", unwind_regno);
+
+  /* If the frame size is larger than an integer, print it as zero to
+     avoid an assembler error.  We won't be properly describing such a
+     frame, but that's the best we can do.  */
+  fprintf (file, HOST_WIDE_INT_PRINT_DEC,
+#if HOST_BITS_PER_WIDE_INT == 64
+	   frame_size >= (1l << 31) ? 0:
+#endif
+	   frame_size
+	   );
+  fprintf (file, ",$26,%d\n", rsa_offset);
 
   /* If we have to allocate space for outgoing args, do it now.  */
   if (current_function_outgoing_args_size != 0)
@@ -2296,6 +2219,19 @@ output_epilog (file, size)
 
   /* Show that we know this function if it is called again.  */
   SYMBOL_REF_FLAG (XEXP (DECL_RTL (current_function_decl), 0)) = 1;
+
+  alpha_return_addr_rtx = 0;
+}
+
+int
+vms_valid_decl_attribute_p (decl, attributes, identifier, args)
+     tree decl;
+     tree attributes;
+     tree identifier;
+     tree args;
+{
+  if (is_attribute_p ("overlaid", identifier))
+    return (args == NULL_TREE);
 }
 
 #else /* !OPEN_VMS */
@@ -2303,7 +2239,7 @@ output_epilog (file, size)
 void
 output_prolog (file, size)
      FILE *file;
-     int size;
+     HOST_WIDE_INT size;
 {
   HOST_WIDE_INT out_args_size
     = ALPHA_ROUND (current_function_outgoing_args_size);
@@ -2458,10 +2394,20 @@ output_prolog (file, size)
   /* Describe our frame.  */
   if (!flag_inhibit_size_directive)
     {
-      fprintf (file, "\t.frame $%d,%d,$26,%d\n", 
+      fprintf (file, "\t.frame $%d,",
 	       (frame_pointer_needed
-	        ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM),
-	       frame_size, current_function_pretend_args_size);
+	        ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM));
+
+      /* If the frame size is larger than an integer, print it as zero to
+	 avoid an assembler error.  We won't be properly describing such a
+	 frame, but that's the best we can do.  */
+      fprintf (file, HOST_WIDE_INT_PRINT_DEC,
+#if HOST_BITS_PER_WIDE_INT == 64
+	       frame_size >= (1l << 31) ? 0 :
+#endif
+	       frame_size
+	       );
+      fprintf (file, ",$26,%d\n", current_function_pretend_args_size);
     }
     
   /* Save register 26 if any other register needs to be saved.  */
@@ -2485,8 +2431,15 @@ output_prolog (file, size)
 
   /* Print the register mask and do floating-point saves.  */
   if (reg_mask && !flag_inhibit_size_directive)
-    fprintf (file, "\t.mask 0x%x,%d\n", reg_mask,
-	     actual_start_reg_offset - frame_size);
+    {
+      fprintf (file, "\t.mask 0x%x,", reg_mask);
+      fprintf (file, HOST_WIDE_INT_PRINT_DEC,
+#if HOST_BITS_PER_WIDE_INT == 64
+	       frame_size >= (1l << 31) ? 0 :
+#endif
+	       actual_start_reg_offset - frame_size);
+      fprintf (file, "\n");
+    }
 
   start_reg_offset = reg_offset;
   reg_mask = 0;
@@ -2618,6 +2571,8 @@ output_epilog (file, size)
 
   /* Show that we know this function if it is called again.  */
   SYMBOL_REF_FLAG (XEXP (DECL_RTL (current_function_decl), 0)) = 1;
+
+  alpha_return_addr_rtx = 0;
 }
 #endif /* !OPEN_VMS */
 
@@ -2678,7 +2633,7 @@ alpha_output_filename (stream, name)
     }
 
   else if (name != current_function_file
-      && strcmp (name, current_function_file) != 0)
+	   && strcmp (name, current_function_file) != 0)
     {
       if (inside_function && ! TARGET_GAS)
 	fprintf (stream, "\t#.file\t%d ", num_source_filenames);
@@ -3057,46 +3012,39 @@ check_float_value (mode, d, overflow)
 
 #if OPEN_VMS
 
-void *
-function_arg (cum, mode, type, named)
-    CUMULATIVE_ARGS *cum;
-    enum machine_mode mode;
-    tree type;
-    int named;
+/* Return the VMS argument type corresponding to MODE.  */
+
+enum avms_arg_type
+alpha_arg_type (mode)
+     enum machine_mode mode;
 {
-  int arg;
-
-  if (mode == VOIDmode)		/* final call, return argument information  */
-    {
-      return GEN_INT (*cum);
-    }
-
-  arg = *cum & 0xff;
-
   switch (mode)
     {
-      case SFmode:
-	*cum |= (((TARGET_FLOAT_VAX)?1:4) << ((arg * 3)+8));      /* 4 = AI$K_AR_FS, IEEE single */
-        break;
-      case DFmode:
-        *cum |= (((TARGET_FLOAT_VAX)?3:5) << ((arg * 3)+8));      /* 5 = AI$K_AR_FT, IEEE double */
-        break;
-      case TFmode:
-        *cum |= (7 << ((arg * 3)+8));        /* 5 = AI$K_AR_FT, IEEE double */
-        break;
-      default:
-        break;
+    case SFmode:
+      return TARGET_FLOAT_VAX ? FF : FS;
+    case DFmode:
+      return TARGET_FLOAT_VAX ? FD : FT;
+    default:
+      return I64;
     }
-
-  return (arg < 6 && ! MUST_PASS_IN_STACK (mode, type)
-	 ? gen_rtx(REG, mode,
-		   (*cum & 0xff) + 16 + ((TARGET_FPREGS
-			  && (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT
-			      || GET_MODE_CLASS (mode) == MODE_FLOAT))
-			 * 32))
-	 : 0);
 }
 
+/* Return an rtx for an integer representing the VMS Argument Information
+   register value.  */
+
+struct rtx_def *
+alpha_arg_info_reg_val (cum)
+     CUMULATIVE_ARGS cum;
+{
+  unsigned HOST_WIDE_INT regval = cum.num_args;
+  int i;
+
+  for (i = 0; i < 6; i++)
+    regval |= ((int) cum.atypes[i]) << (i * 3 + 8);
+
+  return GEN_INT (regval);
+}
+
 /* Structure to collect function names for final output
    in link section.  */
 

gcc/config/alpha/alpha.h

@@ -80,7 +80,8 @@ Boston, MA 02111-1307, USA.  */
 
 enum processor_type
  {PROCESSOR_EV4,			/* 2106[46]{a,} */
-  PROCESSOR_EV5};			/* 21164{a,} */
+  PROCESSOR_EV5,			/* 21164{a,pc,} */
+  PROCESSOR_EV6};			/* 21264 */
 
 extern enum processor_type alpha_cpu;
 
@@ -168,14 +169,31 @@ extern enum alpha_fp_trap_mode alpha_fptm;
 #define MASK_FLOAT_VAX 512
 #define TARGET_FLOAT_VAX (target_flags & MASK_FLOAT_VAX)
 
-/* This means that the processor has byte and half word loads and stores.  */
+/* This means that the processor has byte and half word loads and stores
+   (the BWX extension).  */
 
-#define MASK_BYTE_OPS 1024
-#define TARGET_BYTE_OPS	(target_flags & MASK_BYTE_OPS)
+#define MASK_BWX 1024
+#define TARGET_BWX	(target_flags & MASK_BWX)
 
-/* This means that the processor is an EV5 or EV56.  This is defined only
-   in TARGET_CPU_DEFAULT.  */
-#define MASK_CPU_EV5 2048
+/* This means that the processor has the CIX extension.  */
+#define MASK_CIX 2048
+#define TARGET_CIX	(target_flags & MASK_CIX)
+
+/* This means that the processor has the MAX extension.  */
+#define MASK_MAX 4096
+#define TARGET_MAX	(target_flags & MASK_MAX)
+
+/* This means that the processor is an EV5, EV56, or PCA56.  This is defined
+   only in TARGET_CPU_DEFAULT.  */
+#define MASK_CPU_EV5 8192
+
+/* Likewise for EV6.  */
+#define MASK_CPU_EV6 16384
+
+/* This means we support the .arch directive in the assembler.  Only
+   defined in TARGET_CPU_DEFAULT.  */
+#define MASK_SUPPORT_ARCH 32768
+#define TARGET_SUPPORT_ARCH	(target_flags & MASK_SUPPORT_ARCH)
 
 /* Macro to define tables used to set the flags.
    This is a list in braces of pairs in braces,
@@ -196,8 +214,12 @@ extern enum alpha_fp_trap_mode alpha_fptm;
     {"build-constants", MASK_BUILD_CONSTANTS},  \
     {"float-vax", MASK_FLOAT_VAX},		\
     {"float-ieee", -MASK_FLOAT_VAX},		\
-    {"byte", MASK_BYTE_OPS},			\
-    {"no-byte", -MASK_BYTE_OPS},		\
+    {"bwx", MASK_BWX},				\
+    {"no-bwx", -MASK_BWX},			\
+    {"cix", MASK_CIX},				\
+    {"no-cix", -MASK_CIX},			\
+    {"max", MASK_MAX},				\
+    {"no-max", -MASK_MAX},			\
     {"", TARGET_DEFAULT | TARGET_CPU_DEFAULT} }
 
 #define TARGET_DEFAULT MASK_FP|MASK_FPREGS
@@ -267,6 +289,23 @@ extern void override_options ();
 /* Define to enable software floating point emulation. */
 #define REAL_ARITHMETIC
 
+/* The following #defines are used when compiling the routines in
+   libgcc1.c.  Since the Alpha calling conventions require single
+   precision floats to be passed in the floating-point registers
+   (rather than in the general registers) we have to build the
+   libgcc1.c routines in such a way that they know the actual types
+   of their formal arguments and the actual types of their return
+   values.  Otherwise, gcc will generate calls to the libgcc1.c
+   routines, passing arguments in the floating-point registers,
+   but the libgcc1.c routines will expect their arguments on the
+   stack (where the Alpha calling conventions require structs &
+   unions to be passed).  */
+
+#define FLOAT_VALUE_TYPE	double
+#define INTIFY(FLOATVAL)	(FLOATVAL)
+#define FLOATIFY(INTVAL)	(INTVAL)
+#define FLOAT_ARG_TYPE		double
+
 /* Define the size of `int'.  The default is the same as the word size.  */
 #define INT_TYPE_SIZE 32
 
@@ -386,7 +425,7 @@ extern void override_options ();
 
 /* For atomic access to objects, must have at least 32-bit alignment
    unless the machine has byte operations.  */
-#define MINIMUM_ATOMIC_ALIGNMENT (TARGET_BYTE_OPS ? 8 : 32)
+#define MINIMUM_ATOMIC_ALIGNMENT (TARGET_BWX ? 8 : 32)
 
 /* Align all constants and variables to at least a word boundary so
    we can pick up pieces of them faster.  */
@@ -674,7 +713,7 @@ enum reg_class { NO_REGS, GENERAL_REGS, FLOAT_REGS, ALL_REGS,
 
 #define PREFERRED_RELOAD_CLASS(X, CLASS)		\
   (CONSTANT_P (X) && (X) != const0_rtx && (X) != CONST0_RTX (GET_MODE (X)) \
-   ? ((CLASS) == FLOAT_REGS ? NO_REGS : GENERAL_REGS)			\
+   ? ((CLASS) == FLOAT_REGS || (CLASS) == NO_REGS ? NO_REGS : GENERAL_REGS)\
    : (CLASS))
 
 /* Loading and storing HImode or QImode values to and from memory
@@ -694,7 +733,7 @@ enum reg_class { NO_REGS, GENERAL_REGS, FLOAT_REGS, ALL_REGS,
   && (((CLASS) == FLOAT_REGS						\
        && ((MODE) == SImode || (MODE) == HImode || (MODE) == QImode))	\
       || (((MODE) == QImode || (MODE) == HImode)			\
-	  && ! TARGET_BYTE_OPS && unaligned_memory_operand (IN, MODE)))) \
+	  && ! TARGET_BWX && unaligned_memory_operand (IN, MODE)))) \
  ? GENERAL_REGS								\
  : ((CLASS) == FLOAT_REGS && GET_CODE (IN) == MEM			\
     && GET_CODE (XEXP (IN, 0)) == AND) ? GENERAL_REGS			\
@@ -710,8 +749,9 @@ enum reg_class { NO_REGS, GENERAL_REGS, FLOAT_REGS, ALL_REGS,
        && (GET_CODE (SUBREG_REG (OUT)) == MEM				\
 	   || (GET_CODE (SUBREG_REG (OUT)) == REG			\
 	       && REGNO (SUBREG_REG (OUT)) >= FIRST_PSEUDO_REGISTER)))) \
-  && ((((MODE) == HImode || (MODE) == QImode) && ! TARGET_BYTE_OPS	\
-       || ((MODE) == SImode && (CLASS) == FLOAT_REGS))))		\
+  && ((((MODE) == HImode || (MODE) == QImode)				\
+       && (! TARGET_BWX || (CLASS) == FLOAT_REGS))			\
+      || ((MODE) == SImode && (CLASS) == FLOAT_REGS)))			\
  ? GENERAL_REGS								\
  : ((CLASS) == FLOAT_REGS && GET_CODE (OUT) == MEM			\
     && GET_CODE (XEXP (OUT, 0)) == AND) ? GENERAL_REGS			\
@@ -721,9 +761,10 @@ enum reg_class { NO_REGS, GENERAL_REGS, FLOAT_REGS, ALL_REGS,
  : NO_REGS)
 
 /* If we are copying between general and FP registers, we need a memory
-   location.  */
+   location unless the CIX extension is available.  */
 
-#define SECONDARY_MEMORY_NEEDED(CLASS1,CLASS2,MODE) ((CLASS1) != (CLASS2))
+#define SECONDARY_MEMORY_NEEDED(CLASS1,CLASS2,MODE) \
+ (! TARGET_CIX && (CLASS1) != (CLASS2))
 
 /* Specify the mode to be used for memory when a secondary memory
    location is needed.  If MODE is floating-point, use it.  Otherwise,
@@ -873,8 +914,9 @@ enum reg_class { NO_REGS, GENERAL_REGS, FLOAT_REGS, ALL_REGS,
 
 #define FUNCTION_VALUE(VALTYPE, FUNC)	\
   gen_rtx (REG,							\
-	   (INTEGRAL_MODE_P (TYPE_MODE (VALTYPE))		\
-	    && TYPE_PRECISION (VALTYPE) < BITS_PER_WORD) 	\
+	   ((INTEGRAL_TYPE_P (VALTYPE)				\
+	     && TYPE_PRECISION (VALTYPE) < BITS_PER_WORD)	\
+	    || POINTER_TYPE_P (VALTYPE))			\
 	   ? word_mode : TYPE_MODE (VALTYPE),			\
 	   ((TARGET_FPREGS					\
 	     && (TREE_CODE (VALTYPE) == REAL_TYPE		\
@@ -1237,16 +1279,11 @@ __enable_execute_stack (addr)						\
 /* A C expression whose value is RTL representing the value of the return
    address for the frame COUNT steps up from the current frame.
    FRAMEADDR is the frame pointer of the COUNT frame, or the frame pointer of
-   the COUNT-1 frame if RETURN_ADDR_IN_PREVIOUS_FRAME} is defined.
-
-   This definition for Alpha is broken, but is put in at the request of
-   Mike Stump.  */
+   the COUNT-1 frame if RETURN_ADDR_IN_PREVIOUS_FRAME} is defined.  */
 
 #define RETURN_ADDR_RTX(COUNT, FRAME)					\
-((COUNT == 0 && alpha_sa_size () == 0 && 0 /* not right. */)		\
- ? gen_rtx (REG, Pmode, 26)						\
- : gen_rtx (MEM, Pmode,							\
-	    memory_address (Pmode, FRAME)))
+  ((COUNT) == 0 ? alpha_return_addr() : const0_rtx)
+extern struct rtx_def *alpha_return_addr ();
 
 /* Addressing modes, and classification of registers for them.  */
 
@@ -1526,7 +1563,7 @@ extern void final_prescan_insn ();
 
 /* Define the value returned by a floating-point comparison instruction.  */
 
-#define FLOAT_STORE_FLAG_VALUE 0.5
+#define FLOAT_STORE_FLAG_VALUE (TARGET_FLOAT_VAX ? 0.5 : 2.0)
 
 /* Canonicalize a comparison from one we don't have to one we do have.  */
 
@@ -1707,9 +1744,13 @@ extern void final_prescan_insn ();
   fprintf (FILE, "\t.set noreorder\n");				\
   fprintf (FILE, "\t.set volatile\n");                          \
   fprintf (FILE, "\t.set noat\n");				\
-  fprintf (FILE, "\t.arch %s\n",				\
-	   (TARGET_BYTE_OPS ? "ev56"				\
-	    : alpha_cpu == PROCESSOR_EV4 ? "ev4" : "ev5"));	\
+  if (TARGET_SUPPORT_ARCH)					\
+    fprintf (FILE, "\t.arch %s\n",				\
+             alpha_cpu == PROCESSOR_EV6 ? "ev6"			\
+	     : (alpha_cpu == PROCESSOR_EV5			\
+		? (TARGET_MAX ? "pca56" : TARGET_BWX ? "ev56" : "ev5") \
+		: "ev4"));					\
+								\
   ASM_OUTPUT_SOURCE_FILENAME (FILE, main_input_filename);	\
 }
 
@@ -2244,11 +2285,12 @@ do {							\
 #else
 /* In OSF/1 v3.2c, the assembler by default does not output file names which
    causes mips-tfile to fail.  Passing -g to the assembler fixes this problem.
-   ??? Stricly speaking, we only need -g if the user specifies -g.  Passing
+   ??? Strictly speaking, we need -g only if the user specifies -g.  Passing
    it always means that we get slightly larger than necessary object files
    if the user does not specify -g.  If we don't pass -g, then mips-tfile
-   will need to be fixed to work in this case.  */
-#define ASM_SPEC "%{!mgas:-g} -nocpp %{pg}"
+   will need to be fixed to work in this case.  Pass -O0 since some
+   optimization are broken and don't help us anyway.  */
+#define ASM_SPEC "%{!mgas:-g} -nocpp %{pg} -O0"
 #endif
 
 /* Specify to run a post-processor, mips-tfile after the assembler

gcc/config/alpha/alpha.md

@@ -24,7 +24,7 @@
 ;; Processor type -- this attribute must exactly match the processor_type
 ;; enumeration in alpha.h.
 
-(define_attr "cpu" "ev4,ev5"
+(define_attr "cpu" "ev4,ev5,ev6"
   (const (symbol_ref "alpha_cpu")))
 
 ;; Define an insn type attribute.  This is used in function unit delay
@@ -37,7 +37,7 @@
   (const_string "iadd"))
 
 ;; The TRAP_TYPE attribute marks instructions that may generate traps
-;; (which are imprecise and may need a trapb if software complention
+;; (which are imprecise and may need a trapb if software completion
 ;; is desired).
 (define_attr "trap" "yes,no" (const_string "no"))
 
@@ -120,90 +120,90 @@
   126 118)
 
 ;; EV5 scheduling.  EV5 can issue 4 insns per clock.
-;; Multiply all costs by 4.
+;; Multiply all costs by 4.  We consider the EV6 and EV5 for now.
 
 ;; EV5 has two integer units.
 (define_function_unit "ev5_ebox" 2 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "iadd,ilog,icmp,ldsym"))
   4 4)
 
 ;; Memory takes at least 2 clocks.
 ;; Conditional moves always take 2 ticks.
 (define_function_unit "ev5_ebox" 2 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "ld,cmov"))
   8 4)
 
 ;; Loads can dual issue.  Store cannot; nor can loads + stores.
 ;; Model this with a mythical load/store unit.
 (define_function_unit "ev5_ldst" 1 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "ld"))
   8 4 [(eq_attr "type" "st")])
 
 (define_function_unit "ev5_ldst" 1 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "st"))
   4 4)
 
 (define_function_unit "ev5_ebox" 2 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "imull"))
   32 4)
 
 (define_function_unit "ev5_ebox" 2 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "imulq"))
   48 4)
 
 ;; Multiplies also use the integer multiplier.
 (define_function_unit "ev5_imult" 1 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "imull"))
   16 8)
 
 (define_function_unit "ev5_imult" 1 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "imulq"))
   48 32)
 
 ;; There is only 1 shifter/zapper.
 (define_function_unit "ev5_shift" 1 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "shift"))
   4 4)
 
 ;; We pretend EV5 has symmetrical 2 fpus,
 ;; even though cpys is the only insn that can issue on either unit.
 (define_function_unit "ev5_fpu" 2 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "fadd,fmul,fcpys"))
   16 4)
   
 ;; Multiplies (resp. adds) also use the fmul (resp. fadd) units.
 (define_function_unit "ev5_fpmul" 1 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "fmul"))
   16 4)
 
 (define_function_unit "ev5_fpadd" 1 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "fadd"))
   16 4)
 
 (define_function_unit "ev5_fpadd" 1 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "fbr"))
   4 4)
 
 (define_function_unit "ev5_fpadd" 1 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "fdivs"))
   60 4)
 
 (define_function_unit "ev5_fpadd" 1 0
-  (and (eq_attr "cpu" "ev5")
+  (and (eq_attr "cpu" "ev5,ev6")
        (eq_attr "type" "fdivt"))
   88 4)
 
@@ -805,7 +805,7 @@
 (define_insn ""
   [(set (match_operand:SI 0 "register_operand" "=r,r")
 	(zero_extend:SI (match_operand:QI 1 "nonimmediate_operand" "r,m")))]
-  "TARGET_BYTE_OPS"
+  "TARGET_BWX"
   "@
    zapnot %1,1,%0
    ldbu %0,%1"
@@ -814,7 +814,7 @@
 (define_insn ""
   [(set (match_operand:SI 0 "register_operand" "=r")
 	(zero_extend:SI (match_operand:QI 1 "register_operand" "r")))]
-  "! TARGET_BYTE_OPS"
+  "! TARGET_BWX"
   "zapnot %1,1,%0"
   [(set_attr "type" "shift")])
 
@@ -827,7 +827,7 @@
 (define_insn ""
   [(set (match_operand:DI 0 "register_operand" "=r,r")
 	(zero_extend:DI (match_operand:QI 1 "nonimmediate_operand" "r,m")))]
-  "TARGET_BYTE_OPS"
+  "TARGET_BWX"
   "@
    zapnot %1,1,%0
    ldbu %0,%1"
@@ -836,7 +836,7 @@
 (define_insn ""
   [(set (match_operand:DI 0 "register_operand" "=r")
 	(zero_extend:DI (match_operand:QI 1 "register_operand" "r")))]
-  "! TARGET_BYTE_OPS"
+  "! TARGET_BWX"
   "zapnot %1,1,%0"
   [(set_attr "type" "shift")])
   
@@ -849,7 +849,7 @@
 (define_insn ""
   [(set (match_operand:SI 0 "register_operand" "=r,r")
 	(zero_extend:SI (match_operand:HI 1 "nonimmediate_operand" "r,m")))]
-  "TARGET_BYTE_OPS"
+  "TARGET_BWX"
   "@
    zapnot %1,3,%0
    ldwu %0,%1"
@@ -858,7 +858,7 @@
 (define_insn ""
   [(set (match_operand:SI 0 "register_operand" "=r")
 	(zero_extend:SI (match_operand:HI 1 "register_operand" "r")))]
-  "! TARGET_BYTE_OPS"
+  "! TARGET_BWX"
   "zapnot %1,3,%0"
   [(set_attr "type" "shift")])
 
@@ -871,7 +871,7 @@
 (define_insn ""
   [(set (match_operand:DI 0 "register_operand" "=r,r")
 	(zero_extend:DI (match_operand:HI 1 "nonimmediate_operand" "r,m")))]
-  "TARGET_BYTE_OPS"
+  "TARGET_BWX"
   "@
    zapnot %1,3,%0
    ldwu %0,%1"
@@ -948,6 +948,30 @@
   "eqv %r1,%2,%0"
   [(set_attr "type" "ilog")])
 
+;; Handle the FFS insn if we support CIX. 
+
+(define_expand "ffsdi2"
+  [(set (match_dup 2)
+	(unspec [(match_operand:DI 1 "register_operand" "")] 1))
+   (set (match_dup 3)
+	(plus:DI (match_dup 2) (const_int 1)))
+   (set (match_operand:DI 0 "register_operand" "")
+	(if_then_else:DI (eq (match_dup 1) (const_int 0))
+			 (const_int 0) (match_dup 3)))]
+  "TARGET_CIX"
+  "
+{
+  operands[2] = gen_reg_rtx (DImode);
+  operands[3] = gen_reg_rtx (DImode);
+}")
+
+(define_insn ""
+  [(set (match_operand:DI 0 "register_operand" "=r")
+	(unspec [(match_operand:DI 1 "register_operand" "r")] 1))]
+  "TARGET_CIX"
+  "cttz %1,%0"
+  [(set_attr "type" "shift")])
+
 ;; Next come the shifts and the various extract and insert operations.
 
 (define_insn "ashldi3"
@@ -1015,7 +1039,7 @@
   ""
   "
 {
-  if (TARGET_BYTE_OPS)
+  if (TARGET_BWX)
     {
       emit_insn (gen_extendqihi2x (operands[0],
 				   force_reg (QImode, operands[1])));
@@ -1034,42 +1058,42 @@
     }
 
   operands[0] = gen_lowpart (DImode, operands[0]);
-  operands[1] = gen_lowpart (DImode, force_reg (HImode, operands[1]));
+  operands[1] = gen_lowpart (DImode, force_reg (QImode, operands[1]));
   operands[2] = gen_reg_rtx (DImode);
 }")
 
 (define_insn "extendqidi2x"
   [(set (match_operand:DI 0 "register_operand" "=r")
 	(sign_extend:DI (match_operand:QI 1 "register_operand" "r")))]
-  "TARGET_BYTE_OPS"
+  "TARGET_BWX"
   "sextb %1,%0"
   [(set_attr "type" "shift")])
 
 (define_insn "extendhidi2x"
   [(set (match_operand:DI 0 "register_operand" "=r")
 	(sign_extend:DI (match_operand:HI 1 "register_operand" "r")))]
-  "TARGET_BYTE_OPS"
+  "TARGET_BWX"
   "sextw %1,%0"
   [(set_attr "type" "shift")])
 
 (define_insn "extendqisi2x"
   [(set (match_operand:SI 0 "register_operand" "=r")
 	(sign_extend:SI (match_operand:QI 1 "register_operand" "r")))]
-  "TARGET_BYTE_OPS"
+  "TARGET_BWX"
   "sextb %1,%0"
   [(set_attr "type" "shift")])
 
 (define_insn "extendhisi2x"
   [(set (match_operand:SI 0 "register_operand" "=r")
 	(sign_extend:SI (match_operand:HI 1 "register_operand" "r")))]
-  "TARGET_BYTE_OPS"
+  "TARGET_BWX"
   "sextw %1,%0"
   [(set_attr "type" "shift")])
 
 (define_insn "extendqihi2x"
   [(set (match_operand:HI 0 "register_operand" "=r")
 	(sign_extend:HI (match_operand:QI 1 "register_operand" "r")))]
-  "TARGET_BYTE_OPS"
+  "TARGET_BWX"
   "sextb %1,%0"
   [(set_attr "type" "shift")])
 
@@ -1083,7 +1107,7 @@
   ""
   "
 {
-  if (TARGET_BYTE_OPS)
+  if (TARGET_BWX)
     {
       emit_insn (gen_extendqisi2x (operands[0],
 				   force_reg (QImode, operands[1])));
@@ -1117,7 +1141,7 @@
   "
 { extern rtx get_unaligned_address ();
 
-  if (TARGET_BYTE_OPS)
+  if (TARGET_BWX)
     {
       emit_insn (gen_extendqidi2x (operands[0],
 				   force_reg (QImode, operands[1])));
@@ -1149,7 +1173,7 @@
   ""
   "
 {
-  if (TARGET_BYTE_OPS)
+  if (TARGET_BWX)
     {
       emit_insn (gen_extendhisi2x (operands[0],
 				   force_reg (HImode, operands[1])));
@@ -1183,7 +1207,7 @@
   "
 { extern rtx get_unaligned_address ();
 
-  if (TARGET_BYTE_OPS)
+  if (TARGET_BWX)
     {
       emit_insn (gen_extendhidi2x (operands[0],
 				   force_reg (HImode, operands[1])));
@@ -1778,6 +1802,31 @@
   "sub%-%)%& %R1,%R2,%0"
   [(set_attr "type" "fadd")
    (set_attr "trap" "yes")])
+
+(define_insn "sqrtsf2"
+  [(set (match_operand:SF 0 "register_operand" "=f")
+	(sqrt:SF (match_operand:SF 1 "reg_or_fp0_operand" "fG")))]
+  "TARGET_FP && TARGET_CIX"
+  "sqrt%, %1,%0"
+  [(set_attr "type" "fdivs")
+   (set_attr "trap" "yes")])
+
+(define_insn "sqrtdf2"
+  [(set (match_operand:DF 0 "register_operand" "=f")
+	(sqrt:DF (match_operand:DF 1 "reg_or_fp0_operand" "fG")))]
+  "TARGET_FP && TARGET_CIX"
+  "sqrt%- %1,%0"
+  [(set_attr "type" "fdivt")
+   (set_attr "trap" "yes")])
+
+(define_insn ""
+  [(set (match_operand:DF 0 "register_operand" "=f")
+	(sqrt:DF (float_extend:DF
+		  (match_operand:SF 1 "reg_or_fp0_operand" "fG"))))]
+  "TARGET_FP && TARGET_CIX&& alpha_tp != ALPHA_TP_INSN"
+  "sqrt%- %1,%0"
+  [(set_attr "type" "fdivt")
+   (set_attr "trap" "yes")])
 
 ;; Next are all the integer comparisons, and conditional moves and branches
 ;; and some of the related define_expand's and define_split's.
@@ -2000,6 +2049,70 @@
 				       (match_dup 0) (match_dup 1)))]
   "")
 
+(define_insn "sminqi3"
+  [(set (match_operand:QI 0 "register_operand" "=r")
+	(smin:SI (match_operand:QI 1 "reg_or_0_operand" "%rJ")
+		 (match_operand:QI 2 "reg_or_8bit_operand" "rI")))]
+  "TARGET_MAX"
+  "minsb8 %r1,%2,%0"
+  [(set_attr "type" "shift")])
+
+(define_insn "uminqi3"
+  [(set (match_operand:QI 0 "register_operand" "=r")
+	(umin:SI (match_operand:QI 1 "reg_or_0_operand" "%rJ")
+		 (match_operand:QI 2 "reg_or_8bit_operand" "rI")))]
+  "TARGET_MAX"
+  "minub8 %r1,%2,%0"
+  [(set_attr "type" "shift")])
+
+(define_insn "smaxqi3"
+  [(set (match_operand:QI 0 "register_operand" "=r")
+	(smax:SI (match_operand:QI 1 "reg_or_0_operand" "%rJ")
+		 (match_operand:QI 2 "reg_or_8bit_operand" "rI")))]
+  "TARGET_MAX"
+  "maxsb8 %r1,%2,%0"
+  [(set_attr "type" "shift")])
+
+(define_insn "umaxqi3"
+  [(set (match_operand:QI 0 "register_operand" "=r")
+	(umax:SI (match_operand:QI 1 "reg_or_0_operand" "%rJ")
+		 (match_operand:QI 2 "reg_or_8bit_operand" "rI")))]
+  "TARGET_MAX"
+  "maxub8 %r1,%2,%0"
+  [(set_attr "type" "shift")])
+
+(define_insn "sminhi3"
+  [(set (match_operand:HI 0 "register_operand" "=r")
+	(smin:SI (match_operand:HI 1 "reg_or_0_operand" "%rJ")
+		 (match_operand:HI 2 "reg_or_8bit_operand" "rI")))]
+  "TARGET_MAX"
+  "minsw4 %r1,%2,%0"
+  [(set_attr "type" "shift")])
+
+(define_insn "uminhi3"
+  [(set (match_operand:HI 0 "register_operand" "=r")
+	(umin:SI (match_operand:HI 1 "reg_or_0_operand" "%rJ")
+		 (match_operand:HI 2 "reg_or_8bit_operand" "rI")))]
+  "TARGET_MAX"
+  "minuw4 %r1,%2,%0"
+  [(set_attr "type" "shift")])
+
+(define_insn "smaxhi3"
+  [(set (match_operand:HI 0 "register_operand" "=r")
+	(smax:SI (match_operand:HI 1 "reg_or_0_operand" "%rJ")
+		 (match_operand:HI 2 "reg_or_8bit_operand" "rI")))]
+  "TARGET_MAX"
+  "maxsw4 %r1,%2,%0"
+  [(set_attr "type" "shift")])
+
+(define_insn "umaxhi3"
+  [(set (match_operand:HI 0 "register_operand" "=r")
+	(umax:SI (match_operand:HI 1 "reg_or_0_operand" "%rJ")
+		 (match_operand:HI 2 "reg_or_8bit_operand" "rI")))]
+  "TARGET_MAX"
+  "maxuw4 %r1,%2,%0"
+  [(set_attr "type" "shift")])
+
 (define_expand "smaxdi3"
   [(set (match_dup 3)
 	(le:DI (match_operand:DI 1 "reg_or_0_operand" "")
@@ -2470,16 +2583,23 @@
   "
 {
   enum machine_mode mode;
-  enum rtx_code compare_code, branch_code;
+  enum rtx_code compare_code = EQ, branch_code = NE;
 
   if (alpha_compare_fp_p)
-    mode = DFmode, compare_code = EQ, branch_code = NE;
+    mode = DFmode;
   else
     {
-      mode = DImode, compare_code = MINUS, branch_code = EQ;
-      if (GET_CODE (alpha_compare_op1) == CONST_INT)
+      mode = DImode;
+      /* We want to use cmpeq/bne when we can, since there is a zero-delay
+	 bypass between logicals and br/cmov on the 21164.  But we don't
+	 want to force valid immediate constants into registers needlessly.  */
+      if (GET_CODE (alpha_compare_op1) == CONST_INT
+	  && ((INTVAL (alpha_compare_op1) >= -0x8000
+	       && INTVAL (alpha_compare_op1) < 0)
+	      || (INTVAL (alpha_compare_op1) > 0xff
+		  && INTVAL (alpha_compare_op1) < 0x8000)))
 	{
-	  compare_code = PLUS;
+	  compare_code = PLUS, branch_code = EQ;
 	  alpha_compare_op1 = GEN_INT (- INTVAL (alpha_compare_op1));
 	}
     }
@@ -2501,16 +2621,23 @@
   "
 {
   enum machine_mode mode;
-  enum rtx_code compare_code, branch_code;
+  enum rtx_code compare_code = EQ, branch_code = EQ;
 
   if (alpha_compare_fp_p)
-    mode = DFmode, compare_code = EQ, branch_code = EQ;
+    mode = DFmode;
   else
     {
-      mode = DImode, compare_code = MINUS, branch_code = NE;
-      if (GET_CODE (alpha_compare_op1) == CONST_INT)
+      mode = DImode;
+      /* We want to use cmpeq/bne when we can, since there is a zero-delay
+	 bypass between logicals and br/cmov on the 21164.  But we don't
+	 want to force valid immediate constants into registers needlessly.  */
+      if (GET_CODE (alpha_compare_op1) == CONST_INT
+	  && ((INTVAL (alpha_compare_op1) >= -0x8000
+	       && INTVAL (alpha_compare_op1) < 0)
+	      || (INTVAL (alpha_compare_op1) > 0xff
+		  && INTVAL (alpha_compare_op1) < 0x8000)))
 	{
-	  compare_code = PLUS;
+	  compare_code = PLUS, branch_code = NE;
 	  alpha_compare_op1 = GEN_INT (- INTVAL (alpha_compare_op1));
 	}
     }
@@ -3631,7 +3758,7 @@
 (define_insn ""
   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,r,r,r,r,m,f,f,f,m")
 	(match_operand:SI 1 "input_operand" "r,J,I,K,L,m,rJ,f,J,m,fG"))]
-  "! TARGET_WINDOWS_NT && ! TARGET_OPEN_VMS
+  "! TARGET_WINDOWS_NT && ! TARGET_OPEN_VMS && ! TARGET_CIX
    && (register_operand (operands[0], SImode)
        || reg_or_0_operand (operands[1], SImode))"
   "@
@@ -3644,16 +3771,38 @@
    stl %r1,%0
    cpys %1,%1,%0
    cpys $f31,$f31,%0
-   lds %0,%1
-   sts %R1,%0"
+   ld%, %0,%1
+   st%, %R1,%0"
   [(set_attr "type" "ilog,ilog,ilog,iadd,iadd,ld,st,fcpys,fcpys,ld,st")])
 
+(define_insn ""
+  [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,r,r,r,r,m,f,f,f,m,r,f")
+	(match_operand:SI 1 "input_operand" "r,J,I,K,L,m,rJ,f,J,m,fG,f,r"))]
+  "! TARGET_WINDOWS_NT && ! TARGET_OPEN_VMS && TARGET_CIX
+   && (register_operand (operands[0], SImode)
+       || reg_or_0_operand (operands[1], SImode))"
+  "@
+   bis %1,%1,%0
+   bis $31,$31,%0
+   bis $31,%1,%0
+   lda %0,%1
+   ldah %0,%h1
+   ldl %0,%1
+   stl %r1,%0
+   cpys %1,%1,%0
+   cpys $f31,$f31,%0
+   ld%, %0,%1
+   st%, %R1,%0
+   ftois %1,%0
+   itof%, %1,%0"
+  [(set_attr "type" "ilog,ilog,ilog,iadd,iadd,ld,st,fcpys,fcpys,ld,st,ld,st")])
+
 (define_insn ""
   [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,r,r,r,r,r,m,f,f,f,m")
 	(match_operand:SI 1 "input_operand" "r,J,I,K,L,s,m,rJ,f,J,m,fG"))]
   "(TARGET_WINDOWS_NT || TARGET_OPEN_VMS)
-	&& (register_operand (operands[0], SImode)
-			 || reg_or_0_operand (operands[1], SImode))"
+    && (register_operand (operands[0], SImode)
+        || reg_or_0_operand (operands[1], SImode))"
   "@
    bis %1,%1,%0
    bis $31,$31,%0
@@ -3665,14 +3814,14 @@
    stl %r1,%0
    cpys %1,%1,%0
    cpys $f31,$f31,%0
-   lds %0,%1
-   sts %R1,%0"
+   ld%, %0,%1
+   st%, %R1,%0"
   [(set_attr "type" "ilog,ilog,ilog,iadd,iadd,ldsym,ld,st,fcpys,fcpys,ld,st")])
 
 (define_insn ""
   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,r,f,f")
 	(match_operand:HI 1 "input_operand" "r,J,I,n,f,J"))]
-  "! TARGET_BYTE_OPS
+  "! TARGET_BWX
    && (register_operand (operands[0], HImode)
        || register_operand (operands[1], HImode))"
   "@
@@ -3687,7 +3836,7 @@
 (define_insn ""
   [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,r,r,r,m,f,f")
 	(match_operand:HI 1 "input_operand" "r,J,I,n,m,rJ,f,J"))]
-  "TARGET_BYTE_OPS
+  "TARGET_BWX
    && (register_operand (operands[0], HImode)
        || reg_or_0_operand (operands[1], HImode))"
   "@
@@ -3704,7 +3853,7 @@
 (define_insn ""
   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,r,r,f,f")
 	(match_operand:QI 1 "input_operand" "r,J,I,n,f,J"))]
-  "! TARGET_BYTE_OPS
+  "! TARGET_BWX
    && (register_operand (operands[0], QImode)
        || register_operand (operands[1], QImode))"
   "@
@@ -3719,7 +3868,7 @@
 (define_insn ""
   [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,r,r,r,m,f,f")
 	(match_operand:QI 1 "input_operand" "r,J,I,n,m,rJ,f,J"))]
-  "TARGET_BYTE_OPS
+  "TARGET_BWX
    && (register_operand (operands[0], QImode)
        || reg_or_0_operand (operands[1], QImode))"
   "@
@@ -3779,8 +3928,9 @@
 (define_insn ""
   [(set (match_operand:DI 0 "general_operand" "=r,r,r,r,r,r,r,m,f,f,f,Q")
 	(match_operand:DI 1 "input_operand" "r,J,I,K,L,s,m,rJ,f,J,Q,fG"))]
-  "register_operand (operands[0], DImode)
-   || reg_or_0_operand (operands[1], DImode)"
+  "! TARGET_CIX
+   && (register_operand (operands[0], DImode)
+       || reg_or_0_operand (operands[1], DImode))"
   "@
    bis %1,%1,%0
    bis $31,$31,%0
@@ -3796,6 +3946,29 @@
    stt %R1,%0"
   [(set_attr "type" "ilog,ilog,ilog,iadd,iadd,ldsym,ld,st,fcpys,fcpys,ld,st")])
 
+(define_insn ""
+  [(set (match_operand:DI 0 "general_operand" "=r,r,r,r,r,r,r,m,f,f,f,Q,r,f")
+	(match_operand:DI 1 "input_operand" "r,J,I,K,L,s,m,rJ,f,J,Q,fG,f,r"))]
+  "TARGET_CIX
+   && (register_operand (operands[0], DImode)
+       || reg_or_0_operand (operands[1], DImode))"
+  "@
+   bis %1,%1,%0
+   bis $31,$31,%0
+   bis $31,%1,%0
+   lda %0,%1
+   ldah %0,%h1
+   lda %0,%1
+   ldq%A1 %0,%1
+   stq%A0 %r1,%0
+   cpys %1,%1,%0
+   cpys $f31,$f31,%0
+   ldt %0,%1
+   stt %R1,%0
+   ftoit %1,%0
+   itoft %1,%0"
+  [(set_attr "type" "ilog,ilog,ilog,iadd,iadd,ldsym,ld,st,fcpys,fcpys,ld,st,ld,st")])
+
 ;; We do three major things here: handle mem->mem, put 64-bit constants in
 ;; memory, and construct long 32-bit constants.
 
@@ -4011,7 +4184,7 @@
   "
 { extern rtx get_unaligned_address ();
 
-  if (TARGET_BYTE_OPS)
+  if (TARGET_BWX)
     {
       if (GET_CODE (operands[0]) == MEM
 	  && ! reg_or_0_operand (operands[1], QImode))
@@ -4123,7 +4296,7 @@
   "
 { extern rtx get_unaligned_address ();
 
-  if (TARGET_BYTE_OPS)
+  if (TARGET_BWX)
     {
       if (GET_CODE (operands[0]) == MEM
 	  && ! reg_or_0_operand (operands[1], HImode))
@@ -4237,7 +4410,7 @@
   [(parallel [(match_operand:QI 0 "register_operand" "=r")
 	      (match_operand:QI 1 "unaligned_memory_operand" "m")
 	      (match_operand:TI 2 "register_operand" "=&r")])]
-  "! TARGET_BYTE_OPS"
+  "! TARGET_BWX"
   "
 { extern rtx get_unaligned_address ();
   rtx addr = get_unaligned_address (operands[1], 0);
@@ -4259,7 +4432,7 @@
   [(parallel [(match_operand:HI 0 "register_operand" "=r")
 	      (match_operand:HI 1 "unaligned_memory_operand" "m")
 	      (match_operand:TI 2 "register_operand" "=&r")])]
-  "! TARGET_BYTE_OPS"
+  "! TARGET_BWX"
   "
 { extern rtx get_unaligned_address ();
   rtx addr = get_unaligned_address (operands[1], 0);
@@ -4281,7 +4454,7 @@
   [(parallel [(match_operand:QI 0 "any_memory_operand" "=m")
 	      (match_operand:QI 1 "register_operand" "r")
 	      (match_operand:TI 2 "register_operand" "=&r")])]
-  "! TARGET_BYTE_OPS"
+  "! TARGET_BWX"
   "
 { extern rtx get_unaligned_address ();
 
@@ -4320,7 +4493,7 @@
   [(parallel [(match_operand:HI 0 "any_memory_operand" "=m")
 	      (match_operand:HI 1 "register_operand" "r")
 	      (match_operand:TI 2 "register_operand" "=&r")])]
-  "! TARGET_BYTE_OPS"
+  "! TARGET_BWX"
   "
 { extern rtx get_unaligned_address ();
 
@@ -4377,14 +4550,16 @@
 (define_expand "allocate_stack"
   [(set (reg:DI 30)
 	(plus:DI (reg:DI 30)
-		 (match_operand:DI 0 "reg_or_cint_operand" "")))]
+		 (match_operand:DI 1 "reg_or_cint_operand" "")))
+   (set (match_operand:DI 0 "register_operand" "=r")
+	(match_dup 2))]
   ""
   "
 {
-  if (GET_CODE (operands[0]) == CONST_INT
-	   && INTVAL (operands[0]) < 32768)
+  if (GET_CODE (operands[1]) == CONST_INT
+      && INTVAL (operands[1]) < 32768)
     {
-      if (INTVAL (operands[0]) >= 4096)
+      if (INTVAL (operands[1]) >= 4096)
 	{
 	  /* We do this the same way as in the prologue and generate explicit
 	     probes.  Then we update the stack by the constant.  */
@@ -4392,14 +4567,15 @@
 	  int probed = 4096;
 
 	  emit_insn (gen_probe_stack (GEN_INT (- probed)));
-	  while (probed + 8192 < INTVAL (operands[0]))
+	  while (probed + 8192 < INTVAL (operands[1]))
 	    emit_insn (gen_probe_stack (GEN_INT (- (probed += 8192))));
 
-	  if (probed + 4096 < INTVAL (operands[0]))
-	    emit_insn (gen_probe_stack (GEN_INT (- INTVAL(operands[0]))));
+	  if (probed + 4096 < INTVAL (operands[1]))
+	    emit_insn (gen_probe_stack (GEN_INT (- INTVAL(operands[1]))));
 	}
 
-      operands[0] = GEN_INT (- INTVAL (operands[0]));
+      operands[1] = GEN_INT (- INTVAL (operands[1]));
+      operands[2] = virtual_stack_dynamic_rtx;
     }
   else
     {
@@ -4410,10 +4586,10 @@
       rtx memref;
 
       emit_insn (gen_subdi3 (want, stack_pointer_rtx,
-			     force_reg (Pmode, operands[0])));
+			     force_reg (Pmode, operands[1])));
       emit_insn (gen_adddi3 (tmp, stack_pointer_rtx, GEN_INT (-4096)));
 
-      if (GET_CODE (operands[0]) != CONST_INT)
+      if (GET_CODE (operands[1]) != CONST_INT)
 	{
 	  out_label = gen_label_rtx ();
 	  emit_insn (gen_cmpdi (want, tmp));
@@ -4427,6 +4603,9 @@
       emit_insn (gen_adddi3 (tmp, tmp, GEN_INT(-8192)));
       emit_insn (gen_cmpdi (tmp, want));
       emit_jump_insn (gen_bgtu (loop_label));
+      if (obey_regdecls)
+	gen_rtx (USE, VOIDmode, tmp);
+
       memref = gen_rtx (MEM, DImode, want);
       MEM_VOLATILE_P (memref) = 1;
       emit_move_insn (memref, const0_rtx);
@@ -4435,7 +4614,7 @@
 	emit_label (out_label);
 
       emit_move_insn (stack_pointer_rtx, want);
-
+      emit_move_insn (operands[0], virtual_stack_dynamic_rtx);
       DONE;
     }
 }")

gcc/config/alpha/elf.h

@@ -1,5 +1,5 @@
 /* Definitions of target machine for GNU compiler, for DEC Alpha w/ELF.
-   Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
    Contributed by Richard Henderson (rth@tamu.edu).
 
 This file is part of GNU CC.
@@ -20,10 +20,10 @@ the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.    */
 
 /* This is used on Alpha platforms that use the ELF format.
-Currently only Linux uses this. */
+   Currently only GNU/Linux uses this. */
 
 #undef TARGET_VERSION
-#define TARGET_VERSION fprintf (stderr, " (Alpha Linux/ELF)");
+#define TARGET_VERSION fprintf (stderr, " (Alpha GNU/Linux with ELF)");
 
 #undef OBJECT_FORMAT_COFF
 #undef EXTENDED_COFF
@@ -39,6 +39,15 @@ Currently only Linux uses this. */
 -Asystem(linux) -Acpu(alpha) -Amachine(alpha) -D__ELF__"
 
 #undef LINK_SPEC
+#ifdef USE_GNULIBC_1
+#define LINK_SPEC "-m elf64alpha -G 8 %{O*:-O3} %{!O*:-O1}	\
+  %{shared:-shared}						\
+  %{!shared:							\
+    %{!static:							\
+      %{rdynamic:-export-dynamic}				\
+      %{!dynamic-linker:-dynamic-linker /lib/ld.so.1}}		\
+    %{static:-static}}"
+#else
 #define LINK_SPEC "-m elf64alpha -G 8 %{O*:-O3} %{!O*:-O1}	\
   %{shared:-shared}						\
   %{!shared:							\
@@ -46,6 +55,20 @@ Currently only Linux uses this. */
       %{rdynamic:-export-dynamic}				\
       %{!dynamic-linker:-dynamic-linker /lib/ld-linux.so.2}}	\
     %{static:-static}}"
+#endif
+
+#ifndef USE_GNULIBC_1
+#undef DEFAULT_VTABLE_THUNKS
+#define DEFAULT_VTABLE_THUNKS 1
+#endif
+
+#ifndef USE_GNULIBC_1
+#undef LIB_SPEC
+#define LIB_SPEC \
+  "%{shared: -lc} \
+   %{!shared: %{mieee-fp:-lieee} %{pthread:-lpthread} \
+	%{profile:-lc_p} %{!profile: -lc}}"
+#endif
 
 /* Output at beginning of assembler file.  */
 
@@ -474,8 +497,8 @@ do {									 \
 #undef PREFERRED_DEBUGGING_TYPE
 #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
 
-/* Provide a STARTFILE_SPEC appropriate for Linux.  Here we add
-   the Linux magical crtbegin.o file (see crtstuff.c) which
+/* Provide a STARTFILE_SPEC appropriate for GNU/Linux.  Here we add
+   the GNU/Linux magical crtbegin.o file (see crtstuff.c) which
    provides part of the support for getting C++ file-scope static
    object constructed before entering `main'. */
    
@@ -483,14 +506,14 @@ do {									 \
 #define STARTFILE_SPEC \
   "%{!shared: \
      %{pg:gcrt1.o%s} %{!pg:%{p:gcrt1.o%s} %{!p:crt1.o%s}}}\
-   crti.o%s %{!shared:crtbegin.o%s} %{shared:crtbeginS.o%s}"
+   crti.o%s crtbegin.o%s"
 
-/* Provide a ENDFILE_SPEC appropriate for Linux.  Here we tack on
-   the Linux magical crtend.o file (see crtstuff.c) which
+/* Provide a ENDFILE_SPEC appropriate for GNU/Linux.  Here we tack on
+   the GNU/Linux magical crtend.o file (see crtstuff.c) which
    provides part of the support for getting C++ file-scope static
    object constructed before entering `main', followed by a normal
-   Linux "finalizer" file, `crtn.o'.  */
+   GNU/Linux "finalizer" file, `crtn.o'.  */
 
 #undef	ENDFILE_SPEC
 #define ENDFILE_SPEC \
-  "%{!shared:crtend.o%s} %{shared:crtendS.o%s} crtn.o%s"
+  "crtend.o%s crtn.o%s"

gcc/config/alpha/linux.h

@@ -1,6 +1,6 @@
-/* Definitions of target machine for GNU compiler, for Alpha Linux,
-   using ECOFF.
-   Copyright (C) 1996 Free Software Foundation, Inc.
+/* Definitions of target machine for GNU compiler, for Alpha Linux-based GNU
+   systems using ECOFF.
+   Copyright (C) 1996, 1997 Free Software Foundation, Inc.
    Contributed by Bob Manson.
 
 This file is part of GNU CC.
@@ -23,7 +23,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define TARGET_DEFAULT (3 | MASK_GAS)
 
 #undef TARGET_VERSION
-#define TARGET_VERSION fprintf (stderr, " (Linux/Alpha)");
+#define TARGET_VERSION fprintf (stderr, " (GNU/Linux/Alpha)");
 
 #undef CPP_PREDEFINES
 #define CPP_PREDEFINES "\
@@ -65,6 +65,9 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 /* Show that we need a GP when profiling.  */
 #define TARGET_PROFILING_NEEDS_GP
 
+/* We support #pragma.  */
+#define HANDLE_SYSV_PRAGMA
+
 #undef ASM_FINAL_SPEC
 
 /* Emit RTL insns to initialize the variable parts of a trampoline.
@@ -77,8 +80,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
    range and so the target is in range of something on the stack. 
    Omitting the hint saves a bogus branch-prediction cache line load.
 
-   Linux always has an executable stack -- no need for a system call.
- */
+   GNU/Linux always has an executable stack -- no need for a system call. */
 
 #undef INITIALIZE_TRAMPOLINE
 #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT)                       \

gcc/config/alpha/t-linux

@@ -1,4 +1,4 @@
-# Do not build libgcc1. Let gcc generate those functions. The Linux
+# Do not build libgcc1. Let gcc generate those functions. The GNU/Linux
 # C library can handle them.
 LIBGCC1 = 
 CROSS_LIBGCC1 =

gcc/config/alpha/vms-tramp.asm

@@ -0,0 +1,22 @@
+;# New Alpha OpenVMS trampoline
+;#
+	.set noreorder
+	.set volatile
+	.set noat
+	.file 1 "tramp.s"
+.text
+	.align 3
+	.globl __tramp
+	.ent __tramp
+__tramp..en:
+
+.link
+	.align 3
+__tramp:
+	.pdesc __tramp..en,null
+.text
+	ldq $1,24($27)
+	ldq $27,16($27)
+	ldq $28,8($27)
+	jmp $31,($28),0
+	.end __tramp

gcc/config/alpha/vms.h

@@ -29,13 +29,10 @@ Boston, MA 02111-1307, USA.  */
 
 #include "alpha/alpha.h"
 
-/* Predefine this in CPP because VMS limits the size of command options
-   and GNU CPP is not used on VMS except with GNU C.  */
 #undef CPP_PREDEFINES
 #define CPP_PREDEFINES \
 "-Dalpha -D__ALPHA -Dvms -DVMS -D__alpha__ -D__alpha -D__vms__ -D__VMS__\
- -D__VMS_VER=70000022 \
- -D__GNUC__=2 -D__GNUC_MINOR__=7 -Asystem(vms) -Acpu(alpha) -Amachine(alpha)"
+ -Asystem(vms) -Acpu(alpha) -Amachine(alpha)"
 
 #undef CPP_SPEC
 #define CPP_SPEC "\
@@ -89,10 +86,7 @@ Boston, MA 02111-1307, USA.  */
 #define POINTER_SIZE 32
 #define POINTERS_EXTEND_UNSIGNED 0
 
-/* No data type wants to be aligned rounder than this. */
-#undef BIGGEST_ALIGNMENT
-#define BIGGEST_ALIGNMENT 128       /* X Complex */
-#define MAX_OFILE_ALIGNMENT 524288  /* 8 x 2^16 by DEC Test CD40VRA */
+#define MAX_OFILE_ALIGNMENT 524288  /* 8 x 2^16 by DEC Ada Test CD40VRA */
 
 #undef FIXED_REGISTERS
 #define FIXED_REGISTERS  \
@@ -127,33 +121,91 @@ Boston, MA 02111-1307, USA.  */
   if ((TO) == STACK_POINTER_REGNUM)					\
     (OFFSET) += ALPHA_ROUND (current_function_outgoing_args_size);	\
 }
+
+/* Define a data type for recording info about an argument list
+   during the scan of that argument list.  This data type should
+   hold all necessary information about the function itself
+   and about the args processed so far, enough to enable macros
+   such as FUNCTION_ARG to determine where the next arg should go.
+
+   On Alpha/VMS, this is a structure that contains the number of
+   arguments and, for each argument, the datatype of that argument.
+
+   The number of arguments is a number of words of arguments scanned so far.
+   Thus 6 or more means all following args should go on the stack.  */
+
+enum avms_arg_type {I64, FF, FD, FG, FS, FT};
+typedef struct {char num_args; enum avms_arg_type atypes[6];} avms_arg_info;
+
+#undef CUMULATIVE_ARGS
+#define CUMULATIVE_ARGS avms_arg_info
+
+/* Initialize a variable CUM of type CUMULATIVE_ARGS
+   for a call to a function whose data type is FNTYPE.
+   For a library call, FNTYPE is 0.  */
+
+#undef INIT_CUMULATIVE_ARGS
+#define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,INDIRECT) \
+  (CUM).num_args = 0;						\
+  (CUM).atypes[0] = (CUM).atypes[1] = (CUM).atypes[2] = I64;	\
+  (CUM).atypes[3] = (CUM).atypes[4] = (CUM).atypes[5] = I64;
+
+/* Update the data in CUM to advance over an argument
+   of mode MODE and data type TYPE.
+   (TYPE is null for libcalls where that information may not be available.)  */
+
+extern enum avms_arg_type alpha_arg_type ();
+
+/* Determine where to put an argument to a function.
+   Value is zero to push the argument on the stack,
+   or a hard register in which to store the argument.
+
+   MODE is the argument's machine mode (or VOIDmode for no more args).
+   TYPE is the data type of the argument (as a tree).
+    This is null for libcalls where that information may
+    not be available.
+   CUM is a variable of type CUMULATIVE_ARGS which gives info about
+    the preceding args and about the function being called.
+   NAMED is nonzero if this argument is a named parameter
+    (otherwise it is an extra parameter matching an ellipsis).
+
+   On Alpha the first 6 words of args are normally in registers
+   and the rest are pushed.  */
+
+extern struct rtx_def *alpha_arg_info_reg_val ();
+#undef FUNCTION_ARG
+#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED)	\
+((MODE) == VOIDmode ? alpha_arg_info_reg_val (CUM)		\
+ : ((CUM.num_args) < 6 && ! MUST_PASS_IN_STACK (MODE, TYPE)	\
+    ? gen_rtx(REG, (MODE),					\
+	      ((CUM).num_args + 16				\
+	       + ((TARGET_FPREGS				\
+		   && (GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
+		       || GET_MODE_CLASS (MODE) == MODE_FLOAT)) \
+		  * 32)))			\
+    : 0))
 
 #undef FUNCTION_ARG_ADVANCE
 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)			\
   if (MUST_PASS_IN_STACK (MODE, TYPE))					\
-    (CUM) = (CUM & ~0xff) + 6;						\
+    (CUM).num_args += 6;						\
   else									\
-    (CUM) += ALPHA_ARG_SIZE (MODE, TYPE, NAMED)
+    {									\
+      if ((CUM).num_args < 6)						\
+        (CUM).atypes[(CUM).num_args] = alpha_arg_type (MODE);		\
+									\
+     (CUM).num_args += ALPHA_ARG_SIZE (MODE, TYPE, NAMED);		\
+    }
+
+/* For an arg passed partly in registers and partly in memory,
+   this is the number of registers used.
+   For args passed entirely in registers or entirely in memory, zero.  */
 
 #undef FUNCTION_ARG_PARTIAL_NREGS
 #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED)		\
-((CUM & 0xff) < 6 && 6 < (CUM & 0xff)					\
+((CUM).num_args < 6 && 6 < (CUM).num_args				\
    + ALPHA_ARG_SIZE (MODE, TYPE, NAMED)					\
- ? 6 - (CUM & 0xff) : 0)
-
-extern char *vmskrunch ();
-#undef ENCODE_SECTION_INFO
-#define ENCODE_SECTION_INFO(DECL)				\
-do {								\
-  if (TREE_CODE (DECL) == FUNCTION_DECL && ! TREE_PUBLIC (DECL)) \
-    SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0)) = 1;		\
-								\
-  if (TREE_CODE_CLASS (TREE_CODE (DECL)) == 'd'			\
-      && GET_CODE (DECL_RTL (DECL)) == MEM			\
-      && GET_CODE (XEXP (DECL_RTL (DECL), 0)) == SYMBOL_REF)	\
-	XSTR (XEXP (DECL_RTL (DECL), 0), 0)			\
-	  = vmskrunch (XSTR (XEXP (DECL_RTL (DECL), 0), 0));	\
-} while (0)
+ ? 6 - (CUM).num_args : 0)
 
 /* Perform any needed actions needed for a function that is receiving a
    variable number of arguments. 
@@ -178,7 +230,7 @@ do {								\
 
 #undef SETUP_INCOMING_VARARGS
 #define SETUP_INCOMING_VARARGS(CUM,MODE,TYPE,PRETEND_SIZE,NO_RTL)	\
-{ if ((CUM) < 6)					\
+{ if ((CUM).num_args < 6)				\
     {							\
       if (! (NO_RTL))					\
 	{						\
@@ -191,12 +243,6 @@ do {								\
     }							\
 }
 
-#undef ASM_DECLARE_FUNCTION_NAME
-#define ASM_DECLARE_FUNCTION_NAME(FILE,NAME,DECL)	\
-{							\
-   alpha_function_name = vmskrunch (NAME);		\
-}
-
 #undef ASM_FILE_START
 #define ASM_FILE_START(FILE)					\
 {								\
@@ -226,11 +272,11 @@ do {								\
   }
 
 #define LINK_SECTION_ASM_OP ".link"
-
 #define READONLY_SECTION_ASM_OP ".rdata"
+#define LITERALS_SECTION_ASM_OP ".literals"
 
 #undef EXTRA_SECTIONS
-#define EXTRA_SECTIONS	in_link, in_rdata
+#define EXTRA_SECTIONS	in_link, in_rdata, in_literals
 
 #undef EXTRA_SECTION_FUNCTIONS
 #define EXTRA_SECTION_FUNCTIONS					\
@@ -251,6 +297,15 @@ link_section ()							\
       fprintf (asm_out_file, "%s\n", LINK_SECTION_ASM_OP); 	\
       in_section = in_link;					\
     }								\
+}                                                               \
+void								\
+literals_section ()						\
+{								\
+  if (in_section != in_literals)				\
+    {								\
+      fprintf (asm_out_file, "%s\n", LITERALS_SECTION_ASM_OP); 	\
+      in_section = in_literals;					\
+    }								\
 }
 
 #undef ASM_OUTPUT_ADDR_DIFF_ELT
@@ -265,10 +320,6 @@ link_section ()							\
 
 #define ASM_FILE_END(FILE) alpha_write_linkage (FILE);
 
-#undef FUNCTION_ARG
-void *function_arg ();
-#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED)	function_arg (&CUM, MODE, TYPE, NAMED)
-
 #undef CASE_VECTOR_MODE
 #define CASE_VECTOR_MODE DImode
 #undef CASE_VECTOR_PC_RELATIVE
@@ -293,80 +344,111 @@ void *function_arg ();
 {						\
   fprintf (FILE, "\t.quad 0\n");		\
   fprintf (FILE, "\t.linkage __tramp\n");	\
+  fprintf (FILE, "\t.quad 0\n");		\
 }
 
 /* Length in units of the trampoline for entering a nested function.  */
 
 #undef TRAMPOLINE_SIZE
-#define TRAMPOLINE_SIZE    24
+#define TRAMPOLINE_SIZE    32
 
 /* Emit RTL insns to initialize the variable parts of a trampoline.
    FNADDR is an RTX for the address of the function's pure code.
    CXT is an RTX for the static chain value for the function.  */
 
 #undef INITIALIZE_TRAMPOLINE
-#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT)			\
-{									\
-  emit_move_insn (gen_rtx (MEM, Pmode, (TRAMP)), (FNADDR));		\
-  emit_move_insn (gen_rtx (MEM, Pmode,					\
-			   memory_address (Pmode,			\
+#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT)			  \
+{									  \
+  emit_move_insn (gen_rtx (MEM, Pmode,                                    \
+			   memory_address (Pmode,			  \
 					   plus_constant ((TRAMP), 16))), \
-		  (CXT));						\
+		  (FNADDR));		                                  \
+  emit_move_insn (gen_rtx (MEM, Pmode,					  \
+			   memory_address (Pmode,			  \
+					   plus_constant ((TRAMP), 24))), \
+		  (CXT));						  \
 }
 
 #undef TRANSFER_FROM_TRAMPOLINE
 
+#define VALID_MACHINE_DECL_ATTRIBUTE(DECL, ATTRIBUTES, NAME, ARGS) \
+  (vms_valid_decl_attribute_p (DECL, ATTRIBUTES, NAME, ARGS))
+extern int vms_valid_decl_attribute_p ();
+
 #undef SDB_DEBUGGING_INFO
 #undef MIPS_DEBUGGING_INFO
-
-#ifndef DBX_DEBUGGING_INFO
-#define DBX_DEBUGGING_INFO
-#endif
+#undef DBX_DEBUGGING_INFO
 
 #define DWARF2_DEBUGGING_INFO
 
-#ifdef PREFERRED_DEBUGGING_TYPE
-#undef PREFERRED_DEBUGGING_TYPE
-#endif
-#define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
+/* This is how to output an assembler line
+   that says to advance the location counter
+   to a multiple of 2**LOG bytes.  */
+
+#undef ASM_OUTPUT_ALIGN
+#define ASM_OUTPUT_ALIGN(FILE,LOG)	\
+    fprintf (FILE, "\t.align %d\n", LOG);
+
+#define UNALIGNED_SHORT_ASM_OP	".word"
+#define UNALIGNED_INT_ASM_OP	".long"
+#define UNALIGNED_DOUBLE_INT_ASM_OP	".quad"
+
+#undef ASM_OUTPUT_ALIGNED_COMMON
+#define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN)		\
+do {									\
+  fprintf ((FILE), "\t.comm\t");					\
+  assemble_name ((FILE), (NAME));					\
+  fprintf ((FILE), ",%u,%u\n", (SIZE), (ALIGN) / BITS_PER_UNIT);	\
+} while (0)
+
+#define ASM_OUTPUT_SECTION(FILE,SECTION)			\
+   (strcmp (SECTION, ".text") == 0)				\
+     ? text_section ()						\
+     : named_section (NULL_TREE, SECTION, 0),			\
+       ASM_OUTPUT_ALIGN (FILE, 0)				\
+
+#define ASM_OUTPUT_SECTION_NAME(FILE,DECL,NAME,RELOC)		\
+  do								\
+    {								\
+      char *flags;					 	\
+      int ovr = 0;						\
+      if (DECL && DECL_MACHINE_ATTRIBUTES (DECL)		\
+	  && lookup_attribute					\
+	      ("overlaid", DECL_MACHINE_ATTRIBUTES (DECL)))	\
+	flags = ",OVR", ovr = 1;				\
+      else if (strncmp (NAME,".debug", 6) == 0)			\
+	flags = ",NOWRT";					\
+      else							\
+	flags = "";						\
+      fputc ('\n', (FILE));					\
+      fprintf (FILE, ".section\t%s%s\n", NAME, flags);		\
+      if (ovr)							\
+        (NAME) = "";						\
+    } while (0)
+
+#define ASM_OUTPUT_DEF(FILE,LABEL1,LABEL2)				\
+  do {	literals_section();                                             \
+	fprintf ((FILE), "\t");						\
+	assemble_name (FILE, LABEL1);					\
+	fprintf (FILE, " = ");						\
+	assemble_name (FILE, LABEL2);					\
+	fprintf (FILE, "\n");						\
+  } while (0)
+
+#undef PREFERRED_DEBUGGING_TYPE
+#define PREFERRED_DEBUGGING_TYPE DWARF2_DEBUG
 
-#ifdef ASM_FORMAT_PRIVATE_NAME
 #undef ASM_FORMAT_PRIVATE_NAME
-#endif
 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)	\
 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 12),	\
   sprintf ((OUTPUT), "%s___%d", (NAME), (LABELNO)))
 
 #undef ASM_SPEC
-#define ASM_SPEC "-nocpp %{pg}"
-
 #undef ASM_FINAL_SPEC
-
-#undef LIBGCC_SPEC
-#define LIBGCC_SPEC "-lgcc2 -lgcclib"
-
-#define OPTIMIZATION_OPTIONS                       \
-{                                                  \
-   write_symbols = PREFERRED_DEBUGGING_TYPE;       \
-   debug_info_level = (enum debug_info_level) 2;   \
-}
-
-#undef OVERRIDE_OPTIONS
-#define OVERRIDE_OPTIONS                           \
-{                                                  \
-   if (write_symbols == NO_DEBUG)                  \
-     debug_info_level = (enum debug_info_level) 0; \
-   override_options ();                            \
-}
-
 #undef LINK_SPEC
-#define LINK_SPEC "%{g3:-g3} %{g0:-g0}"
-
 #undef STARTFILE_SPEC
-#define STARTFILE_SPEC ""
-
-#undef ENDFILE_SPEC
-#define ENDFILE_SPEC "gnu:[000000]crt0.obj"
+#define ASM_SPEC "-nocpp %{pg}"
+#define LINK_SPEC "%{g3:-g3} %{g0:-g0} %{shared:-shared} %{v:-v}"
 
 /* Define the names of the division and modulus functions.  */
 #define DIVSI3_LIBCALL "ots$div_i"

gcc/config/alpha/xm-alpha.h

@@ -65,14 +65,6 @@ extern void *malloc (), *realloc (), *calloc ();
 #include "string.h"
 #endif
 
-/* OSF/1 has vprintf.  */
-
-#define HAVE_VPRINTF
-
-/* OSF/1 has putenv.  */
-
-#define HAVE_PUTENV
-
 /* OSF/1 is POSIX.1 compliant.  */
 
 #define POSIX

gcc/config/alpha/xm-vms.h

@@ -1,5 +1,5 @@
 /* Configuration for GNU C-compiler for openVMS/Alpha.
-   Copyright (C)  1996 Free Software Foundation, Inc.
+   Copyright (C) 1996, 1997 Free Software Foundation, Inc.
    Contributed by Klaus Kaempf (kkaempf@progis.de).
 
 This file is part of GNU CC.
@@ -53,7 +53,11 @@ Boston, MA 02111-1307, USA.  */
 
 /* Define a local equivalent (sort of) for unlink */
 #define unlink remove
+
 #define NEED_ATEXIT
+#define HAVE_VPRINTF
+#define HAVE_PUTENV
+#define HAVE_STRERROR
 
 #define NO_SYS_PARAMS_H		/* Don't have <sys/params.h> */
 #define NO_STAB_H		/* Don't have <stab.h> */
@@ -63,17 +67,11 @@ Boston, MA 02111-1307, USA.  */
 #define HAVE_STDLIB_H 1
 #define HAVE_UNISTD_H 1
 #define HAVE_STRING_H 1
+#define HAVE_LIMITS_H 1
+#define HAVE_STDDEF_H 1
+#define HAVE_TIME_H 1
 #define STDC_HEADERS 1
 
-/* Use ANSI/SYSV style byte manipulation routines instead of BSD ones.  */
-
-#define bcopy(s,d,n)	memcpy((d),(s),(n))
-#define bzero(d,n)	memset((d),0,(n))
-#define bcmp(l,r,n)	memcmp((l),(r),(n))
-
-#define index	strchr
-#define rindex	strrchr
-
 #if __STDC__
 extern void *alloca (size_t);
 #else
@@ -82,5 +80,3 @@ extern char *alloca (unsigned int);
 
 #define OBJECT_SUFFIX ".obj"
 #define EXECUTABLE_SUFFIX ".exe"
-#define DIR_SEPARATOR ']'
-#define PATH_SEPARATOR ','

gcc/config/arc/initfini.c

@@ -0,0 +1,157 @@
+/* .init/.fini section handling + C++ global constructor/destructor handling.
+   This file is based on crtstuff.c, sol2-crti.asm, sol2-crtn.asm.
+
+Copyright (C) 1995, 1997 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING.  If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+/* As a special exception, if you link this file with files
+   compiled with GCC to produce an executable, this does not cause
+   the resulting executable to be covered by the GNU General Public License.
+   This exception does not however invalidate any other reasons why
+   the executable file might be covered by the GNU General Public License.  */
+
+/*  Declare a pointer to void function type.  */
+typedef void (*func_ptr) (void);
+
+#ifdef CRT_INIT
+
+/* NOTE:  In order to be able to support SVR4 shared libraries, we arrange
+   to have one set of symbols { __CTOR_LIST__, __DTOR_LIST__, __CTOR_END__,
+   __DTOR_END__ } per root executable and also one set of these symbols
+   per shared library.  So in any given whole process image, we may have
+   multiple definitions of each of these symbols.  In order to prevent
+   these definitions from conflicting with one another, and in order to
+   ensure that the proper lists are used for the initialization/finalization
+   of each individual shared library (respectively), we give these symbols
+   only internal (i.e. `static') linkage, and we also make it a point to
+   refer to only the __CTOR_END__ symbol in crtfini.o and the __DTOR_LIST__
+   symbol in crtinit.o, where they are defined.  */
+
+static func_ptr __CTOR_LIST__[1] __attribute__ ((section (".ctors")))
+     = { (func_ptr) (-1) };
+
+static func_ptr __DTOR_LIST__[1] __attribute__ ((section (".dtors")))
+     = { (func_ptr) (-1) };
+
+/* Run all the global destructors on exit from the program.  */
+ 
+/* Some systems place the number of pointers in the first word of the
+   table.  On SVR4 however, that word is -1.  In all cases, the table is
+   null-terminated.  On SVR4, we start from the beginning of the list and
+   invoke each per-compilation-unit destructor routine in order
+   until we find that null.
+
+   Note that this function MUST be static.  There will be one of these
+   functions in each root executable and one in each shared library, but
+   although they all have the same code, each one is unique in that it
+   refers to one particular associated `__DTOR_LIST__' which belongs to the
+   same particular root executable or shared library file.  */
+
+static void __do_global_dtors ()
+asm ("__do_global_dtors") __attribute__ ((section (".text")));
+
+static void
+__do_global_dtors ()
+{
+  func_ptr *p;
+  for (p = __DTOR_LIST__ + 1; *p; p++)
+    (*p) ();
+}
+
+/* .init section start.
+   This must appear at the start of the .init section.  */
+
+asm ("
+	.section .init\n
+	.global init\n
+	.word 0\n
+init:\n
+	st blink,[sp,4]\n
+	st fp,[sp]\n
+	mov fp,sp\n
+	sub sp,sp,16\n
+");
+
+/* .fini section start.
+   This must appear at the start of the .init section.  */
+
+asm ("
+	.section .fini\n
+	.global fini\n
+	.word 0\n
+fini:\n
+	st blink,[sp,4]\n
+	st fp,[sp]\n
+	mov fp,sp\n
+	sub sp,sp,16\n
+	bl.nd __do_global_dtors
+");
+
+#endif /* CRT_INIT */
+
+#ifdef CRT_FINI
+
+/* Put a word containing zero at the end of each of our two lists of function
+   addresses.  Note that the words defined here go into the .ctors and .dtors
+   sections of the crtend.o file, and since that file is always linked in
+   last, these words naturally end up at the very ends of the two lists
+   contained in these two sections.  */
+
+static func_ptr __CTOR_END__[1] __attribute__ ((section (".ctors")))
+     = { (func_ptr) 0 };
+
+static func_ptr __DTOR_END__[1] __attribute__ ((section (".dtors")))
+     = { (func_ptr) 0 };
+
+/* Run all global constructors for the program.
+   Note that they are run in reverse order.  */
+
+static void __do_global_ctors ()
+asm ("__do_global_ctors") __attribute__ ((section (".text")));
+
+static void
+__do_global_ctors ()
+{
+  func_ptr *p;
+  for (p = __CTOR_END__ - 1; *p != (func_ptr) -1; p--)
+    (*p) ();
+}
+
+/* .init section end.
+   This must live at the end of the .init section.  */
+
+asm ("
+	.section .init\n
+	bl.nd __do_global_ctors
+	ld blink,[fp,4]\n
+	j.d blink\n
+	ld.a fp,[sp,16]\n
+");
+
+/* .fini section end.
+   This must live at the end of the .fini section.  */
+
+asm ("
+	.section .fini\n
+	ld blink,[fp,4]\n
+	j.d blink\n
+	ld.a fp,[sp,16]\n
+");
+
+#endif /* CRT_FINI */

gcc/config/arc/lib1funcs.asm

@@ -0,0 +1,273 @@
+; libgcc1 routines for ARC cpu.
+
+/* Copyright (C) 1995, 1997 Free Software Foundation, Inc.
+
+This file is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2, or (at your option) any
+later version.
+
+In addition to the permissions in the GNU General Public License, the
+Free Software Foundation gives you unlimited permission to link the
+compiled version of this file with other programs, and to distribute
+those programs without any restriction coming from the use of this
+file.  (The General Public License restrictions do apply in other
+respects; for example, they cover modification of the file, and
+distribution when not linked into another program.)
+
+This file is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING.  If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+/* As a special exception, if you link this library with other files,
+   some of which are compiled with GCC, to produce an executable,
+   this library does not by itself cause the resulting executable
+   to be covered by the GNU General Public License.
+   This exception does not however invalidate any other reasons why
+   the executable file might be covered by the GNU General Public License.  */
+
+#ifdef  L_mulsi3
+	.section .text
+	.align 4
+
+#ifdef __base__
+	.cpu base
+	.global ___mulsi3
+___mulsi3:
+
+/* This the simple version.
+
+  while (a) 
+    {
+      if (a & 1)
+        r += b;
+      a >>= 1;
+      b <<= 1;
+    }
+*/
+	mov r2,0		; Accumulate result here.
+.Lloop:
+	sub.f 0,r0,0		; while (a)
+	nop
+	beq.nd .Ldone
+	and.f 0,r0,1		; if (a & 1)
+	add.nz r2,r2,r1		; r += b
+	lsr r0,r0		; a >>= 1
+	b.d .Lloop
+	lsl r1,r1		; b <<= 1
+.Ldone:
+	j.d blink
+	mov r0,r2
+#endif
+
+#endif /* L_mulsi3 */
+
+#ifdef  L_umulsidi3
+	.section .text
+	.align 4
+
+#ifdef __base__
+	.cpu base
+	.global ___umulsidi3
+___umulsidi3:
+
+/* This the simple version.
+
+  while (a) 
+    {
+      if (a & 1)
+        r += b;
+      a >>= 1;
+      b <<= 1;
+    }
+*/
+	mov r2,0		; Top part of b.
+	mov r3,0		; Accumulate result here.
+	mov r4,0
+.Lloop:
+	sub.f 0,r0,0		; while (a)
+	nop
+	beq.nd .Ldone
+	and.f 0,r0,1		; if (a & 1)
+	add.nz r4,r4,r1		; r += b
+	adc.nz r3,r3,r2
+	lsr r0,r0		; a >>= 1
+	lsl.f r1,r1		; b <<= 1
+	b.d .Lloop
+	rlc r2,r2
+.Ldone:
+#ifdef __big_endian__
+	mov r1,r4
+	j.d blink
+	mov r0,r3
+#else
+	mov r0,r4
+	j.d blink
+	mov r1,r3
+#endif
+#endif
+
+#endif /* L_umulsidi3 */
+
+#ifdef L_divmod_tools
+
+; Utilities used by all routines.
+
+	.section .text
+	.align 4
+
+; inputs: r0 = numerator, r1 = denominator
+; outputs: positive r0/r1,
+;          r6.bit1 = sign of numerator, r6.bit0 = sign of result
+
+	.global ___divnorm
+___divnorm:
+	mov r6,0		; keep sign in r6
+	sub.f 0,r0,0		; is numerator -ve?
+	sub.lt r0,0,r0		; negate numerator
+	mov.lt r6,3		; sign is -ve
+	sub.f 0,r1,0		; is denominator -ve?
+	sub.lt r1,0,r1		; negate denominator
+	xor.lt r6,r6,1		; toggle sign
+	j.nd blink
+
+/*
+unsigned long
+udivmodsi4(int modwanted, unsigned long num, unsigned long den)
+{
+  unsigned long bit = 1;
+  unsigned long res = 0;
+
+  while (den < num && bit && !(den & (1L<<31)))
+    {
+      den <<=1;
+      bit <<=1;
+    }
+  while (bit)
+    {
+      if (num >= den)
+	{
+	  num -= den;
+	  res |= bit;
+	}
+      bit >>=1;
+      den >>=1;
+    }
+  if (modwanted) return num;
+  return res;
+}
+*/
+
+; inputs: r0 = numerator, r1 = denominator
+; outputs: r0 = quotient, r1 = remainder, r2/r3 trashed
+
+	.global ___udivmodsi4
+___udivmodsi4:
+	mov r2,1		; bit = 1
+	mov r3,0		; res = 0
+.Lloop1:
+	sub.f 0,r1,r0		; while (den < num
+	nop
+	bnc.nd .Lloop2
+	sub.f 0,r2,0		; && bit
+	nop
+	bz.nd .Lloop2
+	lsl.f 0,r1		; && !(den & (1<<31))
+	nop
+	bc.nd .Lloop2
+	lsl r1,r1		; den <<= 1
+	b.d .Lloop1
+	lsl r2,r2		; bit <<= 1
+.Lloop2:
+	sub.f 0,r2,0		; while (bit)
+	nop
+	bz.nd .Ldivmodend
+	sub.f 0,r0,r1		; if (num >= den)
+	nop
+	bc.nd .Lshiftdown
+	sub r0,r0,r1		; num -= den
+	or r3,r3,r2		; res |= bit
+.Lshiftdown:
+	lsr r2,r2		; bit >>= 1
+	b.d .Lloop2
+	lsr r1,r1		; den >>= 1
+.Ldivmodend:
+	mov r1,r0		; r1 = mod
+	j.d blink
+	mov r0,r3		; r0 = res
+
+#endif
+
+#ifdef  L_udivsi3
+	.section .text
+	.align 4
+
+#ifdef __base__
+	.cpu base
+	.global ___udivsi3
+___udivsi3:
+	mov r7,blink
+	bl.nd ___udivmodsi4
+	j.nd r7
+#endif
+
+#endif /* L_udivsi3 */
+
+#ifdef  L_divsi3
+	.section .text
+	.align 4
+
+#ifdef __base__
+	.cpu base
+	.global ___divsi3
+___divsi3:
+	mov r7,blink
+	bl.nd ___divnorm
+	bl.nd ___udivmodsi4
+	and.f 0,r6,1
+	sub.nz r0,0,r0		; cannot go in delay slot, has limm value
+	j.nd r7
+#endif
+
+#endif /* L_divsi3 */
+
+#ifdef  L_umodsi3
+	.section .text
+	.align 4
+
+#ifdef __base__
+	.cpu base
+	.global ___umodsi3
+___umodsi3:
+	mov r7,blink
+	bl.nd ___udivmodsi4
+	j.d r7
+	mov r0,r1
+#endif
+
+#endif /* L_umodsi3 */
+
+#ifdef  L_modsi3
+	.section .text
+	.align 4
+
+#ifdef __base__
+	.cpu base
+	.global ___modsi3
+___modsi3:
+	mov r7,blink
+	bl.nd ___divnorm
+	bl.nd ___udivmodsi4
+	and.f 0,r6,2
+	sub.nz r1,0,r1
+	j.d r7
+	mov r0,r1
+#endif
+
+#endif /* L_modsi3 */

gcc/config/arc/t-arc

@@ -0,0 +1,72 @@
+CROSS_LIBGCC1 = libgcc1-asm.a
+LIB1ASMSRC = arc/lib1funcs.asm
+LIB1ASMFUNCS = _mulsi3 _umulsidi3 _udivsi3 _divsi3 _umodsi3 _modsi3 _divmod_tools
+
+# We need libgcc routines to be mangled according to which cpu they
+# were compiled for.
+# ??? -mmangle-cpu passed by default for now.
+#LIBGCC2_CFLAGS = -g1 -O2 $(LIBGCC2_INCLUDES) $(GCC_CFLAGS) -mmangle-cpu
+
+# These are really part of libgcc1, but this will cause them to be
+# built correctly, so...
+
+LIB2FUNCS_EXTRA = fp-bit.c dp-bit.c
+
+dp-bit.c: $(srcdir)/config/fp-bit.c
+	echo '#ifndef __big_endian__' > dp-bit.c
+	echo '#define FLOAT_BIT_ORDER_MISMATCH' >> dp-bit.c
+	echo '#endif' >> dp-bit.c
+	cat $(srcdir)/config/fp-bit.c >> dp-bit.c
+
+fp-bit.c: $(srcdir)/config/fp-bit.c
+	echo '#define FLOAT' > fp-bit.c
+	echo '#ifndef __big_endian__' >> fp-bit.c
+	echo '#define FLOAT_BIT_ORDER_MISMATCH' >> fp-bit.c
+	echo '#endif' >> fp-bit.c
+	cat $(srcdir)/config/fp-bit.c >> fp-bit.c
+
+# .init/.fini section routines
+
+x-crtinit.o: $(srcdir)/config/arc/initfini.c $(GCC_PASSES) $(CONFIG_H)
+	$(GCC_FOR_TARGET) $(GCC_CFLAGS) $(INCLUDES) $(CRTSTUFF_T_CFLAGS) \
+	  -DCRT_INIT -finhibit-size-directive -fno-inline-functions \
+	  -g0 -c $(srcdir)/config/arc/initfini.c -o $(dir)/crtinit.o
+
+x-crtfini.o: $(srcdir)/config/arc/initfini.c $(GCC_PASSES) $(CONFIG_H)
+	$(GCC_FOR_TARGET) $(GCC_CFLAGS) $(INCLUDES) $(CRTSTUFF_T_CFLAGS) \
+	  -DCRT_FINI -finhibit-size-directive -fno-inline-functions \
+	  -g0 -c $(srcdir)/config/arc/initfini.c -o $(dir)/crtfini.o
+
+MULTILIB_OPTIONS = EB
+MULTILIB_DIRNAMES = be
+
+# We need our own versions to build multiple copies of crt*.o.
+# ??? Use new support in Makefile.
+
+LIBGCC = stmp-multilib-arc
+INSTALL_LIBGCC = install-multilib-arc
+
+stmp-multilib-arc: stmp-multilib
+	for i in `$(GCC_FOR_TARGET) --print-multi-lib`; do \
+	  dir=`echo $$i | sed -e 's/;.*$$//'`; \
+	  flags=`echo $$i | sed -e 's/^[^;]*;//' -e 's/@/ -/g'`; \
+	  $(MAKE) GCC_FOR_TARGET="$(GCC_FOR_TARGET)" \
+	    CC="$(CC)" CFLAGS="$(CFLAGS)" \
+	    HOST_PREFIX="$(HOST_PREFIX)" HOST_PREFIX_1="$(HOST_PREFIX_1)" \
+	    GCC_CFLAGS="$(GCC_CFLAGS) $${flags}" \
+	    INCLUDES="$(INCLUDES)" CRTSTUFF_T_CFLAGS=$(CRTSTUFF_T_CFLAGS) \
+	    dir="$${dir}" x-crtinit.o x-crtfini.o; \
+	  if [ $$? -eq 0 ] ; then true; else exit 1; fi; \
+	done
+	touch stmp-multilib-arc
+
+install-multilib-arc: install-multilib
+	for i in `$(GCC_FOR_TARGET) --print-multi-lib`; do \
+	  dir=`echo $$i | sed -e 's/;.*$$//'`; \
+	  rm -f $(libsubdir)/$${dir}/crtinit.o; \
+	  $(INSTALL_DATA) $${dir}/crtinit.o $(libsubdir)/$${dir}/crtinit.o; \
+	  chmod a-x $(libsubdir)/$${dir}/crtinit.o; \
+	  rm -f $(libsubdir)/$${dir}/crtfini.o; \
+	  $(INSTALL_DATA) $${dir}/crtfini.o $(libsubdir)/$${dir}/crtfini.o; \
+	  chmod a-x $(libsubdir)/$${dir}/crtfini.o; \
+	done

gcc/config/arc/xm-arc.h

@@ -0,0 +1,47 @@
+/* Configuration for GNU C-compiler for the ARC processor.
+   Copyright (C) 1994, 1997 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING.  If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+/* #defines that need visibility everywhere.  */
+#define FALSE 0
+#define TRUE 1
+
+/* This describes the machine the compiler is hosted on.  */
+#define HOST_BITS_PER_CHAR 8
+#define HOST_BITS_PER_SHORT 16
+#define HOST_BITS_PER_INT 32
+#define HOST_BITS_PER_LONG 32
+#define HOST_BITS_PER_LONGLONG 64
+
+/* Doubles are stored in memory with the high order word first.  This
+   matters when cross-compiling.  */
+#define HOST_WORDS_BIG_ENDIAN 1
+
+/* target machine dependencies.
+   tm.h is a symbolic link to the actual target specific file.   */
+#include "tm.h"
+
+/* Arguments to use with `exit'.  */
+#define SUCCESS_EXIT_CODE 0
+#define FATAL_EXIT_CODE 33
+
+/* If compiled with Sun CC, the use of alloca requires this #include.  */
+#ifndef __GNUC__
+#include "alloca.h"
+#endif

gcc/config/arm/aof.h

@@ -1,6 +1,6 @@
 /* Definitions of target machine for GNU compiler, for Advanced RISC Machines
    ARM compilation, AOF Assembler.
-   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
    Contributed by Richard Earnshaw (rearnsha@armltd.co.uk)
 
 This file is part of GNU CC.
@@ -60,12 +60,13 @@ char *aof_text_section ();
 char *aof_data_section ();
 #define DATA_SECTION_ASM_OP aof_data_section ()
 
-#define EXTRA_SECTIONS in_zero_init, in_ctor, in_dtor
+#define EXTRA_SECTIONS in_zero_init, in_ctor, in_dtor, in_common
 
 #define EXTRA_SECTION_FUNCTIONS	\
 ZERO_INIT_SECTION		\
 CTOR_SECTION			\
-DTOR_SECTION
+DTOR_SECTION			\
+COMMON_SECTION
 
 #define ZERO_INIT_SECTION					\
 void								\
@@ -118,6 +119,18 @@ dtor_section ()								\
     }									\
 }
 
+/* Used by ASM_OUTPUT_COMMON (below) to tell varasm.c that we've
+   changed areas.  */
+#define COMMON_SECTION						\
+void								\
+common_section ()						\
+{								\
+  static int common_count = 1;					\
+  if (in_section != in_common)					\
+    {								\
+      in_section = in_common;					\
+    }								\
+}
 #define CTOR_LIST_BEGIN					\
 asm (CTORS_SECTION_ASM_OP);				\
 extern func_ptr __CTOR_END__[1];			\
@@ -194,7 +207,7 @@ do {					\
 /* Some systems use __main in a way incompatible with its use in gcc, in these
    cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
    give the same symbol without quotes for an alternative entry point.  You
-   must define both, or niether. */
+   must define both, or neither. */
 #define NAME__MAIN "__gccmain"
 #define SYMBOL__MAIN __gccmain
 
@@ -277,7 +290,8 @@ do {							\
 /* Output of Uninitialized Variables */
 
 #define ASM_OUTPUT_COMMON(STREAM,NAME,SIZE,ROUNDED)		\
-  (fprintf ((STREAM), "\tAREA "),				\
+  (common_section (),						\
+   fprintf ((STREAM), "\tAREA "),				\
    assemble_name ((STREAM), (NAME)),				\
    fprintf ((STREAM), ", DATA, COMMON\n\t%% %d\t%s size=%d\n",	\
 	    (ROUNDED), ASM_COMMENT_START, SIZE))
@@ -302,7 +316,7 @@ do {							\
     arm_main_function = 1;				\
 } while (0)
 
-#define ARM_OUTPUT_LABEL(STREAM,NAME)	\
+#define ASM_OUTPUT_LABEL(STREAM,NAME)	\
 do {					\
   assemble_name (STREAM,NAME);		\
   fputs ("\n", STREAM);			\

gcc/config/arm/aout.h

@@ -114,7 +114,7 @@ do {									\
 #define ASM_DECLARE_FUNCTION_NAME(STREAM,NAME,DECL) \
     ASM_OUTPUT_LABEL(STREAM, NAME)
 
-#define ARM_OUTPUT_LABEL(STREAM,NAME)	\
+#define ASM_OUTPUT_LABEL(STREAM,NAME)	\
 do {					\
   assemble_name (STREAM,NAME);		\
   fputs (":\n", STREAM);		\
@@ -224,10 +224,15 @@ do { char dstr[30];							\
    assemble_name ((STREAM), (NAME)),		     			\
    fprintf(STREAM, ", %d\t%s %d\n", ROUNDED, ASM_COMMENT_START, SIZE))
 
-/* Output a local common block.  /bin/as can't do this, so hack a `.space' into
-   the bss segment.  Note that this is *bad* practice.  */
-#define ASM_OUTPUT_ALIGNED_LOCAL(STREAM,NAME,SIZE,ALIGN)  \
-  output_lcomm_directive (STREAM, NAME, SIZE, ALIGN)
+/* Output a local common block.  /bin/as can't do this, so hack a
+   `.space' into the bss segment.  Note that this is *bad* practice.  */
+#define ASM_OUTPUT_ALIGNED_LOCAL(STREAM,NAME,SIZE,ALIGN)		\
+  do {									\
+    bss_section ();							\
+    ASM_OUTPUT_ALIGN (STREAM, floor_log2 (ALIGN / BITS_PER_UNIT));	\
+    ASM_OUTPUT_LABEL (STREAM, NAME);					\
+    fprintf (STREAM, "\t.space\t%d\n", SIZE);				\
+  } while (0)
 
 /* Output a zero-initialized block.  */
 #define ASM_OUTPUT_ALIGNED_BSS(STREAM,DECL,NAME,SIZE,ALIGN) \

gcc/config/arm/arm.c

@@ -1,7 +1,7 @@
 /* Output routines for GCC for ARM/RISCiX.
-   Copyright (C) 1991, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1991, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
    Contributed by Pieter `Tiggr' Schoenmakers (rcpieter@win.tue.nl)
-   	      and Martin Simmons (@harleqn.co.uk).
+   and Martin Simmons (@harleqn.co.uk).
    More major hacks by Richard Earnshaw (rwe11@cl.cam.ac.uk)
 
 This file is part of GNU CC.
@@ -21,10 +21,9 @@ along with GNU CC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
     
+#include "config.h"
 #include <stdio.h>
 #include <string.h>
-#include "assert.h"
-#include "config.h"
 #include "rtl.h"
 #include "regs.h"
 #include "hard-reg-set.h"
@@ -176,7 +175,7 @@ static struct processors all_procs[] =
   {"arm600",	PROCESSOR_ARM6, FL_CO_PROC | FL_MODE32 | FL_MODE26},
   {"arm610",	PROCESSOR_ARM6, FL_MODE32 | FL_MODE26},
   {"arm7",	PROCESSOR_ARM7, FL_CO_PROC | FL_MODE32 | FL_MODE26},
-  /* arm7m doesn't exist on its own, only in conjuction with D, (and I), but
+  /* arm7m doesn't exist on its own, only in conjunction with D, (and I), but
      those don't alter the code, so it is sometimes known as the arm7m */
   {"arm7m",	PROCESSOR_ARM7, (FL_CO_PROC | FL_FAST_MULT | FL_MODE32
 				 | FL_MODE26)},
@@ -376,7 +375,8 @@ use_return_insn ()
 
   if (!reload_completed ||current_function_pretend_args_size
       || current_function_anonymous_args
-      || (get_frame_size () && !(TARGET_APCS || frame_pointer_needed)))
+      || ((get_frame_size () + current_function_outgoing_args_size != 0)
+	  && !(TARGET_APCS || frame_pointer_needed)))
     return 0;
 
   /* Can't be done if interworking with Thumb, and any registers have been
@@ -407,6 +407,13 @@ const_ok_for_arm (i)
 {
   unsigned HOST_WIDE_INT mask = ~0xFF;
 
+  /* For machines with >32 bit HOST_WIDE_INT, the bits above bit 31 must 
+     be all zero, or all one.  */
+  if ((i & ~(unsigned HOST_WIDE_INT) 0xffffffff) != 0
+      && ((i & ~(unsigned HOST_WIDE_INT) 0xffffffff) 
+	  != (((HOST_WIDE_INT) -1) & ~(unsigned HOST_WIDE_INT) 0xffffffff)))
+    return FALSE;
+  
   /* Fast return for 0 and powers of 2 */
   if ((i & (i - 1)) == 0)
     return TRUE;
@@ -1294,10 +1301,12 @@ arm_finalize_pic ()
   l1 = gen_label_rtx ();
 
   global_offset_table = gen_rtx (SYMBOL_REF, Pmode, "_GLOBAL_OFFSET_TABLE_");
+  /* The PC contains 'dot'+8, but the label L1 is on the next
+     instruction, so the offset is only 'dot'+4.  */
   pic_tmp = gen_rtx (CONST, VOIDmode, 
 		     gen_rtx (PLUS, Pmode, 
 			      gen_rtx (LABEL_REF, VOIDmode, l1),
-			      GEN_INT (8)));
+			      GEN_INT (4)));
   pic_tmp2 = gen_rtx (CONST, VOIDmode,
 		      gen_rtx (PLUS, Pmode,
 			       global_offset_table,
@@ -1501,6 +1510,17 @@ arm_rtx_costs (x, code, outer_code)
 	      + (REG_OR_SUBREG_REG (XEXP (x, 0)) ? 0 : 4)
 	      + (REG_OR_SUBREG_REG (XEXP (x, 1)) ? 0 : 4));
 
+    case TRUNCATE:
+      if (arm_fast_multiply && mode == SImode
+	  && GET_CODE (XEXP (x, 0)) == LSHIFTRT
+	  && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
+	  && (GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0))
+	      == GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)))
+	  && (GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == ZERO_EXTEND
+	      || GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == SIGN_EXTEND))
+	return 8;
+      return 99;
+
     case NEG:
       if (GET_MODE_CLASS (mode) == MODE_FLOAT)
 	return 4 + (REG_OR_SUBREG_REG (XEXP (x, 0)) ? 0 : 6);
@@ -2352,6 +2372,10 @@ load_multiple_sequence (operands, nops, regs, base, load_offset)
       rtx reg;
       rtx offset;
 
+      /* Convert a subreg of a mem into the mem itself.  */
+      if (GET_CODE (operands[nops + i]) == SUBREG)
+	operands[nops + i] = alter_subreg(operands[nops + i]);
+
       if (GET_CODE (operands[nops + i]) != MEM)
 	abort ();
 
@@ -2551,6 +2575,10 @@ store_multiple_sequence (operands, nops, regs, base, load_offset)
       rtx reg;
       rtx offset;
 
+      /* Convert a subreg of a mem into the mem itself.  */
+      if (GET_CODE (operands[nops + i]) == SUBREG)
+	operands[nops + i] = alter_subreg(operands[nops + i]);
+
       if (GET_CODE (operands[nops + i]) != MEM)
 	abort ();
 
@@ -2761,16 +2789,20 @@ arm_naked_function_p (func)
 /* Routines for use in generating RTL */
 
 rtx
-arm_gen_load_multiple (base_regno, count, from, up, write_back)
+arm_gen_load_multiple (base_regno, count, from, up, write_back, unchanging_p,
+		       in_struct_p)
      int base_regno;
      int count;
      rtx from;
      int up;
      int write_back;
+     int unchanging_p;
+     int in_struct_p;
 {
   int i = 0, j;
   rtx result;
   int sign = up ? 1 : -1;
+  rtx mem;
 
   result = gen_rtx (PARALLEL, VOIDmode,
                     rtvec_alloc (count + (write_back ? 2 : 0)));
@@ -2785,10 +2817,13 @@ arm_gen_load_multiple (base_regno, count, from, up, write_back)
 
   for (j = 0; i < count; i++, j++)
     {
-      XVECEXP (result, 0, i)
-	= gen_rtx (SET, VOIDmode, gen_rtx (REG, SImode, base_regno + j),
-		   gen_rtx (MEM, SImode,
-			    plus_constant (from, j * 4 * sign)));
+      mem = gen_rtx (MEM, SImode, plus_constant (from, j * 4 * sign));
+      RTX_UNCHANGING_P (mem) = unchanging_p;
+      MEM_IN_STRUCT_P (mem) = in_struct_p;
+
+      XVECEXP (result, 0, i) = gen_rtx (SET, VOIDmode,
+					gen_rtx (REG, SImode, base_regno + j),
+					mem);
     }
 
   if (write_back)
@@ -2798,16 +2833,20 @@ arm_gen_load_multiple (base_regno, count, from, up, write_back)
 }
 
 rtx
-arm_gen_store_multiple (base_regno, count, to, up, write_back)
+arm_gen_store_multiple (base_regno, count, to, up, write_back, unchanging_p,
+			in_struct_p)
      int base_regno;
      int count;
      rtx to;
      int up;
      int write_back;
+     int unchanging_p;
+     int in_struct_p;
 {
   int i = 0, j;
   rtx result;
   int sign = up ? 1 : -1;
+  rtx mem;
 
   result = gen_rtx (PARALLEL, VOIDmode,
                     rtvec_alloc (count + (write_back ? 2 : 0)));
@@ -2822,10 +2861,12 @@ arm_gen_store_multiple (base_regno, count, to, up, write_back)
 
   for (j = 0; i < count; i++, j++)
     {
-      XVECEXP (result, 0, i)
-	= gen_rtx (SET, VOIDmode,
-		   gen_rtx (MEM, SImode, plus_constant (to, j * 4 * sign)),
-		   gen_rtx (REG, SImode, base_regno + j));
+      mem = gen_rtx (MEM, SImode, plus_constant (to, j * 4 * sign));
+      RTX_UNCHANGING_P (mem) = unchanging_p;
+      MEM_IN_STRUCT_P (mem) = in_struct_p;
+
+      XVECEXP (result, 0, i) = gen_rtx (SET, VOIDmode, mem,
+					gen_rtx (REG, SImode, base_regno + j));
     }
 
   if (write_back)
@@ -2843,6 +2884,8 @@ arm_gen_movstrqi (operands)
   rtx src, dst;
   rtx st_src, st_dst, end_src, end_dst, fin_src, fin_dst;
   rtx part_bytes_reg = NULL;
+  rtx mem;
+  int dst_unchanging_p, dst_in_struct_p, src_unchanging_p, src_in_struct_p;
   extern int optimize;
 
   if (GET_CODE (operands[2]) != CONST_INT
@@ -2853,6 +2896,12 @@ arm_gen_movstrqi (operands)
 
   st_dst = XEXP (operands[0], 0);
   st_src = XEXP (operands[1], 0);
+
+  dst_unchanging_p = RTX_UNCHANGING_P (operands[0]);
+  dst_in_struct_p = MEM_IN_STRUCT_P (operands[0]);
+  src_unchanging_p = RTX_UNCHANGING_P (operands[1]);
+  src_in_struct_p = MEM_IN_STRUCT_P (operands[1]);
+
   fin_dst = dst = copy_to_mode_reg (SImode, st_dst);
   fin_src = src = copy_to_mode_reg (SImode, st_src);
 
@@ -2866,24 +2915,32 @@ arm_gen_movstrqi (operands)
   for (i = 0; in_words_to_go >= 2; i+=4)
     {
       if (in_words_to_go > 4)
-	emit_insn (arm_gen_load_multiple (0, 4, src, TRUE, TRUE));
+	emit_insn (arm_gen_load_multiple (0, 4, src, TRUE, TRUE,
+					  src_unchanging_p, src_in_struct_p));
       else
 	emit_insn (arm_gen_load_multiple (0, in_words_to_go, src, TRUE, 
-					  FALSE));
+					  FALSE, src_unchanging_p,
+					  src_in_struct_p));
 
       if (out_words_to_go)
 	{
 	  if (out_words_to_go > 4)
-	    emit_insn (arm_gen_store_multiple (0, 4, dst, TRUE, TRUE));
+	    emit_insn (arm_gen_store_multiple (0, 4, dst, TRUE, TRUE,
+					       dst_unchanging_p,
+					       dst_in_struct_p));
 	  else if (out_words_to_go != 1)
 	    emit_insn (arm_gen_store_multiple (0, out_words_to_go,
 					       dst, TRUE, 
 					       (last_bytes == 0
-						? FALSE : TRUE)));
+						? FALSE : TRUE),
+					       dst_unchanging_p,
+					       dst_in_struct_p));
 	  else
 	    {
-	      emit_move_insn (gen_rtx (MEM, SImode, dst),
-			      gen_rtx (REG, SImode, 0));
+	      mem = gen_rtx (MEM, SImode, dst);
+	      RTX_UNCHANGING_P (mem) = dst_unchanging_p;
+	      MEM_IN_STRUCT_P (mem) = dst_in_struct_p;
+	      emit_move_insn (mem, gen_rtx (REG, SImode, 0));
 	      if (last_bytes != 0)
 		emit_insn (gen_addsi3 (dst, dst, GEN_INT (4)));
 	    }
@@ -2898,9 +2955,16 @@ arm_gen_movstrqi (operands)
   {
     rtx sreg;
 
-    emit_move_insn (sreg = gen_reg_rtx (SImode), gen_rtx (MEM, SImode, src));
+    mem = gen_rtx (MEM, SImode, src);
+    RTX_UNCHANGING_P (mem) = src_unchanging_p;
+    MEM_IN_STRUCT_P (mem) = src_in_struct_p;
+    emit_move_insn (sreg = gen_reg_rtx (SImode), mem);
     emit_move_insn (fin_src = gen_reg_rtx (SImode), plus_constant (src, 4));
-    emit_move_insn (gen_rtx (MEM, SImode, dst), sreg);
+
+    mem = gen_rtx (MEM, SImode, dst);
+    RTX_UNCHANGING_P (mem) = dst_unchanging_p;
+    MEM_IN_STRUCT_P (mem) = dst_in_struct_p;
+    emit_move_insn (mem, sreg);
     emit_move_insn (fin_dst = gen_reg_rtx (SImode), plus_constant (dst, 4));
     in_words_to_go--;
 
@@ -2913,7 +2977,10 @@ arm_gen_movstrqi (operands)
       if (in_words_to_go < 0)
 	abort ();
 
-      part_bytes_reg = copy_to_mode_reg (SImode, gen_rtx (MEM, SImode, src));
+      mem = gen_rtx (MEM, SImode, src);
+      RTX_UNCHANGING_P (mem) = src_unchanging_p;
+      MEM_IN_STRUCT_P (mem) = src_in_struct_p;
+      part_bytes_reg = copy_to_mode_reg (SImode, mem);
     }
 
   if (BYTES_BIG_ENDIAN && last_bytes)
@@ -2930,9 +2997,10 @@ arm_gen_movstrqi (operands)
       
       while (last_bytes)
 	{
-	  emit_move_insn (gen_rtx (MEM, QImode, 
-				   plus_constant (dst, last_bytes - 1)),
-			  gen_rtx (SUBREG, QImode, part_bytes_reg, 0));
+	  mem = gen_rtx (MEM, QImode, plus_constant (dst, last_bytes - 1));
+	  RTX_UNCHANGING_P (mem) = dst_unchanging_p;
+	  MEM_IN_STRUCT_P (mem) = dst_in_struct_p;
+	  emit_move_insn (mem, gen_rtx (SUBREG, QImode, part_bytes_reg, 0));
 	  if (--last_bytes)
 	    {
 	      tmp = gen_reg_rtx (SImode);
@@ -2949,8 +3017,10 @@ arm_gen_movstrqi (operands)
 	  if (part_bytes_reg == NULL)
 	    abort ();
 
-	  emit_move_insn (gen_rtx (MEM, QImode, dst),
-			  gen_rtx (SUBREG, QImode, part_bytes_reg, 0));
+	  mem = gen_rtx (MEM, QImode, dst);
+	  RTX_UNCHANGING_P (mem) = dst_unchanging_p;
+	  MEM_IN_STRUCT_P (mem) = dst_in_struct_p;
+	  emit_move_insn (mem, gen_rtx (SUBREG, QImode, part_bytes_reg, 0));
 	  if (--last_bytes)
 	    {
 	      rtx tmp = gen_reg_rtx (SImode);
@@ -2981,7 +3051,7 @@ gen_rotated_half_load (memref)
       base = XEXP (base, 0);
     }
 
-  /* If we aren't allowed to generate unalligned addresses, then fail.  */
+  /* If we aren't allowed to generate unaligned addresses, then fail.  */
   if (TARGET_SHORT_BY_BYTES
       && ((BYTES_BIG_ENDIAN ? 1 : 0) ^ ((offset & 2) == 0)))
     return NULL;
@@ -3006,7 +3076,7 @@ select_dominance_cc_mode (op, x, y, cond_or)
 
   /* Currently we will probably get the wrong result if the individual
      comparisons are not simple.  This also ensures that it is safe to
-     reverse a comparions if necessary.  */
+     reverse a comparison if necessary.  */
   if ((arm_select_cc_mode (cond1 = GET_CODE (x), XEXP (x, 0), XEXP (x, 1))
        != CCmode)
       || (arm_select_cc_mode (cond2 = GET_CODE (y), XEXP (y, 0), XEXP (y, 1))
@@ -3122,10 +3192,10 @@ arm_select_cc_mode (op, x, y)
 	  || GET_CODE (x) == ROTATERT))
     return CC_SWPmode;
 
-  /* This is a special case, that is used by combine to alow a 
-     comarison of a shifted byte load to be split into a zero-extend
+  /* This is a special case that is used by combine to allow a 
+     comparison of a shifted byte load to be split into a zero-extend
      followed by a comparison of the shifted integer (only valid for
-     equalities and unsigned inequalites.  */
+     equalities and unsigned inequalities).  */
   if (GET_MODE (x) == SImode
       && GET_CODE (x) == ASHIFT
       && GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 24
@@ -3201,6 +3271,16 @@ arm_reload_in_hi (operands)
   rtx base = find_replacement (&XEXP (operands[1], 0));
 
   emit_insn (gen_zero_extendqisi2 (operands[2], gen_rtx (MEM, QImode, base)));
+  /* Handle the case where the address is too complex to be offset by 1.  */
+  if (GET_CODE (base) == MINUS
+      || (GET_CODE (base) == PLUS && GET_CODE (XEXP (base, 1)) != CONST_INT))
+    {
+      rtx base_plus = gen_rtx (REG, SImode, REGNO (operands[0]));
+
+      emit_insn (gen_rtx (SET, VOIDmode, base_plus, base));
+      base = base_plus;
+    }
+
   emit_insn (gen_zero_extendqisi2 (gen_rtx (SUBREG, SImode, operands[0], 0),
 				   gen_rtx (MEM, QImode, 
 					    plus_constant (base, 1))));
@@ -3454,6 +3534,7 @@ find_barrier (from, max_count)
 {
   int count = 0;
   rtx found_barrier = 0;
+  rtx last = from;
 
   while (from && count < max_count)
     {
@@ -3467,11 +3548,12 @@ find_barrier (from, max_count)
 	  && CONSTANT_POOL_ADDRESS_P (SET_SRC (PATTERN (from))))
 	{
 	  rtx src = SET_SRC (PATTERN (from));
-	  count += 2;
+	  count += 8;
 	}
       else
 	count += get_attr_length (from);
 
+      last = from;
       from = NEXT_INSN (from);
     }
 
@@ -3482,7 +3564,7 @@ find_barrier (from, max_count)
       rtx label = gen_label_rtx ();
 
       if (from)
-	from = PREV_INSN (from);
+	from = PREV_INSN (last);
       else
 	from = get_last_insn ();
 
@@ -3913,7 +3995,7 @@ output_move_double (operands)
 {
   enum rtx_code code0 = GET_CODE (operands[0]);
   enum rtx_code code1 = GET_CODE (operands[1]);
-  rtx otherops[2];
+  rtx otherops[3];
 
   if (code0 == REG)
     {
@@ -3964,7 +4046,21 @@ output_move_double (operands)
 	}
       else if (code1 == CONST_INT)
 	{
-	  /* sign extend the intval into the high-order word */
+#if HOST_BITS_PER_WIDE_INT > 32
+	  /* If HOST_WIDE_INT is more than 32 bits, the intval tells us
+	     what the upper word is.  */
+	  if (WORDS_BIG_ENDIAN)
+	    {
+	      otherops[1] = GEN_INT (ARM_SIGN_EXTEND (INTVAL (operands[1])));
+	      operands[1] = GEN_INT (INTVAL (operands[1]) >> 32);
+	    }
+	  else
+	    {
+	      otherops[1] = GEN_INT (INTVAL (operands[1]) >> 32);
+	      operands[1] = GEN_INT (ARM_SIGN_EXTEND (INTVAL (operands[1])));
+	    }
+#else
+	  /* Sign extend the intval into the high-order word */
 	  if (WORDS_BIG_ENDIAN)
 	    {
 	      otherops[1] = operands[1];
@@ -3973,6 +4069,7 @@ output_move_double (operands)
 	    }
 	  else
 	    otherops[1] = INTVAL (operands[1]) < 0 ? constm1_rtx : const0_rtx;
+#endif
 	  output_mov_immediate (otherops);
 	  output_mov_immediate (operands);
 	}
@@ -4762,10 +4859,9 @@ output_func_epilogue (f, frame_size)
 
   if (use_return_insn() && return_used_this_function)
     {
-      if (frame_size && !(frame_pointer_needed || TARGET_APCS))
-        {
-          abort ();
-        }
+      if ((frame_size + current_function_outgoing_args_size) != 0
+	  && !(frame_pointer_needed || TARGET_APCS))
+	abort ();
       goto epilogue_done;
     }
 
@@ -4853,10 +4949,11 @@ output_func_epilogue (f, frame_size)
   else
     {
       /* Restore stack pointer if necessary.  */
-      if (frame_size)
+      if (frame_size + current_function_outgoing_args_size != 0)
 	{
 	  operands[0] = operands[1] = stack_pointer_rtx;
-	  operands[2] = gen_rtx (CONST_INT, VOIDmode, frame_size);
+	  operands[2] = GEN_INT (frame_size
+				 + current_function_outgoing_args_size);
 	  output_add_immediate (operands);
 	}
 
@@ -5028,7 +5125,8 @@ void
 arm_expand_prologue ()
 {
   int reg;
-  rtx amount = GEN_INT (- get_frame_size ());
+  rtx amount = GEN_INT (-(get_frame_size ()
+			  + current_function_outgoing_args_size));
   rtx push_insn;
   int num_regs;
   int live_regs_mask = 0;
@@ -5295,34 +5393,6 @@ arm_print_operand (stream, x, code)
     }
 }
 
-/* Output a label definition.  */
-
-void
-arm_asm_output_label (stream, name)
-     FILE *stream;
-     char *name;
-{
-  ARM_OUTPUT_LABEL (stream, name);
-}
-
-/* Output code resembling an .lcomm directive.  /bin/as doesn't have this
-   directive hence this hack, which works by reserving some `.space' in the
-   bss segment directly.
-
-   XXX This is a severe hack, which is guaranteed NOT to work since it doesn't
-   define STATIC COMMON space but merely STATIC BSS space.  */
-
-void
-output_lcomm_directive (stream, name, size, align)
-     FILE *stream;
-     char *name;
-     int size, align;
-{
-  bss_section ();
-  ASM_OUTPUT_ALIGN (stream, floor_log2 (align / BITS_PER_UNIT));
-  ARM_OUTPUT_LABEL (stream, name);
-  fprintf (stream, "\t.space\t%d\n", size);
-}
 
 /* A finite state machine takes care of noticing whether or not instructions
    can be conditionally executed, and thus decrease execution time and code
@@ -5883,7 +5953,7 @@ aof_data_section ()
 
 /* The AOF assembler is religiously strict about declarations of
    imported and exported symbols, so that it is impossible to declare
-   a function as imported near the begining of the file, and then to
+   a function as imported near the beginning of the file, and then to
    export it later on.  It is, however, possible to delay the decision
    until all the functions in the file have been compiled.  To get
    around this, we maintain a list of the imports and exports, and

gcc/config/arm/arm.h

@@ -86,7 +86,7 @@ extern int frame_pointer_needed;
 #if TARGET_CPU_DEFAULT == TARGET_CPU_arm2
 #define CPP_ARCH_DEFAULT_SPEC "-D__ARM_ARCH_2__"
 #else
-#if TARGET_CPU_DEFAULT == TARGET_CPU_arm6 || TARGET_CPU_DEFUALT == TARGET_CPU_arm610 || TARGET_CPU_DEFAULT == TARGET_CPU_arm7500fe
+#if TARGET_CPU_DEFAULT == TARGET_CPU_arm6 || TARGET_CPU_DEFAULT == TARGET_CPU_arm610 || TARGET_CPU_DEFAULT == TARGET_CPU_arm7500fe
 #define CPP_ARCH_DEFAULT_SPEC "-D__ARM_ARCH_3__"
 #else
 #if TARGET_CPU_DEFAULT == TARGET_CPU_arm7m
@@ -346,7 +346,7 @@ extern char *target_fp_name;
   {"apcs-float",		ARM_FLAG_APCS_FLOAT},	\
   {"no-apcs-float",	       -ARM_FLAG_APCS_FLOAT},	\
   {"apcs-reentrant",		ARM_FLAG_APCS_REENT},	\
-  {"no-apcs-rentrant",	       -ARM_FLAG_APCS_REENT},	\
+  {"no-apcs-reentrant",	       -ARM_FLAG_APCS_REENT},	\
   {"short-load-bytes",		ARM_FLAG_SHORT_BYTE},	\
   {"no-short-load-bytes",      -ARM_FLAG_SHORT_BYTE},	\
   {"short-load-words",	       -ARM_FLAG_SHORT_BYTE},	\
@@ -437,7 +437,7 @@ extern enum floating_point_type arm_fpu;
 /* What type of floating point instructions are available */
 extern enum floating_point_type arm_fpu_arch;
 
-/* Default floating point archtitecture.  Override in sub-target if
+/* Default floating point architecture.  Override in sub-target if
    necessary.  */
 #define FP_DEFAULT FP_SOFT2
 
@@ -483,6 +483,11 @@ extern int arm_arch4;
       (MODE) = SImode;				\
     }
 
+/* Define this macro if the promotion described by `PROMOTE_MODE'
+   should also be done for outgoing function arguments.  */
+/* This is required to ensure that push insns always push a word.  */
+#define PROMOTE_FUNCTION_ARGS
+
 /* Define for XFmode extended real floating point support.
    This will automatically cause REAL_ARITHMETIC to be defined.  */
 /* For the ARM:
@@ -905,7 +910,13 @@ enum reg_class
 
 /* If we generate an insn to push BYTES bytes,
    this says how many the stack pointer really advances by.  */
-#define PUSH_ROUNDING(NPUSHED)  (((NPUSHED) + 3) & ~3)
+/* The push insns do not do this rounding implicitly.  So don't define this. */
+/* #define PUSH_ROUNDING(NPUSHED)  (((NPUSHED) + 3) & ~3) */
+
+/* Define this if the maximum size of all the outgoing args is to be
+   accumulated and pushed during the prologue.  The amount can be
+   found in the variable current_function_outgoing_args_size.  */
+#define ACCUMULATE_OUTGOING_ARGS
 
 /* Offset of first parameter from the argument pointer register value.  */
 #define FIRST_PARM_OFFSET(FNDECL)  4
@@ -1102,8 +1113,10 @@ enum reg_class
   int volatile_func = arm_volatile_func ();				\
   if ((FROM) == ARG_POINTER_REGNUM && (TO) == HARD_FRAME_POINTER_REGNUM)\
     (OFFSET) = 0;							\
-  else if ((FROM) == FRAME_POINTER_REGNUM && (TO) == STACK_POINTER_REGNUM)\
-    (OFFSET) = (get_frame_size () + 3 & ~3);				\
+  else if ((FROM) == FRAME_POINTER_REGNUM				\
+	   && (TO) == STACK_POINTER_REGNUM)				\
+    (OFFSET) = (current_function_outgoing_args_size			\
+		+ (get_frame_size () + 3 & ~3));			\
   else									\
     {									\
       int regno;							\
@@ -1125,8 +1138,10 @@ enum reg_class
 	{								\
 	   if (! frame_pointer_needed)					\
 	     offset -= 16;						\
-	   if (! volatile_func && (regs_ever_live[14] || saved_hard_reg)) \
+	   if (! volatile_func						\
+	       && (regs_ever_live[14] || saved_hard_reg)) 		\
 	     offset += 4;						\
+	   offset += current_function_outgoing_args_size;		\
 	   (OFFSET) = (get_frame_size () + 3 & ~3) + offset;		\
          }								\
     }									\
@@ -1390,14 +1405,15 @@ do									\
       else if (BASE_REGISTER_RTX_P (xop1))				\
 	GO_IF_LEGITIMATE_INDEX (MODE, REGNO (xop1), xop0, LABEL);	\
     }									\
-  else if (GET_CODE (X) == MINUS)					\
+  /* Reload currently can't handle MINUS, so disable this for now */	\
+  /* else if (GET_CODE (X) == MINUS)					\
     {									\
       rtx xop0 = XEXP (X,0);						\
       rtx xop1 = XEXP (X,1);						\
 									\
       if (BASE_REGISTER_RTX_P (xop0))					\
 	GO_IF_LEGITIMATE_INDEX (MODE, -1, xop1, LABEL);			\
-    }									\
+    } */								\
   else if (GET_MODE_CLASS (MODE) != MODE_FLOAT				\
 	   && GET_CODE (X) == SYMBOL_REF				\
 	   && CONSTANT_POOL_ADDRESS_P (X))				\
@@ -1742,27 +1758,23 @@ extern int arm_compare_fp;
   goto JUMPTO
 
 /* Output an internal label definition.  */
-#define ASM_OUTPUT_INTERNAL_LABEL(STREAM, PREFIX, NUM)  \
-  do                                    	      	   		\
-    {						      	   		\
-      char *s = (char *) alloca (40 + strlen (PREFIX));	   		\
-      extern int arm_target_label, arm_ccfsm_state;	   		\
-      extern rtx arm_target_insn;					\
-						           		\
-      if (arm_ccfsm_state == 3 && arm_target_label == (NUM)   		\
-	&& !strcmp (PREFIX, "L"))					\
-	{								\
-	  arm_ccfsm_state = 0;				        	\
-	  arm_target_insn = NULL;					\
-	}								\
-	ASM_GENERATE_INTERNAL_LABEL (s, (PREFIX), (NUM));   		\
-	arm_asm_output_label (STREAM, s);		                \
+#define ASM_OUTPUT_INTERNAL_LABEL(STREAM, PREFIX, NUM)  	\
+  do                                    	      	   	\
+    {						      	   	\
+      char *s = (char *) alloca (40 + strlen (PREFIX));	   	\
+      extern int arm_target_label, arm_ccfsm_state;	   	\
+      extern rtx arm_target_insn;				\
+						           	\
+      if (arm_ccfsm_state == 3 && arm_target_label == (NUM)   	\
+	&& !strcmp (PREFIX, "L"))				\
+	{							\
+	  arm_ccfsm_state = 0;				        \
+	  arm_target_insn = NULL;				\
+	}							\
+	ASM_GENERATE_INTERNAL_LABEL (s, (PREFIX), (NUM));   	\
+	ASM_OUTPUT_LABEL (STREAM, s);		                \
     } while (0)
 
-/* Output a label definition.  */
-#define ASM_OUTPUT_LABEL(STREAM,NAME)		\
-  arm_asm_output_label ((STREAM), (NAME))
-
 /* Output a push or a pop instruction (only used when profiling).  */
 #define ASM_OUTPUT_REG_PUSH(STREAM,REGNO) \
   fprintf(STREAM,"\tstmfd\t%ssp!,{%s%s}\n", \
@@ -1916,9 +1928,10 @@ do {									\
 	  shift += 8;							\
 	}								\
     }									\
-  fprintf (FILE, "\tldr\t%spc, [%spc, #-4]\n", REGISTER_PREFIX,		\
-	   REGISTER_PREFIX);						\
-  ASM_OUTPUT_INT (FILE, XEXP (DECL_RTL (FUNCTION), 0));			\
+  fputs ("\tb\t", FILE);						\
+  assemble_name (FILE,							\
+		 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (FUNCTION)));	\
+  fputc ('\n', FILE);							\
 } while (0)
 
 /* A C expression whose value is RTL representing the value of the return
@@ -1927,7 +1940,7 @@ do {									\
 #define RETURN_ADDR_RTX(COUNT, FRAME)	\
   ((COUNT == 0)				\
    ? gen_rtx (MEM, Pmode, plus_constant (FRAME, -4)) \
-   : (rtx) 0)
+   : NULL_RTX)
 
 /* Used to mask out junk bits from the return address, such as
    processor state, interrupt status, condition codes and the like.  */
@@ -2003,9 +2016,9 @@ int arm_valid_machine_decl_attribute (/* union tree_node *, union tree_node *,
 					 union tree_node *,
 					 union tree_node * */);
 struct rtx_def *arm_gen_load_multiple (/* int, int, struct rtx_def *, 
-					  int, int */);
+					  int, int, int, int */);
 struct rtx_def *arm_gen_store_multiple (/* int, int, struct rtx_def *,
-					   int, int */);
+					   int, int, int, int */);
 int arm_gen_movstrqi (/* struct rtx_def ** */);
 struct rtx_def *gen_rotated_half_load (/* struct rtx_def * */);
 enum machine_mode arm_select_cc_mode (/* enum rtx_code, struct rtx_def *,
@@ -2024,7 +2037,7 @@ char *output_mov_long_double_arm_from_fpu (/* struct rtx_def ** */);
 char *output_mov_long_double_arm_from_arm (/* struct rtx_def ** */);
 char *output_mov_double_fpu_from_arm (/* struct rtx_def ** */);
 char *output_mov_double_arm_from_fpu (/* struct rtx_def ** */);
-char *output_mov_double (/* struct rtx_def ** */);
+char *output_move_double (/* struct rtx_def ** */);
 char *output_mov_immediate (/* struct rtx_def ** */);
 char *output_add_immediate (/* struct rtx_def ** */);
 char *arithmetic_instr (/* struct rtx_def *, int */);
@@ -2035,8 +2048,6 @@ void output_func_prologue (/* FILE *, int */);
 void output_func_epilogue (/* FILE *, int */);
 void arm_expand_prologue (/* void */);
 void arm_print_operand (/* FILE *, struct rtx_def *, int */);
-void arm_asm_output_label (/* FILE *, char * */);
-void output_lcomm_directive (/* FILE *, char *, int, int */);
 void final_prescan_insn (/* struct rtx_def *, struct rtx_def **, int */);
 #ifdef AOF_ASSEMBLER
 struct rtx_def *aof_pic_entry (/* struct rtx_def * */);

gcc/config/arm/arm.md

@@ -1,7 +1,7 @@
 ;;- Machine description for Advanced RISC Machines' ARM for GNU compiler
-;;  Copyright (C) 1991, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+;;  Copyright (C) 1991, 93-97, 1998 Free Software Foundation, Inc.
 ;;  Contributed by Pieter `Tiggr' Schoenmakers (rcpieter@win.tue.nl)
-;;             and Martin Simmons (@harleqn.co.uk).
+;;  and Martin Simmons (@harleqn.co.uk).
 ;;  More major hacks by Richard Earnshaw (rwe11@cl.cam.ac.uk)
 
 ;; This file is part of GNU CC.
@@ -859,6 +859,34 @@
   "umull%?\\t%Q0, %R0, %1, %2"
 [(set_attr "type" "mult")])
 
+(define_insn "smulsi3_highpart"
+  [(set (match_operand:SI 0 "s_register_operand" "=&r,&r")
+	(truncate:SI
+	 (lshiftrt:DI
+	  (mult:DI (sign_extend:DI
+		    (match_operand:SI 1 "s_register_operand" "%r,0"))
+		   (sign_extend:DI
+		    (match_operand:SI 2 "s_register_operand" "r,r")))
+	  (const_int 32))))
+   (clobber (match_scratch:SI 3 "=&r,&r"))]
+  "arm_fast_multiply"
+  "smull%?\\t%3, %0, %2, %1"
+[(set_attr "type" "mult")])
+
+(define_insn "umulsi3_highpart"
+  [(set (match_operand:SI 0 "s_register_operand" "=&r,&r")
+	(truncate:SI
+	 (lshiftrt:DI
+	  (mult:DI (zero_extend:DI
+		    (match_operand:SI 1 "s_register_operand" "%r,0"))
+		   (zero_extend:DI
+		    (match_operand:SI 2 "s_register_operand" "r,r")))
+	  (const_int 32))))
+   (clobber (match_scratch:SI 3 "=&r,&r"))]
+  "arm_fast_multiply"
+  "umull%?\\t%3, %0, %2, %1"
+[(set_attr "type" "mult")])
+
 (define_insn "mulsf3"
   [(set (match_operand:SF 0 "s_register_operand" "=f")
 	(mult:SF (match_operand:SF 1 "s_register_operand" "f")
@@ -1180,7 +1208,21 @@
   "
 {
   HOST_WIDE_INT mask = (((HOST_WIDE_INT)1) << INTVAL (operands[1])) - 1;
+  rtx target, subtarget;
 
+  target = operands[0];
+  /* Avoid using a subreg as a subtarget, and avoid writing a paradoxical 
+     subreg as the final target.  */
+  if (GET_CODE (target) == SUBREG)
+    {
+      subtarget = gen_reg_rtx (SImode);
+      if (GET_MODE_SIZE (GET_MODE (SUBREG_REG (target)))
+	  < GET_MODE_SIZE (SImode))
+        target = SUBREG_REG (target);
+    }
+  else
+    subtarget = target;    
+    
   if (GET_CODE (operands[3]) == CONST_INT)
     {
       /* Since we are inserting a known constant, we may be able to
@@ -1191,7 +1233,7 @@
 			     << INTVAL (operands[2]));
 
       emit_insn (gen_andsi3 (op1, operands[0], GEN_INT (~mask2)));
-      emit_insn (gen_iorsi3 (operands[0], op1,
+      emit_insn (gen_iorsi3 (subtarget, op1,
 			     GEN_INT (INTVAL (operands[3])
 				      << INTVAL (operands[2]))));
     }
@@ -1212,7 +1254,7 @@
       emit_insn (gen_iorsi3 (op1, gen_rtx (LSHIFTRT, SImode, operands[0],
 					   operands[1]),
 			     op0));
-      emit_insn (gen_rotlsi3 (operands[0], op1, operands[1]));
+      emit_insn (gen_rotlsi3 (subtarget, op1, operands[1]));
     }
   else if ((INTVAL (operands[1]) + INTVAL (operands[2]) == 32)
 	   && ! (const_ok_for_arm (mask)
@@ -1226,8 +1268,9 @@
       emit_insn (gen_ashlsi3 (op0, operands[3],
 			      GEN_INT (32 - INTVAL (operands[1]))));
       emit_insn (gen_ashlsi3 (op1, operands[0], operands[1]));
-      emit_insn (gen_iorsi3 (operands[0], gen_rtx (LSHIFTRT, SImode, op1,
-						   operands[1]), op0));
+      emit_insn (gen_iorsi3 (subtarget,
+			     gen_rtx (LSHIFTRT, SImode, op1,
+				      operands[1]), op0));
     }
   else
     {
@@ -1270,7 +1313,17 @@
       if (INTVAL (operands[2]) != 0)
 	op1 = gen_rtx (ASHIFT, SImode, op1, operands[2]);
 
-      emit_insn (gen_iorsi3 (operands[0], op1, op2));
+      emit_insn (gen_iorsi3 (subtarget, op1, op2));
+    }
+
+  if (subtarget != target)
+    {
+      /* If TARGET is still a SUBREG, then it must be wider than a word,
+	 so we must be careful only to set the subword we were asked to. */
+      if (GET_CODE (target) == SUBREG)
+	emit_move_insn (target, subtarget);
+      else
+	emit_move_insn (target, gen_lowpart (GET_MODE (target), subtarget));
     }
 
   DONE;
@@ -2551,23 +2604,24 @@
 
 (define_expand "storehi"
   [;; store the low byte
-   (set (mem:QI (match_operand:SI 1 "" "")) (match_dup 3))
+   (set (match_operand 1 "" "") (match_dup 3))
    ;; extract the high byte
    (set (match_dup 2)
 	(ashiftrt:SI (match_operand 0 "" "") (const_int 8)))
    ;; store the high byte
-   (set (mem:QI (match_dup 4))
-	(subreg:QI (match_dup 2) 0))]	;explicit subreg safe
+   (set (match_dup 4) (subreg:QI (match_dup 2) 0))]	;explicit subreg safe
   ""
   "
 {
-  enum rtx_code code = GET_CODE (operands[1]);
+  rtx addr = XEXP (operands[1], 0);
+  enum rtx_code code = GET_CODE (addr);
 
-  if ((code == PLUS || code == MINUS)
-      && (GET_CODE (XEXP (operands[1], 1)) == REG
-	  || GET_CODE (XEXP (operands[1], 0)) != REG))
-    operands[1] = force_reg (SImode, operands[1]);
-  operands[4] = plus_constant (operands[1], 1);
+  if ((code == PLUS && GET_CODE (XEXP (addr, 1)) != CONST_INT)
+      || code == MINUS)
+    addr = force_reg (SImode, addr);
+
+  operands[4] = change_address (operands[1], QImode, plus_constant (addr, 1));
+  operands[1] = change_address (operands[1], QImode, NULL_RTX);
   operands[3] = gen_lowpart (QImode, operands[0]);
   operands[0] = gen_lowpart (SImode, operands[0]);
   operands[2] = gen_reg_rtx (SImode); 
@@ -2575,21 +2629,22 @@
 ")
 
 (define_expand "storehi_bigend"
-  [(set (mem:QI (match_dup 4)) (match_dup 3))
+  [(set (match_dup 4) (match_dup 3))
    (set (match_dup 2)
 	(ashiftrt:SI (match_operand 0 "" "") (const_int 8)))
-   (set (mem:QI (match_operand 1 "" ""))
-	(subreg:QI (match_dup 2) 0))]
+   (set (match_operand 1 "" "")	(subreg:QI (match_dup 2) 0))]
   ""
   "
 {
-  enum rtx_code code = GET_CODE (operands[1]);
-  if ((code == PLUS || code == MINUS)
-      && (GET_CODE (XEXP (operands[1], 1)) == REG
-	  || GET_CODE (XEXP (operands[1], 0)) != REG))
-    operands[1] = force_reg (SImode, operands[1]);
+  rtx addr = XEXP (operands[1], 0);
+  enum rtx_code code = GET_CODE (addr);
 
-  operands[4] = plus_constant (operands[1], 1);
+  if ((code == PLUS && GET_CODE (XEXP (addr, 1)) != CONST_INT)
+      || code == MINUS)
+    addr = force_reg (SImode, addr);
+
+  operands[4] = change_address (operands[1], QImode, plus_constant (addr, 1));
+  operands[1] = change_address (operands[1], QImode, NULL_RTX);
   operands[3] = gen_lowpart (QImode, operands[0]);
   operands[0] = gen_lowpart (SImode, operands[0]);
   operands[2] = gen_reg_rtx (SImode);
@@ -2598,19 +2653,19 @@
 
 ;; Subroutine to store a half word integer constant into memory.
 (define_expand "storeinthi"
-  [(set (mem:QI (match_operand:SI 0 "" ""))
+  [(set (match_operand 0 "" "")
 	(subreg:QI (match_operand 1 "" "") 0))
-   (set (mem:QI (match_dup 3)) (subreg:QI (match_dup 2) 0))]
+   (set (match_dup 3) (subreg:QI (match_dup 2) 0))]
   ""
   "
 {
   HOST_WIDE_INT value = INTVAL (operands[1]);
-  enum rtx_code code = GET_CODE (operands[0]);
+  rtx addr = XEXP (operands[0], 0);
+  enum rtx_code code = GET_CODE (addr);
 
-  if ((code == PLUS || code == MINUS)
-      && (GET_CODE (XEXP (operands[0], 1)) == REG
-	  || GET_CODE (XEXP (operands[0], 0)) != REG))
-  operands[0] = force_reg (SImode, operands[0]);
+  if ((code == PLUS && GET_CODE (XEXP (addr, 1)) != CONST_INT)
+      || code == MINUS)
+    addr = force_reg (SImode, addr);
 
   operands[1] = gen_reg_rtx (SImode);
   if (BYTES_BIG_ENDIAN)
@@ -2636,7 +2691,8 @@
 	}
     }
 
-  operands[3] = plus_constant (operands[0], 1);
+  operands[3] = change_address (operands[0], QImode, plus_constant (addr, 1));
+  operands[0] = change_address (operands[0], QImode, NULL_RTX);
 }
 ")
 
@@ -2667,16 +2723,15 @@
 	      DONE;
 	    }
 	  if (GET_CODE (operands[1]) == CONST_INT)
-	    emit_insn (gen_storeinthi (XEXP (operands[0], 0), operands[1]));
+	    emit_insn (gen_storeinthi (operands[0], operands[1]));
 	  else
 	    {
 	      if (GET_CODE (operands[1]) == MEM)
 		operands[1] = force_reg (HImode, operands[1]);
 	      if (BYTES_BIG_ENDIAN)
-		emit_insn (gen_storehi_bigend (operands[1],
-					       XEXP (operands[0], 0)));
+		emit_insn (gen_storehi_bigend (operands[1], operands[0]));
 	      else
-		emit_insn (gen_storehi (operands[1], XEXP (operands[0], 0)));
+		emit_insn (gen_storehi (operands[1], operands[0]));
 	    }
 	  DONE;
 	}
@@ -3152,9 +3207,10 @@
     FAIL;
 
   operands[3]
-            = arm_gen_load_multiple (REGNO (operands[0]), INTVAL (operands[2]),
-                                     force_reg (SImode, XEXP (operands[1], 0)),
-                                     TRUE, FALSE);
+    = arm_gen_load_multiple (REGNO (operands[0]), INTVAL (operands[2]),
+			     force_reg (SImode, XEXP (operands[1], 0)),
+			     TRUE, FALSE, RTX_UNCHANGING_P(operands[1]),
+			     MEM_IN_STRUCT_P(operands[1]));
 ")
 
 ;; Load multiple with write-back
@@ -3221,9 +3277,10 @@
     FAIL;
 
   operands[3]
-           = arm_gen_store_multiple (REGNO (operands[1]), INTVAL (operands[2]),
-                                     force_reg (SImode, XEXP (operands[0], 0)),
-                                     TRUE, FALSE);
+    = arm_gen_store_multiple (REGNO (operands[1]), INTVAL (operands[2]),
+			      force_reg (SImode, XEXP (operands[0], 0)),
+			      TRUE, FALSE, RTX_UNCHANGING_P (operands[0]),
+			      MEM_IN_STRUCT_P(operands[0]));
 ")
 
 ;; Store multiple with write-back
@@ -3859,8 +3916,16 @@
   "
 {
   enum rtx_code code = GET_CODE (operands[1]);
-  rtx ccreg = gen_compare_reg (code, arm_compare_op0, arm_compare_op1,
-			       arm_compare_fp);
+  rtx ccreg;
+
+  /* When compiling for SOFT_FLOAT, ensure both arms are in registers. 
+     Otherwise, ensure it is a valid FP add operand */
+  if ((! TARGET_HARD_FLOAT)
+      || (! fpu_add_operand (operands[3], SFmode)))
+    operands[3] = force_reg (SFmode, operands[3]);
+
+  ccreg = gen_compare_reg (code, arm_compare_op0, arm_compare_op1,
+			   arm_compare_fp);
 
   operands[1] = gen_rtx (code, VOIDmode, ccreg, const0_rtx);
 }")
@@ -3869,7 +3934,7 @@
   [(set (match_operand:DF 0 "s_register_operand" "")
 	(if_then_else:DF (match_operand 1 "comparison_operator" "")
 			 (match_operand:DF 2 "s_register_operand" "")
-			 (match_operand:DF 3 "nonmemory_operand" "")))]
+			 (match_operand:DF 3 "fpu_add_operand" "")))]
   "TARGET_HARD_FLOAT"
   "
 {
@@ -3881,57 +3946,77 @@
 }")
 
 (define_insn "*movsicc_insn"
-  [(set (match_operand:SI 0 "s_register_operand" "=r,r,r,r,r,r")
+  [(set (match_operand:SI 0 "s_register_operand" "=r,r,r,r,r,r,r,r")
 	(if_then_else:SI
 	 (match_operator 3 "comparison_operator"
 	  [(match_operand 4 "cc_register" "") (const_int 0)])
-	 (match_operand:SI 1 "arm_not_operand" "0,0,?rI,?rI,K,K")
-	 (match_operand:SI 2 "arm_not_operand" "rI,K,rI,K,rI,K")))]
+	 (match_operand:SI 1 "arm_not_operand" "0,0,rI,K,rI,rI,K,K")
+	 (match_operand:SI 2 "arm_not_operand" "rI,K,0,0,rI,K,rI,K")))]
   ""
   "@
    mov%D3\\t%0, %2
    mvn%D3\\t%0, #%B2
+   mov%d3\\t%0, %1
+   mvn%d3\\t%0, #%B1
    mov%d3\\t%0, %1\;mov%D3\\t%0, %2
    mov%d3\\t%0, %1\;mvn%D3\\t%0, #%B2
    mvn%d3\\t%0, #%B1\;mov%D3\\t%0, %2
    mvn%d3\\t%0, #%B1\;mvn%D3\\t%0, #%B2"
-  [(set_attr "length" "4,4,8,8,8,8")
+  [(set_attr "length" "4,4,4,4,8,8,8,8")
    (set_attr "conds" "use")])
 
 (define_insn "*movsfcc_hard_insn"
-  [(set (match_operand:SF 0 "s_register_operand" "=f,f")
-	(if_then_else:SF (match_operator 3 "comparison_operator" 
-			  [(match_operand 4 "cc_register" "") (const_int 0)])
-			 (match_operand:SF 1 "s_register_operand" "0,0")
-			 (match_operand:SF 2 "fpu_add_operand" "fG,H")))]
+  [(set (match_operand:SF 0 "s_register_operand" "=f,f,f,f,f,f,f,f")
+	(if_then_else:SF
+	 (match_operator 3 "comparison_operator" 
+	  [(match_operand 4 "cc_register" "") (const_int 0)])
+	 (match_operand:SF 1 "fpu_add_operand" "0,0,fG,H,fG,fG,H,H")
+	 (match_operand:SF 2 "fpu_add_operand" "fG,H,0,0,fG,H,fG,H")))]
   "TARGET_HARD_FLOAT"
   "@
    mvf%D3s\\t%0, %2
-   mnf%D3s\\t%0, #%N2"
-  [(set_attr "type" "ffarith")
+   mnf%D3s\\t%0, #%N2
+   mvf%d3s\\t%0, %1
+   mnf%d3s\\t%0, #%N1
+   mvf%d3s\\t%0, %1\;mvf%D3s\\t%0, %2
+   mvf%d3s\\t%0, %1\;mnf%D3s\\t%0, #%N2
+   mnf%d3s\\t%0, #%N1\;mvf%D3s\\t%0, %2
+   mnf%d3s\\t%0, #%N1\;mnf%D3s\\t%0, #%N2"
+  [(set_attr "length" "4,4,4,4,8,8,8,8")
+   (set_attr "type" "ffarith")
    (set_attr "conds" "use")])
 
 (define_insn "*movsfcc_soft_insn"
-  [(set (match_operand:SF 0 "s_register_operand" "=r")
+  [(set (match_operand:SF 0 "s_register_operand" "=r,r")
 	(if_then_else:SF (match_operator 3 "comparison_operator"
 			  [(match_operand 4 "cc_register" "") (const_int 0)])
-			 (match_operand:SF 1 "s_register_operand" "0")
-			 (match_operand:SF 2 "s_register_operand" "r")))]
+			 (match_operand:SF 1 "s_register_operand" "0,r")
+			 (match_operand:SF 2 "s_register_operand" "r,0")))]
   "TARGET_SOFT_FLOAT"
-  "mov%D3\\t%0, %2"
+  "@
+   mov%D3\\t%0, %2
+   mov%d3\\t%0, %1"
   [(set_attr "conds" "use")])
 
 (define_insn "*movdfcc_insn"
-  [(set (match_operand:DF 0 "s_register_operand" "=f,f")
-	(if_then_else:DF (match_operator 3 "comparison_operator"
-			  [(match_operand 4 "cc_register" "") (const_int 0)])
-			 (match_operand:DF 1 "s_register_operand" "0,0")
-			 (match_operand:DF 2 "fpu_add_operand" "fG,H")))]
+  [(set (match_operand:DF 0 "s_register_operand" "=f,f,f,f,f,f,f,f")
+	(if_then_else:DF
+	 (match_operator 3 "comparison_operator"
+	  [(match_operand 4 "cc_register" "") (const_int 0)])
+	 (match_operand:DF 1 "fpu_add_operand" "0,0,fG,H,fG,fG,H,H")
+	 (match_operand:DF 2 "fpu_add_operand" "fG,H,0,0,fG,H,fG,H")))]
   "TARGET_HARD_FLOAT"
   "@
    mvf%D3d\\t%0, %2
-   mnf%D3d\\t%0, #%N2"
-  [(set_attr "type" "ffarith")
+   mnf%D3d\\t%0, #%N2
+   mvf%d3d\\t%0, %1
+   mnf%d3d\\t%0, #%N1
+   mvf%d3d\\t%0, %1\;mvf%D3d\\t%0, %2
+   mvf%d3d\\t%0, %1\;mnf%D3d\\t%0, #%N2
+   mnf%d3d\\t%0, #%N1\;mvf%D3d\\t%0, %2
+   mnf%d3d\\t%0, #%N1\;mnf%D3d\\t%0, #%N2"
+  [(set_attr "length" "4,4,4,4,8,8,8,8")
+   (set_attr "type" "ffarith")
    (set_attr "conds" "use")])
 
 ;; Jump and linkage insns
@@ -4158,14 +4243,17 @@
   DONE;
 }")
 
+;; The USE in this pattern is needed to tell flow analysis that this is
+;; a CASESI insn.  It has no other purpose.
 (define_insn "casesi_internal"
-  [(set (pc)
-	(if_then_else
-	 (leu (match_operand:SI 0 "s_register_operand" "r")
-	      (match_operand:SI 1 "arm_rhs_operand" "rI"))
-	 (mem:SI (plus:SI (mult:SI (match_dup 0) (const_int 4))
-			  (label_ref (match_operand 2 "" ""))))
-	 (label_ref (match_operand 3 "" ""))))]
+  [(parallel [(set (pc)
+	       (if_then_else
+		(leu (match_operand:SI 0 "s_register_operand" "r")
+		     (match_operand:SI 1 "arm_rhs_operand" "rI"))
+		(mem:SI (plus:SI (mult:SI (match_dup 0) (const_int 4))
+				 (label_ref (match_operand 2 "" ""))))
+		(label_ref (match_operand 3 "" ""))))
+	      (use (label_ref (match_dup 2)))])]
   ""
   "*
   if (flag_pic)
@@ -5663,8 +5751,7 @@
   "sub%?s\\t%0, %1, #0"
 [(set_attr "conds" "set")])
 
-; Peepholes to spot possible load- and store-multiples, if the ordering is
-; reversed, check that the memory references aren't volatile.
+; Peepholes to spot possible load- and store-multiples.
 
 (define_peephole
   [(set (match_operand:SI 0 "s_register_operand" "=r")

gcc/config/arm/coff.h

@@ -30,7 +30,7 @@ Boston, MA 02111-1307, USA.  */
    point the default.  NOT --nfp!  --with{enable?} is supposed to replace it
    (right?), so let's stop using it.  */
 #undef TARGET_DEFAULT
-#define TARGET_DEFAULT (ARM_FLAG_SOFT_FLOAT /*+ TARGET_CPU_DEFAULT*/)
+#define TARGET_DEFAULT (ARM_FLAG_SOFT_FLOAT | ARM_FLAG_APCS_32)
 
 /* ??? Is a big-endian default intended to be supported?  */
 #if 0 /*TARGET_CPU_DEFAULT & ARM_FLAG_BIG_END*/

gcc/config/arm/lib1funcs.asm

@@ -402,3 +402,22 @@ SYM (__div0):
 	RET	pc, lr
 
 #endif /* L_divmodsi_tools */
+
+#ifdef L_dvmd_lnx
+@ GNU/Linux division-by zero handler.  Used in place of L_dvmd_tls
+
+#include <asm/unistd.h>
+#define SIGFPE	8			@ cant use <asm/signal.h> as it
+					@ contains too much C rubbish
+	.globl SYM (__div0)
+	.align 0
+SYM (__div0):
+	stmfd	sp!, {r1, lr}
+	swi	__NR_getpid
+	cmn	r0, #1000
+	ldmgefd	sp!, {r1, pc}RETCOND	@ not much we can do
+	mov	r1, #SIGFPE
+	swi	__NR_kill
+	ldmfd	sp!, {r1, pc}RETCOND
+
+#endif /* L_dvmd_lnx */

gcc/config/arm/linux-gas.h

@@ -1,4 +1,5 @@
-/* Definitions of target machine for GNU compiler.  ARM Linux version.
+/* Definitions of target machine for GNU compiler.  ARM Linux-based GNU
+   systems version.
    Copyright (C) 1997 Free Software Foundation, Inc.
    Contributed by Russell King  <rmk92@ecs.soton.ac.uk>.
 

gcc/config/arm/linux.h

@@ -1,6 +1,6 @@
-/* Definitions for ARM running Linux
+/* Definitions for ARM running Linux-based GNU systems.
    Copyright (C) 1993, 1994, 1997 Free Software Foundation, Inc.
-   Adapted from ARM Linux by Russell King  <rmk92@ecs.soton.ac.uk>.
+   Contributed by Russell King  <rmk92@ecs.soton.ac.uk>.
 
 This file is part of GNU CC.
 
@@ -31,7 +31,7 @@ Boston, MA 02111-1307, USA.  */
 #undef COMMENT_BEGIN
  
 /* We default to ARM3.  */
-#define TARGET_CPU_DEFAULT TARGET_CPU_arm3
+#define SUBTARGET_CPU_DEFAULT TARGET_CPU_arm3
 
 #undef CPP_PREDEFINES
 #define CPP_PREDEFINES \
@@ -56,8 +56,7 @@ Boston, MA 02111-1307, USA.  */
 #define HANDLE_SYSV_PRAGMA
   
 /* Run-time Target Specification.  */
-#define TARGET_VERSION  \
-  fputs (" (ARM Linux/a.out)", stderr);
+#define TARGET_VERSION  fputs (" (ARM GNU/Linux with a.out)", stderr);
 
 /* This is used in ASM_FILE_START */
 #define ARM_OS_NAME "Linux"

gcc/config/arm/netbsd.h

@@ -1,6 +1,5 @@
-/*
-   NetBSD/arm (RiscBSD) version.
-   Copyright (C) 1993, 1994 Free Software Foundation, Inc.
+/* NetBSD/arm (RiscBSD) version.
+   Copyright (C) 1993, 1994, 1997 Free Software Foundation, Inc.
    Contributed by Mark Brinicombe (amb@physig.ph.kcl.ac.uk)
 
 This file is part of GNU CC.
@@ -50,7 +49,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
    arm32 is the NetBSD port name, so we always define arm32 and __arm32__.  */
 #undef CPP_PREDEFINES
 #define CPP_PREDEFINES "\
--Dunix -Driscbsd -Darm32 -D__arm32__ -D__NetBSD__ \
+-Dunix -Driscbsd -Darm32 -D__arm32__ -D__arm__ -D__NetBSD__ \
 -Asystem(unix) -Asystem(NetBSD) -Acpu(arm) -Amachine(arm)"
 
 /* Define _POSIX_SOURCE if necessary.  */
@@ -64,6 +63,13 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #undef CPP_APCS_PC_DEFAULT_SPEC
 #define CPP_APCS_PC_DEFAULT_SPEC "-D__APCS_32__"
 
+/* Pass -X to the linker so that it will strip symbols starting with 'L' */
+#undef LINK_SPEC
+#define LINK_SPEC "\
+-X %{!nostdlib:%{!r*:%{!e*:-e start}}} -dc -dp %{R*} \
+%{static:-Bstatic} %{assert*} \
+"
+
 #undef SIZE_TYPE
 #define SIZE_TYPE "unsigned int"
 
@@ -97,12 +103,17 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
   fprintf(STREAM, "\tbl\tmcount\n");					    \
 }
 
+/* On the ARM `@' introduces a comment, so we must use something else
+   for .type directives.  */
+#undef TYPE_OPERAND_FMT
+#define TYPE_OPERAND_FMT "%%%s"
+
 /* VERY BIG NOTE : Change of structure alignment for RiscBSD.
    There are consequences you should be aware of...
 
    Normally GCC/arm uses a structure alignment of 32 for compatibility
    with armcc.  This means that structures are padded to a word
-   boundry.  However this causes problems with bugged NetBSD kernel
+   boundary.  However this causes problems with bugged NetBSD kernel
    code (possibly userland code as well - I have not checked every
    binary).  The nature of this bugged code is to rely on sizeof()
    returning the correct size of various structures rounded to the
@@ -118,7 +129,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
            structures containing shorts will be half word alinged.
            structures containing ints will be word aligned.
 
-      This means structures should be padded to a word boundry if
+      This means structures should be padded to a word boundary if
       alignment of 32 is required for byte structures etc.
       
    2. A potential performance penalty may exist if strings are no longer

gcc/config/arm/t-linux

@@ -10,7 +10,7 @@ ENQUIRE=
 CROSS_LIBGCC1 = libgcc1-asm.a
 LIBGCC1 = libgcc1-asm.a
 LIB1ASMSRC = arm/lib1funcs.asm
-LIB1ASMFUNCS = _udivsi3 _divsi3 _umodsi3 _modsi3 _dvmd_tls
+LIB1ASMFUNCS = _udivsi3 _divsi3 _umodsi3 _modsi3 _dvmd_lnx
 
 MULTILIB_OPTIONS = mapcs-32
 MULTILIB_DIRNAMES = apcs-32

gcc/config/arm/t-netbsd

@@ -5,7 +5,3 @@ LIBGCC2_CFLAGS=-O2 -fomit-frame-pointer $(LIBGCC2_INCLUDES) $(GCC_CFLAGS) -g0
 
 # Don't build enquire
 ENQUIRE=
-
-CROSS_LIBGCC1 = libgcc1-asm.a
-LIB1ASMSRC = arm/lib1funcs.asm
-LIB1ASMFUNCS = _udivsi3 _divsi3 _umodsi3 _modsi3 _dvmd_tls

gcc/config/arm/t-semi

@@ -1,6 +1,6 @@
 # Just for these, we omit the frame pointer since it makes such a big
 # difference.  It is then pointless adding debugging.
-LIBGCC2_CFLAGS=-O2 -fomit-frame-pointer $(LIBGCC2_INCLUDES) $(GCC_CFLAGS) -g0 
+LIBGCC2_CFLAGS=-O2 -fomit-frame-pointer $(LIBGCC2_INCLUDES) $(GCC_CFLAGS) -g0
 
 # Don't build enquire
 ENQUIRE=

gcc/config/arm/x-riscix

@@ -6,4 +6,3 @@ X_CFLAGS= -DPOSIX -Dopterr=gcc_opterr -Doptind=gcc_optind \
 OLDCC=/usr/ucb/cc
 CC=$(OLDCC)
 FIXPROTO_DEFINES= -D_POSIX_SOURCE -D_XOPEN_C -D_BSD_C -D_XOPEN_SOURCE
-INSTALL=$(srcdir)/install.sh -c

gcc/config/arm/xm-arm.h

@@ -44,12 +44,6 @@ Boston, MA 02111-1307, USA.  */
 #define USE_C_ALLOCA
 #endif
 
-/* Define this if the library function putenv is available on your machine */
-#define HAVE_PUTENV 1
-
-/* Define this if the library function vprintf is available on your machine */
-#define HAVE_VPRINTF 1
-
 /* Define this to be 1 if you know the host compiler supports prototypes, even
    if it doesn't define __STDC__, or define it to be 0 if you do not want any
    prototypes when compiling GNU CC. */

gcc/config/clipper/clipper.c

@@ -19,8 +19,8 @@ along with GNU CC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
-#include <stdio.h>
 #include "config.h"
+#include <stdio.h>
 #include "rtl.h"
 #include "regs.h"
 #include "hard-reg-set.h"
@@ -440,23 +440,37 @@ clipper_builtin_saveregs (arglist)
 
   if (flag_check_memory_usage)
     {
-      emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3, addr,
-			 ptr_mode, GEN_INT (5 * GET_MODE_SIZE (SImode)),
+      emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
+			 addr, ptr_mode,
+			 GEN_INT (5 * GET_MODE_SIZE (SImode)),
 			 TYPE_MODE (sizetype),
-			 GEN_INT (MEMORY_USE_RW), QImode);
+			 GEN_INT (MEMORY_USE_RW),
+			 TYPE_MODE (integer_type_node));
 
-      emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3, f0_addr,
-			 ptr_mode, GEN_INT (GET_MODE_SIZE (DFmode)),
-			 TYPE_MODE (sizetype), GEN_INT (MEMORY_USE_RW), QImode);
-      emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3, f1_addr,
-			 ptr_mode, GEN_INT (GET_MODE_SIZE (DFmode)),
-			 TYPE_MODE (sizetype), GEN_INT (MEMORY_USE_RW), QImode);
-      emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3, r0_addr,
-			 ptr_mode, GEN_INT (GET_MODE_SIZE (SImode)),
-			 TYPE_MODE (sizetype), GEN_INT (MEMORY_USE_RW), QImode);
-      emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3, r1_addr,
-			 ptr_mode, GEN_INT (GET_MODE_SIZE (SImode)),
-			 TYPE_MODE (sizetype), GEN_INT (MEMORY_USE_RW), QImode);
+      emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
+			 f0_addr, ptr_mode,
+			 GEN_INT (GET_MODE_SIZE (DFmode)),
+			 TYPE_MODE (sizetype),
+			 GEN_INT (MEMORY_USE_RW), 
+			 TYPE_MODE (integer_type_node));
+      emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
+			 f1_addr, ptr_mode,
+			 GEN_INT (GET_MODE_SIZE (DFmode)),
+			 TYPE_MODE (sizetype),
+			 GEN_INT (MEMORY_USE_RW), 
+			 TYPE_MODE (integer_type_node));
+      emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
+			 r0_addr, ptr_mode,
+			 GEN_INT (GET_MODE_SIZE (SImode)),
+			 TYPE_MODE (sizetype),
+			 GEN_INT (MEMORY_USE_RW),
+			 TYPE_MODE (integer_type_node));
+      emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
+			 r1_addr, ptr_mode,
+			 GEN_INT (GET_MODE_SIZE (SImode)),
+			 TYPE_MODE (sizetype),
+			 GEN_INT (MEMORY_USE_RW),
+			 TYPE_MODE (integer_type_node));
     }
 
   /* Return the address of the va_list constructor, but don't put it in a

gcc/config/clipper/clipper.md

@@ -1,5 +1,5 @@
 ;;- Machine description for GNU compiler, Clipper Version
-;;   Copyright (C) 1987, 1988, 1991, 1993, 1994 Free Software Foundation, Inc.
+;;   Copyright (C) 1987, 88, 91, 93, 94, 1997 Free Software Foundation, Inc.
 ;; Contributed by Holger Teutsch (holger@hotbso.rhein-main.de)
 
 ;; This file is part of GNU CC.
@@ -532,8 +532,8 @@
   operands[6] = addr0;
   operands[7] = addr1;
 
-  operands[0] = gen_rtx (MEM, BLKmode, addr0);
-  operands[1] = gen_rtx (MEM, BLKmode, addr1);
+  operands[0] = change_address (operands[0], VOIDmode, addr0);
+  operands[1] = change_address (operands[1], VOIDmode, addr1);
 
   if (GET_CODE (operands[2]) != CONST_INT)
     operands[2] = force_reg (SImode, operands[2]);

gcc/config/clipper/clix.h

@@ -1,5 +1,5 @@
 /* Definitions of target machine for GNU compiler.  Clipper/Clix version.
-   Copyright (C) 1988, 1993, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1988, 1993, 1996, 1997 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -31,6 +31,8 @@ Boston, MA 02111-1307, USA.  */
 
 #undef LIB_SPEC
 
+#define TARGET_MEM_FUNCTIONS
+
 #undef HAVE_ATEXIT
 #define HAVE_ATEXIT
 

gcc/config/clipper/xm-clix.h

@@ -27,13 +27,4 @@
 /* isinf isn't there, but finite is. */
 #define isinf(x) (!finite(x))
 
-
 #define USG
-
-#define bcopy(a,b,c) memcpy (b,a,c)
-#define bzero(a,b) memset (a,0,b)
-#define bcmp(a,b,c) memcmp (a,b,c)
-#define index strchr
-#define rindex strrchr
-
-#define TARGET_MEM_FUNCTIONS

gcc/config/convex/convex.c

@@ -1,5 +1,5 @@
 /* Subroutines for insn-output.c for Convex.
-   Copyright (C) 1988, 1993, 1994 Free Software Foundation, Inc.
+   Copyright (C) 1988, 1993, 1994, 1997 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -19,6 +19,7 @@ the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
 #include "config.h"
+#include <stdio.h>
 #include "tree.h"
 #include "rtl.h"
 #include "regs.h"
@@ -31,9 +32,6 @@ Boston, MA 02111-1307, USA.  */
 #include "output.h"
 #include "expr.h"
 
-#undef NULL
-#include <stdio.h>
-
 /* Tables used in convex.h */
 
 char regno_ok_for_index_p_base[1 + LAST_VIRTUAL_REGISTER + 1];

gcc/config/convex/x-convex

@@ -1,5 +1,5 @@
 # ld can make exe's c2-only if this lib is searched even though not loaded
-CCLIBFLAGS = -tm c1 
+CCLIBFLAGS = -tm c1
 
 # Use -pcc to avoid surprises.
 CC = cc -pcc

gcc/config/convex/xm-convex.h

@@ -1,5 +1,5 @@
 /* Configuration for GNU C-compiler for Convex.
-   Copyright (C) 1989, 1993 Free Software Foundation, Inc.
+   Copyright (C) 1989, 1993, 1997 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -42,11 +42,6 @@ Boston, MA 02111-1307, USA.  */
 
 #define P_tmpdir	"/tmp/"
 
-/* Use memcpy and memset -- either would work but these get inlined. */
-
-#define bcopy(a,b,c) memcpy (b,a,c)
-#define bzero(a,b) memset (a,0,b)
-
 /* Convex uses Vax or IEEE floats.
    Both formats have Vax semantics. */
 

gcc/config/dsp16xx/dsp16xx.c

@@ -1,5 +1,5 @@
 /* Subroutines for assembler code output on the DSP1610.
-   Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+   Copyright (C) 1994, 1995, 1997 Free Software Foundation, Inc.
    Contributed by Michael Collison (collison@world.std.com).
 
 This file is part of GNU CC.
@@ -20,8 +20,8 @@ the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
 /* Some output-actions in dsp1600.md need these.  */
-#include <stdio.h>
 #include "config.h"
+#include <stdio.h>
 #include "rtl.h"
 #include "regs.h"
 #include "hard-reg-set.h"

gcc/config/dsp16xx/dsp16xx.h

@@ -1,5 +1,5 @@
 /* Definitions of target machine for GNU compiler.  AT&T DSP1600.
-   Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
    Contributed by Michael Collison (collison@world.std.com).
 
 This file is part of GNU CC.
@@ -440,7 +440,7 @@ extern int target_flags;
 /* 1 for registers that have pervasive standard uses
    and are not available for the register allocator.
 
-   The registers are layed out as follows:
+   The registers are laid out as follows:
 
    {a0,a0l,a1,a1l,x,y,yl,p,pl} - Data Arithmetic Unit
    {r0,r1,r2,r3,j,k,ybase} - Y Space Address Arithmetic Unit
@@ -1652,7 +1652,7 @@ const_section ()                                                   \
 /* This is how to output an assembler line defining a `float' constant.  */
 #define ASM_OUTPUT_FLOAT(FILE,VALUE)  asm_output_float (FILE, VALUE)
 
-/* This is how to output and assembler line defininf a 'float' constant of
+/* This is how to output an assembler line defining a 'float' constant of
    size HFmode. */
 #define ASM_OUTPUT_SHORT_FLOAT(FILE,VALUE)  asm_output_float (FILE, VALUE)
 

gcc/config/dsp16xx/dsp16xx.md

@@ -1,5 +1,5 @@
 ;;- Machine description for the AT&T DSP1600 for GNU C compiler
-;;  Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+;;  Copyright (C) 1994, 1995, 1997 Free Software Foundation, Inc.
 ;;  Contributed by Michael Collison (collison@world.std.com).
 
 ;; This file is part of GNU CC.
@@ -1136,8 +1136,8 @@
   operands[5] = addr0;
   operands[6] = addr1;
 
-  operands[0] = gen_rtx (MEM, BLKmode, addr0);
-  operands[1] = gen_rtx (MEM, BLKmode, addr1);
+  operands[0] = change_address (operands[0], VOIDmode, addr0);
+  operands[1] = change_address (operands[1], VOIDmode, addr1);
 }")
 
 (define_insn ""

gcc/config/elxsi/elxsi.c

@@ -1,5 +1,5 @@
 /* Subroutines for insn-output.c for GNU compiler.  Elxsi version.
-   Copyright (C) 1987, 1992 Free Software Foundation, Inc
+   Copyright (C) 1987, 1992, 1997 Free Software Foundation, Inc
    This port, done by Mike Stump <mrs@cygnus.com> in 1988, and is the first
    64 bit port of GNU CC.
    Based upon the VAX port.
@@ -21,8 +21,8 @@ along with GNU CC; see the file COPYING.  If not, write to
 the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
-#include <stdio.h>
 #include "config.h"
+#include <stdio.h>
 #include "rtl.h"
 
 extern char *reg_names[];

gcc/config/float-i128.h

@@ -0,0 +1,96 @@
+/* float.h for target with IEEE 32, 64 and 128 bit floating point formats */
+#ifndef _FLOAT_H_
+#define _FLOAT_H_
+/* Produced by enquire version 4.3, CWI, Amsterdam */
+
+   /* Radix of exponent representation */
+#undef FLT_RADIX
+#define FLT_RADIX 2
+   /* Number of base-FLT_RADIX digits in the significand of a float */
+#undef FLT_MANT_DIG
+#define FLT_MANT_DIG 24
+   /* Number of decimal digits of precision in a float */
+#undef FLT_DIG
+#define FLT_DIG 6
+   /* Addition rounds to 0: zero, 1: nearest, 2: +inf, 3: -inf, -1: unknown */
+#undef FLT_ROUNDS
+#define FLT_ROUNDS 1
+   /* Difference between 1.0 and the minimum float greater than 1.0 */
+#undef FLT_EPSILON
+#define FLT_EPSILON 1.19209290e-07F
+   /* Minimum int x such that FLT_RADIX**(x-1) is a normalised float */
+#undef FLT_MIN_EXP
+#define FLT_MIN_EXP (-125)
+   /* Minimum normalised float */
+#undef FLT_MIN
+#define FLT_MIN 1.17549435e-38F
+   /* Minimum int x such that 10**x is a normalised float */
+#undef FLT_MIN_10_EXP
+#define FLT_MIN_10_EXP (-37)
+   /* Maximum int x such that FLT_RADIX**(x-1) is a representable float */
+#undef FLT_MAX_EXP
+#define FLT_MAX_EXP 128
+   /* Maximum float */
+#undef FLT_MAX
+#define FLT_MAX 3.40282347e+38F
+   /* Maximum int x such that 10**x is a representable float */
+#undef FLT_MAX_10_EXP
+#define FLT_MAX_10_EXP 38
+
+   /* Number of base-FLT_RADIX digits in the significand of a double */
+#undef DBL_MANT_DIG
+#define DBL_MANT_DIG 53
+   /* Number of decimal digits of precision in a double */
+#undef DBL_DIG
+#define DBL_DIG 15
+   /* Difference between 1.0 and the minimum double greater than 1.0 */
+#undef DBL_EPSILON
+#define DBL_EPSILON 2.2204460492503131e-16
+   /* Minimum int x such that FLT_RADIX**(x-1) is a normalised double */
+#undef DBL_MIN_EXP
+#define DBL_MIN_EXP (-1021)
+   /* Minimum normalised double */
+#undef DBL_MIN
+#define DBL_MIN 2.2250738585072014e-308
+   /* Minimum int x such that 10**x is a normalised double */
+#undef DBL_MIN_10_EXP
+#define DBL_MIN_10_EXP (-307)
+   /* Maximum int x such that FLT_RADIX**(x-1) is a representable double */
+#undef DBL_MAX_EXP
+#define DBL_MAX_EXP 1024
+   /* Maximum double */
+#undef DBL_MAX
+#define DBL_MAX 1.7976931348623157e+308
+   /* Maximum int x such that 10**x is a representable double */
+#undef DBL_MAX_10_EXP
+#define DBL_MAX_10_EXP 308
+
+   /* Number of base-FLT_RADIX digits in the significand of a long double */
+#undef LDBL_MANT_DIG
+#define LDBL_MANT_DIG 113
+   /* Number of decimal digits of precision in a long double */
+#undef LDBL_DIG
+#define LDBL_DIG 33
+   /* Difference between 1.0 and the minimum long double greater than 1.0 */
+#undef LDBL_EPSILON
+#define LDBL_EPSILON 1.925929944387235853055977942584927319E-34L
+   /* Minimum int x such that FLT_RADIX**(x-1) is a normalised long double */
+#undef LDBL_MIN_EXP
+#define LDBL_MIN_EXP (-16381)
+   /* Minimum normalised long double */
+#undef LDBL_MIN
+#define LDBL_MIN 3.362103143112093506262677817321752603E-4932L
+   /* Minimum int x such that 10**x is a normalised long double */
+#undef LDBL_MIN_10_EXP
+#define LDBL_MIN_10_EXP (-4931)
+   /* Maximum int x such that FLT_RADIX**(x-1) is a representable long double */
+#undef LDBL_MAX_EXP
+#define LDBL_MAX_EXP 16384
+   /* Maximum long double */
+#undef LDBL_MAX
+#define LDBL_MAX 1.189731495357231765085759326628007016E+4932L
+   /* Maximum int x such that 10**x is a representable long double */
+#undef LDBL_MAX_10_EXP
+#define LDBL_MAX_10_EXP 4932
+
+#endif /*  _FLOAT_H_ */

gcc/config/fp-bit.c

@@ -241,7 +241,7 @@ typedef unsigned int UDItype __attribute__ ((mode (DI)));
 /* numeric parameters */
 /* F_D_BITOFF is the number of bits offset between the MSB of the mantissa
    of a float and of a double. Assumes there are only two float types.
-   (double::FRAC_BITS+double::NGARGS-(float::FRAC_BITS-float::NGARDS))
+   (double::FRAC_BITS+double::NGARDS-(float::FRAC_BITS-float::NGARDS))
  */
 #define F_D_BITOFF (52+8-(23+7))
 
@@ -456,7 +456,7 @@ pack_d ( fp_number_type *  src)
     }
 
   /* We previously used bitfields to store the number, but this doesn't
-     handle little/big endian systems conviently, so use shifts and
+     handle little/big endian systems conveniently, so use shifts and
      masks */
 #ifdef FLOAT_BIT_ORDER_MISMATCH
   dst.bits.fraction = fraction;
@@ -483,7 +483,7 @@ static void
 unpack_d (FLO_union_type * src, fp_number_type * dst)
 {
   /* We previously used bitfields to store the number, but this doesn't
-     handle little/big endian systems conviently, so use shifts and
+     handle little/big endian systems conveniently, so use shifts and
      masks */
   fractype fraction;
   int exp;

gcc/config/fx80/fx80.c

@@ -1,5 +1,5 @@
 /* Subroutines for insn-output.c for Alliant FX computers.
-   Copyright (C) 1989,1991 Free Software Foundation, Inc.
+   Copyright (C) 1989, 1991, 1997 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -20,8 +20,8 @@ Boston, MA 02111-1307, USA.  */
 
 
 /* Some output-actions in alliant.md need these.  */
-#include <stdio.h>
 #include "config.h"
+#include <stdio.h>
 #include "rtl.h"
 #include "regs.h"
 #include "hard-reg-set.h"

gcc/config/gmicro/gmicro.c

@@ -2,7 +2,7 @@
    Ported by Masanobu Yuhara, Fujitsu Laboratories LTD.
    (yuhara@flab.fujitsu.co.jp)
 
-   Copyright (C) 1990, 1991 Free Software Foundation, Inc.
+   Copyright (C) 1990, 1991, 1997 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -25,8 +25,8 @@ the Free Software Foundation, 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.  */
 
 
-#include <stdio.h>
 #include "config.h"
+#include <stdio.h>
 #include "rtl.h"
 #include "regs.h"
 #include "hard-reg-set.h"