lostecho/oldlinux-files
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add directory gnu

Browse Source
This commit is contained in:
gohigh
2024-02-19 00:24:47 -05:00
parent 32616db5a4
commit a40f4cadb0
5086 changed files with 1860970 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
gnu/gcc-2/c-torture-1.11.tar.bz2 Normal file
View File

Binary file not shown.

BIN
gnu/gcc-2/g++-2.5.0-testsuite.tar.bz2 Normal file
View File

Binary file not shown.

BIN
gnu/gcc-2/gcc-2.0.tar.bz2 Normal file
View File

Binary file not shown.

BIN
gnu/gcc-2/gcc-2.1.tar.bz2 Normal file
View File

Binary file not shown.

BIN
gnu/gcc-2/gcc-2.2.2.tar.bz2 Normal file
View File

Binary file not shown.

BIN
gnu/gcc-2/gcc-2.3.3-testsuite.tar.bz2 Normal file
View File

Binary file not shown.

BIN
gnu/gcc-2/gcc-2.3.3.tar.bz2 Normal file
View File

Binary file not shown.

BIN
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3.tar Normal file
View File

Binary file not shown.

80
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/.gdbinit Normal file
View File

@@ -0,0 +1,80 @@
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 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

339
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/COPYING Normal file
View File

@@ -0,0 +1,339 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
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
Appendix: How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to 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., 675 Mass Ave, Cambridge, MA 02139, 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.

481
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/COPYING.LIB Normal file
View File

@@ -0,0 +1,481 @@
GNU LIBRARY GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[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., 675 Mass Ave, Cambridge, MA 02139, 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!

9828
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/ChangeLog Normal file
View File

File diff suppressed because it is too large Load Diff

9207
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/ChangeLog.1 Normal file
View File

File diff suppressed because it is too large Load Diff

7229
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/ChangeLog.2 Normal file
View File

File diff suppressed because it is too large Load Diff

8063
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/ChangeLog.3 Normal file
View File

File diff suppressed because it is too large Load Diff

10783
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/ChangeLog.4 Normal file
View File

File diff suppressed because it is too large Load Diff

8954
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/ChangeLog.5 Normal file
View File

File diff suppressed because it is too large Load Diff

1153
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/INSTALL Normal file
View File

File diff suppressed because it is too large Load Diff

1855
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/Makefile.in Normal file
View File

File diff suppressed because it is too large Load Diff

6671
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/OChangeLog Normal file
View File

File diff suppressed because it is too large Load Diff

117
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/PROBLEMS Normal file
View File

@@ -0,0 +1,117 @@
3. When find_reloads is used to count number of spills needed
it does not take into account the fact that a reload may
turn out to be a dummy.
I'm not sure this really happens any more. Doesn't it find
all the dummies on both passes?
10. movl a3@,a0
movl a3@(16),a1
clrb a0@(a1:l)
is generated and may be worse than
movl a3@,a0
addl a3@(16),a0
clrb a0@
If ordering of operands is improved, many more
such cases will be generated from typical array accesses.
38. Hack expand_mult so that if there is no same-modes multiply
it will use a widening multiply and then truncate rather than
calling the library.
39. Hack expanding of division to notice cases for
long -> short division.
40. Represent divide insns as (DIV:SI ...) followed by
a separate lowpart extract. Represent remainder insns as DIV:SI
followed by a separate highpart extract. Then cse can work on
the DIV:SI part. Problem is, this may not be desirable on machines
where computing the quotient alone does not necessarily give
a remainder--such as the 68020 for long operands.
52. Reloading can look at how reload_contents got set up.
If it was copied from a register, just reload from that register.
Otherwise, perhaps can change the previous insn to move the
data via the reload reg, thus avoiding one memory ref.
63. Potential problem in cc_status.value2, if it ever activates itself
after a two-address subtraction (which currently cannot happen).
It is supposed to compare the current value of the destination
but eliminating it would use the results of the subtraction, equivalent
to comparing the previous value of the destination.
65. Should loops that neither start nor end with a break
be rearranged to end with the last break?
69. Define the floating point converting arithmetic instructions
for the 68881.
74. Combine loop opt with cse opt in one pass. Do cse on each loop,
then loop opt on that loop, and go from innermost loops outward.
Make loop invariants available for cse at end of loop.
85. pea can force a value to be reloaded into an areg
which can make it worse than separate adding and pushing.
This can only happen for adding something within addql range
and it only loses if the qty becomes dead at that point
so it can be added to with no copying.
93. If a pseudo doesn't get a hard reg everywhere,
can it get one during a loop?
96. Can do SImode bitfield insns without reloading, but must
alter the operands in special ways.
99. final could check loop-entry branches to see if they
screw up deletion of a test instruction. If they do,
can put another test instruction before the branch and
make it conditional and redirect it.
106. Aliasing may be impossible if data types of refs differ
and data type of containing objects also differ.
(But check this wrt unions.)
108. Can speed up flow analysis by making a table saying which
register is set and which registers are used by each instruction that
only sets one register and only uses two. This way avoid the tree
walk for such instructions (most instructions).
109. It is desirable to avoid converting INDEX to SImode if a
narrower mode suffices, as HImode does on the 68000.
How can this be done?
110. Possible special combination pattern:
If the two operands to a comparison die there and both come from insns
that are identical except for replacing one operand with the other,
throw away those insns. Ok if insns being discarded are known 1 to 1.
An andl #1 after a seq is 1 to 1, but how should compiler know that?
112. Can convert float to unsigned int by subtracting a constant,
converting to signed int, and changing the sign bit.
117. Any number of slow zero-extensions in one loop, that have
their clr insns moved out of the loop, can share one register
if their original life spans are disjoint.
But it may be hard to be sure of this since
the life span data that regscan produces may be hard to interpret
validly or may be incorrect after cse.
118. In cse, when a bfext insn refers to a register, if the field
corresponds to a halfword or a byte and the register is equivalent
to a memory location, it would be possible to detect this and
replace it with a simple memory reference.
121. Insns that store two values cannot be moved out of loops.
The code in scan_loop doesn't even try to deal with them.
122. When insn-output.c turns a bit-test into a sign-test,
it should see whether the cc is already set up with that sign.
123. When a conditional expression is used as a function arg, it would
be faster (and in some cases shorter) to push each alternative rather
than compute in a register and push that. This would require
being able to specify "push this" as a target for expand_expr.
124. On the 386, bad code results from foo (bar ()) when bar
returns a double, because the pseudo used fails to get preferenced
into an fp reg because of the distinction between regs 8 and 9.

448
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/PROJECTS Normal file
View File

@@ -0,0 +1,448 @@
0. Improved efficiency.
* Parse and output array initializers an element at a time, freeing
storage after each, instead of parsing the whole initializer first and
then outputting. This would reduce memory usage for large
initializers.
* See if the techniques describe in Oct 1991 SIGPLAN Notices
(Frazer and Hanson) are applicable to GCC.
1. Better optimization.
* Constants in unused inline functions
It would be nice to delay output of string constants so that string
constants mentioned in unused inline functions are never generated.
Perhaps this would also take care of string constants in dead code.
The difficulty is in finding a clean way for the RTL which refers
to the constant (currently, only by an assembler symbol name)
to point to the constant and cause it to be output.
* More cse
The techniques for doing full global cse are described in the red
dragon book, or (a different version) in Frederick Chow's thesis from
Stanford. It is likely to be slow and use a lot of memory, but it
might be worth offering as an additional option.
It is probably possible to extend cse to a few very frequent cases
without so much expense.
For example, it is not very hard to handle cse through if-then
statements with no else clauses. Here's how to do it. On reaching a
label, notice that the label's use-count is 1 and that the last
preceding jump jumps conditionally to this label. Now you know it
is a simple if-then statement. Remove from the hash table
all the expressions that were entered since that jump insn
and you can continue with cse.
It is probably not hard to handle cse from the end of a loop
around to the beginning, and a few loops would be greatly sped
up by this.
* Optimize a sequence of if statements whose conditions are exclusive.
It is possible to optimize
if (x == 1) ...;
if (x == 2) ...;
if (x == 3) ...;
into
if (x == 1) ...;
else if (x == 2) ...;
else if (x == 3) ...;
provided that x is not altered by the contents of the if statements.
It's not certain whether this is worth doing. Perhaps programmers
nearly always write the else's themselves, leaving few opportunities
to improve anything.
* Un-cse.
Perhaps we should have an un-cse step right after cse, which tries to
replace a reg with its value if the value can be substituted for the
reg everywhere, if that looks like an improvement. Which is if the
reg is used only a few times. Use rtx_cost to determine if the
change is really an improvement.
* Clean up how cse works.
The scheme is that each value has just one hash entry. The
first_same_value and next_same_value chains are no longer needed.
For arithmetic, each hash table elt has the following slots:
* Operation. This is an rtx code.
* Mode.
* Operands 0, 1 and 2. These point to other hash table elements.
So, if we want to enter (PLUS:SI (REG:SI 30) (CONST_INT 104)), we
first enter (CONST_INT 104) and find the entry that (REG:SI 30) now
points to. Then we put these elts into operands 0 and 1 of a new elt.
We put PLUS and SI into the new elt.
Registers and mem refs would never be entered into the table as such.
However, the values they contain would be entered. There would be a
table indexed by regno which points at the hash entry for the value in
that reg.
The hash entry index now plays the role of a qty number.
We still need qty_first_reg, reg_next_eqv, etc. to record which regs
share a particular qty.
When a reg is used whose contents are unknown, we need to create a
hash table entry whose contents say "unknown", as a place holder for
whatever the reg contains. If that reg is added to something, then
the hash entry for the sum will refer to the "unknown" entry. Use
UNKNOWN for the rtx code in this entry. This replaces make_new_qty.
For a constant, a unique hash entry would be made based on the
value of the constant.
What about MEM? Each time a memory address is referenced, we need a
qty (a hash table elt) to represent what is in it. (Just as for a
register.) If this isn't known, create one, just as for a reg whose
contents are unknown.
We need a way to find all mem refs that still contain a certain value.
Do this with a chain of hash elts (for memory addresses) that point to
locations that hold the value. The hash elt for the value itself should
point to the start of the chain. It would be good for the hash elt
for an address to point to the hash elt for the contents of that address
(but this ptr can be null if the contents have never been entered).
With this data structure, nothing need ever be invalidated except
the lists of which regs or mems hold a particular value. It is easy
to see if there is a reg or mem that is equiv to a particular value.
If the value is constant, it is always explicitly constant.
* Support more general tail-recursion among different functions.
This might be possible under certain circumstances, such as when
the argument lists of the functions have the same lengths.
Perhaps it could be done with a special declaration.
You would need to verify in the calling function that it does not
use the addresses of any local variables and does not use setjmp.
* Put short statics vars at low addresses and use short addressing mode?
Useful on the 68000/68020 and perhaps on the 32000 series,
provided one has a linker that works with the feature.
This is said to make a 15% speedup on the 68000.
* Keep global variables in registers.
Here is a scheme for doing this. A global variable, or a local variable
whose address is taken, can be kept in a register for an entire function
if it does not use non-constant memory addresses and (for globals only)
does not call other functions. If the entire function does not meet
this criterion, a loop may.
The VAR_DECL for such a variable would have to have two RTL expressions:
the true home in memory, and the pseudo-register used temporarily.
It is necessary to emit insns to copy the memory location into the
pseudo-register at the beginning of the function or loop, and perhaps
back out at the end. These insns should have REG_EQUIV notes so that,
if the pseudo-register does not get a hard register, it is spilled into
the memory location which exists in any case.
The easiest way to set up these insns is to modify the routine
put_var_into_stack so that it does not apply to the entire function
(sparing any loops which contain nothing dangerous) and to call it at
the end of the function regardless of where in the function the
address of a local variable is taken. It would be called
unconditionally at the end of the function for all relevant global
variables.
For debugger output, the thing to do is to invent a new binding level
around the appropriate loop and define the variable name as a register
variable with that scope.
* Live-range splitting.
Currently a variable is allocated a hard register either for the full
extent of its use or not at all. Sometimes it would be good to
allocate a variable a hard register for just part of a function; for
example, through a particular loop where the variable is mostly used,
or outside of a particular loop where the variable is not used. (The
latter is nice because it might let the variable be in a register most
of the time even though the loop needs all the registers.)
It might not be very hard to do this in global.c when a variable
fails to get a hard register for its entire life span.
The first step is to find a loop in which the variable is live, but
which is not the whole life span or nearly so. It's probably best to
use a loop in which the variable is heavily used.
Then create a new pseudo-register to represent the variable in that loop.
Substitute this for the old pseudo-register there, and insert move insns
to copy between the two at the loop entry and all exits. (When several
such moves are inserted at the same place, some new feature should be
added to say that none of those registers conflict merely because of
overlap between the new moves. And the reload pass should reorder them
so that a store precedes a load, for any given hard register.)
After doing this for all the reasonable candidates, run global-alloc
over again. With luck, one of the two pseudo-registers will be fit
somewhere. It may even have a much higher priority due to its reduced
life span.
There will be no room in general for the new pseudo-registers in
basic_block_live_at_start, so there will need to be a second such
matrix exclusively for the new ones. Various other vectors indexed by
register number will have to be made bigger, or there will have to be
secondary extender vectors just for global-alloc.
A simple new feature could arrange that both pseudo-registers get the
same stack slot if they both fail to get hard registers.
Other compilers split live ranges when they are not connected, or
try to split off pieces `at the edge'. I think splitting around loops
will provide more speedup.
Creating a fake binding block and a new like-named variable with
shorter life span and different address might succeed in describing
this technique for the debugger.
* Detect dead stores into memory?
A store into memory is dead if it is followed by another store into
the same location; and, in between, there is no reference to anything
that might be that location (including no reference to a variable
address).
* Loop optimization.
Strength reduction and iteration variable elimination could be
smarter. They should know how to decide which iteration variables are
not worth making explicit because they can be computed as part of an
address calculation. Based on this information, they should decide
when it is desirable to eliminate one iteration variable and create
another in its place.
It should be possible to compute what the value of an iteration
variable will be at the end of the loop, and eliminate the variable
within the loop by computing that value at the loop end.
When a loop has a simple increment that adds 1,
instead of jumping in after the increment,
decrement the loop count and jump to the increment.
This allows aob insns to be used.
* Using constraints on values.
Many operations could be simplified based on knowledge of the
minimum and maximum possible values of a register at any particular time.
These limits could come from the data types in the tree, via rtl generation,
or they can be deduced from operations that are performed. For example,
the result of an `and' operation one of whose operands is 7 must be in
the range 0 to 7. Compare instructions also tell something about the
possible values of the operand, in the code beyond the test.
Value constraints can be used to determine the results of a further
comparison. They can also indicate that certain `and' operations are
redundant. Constraints might permit a decrement and branch
instruction that checks zeroness to be used when the user has
specified to exit if negative.
* Smarter reload pass.
The reload pass as currently written can reload values only into registers
that are reserved for reloading. This means that in order to use a
register for reloading it must spill everything out of that register.
It would be straightforward, though complicated, for reload1.c to keep
track, during its scan, of which hard registers were available at each
point in the function, and use for reloading even registers that were
free only at the point they were needed. This would avoid much spilling
and make better code.
* Change the type of a variable.
Sometimes a variable is declared as `int', it is assigned only once
from a value of type `char', and then it is used only by comparison
against constants. On many machines, better code would result if
the variable had type `char'. If the compiler could detect this
case, it could change the declaration of the variable and change
all the places that use it.
* Better handling for very sparse switches.
There may be cases where it would be better to compile a switch
statement to use a fixed hash table rather than the current
combination of jump tables and binary search.
* Order of subexpressions.
It might be possible to make better code by paying attention
to the order in which to generate code for subexpressions of an expression.
* More code motion.
Consider hoisting common code up past conditional branches or
tablejumps.
* Trace scheduling.
This technique is said to be able to figure out which way a jump
will usually go, and rearrange the code to make that path the
faster one.
* Distributive law.
The C expression *(X + 4 * (Y + C)) compiles better on certain
machines if rewritten as *(X + 4*C + 4*Y) because of known addressing
modes. It may be tricky to determine when, and for which machines, to
use each alternative.
Some work has been done on this, in combine.c.
* Can optimize by changing if (x) y; else z; into z; if (x) y;
if z and x do not interfere and z has no effects not undone by y.
This is desirable if z is faster than jumping.
* For a two-insn loop on the 68020, such as
foo: movb a2@+,a3@+
jne foo
it is better to insert dbeq d0,foo before the jne.
d0 can be a junk register. The challenge is to fit this into
a portable framework: when can you detect this situation and
still be able to allocate a junk register?
2. Simpler porting.
Right now, describing the target machine's instructions is done
cleanly, but describing its addressing mode is done with several
ad-hoc macro definitions. Porting would be much easier if there were
an RTL description for addressing modes like that for instructions.
Tools analogous to genflags and genrecog would generate macros from
this description.
There would be one pattern in the address-description file for each
kind of addressing, and this pattern would have:
* the RTL expression for the address
* C code to verify its validity (since that may depend on
the exact data).
* C code to print the address in assembler language.
* C code to convert the address into a valid one, if it is not valid.
(This would replace LEGITIMIZE_ADDRESS).
* Register constraints for all indeterminates that appear
in the RTL expression.
3. Other languages.
Front ends for Pascal, Fortran, Algol, Cobol, Modula-2 and Ada are
desirable.
Pascal, Modula-2 and Ada require the implementation of functions
within functions. Some of the mechanisms for this already exist.
4. More extensions.
* Generated unique labels. Have some way of generating distinct labels
for use in extended asm statements. I don't know what a good syntax would
be.
* A way of defining a structure containing a union, in which the choice of
union alternative is controlled by a previous structure component.
Here is a possible syntax for this.
struct foo {
enum { INT, DOUBLE } code;
auto union { case INT: int i; case DOUBLE: double d;} value : code;
};
* Allow constructor expressions as lvalues, like this:
(struct foo) {a, b, c} = foo();
This would call foo, which returns a structure, and then store the
several components of the structure into the variables a, b, and c.
5. Generalize the machine model.
* Some new compiler features may be needed to do a good job on machines
where static data needs to be addressed using base registers.
* Some machines have two stacks in different areas of memory, one used
for scalars and another for large objects. The compiler does not
now have a way to understand this.
6. Useful warnings.
* Warn about statements that are undefined because the order of
evaluation of increment operators makes a big difference. Here is an
example:
*foo++ = hack (*foo);
7. Better documentation of how GCC works and how to port it.
Here is an outline proposed by Allan Adler.
I. Overview of this document
II. The machines on which GCC is implemented
A. Prose description of those characteristics of target machines and
their operating systems which are pertinent to the implementation
of GCC.
i. target machine characteristics
ii. comparison of this system of machine characteristics with
other systems of machine specification currently in use
B. Tables of the characteristics of the target machines on which
GCC is implemented.
C. A priori restrictions on the values of characteristics of target
machines, with special reference to those parts of the source code
which entail those restrictions
i. restrictions on individual characteristics
ii. restrictions involving relations between various characteristics
D. The use of GCC as a cross-compiler
i. cross-compilation to existing machines
ii. cross-compilation to non-existent machines
E. Assumptions which are made regarding the target machine
i. assumptions regarding the architecture of the target machine
ii. assumptions regarding the operating system of the target machine
iii. assumptions regarding software resident on the target machine
iv. where in the source code these assumptions are in effect made
III. A systematic approach to writing the files tm.h and xm.h
A. Macros which require special care or skill
B. Examples, with special reference to the underlying reasoning
IV. A systematic approach to writing the machine description file md
A. Minimal viable sets of insn descriptions
B. Examples, with special reference to the underlying reasoning
V. Uses of the file aux-output.c
VI. Specification of what constitutes correct performance of an
implementation of GCC
A. The components of GCC
B. The itinerary of a C program through GCC
C. A system of benchmark programs
D. What your RTL and assembler should look like with these benchmarks
E. Fine tuning for speed and size of compiled code
VII. A systematic procedure for debugging an implementation of GCC
A. Use of GDB
i. the macros in the file .gdbinit for GCC
ii. obstacles to the use of GDB
a. functions implemented as macros can't be called in GDB
B. Debugging without GDB
i. How to turn off the normal operation of GCC and access specific
parts of GCC
C. Debugging tools
D. Debugging the parser
i. how machine macros and insn definitions affect the parser
E. Debugging the recognizer
i. how machine macros and insn definitions affect the recognizer
ditto for other components
VIII. Data types used by GCC, with special reference to restrictions not
specified in the formal definition of the data type
IX. References to the literature for the algorithms used in GCC

29
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/README Normal file
View File

@@ -0,0 +1,29 @@
This directory contains the version 2.3.3 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.
This is still a beta test release, but aside from the Objective C
run-time, it ought to be close to reliable.
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).

9
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/README-fixinc Normal file
View File

