d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove files not part of GCC 3.1.

Browse Source
This commit is contained in:
David E. O'Brien 2002-05-12 21:50:48 +00:00
parent 641c89aab9
commit f4603a02f9
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/vendor/gcc/dist/; revision=96480
204 changed files with 0 additions and 80672 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
contrib/gcc/BUGS
View File

@ -1,27 +0,0 @@
If you think you may have found a bug in GCC, please
read the Bugs section of the GCC manual for advice on
(1) how to tell when to report a bug,
(2) where to send your bug report, and
(3) how to write a useful bug report and what information
it needs to have.
There are three ways to read the Bugs section.
(1) In a printed copy of the GCC manual. You can order one from the
Free Software Foundation; see the file ORDERS. But if you don't have
a copy on hand and you think you have found a bug, you shouldn't wait
to get a printed manual; you should read the section right away as
described below.
(2) With Info. Start Emacs, do C-h i to enter Info,
then m gcc RET to get to the GCC manual, then m Bugs RET
to get to the section on bugs. Or use standalone Info in
a like manner. (Standalone Info is part of the Texinfo distribution.)
(3) By hand. Search for the chapter "Reporting Bugs" in gcc.texi, or
cat /usr/local/info/gcc* | more "+/^File: gcc.info, Node: Bugs,"
You may also want to take a look at the GCC FAQ, in which there are
additional instructions for submitting bug reports:
http://www.gnu.org/software/gcc/faq.html#bugreport

1539
contrib/gcc/NEWS
View File

File diff suppressed because it is too large Load Diff

117
contrib/gcc/PROBLEMS
View File

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

449
contrib/gcc/PROJECTS
View File

@ -1,449 +0,0 @@
C++ template friend functions (mmitchell@usa.net)
Haifa scheduler (haifa-sched.c, loop.[ch], unroll.[ch], genattrtab.c):
(contact law@cygnus.com before starting any serious haifa work)
* Fix all the formatting problems. Simple, mindless work.
* Fix/add comments throughout the code. Many of the comments are from
the old scheduler and are out of date and misleading. Many new hunks
of code don't have sufficient comments and documentation. Those which
do have comments need to be rewritten to use complete sentences and
proper formatting.
* Someone needs make one (or more) passes over the scheduler as a whole to
just clean it up. Try to move the machine dependent bits into the target
files where they belong, avoid re-creating functions where or near
equivalents already exist (ie is_conditional_branch and friends), etc., etc.
* Document the new scheduling options. Remove those options which are
not really useful (like reverse scheduling for example). In general
the haifa scheduler adds _way_ too many options. I'm definitely of the
opinion that gcc already has too many -foptions, and haifa doesn't help
that situation.
* Testing and benchmarking. We've converted a few ports to using the
Haifa scheduler (hppa, sparc, ppc, alpha). We need to continue testing
and benchmarking the new scheduler on additional targets.
We need to have some kind of docs for how to best describe a machine to
the haifa scheduler to get good performance. Some existing ports have
been tuned to deal with the old scheduler -- they may need to be tuned
to generate good schedules with haifa.
Improvements to global cse and partial redundancy elimination:
The current implementation of global cse uses partial redundancy elimination
as described in Chow's thesis.
Long term we want to use lazy code motion as the basis for partial redundancy
elimination. lcm will find as many (or more) redunancies *and* it will
place the remaining computations at computationally optimal placement points
within the function. This reduces the number of redundant operations performed
as well as reducing register lifetimes. My experiments have shown that the
cases were the current PRE code hurts performance are greatly helped by using
lazy code motion.
lcm also provides the underlying framework for several additional optimizations
such as shrink wrapping, spill code motion, dead store elimination, and generic
load/store motion (all the other examples are subcases of load/store motion).
It can probably also be used to improve the reg-stack pass of the compiler.
Contact law@cygnus.com if you're interested in working on lazy code motion.
-------------
The old PROJECTS file. Stuff I know has been done has been deleted.
Stuff in progress has a contact name associated with it.
has been
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.
* 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.)
Contact meissner@cygnus.com before starting any work on live range
splitting.
* 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).
This can be modeled as a partial redundancy elimination/lazy code motion
problem. Contact law@cygnus.com before working on dead store elimination
optimizations.
* 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.
Contact law@cygnus.com before working on code hoisting.
* 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

26
contrib/gcc/README
View File

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

144
contrib/gcc/README-bugs
View File

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

574
contrib/gcc/README.DWARF
View File

@ -1,574 +0,0 @@
Notes on the GNU Implementation of DWARF Debugging Information
--------------------------------------------------------------
Last Updated: Sun Jul 17 08:17:42 PDT 1994 by rfg@segfault.us.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 DWARF version 1 specification (in PostScript form) may be
obtained either from me <rfg@netcom.com> or from the main Data General
FTP server. (See below.) The file you are looking at now only describes
known deviations from the 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 and/or DWARF Version 2 specification
from Data General's FTP server, use the following procedure:
---------------------------------------------------------------------------
ftp to machine: "dg-rtp.dg.com" (128.222.1.2).
Log in as "ftp".
cd to "plsig"
get any of the following file you are interested in:
dwarf.1.0.3.ps
dwarf.2.0.0.index.ps
dwarf.2.0.0.ps
---------------------------------------------------------------------------
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 of the DWARF version 2 specification have been adapted to
(and used in) the GNU implementation of DWARF (version 1). In most of
these cases, a DWARF version 2 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 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).
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.
** 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 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 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 "conforming"
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 severely
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.

55
contrib/gcc/README.TRAD
View File

@ -1,55 +0,0 @@
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.)
---------------------------------------------------------------------------

39
contrib/gcc/TESTS.FLUNK
View File

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

54
contrib/gcc/assert.h
View File

