procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial revision

Browse source 
From-SVN: r14764
This commit is contained in:
Jeff Law 1997-08-11 09:56:58 -06:00
parent 737cee66f2
commit 861bb6c1b0
112 changed files with 162370 additions and 430 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

95
gcc/.gdbinit Normal file
View file

@ -0,0 +1,95 @@
define pr
set debug_rtx ($)
end
document pr
Print the full structure of the rtx that is $.
Works only when an inferior is executing.
end
define prl
set debug_rtx_list ($, debug_rtx_count)
end
document prl
Print the full structure of all rtx insns beginning at $.
Works only when an inferior is executing.
Uses variable debug_rtx_count to control number of insns printed:
debug_rtx_count > 0: print from $ on.
debug_rtx_count < 0: print a window around $.
There is also debug_rtx_find (rtx, uid) that will scan a list for UID and print
it using debug_rtx_list. Usage example: set $foo=debug_rtx_find(first, 42)
end
define pt
set debug_tree ($)
end
document pt
Print the full structure of the tree that is $.
Works only when an inferior is executing.
end
define ptc
output (enum tree_code) $.common.code
echo \n
end
document ptc
Print the tree-code of the tree node that is $.
end
define pdn
output $.decl.name->identifier.pointer
echo \n
end
document pdn
Print the name of the decl-node that is $.
end
define ptn
output $.type.name->decl.name->identifier.pointer
echo \n
end
document ptn
Print the name of the type-node that is $.
end
define prc
output (enum rtx_code) $.code
echo \ (
output $.mode
echo )\n
end
document prc
Print the rtx-code and machine mode of the rtx that is $.
end
define pi
print $.fld[0].rtx@7
end
document pi
Print the fields of an instruction that is $.
end
define pbs
set print_binding_stack ()
end
document pbs
In cc1plus, print the current binding stack, frame by frame, up to and
including the global binding level.
end
# Don't let abort actually run, as it will make
# stdio stop working and therefore the `pr' command below as well.
b abort
# Make gdb complain about symbol reading errors. This is so that gcc
# developers can see and fix bugs in gcc debug output.
set complaints 20

340
gcc/COPYING Normal file
View file

@ -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.

482
gcc/COPYING.LIB Normal file
View file

@ -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!

10652
gcc/ChangeLog Normal file
View file

File diff suppressed because it is too large Load diff

6671
gcc/ChangeLog.0 Normal file
View file

File diff suppressed because it is too large Load diff

9207
gcc/ChangeLog.1 Normal file
View file

File diff suppressed because it is too large Load diff

10185
gcc/ChangeLog.10 Normal file
View file

File diff suppressed because it is too large Load diff

7229
gcc/ChangeLog.2 Normal file
View file

File diff suppressed because it is too large Load diff

8063
gcc/ChangeLog.3 Normal file
View file

File diff suppressed because it is too large Load diff

10783
gcc/ChangeLog.4 Normal file
View file

File diff suppressed because it is too large Load diff

8954
gcc/ChangeLog.5 Normal file
View file

File diff suppressed because it is too large Load diff

8173
gcc/ChangeLog.6 Normal file
View file

File diff suppressed because it is too large Load diff

10376
gcc/ChangeLog.7 Normal file
View file

File diff suppressed because it is too large Load diff

11080
gcc/ChangeLog.8 Normal file
View file

File diff suppressed because it is too large Load diff

9968
gcc/ChangeLog.9 Normal file
View file

File diff suppressed because it is too large Load diff

1906
gcc/INSTALL Normal file
View file

File diff suppressed because it is too large Load diff

24
gcc/NEWS
View file

@ -3,12 +3,17 @@ Noteworthy changes in GCC version 2.8.0:
The -specs=file switch allows you to override default specs used in invoking
programs like cc1, as, etc.
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.
The following new targets are supported:
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.
Embedded target m32r-elf.
New features for the Hitachi H8/300(H).
@ -23,6 +28,17 @@ New features for SPARC-based systems:
-mtune=xxx
-mimpure-text and -mno-impure-text
New features for all rs6000 and PowerPC systems:
-mcpu=604e
-mcpu=801
-mcpu=823
-mtune=xxx
-mupdate
-mno-update
-mfused-madd
-mno-fused-madd
New features for PowerPC-based systems running either System V, Linux, Solaris,
or embedded systems:
@ -33,10 +49,16 @@ or embedded systems:
-mcall-sysv-eabi
-mcall-sysv-noeabi
-msdata
-msdata=none
-msdata=default
-msdata=sysv
-msdata=eabi
-memb
-mtune=xxx
-msim
-mmvme
wchar_t is now of type long, not unsigned short as per ABI.
-p/-pg support
-mcpu=403 now implies -mstrict-align.
Options -mno-v8 and -mno-sparclite are no longer supported on SPARC
targets. Options -mcypress, -mv8, -msupersparc, -msparclite, -mf930,

4003
gcc/ORDERS Normal file
View file

File diff suppressed because it is too large Load diff

26
gcc/README Normal file
View file

@ -0,0 +1,26 @@
This directory contains the version 2.7.2 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).

144
gcc/README-bugs Normal file
View file