@@ -0,0 +1,9 @@
This README file is copied into the directory for GCC-only header files
when fixincludes is run by the makefile for GCC.
Many of the files in this directory were made from the standard system
header files of this system by the shell script `fixincludes'.
They are system-specific, and will not work on any other kind of system.
They are also not part of GCC. The reason for making the files here
is to fix the places in the header files which use constructs
that are incompatible with ANSI C.

53
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/README.ALTOS Normal file
View File

@@ -0,0 +1,53 @@
Return-Path: <jkp@sauna.hut.fi>
Date: Mon, 10 Apr 89 10:13:45 +0300
From: Jyrki Kuoppala <jkp@sauna.hut.fi>
Sender: jkp@sauna.hut.fi
To: info-gcc@prep.ai.mit.edu
Subject: Kernel fix needed for Altos 3068 to get coff-encapsulation working right
Organization: Helsinki University of Technology, Finland.
Here's a description how to fix a kernel bug in Altos 3068 and get
gcc-compiled programs working.
Author: Jyrki Kuoppala (jkp@cs.hut.fi)
Last modified: Mon Apr 10 09:28:40 1989
There's a bug in the Altos 3068 kernel that causes gcc-compiled
programs to fail in certain situations when the machine has a heavy
load and also in some other situations. The bug exists at least in
SVR 2.2 1.0gT1 and SVR 2.2 1.0e.
If you have source code to your system, apply the following change to
os/exec.c (function gethead):
Change the lines containing
u.u_exdata.ux_tstart = sizeof(struct naout) +
sizeof(struct filhd) + (ep->ef.nscns * sizeof(struct scnhdr));
to
u.u_exdata.ux_tstart = u.u_exdata.ux_txtorg;
If you only have binary, use sdb to find out the address of the
previous lines (on our system it's gethead+0x140) and use your
favourite binary editor to change the bytes '3036 0162 fffc 0002 0280
0000' to '23f9 01fb f4ca 01fb f4c2 6016'. This may or may not work in
your case, depending on the version of the operating system and the
phase of the moon.
Here's what is just before gethead+0x140 to ease finding out the right place:
0x9224 (gethead+0x122): 23f9 01fb f4ca 01fb f4ce mov.l &0x1fbf4ca.L,&0
x1fbf4ce.L []
0x922e (gethead+0x12c): 23f9 01fb f4c6 01fb f4ca mov.l &0x1fbf4c6.L,&0
x1fbf4ca.L []
0x9238 (gethead+0x136): 23f9 01fb f4c2 01fb f4c6 mov.l &0x1fbf4c2.L,&0
x1fbf4c6.L []
Good luck !
//Jyrki
jkp@cs.hut.fi

112
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/README.APOLLO Normal file
View File

@@ -0,0 +1,112 @@
README.apollo
Building GCC 2.0 for 680x0 based Apollo systems requires the GNU
assembler (GAS) version 1.38.1, with John Vasta's patches applied.
If you haven't done so yet, get `gas-1.38.1.tar.Z' from your favourite
GNU distribution site. Furthermore, get `apollo-gas-1.38.1.diffs'
from `labrea.stanford.edu:/pub/gnu', apply the patches, compile and
install gas (under the name as). This should go through without any
problems.
After switching into the BSD environment, you can configure GCC 2.0
with the command
% ./configure m68k-apollo-bsd
The Apollo's `/usr/include/setjmp.h' uses a nonstandard `#options()'
construct. You should create a local copy of this file and remove
these constructs from the declarations of SIGSETJMP and SIGLONGJMP.
The Apollo's `/usr/include/sys/types.h' (BSD Version) doesn't allow
to test for the definition of `size_t'. This should be fixed by
#ifndef _SIZE_T
#define _SIZE_T
typedef long size_t;
#endif
The script `patch-apollo-includes' fixes these two problems, but does
_not_ pretend to be a full fledged `fixincludes' for this system.
If you now follow the standard GCC installation instructions, building
GCC 2.0 (including G++ 2.0) should proceed without any problems.
NB: Debugging is not yet supported for the Apollo. If someone wants
to do a _big_ favour to the Apollo users, he/she should consider
porting the Binary File Description library (BFD) to the Apollo.
This library can be found in the gdb-4.x distributions or in the
binutils-1.9x distributions.
#!/bin/sh
# patch-apollo-includes -- fix some (but not all!) Apollo brain damage.
FILES_TO_PATCH='sys/types.h setjmp.h'
mkdir sys
for i in $FILES_TO_PATCH;
do
cp /bsd4.3/usr/include/$i ./$i
done
patch -b -apollo <<'EOP'
*** /bsd4.3/usr/include/sys/types.h Fri Apr 8 20:29:06 1988
--- sys/types.h Wed Feb 26 21:17:57 1992
***************
*** 38,44 ****
--- 38,47 ----
typedef char * caddr_t;
typedef u_long ino_t;
typedef long swblk_t;
+ #ifndef _SIZE_T
+ #define _SIZE_T
typedef long size_t;
+ #endif
typedef long time_t;
typedef long dev_t;
typedef long off_t;
*** /bsd4.3/usr/include/setjmp.h Fri Feb 3 21:40:21 1989
--- setjmp.h Sun Feb 23 19:06:55 1992
***************
*** 24,30 ****
--- 24,39 ----
#endif
+ #ifdef __GNUC__
#ifdef _PROTOTYPES
+ extern int sigsetjmp (sigjmp_buf env, int savemask);
+ extern void siglongjmp (sigjmp_buf env, int val);
+ #else
+ extern int sigsetjmp();
+ extern void siglongjmp();
+ #endif /* _PROTOTYPES */
+ #else /* not __GNUC__ */
+ #ifdef _PROTOTYPES
extern int sigsetjmp(
sigjmp_buf env,
int savemask
***************
*** 37,43 ****
extern int sigsetjmp() #options(abnormal);
extern void siglongjmp() #options(noreturn);
#endif /* _PROTOTYPES */
!
#undef _PROTOTYPES
#ifdef __cplusplus
--- 46,52 ----
extern int sigsetjmp() #options(abnormal);
extern void siglongjmp() #options(noreturn);
#endif /* _PROTOTYPES */
! #endif /* not __GNUC__ */
#undef _PROTOTYPES
#ifdef __cplusplus
EOP
exit 0

594
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/README.DWARF Normal file
View File

@@ -0,0 +1,594 @@
Notes on the GNU Implementation of DWARF Debugging Information
--------------------------------------------------------------
Last Updated: Sun Oct 4 10:04:13 PDT 1992 by rfg@netcom.com
-----------------------------------------------------
This file describes special and unique aspects of the GNU implementation
of the DWARF debugging information language, as provided in the GNU version
2.x compiler(s).
For general information about the DWARF debugging information language,
you should obtain the DWARF version 1 specification document (and perhaps
also the DWARF version 2 draft specification document) developed by the
UNIX International Programming Languages Special Interest Group. A copy
of the the DWARF version 1 specification (in PostScript form) may be
obtained either from me <rfg@netcom.com> or from UNIX International. (See
below.) The file you are looking at now only describes known deviations
from the UI/PLSIG DWARF version 1 specification, together with those
things which are allowed by the DWARF version 1 specification but which
are known to cause interoperability problems (e.g. with SVR4 SDB).
To obtain a copy of the DWARF version 1 specification from UNIX International,
use the following procedure:
---------------------------------------------------------------------------
Send mail to archive@ui.org containing the following:
path yourname@your.site
send PUBLIC/dwarf.v1.mm
for the troff source, or
send PUBLIC/dwarf.v1.ps
for the postscript. If you system supports uncompress and uudecode,
you can request that the data be compressed by placing the command
'compress' in the message.
If you have any questions about the archive service, please contact
Shane P. McCarron, UI Project Manager, <s.mccarron@ui.org>.
---------------------------------------------------------------------------
The generation of DWARF debugging information by the GNU version 2.x C
compiler has now been tested rather extensively for m88k, i386, i860, and
Sparc targets. The DWARF output of the GNU C compiler appears to inter-
operate well with the standard SVR4 SDB debugger on these kinds of target
systems (but of course, there are no guarantees).
DWARF generation for the GNU g++ compiler is still not operable. This is
due primarily to the many remaining cases where the g++ front end does not
conform to the conventions used in the GNU C front end for representing
various kinds of declarations in the TREE data structure. It is not clear
at this time how these problems will be addressed.
Future plans for the dwarfout.c module of the GNU compiler(s) includes the
addition of full support for GNU FORTRAN. (This should, in theory, be a
lot simpler to add than adding support for g++... but we'll see.)
Many features from the evolving DWARF version 2 (draft) specification have
been adapted to, and used in the GNU implementation of DWARF (version 1).
In most of these cases, a DWARF version 2 (draft) approach is used in place
of (or in addition to) DWARF version 1 stuff simply because it is apparent
that DWARF version 1 is not sufficiently expressive to provide the kinds of
information which may be necessary to support really robust debugging.
In *all* of these cases however, the use of DWARF version 2 (draft) features
should not interfere in any way with the interoperability (of GNU compilers)
with generally available "classic" (pre version 1) DWARF consumer tools
(e.g. SVR4 SDB). Full support for DWARF version 2 should be available
sometime after the DWARF version 2 specification has been finalized.
The DWARF generation enhancement for the GNU compiler(s) was initially
donated to the Free Software Foundation by Network Computing Devices.
(Thanks NCD!) Additional development and maintenance of dwarfout.c has
been largely supported (i.e. funded) by Intel Corporation. (Thanks Intel!)
If you have questions or comments about the DWARF generation feature, please
send mail to me <rfg@netcom.com>. I will be happy to investigate any bugs
reported and I may even provide fixes (but of course, I can make no promises).
The DWARF debugging information produced by GCC may deviate in a few minor
(but perhaps significant) respects from the DWARF debugging information
currently produced by other C compilers. A serious attempt has been made
however to conform to the published specifications, to existing practice,
and to generally accepted norms in the GNU implementation of DWARF.
If you are interested in obtaining more information about DWARF or in
participating in the continuing evolution of DWARF within the UI/PLSIG
group, please contact either myself or the UI/PLSIG chairman, Dan Oldman
<oldman@dg-rtp.dg.com>. The UI/PLSIG welcomes and encourages the
participation of new members who might be interested in discussing debugging
issues in general, and DWARF in particular. There are no dues and you
DO NOT have to be a UI member in order to join the UI/PLSIG. The UI/PLSIG
operates an E-mail mailing list and holds regular meeting in various cities.
If you don't have time to participate actively, but would like to be kept
abreast of recent developments, you con join the UI/PLSIG mailing list and
just listen in on our lively discussions.
** IMPORTANT NOTE ** ** IMPORTANT NOTE ** ** IMPORTANT NOTE **
Under normal circumstances, the DWARF information generated by the GNU
compilers (in an assembly language file) is essentially impossible for
a human being to read. This fact can make it very difficult to debug
certain DWARF-related problems. In order to overcome this difficulty,
a feature has been added to dwarfout.c (enabled by the -fverbose-asm
option) which causes additional comments to be placed into the assembly
language output file, out to the right-hand side of most bits of DWARF
material. The comments indicate (far more clearly that the obscure
DWARF hex codes do) what is actually being encoded in DWARF. Thus, the
-fverbose-asm option can be highly useful for those who must study the
DWARF output from the GNU compilers in detail.
---------
(Footnote: Within this file, the term `Debugging Information Entry' will
be abbreviated as `DIE'.)
Release Notes (aka known bugs)
-------------------------------
In one very obscure case involving dynamically sized arrays, the DWARF
"location information" for such an array may make it appear that the
array has been totally optimized out of existence, when in fact it
*must* actually exist. (This only happens when you are using *both* -g
*and* -O.) This is due to aggressive dead store elimination in the
compiler, and to the fact that the DECL_RTL expressions associated with
variables are not always updated to correctly reflect the effects of
GCC's aggressive dead store elimination.
-------------------------------
When attempting to set a breakpoint at the "start" of a function compiled
with -g1, the debugger currently has no way of knowing exactly where the
end of the prologue code for the function is. Thus, for most targets,
all the debugger can do is to set the breakpoint at the AT_low_pc address
for the function. But if you stop there and then try to look at one or
more of the formal parameter values, they may not have been "homed" yet,
so you may get inaccurate answers (or perhaps even addressing errors).
Some people may consider this simply a non-feature, but I consider it a
bug, and I hope to provide some some GNU-specific attributes (on function
DIEs) which will specify the address of the end of the prologue and the
address of the beginning of the epilogue in a future release.
-------------------------------
It is believed at this time that old bugs relating to the AT_bit_offset
values for bit-fields have been fixed.
There may still be some very obscure bugs relating to the DWARF description
of type `long long' bit-fields for target machines (e.g. 80x86 machines)
where the alignment of type `long long' data objects is different from
(and less than) the size of a type `long long' data object.
Please report any problems with the DWARF description of bit-fields as you
would any other GCC bug. (Procedures for bug reporting are given in the
GNU C compiler manual.)
--------------------------------
At this time, GCC does not know how to handle the GNU C "nested functions"
extension. (See the GCC manual for more info on this extension to ANSI C.)
--------------------------------
The GNU compilers now represent inline functions (and inlined instances
thereof) in exactly the manner described by the current DWARF version 2
(draft) specification. The version 1 specification for handling inline
functions (and inlined instances) was known to be brain-damaged (by the
PLSIG) when the version 1 spec was finalized, but it was simply too late
in the cycle to get it removed before the version 1 spec was formally
released to the public (by UI).
--------------------------------
At this time, GCC does not generate the kind of really precise information
about the exact declared types of entities with signed integral types which
is required by the current DWARF draft specification.
Specifically, the current DWARF draft specification seems to require that
the type of an non-unsigned integral bit-field member of a struct or union
type be represented as either a "signed" type or as a "plain" type,
depending upon the the exact set of keywords that were used in the
type specification for the given bit-field member. It was felt (by the
UI/PLSIG) that this distinction between "plain" and "signed" integral types
could have some significance (in the case of bit-fields) because ANSI C
does not constrain the signedness of a plain bit-field, whereas it does
constrain the signedness of an explicitly "signed" bit-field. For this
reason, the current DWARF specification calls for compilers to produce
type information (for *all* integral typed entities... not just bit-fields)
which explicitly indicates the signedness of the relevant type to be
"signed" or "plain" or "unsigned".
Unfortunately, the GNU DWARF implementation is currently incapable of making
such distinctions.
--------------------------------
Known Interoperability Problems
-------------------------------
Although the GNU implementation of DWARF conforms (for the most part) with
the current UI/PLSIG DWARF version 1 specification (with many compatible
version 2 features added in as "vendor specific extensions" just for good
measure) there are a few known cases where GCC's DWARF output can cause
some confusion for "classic" (pre version 1) DWARF consumers such as the
System V Release 4 SDB debugger. These cases are described in this section.
--------------------------------
The DWARF version 1 specification includes the fundamental type codes
FT_ext_prec_float, FT_complex, FT_dbl_prec_complex, and FT_ext_prec_complex.
Since GNU C is only a C compiler (and since C doesn't provide any "complex"
data types) the only one of these fundamental type codes which GCC ever
generates is FT_ext_prec_float. This fundamental type code is generated
by GCC for the `long double' data type. Unfortunately, due to an apparent
bug in the SVR4 SDB debugger, SDB can become very confused wherever any
attempt is made to print a variable, parameter, or field whose type was
given in terms of FT_ext_prec_float.
(Actually, SVR4 SDB fails to understand *any* of the four fundamental type
codes mentioned here. This will fact will cause additional problems when
there is a GNU FORTRAN front-end.)
--------------------------------
In general, it appears that SVR4 SDB is not able to effectively ignore
fundamental type codes in the "implementation defined" range. This can
cause problems when a program being debugged uses the `long long' data
type (or the signed or unsigned varieties thereof) because these types
are not defined by ANSI C, and thus, GCC must use its own private fundamental
type codes (from the implementation-defined range) to represent these types.
--------------------------------
General GNU DWARF extensions
----------------------------
In the current DWARF version 1 specification, no mechanism is specified by
which accurate information about executable code from include files can be
properly (and fully) described. (The DWARF version 2 specification *does*
specify such a mechanism, but it is about 10 times more complicated than
it needs to be so I'm not terribly anxious to try to implement it right
away.)
In the GNU implementation of DWARF version 1, a fully downward-compatible
extension has been implemented which permits the GNU compilers to specify
which executable lines come from which files. This extension places
additional information (about source file names) in GNU-specific sections
(which should be totally ignored by all non-GNU DWARF consumers) so that
this extended information can be provided (to GNU DWARF consumers) in a way
which is totally transparent (and invisible) to non-GNU DWARF consumers
(e.g. the SVR4 SDB debugger). The additional information is placed *only*
in specialized GNU-specific sections, where it should never even be seen
by non-GNU DWARF consumers.
To understand this GNU DWARF extension, imagine that the sequence of entries
in the .lines section is broken up into several subsections. Each contiguous
sequence of .line entries which relates to a sequence of lines (or statements)
from one particular file (either a `base' file or an `include' file) could
be called a `line entries chunk' (LEC).
For each LEC there is one entry in the .debug_srcinfo section.
Each normal entry in the .debug_srcinfo section consists of two 4-byte
words of data as follows:
(1) The starting address (relative to the entire .line section)
of the first .line entry in the relevant LEC.
(2) The starting address (relative to the entire .debug_sfnames
section) of a NUL terminated string representing the
relevant filename. (This filename name be either a
relative or an absolute filename, depending upon how the
given source file was located during compilation.)
Obviously, each .debug_srcinfo entry allows you to find the relevant filename,
and it also points you to the first .line entry that was generated as a result
of having compiled a given source line from the given source file.
Each subsequent .line entry should also be assumed to have been produced
as a result of compiling yet more lines from the same file. The end of
any given LEC is easily found by looking at the first 4-byte pointer in
the *next* .debug_srcinfo entry. That next .debug_srcinfo entry points
to a new and different LEC, so the preceding LEC (implicitly) must have
ended with the last .line section entry which occurs at the 2 1/2 words
just before the address given in the first pointer of the new .debug_srcinfo
entry.
The following picture may help to clarify this feature. Let's assume that
`LE' stands for `.line entry'. Also, assume that `* 'stands for a pointer.
.line section .debug_srcinfo section .debug_sfnames section
----------------------------------------------------------------
LE <---------------------- *
LE * -----------------> "foobar.c" <---
LE |
LE |
LE <---------------------- * |
LE * -----------------> "foobar.h" <| |
LE | |
LE | |
LE <---------------------- * | |
LE * -----------------> "inner.h" | |
LE | |
LE <---------------------- * | |
LE * ------------------------------- |
LE |
LE |
LE |
LE |
LE <---------------------- * |
LE * -----------------------------------
LE
LE
LE
In effect, each entry in the .debug_srcinfo section points to *both* a
filename (in the .debug_sfnames section) and to the start of a block of
consecutive LEs (in the .line section).
Note that just like in the .line section, there are specialized first and
last entries in the .debug_srcinfo section for each object file. These
special first and last entries for the .debug_srcinfo section are very
different from the normal .debug_srcinfo section entries. They provide
additional information which may be helpful to a debugger when it is
interpreting the data in the .debug_srcinfo, .debug_sfnames, and .line
sections.
The first entry in the .debug_srcinfo section for each compilation unit
consists of five 4-byte words of data. The contents of these five words
should be interpreted (by debuggers) as follows:
(1) The starting address (relative to the entire .line section)
of the .line section for this compilation unit.
(2) The starting address (relative to the entire .debug_sfnames
section) of the .debug_sfnames section for this compilation
unit.
(3) The starting address (in the execution virtual address space)
of the .text section for this compilation unit.
(4) The ending address plus one (in the execution virtual address
space) of the .text section for this compilation unit.
(5) The date/time (in seconds since midnight 1/1/70) at which the
compilation of this compilation unit occurred. This value
should be interpreted as an unsigned quantity because gcc
might be configured to generate a default value of 0xffffffff
in this field (in cases where it is desired to have object
files created at different times from identical source files
be byte-for-byte identical). By default, these timestamps
are *not* generated by dwarfout.c (so that object files
compiled at different times will be byte-for-byte identical).
If you wish to enable this "timestamp" feature however, you
can simply place a #define for the symbol `DWARF_TIMESTAMPS'
in your target configuration file and then rebuild the GNU
compiler(s).
Note that the first string placed into the .debug_sfnames section for each
compilation unit is the name of the directory in which compilation occurred.
This string ends with a `/' (to help indicate that it is the pathname of a
directory). Thus, the second word of each specialized initial .debug_srcinfo
entry for each compilation unit may be used as a pointer to the (string)
name of the compilation directory, and that string may in turn be used to
"absolutize" any relative pathnames which may appear later on in the
.debug_sfnames section entries for the same compilation unit.
The fifth and last word of each specialized starting entry for a compilation
unit in the .debug_srcinfo section may (depending upon your configuration)
indicate the date/time of compilation, and this may be used (by a debugger)
to determine if any of the source files which contributed code to this
compilation unit are newer than the object code for the compilation unit
itself. If so, the debugger may wish to print an "out-of-date" warning
about the compilation unit.
The .debug_srcinfo section associated with each compilation will also have
a specialized terminating entry. This terminating .debug_srcinfo section
entry will consist of the following two 4-byte words of data:
(1) The offset, measured from the start of the .line section to
the beginning of the terminating entry for the .line section.
(2) A word containing the value 0xffffffff.
--------------------------------
In the current DWARF version 1 specification, no mechanism is specified by
which information about macro definitions and un-definitions may be provided
to the DWARF consumer.
The DWARF version 2 (draft) specification does specify such a mechanism.
That specification was based on the GNU ("vendor specific extension")
which provided some support for macro definitions and un-definitions,
but the "official" DWARF version 2 (draft) specification mechanism for
handling macros and the GNU implementation have diverged somewhat. I
plan to update the GNU implementation to conform to the "official"
DWARF version 2 (draft) specification as soon as I get time to do that.
Note that in the GNU implementation, additional information about macro
definitions and un-definitions is *only* provided when the -g3 level of
debug-info production is selected. (The default level is -g2 and the
plain old -g option is considered to be identical to -g2.)
GCC records information about macro definitions and undefinitions primarily
in a section called the .debug_macinfo section. Normal entries in the
.debug_macinfo section consist of the following three parts:
(1) A special "type" byte.
(2) A 3-byte line-number/filename-offset field.
(3) A NUL terminated string.
The interpretation of the second and third parts is dependent upon the
value of the leading (type) byte.
The type byte may have one of four values depending upon the type of the
.debug_macinfo entry which follows. The 1-byte MACINFO type codes presently
used, and their meanings are as follows:
MACINFO_start A base file or an include file starts here.
MACINFO_resume The current base or include file ends here.
MACINFO_define A #define directive occurs here.
MACINFO_undef A #undef directive occur here.
(Note that the MACINFO_... codes mentioned here are simply symbolic names
for constants which are defined in the GNU dwarf.h file.)
For MACINFO_define and MACINFO_undef entries, the second (3-byte) field
contains the number of the source line (relative to the start of the current
base source file or the current include files) when the #define or #undef
directive appears. For a MACINFO_define entry, the following string field
contains the name of the macro which is defined, followed by its definition.
Note that the definition is always separated from the name of the macro
by at least one whitespace character. For a MACINFO_undef entry, the
string which follows the 3-byte line number field contains just the name
of the macro which is being undef'ed.
For a MACINFO_start entry, the 3-byte field following the type byte contains
the offset, relative to the start of the .debug_sfnames section for the
current compilation unit, of a string which names the new source file which
is beginning its inclusion at this point. Following that 3-byte field,
each MACINFO_start entry always contains a zero length NUL terminated
string.
For a MACINFO_resume entry, the 3-byte field following the type byte contains
the line number WITHIN THE INCLUDING FILE at which the inclusion of the
current file (whose inclusion ends here) was initiated. Following that
3-byte field, each MACINFO_resume entry always contains a zero length NUL
terminated string.
Each set of .debug_macinfo entries for each compilation unit is terminated
by a special .debug_macinfo entry consisting of a 4-byte zero value followed
by a single NUL byte.
--------------------------------
In the current DWARF draft specification, no provision is made for providing
a separate level of (limited) debugging information necessary to support
tracebacks (only) through fully-debugged code (e.g. code in system libraries).
A proposal to define such a level was submitted (by me) to the UI/PLSIG.
This proposal was rejected by the UI/PLSIG for inclusion into the DWARF
version 1 specification for two reasons. First, it was felt (by the PLSIG)
that the issues involved in supporting a "traceback only" subset of DWARF
were not well understood. Second, and perhaps more importantly, the PLSIG
is already having enough trouble agreeing on what it means to be "conformant"
to the DWARF specification, and it was felt that trying to specify multiple
different *levels* of conformance would only complicate our discussions of
this already divisive issue. Nonetheless, the GNU implementation of DWARF
provides an abbreviated "traceback only" level of debug-info production for
use with fully-debugged "system library" code. This level should only be
used for fully debugged system library code, and even then, it should only
be used where there is a very strong need to conserve disk space. This
abbreviated level of debug-info production can be used by specifying the
-g1 option on the compilation command line.
--------------------------------
As mentioned above, the GNU implementation of DWARF currently uses the DWARF
version 2 (draft) approach for inline functions (and inlined instances
thereof). This is used in preference to the version 1 approach because
(quite simply) the version 1 approach is highly brain-damaged and probably
unworkable.
--------------------------------
GNU DWARF Representation of GNU C Extensions to ANSI C
------------------------------------------------------
The file dwarfout.c has been designed and implemented so as to provide
some reasonable DWARF representation for each and every declarative
construct which is accepted by the GNU C compiler. Since the GNU C
compiler accepts a superset of ANSI C, this means that there are some
cases in which the DWARF information produced by GCC must take some
liberties in improvising DWARF representations for declarations which
are only valid in (extended) GNU C.
In particular, GNU C provides at least three significant extensions to
ANSI C when it comes to declarations. These are (1) inline functions,
and (2) dynamic arrays, and (3) incomplete enum types. (See the GCC
manual for more information on these GNU extensions to ANSI C.) When
used, these GNU C extensions are represented (in the generated DWARF
output of GCC) in the most natural and intuitively obvious ways.
In the case of inline functions, the DWARF representation is exactly as
called for in the DWARF version 2 (draft) specification for an identical
function written in C++; i.e. we "reuse" the representation of inline
functions which has been defined for C++ to support this GNU C extension.
In the case of dynamic arrays, we use the most obvious representational
mechanism available; i.e. an array type in which the upper bound of
some dimension (usually the first and only dimension) is a variable
rather than a constant. (See the DWARF version 1 specification for more
details.)
In the case of incomplete enum types, such types are represented simply
as TAG_enumeration_type DIEs which DO NOT contain either AT_byte_size
attributes or AT_element_list attributes.
--------------------------------
Future Directions
-----------------
The codes, formats, and other paraphernalia necessary to provide proper
support for symbolic debugging for the C++ language are still being worked
on by the UI/PLSIG. The vast majority of the additions to DWARF which will
be needed to completely support C++ have already been hashed out and agreed
upon, but a few small issues (e.g. anonymous unions, access declarations)
are still being discussed. Also, we in the PLSIG are still discussing
whether or not we need to do anything special for C++ templates. (At this
time it is not yet clear whether we even need to do anything special for
these.)
Unfortunately, as mentioned above, there are quite a few problems in the
g++ front end itself, and these are currently responsible for severly
restricting the progress which can be made on adding DWARF support
specifically for the g++ front-end. Furthermore, Richard Stallman has
expressed the view that C++ friendships might not be important enough to
describe (in DWARF). This view directly conflicts with both the DWARF
version 1 and version 2 (draft) specifications, so until this small
misunderstanding is cleared up, DWARF support for g++ is unlikely.
With regard to FORTRAN, the UI/PLSIG has defined what is believed to be a
complete and sufficient set of codes and rules for adequately representing
all of FORTRAN 77, and most of Fortran 90 in DWARF. While some support for
this has been implemented in dwarfout.c, further implementation and testing
will have to await the arrival of the GNU Fortran front-end (which is
currently in early alpha test as of this writing).
GNU DWARF support for other languages (i.e. Pascal and Modula) is a moot
issue until there are GNU front-ends for these other languages.
GNU DWARF support for DWARF version 2 will probably not be attempted until
such time as the version 2 specification is finalized. (More work needs
to be done on the version 2 specification to make the new "abbreviations"
feature of version 2 more easily implementable. Until then, it will be
a royal pain the ass to implement version 2 "abbreviations".) For the
time being, version 2 features will be added (in a version 1 compatible
manner) when and where these features seem necessary or extremely desirable.
As currently defined, DWARF only describes a (binary) language which can
be used to communicate symbolic debugging information from a compiler
through an assembler and a linker, to a debugger. There is no clear
specification of what processing should be (or must be) done by the
assembler and/or the linker. Fortunately, the role of the assembler
is easily inferred (by anyone knowledgeable about assemblers) just by
looking at examples of assembly-level DWARF code. Sadly though, the
allowable (or required) processing steps performed by a linker are
harder to infer and (perhaps) even harder to agree upon. There are
several forms of very useful `post-processing' steps which intelligent
linkers *could* (in theory) perform on object files containing DWARF,
but any and all such link-time transformations are currently both disallowed
and unspecified.
In particular, possible link-time transformations of DWARF code which could
provide significant benefits include (but are not limited to):
Commonization of duplicate DIEs obtained from multiple input
(object) files.
Cross-compilation type checking based upon DWARF type information
for objects and functions.
Other possible `compacting' transformations designed to save disk
space and to reduce linker & debugger I/O activity.

69
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/README.ENCAP Normal file
View File

@@ -0,0 +1,69 @@
1/3/89 Pace Willisson
Here is what to do to bring up GCC & tools on an 80386 running system 5.3
(if you are adventurous and want to use the latest and greatest tools.
If you want it to be easy, check back in a couple of months.)
All of these instructions assume you are using the usg compiler. After
you get to the end, you could start over using the GNU compiler, but
that may not work yet ...
First make gcc, cc1, cpp, and gnulib:
cd .../gcc
config.gcc i386-sysv-gas
make start.encap
Don't try to bootstrap the compiler with itself at this point,
since it can't really be used until GAS and the converted libraries
are installed.
Now you must copy `cc1' and `cpp' and `gnulib' into the directory
`/usr/local/lib/gcc-lib/i386-sysv-gas/VERSION', where VERSION stands for
the GCC version number. Also install `gcc' in a directory in your
path.
Now, make the GNU assembler:
cd .../gas
make a386
cp a386 /usr/local/lib/gcc-lib/i386-sysv-gas/VERSION
Now, make the other utilities:
cd .../binutils
edit Makefile to turn on the CFLAGS for USG using COFF_ENCAPSULATE
make
cp ld /usr/local/lib/gcc-lib/i386-sysv-gas/VERSION
Put the other programs (size nm strip ar objdump and ranlib) somewhere
handy, but don't clobber your usg programs. I put them all in
/usr/gnu/gnucomp, and I have this shell script in my path under the name "gnu":
exec /usr/gnu/gnucomp/$*
That way, I can say "gnu nm a.out", etc.
Convert the libraries to the encapsulated format:
make libc.a
cp libc.a /usr/local/lib/gnu/libc.a
cp .../gcc/gnulib usg-gnulib
make gnulib
cp gnulib /usr/local/lib/gcc-lib/i386-sysv-gas/VERSION
robotussin /lib/crt0.o /usr/local/lib/gcc-crt0.o
Now add the parts of `gnulib' that are compiled with GCC,
and install the complete `gnulib' in place of the partial one.
cp gnulib .../gcc
cd .../gcc
make rest.encap
cp gnulib /usr/local/lib/gcc-lib/i386-sysv-gas/VERSION
Now, you should be able to use 'gcc' to compile programs.
If you want to bootstrap GCC with itself, this can now be done.

13
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/README.MIPS Normal file
View File

@@ -0,0 +1,13 @@
If you use the 1.31 version of the MIPS assembler (such as was shipped
with Ultrix 3.1), you will need to use the -fno-delayed-branch switch
when optimizing floating point code. Otherwise, the assembler will
complain when the GCC compiler fills a branch delay slot with a
floating point instruction, such as add.d.
The GCC compiler on the MIPS will put small strings into the short
data area, rather than the read-only data section. This is so that
references to the strings only take one instruction, instead of the
normal two instructions.
Users have reported some problems with version 2.0 of the MIPS
compiler tools (Ultrix 4.1). Version 2.10 seems to work (Ultrix 4.2).

150
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/README.NS32K Normal file
View File

@@ -0,0 +1,150 @@
Copyright (C) 1987 Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@mcc.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 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, 675 Mass Ave, Cambridge, MA 02139, USA.
This file describes the implementation notes of the GNU C Compiler for
the National Semiconductor 32032 chip (and 32000 family).
The 32032 machine description and configuration file for this compiler
is, for NS32000 family machine, primarily machine independent.
However, since this release still depends on vendor-supplied
assemblers and linkers, the compiler must obey the existing
conventions of the actual machine to which this compiler is targeted.
In this case, the actual machine which this compiler was targeted to
is a Sequent Balance 8000, running DYNIX 2.1.
The assembler for DYNIX 2.1 (and DYNIX 3.0, alas) does not cope with
the full generality of the addressing mode REGISTER RELATIVE.
Specifically, it generates incorrect code for operands of the
following form:
sym(rn)
Where `rn' is one of the general registers. Correct code is generated
for operands of the form
sym(pn)
where `pn' is one of the special processor registers (sb, fp, or sp).
An equivalent operand can be generated by the form
sym[rn:b]
although this addressing mode is about twice as slow on the 32032.
The more efficient addressing mode is controlled by defining the
constant SEQUENT_ADDRESS_BUG to 0. It is currently defined to be 1.
Another bug in the assembler makes it impossible to compute with
explicit addresses. In order to compute with a symbolic address, it
is necessary to load that address into a register using the "addr"
instruction. For example, it is not possible to say
cmpd _p,@_x
Rather one must say
addr _x,rn
cmpd _p,rn
The ns32032 chip has a number of known bugs. Any attempt to make the
compiler unaware of these deficiencies will surely bring disaster.
The current list of know bugs are as follows (list provided by Richard
Stallman):
1) instructions with two overlapping operands in memory
(unlikely in C code, perhaps impossible).
2) floating point conversion instructions with constant
operands (these may never happen, but I'm not certain).
3) operands crossing a page boundary. These can be prevented
by setting the flag in tm.h that requires strict alignment.
4) Scaled indexing in an insn following an insn that has a read-write
operand in memory. This can be prevented by placing a no-op in
between. I, Michael Tiemann, do not understand what exactly is meant
by `read-write operand in memory'. If this is referring to the special
TOS mode, for example "addd 5,tos" then one need not fear, since this
will never be generated. However, is this includes "addd 5,-4(fp)"
then there is room for disaster. The Sequent compiler does not insert
a no-op for code involving the latter, and I have been informed that
Sequent is aware of this list of bugs, so I must assume that it is not
a problem.
5) The 32032 cannot shift by 32 bits. It shifts modulo the word size
of the operand. Therefore, for 32-bit operations, 32-bit shifts are
interpreted as zero bit shifts. 32-bit shifts have been removed from
the compiler, but future hackers must be careful not to reintroduce
them.
6) The ns32032 is a very slow chip; however, some instructions are
still very much slower than one might expect. For example, it is
almost always faster to double a quantity by adding it to itself than
by shifting it by one, even if that quantity is deep in memory. The
MOVM instruction has a 20-cycle setup time, after which it moves data
at about the speed that normal moves would. It is also faster to use
address generation instructions than shift instructions for left
shifts less than 4. I do not claim that I generate optimal code for all
given patterns, but where I did escape from National's "clean
architecture", I did so because the timing specification from the data
book says that I will win if I do. I suppose this is called the
"performance gap".
Signed bitfield extraction has not been implemented. It is not
provided by the NS32032, and while it is most certainly possible to do
better than the standard shift-left/shift-right sequence, it is also
quite hairy. Also, since signed bitfields do not yet exist in C, this
omission seems relatively harmless.
Zero extractions could be better implemented if it were possible in
GCC to provide sized zero extractions: i.e. a byte zero extraction
would be allowed to yield a byte result. The current implementation
of GCC manifests 68000-ist thinking, where bitfields are extracted
into a register, and automatically sign/zero extended to fill the
register. See comments in ns32k.md around the "extzv" insn for more
details.
It should be noted that while the NS32000 family was designed to
provide odd-aligned addressing capability for multi-byte data (also
provided by the 68020, but not by the 68000 or 68010), many machines
do not opt to take advantage of this. For example, on the sequent,
although there is no advantage to long-word aligning word data, shorts
must be int-aligned in structs. This is an example of another
machine-specific machine dependency.
Because the ns32032 is has a coherent byte-order/bit-order
architecture, many instructions which would be different for
68000-style machines, fold into the same instruction for the 32032.
The classic case is push effective address, where it does not matter
whether one is pushing a long, word, or byte address. They all will
push the same address.
The macro FUNCTION_VALUE_REGNO_P is probably not sufficient, what is
needed is FUNCTION_VALUE_P, which also takes a MODE parameter. In
this way it will be possible to determine more exactly whether a
register is really a function value register, or just one that happens
to look right.

30
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/README.RS6000 Normal file
View File

@@ -0,0 +1,30 @@
Debugging code compiled with GCC on the RS/6000 requires that you
upgrade the AIX assembler /bin/as with a replacement that is available
from IBM.
Any customer can order and get the replacement assembler, and install
it on one or more machines. It is distributed both on diskette and
via VNET, for downloading via ftp. VNET distribution may be desirable
if you have a friendly IBM rep nearby with a networked VM machine.
In either case, to order, execute
lslpp -h bos.obj to determine your release level. (Look on the
ACTIVE line for something like 03.01.0005.0012.) Then call IBM Support
at 800-237-5511. Ask for emergency shipment of the rs6000 AIX fix for
APAR IX26107. They may ask you to verify that it's a fix for "Don't
allow .csect name[BS] or [UC]"; say yes. They may also ask you for
your customer number. If you do not know it, you will still be able
to getthe fix, but you will have to be persistent.
You will receive a tar or tar.Z file containing an assembler plus
installation instructions.
If you tell them you're running AIX version 3.2, you may be told that
no fix is available yet. In fact the 3.15 fix works fine on version
3.2. Talk them into shipping it to you anyway.
IBM has corresponding support organizations outside of North America.
Call your IBM branch office and ask them to put you in touch with the
department that handles emergency fixes for AIX on the RS/6000. If
that doesn't work, ask for the department that handles software defect
support for AIX on the RS/6000. Then ask for the emergency APAR fix.

55
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/README.TRAD Normal file
View File

@@ -0,0 +1,55 @@
This is a partial list of how `gcc -traditional' disagrees with
traditional C compilers (perhaps only some of them). Most of these
differences are not bugs.
---------------------------------------------------------------------------
K&R-1 (2.4.3) says:
"If the character following a backslash is not one of those
specified {in the table above}, the backslash is ignored."
Up until recently, `gcc -traditional' complained about \x \a and \v
appearing in a character or string literal. I believe however that
this non-feature has been eliminated (recently).
---------------------------------------------------------------------------
When in -traditional mode, gcc allows the following erroneous pair of
declarations to appear together in a given scope:
typedef int foo;
typedef foo foo;
---------------------------------------------------------------------------
K&R-1 (8.5) says:
"No field may be wider than a word."
Gcc however allows:
struct S { int i:33; };
---------------------------------------------------------------------------
In K&R-1 there is no restriction against comments crossing include file
boundaries. Gcc however doesn't allow this, even when in -traditional mode.
---------------------------------------------------------------------------
Regarding the length of identifiers, K&R-1 (2.2) says:
"No more than the first eight characters are significant,
although more may be used."
Gcc treats all characters of identifiers as significant, even when in
-traditional mode.
---------------------------------------------------------------------------
K&R-1 (2.2) says:
"An identifier is a sequence of letters and digits; the first
character must be a letter. The underscore _ counts as a letter."
Gcc also allows dollar signs in identifiers. (This may also be an issue
for the -pedantic option.)
---------------------------------------------------------------------------

203
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/README.X11 Normal file
View File

@@ -0,0 +1,203 @@
How to compile X11R5 (patch level 11) with GCC version 2:
The patches include support for building the shared libraries with GCC 2 on
the Sparc and 68k machines. NOTE: Such shared libraries DO NOT WORK
with executables previously linked using Sun CC! This is because
neither those executables nor the gcc-compiled shared libraries contain
libgcc.a. The shared libraries do work with executables linked using
GCC (running the Sun linker, of course) because GCC tells the linker to
link in libgcc.a. Because of these limitations the default behavior is
to NOT build the shared libraries with gcc. If you want the gcc-compiled
shared libraries turn on "Gcc2BuildLibs" in site.def
If you want to build a shared library that works with executables
linked with Sun CC, you will have to arrange to include libgcc.a in
the shared libraries. The instructions below do not handle this.
Sun forgot to include a static version of libdl.a with some versions
of SunOS (4.1 mainly). If you see undefined symbols _dlopen, _dlsym,
or _dlclose when linking with -lX11, compile and link against the file
mit/util/misc/dlsym.c in the MIT X11R5 distribution.
mit/config/Imake.tmpl -- Do not set -fstrength-reduce if we have GCC 2. If
-fstrength-reduce (or any other -f option) is a major win, then it will
most likely be turned on by -O2 optimization.
mit/config/sunLib.rules -- If HasGcc2 and Gcc2BuildLibs are defined, then
use gcc -fpic to generate PIC code. Make sure that gcc does not use gas (the
GNU assembler) when compiling PIC code; gas does not assemble it correctly.
If you have gas installed where gcc uses it by default, you might have to add
-B/bin/ to the PositionIndependentCFlags.
mit/config/site.def -- Define HasGcc2 to be YES.
mit/config/sun.cf -- When compiling with GCC 2, use -O2 optimization.
mit/rgb/Imakefile -- No longer need to compile some modules with
cc on the Sparc since GCC 2 produces proper -fpcc-struct-return code.
mit/server/os/Imakefile -- Likewise.
mit/clients/twm/Imakefile -- fix bad decls of malloc, realloc in gram.c.
*** mit/config/Imake.tmpl.ORIG Tue Dec 31 11:07:56 1991
--- mit/config/Imake.tmpl Tue Dec 31 12:30:47 1991
***************
*** 499,508 ****
--- 499,512 ----
#define HasGcc NO
#endif
#ifndef CcCmd
+ #if HasGcc2
+ #define CcCmd gcc -fpcc-struct-return
+ #else
#if HasGcc
#define CcCmd gcc -fstrength-reduce -fpcc-struct-return
#else
#define CcCmd cc
+ #endif
#endif
#endif
#if HasFortran
*** mit/config/sunLib.rules.ORIG Tue Dec 31 11:11:24 1991
--- mit/config/sunLib.rules Tue May 5 12:26:12 1992
***************
*** 23,30 ****
--- 23,34 ----
#define SharedLibraryLoadFlags -assert pure-text
#endif
#ifndef PositionIndependentCFlags
+ #if defined(HasGcc2) && defined (Gcc2BuildLibs)
+ #define PositionIndependentCFlags -fpic
+ #else
#define PositionIndependentCFlags -pic
#endif
+ #endif
/*
* InstallSharedLibrary - generate rules to install the shared library.
*** mit/config/site.def.ORIG Tue Dec 31 11:13:49 1991
--- mit/config/site.def Tue Dec 31 12:02:59 1991
***************
*** 25,31 ****
#ifdef BeforeVendorCF
! /* #define HasGcc YES */
#endif /* BeforeVendorCF */
--- 25,33 ----
#ifdef BeforeVendorCF
! #define HasGcc YES
! #define HasGcc2 YES
! /* #define Gcc2BuildLibs YES */
#endif /* BeforeVendorCF */
*** mit/config/sun.cf.ORIG Tue Dec 31 11:13:57 1991
--- mit/config/sun.cf Tue May 5 12:29:50 1992
***************
*** 34,42 ****
--- 41,61 ----
#if HasGcc
+ #if defined(HasGcc2)
+ #define OptimizedCDebugFlags -O2
+ /* Leave Alone XXX */
+ #else
+ #define OptimizedCDebugFlags -O
#define SharedLibraryCcCmd cc
#define ExtraLoadFlags -B/usr/bin/
#define AllocateLocalDefines /**/
+ #endif
+
+ #if !defined(Gcc2BuildLibs)
+ #define SharedLibraryCcCmd cc
+ #define ExtraLoadFlags -B/usr/bin/
+ #define AllocateLocalDefines /**/
+ #endif
.c.o:
$(CC) -c $(CFLAGS) $*.c
*** mit/rgb/Imakefile.ORIG Wed Jan 15 16:43:18 1992
--- mit/rgb/Imakefile Thu Jan 2 13:34:09 1992
***************
*** 17,23 ****
#if !(defined(SGIArchitecture) || SystemV4)
DBMLIB = -ldbm
#endif
! #if defined(SparcArchitecture) && HasGcc
CC = cc
CCOPTIONS = /**/
EXTRA_LOAD_FLAGS = /**/
--- 17,23 ----
#if !(defined(SGIArchitecture) || SystemV4)
DBMLIB = -ldbm
#endif
! #if defined(SparcArchitecture) && HasGcc && !defined(HasGcc2)
CC = cc
CCOPTIONS = /**/
EXTRA_LOAD_FLAGS = /**/
*** mit/server/os/Imakefile.ORIG Wed Jan 15 16:46:23 1992
--- mit/server/os/Imakefile Wed Jan 15 16:46:48 1992
***************
*** 132,138 ****
SpecialObjectRule(osinit.o,$(ICONFIGFILES),$(ADM_DEFINES))
SpecialObjectRule(WaitFor.o,$(ICONFIGFILES),$(EXT_DEFINES))
SpecialObjectRule(fonttype.o,$(ICONFIGFILES),$(FONT_DEFINES))
! #if defined(SparcArchitecture) && HasGcc
oscolor.o: $(ICONFIGFILES)
$(RM) $@
cc -c $(DBM_DEFINES) $(CDEBUGFLAGS) $(ALLDEFINES) $*.c
--- 132,138 ----
SpecialObjectRule(osinit.o,$(ICONFIGFILES),$(ADM_DEFINES))
SpecialObjectRule(WaitFor.o,$(ICONFIGFILES),$(EXT_DEFINES))
SpecialObjectRule(fonttype.o,$(ICONFIGFILES),$(FONT_DEFINES))
! #if defined(SparcArchitecture) && HasGcc && !defined(HasGcc2)
oscolor.o: $(ICONFIGFILES)
$(RM) $@
cc -c $(DBM_DEFINES) $(CDEBUGFLAGS) $(ALLDEFINES) $*.c
*** 1.1 1992/09/08 19:52:07
--- mit/server/ddx/sun/Imakefile 1992/09/08 21:10:22
***************
*** 43,48 ****
--- 43,53 ----
LinkFile(sunGX.o,sunGX.o.dist)
#endif
+ #if HasGcc2
+ SpecialObjectRule(sunCG2C.o,sunCG2C.c,-fvolatile)
+ SpecialObjectRule(sunCG2M.o,sunCG2M.c,-fvolatile)
+ #endif
+
sunInitExtMono.o: $(ICONFIGFILES)
ObjectFromSpecialSource(sunInitExtMono,../mi/miinitext,-UPEXEXT)
ObjectFromSpecialSource(sunInitMono,sunInit,-DMONO_ONLY)
*** /tmp/RCSAa24446 Tue Sep 15 12:23:32 1992
--- mit/clients/twm/Imakefile Thu Aug 13 18:18:07 1992
***************
*** 32,41 ****
--- 32,48 ----
ComplexProgramTarget(twm)
InstallNonExecFile(system.twmrc,$(TWMDIR))
+ #if HasGcc2 && defined (SunArchitecture)
gram.h gram.c: gram.y
yacc $(YFLAGS) gram.y
+ sed -e 's/^extern char \*malloc(), \*realloc();//g' y.tab.c >gram.c
+ $(MV) y.tab.h gram.h
+ #else
+ gram.h gram.c: gram.y
+ yacc $(YFLAGS) gram.y
$(MV) y.tab.c gram.c
$(MV) y.tab.h gram.h
+ #endif
clean::
$(RM) y.tab.h y.tab.c lex.yy.c gram.h gram.c lex.c deftwmrc.c

991
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/SERVICE Normal file
View File

@@ -0,0 +1,991 @@
GNU Service Directory -*- text -*-
This is a list of people who have asked to be listed as offering
support services for GNU software, including GNU Emacs, for a fee
or in some cases at no charge.
The information comes from the people who asked to be listed;
we do not include any information we know to be false, but we
cannot check out any of the information; we are transmitting it to
you as it was given to us and do not promise it is correct.
Also, this is not an endorsement of the people listed here.
We have no opinions and usually no information about the abilities of
any specific person. We provide this list to enable you to contact
service providers and decide for yourself whether to hire one.
Before FSF will list your name in the GNU Service Directory, we ask
that you agree informally to the following terms:
1. You will not restrict (except by copyleft) the use or distribution
of any software, documentation, or other information you supply anyone
in the course of modifying, extending, or supporting GNU software.
This includes any information specifically designed to ameliorate the
use of GNU software.
2. You will not take advantage of contact made through the Service
Directory to advertise an unrelated business (e.g., sales of
non-GNU-related proprietary information). You may spontaneously
mention your availability for general consulting, but you should not
promote a specific unrelated business unless the client asks.
Please include some indication of your rates, because otherwise users
have nothing to go by. Please put each e-mail address inside "<>".
Please put nothing else inside "<>". Thanks!
For a current copy of this directory, or to have yourself listed, ask:
gnu@prep.ai.mit.edu
** Please keep this file alphabetical **

Joseph Arceneaux <jla@ai.mit.edu>
PO Box 460633
San Francisco, CA 94146-0633
+1 415 285 9088
Performed X11 implementation of Emacs version 19.
Worked on Emacs text annotation.
Service and development of GNU and X11 software. Handholding, teaching,
and installations at lower rates.
Rates: $150/hour. Free to selected non-profit and activist organizations.
Updated: 11/7/91

Giuseppe Attardi <attardi@di.unipi.it>
Dipartimento di Informatica
Corso Italia 40
I-56125 Pisa, Italy
+39 (50) 510-111
GNU: help on obtaininig GNU, for italian sites.
Updated: 18/11/91

Randolph Back <rback@boulder.Colorado.edu>
Back Software & Consulting, Inc.
1705 14th St. #344
Boulder, CO 80302
(303) 443-7758
Consulting, installation, cutomization and training for GNU emacs, and
other GNU software.
Entered: 3/13/91

Andrea Baldi
European Space Agency (ESA)
European Space Operations Center (ESOC)
Robert-Bosch-Str 5
D-6100 DARMSTADT
West-Germany
Phone 0049-6151-902762 (Work) Bitnet : <abaldi@esoc.bitnet>
Fax 0049-6151-90-495 Uucp : <unido!esoc.bitnet!abaldi>
Your Rate: Free
Programs Supported: Emacs, bison, gcc, g++, gdb, bash, X11
Emacs: installation and upgrading aid, answering, customization.
Gcc, g++, gdb, bash: installation and upgrading aid.
X11: quick questions
Experience (with gnu software)
I have maintained Emacs for more than 4 years as well as bison, gcc,
g++, gdb, bash, X11. I have written/modified several Emacs lisp programs.
Currently I maintain many GNU programs for my department.
Updated: 11 Sept 91

Bard Bloom
Department of Computer Science
Cornell University
Ithaca, NY 14850
607-255-9211
Your Rate: $200/hour.
I might do work for friends and worthy organizations for free.
Programs Supported: GNU Emacs
Experience: Lots. For example, in 1989 I wrote a safe multi-user
database program of sorts in Gnu Emacs in about a week.
I've written some 30,000 lines of Gnu Lisp code in total.
Degree: PhD in CS from MIT.
Other: My real life as a professor takes precedence over consulting.
Updated: 11 Sept 91