@ -1,54 +0,0 @@
/* 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 *)
__attribute__ ((noreturn));
}
#else
extern void __eprintf (const char *, const char *, unsigned, const char *)
__attribute__ ((noreturn));
#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 () __attribute__ ((noreturn)); /* 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

35
contrib/gcc/build-make
View File

@ -1,35 +0,0 @@
# We have to use the cross-compiler we just built to compile it.
CC = gcc -b $(host)
# 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)
# To build the native compiler with the cross compiler, the headers
# for the target are already fixed. And /usr/include is for host, not
# target.
FIXINCLUDES=Makefile.in
# Don't run fixproto either
STMP_FIXPROTO =
# 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

604
contrib/gcc/c-iterate.c
View File

@ -1,604 +0,0 @@
/* Build expressions with type checking for C compiler.
Copyright (C) 1987, 88, 89, 92, 93, 96, 1997, 1998 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* This file is part of the C front end.
It is responsible for implementing iterators,
both their declarations and the expansion of statements using them. */
#include "config.h"
#include "system.h"
#include "tree.h"
#include "c-tree.h"
#include "flags.h"
#include "obstack.h"
#include "rtl.h"
#include "toplev.h"
#include "expr.h"
/*
KEEPING TRACK OF EXPANSIONS
In order to clean out expansions corresponding to statements inside
"{(...)}" constructs we have to keep track of all expansions. The
cleanup is needed when an automatic, or implicit, expansion on
iterator, say X, happens to a statement which contains a {(...)}
form with a statement already expanded on X. In this case we have
to go back and cleanup the inner expansion. This can be further
complicated by the fact that {(...)} can be nested.
To make this cleanup possible, we keep lists of all expansions, and
to make it work for nested constructs, we keep a stack. The list at
the top of the stack (ITER_STACK.CURRENT_LEVEL) corresponds to the
currently parsed level. All expansions of the levels below the
current one are kept in one list whose head is pointed to by
ITER_STACK.SUBLEVEL_FIRST (SUBLEVEL_LAST is there for making merges
easy). The process works as follows:
-- On "({" a new node is added to the stack by PUSH_ITERATOR_STACK.
The sublevel list is not changed at this point.
-- On "})" the list for the current level is appended to the sublevel
list.
-- On ";" sublevel lists are appended to the current level lists.
The reason is this: if they have not been superseded by the
expansion at the current level, they still might be
superseded later by the expansion on the higher level.
The levels do not have to distinguish levels below, so we
can merge the lists together. */
struct ixpansion
{
tree ixdecl; /* Iterator decl */
rtx ixprologue_start; /* First insn of epilogue. NULL means */
/* explicit (FOR) expansion*/
rtx ixprologue_end;
rtx ixepilogue_start;
rtx ixepilogue_end;
struct ixpansion *next; /* Next in the list */
};
struct iter_stack_node
{
struct ixpansion *first; /* Head of list of ixpansions */
struct ixpansion *last; /* Last node in list of ixpansions */
struct iter_stack_node *next; /* Next level iterator stack node */
};
struct iter_stack_node *iter_stack;
struct iter_stack_node sublevel_ixpansions;
/* A special obstack, and a pointer to the start of
all the data in it (so we can free everything easily). */
static struct obstack ixp_obstack;
static char *ixp_firstobj;
/* During collect_iterators, a list of SAVE_EXPRs already scanned. */
static tree save_exprs;
static void expand_stmt_with_iterators_1 PROTO((tree, tree));
static tree collect_iterators PROTO((tree, tree));
static void iterator_loop_prologue PROTO((tree, rtx *, rtx *));
static void iterator_loop_epilogue PROTO((tree, rtx *, rtx *));
static int top_level_ixpansion_p PROTO((void));
static void isn_append PROTO((struct iter_stack_node *,
struct iter_stack_node *));
static void istack_sublevel_to_current PROTO((void));
static void add_ixpansion PROTO((tree, rtx, rtx, rtx, rtx));
static void delete_ixpansion PROTO((tree));
/* Initialize our obstack once per compilation. */
void
init_iterators ()
{
gcc_obstack_init (&ixp_obstack);
ixp_firstobj = (char *) obstack_alloc (&ixp_obstack, 0);
}
/* Handle the start of an explicit `for' loop for iterator IDECL. */
void
iterator_for_loop_start (idecl)
tree idecl;
{
ITERATOR_BOUND_P (idecl) = 1;
add_ixpansion (idecl, 0, 0, 0, 0);
iterator_loop_prologue (idecl, 0, 0);
}
/* Handle the end of an explicit `for' loop for iterator IDECL. */
void
iterator_for_loop_end (idecl)
tree idecl;
{
iterator_loop_epilogue (idecl, 0, 0);
ITERATOR_BOUND_P (idecl) = 0;
}
/*
ITERATOR RTL EXPANSIONS
Expanding simple statements with iterators is straightforward:
collect the list of all free iterators in the statement, and
generate a loop for each of them.
An iterator is "free" if it has not been "bound" by a FOR
operator. The DECL_RTL of the iterator is the loop counter. */
/* Expand a statement STMT, possibly containing iterator usage, into RTL. */
void
iterator_expand (stmt)
tree stmt;
{
tree iter_list;
save_exprs = NULL_TREE;
iter_list = collect_iterators (stmt, NULL_TREE);
expand_stmt_with_iterators_1 (stmt, iter_list);
istack_sublevel_to_current ();
}
static void
expand_stmt_with_iterators_1 (stmt, iter_list)
tree stmt, iter_list;
{
if (iter_list == 0)
expand_expr_stmt (stmt);
else
{
tree current_iterator = TREE_VALUE (iter_list);
tree iter_list_tail = TREE_CHAIN (iter_list);
rtx p_start, p_end, e_start, e_end;
iterator_loop_prologue (current_iterator, &p_start, &p_end);
expand_stmt_with_iterators_1 (stmt, iter_list_tail);
iterator_loop_epilogue (current_iterator, &e_start, &e_end);
/** Delete all inner expansions based on current_iterator **/
/** before adding the outer one. **/
delete_ixpansion (current_iterator);
add_ixpansion (current_iterator, p_start, p_end, e_start, e_end);
}
}
/* Return a list containing all the free (i.e. not bound by a
containing `for' statement) iterators mentioned in EXP, plus those
in LIST. Do not add duplicate entries to the list. */
static tree
collect_iterators (exp, list)
tree exp, list;
{
if (exp == 0) return list;
switch (TREE_CODE (exp))
{
case VAR_DECL:
if (! ITERATOR_P (exp) || ITERATOR_BOUND_P (exp))
return list;
if (value_member (exp, list))
return list;
return tree_cons (NULL_TREE, exp, list);
case TREE_LIST:
{
tree tail;
for (tail = exp; tail; tail = TREE_CHAIN (tail))
list = collect_iterators (TREE_VALUE (tail), list);
return list;
}
case SAVE_EXPR:
/* In each scan, scan a given save_expr only once. */
if (value_member (exp, save_exprs))
return list;
save_exprs = tree_cons (NULL_TREE, exp, save_exprs);
return collect_iterators (TREE_OPERAND (exp, 0), list);
/* we do not automatically iterate blocks -- one must */
/* use the FOR construct to do that */
case BLOCK:
return list;
default:
switch (TREE_CODE_CLASS (TREE_CODE (exp)))
{
case '1':
return collect_iterators (TREE_OPERAND (exp, 0), list);
case '2':
case '<':
return collect_iterators (TREE_OPERAND (exp, 0),
collect_iterators (TREE_OPERAND (exp, 1),
list));
case 'e':
case 'r':
{
int num_args = tree_code_length[(int) TREE_CODE (exp)];
int i;
/* Some tree codes have RTL, not trees, as operands. */
switch (TREE_CODE (exp))
{
case CALL_EXPR:
num_args = 2;
break;
case METHOD_CALL_EXPR:
num_args = 3;
break;
case WITH_CLEANUP_EXPR:
num_args = 1;
break;
case RTL_EXPR:
return list;
default:
break;
}
for (i = 0; i < num_args; i++)
list = collect_iterators (TREE_OPERAND (exp, i), list);
return list;
}
default:
return list;
}
}
}
/* Emit rtl for the start of a loop for iterator IDECL.
If necessary, create loop counter rtx and store it as DECL_RTL of IDECL.
The prologue normally starts and ends with notes, which are returned
by this function in *START_NOTE and *END_NODE.
If START_NOTE and END_NODE are 0, we don't make those notes. */
static void
iterator_loop_prologue (idecl, start_note, end_note)
tree idecl;
rtx *start_note, *end_note;
{
tree expr;
/* Force the save_expr in DECL_INITIAL to be calculated
if it hasn't been calculated yet. */
expand_expr (DECL_INITIAL (idecl), const0_rtx, VOIDmode,
EXPAND_NORMAL);
if (DECL_RTL (idecl) == 0)
expand_decl (idecl);
if (start_note)
*start_note = emit_note (0, NOTE_INSN_DELETED);
/* Initialize counter. */
expr = build (MODIFY_EXPR, TREE_TYPE (idecl), idecl, integer_zero_node);
TREE_SIDE_EFFECTS (expr) = 1;
expand_expr (expr, const0_rtx, VOIDmode, EXPAND_NORMAL);
expand_start_loop_continue_elsewhere (1);
ITERATOR_BOUND_P (idecl) = 1;
if (end_note)
*end_note = emit_note (0, NOTE_INSN_DELETED);
}
/* Similar to the previous function, but for the end of the loop.
DECL_RTL is zeroed unless we are inside "({...})". The reason for that is
described below.
When we create two (or more) loops based on the same IDECL, and
both inside the same "({...})" construct, we must be prepared to
delete both of the loops and create a single one on the level
above, i.e. enclosing the "({...})". The new loop has to use the
same counter rtl because the references to the iterator decl
(IDECL) have already been expanded as references to the counter
rtl.
It is incorrect to use the same counter reg in different functions,
and it is desirable to use different counters in disjoint loops
when we know there's no need to combine them (because then they can
get allocated separately). */
static void
iterator_loop_epilogue (idecl, start_note, end_note)
tree idecl;
rtx *start_note, *end_note;
{
tree test, incr;
if (start_note)
*start_note = emit_note (0, NOTE_INSN_DELETED);
expand_loop_continue_here ();
incr = build_binary_op (PLUS_EXPR, idecl, integer_one_node, 0);
incr = build (MODIFY_EXPR, TREE_TYPE (idecl), idecl, incr);
TREE_SIDE_EFFECTS (incr) = 1;
expand_expr (incr, const0_rtx, VOIDmode, EXPAND_NORMAL);
test = build_binary_op (LT_EXPR, idecl, DECL_INITIAL (idecl), 0);
expand_exit_loop_if_false (0, test);
expand_end_loop ();
ITERATOR_BOUND_P (idecl) = 0;
/* we can reset rtl since there is not chance that this expansion */
/* would be superseded by a higher level one */
/* but don't do this if the decl is static, since we need to share */
/* the same decl in that case. */
if (top_level_ixpansion_p () && ! TREE_STATIC (idecl))
DECL_RTL (idecl) = 0;
if (end_note)
*end_note = emit_note (0, NOTE_INSN_DELETED);
}
/* Return true if we are not currently inside a "({...})" construct. */
static int
top_level_ixpansion_p ()
{
return iter_stack == 0;
}
/* Given two chains of iter_stack_nodes,
append the nodes in X into Y. */
static void
isn_append (x, y)
struct iter_stack_node *x, *y;
{
if (x->first == 0)
return;
if (y->first == 0)
{
y->first = x->first;
y->last = x->last;
}
else
{
y->last->next = x->first;
y->last = x->last;
}
}
/** Make X empty **/
#define ISN_ZERO(X) (X).first=(X).last=0
/* Move the ixpansions in sublevel_ixpansions into the current
node on the iter_stack, or discard them if the iter_stack is empty.
We do this at the end of a statement. */
static void
istack_sublevel_to_current ()
{
/* At the top level we can throw away sublevel's expansions **/
/* because there is nobody above us to ask for a cleanup **/
if (iter_stack != 0)
/** Merging with empty sublevel list is a no-op **/
if (sublevel_ixpansions.last)
isn_append (&sublevel_ixpansions, iter_stack);
if (iter_stack == 0)
obstack_free (&ixp_obstack, ixp_firstobj);
ISN_ZERO (sublevel_ixpansions);
}
/* Push a new node on the iter_stack, when we enter a ({...}). */
void
push_iterator_stack ()
{
struct iter_stack_node *new_top
= (struct iter_stack_node *)
obstack_alloc (&ixp_obstack, sizeof (struct iter_stack_node));
new_top->first = 0;
new_top->last = 0;
new_top->next = iter_stack;
iter_stack = new_top;
}
/* Pop iter_stack, moving the ixpansions in the node being popped
into sublevel_ixpansions. */
void
pop_iterator_stack ()
{
if (iter_stack == 0)
abort ();
isn_append (iter_stack, &sublevel_ixpansions);
/** Pop current level node: */
iter_stack = iter_stack->next;
}
/* Record an iterator expansion ("ixpansion") for IDECL.
The remaining parameters are the notes in the loop entry
and exit rtl. */
static void
add_ixpansion (idecl, pro_start, pro_end, epi_start, epi_end)
tree idecl;
rtx pro_start, pro_end, epi_start, epi_end;
{
struct ixpansion *newix;
/* Do nothing if we are not inside "({...})",
as in that case this expansion can't need subsequent RTL modification. */
if (iter_stack == 0)
return;
newix = (struct ixpansion *) obstack_alloc (&ixp_obstack,
sizeof (struct ixpansion));
newix->ixdecl = idecl;
newix->ixprologue_start = pro_start;
newix->ixprologue_end = pro_end;
newix->ixepilogue_start = epi_start;
newix->ixepilogue_end = epi_end;
newix->next = iter_stack->first;
iter_stack->first = newix;
if (iter_stack->last == 0)
iter_stack->last = newix;
}
/* Delete the RTL for all ixpansions for iterator IDECL
in our sublevels. We do this when we make a larger
containing expansion for IDECL. */
static void
delete_ixpansion (idecl)
tree idecl;
{
struct ixpansion *previx = 0, *ix;
for (ix = sublevel_ixpansions.first; ix; ix = ix->next)
if (ix->ixdecl == idecl)
{
/** zero means that this is a mark for FOR -- **/
/** we do not delete anything, just issue an error. **/
if (ix->ixprologue_start == 0)
error_with_decl (idecl,
"`for (%s)' appears within implicit iteration");
else
{
rtx insn;
/* We delete all insns, including notes because leaving loop */
/* notes and barriers produced by iterator expansion would */
/* be misleading to other phases */
for (insn = NEXT_INSN (ix->ixprologue_start);
insn != ix->ixprologue_end;
insn = NEXT_INSN (insn))
delete_insn (insn);
for (insn = NEXT_INSN (ix->ixepilogue_start);
insn != ix->ixepilogue_end;
insn = NEXT_INSN (insn))
delete_insn (insn);
}
/* Delete this ixpansion from sublevel_ixpansions. */
if (previx)
previx->next = ix->next;
else
sublevel_ixpansions.first = ix->next;
if (sublevel_ixpansions.last == ix)
sublevel_ixpansions.last = previx;
}
else
previx = ix;
}
#ifdef DEBUG_ITERATORS
/* The functions below are for use from source level debugger.
They print short forms of iterator lists and the iterator stack. */
/* Print the name of the iterator D. */
void
prdecl (d)
tree d;
{
if (d)
{
if (TREE_CODE (d) == VAR_DECL)
{
tree tname = DECL_NAME (d);
char *dname = IDENTIFIER_POINTER (tname);
fprintf (stderr, dname);
}
else
fprintf (stderr, "<<?>>");
}
else
fprintf (stderr, "<<0>>");
}
/* Print Iterator List -- names only */
tree
pil (head)
tree head;
{
tree current, next;
for (current = head; current; current = next)
{
tree node = TREE_VALUE (current);
prdecl (node);
next = TREE_CHAIN (current);
if (next) fprintf (stderr, ",");
}
fprintf (stderr, "\n");
}
/* Print IXpansion List */
struct ixpansion *
pixl (head)
struct ixpansion *head;
{
struct ixpansion *current, *next;
fprintf (stderr, "> ");
if (head == 0)
fprintf (stderr, "(empty)");
for (current=head; current; current = next)
{
tree node = current->ixdecl;
prdecl (node);
next = current->next;
if (next)
fprintf (stderr, ",");
}
fprintf (stderr, "\n");
return head;
}
/* Print Iterator Stack. */
void
pis ()
{
struct iter_stack_node *stack_node;
fprintf (stderr, "--SubLevel: ");
pixl (sublevel_ixpansions.first);
fprintf (stderr, "--Stack:--\n");
for (stack_node = iter_stack;
stack_node;
stack_node = stack_node->next)
pixl (stack_node->first);
}
#endif /* DEBUG_ITERATORS */

88
contrib/gcc/c-parse.gperf
View File

@ -1,88 +0,0 @@
%{
/* Command-line: gperf -L KR-C -F ', 0, 0' -p -j1 -i 1 -g -o -t -N is_reserved_word -k1,3,$ c-parse.gperf */
%}
struct resword { const char *name; short token; enum rid rid; };
%%
@class, CLASS, NORID
@compatibility_alias, ALIAS, NORID
@defs, DEFS, NORID
@encode, ENCODE, NORID
@end, END, NORID
@implementation, IMPLEMENTATION, NORID
@interface, INTERFACE, NORID
@private, PRIVATE, NORID
@protected, PROTECTED, NORID
@protocol, PROTOCOL, NORID
@public, PUBLIC, NORID
@selector, SELECTOR, NORID
__alignof, ALIGNOF, NORID
__alignof__, ALIGNOF, NORID
__asm, ASM_KEYWORD, NORID
__asm__, ASM_KEYWORD, NORID
__attribute, ATTRIBUTE, NORID
__attribute__, ATTRIBUTE, NORID
__complex, TYPESPEC, RID_COMPLEX
__complex__, TYPESPEC, RID_COMPLEX
__const, TYPE_QUAL, RID_CONST
__const__, TYPE_QUAL, RID_CONST
__extension__, EXTENSION, NORID
__imag, IMAGPART, NORID
__imag__, IMAGPART, NORID
__inline, SCSPEC, RID_INLINE
__inline__, SCSPEC, RID_INLINE
__iterator, SCSPEC, RID_ITERATOR
__iterator__, SCSPEC, RID_ITERATOR
__label__, LABEL, NORID
__real, REALPART, NORID
__real__, REALPART, NORID
__restrict, TYPE_QUAL, RID_RESTRICT
__restrict__, TYPE_QUAL, RID_RESTRICT
__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
bycopy, TYPE_QUAL, RID_BYCOPY
byref, TYPE_QUAL, RID_BYREF
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
id, OBJECTNAME, RID_ID
if, IF, NORID
in, TYPE_QUAL, RID_IN
inout, TYPE_QUAL, RID_INOUT
inline, SCSPEC, RID_INLINE
int, TYPESPEC, RID_INT
long, TYPESPEC, RID_LONG
oneway, TYPE_QUAL, RID_ONEWAY
out, TYPE_QUAL, RID_OUT
register, SCSPEC, RID_REGISTER
restrict, TYPE_QUAL, RID_RESTRICT
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

11136
contrib/gcc/cccp.c
View File

File diff suppressed because it is too large Load Diff

1222
contrib/gcc/cexp.y
View File

File diff suppressed because it is too large Load Diff

32
contrib/gcc/config/alpha/netbsd-elf.h
View File