@ -0,0 +1,144 @@
The purpose of GCC pretesting is to verify that the new GCC
distribution, about to be released, works properly on your system *with
no change whatever*, when installed following the precise
recommendations that come with the distribution.
Here are some guidelines on how to do pretesting so as to make it
helpful. All of them follow from common sense together with the
nature of the purpose and the situation.
* It is absolutely vital that you mention even the smallest change or
departure from the standard sources and installation procedure.
Otherwise, you are not testing the same program that I wrote. Testing
a different program is usually of no use whatever. It can even cause
trouble if you fail to tell me that you tested some other program
instead of what I know as GCC. I might think that GCC works, when in
fact it has not been properly tried, and might have a glaring fault.
* Even changing the compilation options counts as a change in the
program. The GCC sources specify which compilation options to use.
Some of them are specified in makefiles, and some in machine-specific
configuration files.
You have ways to override this--but if you do, then you are not
testing what ordinary users will do. Therefore, when pretesting, it
is vital to test with the default compilation options.
(It is okay to test with nonstandard options as well as testing with
the standard ones.)
* The machine and system configuration files of GCC are parts of
GCC. So when you test GCC, you need to do it with the
configuration files that come with GCC.
If GCC does not come with configuration files for a certain machine,
and you test it with configuration files that don't come with GCC,
this is effectively changing GCC. Because the crucial fact about
the planned release is that, without changes, it doesn't work on that
machine.
To make GCC work on that machine, I would need to install new
configuration files. That is not out of the question, since it is
safe--it certainly won't break any other machines that already work.
But you will have to rush me the legal papers to give the FSF
permission to use a large piece of text.
* Look for recommendations for your system.
You can find these recommendations in the Installation node of the
manual, and in the file INSTALL. (These two files have the same text.)
These files say which configuration name to use for your machine, so
use the ones that are recommended. If you guess, you might guess
wrong and encounter spurious difficulties. What's more, if you don't
follow the recommendations then you aren't helping to test that its
recommendations are valid.
These files may describe other things that you need to do to make GCC
work on your machine. If so, you should follow these recommendations
also, for the same reason.
Also look at the Trouble chapter of the manual for items that
pertain to your machine.
* Don't delay sending information.
When you find a problem, please double check it if you can do so
quickly. But don't spend a long time double-checking. A good rule is
always to tell me about every problem on the same day you encounter
it, even if that means you can't find a solution before you report the
problem.
I'd much rather hear about a problem today and a solution tomorrow
than get both of them tomorrow at the same time.
* Make each bug report self-contained.
If you refer back to another message, whether from you or from someone
else, then it will be necessary for anyone who wants to investigate
the bug to find the other message. This may be difficult, it is
probably time-consuming.
To help me save time, simply copy the relevant parts of any previous
messages into your own bug report.
In particular, if I ask you for more information because a bug report
was incomplete, it is best to send me the *entire* collection of
relevant information, all together. If you send just the additional
information, that makes me do extra work. There is even a risk that
I won't remember what question you are sending me the answer to.
* Always be precise when talking about changes you have made. Show
things rather than describing them. Use exact filenames (relative to
the main directory of the distribution), not partial ones. For
example, say "I changed Makefile" rather than "I changed the
makefile". Instead of saying "I defined the MUMBLE macro", send a
diff that shows your change.
* Always use `diff -c' to make diffs. If you don't include context,
it may be hard for me to figure out where you propose to make the
changes. I might have to ignore your patch because I can't tell what
it means.
* When you write a fix, keep in mind that I can't install a change
that would break other systems.
People often suggest fixing a problem by changing machine-independent
files such as toplev.c to do something special that a particular
system needs. Sometimes it is totally obvious that such changes would
break GCC for almost all users. I can't possibly make a change like
that. All I can do is send it back to you and ask you to find a fix
that is safe to install.
Sometimes people send fixes that *might* be an improvement in
general--but it is hard to be sure of this. I can install such
changes some of the time, but not during pretest, when I am trying to
get a new version to work reliably as quickly as possible.
The safest changes for me to install are changes to the configuration
files for a particular machine. At least I know those can't create
bugs on other machines.
* Don't try changing GCC unless it fails to work if you don't change it.
* Don't even suggest changes that would only make GCC cleaner.
Every change I install could introduce a bug, so I won't install
a change unless I see it is necessary.
* If you would like to suggest changes for purposes other than fixing
serious bugs, don't wait till pretest time. Instead, send them just
after I make a release. That's the best time for me to install them.
* In some cases, if you don't follow these guidelines, your
information might still be useful, but I might have to do more work to
make use of it. Unfortunately, I am so far behind in my work that I
just can't get the job done unless you help me to do it efficiently.
Thank you
rms
Local Variables:
mode: text
End:

1460
gcc/SERVICE Normal file
View file

File diff suppressed because it is too large Load diff

39
gcc/TESTS.FLUNK Normal file
View file

@ -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.

980
gcc/bi-parser.c Normal file
View file

@ -0,0 +1,980 @@
/* A Bison parser, made from bi-parser.y with Bison version GNU Bison version 1.24
*/
#define YYBISON 1 /* Identify Bison output. */
#define DEFOP 258
#define STRING 259
#line 22 "bi-parser.y"
#include <stdio.h>
#include "hconfig.h"
#include "bi-defs.h"
extern char yytext[];
extern int yyleng;
/* Chain of all defs built by the parser. */
struct def *defs;
int ndefs;
static struct node *makenode ();
static struct variation *makevar ();
static struct def *makedef ();
void yyerror ();
#line 44 "bi-parser.y"
typedef union
{
char *string;
struct def *def;
struct variation *variation;
struct node *node;
} YYSTYPE;
#ifndef YYLTYPE
typedef
struct yyltype
{
int timestamp;
int first_line;
int first_column;
int last_line;
int last_column;
char *text;
}
yyltype;
#define YYLTYPE yyltype
#endif
#include <stdio.h>
#ifndef __cplusplus
#ifndef __STDC__
#define const
#endif
#endif
#define YYFINAL 39
#define YYFLAG -32768
#define YYNTBASE 8
#define YYTRANSLATE(x) ((unsigned)(x) <= 259 ? yytranslate[x] : 17)
static const char yytranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 5,
7, 2, 2, 6, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 1, 2, 3, 4
};
#if YYDEBUG != 0
static const short yyprhs[] = { 0,
0, 2, 4, 7, 18, 20, 24, 28, 34, 42,
52, 53, 55, 59, 60, 62, 66
};
static const short yyrhs[] = { 9,
0, 10, 0, 9, 10, 0, 3, 5, 4, 6,
13, 6, 5, 11, 7, 7, 0, 12, 0, 11,
6, 12, 0, 5, 13, 7, 0, 5, 13, 6,
14, 7, 0, 5, 13, 6, 14, 6, 14, 7,
0, 5, 13, 6, 14, 6, 14, 6, 14, 7,
0, 0, 4, 0, 5, 15, 7, 0, 0, 16,
0, 16, 6, 15, 0, 4, 0
};
#endif
#if YYDEBUG != 0
static const short yyrline[] = { 0,
60, 65, 67, 71, 76, 78, 82, 85, 87, 89,
93, 95, 98, 101, 105, 108, 112
};
static const char * const yytname[] = { "$","error","$undefined.","DEFOP",
"STRING","'('","','","')'","top","defs","def","variations","variation","opt_string",
"list","items","item",""
};
#endif
static const short yyr1[] = { 0,
8, 9, 9, 10, 11, 11, 12, 12, 12, 12,
13, 13, 14, 14, 15, 15, 16
};
static const short yyr2[] = { 0,
1, 1, 2, 10, 1, 3, 3, 5, 7, 9,
0, 1, 3, 0, 1, 3, 1
};
static const short yydefact[] = { 0,
0, 1, 2, 0, 3, 0, 11, 12, 0, 0,
0, 11, 0, 5, 0, 0, 0, 14, 7, 6,
4, 0, 0, 17, 0, 15, 14, 8, 13, 0,
0, 16, 14, 9, 0, 10, 0, 0, 0
};
static const short yydefgoto[] = { 37,
2, 3, 13, 14, 9, 23, 25, 26
};
static const short yypact[] = { 2,
6, 2,-32768, 8,-32768, 7, 10,-32768, 9, 11,
12, 10, -5,-32768, -3, 12, 13, 14,-32768,-32768,
-32768, 17, 1,-32768, 15, 18, 14,-32768,-32768, 17,
3,-32768, 14,-32768, 16,-32768, 25, 26,-32768
};
static const short yypgoto[] = {-32768,
-32768, 27,-32768, 19, 20, -27, -12,-32768
};
#define YYLAST 35
static const short yytable[] = { 31,
16, 17, 18, 19, 1, 35, 27, 28, 33, 34,
4, 6, 7, 8, 10, 11, 12, 32, 22, 21,
24, 29, 36, 30, 38, 39, 0, 0, 5, 0,
0, 15, 0, 0, 20
};
static const short yycheck[] = { 27,
6, 7, 6, 7, 3, 33, 6, 7, 6, 7,
5, 4, 6, 4, 6, 5, 5, 30, 5, 7,
4, 7, 7, 6, 0, 0, -1, -1, 2, -1,
-1, 12, -1, -1, 16
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
#line 3 "/usr/local/share/bison.simple"
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
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, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
#ifndef alloca
#ifdef __GNUC__
#define alloca __builtin_alloca
#else /* not GNU C. */
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
#include <alloca.h>
#else /* not sparc */
#if defined (MSDOS) && !defined (__TURBOC__)
#include <malloc.h>
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
#include <malloc.h>
#pragma alloca
#else /* not MSDOS, __TURBOC__, or _AIX */
#ifdef __hpux
#ifdef __cplusplus
extern "C" {
void *alloca (unsigned int);
};
#else /* not __cplusplus */
void *alloca ();
#endif /* not __cplusplus */
#endif /* __hpux */
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
#endif /* not sparc. */
#endif /* not GNU C. */
#endif /* alloca not defined. */
/* This is the parser code that is written into each bison parser
when the %semantic_parser declaration is not specified in the grammar.
It was written by Richard Stallman by simplifying the hairy parser
used when %semantic_parser is specified. */
/* Note: there must be only one dollar sign in this file.
It is replaced by the list of actions, each action
as one case of the switch. */
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY -2
#define YYEOF 0
#define YYACCEPT return(0)
#define YYABORT return(1)
#define YYERROR goto yyerrlab1
/* Like YYERROR except do call yyerror.
This remains here temporarily to ease the
transition to the new meaning of YYERROR, for GCC.
Once GCC version 2 has supplanted version 1, this can go. */
#define YYFAIL goto yyerrlab
#define YYRECOVERING() (!!yyerrstatus)
#define YYBACKUP(token, value) \
do \
if (yychar == YYEMPTY && yylen == 1) \
{ yychar = (token), yylval = (value); \
yychar1 = YYTRANSLATE (yychar); \
YYPOPSTACK; \
goto yybackup; \
} \
else \
{ yyerror ("syntax error: cannot back up"); YYERROR; } \
while (0)
#define YYTERROR 1
#define YYERRCODE 256
#ifndef YYPURE
#define YYLEX yylex()
#endif
#ifdef YYPURE
#ifdef YYLSP_NEEDED
#ifdef YYLEX_PARAM
#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
#else
#define YYLEX yylex(&yylval, &yylloc)
#endif
#else /* not YYLSP_NEEDED */
#ifdef YYLEX_PARAM
#define YYLEX yylex(&yylval, YYLEX_PARAM)
#else
#define YYLEX yylex(&yylval)
#endif
#endif /* not YYLSP_NEEDED */
#endif
/* If nonreentrant, generate the variables here */
#ifndef YYPURE
int yychar; /* the lookahead symbol */
YYSTYPE yylval; /* the semantic value of the */
/* lookahead symbol */
#ifdef YYLSP_NEEDED
YYLTYPE yylloc; /* location data for the lookahead */
/* symbol */
#endif
int yynerrs; /* number of parse errors so far */
#endif /* not YYPURE */
#if YYDEBUG != 0
int yydebug; /* nonzero means print parse trace */
/* Since this is uninitialized, it does not stop multiple parsers
from coexisting. */
#endif
/* YYINITDEPTH indicates the initial size of the parser's stacks */
#ifndef YYINITDEPTH
#define YYINITDEPTH 200
#endif
/* YYMAXDEPTH is the maximum size the stacks can grow to
(effective only if the built-in stack extension method is used). */
#if YYMAXDEPTH == 0
#undef YYMAXDEPTH
#endif
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 10000
#endif
/* Prevent warning if -Wstrict-prototypes. */
#ifdef __GNUC__
int yyparse (void);
#endif
#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
#define __yy_memcpy(FROM,TO,COUNT) __builtin_memcpy(TO,FROM,COUNT)
#else /* not GNU C or C++ */
#ifndef __cplusplus
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
__yy_memcpy (from, to, count)
char *from;
char *to;
int count;
{
register char *f = from;
register char *t = to;
register int i = count;
while (i-- > 0)
*t++ = *f++;
}
#else /* __cplusplus */
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
__yy_memcpy (char *from, char *to, int count)
{
register char *f = from;
register char *t = to;
register int i = count;
while (i-- > 0)
*t++ = *f++;
}
#endif
#endif
#line 192 "/usr/local/share/bison.simple"
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
It should actually point to an object.
Grammar actions can access the variable by casting it
to the proper pointer type. */
#ifdef YYPARSE_PARAM
#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
#else
#define YYPARSE_PARAM
#define YYPARSE_PARAM_DECL
#endif
int
yyparse(YYPARSE_PARAM)
YYPARSE_PARAM_DECL
{
register int yystate;
register int yyn;
register short *yyssp;
register YYSTYPE *yyvsp;
int yyerrstatus; /* number of tokens to shift before error messages enabled */
int yychar1 = 0; /* lookahead token as an internal (translated) token number */
short yyssa[YYINITDEPTH]; /* the state stack */
YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
short *yyss = yyssa; /* refer to the stacks thru separate pointers */
YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
#ifdef YYLSP_NEEDED
YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
YYLTYPE *yyls = yylsa;
YYLTYPE *yylsp;
#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
#else
#define YYPOPSTACK (yyvsp--, yyssp--)
#endif
int yystacksize = YYINITDEPTH;
#ifdef YYPURE
int yychar;
YYSTYPE yylval;
int yynerrs;
#ifdef YYLSP_NEEDED
YYLTYPE yylloc;
#endif
#endif
YYSTYPE yyval; /* the variable used to return */
/* semantic values from the action */
/* routines */
int yylen;
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Starting parse\n");
#endif
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
yyssp = yyss - 1;
yyvsp = yyvs;
#ifdef YYLSP_NEEDED
yylsp = yyls;
#endif
/* Push a new state, which is found in yystate . */
/* In all cases, when you get here, the value and location stacks
have just been pushed. so pushing a state here evens the stacks. */
yynewstate:
*++yyssp = yystate;
if (yyssp >= yyss + yystacksize - 1)
{
/* Give user a chance to reallocate the stack */
/* Use copies of these so that the &'s don't force the real ones into memory. */
YYSTYPE *yyvs1 = yyvs;
short *yyss1 = yyss;
#ifdef YYLSP_NEEDED
YYLTYPE *yyls1 = yyls;
#endif
/* Get the current used size of the three stacks, in elements. */
int size = yyssp - yyss + 1;
#ifdef yyoverflow
/* Each stack pointer address is followed by the size of
the data in use in that stack, in bytes. */
#ifdef YYLSP_NEEDED
/* This used to be a conditional around just the two extra args,
but that might be undefined if yyoverflow is a macro. */
yyoverflow("parser stack overflow",
&yyss1, size * sizeof (*yyssp),
&yyvs1, size * sizeof (*yyvsp),
&yyls1, size * sizeof (*yylsp),
&yystacksize);
#else
yyoverflow("parser stack overflow",
&yyss1, size * sizeof (*yyssp),
&yyvs1, size * sizeof (*yyvsp),
&yystacksize);
#endif
yyss = yyss1; yyvs = yyvs1;
#ifdef YYLSP_NEEDED
yyls = yyls1;
#endif
#else /* no yyoverflow */
/* Extend the stack our own way. */
if (yystacksize >= YYMAXDEPTH)
{
yyerror("parser stack overflow");
return 2;
}
yystacksize *= 2;
if (yystacksize > YYMAXDEPTH)
yystacksize = YYMAXDEPTH;
yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
__yy_memcpy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
__yy_memcpy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
#ifdef YYLSP_NEEDED
yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
__yy_memcpy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
#endif
#endif /* no yyoverflow */
yyssp = yyss + size - 1;
yyvsp = yyvs + size - 1;
#ifdef YYLSP_NEEDED
yylsp = yyls + size - 1;
#endif
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Stack size increased to %d\n", yystacksize);
#endif
if (yyssp >= yyss + yystacksize - 1)
YYABORT;
}
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Entering state %d\n", yystate);
#endif
goto yybackup;
yybackup:
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
/* yyresume: */
/* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yydefault;
/* Not known => get a lookahead token if don't already have one. */
/* yychar is either YYEMPTY or YYEOF
or a valid token in external form. */
if (yychar == YYEMPTY)
{
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Reading a token: ");
#endif
yychar = YYLEX;
}
/* Convert token to internal form (in yychar1) for indexing tables with */
if (yychar <= 0) /* This means end of input. */
{
yychar1 = 0;
yychar = YYEOF; /* Don't call YYLEX any more */
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Now at end of input.\n");
#endif
}
else
{
yychar1 = YYTRANSLATE(yychar);
#if YYDEBUG != 0
if (yydebug)
{
fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
/* Give the individual parser a way to print the precise meaning
of a token, for further debugging info. */
#ifdef YYPRINT
YYPRINT (stderr, yychar, yylval);
#endif
fprintf (stderr, ")\n");
}
#endif
}
yyn += yychar1;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
goto yydefault;
yyn = yytable[yyn];
/* yyn is what to do for this token type in this state.
Negative => reduce, -yyn is rule number.
Positive => shift, yyn is new state.
New state is final state => don't bother to shift,
just return success.
0, or most negative number => error. */
if (yyn < 0)
{
if (yyn == YYFLAG)
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrlab;
if (yyn == YYFINAL)
YYACCEPT;
/* Shift the lookahead token. */
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
#endif
/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;
*++yyvsp = yylval;
#ifdef YYLSP_NEEDED
*++yylsp = yylloc;
#endif
/* count tokens shifted since error; after three, turn off error status. */
if (yyerrstatus) yyerrstatus--;
yystate = yyn;
goto yynewstate;
/* Do the default action for the current state. */
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
/* Do a reduction. yyn is the number of a rule to reduce with. */
yyreduce:
yylen = yyr2[yyn];
if (yylen > 0)
yyval = yyvsp[1-yylen]; /* implement default value of the action */
#if YYDEBUG != 0
if (yydebug)
{
int i;
fprintf (stderr, "Reducing via rule %d (line %d), ",
yyn, yyrline[yyn]);
/* Print the symbols being reduced, and their result. */
for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
fprintf (stderr, "%s ", yytname[yyrhs[i]]);
fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
}
#endif
switch (yyn) {
case 1:
#line 62 "bi-parser.y"
{ defs = yyvsp[0].def; ;
break;}
case 3:
#line 68 "bi-parser.y"
{ yyvsp[0].def->next = yyvsp[-1].def; yyval.def = yyvsp[0].def; ;
break;}
case 4:
#line 73 "bi-parser.y"
{ yyval.def = makedef (yyvsp[-7].string, yyvsp[-5].string, yyvsp[-2].variation); ;
break;}
case 6:
#line 79 "bi-parser.y"
{ yyvsp[0].variation->next = yyvsp[-2].variation; yyval.variation = yyvsp[0].variation; ;
break;}
case 7:
#line 84 "bi-parser.y"
{ yyval.variation = makevar (yyvsp[-1].string, (struct node *) NULL, (struct node *) NULL, (struct node *) NULL); ;
break;}
case 8:
#line 86 "bi-parser.y"
{ yyval.variation = makevar (yyvsp[-3].string, yyvsp[-1].node, (struct node *) NULL, (struct node *) NULL); ;
break;}
case 9:
#line 88 "bi-parser.y"
{ yyval.variation = makevar (yyvsp[-5].string, yyvsp[-3].node, yyvsp[-1].node, (struct node *) NULL); ;
break;}
case 10:
#line 90 "bi-parser.y"
{ yyval.variation = makevar (yyvsp[-7].string, yyvsp[-5].node, yyvsp[-3].node, yyvsp[-1].node); ;
break;}
case 11:
#line 94 "bi-parser.y"
{ yyval.string = ""; ;
break;}
case 12:
#line 95 "bi-parser.y"
{ yyval.string = yyvsp[0].string; ;
break;}
case 13:
#line 100 "bi-parser.y"
{ yyval.node = yyvsp[-1].node; ;
break;}
case 14:
#line 102 "bi-parser.y"
{ yyval.node = NULL; ;
break;}
case 16:
#line 109 "bi-parser.y"
{ yyvsp[-2].node->next = yyvsp[0].node; yyval.node = yyvsp[-2].node; ;
break;}
case 17:
#line 114 "bi-parser.y"
{ yyval.node = makenode (yyvsp[0].string); ;
break;}
}
/* the action file gets copied in in place of this dollarsign */
#line 487 "/usr/local/share/bison.simple"
yyvsp -= yylen;
yyssp -= yylen;
#ifdef YYLSP_NEEDED
yylsp -= yylen;
#endif
#if YYDEBUG != 0
if (yydebug)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif
*++yyvsp = yyval;
#ifdef YYLSP_NEEDED
yylsp++;
if (yylen == 0)
{
yylsp->first_line = yylloc.first_line;
yylsp->first_column = yylloc.first_column;
yylsp->last_line = (yylsp-1)->last_line;
yylsp->last_column = (yylsp-1)->last_column;
yylsp->text = 0;
}
else
{
yylsp->last_line = (yylsp+yylen-1)->last_line;
yylsp->last_column = (yylsp+yylen-1)->last_column;
}
#endif
/* Now "shift" the result of the reduction.
Determine what state that goes to,
based on the state we popped back to
and the rule number reduced by. */
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTBASE];
goto yynewstate;
yyerrlab: /* here on detecting error */
if (! yyerrstatus)
/* If not already recovering from an error, report this error. */
{
++yynerrs;
#ifdef YYERROR_VERBOSE
yyn = yypact[yystate];
if (yyn > YYFLAG && yyn < YYLAST)
{
int size = 0;
char *msg;
int x, count;
count = 0;
/* Start X at -yyn if nec to avoid negative indexes in yycheck. */
for (x = (yyn < 0 ? -yyn : 0);
x < (sizeof(yytname) / sizeof(char *)); x++)
if (yycheck[x + yyn] == x)
size += strlen(yytname[x]) + 15, count++;
msg = (char *) malloc(size + 15);
if (msg != 0)
{
strcpy(msg, "parse error");
if (count < 5)
{
count = 0;
for (x = (yyn < 0 ? -yyn : 0);
x < (sizeof(yytname) / sizeof(char *)); x++)
if (yycheck[x + yyn] == x)
{
strcat(msg, count == 0 ? ", expecting `" : " or `");
strcat(msg, yytname[x]);
strcat(msg, "'");
count++;
}
}
yyerror(msg);
free(msg);
}
else
yyerror ("parse error; also virtual memory exceeded");
}
else
#endif /* YYERROR_VERBOSE */
yyerror("parse error");
}
goto yyerrlab1;
yyerrlab1: /* here on error raised explicitly by an action */
if (yyerrstatus == 3)
{
/* if just tried and failed to reuse lookahead token after an error, discard it. */
/* return failure if at end of input */
if (yychar == YYEOF)
YYABORT;
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
#endif
yychar = YYEMPTY;
}
/* Else will try to reuse lookahead token
after shifting the error token. */
yyerrstatus = 3; /* Each real token shifted decrements this */
goto yyerrhandle;
yyerrdefault: /* current state does not do anything special for the error token. */
#if 0
/* This is wrong; only states that explicitly want error tokens
should shift them. */
yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
if (yyn) goto yydefault;
#endif
yyerrpop: /* pop the current state because it cannot handle the error token */
if (yyssp == yyss) YYABORT;
yyvsp--;
yystate = *--yyssp;
#ifdef YYLSP_NEEDED
yylsp--;
#endif
#if YYDEBUG != 0
if (yydebug)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "Error: state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif
yyerrhandle:
yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yyerrdefault;
yyn += YYTERROR;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
goto yyerrdefault;
yyn = yytable[yyn];
if (yyn < 0)
{
if (yyn == YYFLAG)
goto yyerrpop;
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrpop;
if (yyn == YYFINAL)
YYACCEPT;
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Shifting error token, ");
#endif
*++yyvsp = yylval;
#ifdef YYLSP_NEEDED
*++yylsp = yylloc;
#endif
yystate = yyn;
goto yynewstate;
}
#line 117 "bi-parser.y"
static struct node *
makenode (s)
char *s;
{
struct node *n;
n = (struct node *) malloc (sizeof (struct node));
n->text = s;
n->next = NULL;
return n;
}
static struct variation *
makevar (name, inputs, outputs, literals)
char *name;
struct node *inputs, *outputs, *literals;
{
struct variation *v;
v = (struct variation *) malloc (sizeof (struct variation));
v->name = name;
v->code = ndefs++;
v->inputs = inputs;
v->outputs = outputs;
v->literals = literals;
v->next = NULL;
return v;
}
static struct def *
makedef (name, template, vars)
char *name, *template;
struct variation *vars;
{
struct def *d;
d = (struct def *) malloc (sizeof (struct def));
d->basename = name;
d->template = template;
d->variations = vars;
d->next = NULL;
return d;
}
void
yyerror (s)
char *s;
{
fprintf (stderr, "syntax error in input\n");
exit (FATAL_EXIT_CODE);
}

12
gcc/bi-parser.h Normal file
View file

@ -0,0 +1,12 @@
typedef union
{
char *string;
struct def *def;
struct variation *variation;
struct node *node;
} YYSTYPE;
#define DEFOP 258
#define STRING 259
extern YYSTYPE yylval;

25
gcc/c-decl.c
View file

@ -4339,7 +4339,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 +4353,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 +4363,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;

186
gcc/c-gperf.h Normal file
View file

@ -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;
}

3859
gcc/c-parse.c Normal file
View file

File diff suppressed because it is too large Load diff

64
gcc/c-parse.h Normal file
View file

@ -0,0 +1,64 @@
typedef union {long itype; tree ttype; enum tree_code code;
char *filename; int lineno; int ends_in_label; } YYSTYPE;
#define IDENTIFIER 258
#define TYPENAME 259
#define SCSPEC 260
#define TYPESPEC 261
#define TYPE_QUAL 262
#define CONSTANT 263
#define STRING 264
#define ELLIPSIS 265
#define SIZEOF 266
#define ENUM 267
#define STRUCT 268
#define UNION 269
#define IF 270
#define ELSE 271
#define WHILE 272
#define DO 273
#define FOR 274
#define SWITCH 275
#define CASE 276
#define DEFAULT 277
#define BREAK 278
#define CONTINUE 279
#define RETURN 280
#define GOTO 281
#define ASM_KEYWORD 282
#define TYPEOF 283
#define ALIGNOF 284
#define ATTRIBUTE 285
#define EXTENSION 286
#define LABEL 287
#define REALPART 288
#define IMAGPART 289
#define ASSIGN 290
#define OROR 291
#define ANDAND 292
#define EQCOMPARE 293
#define ARITHCOMPARE 294
#define LSHIFT 295
#define RSHIFT 296
#define UNARY 297
#define PLUSPLUS 298
#define MINUSMINUS 299
#define HYPERUNARY 300
#define POINTSAT 301
#define INTERFACE 302
#define IMPLEMENTATION 303
#define END 304
#define SELECTOR 305
#define DEFS 306
#define ENCODE 307
#define CLASSNAME 308
#define PUBLIC 309
#define PRIVATE 310
#define PROTECTED 311
#define PROTOCOL 312
#define OBJECTNAME 313
#define CLASS 314
#define ALIAS 315
#define OBJC_STRING 316
extern YYSTYPE yylval;

2176
gcc/c-parse.y Normal file
View file

File diff suppressed because it is too large Load diff

674
gcc/cccp.1 Normal file
View file

@ -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.

2142
gcc/cexp.c Normal file
View file

File diff suppressed because it is too large Load diff

32
gcc/config.in Normal file
View file

@ -0,0 +1,32 @@
/* config.in. Generated automatically from configure.in by autoheader. */
/* Include the old config.h as config2.h to simplify the transition
to autoconf. */
#include "config2.h"
/* Whether malloc must be declared even if <stdlib.h> is included. */
#undef NEED_DECLARATION_MALLOC
/* Whether realloc must be declared even if <stdlib.h> is included. */
#undef NEED_DECLARATION_REALLOC
/* Whether free must be declared even if <stdlib.h> is included. */
#undef NEED_DECLARATION_FREE
/* Define if you have the <stddef.h> header file. */
#undef HAVE_STDDEF_H
/* Define if you have the <stdlib.h> header file. */
#undef HAVE_STDLIB_H
/* Define if you have the <string.h> header file. */
#undef HAVE_STRING_H
/* Define if you have the <strings.h> header file. */
#undef HAVE_STRINGS_H
/* Define if you have the <time.h> header file. */
#undef HAVE_TIME_H
/* Define if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H

43
gcc/config/a29k/xm-unix.h Normal file
View file

@ -0,0 +1,43 @@
/* Configuration for GNU C-compiler for AMD Am29000 processor.
Copyright (C) 1987, 1988, 1993 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
#define HOST_WORDS_BIG_ENDIAN
/* 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
/* Ultra is V7, which is closest to USG. */
#define USG

17
gcc/config/alpha/alpha.h
View file

@ -267,6 +267,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

3
gcc/config/alpha/xm-linux.h Normal file
View file

@ -0,0 +1,3 @@
#define HAVE_STRERROR
#define DONT_DECLARE_SYS_SIGLIST
#define USE_BFD

24
gcc/config/arm/xm-linux.h Normal file
View file

@ -0,0 +1,24 @@
/* Configuration for GCC for Intel i386 running Linux.
Copyright (C) 1993, 1994, 1995, 1997 Free Software Foundation, Inc.
Contributed by H.J. Lu (hjl@nynexst.com)
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <arm/xm-arm.h>
#include <xm-linux.h>

10
gcc/config/arm/xm-netbsd.h Normal file
View file

@ -0,0 +1,10 @@
/* Configuration for GCC for ARM running NetBSD as host. */
#include <arm/xm-arm.h>
/* xm-netbsd.h defines this */
#ifdef HAVE_VPRINTF
#undef HAVE_VPRINTF
#endif
#include <xm-netbsd.h>

2
gcc/config/i386/dgux.h
View file

@ -25,7 +25,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "i386/sysv4.h"
#ifndef VERSION_INFO2
#define VERSION_INFO2 "$Revision: 1.5 $"
#define VERSION_INFO2 "$Revision: 1.1 $"
#endif
#ifndef VERSION_STRING

11
gcc/config/i386/xm-bsd386.h Normal file
View file

@ -0,0 +1,11 @@
/* Configuration for GCC for Intel i386 running BSDI's BSD/386 as host. */
#include "i386/xm-i386.h"
#define HAVE_STRERROR
/* We have _sys_siglist, but the declaration in <signal.h> conflicts with
the declarations in collect2.c so disable the declarations
in those files. */
#define DONT_DECLARE_SYS_SIGLIST

12
gcc/config/i386/xm-dgux.h Normal file
View file

@ -0,0 +1,12 @@
/* Configuration for GCC for Intel i386 running DG/ux */
/* looks just like sysv4 for now */
#include "i386/xm-i386.h"
#include "xm-svr4.h"
/* If not compiled with GNU C, use the portable alloca. */
#ifndef __GNUC__
#define USE_C_ALLOCA
#endif

4
gcc/config/i386/xm-freebsd.h Normal file
View file

@ -0,0 +1,4 @@
/* Configuration for GCC for Intel i386 running FreeBSD as host. */
#include <i386/xm-i386.h>
#include <xm-freebsd.h>

5
gcc/config/i386/xm-gnu.h Normal file
View file

@ -0,0 +1,5 @@
/* Configuration for GCC for Intel i386 running GNU as host. */
#include <i386/xm-i386.h>
#include <xm-gnu.h>

24
gcc/config/i386/xm-linux.h Normal file
View file

@ -0,0 +1,24 @@
/* Configuration for GCC for Intel i386 running Linux.
Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
Contributed by H.J. Lu (hjl@nynexst.com)
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <i386/xm-i386.h>
#include <xm-linux.h>

4
gcc/config/i386/xm-netbsd.h Normal file
View file

@ -0,0 +1,4 @@
/* Configuration for GCC for Intel i386 running NetBSD as host. */
#include <i386/xm-i386.h>
#include <xm-netbsd.h>

27
gcc/config/i386/xm-sun.h Normal file
View file

@ -0,0 +1,27 @@
/* Configuration for GNU C-compiler for Intel 80386 running SunOS 4.0.
Copyright (C) 1988 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. */
#define USG
#include "i386/xm-i386.h"
#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)

4
gcc/config/i386/xm-sysv3.h Normal file
View file

@ -0,0 +1,4 @@
/* Configuration for GCC for Intel i386 running System V Release 3. */
#include "i386/xm-i386.h"
#include "xm-svr3.h"

24
gcc/config/i386/xm-winnt.h Normal file
View file

@ -0,0 +1,24 @@
/* Configuration for GNU compiler
for an Intel i386 or later processor running Windows NT 3.x.
Copyright (C) 1994 Free Software Foundation, Inc.
Contributed by Douglas B. Rupp (drupp@cs.washington.edu)
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. */
#include "winnt/xm-winnt.h"
#include "i386/xm-i386.h"

6
gcc/config/i860/i860.h
View file

@ -1,6 +1,6 @@
/* Definitions of target machine for GNU compiler, for Intel 860.
Copyright (C) 1989, 1991, 1993, 1995, 1996 Free Software Foundation, Inc.
Hacked substantially by Ron Guilmette (rfg@segfault.us.com) to cater to
Copyright (C) 1989, 91, 93, 95, 96, 1997 Free Software Foundation, Inc.
Hacked substantially by Ron Guilmette (rfg@monkeys.com) to cater to
the whims of the System V Release 4 assembler.
This file is part of GNU CC.
@ -1369,7 +1369,7 @@ extern unsigned long sfmode_constant_to_ulong ();
stack (where the i860 calling conventions require structs &
unions to be passed). */
#define FLOAT_TYPE_VALUE float
#define FLOAT_VALUE_TYPE float
#define INTIFY(FLOATVAL) (FLOATVAL)
#define FLOATIFY(INTVAL) (INTVAL)
#define FLOAT_ARG_TYPE float

7
gcc/config/i860/xm-fx2800.h Normal file
View file

@ -0,0 +1,7 @@
/* Alliant FX/2800 running Concentrix 2.x. */
/* vfprintf is not present prior to Concentrix 2.2. Unfortunately, there
does not seem to be a cpp symbol that identifies OS revision. Undefine
the following if running 2.1 or older. */
#define HAVE_VPRINTF

2
gcc/config/m68k/mot3300-crt0.S
View file

@ -97,7 +97,7 @@ LOCAL_LABEL(isatty):
#ifdef STRING
SECTION (.comment)
STRING ("$Id: crt0.S,v 1.6 1995/12/07 17:17:47 manfred Exp $\n")
STRING ("$Id: mot3300-crt0.S,v 1.1 1997/08/11 15:57:32 law Exp $\n")
STRING ("Contributed by manfred@lts.sel.alcatel.de (Manfred Hollstein, Germany)\n")
#else
byte 'C,'o,'n,'t,'r,'i,'b,'u,'t,'e,'d,' ,'b,'y

2
gcc/config/m68k/mot3300Mcrt0.S
View file

@ -143,7 +143,7 @@ LOCAL_LABEL(endofstart):
#ifdef STRING
SECTION (.comment)
STRING ("$Id: mcrt0.S,v 1.5 1995/12/07 17:23:39 manfred Exp $\n")
STRING ("$Id: mot3300Mcrt0.S,v 1.1 1997/08/11 15:57:32 law Exp $\n")
STRING ("Contributed by manfred@lts.sel.alcatel.de (Manfred Hollstein, Germany)\n")
#else
byte 'C,'o,'n,'t,'r,'i,'b,'u,'t,'e,'d,' ,'b,'y

7
gcc/config/m68k/xm-altos3068.h Normal file
View file

@ -0,0 +1,7 @@
#define USG
#include "m68k/xm-m68k.h"
#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)

47
gcc/config/m68k/xm-amix.h Normal file
View file

@ -0,0 +1,47 @@
/* Definitions of host machine for GNU compiler.
Commodore Amiga A3000UX version.
Copyright (C) 1991 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 1, 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. */
#include "m68k/xm-m68kv.h" /* Use the System V flavor of m68k host */
#define HAVE_VPRINTF /* Host has vprintf() in library */
#define rindex strrchr
#define index strchr
/* Define FULL_PROTOTYPES for protoize.c, to get <unistd.h> included.
We need this file for things like R_OK, not necessarily prototypes. */
#define FULL_PROTOTYPES
#if defined (__GNUC__) && __GNUC__ == 1
#define alloca __builtin_alloca
#endif
#if 0 /* I don't want individual ports to be inconsistent about this.
I regard fancy_abort as a half-solution and not the right way
to do things. --rms. */
/* The m88k and mips ports make use of fancy_abort to give possibly helpful
abort information rather than just dumping core. They do it in their
tm-* files. It seems more logical that this is a characteristic of
the host machine and not the target machine, so we do it here. */
#define abort fancy_abort /* give possibly helpful abort info */
#endif

9
gcc/config/m68k/xm-aux.h Normal file
View file

@ -0,0 +1,9 @@
#ifndef USG
#define USG
#endif
#ifndef AUX
#define AUX
#endif
#include "m68k/xm-m68k.h"

19
gcc/config/m68k/xm-hp320.h Normal file
View file

@ -0,0 +1,19 @@
/* USG is needed to prevent trying to use getrusage and getwd. */
#define USG
#include "m68k/xm-m68k.h"
#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 rindex strrchr
#define index strchr
/* If compiling with HPUX compiler, we are probably using alloca.c,
so help it work right. */
#ifndef __GNUC__
#define USE_C_ALLOCA
#endif
/* Don't try to use sys_siglist. */
#define NO_SYS_SIGLIST

4
gcc/config/m68k/xm-linux.h Normal file
View file

@ -0,0 +1,4 @@
/* Configuration for GCC for Motorola m68k running Linux. */
#include <m68k/xm-m68k.h>
#include <xm-linux.h>

15
gcc/config/m68k/xm-m68kv.h Normal file
View file

@ -0,0 +1,15 @@
/* Host environment for 68000's running System V. */
#include "m68k/xm-m68k.h"
#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 rindex strrchr
#define index strchr
#ifndef __GNUC__
#define USE_C_ALLOCA
#endif

4
gcc/config/m68k/xm-netbsd.h Normal file
View file

@ -0,0 +1,4 @@
/* Configuration for GCC for Motorola 68k running NetBSD as host. */
#include <m68k/xm-m68k.h>
#include <xm-netbsd.h>

5
gcc/config/m68k/xm-sun3.h Normal file
View file

@ -0,0 +1,5 @@
/* Configuration for GCC for Motorola m68k on sun3. */
#define HAVE_POPEN
#include "m68k/xm-m68k.h"

4
gcc/config/m68k/xm-tower.h Normal file
View file

@ -0,0 +1,4 @@
#include "m68k/xm-m68k.h"
#include "xm-svr3.h"
#define HAVE_VPRINTF

2
gcc/config/m88k/dgux.h
View file

@ -30,7 +30,7 @@ Boston, MA 02111-1307, USA. */
(TARGET_SVR4 ? DWARF_DEBUG : SDB_DEBUG)
#ifndef VERSION_INFO2
#define VERSION_INFO2 "$Revision: 1.23 $"
#define VERSION_INFO2 "$Revision: 1.24 $"
#endif
#ifndef NO_BUGS
#define AS_BUG_IMMEDIATE_LABEL

4
gcc/config/m88k/m88k.h
View file

@ -198,13 +198,13 @@ extern char * reg_names[];
Redefined in sysv4.h, and luna.h. */
#define VERSION_INFO1 "m88k, "
#ifndef VERSION_INFO2
#define VERSION_INFO2 "$Revision: 1.72 $"
#define VERSION_INFO2 "$Revision: 1.1 $"
#endif
#ifndef VERSION_STRING
#define VERSION_STRING version_string
#ifdef __STDC__
#define TM_RCS_ID "@(#)" __FILE__ " $Revision: 1.72 $ " __DATE__
#define TM_RCS_ID "@(#)" __FILE__ " $Revision: 1.1 $ " __DATE__
#else
#define TM_RCS_ID "$What: <@(#) m88k.h,v 1.1.1.2.2.2> $"
#endif /* __STDC__ */

24
gcc/config/mips/elflorion.h Normal file
View file

@ -0,0 +1,24 @@
/* Definitions of target machine for GNU compiler. MIPS ORION version with
GOFAST floating point library.
Copyright (C) 1994 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. */
#define MIPS_CPU_STRING_DEFAULT "orion"
#include "mips/elfl64.h"

36
gcc/config/mips/nws3250v4.h Normal file
View file

@ -0,0 +1,36 @@
/* Definitions of target machine for GNU compiler. Sony RISC NEWS (mips)
Copyright (C) 1991 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. */
#define MIPS_NEWS
#define CPP_PREDEFINES "\
-Dmips -Dhost_mips -Dsony -Dsonyrisc -Dunix \
-DLANGUAGE_C -DMIPSEB -DSYSTYPE_SYSV \
-Asystem(unix) -Asystem(svr3) -Acpu(mips) -Amachine(mips)"
#define MD_STARTFILE_PREFIX "/usr/ccs/lib/"
#define LIB_SPEC "%{p:-lprof1} %{pg:-lprof1} -lc crtn.o%s values-Xt.o%s"
#define STARTFILE_SPEC "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt1.o%s}}"
#define MACHINE_TYPE "RISC NEWS-OS SVr4"
#include "mips/mips.h"

8
gcc/config/mips/xm-iris3.h Normal file
View file

@ -0,0 +1,8 @@
#include "mips/xm-mips.h"
#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)

18
gcc/config/mips/xm-iris4.h Normal file
View file

@ -0,0 +1,18 @@
#include "mips/xm-mips.h"
#define USG
#define HAVE_VPRINTF
#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)
#if 0
#ifdef __GNUC__
/* The normal irix compiler requires alloca.h or alloca doesn't work.
However, the IRIX compiler doesn't allow alloca to be stored in
something like ptr->field = alloca(), so we just use the normal
C alloca. */
#include <alloca.h>
#endif
#endif

2
gcc/config/mips/xm-netbsd.h Normal file
View file

@ -0,0 +1,2 @@
#include "mips/xm-mips.h"
#include "config/xm-netbsd.h"

6
gcc/config/mips/xm-news.h Normal file
View file

@ -0,0 +1,6 @@
/* This file is for the Sony Mips News running "NewsOS Version 5",
which is really System V. */
#include "mips/xm-sysv.h"
/* Sony has a funny name for this symbol. */
#define sys_siglist _sys_siglist

9
gcc/config/mips/xm-nws3250v4.h Normal file
View file

@ -0,0 +1,9 @@
#define USG
#include "xm-mips.h"
/* If compiling with mips compiler, we are probably using alloca.c,
so help it work right. */
#ifndef __GNUC__
#define USE_C_ALLOCA
#endif

38
gcc/config/mips/xm-sysv.h Normal file
View file

@ -0,0 +1,38 @@
/* Configuration for GNU C-compiler for UMIPS operating system
Copyright (C) 1989, 1990, 1991 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. */
/*
* Notes for compiling gcc on umips (v3.0)
* - change the -g in the CFLAGS to a -g3 or take it out all together.
* - do not define DBX_DEBUGGING_INFO in tm.h, it doesn't exist (unless
* you get one from a bsd system)
*/
#define USG
#include "mips/xm-mips.h"
#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 rindex strrchr
#define index strchr

11
gcc/config/mips/xm-sysv4.h Normal file
View file

@ -0,0 +1,11 @@
#include "mips/xm-sysv.h"
/* SVR4 provides no sys_siglist,
but does offer the same data under another name. */
#define sys_siglist _sys_siglist
/* There is a declaration in /usr/include/signal.h that conflicts with the
declarations in collect2.c and mips-tfile.c, so disable gcc's declarations.
This is at least true for CDC's EP/IX 2.1.1. It is suspected to be true
for RISC/OS 5.x also. */
#define DONT_DECLARE_SYS_SIGLIST

9
gcc/config/ns32k/xm-genix.h Normal file
View file

@ -0,0 +1,9 @@
/* Config file for ns32k running system V. */
#include "ns32k/xm-ns32k.h"
#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)

10
gcc/config/ns32k/xm-netbsd.h Normal file
View file

@ -0,0 +1,10 @@
/* Configuration for GCC for ns32k running NetBSD as host. */
#include <ns32k/xm-ns32k.h>
/* ns32k/xm-ns32k.h defines these macros, but we don't need them */
#undef memcmp
#undef memcpy
#undef memset
#include <xm-netbsd.h>

4
gcc/config/sparc/xm-netbsd.h Normal file
View file

@ -0,0 +1,4 @@
/* Configuration for GCC for Sun SPARC running NetBSD as host. */
#include <sparc/xm-sparc.h>
#include <xm-netbsd.h>

13
gcc/config/sparc/xm-pbd.h Normal file
View file

@ -0,0 +1,13 @@
/* Host environment for the tti "Unicom" PBB 68020 boards */
#include "sparc/xm-sparc.h"
#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)
#ifndef __GNUC__
#define USE_C_ALLOCA
#endif

3
gcc/config/vax/x-vax Normal file
View file

@ -0,0 +1,3 @@
# If compiling GCC with the Unix assembler, -J will handle a large function.
# With GAS, it should have no effect.
X_CPPFLAGS = -J

7
gcc/config/vax/xm-vaxv.h Normal file
View file

@ -0,0 +1,7 @@
/* Config file for Vax running system V. */
#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)

33
gcc/config/xm-freebsd.h Normal file
View file

@ -0,0 +1,33 @@
/* Configuration for GNU C-compiler for hosts running FreeBSD.
Copyright (C) 1994, 1995 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. */
/* This file defines machine-independent things specific to a host
running FreeBSD. This file should not be specified as $xm_file itself;
instead $xm_file should be CPU/xm-freebsd.h, which should include both
CPU/xm-CPU.h and this file xm-freebsd.h. */
/* FreeBSD has strerror. */
#define HAVE_STRERROR
/* We have _sys_siglist, but the declaration in <signal.h> conflicts with
the declarations in collect2.c and mips-tfile.c, so disable the declarations
in those files. */
#define DONT_DECLARE_SYS_SIGLIST

47
gcc/config/xm-linux.h Normal file
View file

@ -0,0 +1,47 @@
/* Configuration for GCC for Intel i386 running Linux.
Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
Contributed by H.J. Lu (hjl@nynexst.com)
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#undef HAVE_VPRINTF
#define HAVE_VPRINTF
#undef HAVE_STRERROR
#define HAVE_STRERROR
#undef HAVE_POPEN
#define HAVE_POPEN
#undef POSIX
#define POSIX
#undef DONT_DECLARE_SYS_SIGLIST
#define DONT_DECLARE_SYS_SIGLIST
/* We do have one, but I'd like to use the one come with gcc since
we have been doing that for a long time with USG defined. H.J. */
#define NO_STAB_H
#undef BSTRING
#define BSTRING
#undef bcmp
#undef bcopy
#undef bzero
#undef index
#undef rindex

27
gcc/config/xm-netbsd.h Normal file
View file

@ -0,0 +1,27 @@
/* Configuration for GNU C-compiler for hosts running NetBSD.
Copyright (C) 1995 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. */
/* This file defines machine-independent things specific to a host
running NetBSD. This file should not be specified as $xm_file itself;
instead $xm_file should be CPU/xm-netbsd.h, which should include both
CPU/xm-CPU.h and this file xm-netbsd.h. */
#define HAVE_STRERROR
#define HAVE_VPRINTF

33
gcc/config/xm-svr3.h Normal file
View file

@ -0,0 +1,33 @@
/* Configuration for GNU C-compiler for hosts running System V Release 3
Copyright (C) 1991, 1993 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. */
#define bcopy(src,dst,len) memcpy ((dst),(src),(len))
#define bzero(dst,len) memset ((dst),0,(len))
#define bcmp(left,right,len) memcmp ((left),(right),(len))
#define rindex strrchr
#define index strchr
#define USG
#define HAVE_VPRINTF
#ifndef SVR3
#define SVR3
#endif

35
gcc/config/xm-svr4.h Normal file
View file

@ -0,0 +1,35 @@
/* Configuration for GNU C-compiler for hosts running System V Release 4
Copyright (C) 1988 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. */
#define bcopy(src,dst,len) memcpy ((dst),(src),(len))
#define bzero(dst,len) memset ((dst),0,(len))
#define bcmp(left,right,len) memcmp ((left),(right),(len))
#define rindex strrchr
#define index strchr
#define USG
#define HAVE_VPRINTF
#define POSIX
/* SVR4 provides no sys_siglist,
but does offer the same data under another name. */
#define sys_siglist _sys_siglist

4911
gcc/configure vendored Executable file
View file

File diff suppressed because it is too large Load diff

8338
gcc/cp/parse.c Normal file
View file

File diff suppressed because it is too large Load diff

91
gcc/cp/parse.h Normal file
View file

@ -0,0 +1,91 @@
typedef union {long itype; tree ttype; char *strtype; enum tree_code code; flagged_type_tree ftype; } YYSTYPE;
#define IDENTIFIER 258
#define TYPENAME 259
#define SELFNAME 260
#define SCSPEC 261
#define TYPESPEC 262
#define CV_QUALIFIER 263
#define CONSTANT 264
#define STRING 265
#define ELLIPSIS 266
#define SIZEOF 267
#define ENUM 268
#define IF 269
#define ELSE 270
#define WHILE 271
#define DO 272
#define FOR 273
#define SWITCH 274
#define CASE 275
#define DEFAULT 276
#define BREAK 277
#define CONTINUE 278
#define RETURN 279
#define GOTO 280
#define ASM_KEYWORD 281
#define GCC_ASM_KEYWORD 282
#define TYPEOF 283
#define ALIGNOF 284
#define SIGOF 285
#define ATTRIBUTE 286
#define EXTENSION 287
#define LABEL 288
#define REALPART 289
#define IMAGPART 290
#define AGGR 291
#define VISSPEC 292
#define DELETE 293
#define NEW 294
#define THIS 295
#define OPERATOR 296
#define CXX_TRUE 297
#define CXX_FALSE 298
#define NAMESPACE 299
#define TYPENAME_KEYWORD 300
#define USING 301
#define LEFT_RIGHT 302
#define TEMPLATE 303
#define TYPEID 304
#define DYNAMIC_CAST 305
#define STATIC_CAST 306
#define REINTERPRET_CAST 307
#define CONST_CAST 308
#define SCOPE 309
#define EMPTY 310
#define PTYPENAME 311
#define NSNAME 312
#define THROW 313
#define ASSIGN 314
#define OROR 315
#define ANDAND 316
#define MIN_MAX 317
#define EQCOMPARE 318
#define ARITHCOMPARE 319
#define LSHIFT 320
#define RSHIFT 321
#define POINTSAT_STAR 322
#define DOT_STAR 323
#define UNARY 324
#define PLUSPLUS 325
#define MINUSMINUS 326
#define HYPERUNARY 327
#define PAREN_STAR_PAREN 328
#define POINTSAT 329
#define TRY 330
#define CATCH 331
#define TYPENAME_ELLIPSIS 332
#define PRE_PARSED_FUNCTION_DECL 333
#define EXTERN_LANG_STRING 334
#define ALL 335
#define PRE_PARSED_CLASS_DECL 336
#define DEFARG 337
#define DEFARG_MARKER 338
#define TYPENAME_DEFN 339
#define IDENTIFIER_DEFN 340
#define PTYPENAME_DEFN 341
#define END_OF_LINE 342
#define END_OF_SAVED_INPUT 343
extern YYSTYPE yylval;
#define YYEMPTY -2

1
gcc/cstamp-h.in Normal file
View file

@ -0,0 +1 @@
timestamp

4167
gcc/gcc.1 Normal file
View file

File diff suppressed because it is too large Load diff

60
gcc/gcc.c
View file

@ -4302,6 +4302,11 @@ main (argc, argv)
signal (SIGPIPE, fatal_error);
#endif
{ /* Warn users they are using developmental software. */
static void snapshot_warning ();
snapshot_warning ();
}
argbuf_length = 10;
argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
@ -5441,3 +5446,58 @@ print_multilib_info ()
++p;
}
}
/* For snapshots only.
Warn the user that this version of gcc is for testing and developing only.
If this is unix, we can restrict the warning to once per day.
Otherwise always issue it. */
#define TIMESTAMP_FILE ".gcc-test-time"
#define ONE_DAY (24*60*60)
static void
snapshot_warning ()
{
char *home;
int print_p = 1;
#ifdef unix
home = getenv ("HOME");
if (home != NULL)
{
char *file_name = (char *) alloca (strlen (home) + 1 + sizeof (TIMESTAMP_FILE));
struct stat statbuf;
time_t now = time (NULL);
int s;
sprintf (file_name, "%s/%s", home, TIMESTAMP_FILE);
s = stat (file_name, &statbuf);
if (s == 0
&& (statbuf.st_mtime + ONE_DAY > now))
print_p = 0;
else
{
FILE *f;
if ((f = fopen (file_name, "w")) == NULL)
{
/* Ensure we have write access. */
chmod (file_name, s == 0 ? (statbuf.st_mode + 0200) : 0644);
f = fopen (file_name, "w");
}
if (f != NULL)
{
fputc ('\n', f);
fclose (f);
}
}
}
#endif
if (print_p)
{
fprintf (stderr, "*** This is a development snapshot of GCC.\n");
fprintf (stderr, "*** It is not reliable release, and the GCC developers\n");
fprintf (stderr, "*** warn you not to use it for anything except to test it.\n");
}
}

406
gcc/gcc.hlp Normal file
View file

@ -0,0 +1,406 @@
1 GCC
The GCC command invokes the GNU C compiler.
GCC file-spec
2 Parameters
file-spec
A C source file. If no input file extension is specified, GNU C
assumes .C as the default extension unless the /PLUS qualifier is
given, in which case .CC is assumed as the default extension.
If an extension of .CPP is given, then the source file is assumed to
be the output of the preprocessor, and thus the preprocessor is not
executed.
If an extension of .S is given, then the source file is assumed to be
the assembly code output of the compiler, and only the assembler is
called to generate an object file.
2 Qualifiers
GNU C command qualifiers modify the way the compiler handles the
compilation.
The following is the list of available qualifiers for GNU C:
/CASE_HACK
/CC1_OPTIONS=(option [,option...]])
/DEBUG
/DEFINE=(identifier[=definition][,...])
/G_FLOAT
/INCLUDE_DIRECTORY=(path [,path...]])
/LIST[=filename]
/MACHINE_CODE
/OBJECT[=filename]
/OPTIMIZE
/PLUS
/PROFILE[=identifier]
/SCAN=(file[,file...])
/SHOW[=option]
/UNDEFINE=(identifier[,identifier,...])
/VERBOSE
/VERSION
/WARNING
2 Linking
When linking programs compiled with GNU C, you should include the GNU
C library before the VAX C library. For example,
LINK object-file,GNU_CC:[000000]GCCLIB/LIB,SYS$LIBRARY:VAXCRTL/LIB
You can also link your program with the shared VAX C library. This
can reduce the size of the .EXE file, as well as make it smaller when
it's running. For example,
$ LINK object-file, GNU_CC:[000000]GCCLIB/LIB,SYS$INPUT/OPT
SYS$SHARE:VAXCRTL/SHARE
(If you use the second example and type it in by hand, be sure to
type ^Z after the last carriage return). A simpler alternative would
be to place the single line:
SYS$SHARE:VAXCRTL/SHARE
into a file called VAXCRTL.OPT, and then use the link command:
$ LINK object-file, GNU_CC:[000000]GCCLIB/LIB,VAXCRTL.OPT/OPT
If a program has been compiled with /G_FLOAT, then the linking
instructions are slightly different. If you are linking with the
non-shared library, then the command that you should use would be:
LINK object-file,GNU_CC:[000000]GCCLIB/LIB,SYS$LIBRARY:VAXCRTLG/LIB -
,SYS$LIBRARY:VAXCRTL/LIB
Note that both VAXCRTL and VAXCRTLG must be linked to. If you are
using the shared VAX C library, then you should use a command like:
$ LINK object-file, GNU_CC:[000000]GCCLIB/LIB,SYS$INPUT:/OPTIONS
SYS$SHARE:VAXCRTLG/SHARE
In the case of the sharable library, only one library needs to be
linked to.
If you need to link to libg++, it is easiest to use the command
procedure supplied with libg++ to link your program.
2 /CASE_HACK
/[NO]CASE_HACK D=/CASE_HACK
Since the VMS Linker and Librarian are not case sensitive with
respect to symbol names, a "case-hack" is appended to a symbol name
when the symbol contains upper case characters.
There are cases where this is undesirable, (mainly when using certain
applications where modules have been precompiled, perhaps in another
language) and we want to compile without case hacking. In these
cases the /NOCASE_HACK switch disables case hacking.
2 /CC1_OPTIONS
This specifies additional switches to the compiler itself which
cannot be set by means of the compiler driver.
2 /DEBUG
/DEBUG includes additional information in the object file output so
that the program can be debugged with the VAX Symbolic Debugger.
To use the debugger it is also necessary to link the debugger to your
program, which is done by specifying the /DEBUG qualifier to the link
command. With the debugger it is possible to set breakpoints,
examine variables, and set variables to new values. See the VAX
Symbolic Debugger manual for more information, or type "HELP" from
the debugger prompt.
2 /DEFINE
/DEFINE=(identifier[=definition][,...])
/DEFINE defines a string or macro ('definition') to be substituted
for every occurrence of a given string ('identifier') in a program.
It is equivalent to the #define preprocessor directive.
All definitions and identifiers are converted to uppercase unless
they are in quotation marks.
The simple form of the /DEFINE qualifier:
/DEFINE=vms
results in a definition equivalent to the preprocessor directive:
#define VMS 1
You must enclose macro definitions in quotation marks, as in this
example:
/DEFINE="C(x)=((x) & 0xff)"
This definition is the same as the preprocessor definition:
#define C(x) ((x) & 0xff)
If more than one /DEFINE is present on the GCC command line, only the
last /DEFINE is used.
If both /DEFINE and /UNDEFINE are present on a command line, /DEFINE
is evaluated before /UNDEFINE.
2 /G_FLOAT
Instructs the compiler to use "G" floating point arithmetic instead
of "D". The difference is that double precision has a range of
approximately +/-0.56e-308 to +/-0.9 e+308, with approximately 15
decimal digits precision.
"D" floating point has the same range as single precision floating
point, with approximately 17 decimal digits precision.
If you use the /G_FLOAT qualifier, the linking instructions are
different. See "Linking" for further details.
2 /LIST
/LIST[=list_file_name]
This does not generate a listing file in the usual sense, however it
does direct the compiler to save the preprocessor output. If a file
is not specified, then this output is written into a file with the
same name as the source file and an extension of .CPP.
2 /INCLUDE_DIRECTORY
/INCLUDE_DIRECTORY=(path [,path...])
The /INCLUDE_DIRECTORY qualifier provides additional directories to
search for user-defined include files. 'path' can be either a
logical name or a directory specification.
There are two forms for specifying include files - #include
"file-spec" and #include <file-spec>. For the #include "file-spec"
form, the search order is:
1. The directory containing the source file.
2. The directories in the /INCLUDE qualifier (if any).
3. The directory (or directories) specified in the logical name
GNU_CC_INCLUDE.
4. The directory (or directories) specified in the logical name
SYS$LIBRARY.
For the #include <file-spec> form, the search order is:
1. The directories specified in the /INCLUDE qualifier (if any).
2. The directory (or directories) specified in the logical name
GNU_CC_INCLUDE.
3. The directory (or directories) specified in the logical name
SYS$LIBRARY.
2 /MACHINE_CODE
Tells GNU C to output the machine code generated by the compiler.
The machine code is output to a file with the same name as the input
file, with the extension .S. An object file is still generated,
unless /NOOBJ is also specified.
2 /OBJECT
/OBJECT[=filename]
/NOOBJECT
Controls whether or not an object file is generated by the
compiler.
2 /OPTIMIZE
/[NO]OPTIMIZE
Controls whether optimization is performed by the compiler. By
default, optimization is on. /NOOPTIMIZE turns optimization off.
2 /PLUS
Instructs the compiler driver to use the GNU-C++ compiler instead of
the GNU-C compiler. Note that the default extension of source files
is .CC when this qualifier is in effect.
2 /PROFILE
/PROFILE[=identifier]
Instructs the compiler to generate function profiling code. You must
link your program to the profiler when you use this options. The
profile statistics are automatically printed out on the terminal
during image exit. (i.e. no modifications to your source file are
required in order to use the profiler).
There are three identifiers that can be used with the /PROFILE
switch. These are ALL, FUNCTION, and BLOCK. If /PROFILE is given
without an identifier, then FUNCTION is assumed.
3 Block_Profiler
The block profiler counts how many times control of the program
passes certain points in your program. This is useful in determining
which portions of a program would benefit from recoding for
optimization.
The report for the block profiler contains the function name, file
name, PC, and the source file line number as well as the count of how
many times control has passed through the specified source line.
3 Function_Profiler
The function profiler counts how many times each function is entered,
and keeps track of how much CPU time is used within each function.
You should be careful about interpreting the results of profiles
where there are inline functions. When a function is included as
inline, then there is no call to the internal data collection routine
used by the profiler, and thus there will be no record of this
function being called. The compiler does generate a callable version
of each inline function, and if this called version is used, then the
profiler's data collection routine will be called.
2 /SCAN
/SCAN=(file[,file...])
This qualifier supplies a list of files that will be read as input,
and the output will be discarded before processing the regular input
file. Because the output generated from the files is discarded, the
only effect of this qualifier is to make the macros defined in the
files available for use in the main input.
2 /SHOW
/SHOW[=option]
This causes the preprocessor to generate information other than the
preprocessed input file. When this qualifier is used, no assembly
code and no object file is generated.
The output of the preprocessor is placed in the file specified by the
/LIST qualifier, if present. If the /LIST qualifier is not present,
then the output is placed in a file with the same name as the input
file with an extension that depends upon which option that is
selected.
3 DEFINITIONS
This option causes the preprocessor to dump a list of all of the
definitions to the output file. This is useful for debugging
purposes, since it lets you determine whether or not everything has
been defined properly.
If the default file name is used for the output, the extension will
be .DEF.
3 RULES
This option causes the preprocessor to output a rule suitable for
MAKE, describing the dependencies of the main source file. The
preprocessor outputs one MAKE rule containing the object file name
for that source file, a colon, and the names of all the concluded
files. If there are many included files then the rule is split into
several lines using the '\'-newline.
When using this option, only files included with the "#include "file"
directive are mentioned.
If the default file name is used for the output, a null extension
will be used.
3 ALL
This option is similar to RULES, except that it also mentions files
included with the "#include <file.h>" directive.
If the default file name is used for the output, a null extension
will be used.
2 /UNDEFINE
/UNDEFINE cancels a macro definition. Thus, it is the same as the
#undef preprocessor directive.
If more than one /UNDEFINE is present on the GCC command line, only
the last /UNDEFINE is used.
If both /DEFINE and /UNDEFINE are present on a command line, /DEFINE
is evaluated before /UNDEFINE.
2 /VERBOSE
Controls whether the user sees the invocation command strings for the
preprocessor, compiler, and assembler. The compiler also outputs
some statistics on time spent in its various phases.
2 /VERSION
Causes the preprocessor and the compiler to identify themselves by
their version numbers, and in the case of the compiler, the version
number of the compiler that built it.
2 /WARNING
When this qualifier is present, warnings about usage that should be
avoided are given by the compiler. For more information, see "Using
and Porting GNU CC", in the section on command line options, under
"-Wall".
Warnings are also generated by the preprocessor when this qualifier
is given.
2 Known_Incompatibilities_with_VAX-C
There are several known incompatibilities between GNU-C and VAX-C.
Some common ones will be briefly described here. A complete
description can be found in "Using and Porting GNU CC" in the chapter
entitled "Using GNU CC on VMS".
GNU-C provides case hacking as a means of giving case sensitivity
to symbol names. The case hack is a hexadecimal number appended to
the symbol name, with a bit being set for each upper case letter.
Symbols with all lower case, or symbols that have a dollar sign ("$")
are not case hacked. There are times that this is undesirable,
namely when you wish to link your program against a precompiled
library which was compiled with a non-GNU-C compiler. X-windows (or
DECWindows) is an example of this. In these instances, the
/NOCASE_HACK switch should be used.
If you require case hacking in some cases, but not in others (i.e.
Libg++ with DECWindows), then it is recommended that you develop a
header file which will define all mixed case functions that should
not have a case hack as the lower case equivalents.
GNU-C does not provide the globaldef and globalref mechanism
which is used by VAX-C to coerce the VMS linker to include certain
object modules from a library. There are assembler hacks, which are
available to the user through the macros defined in gnu_hacks.h,
which effectively give you the ability to perform these functions.
While not syntactically identical, they do provide most of the
functionality.
Note that globaldefs of enums is not supported in the way that it is
under VAX-C. This can be easily simulated, however, by globaldefing
an integer variable, and then globalvaluing all of the enumerated
states.
Furthermore, the way that globalvalue is currently implemented, the
data type of the globalvalue variable is seen to the compiler to be a
pointer to the data type that you specify. This is necessary in
order to make the compiler correctly address the globalvalue
variables.

4793
gcc/gcc.texi Normal file
View file

File diff suppressed because it is too large Load diff

28
gcc/getopt.c
View file

@ -6,23 +6,23 @@
Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
Free Software Foundation, Inc.
NOTE: The canonical source of this file is maintained with the GNU C Library.
Bugs can be reported to bug-glibc@prep.ai.mit.edu.
NOTE: The canonical source of this file is maintained with the GNU C Library.
Bugs can be reported to bug-glibc@prep.ai.mit.edu.
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, or (at your option) any
later version.
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, 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.
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. */
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. */
/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
Ditto for AIX 3.2 and <stdlib.h>. */

30
gcc/getopt.h
View file

@ -1,23 +1,23 @@
/* Declarations for getopt.
Copyright (C) 1989,90,91,92,93,94,96,97 Free Software Foundation, Inc.
NOTE: The canonical source of this file is maintained with the GNU C Library.
Bugs can be reported to bug-glibc@gnu.org.
NOTE: The canonical source of this file is maintained with the GNU C Library.
Bugs can be reported to bug-glibc@prep.ai.mit.edu.
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, or (at your option) any
later version.
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, 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.
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. */
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. */
#ifndef _GETOPT_H
#define _GETOPT_H 1
@ -130,4 +130,4 @@ extern int _getopt_internal ();
}
#endif
#endif /* getopt.h */
#endif /* _GETOPT_H */

28
gcc/getopt1.c
View file

@ -1,23 +1,23 @@
/* getopt_long and getopt_long_only entry points for GNU getopt.
Copyright (C) 1987,88,89,90,91,92,93,94,96,97 Free Software Foundation, Inc.
NOTE: The canonical source of this file is maintained with the GNU C Library.
Bugs can be reported to bug-glibc@prep.ai.mit.edu.
NOTE: The canonical source of this file is maintained with the GNU C Library.
Bugs can be reported to bug-glibc@prep.ai.mit.edu.
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, or (at your option) any
later version.
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, 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.
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. */
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. */
#ifdef HAVE_CONFIG_H
#include <config.h>

17
gcc/gstab.h Normal file
View file

@ -0,0 +1,17 @@
#ifndef __GNU_STAB__
/* Indicate the GNU stab.h is in use. */
#define __GNU_STAB__
#define __define_stab(NAME, CODE, STRING) NAME=CODE,
enum __stab_debug_code
{
#include "stab.def"
LAST_UNUSED_STAB_CODE
};
#undef __define_stab
#endif /* __GNU_STAB_ */

55
gcc/install.texi
View file

@ -179,13 +179,13 @@ make a difference.
@cindex Objective C threads
@cindex threads, Objective C
@item --enable-objcthreads=@var{type}
Certain systems, notably Linux, can't be relied on to supply a threads
facility for the Objective C runtime and so will default to
single-threaded runtime. They may, however, have a library threads
implementation available, in which case threads can be enabled with this
option by supplying a suitable @var{type}, probably @samp{posix}.
The possibilities for @var{type} are @samp{single}, @samp{posix},
@samp{win32}, @samp{solaris}, @samp{irix} and @samp{mach}.
Certain systems, notably Linux-based GNU systems, can't be relied on to
supply a threads facility for the Objective C runtime and so will
default to single-threaded runtime. They may, however, have a library
threads implementation available, in which case threads can be enabled
with this option by supplying a suitable @var{type}, probably
@samp{posix}. The possibilities for @var{type} are @samp{single},
@samp{posix}, @samp{win32}, @samp{solaris}, @samp{irix} and @samp{mach}.
@end table
The @file{configure} script searches subdirectories of the source
@ -610,7 +610,7 @@ Here is a list of system types:
@quotation
386bsd, aix, acis, amigados, aos, aout, aux, bosx, bsd, clix, coff, ctix, cxux,
dgux, dynix, ebmon, ecoff, elf, esix, freebsd, hms, genix, gnu, gnu/linux,
dgux, dynix, ebmon, ecoff, elf, esix, freebsd, hms, genix, gnu, linux-gnu,
hiux, hpux, iris, irix, isc, luna, lynxos, mach, minix, msdos, mvs,
netbsd, newsos, nindy, ns, osf, osfrose, ptx, riscix, riscos, rtu, sco, sim,
solaris, sunos, sym, sysv, udi, ultrix, unicos, uniplus, unos, vms, vsta,
@ -759,15 +759,22 @@ To avoid this behavior, specify @samp{-gstabs+} and use GDB instead of
DBX. DEC is now aware of this problem with the assembler and hopes to
provide a fix shortly.
@item arm
@item arm-*-aout
Advanced RISC Machines ARM-family processors. These are often used in
embedded applications. There are no standard Unix configurations.
This configuration corresponds to the basic instruction sequences and will
produce a.out format object modules.
produce @file{a.out} format object modules.
You may need to make a variant of the file @file{arm.h} for your particular
configuration.
@item arm-*-linuxaout
Any of the ARM family processors running the Linux-based GNU system with
the @file{a.out} binary format (ELF is not yet supported). You must use
version 2.8.1.0.7 or later of the Linux binutils, which you can download
from @file{sunsite.unc.edu:/pub/Linux/GCC} and other mirror sites for
Linux-based GNU systems.
@item arm-*-riscix
The ARM2 or ARM3 processor running RISC iX, Acorn's port of BSD Unix. If
you are running a version of RISC iX prior to 1.2 then you must specify
@ -880,19 +887,19 @@ option before building.
This port is very preliminary and has many known bugs. We hope to
have a higher-quality port for this machine soon.
@item i386-*-linuxoldld
Use this configuration to generate a.out binaries on Linux if you do not
have gas/binutils version 2.5.2 or later installed. This is an obsolete
configuration.
@item i386-*-linux-gnuoldld
Use this configuration to generate @file{a.out} binaries on Linux-based
GNU systems if you do not have gas/binutils version 2.5.2 or later
installed. This is an obsolete configuration.
@item i386-*-linuxaout
Use this configuration to generate a.out binaries on Linux. This configuration
is being superseded. You must use gas/binutils version 2.5.2 or
later.
@item i386-*-linux-gnuaout
Use this configuration to generate @file{a.out} binaries on Linux-based
GNU systems. This configuration is being superseded. You must use
gas/binutils version 2.5.2 or later.
@item i386-*-linux
Use this configuration to generate ELF binaries on Linux. You must
use gas/binutils version 2.5.2 or later.
@item i386-*-linux-gnu
Use this configuration to generate ELF binaries on Linux-based GNU
systems. You must use gas/binutils version 2.5.2 or later.
@item i386-*-sco
Compilation with RCC is recommended. Also, it may be a good idea to
@ -1017,7 +1024,7 @@ LynxOS 2.2 and earlier comes with GNU CC 1.x already installed as
You can tell GNU CC to use the GNU assembler and linker, by specifying
@samp{--with-gnu-as --with-gnu-ld} when configuring. These will produce
COFF format object files and executables; otherwise GNU CC will use the
installed tools, which produce a.out format executables.
installed tools, which produce @file{a.out} format executables.
@item m32r-*-elf
Embedded M32R system.
@ -1378,8 +1385,8 @@ PowerPC system in big endian mode, running System V.4.
You can specify a default version for the @samp{-mcpu=}@var{cpu_type}
switch by using the configure option @samp{--with-cpu-}@var{cpu_type}.
@item powerpc-*-linux
PowerPC system in big endian mode, running Linux.
@item powerpc-*-linux-gnu
PowerPC system in big endian mode, running the Linux-based GNU system.
You can specify a default version for the @samp{-mcpu=}@var{cpu_type}
switch by using the configure option @samp{--with-cpu-}@var{cpu_type}.

15
gcc/install1.texi Normal file
View file

@ -0,0 +1,15 @@
@setfilename INSTALL
@set INSTALLONLY
@c This file itself, install1.texi, does not apear in the GCC distribution.
@c The immediately following lines apply to the INSTALL file
@c which is generated using this file.
This file documents the installation of the GNU compiler.
Copyright (C) 1988, 1989, 1992, 1994, 1995 Free Software Foundation, Inc.
You may copy, distribute, and modify it freely as long as you preserve
this copyright notice and permission notice.
@node Installation,,, (dir)
@chapter Installing GNU CC
@include install.texi
@bye

442
gcc/invoke.texi
View file

@ -1,4 +1,4 @@
@c Copyright (C) 1988, 89, 92, 93, 94, 1995, 1996 Free Software Foundation, Inc.
@c Copyright (C) 1988,89,92,93,94,95,96,1997 Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
@ -93,8 +93,8 @@ in the following sections.
@item C Language Options
@xref{C Dialect Options,,Options Controlling C Dialect}.
@smallexample
-ansi -fallow-single-precision -fcond-mismatch -fno-asm
-fno-builtin -fsigned-bitfields -fsigned-char
-ansi -fallow-single-precision -fcond-mismatch -fno-asm
-fno-builtin -ffreestanding - fhosted -fsigned-bitfields -fsigned-char
-funsigned-bitfields -funsigned-char -fwritable-strings
-traditional -traditional-cpp -trigraphs
@end smallexample
@ -105,8 +105,8 @@ in the following sections.
-fall-virtual -fdollars-in-identifiers -felide-constructors
-fenum-int-equiv -fexternal-templates -ffor-scope -fno-for-scope
-fhandle-signatures -fmemoize-lookups -fno-default-inline -fno-gnu-keywords
-fnonnull-objects -foperator-names -fstrict-prototype
-fthis-is-variable -nostdinc++ -traditional +e@var{n}
-fnonnull-objects -foperator-names -fstrict-prototype -fthis-is-variable
-ftemplate-depth-@var{n} -nostdinc++ -traditional +e@var{n}
@end smallexample
@item Warning Options
@ -117,20 +117,21 @@ in the following sections.
-Wcast-align -Wcast-qual -Wchar-subscript -Wcomment
-Wconversion -Werror -Wformat
-Wid-clash-@var{len} -Wimplicit -Wimport -Winline
-Wlarger-than-@var{len} -Wmissing-declarations
-Wlarger-than-@var{len} -Wmain -Wmissing-declarations
-Wmissing-prototypes -Wnested-externs
-Wno-import -Woverloaded-virtual -Wparentheses
-Wpointer-arith -Wredundant-decls -Wreorder -Wreturn-type -Wshadow
-Wsign-compare -Wstrict-prototypes -Wswitch -Wsynth
-Wtemplate-debugging -Wtraditional -Wtrigraphs
-Wuninitialized -Wunused -Wwrite-strings
-Wundef -Wuninitialized -Wunused -Wwrite-strings
@end smallexample
@item Debugging Options
@xref{Debugging Options,,Options for Debugging Your Program or GCC}.
@smallexample
-a -ax -d@var{letters} -fpretend-float
-g -g@var{level} -gcoff -gdwarf -gdwarf+
-fprofile-arcs -ftest-coverage
-g -g@var{level} -gcoff -gdwarf -gdwarf-1 -gdwarf-1+ -gdwarf-2
-ggdb -gstabs -gstabs+ -gxcoff -gxcoff+
-p -pg -print-file-name=@var{library} -print-libgcc-file-name
-print-prog-name=@var{program} -print-search-dirs -save-temps
@ -139,6 +140,7 @@ in the following sections.
@item Optimization Options
@xref{Optimize Options,,Options that Control Optimization}.
@smallexample
-fbranch-probabilities
-fcaller-saves -fcse-follow-jumps -fcse-skip-blocks
-fdelayed-branch -fexpensive-optimizations
-ffast-math -ffloat-store -fforce-addr -fforce-mem
@ -184,7 +186,7 @@ in the following sections.
@item Directory Options
@xref{Directory Options,,Options for Directory Search}.
@smallexample
-B@var{prefix} -I@var{dir} -I- -L@var{dir}
-B@var{prefix} -I@var{dir} -I- -L@var{dir} -specs=@var{file}
@end smallexample
@item Target Options
@ -198,9 +200,9 @@ in the following sections.
@xref{Submodel Options,,Hardware Models and Configurations}.
@smallexample
@emph{M680x0 Options}
-m68000 -m68020 -m68020-40 -m68030 -m68040 -m68060
-m5200 -m68881 -mbitfield -mc68000 -mc68020 -mfpa
-mnobitfield -mrtd -mshort -msoft-float
-m68000 -m68020 -m68020-40 -m68020-60 -m68030 -m68040
-m68060 -m5200 -m68881 -mbitfield -mc68000 -mc68020 -mfpa
-mnobitfield -mrtd -mshort -msoft-float -malign-int
@emph{VAX Options}
-mg -mgnu -munix
@ -239,6 +241,10 @@ in the following sections.
-msoft-float -mhard-float
-mbsd -mxopen -mno-symrename
@emph{M32R/D Options}
-mcode-model=@var{model type} -msdata=@var{sdata type}
-G @var{num}
@emph{M88K Options}
-m88000 -m88100 -m88110 -mbig-pic
-mcheck-zero-division -mhandle-large-shift
@ -260,9 +266,10 @@ in the following sections.
-mpowerpc-gfxopt -mno-powerpc-gfxopt
-mnew-mnemonics -mno-new-mnemonics
-mfull-toc -mminimal-toc -mno-fop-in-toc -mno-sum-in-toc
-mxl-call -mno-xl-call
-mxl-call -mno-xl-call -mthreads -mpe
-msoft-float -mhard-float -mmultiple -mno-multiple
-mstring -mno-string -mbit-align -mno-bit-align
-mstring -mno-string -mupdate -mno-update
-mfused-madd -mno-fused-madd -mbit-align -mno-bit-align
-mstrict-align -mno-strict-align -mrelocatable
-mno-relocatable -mrelocatable-lib -mno-relocatable-lib
-mtoc -mno-toc -mtraceback -mno-traceback
@ -297,8 +304,8 @@ in the following sections.
-malign-functions=@var{num}
@emph{HPPA Options}
-mdisable-fpregs -mdisable-indexing -mfast-indirect-calls
-mgas -mjump-in-delay -mlong-load-store -mno-disable-fpregs
-mbig-switch -mdisable-fpregs -mdisable-indexing -mfast-indirect-calls
-mgas -mjump-in-delay -mlong-load-store -mno-big-switch -mno-disable-fpregs
-mno-disable-indexing -mno-fast-indirect-calls -mno-gas
-mno-jump-in-delay
-mno-long-load-store
@ -341,11 +348,12 @@ in the following sections.
@smallexample
-fcall-saved-@var{reg} -fcall-used-@var{reg}
-ffixed-@var{reg} -finhibit-size-directive
-fcheck-memory-usage -fprefix-function-name
-fno-common -fno-ident -fno-gnu-linker
-fpcc-struct-return -fpic -fPIC
-freg-struct-return -fshared-data -fshort-enums
-fshort-double -fvolatile -fvolatile-global
-fverbose-asm -fpack-struct +e0 +e1
-fverbose-asm -fpack-struct -fstack-check +e0 +e1
@end smallexample
@end table
@ -558,8 +566,8 @@ This turns off certain features of GNU C that are incompatible with ANSI
C, such as the @code{asm}, @code{inline} and @code{typeof} keywords, and
predefined macros such as @code{unix} and @code{vax} that identify the
type of system you are using. It also enables the undesirable and
rarely used ANSI trigraph feature, disallows @samp{$} as part of
identifiers, and disables recognition of C++ style @samp{//} comments.
rarely used ANSI trigraph feature, and it disables recognition of C++
style @samp{//} comments.
The alternate keywords @code{__asm__}, @code{__extension__},
@code{__inline__} and @code{__typeof__} continue to work despite
@ -628,6 +636,24 @@ The @samp{-ansi} option prevents @code{alloca} and @code{ffs} from being
builtin functions, since these functions do not have an ANSI standard
meaning.
@item -fhosted
@cindex hosted environment
Assert that compilation takes place in a hosted environment. This implies
@samp{-fbuiltin}. A hosted environment is one in which the
entire standard library is available, and in which @code{main} has a return
type of @code{int}. Examples are nearly everything except a kernel.
This is equivalent to @samp{-fno-freestanding}.
@item -ffreestanding
@cindex hosted environment
Assert that compilation takes place in a freestanding environment. This
implies @samp{-fno-builtin}. A freestanding environment
is one in which the standard library may not exist, and program startup may
not necessarily be at @code{main}. The most obvious example is an OS kernel.
This is equivalent to @samp{-fno-hosted}.
@item -trigraphs
Support ANSI C trigraphs. You don't want to know about this
brain-damage. The @samp{-ansi} option implies @samp{-trigraphs}.
@ -1029,6 +1055,12 @@ vtables; if a class has any non-inline virtual functions, the vtable
will be emitted in the translation unit containing the first one of
those.
@item -ftemplate-depth-@var{n}
Set the maximum instantiation depth for template classes to @var{n}.
A limit on the template instantiation depth is needed to detect
endless recursions during template class instantiation. ANSI/ISO C++
conforming programs must not rely on a maximum depth greater than 17.
@item -nostdinc++
Do not search for header files in the standard directories specific to
C++, but do still search the other standard directories. (This option
@ -1053,6 +1085,9 @@ Do not assume @samp{inline} for functions defined inside a class scope.
Warnings that apply only to C++ programs. @xref{Warning
Options,,Options to Request or Suppress Warnings}.
@item -Weffc++
Warn about violation of some style rules from Effective C++ by Scott Myers.
@item +e@var{n}
Control how virtual function definitions are used, in a fashion
compatible with @code{cfront} 1.x. @xref{Code Gen Options,,Options for
@ -1143,8 +1178,14 @@ the arguments supplied have types appropriate to the format string
specified.
@item -Wimplicit
Warn whenever a function or parameter is implicitly declared.
Warn whenever a function or parameter is implicitly declared,
or when a type implicitly defaults to @code{int}.
@item -Wmain
Warn if the type of @samp{main} is suspicious. @samp{main} should be a
function with external linkage, returning int, taking either zero
arguments, two, or three arguments of appropriate types.
@item -Wparentheses
Warn if parentheses are omitted in certain contexts, such
as when there is an assignment in a context where a truth value
@ -1366,6 +1407,9 @@ the block.
A @code{switch} statement has an operand of type @code{long}.
@end itemize
@item -Wundef
Warn if an undefined identifier is evaluated in an @samp{#if} directive.
@item -Wshadow
Warn whenever a local variable shadows another local variable.
@ -1510,7 +1554,7 @@ makes debugging work better in GDB but will probably make other debuggers
crash or
refuse to read the program. If you want to control for certain whether
to generate the extra information, use @samp{-gstabs+}, @samp{-gstabs},
@samp{-gxcoff+}, @samp{-gxcoff}, @samp{-gdwarf+}, or @samp{-gdwarf}
@samp{-gxcoff+}, @samp{-gxcoff}, @samp{-gdwarf-1+}, or @samp{-gdwarf-1}
(see below).
Unlike most other C compilers, GNU CC allows you to use @samp{-g} with
@ -1528,8 +1572,10 @@ The following options are useful when GNU CC is generated with the
capability for more than one debugging format.
@item -ggdb
Produce debugging information in the native format (if that is supported),
including GDB extensions if at all possible.
Produce debugging information for use by GDB. This means to use the
most expressive format available (DWARF 2, stabs, or the native format
if neither of those are supported), including GDB extensions if at all
possible.
@item -gstabs
Produce debugging information in stabs format (if that is supported),
@ -1561,14 +1607,19 @@ refuse to read the program, and may cause assemblers other than the GNU
assembler (GAS) to fail with an error.
@item -gdwarf
Produce debugging information in DWARF format (if that is supported).
This is the format used by SDB on most System V Release 4 systems.
Produce debugging information in DWARF version 1 format (if that is
supported). This is the format used by SDB on most System V Release 4
systems.
@item -gdwarf+
Produce debugging information in DWARF format (if that is supported),
using GNU extensions understood only by the GNU debugger (GDB). The
use of these extensions is likely to make other debuggers crash or
refuse to read the program.
Produce debugging information in DWARF version 1 format (if that is
supported), using GNU extensions understood only by the GNU debugger
(GDB). The use of these extensions is likely to make other debuggers
crash or refuse to read the program.
@item -gdwarf-2
Produce debugging information in DWARF version 2 format (if that is
supported). This is the format used by DBX on IRIX 6.
@item -g@var{level}
@itemx -ggdb@var{level}
@ -1576,6 +1627,7 @@ refuse to read the program.
@itemx -gcoff@var{level}
@itemx -gxcoff@var{level}
@itemx -gdwarf@var{level}
@itemx -gdwarf-2@var{level}
Request debugging information and also use @var{level} to specify how
much information. The default level is 2.
@ -1688,6 +1740,54 @@ to return instructions is added to the trace. The trace becomes: 0 3 1
written to @file{bbtrace.gz}. It is solely used for counting jump
frequencies.
@item -fprofile-arcs
Instrument @dfn{arcs} during compilation. For each function of your
program, GNU CC creates a program flow graph, then finds a spanning tree
for the graph. Only arcs that are not on the spanning tree have to be
instrumented: the compiler adds code to count the number of times that these
arcs are executed. When an arc is the only exit or only entrance to a
block, the instrumentation code can be added to the block; otherwise, a
new basic block must be created to hold the instrumentation code.
Since not every arc in the program must be instrumented, programs
compiled with this option run faster than programs compiled with
@samp{-a}, which adds instrumentation code to every basic block in the
program. The tradeoff: since @code{gcov} does not have
execution counts for all branches, it must start with the execution
counts for the instrumented branches, and then iterate over the program
flow graph until the entire graph has been solved. Hence, @code{gcov}
runs a little more slowly than a program which uses information from
@samp{-a}.
@samp{-fprofile-arcs} also makes it possible to estimate branch
probabilities, and to calculate basic block execution counts. In
general, basic block execution counts do not give enough information to
estimate all branch probabilities. When the compiled program exits, it
saves the arc execution counts to a file called
@file{@var{sourcename}.da}. Use the compiler option
@samp{-fbranch-probabilities} (@pxref{Optimize Options,,Options that
Control Optimization}) when recompiling, to optimize using estimated
branch probabilities.
@need 2000
@item -ftest-coverage
Create data files for the @code{gcov} code-coverage utility
(@pxref{Gcov,, @code{gcov}: a GNU CC Test Coverage Program}).
The data file names begin with the name of your source file:
@table @code
@item @var{sourcename}.bb
A mapping from basic blocks to line numbers, which @code{gcov} uses to
associate basic block execution counts with line numbers.
@item @var{sourcename}.bbg
A list of all arcs in the program flow graph. This allows @code{gcov}
to reconstruct the program flow graph, so that it can compute all basic
block and arc execution counts from the information in the
@code{@var{sourcename}.da} file (this last file is the output from
@samp{-fprofile-arcs}).
@end table
@item -d@var{letters}
Says to make debugging dumps during compilation at times specified by
@var{letters}. This is used for debugging the compiler. The file names
@ -2078,6 +2178,23 @@ implies @samp{-fstrength-reduce} as well as @samp{-frerun-cse-after-loop}.
@item -fno-peephole
Disable any machine-specific peephole optimizations.
@item -fbranch-probabilities
After running a program compiled with @samp{-fprofile-arcs}
(@pxref{Debugging Options,, Options for Debugging Your Program or
@code{gcc}}), you can compile it a second time using
@samp{-fbranch-probabilities}, to improve optimizations based on
guessing the path a branch might take.
@ifset INTERNALS
With @samp{-fbranch-probabilities}, GNU CC puts a @samp{REG_EXEC_COUNT}
note on the first instruction of each basic block, and a
@samp{REG_BR_PROB} note on each @samp{JUMP_INSN} and @samp{CALL_INSN}.
These can be used to improve optimization. Currently, they are only
used in one place: in @file{reorg.c}, instead of guessing which path a
branch is mostly to take, the @samp{REG_BR_PROB} values are used to
exactly determine which path is taken more often.
@end ifset
@end table
@node Preprocessor Options
@ -2412,9 +2529,9 @@ libraries and for parts of the compiler:
@table @code
@item -I@var{dir}
Add the directory @var{directory} to the head 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
Add the directory @var{dir} to the head 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 @samp{-I} option, the directories are scanned in left-to-right
order; the standard system directories come after.
@ -2477,6 +2594,14 @@ out of the link if it is not found by those means.
Another way to specify a prefix much like the @samp{-B} prefix is to use
the environment variable @code{GCC_EXEC_PREFIX}. @xref{Environment
Variables}.
@item -specs=@var{file}
Process @var{file} after the compiler reads in the standard @file{specs}
file, in order to override the defaults that the @file{gcc} driver
program uses when determining what switches to pass to @file{cc1},
@file{cc1plus}, @file{as}, @file{ld}, etc. More than one
@samp{-specs=}@var{file} can be specified on the command line, and they
are processed in order, from left to right.
@end table
@node Target Options
@ -2594,6 +2719,7 @@ that macro, which enables you to change the defaults.
* Convex Options::
* AMD29K Options::
* ARM Options::
* M32R/D Options::
* M88K Options::
* RS/6000 and PowerPC Options::
* RT Options::
@ -2664,6 +2790,12 @@ This results in code which can run relatively efficiently on either a
68020/68881 or a 68030 or a 68040. The generated code does use the
68881 instructions that are emulated on the 68040.
@item -m68020-60
Generate output for a 68060, without using any of the new instructions.
This results in code which can run relatively efficiently on either a
68020/68881 or a 68030 or a 68040. The generated code does use the
68881 instructions that are emulated on the 68060.
@item -mfpa
Generate output containing Sun FPA instructions for floating point.
@ -2710,6 +2842,19 @@ harmlessly ignored.)
The @code{rtd} instruction is supported by the 68010, 68020, 68030,
68040, and 68060 processors, but not by the 68000 or 5200.
@item -malign-int
@itemx -mno-align-int
Control whether GNU CC aligns @code{int}, @code{long}, @code{long long},
@code{float}, @code{double}, and @code{long double} variables on a 32-bit
boundary (@samp{-malign-int}) or a 16-bit boundary (@samp{-mno-align-int}).
Aligning variables on 32-bit boundaries produces code that runs somewhat
faster on processors with 32-bit busses at the expense of more memory.
@strong{Warning:} if you use the @samp{-malign-int} switch, GNU CC will
align structures containing the above types differently than
most published application binary interface specifications for the m68k.
@end table
@node VAX Options
@ -3090,6 +3235,12 @@ to date, but not the 29050).
registers for copying out arguments. This helps detect calling a function
with fewer arguments than it was declared with.
@item -mno-impure-text
@itemx -mimpure-text
@kindex -mimpure-text
@samp{-mimpure-text}, used in addition to @samp{-shared}, tells the compiler to
not pass @samp{-assert pure-text} to the linker when linking a shared object.
@item -msoft-float
@kindex -msoft-float
Generate output containing library calls for floating point.
@ -3195,6 +3346,67 @@ suppresses this pass. The post-processor is never run when the
compiler is built for cross-compilation.
@end table
@node M32R/D Options
@subsection M32R/D Options
@cindex M32R/D options
These @samp{-m} options are defined for Mitsubishi M32R/D architectures:
@table @code
@item -mcode-model=small
Assume all objects live in the lower 16MB of memory (so that their addresses
can be loaded with the @code{ld24} instruction), and assume all subroutines
are reachable with the @code{bl} instruction.
This is the default.
The addressability of a particular object can be set with the
@code{model} attribute.
@item -mcode-model=medium
Assume objects may be anywhere in the 32 bit address space (the compiler
will generate @code{seth/add3} instructions to load their addresses), and
assume all subroutines are reachable with the @code{bl} instruction.
@item -mcode-model=large
Assume objects may be anywhere in the 32 bit address space (the compiler
will generate @code{seth/add3} instructions to load their addresses), and
assume subroutines may not be reachable with the @code{bl} instruction
(the compiler will generate the much slower @code{seth/add3/jl}
instruction sequence).
@item -msdata=none
Disable use of the small data area. Variables will be put into
one of @samp{.data}, @samp{bss}, or @samp{.rodata} (unless the
@code{section} attribute has been specified).
This is the default.
The small data area consists of sections @samp{.sdata} and @samp{.sbss}.
Objects may be explicitly put in the small data area with the
@code{section} attribute using one of these sections.
@item -msdata=sdata
Put small global and static data in the small data area, but do not
generate special code to reference them.
@item -msdata=use
Put small global and static data in the small data area, and generate
special instructions to reference them.
@item -G @var{num}
@cindex smaller data references
Put global and static objects less than or equal to @var{num} bytes
into the small data or bss sections instead of the normal data or bss
sections. The default value of @var{num} is 8.
The @samp{-msdata} option must be set to one of @samp{sdata} or @samp{use}
for this option to have any effect.
All modules should be compiled with the same @samp{-G @var{num}} value.
Compiling with different values of @var{num} may or may not work; if it
doesn't the linker will give an error message - incorrect code will not be
generated.
@end table
@node M88K Options
@subsection M88K Options
@cindex M88k options
@ -3448,8 +3660,7 @@ RS/6000 and PowerPC. The @dfn{POWER} instruction set are those
instructions supported by the @samp{rios} chip set used in the original
RS/6000 systems and the @dfn{PowerPC} instruction set is the
architecture of the Motorola MPC5xx, MPC6xx, MPC8xx microprocessors, and
the IBM 40x microprocessors. The PowerPC architecture defines 64-bit
instructions, but they are not supported by any current processors.
the IBM 4xx microprocessors.
Neither architecture is a subset of the other. However there is a
large common subset of instructions supported by both. An MQ
@ -3512,25 +3723,28 @@ Set architecture type, register usage, choice of mnemonics, and
instruction scheduling parameters for machine type @var{cpu_type}.
Supported values for @var{cpu_type} are @samp{rs6000}, @samp{rios1},
@samp{rios2}, @samp{rsc}, @samp{601}, @samp{602}, @samp{603},
@samp{603e}, @samp{604}, @samp{620}, @samp{power}, @samp{power2},
@samp{powerpc}, @samp{403}, @samp{505}, @samp{821}, and @samp{860} and
@samp{common}. @samp{-mcpu=power}, @samp{-mcpu=power2}, and
@samp{-mcpu=powerpc} specify generic POWER, POWER2 and pure PowerPC
(i.e., not MPC601) architecture machine types, with an appropriate,
generic processor model assumed for scheduling purposes.@refill
@samp{603e}, @samp{604}, @samp{604e}, @samp{620}, @samp{power},
@samp{power2}, @samp{powerpc}, @samp{403}, @samp{505}, @samp{801},
@samp{821}, @samp{823}, and @samp{860} and @samp{common}.
@samp{-mcpu=power}, @samp{-mcpu=power2}, and @samp{-mcpu=powerpc}
specify generic POWER, POWER2 and pure PowerPC (i.e., not MPC601)
architecture machine types, with an appropriate, generic processor model
assumed for scheduling purposes.@refill
@c overfull hbox here --bob 22 jul96
@c original text between ignore ... end ignore
@ignore
Specifying any of the @samp{-mcpu=rios1}, @samp{-mcpu=rios2}, @samp{-mcpu=rsc},
@samp{-mcpu=power}, or @samp{-mcpu=power2} options enables the @samp{-mpower}
option and disables the @samp{-mpowerpc} option; @samp{-mcpu=601}
enables both the @samp{-mpower} and @samp{-mpowerpc} options;
all of @samp{-mcpu=602}, @samp{-mcpu=603}, @samp{-mcpu=603e}, @samp{-mcpu=604},
@samp{-mcpu=620}, @samp{-mcpu=403}, @samp{-mcpu=505}, @samp{-mcpu=821},
@samp{-mcpu=860} and @samp{-mcpu=powerpc} enable the @samp{-mpowerpc}
option and disable the @samp{-mpower} option; @samp{-mcpu=common}
disables both the @samp{-mpower} and @samp{-mpowerpc} options.@refill
Specifying any of the @samp{-mcpu=rios1}, @samp{-mcpu=rios2},
@samp{-mcpu=rsc}, @samp{-mcpu=power}, or @samp{-mcpu=power2} options
enables the @samp{-mpower} option and disables the @samp{-mpowerpc}
option; @samp{-mcpu=601} enables both the @samp{-mpower} and
@samp{-mpowerpc} options; all of @samp{-mcpu=602}, @samp{-mcpu=603},
@samp{-mcpu=603e}, @samp{-mcpu=604}, @samp{-mcpu=604e},
@samp{-mcpu=620}, @samp{-mcpu=403}, @samp{-mcpu=505}, @samp{-mcpu=801},
@samp{-mcpu=821}, @samp{-mcpu=823}, @samp{-mcpu=860} and
@samp{-mcpu=powerpc} enable the @samp{-mpowerpc} option and disable the
@samp{-mpower} option; @samp{-mcpu=common} disables both the
@samp{-mpower} and @samp{-mpowerpc} options.@refill
@end ignore
@c changed paragraph
Specifying any of the following options:
@ -3616,6 +3830,21 @@ stack is inefficient and rarely needed, this option is not enabled by
default and only is necessary when calling subroutines compiled by AIX
XL compilers without optimization.
@item -mthreads
Support @dfn{AIX Threads}. Link an application written to use
@dfn{pthreads} with special libraries and startup code to enable the
application to run.
@item -mpe
Support @dfn{IBM RS/6000 SP} @dfn{Parallel Environment} (PE). Link an
application written to use message passing with special startup code to
enable the application to run. The system must have PE installed in the
standard location (@file{/usr/lpp/ppe.poe/}), or the @file{specs} file
must be overridden with the @samp{-specs=} option to specify the
appropriate directory location. The Parallel Environment does not
support threads, so the @samp{-mpe} option and the @samp{-mthreads}
option are incompatible.
@item -msoft-float
@itemx -mhard-float
Generate code that does not use (uses) the floating-point register set.
@ -3635,11 +3864,27 @@ processor is in little endian mode.
@itemx -mno-string
Generate code that uses (does not use) the load string instructions and the
store string word instructions to save multiple registers and do small block
moves. These instructions are generated by default on POWER systems, anod not
moves. These instructions are generated by default on POWER systems, and not
generated on PowerPC systems. Do not use @samp{-mstring} on little endian
PowerPC systems, since those instructions do not work when the processor is in
little endian mode.
@item -mupdate
@itemx -mno-update
Generate code that uses (does not use) the load or store instructions
that update the base register to the address of the calculated memory
location. These instructions are generated by default. If you use
@samp{-mno-update}, there is a small window between the time that the
stack pointer is updated and the address of the previous frame is
stored, which means code that walks the stack frame across interrupts or
signals may get corrupted data.
@item -mfused-madd
@itemx -mno-fused-madd
Generate code that uses (does not use) the floating point multiply and
accumulate instructions. These instructions are generated by default if
hardware floating is used.
@item -mno-bit-align
@itemx -mbit-align
On System V.4 and embedded PowerPC systems do not (do) force structures
@ -3718,8 +3963,8 @@ On System V.4 and embedded PowerPC systems compile code for the Solaris
operating system.
@item -mcall-linux
On System V.4 and embedded PowerPC systems compile code for the Linux
operating system.
On System V.4 and embedded PowerPC systems compile code for the
Linux-based GNU system.
@item -mprototype
@item -mno-prototype
@ -3927,7 +4172,16 @@ stabs within MIPS ECOFF.
@item -mgas
Generate code for the GNU assembler. This is the default on the OSF/1
reference platform, using the OSF/rose object format.
reference platform, using the OSF/rose object format. Also, this is
the default if the configure option @samp{--with-gnu-as} is used.
@item -msplit-addresses
@itemx -mno-split-addresses
Generate code to load the high and low parts of address constants separately.
This allows @code{gcc} to optimize away redundant loads of the high order
bits of addresses. This optimization requires GNU as and GNU ld.
This optimization is enabled by default for some embedded targets where
GNU as and GNU ld are standard.
@item -mrnames
@itemx -mno-rnames
@ -4206,6 +4460,11 @@ Generate code for a PA 1.0 processor.
@item -mpa-risc-1-1
Generate code for a PA 1.1 processor.
@item -mbig-switch
Generate code suitable for big switch tables. Use this option only if
the assembler/linker complain about out of range branches within a switch
table.
@item -mjump-in-delay
Fill delay slots of function calls with unconditional jump instructions
by modifying the return pointer for the function call to be the target
@ -4353,8 +4612,7 @@ Do not permit (do permit) unaligned accesses.
@item -mold-align
Enable structure-alignment compatibility with Intel's gcc release version
1.3 (based on gcc 1.37). Currently this is buggy in that @samp{#pragma
align 1} is always assumed as well, and cannot be turned off.
1.3 (based on gcc 1.37). This option implies @samp{-mstrict-align}.
@end table
@node DEC Alpha Options
@ -4733,23 +4991,20 @@ be volatile.
@cindex PIC
Generate position-independent code (PIC) suitable for use in a shared
library, if supported for the target machine. Such code accesses all
constant addresses through a global offset table (GOT). If the GOT size
for the linked executable exceeds a machine-specific maximum size, you
get an error message from the linker indicating that @samp{-fpic} does
not work; in that case, recompile with @samp{-fPIC} instead. (These
maximums are 16k on the m88k, 8k on the Sparc, and 32k on the m68k and
RS/6000. The 386 has no such limit.)
constant addresses through a global offset table (GOT). The dynamic
loader resolves the GOT entries when the program starts (the dynamic
loader is not part of GNU CC; it is part of the operating system). If
the GOT size for the linked executable exceeds a machine-specific
maximum size, you get an error message from the linker indicating that
@samp{-fpic} does not work; in that case, recompile with @samp{-fPIC}
instead. (These maximums are 16k on the m88k, 8k on the Sparc, and 32k
on the m68k and RS/6000. The 386 has no such limit.)
Position-independent code requires special support, and therefore works
only on certain machines. For the 386, GNU CC supports PIC for System V
but not for the Sun 386i. Code generated for the IBM RS/6000 is always
position-independent.
The GNU assembler does not fully support PIC. Currently, you must use
some other assembler in order for PIC to work. We would welcome
volunteers to upgrade GAS to handle this; the first part of the job is
to figure out what the assembler must do differently.
@item -fPIC
If supported for the target machine, emit position-independent code,
suitable for dynamic linking and avoiding any limit on the size of the
@ -4805,6 +5060,61 @@ Pack all structure members together without holes. Usually you would
not want to use this option, since it makes the code suboptimal, and
the offsets of structure members won't agree with system libraries.
@item -fcheck-memory-usage
Generate extra code to check each memory access. GNU CC will generate
code that is suitable for a detector of bad memory accesses such as
@file{Checker}. If you specify this option, you can not use the
@code{asm} or @code{__asm__} keywords.
You must also specify this option when you compile functions you call that
have side effects. If you do not, you may get erronous messages from
the detector. Normally, you should compile all your code with this option.
If you use functions from a library that have side-effects (such as
@code{read}), you may not be able to recompile the library and
specify this option. In that case, you can enable the
@samp{-fprefix-function-name} option, which requests GNU CC to encapsulate
your code and make other functions look as if they were compiled with
@samp{-fcheck-memory-usage}. This is done by calling ``stubs'',
which are provided by the detector. If you cannot find or build
stubs for every function you call, you may have to specify
@samp{-fcheck-memory-usage} without @samp{-fprefix-function-name}.
@item -fprefix-function-name
Request GNU CC to add a prefix to the symbols generated for function names.
GNU CC adds a prefix to the names of functions defined as well as
functions called. Code compiled with this option and code compiled
without the option can't be linked together, unless or stubs are used.
If you compile the following code with @samp{-fprefix-function-name}
@example
extern void bar (int);
void
foo (int a)
@{
return bar (a + 5);
@}
@end example
@noindent
GNU CC will compile the code as if it was written:
@example
extern void prefix_bar (int);
void
prefix_foo (int a)
@{
return prefix_bar (a + 5);
@}
@end example
This option is designed to be used with @samp{-fcheck-memory-usage}.
@item -fstack-check
Generate code to verify that you do not go beyond the boundary of the
stack. You should specify this flag if you are running in an
environment with multiple threads, but only rarely need to specify it in
a single-threaded environment since stack overflow is automatically
detected on nearly all systems if there is only one stack.
@item +e0
@itemx +e1
Control whether virtual function definitions in classes are used to

2
gcc/just-fixinc
View file

@ -1,5 +1,5 @@
#!/bin/sh
# $Id$
# $Id: just-fixinc,v 1.1 1997/08/11 15:57:11 law Exp $
# This script exists for use after installing
# the GCC binaries from a distribution tape/CD-ROM.
# Use it *after* copying the directory of binaries

19
gcc/md.texi
View file

@ -2410,6 +2410,16 @@ this pattern to emit the required instructions.
No operands are provided.
@cindex @code{check_stack} instruction pattern
@item @samp{check_stack}
If stack checking cannot be done on your system by probing the stack with
a load or store instruction (@pxref{Stack Checking}), define this pattern
to perform the needed check and signaling an error if the stack
has overflowed. The single operand is the location in the stack furthest
from the current stack pointer that you need to validate. Normally,
on machines where this pattern is needed, you would obtain the stack
limit from a global or thread-specific variable or register.
@cindex @code{nonlocal_goto} instruction pattern
@item @samp{nonlocal_goto}
Emit code to generate a non-local goto, e.g., a jump from one function
@ -2436,6 +2446,15 @@ normally need to define this pattern. A typical reason why you might
need this pattern is if some value, such as a pointer to a global table,
must be restored when the frame pointer is restored. There are no
arguments.
@cindex @code{exception_receiver} instruction pattern
@item @samp{exception_receiver}
This pattern, if defined, contains code needed at the site of an
exception handler that isn't needed at the site of a nonlocal goto. You
will not normally need to define this pattern. A typical reason why you
might need this pattern is if some value, such as a pointer to a global
table, must be restored after control flow is branched to the handler of
an exception. There are no arguments.
@end table
@node Pattern Ordering

17
gcc/move-if-change Executable file
View file

@ -0,0 +1,17 @@
#!/bin/sh
# Like mv $1 $2, but if the files are the same, just delete $1.
# Status is 0 if $2 is changed, 1 otherwise.
if
test -r $2
then
if
cmp -s $1 $2
then
echo $2 is unchanged
rm -f $1
else
mv -f $1 $2
fi
else
mv -f $1 $2
fi

Some files were not shown because too many files have changed in this diff Show more