James Craig Burley
4 Mountain Gate Rd.
Ashland, MA 01721-2326
(508) 881-6087, -4745
Email: <burley@gnu.ai.mit.edu> (preferred)
<burley@cygnus.com>
<burley@world.std.com>
Expertise:
Compiler Internals (author of GNU Fortran, for example)
Operating Systems Internals (lately Linux on the ix86)
Tools/Utilities Development and Maintenance
Microcode Development and Maintenance (primarily VLIW machines)
Debugging (often asked to help debug Other People's Code)
Documentation (authored many books and ran a few doc projects)
Extensive experience with a variety of operating systems, hardware,
languages, and so on
Rate: $75/hour, though somewhat volatile due to commitments regarding
GNU Fortran -- willing to consider flat-fee arrangements
Entered: 10 Jul 92

Michael I. Bushnell <mib@gnu.ai.mit.edu>
NE43-426, 545 Technology Square
Cambridge, MA 02139
(617) 253-8568
All GNU software: Installation, customization, answering simple or
complex questions, bug fixing, extension.
Experience: I have done Unix and GNU programming for several years,
I am the primary author of the Hurd (which provides most
kernel related facilities for the GNU OS).
I am easily available in the Cambridge/Boston area; work via email.
I am willing to travel for sufficiently large jobs.
Rates: $50/hr, negotiable, less for non-profit organizaions.
Updated: 10/29/91

C2V Renaud Dumeur <renaud@ccv.fr>
82 bd Haussmann Jean-Alain Le Borgne <jalb@ccv.fr>
75009 Paris
France
Tel (1) 40.08.07.07
Fax (1) 43.87.35.99
Emacs: questions answered, installation, teaching (all levels), elisp
and C extensions and customization, porting, troubleshooting
gcc: installation, extensions, porting
gdb: installation, debugging, porting
X11: installation, debugging, internationalization
Experience: yes (ask for details)
Rates: 500ff/hr, negotiable.
Entered: 12/17/91

Mr. David J. Camp <david@wubios.wustl.edu>
6103 Charlotte Avenue
Saint Louis, MO 63120-1201
Background: Bachelor of Science in Computer Science, Washington University
Master of Science in Computer Science, Washington University
Over 12 years experience in the computer industry.
Author of the future GNU uu/xxen/decoder program.
Skilled in many languages, including C and Unix scripts.
Tasks: I can do on-site service in the St. Louis area.
I prefer short-term projects.
I can handle long projects given time.
I reserve the right to refuse work.
Rates: $50 per hour, including travel time
Entered: 1/1/91

Computing Support Team (CSTeam)
111 College Place, Rm 2-212
Syracuse, NY, 13244-4100
phone: 1-315-443-3929, fax: 1-315-443-4745, email: <info@csteam.com>
The Computing Support Team offers a wide variety of support services
including system design, installation, software support, contract
programming, network design, integration and migration services,
training, e-mail and telephone support. Experienced with GNU, X, TeX,
and other public domain software.
Rates: $50-$80/hr, 33% non-profit discount.
Entered: 10 Jul 92

Contributed Software
Graefestr. 76
1000 Berlin 61, Germany
phone: (+49 30) 694 69 07
modems: (+49 30) 694 {61 82 | 67 49 | 68 09}
email: <info@contrib.de>
internet: scuzzy.contrib.de [192.109.39.1]
We distribute, install/port, teach and support free software
in general, i.e. X11, GNU, khoros etc.
Rates are DM 150,-- plus tax per hour, educational sites get rebates.
Entered: 10 Jul 92

Cygnus Support <info@cygnus.com>
1937 Landings Drive ...uunet!cygint!info
Mountain View, CA 94043 USA
+1 415 903 1400 voice
+1 415 903 0122 fax
Cygnus Support
1 Kendall Square
Cambridge, MA 02139
+1 617 494 1040
Cygnus Support offers warranty protection (service contracts) for a
number of free software tools. For a fixed annual fee our customers
receive binary and source distributions, mail and phone support,
documentation and customization assistance on a variety of popular
platforms.
At the time of this writing we offer support for a development package
including (among other things) gcc, g++, gdb, and of course, GNU
Emacs. We also offer support for a network facilities package
including many of the Athena tools like Kerberos and Hesiod. However
the set of supported tools and platforms increases frequently so
contact us for the latest information.
For those who need on-site assistance, support is also available from
our Cambridge office.
Rates: $300/hour. Annual Support starts at $35,000.
Updated: 11 Sept 91

Bradley N. Davis <b-davis@jaguar.utah.edu>
3242 South 540 West
Bountiful, UT 84010
(801) 298-6345
Will work on most GNU software. Especially GNU Emacs, GCC and a
little X11 and G++. Experienced with PCs and 386s.
Services offered: Installation, porting, customizing, troubleshooting.
Fee: $20 to $50 / hour depending on job
Updated: 6/11/91

DePalma SoftCraft Contact: Mauro DePalma
2923 Cohansey Drive Voice: (408) 259-4789
San Jose, CA 95132-1619 Fax: (408) 259-6935
Internet: <mauro@netcom.com> (or <apple!netcom!mauro>)
DePalma SoftCraft provides distribution, installation, setup, and
support for the X Window System (X11R4).
This small business provides consulting in every area of a computer
s/w project life cycle. We specialize in UNIX, GNU Development Tools
(gcc, g++, ...), RCS, and XView.
Updated: 4/29/91

Equivalent Software HB <ingwa@isy.liu.se>
Repslagaregatan 34 or <jonas-y@isy.liu.se>
582 22 Linkoping
SWEDEN
+46 (0)13 13 54 21
Equivalent Software HB is the worlds second(?) company dedicated to
supporting free UNIX software. The owners have more than 5 years of
UNIX experience, both as system adminstrators and programmers. We
also have extensive experience in maintaining the GNU programs, both
administrating it and fixing bugs.
Services offered:
- Installation and custumizing GNU and other free software. We will
make free software as easy to install and use as shrink wrapped
programs.
- Customization and porting.
- Subscriptions to new versions which we will send monthly or with
any other interval.
- Finding, Recommending and Investigation of free software in any
area of the customers choise.
- Regular consulting. We prefer smaller jobs, but are willing to
consider larger ones. We can work through the Internet, but prefer
jobs in Sweden.
Rates: For software items, request our price list.
For consulting, 450 SEK/hour.
Entered: 2/14/92

Free Software Association of Germany
Michaela Merz
Heimatring 19
6000 Frankfurt/Main 70
phone: (+49 69) 6312083
modems: (+49 69) 6312934 | 6311235 | 634588
email: <misch@eurom.rhein-main.de>
We distribute, install and/or port, teach, support free software and
offer regular consulting. We accept software development contracts for
any (unix) software as long as you will release it into free software.
Rates are DM 200,-- plus VAT per hour. 25 % will be donated to the
Free Software Foundation. For worthy organizations, we may
offer our services for free. Please ask.
Entered: 12/24/92

Andy Gaynor -- [Ag] <gaynor@paul.rutgers.edu>
597 Hoes Lane, Piscataway, NJ 08854
908-463-3376
GNU Emacs:
Lisp development, customization, troubleshooting, support, etc
User instruction and management for all levels of experience
Umpteen-thousand lines of Lisp code, careful study of GNU Emacs organization,
years of monitoring the UseNet Emacs and GNU groups, etc
Version 19 is due soon -- I will be up-to-speed as quickly as possible
$50/hour starting, negotiable on difficulty, organization, distribution, etc
Other Tasks:
General programming/software engineering (language software preferred)
Familiar with Unix, C, Lisp, networking, standard Unix utilities, various
other languages, etc
Contact me for more info
Entered: 10 Feb 92

Ron Guilmette <rfg@ncd.com>
396 Ano Nuevo Ave. #216
Sunnyvale, CA 94086
408-732-7839
Services: Development & porting of GNU software development tools.
GNU Contributions:
Invented, designed, and implemented the protoize and
unprotoize tools supplied with GCC2.
Designed and developed all code to support the generation
of Dwarf symbolic debugging information for System V Release
4 in GCC2.
Finished GCC2 port to the Intel i860 RISC processor.
Now developing GDB code for System V Release 4 support of
ELF and Dwarf.
Experience: 9+ years UNIX systems experience, all working on compilers
and related tools.
3+ years working professionally on GCC, G++, and GDB under
contract to various firms including the Microelectronics
and Computer Technology Corporation (MCC), Data General (DG),
Network Computing Devices (NCD), and Intel Corp.
Other qualifications:
Holder of both a Bachelor's and a Master's degree, both in
Computer Science.
Observer Member of ANSI X3J16 (C++ standardization) committee.
Former vice-chairman of UNIX International Programming
Languages Special Interest Group (UI/PLSIG).
Rates: Variable depending upon contract duration. Call for quote.
Updated: 9 Feb 92

Johannes M. Heuft <ksh@pcs.com>
Pfarrweg 2c
D-8000 Munich 90
Germany
Telephone: Germany+89/681773
Rate: min. DM 180.- ($ 120.-) per hour
interesting tasks for non-profit organisations may be free
Supported Programs: gcc, gas, g++, gdb, binutils, gnuplot, ...; (not emacs)
Experience: 10 years of operating system, network, and compiler
construction; also includes engineering management.
Degrees: Dipl. Inform. (similar to MS CS)
Updated: 11/9/91

Sanjay Hiranandani <4393472@mcimail.com>
16 Campus Plaza, Suite 180
Vestal, NY 13850
Work:607-729-7834 ext. 180
Home:607-748-2709
Fax:607-748-0243
Rate: $40/hr. Phone questions for free are ok as far as my schedule will permit
Lower rates for students and certain non-profit organizations
Can help with installation/customization/modification of most GNU software.
Experience: Software Development, System Administration, and Consulting on
a variety of computing platforms.
Updated: 11 Sept 91

Hundred Acre Software Consultants <info@pooh.com>
1280 Terminal Way, Suite 26 <uunet!heather!info>
Reno NV 89502-3243
(702) 329-9333
Hundred Acre is a consulting group providing support and development
services to organizations of all sizes. We support all kinds of publicly
available software, not just GNU; write for the current list. We work on
a "service contract" basis for support -- for a yearly fee, we provide email
and toll free telephone support, and free updates and bug fixes. Certain
support levels even have free on-site support. Development is charged on
either an hourly or fixed bid basis.
Consulting rates: $50 to $70 per hour, or fixed bid.
Support contracts: Several levels, from $500 to $30000 per year.
Updated: 2 Jul 91

Jose A. Fernandez <jaf@inference.com>
WORK: Inference Corporation HOME:
550 N. Continental Blvd. 1025 Hillside Dr.
El Segundo, CA 90245 Chino Hills, CA 91709
(310) 322-0200 (714) 528-2523
RATES:
$50-$200/hour plus expenses (or possibly free), depending on task.
SERVICES:
GNU software: installation, troubleshooting, and customization.
X11 software: installation and troubleshooting.
SysAdmin: installation, configuration, and trouble-shooting.
NetAdmin: installation, configuration, and trouble-shooting.
Education: teaching how to fish opens the demand for fishing poles.
Advice: free over email.
Entered: 10 Jul 92

Scott D. Kalter <sdk@twinsun.com>
970 Palm Ave. #218
West Hollywood, CA 90069
Home: (213)657-9174
Work: (213)524-1805
Emacs: e-lisp and C level customization/extension
training for general use and customization
user support, installation, troubleshooting
Rates: approx. $50/hr, negotiable
Very willing to answer quick questions for free.
Prefer e-mail communication to telephone.
Qualifications: BS Math/CS 1985: Carnegie Mellon University
MS CS 1988: UCLA
Extensive e-lisp level modification for rapid prototyping of
designs used in groupware research. Very familiar with all
levels of elisp programming. Taught Emacs use and
customization in universities and industry. Extensive
troubleshooting and user support experience.
Updated:10/10/91

Scott J. Kramer <sjk@aura.nbn.com>
P.O. Box 3392
San Rafael, CA 94912
+1 415-454-1295
Emacs: Tutoring, installations/upgrades, Lisp customizations,
general troubleshooting/support. Prefer that work I do
becomes part of the official Free Software Foundation
distribution.
Rate: Task- and time-dependent; non-monetary offers considered.
Updated: 28Aug91

Fen Labalme <fen@well.sf.ca.us>
Broadcatch Technologies
40 Carl St. #4
San Francisco CA 94117
(415) 731-1174
Rates: Free phone consultation
Extended project or consultation: $70/hour plus expenses
Non-profits get lower rates or free; barter welcome!
Emacs: Anything but specific termcap questions (general ones OK).
Includes elisp extensions & teaching beginning or advanced users.
Experience: I've been "hacking Emacs" for just about 15 years now.
Updated: 7/30/91

David C Lawrence <tale@cs.rpi.edu>
P.O. Box 61
North Chatham, NY 12132-0061
Home:518 766-9098 Work:518 851-2813
Rates: $30 hour for projects less than 8 hours.
$20 hour for longer projects.
Course fees vary with level of subject being taught.
Short queries answered free of charge.
All rates negotiable.
Support: Emacs (both lisp and C aspects), GCC, GAWK, sed, fileutils,
binutils, miscellaneous others. Definitely not G++.
Consulting via email or telephone, or possibly on-site.
Updated: 11 Sept 91

Greg Lehey
LEMIS
Schellnhausen 2
W-6324 Feldatal
Germany
Phone: +49-6637-1488
Fax: +49-6637-1489
Mail <grog%lemis@Germany.EU.net>
Services: Supply, porting, installation, consultation on all GNU
products.
Experience: 20 years OS and compiler experience, portations of most
GNU products.
Entered: 10 Jul 92

Marty Leisner <leisner.henr801c@xerox.com>
332 Shaftsbury Road
Rochester, New York 14610
Home:(716) 654-7931
Experience: 10 years C/Unix, 7 years DOS.
Extensive experience with GNU binary tools, cross-compilers,
embedded/hosted systems.
Degree : BS CS, Cornell University
Rates: $75/hr
Updated: 6 Jul 91

Roland McGrath <roland@idr.org>
545 Tech Sq rm 426
Cambridge, MA 02139
Work: (617) 253-8568
Co-author of GNU Make (with Richard Stallman); maintainer of GNU Make.
Author and maintainer of the GNU C Library and parts of the GNU Hurd.
FSF employee summer 1989, fall 1990 to the present.
Installation, maintenance, porting, enhancement of all GNU software.
Fees negotiable. I can work anywhere in the Boston or SF Bay Area, or
anywhere on the Internet.
Updated: 10/18/92

Lee McLoughlin <lmjm@doc.ic.ac.uk>
Department of Computing,
Imperial College,
180 Queens Gate,
London
SW7 2BZ,
UK work: +44 71 589 5111 X 5085
gcc, emacs: can support and port to new machines
other: some experience with most gnu packages
Ported emacs to two new platforms (WhiteChappel Worstations,
HLH Orion). Worked on gcc port to Intergraph Clipper. Support
various gnu packages as part of a teaching service.
Rates: Quick phone questions are free.
Degrees:.Sc(Hons) Computer Science
Other: I'm a general workaholic and well versed in compilers, communications
and most things related to Unix.
Updated: 10.10.91

T.S.Mohan <mohan%vidya@shakti.ernet.in>
KBCS Group <mohan@vigyan.ernet.in>
Supercomputer Education and Research Centre
Indian Institute of Science
Bangalore 560 012
INDIA
Telephone (01-91-812)-341811, -341805
Rate: NIL. Availability for consultancy depends on
work load. High preference for academic institutions.
Support: emacs, gdb, gcc, g++ and other small public domain utilities
Experience: Installed and supported these + other gnu programs in our
centre for the past three years. General help to sister academic
departments and other academic institutions.
Degrees: Master of Engineering in CS. Currently working towards a PhD
in Distributed computing and programming languages.
Updated: 1 Dec 1991

Mojave Systems <mojsys!support@uunet.uu.net>
1254 Harvard Avenue
Claremont, CA 91711
714-621-7372
Mojave Systems offers porting services, warranty protection, and
software support for several GNU products. Porting services are
provided for a fixed fee. Software support is provided for fixed
annual fee.
Mojave Systems is able to provide these services for a wide variety of
hosts. We are currently porting GNU make and RCS to non-Unix hosts.
Entered: 12 Dec 90

Eric Raible <raible@nas.nasa.gov>
Nasa Ames Research Center
Mail Stop T045-1
Moffett Field, CA, 94035
(415) 604-4320 (W)
Rates: $40 hour; email questions free.
Gnu emacs C/lisp programming and porting. General
unix/graphics/emacs hacking, especially on Silicon Graphics
workstations.
Degree: MIT 83 BS CS.
Updated: 11 Sept 91

Paul Reilly <reilly@dg-rtp.dg.com>
721 Bennington Drive
Raleigh, NC 27615
Work: 919 248 6210
Home: 919 847 7294
Services: access, installation, porting, customizing and debugging
Unix Free software: X11, GNU, TeX, etc.
Rates: $150/hour
Updated: Dec 1991

Adam J. Richter <adam@soda.berkeley.edu> ...!ucbvax!soda!adam
409 Evelyn Avenue, Apartment 312 (510) 528-3209
Albany, CA 94706 fax: (510) 528-8508
X windows server expert. Freeware (especially copylefted) projects
preferred.
Updated: 18 Nov 91

Wolfgang S. Rupprecht <wolfgang@wsrcc.com>
PO Box 6524 <uunet!wsrcc!wolfgang>
Alexandria, VA 22306-0524 <wolfgang%wsrcc.com@uunet.uu.net>
(703) 768-2640
Emacs: Anything, (lisp, C, customization, porting, installing) I have
written thousands of lines of GNU Emacs C and Lisp code. Original
author of the floating point additions to appear in Emacs 19.
Rates: $75/hr.
Updated: 7/20/91

John Sechrest
Jasmic Systems Internet: <sechrest@jasmic.uucp>
2140 SW 49th St. UUCP: <hp-pcd!orstcs!jasmic!sechrest>
Corvallis, Oregon 97333
Gnu software: Questions about gnu emacs general use, training and classes,
documentation, system set up and design.
Experience: 11 years of Unix work. Heavy on System administration.
Teaching classes in Unix system administraion, Unix
Kernal Programming, Networking and Consulting services.
Currently working as the Support Coordinator for
Oregon State University (for 8 years).
Familiar with BSD systems mostly. Some SysVR4.
I have supported VAxes, HP's with HPUX, HP's with 4.3 BSD,
Sequent's, Next's and a few other misc. machines.
Updated: 28 Oct 1991

Steve Simmons <scs@lokkur.dexter.mi.us>
Inland Sea
9353 Hidden Lake Circle
Dexter, MI 48130
313-769-4086 (office1)
313-426-2086 (office2)
Rate: $75.00/hr for straight time until Jan 1, 1992. Rates will go up
an undetermined amount at that time. Free advice for short questions
by phone or email.
Programs Supported: Any. Quality of support I can offer depends on
the nature of the software; in particular I am *not* a compiler person.
Experiance: 13 years in computing, 10 with UNIX and various derivatives.
Specialist in systems administration. Lots of network admin.
Degree: Bachelors from University of Michigan, 1980.
Updated: 10 Oct 91

Lynn Slater <lrs@indetech.com>
42075 Lawrence Place
Fremont Ca 94538
Office (415) 438-2048; Home (415) 793-1864; Fax (415) 438-2034
Programs: Gnu Emacs Ada Mode, Gnu Emacs Empire Tool, Emacs,
g++ and gnumake (limited support only).
Experiance:
Gnu Emacs Ada Mode -- Co-author, principle integrator
Gnu Emacs Empire Tool -- Originator, co-author, principle distributor
Emacs -- Almost all parts. Authored super-apropos, headers, first GDB
interface, fancy-lisp, enhanced scribe mode,and lots of small stuff
g++ -- Have maintained, modified, and used G++ on 300+ user commercial
OLTP software.
gnumake -- Have bug fixed and extended.
Have single makefile that can merge in local changes and build the
following systems in a consistent manner in multiple releases on multiple
machines:
asm, bison, gcc, g++, emacs, rcs, gdb, libg++, att c++ libs, gnumake,
diff, tex2iroff
The makefile and related techniques are a bit hard to explain, but they
enable use and local changes in a broad spectrum of FSF code on many
platforms without having to remember all the individual make procedures.
Rate: Free for good cause or short stuff as there is time.
Am most likely to help in areas in which I have had problems or expect to
have problems.
Updated: 10 Oct 91

Small Business Systems, Inc. <postmaster@anomaly.sbs.com>
Box 17220, Route 104
Esmond, RI 02917
401.273.4669
Rate: Varies depending on complexity of task.
Hourly and fixed-rate contracts are available.
Programs Supported: All
Updated: 11 Sept 91

Randall D. Smith <randy@ai.mit.edu>
20 Watson Street
Cambridge, MA 02139, USA
+1 (617) 983-0276
Will work on most GNU software.
Installation, handholding, trouble shooting, extensions, teaching,
GCC, GDB, GNU-EMACS, and other ports.
Rates: Upward from $50.00/hour depending on my expertise in the area of the
job. GDB consulting at $80.00/hour.
Experience: 4 years of intensive experience with Unix and C including
system hacking and modification. Experience in porting GNU-EMACS (to
SGI Iris 4D) and GCC (to use Sun FPA chip). Experience working
full-time for the GNU project on other GNU programs (June 1988 -
August 1989). Primary maintainer of GDB and the GNU loader for that
period. Resume available on request.
Entered: 10 Feb 92

Richard M. Stallman <rms@prep.ai.mit.edu>
UUCP: {mit-eddie,ucbvax,uunet,harvard,uw-beaver}!ai.mit.edu!rms
545 Tech Sq, Rm 430
Cambridge, MA 02139
Emacs: anything whatever
Is anyone interested in courses in using or extending GNU Emacs?
Original inventor of Emacs and main author of GNU Emacs and GCC.
Rates: $6/min or $250/hr.
Entered: 5/24/90

Jonathan Stone <jonathan@isor.vuw.ac.nz>
c/o- Institute of Statistics and Operations Research
Victoria University of Wellington
P.O Box 600
Wellington
New Zealand
Work: +64 4 715-315 Fax: +64 4 712-070
Rate: hourly rate: NZ $ 150/hr. Quick phone questions are free.
Reduced rates available for for non-profit/educational insts
and daily rate work. Fixed-price contracts also considered.
Programs: GNU Emacs, GCC, GDB, GNU binutils,
Ghostscript, MIT X11
I am the author of the Pyramid ports of gcc and gdb.
Experiance: Five years administration of Unix systems and GNU tools
in University environments, and support of Unix administrators
and GNU tools as an external contractor to New Zealand Government
departments.
Degrees: M.Sc (Distinction) for a thesis involving work done on GCC.
Updated: 28 Aug 91

Bob Sutterfield <bob@morningstar.com>
work: home:
Morning Star Technologies
1760 Zollinger Road 3542 Norwood Street
Columbus, Ohio 43221 USA Columbus, Ohio 43224-3424 USA
(614)451-1883 (614)267-7611
Rates: $50/hr (negotiable) plus travel expenses
Gratis to Christian missionaries and mission agencies
Services: Installation, troubleshooting, and mild customization of
most GNU production and beta-test software; tutorials, training,
and handholding; general UNIX system and network consulting.
Entered: 2/16/92

Kayvan Sylvan <kayvan@satyr.Sylvan.COM>
Sylvan Associates
879 Lewiston Drive
San Jose, CA 95136
Phone: 408-978-1407
I will help you port, install and customize GNU Emacs, GCC, G++,
bison, and other GNU tools on almost any architechture and operating
system. Questions answered. GNU C and lisp hacking available. I will
also do ongoing support and periodic upgrades if you get on my GNU
software subscription list.
Rates: $60-$100/hour, depending on type of work. Substantial discounts
for long-term contracts and also for educational or non-profit
institutions.
Experience: Many different Unix systems (2.9BSD to 4.3BSD, SVR3 and
SVR4, Xenix). Systems programming and system administration on all
brands of Unix. Kernel hacking experience. Lots of porting experience.
I can port anything to anything (within reason).
Updated: 10 Jul 92

Leonard H. Tower Jr. <tower@prep.ai.mit.edu>
36 Porter Street
Somerville, MA 02143, USA
+1 (617) 623-7739
Will work on most GNU software.
Installation, handholding, trouble shooting, extensions, teaching.
Rates: 100.00/hour + travel expenses. Negotiable for non-profits.
Experience: Have hacked on over a dozen architectures in many languages. Have
system mothered several varieties of Unixes. Assisted rms with the front end
of gcc and it's back-end support. Resume available on request.
Entered: 12 Feb 92

Watchmaker Computing <support@watch.com>
P.O.Box 163, Kendall Square
Cambridge, MA 02142
email: support@watch.com
Emacs: We'll do GNUEmacs support, porting, bug fixing, and customizing.
We also have specific expertise in:
packages: GCC, G++, X11, Xt, InterViews, PERL, TeX, Epoch
languages: C, C++, Lisp, most others; we learn quickly!
Extensive experience coding for portability under UNIX.
Typical rates $35-$150/hour; will telecommute (Internet or phone)
Entered: 1/16/91

Chris Welty <weltyc@cs.rpi.edu>
RPI Computer Science Dept
Troy, NY 12180
518-276-2816 (W)
EMail correspondance preferred.
Rates vary depending on need, barter often accepted.
Programs: emacs, especially emacs lisp.
Lots of experience in various areas.
BS, MS from RPI. Currently working on PhD.
Updated: 10/10/91

Pace Willisson <pace@blitz.com>
Blitz Product Development Corporation <uunet!blitz!pace>
4 Spruce Road
Medway, MA 02053, USA
Work: (508) 533-6430
Rates: $80.00/hour
Will work on any GNU software.
Experience: 12 years working with C, Unix and Lisp Machines including
compilation systems, networks, device drivers, demand paging systems,
boot programs and window systems. Ported GDB to 80386. Designed COFF
encapsulation scheme to run GNU linker output on System 5 kernels.
Author of Unix "ispell".
Degree: BS in Computer Science from MIT
Updated: 7/31/91

Patrick Wood
Pipeline Associates, Inc.
2740 Route 10 West
Morris Plains, NJ 07950
Rate: Free
Support For: gcc, binutils, gnulib, using gcc for cross compiling
Experiance: used gcc for cross compiling for over 2 years; used
gcc for three years; installed and support gcc on several
BSD and System V UNIX systems; wrote peephole optimizer for
gcc on 68K, wrote portable replacement for FP routines in
gnulib.c. Modified gcc and binutils to work in byte-swapped
environments.
Other: email consulting only <pipeline!phw@motown.com>,
uunet!motown!pipeline!phw,sun!pipeline!phw, amdcad!pipeline!phw
Updated: 18 Sept 91

xprt Computer Consulting, Inc. <jody@shell.com>
17200 El Camino Real Suite 110 T
Houston, TX 77058
(713) 480 UNIX
(713) 486 8575 (Fax)
Programs Supported:
X11, TeX, and all of GNU.
Experience:
We have supported and maintained all of GNU, X11 and TeX for over four
years for a major oil company's research division on several different
Unix platforms.
Rates: $150/hour
Entered: 10 Jul 92

Name: david d [zoo] zuhn <zuhn@cs.umn.edu>
Company: armadillo zoo software
Fees: $50/hour, discounts for educational institutions and non-profits
GNU and X11 installation and maintainance on SGI Iris, Sun [68k &
SPARC], and Sequent machines. Additional machines a possibility.
Any GNU software installed. Most supported.
Updated: 7/11/92

** Please keep this file alphabetical **

39
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/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.

197
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/alloca.c Normal file
View File

@@ -0,0 +1,197 @@
/*
alloca -- (mostly) portable public-domain implementation -- D A Gwyn
last edit: 86/05/30 rms
include config.h, since on VMS it renames some symbols.
Use xmalloc instead of malloc.
This implementation of the PWB library alloca() function,
which is used to allocate space off the run-time stack so
that it is automatically reclaimed upon procedure exit,
was inspired by discussions with J. Q. Johnson of Cornell.
It should work under any C implementation that uses an
actual procedure stack (as opposed to a linked list of
frames). There are some preprocessor constants that can
be defined when compiling for your specific system, for
improved efficiency; however, the defaults should be okay.
The general concept of this implementation is to keep
track of all alloca()-allocated blocks, and reclaim any
that are found to be deeper in the stack than the current
invocation. This heuristic does not reclaim storage as
soon as it becomes invalid, but it will do so eventually.
As a special case, alloca(0) reclaims storage without
allocating any. It is a good idea to use alloca(0) in
your main control loop, etc. to force garbage collection.
*/
#ifndef lint
static char SCCSid[] = "@(#)alloca.c 1.1"; /* for the "what" utility */
#endif
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifdef emacs
#ifdef static
/* actually, only want this if static is defined as ""
-- this is for usg, in which emacs must undefine static
in order to make unexec workable
*/
#ifndef STACK_DIRECTION
you
lose
-- must know STACK_DIRECTION at compile-time
#endif /* STACK_DIRECTION undefined */
#endif /* static */
#endif /* emacs */
#ifndef alloca /* If compiling with GCC, this file's not needed. */
#ifdef __STDC__
typedef void *pointer; /* generic pointer type */
#else
typedef char *pointer; /* generic pointer type */
#endif
#define NULL 0 /* null pointer constant */
extern void free();
extern pointer xmalloc();
/*
Define STACK_DIRECTION if you know the direction of stack
growth for your system; otherwise it will be automatically
deduced at run-time.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown
*/
#ifndef STACK_DIRECTION
#define STACK_DIRECTION 0 /* direction unknown */
#endif
#if STACK_DIRECTION != 0
#define STACK_DIR STACK_DIRECTION /* known at compile-time */
#else /* STACK_DIRECTION == 0; need run-time code */
static int stack_dir; /* 1 or -1 once known */
#define STACK_DIR stack_dir
static void
find_stack_direction (/* void */)
{
static char *addr = NULL; /* address of first
`dummy', once known */
auto char dummy; /* to get stack address */
if (addr == NULL)
{ /* initial entry */
addr = &dummy;
find_stack_direction (); /* recurse once */
}
else /* second entry */
if (&dummy > addr)
stack_dir = 1; /* stack grew upward */
else
stack_dir = -1; /* stack grew downward */
}
#endif /* STACK_DIRECTION == 0 */
/*
An "alloca header" is used to:
(a) chain together all alloca()ed blocks;
(b) keep track of stack depth.
It is very important that sizeof(header) agree with malloc()
alignment chunk size. The following default should work okay.
*/
#ifndef ALIGN_SIZE
#define ALIGN_SIZE sizeof(double)
#endif
typedef union hdr
{
char align[ALIGN_SIZE]; /* to force sizeof(header) */
struct
{
union hdr *next; /* for chaining headers */
char *deep; /* for stack depth measure */
} h;
} header;
/*
alloca( size ) returns a pointer to at least `size' bytes of
storage which will be automatically reclaimed upon exit from
the procedure that called alloca(). Originally, this space
was supposed to be taken from the current stack frame of the
caller, but that method cannot be made to work for some
implementations of C, for example under Gould's UTX/32.
*/
static header *last_alloca_header = NULL; /* -> last alloca header */
pointer
alloca (size) /* returns pointer to storage */
unsigned size; /* # bytes to allocate */
{
auto char probe; /* probes stack depth: */
register char *depth = &probe;
#if STACK_DIRECTION == 0
if (STACK_DIR == 0) /* unknown growth direction */
find_stack_direction ();
#endif
/* Reclaim garbage, defined as all alloca()ed storage that
was allocated from deeper in the stack than currently. */
{
register header *hp; /* traverses linked list */
for (hp = last_alloca_header; hp != NULL;)
if ((STACK_DIR > 0 && hp->h.deep > depth)
|| (STACK_DIR < 0 && hp->h.deep < depth))
{
register header *np = hp->h.next;
free ((pointer) hp); /* collect garbage */
hp = np; /* -> next header */
}
else
break; /* rest are not deeper */
last_alloca_header = hp; /* -> last valid storage */
}
if (size == 0)
return NULL; /* no allocation required */
/* Allocate combined header + user data storage. */
{
register pointer new = xmalloc (sizeof (header) + size);
/* address of header */
((header *)new)->h.next = last_alloca_header;
((header *)new)->h.deep = depth;
last_alloca_header = (header *)new;
/* User storage begins just after header. */
return (pointer)((char *)new + sizeof(header));
}
}
#endif /* no alloca */

52
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/assert.h Normal file
View File

@@ -0,0 +1,52 @@
/* Allow this file to be included multiple times
with different settings of NDEBUG. */
#undef assert
#undef __assert
#ifdef NDEBUG
#define assert(ignore) ((void) 0)
#else
#ifndef __GNUC__
#define assert(expression) \
((void) ((expression) ? 0 : __assert (expression, __FILE__, __LINE__)))
#define __assert(expression, file, lineno) \
(printf ("%s:%u: failed assertion\n", file, lineno), \
abort (), 0)
#else
#if defined(__STDC__) || defined (__cplusplus)
/* Defined in libgcc.a */
#ifdef __cplusplus
extern "C" {
extern void __eprintf (const char *, const char *, unsigned, const char *);
}
#else
extern void __eprintf (const char *, const char *, unsigned, const char *);
#endif
#define assert(expression) \
((void) ((expression) ? 0 : __assert (#expression, __FILE__, __LINE__)))
#define __assert(expression, file, line) \
(__eprintf ("%s:%u: failed assertion `%s'\n", \
file, line, expression), 0)
#else /* no __STDC__ and not C++; i.e. -traditional. */
extern void __eprintf (); /* Defined in libgcc.a */
#define assert(expression) \
((void) ((expression) ? 0 : __assert (expression, __FILE__, __LINE__)))
#define __assert(expression, file, lineno) \
(__eprintf ("%s:%u: failed assertion `%s'\n", \
file, lineno, "expression"), 0)
#endif /* no __STDC__ and not C++; i.e. -traditional. */
#endif /* no __GNU__; i.e., /bin/cc. */
#endif

68
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/basic-block.h Normal file
View File

@@ -0,0 +1,68 @@
/* Define control and data flow tables, and regsets.
Copyright (C) 1987 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Number of bits in each actual element of a regset. */
#define REGSET_ELT_BITS HOST_BITS_PER_WIDE_INT
/* Type to use for a regset element. Note that lots of code assumes
that the initial part of a regset that contains information on the
hard registers is the same format as a HARD_REG_SET. */
#define REGSET_ELT_TYPE HOST_WIDE_INT
/* Define the type for a pointer to a set with a bit for each
(hard or pseudo) register. */
typedef REGSET_ELT_TYPE *regset;
/* Size of a regset for the current function,
in (1) bytes and (2) elements. */
extern int regset_bytes;
extern int regset_size;
/* Number of basic blocks in the current function. */
extern int n_basic_blocks;
/* Index by basic block number, get first insn in the block. */
extern rtx *basic_block_head;
/* Index by basic block number, get last insn in the block. */
extern rtx *basic_block_end;
/* Index by basic block number, get address of regset
describing the registers live at the start of that block. */
extern regset *basic_block_live_at_start;
/* Indexed by n, gives number of basic block that (REG n) is used in.
If the value is REG_BLOCK_GLOBAL (-2),
it means (REG n) is used in more than one basic block.
REG_BLOCK_UNKNOWN (-1) means it hasn't been seen yet so we don't know.
This information remains valid for the rest of the compilation
of the current function; it is used to control register allocation. */
#define REG_BLOCK_UNKNOWN -1
#define REG_BLOCK_GLOBAL -2
extern short *reg_basic_block;

28
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/build-make Normal file
View File

@@ -0,0 +1,28 @@
# We have to use the cross-compiler we just built to compile it.
CC = gcc -b $(target)
# Need those to compile binaries running on host machine.
# It is configured by
#
# configure --host=target_cpu-target_os \
# --target=host=target_cpu-target_os --build=host_cpu-host_os
#
# That HOST stuff has to be taken care of very carefully.
HOST_PREFIX=l-
HOST_PREFIX_1=$(HOST_PREFIX)
HOST_CC=$(CC) -b $(build)
HOST_CFLAGS=$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS) $(XCFLAGS)
HOST_CLIB=
HOST_LDFLAGS=$(LDFLAGS)
HOST_CPPFLAGS=$(ALL_CPPFLAGS)
HOST_ALLOCA=$(ALLOCA)
HOST_MALLOC=$(MALLOC)
HOST_OBSTACK=$(OBSTACK)
# Cause installation using install-build. We do nothing here.
INSTALL_TARGET = install-build
# Don't try to compile the things we can't compile or we have made
# while making gcc with the cross-compiler.
ALL = all.build

143
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/byteorder.h Normal file
View File

@@ -0,0 +1,143 @@
#ifndef _SYS_BYTEORDER_H
#define _SYS_BYTEORDER_H
/* Functions to convert `short' and `long' quantities from host byte order
to (internet) network byte order (i.e. big-endian).
Written by Ron Guilmette (rfg@ncd.com).
This isn't actually used by GCC. It is installed by fixinc.svr4.
For big-endian machines these functions are essentially no-ops.
For little-endian machines, we define the functions using specialized
asm sequences in cases where doing so yields better code (e.g. i386). */
#if !defined (__GNUC__) && !defined (__GNUG__)
#error You lose! This file is only useful with GNU compilers.
#endif
#ifdef __GNUC__
#define __STATIC static
#else
#define __STATIC
#endif
#ifdef __STDC__
__STATIC __inline__ unsigned long htonl (unsigned long);
__STATIC __inline__ unsigned short htons (unsigned int);
__STATIC __inline__ unsigned long ntohl (unsigned long);
__STATIC __inline__ unsigned short ntohs (unsigned int);
#endif /* defined (__STDC__) */
#if defined (__i386__)
/* Convert a host long to a network long. */
__STATIC __inline__ unsigned long
htonl (__arg)
unsigned long __arg;
{
register unsigned long __result __asm__ ("%eax");
__result = __arg;
__asm__ ("xchgb %%ah, %%al\n\
rorl $16, %%eax\n\
xchgb %%ah, %%al\n\
clc" : "=r" (__result) : "0" (__result));
return __result;
}
/* Convert a host short to a network short. */
__STATIC __inline__ unsigned short
htons (__arg)
unsigned int __arg;
{
register unsigned short __result __asm__ ("%eax");
__result = __arg;
__asm__ ("xchgb %%ah, %%al\n\
clc" : "=r" (__result) : "0" (__result));
return __result;
}
#elif ((defined (__i860__) && !defined (__i860_big_endian__)) \
|| defined (__ns32k__) || defined (__vax__) \
|| defined (__spur__) || defined (__arm__))
/* For other little-endian machines, using C code is just as efficient as
using assembly code. */
/* Convert a host long to a network long. */
__STATIC __inline__ unsigned long
htonl (__arg)
unsigned long __arg;
{
register unsigned long __result;
__result = (__arg >> 24) & 0x000000ff;
__result |= (__arg >> 8) & 0x0000ff00;
__result |= (__arg << 8) & 0x00ff0000;
__result |= (__arg << 24) & 0xff000000;
return __result;
}
/* Convert a host short to a network short. */
__STATIC __inline__ unsigned short
htons (__arg)
unsigned int __arg;
{
register unsigned short __result;
__result = (__arg << 8) & 0xff00;
__result |= (__arg >> 8) & 0x00ff;
return __result;
}
#else /* must be a big-endian machine */
/* Convert a host long to a network long. */
__STATIC __inline__ unsigned long
htonl (__arg)
unsigned long __arg;
{
return __arg;
}
/* Convert a host short to a network short. */
__STATIC __inline__ unsigned short
htons (__arg)
unsigned int __arg;
{
return __arg;
}
#endif /* big-endian */
/* Convert a network long to a host long. */
__STATIC __inline__ unsigned long
ntohl (__arg)
unsigned long __arg;
{
return htonl (__arg);
}
/* Convert a network short to a host short. */
__STATIC __inline__ unsigned short
ntohs (__arg)
unsigned int __arg;
{
return htons (__arg);
}
#undef __STATIC
#endif /* !defined (_SYS_BYTEORDER_H) */

107
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c++ Normal file
View File

@@ -0,0 +1,107 @@
#!/bin/sh
# Compile programs, treating .c files as C++.
: || exec /bin/sh -f $0 $argv:q
# The compiler name might be different when doing cross-compilation
# (this should be configured)
gcc_name=gcc
speclang=-xnone
# replace the command name by the name of the new command
progname=`basename $0`
case "$0" in
*/*)
gcc=`echo $0 | sed -e "s;/[^/]*$;;"`/$gcc_name
;;
*)
gcc=$gcc_name
;;
esac
# $first is yes for first arg, no afterwards.
first=yes
# If next arg is the argument of an option, $quote is non-empty.
# More precisely, it is the option that wants an argument.
quote=
# $library is made empty to disable use of libg++.
library=-lg++
numargs=$#
# ash requires the newline before `do'.
for arg
do
if [ $first = yes ]
then
# Need some 1st arg to `set' which does not begin with `-'.
# We get rid of it after the loop ends.
set gcc
first=no
fi
# If you have to ask what this does, you should not edit this file. :-)
# The ``S'' at the start is so that echo -nostdinc does not eat the
# -nostdinc.
arg=`echo "S$arg" | sed "s/^S//; s/'/'\\\\\\\\''/g"`
if [ x$quote != x ]
then
quote=
else
quote=
case $arg in
-nostdlib)
# Inhibit linking with -lg++.
library=
;;
-lm)
# Because libg++ uses things from the math library, make sure it
# always comes before the math library.
set "$@" $library
library=""
;;
-[bBVDUoeTuIYmLiA] | -Tdata)
# these switches take following word as argument,
# so don't treat it as a file name.
quote=$arg
;;
-[cSEM] | -MM)
# Don't specify libraries if we won't link,
# since that would cause a warning.
library=
;;
-x*)
speclang=$arg
;;
-v)
# catch `g++ -v'
if [ $numargs = 1 ] ; then library="" ; fi
;;
-*)
# Pass other options through; they don't need -x and aren't inputs.
;;
*)
# If file ends in .c or .i, put options around it.
# But not if a specified -x option is currently active.
case "$speclang $arg" in -xnone\ *.[ci])
set "$@" -xc++ "'$arg'" -xnone
continue
esac
;;
esac
fi
set "$@" "'$arg'"
done
# Get rid of that initial 1st arg
if [ $first = no ]; then
shift
else
echo "$0: No input files specified."
exit 1
fi
if [ x$quote != x ]
then
echo "$0: argument to \`$quote' missing"
exit 1
fi
eval $gcc "$@" $library

642
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-aux-info.c Normal file
View File

@@ -0,0 +1,642 @@
/* Generate information regarding function declarations and definitions based
on information stored in GCC's tree structure. This code implements the
-aux-info option.
This code was written by Ron Guilmette (rfg@mcc.com).
Copyright (C) 1989, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <stdio.h>
#include "config.h"
#include "flags.h"
#include "tree.h"
#include "c-tree.h"
extern char* xmalloc ();
enum formals_style_enum {
ansi,
k_and_r_names,
k_and_r_decls
};
typedef enum formals_style_enum formals_style;
static char* data_type;
static char * concat ();
static char * concat3 ();
static char * gen_formal_list_for_type ();
static int deserves_ellipsis ();
static char * gen_formal_list_for_func_def ();
static char * gen_type ();
static char * gen_decl ();
void gen_aux_info_record ();
/* Take two strings and mash them together into a newly allocated area. */
static char*
concat (s1, s2)
char* s1;
char* s2;
{
int size1, size2;
char* ret_val;
if (!s1)
s1 = "";
if (!s2)
s2 = "";
size1 = strlen (s1);
size2 = strlen (s2);
ret_val = xmalloc (size1 + size2 + 1);
strcpy (ret_val, s1);
strcpy (&ret_val[size1], s2);
return ret_val;
}
/* Take three strings and mash them together into a newly allocated area. */
static char*
concat3 (s1, s2, s3)
char* s1;
char* s2;
char* s3;
{
int size1, size2, size3;
char* ret_val;
if (!s1)
s1 = "";
if (!s2)
s2 = "";
if (!s3)
s3 = "";
size1 = strlen (s1);
size2 = strlen (s2);
size3 = strlen (s3);
ret_val = xmalloc (size1 + size2 + size3 + 1);
strcpy (ret_val, s1);
strcpy (&ret_val[size1], s2);
strcpy (&ret_val[size1+size2], s3);
return ret_val;
}
/* Given a string representing an entire type or an entire declaration
which only lacks the actual "data-type" specifier (at its left end),
affix the data-type specifier to the left end of the given type
specification or object declaration.
Because of C language weirdness, the data-type specifier (which normally
goes in at the very left end) may have to be slipped in just to the
right of any leading "const" or "volatile" qualifiers (there may be more
than one). Actually this may not be strictly necessary because it seems
that GCC (at least) accepts `<data-type> const foo;' and treats it the
same as `const <data-type> foo;' but people are accustomed to seeing
`const char *foo;' and *not* `char const *foo;' so we try to create types
that look as expected. */
static char*
affix_data_type (type_or_decl)
char *type_or_decl;
{
char *p = type_or_decl;
char *qualifiers_then_data_type;
char saved;
/* Skip as many leading const's or volatile's as there are. */
for (;;)
{
if (!strncmp (p, "volatile ", 9))
{
p += 9;
continue;
}
if (!strncmp (p, "const ", 6))
{
p += 6;
continue;
}
break;
}
/* p now points to the place where we can insert the data type. We have to
add a blank after the data-type of course. */
if (p == type_or_decl)
return concat3 (data_type, " ", type_or_decl);
saved = *p;
*p = '\0';
qualifiers_then_data_type = concat (type_or_decl, data_type);
*p = saved;
return concat3 (qualifiers_then_data_type, " ", p);
}
/* Given a tree node which represents some "function type", generate the
source code version of a formal parameter list (of some given style) for
this function type. Return the whole formal parameter list (including
a pair of surrounding parens) as a string. Note that if the style
we are currently aiming for is non-ansi, then we just return a pair
of empty parens here. */
static char*
gen_formal_list_for_type (fntype, style)
tree fntype;
formals_style style;
{
char* formal_list = "";
tree formal_type;
if (style != ansi)
return "()";
formal_type = TYPE_ARG_TYPES (fntype);
while (formal_type && TREE_VALUE (formal_type) != void_type_node)
{
char* this_type;
if (*formal_list)
formal_list = concat (formal_list, ", ");
this_type = gen_type ("", TREE_VALUE (formal_type), ansi);
formal_list =
(strlen (this_type))
? concat (formal_list, affix_data_type (this_type))
: concat (formal_list, data_type);
formal_type = TREE_CHAIN (formal_type);
}
/* If we got to here, then we are trying to generate an ANSI style formal
parameters list.
New style prototyped ANSI formal parameter lists should in theory always
contain some stuff between the opening and closing parens, even if it is
only "void".
The brutal truth though is that there is lots of old K&R code out there
which contains declarations of "pointer-to-function" parameters and
these almost never have fully specified formal parameter lists associated
with them. That is, the pointer-to-function parameters are declared
with just empty parameter lists.
In cases such as these, protoize should really insert *something* into
the vacant parameter lists, but what? It has no basis on which to insert
anything in particular.
Here, we make life easy for protoize by trying to distinguish between
K&R empty parameter lists and new-style prototyped parameter lists
that actually contain "void". In the latter case we (obviously) want
to output the "void" verbatim, and that what we do. In the former case,
we do our best to give protoize something nice to insert.
This "something nice" should be something that is still legal (when
re-compiled) but something that can clearly indicate to the user that
more typing information (for the parameter list) should be added (by
hand) at some convenient moment.
The string chosen here is a comment with question marks in it. */
if (!*formal_list)
{
if (TYPE_ARG_TYPES (fntype))
/* assert (TREE_VALUE (TYPE_ARG_TYPES (fntype)) == void_type_node); */
formal_list = "void";
else
formal_list = "/* ??? */";
}
else
{
/* If there were at least some parameters, and if the formals-types-list
petered out to a NULL (i.e. without being terminated by a
void_type_node) then we need to tack on an ellipsis. */
if (!formal_type)
formal_list = concat (formal_list, ", ...");
}
return concat3 (" (", formal_list, ")");
}
/* For the generation of an ANSI prototype for a function definition, we have
to look at the formal parameter list of the function's own "type" to
determine if the function's formal parameter list should end with an
ellipsis. Given a tree node, the following function will return non-zero
if the "function type" parameter list should end with an ellipsis. */
static int
deserves_ellipsis (fntype)
tree fntype;
{
tree formal_type;
formal_type = TYPE_ARG_TYPES (fntype);
while (formal_type && TREE_VALUE (formal_type) != void_type_node)
formal_type = TREE_CHAIN (formal_type);
/* If there were at least some parameters, and if the formals-types-list
petered out to a NULL (i.e. without being terminated by a void_type_node)
then we need to tack on an ellipsis. */
return (!formal_type && TYPE_ARG_TYPES (fntype));
}
/* Generate a parameter list for a function definition (in some given style).
Note that this routine has to be separate (and different) from the code that
generates the prototype parameter lists for function declarations, because
in the case of a function declaration, all we have to go on is a tree node
representing the function's own "function type". This can tell us the types
of all of the formal parameters for the function, but it cannot tell us the
actual *names* of each of the formal parameters. We need to output those
parameter names for each function definition.
This routine gets a pointer to a tree node which represents the actual
declaration of the given function, and this DECL node has a list of formal
parameter (variable) declarations attached to it. These formal parameter
(variable) declaration nodes give us the actual names of the formal
parameters for the given function definition.
This routine returns a string which is the source form for the entire
function formal parameter list. */
static char*
gen_formal_list_for_func_def (fndecl, style)
tree fndecl;
formals_style style;
{
char* formal_list = "";
tree formal_decl;
formal_decl = DECL_ARGUMENTS (fndecl);
while (formal_decl)
{
char *this_formal;
if (*formal_list && ((style == ansi) || (style == k_and_r_names)))
formal_list = concat (formal_list, ", ");
this_formal = gen_decl (formal_decl, 0, style);
if (style == k_and_r_decls)
formal_list = concat3 (formal_list, this_formal, "; ");
else
formal_list = concat (formal_list, this_formal);
formal_decl = TREE_CHAIN (formal_decl);
}
if (style == ansi)
{
if (!DECL_ARGUMENTS (fndecl))
formal_list = concat (formal_list, "void");
if (deserves_ellipsis (TREE_TYPE (fndecl)))
formal_list = concat (formal_list, ", ...");
}
if ((style == ansi) || (style == k_and_r_names))
formal_list = concat3 (" (", formal_list, ")");
return formal_list;
}
/* Generate a string which is the source code form for a given type (t). This
routine is ugly and complex because the C syntax for declarations is ugly
and complex. This routine is straightforward so long as *no* pointer types,
array types, or function types are involved.
In the simple cases, this routine will return the (string) value which was
passed in as the "ret_val" argument. Usually, this starts out either as an
empty string, or as the name of the declared item (i.e. the formal function
parameter variable).
This routine will also return with the global variable "data_type" set to
some string value which is the "basic" data-type of the given complete type.
This "data_type" string can be concatenated onto the front of the returned
string after this routine returns to its caller.
In complicated cases involving pointer types, array types, or function
types, the C declaration syntax requires an "inside out" approach, i.e. if
you have a type which is a "pointer-to-function" type, you need to handle
the "pointer" part first, but it also has to be "innermost" (relative to
the declaration stuff for the "function" type). Thus, is this case, you
must prepend a "(*" and append a ")" to the name of the item (i.e. formal
variable). Then you must append and prepend the other info for the
"function type" part of the overall type.
To handle the "innermost precedence" rules of complicated C declarators, we
do the following (in this routine). The input parameter called "ret_val"
is treated as a "seed". Each time gen_type is called (perhaps recursively)
some additional strings may be appended or prepended (or both) to the "seed"
string. If yet another (lower) level of the GCC tree exists for the given
type (as in the case of a pointer type, an array type, or a function type)
then the (wrapped) seed is passed to a (recursive) invocation of gen_type()
this recursive invocation may again "wrap" the (new) seed with yet more
declarator stuff, by appending, prepending (or both). By the time the
recursion bottoms out, the "seed value" at that point will have a value
which is (almost) the complete source version of the declarator (except
for the data_type info). Thus, this deepest "seed" value is simply passed
back up through all of the recursive calls until it is given (as the return
value) to the initial caller of the gen_type() routine. All that remains
to do at this point is for the initial caller to prepend the "data_type"
string onto the returned "seed". */
static char*
gen_type (ret_val, t, style)
char* ret_val;
tree t;
formals_style style;
{
tree chain_p;
if (TYPE_NAME (t) && DECL_NAME (TYPE_NAME (t)))
data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
else
{
switch (TREE_CODE (t))
{
case POINTER_TYPE:
if (TYPE_READONLY (t))
ret_val = concat ("const ", ret_val);
if (TYPE_VOLATILE (t))
ret_val = concat ("volatile ", ret_val);
ret_val = concat ("*", ret_val);
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
ret_val = concat3 ("(", ret_val, ")");
ret_val = gen_type (ret_val, TREE_TYPE (t), style);
return ret_val;
case ARRAY_TYPE:
if (TYPE_SIZE (t) == 0 || TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
ret_val = gen_type (concat (ret_val, "[]"), TREE_TYPE (t), style);
else if (int_size_in_bytes (t) == 0)
ret_val = gen_type (concat (ret_val, "[0]"), TREE_TYPE (t), style);
else
{
int size = (int_size_in_bytes (t) / int_size_in_bytes (TREE_TYPE (t)));
char buff[10];
sprintf (buff, "[%d]", size);
ret_val = gen_type (concat (ret_val, buff),
TREE_TYPE (t), style);
}
break;
case FUNCTION_TYPE:
ret_val = gen_type (concat (ret_val, gen_formal_list_for_type (t, style)), TREE_TYPE (t), style);
break;
case IDENTIFIER_NODE:
data_type = IDENTIFIER_POINTER (t);
break;
/* The following three cases are complicated by the fact that a
user may do something really stupid, like creating a brand new
"anonymous" type specification in a formal argument list (or as
part of a function return type specification). For example:
int f (enum { red, green, blue } color);
In such cases, we have no name that we can put into the prototype
to represent the (anonymous) type. Thus, we have to generate the
whole darn type specification. Yuck! */
case RECORD_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
{
data_type = "";
chain_p = TYPE_FIELDS (t);
while (chain_p)
{
data_type = concat (data_type, gen_decl (chain_p, 0, ansi));
chain_p = TREE_CHAIN (chain_p);
data_type = concat (data_type, "; ");
}
data_type = concat3 ("{ ", data_type, "}");
}
data_type = concat ("struct ", data_type);
break;
case UNION_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
{
data_type = "";
chain_p = TYPE_FIELDS (t);
while (chain_p)
{
data_type = concat (data_type, gen_decl (chain_p, 0, ansi));
chain_p = TREE_CHAIN (chain_p);
data_type = concat (data_type, "; ");
}
data_type = concat3 ("{ ", data_type, "}");
}
data_type = concat ("union ", data_type);
break;
case ENUMERAL_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
{
data_type = "";
chain_p = TYPE_VALUES (t);
while (chain_p)
{
data_type = concat (data_type,
IDENTIFIER_POINTER (TREE_PURPOSE (chain_p)));
chain_p = TREE_CHAIN (chain_p);
if (chain_p)
data_type = concat (data_type, ", ");
}
data_type = concat3 ("{ ", data_type, " }");
}
data_type = concat ("enum ", data_type);
break;
case TYPE_DECL:
data_type = IDENTIFIER_POINTER (DECL_NAME (t));
break;
case INTEGER_TYPE:
data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
/* Normally, `unsigned' is part of the deal. Not so if it comes
with `const' or `volatile'. */
if (TREE_UNSIGNED (t) && (TYPE_READONLY (t) || TYPE_VOLATILE (t)))
data_type = concat ("unsigned ", data_type);
break;
case REAL_TYPE:
data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
break;
case VOID_TYPE:
data_type = "void";
break;
default:
abort ();
}
}
if (TYPE_READONLY (t))
ret_val = concat ("const ", ret_val);
if (TYPE_VOLATILE (t))
ret_val = concat ("volatile ", ret_val);
return ret_val;
}
/* Generate a string (source) representation of an entire entity declaration
(using some particular style for function types).
The given entity may be either a variable or a function.
If the "is_func_definition" parameter is non-zero, assume that the thing
we are generating a declaration for is a FUNCTION_DECL node which is
associated with a function definition. In this case, we can assume that
an attached list of DECL nodes for function formal arguments is present. */
static char*
gen_decl (decl, is_func_definition, style)
tree decl;
int is_func_definition;
formals_style style;
{
char* ret_val;
char* outer_modifier = "";
if (DECL_NAME (decl))
ret_val = IDENTIFIER_POINTER (DECL_NAME (decl));
else
ret_val = "";
/* If we are just generating a list of names of formal parameters, we can
simply return the formal parameter name (with no typing information
attached to it) now. */
if (style == k_and_r_names)
return ret_val;
/* Note that for the declaration of some entity (either a function or a
data object, like for instance a parameter) if the entity itself was
declared as either const or volatile, then const and volatile properties
are associated with just the declaration of the entity, and *not* with
the `type' of the entity. Thus, for such declared entities, we have to
generate the qualifiers here. */
if (TREE_THIS_VOLATILE (decl))
ret_val = concat ("volatile ", ret_val);
if (TREE_READONLY (decl))
ret_val = concat ("const ", ret_val);
data_type = "";
/* For FUNCTION_DECL nodes, there are two possible cases here. First, if
this FUNCTION_DECL node was generated from a function "definition", then
we will have a list of DECL_NODE's, one for each of the function's formal
parameters. In this case, we can print out not only the types of each
formal, but also each formal's name. In the second case, this
FUNCTION_DECL node came from an actual function declaration (and *not*
a definition). In this case, we do nothing here because the formal
argument type-list will be output later, when the "type" of the function
is added to the string we are building. Note that the ANSI-style formal
parameter list is considered to be a (suffix) part of the "type" of the
function. */
if (TREE_CODE (decl) == FUNCTION_DECL && is_func_definition)
{
ret_val = concat (ret_val, gen_formal_list_for_func_def (decl, ansi));
/* Since we have already added in the formals list stuff, here we don't
add the whole "type" of the function we are considering (which
would include its parameter-list info), rather, we only add in
the "type" of the "type" of the function, which is really just
the return-type of the function (and does not include the parameter
list info). */
ret_val = gen_type (ret_val, TREE_TYPE (TREE_TYPE (decl)), style);
}
else
ret_val = gen_type (ret_val, TREE_TYPE (decl), style);
ret_val = affix_data_type (ret_val);
if (DECL_REGISTER (decl))
ret_val = concat ("register ", ret_val);
if (TREE_PUBLIC (decl))
ret_val = concat ("extern ", ret_val);
if (TREE_CODE (decl) == FUNCTION_DECL && !TREE_PUBLIC (decl))
ret_val = concat ("static ", ret_val);
return ret_val;
}
extern FILE* aux_info_file;
/* Generate and write a new line of info to the aux-info (.X) file. This
routine is called once for each function declaration, and once for each
function definition (even the implicit ones). */
void
gen_aux_info_record (fndecl, is_definition, is_implicit, is_prototyped)
tree fndecl;
int is_definition;
int is_implicit;
int is_prototyped;
{
if (flag_gen_aux_info)
{
static int compiled_from_record = 0;
/* Each output .X file must have a header line. Write one now if we
have not yet done so. */
if (! compiled_from_record++)
{
/* The first line tells which directory file names are relative to.
Currently, -aux-info works only for files in the working
directory, so just use a `.' as a placeholder for now. */
fprintf (aux_info_file, "/* compiled from: . */\n");
}
/* Write the actual line of auxiliary info. */
fprintf (aux_info_file, "/* %s:%d:%c%c */ %s;",
DECL_SOURCE_FILE (fndecl),
DECL_SOURCE_LINE (fndecl),
(is_implicit) ? 'I' : (is_prototyped) ? 'N' : 'O',
(is_definition) ? 'F' : 'C',
gen_decl (fndecl, is_definition, ansi));
/* If this is an explicit function declaration, we need to also write
out an old-style (i.e. K&R) function header, just in case the user
wants to run unprotoize. */
if (is_definition)
{
fprintf (aux_info_file, " /*%s %s*/",
gen_formal_list_for_func_def (fndecl, k_and_r_names),
gen_formal_list_for_func_def (fndecl, k_and_r_decls));
}
fprintf (aux_info_file, "\n");
}
}

1009
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-common.c Normal file
View File

File diff suppressed because it is too large Load Diff

415
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-convert.c Normal file
View File

@@ -0,0 +1,415 @@
/* Language-level data type conversion for GNU C.
Copyright (C) 1987, 1988, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* This file contains the functions for converting C expressions
to different data types. The only entry point is `convert'.
Every language front end must have a `convert' function
but what kind of conversions it does will depend on the language. */
#include "config.h"
#include "tree.h"
#include "flags.h"
/* Change of width--truncation and extension of integers or reals--
is represented with NOP_EXPR. Proper functioning of many things
assumes that no other conversions can be NOP_EXPRs.
Conversion between integer and pointer is represented with CONVERT_EXPR.
Converting integer to real uses FLOAT_EXPR
and real to integer uses FIX_TRUNC_EXPR.
Here is a list of all the functions that assume that widening and
narrowing is always done with a NOP_EXPR:
In c-convert.c, convert_to_integer.
In c-typeck.c, build_binary_op (boolean ops), and truthvalue_conversion.
In expr.c: expand_expr, for operands of a MULT_EXPR.
In fold-const.c: fold.
In tree.c: get_narrower and get_unwidened. */
/* Subroutines of `convert'. */
static tree
convert_to_pointer (type, expr)
tree type, expr;
{
register tree intype = TREE_TYPE (expr);
register enum tree_code form = TREE_CODE (intype);
if (integer_zerop (expr))
{
if (type == TREE_TYPE (null_pointer_node))
return null_pointer_node;
expr = build_int_2 (0, 0);
TREE_TYPE (expr) = type;
return expr;
}
if (form == POINTER_TYPE)
return build1 (NOP_EXPR, type, expr);
if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
{
if (type_precision (intype) == POINTER_SIZE)
return build1 (CONVERT_EXPR, type, expr);
expr = convert (type_for_size (POINTER_SIZE, 0), expr);
if (TYPE_MODE (TREE_TYPE (expr)) != TYPE_MODE (type))
/* There is supposed to be some integral type
that is the same width as a pointer. */
abort ();
return convert_to_pointer (type, expr);
}
error ("cannot convert to a pointer type");
return null_pointer_node;
}
static tree
convert_to_real (type, expr)
tree type, expr;
{
register enum tree_code form = TREE_CODE (TREE_TYPE (expr));
if (form == REAL_TYPE)
return build1 (flag_float_store ? CONVERT_EXPR : NOP_EXPR,
type, expr);
if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
return build1 (FLOAT_EXPR, type, expr);
if (form == POINTER_TYPE)
error ("pointer value used where a float was expected");
else
error ("aggregate value used where a float was expected");
{
register tree tem = make_node (REAL_CST);
TREE_TYPE (tem) = type;
TREE_REAL_CST (tem) = REAL_VALUE_ATOF ("0.0");
return tem;
}
}
/* The result of this is always supposed to be a newly created tree node
not in use in any existing structure. */
static tree
convert_to_integer (type, expr)
tree type, expr;
{
register tree intype = TREE_TYPE (expr);
register enum tree_code form = TREE_CODE (intype);
if (form == POINTER_TYPE)
{
if (integer_zerop (expr))
expr = integer_zero_node;
else
expr = fold (build1 (CONVERT_EXPR,
type_for_size (POINTER_SIZE, 0), expr));
intype = TREE_TYPE (expr);
form = TREE_CODE (intype);
if (intype == type)
return expr;
}
if (form == INTEGER_TYPE || form == ENUMERAL_TYPE)
{
register unsigned outprec = TYPE_PRECISION (type);
register unsigned inprec = TYPE_PRECISION (intype);
register enum tree_code ex_form = TREE_CODE (expr);
/* If we are widening the type, put in an explicit conversion.
Similarly if we are not changing the width. However, if this is
a logical operation that just returns 0 or 1, we can change the
type of the expression (see below). */
if (TREE_CODE_CLASS (ex_form) == '<'
|| ex_form == TRUTH_AND_EXPR || ex_form == TRUTH_ANDIF_EXPR
|| ex_form == TRUTH_OR_EXPR || ex_form == TRUTH_ORIF_EXPR
|| ex_form == TRUTH_NOT_EXPR)
{
TREE_TYPE (expr) = type;
return expr;
}
else if (outprec >= inprec)
return build1 (NOP_EXPR, type, expr);
/* Here detect when we can distribute the truncation down past some arithmetic.
For example, if adding two longs and converting to an int,
we can equally well convert both to ints and then add.
For the operations handled here, such truncation distribution
is always safe.
It is desirable in these cases:
1) when truncating down to full-word from a larger size
2) when truncating takes no work.
3) when at least one operand of the arithmetic has been extended
(as by C's default conversions). In this case we need two conversions
if we do the arithmetic as already requested, so we might as well
truncate both and then combine. Perhaps that way we need only one.
Note that in general we cannot do the arithmetic in a type
shorter than the desired result of conversion, even if the operands
are both extended from a shorter type, because they might overflow
if combined in that type. The exceptions to this--the times when
two narrow values can be combined in their narrow type even to
make a wider result--are handled by "shorten" in build_binary_op. */
switch (ex_form)
{
case RSHIFT_EXPR:
/* We can pass truncation down through right shifting
when the shift count is a nonpositive constant. */
if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
&& tree_int_cst_lt (TREE_OPERAND (expr, 1), integer_one_node))
goto trunc1;
break;
case LSHIFT_EXPR:
/* We can pass truncation down through left shifting
when the shift count is a nonnegative constant. */
if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST
&& ! tree_int_cst_lt (TREE_OPERAND (expr, 1), integer_zero_node)
&& TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
{
/* If shift count is less than the width of the truncated type,
really shift. */
if (tree_int_cst_lt (TREE_OPERAND (expr, 1), TYPE_SIZE (type)))
/* In this case, shifting is like multiplication. */
goto trunc1;
else
/* If it is >= that width, result is zero.
Handling this with trunc1 would give the wrong result:
(int) ((long long) a << 32) is well defined (as 0)
but (int) a << 32 is undefined and would get a warning. */
return convert_to_integer (type, integer_zero_node);
}
break;
case MAX_EXPR:
case MIN_EXPR:
case MULT_EXPR:
{
tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
/* Don't distribute unless the output precision is at least as big
as the actual inputs. Otherwise, the comparison of the
truncated values will be wrong. */
if (outprec >= TYPE_PRECISION (TREE_TYPE (arg0))
&& outprec >= TYPE_PRECISION (TREE_TYPE (arg1))
/* If signedness of arg0 and arg1 don't match,
we can't necessarily find a type to compare them in. */
&& (TREE_UNSIGNED (TREE_TYPE (arg0))
== TREE_UNSIGNED (TREE_TYPE (arg1))))
goto trunc1;
break;
}
case PLUS_EXPR:
case MINUS_EXPR:
case BIT_AND_EXPR:
case BIT_IOR_EXPR:
case BIT_XOR_EXPR:
case BIT_ANDTC_EXPR:
trunc1:
{
tree arg0 = get_unwidened (TREE_OPERAND (expr, 0), type);
tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
if (outprec >= BITS_PER_WORD
|| TRULY_NOOP_TRUNCATION (outprec, inprec)
|| inprec > TYPE_PRECISION (TREE_TYPE (arg0))
|| inprec > TYPE_PRECISION (TREE_TYPE (arg1)))
{
/* Do the arithmetic in type TYPEX,
then convert result to TYPE. */
register tree typex = type;
/* Can't do arithmetic in enumeral types
so use an integer type that will hold the values. */
if (TREE_CODE (typex) == ENUMERAL_TYPE)
typex = type_for_size (TYPE_PRECISION (typex),
TREE_UNSIGNED (typex));
/* But now perhaps TYPEX is as wide as INPREC.
In that case, do nothing special here.
(Otherwise would recurse infinitely in convert. */
if (TYPE_PRECISION (typex) != inprec)
{
/* Don't do unsigned arithmetic where signed was wanted,
or vice versa.
Exception: if either of the original operands were
unsigned then can safely do the work as unsigned.
And we may need to do it as unsigned
if we truncate to the original size. */
typex = ((TREE_UNSIGNED (TREE_TYPE (expr))
|| TREE_UNSIGNED (TREE_TYPE (arg0))
|| TREE_UNSIGNED (TREE_TYPE (arg1)))
? unsigned_type (typex) : signed_type (typex));
return convert (type,
build_binary_op (ex_form,
convert (typex, arg0),
convert (typex, arg1),
0));
}
}
}
break;
case NEGATE_EXPR:
case BIT_NOT_EXPR:
{
register tree typex = type;
/* Can't do arithmetic in enumeral types
so use an integer type that will hold the values. */
if (TREE_CODE (typex) == ENUMERAL_TYPE)
typex = type_for_size (TYPE_PRECISION (typex),
TREE_UNSIGNED (typex));
/* But now perhaps TYPEX is as wide as INPREC.
In that case, do nothing special here.
(Otherwise would recurse infinitely in convert. */
if (TYPE_PRECISION (typex) != inprec)
{
/* Don't do unsigned arithmetic where signed was wanted,
or vice versa. */
typex = (TREE_UNSIGNED (TREE_TYPE (expr))
? unsigned_type (typex) : signed_type (typex));
return convert (type,
build_unary_op (ex_form,
convert (typex, TREE_OPERAND (expr, 0)),
1));
}
}
case NOP_EXPR:
/* If truncating after truncating, might as well do all at once.
If truncating after extending, we may get rid of wasted work. */
return convert (type, get_unwidened (TREE_OPERAND (expr, 0), type));
case COND_EXPR:
/* Can treat the two alternative values like the operands
of an arithmetic expression. */
{
tree arg1 = get_unwidened (TREE_OPERAND (expr, 1), type);
tree arg2 = get_unwidened (TREE_OPERAND (expr, 2), type);
if (outprec >= BITS_PER_WORD
|| TRULY_NOOP_TRUNCATION (outprec, inprec)
|| inprec > TYPE_PRECISION (TREE_TYPE (arg1))
|| inprec > TYPE_PRECISION (TREE_TYPE (arg2)))
{
/* Do the arithmetic in type TYPEX,
then convert result to TYPE. */
register tree typex = type;
/* Can't do arithmetic in enumeral types
so use an integer type that will hold the values. */
if (TREE_CODE (typex) == ENUMERAL_TYPE)
typex = type_for_size (TYPE_PRECISION (typex),
TREE_UNSIGNED (typex));
/* But now perhaps TYPEX is as wide as INPREC.
In that case, do nothing special here.
(Otherwise would recurse infinitely in convert. */
if (TYPE_PRECISION (typex) != inprec)
{
/* Don't do unsigned arithmetic where signed was wanted,
or vice versa. */
typex = (TREE_UNSIGNED (TREE_TYPE (expr))
? unsigned_type (typex) : signed_type (typex));
return convert (type,
fold (build (COND_EXPR, typex,
TREE_OPERAND (expr, 0),
convert (typex, arg1),
convert (typex, arg2))));
}
else
/* It is sometimes worthwhile
to push the narrowing down through the conditional. */
return fold (build (COND_EXPR, type,
TREE_OPERAND (expr, 0),
convert (type, TREE_OPERAND (expr, 1)),
convert (type, TREE_OPERAND (expr, 2))));
}
}
}
return build1 (NOP_EXPR, type, expr);
}
if (form == REAL_TYPE)
return build1 (FIX_TRUNC_EXPR, type, expr);
error ("aggregate value used where an integer was expected");
{
register tree tem = build_int_2 (0, 0);
TREE_TYPE (tem) = type;
return tem;
}
}
/* Create an expression whose value is that of EXPR,
converted to type TYPE. The TREE_TYPE of the value
is always TYPE. This function implements all reasonable
conversions; callers should filter out those that are
not permitted by the language being compiled. */
tree
convert (type, expr)
tree type, expr;
{
register tree e = expr;
register enum tree_code code = TREE_CODE (type);
if (type == TREE_TYPE (expr)
|| TREE_CODE (expr) == ERROR_MARK)
return expr;
if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
return fold (build1 (NOP_EXPR, type, expr));
if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
return error_mark_node;
if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
{
error ("void value not ignored as it ought to be");
return error_mark_node;
}
if (code == VOID_TYPE)
return build1 (CONVERT_EXPR, type, e);
#if 0
/* This is incorrect. A truncation can't be stripped this way.
Extensions will be stripped by the use of get_unwidened. */
if (TREE_CODE (expr) == NOP_EXPR)
return convert (type, TREE_OPERAND (expr, 0));
#endif
if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
return fold (convert_to_integer (type, e));
if (code == POINTER_TYPE)
return fold (convert_to_pointer (type, e));
if (code == REAL_TYPE)
return fold (convert_to_real (type, e));
error ("conversion to non-scalar type requested");
return error_mark_node;
}

6215
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-decl.c Normal file
View File

File diff suppressed because it is too large Load Diff

98
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-lang.c Normal file
View File

@@ -0,0 +1,98 @@
/* Language-specific hook definitions for C front end.
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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "config.h"
#include "tree.h"
#include <stdio.h>
#include "input.h"
/* Each of the functions defined here
is an alternative to a function in objc-actions.c. */
int
lang_decode_option (p)
char *p;
{
return c_decode_option (p);
}
void
lang_init ()
{
/* the beginning of the file is a new line; check for # */
/* With luck, we discover the real source file's name from that
and put it in input_filename. */
ungetc (check_newline (), finput);
}
void
lang_finish ()
{
}
/* Used by c-lex.c, but only for objc. */
tree
lookup_interface (arg)
tree arg;
{
return 0;
}
void
maybe_objc_check_decl (decl)
tree decl;
{
}
int
maybe_objc_comptypes (lhs, rhs)
tree lhs, rhs;
{
return 0;
}
tree
maybe_building_objc_message_expr ()
{
return 0;
}
int
recognize_objc_keyword ()
{
return 0;
}
void
print_lang_statistics ()
{
}
void
GNU_xref_begin ()
{
fatal ("GCC does not yet support XREF");
}
void
GNU_xref_end ()
{
fatal ("GCC does not yet support XREF");
}

1927
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-lex.c Normal file
View File

File diff suppressed because it is too large Load Diff

68
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-lex.h Normal file
View File

@@ -0,0 +1,68 @@
/* Define constants for communication with c-parse.y.
Copyright (C) 1987, 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
enum rid
{
RID_UNUSED,
RID_INT,
RID_CHAR,
RID_FLOAT,
RID_DOUBLE,
RID_VOID,
RID_UNUSED1,
RID_UNSIGNED,
RID_SHORT,
RID_LONG,
RID_AUTO,
RID_STATIC,
RID_EXTERN,
RID_REGISTER,
RID_TYPEDEF,
RID_SIGNED,
RID_CONST,
RID_VOLATILE,
RID_INLINE,
RID_NOALIAS,
RID_MAX
};
#define NORID RID_UNUSED
#define RID_FIRST_MODIFIER RID_UNSIGNED
/* The elements of `ridpointers' are identifier nodes
for the reserved type names and storage classes.
It is indexed by a RID_... value. */
extern tree ridpointers[(int) RID_MAX];
/* the declaration found for the last IDENTIFIER token read in.
yylex must look this up to detect typedefs, which get token type TYPENAME,
so it is left around in case the identifier is not a typedef but is
used in a context which makes it a reference to a variable. */
extern tree lastiddecl;
extern char *token_buffer; /* Pointer to token buffer. */
extern tree make_pointer_declarator ();
extern void reinit_parse_for_function ();
extern int yylex ();

3361
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-parse.c Normal file
View File

File diff suppressed because it is too large Load Diff

58
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-parse.gperf Normal file
View File

@@ -0,0 +1,58 @@
%{
/* 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; };
%%
__alignof, ALIGNOF, NORID
__alignof__, ALIGNOF, NORID
__asm, ASM_KEYWORD, NORID
__asm__, ASM_KEYWORD, NORID
__attribute, ATTRIBUTE, NORID
__attribute__, ATTRIBUTE, NORID
__const, TYPE_QUAL, RID_CONST
__const__, TYPE_QUAL, RID_CONST
__extension__, EXTENSION, NORID
__inline, SCSPEC, RID_INLINE
__inline__, SCSPEC, RID_INLINE
__label__, LABEL, NORID
__signed, TYPESPEC, RID_SIGNED
__signed__, TYPESPEC, RID_SIGNED
__typeof, TYPEOF, NORID
__typeof__, TYPEOF, NORID
__volatile, TYPE_QUAL, RID_VOLATILE
__volatile__, TYPE_QUAL, RID_VOLATILE
asm, ASM_KEYWORD, NORID
auto, SCSPEC, RID_AUTO
break, BREAK, NORID
case, CASE, NORID
char, TYPESPEC, RID_CHAR
const, TYPE_QUAL, RID_CONST
continue, CONTINUE, NORID
default, DEFAULT, NORID
do, DO, NORID
double, TYPESPEC, RID_DOUBLE
else, ELSE, NORID
enum, ENUM, NORID
extern, SCSPEC, RID_EXTERN
float, TYPESPEC, RID_FLOAT
for, FOR, NORID
goto, GOTO, NORID
if, IF, NORID
inline, SCSPEC, RID_INLINE
int, TYPESPEC, RID_INT
long, TYPESPEC, RID_LONG
register, SCSPEC, RID_REGISTER
return, RETURN, NORID
short, TYPESPEC, RID_SHORT
signed, TYPESPEC, RID_SIGNED
sizeof, SIZEOF, NORID
static, SCSPEC, RID_STATIC
struct, STRUCT, NORID
switch, SWITCH, NORID
typedef, SCSPEC, RID_TYPEDEF
typeof, TYPEOF, NORID
union, UNION, NORID
unsigned, TYPESPEC, RID_UNSIGNED
void, TYPESPEC, RID_VOID
volatile, TYPE_QUAL, RID_VOLATILE
while, WHILE, NORID

56
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-parse.h Normal file
View File

@@ -0,0 +1,56 @@
typedef union {long itype; tree ttype; enum tree_code code;
char *filename; int lineno; } 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 ALIGN 285
#define ATTRIBUTE 286
#define EXTENSION 287
#define LABEL 288
#define ASSIGN 289
#define OROR 290
#define ANDAND 291
#define EQCOMPARE 292
#define ARITHCOMPARE 293
#define LSHIFT 294
#define RSHIFT 295
#define UNARY 296
#define PLUSPLUS 297
#define MINUSMINUS 298
#define HYPERUNARY 299
#define POINTSAT 300
#define INTERFACE 301
#define IMPLEMENTATION 302
#define END 303
#define SELECTOR 304
#define DEFS 305
#define ENCODE 306
#define CLASSNAME 307
#define PUBLIC 308
extern YYSTYPE yylval;

2523
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-parse.in Normal file
View File

File diff suppressed because it is too large Load Diff

1786
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-parse.y Normal file
View File

File diff suppressed because it is too large Load Diff

198
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-pragma.c Normal file
View File

@@ -0,0 +1,198 @@
/* Handle #pragma, system V.4 style. Supports #pragma weak and #pragma pack.
Copyright (C) 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <stdio.h>
#include "config.h"
#include "tree.h"
#ifdef HANDLE_SYSV_PRAGMA
/* Support #pragma weak by default if WEAK_ASM_OP is defined. */
#if !defined (HANDLE_PRAGMA_WEAK) && defined (WEAK_ASM_OP) && defined (SET_ASM_OP)
#define HANDLE_PRAGMA_WEAK 1
#endif
/* When structure field packing is in effect, this variable is the
number of bits to use as the maximum alignment. When packing is not
in effect, this is zero. */
extern int maximum_field_alignment;
/* File used for outputting assembler code. */
extern FILE *asm_out_file;
/* Handle one token of a pragma directive. TOKEN is the
current token, and STRING is its printable form. */
void
handle_pragma_token (string, token)
char *string;
tree token;
{
static enum pragma_state
{
ps_start,
ps_done,
ps_bad,
ps_weak,
ps_name,
ps_equals,
ps_value,
ps_pack,
ps_left,
ps_align,
ps_right
} state = ps_start, type;
static char *name;
static char *value;
static int align;
if (string == 0)
{
if (type == ps_pack)
{
if (state == ps_right)
maximum_field_alignment = align * 8;
else
warning ("malformed `#pragma pack'");
}
else if (type == ps_weak)
{
#ifdef HANDLE_PRAGMA_WEAK
if (HANDLE_PRAGMA_WEAK)
{
if (state == ps_name || state == ps_value)
{
fprintf (asm_out_file, "\t%s\t", WEAK_ASM_OP);
ASM_OUTPUT_LABELREF (asm_out_file, name);
fputc ('\n', asm_out_file);
if (state == ps_value)
{
fprintf (asm_out_file, "\t%s\t", SET_ASM_OP);
ASM_OUTPUT_LABELREF (asm_out_file, name);
fputc (',', asm_out_file);
ASM_OUTPUT_LABELREF (asm_out_file, value);
fputc ('\n', asm_out_file);
}
}
else if (! (state == ps_done || state == ps_start))
warning ("malformed `#pragma weak'");
}
#endif /* HANDLE_PRAMA_WEAK */
}
type = state = ps_start;
return;
}
switch (state)
{
case ps_start:
if (token && TREE_CODE (token) == IDENTIFIER_NODE)
{
if (strcmp (IDENTIFIER_POINTER (token), "pack") == 0)
type = state = ps_pack;
else if (strcmp (IDENTIFIER_POINTER (token), "weak") == 0)
type = state = ps_weak;
else
type = state = ps_done;
}
else
type = state = ps_done;
break;
case ps_weak:
if (token && TREE_CODE (token) == IDENTIFIER_NODE)
{
name = IDENTIFIER_POINTER (token);
state = ps_name;
}
else
state = ps_bad;
break;
case ps_name:
state = (strcmp (string, "=") ? ps_bad : ps_equals);
break;
case ps_equals:
if (token && TREE_CODE (token) == IDENTIFIER_NODE)
{
value = IDENTIFIER_POINTER (token);
state = ps_value;
}
else
state = ps_bad;
break;
case ps_value:
state = ps_bad;
break;
case ps_pack:
if (strcmp (string, "(") == 0)
state = ps_left;
else
state = ps_bad;
break;
case ps_left:
if (token && TREE_CODE (token) == INTEGER_CST
&& TREE_INT_CST_HIGH (token) == 0)
switch (TREE_INT_CST_LOW (token))
{
case 1:
case 2:
case 4:
align = TREE_INT_CST_LOW (token);
state = ps_align;
break;
default:
state = ps_bad;
}
else if (! token && strcmp (string, ")") == 0)
{
align = 0;
state = ps_right;
}
else
state = ps_bad;
break;
case ps_align:
if (strcmp (string, ")") == 0)
state = ps_right;
else
state = ps_bad;
break;
case ps_right:
state = ps_bad;
break;
case ps_bad:
case ps_done:
break;
default:
abort ();
}
}
#endif /* HANDLE_SYSV_PRAGMA */

334
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-tree.h Normal file
View File

@@ -0,0 +1,334 @@
/* Definitions for C parsing and type checking.
Copyright (C) 1987 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Language-dependent contents of an identifier. */
/* The limbo_value is used for block level extern declarations, which need
to be type checked against subsequent extern declarations. They can't
be referenced after they fall out of scope, so they can't be global. */
struct lang_identifier
{
struct tree_identifier ignore;
tree global_value, local_value, label_value, implicit_decl;
tree error_locus, limbo_value;
};
/* Macros for access to language-specific slots in an identifier. */
/* Each of these slots contains a DECL node or null. */
/* This represents the value which the identifier has in the
file-scope namespace. */
#define IDENTIFIER_GLOBAL_VALUE(NODE) \
(((struct lang_identifier *)(NODE))->global_value)
/* This represents the value which the identifier has in the current
scope. */
#define IDENTIFIER_LOCAL_VALUE(NODE) \
(((struct lang_identifier *)(NODE))->local_value)
/* This represents the value which the identifier has as a label in
the current label scope. */
#define IDENTIFIER_LABEL_VALUE(NODE) \
(((struct lang_identifier *)(NODE))->label_value)
/* This records the extern decl of this identifier, if it has had one
at any point in this compilation. */
#define IDENTIFIER_LIMBO_VALUE(NODE) \
(((struct lang_identifier *)(NODE))->limbo_value)
/* This records the implicit function decl of this identifier, if it
has had one at any point in this compilation. */
#define IDENTIFIER_IMPLICIT_DECL(NODE) \
(((struct lang_identifier *)(NODE))->implicit_decl)
/* This is the last function in which we printed an "undefined variable"
message for this identifier. Value is a FUNCTION_DECL or null. */
#define IDENTIFIER_ERROR_LOCUS(NODE) \
(((struct lang_identifier *)(NODE))->error_locus)
/* In identifiers, C uses the following fields in a special way:
TREE_PUBLIC to record that there was a previous local extern decl.
TREE_USED to record that such a decl was used.
TREE_ADDRESSABLE to record that the address of such a decl was used. */
/* Nonzero means reject anything that ANSI standard C forbids. */
extern int pedantic;
/* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. */
#define C_TYPE_FIELDS_READONLY(type) TREE_LANG_FLAG_1 (type)
/* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is volatile. */
#define C_TYPE_FIELDS_VOLATILE(type) TREE_LANG_FLAG_2 (type)
/* In a RECORD_TYPE or UNION_TYPE or ENUMERAL_TYPE
nonzero if the definition of the type has already started. */
#define C_TYPE_BEING_DEFINED(type) TYPE_LANG_FLAG_0 (type)
/* In a RECORD_TYPE, a sorted array of the fields of the type. */
struct lang_type
{
int len;
tree elts[1];
};
/* Mark which labels are explicitly declared.
These may be shadowed, and may be referenced from nested functions. */
#define C_DECLARED_LABEL_FLAG(label) TREE_LANG_FLAG_1 (label)
/* Record whether a type or decl was written with nonconstant size.
Note that TYPE_SIZE may have simplified to a constant. */
#define C_TYPE_VARIABLE_SIZE(type) TYPE_LANG_FLAG_1 (type)
#define C_DECL_VARIABLE_SIZE(type) DECL_LANG_FLAG_0 (type)
/* Record in each node resulting from a binary operator
what operator was specified for it. */
#define C_EXP_ORIGINAL_CODE(exp) ((enum tree_code) TREE_COMPLEXITY (exp))
#if 0 /* Not used. */
/* Record whether a decl for a function or function pointer has
already been mentioned (in a warning) because it was called
but didn't have a prototype. */
#define C_MISSING_PROTOTYPE_WARNED(decl) DECL_LANG_FLAG_2(decl)
#endif
/* Store a value in that field. */
#define C_SET_EXP_ORIGINAL_CODE(exp, code) \
(TREE_COMPLEXITY (exp) = (int)(code))
/* Record whether a typedef for type `int' was actually `signed int'. */
#define C_TYPEDEF_EXPLICITLY_SIGNED(exp) DECL_LANG_FLAG_1 ((exp))
/* Nonzero for a declaration of a built in function if there has been no
occasion that would declare the function in ordinary C.
Using the function draws a pedantic warning in this case. */
#define C_DECL_ANTICIPATED(exp) DECL_LANG_FLAG_3 ((exp))
/* For FUNCTION_TYPE, a hidden list of types of arguments. The same as
TYPE_ARG_TYPES for functions with prototypes, but created for functions
without prototypes. */
#define TYPE_ACTUAL_ARG_TYPES(NODE) TYPE_NONCOPIED_PARTS (NODE)
/* Nonzero if the type T promotes to itself.
ANSI C states explicitly the list of types that promote;
in particular, short promotes to int even if they have the same width. */
#define C_PROMOTING_INTEGER_TYPE_P(t) \
(TREE_CODE ((t)) == INTEGER_TYPE \
&& (TYPE_MAIN_VARIANT (t) == char_type_node \
|| TYPE_MAIN_VARIANT (t) == signed_char_type_node \
|| TYPE_MAIN_VARIANT (t) == unsigned_char_type_node \
|| TYPE_MAIN_VARIANT (t) == short_integer_type_node \
|| TYPE_MAIN_VARIANT (t) == short_unsigned_type_node))
/* in c-typecheck.c */
extern tree build_component_ref (), build_conditional_expr (), build_compound_expr ();
extern tree build_unary_op (), build_binary_op (), build_function_call ();
extern tree parser_build_binary_op ();
extern tree build_indirect_ref (), build_array_ref (), build_c_cast ();
extern tree build_modify_expr ();
extern tree c_sizeof (), c_alignof (), c_alignof_expr ();
extern void store_init_value ();
extern tree digest_init ();
extern tree c_expand_start_case ();
extern tree default_conversion ();
/* Given two integer or real types, return the type for their sum.
Given two compatible ANSI C types, returns the merged type. */
extern tree common_type ();
/* in c-decl.c */
extern tree build_label ();
extern int start_function ();
extern void finish_function ();
extern void store_parm_decls ();
extern tree get_parm_info ();
extern tree combine_parm_decls ();
extern void pushlevel ();
extern tree poplevel ();
extern tree groktypename (), lookup_name ();
extern tree lookup_label (), define_label (), shadow_label ();
extern tree implicitly_declare (), getdecls (), gettags ();
extern tree start_decl ();
extern void finish_decl ();
extern tree start_struct (), finish_struct (), xref_tag ();
extern tree grokfield ();
extern tree start_enum (), finish_enum ();
extern tree build_enumerator ();
extern tree make_index_type ();
/* Add qualifiers to a type, in the fashion for C. */
extern tree c_build_type_variant ();
/* Declare a predefined function. Return the declaration. */
extern tree builtin_function ();
/* Functions in c-common.c: */
/* Concatenate a list of STRING_CST nodes into one STRING_CST. */
extern tree combine_strings ();
/* Validate the expression after `case' and apply default promotions. */
extern tree check_case_value ();
/* Print an error message for invalid operands to arith operation CODE.
NOP_EXPR is used as a special case (see truthvalue_conversion). */
extern void binary_op_error ();
/* Subroutine of build_binary_op, used for comparison operations.
See if the operands have both been converted from subword integer types
and, if so, perhaps change them both back to their original type. */
extern tree shorten_compare ();
/* Read the rest of the current #-directive line. */
extern char *get_directive_line ();
/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
or validate its data type for an `if' or `while' statement or ?..: exp. */
extern tree truthvalue_conversion ();
extern int maybe_objc_comptypes ();
extern tree maybe_building_objc_message_expr ();
/* Standard named or nameless data types of the C compiler. */
extern tree short_integer_type_node, integer_type_node;
extern tree long_integer_type_node, long_long_integer_type_node;
extern tree short_unsigned_type_node, unsigned_type_node;
extern tree long_unsigned_type_node, long_long_unsigned_type_node;
extern tree ptrdiff_type_node;
extern tree unsigned_char_type_node, signed_char_type_node, char_type_node;
extern tree wchar_type_node, signed_wchar_type_node, unsigned_wchar_type_node;
extern tree float_type_node, double_type_node, long_double_type_node;
extern tree intQI_type_node, unsigned_intQI_type_node;
extern tree intHI_type_node, unsigned_intHI_type_node;
extern tree intSI_type_node, unsigned_intSI_type_node;
extern tree intDI_type_node, unsigned_intDI_type_node;
extern tree void_type_node, ptr_type_node, const_ptr_type_node;
extern tree string_type_node, const_string_type_node;
extern tree char_array_type_node, int_array_type_node, wchar_array_type_node;
extern tree default_function_type;
extern tree double_ftype_double, double_ftype_double_double;
extern tree int_ftype_int, long_ftype_long;
extern tree void_ftype_ptr_ptr_int, int_ftype_ptr_ptr_int;
extern tree void_ftype_ptr_int_int, string_ftype_ptr_ptr;
extern tree int_ftype_string_string, int_ftype_cptr_cptr_sizet;
/* Set to 0 at beginning of a function definition, set to 1 if
a return statement that specifies a return value is seen. */
extern int current_function_returns_value;
/* Set to 0 at beginning of a function definition, set to 1 if
a return statement with no argument is seen. */
extern int current_function_returns_null;
/* Nonzero means `$' can be in an identifier. */
extern int dollars_in_ident;
/* Nonzero means allow type mismatches in conditional expressions;
just make their values `void'. */
extern int flag_cond_mismatch;
/* Nonzero means don't recognize the keyword `asm'. */
extern int flag_no_asm;
/* Nonzero means ignore `#ident' directives. */
extern int flag_no_ident;
/* Nonzero means warn about implicit declarations. */
extern int warn_implicit;
/* Nonzero means give string constants the type `const char *'
to get extra warnings from them. These warnings will be too numerous
to be useful, except in thoroughly ANSIfied programs. */
extern int warn_write_strings;
/* Nonzero means warn about sizeof (function) or addition/subtraction
of function pointers. */
extern int warn_pointer_arith;
/* Nonzero means warn for all old-style non-prototype function decls. */
extern int warn_strict_prototypes;
/* Nonzero means warn about multiple (redundant) decls for the same single
variable or function. */
extern int warn_redundant_decls;
/* Nonzero means warn about extern declarations of objects not at
file-scope level and about *all* declarations of functions (whether
extern or static) not at file-scope level. Note that we exclude
implicit function declarations. To get warnings about those, use
-Wimplicit. */
extern int warn_nested_externs;
/* Nonzero means warn about pointer casts that can drop a type qualifier
from the pointer target type. */
extern int warn_cast_qual;
/* Warn about traditional constructs whose meanings changed in ANSI C. */
extern int warn_traditional;
/* Warn about *printf or *scanf format/argument anomalies. */
extern int warn_format;
/* Warn about a subscript that has type char. */
extern int warn_char_subscripts;
/* Warn if a type conversion is done that might have confusing results. */
extern int warn_conversion;
/* Nonzero means do some things the same way PCC does. */
extern int flag_traditional;
/* Nonzero means warn about suggesting putting in ()'s. */
extern int warn_parentheses;
/* Nonzero means this is a function to call to perform comptypes
on two record types. */
extern int (*comptypes_record_hook) ();
/* Nonzero means we are reading code that came from a system header file. */
extern int system_header_p;

5474
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/c-typeck.c Normal file
View File

File diff suppressed because it is too large Load Diff

764
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/caller-save.c Normal file
View File

@@ -0,0 +1,764 @@
/* Save and restore call-clobbered registers which are live across a call.
Copyright (C) 1989, 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "config.h"
#include "rtl.h"
#include "insn-config.h"
#include "flags.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "recog.h"
#include "basic-block.h"
#include "reload.h"
#include "expr.h"
#define CEIL(x,y) (((x) + (y) - 1) / (y))
/* Modes for each hard register that we can save. The smallest mode is wide
enough to save the entire contents of the register. When saving the
register because it is live we first try to save in multi-register modes.
If that is not possible the save is done one register at a time. */
static enum machine_mode
regno_save_mode[FIRST_PSEUDO_REGISTER][MOVE_MAX / UNITS_PER_WORD + 1];
/* For each hard register, a place on the stack where it can be saved,
if needed. */
static rtx
regno_save_mem[FIRST_PSEUDO_REGISTER][MOVE_MAX / UNITS_PER_WORD + 1];
/* We will only make a register eligible for caller-save if it can be
saved in its widest mode with a simple SET insn as long as the memory
address is valid. We record the INSN_CODE is those insns here since
when we emit them, the addresses might not be valid, so they might not
be recognized. */
static enum insn_code
reg_save_code[FIRST_PSEUDO_REGISTER][MOVE_MAX / UNITS_PER_WORD + 1];
static enum insn_code
reg_restore_code[FIRST_PSEUDO_REGISTER][MOVE_MAX / UNITS_PER_WORD + 1];
/* Set of hard regs currently live (during scan of all insns). */
static HARD_REG_SET hard_regs_live;
/* Set of hard regs currently residing in save area (during insn scan). */
static HARD_REG_SET hard_regs_saved;
/* Set of hard regs which need to be restored before referenced. */
static HARD_REG_SET hard_regs_need_restore;
/* Number of registers currently in hard_regs_saved. */
int n_regs_saved;
static void set_reg_live ();
static void clear_reg_live ();
static void restore_referenced_regs ();
static int insert_save_restore ();
/* Return a machine mode that is legitimate for hard reg REGNO and large
enough to save nregs. If we can't find one, return VOIDmode. */
static enum machine_mode
choose_hard_reg_mode (regno, nregs)
int regno;
{
enum machine_mode found_mode = VOIDmode, mode;
/* We first look for the largest integer mode that can be validly
held in REGNO. If none, we look for the largest floating-point mode.
If we still didn't find a valid mode, try CCmode. */
for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
if (HARD_REGNO_NREGS (regno, mode) == nregs
&& HARD_REGNO_MODE_OK (regno, mode))
found_mode = mode;
if (found_mode != VOIDmode)
return found_mode;
for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
if (HARD_REGNO_NREGS (regno, mode) == nregs
&& HARD_REGNO_MODE_OK (regno, mode))
found_mode = mode;
if (found_mode != VOIDmode)
return found_mode;
if (HARD_REGNO_NREGS (regno, CCmode) == nregs
&& HARD_REGNO_MODE_OK (regno, CCmode))
return CCmode;
/* We can't find a mode valid for this register. */
return VOIDmode;
}
/* Initialize for caller-save.
Look at all the hard registers that are used by a call and for which
regclass.c has not already excluded from being used across a call.
Ensure that we can find a mode to save the register and that there is a
simple insn to save and restore the register. This latter check avoids
problems that would occur if we tried to save the MQ register of some
machines directly into memory. */
void
init_caller_save ()
{
char *first_obj = (char *) oballoc (0);
rtx addr_reg;
int offset;
rtx address;
int i, j;
/* First find all the registers that we need to deal with and all
the modes that they can have. If we can't find a mode to use,
we can't have the register live over calls. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
{
if (call_used_regs[i] && ! call_fixed_regs[i])
{
for (j = 1; j <= MOVE_MAX / UNITS_PER_WORD; j++)
{
regno_save_mode[i][j] = choose_hard_reg_mode (i, j);
if (regno_save_mode[i][j] == VOIDmode && j == 1)
{
call_fixed_regs[i] = 1;
SET_HARD_REG_BIT (call_fixed_reg_set, i);
}
}
}
else
regno_save_mode[i][1] = VOIDmode;
}
/* The following code tries to approximate the conditions under which
we can easily save and restore a register without scratch registers or
other complexities. It will usually work, except under conditions where
the validity of an insn operand is dependent on the address offset.
No such cases are currently known.
We first find a typical offset from some BASE_REG_CLASS register.
This address is chosen by finding the first register in the class
and by finding the smallest power of two that is a valid offset from
that register in every mode we will use to save registers. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (TEST_HARD_REG_BIT (reg_class_contents[(int) BASE_REG_CLASS], i))
break;
if (i == FIRST_PSEUDO_REGISTER)
abort ();
addr_reg = gen_rtx (REG, Pmode, i);
for (offset = 1 << (HOST_BITS_PER_INT / 2); offset; offset >>= 1)
{
address = gen_rtx (PLUS, Pmode, addr_reg, GEN_INT (offset));
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
if (regno_save_mode[i][1] != VOIDmode
&& ! strict_memory_address_p (regno_save_mode[i][1], address))
break;
if (i == FIRST_PSEUDO_REGISTER)
break;
}
/* If we didn't find a valid address, we must use register indirect. */
if (offset == 0)
address = addr_reg;
/* Next we try to form an insn to save and restore the register. We
see if such an insn is recognized and meets its constraints. */
start_sequence ();
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
for (j = 1; j <= MOVE_MAX / UNITS_PER_WORD; j++)
if (regno_save_mode[i][j] != VOIDmode)
{
rtx mem = gen_rtx (MEM, regno_save_mode[i][j], address);
rtx reg = gen_rtx (REG, regno_save_mode[i][j], i);
rtx savepat = gen_rtx (SET, VOIDmode, mem, reg);
rtx restpat = gen_rtx (SET, VOIDmode, reg, mem);
rtx saveinsn = emit_insn (savepat);
rtx restinsn = emit_insn (restpat);
int ok;
reg_save_code[i][j] = recog_memoized (saveinsn);
reg_restore_code[i][j] = recog_memoized (restinsn);
/* Now extract both insns and see if we can meet their constraints. */
ok = (reg_save_code[i][j] != -1 && reg_restore_code[i][j] != -1);
if (ok)
{
insn_extract (saveinsn);
ok = constrain_operands (reg_save_code[i][j], 1);
insn_extract (restinsn);
ok &= constrain_operands (reg_restore_code[i][j], 1);
}
if (! ok)
{
regno_save_mode[i][j] = VOIDmode;
if (j == 1)
{
call_fixed_regs[i] = 1;
SET_HARD_REG_BIT (call_fixed_reg_set, i);
}
}
}
end_sequence ();
obfree (first_obj);
}
/* Initialize save areas by showing that we haven't allocated any yet. */
void
init_save_areas ()
{
int i, j;
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
for (j = 1; j <= MOVE_MAX / UNITS_PER_WORD; j++)
regno_save_mem[i][j] = 0;
}
/* Allocate save areas for any hard registers that might need saving.
We take a conservative approach here and look for call-clobbered hard
registers that are assigned to pseudos that cross calls. This may
overestimate slightly (especially if some of these registers are later
used as spill registers), but it should not be significant.
Then perform register elimination in the addresses of the save area
locations; return 1 if all eliminated addresses are strictly valid.
We assume that our caller has set up the elimination table to the
worst (largest) possible offsets.
Set *PCHANGED to 1 if we had to allocate some memory for the save area.
Future work:
In the fallback case we should iterate backwards across all possible
modes for the save, choosing the largest available one instead of
falling back to the smallest mode immediately. (eg TF -> DF -> SF).
We do not try to use "move multiple" instructions that exist
on some machines (such as the 68k moveml). It could be a win to try
and use them when possible. The hard part is doing it in a way that is
machine independent since they might be saving non-consecutive
registers. (imagine caller-saving d0,d1,a0,a1 on the 68k) */
int
setup_save_areas (pchanged)
int *pchanged;
{
int i, j, k;
HARD_REG_SET hard_regs_used;
int ok = 1;
/* Allocate space in the save area for the largest multi-register
pseudos first, then work backwards to single register
pseudos. */
/* Find and record all call-used hard-registers in this function. */
CLEAR_HARD_REG_SET (hard_regs_used);
for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
if (reg_renumber[i] >= 0 && reg_n_calls_crossed[i] > 0)
{
int regno = reg_renumber[i];
int endregno
= regno + HARD_REGNO_NREGS (regno, GET_MODE (regno_reg_rtx[i]));
int nregs = endregno - regno;
for (j = 0; j < nregs; j++)
{
if (call_used_regs[regno+j])
SET_HARD_REG_BIT (hard_regs_used, regno+j);
}
}
/* Now run through all the call-used hard-registers and allocate
space for them in the caller-save area. Try to allocate space
in a manner which allows multi-register saves/restores to be done. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
for (j = MOVE_MAX / UNITS_PER_WORD; j > 0; j--)
{
int ok = 1;
/* If no mode exists for this size, try another. Also break out
if we have already saved this hard register. */
if (regno_save_mode[i][j] == VOIDmode || regno_save_mem[i][1] != 0)
continue;
for (k = 0; k < j; k++)
{
int regno = i + k;
ok &= (TEST_HARD_REG_BIT (hard_regs_used, regno) != 0);
}
/* We have found an acceptable mode to store in. */
if (ok)
{
regno_save_mem[i][j]
= assign_stack_local (regno_save_mode[i][j],
GET_MODE_SIZE (regno_save_mode[i][j]), 0);
/* Setup single word save area just in case... */
for (k = 0; k < j; k++)
{
/* This should not depend on WORDS_BIG_ENDIAN.
The order of words in regs is the same as in memory. */
rtx temp = gen_rtx (MEM, regno_save_mode[i+k][1],
XEXP (regno_save_mem[i][j], 0));
regno_save_mem[i+k][1]
= adj_offsettable_operand (temp, k * UNITS_PER_WORD);
}
*pchanged = 1;
}
}
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
for (j = 1; j <= MOVE_MAX / UNITS_PER_WORD; j++)
if (regno_save_mem[i][j] != 0)
ok &= strict_memory_address_p (GET_MODE (regno_save_mem[i][j]),
XEXP (eliminate_regs (regno_save_mem[i][j], 0, NULL_RTX), 0));
return ok;
}
/* Find the places where hard regs are live across calls and save them.
INSN_MODE is the mode to assign to any insns that we add. This is used
by reload to determine whether or not reloads or register eliminations
need be done on these insns. */
void
save_call_clobbered_regs (insn_mode)
enum machine_mode insn_mode;
{
rtx insn;
int b;
for (b = 0; b < n_basic_blocks; b++)
{
regset regs_live = basic_block_live_at_start[b];
rtx prev_block_last = PREV_INSN (basic_block_head[b]);
REGSET_ELT_TYPE bit;
int offset, i, j;
int regno;
/* Compute hard regs live at start of block -- this is the
real hard regs marked live, plus live pseudo regs that
have been renumbered to hard regs. No registers have yet been
saved because we restore all of them before the end of the basic
block. */
#ifdef HARD_REG_SET
hard_regs_live = *regs_live;
#else
COPY_HARD_REG_SET (hard_regs_live, regs_live);
#endif
CLEAR_HARD_REG_SET (hard_regs_saved);
CLEAR_HARD_REG_SET (hard_regs_need_restore);
n_regs_saved = 0;
for (offset = 0, i = 0; offset < regset_size; offset++)
{
if (regs_live[offset] == 0)
i += REGSET_ELT_BITS;
else
for (bit = 1; bit && i < max_regno; bit <<= 1, i++)
if ((regs_live[offset] & bit)
&& (regno = reg_renumber[i]) >= 0)
for (j = regno;
j < regno + HARD_REGNO_NREGS (regno,
PSEUDO_REGNO_MODE (i));
j++)
SET_HARD_REG_BIT (hard_regs_live, j);
}
/* Now scan the insns in the block, keeping track of what hard
regs are live as we go. When we see a call, save the live
call-clobbered hard regs. */
for (insn = basic_block_head[b]; ; insn = NEXT_INSN (insn))
{
RTX_CODE code = GET_CODE (insn);
if (GET_RTX_CLASS (code) == 'i')
{
rtx link;
/* If some registers have been saved, see if INSN references
any of them. We must restore them before the insn if so. */
if (n_regs_saved)
restore_referenced_regs (PATTERN (insn), insn, insn_mode);
/* NB: the normal procedure is to first enliven any
registers set by insn, then deaden any registers that
had their last use at insn. This is incorrect now,
since multiple pseudos may have been mapped to the
same hard reg, and the death notes are ambiguous. So
it must be done in the other, safe, order. */
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
if (REG_NOTE_KIND (link) == REG_DEAD)
clear_reg_live (XEXP (link, 0));
/* When we reach a call, we need to save all registers that are
live, call-used, not fixed, and not already saved. We must
test at this point because registers that die in a CALL_INSN
are not live across the call and likewise for registers that
are born in the CALL_INSN. */
if (code == CALL_INSN)
{
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (call_used_regs[regno] && ! call_fixed_regs[regno]
&& TEST_HARD_REG_BIT (hard_regs_live, regno)
&& ! TEST_HARD_REG_BIT (hard_regs_saved, regno))
regno += insert_save_restore (insn, 1, regno,
insn_mode, 0);
#ifdef HARD_REG_SET
hard_regs_need_restore = hard_regs_saved;
#else
COPY_HARD_REG_SET (hard_regs_need_restore,
hard_regs_saved);
#endif
/* Must recompute n_regs_saved. */
n_regs_saved = 0;
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (TEST_HARD_REG_BIT (hard_regs_saved, regno))
n_regs_saved++;
}
note_stores (PATTERN (insn), set_reg_live);
for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
if (REG_NOTE_KIND (link) == REG_UNUSED)
clear_reg_live (XEXP (link, 0));
}
if (insn == basic_block_end[b])
break;
}
/* At the end of the basic block, we must restore any registers that
remain saved. If the last insn in the block is a JUMP_INSN, put
the restore before the insn, otherwise, put it after the insn. */
if (n_regs_saved)
for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
if (TEST_HARD_REG_BIT (hard_regs_need_restore, regno))
regno += insert_save_restore ((GET_CODE (insn) == JUMP_INSN
? insn : NEXT_INSN (insn)), 0,
regno, insn_mode, MOVE_MAX / UNITS_PER_WORD);
/* If we added any insns at the start of the block, update the start
of the block to point at those insns. */
basic_block_head[b] = NEXT_INSN (prev_block_last);
}
}
/* Here from note_stores when an insn stores a value in a register.
Set the proper bit or bits in hard_regs_live. All pseudos that have
been assigned hard regs have had their register number changed already,
so we can ignore pseudos. */
static void
set_reg_live (reg, setter)
rtx reg, setter;
{
register int regno, endregno, i;
enum machine_mode mode = GET_MODE (reg);
int word = 0;
if (GET_CODE (reg) == SUBREG)
{
word = SUBREG_WORD (reg);
reg = SUBREG_REG (reg);
}
if (GET_CODE (reg) != REG || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
return;
regno = REGNO (reg) + word;
endregno = regno + HARD_REGNO_NREGS (regno, mode);
for (i = regno; i < endregno; i++)
{
SET_HARD_REG_BIT (hard_regs_live, i);
CLEAR_HARD_REG_BIT (hard_regs_saved, i);
CLEAR_HARD_REG_BIT (hard_regs_need_restore, i);
}
}
/* Here when a REG_DEAD note records the last use of a reg. Clear
the appropriate bit or bits in hard_regs_live. Again we can ignore
pseudos. */
static void
clear_reg_live (reg)
rtx reg;
{
register int regno, endregno, i;
if (GET_CODE (reg) != REG || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
return;
regno = REGNO (reg);
endregno= regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
for (i = regno; i < endregno; i++)
{
CLEAR_HARD_REG_BIT (hard_regs_live, i);
CLEAR_HARD_REG_BIT (hard_regs_need_restore, i);
CLEAR_HARD_REG_BIT (hard_regs_saved, i);
}
}
/* If any register currently residing in the save area is referenced in X,
which is part of INSN, emit code to restore the register in front of INSN.
INSN_MODE is the mode to assign to any insns that we add. */
static void
restore_referenced_regs (x, insn, insn_mode)
rtx x;
rtx insn;
enum machine_mode insn_mode;
{
enum rtx_code code = GET_CODE (x);
char *fmt;
int i, j;
if (code == CLOBBER)
return;
if (code == REG)
{
int regno = REGNO (x);
/* If this is a pseudo, scan its memory location, since it might
involve the use of another register, which might be saved. */
if (regno >= FIRST_PSEUDO_REGISTER
&& reg_equiv_mem[regno] != 0)
restore_referenced_regs (XEXP (reg_equiv_mem[regno], 0),
insn, insn_mode);
else if (regno >= FIRST_PSEUDO_REGISTER
&& reg_equiv_address[regno] != 0)
restore_referenced_regs (reg_equiv_address[regno],
insn, insn_mode);
/* Otherwise if this is a hard register, restore any piece of it that
is currently saved. */
else if (regno < FIRST_PSEUDO_REGISTER)
{
int endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
for (i = regno; i < endregno; i++)
if (TEST_HARD_REG_BIT (hard_regs_need_restore, i))
i += insert_save_restore (insn, 0, i, insn_mode,
CEIL (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD));
}
return;
}
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
{
if (fmt[i] == 'e')
restore_referenced_regs (XEXP (x, i), insn, insn_mode);
else if (fmt[i] == 'E')
for (j = XVECLEN (x, i) - 1; j >= 0; j--)
restore_referenced_regs (XVECEXP (x, i, j), insn, insn_mode);
}
}
/* Insert a sequence of insns to save or restore, SAVE_P says which,
REGNO. Place these insns in front of INSN. INSN_MODE is the mode
to assign to these insns. MAXRESTORE is the maximum number of registers
which should be restored during this call (when SAVE_P == 0). It should
never be less than 1 since we only work with entire registers.
Note that we have verified in init_caller_save that we can do this
with a simple SET, so use it. Set INSN_CODE to what we save there
since the address might not be valid so the insn might not be recognized.
These insns will be reloaded and have register elimination done by
find_reload, so we need not worry about that here.
Return the extra number of registers saved. */
static int
insert_save_restore (insn, save_p, regno, insn_mode, maxrestore)
rtx insn;
int save_p;
int regno;
enum machine_mode insn_mode;
int maxrestore;
{
rtx pat;
enum insn_code code;
int i, numregs;
/* A common failure mode if register status is not correct in the RTL
is for this routine to be called with a REGNO we didn't expect to
save. That will cause us to write an insn with a (nil) SET_DEST
or SET_SRC. Instead of doing so and causing a crash later, check
for this common case and abort here instead. This will remove one
step in debugging such problems. */
if (regno_save_mem[regno][1] == 0)
abort ();
/* If INSN is a CALL_INSN, we must insert our insns before any
USE insns in front of the CALL_INSN. */
if (GET_CODE (insn) == CALL_INSN)
while (GET_CODE (PREV_INSN (insn)) == INSN
&& GET_CODE (PATTERN (PREV_INSN (insn))) == USE)
insn = PREV_INSN (insn);
#ifdef HAVE_cc0
/* If INSN references CC0, put our insns in front of the insn that sets
CC0. This is always safe, since the only way we could be passed an
insn that references CC0 is for a restore, and doing a restore earlier
isn't a problem. We do, however, assume here that CALL_INSNs don't
reference CC0. Guard against non-INSN's like CODE_LABEL. */
if ((GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
&& reg_referenced_p (cc0_rtx, PATTERN (insn)))
insn = prev_nonnote_insn (insn);
#endif
/* Get the pattern to emit and update our status. */
if (save_p)
{
int i, j, k;
int ok;
/* See if we can save several registers with a single instruction.
Work backwards to the single register case. */
for (i = MOVE_MAX / UNITS_PER_WORD; i > 0; i--)
{
ok = 1;
if (regno_save_mem[regno][i] != 0)
for (j = 0; j < i; j++)
{
if (! call_used_regs[regno + j] || call_fixed_regs[regno + j]
|| ! TEST_HARD_REG_BIT (hard_regs_live, regno + j)
|| TEST_HARD_REG_BIT (hard_regs_saved, regno + j))
ok = 0;
}
else
continue;
/* Must do this one save at a time */
if (! ok)
continue;
pat = gen_rtx (SET, VOIDmode, regno_save_mem[regno][i],
gen_rtx (REG, GET_MODE (regno_save_mem[regno][i]), regno));
code = reg_save_code[regno][i];
/* Set hard_regs_saved for all the registers we saved. */
for (k = 0; k < i; k++)
{
SET_HARD_REG_BIT (hard_regs_saved, regno + k);
SET_HARD_REG_BIT (hard_regs_need_restore, regno + k);
n_regs_saved++;
}
numregs = i;
break;
}
}
else
{
int i, j, k;
int ok;
/* See if we can restore `maxrestore' registers at once. Work
backwards to the single register case. */
for (i = maxrestore; i > 0; i--)
{
ok = 1;
if (regno_save_mem[regno][i])
for (j = 0; j < i; j++)
{
if (! TEST_HARD_REG_BIT (hard_regs_need_restore, regno + j))
ok = 0;
}
else
continue;
/* Must do this one restore at a time */
if (! ok)
continue;
pat = gen_rtx (SET, VOIDmode,
gen_rtx (REG, GET_MODE (regno_save_mem[regno][i]),
regno),
regno_save_mem[regno][i]);
code = reg_restore_code[regno][i];
/* Clear status for all registers we restored. */
for (k = 0; k < i; k++)
{
CLEAR_HARD_REG_BIT (hard_regs_need_restore, regno + k);
n_regs_saved--;
}
numregs = i;
break;
}
}
/* Emit the insn and set the code and mode. */
insn = emit_insn_before (pat, insn);
PUT_MODE (insn, insn_mode);
INSN_CODE (insn) = code;
/* Tell our callers how many extra registers we saved/restored */
return numregs - 1;
}

2113
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/calls.c Normal file
View File

File diff suppressed because it is too large Load Diff

593
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/cccp.1 Normal file
View File

@@ -0,0 +1,593 @@
.\" Copyright (c) 1991, 1992 Free Software Foundation \-*-Text-*-
.\" See section COPYING for conditions for redistribution
.TH cpp 1 "2Jan1992" "GNU Tools" "GNU Tools"
.SH NAME
cccp, cpp \- The GNU C-Compatible Compiler Preprocessor.
.SH SYNOPSIS
.hy 0
.na
.TP
.B cccp
.RB "[\|" \-$ "\|]"
.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 "[\|" \-lang\-c "\|]"
.RB "[\|" \-lang\-c++ "\|]"
.RB "[\|" \-lang\-objc "\|]"
.RB "[\|" \-lang\-objc++ "\|]"
.RB "[\|" \-lint "\|]"
.RB "[\|" \-M "\|]"
.RB "[\|" \-MD "\|]"
.RB "[\|" \-MM "\|]"
.RB "[\|" \-MMD "\|]"
.RB "[\|" \-nostdinc "\|]"
.RB "[\|" \-P "\|]"
.RB "[\|" \-pedantic "\|]"
.RB "[\|" \-pedantic\-errors "\|]"
.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 preprocessor commands, 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 \-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
.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
.B \-dM
Instead of outputting the result of preprocessing, output a list of
`\|\c
.B #define\c
\&\|' commands 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
\&\|'
commands and the result of preprocessing. Both kinds of output go to
the standard output file.
.PP
.TP
.B \-M
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.
This feature is used in automatic updating of makefiles.
.TP
.B \-MM
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
.B \-MD
Like `\|\c
.B \-M\c
\&\|' but the dependency information is written to files with
names made by replacing `\|\c
.B .c\c
\&\|' with `\|\c
.B .d\c
\&\|' at the end of the
input file names. 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.
In Mach, you can use the utility \c
.B md\c
\& to merge the `\|\c
.B .d\c
\&\|' files
into a single dependency file suitable for using with the `\|\c
.B make\c
\&\|'
command.
.TP
.B \-MMD
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
.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 is required for ANSI
conformance. \c
.B gcc\c
\& automatically supplies this option to the
preprocessor if you specify `\|\c
.B \-ansi\c
\&\|', but \c
.B gcc\c
\& doesn't
recognize the `\|\c
.B \-$\c
\&\|' option itself\(em\&to use it without the other
effects of `\|\c
.B \-ansi\c
\&\|', you must call the preprocessor directly.
.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 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.

8918
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/cccp.c Normal file
View File

File diff suppressed because it is too large Load Diff

1864
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/cexp.c Normal file
View File

File diff suppressed because it is too large Load Diff

1010
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/cexp.y Normal file
View File

File diff suppressed because it is too large Load Diff

1952
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/collect2.c Normal file
View File

File diff suppressed because it is too large Load Diff

9609
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/combine.c Normal file
View File

File diff suppressed because it is too large Load Diff

10
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/cond.awk Normal file
View File

@@ -0,0 +1,10 @@
# Simpleminded conditional-processor awk script
# to permit use of a single .y source file for C and Objective C.
# If objc=1, the ifobjc conditionals succeed.
# If objc=0, the ifc conditionals succeed.
/^ifobjc$/,/^end ifobjc$/ \
{ if (objc != 0 && $0 != "ifobjc" && $0 != "end ifobjc") print; next }
/^ifc$/,/^end ifc$/ \
{ if (objc == 0 && $0 != "ifc" && $0 != "end ifc") print; next }
{ print }

115
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/conditions.h Normal file
View File

@@ -0,0 +1,115 @@
/* Definitions for condition code handling in final.c and output routines.
Copyright (C) 1987 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* None of the things in the files exist if we don't use CC0. */
#ifdef HAVE_cc0
/* The variable cc_status says how to interpret the condition code.
It is set by output routines for an instruction that sets the cc's
and examined by output routines for jump instructions.
cc_status contains two components named `value1' and `value2'
that record two equivalent expressions for the values that the
condition codes were set from. (Either or both may be null if
there is no useful expression to record.) These fields are
used for eliminating redundant test and compare instructions
in the cases where the condition codes were already set by the
previous instruction.
cc_status.flags contains flags which say that the condition codes
were set in a nonstandard manner. The output of jump instructions
uses these flags to compensate and produce the standard result
with the nonstandard condition codes. Standard flags are defined here.
The tm.h file can also define other machine-dependent flags.
cc_status also contains a machine-dependent component `mdep'
whose type, `CC_STATUS_MDEP', may be defined as a macro in the
tm.h file. */
#ifndef CC_STATUS_MDEP
#define CC_STATUS_MDEP int
#endif
#ifndef CC_STATUS_MDEP_INIT
#define CC_STATUS_MDEP_INIT 0
#endif
typedef struct {int flags; rtx value1, value2; CC_STATUS_MDEP mdep;} CC_STATUS;
/* While outputting an insn as assembler code,
this is the status BEFORE that insn. */
extern CC_STATUS cc_prev_status;
/* While outputting an insn as assembler code,
this is being altered to the status AFTER that insn. */
extern CC_STATUS cc_status;
/* These are the machine-independent flags: */
/* Set if the sign of the cc value is inverted:
output a following jump-if-less as a jump-if-greater, etc. */
#define CC_REVERSED 1
/* This bit means that the current setting of the N bit is bogus
and conditional jumps should use the Z bit in its place.
This state obtains when an extraction of a signed single-bit field
or an arithmetic shift right of a byte by 7 bits
is turned into a btst, because btst does not set the N bit. */
#define CC_NOT_POSITIVE 2
/* This bit means that the current setting of the N bit is bogus
and conditional jumps should pretend that the N bit is clear.
Used after extraction of an unsigned bit
or logical shift right of a byte by 7 bits is turned into a btst.
The btst does not alter the N bit, but the result of that shift
or extract is never negative. */
#define CC_NOT_NEGATIVE 4
/* This bit means that the current setting of the overflow flag
is bogus and conditional jumps should pretend there is no overflow. */
#define CC_NO_OVERFLOW 010
/* This bit means that what ought to be in the Z bit
should be tested as the complement of the N bit. */
#define CC_Z_IN_NOT_N 020
/* This bit means that what ought to be in the Z bit
should be tested as the N bit. */
#define CC_Z_IN_N 040
/* Nonzero if we must invert the sense of the following branch, i.e.
change EQ to NE. This is not safe for IEEE floating point operations!
It is intended for use only when a combination of arithmetic
or logical insns can leave the condition codes set in a fortuitous
(though inverted) state. */
#define CC_INVERTED 0100
/* Nonzero if we must convert signed condition operators to unsigned.
This is only used by machine description files. */
#define CC_NOT_SIGNED 0200
/* This is how to initialize the variable cc_status.
final does this at appropriate moments. */
#define CC_STATUS_INIT \
(cc_status.flags = 0, cc_status.value1 = 0, cc_status.value2 = 0, \
CC_STATUS_MDEP_INIT)
#endif

659
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config.sub vendored Normal file
View File

@@ -0,0 +1,659 @@
#!/bin/sh
# Configuration validation subroutine script, version 1.1.
# Copyright (C) 1991, 1992 Free Software Foundation, Inc.
# This file is (in principle) common to ALL GNU software.
# The presence of a machine in this file suggests that SOME GNU software
# can handle that machine. It does not imply ALL GNU software can.
#This file is free software; you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation; either version 2 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., 675 Mass Ave, Cambridge, MA 02139, USA.
# Configuration subroutine to validate and canonicalize a configuration type.
# Supply the specified configuration type as an argument.
# If it is invalid, we print an error message on stderr and exit with code 1.
# Otherwise, we print the canonical config type on stdout and succeed.
# This file is supposed to be the same for all GNU packages
# and recognize all the CPU types, system types and aliases
# that are meaningful with *any* GNU software.
# Each package is responsible for reporting which valid configurations
# it does not support. The user should be able to distinguish
# a failure to support a valid configuration from a meaningless
# configuration.
# The goal of this file is to map all the various variations of a given
# machine specification into a single specification in the form:
# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
# It is wrong to echo any other type of specification.
# First pass through any local machine types.
case $1 in
*local*)
echo $1
exit 0
;;
*)
;;
esac
# Separate what the user gave into CPU-COMPANY and OS (if any).
basic_machine=`echo $1 | sed 's/-[^-]*$//'`
if [ $basic_machine != $1 ]
then os=`echo $1 | sed 's/.*-/-/'`
else os=; fi
### Let's recognize common machines as not being operating systems so
### that things like config.sub decstation-3100 work. We also
### recognize some manufacturers as not being operating systems, so we
### can provide default operating systems below.
case $os in
-dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \
-att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \
-unicom* | -ibm* | -next* | -hp | -isi* | -apollo | -altos* | \
-convergent* | -ncr* | -news | -32* | -3600* | -3100* | \
-c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \
-harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp )
os=
basic_machine=$1
;;
-sco3.2v[4-9]*)
# Don't forget version if it is 3.2v4 or newer.
os=-sco3.2v4
basic_machine=i386-unknown
;;
-sco*)
os=-sco3.2v2
basic_machine=i386-unknown
;;
-isc)
os=-isc2.2
basic_machine=i386-unknown
;;
-isc*)
basic_machine=i386-unknown
;;
esac
# Decode aliases for certain CPU-COMPANY combinations.
case $basic_machine in
# Recognize the basic CPU types with without company name.
# Some are omitted here because they have special meanings below.
tahoe | i[34]86 | i860 | m68k | m68000 | m88k | ns32k | arm | pyramid \
| tron | a29k | 580 | i960 | h8300 | hppa1.0 | hppa1.1 \
| alpha | we32k | ns16k | clipper )
basic_machine=$basic_machine-unknown
;;
# Recognize the basic CPU types with with company name.
vax-* | tahoe-* | i[34]86-* | i860-* | m68k-* | m68000-* | m88k-* \
| sparc-* | ns32k-* | fx80-* | arm-* | c[123]* \
| mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \
| none-* | 580-* | cray2-* | h8300-* | i960-* | xmp-* | ymp-* \
| hppa1.0-* | hppa1.1-* | alpha-* | we32k-* | cydra-* | ns16k-* \
| pn-* | np1-* | xps100-* | clipper-* | orion-* )
;;
# Recognize the various machine names and aliases which stand
# for a CPU type and a company and sometimes even an OS.
vaxv)
basic_machine=vax-dec
os=-sysv
;;
vms)
basic_machine=vax-dec
os=-vms
;;
i386v32)
basic_machine=i386-unknown
os=-sysv32
;;
i386-sco* | i386sco | sco)
basic_machine=i386-unknown
os=-sco3.2v2
;;
i386-isc* | isc)
basic_machine=i386-unknown
os=-isc
;;
i486v32)
basic_machine=i486-unknown
os=-sysv32
;;
i486-sco* | i486sco | sco)
basic_machine=i486-unknown
os=-sco3.2v2
;;
i486-isc* | isc)
basic_machine=i486-unknown
os=-isc
;;
i386v4*)
basic_machine=i386-unknown
os=-sysv4
;;
i486v4*)
basic_machine=i486-unknown
os=-sysv4
;;
i386v)
basic_machine=i386-unknown
os=-sysv
;;
i486v)
basic_machine=i486-unknown
os=-sysv
;;
spur)
basic_machine=spur-unknown
;;
alliant | fx80)
basic_machine=fx80-alliant
;;
convex-c1)
basic_machine=c1-convex
os=-bsd
;;
convex-c2)
basic_machine=c2-convex
os=-bsd
;;
convex-c32)
basic_machine=c32-convex
os=-bsd
;;
convex-c34)
basic_machine=c34-convex
os=-bsd
;;
convex-c38)
basic_machine=c38-convex
os=-bsd
;;
m88k-omron*)
basic_machine=m88k-omron
;;
merlin)
basic_machine=ns32k-utek
os=-sysv
;;
crds | unos)
basic_machine=m68k-crds
;;
elxsi)
basic_machine=elxsi-elxsi
os=-bsd
;;
encore | umax | mmax)
basic_machine=ns32k-encore
;;
genix)
basic_machine=ns32k-ns
;;
iris | iris4d)
basic_machine=mips-sgi
case $os in
-irix*)
;;
*)
os=-irix4
;;
esac
;;
news | news700 | news800 | news900)
basic_machine=m68k-sony
os=-newsos
;;
3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc)
basic_machine=m68000-att
;;
3b*)
basic_machine=we32k-att
;;
delta | 3300 | motorola-3300 | motorola-delta \
| 3300-motorola | delta-motorola)
basic_machine=m68k-motorola
;;
balance)
basic_machine=ns32k-sequent
os=-dynix
;;
pc532)
basic_machine=ns32k-pc532
;;
symmetry)
basic_machine=i386-sequent
os=-dynix
;;
sun2)
basic_machine=m68000-sun
;;
sun2os3)
basic_machine=m68000-sun
os=-sunos3
;;
sun2os4)
basic_machine=m68000-sun
os=-sunos4
;;
sun3os3)
basic_machine=m68k-sun
os=-sunos3
;;
sun3os4)
basic_machine=m68k-sun
os=-sunos4
;;
sun4os3)
basic_machine=sparc-sun
os=-sunos3
;;
sun4os4)
basic_machine=sparc-sun
os=-sunos4
;;
sun3)
basic_machine=m68k-sun
;;
sun4)
basic_machine=sparc-sun
;;
pbd)
basic_machine=sparc-tti
;;
pbb)
basic_machine=m68k-tti
;;
sun386 | sun386i | roadrunner)
basic_machine=i386-sun
;;
ps2)
basic_machine=i386-ibm
;;
fx2800)
basic_machine=i860-alliant
;;
next)
basic_machine=m68k-next
os=-bsd
;;
amiga)
basic_machine=m68k-cbm
;;
amigados)
basic_machine=m68k-cbm
os=-amigados
;;
amigaunix | amix)
basic_machine=m68k-cbm
os=-sysv4
;;
hp9k3[2-9][0-9])
basic_machine=m68k-hp
;;
hp9k31[0-9] | hp9k2[0-9][0-9])
basic_machine=m68000-hp
;;
hp9k7[0-9][0-9] | hp7[0-9][0-9] | hp9k8[0-9]7 | hp8[0-9]7)
basic_machine=hppa1.1-hp
;;
hp9k8[0-9][0-9] | hp8[0-9][0-9])
basic_machine=hppa1.0-hp
;;
isi68 | isi)
basic_machine=m68k-isi
os=-sysv
;;
apollo68)
basic_machine=m68k-apollo
os=-sysv
;;
altos | altos3068)
basic_machine=m68k-altos
;;
miniframe)
basic_machine=m68000-convergent
;;
tower | tower-32)
basic_machine=m68k-ncr
;;
news-3600 | risc-news)
basic_machine=mips-sony
os=-newsos
;;
decstation | decstation-3100 | pmax | pmin | dec3100 | decstatn)
basic_machine=mips-dec
;;
magnum | m3230)
basic_machine=mips-mips
os=-sysv
;;
gmicro)
basic_machine=tron-gmicro
os=-sysv
;;
rtpc | rtpc-*)
basic_machine=romp-ibm
;;
am29k)
basic_machine=a29k-none
os=-bsd
;;
amdahl)
basic_machine=580-amdahl
os=-sysv
;;
cray | ymp)
basic_machine=ymp-cray
os=-unicos
;;
cray2)
basic_machine=cray2-cray
os=-unicos
;;
xmp)
basic_machine=xmp-cray
os=-unicos
;;
delta88)
basic_machine=m88k-motorola
os=-m88kbcs
;;
dpx2)
basic_machine=m68k-bull
os=-sysv
;;
ebmon29k)
basic_machine=a29k-amd
os=-ebmon
;;
h8300hds)
basic_machine=h8300-hitachi
os=-hds
;;
harris)
basic_machine=m88k-harris
os=-m88kbcs
;;
hp300bsd)
basic_machine=m68k-hp
os=-bsd
;;
hp300hpux)
basic_machine=m68k-hp
os=-hpux
;;
hp9k2[0-9][0-9] | hp9k31[0-9])
basic_machine=m68000-hp
os=-hpux
;;
hp9k3[2-9][0-9])
basic_machine=m68k-hp
os=-hpux
;;
ncr3000)
basic_machine=i486-ncr
os=-sysv4
;;
news1000)
basic_machine=m68030-sony
os=-newsos
;;
nindy960)
basic_machine=i960-intel
os=-nindy
;;
pn)
basic_machine=pn-gould
;;
np1)
basic_machine=np1-gould
;;
ultra3)
basic_machine=a29k-nyu
os=-sym1
;;
vxworks960)
basic_machine=i960-wrs
os=-vxworks
;;
vxworks68)
basic_machine=m68k-wrs
os=-vxworks
;;
xps | xps100)
basic_machine=xps100-honeywell
;;
none)
basic_machine=none-none
os=-none
;;
# Here we handle the default manufacturer of certain CPU types. It is in
# some cases the only manufacturer, in others, it is the most popular.
mips)
basic_machine=mips-mips
;;
romp)
basic_machine=romp-ibm
;;
rs6000)
basic_machine=rs6000-ibm
;;
vax)
basic_machine=vax-dec
;;
we32k)
basic_machine=we32k-att
;;
sparc)
basic_machine=sparc-sun
;;
cydra)
basic_machine=cydra-cydrome
;;
orion)
basic_machine=orion-highlevel
;;
orion105)
basic_machine=clipper-highlevel
;;
*)
echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2
exit 1
;;
esac
# Here we canonicalize certain aliases for manufacturers.
case $basic_machine in
*-digital*)
basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'`
;;
*-commodore*)
basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'`
;;
*)
;;
esac
# Decode manufacturer-specific aliases for certain operating systems.
if [ "$os" ]
then
case $os in
# First accept the basic system types.
# The portable systems comes first.
# Each alternative must end in a *, to match a version number.
-bsd* | -sysv* | -mach* | -minix* | -genix* | -ultrix* | -irix* \
| -vms* | -sco* | -esix* | -isc* | -aix* | -sunos* | -hpux* \
| -unos* | -osf* | -luna* | -dgux* | -solari* | -sym* \
| -amigados* | -msdos* | -newsos* | -unicos* | -aos* \
| -nindy* | -vxworks* | -ebmon* | -hds* | -m88kbcs* \
| -riscos* | -linux* | -uniplus* | -iris* | -rtu* | -xenix* )
;;
-osfrose*)
os=-osfrose
;;
-osf*)
os=-osf
;;
-utek*)
os=-bsd
;;
-dynix*)
os=-bsd
;;
-acis*)
os=-aos
;;
-ctix* | -uts*)
os=-sysv
;;
-triton*)
os=-sysv3
;;
-oss*)
os=-sysv3
;;
-svr4)
os=-sysv4
;;
-svr3)
os=-sysv3
;;
-xenix)
os=-xenix
;;
-none)
;;
*)
# Get rid of the `-' at the beginning of $os.
os=`echo $1 | sed 's/[^-]*-//'`
echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2
exit 1
;;
esac
else
# Here we handle the default operating systems that come with various machines.
# The value should be what the vendor currently ships out the door with their
# machine or put another way, the most popular os provided with the machine.
# Note that if you're going to try to match "-MANUFACTURER" here (say,
# "-sun"), then you have to tell the case statement up towards the top
# that MANUFACTURER isn't an operating system. Otherwise, code above
# will signal an error saying that MANUFACTURER isn't an operating
# system, and we'll never get to this point.
case $basic_machine in
*-dec | vax-*)
os=-ultrix4.2
;;
i386-sun)
os=-sunos4.0.2
;;
m68000-sun)
os=-sunos3
# This also exists in the configure program, but was not the
# default.
# os=-sunos4
;;
*-tti) # must be before sparc entry or we get the wrong os.
os=-sysv3
;;
sparc-* | *-sun)
os=-sunos4.1.1
;;
*-ibm)
os=-aix
;;
*-hp)
os=-hpux
;;
i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent)
os=-sysv
;;
*-cbm)
os=-amigados
;;
*-dg)
os=-dgux
;;
*-dolphin)
os=-sysv3
;;
m88k-omron*)
os=-luna
;;
*-crds)
os=-unos
;;
*-ns)
os=-genix
;;
i[34]86-*)
os=-sco3.2v2
;;
*-gould)
os=-sysv
;;
*-highlevel)
os=-bsd
;;
*-encore)
os=-bsd
;;
*-sgi)
os=-irix
;;
*-masscomp)
os=-rtu
;;
*)
os=-none
;;
esac
fi
# Here we handle the case where we know the os, and the CPU type, but not the
# manufacturer. We pick the logical manufacturer.
vendor=unknown
case $basic_machine in
*-unknown)
case $os in
-sunos*)
vendor=sun
;;
-aix*)
vendor=ibm
;;
-hpux*)
vendor=hp
;;
-unos*)
vendor=crds
;;
-dgux*)
vendor=dg
;;
-luna*)
vendor=omron
;;
-genix*)
vendor=ns
;;
esac
basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"`
;;
esac
echo $basic_machine$os