@ -1,32 +0,0 @@
/* Definitions of target machine for GNU compiler
for Alpha NetBSD systems using ELF.
Copyright (C) 1998 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#undef TARGET_VERSION
#define TARGET_VERSION fprintf (stderr, " (Alpha NetBSD/ELF)");
#undef SUB_CPP_PREDEFINES
#define SUB_CPP_PREDEFINES "-D__ELF__"
#undef SUBTARGET_EXTRA_SPECS
#define SUBTARGET_EXTRA_SPECS \
{ "elf_dynamic_linker", ELF_DYNAMIC_LINKER },
#define ELF_DYNAMIC_LINKER "/usr/libexec/ld.elf_so"

9
contrib/gcc/config/alpha/t-crtbe
View File

@ -1,9 +0,0 @@
# Effectively disable the crtbegin/end rules using crtstuff.c
T = disable
# Assemble startup files.
crtbegin.o: $(srcdir)/config/alpha/crtbegin.asm $(GCC_PASSES)
$(GCC_FOR_TARGET) -c -o crtbegin.o -x assembler $(srcdir)/config/alpha/crtbegin.asm
crtend.o: $(srcdir)/config/alpha/crtend.asm $(GCC_PASSES)
$(GCC_FOR_TARGET) -c -o crtend.o -x assembler $(srcdir)/config/alpha/crtend.asm

22
contrib/gcc/config/alpha/vms-tramp.asm
View File

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

2
contrib/gcc/config/alpha/x-alpha
View File

@ -1,2 +0,0 @@
CLIB=-lmld
EXTRA_HEADERS = $(srcdir)/config/alpha/va_list.h

76
contrib/gcc/config/alpha/xm-alpha.h
View File

@ -1,76 +0,0 @@
/* Configuration for GNU C-compiler for DEC Alpha.
Copyright (C) 1990, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
Contributed by Richard Kenner (kenner@vlsi1.ultra.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, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* #defines that need visibility everywhere. */
#define FALSE 0
#define TRUE 1
/* This describes the machine the compiler is hosted on. */
#define HOST_BITS_PER_CHAR 8
#define HOST_BITS_PER_SHORT 16
#define HOST_BITS_PER_INT 32
#define HOST_BITS_PER_LONG 64
#define HOST_BITS_PER_LONGLONG 64
/* #define HOST_WORDS_BIG_ENDIAN */
/* target machine dependencies.
tm.h is a symbolic link to the actual target specific file. */
#include "tm.h"
/* Arguments to use with `exit'. */
#define SUCCESS_EXIT_CODE 0
#define FATAL_EXIT_CODE 33
/* If compiled with GNU C, use the builtin alloca. */
#ifndef alloca
#if defined(__GNUC__) && !defined(USE_C_ALLOCA)
#define alloca __builtin_alloca
#else
#if !defined(_WIN32) && !defined(USE_C_ALLOCA) && !defined(OPEN_VMS) && !defined(__INTERIX)
#include <alloca.h>
#else
extern void *alloca ();
#endif
#endif
#endif
/* The host compiler has problems with enum bitfields since it makes
them signed so we can't fit all our codes in. */
#ifndef __GNUC__
#define ONLY_INT_FIELDS
#endif
/* Declare some functions needed for this machine. We don't want to
include these in the sources since other machines might define them
differently. */
extern void *malloc (), *realloc (), *calloc ();
#ifndef inhibit_libc
#include "string.h"
#endif
/* OSF/1 is POSIX.1 compliant. */
#define POSIX

23
contrib/gcc/config/alpha/xm-openbsd.h
View File

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

38
contrib/gcc/config/i386/config-nt.sed
View File

@ -1,38 +0,0 @@
/^Makefile/,/^ rm -f config.run/d
s/rm -f/del/
s/|| cp/|| copy/
/^config.status/,/ fi/d
s/config.status//g
s/\/dev\/null/NUL/g
s/$(srcdir)\/c-parse/c-parse/g
s/$(srcdir)\/c-gperf/c-gperf/g
/^multilib.h/ s/multilib/not-multilib/
/^target=/ c\
target=winnt3.5
/^xmake_file=/ d
/^tmake_file=/ d
/^out_file/ c\
out_file=config/i386/i386.c
/^out_object_file/ c\
out_object_file=i386.obj
/^md_file/ c\
md_file=config/i386/i386.md
/^tm_file/ c\
tm_file=config/i386/win-nt.h
/^build_xm_file/ c\
build_xm_file=config/i386/xm-winnt.h
/^host_xm_file/ c\
host_xm_file=config/i386/xm-winnt.h
/^####target/ i\
CC = cl \
CLIB = libc.lib kernel32.lib \
CFLAGS = -Di386 -DWIN32 -D_WIN32 -D_M_IX86=300 -D_X86_=1 \\\
-DALMOST_STDC -D_MSC_VER=800 \
LDFLAGS = -align:0x1000 -subsystem:console -entry:mainCRTStartup \\\
-stack:1000000,1000 \
\
EXTRA_OBJS=winnt.obj \
winnt.obj: $(srcdir)/config/i386/winnt.c \
\ $(CC) $(CFLAGS) \\\
\ -I. -I$(srcdir) -I$(srcdir)/config -c $(srcdir)/config/i386/winnt.c \

192
contrib/gcc/config/i386/dgux.c
View File

@ -1,192 +0,0 @@
/* Subroutines for GNU compiler for Intel 80x86 running DG/ux
Copyright (C) 1993, 1995, 1997 Free Software Foundation, Inc.
Currently maintained by (gcc@dg-rtp.dg.com)
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <time.h>
#include "i386/i386.c"
extern char *version_string;
struct option
{
char *string;
int *variable;
int on_value;
char *description;
};
static int
output_option (file, sep, type, name, indent, pos, max)
FILE *file;
char *sep;
char *type;
char *name;
char *indent;
int pos;
int max;
{
if (strlen (sep) + strlen (type) + strlen (name) + pos > max)
{
fprintf (file, indent);
return fprintf (file, "%s%s", type, name);
}
return pos + fprintf (file, "%s%s%s", sep, type, name);
}
static struct { char *name; int value; } m_options[] = TARGET_SWITCHES;
static void
output_options (file, f_options, f_len, W_options, W_len,
pos, max, sep, indent, term)
FILE *file;
struct option *f_options;
struct option *W_options;
int f_len, W_len;
int pos;
int max;
char *indent;
char *term;
{
register int j;
if (optimize)
pos = output_option (file, sep, "-O", "", indent, pos, max);
if (write_symbols != NO_DEBUG)
pos = output_option (file, sep, "-g", "", indent, pos, max);
/* if (flag_traditional)
pos = output_option (file, sep, "-traditional", "", indent, pos, max);*/
if (profile_flag)
pos = output_option (file, sep, "-p", "", indent, pos, max);
if (profile_block_flag)
pos = output_option (file, sep, "-a", "", indent, pos, max);
for (j = 0; j < f_len; j++)
if (*f_options[j].variable == f_options[j].on_value)
pos = output_option (file, sep, "-f", f_options[j].string,
indent, pos, max);
for (j = 0; j < W_len; j++)
if (*W_options[j].variable == W_options[j].on_value)
pos = output_option (file, sep, "-W", W_options[j].string,
indent, pos, max);
for (j = 0; j < sizeof m_options / sizeof m_options[0]; j++)
if (m_options[j].name[0] != '\0'
&& m_options[j].value > 0
&& ((m_options[j].value & target_flags)
== m_options[j].value))
pos = output_option (file, sep, "-m", m_options[j].name,
indent, pos, max);
pos = output_option (file, sep, "-mcpu=", ix86_cpu_string, indent, pos, max);
pos = output_option (file, sep, "-march=", ix86_arch_string, indent, pos, max);
fprintf (file, term);
}
/* Output to FILE the start of the assembler file. */
void
output_file_start (file, f_options, f_len, W_options, W_len)
FILE *file;
struct option *f_options;
struct option *W_options;
int f_len, W_len;
{
register int pos;
output_file_directive (file, main_input_filename);
fprintf (file, "\t.version\t\"01.01\"\n"); \
/* Switch to the data section so that the coffsem symbol and the
gcc2_compiled. symbol aren't in the text section. */
data_section ();
pos = fprintf (file, "\n// cc1 (%s) arguments:", VERSION_STRING);
output_options (file, f_options, f_len, W_options, W_len,
pos, 75, " ", "\n// ", "\n\n");
#ifdef TARGET_IDENTIFY_REVISION
if (TARGET_IDENTIFY_REVISION)
{
char indent[256];
time_t now = time ((time_t *)0);
sprintf (indent, "]\"\n\t%s\t \"@(#)%s [", IDENT_ASM_OP, main_input_filename);
fprintf (file, indent+3);
pos = fprintf (file, "gcc %s, %.24s,", VERSION_STRING, ctime (&now));
output_options (file, f_options, f_len, W_options, W_len,
pos, 150 - strlen (indent), " ", indent, "]\"\n\n");
}
#endif /* TARGET_IDENTIFY_REVISION */
}
#ifndef CROSS_COMPILE
#if defined (_abort_aux)
/* Debugging aid to be registered via `atexit'. See the definition
of abort in dgux.h. */
void
abort_aux ()
{
extern int insn_;
extern char * file_;
extern int line_;
static int done;
rtx line_note;
if (done++)
return;
if (file_ || line_)
{
if (write_symbols != NO_DEBUG)
{
for (line_note = (rtx) insn_ ; line_note != 0 ; line_note = PREV_INSN (line_note))
if (GET_CODE (line_note) == NOTE && NOTE_LINE_NUMBER (line_note) > 0)
break;
if (line_note != 0)
{
error_with_file_and_line (NOTE_SOURCE_FILE (line_note),
NOTE_LINE_NUMBER (line_note),
"Internal gcc abort from %s:%d",
file_ ? file_ : "<nofile>", line_);
if (insn_ && file_ && strcmp (file_, "toplev.c"))
{
error_with_file_and_line (NOTE_SOURCE_FILE (line_note),
NOTE_LINE_NUMBER (line_note),
"The local variable `insn' has the value:", 0);
debug_rtx ((rtx) insn_);
}
}
}
if (write_symbols == NO_DEBUG || line_note == 0)
{
error ("Internal gcc abort from %s:%d",
file_ ? file_ : "<nofile>", line_);
if (insn_ && file_ && strcmp (file_, "toplev.c"))
{
error ("The local variable `insn' has the value:", 0);
debug_rtx ((rtx) insn_);
}
}
}
}
#endif
#endif

76
contrib/gcc/config/i386/os2.h
View File

@ -1,76 +0,0 @@
/* Definitions of target machine for GNU compiler
for an Intel i386 or later processor running OS/2 2.x.
Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
Contributed by Samuel Figueroa (figueroa@cs.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, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#ifndef DEFAULT_TARGET_MACHINE
#define DEFAULT_TARGET_MACHINE "i386-os2"
#endif
#ifndef LINK_SPEC
#define LINK_SPEC "/st:1048576/pm:vio/noi/a:16/e/bas:65536/nol"
#endif
#ifndef LIB_SPEC
#define LIB_SPEC "libgcc libc"
#endif
#ifndef STARTFILE_SPEC
#define STARTFILE_SPEC "libcrt.lib"
#endif
#ifndef MD_EXEC_PREFIX
#define MD_EXEC_PREFIX "\\gcc\\bin\\"
#endif
#ifndef STANDARD_STARTFILE_PREFIX
#define STANDARD_STARTFILE_PREFIX "\\gcc\\lib\\"
#endif
#ifndef LOCAL_INCLUDE_DIR
#define LOCAL_INCLUDE_DIR "\\gcc\\include"
#endif
#define YES_UNDERSCORES
#include "i386/gstabs.h"
#define USE_COLLECT
#define BIGGEST_FIELD_ALIGNMENT \
(maximum_field_alignment ? maximum_field_alignment : 32)
extern int maximum_field_alignment;
#undef PCC_BITFIELD_TYPE_MATTERS
#define PCC_BITFIELD_TYPE_MATTERS (maximum_field_alignment == 0)
/* Define this macro if it is advisable to hold scalars in registers
in a wider mode than that declared by the program. In such cases,
the value is constrained to be within the bounds of the declared
type, but kept valid in the wider mode. The signedness of the
extension may differ from that of the type. */
#define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \
if (GET_MODE_CLASS (MODE) == MODE_INT \
&& GET_MODE_SIZE (MODE) < UNITS_PER_WORD) \
(MODE) = SImode;
/* Define this if function arguments should also be promoted using the above
procedure. */
#define PROMOTE_FUNCTION_ARGS
/* Likewise, if the function return value is promoted. */
#define PROMOTE_FUNCTION_RETURN

98
contrib/gcc/config/i386/perform.h
View File

@ -1,98 +0,0 @@
/* Definitions for AT&T assembler syntax for the Intel 80386.
Copyright (C) 1993 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* Defines to be able to build libgcc.a with GCC. */
/* It might seem that these are not important, since gcc 2 will never
call libgcc for these functions. But programs might be linked with
code compiled by gcc 1, and then these will be used. */
/* The arg names used to be a and b, but `a' appears inside strings
and that confuses non-ANSI cpp. */
#define perform_udivsi3(arg0,arg1) \
{ \
register int dx asm("dx"); \
register int ax asm("ax"); \
\
dx = 0; \
ax = arg0; \
asm ("divl %3" : "=a" (ax), "=d" (dx) : "a" (ax), "g" (arg1), "d" (dx)); \
return ax; \
}
#define perform_divsi3(arg0,arg1) \
{ \
register int dx asm("dx"); \
register int ax asm("ax"); \
register int cx asm("cx"); \
\
ax = arg0; \
cx = arg1; \
asm ("cltd\n\tidivl %3" : "=a" (ax), "=&d" (dx) : "a" (ax), "c" (cx)); \
return ax; \
}
#define perform_umodsi3(arg0,arg1) \
{ \
register int dx asm("dx"); \
register int ax asm("ax"); \
\
dx = 0; \
ax = arg0; \
asm ("divl %3" : "=a" (ax), "=d" (dx) : "a" (ax), "g" (arg1), "d" (dx)); \
return dx; \
}
#define perform_modsi3(arg0,arg1) \
{ \
register int dx asm("dx"); \
register int ax asm("ax"); \
register int cx asm("cx"); \
\
ax = arg0; \
cx = arg1; \
asm ("cltd\n\tidivl %3" : "=a" (ax), "=&d" (dx) : "a" (ax), "c" (cx)); \
return dx; \
}
#define perform_fixdfsi(arg0) \
{ \
auto unsigned short ostatus; \
auto unsigned short nstatus; \
auto int ret; \
auto double tmp; \
\
&ostatus; /* guarantee these land in memory */ \
&nstatus; \
&ret; \
&tmp; \
\
asm volatile ("fnstcw %0" : "=m" (ostatus)); \
nstatus = ostatus | 0x0c00; \
asm volatile ("fldcw %0" : /* no outputs */ : "m" (nstatus)); \
tmp = arg0; \
asm volatile ("fldl %0" : /* no outputs */ : "m" (tmp)); \
asm volatile ("fistpl %0" : "=m" (ret)); \
asm volatile ("fldcw %0" : /* no outputs */ : "m" (ostatus)); \
\
return ret; \
}