498
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/3b1.h Normal file
View File

@@ -0,0 +1,498 @@
/* Definitions of target machine for GNU compiler.
AT&T UNIX PC version (pc7300, 3b1)
Written by Alex Crain
bug reports to alex@umbc3.umd.edu
Copyright (C) 1987 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#define SGS_SWITCH_TABLES /* Different switch table handling */
#include "hp320.h"
/* See m68k.h. 0 means 680[01]0 with no 68881. */
#undef TARGET_DEFAULT
#define TARGET_DEFAULT 0
/* -m68020 requires special flags to the assembler. */
#undef ASM_SPEC
#define ASM_SPEC "%{m68020:-68020}%{!m68020:-68010} %{m68881:-68881}"
/* we use /lib/libp/lib* when profiling */
#undef LIB_SPEC
#define LIB_SPEC "%{!shlib:%{p:-L/lib/libp} %{pg:-L/lib/libp} -lc}"
/* shared libraries need to use crt0s.o */
#undef STARTFILE_SPEC
#define STARTFILE_SPEC \
"%{!shlib:%{pg:mcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}}\
%{shlib:crt0s.o%s shlib.ifile%s} "
/* cpp has to support a #sccs directive for the /usr/include files */
#define SCCS_DIRECTIVE
/* Make output for SDB. */
#define SDB_DEBUGGING_INFO
/* The .file command should always begin the output. */
#undef ASM_FILE_START
#define ASM_FILE_START(FILE) \
output_file_directive ((FILE), main_input_filename)
/* Don't try to define `gcc_compiled.' since the assembler might not
accept symbols with periods and GDB doesn't run on this machine anyway. */
#define ASM_IDENTIFY_GCC(FILE)
/* Define __HAVE_68881__ in preprocessor if -m68881 is specified.
This will control the use of inline 68881 insns in certain macros. */
#undef CPP_SPEC
#define CPP_SPEC "%{m68881:-D__HAVE_68881__}"
/* Names to predefine in the preprocessor for this target machine. */
/* ihnp4!lmayk!lgm@eddie.mit.edu says mc68000 and m68k should not be here. */
#undef CPP_PREDEFINES
#define CPP_PREDEFINES "-Dmc68k -Dunix -Dunixpc"
#undef REGISTER_NAMES
#define REGISTER_NAMES \
{"%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7", \
"%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%fp", "%sp", \
"%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7"}
/* Specify how to pad function arguments.
Value should be `upward', `downward' or `none'.
Same as the default, except no padding for large or variable-size args. */
#define FUNCTION_ARG_PADDING(MODE, TYPE) \
(((MODE) == BLKmode \
? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \
&& int_size_in_bytes (TYPE) < PARM_BOUNDARY / BITS_PER_UNIT) \
: GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \
? downward : none)
/* Override part of the obstack macros. */
#define __PTR_TO_INT(P) ((int)(P))
#define __INT_TO_PTR(P) ((char *)(P))
/* The 3b1 does not have `atexit'. */
#undef HAVE_ATEXIT
/* Override parts of m68k.h to fit the SGS-3b1 assembler. */
#undef TARGET_VERSION
#undef ASM_FORMAT_PRIVATE_NAME
#undef ASM_OUTPUT_DOUBLE
#undef ASM_OUTPUT_FLOAT
#undef ASM_OUTPUT_ALIGN
#undef ASM_OUTPUT_SOURCE_FILENAME
#undef ASM_OUTPUT_SOURCE_LINE
#undef PRINT_OPERAND_ADDRESS
#undef ASM_GENERATE_INTERNAL_LABEL
#undef FUNCTION_PROFILER
#undef ASM_OUTPUT_ADDR_VEC_ELT
#undef ASM_OUTPUT_ADDR_DIFF_ELT
#undef ASM_OUTPUT_INTERNAL_LABEL
#undef ASM_OUTPUT_OPCODE
#undef ASM_OUTPUT_LOCAL
#undef ASM_OUTPUT_LABELREF
#undef ASM_OUTPUT_ASCII
#define TARGET_VERSION fprintf (stderr, " (68k, SGS/AT&T unixpc syntax)");
/* Store in OUTPUT a string (made with alloca) containing
an assembler-name for a local static variable named NAME.
LABELNO is an integer which is different for each call. */
#define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \
( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 12), \
sprintf ((OUTPUT), "%s_%%%d", (NAME), (LABELNO)))
/* The unixpc doesn't know about double's and float's */
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { union { double d; long l[2]; } tem; \
tem.d = (VALUE); \
fprintf(FILE, "\tlong 0x%x,0x%x\n", tem.l[0], tem.l[1]); \
} while (0)
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
do { union { float f; long l;} tem; \
tem.f = (VALUE); \
fprintf (FILE, "\tlong 0x%x\n", tem.l); \
} while (0)
#define ASM_OUTPUT_ALIGN(FILE,LOG) \
if ((LOG) == 1) \
fprintf (FILE, "\teven\n"); \
else if ((LOG) != 0) \
abort ();
/* This is how to output an assembler line
that says to advance the location counter by SIZE bytes. */
#undef ASM_OUTPUT_SKIP
#define ASM_OUTPUT_SKIP(FILE,SIZE) \
fprintf (FILE, "\tspace %d\n", (SIZE))
/* Can't use ASM_OUTPUT_SKIP in text section; it doesn't leave 0s. */
#define ASM_NO_SKIP_IN_TEXT 1
/* The beginnings of sdb support... */
#define ASM_OUTPUT_SOURCE_FILENAME(FILE, FILENAME) \
fprintf (FILE, "\tfile\t\"%s\"\n", FILENAME)
#define ASM_OUTPUT_SOURCE_LINE(FILE, LINENO) \
fprintf (FILE, "\tln\t%d\n", \
(sdb_begin_function_line \
? last_linenum - sdb_begin_function_line : 1))
/* Yet another null terminated string format. */
#define ASM_OUTPUT_ASCII(FILE,PTR,LEN) \
{ register int sp = 0, lp = 0; \
fprintf ((FILE), "\tbyte\t"); \
loop: \
if ((PTR)[sp] > ' ' && ! ((PTR)[sp] & 0x80) && (PTR)[sp] != '\\') \
{ lp += 3; \
fprintf ((FILE), "'%c", (PTR)[sp]); } \
else \
{ lp += 5; \
fprintf ((FILE), "0x%x", (PTR)[sp]); } \
if (++sp < (LEN)) \
{ if (lp > 60) \
{ lp = 0; \
fprintf ((FILE), "\n\t%s ", ASCII_DATA_ASM_OP); } \
else \
putc (',', (FILE)); \
goto loop; } \
putc ('\n', (FILE)); }
/* Note that in the case of the movhi which fetches an element of
an ADDR_DIFF_VEC the offset output is too large by 2.
This is because the 3b1 assembler refuses to subtract 2.
ASM_OUTPUT_CASE_LABEL, below, compensates for this. */
#define PRINT_OPERAND_ADDRESS(FILE, ADDR) \
{ register rtx reg1, reg2, breg, ireg; \
register rtx addr = ADDR; \
rtx offset; \
switch (GET_CODE (addr)) \
{ \
case REG: \
fprintf (FILE, "(%s)", reg_names[REGNO (addr)]); \
break; \
case PRE_DEC: \
fprintf (FILE, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]); \
break; \
case POST_INC: \
fprintf (FILE, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]); \
break; \
case PLUS: \
reg1 = 0; reg2 = 0; \
ireg = 0; breg = 0; \
offset = 0; \
if (CONSTANT_ADDRESS_P (XEXP (addr, 0))) \
{ \
offset = XEXP (addr, 0); \
addr = XEXP (addr, 1); \
} \
else if (CONSTANT_ADDRESS_P (XEXP (addr, 1))) \
{ \
offset = XEXP (addr, 1); \
addr = XEXP (addr, 0); \
} \
if (GET_CODE (addr) != PLUS) ; \
else if (GET_CODE (XEXP (addr, 0)) == SIGN_EXTEND) \
{ \
reg1 = XEXP (addr, 0); \
addr = XEXP (addr, 1); \
} \
else if (GET_CODE (XEXP (addr, 1)) == SIGN_EXTEND) \
{ \
reg1 = XEXP (addr, 1); \
addr = XEXP (addr, 0); \
} \
else if (GET_CODE (XEXP (addr, 0)) == MULT) \
{ \
reg1 = XEXP (addr, 0); \
addr = XEXP (addr, 1); \
} \
else if (GET_CODE (XEXP (addr, 1)) == MULT) \
{ \
reg1 = XEXP (addr, 1); \
addr = XEXP (addr, 0); \
} \
else if (GET_CODE (XEXP (addr, 0)) == REG) \
{ \
reg1 = XEXP (addr, 0); \
addr = XEXP (addr, 1); \
} \
else if (GET_CODE (XEXP (addr, 1)) == REG) \
{ \
reg1 = XEXP (addr, 1); \
addr = XEXP (addr, 0); \
} \
if (GET_CODE (addr) == REG || GET_CODE (addr) == MULT \
|| GET_CODE (addr) == SIGN_EXTEND) \
{ if (reg1 == 0) reg1 = addr; else reg2 = addr; addr = 0; } \
/* for OLD_INDEXING \
else if (GET_CODE (addr) == PLUS) \
{ \
if (GET_CODE (XEXP (addr, 0)) == REG) \
{ \
reg2 = XEXP (addr, 0); \
addr = XEXP (addr, 1); \
} \
else if (GET_CODE (XEXP (addr, 1)) == REG) \
{ \
reg2 = XEXP (addr, 1); \
addr = XEXP (addr, 0); \
} \
} \
*/ \
if (offset != 0) { if (addr != 0) abort (); addr = offset; } \
if ((reg1 && (GET_CODE (reg1) == SIGN_EXTEND \
|| GET_CODE (reg1) == MULT)) \
|| (reg2 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg2)))) \
{ breg = reg2; ireg = reg1; } \
else if (reg1 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg1))) \
{ breg = reg1; ireg = reg2; } \
if (ireg != 0 && breg == 0 && GET_CODE (addr) == LABEL_REF) \
{ int scale = 1; \
if (GET_CODE (ireg) == MULT) \
{ scale = INTVAL (XEXP (ireg, 1)); \
ireg = XEXP (ireg, 0); } \
if (GET_CODE (ireg) == SIGN_EXTEND) \
fprintf (FILE, "LD%%%d(%%pc,%s.w", \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
reg_names[REGNO (XEXP (ireg, 0))]); \
else \
fprintf (FILE, "LD%%%d(%%pc,%s.l", \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
reg_names[REGNO (ireg)]); \
if (scale != 1) fprintf (FILE, "*%d", scale); \
fprintf (FILE, ")"); \
break; } \
if (breg != 0 && ireg == 0 && GET_CODE (addr) == LABEL_REF) \
{ fprintf (FILE, "LD%%%d(%%pc,%s.l", \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
reg_names[REGNO (breg)]); \
putc (')', FILE); \
break; } \
if (ireg != 0 || breg != 0) \
{ int scale = 1; \
if (breg == 0) \
abort (); \
if (addr != 0) \
output_addr_const (FILE, addr); \
fprintf (FILE, "(%s", reg_names[REGNO (breg)]); \
if (ireg != 0) \
putc (',', FILE); \
if (ireg != 0 && GET_CODE (ireg) == MULT) \
{ scale = INTVAL (XEXP (ireg, 1)); \
ireg = XEXP (ireg, 0); } \
if (ireg != 0 && GET_CODE (ireg) == SIGN_EXTEND) \
fprintf (FILE, "%s.w", reg_names[REGNO (XEXP (ireg, 0))]); \
else if (ireg != 0) \
fprintf (FILE, "%s.l", reg_names[REGNO (ireg)]); \
if (scale != 1) fprintf (FILE, "*%d", scale); \
putc (')', FILE); \
break; \
} \
else if (reg1 != 0 && GET_CODE (addr) == LABEL_REF) \
{ fprintf (FILE, "LD%%%d(%%pc,%s.w)", \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
reg_names[REGNO (reg1)]); \
break; } \
default: \
if (GET_CODE (addr) == CONST_INT \
&& INTVAL (addr) < 0x8000 \
&& INTVAL (addr) >= -0x8000) \
fprintf (FILE, "%d", INTVAL (addr)); \
else \
output_addr_const (FILE, addr); \
}}
#define ASM_GENERATE_INTERNAL_LABEL(LABEL, PREFIX, NUM) \
sprintf ((LABEL), "%s%%%d", (PREFIX), (NUM))
#define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \
fprintf (FILE, "%s%%%d:\n", PREFIX, NUM)
/* Must put address in %a0 , not %d0 . -- LGM, 7/15/88 */
#define FUNCTION_PROFILER(FILE, LABEL_NO) \
fprintf (FILE, "\tmov.l &LP%%%d,%%a0\n\tjsr mcount\n", (LABEL_NO))
#define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \
fprintf (FILE, "\tlong L%%%d\n", (VALUE))
#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \
fprintf (FILE, "\tshort L%%%d-L%%%d\n", (VALUE), (REL))
/* ihnp4!lmayk!lgm says that `short 0' triggers assembler bug;
`short L%nn-L%nn' supposedly works. */
#define ASM_OUTPUT_CASE_LABEL(FILE,PREFIX,NUM,TABLE) \
if (! RTX_INTEGRATED_P (TABLE)) \
fprintf (FILE, "\tswbeg &%d\n%s%%%d:\n", \
XVECLEN (PATTERN (TABLE), 1), (PREFIX), (NUM)); \
else \
fprintf (FILE, "\tswbeg &%d\n%s%%%d:\n\tshort %s%%%d-%s%%%d\n", \
XVECLEN (PATTERN (TABLE), 1) + 1, (PREFIX), (NUM), \
(PREFIX), (NUM), (PREFIX), (NUM))
/* At end of a switch table, define LDnnn iff the symbol LInnn was defined.
Some SGS assemblers have a bug such that "Lnnn-LInnn-2.b(pc,d0.l*2)"
fails to assemble. Luckily "LDnnn(pc,d0.l*2)" produces the results
we want. This difference can be accommodated by making the assembler
define such "LDnnn" to be either "Lnnn-LInnn-2.b", "Lnnn", or any other
string, as necessary. This is accomplished via the ASM_OUTPUT_CASE_END
macro. */
#define ASM_OUTPUT_CASE_END(FILE,NUM,TABLE) \
{ if (switch_table_difference_label_flag) \
fprintf (FILE, "\tset LD%%%d,L%%%d-LI%%%d\n", (NUM), (NUM), (NUM)) \
switch_table_difference_label_flag = 0; }
int switch_table_difference_label_flag;
#define ASM_OUTPUT_OPCODE(FILE, PTR) \
{ if ((PTR)[0] == 'j' && (PTR)[1] == 'b') \
{ ++(PTR); \
while (*(PTR) != ' ') \
{ putc (*(PTR), (FILE)); ++(PTR); } \
fprintf ((FILE), ".w"); } \
else if ((PTR)[0] == 's') \
{ \
if (!strncmp ((PTR), "swap", 4)) \
{ fprintf ((FILE), "swap.w"); (PTR) += 4; } \
} \
else if ((PTR)[0] == 'f') \
{ \
if (!strncmp ((PTR), "fmove", 5)) \
{ fprintf ((FILE), "fmov"); (PTR) += 5; } \
else if (!strncmp ((PTR), "fbne", 4)) \
{ fprintf ((FILE), "fbneq"); (PTR) += 4; } \
} \
/* MOVE, MOVEA, MOVEQ, MOVEC ==> MOV */ \
else if ((PTR)[0] == 'm' && (PTR)[1] == 'o' \
&& (PTR)[2] == 'v' && (PTR)[3] == 'e') \
{ fprintf ((FILE), "mov"); (PTR) += 4; \
if ((PTR)[0] == 'q' || (PTR)[0] == 'a' \
|| (PTR)[0] == 'c') (PTR)++; } \
/* SUB, SUBQ, SUBA, SUBI ==> SUB */ \
else if ((PTR)[0] == 's' && (PTR)[1] == 'u' \
&& (PTR)[2] == 'b') \
{ fprintf ((FILE), "sub"); (PTR) += 3; \
if ((PTR)[0] == 'q' || (PTR)[0] == 'i' \
|| (PTR)[0] == 'a') (PTR)++; } \
/* CMP, CMPA, CMPI, CMPM ==> CMP */ \
else if ((PTR)[0] == 'c' && (PTR)[1] == 'm' \
&& (PTR)[2] == 'p') \
{ fprintf ((FILE), "cmp"); (PTR) += 3; \
if ((PTR)[0] == 'a' || (PTR)[0] == 'i' \
|| (PTR)[0] == 'm') (PTR)++; } \
}
#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \
( fputs ("\tlcomm ", (FILE)), \
assemble_name ((FILE), (NAME)), \
fprintf ((FILE), ",%u\n", (ROUNDED)))
#define ASM_OUTPUT_LABELREF(FILE,NAME) \
fprintf (FILE, "%s", NAME)
/* Override usual definitions of SDB output macros.
These definitions differ only in the absence of the period
at the beginning of the name of the directive
and in the use of `~' as the symbol for the current location. */
#define PUT_SDB_SCL(a) fprintf(asm_out_file, "\tscl\t%d;", (a))
#define PUT_SDB_INT_VAL(a) fprintf (asm_out_file, "\tval\t%d;", (a))
#define PUT_SDB_VAL(a) \
( fputs ("\tval\t", asm_out_file), \
output_addr_const (asm_out_file, (a)), \
fputc (';', asm_out_file))
#define PUT_SDB_DEF(a) \
do { fprintf (asm_out_file, "\tdef\t"); \
ASM_OUTPUT_LABELREF (asm_out_file, a); \
fprintf (asm_out_file, ";"); } while (0)
#define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\tdef\t~%s;",a)
#define PUT_SDB_ENDEF fputs("\tendef\n", asm_out_file)
#define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\ttype\t0%o;", a)
#define PUT_SDB_SIZE(a) fprintf(asm_out_file, "\tsize\t%d;", a)
#define PUT_SDB_START_DIM fprintf(asm_out_file, "\tdim\t")
#define PUT_SDB_TAG(a) \
do { fprintf (asm_out_file, "\ttag\t"); \
ASM_OUTPUT_LABELREF (asm_out_file, a); \
fprintf (asm_out_file, ";"); } while (0)
#define PUT_SDB_BLOCK_START(LINE) \
fprintf (asm_out_file, \
"\tdef\t~bb;\tval\t~;\tscl\t100;\tline\t%d;\tendef\n", \
(LINE))
#define PUT_SDB_BLOCK_END(LINE) \
fprintf (asm_out_file, \
"\tdef\t~eb;\tval\t~;\tscl\t100;\tline\t%d;\tendef\n", \
(LINE))
#define PUT_SDB_FUNCTION_START(LINE) \
fprintf (asm_out_file, \
"\tdef\t~bf;\tval\t~;\tscl\t101;\tline\t%d;\tendef\n", \
(LINE))
#define PUT_SDB_FUNCTION_END(LINE) \
fprintf (asm_out_file, \
"\tdef\t~ef;\tval\t~;\tscl\t101;\tline\t%d;\tendef\n", \
(LINE))
#define PUT_SDB_EPILOGUE_END(NAME) \
fprintf (asm_out_file, \
"\tdef\t%s;\tval\t~;\tscl\t-1;\tendef\n", \
(NAME))
#define SDB_GENERATE_FAKE(BUFFER, NUMBER) \
sprintf ((BUFFER), "~%dfake", (NUMBER));
/* Define subroutines to call to handle multiply, divide, and remainder.
Use the subroutines that the 3b1's library provides.
The `*' prevents an underscore from being prepended by the compiler. */
#define DIVSI3_LIBCALL "*ldiv"
#define UDIVSI3_LIBCALL "*uldiv"
#define MODSI3_LIBCALL "*lrem"
#define UMODSI3_LIBCALL "*ulrem"
#define MULSI3_LIBCALL "*lmul"
#define UMULSI3_LIBCALL "*ulmul"

63
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/3b1g.h Normal file
View File

@@ -0,0 +1,63 @@
/* Definitions of target machine for GNU compiler, for a 3b1 using GAS.
Copyright (C) 1987, 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "m68k.h"
/* See m68k.h. 0 means 68000 with no 68881. */
#define TARGET_DEFAULT 0
/* Define __HAVE_68881 in preprocessor only if -m68881 is specified.
This will control the use of inline 68881 insns in certain macros.
Also inform the program which CPU this is for. */
#define CPP_SPEC "%{m68881:-D__HAVE_68881__} \
%{!ansi:%{m68020:-Dmc68020}%{mc68020:-Dmc68020}%{!mc68020:%{!m68020:-Dmc68010}}}"
/* -m68020 requires special flags to the assembler. */
#define ASM_SPEC \
"%{m68020:-mc68020}%{mc68020:-mc68020}%{!mc68020:%{!m68020:-mc68010}}"
/* Names to predefine in the preprocessor for this target machine. */
#define CPP_PREDEFINES "-Dmc68000 -Dmc68k -Dunix -Dunixpc"
/* This is (not really) BSD, so (but) it wants DBX format. */
#define DBX_DEBUGGING_INFO
/* Brain damage. */
#define SCCS_DIRECTIVE
/* Specify how to pad function arguments.
Value should be `upward', `downward' or `none'.
Same as the default, except no padding for large or variable-size args. */
#define FUNCTION_ARG_PADDING(MODE, TYPE) \
(((MODE) == BLKmode \
? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \
&& int_size_in_bytes (TYPE) < PARM_BOUNDARY / BITS_PER_UNIT) \
: GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \
? downward : none)
/* Override part of the obstack macros. */
#define __PTR_TO_INT(P) ((int)(P))
#define __INT_TO_PTR(P) ((char *)(P))
/* Every structure or union's size must be a multiple of 2 bytes. */
#define STRUCTURE_SIZE_BOUNDARY 16
/* Generate calls to memcpy, memcmp and memset. */
#define TARGET_MEM_FUNCTIONS