117
contrib/gcc/config/i386/sco.h
View File

@ -1,117 +0,0 @@
/* Definitions for Intel 386 running SCO Unix System V.
Copyright (C) 1988, 92, 94, 95, 96, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* Mostly it's like AT&T Unix System V. */
#include "i386/sysv3.h"
/* By default, target has a 80387, uses IEEE compatible arithmetic,
and returns float values in the 387, ie,
(TARGET_80387 | TARGET_FLOAT_RETURNS_IN_80387)
SCO's software emulation of a 387 fails to handle the `fucomp'
opcode. fucomp is only used when generating IEEE compliant code.
So don't make TARGET_IEEE_FP default for SCO. */
#undef TARGET_DEFAULT
#define TARGET_DEFAULT (MASK_80387 | MASK_FLOAT_RETURNS)
/* Let's guess that the SCO software FPU emulator can't handle
80-bit XFmode insns, so don't generate them. */
#undef LONG_DOUBLE_TYPE_SIZE
#define LONG_DOUBLE_TYPE_SIZE 64
/* Use crt1.o as a startup file and crtn.o as a closing file. */
#undef STARTFILE_SPEC
#define STARTFILE_SPEC \
"%{pg:gcrt1.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}} crtbegin.o%s"
#define ENDFILE_SPEC "crtend.o%s crtn.o%s"
/* Library spec, including SCO international language support. */
#undef LIB_SPEC
#define LIB_SPEC \
"%{p:-L/usr/lib/libp}%{pg:-L/usr/lib/libp} %{scointl:libintl.a%s} -lc"
/* Specify predefined symbols in preprocessor. */
#undef CPP_PREDEFINES
#define CPP_PREDEFINES "-Dunix -DM_UNIX -DM_I386 -DM_COFF -DM_WORDSWAP -Asystem(svr3)"
#undef CPP_SPEC
#define CPP_SPEC "%(cpp_cpu) %{scointl:-DM_INTERNAT}"
/* This spec is used for telling cpp whether char is signed or not. */
#undef SIGNED_CHAR_SPEC
#if DEFAULT_SIGNED_CHAR
#define SIGNED_CHAR_SPEC \
"%{funsigned-char:-D__CHAR_UNSIGNED__ -D_CHAR_UNSIGNED}"
#else
#define SIGNED_CHAR_SPEC \
"%{!fsigned-char:-D__CHAR_UNSIGNED__ -D_CHAR_UNSIGNED}"
#endif
/* Use atexit for static destructors, instead of defining
our own exit function. */
#define HAVE_ATEXIT
/* Specify the size_t type. */
#define SIZE_TYPE "unsigned int"
#if 0 /* Not yet certain whether this is needed. */
/* If no 387, use the general regs to return floating values,
since this system does not emulate the 80387. */
#undef VALUE_REGNO
#define VALUE_REGNO(MODE) \
((TARGET_80387
&& ((MODE) == SFmode || (MODE) == DFmode || (MODE) == XFmode)
? FIRST_FLOAT_REG : 0)
#undef HARD_REGNO_MODE_OK
#define HARD_REGNO_MODE_OK(REGNO, MODE) \
((REGNO) < 2 ? 1 \
: (REGNO) < 4 ? 1 \
: FP_REGNO_P (REGNO) ? ((GET_MODE_CLASS (MODE) == MODE_FLOAT \
|| GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT) \
&& TARGET_80387 \
&& GET_MODE_UNIT_SIZE (MODE) <= 8) \
: (MODE) != QImode)
#endif
/* caller has to pop the extra argument passed to functions that return
structures. */
#undef RETURN_POPS_ARGS
#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) \
((FUNDECL) && TREE_CODE (FUNDECL) == IDENTIFIER_NODE ? 0 \
: (TARGET_RTD \
&& (TYPE_ARG_TYPES (FUNTYPE) == 0 \
|| (TREE_VALUE (tree_last (TYPE_ARG_TYPES (FUNTYPE))) \
== void_type_node))) ? (SIZE) \
: 0)
/* On other 386 systems, the last line looks like this:
: (aggregate_value_p (TREE_TYPE (FUNTYPE))) ? GET_MODE_SIZE (Pmode) : 0) */
/* Handle #pragma pack. */
#define HANDLE_SYSV_PRAGMA

86
contrib/gcc/config/i386/sco4.h
View File

@ -1,86 +0,0 @@
/* Definitions for Intel 386 running SCO Unix System V 3.2 Version 4.
Written by Chip Salzenberg.
Copyright (C) 1992, 1994 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* Mostly it's like earlier SCO UNIX. */
#include "i386/sco.h"
/* Use crt1.o as a startup file and crtn.o as a closing file. */
#undef STARTFILE_SPEC
#define STARTFILE_SPEC \
"%{scoxpg3:%{p:mcrt1X.o%s}%{!p:crt1X.o%s}} \
%{!scoxpg3:\
%{posix:%{p:mcrt1P.o%s}%{!p:crt1P.o%s}} \
%{!posix:\
%{ansi:%{p:mcrt1A.o%s}%{!p:crt1A.o%s}} \
%{!ansi:%{pg:gcrt1.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}}}}} \
crtbegin.o%s"
#undef ENDFILE_SPEC
#define ENDFILE_SPEC \
"crtend.o%s \
%{scoxpg3:crtnX.o%s} \
%{!scoxpg3:\
%{posix:crtnP.o%s} \
%{!posix:\
%{ansi:crtnA.o%s} \
%{!ansi:crtn.o%s}}}"
/* Library spec. */
#undef LIB_SPEC
#define LIB_SPEC \
"%{p:-L/usr/lib/libp}%{pg:-L/usr/lib/libp} \
%{scoxpg3:-lcX -lcP -lcA} \
%{!scoxpg3:\
%{posix:-lcP -lcA} \
%{!posix:\
%{ansi:-lcA} \
%{!ansi:%{scointl:-lintl} -lc}}}"
/* Macros, macros everywhere:
Specify predefined symbols in preprocessor. */
#undef CPP_PREDEFINES
#define CPP_PREDEFINES \
"-Asystem(svr3)"
#undef CPP_SPEC
#define CPP_SPEC "%(cpp_cpu) \
-D_i386 -D_M_I386 -D_M_I86 -D_M_I86SM -D_M_SDATA -D_M_STEXT \
-D_unix -D_M_UNIX -D_M_XENIX \
-D_M_SYS5 -D_M_SYSV -D_M_SYS3 -D_M_SYSIII \
-D_M_COFF -D_M_BITFIELDS -D_M_WORDSWAP \
%{scoxpg3:-D_XOPEN_SOURCE -D_STRICT_NAMES} \
%{!scoxpg3:%{posix:-D_POSIX_SOURCE -D_STRICT_NAMES}} \
%{!scoxpg3:%{!posix:\
%{ansi:-D_STRICT_NAMES}%{!ansi:\
-Di386 -DM_I386 -DM_I86 -DM_I86SM -DM_SDATA -DM_STEXT \
-Dunix -DM_UNIX -DM_XENIX \
-DM_SYS5 -DM_SYSV -DM_SYS3 -DM_SYSIII \
-DM_COFF -DM_BITFIELDS -DM_WORDSWAP \
%{scointl:-D_M_INTERNAT -DM_INTERNAT} \
%{traditional:-D_KR -D_SVID -D_NO_PROTOTYPE}}}}"
/* The system headers are C++-aware. */
#define NO_IMPLICIT_EXTERN_C

81
contrib/gcc/config/i386/sco4dbx.h
View File

@ -1,81 +0,0 @@
/* Definitions for Intel 386 running SCO Unix System V 3.2 Version 4.s,
using dbx-in-coff encapsulation.
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, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* Mostly it's like earlier SCO UNIX. */
#include "i386/scodbx.h"
/* Use crt1.o as a startup file and crtn.o as a closing file. */
#undef STARTFILE_SPEC
#define STARTFILE_SPEC \
"%{!r:%{!z:gcc.ifile%s}%{z:gccz.ifile%s}}\
%{scoxpg3:%{p:mcrt1X.o%s}%{!p:crt1X.o%s}} \
%{!scoxpg3:\
%{posix:%{p:mcrt1P.o%s}%{!p:crt1P.o%s}} \
%{!posix:\
%{ansi:%{p:mcrt1A.o%s}%{!p:crt1A.o%s}} \
%{!ansi:%{pg:gcrt1.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}}}}}"
#undef ENDFILE_SPEC
#define ENDFILE_SPEC \
"%{scoxpg3:crtnX.o%s} \
%{!scoxpg3:\
%{posix:crtnP.o%s} \
%{!posix:\
%{ansi:crtnA.o%s} \
%{!ansi:crtn.o%s}}}"
/* Library spec. */
#undef LIB_SPEC
#define LIB_SPEC \
"%{p:-L/usr/lib/libp}%{pg:-L/usr/lib/libp} \
%{scoxpg3:-lcX -lcP -lcA} \
%{!scoxpg3:\
%{posix:-lcP -lcA} \
%{!posix:\
%{ansi:-lcA} \
%{!ansi:%{scointl:-lintl} -lc}}}"
/* Macros, macros everywhere:
Specify predefined symbols in preprocessor. */
#undef CPP_PREDEFINES
#define CPP_PREDEFINES "-Dunix -Asystem(svr3)"
#undef CPP_SPEC
#define CPP_SPEC "%(cpp_cpu) \
-D_M_I386 -D_M_I86 -D_M_I86SM -D_M_SDATA -D_M_STEXT \
-D_M_UNIX -D_M_XENIX \
-D_M_SYS5 -D_M_SYSV -D_M_SYS3 -D_M_SYSIII \
-D_M_COFF -D_M_BITFIELDS -D_M_WORDSWAP \
%{scoxpg3:-D_XOPEN_SOURCE -D_STRICT_NAMES} \
%{!scoxpg3:%{posix:-D_POSIX_SOURCE -D_STRICT_NAMES}} \
%{!scoxpg3:%{!posix:\
%{ansi:-D_STRICT_NAMES}%{!ansi:\
-DM_I386 -DM_I86 -DM_I86SM -DM_SDATA -DM_STEXT \
-DM_UNIX -DM_XENIX \
-DM_SYS5 -DM_SYSV -DM_SYS3 -DM_SYSIII \
-DM_COFF -DM_BITFIELDS -DM_WORDSWAP \
%{scointl:-D_M_INTERNAT -DM_INTERNAT} \
%{traditional:-D_KR -D_SVID -D_NO_PROTOTYPE}}}}"

24
contrib/gcc/config/i386/sco5gas.h
View File

@ -1,24 +0,0 @@
/* Definitions for Intel x86 running SCO OpenServer, running GNU assembler
Copyright (C) 1998 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* Just set a single flag we can test for inside of sco5.h and include it. */
#define USE_GAS 1

84
contrib/gcc/config/i386/scodbx.h
View File

@ -1,84 +0,0 @@
/* Definitions for Intel 386 running SCO Unix System V,
using dbx-in-coff encapsulation.
Copyright (C) 1992, 1995, 1996, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "i386/svr3dbx.h"
/* Overridden defines for SCO systems from sco.h. */
/* By default, target has a 80387, uses IEEE compatible arithmetic,
and returns float values in the 387, ie,
(TARGET_80387 | TARGET_FLOAT_RETURNS_IN_80387)
SCO's software emulation of a 387 fails to handle the `fucomp'
opcode. fucomp is only used when generating IEEE compliant code.
So don't make TARGET_IEEE_FP default for SCO. */
#undef TARGET_SUBTARGET_DEFAULT
#define TARGET_SUBTARGET_DEFAULT (MASK_80387 | MASK_FLOAT_RETURNS)
/* Use crt1.o as a startup file and crtn.o as a closing file. */
#undef STARTFILE_SPEC
#define STARTFILE_SPEC \
"%{!r:%{!z:svr3.ifile%s}%{z:svr3z.ifile%s}}\
%{pg:gcrt1.o%s}%{!pg:%{p:mcrt1.o%s}%{!p:crt1.o%s}}"
/* Library spec, including SCO international language support. */
#undef LIB_SPEC
#define LIB_SPEC \
"%{p:-L/usr/lib/libp}%{pg:-L/usr/lib/libp} %{scointl:libintl.a%s} -lc"
/* Specify predefined symbols in preprocessor. */
#undef CPP_PREDEFINES
#define CPP_PREDEFINES "-Dunix -DM_UNIX -DM_I386 -DM_COFF -DM_WORDSWAP -Asystem=svr3"
#undef CPP_SPEC
#define CPP_SPEC "%(cpp_cpu) %{scointl:-DM_INTERNAT}"
/* This spec is used for telling cpp whether char is signed or not. */
#undef SIGNED_CHAR_SPEC
#if DEFAULT_SIGNED_CHAR
#define SIGNED_CHAR_SPEC \
"%{funsigned-char:-D__CHAR_UNSIGNED__ -D_CHAR_UNSIGNED}"
#else
#define SIGNED_CHAR_SPEC \
"%{!fsigned-char:-D__CHAR_UNSIGNED__ -D_CHAR_UNSIGNED}"
#endif
/* caller has to pop the extra argument passed to functions that return
structures. */
#undef RETURN_POPS_ARGS
#define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) \
((FUNDECL) && TREE_CODE (FUNDECL) == IDENTIFIER_NODE ? 0 \
: (TARGET_RTD \
&& (TYPE_ARG_TYPES (FUNTYPE) == 0 \
|| (TREE_VALUE (tree_last (TYPE_ARG_TYPES (FUNTYPE))) \
== void_type_node))) ? (SIZE) \
: 0)
/* On other 386 systems, the last line looks like this:
: (aggregate_value_p (TREE_TYPE (FUNTYPE))) ? GET_MODE_SIZE (Pmode) : 0) */
/* Handle #pragma pack. */
#define HANDLE_SYSV_PRAGMA

3
contrib/gcc/config/i386/t-i386bare
View File

@ -1,3 +0,0 @@
# The i386 md has all of these taken care of, according to sef.
LIBGCC1 =
CROSS_LIBGCC1 =

2
contrib/gcc/config/i386/t-vsta
View File

@ -1,2 +0,0 @@
LIBGCC1 = libgcc1.null
CROSS_LIBGCC1 = libgcc1.null

6
contrib/gcc/config/i386/t-winnt
View File

@ -1,6 +0,0 @@
winnt.o: $(srcdir)/config/i386/winnt.c
$(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $(srcdir)/config/i386/winnt.c
oldnames.o: $(srcdir)/config/winnt/oldnames.c
$(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $(srcdir)/config/winnt/oldnames.c
spawnv.o: $(srcdir)/config/winnt/spawnv.c
$(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) $(srcdir)/config/winnt/spawnv.c

150
contrib/gcc/config/i386/win-nt.h
View File

@ -1,150 +0,0 @@
/* Operating system specific defines to be used when targeting GCC for
Windows NT 3.x on an i386.
Copyright (C) 1994, 1995 Free Software Foundation, Inc.
Contributed by Douglas B. Rupp (drupp@cs.washington.edu).
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#define YES_UNDERSCORES
#include "i386/gas.h"
#ifdef CPP_PREDEFINES
#undef CPP_PREDEFINES
#endif
#define CPP_PREDEFINES "-Dunix -Di386 -DWIN32 -D_WIN32 \
-DWINNT -D_M_IX86=300 -D_X86_=1 -D__STDC__=0 -DALMOST_STDC -D_MSC_VER=800 \
-D__stdcall=__attribute__((__stdcall__)) \
-D__cdecl=__attribute__((__cdecl__)) \
-D_cdecl=__attribute__((__cdecl__)) \
-Asystem(unix) -Asystem(winnt) -Acpu(i386) -Amachine(i386)"
#define SIZE_TYPE "unsigned int"
#define PTRDIFF_TYPE "int"
#define WCHAR_UNSIGNED 1
#define WCHAR_TYPE_SIZE 16
#define WCHAR_TYPE "short unsigned int"
#undef LONG_DOUBLE_TYPE_SIZE
#define LONG_DOUBLE_TYPE_SIZE 64
#define HAVE_ATEXIT 1
#undef EXTRA_SECTIONS
#define EXTRA_SECTIONS in_ctor, in_dtor
#undef EXTRA_SECTION_FUNCTIONS
#define EXTRA_SECTION_FUNCTIONS \
CTOR_SECTION_FUNCTION \
DTOR_SECTION_FUNCTION
#define CTOR_SECTION_FUNCTION \
void \
ctor_section () \
{ \
if (in_section != in_ctor) \
{ \
fprintf (asm_out_file, "\t.section .ctor\n"); \
in_section = in_ctor; \
} \
}
#define DTOR_SECTION_FUNCTION \
void \
dtor_section () \
{ \
if (in_section != in_dtor) \
{ \
fprintf (asm_out_file, "\t.section .dtor\n"); \
in_section = in_dtor; \
} \
}
#define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \
do { \
ctor_section (); \
fprintf (FILE, "%s\t", ASM_LONG); \
assemble_name (FILE, NAME); \
fprintf (FILE, "\n"); \
} while (0)
#define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \
do { \
dtor_section (); \
fprintf (FILE, "%s\t", ASM_LONG); \
assemble_name (FILE, NAME); \
fprintf (FILE, "\n"); \
} while (0)
/* Define this macro if references to a symbol must be treated
differently depending on something about the variable or
function named by the symbol (such as what section it is in).
On i386, if using PIC, mark a SYMBOL_REF for a non-global symbol
so that we may access it directly in the GOT.
On i386 running Windows NT, modify the assembler name with a suffix
consisting of an atsign (@) followed by string of digits that represents
the number of bytes of arguments passed to the function, if it has the
attribute STDCALL. */
#ifdef ENCODE_SECTION_INFO
#undef ENCODE_SECTION_INFO
#define ENCODE_SECTION_INFO(DECL) \
do \
{ \
if (flag_pic) \
{ \
rtx rtl = (TREE_CODE_CLASS (TREE_CODE (DECL)) != 'd' \
? TREE_CST_RTL (DECL) : DECL_RTL (DECL)); \
SYMBOL_REF_FLAG (XEXP (rtl, 0)) \
= (TREE_CODE_CLASS (TREE_CODE (DECL)) != 'd' \
|| ! TREE_PUBLIC (DECL)); \
} \
if (TREE_CODE (DECL) == FUNCTION_DECL) \
if (lookup_attribute ("stdcall", \
TYPE_ATTRIBUTES (TREE_TYPE (DECL)))) \
XEXP (DECL_RTL (DECL), 0) = \
gen_rtx (SYMBOL_REF, Pmode, gen_stdcall_suffix (DECL)); \
} \
while (0)
#endif
/* The global __fltused is necessary to cause the printf/scanf routines
for outputting/inputting floating point numbers to be loaded. Since this
is kind of hard to detect, we just do it all the time. */
#ifdef ASM_FILE_START
#undef ASM_FILE_START
#endif
#define ASM_FILE_START(FILE) \
do { output_file_directive (FILE, main_input_filename); \
fprintf (FILE, ".global\t__fltused\n"); \
} while (0)
/* if the switch "-mwindows" is passed to ld, then specify to the Microsoft
linker the proper switches and libraries to build a graphical program */
#undef LIB_SPEC
#define LIB_SPEC "%{mwindows:-subsystem windows -e _WinMainCRTStartup \
USER32.LIB%s GDI32.LIB%s COMDLG32.LIB%s WINSPOOL.LIB%s} \
%{!mwindows:-subsystem console -e _mainCRTStartup} \
%{mcrtmt:LIBCMT.LIB%s KERNEL32.LIB%s ADVAPI32.LIB%s} \
%{!mcrtmt:LIBC.LIB%s KERNEL32.LIB%s ADVAPI32.LIB%s} \
%{v}"
#include "winnt/win-nt.h"

12
contrib/gcc/config/i386/x-aix
View File

@ -1,12 +0,0 @@
# There is an alloca in -lbsd, but it is limited to 32K
ALLOCA = alloca.o
# If you are running out of memory while compiling gcc, with the standard
# /bin/cc uncomment MALLOCLIB line. That version of malloc is slower but
# has less overhead than the one in libc.
#MALLOCLIB = -lmalloc
# Uncomment out the next line if you want to link with the shareable libc_s.
#CLIB_S = -lc_s
CLIB = -lld $(MALLOCLIB) $(CLIB_S)

4
contrib/gcc/config/i386/x-cygwin
View File

@ -1,4 +0,0 @@
# Don't run fixproto
STMP_FIXPROTO =
# prefix.c wants to poke around the Registry
CLIB = -ladvapi32

11
contrib/gcc/config/i386/x-dgux
View File

@ -1,11 +0,0 @@
#
# host is ix86 running dgux
#
CC = /bin/gcc
X_CFLAGS = -O -mstandard -mlegend
BOOT_CFLAGS = -O2 -g -mstandard -mlegend $(CFLAGS)
CLIB = -lw32
RANLIB = true
USER_H = $(EXTRA_HEADERS) $(LANG_EXTRA_HEADERS)
STMP_FIXPROTO =

24
contrib/gcc/config/i386/x-djgpp
View File

@ -1,24 +0,0 @@
# translate the version string, so it can be used on DJGPP, where only
# one dot in filename is allowed
# to avoid recursion when redefining $(version)
_version:=$(version)
__version=$(subst ., ,$(_version))
version=$(word 1,$(__version))$(word 2,$(__version)).$(word 3,$(__version))
SYSTEM_HEADER_DIR=$(DJDIR)/include
X_CPPFLAGS=-DSTANDARD_INCLUDE_DIR=\"\$$DJDIR/include\" \
-DSTANDARD_INCLUDE_COMPONENT=\"\"
# when building a native compiler for DJGPP, make the target_alias
# a shorter name, since otherwise it will produce some problems, when
# using the same gcc once with long filenames and once with short (8+3)
# filenames
ifeq ($(findstring -pc-msdosdjgpp,$(target_alias)),-pc-msdosdjgpp)
target_alias=djgpp
endif
# on DJGPP the 'ln -s' does not work correctly
LN = cp -p
LN_S = cp -p

3
contrib/gcc/config/i386/x-isc
View File

@ -1,3 +0,0 @@
CLIB = -lPW -lcposix
X_CFLAGS = -D_POSIX_SOURCE
ENQUIRE_LDFLAGS = -posix $(LDFLAGS)

4
contrib/gcc/config/i386/x-isc3
View File

@ -1,4 +0,0 @@
CLIB = -lPW
# One person said it needs -DPOSIX_JC, but daa@CERF.NET says no.
X_CFLAGS = -D_SYSV3 -Xp
ENQUIRE_LDFLAGS = $(LDFLAGS)

34
contrib/gcc/config/i386/x-ncr3000
View File

@ -1,34 +0,0 @@
# Makefile additions for the NCR3000 as host system.
# Using -O with the AT&T compiler fails, with a message about a missing
# /usr/ccs/lib/optim pass. So override the default in Makefile.in
CCLIBFLAGS=
## Supposedly not needed now that xm-sysv4.h includes alloc.h for Metaware.
### NCR3000 ships with a MetaWare compiler installed as CC, which chokes and
### dies all over the place on GCC source. However, the AT&T compiler,
### crusty as it is, can be used to bootstrap GCC. It can be found in
### /usr/ccs/ATT/cc. It is also used to compile the things that should
### not be compiled with GCC.
##
##CC = /usr/ccs/ATT/cc
##OLDCC = /usr/ccs/ATT/cc
# The rest is just x-i386v4.
# Some versions of SVR4 have an alloca in /usr/ucblib/libucb.a, and if we are
# careful to link that in after libc we can use it, but since newer versions of
# SVR4 are dropping libucb, it is better to just use the portable C version for
# bootstrapping. Do this by defining ALLOCA.
ALLOCA = alloca.o
# We used to build all stages *without* shared libraries because that may make
# debugging the compiler easier (until there is a GDB which supports
# both Dwarf *and* svr4 shared libraries).
# But james@bigtex.cactus.org says that redefining GCC_CFLAGS causes trouble,
# and that it is easy enough to debug using shared libraries.
# CCLIBFLAGS=-Bstatic -dn -g
# GCC_CFLAGS=-static -g -O2 -B./

3
contrib/gcc/config/i386/x-next
View File

@ -1,3 +0,0 @@
# Make assignments for compiling on NeXT with their compiler version.
CC=cc -traditional-cpp
OLDCC=cc -traditional-cpp

8
contrib/gcc/config/i386/x-osf1elf
View File

@ -1,8 +0,0 @@
# Defaults for OSF/1 1.3+
CC = $(OLDCC)
CLIB = -lld
INSTALL = installbsd -c
OLDCC = /usr/ccs/gcc/gcc
X_CFLAGS = -static
# FIXPROTO_DEFINES = -D_XOPEN_SOURCE

27
contrib/gcc/config/i386/x-osfrose
View File

@ -1,27 +0,0 @@
# Define CC and OLDCC as the same, so that the tests:
# if [ x"$(OLDCC)" = x"$(CC)" ] ...
#
# will succeed (if OLDCC != CC, it is assumed that GCC is
# being used in secondary stage builds).
BUILD =
CC = $(OLDCC)
CLIB = -lld
X_CFLAGS = $(DEB_OPT) $(MSTATS) $(X_DEFINES)
X_CFLAGS_NODEBUG = $(NO_DEBUG) $(MSTATS) $(OPT) $(PROFILE) $(X_DEFINES) $(XCFLAGS)
XCFLAGS = $(SHLIB)
CPP_ABORT = # -Dabort=fancy_abort
CPPFLAGS = $(CPP_ABORT) $(SYSTEM_INCLUDES)
DEB_OPT = $(OPT) $(DEBUG) $(PROFILE)
DEBUG =
DEBUG_COLLECT = # -DDEBUG
CCLIBFLAGS = -O -DNO_HALF_PIC
GCC_CFLAGS = $(INTERNAL_CFLAGS) $(X_CFLAGS) $(T_CFLAGS) $(CFLAGS) -B./ -DPOSIX -DNO_HALF_PIC
LDFLAGS =
MSTATS = # -mstats
OLDCC = /usr/ccs/gcc/gcc
OPT = -O
PROFILE =
SHLIB = -pic-none
SYSTEM_INCLUDES = # -I${BUILD}/usr/include
X_DEFINES = -Dvfork=fork

7
contrib/gcc/config/i386/x-sco
View File

@ -1,7 +0,0 @@
RANLIB = :
RANLIB_TEST = false
CC = rcc $(RCCFLAGS)
OLDCC = rcc $(RCCFLAGS)
RCCFLAGS = -Dunix -Di386 -DM_UNIX -DM_I386 -DNULL=0
CCLIBFLAGS =
CLIB = -lmalloc -lPW

10
contrib/gcc/config/i386/x-sco4
View File

@ -1,10 +0,0 @@
RANLIB = :
RANLIB_TEST = false
CC = rcc $(RCCFLAGS)
OLDCC = rcc $(RCCFLAGS)
RCCFLAGS = -Dunix -Di386 -DM_UNIX -DM_I386 -DNULL=0
CCLIBFLAGS =
CLIB = -lmalloc -lPW
# See all the declarations.
FIXPROTO_DEFINES = -D_XOPEN_SOURCE

10
contrib/gcc/config/i386/x-sco5
View File

@ -1,10 +0,0 @@
RANLIB = :
RANLIB_TEST = false
CC = cc
OLDCC = cc
CCLIBFLAGS =
# We avoid the ALLOCA in -lPW becuase it gives us an evil index()
ALLOCA = alloca.o
# See all the declarations.
FIXPROTO_DEFINES = -D_XOPEN_SOURCE -D_POSIX_C_SOURCE=2

1
contrib/gcc/config/i386/x-sysv3
View File

@ -1 +0,0 @@
CLIB=-lPW

1
contrib/gcc/config/i386/x-vsta
View File

@ -1 +0,0 @@
CLIB=-lm

2
contrib/gcc/config/i386/xm-aix.h
View File

@ -1,2 +0,0 @@
#undef TRUE
#undef FALSE

3
contrib/gcc/config/i386/xm-bsd386.h
View File

@ -1,3 +0,0 @@
/* Configuration for GCC for Intel i386 running BSDI's BSD/386 as host. */
#include "i386/xm-i386.h"

4
contrib/gcc/config/i386/xm-dgux.h
View File

@ -1,4 +0,0 @@
/* Configuration for GCC for Intel i386 running DG/ux */
/* looks just like sysv4 for now */
#include "xm-svr4.h"

38
contrib/gcc/config/i386/xm-dos.h
View File

@ -1,38 +0,0 @@
/* Configuration for GNU C-compiler for Intel 80386 running DOS.
Copyright (C) 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "i386/xm-i386.h"
/* Use semicolons to separate elements of a path. */
#define PATH_SEPARATOR ';'
/* Use backslashs to separate levels of directory. */
#define DIR_SEPARATOR '\\'
#define DIR_SEPARATOR_2 '/'
/* Allow checks for drive names. */
#define HAVE_DOS_BASED_FILE_SYSTEM
/* Suffix for executable file names. */
#define EXECUTABLE_SUFFIX ".exe"
#define MKTEMP_EACH_FILE 1
#define NO_PRECOMPILES 1

4
contrib/gcc/config/i386/xm-freebsd.h
View File

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

5
contrib/gcc/config/i386/xm-gnu.h
View File

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

43
contrib/gcc/config/i386/xm-i386.h
View File

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

4
contrib/gcc/config/i386/xm-isc.h
View File

@ -1,4 +0,0 @@
#ifndef REAL_ARITHMETIC
#define REAL_VALUE_ATOF(x, mode) strtod ((x), (char **)0)
extern double strtod ();
#endif

24
contrib/gcc/config/i386/xm-linux.h
View File

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

33
contrib/gcc/config/i386/xm-lynx.h
View File

@ -1,33 +0,0 @@
/* Configuration for GNU C-compiler for i386 platforms running LynxOS.
Copyright (C) 1995 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <xm-lynx.h>
/* This describes the machine the compiler is hosted on. */
#define HOST_BITS_PER_CHAR 8
#define HOST_BITS_PER_SHORT 16
#define HOST_BITS_PER_INT 32
#define HOST_BITS_PER_LONG 32
#define HOST_BITS_PER_LONGLONG 64
/* target machine dependencies.
tm.h is a symbolic link to the actual target specific file. */
#include "tm.h"

5
contrib/gcc/config/i386/xm-next.h
View File

@ -1,5 +0,0 @@
#include "i386/xm-i386.h"
/* malloc does better with chunks the size of a page. */
#define OBSTACK_CHUNK_SIZE (getpagesize ())

23
contrib/gcc/config/i386/xm-openbsd.h
View File

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

75
contrib/gcc/config/i386/xm-os2.h
View File

@ -1,75 +0,0 @@
/* Configuration for GNU compiler
for an Intel i386 or later processor running OS/2 2.x.
Copyright (C) 1993, 1994, 1995, 1997, 1998, 1999 Free Software Foundation, Inc.
Contributed by Samuel Figueroa (figueroa@apple.com)
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#ifndef OS2
#define OS2
#endif
#ifdef __IBMC__
#include <stdlib.h> /* this defines alloca */
#define USG
#define ONLY_INT_FIELDS
#define USE_PROTOTYPES 1
#define strcasecmp stricmp
#define kill(a,b) raise(b)
#define mktemp tmpnam
#else
#ifdef __EMX__
#define EMX
#define USG
#define BSTRING
#define HAVE_PUTENV
#define HAVE_VPRINTF
#define HAVE_STRERROR
#define strcasecmp stricmp
#else
#define ____386BSD____
int spawnv (int modeflag, char *path, char *argv[]);
int spawnvp (int modeflag, char *path, char *argv[]);
#endif /* __EMX__ */
#endif /* __IBMC__ */
#ifndef PATH_SEPARATOR
#define PATH_SEPARATOR ';'
#endif
#ifndef DIR_SEPARATOR
#define DIR_SEPARATOR '\\'
#endif
#ifndef DIR_SEPARATOR_2
#define DIR_SEPARATOR_2 '/'
#endif
/* Allow handling of drive names. */
#define HAVE_DOS_BASED_FILE_SYSTEM
#define EXECUTABLE_SUFFIX ".exe"
/* The EMX compiler uses regular .o files */
#ifndef __EMX__
#define OBJECT_SUFFIX ".obj"
#endif
/* This is required to make temporary file names unique on file
systems which severely restrict the length of file names. */
#define MKTEMP_EACH_FILE
#include "i386/xm-i386.h"

2
contrib/gcc/config/i386/xm-osf.h
View File

@ -1,2 +0,0 @@
#undef TRUE
#undef FALSE

6
contrib/gcc/config/i386/xm-osf1elf.h
View File

@ -1,6 +0,0 @@
/* Configuration for GCC for Intel i386 running OSF/1 1.3. */
#ifndef HZ
#include <machine/machtime.h>
#define HZ DEFAULT_CLK_TCK
#endif

13
contrib/gcc/config/i386/xm-sco.h
View File

@ -1,13 +0,0 @@
/* Configuration for GCC for Intel i386 running SCO. */
/* Big buffers improve performance. */
#define IO_BUFFER_SIZE (0x8000 - 1024)
#ifndef __GNUC__
/* The SCO compiler gets it wrong, and treats enumerated bitfields
as signed quantities, making it impossible to use an 8-bit enum
for compiling GNU C++. */
#define ONLY_INT_FIELDS 1
#define CODE_FIELD_BUG 1
#endif

7
contrib/gcc/config/i386/xm-sco5.h
View File

@ -1,7 +0,0 @@
/* Configuration for GCC for Intel i386 running SCO. */
/* Big buffers improve performance. */
#define IO_BUFFER_SIZE (0x8000 - 1024)

21
contrib/gcc/config/i386/xm-sun.h
View File

@ -1,21 +0,0 @@
/* Configuration for GNU C-compiler for Intel 80386 running SunOS 4.0.
Copyright (C) 1988, 1997 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#define USG

3
contrib/gcc/config/i386/xm-sysv3.h
View File

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

5
contrib/gcc/config/i386/xm-sysv4.h
View File

@ -1,5 +0,0 @@
/* Configuration for GCC for Intel i386 running System V Release 4. */
#ifdef __HIGHC__
#include <alloca.h> /* for MetaWare High-C on NCR System 3000 */
#endif

39
contrib/gcc/config/i386/xm-uwin.h
View File

@ -1,39 +0,0 @@
/* Configuration for GNU C-compiler for hosting on Windows32.
using GNU tools and the Windows32 API Library.
Copyright (C) 1999 Free Software Foundation, Inc.
Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#ifndef ONLY_INT_FIELD
#define ONLY_INT_FIELDS 1
#endif
#ifndef USE_PROTOTYPES
#define USE_PROTOTYPES 1
#endif
/* U/WIN system calls only support '/' */
#undef DIR_SEPARATOR
#define DIR_SEPARATOR '/'
#undef EXECUTABLE_SUFFIX
#define EXECUTABLE_SUFFIX ".exe"
#undef PATH_SEPARATOR
#define PATH_SEPARATOR ':'

24
contrib/gcc/config/i386/xm-winnt.h
View File

@ -1,24 +0,0 @@
/* Configuration for GNU compiler
for an Intel i386 or later processor running Windows NT 3.x.
Copyright (C) 1994 Free Software Foundation, Inc.
Contributed by Douglas B. Rupp (drupp@cs.washington.edu)
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include "winnt/xm-winnt.h"
#include "i386/xm-i386.h"

335
contrib/gcc/config/sparc/sol2-sld-64.h
View File

@ -1,335 +0,0 @@
/* Definitions of target machine for GNU compiler, for 64-bit SPARC
running Solaris 2 using the system linker. */
#ifdef AS_SPARC64_FLAG
#include "sparc/sparc_bi.h"
#endif
#include "sparc/sparc.h"
#include "dbxelf.h"
#include "elfos.h"
#include "svr4.h"
#include "sparc/sysv4.h"
#include "sparc/sol2.h"
#ifdef AS_SPARC64_FLAG
/* At least up through Solaris 2.6,
the system linker does not work with DWARF or DWARF2,
since it does not have working support for relocations
to unaligned data. */
#define LINKER_DOES_NOT_WORK_WITH_DWARF2
/* A 64 bit v9 compiler with stack-bias */
#if TARGET_CPU_DEFAULT == TARGET_CPU_v9 || TARGET_CPU_DEFAULT == TARGET_CPU_ultrasparc
#undef TARGET_DEFAULT
#define TARGET_DEFAULT \
(MASK_V9 + MASK_PTR64 + MASK_64BIT /* + MASK_HARD_QUAD */ + \
MASK_STACK_BIAS + MASK_EPILOGUE + MASK_FPU + MASK_LONG_DOUBLE_128)
#endif
/* The default code model. */
#undef SPARC_DEFAULT_CMODEL
#define SPARC_DEFAULT_CMODEL CM_MEDANY
#undef LONG_DOUBLE_TYPE_SIZE
#define LONG_DOUBLE_TYPE_SIZE 128
#undef ASM_CPU32_DEFAULT_SPEC
#define ASM_CPU32_DEFAULT_SPEC ""
#undef ASM_CPU64_DEFAULT_SPEC
#define ASM_CPU64_DEFAULT_SPEC AS_SPARC64_FLAG
#if TARGET_CPU_DEFAULT == TARGET_CPU_v9
#undef CPP_CPU64_DEFAULT_SPEC
#define CPP_CPU64_DEFAULT_SPEC ""
#undef ASM_CPU32_DEFAULT_SPEC
#define ASM_CPU32_DEFAULT_SPEC "-xarch=v8plus"
#endif
#if TARGET_CPU_DEFAULT == TARGET_CPU_ultrasparc
#undef CPP_CPU64_DEFAULT_SPEC
#define CPP_CPU64_DEFAULT_SPEC ""
#undef ASM_CPU32_DEFAULT_SPEC
#define ASM_CPU32_DEFAULT_SPEC "-xarch=v8plusa"
#undef ASM_CPU64_DEFAULT_SPEC
#define ASM_CPU64_DEFAULT_SPEC AS_SPARC64_FLAG "a"
#endif
/* The sun bundled assembler doesn't accept -Yd, (and neither does gas).
It's safe to pass -s always, even if -g is not used. */
#undef ASM_SPEC
#define ASM_SPEC "\
%{v:-V} %{Qy:} %{!Qn:-Qy} %{n} %{T} %{Ym,*} %{Wa,*:%*} -s \
%{fpic:-K PIC} %{fPIC:-K PIC} \
%(asm_cpu)\
"
#if DEFAULT_ARCH32_P
#define DEF_ARCH32_SPEC(__str) "%{!m64:" __str "}"
#define DEF_ARCH64_SPEC(__str) "%{m64:" __str "}"
#else
#define DEF_ARCH32_SPEC(__str) "%{m32:" __str "}"
#define DEF_ARCH64_SPEC(__str) "%{!m32:" __str "}"
#endif
#undef CPP_CPU_SPEC
#define CPP_CPU_SPEC "\
%{mcypress:} \
%{msparclite:-D__sparclite__} \
%{mf930:-D__sparclite__} %{mf934:-D__sparclite__} \
%{mv8:" DEF_ARCH32_SPEC("-D__sparcv8") "} \
%{msupersparc:-D__supersparc__ " DEF_ARCH32_SPEC("-D__sparcv8") "} \
%{mcpu=sparclet:-D__sparclet__} %{mcpu=tsc701:-D__sparclet__} \
%{mcpu=sparclite:-D__sparclite__} \
%{mcpu=f930:-D__sparclite__} %{mcpu=f934:-D__sparclite__} \
%{mcpu=v8:" DEF_ARCH32_SPEC("-D__sparcv8") "} \
%{mcpu=supersparc:-D__supersparc__ " DEF_ARCH32_SPEC("-D__sparcv8") "} \
%{mcpu=v9:" DEF_ARCH32_SPEC("-D__sparcv8") "} \
%{mcpu=ultrasparc:" DEF_ARCH32_SPEC("-D__sparcv8") "} \
%{!mcpu*:%{!mcypress:%{!msparclite:%{!mf930:%{!mf934:%{!mv8:%{!msupersparc:%(cpp_cpu_default)}}}}}}} \
"
#undef ASM_CPU_SPEC
#define ASM_CPU_SPEC "\
%{mcpu=ultrasparc:" DEF_ARCH32_SPEC("-xarch=v8plusa") DEF_ARCH64_SPEC(AS_SPARC64_FLAG "a") "} \
%{mcpu=v9:" DEF_ARCH32_SPEC("-xarch=v8plus") DEF_ARCH64_SPEC(AS_SPARC64_FLAG) "} \
%{!mcpu=ultrasparc:%{!mcpu=v9:%{mcpu*:" DEF_ARCH32_SPEC("-xarch=v8") DEF_ARCH64_SPEC(AS_SPARC64_FLAG) "}}} \
%{!mcpu*:%(asm_cpu_default)} \
"
#define STARTFILE_SPEC32 "\
%{ansi:values-Xc.o%s} \
%{!ansi: \
%{traditional:values-Xt.o%s} \
%{!traditional:values-Xa.o%s}}"
#define STARTFILE_SPEC64 "\
%{ansi:/usr/lib/sparcv9/values-Xc.o%s} \
%{!ansi: \
%{traditional:/usr/lib/sparcv9/values-Xt.o%s} \
%{!traditional:/usr/lib/sparcv9/values-Xa.o%s}}"
#ifdef SPARC_BI_ARCH
#if DEFAULT_ARCH32_P
#define STARTFILE_ARCH_SPEC "\
%{m32:" STARTFILE_SPEC32 "} \
%{m64:" STARTFILE_SPEC64 "} \
%{!m32:%{!m64:" STARTFILE_SPEC32 "}}"
#else
#define STARTFILE_ARCH_SPEC "\
%{m32:" STARTFILE_SPEC32 "} \
%{m64:" STARTFILE_SPEC64 "} \
%{!m32:%{!m64:" STARTFILE_SPEC64 "}}"
#endif
#else /* !SPARC_BI_ARCH */
/* In this case we define MD_STARTFILE_PREFIX to /usr/lib/sparcv9/ */
#define STARTFILE_ARCH_SPEC STARTFILE_SPEC32
#endif /* !SPARC_BI_ARCH */
#undef STARTFILE_SPEC
#define STARTFILE_SPEC "%{!shared: \
%{!symbolic: \
%{p:mcrt1.o%s} \
%{!p: \
%{pg:gcrt1.o%s gmon.o%s} \
%{!pg:crt1.o%s}}}} \
crti.o%s " STARTFILE_ARCH_SPEC " \
crtbegin.o%s"
#ifdef SPARC_BI_ARCH
#undef CPP_CPU_DEFAULT_SPEC
#define CPP_CPU_DEFAULT_SPEC \
(DEFAULT_ARCH32_P ? "\
%{m64:" CPP_CPU64_DEFAULT_SPEC "} \
%{!m64:" CPP_CPU32_DEFAULT_SPEC "} \
" : "\
%{m32:" CPP_CPU32_DEFAULT_SPEC "} \
%{!m32:" CPP_CPU64_DEFAULT_SPEC "} \
")
#undef ASM_CPU_DEFAULT_SPEC
#define ASM_CPU_DEFAULT_SPEC \
(DEFAULT_ARCH32_P ? "\
%{m64:" ASM_CPU64_DEFAULT_SPEC "} \
%{!m64:" ASM_CPU32_DEFAULT_SPEC "} \
" : "\
%{m32:" ASM_CPU32_DEFAULT_SPEC "} \
%{!m32:" ASM_CPU64_DEFAULT_SPEC "} \
")
/* wchar_t is called differently in <wchar.h> for 32 and 64-bit
compilations. This is called for by SCD 2.4.1, p. 6-83, Figure 6-65
(32-bit) and p. 6P-10, Figure 6.38 (64-bit). */
#define NO_BUILTIN_WCHAR_TYPE
#undef WCHAR_TYPE
#define WCHAR_TYPE (TARGET_ARCH64 ? "int" : "long int")
#undef WCHAR_TYPE_SIZE
#define WCHAR_TYPE_SIZE 32
/* Same for wint_t. See SCD 2.4.1, p. 6-83, Figure 6-66 (32-bit). There's
no corresponding 64-bit definition, but this is what Solaris 8
<iso/wchar_iso.h> uses. */
#define NO_BUILTIN_WINT_TYPE
#undef WINT_TYPE
#define WINT_TYPE (TARGET_ARCH64 ? "int" : "long int")
#undef WINT_TYPE_SIZE
#define WINT_TYPE_SIZE 32
#undef CPP_ARCH32_SPEC
#define CPP_ARCH32_SPEC "-D__SIZE_TYPE__=unsigned\\ int -D__PTRDIFF_TYPE__=int \
-D__WCHAR_TYPE__=long\\ int -D__WINT_TYPE__=long\\ int \
-D__GCC_NEW_VARARGS__ -Acpu=sparc -Amachine=sparc"
#undef CPP_ARCH64_SPEC
#define CPP_ARCH64_SPEC "-D__SIZE_TYPE__=long\\ unsigned\\ int -D__PTRDIFF_TYPE__=long\\ int \
-D__WCHAR_TYPE__=int -D__WINT_TYPE__=int \
-D__arch64__ -Acpu=sparc64 -Amachine=sparcv9 -D__sparcv9"
#undef CPP_ARCH_SPEC
#define CPP_ARCH_SPEC "\
%{m32:%(cpp_arch32)} \
%{m64:%(cpp_arch64)} \
%{!m32:%{!m64:%(cpp_arch_default)}} \
"
#undef ASM_ARCH_SPEC
#define ASM_ARCH_SPEC ""
#undef ASM_ARCH32_SPEC
#define ASM_ARCH32_SPEC ""
#undef ASM_ARCH64_SPEC
#define ASM_ARCH64_SPEC ""
#undef ASM_ARCH_DEFAULT_SPEC
#define ASM_ARCH_DEFAULT_SPEC ""
#undef SUBTARGET_EXTRA_SPECS
#define SUBTARGET_EXTRA_SPECS \
{ "link_arch32", LINK_ARCH32_SPEC }, \
{ "link_arch64", LINK_ARCH64_SPEC }, \
{ "link_arch_default", LINK_ARCH_DEFAULT_SPEC }, \
{ "link_arch", LINK_ARCH_SPEC },
/* This should be the same as in svr4.h, except with -R added. */
#define LINK_ARCH32_SPEC \
"%{G:-G} \
%{YP,*} \
%{R*} \
%{compat-bsd: \
%{!YP,*:%{p:-Y P,/usr/ucblib:/usr/ccs/lib/libp:/usr/lib/libp:/usr/ccs/lib:/usr/lib} \
%{pg:-Y P,/usr/ucblib:/usr/ccs/lib/libp:/usr/lib/libp:/usr/ccs/lib:/usr/lib} \
%{!p:%{!pg:-Y P,/usr/ucblib:/usr/ccs/lib:/usr/lib}}} \
-R /usr/ucblib} \
%{!compat-bsd: \
%{!YP,*:%{p:-Y P,/usr/ccs/lib/libp:/usr/lib/libp:/usr/ccs/lib:/usr/lib} \
%{pg:-Y P,/usr/ccs/lib/libp:/usr/lib/libp:/usr/ccs/lib:/usr/lib} \
%{!p:%{!pg:-Y P,/usr/ccs/lib:/usr/lib}}}}"
#define LINK_ARCH64_SPEC \
"%{mcmodel=medlow:-M /usr/lib/ld/sparcv9/map.below4G} \
%{G:-G} \
%{YP,*} \
%{R*} \
%{compat-bsd: \
%{!YP,*:%{p:-Y P,/usr/ucblib/sparcv9:/usr/lib/libp/sparcv9:/usr/lib/sparcv9} \
%{pg:-Y P,/usr/ucblib/sparcv9:/usr/lib/libp/sparcv9:/usr/lib/sparcv9} \
%{!p:%{!pg:-Y P,/usr/ucblib/sparcv9:/usr/lib/sparcv9}}} \
-R /usr/ucblib} \
%{!compat-bsd: \
%{!YP,*:%{p:-Y P,/usr/lib/libp/sparcv9:/usr/lib/sparcv9} \
%{pg:-Y P,/usr/lib/libp/sparcv9:/usr/lib/sparcv9} \
%{!p:%{!pg:-Y P,/usr/lib/sparcv9}}}}"
#define LINK_ARCH_SPEC "\
%{m32:%(link_arch32)} \
%{m64:%(link_arch64)} \
%{!m32:%{!m64:%(link_arch_default)}} \
"
#define LINK_ARCH_DEFAULT_SPEC \
(DEFAULT_ARCH32_P ? LINK_ARCH32_SPEC : LINK_ARCH64_SPEC)
#undef LINK_SPEC
#define LINK_SPEC \
"%{h*} %{v:-V} \
%{b} %{Wl,*:%*} \
%{static:-dn -Bstatic} \
%{shared:-G -dy %{!mimpure-text:-z text}} \
%{symbolic:-Bsymbolic -G -dy -z text} \
%(link_arch) \
%{Qy:} %{!Qn:-Qy}"
#undef CC1_SPEC
#if DEFAULT_ARCH32_P
#define CC1_SPEC "\
%{sun4:} %{target:} \
%{mcypress:-mcpu=cypress} \
%{msparclite:-mcpu=sparclite} %{mf930:-mcpu=f930} %{mf934:-mcpu=f934} \
%{mv8:-mcpu=v8} %{msupersparc:-mcpu=supersparc} \
%{m64:-mptr64 -mstack-bias -mno-v8plus \
%{!mcpu*:%{!mcypress:%{!msparclite:%{!mf930:%{!mf934:%{!mv8*:%{!msupersparc:-mcpu=v9}}}}}}}} \
"
#else
#define CC1_SPEC "\
%{sun4:} %{target:} \
%{mcypress:-mcpu=cypress} \
%{msparclite:-mcpu=sparclite} %{mf930:-mcpu=f930} %{mf934:-mcpu=f934} \
%{mv8:-mcpu=v8} %{msupersparc:-mcpu=supersparc} \
%{m32:-mptr32 -mno-stack-bias \
%{!mcpu*:%{!mcypress:%{!msparclite:%{!mf930:%{!mf934:%{!mv8*:%{!msupersparc:-mcpu=cypress}}}}}}}} \
%{mv8plus:-m32 -mptr32 -mno-stack-bias \
%{!mcpu*:%{!mcypress:%{!msparclite:%{!mf930:%{!mf934:%{!mv8:%{!msupersparc:-mcpu=v9}}}}}}}} \
"
#endif
#if DEFAULT_ARCH32_P
#define MULTILIB_DEFAULTS { "m32" }
#else
#define MULTILIB_DEFAULTS { "m64" }
#endif
#else /* !SPARC_BI_ARCH */
/*
* This should be the same as in sol2-sld.h, except with "/sparcv9"
* appended to the paths and /usr/ccs/lib is no longer necessary
*/
#undef LINK_SPEC
#define LINK_SPEC \
"%{h*} %{v:-V} \
%{b} %{Wl,*:%*} \
%{static:-dn -Bstatic} \
%{shared:-G -dy %{!mimpure-text:-z text}} \
%{symbolic:-Bsymbolic -G -dy -z text} \
%{mcmodel=medlow:-M /usr/lib/ld/sparcv9/map.below4G} \
%{G:-G} \
%{YP,*} \
%{R*} \
%{compat-bsd: \
%{!YP,*:%{p:-Y P,/usr/ucblib/sparcv9:/usr/lib/libp/sparcv9:/usr/lib/sparcv9} \
%{pg:-Y P,/usr/ucblib/sparcv9:/usr/lib/libp/sparcv9:/usr/lib/sparcv9} \
%{!p:%{!pg:-Y P,/usr/ucblib/sparcv9:/usr/lib/sparcv9}}} \
-R /usr/ucblib} \
%{!compat-bsd: \
%{!YP,*:%{p:-Y P,/usr/lib/libp/sparcv9:/usr/lib/sparcv9} \
%{pg:-Y P,/usr/lib/libp/sparcv9:/usr/lib/sparcv9} \
%{!p:%{!pg:-Y P,/usr/lib/sparcv9}}}} \
%{Qy:} %{!Qn:-Qy}"
#undef MD_STARTFILE_PREFIX
#define MD_STARTFILE_PREFIX "/usr/lib/sparcv9/"
#endif /* ! SPARC_BI_ARCH */
#endif

9
contrib/gcc/config/sparc/sol2-sld.h
View File

@ -1,9 +0,0 @@
/* Definitions of target machine for GNU compiler, for SPARC running Solaris 2
using the system linker. */
/* At least up through Solaris 2.6,
the system linker does not work with DWARF or DWARF2,
since it does not have working support for relocations
to unaligned data. */
#define LINKER_DOES_NOT_WORK_WITH_DWARF2

2
contrib/gcc/config/sparc/t-sp64
View File

@ -1,2 +0,0 @@
LIBGCC1 =
CROSS_LIBGCC1 =

7
contrib/gcc/config/sparc/t-sunos40
View File

@ -1,7 +0,0 @@
# SunOS 4.0.*
# /bin/as doesn't recognize the v8 instructions, so we can't do a v8
# multilib build.
LIBGCC1 =
CROSS_LIBGCC1 =
LIBGCC1_TEST =

2
contrib/gcc/config/sparc/x-sysv4
View File

@ -1,2 +0,0 @@
X_CFLAGS=-DSVR4
ALLOCA=alloca.o

26
contrib/gcc/config/sparc/xm-linux.h
View File

@ -1,26 +0,0 @@
/* Configuration for GCC for SPARC running Linux-based GNU systems.
Copyright (C) 1996, 1997 Free Software Foundation, Inc.
Contributed by Eddie C. Dost (ecd@skynet.be)
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#ifndef inhibit_libc
#include <alloca.h>
#include <stdlib.h>
#include <string.h>
#endif

39
contrib/gcc/config/sparc/xm-lynx.h
View File

@ -1,39 +0,0 @@
/* Configuration for GNU C-compiler for sparc platforms running LynxOS.
Copyright (C) 1995 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <xm-lynx.h>
/* This describes the machine the compiler is hosted on. */
#define HOST_BITS_PER_CHAR 8
#define HOST_BITS_PER_SHORT 16
#define HOST_BITS_PER_INT 32
#define HOST_BITS_PER_LONG 32
#define HOST_BITS_PER_LONGLONG 64
#define HOST_WORDS_BIG_ENDIAN 1
/* Include <sys/wait.h> to define the exit status access macros. */
#include <sys/types.h>
#include <sys/wait.h>
/* target machine dependencies.
tm.h is a symbolic link to the actual target specific file. */
#include "tm.h"

23
contrib/gcc/config/sparc/xm-openbsd.h
View File

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

10
contrib/gcc/config/sparc/xm-pbd.h
View File

@ -1,10 +0,0 @@
/* Host environment for the tti "Unicom" PBB 68020 boards */
#include "sparc/xm-sparc.h"
#define USG
#ifndef __GNUC__
#define USE_C_ALLOCA
#endif

4
contrib/gcc/config/sparc/xm-sol2.h
View File

@ -1,4 +0,0 @@
/* If not compiled with GNU C, include the system's <alloca.h> header. */
#ifndef __GNUC__
#include <alloca.h>
#endif

27
contrib/gcc/config/sparc/xm-sp64.h
View File

@ -1,27 +0,0 @@
/* Configuration for GCC for Sparc v9 running 64-bit native.
Copyright (C) 1997 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <sparc/xm-sparc.h>
/* This describes the machine the compiler is hosted on. */
#if defined(__arch64__) || defined(__sparc_v9__) || defined(__sparcv9)
#undef HOST_BITS_PER_LONG
#define HOST_BITS_PER_LONG 64
#endif

49
contrib/gcc/config/sparc/xm-sparc.h
View File

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

27
contrib/gcc/config/sparc/xm-sysv4-64.h
View File

@ -1,27 +0,0 @@
/* Configuration for GCC for Sparc v9 running 64-bit native.
Copyright (C) 1998 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <sparc/xm-sysv4.h>
/* This describes the machine the compiler is hosted on. */
#if defined(__arch64__) || defined(__sparc_v9__) || defined(__sparcv9)
#undef HOST_BITS_PER_LONG
#define HOST_BITS_PER_LONG 64
#endif

48
contrib/gcc/config/sparc/xm-sysv4.h
View File

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

5
contrib/gcc/config/x-linux
View File

@ -1,5 +0,0 @@
# Don't run fixproto
STMP_FIXPROTO =
# Don't install "assert.h" in gcc. We use the one in glibc.
INSTALL_ASSERT_H =

14
contrib/gcc/config/x-linux-aout
View File

@ -1,14 +0,0 @@
# It is defined in config/xm-linux.h.
# X_CFLAGS = -DPOSIX
# The following is needed when compiling stages 2 and 3 because gcc's
# limits.h must be picked up before /usr/include/limits.h. This is because
# each does an #include_next of the other if the other hasn't been included.
# /usr/include/limits.h loses if it gets found first because /usr/include is
# at the end of the search order. When a new version of gcc is released,
# gcc's limits.h hasn't been installed yet and hence isn't found.
# BOOT_CFLAGS = -O $(CFLAGS) -Iinclude
# Don't run fixproto
# STMP_FIXPROTO =

6
contrib/gcc/config/x-lynx
View File

@ -1,6 +0,0 @@
# /bin/cc is hopelessly broken, so we must use /bin/gcc instead.
CC = $(OLDCC)
OLDCC = /bin/gcc
# /bin/sh is too buggy, so use /bin/bash instead.
SHELL = /bin/bash

9
contrib/gcc/config/x-svr4
View File

@ -1,9 +0,0 @@
# Some versions of SVR4 have an alloca in /usr/ucblib/libucb.a, and if we are
# careful to link that in after libc we can use it, but since newer versions of
# SVR4 are dropping libucb, it is better to just use the portable C version for
# bootstrapping. Do this by defining ALLOCA.
ALLOCA = alloca.o
# See all the declarations.
FIXPROTO_DEFINES = -D_XOPEN_SOURCE

4
contrib/gcc/config/xm-alloca.h
View File

@ -1,4 +0,0 @@
/* If not compiled with GNU C, use the portable alloca. */
#ifndef __GNUC__
#define USE_C_ALLOCA
#endif

24
contrib/gcc/config/xm-freebsd.h
View File

@ -1,24 +0,0 @@
/* Configuration for GNU C-compiler for hosts running FreeBSD.
Copyright (C) 1994, 1995 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* This file defines machine-independent things specific to a host
running FreeBSD. This file should not be specified as $xm_file itself;
instead $xm_file should be CPU/xm-freebsd.h, which should include both
CPU/xm-CPU.h and this file xm-freebsd.h. */

32
contrib/gcc/config/xm-gnu.h
View File

@ -1,32 +0,0 @@
/* Configuration for GNU C-compiler for hosts running GNU.
Copyright (C) 1994, 1995, 1997 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* This file defines machine-independent things specific to a host
running GNU. This file should not be specified as $xm_file itself;
instead $xm_file should be CPU/xm-gnu.h, which should include both
CPU/xm-CPU.h and this file xm-gnu.h. */
#define POSIX /* GNU complies to POSIX.1. */
#ifndef inhibit_libc
/* Get a definition of O_RDONLY; some of the GCC files don't include this
properly and will define it themselves to be zero. */
#include <fcntl.h>
#endif

77
contrib/gcc/config/xm-interix.h
View File

@ -1,77 +0,0 @@
/* Configuration for GNU compiler for processor running Interix
Copyright (C) 1993, 1995, 1999 Free Software Foundation, Inc.
Donn Terry, Softway Systems, Inc,
from code
Contributed by Douglas B. Rupp (drupp@cs.washington.edu)
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#ifndef USG
#define USG 1
#endif
#ifndef ONLY_INT_FIELDS
#ifndef __GNUC__
#define ONLY_INT_FIELDS 1
#endif
#endif
#ifndef USE_PROTOTYPES
#define USE_PROTOTYPES 1
#endif
/* If not compiled with GNU C, use the portable alloca. */
#ifndef __GNUC__
#define USE_C_ALLOCA 1
#endif
#define NO_SYS_SIGLIST 1
/* Our strategy for finding global constructors is a bit different, although
not a lot. */
#define DO_GLOBAL_CTORS_BODY \
do { \
int i; \
unsigned long nptrs; \
func_ptr *p; \
asm( \
" .section .ctor_head, \"rw\"\n" \
"1:\n" \
" .text \n" \
ASM_LOAD_ADDR(1b,%0) \
: "=r" (p) : : "cc"); \
for (nptrs = 0; p[nptrs] != 0; nptrs++); \
for (i = nptrs-1; i >= 0; i--) \
p[i] (); \
} while (0)
#define DO_GLOBAL_DTORS_BODY \
do { \
func_ptr *p; \
asm( \
" .section .dtor_head, \"rw\"\n" \
"1:\n" \
" .text \n" \
ASM_LOAD_ADDR(1b,%0) \
: "=r" (p) : : "cc"); \
while (*p) \
{ \
p++; \
(*(p-1)) (); \
} \
} while (0)

33
contrib/gcc/config/xm-linux.h
View File

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

51
contrib/gcc/config/xm-lynx.h
View File

@ -1,51 +0,0 @@
/* Configuration for GNU C-compiler for Lynx.
Copyright (C) 1993, 1995 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* This file defines machine-independent things specific to a host
running Lynx. This file should not be specified as $xm_file itself;
instead $xm_file should be CPU/xm-lynx.h, which should include this one. */
/* #defines that need visibility everywhere. */
#define FALSE 0
#define TRUE 1
/* Arguments to use with `exit'. */
#define SUCCESS_EXIT_CODE 0
#define FATAL_EXIT_CODE 33
/* Lynx has no vfork system call. */
#define vfork fork
/* Lynx has a non-standard mktemp function. */
/* ??? This is simpler than creating YATM: Yet Another Target Macro. */
#define mktemp lynx_mktemp
#define lynx_mktemp(template) \
do { \
int pid = getpid (); \
char *t = template; \
char *p; \
p = t + strlen (t); \
while (*--p == 'X') \
{ \
*p = (pid % 10) + '0'; \
pid /= 10; \
} \
} while (0)

35
contrib/gcc/config/xm-openbsd.h
View File

@ -1,35 +0,0 @@
/* Configuration fragment for hosts running a version of OpenBSD.
Copyright (C) 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* This file gets included by all architectures. It holds stuff
that ought to be defined when hosting a compiler on an OpenBSD
machine, independently of the architecture. It's included by
${cpu_type}/xm-openbsd.h, not included directly. */
/* OpenBSD is trying to be POSIX-compliant, to the point of fixing
problems that may occur with gcc's interpretation. */
#undef POSIX
#define POSIX
/* Ensure we get gnu C's defaults. */
#ifdef __GNUC__
#define alloca __builtin_alloca
#endif

6
contrib/gcc/config/xm-siglist.h
View File

@ -1,6 +0,0 @@
/* Some systems provide no sys_siglist, but do offer the same data under
another name. */
#define sys_siglist _sys_siglist
#undef SYS_SIGLIST_DECLARED
#define SYS_SIGLIST_DECLARED

34
contrib/gcc/config/xm-std32.h
View File

@ -1,34 +0,0 @@
/* Configuration for GNU C-compiler for standard 32-bit host machine.
Copyright (C) 1997 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* #defines that need visibility everywhere. */
#define FALSE 0
#define TRUE 1
/* This describes the machine the compiler is hosted on. */
#define HOST_BITS_PER_CHAR 8
#define HOST_BITS_PER_SHORT 16
#define HOST_BITS_PER_INT 32
#define HOST_BITS_PER_LONG 32
#define HOST_BITS_PER_LONGLONG 64
/* Arguments to use with `exit'. */
#define SUCCESS_EXIT_CODE 0
#define FATAL_EXIT_CODE 33

25
contrib/gcc/config/xm-svr3.h
View File

@ -1,25 +0,0 @@
/* Configuration for GNU C-compiler for hosts running System V Release 3
Copyright (C) 1991, 1993, 1996 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#define USG
#ifndef SVR3
#define SVR3
#endif

29
contrib/gcc/config/xm-svr4.h
View File

@ -1,29 +0,0 @@
/* Configuration for GNU C-compiler for hosts running System V Release 4
Copyright (C) 1988, 1997 Free Software Foundation, Inc.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#define USG
#define POSIX
/* SVR4 provides no sys_siglist,
but does offer the same data under another name. */
#define sys_siglist _sys_siglist
#undef SYS_SIGLIST_DECLARED
#define SYS_SIGLIST_DECLARED

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