1433
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/a29k.c Normal file
View File

File diff suppressed because it is too large Load Diff

1592
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/a29k.h Normal file
View File

File diff suppressed because it is too large Load Diff

2908
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/a29k.md Normal file
View File

File diff suppressed because it is too large Load Diff

84
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/a29kunix.h Normal file
View File

@@ -0,0 +1,84 @@
/* Definitions of target machine for GNU compiler, for AMD Am29000 CPU, Unix.
Copyright (C) 1991 Free Software Foundation, Inc.
Contributed by Richard Kenner (kenner@nyu.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, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* This is mostly the same as a29k.h, except that we define unix instead of
EPI and define unix-style machine names. */
#include "a29k.h"
/* Set our default target to be the 29050; that is the more interesting chip
for Unix systems. */
#undef TARGET_DEFAULT
#define TARGET_DEFAULT (1+2+8+64)
#undef CPP_PREDEFINES
#define CPP_PREDEFINES "-Dam29k -Da29k -Dam29000"
#undef CPP_SPEC
#define CPP_SPEC "%{!m29000:-Dam29050 -D__am29050__}"
/* Use a default linker configuration file. */
#undef LINK_SPEC
#define LINK_SPEC "-T default.gld%s"
/* For some systems, it is best if double-word objects are aligned on a
doubleword boundary. We want to maintain compatibility with MetaWare in
a29k.h, but do not feel constrained to do so here. */
#undef BIGGEST_ALIGNMENT
#define BIGGEST_ALIGNMENT 64
/* Add shared data as a kludge for now. */
#undef ASM_FILE_START
#define ASM_FILE_START(FILE) \
{ char *p, *after_dir = main_input_filename; \
if (TARGET_29050) \
fprintf (FILE, "\t.cputype 29050\n"); \
for (p = main_input_filename; *p; p++) \
if (*p == '/') \
after_dir = p + 1; \
fprintf (FILE, "\t.file \"%s\"\n", after_dir); \
if (flag_shared_data) \
fprintf (FILE, "\t.sect .shdata,data\n"); \
fprintf (FILE, "\t.sect .lit,lit\n"); }
/* Output before shared data. */
#define SHARED_SECTION_ASM_OP "\t.use .shdata"
/* If we want shared data, we have to turn off commons. */
#define OVERRIDE_OPTIONS if (flag_shared_data) flag_no_common = 1;
#if 0 /* This would be needed except that the 29k doesn't have strict
alignment requirements. */
#define FUNCTION_ARG_BOUNDARY(MODE, TYPE) \
(((TYPE) != 0) \
? ((TYPE_ALIGN(TYPE) <= PARM_BOUNDARY) \
? PARM_BOUNDARY \
: TYPE_ALIGN(TYPE)) \
: ((GET_MODE_ALIGNMENT(MODE) <= PARM_BOUNDARY) \
? PARM_BOUNDARY \
: GET_MODE_ALIGNMENT(MODE)))
#endif

111
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/aix386.h Normal file
View File

@@ -0,0 +1,111 @@
/* Definitions for IBM PS2 running AIX/386.
From: Minh Tran-Le <TRANLE@intellicorp.com>
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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "i386.h"
/* Get the generic definitions for system V.3. */
#include "svr3.h"
/* Use the ATT assembler syntax.
This overrides at least one macro (ASM_OUTPUT_LABELREF) from svr3.h. */
#include "att386.h"
/* Use crt1.o as a startup file and crtn.o as a closing file. */
#define STARTFILE_SPEC \
"%{pg:gcrt1.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}} crtbegin.o%s"
#define LIB_SPEC "%{p:-L/usr/lib/libp}%{pg:-L/usr/lib/libp} -lc \
crtend.o%s crtn.o%s"
/* Special flags for the linker. I don't know what they do. */
#define LINK_SPEC "%{K} %{!K:-K} %{T*} %{z:-lm}"
/* Specify predefined symbols in preprocessor. */
#define CPP_PREDEFINES "-D_I386 -Di386 -DAIX -D_AIX"
/* special flags for the aix assembler to generate the short form for all
qualifying forward reference */
#define ASM_SPEC "-s2"
#undef ASM_FILE_START
#define ASM_FILE_START(FILE) \
do { fprintf (FILE, "\t.file\t\"%s\"\n", dump_base_name); \
if (optimize) \
ASM_FILE_START_1 (FILE); \
else \
fprintf (FILE, "\t.noopt\n"); \
} while (0)
/* This was suggested, but it shouldn't be right for DBX output. -- RMS
#define ASM_OUTPUT_SOURCE_FILENAME(FILE, NAME) */
/* Writing `int' for a bitfield forces int alignment for the structure. */
#define PCC_BITFIELD_TYPE_MATTERS 1
#if 0
/* Don't write a `.optim' pseudo; this assembler
is said to have a bug when .optim is used. */
#undef ASM_FILE_START_1
#define ASM_FILE_START_1(FILE) fprintf (FILE, "\t.noopt\n");
#endif
/* Output assembler code to FILE to increment profiler label # LABELNO
for profiling a function entry. */
#undef FUNCTION_PROFILER
#define FUNCTION_PROFILER(FILE, LABELNO) \
fprintf (FILE, "\tleal %sP%d,%%eax\n\tcall mcount\n", LPREFIX, (LABELNO));
/* Note that using bss_section here caused errors
in building shared libraries on system V.3.
but AIX 1.2 does not have yet shareable libraries on PS2 */
#undef ASM_OUTPUT_LOCAL
#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \
(bss_section (), \
ASM_OUTPUT_LABEL ((FILE), (NAME)), \
fprintf ((FILE), "\t.set .,.+%u\n", (ROUNDED)))
/* Define a few machine-specific details of the implementation of
constructors. */
#undef INIT_SECTION_ASM_OP
#define INIT_SECTION_ASM_OP ".section .init,\"x\""
#define CTOR_LIST_BEGIN \
asm (INIT_SECTION_ASM_OP); \
asm ("pushl $0")
#define CTOR_LIST_END CTOR_LIST_BEGIN
#define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \
do { \
init_section (); \
fprintf (FILE, "\tpushl $"); \
assemble_name (FILE, NAME); \
fprintf (FILE, "\n"); \
} while (0)

92
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/aix386ng.h Normal file
View File

@@ -0,0 +1,92 @@
/* Definitions for IBM PS2 running AIX/386.
From: Minh Tran-Le <TRANLE@intellicorp.com>
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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "i386.h"
/* Get the generic definitions for system V.3. */
#include "svr3.h"
/* Use the ATT assembler syntax.
This overrides at least one macro (ASM_OUTPUT_LABELREF) from svr3.h. */
#include "att386.h"
/* Use crt1.o as a startup file and crtn.o as a closing file. */
#define STARTFILE_SPEC \
"%{pg:gcrt1.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}} crtbegin.o%s"
#define LIB_SPEC "%{p:-L/usr/lib/libp}%{pg:-L/usr/lib/libp} -lc \
crtend.o%s crtn.o%s"
/* Special flags for the linker. I don't know what they do. */
#define LINK_SPEC "%{K} %{!K:-K} %{T*} %{z:-lm}"
/* Specify predefined symbols in preprocessor. */
#define CPP_PREDEFINES "-D_I386 -Di386 -DAIX -D_AIX"
/* special flags for the aix assembler to generate the short form for all
qualifying forward reference */
#define ASM_SPEC "-s2"
#undef ASM_FILE_START
#define ASM_FILE_START(FILE) \
do { fprintf (FILE, "\t.file\t\"%s\"\n", dump_base_name); \
if (optimize) \
ASM_FILE_START_1 (FILE); \
else \
fprintf (FILE, "\t.noopt\n"); \
} while (0)
/* This was suggested, but it shouldn't be right for DBX output. -- RMS
#define ASM_OUTPUT_SOURCE_FILENAME(FILE, NAME) */
/* Writing `int' for a bitfield forces int alignment for the structure. */
#define PCC_BITFIELD_TYPE_MATTERS 1
#if 0
/* Don't write a `.optim' pseudo; this assembler
is said to have a bug when .optim is used. */
#undef ASM_FILE_START_1
#define ASM_FILE_START_1(FILE) fprintf (FILE, "\t.noopt\n");
#endif
/* Output assembler code to FILE to increment profiler label # LABELNO
for profiling a function entry. */
#undef FUNCTION_PROFILER
#define FUNCTION_PROFILER(FILE, LABELNO) \
fprintf (FILE, "\tleal %sP%d,%%eax\n\tcall mcount\n", LPREFIX, (LABELNO));
/* Note that using bss_section here caused errors
in building shared libraries on system V.3.
but AIX 1.2 does not have yet shareable libraries on PS2 */
#undef ASM_OUTPUT_LOCAL
#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \
(bss_section (), \
ASM_OUTPUT_LABEL ((FILE), (NAME)), \
fprintf ((FILE), "\t.set .,.+%u\n", (ROUNDED)))

1516
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/alpha.c Normal file
View File

File diff suppressed because it is too large Load Diff

1588
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/alpha.h Normal file
View File

File diff suppressed because it is too large Load Diff

3013
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/alpha.md Normal file
View File

File diff suppressed because it is too large Load Diff

107
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/altos3068.h Normal file
View File

@@ -0,0 +1,107 @@
/* Definitions of target machine for GNU compiler. Altos 3068 68020 version.
Copyright (C) 1988,1989 Free Software Foundation, Inc.
Written by Jyrki Kuoppala <jkp@cs.hut.fi>
Last modified: Mon Mar 6 22:47:58 1989
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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "m68k.h"
/* See m68k.h. 7 means 68020 with 68881. */
/* 5 is without 68881. Change to 7 if you have 68881 */
#ifndef TARGET_DEFAULT
#define TARGET_DEFAULT 5
#endif
/* Define __HAVE_68881__ in preprocessor,
according to the -m flags.
This will control the use of inline 68881 insns in certain macros.
Also inform the program which CPU this is for. */
#if TARGET_DEFAULT & 02
/* -m68881 is the default */
#define CPP_SPEC \
"%{!msoft-float:-D__HAVE_68881__ }\
%{!ansi:%{m68000:-Dmc68010}%{mc68000:-Dmc68010}%{!mc68000:%{!m68000:-Dmc68020}}}"
#else
/* -msoft-float is the default */
#define CPP_SPEC \
"%{m68881:-D__HAVE_68881__ }\
%{!ansi:%{m68000:-Dmc68010}%{mc68000:-Dmc68010}%{!mc68000:%{!m68000:-Dmc68020}}}"
#endif
/* -m68000 requires special flags to the assembler. */
#define ASM_SPEC \
"%{m68000:-mc68010}%{mc68000:-mc68010}%{!mc68000:%{!m68000:-mc68020}}"
/* Names to predefine in the preprocessor for this target machine. */
#define CPP_PREDEFINES "-Dmc68000 -DPORTAR -Dmc68k32 -Uvax -Dm68k -Dunix"
/* Every structure or union's size must be a multiple of 2 bytes. */
#define STRUCTURE_SIZE_BOUNDARY 16
/* Generate calls to memcpy, memcmp and memset. */
#define TARGET_MEM_FUNCTIONS
/* We use gnu assembler, linker and gdb, so we want DBX format. */
#define DBX_DEBUGGING_INFO
/* Tell some conditionals we will use GAS. Is this really used? */
#define USE_GAS
/* This is how to output an assembler line defining a `double' constant. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
fprintf (FILE, "\t.double 0r%.20e\n", (VALUE))
/* This is how to output an assembler line defining a `float' constant. */
#undef ASM_OUTPUT_FLOAT
#define ASM_OUTPUT_FLOAT(FILE,VALUE) \
fprintf (FILE, "\t.single 0r%.20e\n", (VALUE))
#undef ASM_OUTPUT_FLOAT_OPERAND
#define ASM_OUTPUT_FLOAT_OPERAND(FILE,VALUE) \
fprintf (FILE, "#0r%.9g", (VALUE))
#undef ASM_OUTPUT_DOUBLE_OPERAND
#define ASM_OUTPUT_DOUBLE_OPERAND(FILE,VALUE) \
fprintf (FILE, "#0r%.20g", (VALUE))
/* Return pointer values in both d0 and a0. */
#undef FUNCTION_EXTRA_EPILOGUE
#define FUNCTION_EXTRA_EPILOGUE(FILE, SIZE) \
{ \
extern int current_function_returns_pointer; \
if ((current_function_returns_pointer) && \
! find_equiv_reg (0, get_last_insn (), 0, 0, 0, 8, Pmode))\
fprintf (FILE, "\tmovel d0,a0\n"); \
}

123
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/amix.h Normal file
View File

@@ -0,0 +1,123 @@
/* Definitions of target 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "m68kv4.h"
/* Alter assembler syntax for fsgldiv and fsglmul.
It is highly likely that this is a generic SGS m68k assembler dependency.
If so, it should eventually be handled in the m68ksgs.h ASM_OUTPUT_OPCODE
macro, like the other SGS assembler quirks. -fnf */
#define FSGLDIV_USE_S /* Use fsgldiv.s, not fsgldiv.x */
#define FSGLMUL_USE_S /* Use fsglmul.s, not fsglmul.x */
/* Names to predefine in the preprocessor for this target machine. For the
Amiga, these definitions match those of the native AT&T compiler. Note
that we override the definition in m68kv4.h, where SVR4 is defined and
AMIX isn't. */
#undef CPP_PREDEFINES
#define CPP_PREDEFINES \
"-Dm68k -Dunix -DAMIX -Amachine(m68k) -Acpu(m68k) -Asystem(unix) -Alint(off)"
/* At end of a switch table, define LDnnn iff the symbol LInnn was defined.
Some SGS assemblers have a bug such that "Lnnn-LInnn-2.b(pc,d0.l*2)"
fails to assemble. Luckily "Lnnn(pc,d0.l*2)" produces the results
we want. This difference can be accommodated by making the assembler
define such "LDnnn" to be either "Lnnn-LInnn-2.b", "Lnnn", or any other
string, as necessary. This is accomplished via the ASM_OUTPUT_CASE_END
macro. (the Amiga assembler has this bug) */
#undef ASM_OUTPUT_CASE_END
#define ASM_OUTPUT_CASE_END(FILE,NUM,TABLE) \
do { \
if (switch_table_difference_label_flag) \
asm_fprintf ((FILE), "\t%s %LLD%d,%LL%d\n", SET_ASM_OP, (NUM), (NUM));\
switch_table_difference_label_flag = 0; \
} while (0)
int switch_table_difference_label_flag;
/* This says how to output assembler code to declare an
uninitialized external linkage data object. Under SVR4,
the linker seems to want the alignment of data objects
to depend on their types. We do exactly that here.
[This macro overrides the one in svr4.h because the amix assembler
has a minimum default alignment of 4, and will not accept any
explicit alignment smaller than this. -fnf] */
#undef ASM_OUTPUT_ALIGNED_COMMON
#define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGN) \
do { \
fputs ("\t.comm\t", (FILE)); \
assemble_name ((FILE), (NAME)); \
fprintf ((FILE), ",%u,%u\n", (SIZE), MAX ((ALIGN) / BITS_PER_UNIT, 4)); \
} while (0)
/* This says how to output assembler code to declare an
uninitialized internal linkage data object. Under SVR4,
the linker seems to want the alignment of data objects
to depend on their types. We do exactly that here.
[This macro overrides the one in svr4.h because the amix assembler
has a minimum default alignment of 4, and will not accept any
explicit alignment smaller than this. -fnf] */
#undef ASM_OUTPUT_ALIGNED_LOCAL
#define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGN) \
do { \
fprintf ((FILE), "\t%s\t%s,%u,%u\n", \
BSS_ASM_OP, (NAME), (SIZE), MAX ((ALIGN) / BITS_PER_UNIT, 4)); \
} while (0)
/* This definition of ASM_OUTPUT_ASCII is the same as the one in m68ksgs.h,
which has been overridden by the one in svr4.h. However, we can't use
the one in svr4.h because the amix assembler croaks on some of the
strings that it emits (such as .string "\"%s\"\n"). */
#undef ASM_OUTPUT_ASCII
#define ASM_OUTPUT_ASCII(FILE,PTR,LEN) \
{ \
register int sp = 0, lp = 0, ch; \
fprintf ((FILE), "\t%s ", BYTE_ASM_OP); \
do { \
ch = (PTR)[sp]; \
if (ch > ' ' && ! (ch & 0x80) && ch != '\\') \
{ \
fprintf ((FILE), "'%c", ch); \
} \
else \
{ \
fprintf ((FILE), "0x%x", ch); \
} \
if (++sp < (LEN)) \
{ \
if ((sp % 10) == 0) \
{ \
fprintf ((FILE), "\n\t%s ", BYTE_ASM_OP); \
} \
else \
{ \
putc (',', (FILE)); \
} \
} \
} while (sp < (LEN)); \
putc ('\n', (FILE)); \
}

87
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/aoutos.h Normal file
View File

@@ -0,0 +1,87 @@
/* aoutos.h -- operating system specific defines to be used when
targeting GCC for some system that uses a.out file format.
Copyright (C) 1992 Free Software Foundation, Inc.
Written by Ron Guilmette (rfg@ncd.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, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* To use this file, make up a file with a name like:
?????aout.h
where ????? is replaced by the name of the basic hardware that you
are targeting for. Then, in the file ?????aout.h, put something
like:
#include "?????.h"
#include "aoutos.h"
followed by any really system-specific defines (or overrides of
defines) which you find that you need. Now, modify the configure
or configure.in script to properly use the new ?????aout.h file
when configuring for the system. */
/* Define a symbol indicating that we are using aoutos.h. */
#define USING_AOUTOS_H
/* A C statement (sans semicolon) to output an element in the table of
global constructors.
If using GNU LD, tell it that this is part of the static destructor set.
This code works for any machine provided you use GNU as/ld.
If not using GNU LD, rely on a "collect" program to look for names defined
in the particular form we choose as global constructor function names. */
#define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \
do { \
if (flag_gnu_linker) \
{ \
/* Output an N_SETT (0x16, 22.) for the name. */ \
fprintf (FILE, "%s \"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP); \
assemble_name (FILE, NAME); \
fputc ('\n', FILE); \
} \
} while (0)
/* A C statement (sans semicolon) to output an element in the table of
global destructors. */
#define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \
do { \
if (flag_gnu_linker) \
{ \
/* Output an N_SETT (0x16, 22.) for the name. */ \
fprintf (FILE, "%s \"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP); \
assemble_name (FILE, NAME); \
fputc ('\n', FILE); \
} \
} while (0)
/* Likewise for entries we want to record for garbage collection.
Garbage collection is still under development. */
#define ASM_OUTPUT_GC_ENTRY(FILE,NAME) \
do { \
if (flag_gnu_linker) \
{ \
/* Output an N_SETT (0x16, 22.) for the name. */ \
fprintf (FILE, "%s \"___PTR_LIST__\",22,0,0,", ASM_STABS_OP); \
assemble_name (FILE, NAME); \
fputc ('\n', FILE); \
} \
} while (0)

211
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/apollo68.h Normal file
View File

@@ -0,0 +1,211 @@
/* Definitions of target machine for GNU compiler. Apollo 680X0 version.
Copyright (C) 1989,1992 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "m68k.h"
/* This symbol may be tested in other files for special Apollo handling */
#define TM_APOLLO
/* See m68k.h. 7 means 68020 with 68881. */
#ifndef TARGET_DEFAULT
#define TARGET_DEFAULT 7
#endif
/* Target switches for the Apollo is the same as in m68k.h, except
there is no Sun FPA. */
#undef TARGET_SWITCHES
#define TARGET_SWITCHES \
{ { "68020", 5}, \
{ "c68020", 5}, \
{ "68881", 2}, \
{ "bitfield", 4}, \
{ "68000", -5}, \
{ "c68000", -5}, \
{ "soft-float", -0102}, \
{ "nobitfield", -4}, \
{ "rtd", 8}, \
{ "nortd", -8}, \
{ "short", 040}, \
{ "noshort", -040}, \
{ "", TARGET_DEFAULT}}
/* Define __HAVE_68881__ in preprocessor,
according to the -m flags.
This will control the use of inline 68881 insns in certain macros.
Also inform the program which CPU this is for. */
#if TARGET_DEFAULT & 02
/* -m68881 is the default */
#define CPP_SPEC \
"%{!msoft-float:%{mfpa:-D__HAVE_FPA__ }%{!mfpa:-D__HAVE_68881__ }}\
%{!ansi:%{m68000:-Dmc68010 }%{mc68000:-Dmc68010 }%{!mc68000:%{!m68000:-Dmc68020 }}\
%{!ansi:-D_APOLLO_SOURCE}}"
#else
/* -msoft-float is the default */
#define CPP_SPEC \
"%{m68881:-D__HAVE_68881__ }%{mfpa:-D__HAVE_FPA__ }\
%{!ansi:%{m68000:-Dmc68010 }%{mc68000:-Dmc68010 }%{!mc68000:%{!m68000:-Dmc68020 }}\
%{!ansi:-D_APOLLO_SOURCE}}"
#endif
/* Names to predefine in the preprocessor for this target machine. */
/* These are the ones defined by Apollo, plus mc68000 for uniformity with
GCC on other 68000 systems. */
#define CPP_PREDEFINES "-Dapollo -Daegis -Dunix"
/* cpp has to support a #sccs directive for the /usr/include files */
#define SCCS_DIRECTIVE
/* Allow #ident but output nothing for it. */
#define IDENT_DIRECTIVE
#define ASM_OUTPUT_IDENT(FILE, NAME)
/* Allow dollarsigns in identifiers */
#define DOLLARS_IN_IDENTIFIERS 2
/* -m68000 requires special flags to the assembler. */
#define ASM_SPEC \
"%{m68000:-mc68010}%{mc68000:-mc68010}%{!mc68000:%{!m68000:-mc68020}}"
/* STARTFILE_SPEC
Note that includes knowledge of the default specs for gcc, ie. no
args translates to the same effect as -m68881 */
#if TARGET_DEFAULT & 2
/* -m68881 is the default */
#define STARTFILE_SPEC \
"%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
#else
/* -msoft-float is the default */
#define STARTFILE_SPEC \
"%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
#endif
/* Specify library to handle `-a' basic block profiling. */
#define LIB_SPEC "%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p} \
%{a:/usr/lib/bb_link.o} "
/* Debugging is not supported yet */
#undef DBX_DEBUGGING_INFO
#undef SDB_DEBUGGING_INFO
/* We have atexit(2). So C++ can use it for global destructors. */
#if 0 /* troy@cbme.unsw.edu.au says people are still using sr10.2
and it does not support atexit. */
#define HAVE_ATEXIT
#endif
/* Every structure or union's size must be a multiple of 2 bytes. */
#define STRUCTURE_SIZE_BOUNDARY 16
/* Boundary (in *bits*) on which stack pointer should be aligned. */
#undef STACK_BOUNDARY
#define STACK_BOUNDARY 32
/* Functions which return large structures get the address
to place the wanted value from a hidden parameter. */
#undef PCC_STATIC_STRUCT_RETURN
#undef STRUCT_VALUE_REGNUM
#define STRUCT_VALUE 0
#define STRUCT_VALUE_INCOMING 0
/* Specify how to pad function arguments.
Arguments are not padded at all; the stack is kept aligned on long
boundaries. */
#define FUNCTION_ARG_PADDING(mode, size) none
/* The definition of this macro imposes a limit on the size of
an aggregate object which can be treated as if it were a scalar
object. */
#define MAX_FIXED_MODE_SIZE BITS_PER_WORD
/* The definition of this macro implies that there are cases where
a scalar value cannot be returned in registers.
For Apollo, anything larger than one integer register is returned
using the structure-value mechanism, i.e. objects of DFmode are
returned that way. */
#define RETURN_IN_MEMORY(type) \
(GET_MODE_SIZE (TYPE_MODE (type)) > UNITS_PER_WORD)
/* In order to link with Apollo libraries, we can't prefix external
symbols with an underscore. */
#undef USER_LABEL_PREFIX
/* Use a prefix for local labels, just to be on the save side. */
#undef LOCAL_LABEL_PREFIX
#define LOCAL_LABEL_PREFIX "."
/* Use a register prefix to avoid clashes with external symbols (classic
example: `extern char PC;' in termcap). */
#undef REGISTER_PREFIX
#define REGISTER_PREFIX "%"
/* In the machine description we can't use %R, because it will not be seen
by ASM_FPRINTF. (Isn't that a design bug?). */
#undef REGISTER_PREFIX_MD
#define REGISTER_PREFIX_MD "%%"
/* config/m68k.md has an explicit reference to the program counter,
prefix this by the register prefix. */
#define ASM_RETURN_CASE_JUMP return "jmp %%pc@(2,%0:w)"
/* Here are the new register names. */
#undef REGISTER_NAMES
#ifndef SUPPORT_SUN_FPA
#define REGISTER_NAMES \
{"%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7", \
"%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%sp", \
"%fp0", "%fp1", "%fp2", "%fp3", "%fp4", "%fp5", "%fp6", "%fp7" }
#else /* SUPPORTED_SUN_FPA */
#define REGISTER_NAMES \
{"%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7", \
"%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%sp", \
"%fp0", "%fp1", "%fp2", "%fp3", "%fp4", "%fp5", "%fp6", "%fp7", \
"%fpa0", "%fpa1", "%fpa2", "%fpa3", "%fpa4", "%fpa5", "%fpa6", "%fpa7", \
"%fpa8", "%fpa9", "%fpa10", "%fpa11", "%fpa12", "%fpa13", "%fpa14", "%fpa15", \
"%fpa16", "%fpa17", "%fpa18", "%fpa19", "%fpa20", "%fpa21", "%fpa22", "%fpa23", \
"%fpa24", "%fpa25", "%fpa26", "%fpa27", "%fpa28", "%fpa29", "%fpa30", "%fpa31" }
#endif /* defined SUPPORT_SUN_FPA */

1343
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/arm.c Normal file
View File

File diff suppressed because it is too large Load Diff

1308
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/arm.h Normal file
View File

File diff suppressed because it is too large Load Diff

1317
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/arm.md Normal file
View File

File diff suppressed because it is too large Load Diff

103
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/att386.h Normal file
View File

@@ -0,0 +1,103 @@
/* Definitions for AT&T assembler syntax for the Intel 80386.
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, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Include common aspects of all 386 Unix assemblers. */
#include "unx386.h"
#define TARGET_VERSION fprintf (stderr, " (80386, ATT syntax)");
/* Define the syntax of instructions and addresses. */
/* Prefix for internally generated assembler labels. */
#define LPREFIX ".L"
/* Assembler pseudos to introduce constants of various size. */
/* #define ASM_BYTE_OP "\t.byte" Now in svr3.h or svr4.h. */
#define ASM_SHORT "\t.value"
#define ASM_LONG "\t.long"
#define ASM_DOUBLE "\t.double"
/* How to output an ASCII string constant. */
#define ASM_OUTPUT_ASCII(FILE, p, size) \
{ int i = 0; \
while (i < (size)) \
{ if (i%10 == 0) { if (i!=0) fprintf ((FILE), "\n"); \
fprintf ((FILE), "%s ", ASM_BYTE_OP); } \
else fprintf ((FILE), ","); \
fprintf ((FILE), "0x%x", ((p)[i++] & 0377)) ;} \
fprintf ((FILE), "\n"); }
/* Do use .optim by default on this machine. */
#undef ASM_FILE_START_1
#define ASM_FILE_START_1(FILE) fprintf (FILE, "\t.optim\n")
/* This is how to output an assembler line
that says to advance the location counter
to a multiple of 2**LOG bytes. */
#define ASM_OUTPUT_ALIGN(FILE,LOG) \
if ((LOG)!=0) fprintf ((FILE), "\t.align %d\n", 1<<(LOG))
/* This is how to output an assembler line
that says to advance the location counter by SIZE bytes. */
#define ASM_OUTPUT_SKIP(FILE,SIZE) \
fprintf ((FILE), "\t.set .,.+%u\n", (SIZE))
/* Can't use ASM_OUTPUT_SKIP in text section; it doesn't leave 0s. */
#define ASM_NO_SKIP_IN_TEXT 1
#undef BSS_SECTION_FUNCTION /* Override the definition from svr3.h. */
#define BSS_SECTION_FUNCTION \
void \
bss_section () \
{ \
if (in_section != in_bss) \
{ \
fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP); \
in_section = in_bss; \
} \
}
/* Define the syntax of labels and symbol definitions/declarations. */
/* This is how to store into the string BUF
the symbol_ref name of an internal numbered label where
PREFIX is the class of label and NUM is the number within the class.
This is suitable for output with `assemble_name'. */
#undef ASM_GENERATE_INTERNAL_LABEL
#define ASM_GENERATE_INTERNAL_LABEL(BUF,PREFIX,NUMBER) \
sprintf ((BUF), ".%s%d", (PREFIX), (NUMBER))
/* This is how to output an internal numbered label where
PREFIX is the class of label and NUM is the number within the class. */
#undef ASM_OUTPUT_INTERNAL_LABEL
#define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \
fprintf (FILE, ".%s%d:\n", PREFIX, NUM)
/* This is how to output a reference to a user-level label named NAME. */
#undef ASM_OUTPUT_LABELREF
#define ASM_OUTPUT_LABELREF(FILE,NAME) \
fprintf (FILE, "%s", NAME)

122
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/bsd386.h Normal file
View File

@@ -0,0 +1,122 @@
/* Definitions for BSD assembler syntax for Intel 386
(actually AT&T syntax for insns and operands,
adapted to BSD conventions for symbol names and debugging.)
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, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Include common aspects of all 386 Unix assemblers. */
#include "unx386.h"
/* Use the Sequent Symmetry assembler syntax. */
#define TARGET_VERSION fprintf (stderr, " (80386, BSD syntax)");
/* Define the syntax of pseudo-ops, labels and comments. */
/* Prefix for internally generated assembler labels. If we aren't using
underscores, we are using prefix `.'s to identify labels that should
be ignored, as in `i386gas.h' --karl@cs.umb.edu */
#ifdef NO_UNDERSCORES
#define LPREFIX ".L"
#else
#define LPREFIX "L"
#endif /* not NO_UNDERSCORES */
/* Assembler pseudos to introduce constants of various size. */
#define ASM_BYTE_OP "\t.byte"
#define ASM_SHORT "\t.word"
#define ASM_LONG "\t.long"
#define ASM_DOUBLE "\t.double"
/* Output at beginning of assembler file.
??? I am skeptical of this -- RMS. */
#define ASM_FILE_START(FILE) \
fprintf (FILE, "\t.file\t\"%s\"\n", dump_base_name);
/* This was suggested, but it shouldn't be right for DBX output. -- RMS
#define ASM_OUTPUT_SOURCE_FILENAME(FILE, NAME) */
/* Define the syntax of labels and symbol definitions/declarations. */
/* This is how to output an assembler line
that says to advance the location counter by SIZE bytes. */
#define ASM_OUTPUT_SKIP(FILE,SIZE) \
fprintf (FILE, "\t.space %u\n", (SIZE))
/* Define the syntax of labels and symbol definitions/declarations. */
/* This says how to output an assembler line
to define a global common symbol. */
#define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \
( fputs (".comm ", (FILE)), \
assemble_name ((FILE), (NAME)), \
fprintf ((FILE), ",%u\n", (ROUNDED)))
/* This says how to output an assembler line
to define a local common symbol. */
#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \
( fputs (".lcomm ", (FILE)), \
assemble_name ((FILE), (NAME)), \
fprintf ((FILE), ",%u\n", (ROUNDED)))
/* This is how to output an assembler line
that says to advance the location counter
to a multiple of 2**LOG bytes. */
#define ASM_OUTPUT_ALIGN(FILE,LOG) \
if ((LOG)!=0) fprintf ((FILE), "\t.align %d\n", (LOG))
/* This is how to store into the string BUF
the symbol_ref name of an internal numbered label where
PREFIX is the class of label and NUM is the number within the class.
This is suitable for output with `assemble_name'. */
#define ASM_GENERATE_INTERNAL_LABEL(BUF,PREFIX,NUMBER) \
sprintf ((BUF), "*%s%d", (PREFIX), (NUMBER))
/* This is how to output an internal numbered label where
PREFIX is the class of label and NUM is the number within the class. */
#define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \
fprintf (FILE, "%s%d:\n", PREFIX, NUM)
/* This is how to output a reference to a user-level label named NAME. */
#ifdef NO_UNDERSCORES
#define ASM_OUTPUT_LABELREF(FILE,NAME) fprintf (FILE, "%s", NAME)
#else
#define ASM_OUTPUT_LABELREF(FILE,NAME) fprintf (FILE, "_%s", NAME)
#endif /* not NO_UNDERSCORES */
/* Sequent has some changes in the format of DBX symbols. */
#define DBX_NO_XREFS 1
/* Don't split DBX symbols into continuations. */
#define DBX_CONTIN_LENGTH 0
/* This is how to output an assembler line defining a `double' constant. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
fprintf (FILE, "\t.double 0d%.20e\n", (VALUE))

220
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/convex.c Normal file
View File

@@ -0,0 +1,220 @@
/* Subroutines for insn-output.c for Convex.
Copyright (C) 1989,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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "config.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "real.h"
#include "insn-config.h"
#include "conditions.h"
#include "insn-flags.h"
#include "output.h"
#include "insn-attr.h"
/* Boolean to keep track of whether the current section is .text or not.
Used by .align handler in convex.h. */
int current_section_is_text;
/* set_cmp saves the operands of a "cmp" insn, along with the type character
* to be used in the compare instruction.
*
* gen_cmp finds out what comparison is to be performed and outputs the
* necessary instructions, e.g.
* "eq.w a1,a2\;jbra.t L5"
* for (cmpsi a1 a2) (beq L5) */
static rtx xop0, xop1;
static char typech, regch;
char *
set_cmp (op0, op1, typechr)
rtx op0, op1;
char typechr;
{
xop0 = op0;
xop1 = op1;
typech = typechr;
if (GET_CODE (op0) == REG)
regch = A_REGNO_P (REGNO (op0)) ? 'a' : 's';
else if (GET_CODE (op1) == REG)
regch = A_REGNO_P (REGNO (op1)) ? 'a' : 's';
else abort ();
return "";
}
char *
gen_cmp (label, cmpop, tf)
rtx label;
char *cmpop;
char tf;
{
char buf[80];
char revop[4];
rtx ops[3];
ops[2] = label;
/* Constant must be first; swap operands if necessary.
If lt, le, ltu, leu are swapped, change to le, lt, leu, ltu
and reverse the sense of the jump. */
if (CONSTANT_P (xop1))
{
ops[0] = xop1;
ops[1] = xop0;
if (cmpop[0] == 'l')
{
bcopy (cmpop, revop, sizeof revop);
revop[1] ^= 'e' ^ 't';
tf ^= 't' ^ 'f';
cmpop = revop;
}
}
else
{
ops[0] = xop0;
ops[1] = xop1;
}
sprintf (buf, "%s.%c %%0,%%1\n\tjbr%c.%c %%l2", cmpop, typech, regch, tf);
output_asm_insn (buf, ops);
return "";
}
/* Routines to separate CONST_DOUBLEs into component parts. */
int
const_double_high_int (x)
rtx x;
{
if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
return CONST_DOUBLE_LOW (x);
else
return CONST_DOUBLE_HIGH (x);
}
int
const_double_low_int (x)
rtx x;
{
if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
return CONST_DOUBLE_HIGH (x);
else
return CONST_DOUBLE_LOW (x);
}
/* Return the number of args in the call insn X. */
static int
call_num_args (x)
rtx x;
{
if (GET_CODE (x) == CALL)
return INTVAL (x->fld[1].rtx);
if (GET_CODE (x) == SET)
return call_num_args (SET_SRC (x));
abort ();
}
/* Scan forward from a call to decide whether we need to reload AP
from 12(FP) after it. We need to if there can be a reference to
arg_pointer_rtx before the next call, which will clobber AP.
Look forward in the instruction list until encountering a call
(don't need the load), or a reference to AP (do need it), or
a jump (don't know, do the load). */
static int
ap_reload_needed (insn)
rtx insn;
{
for (;;)
{
insn = NEXT_INSN (insn);
switch (GET_CODE (insn))
{
case JUMP_INSN:
/* Basic block ends. If return, no AP needed, else assume it is. */
return GET_CODE (PATTERN (insn)) != RETURN;
case CALL_INSN:
/* A subsequent call. AP isn't needed unless the call itself
requires it. But zero-arg calls don't clobber AP, so
don't terminate the search in that case. */
if (reg_mentioned_p (arg_pointer_rtx, PATTERN (insn)))
return 1;
if (! TARGET_ARGCOUNT && call_num_args (PATTERN (insn)) == 0)
break;
return 0;
case BARRIER:
/* Barrier, don't need AP. */
return 0;
case INSN:
/* Other insn may need AP; if not, keep looking. */
if (reg_mentioned_p (arg_pointer_rtx, PATTERN (insn)))
return 1;
}
}
}
/* Output the insns needed to do a call. */
char *
output_call (insn, address, argcount)
rtx insn, address, argcount;
{
int set_ap = TARGET_ARGCOUNT || argcount != const0_rtx;
/* If AP is used by the call address, evaluate the address into a temp. */
if (reg_mentioned_p (arg_pointer_rtx, address))
if (set_ap)
{
address = XEXP (address, 0);
output_asm_insn ("ld.w %0,a1", &address);
address = gen_rtx (MEM, QImode, gen_rtx (REG, Pmode, 9));
}
/* If there are args, point AP to them. */
if (set_ap)
output_asm_insn ("mov sp,ap");
/* If we are passing an arg count, convert it to words and push it. */
if (TARGET_ARGCOUNT)
{
argcount = gen_rtx (CONST_INT, VOIDmode, (INTVAL (argcount) + 3) / 4);
output_asm_insn ("pshea %a0", &argcount);
}
/* The call. */
output_asm_insn ("calls %0", &address);
/* If we clobbered AP, reload it if it is live. */
if (set_ap)
if (ap_reload_needed (insn))
output_asm_insn ("ld.w 12(fp),ap");
/* If we pushed an arg count, pop it and the args. */
if (TARGET_ARGCOUNT)
{
argcount = gen_rtx (CONST_INT, VOIDmode, INTVAL (argcount) * 4 + 4);
output_asm_insn ("add.w %0,sp", &argcount);
}
return "";
}

1193
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/convex.h Normal file
View File

File diff suppressed because it is too large Load Diff

1351
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/convex.md Normal file
View File

File diff suppressed because it is too large Load Diff

26
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/convex1.h Normal file
View File

@@ -0,0 +1,26 @@
/* tm.h file for a Convex C1. */
#include "convex.h"
#undef TARGET_DEFAULT
#define TARGET_DEFAULT 1
#define CC1_SPEC "%{mc2:-mnoc1}"
/* Include Posix prototypes unless -ansi. */
#define CPP_SPEC \
"%{mc2:-D__convex_c2__}%{!mc2:-D__convex_c1__} \
-D__NO_INLINE_MATH -D__NO_INLINE_STDLIB \
%{!traditional:-D__stdc__ \
-D_LONGLONG -Ds64_t=long\\ long -Du64_t=unsigned\\ long\\ long} \
%{!ansi:-D_POSIX_SOURCE -D_CONVEX_SOURCE}"
/* Search Posix or else backward-compatible libraries depending
on -traditional. */
#define LIB_SPEC \
"%{mc2:-lC2}%{!mc2:-lC1} \
%{!p:%{!pg:%{traditional:-lc_old}%{!traditional:-lc}}} \
%{p:%{traditional:-lc_old_p}%{!traditional:-lc_p}} \
%{pg:%{traditional:-lc_old_p}%{!traditional:-lc_p}}"

26
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/convex2.h Normal file
View File

@@ -0,0 +1,26 @@
/* tm.h file for a Convex C2. */
#include "convex.h"
#undef TARGET_DEFAULT
#define TARGET_DEFAULT 2
#define CC1_SPEC "%{mc1:-mnoc2}"
/* Include Posix prototypes unless -ansi. */
#define CPP_SPEC \
"%{mc1:-D__convex_c1__}%{!mc1:-D__convex_c2__} \
-D__NO_INLINE_MATH -D__NO_INLINE_STDLIB \
%{!traditional:-D__stdc__ \
-D_LONGLONG -Ds64_t=long\\ long -Du64_t=unsigned\\ long\\ long} \
%{!ansi:-D_POSIX_SOURCE -D_CONVEX_SOURCE}"
/* Search Posix or else backward-compatible libraries depending
on -traditional. */
#define LIB_SPEC \
"%{mc1:-lC1}%{!mc1:-lC2} \
%{!p:%{!pg:%{traditional:-lc_old}%{!traditional:-lc}}} \
%{p:%{traditional:-lc_old_p}%{!traditional:-lc_p}} \
%{pg:%{traditional:-lc_old_p}%{!traditional:-lc_p}}"

26
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/convex32.h Normal file
View File

@@ -0,0 +1,26 @@
/* tm.h file for a Convex C32xx. */
#include "convex.h"
#undef TARGET_DEFAULT
#define TARGET_DEFAULT 2
#define CC1_SPEC "%{mc1:-mnoc2}"
/* Include Posix prototypes unless -ansi. */
#define CPP_SPEC \
"%{mc1:-D__convex_c1__}%{!mc1:-D__convex_c2__} \
-D__NO_INLINE_MATH -D__NO_INLINE_STDLIB \
%{!traditional:-D__stdc__ \
-D_LONGLONG -Ds64_t=long\\ long -Du64_t=unsigned\\ long\\ long} \
%{!ansi:-D_POSIX_SOURCE -D_CONVEX_SOURCE}"
/* Search Posix or else backward-compatible libraries depending
on -traditional. */
#define LIB_SPEC \
"%{mc1:-lC1}%{!mc1:-lC2} \
%{!p:%{!pg:%{traditional:-lc_old}%{!traditional:-lc}}} \
%{p:%{traditional:-lc_old_p}%{!traditional:-lc_p}} \
%{pg:%{traditional:-lc_old_p}%{!traditional:-lc_p}}"

26
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/convex34.h Normal file
View File

@@ -0,0 +1,26 @@
/* tm.h file for a Convex C34xx. */
#include "convex.h"
#undef TARGET_DEFAULT
#define TARGET_DEFAULT 6
#define CC1_SPEC "%{mc1:-mnoc2}"
/* Include Posix prototypes unless -ansi. */
#define CPP_SPEC \
"%{mc1:-D__convex_c1__}%{!mc1:-D__convex_c2__} \
-D__NO_INLINE_MATH -D__NO_INLINE_STDLIB \
%{!traditional:-D__stdc__ \
-D_LONGLONG -Ds64_t=long\\ long -Du64_t=unsigned\\ long\\ long} \
%{!ansi:-D_POSIX_SOURCE -D_CONVEX_SOURCE}"
/* Search Posix or else backward-compatible libraries depending
on -traditional. */
#define LIB_SPEC \
"%{mc1:-lC1}%{!mc1:-lC2} \
%{!p:%{!pg:%{traditional:-lc_old}%{!traditional:-lc}}} \
%{p:%{traditional:-lc_old_p}%{!traditional:-lc_p}} \
%{pg:%{traditional:-lc_old_p}%{!traditional:-lc_p}}"

26
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/convex38.h Normal file
View File

@@ -0,0 +1,26 @@
/* tm.h file for a Convex C38xx. */
#include "convex.h"
#undef TARGET_DEFAULT
#define TARGET_DEFAULT 012
#define CC1_SPEC "%{mc1:-mnoc2}"
/* Include Posix prototypes unless -ansi. */
#define CPP_SPEC \
"%{mc1:-D__convex_c1__}%{!mc1:-D__convex_c2__} \
-D__NO_INLINE_MATH -D__NO_INLINE_STDLIB \
%{!traditional:-D__stdc__ \
-D_LONGLONG -Ds64_t=long\\ long -Du64_t=unsigned\\ long\\ long} \
%{!ansi:-D_POSIX_SOURCE -D_CONVEX_SOURCE}"
/* Search Posix or else backward-compatible libraries depending
on -traditional. */
#define LIB_SPEC \
"%{mc1:-lC1}%{!mc1:-lC2} \
%{!p:%{!pg:%{traditional:-lc_old}%{!traditional:-lc}}} \
%{p:%{traditional:-lc_old_p}%{!traditional:-lc_p}} \
%{pg:%{traditional:-lc_old_p}%{!traditional:-lc_p}}"

603
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/crds.h Normal file
View File

@@ -0,0 +1,603 @@
/* Definitions of target machine for GNU compiler.
Charles River Data Systems UNiverse/32
Written by Gary E. Miller
bug reports to Gary_Edmunds_Miller@cup.portal.com
Copyright (C) 1987 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#define MOTOROLA /* Use Motorola syntax rather than "MIT" */
#define SGS /* Uses SGS assembler */
#define SGS_SWITCH_TABLES /* Different switch table handling */
#define CRDS /* Charles River Data Systems assembler */
#include "m68k.h"
/* Without STRUCTURE_SIZE_BOUNDARY, we can't ensure that structures are
aligned such that we can correctly extract bitfields from them.
Someone should check whether the usual compiler on the crds machine
provides the equivalent behavior of STRUCTURE_SIZE_BOUNDARY. */
#error This doesn't define STRUCTURE_SIZE_BOUNDARY
/* See m68k.h. 0 means 680[01]0 with no 68881. */
#undef TARGET_DEFAULT
#define TARGET_DEFAULT 0
/* special flags to the unos assembler. */
#undef ASM_SPEC
#define ASM_SPEC "-g"
#undef LIB_SPEC
#define LIB_SPEC "%{!p:%{!pg:-lunos}}%{p:-lc_p}%{pg:-lc_p}"
#undef STARTFILE_SPEC
#define STARTFILE_SPEC \
"%{pg:gcrt0.o%s}%{!pg:%{p:mc68rt0.o%s}%{!p:c68rt0.o%s}}"
/* CC1 spec */
#if 0
/* c.sac only used in _s_call_r() in libunos.a and malloc() in libmalloc.a */
/* so we do not need to bother ! */
#define CC1_SPEC "-fpcc-struct-return"
#endif
/* -O2 for MAX optimization */
#undef CC1_SPEC
#define CC1_SPEC "%{O2:-fstrength-reduce}"
/* cpp has to support a #sccs directive for the /usr/include files */
#define SCCS_DIRECTIVE
/* Make output for SDB. */
/* #define SDB_DEBUGGING_INFO UNOS casm has no debugging :-( */
/* UNOS has vprintf() */
#define HAVE_VPRINTF
/* UNOS need stack probe :-( */
#define HAVE_probe 1
#define gen_probe() gen_rtx(ASM_INPUT, VOIDmode, "tstb -2048(sp)\t;probe\n")
/* use memcpy, memset instead of bcopy, etc. */
#define TARGET_MEM_FUNCTIONS
/* Don't try to define `gcc_compiled.' since the assembler might not
accept symbols with periods and GDB doesn't run on this machine anyway. */
#define ASM_IDENTIFY_GCC(FILE)
/* Define __HAVE_68881__ in preprocessor if -m68881 is specified.
This will control the use of inline 68881 insns in certain macros. */
#undef CPP_SPEC
#define CPP_SPEC "%{m68881:-D__HAVE_68881__}"
/* Names to predefine in the preprocessor for this target machine. */
#undef CPP_PREDEFINES
#define CPP_PREDEFINES "-Dmc68k -DM68000 -Dmc68000 -Dunos -Dunix"
/* Register in which address to store a structure value
is passed to a function. */
/* unos uses ".comm c.sac" returns &c.sac in d0 */
/* make pointer to c.sac ?
#undef STRUCT_VALUE_REGNUM
#define STRUCT_VALUE gen_rtx(MEM, Pmode, gen_rtx( , , ) )
*/
#define EXTRA_SECTIONS in_bss
#define EXTRA_SECTION_FUNCTIONS \
void \
bss_section () \
{ \
if (in_section != in_bss) \
{ \
fprintf (asm_out_file, ".bss\n"); \
in_section = in_bss; \
} \
}
/* Specify how to pad function arguments.
Value should be `upward', `downward' or `none'.
Same as the default, except no padding for large or variable-size args. */
#define FUNCTION_ARG_PADDING(MODE, TYPE) \
(((MODE) == BLKmode \
? ((TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) == INTEGER_CST \
&& int_size_in_bytes (TYPE) < PARM_BOUNDARY / BITS_PER_UNIT) \
: GET_MODE_BITSIZE (MODE) < PARM_BOUNDARY) \
? downward : none)
/* Override part of the obstack macros. */
#define __PTR_TO_INT(P) ((int)(P))
#define __INT_TO_PTR(P) ((char *)(P))
/* Override parts of m68k.h to fit the CRuDS assembler. */
#undef TARGET_VERSION
#define TARGET_VERSION fprintf (stderr, " (68k, CRDS/UNOS)");
/* Specify extra dir to search for include files. */
#define SYSTEM_INCLUDE_DIR "/include"
/* Control the assembler format that we output. */
/* Output at beginning of assembler file. */
#undef ASM_FILE_START
#define ASM_FILE_START(FILE) \
fprintf (FILE, ";#NO_APP\n");
/* Output to assembler file text saying following lines
may contain character constants, extra white space, comments, etc. */
#undef ASM_APP_ON
#define ASM_APP_ON ";#APP\n"
/* Output to assembler file text saying following lines
no longer contain unusual constructs. */
#undef ASM_APP_OFF
#define ASM_APP_OFF ";#NO_APP\n"
/* This is how to output an assembler line defining a `double' constant. */
#undef ASM_OUTPUT_DOUBLE
#define ASM_OUTPUT_DOUBLE(FILE,VALUE) \
do { union { double f; long l[2];} tem; \
tem.f = (VALUE); \
fprintf (FILE, "\t.long 0x%x, 0x%x\n", tem.l[0], tem.l[1]); \
} while (0)
/*unos has no .skip :-( */
#undef ASM_OUTPUT_SKIP
#define ASM_OUTPUT_SKIP(FILE,SIZE) \
fprintf (FILE, "\t. = . + %u\n", (SIZE));
/* This says how to output an assembler line
to define a local common symbol. */
/* should use bss_section instead of data_section but this makes casm die ? */
#undef ASM_OUTPUT_LOCAL
#define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \
{ data_section (); \
if ((SIZE) > 1) fprintf (FILE, "\t.even\n"); \
assemble_name ((FILE), (NAME)); \
fprintf ((FILE), ":\t. = . + %u\n", (ROUNDED));}
/* This is how to output an insn to push a register on the stack.
It need not be very fast code. */
#undef ASM_OUTPUT_REG_PUSH
#define ASM_OUTPUT_REG_PUSH(FILE,REGNO) \
fprintf (FILE, "\tmovel %s,-(sp)\n", reg_names[REGNO])
/* This is how to output an insn to pop a register from the stack.
It need not be very fast code. */
#undef ASM_OUTPUT_REG_POP
#define ASM_OUTPUT_REG_POP(FILE,REGNO) \
fprintf (FILE, "\tmovel (sp)+,%s\n", reg_names[REGNO])
#undef ASM_OUTPUT_ASCII
#define ASM_OUTPUT_ASCII(FILE, P , SIZE) \
{ int i; \
fprintf ((FILE), "\t.ascii \""); \
for (i = 0; i < (SIZE); i++) \
{ \
register int c = (P)[i]; \
if (i != 0 && (i / 200) * 200 == i) \
fprintf ((FILE), "\"\n\t.ascii \""); \
if (c >= ' ' && c < 0177) { \
if (c != '\"' && c != '\\') { \
putc (c, (FILE)); \
continue; \
} \
} \
/* brain dead asm doesn't understand char escapes */ \
fprintf ((FILE), "\"\n\t.byte\t%d\n\t.ascii \"", c); \
} \
fprintf ((FILE), "\"\n"); \
}
/* Change all JBxx to Bxx. Also change all DBRA to DBF.
Also change divs.l, etc., to divs, etc. But don't change divsl.l. */
#define ASM_OUTPUT_OPCODE(FILE, PTR) \
{ if ((PTR)[0] == 'j' && (PTR)[1] == 'b') \
{ ++(PTR); } \
else if ((PTR)[0] == 'd') \
{ \
if (!strncmp ((PTR), "dbra", 4)) \
{ fprintf ((FILE), "dbf"); (PTR) += 4; } \
else if (!strncmp ((PTR), "div", 3) && (PTR)[5] == ' ') \
{ fprintf ((FILE), "div%c", (PTR)[3]); (PTR) += 6; } \
} \
}
/* Print operand X (an rtx) in assembler syntax to file FILE.
CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
For `%' followed by punctuation, CODE is the punctuation and X is null.
On the 68000, we use several CODE characters:
'.' for dot needed in Motorola-style opcode names.
'-' for an operand pushing on the stack:
sp@-, -(sp) or -(%sp) depending on the style of syntax.
'+' for an operand pushing on the stack:
sp@+, (sp)+ or (%sp)+ depending on the style of syntax.
'@' for a reference to the top word on the stack:
sp@, (sp) or (%sp) depending on the style of syntax.
'#' for an immediate operand prefix (# in MIT and Motorola syntax
but & in SGS syntax, $ in unos syntax).
'!' for the fpcr register (used in some float-to-fixed conversions).
'b' for byte insn (no effect, on the Sun; this is for the ISI).
'd' to force memory addressing to be absolute, not relative.
'f' for float insn (print a CONST_DOUBLE as a float rather than in hex)
'w' for FPA insn (print a CONST_DOUBLE as a SunFPA constant rather
than directly). Second part of 'y' below.
'x' for float insn (print a CONST_DOUBLE as a float rather than in hex),
or print pair of registers as rx:ry.
'y' for a FPA insn (print pair of registers as rx:ry). This also outputs
CONST_DOUBLE's as SunFPA constant RAM registers if
possible, so it should not be used except for the SunFPA. */
#undef PRINT_OPERAND_PUNCT_VALID_P
#define PRINT_OPERAND_PUNCT_VALID_P(CODE) \
((CODE) == '.' || (CODE) == '#' || (CODE) == '-' \
|| (CODE) == '+' || (CODE) == '@' || (CODE) == '!')
#undef PRINT_OPERAND
#define PRINT_OPERAND(FILE, X, CODE) \
{ int i; \
if (CODE == '.') ; \
else if (CODE == '#') fprintf (FILE, "$"); \
else if (CODE == '-') fprintf (FILE, "-(sp)"); \
else if (CODE == '+') fprintf (FILE, "(sp)+"); \
else if (CODE == '@') fprintf (FILE, "(sp)"); \
else if (CODE == '!') fprintf (FILE, "fpcr"); \
else if (GET_CODE (X) == REG) \
{ if (REGNO (X) < 16 && (CODE == 'y' || CODE == 'x') && GET_MODE (X) == DFmode) \
fprintf (FILE, "%s:%s", reg_names[REGNO (X)], reg_names[REGNO (X)+1]); \
else \
fprintf (FILE, "%s", reg_names[REGNO (X)]); \
} \
else if (GET_CODE (X) == MEM) \
{ \
output_address (XEXP (X, 0)); \
if (CODE == 'd' && ! TARGET_68020 \
&& CONSTANT_ADDRESS_P (XEXP (X, 0))) \
/* fprintf (FILE, ".l") */; \
} \
else if ((CODE == 'y' || CODE == 'w') \
&& GET_CODE(X) == CONST_DOUBLE \
&& (i = standard_sun_fpa_constant_p (X))) \
fprintf (FILE, "%%%d", i & 0x1ff); \
else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == SFmode) \
{ union { double d; int i[2]; } u; \
union { float f; int i; } u1; \
u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X); \
u1.f = u.d; \
if (CODE == 'f') \
ASM_OUTPUT_FLOAT_OPERAND (FILE, u1.f); \
else \
fprintf (FILE, "$0x%x", u1.i); } \
else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != DImode) \
{ union { double d; int i[2]; } u; \
u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X); \
ASM_OUTPUT_DOUBLE_OPERAND (FILE, u.d); } \
else { putc ('$', FILE); output_addr_const (FILE, X); }}
/* Note that this contains a kludge that knows that the only reason
we have an address (plus (label_ref...) (reg...))
is in the insn before a tablejump, and we know that m68k.md
generates a label LInnn: on such an insn. */
#undef PRINT_OPERAND_ADDRESS
#define PRINT_OPERAND_ADDRESS(FILE, ADDR) \
{ register rtx reg1, reg2, breg, ireg; \
register rtx addr = ADDR; \
rtx offset; \
switch (GET_CODE (addr)) \
{ \
case REG: \
fprintf (FILE, "(%s)", reg_names[REGNO (addr)]); \
break; \
case PRE_DEC: \
fprintf (FILE, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]); \
break; \
case POST_INC: \
fprintf (FILE, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]); \
break; \
case PLUS: \
reg1 = 0; reg2 = 0; \
ireg = 0; breg = 0; \
offset = 0; \
if (CONSTANT_ADDRESS_P (XEXP (addr, 0))) \
{ \
offset = XEXP (addr, 0); \
addr = XEXP (addr, 1); \
} \
else if (CONSTANT_ADDRESS_P (XEXP (addr, 1))) \
{ \
offset = XEXP (addr, 1); \
addr = XEXP (addr, 0); \
} \
if (GET_CODE (addr) != PLUS) ; \
else if (GET_CODE (XEXP (addr, 0)) == SIGN_EXTEND) \
{ \
reg1 = XEXP (addr, 0); \
addr = XEXP (addr, 1); \
} \
else if (GET_CODE (XEXP (addr, 1)) == SIGN_EXTEND) \
{ \
reg1 = XEXP (addr, 1); \
addr = XEXP (addr, 0); \
} \
else if (GET_CODE (XEXP (addr, 0)) == MULT) \
{ \
reg1 = XEXP (addr, 0); \
addr = XEXP (addr, 1); \
} \
else if (GET_CODE (XEXP (addr, 1)) == MULT) \
{ \
reg1 = XEXP (addr, 1); \
addr = XEXP (addr, 0); \
} \
else if (GET_CODE (XEXP (addr, 0)) == REG) \
{ \
reg1 = XEXP (addr, 0); \
addr = XEXP (addr, 1); \
} \
else if (GET_CODE (XEXP (addr, 1)) == REG) \
{ \
reg1 = XEXP (addr, 1); \
addr = XEXP (addr, 0); \
} \
if (GET_CODE (addr) == REG || GET_CODE (addr) == MULT \
|| GET_CODE (addr) == SIGN_EXTEND) \
{ if (reg1 == 0) reg1 = addr; else reg2 = addr; addr = 0; } \
if (offset != 0) { if (addr != 0) abort (); addr = offset; } \
if ((reg1 && (GET_CODE (reg1) == SIGN_EXTEND \
|| GET_CODE (reg1) == MULT)) \
|| (reg2 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg2)))) \
{ breg = reg2; ireg = reg1; } \
else if (reg1 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg1))) \
{ breg = reg1; ireg = reg2; } \
if (ireg != 0 && breg == 0 && GET_CODE (addr) == LABEL_REF) \
{ int scale = 1; \
if (GET_CODE (ireg) == MULT) \
{ scale = INTVAL (XEXP (ireg, 1)); \
ireg = XEXP (ireg, 0); } \
if (GET_CODE (ireg) == SIGN_EXTEND) \
fprintf (FILE, "L%d-LI%d-2(pc,%s.w", \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
reg_names[REGNO (XEXP (ireg, 0))]); \
else \
fprintf (FILE, "L%d-LI%d-2(pc,%s.l", \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
reg_names[REGNO (ireg)]); \
if (scale != 1) fprintf (FILE, ":%d", scale); \
putc (')', FILE); \
break; } \
if (breg != 0 && ireg == 0 && GET_CODE (addr) == LABEL_REF) \
{ fprintf (FILE, "L%d-LI%d-2(pc,%s.l", \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
reg_names[REGNO (breg)]); \
putc (')', FILE); \
break; } \
if (ireg != 0 || breg != 0) \
{ int scale = 1; \
if (breg == 0) \
abort (); \
if (addr && GET_CODE (addr) == LABEL_REF) abort (); \
if (addr != 0) \
output_addr_const (FILE, addr); \
fprintf (FILE, "(%s", reg_names[REGNO (breg)]); \
if (breg != 0 && ireg != 0) \
putc (',', FILE); \
if (ireg != 0 && GET_CODE (ireg) == MULT) \
{ scale = INTVAL (XEXP (ireg, 1)); \
ireg = XEXP (ireg, 0); } \
if (ireg != 0 && GET_CODE (ireg) == SIGN_EXTEND) \
fprintf (FILE, "%s.w", reg_names[REGNO (XEXP (ireg, 0))]); \
else if (ireg != 0) \
fprintf (FILE, "%s.l", reg_names[REGNO (ireg)]); \
if (scale != 1) fprintf (FILE, ":%d", scale); \
putc (')', FILE); \
break; \
} \
else if (reg1 != 0 && GET_CODE (addr) == LABEL_REF) \
{ fprintf (FILE, "L%d-LI%d-2(pc,%s.l)", \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
CODE_LABEL_NUMBER (XEXP (addr, 0)), \
reg_names[REGNO (reg1)]); \
break; } \
default: \
if (GET_CODE (addr) == CONST_INT \
&& INTVAL (addr) < 0x8000 \
&& INTVAL (addr) >= -0x8000) \
fprintf (FILE, "%d", INTVAL (addr)); \
else \
output_addr_const (FILE, addr); \
}}
#define ASM_OUTPUT_SOURCE_FILENAME(FILE, FILENAME) \
fprintf (FILE, "\t; file\t\"%s\"\n", FILENAME)
#define ASM_OUTPUT_SOURCE_LINE(FILE, LINENO) \
fprintf (FILE, "\t; ln\t%d\n", \
(sdb_begin_function_line \
? last_linenum - sdb_begin_function_line : 1))
/* This macro generates the assembly code for function entry.
FILE is a stdio stream to output the code to.
SIZE is an int: how many units of temporary storage to allocate.
Refer to the array `regs_ever_live' to determine which registers
to save; `regs_ever_live[I]' is nonzero if register number I
is ever used in the function. This macro is responsible for
knowing which registers should not be saved even if used. */
/* Note that the order of the bit mask for fmovem is the opposite
of the order for movem! */
#undef FUNCTION_PROLOGUE
#define FUNCTION_PROLOGUE(FILE, SIZE) \
{ register int regno; \
register int mask = 0; \
extern char call_used_regs[]; \
int fsize = ((SIZE) + 3) & -4; \
/* unos stack probe */ \
if ( fsize > 30000 ) { \
fprintf (FILE, "\tmovel sp,a0\n"); \
fprintf (FILE, "\taddl $-%d,a0\n", 2048 + fsize); \
fprintf (FILE, "\ttstb (a0)\n"); \
} else { \
fprintf (FILE, "\ttstb -%d(sp)\n", 2048 + fsize); \
} \
if (frame_pointer_needed) \
{ if (TARGET_68020 || fsize < 0x8000) \
fprintf (FILE, "\tlink a6,$%d\n", -fsize); \
else \
fprintf (FILE, "\tlink a6,$0\n\tsubl $%d,sp\n", fsize); } \
for (regno = 24; regno < 56; regno++) \
if (regs_ever_live[regno] && ! call_used_regs[regno]) \
fprintf(FILE, "\tfpmoved %s, sp@-\n", \
reg_names[regno]); \
for (regno = 16; regno < 24; regno++) \
if (regs_ever_live[regno] && ! call_used_regs[regno]) \
mask |= 1 << (regno - 16); \
if ((mask & 0xff) != 0) \
fprintf (FILE, "\tfmovem $0x%x,-(sp)\n", mask & 0xff); \
mask = 0; \
for (regno = 0; regno < 16; regno++) \
if (regs_ever_live[regno] && ! call_used_regs[regno]) \
mask |= 1 << (15 - regno); \
if (frame_pointer_needed) \
mask &= ~ (1 << (15-FRAME_POINTER_REGNUM)); \
if (exact_log2 (mask) >= 0) \
fprintf (FILE, "\tmovel %s,-(sp)\n", reg_names[15 - exact_log2 (mask)]); \
else if (mask) fprintf (FILE, "\tmovem $0x%x,-(sp)\n", mask); }
/* Must put address in %a0 , not %d0 . -- LGM, 7/15/88 */
/* UNOS ?? */
#undef FUNCTION_PROFILER
#define FUNCTION_PROFILER(FILE, LABEL_NO) \
fprintf (FILE, "\tmovl &LP%%%d,%%a0\n\tjsr mcount\n", (LABEL_NO))
/* This macro generates the assembly code for function exit,
on machines that need it. If FUNCTION_EPILOGUE is not defined
then individual return instructions are generated for each
return statement. Args are same as for FUNCTION_PROLOGUE.
The function epilogue should not depend on the current stack pointer!
It should use the frame pointer only. This is mandatory because
of alloca; we also take advantage of it to omit stack adjustments
before returning. */
#undef FUNCTION_EPILOGUE
#define FUNCTION_EPILOGUE(FILE, SIZE) \
{ register int regno; \
register int mask, fmask; \
register int nregs; \
int offset, foffset, fpoffset; \
extern char call_used_regs[]; \
int fsize = ((SIZE) + 3) & -4; \
int big = 0; \
nregs = 0; fmask = 0; fpoffset = 0; \
for (regno = 24 ; regno < 56 ; regno++) \
if (regs_ever_live[regno] && ! call_used_regs[regno]) \
nregs++; \
fpoffset = nregs*8; \
nregs = 0; \
for (regno = 16; regno < 24; regno++) \
if (regs_ever_live[regno] && ! call_used_regs[regno]) \
{ nregs++; fmask |= 1 << (23 - regno); } \
foffset = fpoffset + nregs * 12; \
nregs = 0; mask = 0; \
if (frame_pointer_needed) regs_ever_live[FRAME_POINTER_REGNUM] = 0; \
for (regno = 0; regno < 16; regno++) \
if (regs_ever_live[regno] && ! call_used_regs[regno]) \
{ nregs++; mask |= 1 << regno; } \
offset = foffset + nregs * 4; \
if (offset + fsize >= 0x8000 \
&& frame_pointer_needed \
&& (mask || fmask || fpoffset)) \
{ fprintf (FILE, "\tmovel $%d,a0\n", -fsize); \
fsize = 0, big = 1; } \
if (exact_log2 (mask) >= 0) { \
if (big) \
fprintf (FILE, "\tmovel -%d(a6,a0.l),%s\n", \
offset + fsize, reg_names[exact_log2 (mask)]); \
else if (! frame_pointer_needed) \
fprintf (FILE, "\tmovel (sp)+,%s\n", \
reg_names[exact_log2 (mask)]); \
else \
fprintf (FILE, "\tmovel -%d(a6),%s\n", \
offset + fsize, reg_names[exact_log2 (mask)]); } \
else if (mask) { \
if (big) \
fprintf (FILE, "\tmovem -%d(a6,a0.l),$0x%x\n", \
offset + fsize, mask); \
else if (! frame_pointer_needed) \
fprintf (FILE, "\tmovem (sp)+,$0x%x\n", mask); \
else \
fprintf (FILE, "\tmovem -%d(a6),$0x%x\n", \
offset + fsize, mask); } \
if (fmask) { \
if (big) \
fprintf (FILE, "\tfmovem -%d(a6,a0.l),$0x%x\n", \
foffset + fsize, fmask); \
else if (! frame_pointer_needed) \
fprintf (FILE, "\tfmovem (sp)+,$0x%x\n", fmask); \
else \
fprintf (FILE, "\tfmovem -%d(a6),$0x%x\n", \
foffset + fsize, fmask); } \
if (fpoffset != 0) \
for (regno = 55; regno >= 24; regno--) \
if (regs_ever_live[regno] && ! call_used_regs[regno]) { \
if (big) \
fprintf(FILE, "\tfpmoved -%d(a6,a0.l), %s\n", \
fpoffset + fsize, reg_names[regno]); \
else if (! frame_pointer_needed) \
fprintf(FILE, "\tfpmoved (sp)+, %s\n", \
reg_names[regno]); \
else \
fprintf(FILE, "\tfpmoved -%d(a6), %s\n", \
fpoffset + fsize, reg_names[regno]); \
fpoffset -= 8; \
} \
if (frame_pointer_needed) \
fprintf (FILE, "\tunlk a6\n"); \
if (current_function_pops_args) \
fprintf (FILE, "\trtd $%d\n", current_function_pops_args); \
else fprintf (FILE, "\trts\n"); }

47
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/ctix.h Normal file
View File

@@ -0,0 +1,47 @@
/* Definitions of target machine for GNU compiler.
Convergent Technologies MiniFrame version,
using GAS and binutils with COFF encapsulation.
Written by Ronald Cole
Because the MiniFrame's C compiler is so completely lobotomized,
bootstrapping this is damn near impossible!
Write to me for information on obtaining the binaries...
bug reports to csusac!unify!rjc@ucdavis.edu
Copyright (C) 1990 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "3b1g.h"
/* Names to predefine in the preprocessor for this target machine. */
#undef CPP_PREDEFINES
#define CPP_PREDEFINES "-Dmc68000 -Dmc68k -Dunix -Dctix"
/* Where to look for robotussinized startfiles. */
#undef STANDARD_STARTFILE_PREFIX
#define STANDARD_STARTFILE_PREFIX "/usr/local/lib/gnu/"
/* Generate calls to the MiniFrame's library (for speed). */
#define DIVSI3_LIBCALL "ldiv"
#define UDIVSI3_LIBCALL "uldiv"
#define MODSI3_LIBCALL "lrem"
#define UMODSI3_LIBCALL "ulrem"
#define MULSI3_LIBCALL "lmul"
#define UMULSI3_LIBCALL "ulmul"

24
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/dec-gosf1.h Normal file
View File

@@ -0,0 +1,24 @@
/* Definitions of target machine for GNU compiler.
DECstation (OSF/1) version with stabs.
Copyright (C) 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Use stabs instead of ECOFF debug format. */
#define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
#include "dec-osf1.h"

51
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/dec-osf1.h Normal file
View File

@@ -0,0 +1,51 @@
/* Definitions of target machine for GNU compiler. DECstation (OSF/1) version.
Copyright (C) 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#define DEC_OSF1
#define CPP_PREDEFINES "-D__ANSI_COMPAT \
-DMIPSEL -DR3000 -DSYSTYPE_BSD -D_SYSTYPE_BSD -Dbsd4_2 -Dhost_mips -Dmips -Dosf -Dunix"
#define LINK_SPEC "\
%{G*} \
%{!mgas: \
%{EL} %{!EL: -EL} \
%{EB: %e-EB not supported} \
%{mips1} %{mips2} %{mips3} %{bestGnum} \
%{shared} %{non_shared} %{call_shared} %{no_archive} %{exact_version} \
%{!shared: %{!non_shared: %{!call_shared: -non_shared}}}}"
#include "decstatn.h"
/* Specify size_t, ptrdiff_t, and wchar_t types. */
#undef SIZE_TYPE
#undef PTRDIFF_TYPE
#undef WCHAR_TYPE
#undef WCHAR_TYPE_SIZE
#define SIZE_TYPE "long unsigned int"
#define PTRDIFF_TYPE "int"
#define WCHAR_TYPE "short unsigned int"
#define WCHAR_TYPE_SIZE SHORT_TYPE_SIZE
/* turn off collect2 COFF support, since ldfcn now has elf declaration */
#undef OBJECT_FORMAT_COFF
#undef MACHINE_TYPE
#define MACHINE_TYPE "DECstation running DEC OSF/1"

175
gnu/gcc-2/gcc-2.3.3.tar/gcc-2.3.3/gcc-2.3.3/config/decrose.h Normal file
View File

@@ -0,0 +1,175 @@
/* Definitions of target machine for GNU compiler.
DECstation (OSF/1 reference port with OSF/rose) version.
Copyright (C) 1991, 1992 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
#define DECSTATION
#define OSF_OS
#define HALF_PIC_DEBUG TARGET_DEBUG_B_MODE
#define HALF_PIC_PREFIX "$Lp."
#include "halfpic.h"
#define WORD_SWITCH_TAKES_ARG(STR) \
(!strcmp (STR, "Tdata") || !strcmp (STR, "Ttext") \
|| !strcmp (STR, "Tbss") || !strcmp (STR, "include") \
|| !strcmp (STR, "imacros") || !strcmp (STR, "aux-info") \
|| !strcmp (STR, "pic-names"))
#define CPP_PREDEFINES "-DOSF -DOSF1 -Dbsd4_2 -DMIPSEL -Dhost_mips -Dmips -Dunix -DR3000 -DSYSTYPE_BSD"
#define ASM_SPEC "\
%{mmips-as: \
%{pipe:%e:-pipe not supported} \
%{EL} %{!EL:-EL} \
%{EB: %e-EB not supported} \
%{!mrnames: %{!.s:-nocpp} %{.s: %{cpp} %{nocpp}}} \
%{mips1} %{mips2} %{mips3} \
%{O:-O2} %{O1:-O2} %{O2:-O2} %{O3:-O3} \
%{g} %{g0} %{g1} %{g2} %{g3} \
%{K} %{Q}} \
%{v*: -v} \
%{G*}"
#ifndef CROSS_COMPILE
#define ASM_FINAL_SPEC "\
%{mmips-as: %{!mno-mips-tfile: \
\n mips-tfile %{v*: -v} %{d*} \
%{K: -I %b.o~} \
%{!K: %{save-temps: -I %b.o~}} \
%{c:%W{o*}%{!o*:-o %b.o}}%{!c:-o %U.o} \
%{.s:%i} %{!.s:%g.s}}}"
#else /* CROSS_COMPILE */
#define ASM_FINAL_SPEC "\
%{mmips-as: %{mmips-tfile: \
\n mips-tfile %{v*: -v} %{d*} \
%{K: -I %b.o~} \
%{!K: %{save-temps: -I %b.o~}} \
%{c:%W{o*}%{!o*:-o %b.o}}%{!c:-o %U.o} \
%{.s:%i} %{!.s:%g.s}}}"
#endif
#define CPP_SPEC "\
%{.S: -D__LANGUAGE_ASSEMBLY__ -D__LANGUAGE_ASSEMBLY %{!ansi:-DLANGUAGE_ASSEMBLY} \
-ULANGUAGE_C -U__LANGUAGE_C__} \
%{.cc: -D__LANGUAGE_C_PLUS_PLUS__ -D__LANGUAGE_C_PLUS_PLUS} \
%{.cxx: -D__LANGUAGE_C_PLUS_PLUS__ -D__LANGUAGE_C_PLUS_PLUS} \
%{.C: -D__LANGUAGE_C_PLUS_PLUS__ -D__LANGUAGE_C_PLUS_PLUS} \
%{.m: -D__LANGUAGE_OBJECTIVE_C__ -D__LANGUAGE_OBJECTIVE_C} \
%{!.S: -D__LANGUAGE_C__ -D__LANGUAGE_C %{!ansi:-DLANGUAGE_C}}"
#define LINK_SPEC "\
%{G*} \
%{mmips-as: \
%{EL} %{!EL: -EL} \
%{EB: %e-EB not supported} \
%{mips1} %{mips2} %{mips3} \
%{bestGnum}} \
%{!mmips-as: \
%{v*: -v} \
%{!noshrlib: %{pic-none: -noshrlib} %{!pic-none: -warn_nopic}} \
%{nostdlib} %{noshrlib} %{glue}}"
#define LIB_SPEC "-lc"
/* Define this macro meaning that `gcc' should find the library
`libgcc.a' by hand, rather than passing the argument `-lgcc' to
tell the linker to do the search. */
#define LINK_LIBGCC_SPECIAL 1
#define STARTFILE_SPEC "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}"
#define MACHINE_TYPE "DECstation with OSF/rose objects"
#ifndef MD_EXEC_PREFIX
#define MD_EXEC_PREFIX "/usr/ccs/gcc/"
#endif
#ifndef MD_STARTFILE_PREFIX
#define MD_STARTFILE_PREFIX "/usr/ccs/lib/"
#endif
/* Turn on -mpic-extern by default. */
#define CC1_SPEC "\
%{O*: %{!mno-gpOPT:%{!mno-gpopt: -mgpopt}}} \
%{gline:%{!g:%{!g0:%{!g1:%{!g2: -g1}}}}} \
%{G*} \
%{pic-none: -mno-half-pic} \
%{pic-lib: -mhalf-pic} \
%{pic-extern: -mhalf-pic} \
%{pic-calls: -mhalf-pic} \
%{pic-names*: -mhalf-pic} \
%{!pic-*: -mhalf-pic}"
/* Specify size_t, ptrdiff_t, and wchar_t types. */
#define SIZE_TYPE "long unsigned int"
#define PTRDIFF_TYPE "int"
#define WCHAR_TYPE "unsigned int"
#define WCHAR_TYPE_SIZE BITS_PER_WORD
#if 0
#define WCHAR_TYPE ((TARGET_WC8) \
? "unsigned char" \
: ((TARGET_WC16) \
? "short unsigned int" \
: "long unsigned int"))
#endif
#define TARGET_DEFAULT MASK_GAS
/* OSF/rose uses stabs, not ECOFF. */
#define PREFERRED_DEBUGGING_TYPE DBX_DEBUG
/* Tell collect that the object format is OSF/rose. */
#define OBJECT_FORMAT_ROSE
/* Tell collect where the appropriate binaries are. */
#define REAL_LD_FILE_NAME "/usr/ccs/gcc/gld"
#define REAL_NM_FILE_NAME "/usr/ccs/bin/nm"
#define REAL_STRIP_FILE_NAME "/usr/ccs/bin/strip"
/* Use atexit for static constructors/destructors, instead of defining
our own exit function. */
#define HAVE_ATEXIT
/* Generate calls to memcpy, etc., not bcopy, etc. */
#define TARGET_MEM_FUNCTIONS
/* A C statement to output assembler commands which will identify
the object file as having been compiled with GNU CC (or another
GNU compiler).
If you don't define this macro, the string `gcc2_compiled.:' is
output. This string is calculated to define a symbol which, on
BSD systems, will never be defined for any other reason. GDB
checks for the presence of this symbol when reading the symbol
table of an executable.
On non-BSD systems, you must arrange communication with GDB in
some other fashion. If GDB is not used on your system, you can
define this macro with an empty body.
On OSF/1, gcc2_compiled. confuses the kernel debugger, so don't
put it out. */
#define ASM_IDENTIFY_GCC(STREAM)
#include "mips.h"

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