mirror of
https://gcc.gnu.org/git/gcc.git
synced 2026-02-22 12:00:03 -05:00
Compare commits
1 Commits
devel/m2li
...
prerelease
| Author | SHA1 | Date | |
|---|---|---|---|
|
7df95df047 |
32
.cvsignore
32
.cvsignore
@@ -1,32 +0,0 @@
|
||||
*-all
|
||||
*-co
|
||||
*-dirs
|
||||
*-done
|
||||
*-install-info
|
||||
*-src
|
||||
*-stamp-*
|
||||
*-tagged
|
||||
blockit
|
||||
cfg-paper.info
|
||||
config.status
|
||||
configure.aux
|
||||
configure.cp
|
||||
configure.cps
|
||||
configure.dvi
|
||||
configure.fn
|
||||
configure.fns
|
||||
configure.ky
|
||||
configure.kys
|
||||
configure.log
|
||||
configure.pg
|
||||
configure.pgs
|
||||
configure.toc
|
||||
configure.tp
|
||||
configure.tps
|
||||
configure.vr
|
||||
configure.vrs
|
||||
dir.info
|
||||
Makefile
|
||||
lost+found
|
||||
update.out
|
||||
LAST_UPDATED
|
||||
340
COPYING
340
COPYING
@@ -1,340 +0,0 @@
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
|
||||
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
License is intended to guarantee your freedom to share and change free
|
||||
software--to make sure the software is free for all its users. This
|
||||
General Public License applies to most of the Free Software
|
||||
Foundation's software and to any other program whose authors commit to
|
||||
using it. (Some other Free Software Foundation software is covered by
|
||||
the GNU Library General Public License instead.) You can apply it to
|
||||
your programs, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
this service if you wish), that you receive source code or can get it
|
||||
if you want it, that you can change the software or use pieces of it
|
||||
in new free programs; and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
anyone to deny you these rights or to ask you to surrender the rights.
|
||||
These restrictions translate to certain responsibilities for you if you
|
||||
distribute copies of the software, or if you modify it.
|
||||
|
||||
For example, if you distribute copies of such a program, whether
|
||||
gratis or for a fee, you must give the recipients all the rights that
|
||||
you have. You must make sure that they, too, receive or can get the
|
||||
source code. And you must show them these terms so they know their
|
||||
rights.
|
||||
|
||||
We protect your rights with two steps: (1) copyright the software, and
|
||||
(2) offer you this license which gives you legal permission to copy,
|
||||
distribute and/or modify the software.
|
||||
|
||||
Also, for each author's protection and ours, we want to make certain
|
||||
that everyone understands that there is no warranty for this free
|
||||
software. If the software is modified by someone else and passed on, we
|
||||
want its recipients to know that what they have is not the original, so
|
||||
that any problems introduced by others will not reflect on the original
|
||||
authors' reputations.
|
||||
|
||||
Finally, any free program is threatened constantly by software
|
||||
patents. We wish to avoid the danger that redistributors of a free
|
||||
program will individually obtain patent licenses, in effect making the
|
||||
program proprietary. To prevent this, we have made it clear that any
|
||||
patent must be licensed for everyone's free use or not licensed at all.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow.
|
||||
|
||||
GNU GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License applies to any program or other work which contains
|
||||
a notice placed by the copyright holder saying it may be distributed
|
||||
under the terms of this General Public License. The "Program", below,
|
||||
refers to any such program or work, and a "work based on the Program"
|
||||
means either the Program or any derivative work under copyright law:
|
||||
that is to say, a work containing the Program or a portion of it,
|
||||
either verbatim or with modifications and/or translated into another
|
||||
language. (Hereinafter, translation is included without limitation in
|
||||
the term "modification".) Each licensee is addressed as "you".
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running the Program is not restricted, and the output from the Program
|
||||
is covered only if its contents constitute a work based on the
|
||||
Program (independent of having been made by running the Program).
|
||||
Whether that is true depends on what the Program does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Program's
|
||||
source code as you receive it, in any medium, provided that you
|
||||
conspicuously and appropriately publish on each copy an appropriate
|
||||
copyright notice and disclaimer of warranty; keep intact all the
|
||||
notices that refer to this License and to the absence of any warranty;
|
||||
and give any other recipients of the Program a copy of this License
|
||||
along with the Program.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy, and
|
||||
you may at your option offer warranty protection in exchange for a fee.
|
||||
|
||||
2. You may modify your copy or copies of the Program or any portion
|
||||
of it, thus forming a work based on the Program, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) You must cause the modified files to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
b) You must cause any work that you distribute or publish, that in
|
||||
whole or in part contains or is derived from the Program or any
|
||||
part thereof, to be licensed as a whole at no charge to all third
|
||||
parties under the terms of this License.
|
||||
|
||||
c) If the modified program normally reads commands interactively
|
||||
when run, you must cause it, when started running for such
|
||||
interactive use in the most ordinary way, to print or display an
|
||||
announcement including an appropriate copyright notice and a
|
||||
notice that there is no warranty (or else, saying that you provide
|
||||
a warranty) and that users may redistribute the program under
|
||||
these conditions, and telling the user how to view a copy of this
|
||||
License. (Exception: if the Program itself is interactive but
|
||||
does not normally print such an announcement, your work based on
|
||||
the Program is not required to print an announcement.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Program,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Program, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Program.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Program
|
||||
with the Program (or with a work based on the Program) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may copy and distribute the Program (or a work based on it,
|
||||
under Section 2) in object code or executable form under the terms of
|
||||
Sections 1 and 2 above provided that you also do one of the following:
|
||||
|
||||
a) Accompany it with the complete corresponding machine-readable
|
||||
source code, which must be distributed under the terms of Sections
|
||||
1 and 2 above on a medium customarily used for software interchange; or,
|
||||
|
||||
b) Accompany it with a written offer, valid for at least three
|
||||
years, to give any third party, for a charge no more than your
|
||||
cost of physically performing source distribution, a complete
|
||||
machine-readable copy of the corresponding source code, to be
|
||||
distributed under the terms of Sections 1 and 2 above on a medium
|
||||
customarily used for software interchange; or,
|
||||
|
||||
c) Accompany it with the information you received as to the offer
|
||||
to distribute corresponding source code. (This alternative is
|
||||
allowed only for noncommercial distribution and only if you
|
||||
received the program in object code or executable form with such
|
||||
an offer, in accord with Subsection b above.)
|
||||
|
||||
The source code for a work means the preferred form of the work for
|
||||
making modifications to it. For an executable work, complete source
|
||||
code means all the source code for all modules it contains, plus any
|
||||
associated interface definition files, plus the scripts used to
|
||||
control compilation and installation of the executable. However, as a
|
||||
special exception, the source code distributed need not include
|
||||
anything that is normally distributed (in either source or binary
|
||||
form) with the major components (compiler, kernel, and so on) of the
|
||||
operating system on which the executable runs, unless that component
|
||||
itself accompanies the executable.
|
||||
|
||||
If distribution of executable or object code is made by offering
|
||||
access to copy from a designated place, then offering equivalent
|
||||
access to copy the source code from the same place counts as
|
||||
distribution of the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
4. You may not copy, modify, sublicense, or distribute the Program
|
||||
except as expressly provided under this License. Any attempt
|
||||
otherwise to copy, modify, sublicense or distribute the Program is
|
||||
void, and will automatically terminate your rights under this License.
|
||||
However, parties who have received copies, or rights, from you under
|
||||
this License will not have their licenses terminated so long as such
|
||||
parties remain in full compliance.
|
||||
|
||||
5. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Program or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Program (or any work based on the
|
||||
Program), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Program or works based on it.
|
||||
|
||||
6. Each time you redistribute the Program (or any work based on the
|
||||
Program), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute or modify the Program subject to
|
||||
these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties to
|
||||
this License.
|
||||
|
||||
7. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Program at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Program by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Program.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under
|
||||
any particular circumstance, the balance of the section is intended to
|
||||
apply and the section as a whole is intended to apply in other
|
||||
circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system, which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
8. If the distribution and/or use of the Program is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Program under this License
|
||||
may add an explicit geographical distribution limitation excluding
|
||||
those countries, so that distribution is permitted only in or among
|
||||
countries not thus excluded. In such case, this License incorporates
|
||||
the limitation as if written in the body of this License.
|
||||
|
||||
9. The Free Software Foundation may publish revised and/or new versions
|
||||
of the General Public License from time to time. Such new versions will
|
||||
be similar in spirit to the present version, but may differ in detail to
|
||||
address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Program
|
||||
specifies a version number of this License which applies to it and "any
|
||||
later version", you have the option of following the terms and conditions
|
||||
either of that version or of any later version published by the Free
|
||||
Software Foundation. If the Program does not specify a version number of
|
||||
this License, you may choose any version ever published by the Free Software
|
||||
Foundation.
|
||||
|
||||
10. If you wish to incorporate parts of the Program into other free
|
||||
programs whose distribution conditions are different, write to the author
|
||||
to ask for permission. For software which is copyrighted by the Free
|
||||
Software Foundation, write to the Free Software Foundation; we sometimes
|
||||
make exceptions for this. Our decision will be guided by the two goals
|
||||
of preserving the free status of all derivatives of our free software and
|
||||
of promoting the sharing and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
|
||||
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
|
||||
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
|
||||
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
|
||||
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
|
||||
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
|
||||
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
|
||||
REPAIR OR CORRECTION.
|
||||
|
||||
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
|
||||
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
|
||||
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
|
||||
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
|
||||
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
|
||||
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
|
||||
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Programs
|
||||
|
||||
If you develop a new program, and you want it to be of the greatest
|
||||
possible use to the public, the best way to achieve this is to make it
|
||||
free software which everyone can redistribute and change under these terms.
|
||||
|
||||
To do so, attach the following notices to the program. It is safest
|
||||
to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least
|
||||
the "copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the program's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This program is free software; you can redistribute it and/or modify
|
||||
it under the terms of the GNU General Public License as published by
|
||||
the Free Software Foundation; either version 2 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
If the program is interactive, make it output a short notice like this
|
||||
when it starts in an interactive mode:
|
||||
|
||||
Gnomovision version 69, Copyright (C) year name of author
|
||||
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
|
||||
This is free software, and you are welcome to redistribute it
|
||||
under certain conditions; type `show c' for details.
|
||||
|
||||
The hypothetical commands `show w' and `show c' should show the appropriate
|
||||
parts of the General Public License. Of course, the commands you use may
|
||||
be called something other than `show w' and `show c'; they could even be
|
||||
mouse-clicks or menu items--whatever suits your program.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the program, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
|
||||
`Gnomovision' (which makes passes at compilers) written by James Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1989
|
||||
Ty Coon, President of Vice
|
||||
|
||||
This General Public License does not permit incorporating your program into
|
||||
proprietary programs. If your program is a subroutine library, you may
|
||||
consider it more useful to permit linking proprietary applications with the
|
||||
library. If this is what you want to do, use the GNU Library General
|
||||
Public License instead of this License.
|
||||
504
COPYING.LIB
504
COPYING.LIB
@@ -1,504 +0,0 @@
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
Version 2.1, February 1999
|
||||
|
||||
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
|
||||
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
[This is the first released version of the Lesser GPL. It also counts
|
||||
as the successor of the GNU Library Public License, version 2, hence
|
||||
the version number 2.1.]
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
Licenses are intended to guarantee your freedom to share and change
|
||||
free software--to make sure the software is free for all its users.
|
||||
|
||||
This license, the Lesser General Public License, applies to some
|
||||
specially designated software packages--typically libraries--of the
|
||||
Free Software Foundation and other authors who decide to use it. You
|
||||
can use it too, but we suggest you first think carefully about whether
|
||||
this license or the ordinary General Public License is the better
|
||||
strategy to use in any particular case, based on the explanations below.
|
||||
|
||||
When we speak of free software, we are referring to freedom of use,
|
||||
not price. Our General Public Licenses are designed to make sure that
|
||||
you have the freedom to distribute copies of free software (and charge
|
||||
for this service if you wish); that you receive source code or can get
|
||||
it if you want it; that you can change the software and use pieces of
|
||||
it in new free programs; and that you are informed that you can do
|
||||
these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
distributors to deny you these rights or to ask you to surrender these
|
||||
rights. These restrictions translate to certain responsibilities for
|
||||
you if you distribute copies of the library or if you modify it.
|
||||
|
||||
For example, if you distribute copies of the library, whether gratis
|
||||
or for a fee, you must give the recipients all the rights that we gave
|
||||
you. You must make sure that they, too, receive or can get the source
|
||||
code. If you link other code with the library, you must provide
|
||||
complete object files to the recipients, so that they can relink them
|
||||
with the library after making changes to the library and recompiling
|
||||
it. And you must show them these terms so they know their rights.
|
||||
|
||||
We protect your rights with a two-step method: (1) we copyright the
|
||||
library, and (2) we offer you this license, which gives you legal
|
||||
permission to copy, distribute and/or modify the library.
|
||||
|
||||
To protect each distributor, we want to make it very clear that
|
||||
there is no warranty for the free library. Also, if the library is
|
||||
modified by someone else and passed on, the recipients should know
|
||||
that what they have is not the original version, so that the original
|
||||
author's reputation will not be affected by problems that might be
|
||||
introduced by others.
|
||||
|
||||
Finally, software patents pose a constant threat to the existence of
|
||||
any free program. We wish to make sure that a company cannot
|
||||
effectively restrict the users of a free program by obtaining a
|
||||
restrictive license from a patent holder. Therefore, we insist that
|
||||
any patent license obtained for a version of the library must be
|
||||
consistent with the full freedom of use specified in this license.
|
||||
|
||||
Most GNU software, including some libraries, is covered by the
|
||||
ordinary GNU General Public License. This license, the GNU Lesser
|
||||
General Public License, applies to certain designated libraries, and
|
||||
is quite different from the ordinary General Public License. We use
|
||||
this license for certain libraries in order to permit linking those
|
||||
libraries into non-free programs.
|
||||
|
||||
When a program is linked with a library, whether statically or using
|
||||
a shared library, the combination of the two is legally speaking a
|
||||
combined work, a derivative of the original library. The ordinary
|
||||
General Public License therefore permits such linking only if the
|
||||
entire combination fits its criteria of freedom. The Lesser General
|
||||
Public License permits more lax criteria for linking other code with
|
||||
the library.
|
||||
|
||||
We call this license the "Lesser" General Public License because it
|
||||
does Less to protect the user's freedom than the ordinary General
|
||||
Public License. It also provides other free software developers Less
|
||||
of an advantage over competing non-free programs. These disadvantages
|
||||
are the reason we use the ordinary General Public License for many
|
||||
libraries. However, the Lesser license provides advantages in certain
|
||||
special circumstances.
|
||||
|
||||
For example, on rare occasions, there may be a special need to
|
||||
encourage the widest possible use of a certain library, so that it becomes
|
||||
a de-facto standard. To achieve this, non-free programs must be
|
||||
allowed to use the library. A more frequent case is that a free
|
||||
library does the same job as widely used non-free libraries. In this
|
||||
case, there is little to gain by limiting the free library to free
|
||||
software only, so we use the Lesser General Public License.
|
||||
|
||||
In other cases, permission to use a particular library in non-free
|
||||
programs enables a greater number of people to use a large body of
|
||||
free software. For example, permission to use the GNU C Library in
|
||||
non-free programs enables many more people to use the whole GNU
|
||||
operating system, as well as its variant, the GNU/Linux operating
|
||||
system.
|
||||
|
||||
Although the Lesser General Public License is Less protective of the
|
||||
users' freedom, it does ensure that the user of a program that is
|
||||
linked with the Library has the freedom and the wherewithal to run
|
||||
that program using a modified version of the Library.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow. Pay close attention to the difference between a
|
||||
"work based on the library" and a "work that uses the library". The
|
||||
former contains code derived from the library, whereas the latter must
|
||||
be combined with the library in order to run.
|
||||
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License Agreement applies to any software library or other
|
||||
program which contains a notice placed by the copyright holder or
|
||||
other authorized party saying it may be distributed under the terms of
|
||||
this Lesser General Public License (also called "this License").
|
||||
Each licensee is addressed as "you".
|
||||
|
||||
A "library" means a collection of software functions and/or data
|
||||
prepared so as to be conveniently linked with application programs
|
||||
(which use some of those functions and data) to form executables.
|
||||
|
||||
The "Library", below, refers to any such software library or work
|
||||
which has been distributed under these terms. A "work based on the
|
||||
Library" means either the Library or any derivative work under
|
||||
copyright law: that is to say, a work containing the Library or a
|
||||
portion of it, either verbatim or with modifications and/or translated
|
||||
straightforwardly into another language. (Hereinafter, translation is
|
||||
included without limitation in the term "modification".)
|
||||
|
||||
"Source code" for a work means the preferred form of the work for
|
||||
making modifications to it. For a library, complete source code means
|
||||
all the source code for all modules it contains, plus any associated
|
||||
interface definition files, plus the scripts used to control compilation
|
||||
and installation of the library.
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running a program using the Library is not restricted, and output from
|
||||
such a program is covered only if its contents constitute a work based
|
||||
on the Library (independent of the use of the Library in a tool for
|
||||
writing it). Whether that is true depends on what the Library does
|
||||
and what the program that uses the Library does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Library's
|
||||
complete source code as you receive it, in any medium, provided that
|
||||
you conspicuously and appropriately publish on each copy an
|
||||
appropriate copyright notice and disclaimer of warranty; keep intact
|
||||
all the notices that refer to this License and to the absence of any
|
||||
warranty; and distribute a copy of this License along with the
|
||||
Library.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy,
|
||||
and you may at your option offer warranty protection in exchange for a
|
||||
fee.
|
||||
|
||||
2. You may modify your copy or copies of the Library or any portion
|
||||
of it, thus forming a work based on the Library, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) The modified work must itself be a software library.
|
||||
|
||||
b) You must cause the files modified to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
c) You must cause the whole of the work to be licensed at no
|
||||
charge to all third parties under the terms of this License.
|
||||
|
||||
d) If a facility in the modified Library refers to a function or a
|
||||
table of data to be supplied by an application program that uses
|
||||
the facility, other than as an argument passed when the facility
|
||||
is invoked, then you must make a good faith effort to ensure that,
|
||||
in the event an application does not supply such function or
|
||||
table, the facility still operates, and performs whatever part of
|
||||
its purpose remains meaningful.
|
||||
|
||||
(For example, a function in a library to compute square roots has
|
||||
a purpose that is entirely well-defined independent of the
|
||||
application. Therefore, Subsection 2d requires that any
|
||||
application-supplied function or table used by this function must
|
||||
be optional: if the application does not supply it, the square
|
||||
root function must still compute square roots.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Library,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Library, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote
|
||||
it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Library.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Library
|
||||
with the Library (or with a work based on the Library) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may opt to apply the terms of the ordinary GNU General Public
|
||||
License instead of this License to a given copy of the Library. To do
|
||||
this, you must alter all the notices that refer to this License, so
|
||||
that they refer to the ordinary GNU General Public License, version 2,
|
||||
instead of to this License. (If a newer version than version 2 of the
|
||||
ordinary GNU General Public License has appeared, then you can specify
|
||||
that version instead if you wish.) Do not make any other change in
|
||||
these notices.
|
||||
|
||||
Once this change is made in a given copy, it is irreversible for
|
||||
that copy, so the ordinary GNU General Public License applies to all
|
||||
subsequent copies and derivative works made from that copy.
|
||||
|
||||
This option is useful when you wish to copy part of the code of
|
||||
the Library into a program that is not a library.
|
||||
|
||||
4. You may copy and distribute the Library (or a portion or
|
||||
derivative of it, under Section 2) in object code or executable form
|
||||
under the terms of Sections 1 and 2 above provided that you accompany
|
||||
it with the complete corresponding machine-readable source code, which
|
||||
must be distributed under the terms of Sections 1 and 2 above on a
|
||||
medium customarily used for software interchange.
|
||||
|
||||
If distribution of object code is made by offering access to copy
|
||||
from a designated place, then offering equivalent access to copy the
|
||||
source code from the same place satisfies the requirement to
|
||||
distribute the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
5. A program that contains no derivative of any portion of the
|
||||
Library, but is designed to work with the Library by being compiled or
|
||||
linked with it, is called a "work that uses the Library". Such a
|
||||
work, in isolation, is not a derivative work of the Library, and
|
||||
therefore falls outside the scope of this License.
|
||||
|
||||
However, linking a "work that uses the Library" with the Library
|
||||
creates an executable that is a derivative of the Library (because it
|
||||
contains portions of the Library), rather than a "work that uses the
|
||||
library". The executable is therefore covered by this License.
|
||||
Section 6 states terms for distribution of such executables.
|
||||
|
||||
When a "work that uses the Library" uses material from a header file
|
||||
that is part of the Library, the object code for the work may be a
|
||||
derivative work of the Library even though the source code is not.
|
||||
Whether this is true is especially significant if the work can be
|
||||
linked without the Library, or if the work is itself a library. The
|
||||
threshold for this to be true is not precisely defined by law.
|
||||
|
||||
If such an object file uses only numerical parameters, data
|
||||
structure layouts and accessors, and small macros and small inline
|
||||
functions (ten lines or less in length), then the use of the object
|
||||
file is unrestricted, regardless of whether it is legally a derivative
|
||||
work. (Executables containing this object code plus portions of the
|
||||
Library will still fall under Section 6.)
|
||||
|
||||
Otherwise, if the work is a derivative of the Library, you may
|
||||
distribute the object code for the work under the terms of Section 6.
|
||||
Any executables containing that work also fall under Section 6,
|
||||
whether or not they are linked directly with the Library itself.
|
||||
|
||||
6. As an exception to the Sections above, you may also combine or
|
||||
link a "work that uses the Library" with the Library to produce a
|
||||
work containing portions of the Library, and distribute that work
|
||||
under terms of your choice, provided that the terms permit
|
||||
modification of the work for the customer's own use and reverse
|
||||
engineering for debugging such modifications.
|
||||
|
||||
You must give prominent notice with each copy of the work that the
|
||||
Library is used in it and that the Library and its use are covered by
|
||||
this License. You must supply a copy of this License. If the work
|
||||
during execution displays copyright notices, you must include the
|
||||
copyright notice for the Library among them, as well as a reference
|
||||
directing the user to the copy of this License. Also, you must do one
|
||||
of these things:
|
||||
|
||||
a) Accompany the work with the complete corresponding
|
||||
machine-readable source code for the Library including whatever
|
||||
changes were used in the work (which must be distributed under
|
||||
Sections 1 and 2 above); and, if the work is an executable linked
|
||||
with the Library, with the complete machine-readable "work that
|
||||
uses the Library", as object code and/or source code, so that the
|
||||
user can modify the Library and then relink to produce a modified
|
||||
executable containing the modified Library. (It is understood
|
||||
that the user who changes the contents of definitions files in the
|
||||
Library will not necessarily be able to recompile the application
|
||||
to use the modified definitions.)
|
||||
|
||||
b) Use a suitable shared library mechanism for linking with the
|
||||
Library. A suitable mechanism is one that (1) uses at run time a
|
||||
copy of the library already present on the user's computer system,
|
||||
rather than copying library functions into the executable, and (2)
|
||||
will operate properly with a modified version of the library, if
|
||||
the user installs one, as long as the modified version is
|
||||
interface-compatible with the version that the work was made with.
|
||||
|
||||
c) Accompany the work with a written offer, valid for at
|
||||
least three years, to give the same user the materials
|
||||
specified in Subsection 6a, above, for a charge no more
|
||||
than the cost of performing this distribution.
|
||||
|
||||
d) If distribution of the work is made by offering access to copy
|
||||
from a designated place, offer equivalent access to copy the above
|
||||
specified materials from the same place.
|
||||
|
||||
e) Verify that the user has already received a copy of these
|
||||
materials or that you have already sent this user a copy.
|
||||
|
||||
For an executable, the required form of the "work that uses the
|
||||
Library" must include any data and utility programs needed for
|
||||
reproducing the executable from it. However, as a special exception,
|
||||
the materials to be distributed need not include anything that is
|
||||
normally distributed (in either source or binary form) with the major
|
||||
components (compiler, kernel, and so on) of the operating system on
|
||||
which the executable runs, unless that component itself accompanies
|
||||
the executable.
|
||||
|
||||
It may happen that this requirement contradicts the license
|
||||
restrictions of other proprietary libraries that do not normally
|
||||
accompany the operating system. Such a contradiction means you cannot
|
||||
use both them and the Library together in an executable that you
|
||||
distribute.
|
||||
|
||||
7. You may place library facilities that are a work based on the
|
||||
Library side-by-side in a single library together with other library
|
||||
facilities not covered by this License, and distribute such a combined
|
||||
library, provided that the separate distribution of the work based on
|
||||
the Library and of the other library facilities is otherwise
|
||||
permitted, and provided that you do these two things:
|
||||
|
||||
a) Accompany the combined library with a copy of the same work
|
||||
based on the Library, uncombined with any other library
|
||||
facilities. This must be distributed under the terms of the
|
||||
Sections above.
|
||||
|
||||
b) Give prominent notice with the combined library of the fact
|
||||
that part of it is a work based on the Library, and explaining
|
||||
where to find the accompanying uncombined form of the same work.
|
||||
|
||||
8. You may not copy, modify, sublicense, link with, or distribute
|
||||
the Library except as expressly provided under this License. Any
|
||||
attempt otherwise to copy, modify, sublicense, link with, or
|
||||
distribute the Library is void, and will automatically terminate your
|
||||
rights under this License. However, parties who have received copies,
|
||||
or rights, from you under this License will not have their licenses
|
||||
terminated so long as such parties remain in full compliance.
|
||||
|
||||
9. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Library or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Library (or any work based on the
|
||||
Library), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Library or works based on it.
|
||||
|
||||
10. Each time you redistribute the Library (or any work based on the
|
||||
Library), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute, link with or modify the Library
|
||||
subject to these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties with
|
||||
this License.
|
||||
|
||||
11. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Library at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Library by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Library.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under any
|
||||
particular circumstance, the balance of the section is intended to apply,
|
||||
and the section as a whole is intended to apply in other circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
12. If the distribution and/or use of the Library is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Library under this License may add
|
||||
an explicit geographical distribution limitation excluding those countries,
|
||||
so that distribution is permitted only in or among countries not thus
|
||||
excluded. In such case, this License incorporates the limitation as if
|
||||
written in the body of this License.
|
||||
|
||||
13. The Free Software Foundation may publish revised and/or new
|
||||
versions of the Lesser General Public License from time to time.
|
||||
Such new versions will be similar in spirit to the present version,
|
||||
but may differ in detail to address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Library
|
||||
specifies a version number of this License which applies to it and
|
||||
"any later version", you have the option of following the terms and
|
||||
conditions either of that version or of any later version published by
|
||||
the Free Software Foundation. If the Library does not specify a
|
||||
license version number, you may choose any version ever published by
|
||||
the Free Software Foundation.
|
||||
|
||||
14. If you wish to incorporate parts of the Library into other free
|
||||
programs whose distribution conditions are incompatible with these,
|
||||
write to the author to ask for permission. For software which is
|
||||
copyrighted by the Free Software Foundation, write to the Free
|
||||
Software Foundation; we sometimes make exceptions for this. Our
|
||||
decision will be guided by the two goals of preserving the free status
|
||||
of all derivatives of our free software and of promoting the sharing
|
||||
and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
|
||||
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
|
||||
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
|
||||
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
|
||||
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
|
||||
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
|
||||
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
|
||||
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
|
||||
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
|
||||
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
|
||||
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
|
||||
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
|
||||
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
|
||||
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
|
||||
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
||||
DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
How to Apply These Terms to Your New Libraries
|
||||
|
||||
If you develop a new library, and you want it to be of the greatest
|
||||
possible use to the public, we recommend making it free software that
|
||||
everyone can redistribute and change. You can do so by permitting
|
||||
redistribution under these terms (or, alternatively, under the terms of the
|
||||
ordinary General Public License).
|
||||
|
||||
To apply these terms, attach the following notices to the library. It is
|
||||
safest to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least the
|
||||
"copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the library's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with this library; if not, write to the Free Software
|
||||
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the library, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the
|
||||
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1990
|
||||
Ty Coon, President of Vice
|
||||
|
||||
That's all there is to it!
|
||||
|
||||
|
||||
@@ -1,6 +0,0 @@
|
||||
This directory has been obsoleted for GCC snapshots and CVS access.
|
||||
|
||||
For releases the installation documentation is generated from
|
||||
gcc/doc/install.texi and copied into this directory.
|
||||
|
||||
To read this documentation, please point your HTML browser to "index.html".
|
||||
224
MAINTAINERS
224
MAINTAINERS
@@ -1,224 +0,0 @@
|
||||
Blanket Write Privs.
|
||||
|
||||
John Carr jfc@mit.edu
|
||||
Richard Earnshaw rearnsha@arm.com
|
||||
Richard Henderson rth@redhat.com
|
||||
Geoffrey Keating geoffk@redhat.com
|
||||
Richard Kenner kenner@nyu.edu
|
||||
Jeff Law law@redhat.com
|
||||
Jason Merrill jason@redhat.com
|
||||
Michael Meissner meissner@redhat.com
|
||||
David S. Miller davem@redhat.com
|
||||
Mark Mitchell mark@codesourcery.com
|
||||
Bernd Schmidt bernds@redhat.com
|
||||
Jim Wilson wilson@redhat.com
|
||||
|
||||
|
||||
CPU Port Maintainers (CPU alphabetical order)
|
||||
|
||||
a29k port Jim Wilson wilson@redhat.com
|
||||
alpha port Richard Henderson rth@redhat.com
|
||||
arc port Richard Kenner kenner@nyu.edu
|
||||
arm port Nick Clifton nickc@redhat.com
|
||||
arm port Richard Earnshaw rearnsha@arm.com
|
||||
avr port Denis Chertykov denisc@overta.ru
|
||||
avr port Marek Michalkiewicz marekm@linux.org.pl
|
||||
c4x port Michael Hayes m.hayes@elec.canterbury.ac.nz
|
||||
cris port Hans-Peter Nilsson hp@axis.com
|
||||
fr30 port Nick Clifton niclc@redhat.com
|
||||
h8 port Jeff Law law@redhat.com
|
||||
h8 port Kazu Hirata kazu@hxi.com
|
||||
hppa port Jeff Law law@redhat.com
|
||||
hppa port Dave Anglin dave.anglin@nrc.ca
|
||||
i860 port Jason Eckhardt jle@redhat.com
|
||||
i960 port Jim Wilson wilson@redhat.com
|
||||
ia64 port Jim Wilson wilson@redhat.com
|
||||
m32r port Nick Clifton nickc@redhat.com
|
||||
m32r port Michael Meissner meissner@redhat.com
|
||||
m68hc11 port Stephane Carrez Stephane.Carrez@worldnet.fr
|
||||
m68k port (?) Jeff Law law@redhat.com
|
||||
m68k-motorola-sysv port Philippe De Muyter phdm@macqel.be
|
||||
mcore port Nick Clifton nickc@redhat.com
|
||||
mips port Eric Christopher echristo@redhat.com
|
||||
mmix port Hans-Peter Nilsson hp@bitrange.com
|
||||
mn10200 port Jeff Law law@redhat.com
|
||||
mn10300 port Jeff Law law@redhat.com
|
||||
mn10300 port Alexandre Oliva aoliva@redhat.com
|
||||
rs6000 port Geoff Keating geoffk@redhat.com
|
||||
rs6000 port David Edelsohn dje@watson.ibm.com
|
||||
s390 port Hartmut Penner hpenner@de.ibm.com
|
||||
s390 port Ulrich Weigand uweigand@de.ibm.com
|
||||
sh port Joern Rennecke amylaar@onetel.net.uk
|
||||
sh port Alexandre Oliva aoliva@redhat.com
|
||||
sparc port Richard Henderson rth@redhat.com
|
||||
sparc port David S. Miller davem@redhat.com
|
||||
sparc port Jakub Jelinek jakub@redhat.com
|
||||
x86 ports Stan Cox scox@redhat.com
|
||||
xstormy16 port Geoffrey Keating geoffk@redhat.com
|
||||
v850 port Nick Clifton nickc@redhat.com
|
||||
v850 port Michael Meissner meissner@redhat.com
|
||||
vax port Dave Anglin dave.anglin@nrc.ca
|
||||
|
||||
OS Port Maintainers (OS alphabetical order)
|
||||
|
||||
darwin port Stan Shebs shebs@apple.com
|
||||
sco5, unixware, sco udk Robert Lipe robertlipe@usa.net
|
||||
|
||||
Various Maintainers
|
||||
|
||||
C front end/ISO C99 Joseph Myers jsm28@cam.ac.uk
|
||||
C front end/ISO C99 Richard Henderson rth@redhat.com
|
||||
Ada front end Geert Bosch bosch@gnat.com
|
||||
Ada front end Robert Dewar dewar@gnat.com
|
||||
fortran Richard Henderson rth@redhat.com
|
||||
fortran Toon Moene toon@moene.indiv.nluug.nl
|
||||
c++ Jason Merrill jason@redhat.com
|
||||
c++ Mark Mitchell mark@codesourcery.com
|
||||
chill Dave Brolley brolley@redhat.com
|
||||
chill Per Bothner per@bothner.com
|
||||
cpplib Dave Brolley brolley@redhat.com
|
||||
cpplib Per Bothner per@bothner.com
|
||||
cpplib Zack Weinberg zack@codesourcery.com
|
||||
cpplib Neil Booth neil@daikokuya.demon.co.uk
|
||||
java Per Bothner per@bothner.com
|
||||
java Alexandre Petit-Bianco apbianco@redhat.com
|
||||
mercury Fergus Henderson fjh@cs.mu.oz.au
|
||||
objective-c Stan Shebs shebs@apple.com
|
||||
objective-c Ovidiu Predescu ovidiu@cup.hp.com
|
||||
alias analysis John Carr jfc@mit.edu
|
||||
loop unrolling Jim Wilson wilson@redhat.com
|
||||
loop discovery Michael Hayes m.hayes@elec.canterbury.ac.nz
|
||||
scheduler (+ haifa) Jim Wilson wilson@redhat.com
|
||||
scheduler (+ haifa) Michael Meissner meissner@redhat.com
|
||||
scheduler (+ haifa) Jeff Law law@redhat.com
|
||||
reorg Jeff Law law@redhat.com
|
||||
caller-save.c Jeff Law law@redhat.com
|
||||
debugging code Jim Wilson wilson@redhat.com
|
||||
dwarf debugging code Jason Merrill jason@redhat.com
|
||||
c++ runtime libs Gabriel Dos Reis dosreis@cmla.ens-cachan.fr
|
||||
c++ runtime libs Ulrich Drepper drepper@redhat.com
|
||||
c++ runtime libs Phil Edwards pedwards@jaj.com
|
||||
c++ runtime libs Benjamin Kosnik bkoz@redhat.com
|
||||
*synthetic multiply Torbjorn Granlund tege@swox.com
|
||||
*c-torture Torbjorn Granlund tege@swox.com
|
||||
fixincludes Bruce Korb bkorb@gnu.org
|
||||
gcse.c Jeff Law law@redhat.com
|
||||
global opt framework Jeff Law law@redhat.com
|
||||
jump.c David S. Miller davem@redhat.com
|
||||
web pages Gerald Pfeifer pfeifer@dbai.tuwien.ac.at
|
||||
config.sub/config.guess Ben Elliston config-patches@gnu.org
|
||||
basic block reordering Jason Eckhardt jle@redhat.com
|
||||
i18n Philipp Thomas pthomas@suse.de
|
||||
diagnostic messages Gabriel Dos Reis gdr@codesourcery.com
|
||||
windows, cygwin, mingw Christopher Faylor cgf@redhat.com
|
||||
windows, cygwin, mingw DJ Delorie dj@redhat.com
|
||||
DJGPP DJ Delorie dj@delorie.com
|
||||
libiberty DJ Delorie dj@redhat.com
|
||||
build machinery (*.in) DJ Delorie dj@redhat.com
|
||||
build machinery (*.in) Alexandre Oliva aoliva@redhat.com
|
||||
docs co-maintainer Gerald Pfeifer pfeifer@dbai.tuwien.ac.at
|
||||
docs co-maintainer Joseph Myers jsm28@cam.ac.uk
|
||||
Pico-Java port Steve Chamberlain sac@transmeta.com
|
||||
RTEMS Ports Joel Sherrill
|
||||
predict.def Jan Hubicka jh@suse.cz
|
||||
|
||||
Note individuals who maintain parts of the compiler need approval to check
|
||||
in changes outside of the parts of the compiler they maintain.
|
||||
|
||||
|
||||
Write After Approval (last name alphabetical order)
|
||||
Scott Bambrough scottb@netwinder.org
|
||||
David Billinghurst David.Billinghurst@riotinto.com
|
||||
Laurynas Biveinis lauras@softhome.net
|
||||
Phil Blundell pb@futuretv.com
|
||||
Hans Boehm hboehm@gcc.gnu.org
|
||||
Andrew Cagney cagney@redhat.com
|
||||
Paolo Carlini pcarlini@unitus.it
|
||||
William Cohen wcohen@redhat.com
|
||||
*Paul Eggert eggert@twinsun.com
|
||||
Ben Elliston bje@redhat.com
|
||||
Marc Espie espie@cvs.openbsd.org
|
||||
Kaveh Ghazi ghazi@caip.rutgers.edu
|
||||
Anthony Green green@redhat.com
|
||||
Stu Grossman grossman@redhat.com
|
||||
Laurent Guerby guerby@acm.org
|
||||
Andrew Haley aph@redhat.com
|
||||
Aldy Hernandez aldyh@redhat.com
|
||||
Matthew Hiller hiller@redhat.com
|
||||
Kazu Hirata kazu@hxi.com
|
||||
Manfred Hollstein mhollstein@redhat.com
|
||||
Jan Hubicka hubicka@freesoft.cz
|
||||
Andreas Jaeger aj@suse.de
|
||||
Jakub Jelinek jakub@redhat.com
|
||||
Dale Johannesen dalej@apple.com
|
||||
Janis Johnson janis187@us.ibm.com
|
||||
Klaus Kaempf kkaempf@progis.de
|
||||
Brendan Kehoe brendan@zen.org
|
||||
Mumit Khan khan@xraylith.wisc.edu
|
||||
Matthias Klose doko@debian.org
|
||||
Jeff Knaggs jknaggs@redhat.com
|
||||
Matt Kraai kraai@alumni.carnegiemellon.edu
|
||||
Ziemowit Laski zlaski@apple.com
|
||||
Marc Lehmann pcg@goof.com
|
||||
Alan Lehotsky apl@alum.mit.edu
|
||||
Warren Levy warrenl@redhat.com
|
||||
Kriang Lerdsuwanakij lerdsuwa@users.sourceforge.net
|
||||
Don Lindsay dlindsay@redhat.com
|
||||
Dave Love d.love@dl.ac.uk
|
||||
Martin v. Löwis loewis@informatik.hu-berlin.de
|
||||
*HJ Lu hjl@lucon.org
|
||||
Andrew Macleod amacleod@redhat.com
|
||||
Vladimir Makarov vmakarov@redhat.com
|
||||
Greg McGary gkm@gnu.org
|
||||
Bryce McKinlay bryce@gcc.gnu.org
|
||||
Alan Modra amodra@bigpond.net.au
|
||||
Toon Moene toon@moene.indiv.nluug.nl
|
||||
Catherine Moore clm@redhat.com
|
||||
Diego Novillo dnovillo@redhat.com
|
||||
David O'Brien obrien@FreeBSD.org
|
||||
Turly O'Connor turly@apple.com
|
||||
Jeffrey D. Oldham oldham@codesourcery.com
|
||||
Rainer Orth ro@TechFak.Uni-Bielefeld.DE
|
||||
Nicola Pero n.pero@mi.flashnet.it
|
||||
Alexandre Petit-Bianco apbianco@redhat.com
|
||||
Clinton Popetz cpopetz@cpopetz.com
|
||||
Ken Raeburn raeburn@redhat.com
|
||||
Rolf Rasmussen rolfwr@gcc.gnu.org
|
||||
Gabriel Dos Reis dosreis@cmla.ens-cachan.fr
|
||||
Loren J. Rittle ljrittle@acm.org
|
||||
Craig Rodrigues rodrigc@gcc.gnu.org
|
||||
Gavin Romig-Koch gavin@redhat.com
|
||||
Alex Samuel samuel@codesourcery.com
|
||||
Richard Sandiford rsandifo@redhat.com
|
||||
Bernd Schmidt bernds@redhat.com
|
||||
Andreas Schwab schwab@suse.de
|
||||
Stan Shebs shebs@apple.com
|
||||
Nathan Sidwell nathan@acm.org
|
||||
Franz Sirl franz.sirl-kernel@lauterbach.com
|
||||
Michael Sokolov msokolov@ivan.Harhan.ORG
|
||||
Mike Stump mrs@windriver.com
|
||||
Ian Taylor ian@zembu.com
|
||||
Michael Tiemann tiemann@redhat.com
|
||||
Philipp Thomas pthomas@suse.de
|
||||
Kresten Krab Thorup krab@gcc.gnu.org
|
||||
Tom Tromey tromey@redhat.com
|
||||
John Wehle john@feith.com
|
||||
Mark Wielaard mark@gcc.gnu.org
|
||||
Graham Stott grahams@redhat.com
|
||||
Daniel Berlin dan@cgsoftware.com
|
||||
Jim Blandy jimb@redhat.com
|
||||
Chandra Chavva cchavva@redhat.com
|
||||
Chris Demetriou cgd@sibyte.com
|
||||
Doug Evans devans@transmeta.com
|
||||
Michael Matz
|
||||
Tom Rix trix@redhat.com
|
||||
Richard Stallman rms@gnu.org
|
||||
Graham Stott grahams@redhat.com
|
||||
Florian Weimer fw@deneb.enyo.de
|
||||
|
||||
GNATS only accounts
|
||||
Peter Bienstman(?)
|
||||
Benjamin Chelf(?)
|
||||
James Dennett(?)
|
||||
Mark Galassi(?)
|
||||
Jeff Strum(?)
|
||||
2106
Makefile.in
2106
Makefile.in
File diff suppressed because it is too large
Load Diff
17
README
17
README
@@ -1,17 +0,0 @@
|
||||
This directory contains the GNU Compiler Collection (GCC).
|
||||
|
||||
The GNU Compiler Collection is free software. See the file COPYING
|
||||
for copying permission. The manuals, and some of the runtime
|
||||
libraries, are under different terms; see the individual source files
|
||||
for details.
|
||||
|
||||
The directory INSTALL contains copies of the installation information
|
||||
as HTML and plain text. The source of this information is
|
||||
gcc/doc/install.texi. The installation information includes details
|
||||
of what is included in the GCC sources and what files GCC installs.
|
||||
|
||||
See the file gcc/doc/gcc.texi (together with other files that it
|
||||
includes) for usage and porting information. An online readable
|
||||
version of the manual is in the files gcc/doc/gcc.info*.
|
||||
|
||||
See http://gcc.gnu.org/bugs.html for how to report bugs usefully.
|
||||
@@ -1,623 +0,0 @@
|
||||
|
||||
|
||||
/******************************************************************
|
||||
|
||||
AmigaOS-spesific routines for GC.
|
||||
This file is normally included from os_dep.c
|
||||
|
||||
******************************************************************/
|
||||
|
||||
|
||||
#if !defined(GC_AMIGA_DEF) && !defined(GC_AMIGA_SB) && !defined(GC_AMIGA_DS) && !defined(GC_AMIGA_AM)
|
||||
# include "gc_priv.h"
|
||||
# include <stdio.h>
|
||||
# include <signal.h>
|
||||
# define GC_AMIGA_DEF
|
||||
# define GC_AMIGA_SB
|
||||
# define GC_AMIGA_DS
|
||||
# define GC_AMIGA_AM
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef GC_AMIGA_DEF
|
||||
|
||||
# ifndef __GNUC__
|
||||
# include <exec/exec.h>
|
||||
# endif
|
||||
# include <proto/exec.h>
|
||||
# include <proto/dos.h>
|
||||
# include <dos/dosextens.h>
|
||||
# include <workbench/startup.h>
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
#ifdef GC_AMIGA_SB
|
||||
|
||||
/******************************************************************
|
||||
Find the base of the stack.
|
||||
******************************************************************/
|
||||
|
||||
ptr_t GC_get_stack_base()
|
||||
{
|
||||
struct Process *proc = (struct Process*)SysBase->ThisTask;
|
||||
|
||||
/* Reference: Amiga Guru Book Pages: 42,567,574 */
|
||||
if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS
|
||||
&& proc->pr_CLI != NULL) {
|
||||
/* first ULONG is StackSize */
|
||||
/*longPtr = proc->pr_ReturnAddr;
|
||||
size = longPtr[0];*/
|
||||
|
||||
return (char *)proc->pr_ReturnAddr + sizeof(ULONG);
|
||||
} else {
|
||||
return (char *)proc->pr_Task.tc_SPUpper;
|
||||
}
|
||||
}
|
||||
|
||||
#if 0 /* old version */
|
||||
ptr_t GC_get_stack_base()
|
||||
{
|
||||
extern struct WBStartup *_WBenchMsg;
|
||||
extern long __base;
|
||||
extern long __stack;
|
||||
struct Task *task;
|
||||
struct Process *proc;
|
||||
struct CommandLineInterface *cli;
|
||||
long size;
|
||||
|
||||
if ((task = FindTask(0)) == 0) {
|
||||
GC_err_puts("Cannot find own task structure\n");
|
||||
ABORT("task missing");
|
||||
}
|
||||
proc = (struct Process *)task;
|
||||
cli = BADDR(proc->pr_CLI);
|
||||
|
||||
if (_WBenchMsg != 0 || cli == 0) {
|
||||
size = (char *)task->tc_SPUpper - (char *)task->tc_SPLower;
|
||||
} else {
|
||||
size = cli->cli_DefaultStack * 4;
|
||||
}
|
||||
return (ptr_t)(__base + GC_max(size, __stack));
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef GC_AMIGA_DS
|
||||
/******************************************************************
|
||||
Register data segments.
|
||||
******************************************************************/
|
||||
|
||||
void GC_register_data_segments()
|
||||
{
|
||||
struct Process *proc;
|
||||
struct CommandLineInterface *cli;
|
||||
BPTR myseglist;
|
||||
ULONG *data;
|
||||
|
||||
int num;
|
||||
|
||||
|
||||
# ifdef __GNUC__
|
||||
ULONG dataSegSize;
|
||||
GC_bool found_segment = FALSE;
|
||||
extern char __data_size[];
|
||||
|
||||
dataSegSize=__data_size+8;
|
||||
/* Can`t find the Location of __data_size, because
|
||||
it`s possible that is it, inside the segment. */
|
||||
|
||||
# endif
|
||||
|
||||
proc= (struct Process*)SysBase->ThisTask;
|
||||
|
||||
/* Reference: Amiga Guru Book Pages: 538ff,565,573
|
||||
and XOper.asm */
|
||||
if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS) {
|
||||
if (proc->pr_CLI == NULL) {
|
||||
myseglist = proc->pr_SegList;
|
||||
} else {
|
||||
/* ProcLoaded 'Loaded as a command: '*/
|
||||
cli = BADDR(proc->pr_CLI);
|
||||
myseglist = cli->cli_Module;
|
||||
}
|
||||
} else {
|
||||
ABORT("Not a Process.");
|
||||
}
|
||||
|
||||
if (myseglist == NULL) {
|
||||
ABORT("Arrrgh.. can't find segments, aborting");
|
||||
}
|
||||
|
||||
/* xoper hunks Shell Process */
|
||||
|
||||
num=0;
|
||||
for (data = (ULONG *)BADDR(myseglist); data != NULL;
|
||||
data = (ULONG *)BADDR(data[0])) {
|
||||
if (((ULONG) GC_register_data_segments < (ULONG) &data[1]) ||
|
||||
((ULONG) GC_register_data_segments > (ULONG) &data[1] + data[-1])) {
|
||||
# ifdef __GNUC__
|
||||
if (dataSegSize == data[-1]) {
|
||||
found_segment = TRUE;
|
||||
}
|
||||
# endif
|
||||
GC_add_roots_inner((char *)&data[1],
|
||||
((char *)&data[1]) + data[-1], FALSE);
|
||||
}
|
||||
++num;
|
||||
} /* for */
|
||||
# ifdef __GNUC__
|
||||
if (!found_segment) {
|
||||
ABORT("Can`t find correct Segments.\nSolution: Use an newer version of ixemul.library");
|
||||
}
|
||||
# endif
|
||||
}
|
||||
|
||||
#if 0 /* old version */
|
||||
void GC_register_data_segments()
|
||||
{
|
||||
extern struct WBStartup *_WBenchMsg;
|
||||
struct Process *proc;
|
||||
struct CommandLineInterface *cli;
|
||||
BPTR myseglist;
|
||||
ULONG *data;
|
||||
|
||||
if ( _WBenchMsg != 0 ) {
|
||||
if ((myseglist = _WBenchMsg->sm_Segment) == 0) {
|
||||
GC_err_puts("No seglist from workbench\n");
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
if ((proc = (struct Process *)FindTask(0)) == 0) {
|
||||
GC_err_puts("Cannot find process structure\n");
|
||||
return;
|
||||
}
|
||||
if ((cli = BADDR(proc->pr_CLI)) == 0) {
|
||||
GC_err_puts("No CLI\n");
|
||||
return;
|
||||
}
|
||||
if ((myseglist = cli->cli_Module) == 0) {
|
||||
GC_err_puts("No seglist from CLI\n");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
for (data = (ULONG *)BADDR(myseglist); data != 0;
|
||||
data = (ULONG *)BADDR(data[0])) {
|
||||
# ifdef AMIGA_SKIP_SEG
|
||||
if (((ULONG) GC_register_data_segments < (ULONG) &data[1]) ||
|
||||
((ULONG) GC_register_data_segments > (ULONG) &data[1] + data[-1])) {
|
||||
# else
|
||||
{
|
||||
# endif /* AMIGA_SKIP_SEG */
|
||||
GC_add_roots_inner((char *)&data[1],
|
||||
((char *)&data[1]) + data[-1], FALSE);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* old version */
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#ifdef GC_AMIGA_AM
|
||||
|
||||
#ifndef GC_AMIGA_FASTALLOC
|
||||
|
||||
void *GC_amiga_allocwrapper(size_t size,void *(*AllocFunction)(size_t size2)){
|
||||
return (*AllocFunction)(size);
|
||||
}
|
||||
|
||||
void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2))
|
||||
=GC_amiga_allocwrapper;
|
||||
|
||||
#else
|
||||
|
||||
|
||||
|
||||
|
||||
void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2));
|
||||
|
||||
void *(*GC_amiga_allocwrapper_do)(size_t size,void *(*AllocFunction)(size_t size2))
|
||||
=GC_amiga_allocwrapper_firsttime;
|
||||
|
||||
|
||||
/******************************************************************
|
||||
Amiga-spesific routines to obtain memory, and force GC to give
|
||||
back fast-mem whenever possible.
|
||||
These hacks makes gc-programs go many times faster when
|
||||
the amiga is low on memory, and are therefore strictly necesarry.
|
||||
|
||||
-Kjetil S. Matheussen, 2000.
|
||||
******************************************************************/
|
||||
|
||||
|
||||
|
||||
/* List-header for all allocated memory. */
|
||||
|
||||
struct GC_Amiga_AllocedMemoryHeader{
|
||||
ULONG size;
|
||||
struct GC_Amiga_AllocedMemoryHeader *next;
|
||||
};
|
||||
struct GC_Amiga_AllocedMemoryHeader *GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(int)~(NULL);
|
||||
|
||||
|
||||
|
||||
/* Type of memory. Once in the execution of a program, this might change to MEMF_ANY|MEMF_CLEAR */
|
||||
|
||||
ULONG GC_AMIGA_MEMF = MEMF_FAST | MEMF_CLEAR;
|
||||
|
||||
|
||||
/* Prevents GC_amiga_get_mem from allocating memory if this one is TRUE. */
|
||||
#ifndef GC_AMIGA_ONLYFAST
|
||||
BOOL GC_amiga_dontalloc=FALSE;
|
||||
#endif
|
||||
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
int succ=0,succ2=0;
|
||||
int nsucc=0,nsucc2=0;
|
||||
int nullretries=0;
|
||||
int numcollects=0;
|
||||
int chipa=0;
|
||||
int allochip=0;
|
||||
int allocfast=0;
|
||||
int cur0=0;
|
||||
int cur1=0;
|
||||
int cur10=0;
|
||||
int cur50=0;
|
||||
int cur150=0;
|
||||
int cur151=0;
|
||||
int ncur0=0;
|
||||
int ncur1=0;
|
||||
int ncur10=0;
|
||||
int ncur50=0;
|
||||
int ncur150=0;
|
||||
int ncur151=0;
|
||||
#endif
|
||||
|
||||
/* Free everything at program-end. */
|
||||
|
||||
void GC_amiga_free_all_mem(void){
|
||||
struct GC_Amiga_AllocedMemoryHeader *gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(GC_AMIGAMEM));
|
||||
struct GC_Amiga_AllocedMemoryHeader *temp;
|
||||
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
printf("\n\n"
|
||||
"%d bytes of chip-mem, and %d bytes of fast-mem where allocated from the OS.\n",
|
||||
allochip,allocfast
|
||||
);
|
||||
printf(
|
||||
"%d bytes of chip-mem were returned from the GC_AMIGA_FASTALLOC supported allocating functions.\n",
|
||||
chipa
|
||||
);
|
||||
printf("\n");
|
||||
printf("GC_gcollect was called %d times to avoid returning NULL or start allocating with the MEMF_ANY flag.\n",numcollects);
|
||||
printf("%d of them was a success. (the others had to use allocation from the OS.)\n",nullretries);
|
||||
printf("\n");
|
||||
printf("Succeded forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",succ,succ2);
|
||||
printf("Failed forcing %d gc-allocations (%d bytes) of chip-mem to be fast-mem.\n",nsucc,nsucc2);
|
||||
printf("\n");
|
||||
printf(
|
||||
"Number of retries before succeding a chip->fast force:\n"
|
||||
"0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n",
|
||||
cur0,cur1,cur10,cur50,cur150,cur151
|
||||
);
|
||||
printf(
|
||||
"Number of retries before giving up a chip->fast force:\n"
|
||||
"0: %d, 1: %d, 2-9: %d, 10-49: %d, 50-149: %d, >150: %d\n",
|
||||
ncur0,ncur1,ncur10,ncur50,ncur150,ncur151
|
||||
);
|
||||
#endif
|
||||
|
||||
while(gc_am!=NULL){
|
||||
temp=gc_am->next;
|
||||
FreeMem(gc_am,gc_am->size);
|
||||
gc_am=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(temp));
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef GC_AMIGA_ONLYFAST
|
||||
|
||||
/* All memory with address lower than this one is chip-mem. */
|
||||
|
||||
char *chipmax;
|
||||
|
||||
|
||||
/*
|
||||
* Allways set to the last size of memory tried to be allocated.
|
||||
* Needed to ensure allocation when the size is bigger than 100000.
|
||||
*
|
||||
*/
|
||||
size_t latestsize;
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* The actual function that is called with the GET_MEM macro.
|
||||
*
|
||||
*/
|
||||
|
||||
void *GC_amiga_get_mem(size_t size){
|
||||
struct GC_Amiga_AllocedMemoryHeader *gc_am;
|
||||
|
||||
#ifndef GC_AMIGA_ONLYFAST
|
||||
if(GC_amiga_dontalloc==TRUE){
|
||||
// printf("rejected, size: %d, latestsize: %d\n",size,latestsize);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// We really don't want to use chip-mem, but if we must, then as little as possible.
|
||||
if(GC_AMIGA_MEMF==(MEMF_ANY|MEMF_CLEAR) && size>100000 && latestsize<50000) return NULL;
|
||||
#endif
|
||||
|
||||
gc_am=AllocMem((ULONG)(size + sizeof(struct GC_Amiga_AllocedMemoryHeader)),GC_AMIGA_MEMF);
|
||||
if(gc_am==NULL) return NULL;
|
||||
|
||||
gc_am->next=GC_AMIGAMEM;
|
||||
gc_am->size=size + sizeof(struct GC_Amiga_AllocedMemoryHeader);
|
||||
GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader *)(~(int)(gc_am));
|
||||
|
||||
// printf("Allocated %d (%d) bytes at address: %x. Latest: %d\n",size,tot,gc_am,latestsize);
|
||||
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
if((char *)gc_am<chipmax){
|
||||
allochip+=size;
|
||||
}else{
|
||||
allocfast+=size;
|
||||
}
|
||||
#endif
|
||||
|
||||
return gc_am+1;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
#ifndef GC_AMIGA_ONLYFAST
|
||||
|
||||
/* Tries very hard to force GC to find fast-mem to return. Done recursively
|
||||
* to hold the rejected memory-pointers reachable from the collector in an
|
||||
* easy way.
|
||||
*
|
||||
*/
|
||||
#ifdef GC_AMIGA_RETRY
|
||||
void *GC_amiga_rec_alloc(size_t size,void *(*AllocFunction)(size_t size2),const int rec){
|
||||
void *ret;
|
||||
|
||||
ret=(*AllocFunction)(size);
|
||||
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
if((char *)ret>chipmax || ret==NULL){
|
||||
if(ret==NULL){
|
||||
nsucc++;
|
||||
nsucc2+=size;
|
||||
if(rec==0) ncur0++;
|
||||
if(rec==1) ncur1++;
|
||||
if(rec>1 && rec<10) ncur10++;
|
||||
if(rec>=10 && rec<50) ncur50++;
|
||||
if(rec>=50 && rec<150) ncur150++;
|
||||
if(rec>=150) ncur151++;
|
||||
}else{
|
||||
succ++;
|
||||
succ2+=size;
|
||||
if(rec==0) cur0++;
|
||||
if(rec==1) cur1++;
|
||||
if(rec>1 && rec<10) cur10++;
|
||||
if(rec>=10 && rec<50) cur50++;
|
||||
if(rec>=50 && rec<150) cur150++;
|
||||
if(rec>=150) cur151++;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
if (((char *)ret)<=chipmax && ret!=NULL && (rec<(size>500000?9:size/5000))){
|
||||
ret=GC_amiga_rec_alloc(size,AllocFunction,rec+1);
|
||||
// GC_free(ret2);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/* The allocating-functions defined inside the amiga-blocks in gc.h is called
|
||||
* via these functions.
|
||||
*/
|
||||
|
||||
|
||||
void *GC_amiga_allocwrapper_any(size_t size,void *(*AllocFunction)(size_t size2)){
|
||||
void *ret,*ret2;
|
||||
|
||||
GC_amiga_dontalloc=TRUE; // Pretty tough thing to do, but its indeed necesarry.
|
||||
latestsize=size;
|
||||
|
||||
ret=(*AllocFunction)(size);
|
||||
|
||||
if(((char *)ret) <= chipmax){
|
||||
if(ret==NULL){
|
||||
//Give GC access to allocate memory.
|
||||
#ifdef GC_AMIGA_GC
|
||||
if(!GC_dont_gc){
|
||||
GC_gcollect();
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
numcollects++;
|
||||
#endif
|
||||
ret=(*AllocFunction)(size);
|
||||
}
|
||||
#endif
|
||||
if(ret==NULL){
|
||||
GC_amiga_dontalloc=FALSE;
|
||||
ret=(*AllocFunction)(size);
|
||||
if(ret==NULL){
|
||||
WARN("Out of Memory! Returning NIL!\n", 0);
|
||||
}
|
||||
}
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
else{
|
||||
nullretries++;
|
||||
}
|
||||
if(ret!=NULL && (char *)ret<=chipmax) chipa+=size;
|
||||
#endif
|
||||
}
|
||||
#ifdef GC_AMIGA_RETRY
|
||||
else{
|
||||
/* We got chip-mem. Better try again and again and again etc., we might get fast-mem sooner or later... */
|
||||
/* Using gctest to check the effectiviness of doing this, does seldom give a very good result. */
|
||||
/* However, real programs doesn't normally rapidly allocate and deallocate. */
|
||||
// printf("trying to force... %d bytes... ",size);
|
||||
if(
|
||||
AllocFunction!=GC_malloc_uncollectable
|
||||
#ifdef ATOMIC_UNCOLLECTABLE
|
||||
&& AllocFunction!=GC_malloc_atomic_uncollectable
|
||||
#endif
|
||||
){
|
||||
ret2=GC_amiga_rec_alloc(size,AllocFunction,0);
|
||||
}else{
|
||||
ret2=(*AllocFunction)(size);
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
if((char *)ret2<chipmax || ret2==NULL){
|
||||
nsucc++;
|
||||
nsucc2+=size;
|
||||
ncur0++;
|
||||
}else{
|
||||
succ++;
|
||||
succ2+=size;
|
||||
cur0++;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
if(((char *)ret2)>chipmax){
|
||||
// printf("Succeeded.\n");
|
||||
GC_free(ret);
|
||||
ret=ret2;
|
||||
}else{
|
||||
GC_free(ret2);
|
||||
// printf("But did not succeed.\n");
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
GC_amiga_dontalloc=FALSE;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void (*GC_amiga_toany)(void)=NULL;
|
||||
|
||||
void GC_amiga_set_toany(void (*func)(void)){
|
||||
GC_amiga_toany=func;
|
||||
}
|
||||
|
||||
#endif // !GC_AMIGA_ONLYFAST
|
||||
|
||||
|
||||
void *GC_amiga_allocwrapper_fast(size_t size,void *(*AllocFunction)(size_t size2)){
|
||||
void *ret;
|
||||
|
||||
ret=(*AllocFunction)(size);
|
||||
|
||||
if(ret==NULL){
|
||||
// Enable chip-mem allocation.
|
||||
// printf("ret==NULL\n");
|
||||
#ifdef GC_AMIGA_GC
|
||||
if(!GC_dont_gc){
|
||||
GC_gcollect();
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
numcollects++;
|
||||
#endif
|
||||
ret=(*AllocFunction)(size);
|
||||
}
|
||||
#endif
|
||||
if(ret==NULL){
|
||||
#ifndef GC_AMIGA_ONLYFAST
|
||||
GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR;
|
||||
if(GC_amiga_toany!=NULL) (*GC_amiga_toany)();
|
||||
GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
|
||||
return GC_amiga_allocwrapper_any(size,AllocFunction);
|
||||
#endif
|
||||
}
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
else{
|
||||
nullretries++;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void *GC_amiga_allocwrapper_firsttime(size_t size,void *(*AllocFunction)(size_t size2)){
|
||||
atexit(&GC_amiga_free_all_mem);
|
||||
chipmax=(char *)SysBase->MaxLocMem; // For people still having SysBase in chip-mem, this might speed up a bit.
|
||||
GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_fast;
|
||||
return GC_amiga_allocwrapper_fast(size,AllocFunction);
|
||||
}
|
||||
|
||||
|
||||
#endif //GC_AMIGA_FASTALLOC
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* The wrapped realloc function.
|
||||
*
|
||||
*/
|
||||
void *GC_amiga_realloc(void *old_object,size_t new_size_in_bytes){
|
||||
#ifndef GC_AMIGA_FASTALLOC
|
||||
return GC_realloc(old_object,new_size_in_bytes);
|
||||
#else
|
||||
void *ret;
|
||||
latestsize=new_size_in_bytes;
|
||||
ret=GC_realloc(old_object,new_size_in_bytes);
|
||||
if(ret==NULL && GC_AMIGA_MEMF==(MEMF_FAST | MEMF_CLEAR)){
|
||||
/* Out of fast-mem. */
|
||||
#ifdef GC_AMIGA_GC
|
||||
if(!GC_dont_gc){
|
||||
GC_gcollect();
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
numcollects++;
|
||||
#endif
|
||||
ret=GC_realloc(old_object,new_size_in_bytes);
|
||||
}
|
||||
#endif
|
||||
if(ret==NULL){
|
||||
#ifndef GC_AMIGA_ONLYFAST
|
||||
GC_AMIGA_MEMF=MEMF_ANY | MEMF_CLEAR;
|
||||
if(GC_amiga_toany!=NULL) (*GC_amiga_toany)();
|
||||
GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
|
||||
ret=GC_realloc(old_object,new_size_in_bytes);
|
||||
#endif
|
||||
}
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
else{
|
||||
nullretries++;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
if(ret==NULL){
|
||||
WARN("Out of Memory! Returning NIL!\n", 0);
|
||||
}
|
||||
#ifdef GC_AMIGA_PRINTSTATS
|
||||
if(((char *)ret)<chipmax && ret!=NULL){
|
||||
chipa+=new_size_in_bytes;
|
||||
}
|
||||
#endif
|
||||
return ret;
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif //GC_AMIGA_AM
|
||||
|
||||
|
||||
@@ -1,82 +0,0 @@
|
||||
# Makefile for Borland C++ 4.5 on NT
|
||||
# For Borland 5.0, replace bc45 by bc5.
|
||||
# If you have the Borland assembler, remove "-DUSE_GENERIC"
|
||||
#
|
||||
bc= c:\bc45
|
||||
bcbin= $(bc)\bin
|
||||
bclib= $(bc)\lib
|
||||
bcinclude= $(bc)\include
|
||||
|
||||
cc= $(bcbin)\bcc32
|
||||
rc= $(bcbin)\brc32
|
||||
lib= $(bcbin)\tlib
|
||||
link= $(bcbin)\tlink32
|
||||
cflags= -R -v -vi -H -H=gc.csm -I$(bcinclude);cord -L$(bclib) \
|
||||
-w-pro -w-aus -w-par -w-ccc -w-rch -a4 -D__STDC__=0
|
||||
#defines= -DSILENT
|
||||
defines= -DSMALL_CONFIG -DSILENT -DALL_INTERIOR_POINTERS -DUSE_GENERIC
|
||||
|
||||
.c.obj:
|
||||
$(cc) @&&|
|
||||
$(cdebug) $(cflags) $(cvars) $(defines) -o$* -c $*.c
|
||||
|
|
||||
|
||||
.cpp.obj:
|
||||
$(cc) @&&|
|
||||
$(cdebug) $(cflags) $(cvars) $(defines) -o$* -c $*.cpp
|
||||
|
|
||||
|
||||
.rc.res:
|
||||
$(rc) -i$(bcinclude) -r -fo$* $*.rc
|
||||
|
||||
XXXOBJS= XXXalloc.obj XXXreclaim.obj XXXallchblk.obj XXXmisc.obj \
|
||||
XXXmach_dep.obj XXXos_dep.obj XXXmark_rts.obj XXXheaders.obj XXXmark.obj \
|
||||
XXXobj_map.obj XXXblacklst.obj XXXfinalize.obj XXXnew_hblk.obj \
|
||||
XXXdbg_mlc.obj XXXmalloc.obj XXXstubborn.obj XXXdyn_load.obj \
|
||||
XXXtypd_mlc.obj XXXptr_chck.obj XXXgc_cpp.obj XXXmallocx.obj
|
||||
|
||||
OBJS= $(XXXOBJS:XXX=)
|
||||
|
||||
all: gctest.exe cord\de.exe test_cpp.exe
|
||||
|
||||
$(OBJS) test.obj: gc_priv.h gc_hdrs.h gc.h gcconfig.h MAKEFILE
|
||||
|
||||
gc.lib: $(OBJS)
|
||||
-del gc.lib
|
||||
tlib $* @&&|
|
||||
$(XXXOBJS:XXX=+)
|
||||
|
|
||||
|
||||
gctest.exe: tests\test.obj gc.lib
|
||||
$(cc) @&&|
|
||||
$(cflags) -W -e$* tests\test.obj gc.lib
|
||||
|
|
||||
|
||||
cord\de.obj cord\de_win.obj: cord\cord.h cord\private\cord_pos.h cord\de_win.h \
|
||||
cord\de_cmds.h
|
||||
|
||||
cord\de.exe: cord\cordbscs.obj cord\cordxtra.obj cord\de.obj cord\de_win.obj \
|
||||
cord\de_win.res gc.lib
|
||||
$(cc) @&&|
|
||||
$(cflags) -W -e$* cord\cordbscs.obj cord\cordxtra.obj \
|
||||
cord\de.obj cord\de_win.obj gc.lib
|
||||
|
|
||||
$(rc) cord\de_win.res cord\de.exe
|
||||
|
||||
gc_cpp.obj: gc_cpp.h gc.h
|
||||
|
||||
gc_cpp.cpp: gc_cpp.cc
|
||||
copy gc_cpp.cc gc_cpp.cpp
|
||||
|
||||
test_cpp.cpp: tests\test_cpp.cc
|
||||
copy tests\test_cpp.cc test_cpp.cpp
|
||||
|
||||
test_cpp.exe: test_cpp.obj gc_cpp.h gc.h gc.lib
|
||||
$(cc) @&&|
|
||||
$(cflags) -W -e$* test_cpp.obj gc.lib
|
||||
|
|
||||
|
||||
scratch:
|
||||
-del *.obj *.res *.exe *.csm cord\*.obj cord\*.res cord\*.exe cord\*.csm
|
||||
|
||||
|
||||
@@ -1,871 +0,0 @@
|
||||
2001-12-16 Jeff Sturm <jsturm@one-point.com>
|
||||
|
||||
* dyn_load.c: Define ElfW (if needed) for all targets,
|
||||
not just GNU/Linux.
|
||||
(GC_FirstDLOpenedLinkMap): Use it.
|
||||
(GC_register_dynamic_libraries_dl): Use it.
|
||||
* include/private/gcconfig.h: Define CPP_WORDSZ, ELF_CLASS
|
||||
for sparcv9.
|
||||
|
||||
2001-12-16 Craig Rodrigues <rodrigc@gcc.gnu.org>
|
||||
|
||||
PR other/3725
|
||||
* configure.in: Add AC_SUBST(target_alias).
|
||||
* configure: Regenerated.
|
||||
|
||||
2001-11-26 Loren J. Rittle <ljrittle@acm.org>
|
||||
|
||||
* linux_threads.c (WRAP_FUNC(pthread_join)): Remove special
|
||||
case for GC_FREEBSD_THREADS.
|
||||
* configure.in (*-*-freebsd*): Clarify warning.
|
||||
* configure: Rebuilt.
|
||||
|
||||
2001-10-23 Loren J. Rittle <ljrittle@acm.org>
|
||||
Andreas Tobler <toa@pop.agri.ch>
|
||||
|
||||
* include/private/solaris_threads.h: Update to use GC_SOLARIS_THREADS.
|
||||
|
||||
2001-10-22 Bryce McKinlay <bryce@waitaki.otago.ac.nz>
|
||||
|
||||
* linux_threads.c (GC_init_parallel): Do not declare as a static
|
||||
constructor.
|
||||
* include/gc.h (GC_init): Declare here. Add description.
|
||||
* include/private/gc_priv.h (GC_init): Remove declaration.
|
||||
|
||||
2001-10-16 Loren J. Rittle <ljrittle@acm.org>
|
||||
|
||||
* include/gc_pthread_redirects.h: Generalize test to use GC_PTHREADS.
|
||||
* linux_threads.c (WRAP_FUNC(pthread_join)): Conditionalized on
|
||||
GC_FREEBSD_THREADS, handle strange interaction between system
|
||||
pthread implementation and boehm-gc signal-handler architecture.
|
||||
* tests/test.c (main): Conditionalized on GC_FREEBSD_THREADS,
|
||||
set stack.
|
||||
* include/private/gcconfig.h (configuration keyed off FREEBSD):
|
||||
Define SIG_SUSPEND, SIG_THR_RESTART. Do not define
|
||||
MPROTECT_VDB when GC_FREEBSD_THREADS is defined.
|
||||
|
||||
2001-10-16 Loren J. Rittle <ljrittle@acm.org>
|
||||
|
||||
* Makefile.am (test.o): Find tests/test.c in $(srcdir).
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
2001-10-16 Bryce McKinlay <bryce@waitaki.otago.ac.nz>
|
||||
|
||||
* Makefile.am, acinclude.m4, configure.in: Imported GC 6.1 Alpha 1 and
|
||||
merged local changes.
|
||||
|
||||
2001-09-26 Rainer Orth <ro@TechFak.Uni-Bielefeld.DE>
|
||||
|
||||
* solaris_threads.c (MAX_ORIG_STACK_SIZE) [I386]: Provide special
|
||||
Solaris 2/Intel definition.
|
||||
|
||||
* configure.in (i?86-*-solaris2.[89]*): Define
|
||||
SOLARIS25_PROC_VDB_BUG_FIXED.
|
||||
* include/private/gcconfig.h [I386 && SUNOS5]: Use it.
|
||||
* configure: Regenerate.
|
||||
|
||||
* include/private/gcconfig.h [I386 && SUNOS5] (DATASTART): Use _etext.
|
||||
(DATAEND): Define using _end.
|
||||
|
||||
2001-09-11 Per Bothner <per@bothner.com>
|
||||
|
||||
* include/Makefile.am: New file. It defines include_HEADERS.
|
||||
* Makefile.am (SUBDIRS): New macro, set to include.
|
||||
* configure.in (AC_OUTPUT): Add include/Makefile.
|
||||
|
||||
2001-08-20 Tom Tromey <tromey@redhat.com>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Always ask gcc for threads package.
|
||||
|
||||
2001-08-17 Tom Tromey <tromey@redhat.com>
|
||||
|
||||
* Makefile.am, acinclude.m4, configure.in: Imported GC 6.0 and
|
||||
merged local changes.
|
||||
|
||||
2001-08-02 David Billinghurst <David.Billinghurst>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: POSIX threads on cygwin does not link with
|
||||
-lpthreads.
|
||||
|
||||
2001-07-03 Tom Tromey <tromey@redhat.com>
|
||||
|
||||
Fix for PR bootstrap/3281:
|
||||
* aclocal.m4, configure, Makefile.in: Rebuilt.
|
||||
* acinclude.m4: Set mkinstalldirs for in-tree build.
|
||||
|
||||
2001-06-26 Richard Henderson <rth@redhat.com>
|
||||
|
||||
* alpha_mach_dep.s: Mark call-saved FP registers.
|
||||
* include/private/gcconfig.h (ALPHA): Remove USE_GENERIC_PUSH_REGS.
|
||||
* configure.in (alpha*): Re-enable alpha_mach_dep.s
|
||||
* configure: Rebuild.
|
||||
|
||||
2001-06-12 Tom Tromey <tromey@redhat.com>
|
||||
|
||||
* aclocal.m4, configure: Rebuilt.
|
||||
* acinclude.m4: Find configure.host in srcdir.
|
||||
|
||||
2001-06-09 Alexandre Oliva <aoliva@redhat.com>, Stephen L Moshier <moshier@mediaone.net>
|
||||
|
||||
* configure.in (AC_EXEEXT): Work around in case it expands to
|
||||
nothing, as in autoconf 2.50.
|
||||
* acinclude.m4: Likewise.
|
||||
* aclocal.m4, configure: Rebuilt.
|
||||
|
||||
2001-06-07 Tom Tromey <tromey@redhat.com>
|
||||
|
||||
For PR bootstrap/3075:
|
||||
* configure, aclocal.m4, Makefile.in: Rebuilt.
|
||||
* configure.in: Don't call AC_CONFIG_AUX_DIR or
|
||||
AC_CANONICAL_SYSTEM.
|
||||
* acinclude.m4 (BOEHM_CONFIGURE): Call AC_CONFIG_AUX_DIR and
|
||||
AC_CANONICAL_SYSTEM here.
|
||||
* Makefile.am (CONFIG_STATUS_DEPENDENCIES): Use srcdir, not
|
||||
boehm_gc_basedir.
|
||||
|
||||
2001-05-24 Bryce McKinlay <bryce@waitaki.otago.ac.nz>
|
||||
|
||||
* Makefile.am: Override gctest_OBJECTS so tests/test.c can be built.
|
||||
(libgcjgc_la_SOURCES): Remove typo.
|
||||
* tests/test.c: Fix struct names and includes for GC_GCJ_SUPPORT case.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
2001-05-21 Bryce McKinlay <bryce@waitaki.otago.ac.nz>
|
||||
|
||||
Imported version version 6.0alpha7.
|
||||
|
||||
* README, README.Mac, README.OS2, README.QUICK, README.alpha,
|
||||
README.amiga, README.debugging, README.dj, README.hp, README.linux,
|
||||
README.rs6000, README.sgi, README.solaris2, README.uts,
|
||||
README.win32, SCoptions.amiga, backptr.h, barrett_diagram,
|
||||
dbg_mlc.h, gc.h, gc.man, gc_alloc.h, gc_cpp.h, gc_hdrs.h, gc_mark.h,
|
||||
gc_priv.h, gc_private.h, gc_typed.h, gcconfig.h,
|
||||
hpux_irix_threads.c, makefile.depend, nursery.c,
|
||||
solaris_threads.h, test.c, test_cpp.cc, weakpointer.h, cord/README,
|
||||
cord/SCOPTIONS.amiga, cord/SMakefile.amiga, cord/cord.h,
|
||||
cord/ec.h, cord/gc.h, cord/private/cord_pos.h, include/backptr.h,
|
||||
include/gc_copy_descr.h, include/gc_nursery.h: Remove obsolete/moved
|
||||
files.
|
||||
|
||||
2001-05-19 Hans Boehm <hans_boehm@hp.com>
|
||||
|
||||
* configure.host: Build with -fexceptions.
|
||||
* linux_threads.c: Remember which thread stopped world for
|
||||
|
||||
2001-05-04 Loren J. Rittle <ljrittle@acm.org>
|
||||
with final tuning by Bryce McKinlay
|
||||
|
||||
* configure.in: Add support for --enable-threads=posix on FreeBSD.
|
||||
* configure: Rebuilt.
|
||||
|
||||
2001-05-01 Jeffrey Oldham <oldham@codesourcery.com>
|
||||
|
||||
* gc_priv.h (UNLOCK): Change type of GC_noop1 argument.
|
||||
(GC_noop1): Change declaration to take one argument.
|
||||
|
||||
2001-04-26 Alexandre Oliva <aoliva@redhat.com>
|
||||
|
||||
* configure.in: Obtain THREADS with `gcc -v'.
|
||||
* configure: Rebuilt.
|
||||
|
||||
2001-04-05 Hans Boehm <hans_boehm@hp.com>
|
||||
|
||||
* misc.c: Back out buggy changes to stack clearing code.
|
||||
Reduce CLEAR_SIZE to 1/4 of original value to reduce time
|
||||
spent clearing memory.
|
||||
|
||||
2001-04-04 Hans Boehm <hans_boehm@hp.com>
|
||||
|
||||
* finalize.c:
|
||||
- Accomodate finalization requests for static objects.
|
||||
(Will be required by hash synchronization. May be needed
|
||||
in some configurations now.)
|
||||
|
||||
* gc_priv.h:
|
||||
- Define MIN_WORDS. All allocation requests are rounded
|
||||
up to at least this size. Removes a subtle assumption that
|
||||
Java objects have a 2 word header.
|
||||
|
||||
* gcconfig.h:
|
||||
- Adjust Linux/IA64 configuration for non-ancient kernels.
|
||||
(Necessary fix for IA64.)
|
||||
|
||||
* linux_threads.c:
|
||||
- Fix syntax error in currently unused code. Will be needed
|
||||
for Linux/PA-RISC.
|
||||
|
||||
* malloc.c:
|
||||
- Handle MIN_WORDS.
|
||||
|
||||
* misc.c:
|
||||
- Handle MIN_WORDS.
|
||||
- Change stack cleaning code to typically clear about one tenth
|
||||
the memory it used to in the threads configuration. Occasionally
|
||||
still clear more. (This is really a fix for a long-standing
|
||||
and fairly significant performance bug with threads.)
|
||||
|
||||
* os_dep.c:
|
||||
- Fix the code for finding the beginning of the data segment under
|
||||
Linux. I believe this is necessary for some IA64 Linux
|
||||
distributions. It will also helo other platforms, though those
|
||||
may additionally require a gcconfig.h adjustment. (This basically
|
||||
works around the absence of a data_start or __data_start
|
||||
definition in glibc.)
|
||||
|
||||
* test.c:
|
||||
- Handle rounding due to MIN_WORDS.
|
||||
|
||||
2001-03-22 Tom Tromey <tromey@redhat.com>
|
||||
|
||||
* Makefile.am (gctest_LDFLAGS): Use -shared-libgcc.
|
||||
|
||||
2001-03-19 Tom Tromey <tromey@redhat.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (gctest_LDFLAGS): new macro.
|
||||
|
||||
2001-03-16 Tom Tromey <tromey@redhat.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (TESTS_ENVIRONMENT): New macro.
|
||||
|
||||
2001-01-23 Rod Stewart <stewart@lab43.org>
|
||||
|
||||
* gcconfig.h: Check for `__arm__', not `arm'.
|
||||
|
||||
2000-12-30 Bryce McKinlay <bryce@albatross.co.nz>
|
||||
|
||||
* configure.in: Rename THREADLIB to THREADLIBS.
|
||||
* Makefile.am (LINK): Add $(THREADLIBS) to libtool command line. This
|
||||
ensures that we link the correct version of the linuxthreads semaphore
|
||||
functions.
|
||||
* Makefile.in: Rebuilt.
|
||||
* configure: Rebuilt.
|
||||
|
||||
* linux_thread.c (GC_thr_init, GC_suspend_handler): Add SIGABRT to the
|
||||
list of signals which are not blocked during suspend in the NO_SIGNALS
|
||||
case.
|
||||
|
||||
2000-12-23 Hans Boehm <Hans_Boehm@hp.com>
|
||||
|
||||
* gcj_mlc.c (GC_gcj_malloc): Don't release allocation lock twice.
|
||||
|
||||
2000-12-15 Bryce McKinlay <bryce@albatross.co.nz>
|
||||
|
||||
* Makefile.dist: Renamed from Makefile.orig.
|
||||
|
||||
2000-12-11 Alexandre Petit-Bianco <apbianco@cygnus.com>
|
||||
|
||||
* Makefile.am (gctest_LDADD): Added EXTRA_TEST_LIBS.
|
||||
* configure.in (EXTRA_TEST_LIBS): Check for `dlopen' in -ldl and
|
||||
set accordingly.
|
||||
* Makefile.in: Rebuilt.
|
||||
* configure: Likewise.
|
||||
|
||||
2000-12-10 Geoffrey Keating <geoffk@redhat.com>
|
||||
|
||||
* gcconfig.h: Add new case for powerpc EABI.
|
||||
[PPC]: Handle embedded OS for powerpc simulator.
|
||||
|
||||
2000-09-30 Bryce McKinlay <bryce@albatross.co.nz>
|
||||
|
||||
* configure.in: Define GC_GCJ_SUPPORT. Define NO_DEBUGGING in
|
||||
cross-compile configuration only.
|
||||
* Makefile.am: Build gcj_mlc.c.
|
||||
* configure, Makefile.in: Rebuilt.
|
||||
|
||||
2000-09-10 Alexandre Oliva <aoliva@redhat.com>
|
||||
|
||||
* acinclude.m4: Include libtool macros from the top level.
|
||||
* aclocal.m4, configure: Rebuilt.
|
||||
|
||||
2000-09-04 Anthony Green <green@redhat.com>
|
||||
|
||||
Fix for PR libgcj/230:
|
||||
* mark.c (GC_mark_from_mark_stack): Remove call to
|
||||
GC_debug_object_start.
|
||||
* gc_priv.h (GC_debug_object_start): Remove prototype.
|
||||
|
||||
2000-08-16 Alexandre Oliva <aoliva@redhat.com>
|
||||
|
||||
* gcconfig.h [OSF1] (_end): Declare as `int'.
|
||||
|
||||
2000-08-02 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* gc_priv.h (GC_generic_malloc_inner): Prototype.
|
||||
(GC_generic_malloc): Likewise.
|
||||
(GC_add_to_black_list_normal): Likewise.
|
||||
(GC_find_header): Likewise.
|
||||
(GC_ADD_TO_BLACK_LIST_NORMAL): Cast bits argument to word.
|
||||
* gc_mark.h (GC_find_start): Prototype.
|
||||
(GC_signal_mark_stack_overflow): Likewise.
|
||||
|
||||
2000-07-24 Alexandre Oliva <aoliva@redhat.com>
|
||||
|
||||
* configure.in (THREADS): Don't --enable-threads on IRIX <= 5.*.
|
||||
* configure: Rebuilt.
|
||||
|
||||
* dyn_load.c (GC_scratch_last_end_ptr): Don't declare a #define.
|
||||
|
||||
2000-06-20 Bryce McKinlay <bryce@albatross.co.nz>
|
||||
|
||||
Imported version 5.1.
|
||||
* acinclude.m4: Push version to 5.1.
|
||||
|
||||
2000-06-19 Andrew Haley <aph@cygnus.com>
|
||||
|
||||
* os_dep.c (read): Pass two dummy args to syscall().
|
||||
|
||||
2000-05-11 Bryce McKinlay <bryce@albatross.co.nz>
|
||||
|
||||
Imported 5.0 release version.
|
||||
* acinclude.m4: Increment version to 5.0.
|
||||
|
||||
2000-05-07 Bryce McKinlay <bryce@albatross.co.nz>
|
||||
|
||||
Imported version 5.0alpha7.
|
||||
* acinclude.m4: Update version to 5.0a7.
|
||||
|
||||
2000-04-26 Jakub Jelinek <jakub@redhat.com>
|
||||
|
||||
* gcconfig.h (SPARC): Define ALIGNMENT to 8 for 64bit SPARC.
|
||||
(SPARC/LINUX): Use GC_SysVGetDataStart instead of LINUX_DATA_START
|
||||
- sparc glibc does not provide it.
|
||||
(SAVE_CALL_CHAIN, ASM_CLEAR_CODE): Define on sparc*-linux*.
|
||||
Make STACKBOTTOM depend on the wordsize.
|
||||
* os_dep.c (GC_SysVGetDataStart): Compile in on sparc*-linux*.
|
||||
(struct frame): Declare on sparc*-linux*.
|
||||
(GC_save_callers): Bias the frame pointers if needed (sparc64).
|
||||
* mach_dep.c (GC_save_regs_in_stack): Optimize on sparc32.
|
||||
Implement on sparc64.
|
||||
(GC_clear_stack_inner): Implement on sparc64.
|
||||
* gc_priv.h (GC_test_and_set): Implement for sparc.
|
||||
* linux_threads.c (GC_suspend_handler, GC_push_all_stacks): Use
|
||||
GC_save_regs_in_stack on sparc.
|
||||
|
||||
2000-04-23 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* gcconfig.h (DYNAMIC_LOADING): Define for PPC Linux.
|
||||
|
||||
2000-04-19 Bryce McKinlay <bryce@albatross.co.nz>
|
||||
|
||||
Imported version version 5.0alpha6.
|
||||
* acinclude.m4: Bump version to 5.0a6.
|
||||
* configure.in: Don't use alpha_mach_dep.s.
|
||||
* include/private/config.h, irix_threads.c gc_watcom.asm: Delete
|
||||
obsolete files.
|
||||
* Makefile.am, Makefile.in: irix_threads.c is now
|
||||
hpux_irix_threads.c.
|
||||
* Makefile.orig: Updated from gc distribution Makefile.
|
||||
|
||||
2000-03-26 Anthony Green <green@redhat.com>
|
||||
|
||||
* misc.c (GC_enable): Always define GC_enable and GC_disable.
|
||||
|
||||
2000-02-14 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* gc.h (dlopen): Define as GC_dlopen on Linux.
|
||||
(GC_dlopen): Declare on Linux.
|
||||
* dyn_load.c (GC_dlopen): Define for Linux.
|
||||
|
||||
Fri Jan 28 17:13:20 2000 Anthony Green <green@cygnus.com>
|
||||
|
||||
* gcconfig.h (DATASTART): Add missing extern declaration
|
||||
for data_start on powerpc.
|
||||
|
||||
1999-12-22 Bryce McKinlay <bryce@albatross.co.nz>
|
||||
|
||||
* linux_threads.c: Don't block SIGINT, SIGQUIT, SIGTERM in the
|
||||
NO_SIGNALS case.
|
||||
|
||||
1999-12-19 Jeff Sturm <jsturm@sigma6.com>
|
||||
|
||||
* gcconfig.h: Define DATASTART for Alpha Linux.
|
||||
|
||||
1999-12-19 Anthony Green <green@cygnus.com>
|
||||
|
||||
* gcconfig.h: Use libgcj hack for Alpha Linux.
|
||||
Undefine MPROTEXT_VDB (from Jeff Sturm).
|
||||
* os_dep.c: Remove Alpha Linux hacks.
|
||||
* misc.c: Ditto.
|
||||
|
||||
1999-12-13 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* aclocal.m4, configure: Rebuilt.
|
||||
* acinclude.m4: Changed version to 5.0a4.
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (libgcjgc_la_LDFLAGS): Changed version to 1:1:0.
|
||||
|
||||
1999-12-12 Anthony Green <green@cygnus.com>
|
||||
|
||||
* gcconfig.h (DATASTART): Define as (&data_start) for PowerPC
|
||||
Linux.
|
||||
(DYNAMIC_LOADING): Define for PowerPC Linux.
|
||||
* os_dep.c: Remove some special cases for PowerPC Linux.
|
||||
* misc.c (GC_init_inner): Don't call GC_init_linux_data_start
|
||||
for PowerPC Linux.
|
||||
|
||||
1999-11-04 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (libgcjgc_la_SOURCES): Removed quick_threads.c.
|
||||
|
||||
* misc.c (GC_init_inner): Don't call GC_init_linuxppc().
|
||||
(GC_thr_init): Don't declare.
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Removed qt threads case.
|
||||
* dyn_load.c: Don't mention QUICK_THREADS.
|
||||
* os_dep.c: Don't mention QUICK_THREADS.
|
||||
* misc.c: Don't mention QUICK_THREADS.
|
||||
* gcconfig.h: Don't mention QUICK_THREADS.
|
||||
* gc_priv.h: Removed QUICK_THREADS code.
|
||||
* quick_threads.c: Removed.
|
||||
|
||||
1999-11-03 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* gcconfig.h: Merged in local changes from old config.h.
|
||||
|
||||
1999-11-02 Bryce McKinlay <bryce@albatross.co.nz>
|
||||
|
||||
* gcconfig.h: Don't define MPROTECT_VDB on Linux/i386.
|
||||
|
||||
1999-11-02 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* quick_threads.c: Include gcconfig.h, not boehm-config.h.
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Don't create boehm-config.h.
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (libgcjgc_la_SOURCES): Reference gcconfig.h, not
|
||||
config.h.
|
||||
($(all_objs)): Depend on gcconfig.h.
|
||||
* gc_priv.h: Reference GCCONFIG_H, not CONFIG_H.
|
||||
* gcconfig.h: Define GCCONFIG_H, not CONFIG_H.
|
||||
* config.h: Removed.
|
||||
|
||||
1999-11-01 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (gctest_LDADD): Added THREADLIB.
|
||||
(TESTS): New macro.
|
||||
* configure: Rebuilt.
|
||||
* configure.in (INCLUDES): New subst.
|
||||
|
||||
1999-09-29 Steve Chamberlain <sac@pobox.com>
|
||||
|
||||
* config.h: Added picoJava target.
|
||||
* mach_dep.h (GC_push_regs): New code for picoJava.
|
||||
|
||||
1999-09-28 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* aclocal.m4, configure: Rebuilt.
|
||||
* acinclude.m4 (LIB_AC_PROG_CC, LIB_AC_PROG_CXX): Provide
|
||||
appropriate AC_PROG_ symbol.
|
||||
|
||||
Tue Aug 10 00:08:29 1999 Rainer Orth <ro@TechFak.Uni-Bielefeld.DE>
|
||||
|
||||
* gc_priv.h: IRIX thread changes from
|
||||
include/private/gc_priv.h.
|
||||
|
||||
Mon Aug 9 18:33:38 1999 Rainer Orth <ro@TechFak.Uni-Bielefeld.DE>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (toolexeclibdir): Add $(MULTISUBDIR) even for native
|
||||
builds.
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Properly align --help output, fix capitalization
|
||||
and punctuation.
|
||||
* acinclude.m4: Likewise.
|
||||
|
||||
1999-08-04 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* configure.in: Added missing `;;'. From Anthony Green.
|
||||
|
||||
Mon Aug 2 23:09:41 1999 Rainer Orth <ro@TechFak.Uni-Bielefeld.DE>
|
||||
|
||||
* configure.in (machdep): Use mips_ultrix_mach_dep.s on Ultrix V4.
|
||||
|
||||
1999-08-03 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* gc_priv.h (GC_test_and_set): Implementation for Linux PPC from
|
||||
Franz Sirl <Franz.Sirl-kernel@lauterbach.com>.
|
||||
|
||||
1999-08-02 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* aclocal.m4, configure: Rebuilt for new libtool.
|
||||
|
||||
1999-07-31 Alexandre Oliva <oliva@dcc.unicamp.br>
|
||||
|
||||
* mips_sgi_mach_dep.s: Enable PIC option.
|
||||
|
||||
1999-07-19 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* config.h (MPROTECT_VDB): Don't define on Linux.
|
||||
|
||||
1999-07-19 Alexandre Oliva <oliva@dcc.unicamp.br>
|
||||
|
||||
* Makefile.am (.s.lo): Avoid `#line' directives.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
1999-07-19 Alexandre Oliva <oliva@dcc.unicamp.br>
|
||||
|
||||
* Makefile.am (*-recursive, *-am, *-multi): Automake does not
|
||||
generate *-recursive for this Makefile, use *-am instead.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
1999-06-30 Alexandre Oliva <oliva@dcc.unicamp.br>
|
||||
|
||||
* Makefile.am (.s.lo): Renamed from `.s.o'.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
1999-06-21 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
Alpha patch from Jeff Sturm:
|
||||
* os_dep.c (GC_init_linuxalpha): New function.
|
||||
* misc.c: Initialize for alpha linux.
|
||||
* gc_priv.h (GC_test_and_set): Define for alpha.
|
||||
* config.h: Don't assume __data_start on alpha.
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (libgcjgc_la_LDFLAGS): Use -version-info, not
|
||||
-release.
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (toolexeclibdir): Define as libdir when
|
||||
appropriate.
|
||||
* configure: Rebuilt.
|
||||
* configure.in (USE_LIBDIR): New conditional.
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Recognize all forms of alpha.
|
||||
|
||||
1999-06-17 Anthony Green <green@cygnus.com>
|
||||
|
||||
* mach_dep.c (GC_push_regs): FreeBSD-elf support (from
|
||||
Carlo Dapor <carlo@vis.ethz.ch>).
|
||||
|
||||
1999-05-05 Gilles Zunino <Gilles.Zunino@hei.fr>
|
||||
|
||||
* configure.in: Switch from irix threads to posix threads
|
||||
Defined IRIX_THREADS. Put mips_sgi_mach_dep.lo into machdep
|
||||
for mips architecture.
|
||||
* configure: Regenerate.
|
||||
|
||||
1999-04-30 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* linux_threads.c: Don't reference __pthread_initial_thread_bos.
|
||||
|
||||
1999-04-26 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* dyn_load.c (GC_FirstDLOpenedLinkMap): Declare _DYNAMIC as
|
||||
`weak'.
|
||||
|
||||
1999-04-23 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Makefile.in, configure: Rebuilt.
|
||||
* Makefile.am (EXTRA_LIBRARIES): Mention libgcjgc.la.
|
||||
(libgcjgc_la_SOURCES): Renamed.
|
||||
(libgcjgc_la_LIBADD): Likewise.
|
||||
(libgcjgc_la_DEPENDENCIES): Likewise.
|
||||
(EXTRA_libgcjgc_la_SOURCES): Likewise.
|
||||
(gctest_LDADD): Use libgcjgc.la.
|
||||
(all_objs): Mention libgcj_la_OBJECTS.
|
||||
(EXTRA_LTLIBRARIES): Renamed.
|
||||
(toollib_LTLIBRARIES): Likewise.
|
||||
(libgcjgc_la_LDFLAGS): New macro
|
||||
(toolexecdir): Renamed.
|
||||
(toolexeclibdir): Likewise.
|
||||
(toolexeclib_LTLIBRARIES): Likewise.
|
||||
(LTCOMPILE): Renamed; added libtool invocation.
|
||||
(LINK): Added libtool invocation.
|
||||
(.s.o): use LTCOMPILE.
|
||||
* configure.in: Call AM_PROG_LIBTOOL.
|
||||
(target_all): Set to libgcjgc.la.
|
||||
Mention `.lo' forms of object files.
|
||||
|
||||
1999-04-21 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* misc.c (GC_init_inner): If QUICK_THREADS defined, compute
|
||||
GC_stackbottom.
|
||||
|
||||
* os_dep.c: glibc 2.1 requires asm/sigcontext.h, not
|
||||
sigcontext.h. From Matthias Klose <doko@itso.de>.
|
||||
|
||||
1999-04-16 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* config.h (__start): Declare as `int' in alpha/OSF1 case. From
|
||||
David Pettersson <dapet@mai.liu.se>
|
||||
|
||||
1999-04-14 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Don't use sparc_mach_dep.o for Solaris. Reverts
|
||||
incorrect patch of 199-04-09.
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Added support for alpha.
|
||||
From David Pettersson <dapet@mai.liu.se>.
|
||||
|
||||
1999-04-13 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (libgcjgc_a_SOURCES): Added solaris-threads.c and
|
||||
solaris-threads.h.
|
||||
|
||||
1999-04-09 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Use sparc_mach_dep.s when building on Solaris.
|
||||
|
||||
1999-02-23 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: For Linux, define _REENTRANT. For Solaris, define
|
||||
SOLARIS_THREADS and _SOLARIS_PTHREADS.
|
||||
|
||||
1999-02-18 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* quick_threads.c (GC_push_all_stacks): Change order of arguments
|
||||
to GC_push_all_stacks depending on STACK_GROWS_DOWN define. Check
|
||||
for case where LO is NULL.
|
||||
|
||||
1999-02-10 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* aclocal.m4, configure, Makefile.in: Rebuilt.
|
||||
* acinclude.m4: Updated to be used with automake 1.4.
|
||||
* configure.in: Renamed libgc to libgcjgc. Updated to be used
|
||||
with automake 1.4.
|
||||
* Makefile.am (EXTRA_LIBRARIES): Renamed libgc to libgcjgc.
|
||||
(libgcjgc_a_SOURCES): Likewise.
|
||||
(libgcjgc_a_LIBADD): Likewise.
|
||||
(libgcjgc_a_DEPENDENCIES): Likewise.
|
||||
(EXTRA_libgcjgc_a_SOURCES): Likewise.
|
||||
(gctest_LDADD): Likewise.
|
||||
(all_objs): Likewise.
|
||||
|
||||
1999-01-08 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Define LINUX_THREADS if using POSIX threads on
|
||||
Linux.
|
||||
|
||||
* gc_priv.h (GC_test_and_set): Put return type into definition.
|
||||
|
||||
1998-11-24 Andrew Haley <aph@viagra.cygnus.co.uk>
|
||||
|
||||
* Makefile.am: add support for eCos. In particular, add C++
|
||||
support for compiling the file ecos.cc.
|
||||
* ecos.cc: new file.
|
||||
* acinclude.m4: add C++ support.
|
||||
* aclocal.m4: likewise
|
||||
* config.h: add eCos support.
|
||||
* configure: likewise
|
||||
* configure.in: likewise
|
||||
* misc.c (GC_write): add eCos support.
|
||||
* os_dep.c (tiny_sbrk): add eCos support.
|
||||
|
||||
Thu Dec 10 18:24:34 1998 Warren Levy <warrenl@cygnus.com>
|
||||
|
||||
* misc.c (GC_init_inner): Moved STACKBASE code to os_dep.c.
|
||||
* os_dep.c (GC_get_stack_base): Moved STACKBASE code from misc.c.
|
||||
|
||||
1998-11-23 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* configure.host (boehm_gc_cflags): Don't add `-O2'.
|
||||
|
||||
1998-11-20 Andrew Haley <aph@viagra.cygnus.co.uk>
|
||||
|
||||
* Makefile.am, Makefile.in, configure.host: tx39 build option
|
||||
"-G 0" added.
|
||||
|
||||
1998-11-17 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Switch on host, not target.
|
||||
|
||||
1998-11-16 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* gc_priv.h (GC_debug_object_start): Declare.
|
||||
* mark.c (GC_mark_from_mark_stack): Call GC_debug_object_start.
|
||||
* gc.h (GC_debug_register_finalizer_no_order,
|
||||
GC_register_finalizer_no_order): Declare.
|
||||
(GC_REGISTER_FINALIZER_NO_ORDER): New macro.
|
||||
* dbg_mlc.c (GC_debug_register_finalizer_no_order): New function.
|
||||
(GC_debug_generic_malloc): Likewise.
|
||||
(GC_debug_object_start): new function.
|
||||
|
||||
1998-11-11 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Recognize --enable-java-gc, not --enable-gc.
|
||||
|
||||
Tue Nov 3 18:01:12 1998 Tom Tromey <tromey@sanguine.cygnus.com>
|
||||
|
||||
* dyn_load.c: Handle QUICK_THREADS case.
|
||||
|
||||
1998-10-21 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Put cpp defines here, not in config.h. Recognize
|
||||
--enable-threads. Set INCLUDES. Create boehm-cflags file. Don't
|
||||
define PACKAGE or VERSION.
|
||||
* config.h (SILENT, NO_SIGNALS, NO_DEBUGGING, JAVA_FINALIZATION):
|
||||
Don't define.
|
||||
|
||||
* os_dep.c (GC_default_push_other_roots): Define when
|
||||
QUICK_THREADS defined.
|
||||
* misc.c: Added QUICK_THREADS case.
|
||||
* gc_priv.h: Added QUICK_THREADS case to define LOCK and UNLOCK.
|
||||
* config.h (THREADS): Define if QUICK_THREADS defined.
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (libgc_a_SOURCES): Added linux_threads.c,
|
||||
quick_threads.c.
|
||||
* quick_threads.c: New file.
|
||||
|
||||
1998-10-20 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* aclocal.m4, configure: Rebuilt.
|
||||
* acinclude.m4: Don't subst machine_dir or sys_dir.
|
||||
* configure.host: Removed unused code.
|
||||
|
||||
Sun Oct 11 08:18:02 1998 Anthony Green <green@cygnus.com>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Fix typo in previous patch.
|
||||
|
||||
Sun Oct 11 08:06:11 1998 Anthony Green <green@cygnus.com>
|
||||
|
||||
* Makefile.in, aclocal.m4, configure: Rebuilt.
|
||||
* Makefile.am, acinclude.m4, configure.in: Add multilib support.
|
||||
* configure.host: Created.
|
||||
|
||||
Tue Sep 1 10:58:15 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (lib_LIBRARIES): Use target_all.
|
||||
(EXTRA_LIBRARIES): New macro.
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Recognize --enable-gc.
|
||||
|
||||
Thu Aug 13 10:52:45 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (COMPILE): Define.
|
||||
(LINK): Likewise.
|
||||
(.s.o): Use MY_CFLAGS.
|
||||
* configure: Rebuilt.
|
||||
* configure.in (MY_CFLAGS): Define and subst.
|
||||
|
||||
Wed Aug 12 11:41:43 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Added --with-cross-host argument. Use
|
||||
$with_cross_host to determine when cross-compiling.
|
||||
|
||||
* config.h (SMALL_CONFIG): Don't define.
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Define SMALL_CONFIG when cross-compiling.
|
||||
|
||||
Tue Aug 11 11:41:25 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* solaris_pthreads.c, misc.c, gc_priv.h, config.h, alloc.c,
|
||||
allchblk.c: Merged with 4.13a2 while preserving local changes.
|
||||
|
||||
* Makefile.orig: Updated from Makefile in 4.13a2.
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Updated version number to 4.13a2. On Solaris,
|
||||
don't build with -O when using gcc.
|
||||
|
||||
Merged in version 4.13alpha2:
|
||||
* config.h (USE_MMAP): Re-enable on Solaris.
|
||||
* solaris_pthreads.c: Removed RCS Id line.
|
||||
* alpha_mach_dep.s: Removed RCS Id line.
|
||||
|
||||
Wed Jul 22 15:38:12 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* config.h (USE_MMAP): Don't define for Solaris.
|
||||
|
||||
Wed Jun 10 12:51:41 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (libgc_a_SOURCES): Removed setjmp_t.c.
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (libgc_a_SOURCES): Removed add_gc_prefix.c.
|
||||
|
||||
Thu May 14 15:32:58 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am ($(all_objs)): Depend on config.h.
|
||||
|
||||
* config.h: [MIPS] If DATASTART_IS_ETEXT defined then define
|
||||
DATASTART as &_etext.
|
||||
* misc.c (GC_init_inner): If STACKBASE defined, then use it.
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Define STACKBASE and DATASTART_IS_ETEXT for the
|
||||
tx39.
|
||||
|
||||
Tue May 12 13:15:45 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* alloc.c: Don't call GET_TIME if NO_CLOCK defined.
|
||||
(GC_maybe_gc): Likewise.
|
||||
* os_dep.c: If NO_SIGSET defined, then have empty
|
||||
GC_disable_signals and GC_enable_signals.
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Added --with-target-subdir option. If
|
||||
cross-compiling, define NO_SIGSET and NO_CLOCK.
|
||||
|
||||
Wed May 6 16:40:28 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (.s.o): Directly use CC -x assembler-with-cpp.
|
||||
(AS): Removed.
|
||||
* aclocal.m4, configure: Rebuilt.
|
||||
* acinclude.m4: New file.
|
||||
* configure.in: Don't run AM_EXEEXT. Use LIB_AC_PROG_CC.
|
||||
|
||||
Thu Apr 30 14:51:12 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Link boehm-config.h to config.h.
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (INCLUDES): Removed.
|
||||
* config.h (SILENT, SMALL_CONFIG, NO_SIGNALS, NO_DEBUGGING,
|
||||
JAVA_FINALIZATION): Define
|
||||
|
||||
Wed Apr 29 11:03:14 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Many files: Use GC_bool, not bool.
|
||||
* gc_priv.h: Define GC_bool, not bool.
|
||||
|
||||
* misc.c (GC_dont_gc): Define as int.
|
||||
(GC_quiet): Likewise.
|
||||
* gc_priv.h (GC_never_stop_func): Declare as returning bool.
|
||||
* alloc.c (GC_dont_expand): Define as int.
|
||||
* gc_priv.h: For gcc, define bool as char.
|
||||
|
||||
Tue Apr 28 22:44:16 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (check_PROGRAMS): New macro.
|
||||
(gctest_SOURCES): Likewise.
|
||||
(gctest_LDADD): Likewise.
|
||||
|
||||
Mon Apr 27 23:53:24 1998 Tom Tromey <tromey@cygnus.com>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (libgc_a_SOURCES): Added dyn_load.c.
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Define SUNOS53_SHARED_LIB on Solaris 2.3.
|
||||
|
||||
Wed Apr 15 11:40:56 1998 Tom Tromey <tromey@sanguine.cygnus.com>
|
||||
|
||||
* Makefile.am, Makefile.in, configure.in, configure, aclocal.m4:
|
||||
New files.
|
||||
* Makefile.orig: Renamed from Makefile.
|
||||
|
||||
@@ -1,141 +0,0 @@
|
||||
#
|
||||
# OS/2 specific Makefile for the EMX environment
|
||||
#
|
||||
# You need GNU Make 3.71, gcc 2.5.7, emx 0.8h and GNU fileutils 3.9
|
||||
# or similar tools. C++ interface and de.exe weren't tested.
|
||||
#
|
||||
# Rename this file "Makefile".
|
||||
#
|
||||
|
||||
# Primary targets:
|
||||
# gc.a - builds basic library
|
||||
# c++ - adds C++ interface to library and include directory
|
||||
# cords - adds cords (heavyweight strings) to library and include directory
|
||||
# test - prints porting information, then builds basic version of gc.a, and runs
|
||||
# some tests of collector and cords. Does not add cords or c++ interface to gc.a
|
||||
# cord/de.exe - builds dumb editor based on cords.
|
||||
CC= gcc
|
||||
CXX=g++
|
||||
# Needed only for "make c++", which adds the c++ interface
|
||||
|
||||
CFLAGS= -O -DALL_INTERIOR_POINTERS -DSILENT
|
||||
# Setjmp_test may yield overly optimistic results when compiled
|
||||
# without optimization.
|
||||
# -DSILENT disables statistics printing, and improves performance.
|
||||
# -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
|
||||
# altered stubborn objects, at substantial performance cost.
|
||||
# -DFIND_LEAK causes the collector to assume that all inaccessible
|
||||
# objects should have been explicitly deallocated, and reports exceptions
|
||||
# -DSOLARIS_THREADS enables support for Solaris (thr_) threads.
|
||||
# (Clients should also define SOLARIS_THREADS and then include
|
||||
# gc.h before performing thr_ or GC_ operations.)
|
||||
# -DALL_INTERIOR_POINTERS allows all pointers to the interior
|
||||
# of objects to be recognized. (See gc_private.h for consequences.)
|
||||
# -DSMALL_CONFIG tries to tune the collector for small heap sizes,
|
||||
# usually causing it to use less space in such situations.
|
||||
# Incremental collection no longer works in this case.
|
||||
# -DDONT_ADD_BYTE_AT_END is meaningful only with
|
||||
# -DALL_INTERIOR_POINTERS. Normally -DALL_INTERIOR_POINTERS
|
||||
# causes all objects to be padded so that pointers just past the end of
|
||||
# an object can be recognized. This can be expensive. (The padding
|
||||
# is normally more than one byte due to alignment constraints.)
|
||||
# -DDONT_ADD_BYTE_AT_END disables the padding.
|
||||
|
||||
AR= ar
|
||||
RANLIB= ar s
|
||||
|
||||
# Redefining srcdir allows object code for the nonPCR version of the collector
|
||||
# to be generated in different directories
|
||||
srcdir = .
|
||||
VPATH = $(srcdir)
|
||||
|
||||
OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dyn_load.o dbg_mlc.o malloc.o stubborn.o checksums.o typd_mlc.o ptr_chck.o mallocx.o
|
||||
|
||||
CORD_OBJS= cord/cordbscs.o cord/cordxtra.o cord/cordprnt.o
|
||||
|
||||
CORD_INCLUDE_FILES= $(srcdir)/gc.h $(srcdir)/cord/cord.h $(srcdir)/cord/ec.h \
|
||||
$(srcdir)/cord/cord_pos.h
|
||||
|
||||
# Libraries needed for curses applications. Only needed for de.
|
||||
CURSES= -lcurses -ltermlib
|
||||
|
||||
# The following is irrelevant on most systems. But a few
|
||||
# versions of make otherwise fork the shell specified in
|
||||
# the SHELL environment variable.
|
||||
SHELL= bash
|
||||
|
||||
SPECIALCFLAGS =
|
||||
# Alternative flags to the C compiler for mach_dep.c.
|
||||
# Mach_dep.c often doesn't like optimization, and it's
|
||||
# not time-critical anyway.
|
||||
|
||||
all: gc.a gctest.exe
|
||||
|
||||
$(OBJS) test.o: $(srcdir)/gc_priv.h $(srcdir)/gc_hdrs.h $(srcdir)/gc.h \
|
||||
$(srcdir)/gcconfig.h $(srcdir)/gc_typed.h
|
||||
# The dependency on Makefile is needed. Changing
|
||||
# options such as -DSILENT affects the size of GC_arrays,
|
||||
# invalidating all .o files that rely on gc_priv.h
|
||||
|
||||
mark.o typd_mlc.o finalize.o: $(srcdir)/include/gc_mark.h $(srcdir)/include/private/gc_pmark.h
|
||||
|
||||
gc.a: $(OBJS)
|
||||
$(AR) ru gc.a $(OBJS)
|
||||
$(RANLIB) gc.a
|
||||
|
||||
cords: $(CORD_OBJS) cord/cordtest.exe
|
||||
$(AR) ru gc.a $(CORD_OBJS)
|
||||
$(RANLIB) gc.a
|
||||
cp $(srcdir)/cord/cord.h include/cord.h
|
||||
cp $(srcdir)/cord/ec.h include/ec.h
|
||||
cp $(srcdir)/cord/cord_pos.h include/cord_pos.h
|
||||
|
||||
gc_cpp.o: $(srcdir)/gc_cpp.cc $(srcdir)/gc_cpp.h
|
||||
$(CXX) -c -O $(srcdir)/gc_cpp.cc
|
||||
|
||||
c++: gc_cpp.o $(srcdir)/gc_cpp.h
|
||||
$(AR) ru gc.a gc_cpp.o
|
||||
$(RANLIB) gc.a
|
||||
cp $(srcdir)/gc_cpp.h include/gc_cpp.h
|
||||
|
||||
mach_dep.o: $(srcdir)/mach_dep.c
|
||||
$(CC) -o mach_dep.o -c $(SPECIALCFLAGS) $(srcdir)/mach_dep.c
|
||||
|
||||
mark_rts.o: $(srcdir)/mark_rts.c
|
||||
$(CC) -o mark_rts.o -c $(CFLAGS) $(srcdir)/mark_rts.c
|
||||
|
||||
cord/cordbscs.o: $(srcdir)/cord/cordbscs.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c $(srcdir)/cord/cordbscs.c -o cord/cordbscs.o
|
||||
|
||||
cord/cordxtra.o: $(srcdir)/cord/cordxtra.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c $(srcdir)/cord/cordxtra.c -o cord/cordxtra.o
|
||||
|
||||
cord/cordprnt.o: $(srcdir)/cord/cordprnt.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c $(srcdir)/cord/cordprnt.c -o cord/cordprnt.o
|
||||
|
||||
cord/cordtest.exe: $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a
|
||||
$(CC) $(CFLAGS) -o cord/cordtest.exe $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a
|
||||
|
||||
cord/de.exe: $(srcdir)/cord/de.c $(srcdir)/cord/cordbscs.o $(srcdir)/cord/cordxtra.o gc.a
|
||||
$(CC) $(CFLAGS) -o cord/de.exe $(srcdir)/cord/de.c $(srcdir)/cord/cordbscs.o $(srcdir)/cord/cordxtra.o gc.a $(CURSES)
|
||||
|
||||
clean:
|
||||
rm -f gc.a tests/test.o gctest.exe output-local output-diff $(OBJS) \
|
||||
setjmp_test mon.out gmon.out a.out core \
|
||||
$(CORD_OBJS) cord/cordtest.exe cord/de.exe
|
||||
-rm -f *~
|
||||
|
||||
gctest.exe: tests/test.o gc.a
|
||||
$(CC) $(CFLAGS) -o gctest.exe tests/test.o gc.a
|
||||
|
||||
# If an optimized setjmp_test generates a segmentation fault,
|
||||
# odds are your compiler is broken. Gctest may still work.
|
||||
# Try compiling setjmp_t.c unoptimized.
|
||||
setjmp_test.exe: $(srcdir)/setjmp_t.c $(srcdir)/gc.h
|
||||
$(CC) $(CFLAGS) -o setjmp_test.exe $(srcdir)/setjmp_t.c
|
||||
|
||||
test: setjmp_test.exe gctest.exe
|
||||
./setjmp_test
|
||||
./gctest
|
||||
make cord/cordtest.exe
|
||||
cord/cordtest
|
||||
154
boehm-gc/MacOS.c
154
boehm-gc/MacOS.c
@@ -1,154 +0,0 @@
|
||||
/*
|
||||
MacOS.c
|
||||
|
||||
Some routines for the Macintosh OS port of the Hans-J. Boehm, Alan J. Demers
|
||||
garbage collector.
|
||||
|
||||
<Revision History>
|
||||
|
||||
11/22/94 pcb StripAddress the temporary memory handle for 24-bit mode.
|
||||
11/30/94 pcb Tracking all memory usage so we can deallocate it all at once.
|
||||
02/10/96 pcb Added routine to perform a final collection when
|
||||
unloading shared library.
|
||||
|
||||
by Patrick C. Beard.
|
||||
*/
|
||||
/* Boehm, February 15, 1996 2:55 pm PST */
|
||||
|
||||
#include <Resources.h>
|
||||
#include <Memory.h>
|
||||
#include <LowMem.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "gc.h"
|
||||
#include "gc_priv.h"
|
||||
|
||||
// use 'CODE' resource 0 to get exact location of the beginning of global space.
|
||||
|
||||
typedef struct {
|
||||
unsigned long aboveA5;
|
||||
unsigned long belowA5;
|
||||
unsigned long JTSize;
|
||||
unsigned long JTOffset;
|
||||
} *CodeZeroPtr, **CodeZeroHandle;
|
||||
|
||||
void* GC_MacGetDataStart()
|
||||
{
|
||||
CodeZeroHandle code0 = (CodeZeroHandle)GetResource('CODE', 0);
|
||||
if (code0) {
|
||||
long belowA5Size = (**code0).belowA5;
|
||||
ReleaseResource((Handle)code0);
|
||||
return (LMGetCurrentA5() - belowA5Size);
|
||||
}
|
||||
fprintf(stderr, "Couldn't load the jump table.");
|
||||
exit(-1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* track the use of temporary memory so it can be freed all at once. */
|
||||
|
||||
typedef struct TemporaryMemoryBlock TemporaryMemoryBlock, **TemporaryMemoryHandle;
|
||||
|
||||
struct TemporaryMemoryBlock {
|
||||
TemporaryMemoryHandle nextBlock;
|
||||
char data[];
|
||||
};
|
||||
|
||||
static TemporaryMemoryHandle theTemporaryMemory = NULL;
|
||||
static Boolean firstTime = true;
|
||||
|
||||
void GC_MacFreeTemporaryMemory(void);
|
||||
|
||||
Ptr GC_MacTemporaryNewPtr(size_t size, Boolean clearMemory)
|
||||
{
|
||||
static Boolean firstTime = true;
|
||||
OSErr result;
|
||||
TemporaryMemoryHandle tempMemBlock;
|
||||
Ptr tempPtr = nil;
|
||||
|
||||
tempMemBlock = (TemporaryMemoryHandle)TempNewHandle(size + sizeof(TemporaryMemoryBlock), &result);
|
||||
if (tempMemBlock && result == noErr) {
|
||||
HLockHi((Handle)tempMemBlock);
|
||||
tempPtr = (**tempMemBlock).data;
|
||||
if (clearMemory) memset(tempPtr, 0, size);
|
||||
tempPtr = StripAddress(tempPtr);
|
||||
|
||||
// keep track of the allocated blocks.
|
||||
(**tempMemBlock).nextBlock = theTemporaryMemory;
|
||||
theTemporaryMemory = tempMemBlock;
|
||||
}
|
||||
|
||||
# if !defined(SHARED_LIBRARY_BUILD)
|
||||
// install an exit routine to clean up the memory used at the end.
|
||||
if (firstTime) {
|
||||
atexit(&GC_MacFreeTemporaryMemory);
|
||||
firstTime = false;
|
||||
}
|
||||
# endif
|
||||
|
||||
return tempPtr;
|
||||
}
|
||||
|
||||
extern word GC_fo_entries;
|
||||
|
||||
static void perform_final_collection()
|
||||
{
|
||||
unsigned i;
|
||||
word last_fo_entries = 0;
|
||||
|
||||
/* adjust the stack bottom, because CFM calls us from another stack
|
||||
location. */
|
||||
GC_stackbottom = (ptr_t)&i;
|
||||
|
||||
/* try to collect and finalize everything in sight */
|
||||
for (i = 0; i < 2 || GC_fo_entries < last_fo_entries; i++) {
|
||||
last_fo_entries = GC_fo_entries;
|
||||
GC_gcollect();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void GC_MacFreeTemporaryMemory()
|
||||
{
|
||||
# if defined(SHARED_LIBRARY_BUILD)
|
||||
/* if possible, collect all memory, and invoke all finalizers. */
|
||||
perform_final_collection();
|
||||
# endif
|
||||
|
||||
if (theTemporaryMemory != NULL) {
|
||||
long totalMemoryUsed = 0;
|
||||
TemporaryMemoryHandle tempMemBlock = theTemporaryMemory;
|
||||
while (tempMemBlock != NULL) {
|
||||
TemporaryMemoryHandle nextBlock = (**tempMemBlock).nextBlock;
|
||||
totalMemoryUsed += GetHandleSize((Handle)tempMemBlock);
|
||||
DisposeHandle((Handle)tempMemBlock);
|
||||
tempMemBlock = nextBlock;
|
||||
}
|
||||
theTemporaryMemory = NULL;
|
||||
|
||||
# if !defined(SILENT) && !defined(SHARED_LIBRARY_BUILD)
|
||||
fprintf(stdout, "[total memory used: %ld bytes.]\n",
|
||||
totalMemoryUsed);
|
||||
fprintf(stdout, "[total collections: %ld.]\n", GC_gc_no);
|
||||
# endif
|
||||
}
|
||||
}
|
||||
|
||||
#if __option(far_data)
|
||||
|
||||
void* GC_MacGetDataEnd()
|
||||
{
|
||||
CodeZeroHandle code0 = (CodeZeroHandle)GetResource('CODE', 0);
|
||||
if (code0) {
|
||||
long aboveA5Size = (**code0).aboveA5;
|
||||
ReleaseResource((Handle)code0);
|
||||
return (LMGetCurrentA5() + aboveA5Size);
|
||||
}
|
||||
fprintf(stderr, "Couldn't load the jump table.");
|
||||
exit(-1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* __option(far_data) */
|
||||
@@ -1,886 +0,0 @@
|
||||
(This file must be converted with BinHex 4.0)
|
||||
|
||||
:$deKBe"bEfTPBh4c,R0TG!"6594%8dP8)3#3"&)e!!!"4UiT8dP8)3!(!!"50A*
|
||||
|
||||
-BA8#ZJ#3!aB"#3d0#'GM,MBi5bkjBf038%-ZZ3#3%)Zi!*!8"@`!N!6rN!4069"
|
||||
|
||||
568e$3`%!UbqAD+X`19S!!!Ba!!!,*J!!!F%!!!-PfTmj1`#3"PET)d31)LTH6H4
|
||||
|
||||
#*AqG5b5HI*)QjY$IIb00%ReTJSi6rG$jG(bZ,"Rc,9Umf[IRj)6FZ-j`GfGR)#!
|
||||
|
||||
m-#qLqB#cj'G%46qffB3q8AppLXKc+P&*il4FMJMq3N32r[U,(PlSNdrQm-J(4!p
|
||||
|
||||
jK)NHmKJSHY!,&chS$4)pk%8mL3I)B0'$AU6S3'q)k%%[5[5J&ffa#68)0ZM&#T!
|
||||
|
||||
!*fHC-2dFZ3i83[Vr[4Xh'+DNQrm'J)rrpqe%ST`,FeVi6b,*qHH")4eQc28NFMN
|
||||
|
||||
ZT*m,L"Y%-`pdAk6RLHDaeVV0a,,@P(4UUK66rUM'8bf91llS("lTh81)MBQ+4*q
|
||||
|
||||
rfHENEhD)Ke#3!09'M%bL[P1+G88fa$3e)5Gpf0kARpBf*6eIH*0`ZBHR%ii"PbN
|
||||
|
||||
+D&*)688M)Sm$Bm[cCdDjh2YIjmAc`(TVpi*Vka((A*&Yl@'LTSH1M*AMP#,2[A$
|
||||
|
||||
(FHA@S"dL4dER#3b!EfBYem(C9P5iGH"a-bb-AL(F"bb-AL,F6)%a9pJUL,(hf%B
|
||||
|
||||
TeQb["X5ib4DQXV!-fa6&mZf&3,(C&UDd-((SpeMBEIB`8Zc,BcZR3A5'X+jYj$'
|
||||
|
||||
6)6HVV+R[!`#3!`X!(E@*MFQ%R4d"))`m[3JM[c)bBS54Tj'M(AP+MK&f%VD5SdG
|
||||
|
||||
SANFB@3Rqc$Am83(+)`"G(D%A'9!bBQ6!b)b4Sq3SH8D1NDGNX$)bBi54!51--$*
|
||||
|
||||
Kj0L!M"KKK"dC--,)-h+-6#KKC-$)-F)NamL!!Z06#X!!b&%bBUHp8RcN'%%6!b,
|
||||
|
||||
i!!kV"`"DLHFaK*!!"Ym4K,,2i2X4c[,`c5!GIPf!ZcNi'8'VfJFpSfdpq+CY$8j
|
||||
|
||||
-V'f-DZr2[36#1(ael5hmfT@1cSU66D5pqDSA89pdTP-`Z[jj6T&!PmZBFZjal"&
|
||||
|
||||
5iG6#blE$+&kLh#QZ118&(0T1J(hZ,9)5MJ9ic*qPI!ac'RJ96QMZjSbkMq()Ui6
|
||||
|
||||
B+f,,#'N1icbM4N"aaBr1`3Z9U'8RY'XAiVXFKp#&k2D5Be%VCdh4%,+2QS'b"Q2
|
||||
|
||||
%0PNT4rE#%kTUFqYDM56bVjfe!p8MqmL)1VmjVkJY`U[*$&*L3AMSpB@LCQ*U&l%
|
||||
|
||||
T+3890rL,V9klFN*4@f0UTf8Z&&afN!"4GC6G8p3fN9$4+4[-@DAeK%lej"@eAAL
|
||||
|
||||
eU@&4[Tm28%mqqUkS(F+VDa#lB&'rlRAllRP&l460Qc,)MHR$jMh@$8Y4Xc'e`cd
|
||||
|
||||
ZE2AUUiH+fK96feb$epq&'RAQeLG&lCDjmP+"Kr8k9#qp'eI8RPf[6R$dS+$UcqI
|
||||
|
||||
ELYSV[*ETFL&j[@lr803qd9I2A#bi4Vei3*d[+@Urk*!!&abe0HTVm%44"i4A6JN
|
||||
|
||||
c(2I!kjRl6a9e813DK"A6p(LjRZZGaGH+1L5SiBT[(6ekd2*ILMSXU(l)#m3QMDB
|
||||
|
||||
V+QTG!r*NG#RQai#DNh4,l0&!Ie`dYi98Y1%1A$5hKP4,`d9cHdKP'LkD@q4hYC*
|
||||
|
||||
%dfdLeCCNN@i9UIBNLh5l5(8N68qhM&4R`d9cfdKP'bkD@dHU+qe&XRfNZSqc10j
|
||||
|
||||
#8Me*&ZNfNZT0hSYd+dP&ri-FGM6G6P,p5D,rPNT0`dQLk5+6'NLb5"HDe'$L)Pe
|
||||
|
||||
X8N2bj-Z'$r$6-$NZjLGC)1lB-"jQSff@[ak%LJ[rI#%p2ddAGREN(@"V+,S6CI!
|
||||
|
||||
I!!!0$3KRBbj38%-ZZ@0M8&"$,VN!N"#$BJ#3%4B!!!d'!*!%rj!%68e38Ne33d-
|
||||
|
||||
"!+X[PfqV-$P*!!!'-3!!&UB!!!(&!!!&C80(jji!N!BMM#0%$L)UANhN3L9rV@9
|
||||
|
||||
B`f#c2p$XpAVVCc-[`k20Y5bJ+CTHPScj`Z'!lmr*#EPaRH(ZcR!J!!rqMKG"q)#
|
||||
|
||||
cj'G%46qffB3q8Aqp4R6FA83PM6`KUjaYD&IlZ@jDrY"pk[b&AZrdH*kFbb9PM*S
|
||||
|
||||
`4Kh$c8Lf0bVe+Y`Q$amM6mc%*C1(jF&1bFSdGIlLpc*04b#X&D8[&6R%+-#6HhJ
|
||||
|
||||
kX"#A+Bp6%6RGkB&kM%'jh$ZLmam[1Irq,r82rGM"5H4bh1ZB+b"Z%&-pD)5CL9(
|
||||
|
||||
AP(4UUK6$!(lkH+UPFXFARF-MIHHMXf!5Nd%SZYRQj'pfL)G3N!$94X#(q25G8U`
|
||||
|
||||
VXL'QU3Njk8[phV2@0Q92J#d6rA2N1["[!%c(M4X-8p,0IcYJf2lRBmD2c)*RQEF
|
||||
|
||||
68m'9jqq*MjHTji&GqDp$kh501r9fqVPJe4iQDRS)L!)ELqiX08i#@40jpP1+F@p
|
||||
|
||||
iC&))L)Qq4Bk-cK-i*h`cDlN1cMBUbZA3+beKhX*-&UD`X%ME%F91fHB3BaCC''Y
|
||||
|
||||
KNba-C@(,"-40Yl"l,#c8`YCDf%#"XGD%F4m3'*i'k"iah[Ddam+k"Xd3eV@02'B
|
||||
|
||||
bj'D90I9p!!!-q)[jAU2HhQ[NiCQC&f(Ne`JR!hlN1''4Sjc`)hcL5IK+f(@8(q&
|
||||
|
||||
(1&Nj2XreTBI[M!0dGB4'MK01#CFF2c,JK"*1MNZ1(q&(11@5ii5EKimF*ja``Np
|
||||
|
||||
#bA(#bBL6BpQ6jq5imT-m2mQ!dq2N'H&2RT2M%Nii'6$J,PF!#N#jGS3IS9Uba%G
|
||||
|
||||
'A-)*8[#%!j-9'#r3@EpUPQ9+NL6$ldj*kVS6INIK@`*q'q$hGRJCPb,`pUJm(fQ
|
||||
|
||||
3!#mGrdQqe$Nm22hkJ2cerNp"i3$m4Z62S5YA40V([V`MbHF@)QPT2IN@3@$ceHm
|
||||
|
||||
I&dT3GqF9K,'&&8[6LKMTbQ6@-*%bJE#4RM,b'FA*'VC5`0BBdTa"@aNXM#)mU'"
|
||||
|
||||
N@d@XSIKMMiMh#RbbLSjLT49GG9"F84)Q8QfN&![N1hK"A'V5F,,dJIF@+`iNJEb
|
||||
|
||||
H-(5Nar84j!"*Q54MH+j&08dYQc,(ipT9I+aFqIQc-XP313&803UUPPD4*+UAIlj
|
||||
|
||||
$U+jMAP1QUSfEYV2Qp4HKfZ#TYQTCT)hEaCbp+ZXH0"m5USfHDV1HbL4cCT@41rr
|
||||
|
||||
5+d+eL4&+'hR90)iLRp$LYcm)e5McQN@UMR#&$kKqr%eHU-DBejbUCC-k+P4N5r%
|
||||
|
||||
Iha+Uc5aj)kVfm*'ej*8Dali5ULfHDLah-l$Zfer1#G9@6l8TTf*r,RKTZ2#Q8'h
|
||||
|
||||
MA2&i%MYq(0aCicHKfPlfDYLeJ3*FFEG3l@"HmfJbqFrdHU&IU+jRHE95BmQFkJF
|
||||
|
||||
29)qp)93hX!aCGLfYP0!jSEU4HF9)-e8M9rADGfC4U(BbVVC66+8XR2Hj2RAmGk'
|
||||
|
||||
kLDNk8`@p0[6F"hrG,e3h`kmm(BhDMQjBm@`ejDH1pG)YbUXYM'Y'5aD`-H(VPZ)
|
||||
|
||||
,*i6A,Nqe)D1Y'5@UV@HM3VAE)a3$3MT+9jAGa)HI#%*E@9ie+jmf-PA9dY#66`Z
|
||||
|
||||
[fkMA!l&$eZ3)bP996crcal6`ZRdT$9NG0S#+V([`rRZ&eae,A%dMGB2V4H%9YPL
|
||||
|
||||
LfZ3B194,NC[ik!QKZSYlaE"deVc1$3[9(XVeFJIG0T,9**@'AVXJZ2Db$%'!,$a
|
||||
|
||||
e+d2+8SES`Z&RD1(C`m,VlM*Aj)cP#M@ZlJI#Djp(U28`fl)VL9dKY+IXeFM!HRJ
|
||||
|
||||
MVc0#YCpj6@!,M0VrHYh,CMQN!FBjl1ZVEPhjaCK)``"6,6JiU@@ekMjdmEEPI@M
|
||||
|
||||
3DpXKj3pi+f`LFFpIUPrF058)N4X)f4ZQ*P5c1[&!pGhC4i@Ue2BCE"bRL&haLRk
|
||||
|
||||
Thb#ZUK&ZK-Kc9k4Z-[QKhdaf&1KhN!#*#IdZ-XfJhdPQ)I6l#![SYjD'HXp$hdA
|
||||
|
||||
f$1LhNlN-r4DbV8$I8iS[RSEqj#URqY@$9b3dJG1XG))%khUHJMX,Vh896Z%"I%B
|
||||
|
||||
PFK1MejpP2[@,$LpbTe[Q%h#[hhai0BBHF+r-MrTeL9G6k!!IKHa1rmf2qMf,9c6
|
||||
|
||||
d)%I[5Hq$1hVVq60(`H@-9fb&cfkb$BBDc1-Ck@@#jrVH%0cXH$@cIK[C#F&2Q9X
|
||||
|
||||
[qpl(HTpEQ9F`KqVA3&iYS3Pl6#ARpIXMVpCP6[+ma`PkbJPkbJPkbJPkbJPkbJP
|
||||
|
||||
kbJPkbJPkbJPk1MHKTlbJTlbJpqGlF2RNe4CD`1XDTfUZEYjDHE@[F0T$,KbK"Vc
|
||||
|
||||
mA!9AAPiGS3Qjm[HQi+l-LraVj'p1i3&mcNKce1@eZ4pFX(PY@1(66rD18)Im"eF
|
||||
|
||||
YAJ1K#AYcK92peXpVBfM#AZAIKi*r&r$U$"h)dkhp2[JI!kp0S3GjhdZZV))A!43
|
||||
|
||||
jH4kk(TLQKF4pTXhHI!ITRb%hcX3KfeN#**1EI54a"'@Z8(9Dm%D@b"Y#qhm!N!-
|
||||
|
||||
0!!PRBfaTBLda,VPM8&"$,VN!N"#ah3#3%!9X!!!I``#3"2q3"&"56dT,38K-!3#
|
||||
|
||||
TY1))Uc!eD!!!@F-!N!B563#3"2$I!*!)22J1`2KbNQaPEr+hGEX``Jk!Vpa0&eT
|
||||
|
||||
RDl*eSGZ&%EEAc@iGG+hAYBDRapHZd6ETQH'lV2AbpMVJ4lN,ck0G4lMb)fcKAQi
|
||||
|
||||
*AeLhm1)VRfPGM,"Zi8pBG1%a3VYZi@m,@rM#2'iAfhjHacE,K"[bJGYB,ZcNP&#
|
||||
|
||||
"$cqJ[fRG`SmXR'aMC-H6r-)AXTaNHE+Fj"HkN!"0"R[G!H4jITB&`!(!dKX"PZ#
|
||||
|
||||
Z+PX+S(dCS&YGZI3,cN3L+P4H)V5R@D3p,54$JD"3'!j')mhRcl%mUJ)9e2PVUaF
|
||||
|
||||
j[6lNX)ll!4,jajb6UrZK!hSTX[caD`$ZIHl,pdeVm&EaLeKG-YjQB6AKT)84pF,
|
||||
|
||||
kB$+55%ID`b-4QF0T19ckfSl,d['15$X-4cTr0"2!dIR5%1j[S4JQa0,J4lT!pkc
|
||||
|
||||
"EjcQ2ZmmNDF36,1DH)X!8($N3ihbR+mcX1GC!E!0fi)+ra)rCUL`#HU&V9)ke`6
|
||||
|
||||
IhTB!b&RK%B!&4fA8Ecr8+8IBcr)4Z8L+$bmVaA0$-Lr)$3+SMf0Xkh!%1L(hiM$
|
||||
|
||||
H56i!P'Q(V3ZXrmCRE,f[6f'0N!"Z$E6%fl(AqCL20Ka-#kRdjh`qA&CRACe[!5i
|
||||
|
||||
+PSiKjh)6PJM4H$#5%&U%HF#GqF0F$MM6fH)T68dFSQ!hQ*["e3hGME'TS#e`Fmq
|
||||
|
||||
Sl`'0qRTZMfEcM@b8M`(hV,a,kqB4N8iZ[4Sh5b!9ddQpT9YP#5UK!NX`BDbr,"E
|
||||
|
||||
!TME)X#08Bm,*$)fP2Ci@G1bTGUbETe@@q%4QL60h[2d5)BQGX-U5,*6)q)99'NX
|
||||
|
||||
bP3a1pJZTH#BC&"!P%4'5XP`!Fm82LidDE@#h&eejC#m'cSQd"k1C&S(CD`*"Va"
|
||||
|
||||
S%C+TmmkE6aJ*6S3kTd8)4GS&PNjQ"#DY1419T&!JQT+cV-0*5@'9$$5+K-58Y"%
|
||||
|
||||
N8Ea'&)q3!*!!UeBZ'qd'!&14D",LQVJ'$qTI1DUU3$%0cAD!e9HMkl`KaGAASBj
|
||||
|
||||
TJ#pMhSb5Rq0c+LJ3l3LJkD2dcrJM2Q%3Kh&mZL-JR(&m+L$L-)j29b,%B4br8)j
|
||||
|
||||
X!Y$j4ZUh`)[eI!A!R(d!4AHG`LH[d[f@re6*b2mAI`)H5F0aI+2XYq2iC)+N`6M
|
||||
|
||||
qC$b5"Z2ij,N%KHI*24K!$k@Plm*Hm'Rd8-bci0h@*rK6m%JDM[-[aZ1Nhq+IKNH
|
||||
|
||||
UJA&mE-V&'KM(2a129!2Mq2,5(2qIrSHmNfTSR2rTH+3D'XHRfL81irM8FE,Ep4r
|
||||
|
||||
eTUeM[5Ra8bilkJJ6f!)lF0e(0'p*Cke+2Nq9ccEjh#UIZq6c&[RmM(3ZV*!!cL0
|
||||
|
||||
k&5l"Jp4$Ilc)-m$9BDMqeV0m$l6LhM(EAX9A,10lG,aR)2GNb6Sm29&b0@CfmMd
|
||||
|
||||
&Mr!pHLh'hX&p"qiPVV#h)jIcaN(YAHVY!-im,lH&lp&Fc$pX!KD$+,qKqbMQh",
|
||||
|
||||
@BjDAX[M-KFF0&bH!le%r'GC@E`LVXP9mKXdeG)3QcED[U18Vq4jY2c-fD8XFl$a
|
||||
|
||||
Jb0pEdXPRCYXVR!e1c(f%qF`GKAUQcPT3T6E-YjCF2GYHhq#[aqa0'*p@XJl4r*8
|
||||
|
||||
qM(Fa(e1(MAb2DUZDVTq-SD2mJ+kFAj*ldAQmX-KFQf"C5i,E1fA&P2jHj`!8*c4
|
||||
|
||||
Cbq,eU+LUqmriLrQ-H$8"RJ(GXC,YKXYCKk(M!EcN!3MV-HG3b@DB@MEAd"P5,9[
|
||||
|
||||
2CjDYplkH1ckr$1D5aNf'jH[,p0ehXaPCKe@(eI0#11SC',UQT)X9K3qD(G8hK#c
|
||||
|
||||
C@GQUfADhU*AQPE#2X"A&i-9KaAUdDe$"bpQU)@mfJNfL,U61YQ4RBFiKFac+[hC
|
||||
|
||||
Y@49Fi(Ye4UjKII9Fl[b`UM[(Ca+6ZhF[@mq`0Seer)R3*#Y$$IcK`pPc%EI6FKZ
|
||||
|
||||
I`IV"'%bLZK'Mdl!5jqQ+3J!feU'k*f(FZf(EGY@@N!!CGAmMqd9@CrDD68d'jf(
|
||||
|
||||
3TlQV6AYhAEJlGh4$epjV3bSqBiDXKA!BPjeTVUYp1pI,DPfESAK1"2eSD[B-elh
|
||||
|
||||
H#"KCEIFl0K-Um0E-CFr[,$HC6Hhc`fDr-eb-HmN5*`iSE-8)!#TL+mfKpUV"jrc
|
||||
|
||||
$X6fMXIlRYZ5'5$I94YXX-&C(`""L$Dkf)VmVe*%)GZr'mh(#3i3EqlYKNKblRf*
|
||||
|
||||
'9fi`h"aV43`ejERI0DPfA"MDB``XX)HHa#bYS3h1c!hCcPlQ0+mDh0Yr`mEU8Hk
|
||||
|
||||
YrAmUXCIMj8SFBkA%6iNVCjRI%C(IMj&E3@l3G[C&a#hGId-rBQbXrT)c0e6q'2p
|
||||
|
||||
eC)89`[fJmPd62,qrh"5fBCA-$%rb1d1R5hbj`ddQ1G,60%Q1l'T#EqB1)110@)h
|
||||
|
||||
%i!95M+ekEiM0HfqSHM1k9UQY&%V$jTQPB&VZFVm*4FmG"[Acbff$#qbZ,a3IKUr
|
||||
|
||||
B"VZ2A1J-[B%elK$paa&k8Z63JaakNVNdL$c1fP%+A`QGIJ'bm6iH0ZklkX(0S"E
|
||||
|
||||
8jP*3Mb,[3pbE@&fLD'2RS@ZY1`pG"kj1X1j#2R9*X*QX*TAMbYcVef*YX2)T6FA
|
||||
|
||||
Q@D$Hf'AE5@VBGSP+2*elSqN#9T4Gc"`I)"SMr!P3K8hPL)Se--@E+!*#j8qBAdA
|
||||
|
||||
F)f`H'*JMT!TSH@V*`'V2IZI1K@DpeEljYRXA2YJ9eU,IcfjLaVQJjXS%LTUELM'
|
||||
|
||||
UNU1Q*M@HTVX(FV[-AA`QqadqFr3i9[JU81PlSB$r%d$A3iqhZfXV+KG!GjBeeU(
|
||||
|
||||
[-cfI+9deX0(XqqDqeeCrEqGcqm6iUPf$i$#AQd`B@p0rSjJ6NR2d'hX'fX5-"MQ
|
||||
|
||||
MU,pRS%(-F-NCDZeUk[$*BA*h$2XG9RaZHj-D6bq3!1YJC6AD61@QEFZ@lXi09,[
|
||||
|
||||
#3r`40LMRE"V0'C!!FecYKJh1Q(D[`hN%90BLbX@@Y!c8C8j3QmY!ApD)[GhVGTJ
|
||||
|
||||
**CcApF6MTA!ZjkemqUrh9AKG,PI[cVeVI+q#h6`$QIm$kKcXmZ"@c&ph+[pbaRf
|
||||
|
||||
+-2[6I1-)JqV1YQR9UpZ-&Cd9Uc'6i5P6JCdV6"8c-TKV%$1eQ*@af2(L22GJCe"
|
||||
|
||||
VaTDFcfaEffcXh1Pef-$Pm$Vic)0VQmqbL$(+mRVQJpGcr8kVcZZakIJ-9F5"VJ2
|
||||
|
||||
A)XVacTfpDfd&ZhSY"9l2XleH6rpD3Epa6E1D10FlQJjH!G34SPGS&qM3*fC3Pe2
|
||||
|
||||
L`2L%lVY,CV!*T39qcpXH[fHHVQRU'%UAhk2&Qk`VKaD[,i2ZHk`cX2[6K&iQRrQ
|
||||
|
||||
lbPXmS@QX)1Y!&RH`da"Y"8BfPYDc4GPC#3lV4AhlG+E(2&HTGaMM!VD)&65CaPL
|
||||
|
||||
Dr4lQB&J09`k9kE(,mhf[0f[T[[2#[mfpH2-6*6k4bk,U5Z`kcd%Ia$UcfEZ2Z!G
|
||||
|
||||
1&'%PEF2B1aKl$'0hBH`R',X1BjX`pP1-h6AD-aHa8TJD0Z"T@[KdIJ$5L*0!R+1
|
||||
|
||||
)NmCi#mDEj(J5i`fS4KaV[49[Y[ASjjGJCfSIkdaR)f+)e-#cLpMMH4iTJQFE+B$
|
||||
|
||||
RFiN4RXfXNFpBZGXAc[3QM,G2Yh*CMh@3!(q8lFE6#ID-P'YZ"AefKT9M99N2Re%
|
||||
|
||||
Z5UJ[cKd0UjR$Y@%N5eQr[bVdDANH1X3[2[#XjcJ0%Se1!jKa'U#f[M%BE`p&`TC
|
||||
|
||||
@-mfEF*1J""c`J'Sc4b0!`0Q1cH9X!e(3aCl!)H`k4qIhpfYS1)*',+EMMLJR'JM
|
||||
|
||||
*XAVRp4,L3*6EFHJLENI+bThcfZ@BBX$BV8U1Sr-@+@iljX&F'M+D6*J-'5#(%1k
|
||||
|
||||
[1&EhlT'("@L3!%(&RA-a6V0,2#9X9%3D8*&8fT'k`V(k5V),NCZX$kh*MY@GDYV
|
||||
|
||||
4Y-8%c[bAlh!l-U6&69c*e@N4Mj-C)C2d+XbiMLZjUSJ3--Aq8HQ-$[R0RcMaPa8
|
||||
|
||||
e&lLqlpUj[TGS[iMVqri'VZr9AUl[KhZi[J-YA0r"GUl[d&eFhq'YA0rr0h*pEml
|
||||
|
||||
RqYlHa2Ap"212)[Ba!pGh2-6e$Gc+p3dqbr80[FMe`hbZAjA&I4IA2aN0'##DQ-I
|
||||
|
||||
F0B%8$M1bX*!!6V&dUi!$KD&N2-DNDAZFBic&F2BrKF2r6-!j%"D+4)8c'q,aD,f
|
||||
|
||||
3!-3j51B9SJP@RdlLA(j+(8X++A@L25E3BD9ki@,HV9l@i1F0$6KDbP$RC(bL'2*
|
||||
|
||||
%ikP8)(QCZL15MXe30%"dDAVbI)DMURqBCV&i5b4dfDrbrk!LN!!@@#SGL#9B+*j
|
||||
|
||||
N3JH#Y3HLV#@5r"fhhq@IS5Jp9LM&BLQF6+PSMTk2cbS%9c)KQ@5a90K#Sf4N5PN
|
||||
|
||||
S5M[3da4hiQK)k+XiA(ND$YpSYSe-m)LIZ,6N5rL%!p$M"e)Z2G@JJJ8FXU,((EM
|
||||
|
||||
pQ)@$C4*&(*ZN6`SqKSGP)q02Q+F@[iqA@RaFJFBHbCM4qfMF%h!%89`D('LN6e`
|
||||
|
||||
k'KDkIh4i5)XM8r4*4)JcM9hKZ+)%Kcj2Rl4%aj+pAcSALTmN,qQmF&6[3Z`$k*0
|
||||
|
||||
%H%M18RJEF-b22R&0qM&+6,@P[&-a!BIik*1U!BGKe64B611lY)`iBNHI9"S+Ab9
|
||||
|
||||
l)JjKd5HT3V25,H+!P%`9Z`rkT%9kNCS1THY!pHQ6Q&%@$8)T99L%Sfhd5H*hI$J
|
||||
|
||||
64C28Y,C`Djl#m$6b!XGfTmrR*X8$d@L`Y6QkdK+%4i(E8[b59GP&,"cqQPC3ih4
|
||||
|
||||
MlA''N6k&X1iVfl4IfC%6%hNG3kaD8[4Nmd+LGcpXR+[Xb-XNFZZYEkLS`Q4G+Yd
|
||||
|
||||
5L413!'S-T`$1NR'U9P55`+R)+U%aM8!K9-"b-+[Xk$GR5FTkh)hN*rJB5@-L'EP
|
||||
|
||||
%j(6IK+GdbSlH-e9"XT!!TkM$335*3-%BFqd`miD+#P4)M`VKJ,5STAS-5DFJ,A9
|
||||
|
||||
lRF6mdQ"V)#Q+K-c,[YUNl&M9XNEZ@PkXmY(k8'eCj+P3G[5T%69*)e+cY5@CqV"
|
||||
|
||||
#$%SP0969B)9`fR3N*L#-jAfF#50kqURL8%pU-)M3+FmipZBILqkTH!E9YJip)aj
|
||||
|
||||
%`mKhi"GMeDhkeqSZq1IU*VIi[,SeRcM3"dM$M['C$j!!BhcZ!m11mCN2&2k,$aK
|
||||
|
||||
qi32[Hr5%Rh[d,hX-I&T(k6&F2UIBBc4(!m'9d93k(d+2NBr*-djj`D*SpBJAZ,f
|
||||
|
||||
9j!86F'3iZ$+9LDAqShqJf[jh,cLPbr2V[SPKZ8BUA*j'UT'@jR"M,2UIAFerUC*
|
||||
|
||||
hbU&Hqqk24KaUB492qKV`$C4!&+Z"V#$rQ"GJ24rmKPrCa6X4KAZ0c$d@5+lmTal
|
||||
|
||||
hVejS(qNI[*91V#iSP&p#b,2@2paR1A6E52mJe6FBBMJ1dGJL*2+9p3qIhj!![Bp
|
||||
|
||||
M('C8fB"h)XK)5,I&%TpfThIZ`BHa&(9Vm2+9kL#QA,kQIZdYiIaLYrARRVV2f2q
|
||||
|
||||
YNG[k'UGr%8DeBN-EK0EmEAlarTd(p5,rIHIa&j&hIpETLXk#R@jbC@-b,9jkj$[
|
||||
|
||||
SG20dc3jaep#MG,*Rm*9,kClGd#jFfLM2Qq@TmibVrRcNcU2@95h1CX5Efl"&%5r
|
||||
|
||||
8mURGV@U5ZdHGS,k4EYRemG4[EPCrFjZ4PqYQYFV$Li`LB4cI%5Ak4CIabTc4cV5
|
||||
|
||||
Z`5pfTSPdXM(B'Xb,d*RQlCVl-6rbfNK(iUpddhemB9))4J14@"k%hM42efh'efl
|
||||
|
||||
%*i192U1qBE',qSa81Y2F(%qfjbIV-mbRlM2Dk!QiiGN-X@CeBXhQjHJG2R%#l)P
|
||||
|
||||
%*m$r!"'46R)DGS+2k[XNTp(qiGGq@r81$FI)IYZ`[)lZM!cTba)YbQKh2VHq(T'
|
||||
|
||||
iYATPahXMf583L9i#-b!5'SA3JP$LMk5FV"eL5P&e,)!2AM(fqq[&rAqqJEX3ZJ0
|
||||
|
||||
4GUAcq1#I[$MlrpXrj3jb$ZiY+2BkkdRM@qKR3r"mcb,mia%m2lM89dZ[Vqh!-,f
|
||||
|
||||
QqNbpVjjZ29qJCq04M`2d!b+N'UT5MqGLqX832%q[Aej$mA2Gr%)2D,J,T!VQVUK
|
||||
|
||||
`%6jhAB9V+HAI4,rjJHFl+Pb,m4eQEZZ5@KrPp5aF@N9GqC2+ql1S&YkPdTmG6Gr
|
||||
|
||||
!qEV`09U+&4c&223NLQNk-DpALZNdR1mDqVXNM'QAB`crlBKL%mp(M*G"*FCZ`&J
|
||||
|
||||
DZ&cZG*Ki-f,J@mmLMhX`*R29E-FB[Qe,XDNr4DlPFZc[1GrDKlkqQYkKeBBaYUl
|
||||
|
||||
YEqK(@E3aM+N[HKM14ThU%2X*Hb(-`McNHXhpB"3j2BDaPJB6I!Ne%&qEaD`r`V`
|
||||
|
||||
YU-G"k"3ar)MaKKaEKl'$NQC6hd1-Lq4B$Q0G-XB+e-BRajCJ,+'*V3bd4NrqAp,
|
||||
|
||||
B[bJT[kddmXG*R(e#AIa5)9RRT[cr!`!!$3!*Cf0XD@)Y-LkjBe"33bkj!*!3qL)
|
||||
|
||||
!N"!0"J!!,h3!N!6rN!438Np+5d&)6!%!UE6L#+X`0A!!!#*k!*!'$d%!N!43[J#
|
||||
|
||||
3#1j"$F$iCXbcEQ9ffFS2dS@*jbZl63NYVcACZY$0##1XPDZ$V[@ke[$dmVQ6K5h
|
||||
|
||||
FYGEmE+(Rmc@246PGf0D9hF)@VNAi`VhS`KGM(GQA+lmmdfiI)f`c`Tq`63P23V[
|
||||
|
||||
Y`VEH`KHqX)9f(@(E*!Zrf-)@IZi)AhKXi3[E,M3j*432"&!HrHaD@&$M#f(,qq3
|
||||
|
||||
@XL1hN!$"3Rk6AcKCb%+1%di@J&@""TeG+a&(42abSQ*m9@@VL(4[%29TUPEGj%S
|
||||
|
||||
NfN09'd1a&"q0T8,*F(-`0#85E)pZZ-eZrEB+Z[80G6A,A6ir2'5jYd$i*mlPdrI
|
||||
|
||||
-@8-1XA6I6r6dUG[h&cAjUSAPI(dbhQEPDb0*+mqX6fN-*U1*9$3@'8GN$c0%(%0
|
||||
|
||||
GelfTH&Fd4Q0)jLrR%MNc2aM&pcf8d``Y,Ak!B(cHb*GQH1E2Phb'JLQq0Yi5)P*
|
||||
|
||||
IZ&DMccNrDX`mDiN1BLbSE&MC!)B+3p!!(FM4Z3"pmf##5,64Fd39&fA9Eck6N4(
|
||||
|
||||
q-Kr+TK`qGQ`-&dGPAb51%'Q'J"dB3bK$iZYMHPIm%$'QJ`j8f2l6cq5j@TmTYD&
|
||||
|
||||
8Dh0,2)CCjkGqG*&J+Y5CqU@IDmIQUUrh9q!`X*4GG$59b(1#DBYLrXT3Hc`B6B4
|
||||
|
||||
D3NZ)Zr'(SNLFq4ETPX+0#01J@-c9Mci&E"ETe"lZK'B2D682F5pVpcl#6cM0`cF
|
||||
|
||||
VIh2RdI%LA6N'$6l@jXi1I@kfp+LX3395@i-*Bq1p(FdBDS-m*N)0#&FB@QXXRJV
|
||||
|
||||
TqHr&d$F[UDca!YiDjchaf-C3%T1`bTUFNM26%1V@@T1GbH#dKP"R2*d-KU#5L)D
|
||||
|
||||
5FVQ)&NXr0"XEY)Prh,6j`NN!Fk+aB(Zk*F3lDTZ$[P"c5bMC1Arq8UD4i#5T15f
|
||||
|
||||
KF$3@iP2*G)M2RB8&#LRFh0iTXfaMT'5S@aDD8))aK6DZ*"9[2BV(P+51c4hG,L+
|
||||
|
||||
c53S*k44Xa8Acmd49U9R$Xk-p6,4P'e,Rh4bZH3"e6"(G$Pjab5Ikh&MNk*3JKBH
|
||||
|
||||
am`[rd,p4KJ)IdrpGAkQ!SYrdArSB+K6p(4q-kaYR%DeiK@MHTTrT+airpFpf(!c
|
||||
|
||||
C6D6hMrH[fSGq[SpSi@NLdj2ApC8!q05rrM0pH5A%p,FGr*AqP!RpYPrTjl,kIr)
|
||||
|
||||
Mrc0p)kiXJcl9Cb(1%'6hP`BRQ0MP'EU4U`lF@CCrSLp0(%#3!"HAp98B52*lSGq
|
||||
|
||||
&ZrfkrM3CD5@kEp'%2R+m!*ldPFM#f(9p0R-`C#rdT5&)cLr`#Kk#rMULrlIXZ[j
|
||||
|
||||
d'6P$Y0N+!(Y!54rDdc&h'$"brDYqB3l4$[hhr$0$4PE$2eXNb2ieb2fErJLM)1T
|
||||
|
||||
RZCa*(rQIH68r2Xk[*I+#iKreEj!!r52r-kc1XRmYjSpI3ai@B(RaKIqI,BSqG$#
|
||||
|
||||
E'MkH69X[ckB'iJEe$Qi`RhhAFB-&cq&lKKZFKRc"-D9m50)#'Z6Fp%2+jFLffS0
|
||||
|
||||
N5Tj%4@C5"GI&cC(ZFcD,h$e838lFZmM*m-eX'F$dP%A,,mqff[SF8$&N-KPiM91
|
||||
|
||||
9NF2XSa0J@f1fH(J8"hGPCVYkTSRLJ,V55r6R486P'%J,"U5PdFrVi(p*UM20Z#1
|
||||
|
||||
AjGIGE[0r"EdLeqdcjp[mNSplX,Y)hCYJ5aj0I@@G*jb-Gm65lHf-'iiR1d+aG!I
|
||||
|
||||
M4Q-YACfKpTEfZ,40CpQLY-XkZ5B+lNFp6BS(cVppFXHLm)JE3biI%jRZ4TD29iR
|
||||
|
||||
SY!R1P$QEBbjeBD*lqi'1GccMbIje'bEC1H@a56dI1a@*I@9pEqBF-qYcdaaAM`b
|
||||
|
||||
5FjP9B(QLVT*e4Aa$'kXN*T*FX[j[jrbLXcJ8Me@X&Eh%AL-JTT!!Gd4B3#S&rjI
|
||||
|
||||
6(0UBDSje*M'BT4+G-9BhC9*@-5jcH$[1@!XpJKl'$ZGDCHXmRb03ICB4reapCC!
|
||||
|
||||
!(Mqj("6&rGSNfp+B@FQGKfZV'cfXb6ZLR8&V%2h"l5[mJ8hjJPR%eT0&kPUA"r-
|
||||
|
||||
MPcHq*D-)FI[,GTp4[[$$5jiqJ&BGP+G#UkjaI6!H#dFM9NbNa28pDebXI1(,,(N
|
||||
|
||||
ED'bUV!CChjPULFDCN!"U8NG00mXke@ZV@1Ge4VY$ke-3#PpeT"PAmJT`"+9)V,N
|
||||
|
||||
pTl6IHLkVI,'RZ6PAIkpR2HXM[+GCRdK'0dVZpqGr6kpmXC'CT5KCd3'NL33K%LA
|
||||
|
||||
eT(2pQ21Q5[3dR+GDX116UUkC9$)S5UXm2KGcINq`Y6NTP421bhiMS(ba5j&Vj+N
|
||||
|
||||
6f#aTQ1JNeElPhNVPLj`GVbDV%DYQDdZbmeS[j5Xpee4GLelLG+PS4`JbeUXka[&
|
||||
|
||||
k0V$H4$f6H2FMHFHjNP0bI"Sd(Fh4'2DERk5`R-%10TmaEFjrI`$I68b$mrG)kq6
|
||||
|
||||
aHBBP*&LlQC0%8Xl9HQQfr9b!L@&XcMHPT*eJ*QI3,1Ibj`$iNqZ&q@YbPJ1Ha&!
|
||||
|
||||
Tc3P+,rc(E-IjIaGE%9QEH@4l"'92bccba&FiN!#)&l6[jHikPAbI*GrYmVe9[[I
|
||||
|
||||
)phhbr86Z2U8bGeIk!)'b%TGV)mAiNDCMGeGHc9GI%IUT&GqZ"BjUSA+ed+mA[-2
|
||||
|
||||
LXC)(FAZaC"ZB'D&IrCc3Ep!"HarI&r!YF8GmAD,SLj2'YmVA4CaPLEK2k0IH*6a
|
||||
|
||||
V*Vk$fS9GI4I"H5aL!-[(@%*ka9$HA3N5qMA()VUDA4&9YPT)mi[cZX*6&cM@eJP
|
||||
|
||||
93VpZN!!h"R3P6RiqmI$[+mN)k3@15PH6#pcRH,qPD`T@&9NVUY3'[UeNf`)(%Um
|
||||
|
||||
4l0h!LdSHK&T$P4pi$qrR04'Md+mkS'(0E3aI&)EejF*+mAAAd"56T5l"Ckd*lZ6
|
||||
|
||||
dYG-("ec$9*M3CUehlN4&9Aer+0`PT+AR#H3GeRp3FMK[%pq9er8Y223JLKM!HEY
|
||||
|
||||
N,mdU@jbA#DY@la65UhIkhK'(PTE4BPEM30kDR@@'[UIiiUc6TNIh["CTp`k2hPr
|
||||
|
||||
5`jXLjbc1QSI$eZbmE28#KdHUPIB[)RkQV95-AKqV@,pZ+bUiLHmHp@@M''(eB8f
|
||||
|
||||
f*6X2R,FYF5Vrc4ePeE6)rfDaf,5cCM&h@d69*`VTa,5qikYhmZK0Ble`+6c9aU-
|
||||
|
||||
'$C(cf9ZKQl&q68LMIi$490Bh%PU%6PbL0f'aB1Hl9(X5aT1l$Kj@l3YE82GhXer
|
||||
|
||||
JkbdqLcQ3!1Fk6iB8YmemmZL+iq,&A6dRGi493YT#@5[6iERXA%YphBr&!El1[CF
|
||||
|
||||
+&dD44l1b0lLIpNA*b0Ie[@mhS`,[c9hpkT&bXm8F@aUa0,JLKIL@V(3KLJm!)8*
|
||||
|
||||
&l+8LDUmD1G8`KVdmJ3fHfLH1XVUTHZhcb&J6TE``hq4Z-c@i`ef*B0pah)HB(K3
|
||||
|
||||
H'HbMU6,f$BBChH*)C%0(+c3dM1IjL9Re`SV`bmEQ#NIi'&Lk[$Dk84behl,DCHN
|
||||
|
||||
H16RiF'r0K2I@`Gr,ZCIaFJ8(9XVm+EKbPreGN!$mr6@mUF84qbhVQ,I8i-1$d1L
|
||||
|
||||
YqD*,(#erAVJEVY!Kh&Y92c(6UfI+c4%lZQ4ZC'U$+c`cjjFl(c$,5(pJUS`F$5#
|
||||
|
||||
EZE0`h)YZC!jHBaAMZcmFjCGm1&U$M9+Ne&j+T4(,h&)bVh&lrSC-Tmk6jY8epT%
|
||||
|
||||
+KrZQ`[0dKhfNlm)+9rKGp,K6bKpRq*MNS4mHqT0LLL3I0lp35RH%Cbk#'pph)mE
|
||||
|
||||
6[h0S,fP#'NXTD5D86d2hbhap`Y5EHAZ(lFME$j!!1d1fSr"6Rb5lf@C@BB2jcJl
|
||||
|
||||
d"Pmq29"SQ8HDhKll%9B0qe'T%Lq*l`B@mDEXREcc)d9M9,K%USLj(+VSJHQqK)Q
|
||||
|
||||
BUR$*mLCd,r",+)phKPA01S'YCFRQb(lRkmXX"TYMlpHHARDS*k*$hLm)m'`$`C@
|
||||
|
||||
&''S*&!*9bDJjS-&YYQGB2'VT%G,Cl`MTLd2Sm'j5'3C),I`f)I@3!2%1,)HU+UJ
|
||||
|
||||
[bkq[4qlc"L&GfMhFDr(rrZQrf[,p)kG15hMhd4&b@XV0CQ"E"aq41''CBqMY(fk
|
||||
|
||||
6'%db`c6B2p`N-G`b3k2E`LC4PM$L%f0jKiiA$`FdZ,h'8JHGYGjZ,MFIA,hUZ$K
|
||||
|
||||
Fiik-#KIi%CQcHi)c,(2FXEaGVJlG5DIV!UPX*XE&5&T'QM)AD5aPC#KEMpRZ(3F
|
||||
|
||||
@d#@FcrhLGd[T9XjApG)IRkldZGhZJ5-RYrVI*)HP'-lr3A8KTMck#[J2AZG[`VV
|
||||
|
||||
Jha3@r)a[((G3NfNVUYR5CUc-9'i"NmFYABR*P@C*M$5iH4*6"eEDLVfl+"l+"(8
|
||||
|
||||
@M14#qZ$f$FE-%Cr66QkRcbQN$fhIF,09`KM,jee+2Zp$4fakRpHZ&p+X)mlfR0d
|
||||
|
||||
"PD(-NB(YG[A4!D[DjheP`1FGh"ibp'lGS''H'jf"FrF4Q`L4&ES+2A+LQ%dj*8l
|
||||
|
||||
JqAe2P46cqDAU"Zq2[3hH*IV!V%Q9RJD[$Y[IcD0hlLbM[MffBNarf[!E,'IqV1S
|
||||
|
||||
aElL)9fHGF2%%2`0UDi(dPMEbbl2c%Kck4I2iE0i!RV[80kDaL&r1U`2Q5CH@"Lr
|
||||
|
||||
[j0%0QdI,$*Mbr0mIb&Vl[VlL6mAA(hfaa#pj@9j6KDPc$R)3I@Chp&h`$&mbSC-
|
||||
|
||||
1!RXIf22!RJ6fYm!H!,BEf0m"Hh*LCMEaT63VNSGE8@5Q-%`Tk#5JFa%k+H!Y`!-
|
||||
|
||||
bRJ6HK'V%dHZYf,SBN!$R'c'C1LBRd`93$,0Ui1jQlR&I`LU#Zje9!2GEQ52F,Ia
|
||||
|
||||
k)@hM(PmfejF`2MlEaQ@pYK(Kfraah#la*h*F5bXCXX8fMUr1HS@dXLKKFl&i-D,
|
||||
|
||||
KRHjGikbVar'Y9la$l2RB6pmR,LdS'+0CVLaC,H`"dT@r%Z!F2cScr3P3LVMhU0$
|
||||
|
||||
RDQ6lXmIBIJ6h2FZaT-(pd#Tr(GX$[`!BEfIS4+1rNEepHBe0*1LCXfaR!QFkYKh
|
||||
|
||||
"[C!!E89`RpfiTTEKYhU%C9l5FSYb1eVZ[NShdqFHU(5[B[`[Xmd%lNp8ZZr%``V
|
||||
|
||||
Z`-Sk2q2e,eY9c6DeamCH2MPq""hf),AJ0Z`'mAk4BHU,`2"fN@(D$$6B3eKJHLe
|
||||
|
||||
ijh+BEJhfCmrNX"X@BR0iMP35pJI3b"!RLM2TKUm#`jj4mR%B@%X1Qrhh`&k8X3q
|
||||
|
||||
"I82'4(M5h,f&[F[64H#l[1e2f"XKA3FdhPMh,0f#,XX(PR*-SARJ23cXC6*+rTj
|
||||
|
||||
($GBeQHQ,U+Ad,JkXA`G[(hJpP*%d'S#PC1a"B'rNDPDX"RC'a[6!hT)eeX&I3XE
|
||||
|
||||
f-%rDMYpUEQfrmLafmJQYmYTfr+%XjmL[Mpm65YCl'2rr!!d!#'GMG'9cG#kjZ@0
|
||||
|
||||
38%-ZZ3#3%%0D!*!3(m-!!%+&!*!%rj!%8&*25NY"5%`"!+QdiJLV-$9B!!"5l3#
|
||||
|
||||
3"K+K!*!%$I3!N!Me"!i!pCQCc1abX2*Ef-,&mj8EA@KjV4fRQfkf--,fZP@[Eld
|
||||
|
||||
Z$dq2VmN'A5Bp-hbAY9lHAJFXfQdl+AG,Z2)ME*&GEJRrA-libQIDl@-,fic`*fc
|
||||
|
||||
6K5HKhAEKE`YIq-)mEQiRK(pXXmb@iapGq-+kKCfFELT3q1c,IZ&ZXPf1@pl#b%)
|
||||
|
||||
ffjdZC,)F@FK#&m,)B+r,!D4[CPq-FBbaqZ@-eH&@A,@%-I9,M(@V+THFE3i'I@,
|
||||
|
||||
PFV%p`R[E)f,)lA5*'SmV)SBMaKm`"H(DkkSAQQdeb1%*lP8%I"Kcj(3rX&H6m0M
|
||||
|
||||
IZTkaqjrj`UCT$PZ9X*!!V`m&fSamV5GNj#ReR!CAb"Z-H0XpDBqF`ePa(%eGaiT
|
||||
|
||||
)S-2EcP+HcTr1B+bXmm9Kh'q$6Mf`X[$"KF4R$RhYV2*CXk3m49H%V`fdL)`T"cl
|
||||
|
||||
J+-2j13Fpcq@-E8&E8'&IE%H%!Ne3,pZF#1HDf2Hf""Q,&l1('*Yr8%EphJ1GXSF
|
||||
|
||||
r%JrNr)3rGBV*(aq@mf,a)FC8Kq$ER2+`6KCr)B9h0"r'+0,%0Xm[rQdqSqFB2cQ
|
||||
|
||||
eBU69f4*S4krcbhc8LClZG$iIR'*cIAh0I"abUXM3iXkAEq$(ilQ,49r!j3f+,H)
|
||||
|
||||
maNhp56c112ejNK@"P6JkPXIB&fjK8aKcR!drZX6iG+jqq&li[TdQiqM4U(!CR@&
|
||||
|
||||
rGU+(,&FBA8QAdZJ+kKT@q*eSAPdm1Mm9!Sj'C"RE!a%aQhqm(IAaK-)B'-FE!ha
|
||||
|
||||
jS(fj'%,(Uc#'FK,*f-@9@FC3113DEaI$J@M)*3)Pk"9$i'!+Qm`pccf[0,(*#J2
|
||||
|
||||
h%ZcNS8*JE#k(6ij38,[0q$[cVaRB"FIjhRDA,pSLmUCDTmXQ1P[%8(M@V%X))mK
|
||||
|
||||
*81HhL'j[ZmK(3P'46jb,ab@$h%jI@)iU6J@&a*8bd!J5%NZ'TC%NDKY",5%K9lA
|
||||
|
||||
%%1kQ%f8Z9IE(4kQ5X*9Mq!UPK%dirih2+53-k[E(m!QELQ!-Rl#ccq$6B)6Z-I`
|
||||
|
||||
FQ(52iC0Hd6f'2a&QlKPm`YDG`5GX%V)aI-*'%r+rq)3prJ`qB9260)C2f"21i"-
|
||||
|
||||
feI!B2QRI@@I`#A[5'Ic*-1NH`dIV+GeMrFY8Q(52j8mG(mdXar#TGUKe(X1R`pq
|
||||
|
||||
T1G'EYSlfTT4IFZ446jL-RfpLA2G!eYX*@kf3!1dTXPdLfkfbh5AE'fAlbB5G8j'
|
||||
|
||||
`4rJkCZFXKT(SUhpj-0jKc0+KVIl1dd)2DmAG-GY8*93X&AUb"HYJr,'#0E!H,EJ
|
||||
|
||||
1NCe#Mr)KS8HMKZmGh)rJ,V"iE"haZ#h!9,BPYJl''HE&0`Sp@9F+$qSClfFqB9h
|
||||
|
||||
h3F6FlY%JbNC43[653pSVJdcS86hQ89H[mbKL98+8Rk[YF1I00PeH*e3+2HTqAYH
|
||||
|
||||
N,LMMCc%HqGX+1SASE&1&f@&'l%0mMD%M4m1VBND`e)EiiS,VCTXD(2B'40m'rl5
|
||||
|
||||
#08#c9pE!hmAAm#U26ZK4E&E48%VR2LJ-CTF+Lq-[Q!rPj"[UJRc-'14f6EKm3Rq
|
||||
|
||||
[HC!!63aQaBb,eS*44IHY`T9#9"TN-1YJpRX&fl4AmahDMZpMp-1B4i1Br38Ef*5
|
||||
|
||||
LZGT1Yf,T@L'kG+hYpILK5iVBA1+i5A[CfL*0plhmp&KCF6DUCir(CadF[VkJLmr
|
||||
|
||||
hl$189GrN0XCQaUTQQmSPVV*HpY33GT)apN++X4le+M"i0Epbf"EcSZR0GUYL,E'
|
||||
|
||||
CL0P[#,$5,pp39-AQe,`b2HjB@cfAZmLMk)i,dH$ilTe,er+S69fpF0LG9mb$!l[
|
||||
|
||||
R31a#i(BDla#LU"ri@"l9MH5GKNUFPjh[CUb%le$F&p6Y@VGPQf+Mf`$HhiaG`0F
|
||||
|
||||
EE!CpNpCmJ'NLh(AkA6XZh4NrZ+jVe`eZK4!eX*L4F(JZ0X03ArHcH#pICpR!*Pl
|
||||
|
||||
XK4j0L8ffh'rc-KeIere1L4i-[$eMkE2E5r8'IIXP(S2Gl*Q)Zf#a'@X,Qq&K$)b
|
||||
|
||||
8&-E"[@,S'A[+pp5)VrqCMI&KiNfa[Q3Qde9lQGE01baYqAD,Zb2SkYi*qa$K!H(
|
||||
|
||||
QrQk@*rZq5ckG*6lNDIDh!N0&FHA[kK@2A1Tq5ZHFEh)rKLLeYSe0M3qAR,I8E&J
|
||||
|
||||
jY+[rT[A9)lQhp[p4)R[CAjVd`eG)q5Ap59[1Ed$+lfq3!*Xb2P4bhK@8@k6rTRj
|
||||
|
||||
JV+rq[$NqA2U`m"9NK3VKAUem9mqHIDj8lbP"PFc`j0R0lNQ*I,N$6AVCdp18*hY
|
||||
|
||||
f0%'EZEh)H$fUN6,B3ica+pmIjZHp2ebp!DT9@&,)#Mf''B9-IjQPr#f@rm`"TRV
|
||||
|
||||
fXT+Kq5E,f4-2X#q@$(82A'Tf[iND,j2dTmcpQ*4$$h,S#F8M6-VMR%F+f4IGNqB
|
||||
|
||||
J'pZ22,VGhpLkJDP%PD'3!+P'N!"h!rF@[MkB[ljcr`h&frIIb#bGV(J(mUN2X4*
|
||||
|
||||
pX9j4GNhmp4Y3'hcTK+D*KTP-YEkVC$Za8E*$BZ+*q*Y0FrMmf#+ql$LLcLXFCJU
|
||||
|
||||
2[K5SU)%*YQ!q)e6KX1%9i!l`mjL@,h-VR'U"@M4@E)Vpm1i&"NfaDF-GpbrBfZ9
|
||||
|
||||
43qpR0r'kZ8c&&BRN0640K&FKHr90+PMRPJr'GaLkK'MXKd,di#&8q%UQd23bTI"
|
||||
|
||||
9"Y@$aT[+kbSUjl2Z'0pB$phR08+dF1AJHN20YhDrGZhcfjrC,IPAlKKLCBC5[4k
|
||||
|
||||
q9Idh5c&Z18Dc[QH`6BT`b"(jr6f$$LR#)NHSe0H#a(a5Q2KG+Ee$aFHh0DPJl5(
|
||||
|
||||
93@8ePZK,p9Z@,YNC(kbfH)D&!Aj)MVPY*'C3MV'dDpHCrHTGCHB"TLM1TeLdU%9
|
||||
|
||||
-9@4Q+N-4da3eSVGlhF4QX!,1CRRd4iAX3Xj@qF4Il+k`@5b@hZfl9Y@m`Nb'kFM
|
||||
|
||||
m(e%[4TI(rJ6aDdl'AmecRb,-rM4HPmkJZV0Y@[@eEEU+cSTV%FR$LPDJFf96T)J
|
||||
|
||||
SBV95T"T4851Qcr(ieNkAfS!@ABKZ@GfXkpaZ+bYKPM*EQ4$GZVVj(+2NSbLEp4*
|
||||
|
||||
QXhjcHh'fc9U5,85T)[CflEd"+)FkYrHZ,P(Zk$8UEGDRHfh@rY@LC[fUCKAPh&$
|
||||
|
||||
@Y1rVM$T#D)9kIMCdBMTe139Pm1GfheX`RFmY90UY2l2DVI1bQkD-SR6CVHVV',Y
|
||||
|
||||
QH0(D)YCpAr&dG(pClTG)CrkkmRDVHaU[M*8KLl[iXi"f16cV#a[iKE'C33leSVV
|
||||
|
||||
cA&k$1%ZK,B8aKer)+j[dSeNDl&DqM%FeA$0FT%'A9r0mEmcBIIHPIa9riGZ2&Y4
|
||||
|
||||
)Z5bXVN6AH6jd%(9@BZSH+"mmR)p+fJ,I1r!p$0mpm2dGI$I#GaYmI`rI25-pFcj
|
||||
|
||||
Ib+CiY,#QH5B*Jb`#R#"`$J)R!Rm,r%fb2`5r!f`%81ZYQ*CVS1I,dCQD4M[6f8"
|
||||
|
||||
d%aZ`,C3pl(R%#1`5BJ$fKC34E!2I+%5,Z6XAc,!&GAHH@mc&V-9$`JriRE!1mdm
|
||||
|
||||
QBJfY6"1EAXca96'V%%d15UJ[MKrdU2JbblTde+I(r2fRV)GU*0F[GKFZ'6FZ&@C
|
||||
|
||||
!@&e$S`1V*BfZ3,[Ekc'f'QM#1TGaI6mfFAd[dRd&lTYa2mhe[DcQqPkGarAYVFD
|
||||
|
||||
pRq[EGj!!kh[Gb2@pdFVerHebVZqYjlLqJ6bZladIehI`(Ul[(a4Fhf(J[@rMqRk
|
||||
|
||||
qJHZ,jh2ph!,FAqIkPGrNqY@YA,rQDG`$A2piD5R$)dE#I+49a0+%1a6`miQp3Qa
|
||||
|
||||
bq2hBFJaMcC%A-H[Lh9kI1084#2JDa"!f3ALEk![b$C%30K$$+Rp)$+Z#lAk4M'@
|
||||
|
||||
U"BZ%FY95Keh3%Y-m5!m&aNNZUbm3$MY$+e3GhSKrHRQY-ib9%UaRb2XM&r&Bb[Q
|
||||
|
||||
$#1m2Y(MG+riPr[FUR"'4$dHFrL$[$S4iX30Jl8iIhq)0r5khhm926M)p@LJ6T9)
|
||||
|
||||
i'P,4l,[)jI1kP[&L+-6l`aiMMHaaP!k@(kR(!$5jIF64)2HV9c"fkm2Bb8M[NA,
|
||||
|
||||
5*ahe$KKB9T9'TSPBKI4**`H4UR2Kk*+M&9J[`FHC*Q&NUD#pVUA83F[45Jadk'0
|
||||
|
||||
F3Yf1$dpTM65,Hfl&AGM3!#1U'a&eQabGKF82I&eA%c-D$%HjjT%"U4TMFAb*[&A
|
||||
|
||||
h)@)HETXFRBf&$h`V0NVHj1U3!,`K#cY(qL511H*j`3MI14L%iN0H')LU%pY@kEb
|
||||
|
||||
e@+I!ap@!&jDr$K6[395bNR+a,%&ISM6!LST@Uj*V5MUX3Y#A)"$4+kM@NKY`il$
|
||||
|
||||
S30pF$R`T#q@S*(BHeKMSieHp#Flf)`,0AQTaDcb@&2)PHQQ)5fb5Xdb1cXF+!Vj
|
||||
|
||||
N8DB2,Ic5f4Kjid'T!M!XRlE0,$48%8&NcjVeLhiPLG[pfVbedR#BF'qX0CFl+(-
|
||||
|
||||
SP#2N$)DCki1*FLTMEYAMF%qMfLlECUkT+5IZR$kIUlACYmcS)YhC12(&iZ3YB9'
|
||||
|
||||
@5Q5*+ZHdkID)X$BCAmp+hXKTKT6AHm#U3r4C*hSQB(BrU*ZE[*&EJ[hH"NF&f1H
|
||||
|
||||
b`j%@Ei"`&+-i5TRYhSDUbbZ*lE"hTGJB!9#%@0JA5pj3Yh-5l&V,'fQFRq0a03C
|
||||
|
||||
$hZ956TYb(mp1hP#k+8NN)bQBbZ-#L*FT4c0ATc*h9&5!)3dB`XSCTF08SdMC5D3
|
||||
|
||||
Pj6BcCAk9Up8CNNK#jN9IDNVH8!QCSr)k39+0G(N`aFD&eSVN$99-XdNF%CZY,D(
|
||||
|
||||
`"a@L69D5SkS@&F+T)ekr#"MM-CcF0*pfUMM`5Hd-*A450pjlk`mPT8VU"Y9h0R3
|
||||
|
||||
Mi#,4b)#J'D-9V[Mh#PIqZX**-8jAH0BrUp"aT*4UR0)#8Sh6@T!!8Se6@T!!maX
|
||||
|
||||
Yd(kN"FGd1[HIG2TA[3DH,8Mf'TBDXp4V02ZFVQ8q2,U3!#'KemM%T"XRp@#KVcU
|
||||
|
||||
Y"q@f5Y+$A#aMZCD&Srj`4S3qiL3hckljPY445pa8@+b09#FYcCj'[bpc@BGcr'Q
|
||||
|
||||
!%69iq@)m[C*8URU(RG4!'ib%'PfYVS`*8j,-6"h[aReIXbG[D8k5c,e@cYh[$#h
|
||||
|
||||
lT)pilFFr65[(JLU"+N',p`QF2Y40KM[Pq2-plHN1e&CT4R@a((P61@0C"rU4'Q`
|
||||
|
||||
blVmMh8FNDTaTr9MRD@`4JjR-qSM6-pGM1,T84T8160L3!*%BDI-(2jh'hIh8YR5
|
||||
|
||||
r8BZ42Y@"2cR5GhfQ,m$+0,B(FZ(*qFCchdR[JG5Dl3[K98[0EFBhc6Jf!k'Hj$p
|
||||
|
||||
R)(rUIIG)ebZT#lVHd,,'8%3DJQ5UfdlEP"@LKiU5A8P9!ff@U2hH-(@biF`FQ[(
|
||||
|
||||
KV+6++NJeiI9JS(a#A@K@FPTGe,p@Pj4QR&)AdSc6kT,5M&2U3T15dqU5QT4mULl
|
||||
|
||||
T5FPrl#eaeipXJ`L95k4YN!"fmDV'M(FlXp`hrMJpBDZc9%XlCB(Q0M6#dJJhdpT
|
||||
|
||||
%2bZdFd30'KTT[d-6#2rA22prCQFCZHEjar[pNj2C69PYp)K@DM)V+8'fT!3C%RU
|
||||
|
||||
0$!Sc%%F&0K8NII&jQb@NScQPp1@%DKc0DD4,rDbV-ccd@PV(lCAPY$H4%a*G2UI
|
||||
|
||||
ARl'MdM)(c3+5MpDF8)f1Rr4*kNc)faB*9I4DMcVDlZfJPej1UXfAEck8RMde1"C
|
||||
|
||||
Ci0@')p(QjN#S(A*Mr%a[J*8"E)T3G!%pL5YhHBl+"RVj4bhpa)5,Y@G#d)*M[FH
|
||||
|
||||
rp@3IGap(N9*kF+TlbrUSQrlA5IIaD[aidXeYj&CVNMH83&CM+!&9RaC+%&Q"[`%
|
||||
|
||||
!PM5C'9(,)ph(*fUTr9!YMqT9DV2iP&iGfErj4+r'r8D[mMkHFibb02iMPNjf1PA
|
||||
|
||||
[d("$VLh(CI8d(p1LX&VN*cJbP(8k[pfF2kE#ZPqTX(51-%LC%ZXU[a22)[*i8[E
|
||||
|
||||
rZJ[cIcUGL4G#pHMBk,e2kCF0VX,2PP#E5Iik[#T1$qmHrqXJc[6'Fa2`XLUETTM
|
||||
|
||||
$*YV-$D3cYp12%m#qEb(qhJ$feL8eGE5PqJMF0!YqXU&'QZAY39+9b(8[r8`"-MX
|
||||
|
||||
Ah$6![T!!ITF!pTb'bfV*EbNA&PMaKL[H#UA+i@kTX"!qGeH&C3R&EkCI&X"$k6d
|
||||
|
||||
9PN9@f#m[VUY"R%+aB%N90%@4PhahPUZj([c3IkY-$A%eUr''+[Q8"m(LQS3[kcE
|
||||
|
||||
1G+!PiF[1j8b6mBiYqG4I![EZK'rFji"Ab"55leDmdYV+9*,[$[MHa&2kj,XIH(K
|
||||
|
||||
90KkIa-Ep'I$!Tj5(&h&2b4cN`,G2pSf$$kqZ5Vi*m(hh+pHLCV(B#pqMEAp*2`L
|
||||
|
||||
K$S-ce482X[1!F4&mDd`jE#EL`-(e-DD6q,X(FCd12IXm1+#IdU#-2SFi1q)HB*d
|
||||
|
||||
54KI`ANVie'C`8jVJFZTNa%85A%ip'ebqP1"bkZr$jj-acJ0'8-Di!,i@'@-Q-2E
|
||||
|
||||
*q68KTiMXZ`ja[9RqCFj@hp%rG"RpQjINMlqNrpQ&-qA@"ki53rAP&2rr!!!0$3p
|
||||
|
||||
YGbpRBh4PFh3Z0MK,,VN!N""453#3%#pd!!"+8`#3"2q3"%e08&*0680$!3#V,jH
|
||||
|
||||
ZUc!jB!!!"M%!!"R%!!!"V3!!"E(*MaZS!*!'[VXM4!iL+Pj0j%)PIdhl9fbRBC!
|
||||
|
||||
!DR1(JAFp3hUJ2KNcZ@(k&LeHlIYc*cMM1X2GRCf"!*`N(81C&iAQNTm4&Ifii1"
|
||||
|
||||
EpGII4h6#PiP+'R-jb[e$&IeM12rA3hh-XBk+D2XK9#@U!P9e!@eRU22XRT!!%ar
|
||||
|
||||
%6jaP3[FjFKhiIjQ@hidE$&25cAm$`-IrIXai*1U*jZd88q%pXX1%F$M`RNJbAQS
|
||||
|
||||
ih%%N0J*@A""6p[pE#%1,cL9X%K8j[Z%i38$F)*'R%8!QpTQQT&06TCMf4amme9+
|
||||
|
||||
jii[1iC(HE43E%aa#QlrCjZ4[GSL(8*!!e8D-E"#r6LR@&GN3aF6F'028K*cdTGk
|
||||
|
||||
aT$fkUhhK6F,P(Tj11!CFTLJ+QQSXDINp,M$RL-+Cm9q6j"VK+Hr'rhrjXB16b1@
|
||||
|
||||
iec&AC&Z,)bAP)A[QZNkT`brFF9bj0@L(b*(4H3)$i*YCbh9`YK90aj%$0a!Gm&!
|
||||
|
||||
,de[B3!XlC'%$"-Eme,D0'(Z229-8DlB`9Q$FC!Y6@9L'KA%@PQm[")V0YM#PKBP
|
||||
|
||||
$[mI#m!L#i#MfjAH50i4eE512Q3bj@@90I4m!N!--!'XcXfpJlh2Ij$4lRaZHF-P
|
||||
|
||||
a`Tr-D)4&@%FjIAiV9hi5rZ3i@3NqRhV5`hI'm8m[3MNjENHi%AjN`!NMR"`rbB$
|
||||
|
||||
bTrc)FA,m$%r*F51Fm*03FTa`FTa`-Q#%%hlN'4R`Pa`RA(+FF+mMamRa)mq2m$2
|
||||
|
||||
#bB!#GjN8B'@Y6-+0iUpN*rl)-F)*2m)*8[#%!j-9H"9SN!!()1QkKK#+`Hm@K$S
|
||||
|
||||
HJ&m,rN[#E`hmIJLEJ,q0bk)PQTCS@&q4J@q@4d"9U,FU)md-(0Yrf-'kLSC3Ech
|
||||
|
||||
QTZ6PDfM!,6kXTJh48"8c3%-B$Af2ZR8CG9Ip2$-35k-p#&9[4Zd)$4`EE%%G46!
|
||||
|
||||
,R0"9-23T99CN34j4,-#2%@HJ4P(6T'aDQa#N[iMDX5G2a3J5j8hqU`G8AI)J-HU
|
||||
|
||||
[2pc+8DXTel3Q5K1DDDe`rC'MeMLS#5QV5"2QC-jFKV@(Y,XiDUf$'TI6Q941+fY
|
||||
|
||||
NIrEXmabeMLSdTZC&6Ae8m48krm8h(,@HFXdUSU`BRMk!q[lRHBlD3,RQ4#QENT@
|
||||
|
||||
#"cXRI2X+4ie6jif)dMfM+mkEUadrc9%E(G5'h+TKlGFqRHHS#3He,LFDrPe`h($
|
||||
|
||||
QCBlDa(3e*P+'jG["RP9riDM0,PI9V"`8d09SikJYP'YH1C5kHVfHlZ'SDkKIpI4
|
||||
|
||||
i+LIkaJ28)bpbe,88e9!N694cCG6ZNqFjkMUUN!"T6DE6ZT(h&AViKGmikRVU"NX
|
||||
|
||||
TAdR(H9q1FY4@bY@D,XL9SfF2rY6286HiPp,*+'9G,aJIFG50p#Uce14Gj3Y'd81
|
||||
|
||||
Ek"h5cFV&)blrQ+1f8B8b8UTJU&0#eN-9cVh+8GXGe*U-j!-kU)P6p4b9*UB'dj*
|
||||
|
||||
PCDb-E#IIrF$K4qBkCkfIRK)eFi@ZrFEXr4ae-h@$T1I(e%`C&K,!AUi3T&L#1U`
|
||||
|
||||
I'P&bCG3h(rRp#Fje+d8&50fBrKHeFp&j@4Q5M3GV$pea1eGSfk+(0$9pa80R1GF
|
||||
|
||||
ZCkfce*a5FDbGI1mKMRSpifUSq482fFRj!BlD6Id+#UPkaDr(MfcMU0YGVSSeRLY
|
||||
|
||||
8Z0V[F05H43q4)19lk0aM"lL(GMKViS"LkT1'T(MH+rPeTkZ3!*U"!([&H8FjkLl
|
||||
|
||||
+0@RS306mKfX[64ZJ+`31D"5@fGUaCaUiVRd8Y@!C+5NVP42Ef6h&a0E[S,D5e*Z
|
||||
|
||||
k$e*4k[,4R"1qUq@S0cKV-k$Hk86c@fiEqT2V*rYSlLHcfePEppip1YM9Hl2Del9
|
||||
|
||||
2!&`"@TQ,U#F1&[Z''jdelZ4b1(ZHmdimH"0(45eR)(&!*q9f)f6q6PCX0VTUBad
|
||||
|
||||
IAd$pf!@`[ik1Br'KUlR)+fakrN"cHF(H36)2h%jb&H(+NrX0&jMF9VMIj$*$&L)
|
||||
|
||||
T"p)0cLf`Yq1%"AXR6JQ`Yq'FKMf0GB,GdbRXPYLiZ+lq4#IBL8k`%jeJ*cV"6R5
|
||||
|
||||
#RHJ%1p%*GU)6l%3Rf)P1h%qc#+[@Y15RS-eL8qhT&"fJcd&k4dVkK,dC'pb'AVi
|
||||
|
||||
MRZjKXmB'HccD3(IrcJ8G(KYmfk)&p1R"5Hkrqa'fKQc`$Bdfm0&Ek'dF5*Cm&25
|
||||
|
||||
6E"T+qQc(16M5i"iI4FpKHCCb3p#-XSR6I3[1YF$(e@dVrAm(hAhGA,f#1a4fVQ`
|
||||
|
||||
D)a0bM1IcX19PNiJXd-QrQrjp$rTP0Nh4$ljDEE6C0*GdfSPEQNJ$[AaI"9dkQjE
|
||||
|
||||
)"&rjZ5PSlpQXL6c)65I42'&jkHi((6HE659pGY(F%GhJrk#CBp-AQC!!QcfG`RF
|
||||
|
||||
BE0C'2GbTm18(Qh@4"hI+cbI"'a-fkb-2I05,Qq*VI86`ZS90Dq6"IEUNPpZrZ6d
|
||||
|
||||
IkmP@hp@`f9$5UmK,"LjZ2dGjKIdd'pTRSrf,Re6[[[HdcbYXX0R3aK[KcVI)#mr
|
||||
|
||||
A-dm"R8jJFcLjAc2T0r!1Xr%Ph(NRKdhm"Y1PM9qd9#9(PFc#![X)[SNKr!e@jAm
|
||||
|
||||
!N!-0$3pYGbpRBh4PFh3Z8&"$,VN!N"!4c!#3%%+&!*!)rj!%68e38Ne33d-"!+X
|
||||
|
||||
[PkkV-$P&!!!'-3!!'Z!!!!'T!!!&bE5F%03!N!B"fL0%$L)UANhN3L9r6IYAE+G
|
||||
|
||||
KN!"UFiH"Gce$HU!q'61jBIV#iB$[cjhJM1X-GhH'!`%ib6Q'-Lm+c58r)bVkFF(
|
||||
|
||||
"YqU[[irS4$#9MENFjIkKL[iaR2rVS6lQ@%G&Y2d3UK*9JDUkJ,Bce(Pf6fJm&6R
|
||||
|
||||
b2Z8HRJiXa'A+ir""h#2TreqK*11PKX-G4'@dI[MrP@fl(cXiL9b1Haec4BbeKmP
|
||||
|
||||
aeJj"iNA$iL1d#Y1J+HR89#QQrG%86l98l[LLFhLNlhad)NaL2JK&0pZFr-d1m4!
|
||||
|
||||
+XYS)fcSm[diTeKAC%-A8h"M6e)5Fp+AHXD3p1ZNm1FY%rabj$[`E!$0bi`E$P26
|
||||
|
||||
rG@!p"$aQr-JXH*CjLX,-Um9UPGj1-5VH)fY@`*(4VHaDSf,&r6CPrlq&--R1K6X
|
||||
|
||||
*#r!9a`Q#"HZ@0$hdcLR&Z$Fm-LN%a%6I)NG'j`NF&EkCY9`(CaX9iFL4(fpK!IC
|
||||
|
||||
B8#c-*P,XP1dG-@D4KE%@0XR#9"C'PcdhhF,ZXE"3#eYVB3-&a[CDHNU"FB-@YXI
|
||||
|
||||
#PPJD!bcX5f0T(aH0)DaV'hR-C-M0+Q[Uq``!Da0l'f3fmMSr"jhCCQZ%N3NRNdf
|
||||
|
||||
14LJRP"rPR[a@3Sqr%8D1NjAJmk5Hp2#G-Ic6Le"1MJm)Pachb(2###I(6c*J%8k
|
||||
|
||||
j%8k1RiHRj,J46[K*+$P11$P11"P3`JNrmS`-q)!-Z'6!D6eKj2L4C`f-F$+J`(8
|
||||
|
||||
Q"D$m9QE4e,T1r"&qK,q%%k6J#3FQ+c!qS%%HJ+LU#N)S",rE%'S`i2Fjq"D$ha,
|
||||
|
||||
iI4qf+2P[K53BJQi)Q['&0I#IjBQL)Y4CP"42pjcUHm,'ZSf'8'HBF--Ck@qdLS0
|
||||
|
||||
b3K-d'HXH'L*+S#ZS9C93Dp(hThY##E32SH*'Y!@KRP2p0@MV!TJ"6QM*DZUi,'%
|
||||
|
||||
T+JeJ!r"$PM03TD!SBLUKM%E&Qd60d0-c)3Z*mVDqK3&9&I13!!6eTfr[iUM&P'Y
|
||||
|
||||
#%F4446G@Z(l(88YXe)LB`Z+S2TE@Pf(0!mTp(,A84Uf3!",*H&STD'4qmZcc(,@
|
||||
|
||||
-+M3XC`4&IJbl#Phql%Z1'UCF8eL3!,#@e`G3hrdd`e(,+GHd)+EL%XlQBDHLAlh
|
||||
|
||||
-85ZSm`B%mB'K&HG0PBjFj+L90QTjHXf`jUXI6h28L)eDPKBdpblBE[Mm*BjDaA6
|
||||
|
||||
94Z1DiGV"R*4rj+M9$PGCAcdSS+ZfQD2@8+iCI$4qqhSpdmj4DkPIeF4)2#fiaJ2
|
||||
|
||||
8Bbpbe(889F1L)XMT!QVVKFXFYBiUT"YMLB5UC9b&(RhKCikkRVV"`)8VDEQKZf-
|
||||
|
||||
V4kfRA)f*V,4kp-cqUedFGB0c+Hf-8Y$eQ[B"4pe)Vc*,6IQVI%eEm0!QHSG8IIA
|
||||
|
||||
L@5lrN!#MEUCQhhrr8(p,Ec3@kie#4,V"pIbK)a`9-T!!GBlk-`E@KJ84,f%LG'i
|
||||
|
||||
f[T!!!'KLUKNie$XiPM(N0&lQH[KU'dGYS"j+L['X*Sp(8hPGSl0R1'UMM9U5&&e
|
||||
|
||||
!'c8b%qDSN!"L,3rTKL6Ki3+b'A[l2CZI0G[Y06`a,LMk#PhcpFQ(1'S6pDZSCSE
|
||||
|
||||
PC!&fUR[r&Uj3-eASS(Td!+F,U1H1r2)8jpT#83&5e5EZS1kBGej+JZb9Kc82h(-
|
||||
|
||||
h9kKehN1+R,MPS8ZFDjZpPPPABF@aCZbG`abeRA(9j-b+KmcBG!p(lD"q"B9NGG@
|
||||
|
||||
[CimeFp5G$PGXM+5cUec0YcMUVRN2@9(2pG$Xii2F3jhf'KR%ZMUQL6M[[CaIGcX
|
||||
|
||||
+b8Q)f,HFGj+MGP'Z-8d&S[SrA2I32!5k3L5#cQ1CV4NkAXjer4pehS"JT*BMJmh
|
||||
|
||||
eq+jHMVUAFXdD@Pa-LB8NHQRI3K)PI3p-0D6jHqhb!-,0lkJIrAq#kpTYIkZh1S$
|
||||
|
||||
iJj!!%H0,"hSUqR8TjiTU6d$LH!3qd"l'QVp5(*Z0MQj%N5IR8$IK#2YVk#b4%AU
|
||||
|
||||
KAhRjVG*[D*cA0T*HB1mJp`hf9R+*B@mR9a,f0R*MBGp1mJVX655"`0j)XK,X1mL
|
||||
|
||||
pKlf"*+irG2*l,$B1E[#"6T2S$,#X@[56ejba+FlV&"bJcm2dMZ6dm6Xk0U4jAES
|
||||
|
||||
MHGhp&Sp0DH#"lZkGmrT#0Q@"!rVX)TRXhr[K0j4X`S%(2RS$[3RXDKCpj(@KE-T
|
||||
|
||||
cqZ`NL6E3i"kI4160319LE["D@$B9G'mQ#4Ai1,Ued1qGG(GeFr6blT!!hqqbU3a
|
||||
|
||||
-b$&jRrZ0-TY)B)&1lYedll[ACE1T#Rl`e9TlcUBkTp0ZdVF%-H4Z[lGR8a1Bi#X
|
||||
|
||||
h0hN["GM8"KlNTJYSfQ*jrHjlI6UE66PpZQMZ#'l`[pH@XGNEQ*!!Qr-kq@mqf+`
|
||||
|
||||
,HVK6rLX60R@""hI+c5IHHaBfk`-2I,5(G,jrpK(H5aSfpB%(pqQkANlrj[4mV#G
|
||||
|
||||
EHm2$CN01V`9H%R"aqMR+bhpj`iDqe%&p8bAIR!qTj%[4$kpFY(MK'lcmYcPXk&Z
|
||||
|
||||
H1lcmlTi0lIT[mPVbJIFUL!elGjRM4BM8c8"+#$@"@kr%qK5GrJGH8d5JeDSp%6Z
|
||||
|
||||
S`aY94TZmpLQ+$H(Nh"cl%r`RK-KrL#Vr!3#3!aq$!!!"!*!$!43!N!-8!*!$-Tr
|
||||
|
||||
lRLe!rr#`!,K[$#eZd!6rm2rdd"lm`FAKdkSV8FY+$deKBe"bEfTPBh4c,R0TG!)
|
||||
|
||||
!N!06594%8dP8)3#3"P0*9%46593K!*!BUc!jI3!!8M8!!!&'"1"2l'mDG@6JrHc
|
||||
|
||||
K@5U#NI*HN@GK!Z"2kQ`FG&2UN!"S!!,L@5[48(adA`CdC!EJ6qj[8hJS!!EJEHl
|
||||
|
||||
LEe5!)D$!FJC1ANl!*IrX51FI-#D`jL63G!*&0K!+1Li!&Ri!)VX-S"lbUKQJ(Z`
|
||||
|
||||
3!+SDI!$!#3ZT8,aIE!!!Q$!'8!6"aG!!N!-3!#X!"3%B!J#3"`-!N!-"!*!$!43
|
||||
|
||||
!N!-8!*!$-J$j(l!@#J#3!a`!-J!!8f9dC`#3!`S!!2rr!*!&q@G%'@B:
|
||||
|
||||
@@ -1,91 +0,0 @@
|
||||
/*
|
||||
MacOS_Test_config.h
|
||||
|
||||
Configuration flags for Macintosh development systems.
|
||||
|
||||
Test version.
|
||||
|
||||
<Revision History>
|
||||
|
||||
11/16/95 pcb Updated compilation flags to reflect latest 4.6 Makefile.
|
||||
|
||||
by Patrick C. Beard.
|
||||
*/
|
||||
/* Boehm, November 17, 1995 12:05 pm PST */
|
||||
|
||||
#ifdef __MWERKS__
|
||||
|
||||
// for CodeWarrior Pro with Metrowerks Standard Library (MSL).
|
||||
// #define MSL_USE_PRECOMPILED_HEADERS 0
|
||||
#include <ansi_prefix.mac.h>
|
||||
#ifndef __STDC__
|
||||
#define __STDC__ 0
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
// these are defined again in gc_priv.h.
|
||||
#undef TRUE
|
||||
#undef FALSE
|
||||
|
||||
#define ALL_INTERIOR_POINTERS // follows interior pointers.
|
||||
//#define SILENT // want collection messages.
|
||||
//#define DONT_ADD_BYTE_AT_END // no padding.
|
||||
//#define SMALL_CONFIG // whether to a smaller heap.
|
||||
#define NO_SIGNALS // signals aren't real on the Macintosh.
|
||||
#define USE_TEMPORARY_MEMORY // use Macintosh temporary memory.
|
||||
|
||||
// CFLAGS= -O -DNO_SIGNALS -DALL_INTERIOR_POINTERS -DSILENT
|
||||
//
|
||||
//LIBGC_CFLAGS= -O -DNO_SIGNALS -DSILENT \
|
||||
// -DREDIRECT_MALLOC=GC_malloc_uncollectable \
|
||||
// -DDONT_ADD_BYTE_AT_END -DALL_INTERIOR_POINTERS
|
||||
// Flags for building libgc.a -- the last two are required.
|
||||
//
|
||||
// Setjmp_test may yield overly optimistic results when compiled
|
||||
// without optimization.
|
||||
// -DSILENT disables statistics printing, and improves performance.
|
||||
// -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
|
||||
// altered stubborn objects, at substantial performance cost.
|
||||
// Use only for incremental collector debugging.
|
||||
// -DFIND_LEAK causes the collector to assume that all inaccessible
|
||||
// objects should have been explicitly deallocated, and reports exceptions.
|
||||
// Finalization and the test program are not usable in this mode.
|
||||
// -DSOLARIS_THREADS enables support for Solaris (thr_) threads.
|
||||
// (Clients should also define SOLARIS_THREADS and then include
|
||||
// gc.h before performing thr_ or GC_ operations.)
|
||||
// This is broken on nonSPARC machines.
|
||||
// -DALL_INTERIOR_POINTERS allows all pointers to the interior
|
||||
// of objects to be recognized. (See gc_priv.h for consequences.)
|
||||
// -DSMALL_CONFIG tries to tune the collector for small heap sizes,
|
||||
// usually causing it to use less space in such situations.
|
||||
// Incremental collection no longer works in this case.
|
||||
// -DLARGE_CONFIG tunes the collector for unusually large heaps.
|
||||
// Necessary for heaps larger than about 500 MB on most machines.
|
||||
// Recommended for heaps larger than about 64 MB.
|
||||
// -DDONT_ADD_BYTE_AT_END is meaningful only with
|
||||
// -DALL_INTERIOR_POINTERS. Normally -DALL_INTERIOR_POINTERS
|
||||
// causes all objects to be padded so that pointers just past the end of
|
||||
// an object can be recognized. This can be expensive. (The padding
|
||||
// is normally more than one byte due to alignment constraints.)
|
||||
// -DDONT_ADD_BYTE_AT_END disables the padding.
|
||||
// -DNO_SIGNALS does not disable signals during critical parts of
|
||||
// the GC process. This is no less correct than many malloc
|
||||
// implementations, and it sometimes has a significant performance
|
||||
// impact. However, it is dangerous for many not-quite-ANSI C
|
||||
// programs that call things like printf in asynchronous signal handlers.
|
||||
// -DOPERATOR_NEW_ARRAY declares that the C++ compiler supports the
|
||||
// new syntax "operator new[]" for allocating and deleting arrays.
|
||||
// See gc_cpp.h for details. No effect on the C part of the collector.
|
||||
// This is defined implicitly in a few environments.
|
||||
// -DREDIRECT_MALLOC=X causes malloc, realloc, and free to be defined
|
||||
// as aliases for X, GC_realloc, and GC_free, respectively.
|
||||
// Calloc is redefined in terms of the new malloc. X should
|
||||
// be either GC_malloc or GC_malloc_uncollectable.
|
||||
// The former is occasionally useful for working around leaks in code
|
||||
// you don't want to (or can't) look at. It may not work for
|
||||
// existing code, but it often does. Neither works on all platforms,
|
||||
// since some ports use malloc or calloc to obtain system memory.
|
||||
// (Probably works for UNIX, and win32.)
|
||||
// -DNO_DEBUG removes GC_dump and the debugging routines it calls.
|
||||
// Reduces code size slightly at the expense of debuggability.
|
||||
@@ -1,89 +0,0 @@
|
||||
/*
|
||||
MacOS_config.h
|
||||
|
||||
Configuration flags for Macintosh development systems.
|
||||
|
||||
<Revision History>
|
||||
|
||||
11/16/95 pcb Updated compilation flags to reflect latest 4.6 Makefile.
|
||||
|
||||
by Patrick C. Beard.
|
||||
*/
|
||||
/* Boehm, November 17, 1995 12:10 pm PST */
|
||||
|
||||
#ifdef __MWERKS__
|
||||
|
||||
// for CodeWarrior Pro with Metrowerks Standard Library (MSL).
|
||||
// #define MSL_USE_PRECOMPILED_HEADERS 0
|
||||
#include <ansi_prefix.mac.h>
|
||||
#ifndef __STDC__
|
||||
#define __STDC__ 0
|
||||
#endif
|
||||
|
||||
#endif /* __MWERKS__ */
|
||||
|
||||
// these are defined again in gc_priv.h.
|
||||
#undef TRUE
|
||||
#undef FALSE
|
||||
|
||||
#define ALL_INTERIOR_POINTERS // follows interior pointers.
|
||||
#define SILENT // no collection messages.
|
||||
//#define DONT_ADD_BYTE_AT_END // no padding.
|
||||
//#define SMALL_CONFIG // whether to use a smaller heap.
|
||||
#define NO_SIGNALS // signals aren't real on the Macintosh.
|
||||
#define USE_TEMPORARY_MEMORY // use Macintosh temporary memory.
|
||||
|
||||
// CFLAGS= -O -DNO_SIGNALS -DSILENT -DALL_INTERIOR_POINTERS
|
||||
//
|
||||
//LIBGC_CFLAGS= -O -DNO_SIGNALS -DSILENT \
|
||||
// -DREDIRECT_MALLOC=GC_malloc_uncollectable \
|
||||
// -DDONT_ADD_BYTE_AT_END -DALL_INTERIOR_POINTERS
|
||||
// Flags for building libgc.a -- the last two are required.
|
||||
//
|
||||
// Setjmp_test may yield overly optimistic results when compiled
|
||||
// without optimization.
|
||||
// -DSILENT disables statistics printing, and improves performance.
|
||||
// -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
|
||||
// altered stubborn objects, at substantial performance cost.
|
||||
// Use only for incremental collector debugging.
|
||||
// -DFIND_LEAK causes the collector to assume that all inaccessible
|
||||
// objects should have been explicitly deallocated, and reports exceptions.
|
||||
// Finalization and the test program are not usable in this mode.
|
||||
// -DSOLARIS_THREADS enables support for Solaris (thr_) threads.
|
||||
// (Clients should also define SOLARIS_THREADS and then include
|
||||
// gc.h before performing thr_ or GC_ operations.)
|
||||
// This is broken on nonSPARC machines.
|
||||
// -DALL_INTERIOR_POINTERS allows all pointers to the interior
|
||||
// of objects to be recognized. (See gc_priv.h for consequences.)
|
||||
// -DSMALL_CONFIG tries to tune the collector for small heap sizes,
|
||||
// usually causing it to use less space in such situations.
|
||||
// Incremental collection no longer works in this case.
|
||||
// -DLARGE_CONFIG tunes the collector for unusually large heaps.
|
||||
// Necessary for heaps larger than about 500 MB on most machines.
|
||||
// Recommended for heaps larger than about 64 MB.
|
||||
// -DDONT_ADD_BYTE_AT_END is meaningful only with
|
||||
// -DALL_INTERIOR_POINTERS. Normally -DALL_INTERIOR_POINTERS
|
||||
// causes all objects to be padded so that pointers just past the end of
|
||||
// an object can be recognized. This can be expensive. (The padding
|
||||
// is normally more than one byte due to alignment constraints.)
|
||||
// -DDONT_ADD_BYTE_AT_END disables the padding.
|
||||
// -DNO_SIGNALS does not disable signals during critical parts of
|
||||
// the GC process. This is no less correct than many malloc
|
||||
// implementations, and it sometimes has a significant performance
|
||||
// impact. However, it is dangerous for many not-quite-ANSI C
|
||||
// programs that call things like printf in asynchronous signal handlers.
|
||||
// -DOPERATOR_NEW_ARRAY declares that the C++ compiler supports the
|
||||
// new syntax "operator new[]" for allocating and deleting arrays.
|
||||
// See gc_cpp.h for details. No effect on the C part of the collector.
|
||||
// This is defined implicitly in a few environments.
|
||||
// -DREDIRECT_MALLOC=X causes malloc, realloc, and free to be defined
|
||||
// as aliases for X, GC_realloc, and GC_free, respectively.
|
||||
// Calloc is redefined in terms of the new malloc. X should
|
||||
// be either GC_malloc or GC_malloc_uncollectable.
|
||||
// The former is occasionally useful for working around leaks in code
|
||||
// you don't want to (or can't) look at. It may not work for
|
||||
// existing code, but it often does. Neither works on all platforms,
|
||||
// since some ports use malloc or calloc to obtain system memory.
|
||||
// (Probably works for UNIX, and win32.)
|
||||
// -DNO_DEBUG removes GC_dump and the debugging routines it calls.
|
||||
// Reduces code size slightly at the expense of debuggability.
|
||||
@@ -1,9 +0,0 @@
|
||||
/*
|
||||
dataend.c
|
||||
|
||||
A hack to get the extent of global data for the Macintosh.
|
||||
|
||||
by Patrick C. Beard.
|
||||
*/
|
||||
|
||||
long __dataend;
|
||||
@@ -1,9 +0,0 @@
|
||||
/*
|
||||
datastart.c
|
||||
|
||||
A hack to get the extent of global data for the Macintosh.
|
||||
|
||||
by Patrick C. Beard.
|
||||
*/
|
||||
|
||||
long __datastart;
|
||||
@@ -1,107 +0,0 @@
|
||||
#-----------------------------------------------------------------------------#
|
||||
|
||||
# Makefile.DLLs, version 0.4.
|
||||
|
||||
# Contributed by Fergus Henderson.
|
||||
|
||||
# This Makefile contains rules for creating DLLs on Windows using gnu-win32.
|
||||
|
||||
#-----------------------------------------------------------------------------#
|
||||
|
||||
# This rule creates a `.def' file, which lists the symbols that are exported
|
||||
# from the DLL. We use `nm' to get a list of all the exported text (`T')
|
||||
# symbols and data symbols -- including uninitialized data (`B'),
|
||||
# initialized data (`D'), read-only data (`R'), and common blocks (`C').
|
||||
%.def: %.a
|
||||
echo EXPORTS > $@
|
||||
nm $< | grep '^........ [BCDRT] _' | sed 's/[^_]*_//' >> $@
|
||||
|
||||
# We need to use macros to access global data:
|
||||
# the user of the DLL must refer to `foo' as `(*__imp_foo)'.
|
||||
# This rule creates a `_globals.h' file, which contains macros
|
||||
# for doing this.
|
||||
|
||||
SYM_PREFIX = $(firstword $(SYM_PREFIX-$*) $*)
|
||||
DLL_MACRO = $(SYM_PREFIX)_USE_DLL
|
||||
IMP_MACRO = $(SYM_PREFIX)_IMP
|
||||
GLOBAL_MACRO = $(SYM_PREFIX)_GLOBAL
|
||||
|
||||
%_globals.h: %.a
|
||||
echo "/* automatically generated by Makefile.DLLs */" > $@
|
||||
echo "#if defined(__GNUC__) && defined(_WIN32) \\" >> $@
|
||||
echo " && defined($(DLL_MACRO))" >> $@
|
||||
echo "# define $(IMP_MACRO)(name) __imp_##name" >> $@
|
||||
echo "# define $(GLOBAL_MACRO)(name) (*$(IMP_MACRO)(name))" >> $@
|
||||
echo "#else" >> $@
|
||||
echo "# define $(GLOBAL_MACRO)(name) name" >> $@
|
||||
echo "#endif" >> $@
|
||||
echo "" >> $@
|
||||
for sym in `nm $< | grep '^........ [BCDR] _' | sed 's/[^_]*_//'`; do \
|
||||
echo "#define $$sym $(GLOBAL_MACRO)($$sym)" >> $@; \
|
||||
done
|
||||
|
||||
# This rule creates the export object file (`foo.exp') which contains the
|
||||
# jump table array; this export object file becomes part of the DLL.
|
||||
# This rule also creates the import library (`foo_dll.a') which contains small
|
||||
# stubs for all the functions exported by the DLL which jump to them via the
|
||||
# jump table. Executables that will use the DLL must be linked against this
|
||||
# stub library.
|
||||
%.exp %_dll.a : %.def
|
||||
dlltool $(DLLTOOLFLAGS) $(DLLTOOLFLAGS-$*) \
|
||||
--def $< \
|
||||
--dllname $*.dll \
|
||||
--output-exp $*.exp \
|
||||
--output-lib $*_dll.a
|
||||
|
||||
# The `sed' commands below are to convert DOS-style `C:\foo\bar'
|
||||
# pathnames into Unix-style `//c/foo/bar' pathnames.
|
||||
CYGWIN32_LIBS = $(shell echo \
|
||||
-L`dirname \`gcc -print-file-name=libgcc.a | \
|
||||
sed -e 's@^\\\\([A-Za-z]\\\\):@//\\\\1@g' -e 's@\\\\\\\\@/@g' \` ` \
|
||||
-L`dirname \`gcc -print-file-name=libcygwin.a | \
|
||||
sed -e 's@^\\\\([A-Za-z]\\\\):@//\\\\1@g' -e 's@\\\\\\\\@/@g' \` ` \
|
||||
-L`dirname \`gcc -print-file-name=libkernel32.a | \
|
||||
sed -e 's@^\\\\([A-Za-z]\\\\):@//\\\\1@g' -e 's@\\\\\\\\@/@g' \` ` \
|
||||
-lgcc -lcygwin -lkernel32 -lgcc)
|
||||
|
||||
RELOCATABLE=yes
|
||||
|
||||
ifeq "$(strip $(RELOCATABLE))" "yes"
|
||||
|
||||
# to create relocatable DLLs, we need to do two passes
|
||||
%.dll: %.exp %.a dll_fixup.o dll_init.o
|
||||
$(LD) $(LDFLAGS) $(LDFLAGS-$*) --dll -o $*.base \
|
||||
-e _dll_entry@12 dll_init.o \
|
||||
dll_fixup.o $*.exp $*.a \
|
||||
$(LDLIBS) $(LDLIBS-$*) \
|
||||
$(CYGWIN32_LIBS)
|
||||
$(LD) $(LDFLAGS) $(LDFLAGS-$*) --dll --base-file $*.base -o $@ \
|
||||
-e _dll_entry@12 dll_init.o \
|
||||
dll_fixup.o $*.exp $*.a \
|
||||
$(LDLIBS) $(LDLIBS-$*) \
|
||||
$(CYGWIN32_LIBS)
|
||||
rm -f $*.base
|
||||
else
|
||||
|
||||
%.dll: %.exp %.a dll_fixup.o dll_init.o
|
||||
$(LD) $(LDFLAGS) $(LDFLAGS-$*) --dll -o $@ \
|
||||
-e _dll_entry@12 dll_init.o \
|
||||
dll_fixup.o $*.exp $*.a \
|
||||
$(LDLIBS) $(LDLIBS-$*) \
|
||||
$(CYGWIN32_LIBS)
|
||||
|
||||
endif
|
||||
|
||||
# This black magic piece of assembler needs to be linked in in order to
|
||||
# properly terminate the list of imported DLLs.
|
||||
dll_fixup.s:
|
||||
echo '.section .idata$$3' > dll_fixup.s
|
||||
echo '.long 0,0,0,0, 0,0,0,0' >> dll_fixup.s
|
||||
|
||||
# This bit is necessary to provide an initialization function for the DLL.
|
||||
dll_init.c:
|
||||
echo '__attribute__((stdcall))' > dll_init.c
|
||||
echo 'int dll_entry(int handle, int reason, void *ptr)' >> dll_init.c
|
||||
echo '{return 1; }' >> dll_init.c
|
||||
|
||||
dont_throw_away: dll_fixup.o dll_init.o
|
||||
@@ -1,150 +0,0 @@
|
||||
## Process this file with automake to produce Makefile.in.
|
||||
|
||||
## FIXME: `make dist' in this directory will not currently work. Many
|
||||
## files that should be in the distribution are not mentioned in this
|
||||
## Makefile.am.
|
||||
|
||||
AUTOMAKE_OPTIONS = cygnus
|
||||
|
||||
SUBDIRS = include
|
||||
|
||||
# Multilib support variables.
|
||||
MULTISRCTOP =
|
||||
MULTIBUILDTOP =
|
||||
MULTIDIRS =
|
||||
MULTISUBDIR =
|
||||
MULTIDO = true
|
||||
MULTICLEAN = true
|
||||
|
||||
## Install a library built with a cross compiler in tooldir, not
|
||||
## libdir.
|
||||
if USE_LIBDIR
|
||||
toolexeclibdir = $(libdir)$(MULTISUBDIR)
|
||||
else
|
||||
toolexecdir = $(exec_prefix)/$(target_alias)
|
||||
toolexeclibdir = $(toolexecdir)/lib$(MULTISUBDIR)
|
||||
endif
|
||||
|
||||
toolexeclib_LTLIBRARIES = $(target_all)
|
||||
EXTRA_LTLIBRARIES = libgcjgc.la
|
||||
libgcjgc_la_SOURCES = allchblk.c alloc.c blacklst.c checksums.c dbg_mlc.c \
|
||||
dyn_load.c finalize.c gc_dlopen.c gcj_mlc.c headers.c irix_threads.c \
|
||||
linux_threads.c malloc.c mallocx.c mark.c mark_rts.c misc.c new_hblk.c \
|
||||
obj_map.c os_dep.c pcr_interface.c ptr_chck.c real_malloc.c reclaim.c \
|
||||
solaris_pthreads.c solaris_threads.c specific.c stubborn.c typd_mlc.c
|
||||
|
||||
# Include THREADLIBS here to ensure that the correct versions of
|
||||
# linuxthread semaphore functions get linked:
|
||||
libgcjgc_la_LIBADD = @addobjs@ $(THREADLIBS)
|
||||
libgcjgc_la_DEPENDENCIES = @addobjs@
|
||||
libgcjgc_la_LDFLAGS = -version-info 1:1:0 -rpath $(toolexeclibdir)
|
||||
|
||||
EXTRA_libgcjgc_la_SOURCES = alpha_mach_dep.s \
|
||||
mips_sgi_mach_dep.s mips_ultrix_mach_dep.s powerpc_macosx_mach_dep.s \
|
||||
rs6000_mach_dep.s sparc_mach_dep.s sparc_netbsd_mach_dep.s \
|
||||
sparc_sunos4_mach_dep.s ia64_save_regs_in_stack.s
|
||||
|
||||
AM_CXXFLAGS = @GC_CFLAGS@
|
||||
AM_CFLAGS = @GC_CFLAGS@
|
||||
|
||||
check_PROGRAMS = gctest
|
||||
# The following hack produces a warning from automake, but we need it in order
|
||||
# to build a file from a subdirectory. FIXME.
|
||||
test.o: tests/test.c
|
||||
$(COMPILE) -c $(srcdir)/tests/test.c
|
||||
# Using $< in the above seems to fail with the HP/UX on Itanium make.
|
||||
|
||||
gctest_OBJECTS = test.o
|
||||
gctest_LDADD = ./libgcjgc.la $(THREADLIBS) $(EXTRA_TEST_LIBS)
|
||||
gctest_LDFLAGS = -shared-libgcc
|
||||
TESTS_ENVIRONMENT = LD_LIBRARY_PATH=../../$(MULTIBUILDTOP)gcc
|
||||
TESTS = gctest
|
||||
|
||||
## FIXME: relies on internal code generated by automake.
|
||||
all_objs = @addobjs@ $(libgcjgc_la_OBJECTS)
|
||||
$(all_objs) : include/private/gcconfig.h include/private/gc_priv.h \
|
||||
include/private/gc_hdrs.h include/gc.h include/gc_gcj.h include/gc_mark.h
|
||||
|
||||
## FIXME: we shouldn't have to do this, but automake forces us to.
|
||||
.s.lo:
|
||||
## We use -Wp,-P to strip #line directives. Irix `as' chokes on
|
||||
## these.
|
||||
$(LTCOMPILE) -Wp,-P -x assembler-with-cpp -c $<
|
||||
|
||||
## We have our own definition of LTCOMPILE because we want to use our
|
||||
## CFLAGS, not those passed in from the top level make.
|
||||
LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) \
|
||||
$(AM_CPPFLAGS) $(CPPFLAGS) \
|
||||
$(AM_CFLAGS) $(MY_CFLAGS) $(GC_CFLAGS)
|
||||
LINK = $(LIBTOOL) --mode=link $(CC) $(AM_CFLAGS) $(MY_CFLAGS) $(LDFLAGS) -o $@
|
||||
|
||||
AM_CFLAGS = @GC_CFLAGS@
|
||||
|
||||
# Work around what appears to be a GNU make bug handling MAKEFLAGS
|
||||
# values defined in terms of make variables, as is the case for CC and
|
||||
# friends when we are called from the top level Makefile.
|
||||
AM_MAKEFLAGS = \
|
||||
"AR_FLAGS=$(AR_FLAGS)" \
|
||||
"CC_FOR_BUILD=$(CC_FOR_BUILD)" \
|
||||
"CFLAGS=$(CFLAGS)" \
|
||||
"CXXFLAGS=$(CXXFLAGS)" \
|
||||
"CFLAGS_FOR_BUILD=$(CFLAGS_FOR_BUILD)" \
|
||||
"CFLAGS_FOR_TARGET=$(CFLAGS_FOR_TARGET)" \
|
||||
"INSTALL=$(INSTALL)" \
|
||||
"INSTALL_DATA=$(INSTALL_DATA)" \
|
||||
"INSTALL_PROGRAM=$(INSTALL_PROGRAM)" \
|
||||
"INSTALL_SCRIPT=$(INSTALL_SCRIPT)" \
|
||||
"LDFLAGS=$(LDFLAGS)" \
|
||||
"LIBCFLAGS=$(LIBCFLAGS)" \
|
||||
"LIBCFLAGS_FOR_TARGET=$(LIBCFLAGS_FOR_TARGET)" \
|
||||
"MAKE=$(MAKE)" \
|
||||
"MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" \
|
||||
"PICFLAG=$(PICFLAG)" \
|
||||
"PICFLAG_FOR_TARGET=$(PICFLAG_FOR_TARGET)" \
|
||||
"SHELL=$(SHELL)" \
|
||||
"EXPECT=$(EXPECT)" \
|
||||
"RUNTEST=$(RUNTEST)" \
|
||||
"RUNTESTFLAGS=$(RUNTESTFLAGS)" \
|
||||
"exec_prefix=$(exec_prefix)" \
|
||||
"infodir=$(infodir)" \
|
||||
"libdir=$(libdir)" \
|
||||
"prefix=$(prefix)" \
|
||||
"tooldir=$(tooldir)" \
|
||||
"AR=$(AR)" \
|
||||
"AS=$(AS)" \
|
||||
"CC=$(CC)" \
|
||||
"CXX=$(CXX)" \
|
||||
"LD=$(LD)" \
|
||||
"LIBCFLAGS=$(LIBCFLAGS)" \
|
||||
"NM=$(NM)" \
|
||||
"PICFLAG=$(PICFLAG)" \
|
||||
"RANLIB=$(RANLIB)" \
|
||||
"DESTDIR=$(DESTDIR)"
|
||||
|
||||
CONFIG_STATUS_DEPENDENCIES = $(srcdir)/configure.host
|
||||
|
||||
# Multilib support.
|
||||
.PHONY: all-multi mostlyclean-multi clean-multi distclean-multi \
|
||||
maintainer-clean-multi
|
||||
|
||||
all-am: all-multi
|
||||
install-am: install-multi
|
||||
mostlyclean-am: mostlyclean-multi
|
||||
clean-am: clean-multi
|
||||
distclean-am: distclean-multi
|
||||
maintainer-clean-am: maintainer-clean-multi
|
||||
|
||||
all-multi:
|
||||
$(MULTIDO) $(AM_MAKEFLAGS) DO=all multi-do
|
||||
install-multi:
|
||||
$(MULTIDO) $(AM_MAKEFLAGS) DO=install multi-do
|
||||
mostlyclean-multi:
|
||||
$(MULTICLEAN) $(AM_MAKEFLAGS) DO=mostlyclean multi-clean
|
||||
clean-multi:
|
||||
$(MULTICLEAN) $(AM_MAKEFLAGS) DO=clean multi-clean
|
||||
distclean-multi:
|
||||
$(MULTICLEAN) $(AM_MAKEFLAGS) DO=distclean multi-clean
|
||||
maintainer-clean-multi:
|
||||
$(MULTICLEAN) $(AM_MAKEFLAGS) DO=maintainer-clean multi-clean
|
||||
|
||||
MAKEOVERRIDES=
|
||||
@@ -1,611 +0,0 @@
|
||||
# This is the original manually generated Makefile. It may still be used
|
||||
# to build the collector.
|
||||
#
|
||||
# Primary targets:
|
||||
# gc.a - builds basic library
|
||||
# c++ - adds C++ interface to library
|
||||
# cords - adds cords (heavyweight strings) to library
|
||||
# test - prints porting information, then builds basic version of gc.a,
|
||||
# and runs some tests of collector and cords. Does not add cords or
|
||||
# c++ interface to gc.a
|
||||
# cord/de - builds dumb editor based on cords.
|
||||
ABI_FLAG=
|
||||
# ABI_FLAG should be the cc flag that specifies the ABI. On most
|
||||
# platforms this will be the empty string. Possible values:
|
||||
# +DD64 for 64-bit executable on HP/UX.
|
||||
# -n32, -n64, -o32 for SGI/MIPS ABIs.
|
||||
|
||||
AS_ABI_FLAG=$(ABI_FLAG)
|
||||
# ABI flag for assembler. On HP/UX this is +A64 for 64 bit
|
||||
# executables.
|
||||
|
||||
CC=cc $(ABI_FLAG)
|
||||
CXX=g++ $(ABI_FLAG)
|
||||
AS=as $(AS_ABI_FLAG)
|
||||
# The above doesn't work with gas, which doesn't run cpp.
|
||||
# Define AS as `gcc -c -x assembler-with-cpp' instead.
|
||||
|
||||
# Redefining srcdir allows object code for the nonPCR version of the collector
|
||||
# to be generated in different directories.
|
||||
srcdir= .
|
||||
VPATH= $(srcdir)
|
||||
|
||||
CFLAGS= -O -I$(srcdir)/include -DATOMIC_UNCOLLECTABLE -DNO_SIGNALS -DNO_EXECUTE_PERMISSION -DSILENT -DALL_INTERIOR_POINTERS
|
||||
|
||||
# To build the parallel collector on Linux, add to the above:
|
||||
# -DGC_LINUX_THREADS -DPARALLEL_MARK -DTHREAD_LOCAL_ALLOC
|
||||
# To build the parallel collector n a static library on HP/UX, add to the above:
|
||||
# -DGC_HPUX_THREADS -DPARALLEL_MARK -DTHREAD_LOCAL_ALLOC -DUSE_HPUX_TLS -D_POSIX_C_SOURCE=199506L
|
||||
|
||||
# HOSTCC and HOSTCFLAGS are used to build executables that will be run as
|
||||
# part of the build process, i.e. on the build machine. These will usually
|
||||
# be the same as CC and CFLAGS, except in a cross-compilation environment.
|
||||
# Note that HOSTCFLAGS should include any -D flags that affect thread support.
|
||||
HOSTCC=$(CC)
|
||||
HOSTCFLAGS=$(CFLAGS)
|
||||
|
||||
# For dynamic library builds, it may be necessary to add flags to generate
|
||||
# PIC code, e.g. -fPIC on Linux.
|
||||
|
||||
# Setjmp_test may yield overly optimistic results when compiled
|
||||
# without optimization.
|
||||
|
||||
# These define arguments influence the collector configuration:
|
||||
# -DSILENT disables statistics printing, and improves performance.
|
||||
# -DFIND_LEAK causes GC_find_leak to be initially set.
|
||||
# This causes the collector to assume that all inaccessible
|
||||
# objects should have been explicitly deallocated, and reports exceptions.
|
||||
# Finalization and the test program are not usable in this mode.
|
||||
# -DGC_SOLARIS_THREADS enables support for Solaris (thr_) threads.
|
||||
# (Clients should also define GC_SOLARIS_THREADS and then include
|
||||
# gc.h before performing thr_ or dl* or GC_ operations.)
|
||||
# Must also define -D_REENTRANT.
|
||||
# -DGC_SOLARIS_PTHREADS enables support for Solaris pthreads.
|
||||
# (Internally this define GC_SOLARIS_THREADS as well.)
|
||||
# -DGC_IRIX_THREADS enables support for Irix pthreads. See README.irix.
|
||||
# -DGC_HPUX_THREADS enables support for HP/UX 11 pthreads.
|
||||
# Also requires -D_REENTRANT or -D_POSIX_C_SOURCE=199506L. See README.hp.
|
||||
# -DGC_LINUX_THREADS enables support for Xavier Leroy's Linux threads.
|
||||
# see README.linux. -D_REENTRANT may also be required.
|
||||
# -DGC_OSF1_THREADS enables support for Tru64 pthreads. Untested.
|
||||
# -DGC_FREEBSD_THREADS enables support for FreeBSD pthreads. Untested.
|
||||
# Appeared to run into some underlying thread problems.
|
||||
# -DALL_INTERIOR_POINTERS allows all pointers to the interior
|
||||
# of objects to be recognized. (See gc_priv.h for consequences.)
|
||||
# Alternatively, GC_all_interior_pointers can be set at process
|
||||
# initialization time.
|
||||
# -DSMALL_CONFIG tries to tune the collector for small heap sizes,
|
||||
# usually causing it to use less space in such situations.
|
||||
# Incremental collection no longer works in this case.
|
||||
# -DLARGE_CONFIG tunes the collector for unusually large heaps.
|
||||
# Necessary for heaps larger than about 500 MB on most machines.
|
||||
# Recommended for heaps larger than about 64 MB.
|
||||
# -DDONT_ADD_BYTE_AT_END is meaningful only with -DALL_INTERIOR_POINTERS or
|
||||
# GC_all_interior_pointers = 1. Normally -DALL_INTERIOR_POINTERS
|
||||
# causes all objects to be padded so that pointers just past the end of
|
||||
# an object can be recognized. This can be expensive. (The padding
|
||||
# is normally more than one byte due to alignment constraints.)
|
||||
# -DDONT_ADD_BYTE_AT_END disables the padding.
|
||||
# -DNO_SIGNALS does not disable signals during critical parts of
|
||||
# the GC process. This is no less correct than many malloc
|
||||
# implementations, and it sometimes has a significant performance
|
||||
# impact. However, it is dangerous for many not-quite-ANSI C
|
||||
# programs that call things like printf in asynchronous signal handlers.
|
||||
# This is on by default. Turning it off has not been extensively tested with
|
||||
# compilers that reorder stores. It should have been.
|
||||
# -DNO_EXECUTE_PERMISSION may cause some or all of the heap to not
|
||||
# have execute permission, i.e. it may be impossible to execute
|
||||
# code from the heap. Currently this only affects the incremental
|
||||
# collector on UNIX machines. It may greatly improve its performance,
|
||||
# since this may avoid some expensive cache synchronization.
|
||||
# -DGC_NO_OPERATOR_NEW_ARRAY declares that the C++ compiler does not support
|
||||
# the new syntax "operator new[]" for allocating and deleting arrays.
|
||||
# See gc_cpp.h for details. No effect on the C part of the collector.
|
||||
# This is defined implicitly in a few environments. Must also be defined
|
||||
# by clients that use gc_cpp.h.
|
||||
# -DREDIRECT_MALLOC=X causes malloc, realloc, and free to be defined
|
||||
# as aliases for X, GC_realloc, and GC_free, respectively.
|
||||
# Calloc is redefined in terms of the new malloc. X should
|
||||
# be either GC_malloc or GC_malloc_uncollectable, or
|
||||
# GC_debug_malloc_replacement. (The latter invokes GC_debug_malloc
|
||||
# with dummy source location information, but still results in
|
||||
# properly remembered call stacks on Linux/X86 and Solaris/SPARC.)
|
||||
# The former is occasionally useful for working around leaks in code
|
||||
# you don't want to (or can't) look at. It may not work for
|
||||
# existing code, but it often does. Neither works on all platforms,
|
||||
# since some ports use malloc or calloc to obtain system memory.
|
||||
# (Probably works for UNIX, and win32.)
|
||||
# -DREDIRECT_REALLOC=X causes GC_realloc to be redirected to X.
|
||||
# The canonical use is -DREDIRECT_REALLOC=GC_debug_realloc_replacement,
|
||||
# together with -DREDIRECT_MALLOC=GC_debug_malloc_replacement to
|
||||
# generate leak reports with call stacks for both malloc and realloc.
|
||||
# -DIGNORE_FREE turns calls to free into a noop. Only useful with
|
||||
# -DREDIRECT_MALLOC.
|
||||
# -DNO_DEBUGGING removes GC_dump and the debugging routines it calls.
|
||||
# Reduces code size slightly at the expense of debuggability.
|
||||
# -DJAVA_FINALIZATION makes it somewhat safer to finalize objects out of
|
||||
# order by specifying a nonstandard finalization mark procedure (see
|
||||
# finalize.c). Objects reachable from finalizable objects will be marked
|
||||
# in a sepearte postpass, and hence their memory won't be reclaimed.
|
||||
# Not recommended unless you are implementing a language that specifies
|
||||
# these semantics. Since 5.0, determines only only the initial value
|
||||
# of GC_java_finalization variable.
|
||||
# -DFINALIZE_ON_DEMAND causes finalizers to be run only in response
|
||||
# to explicit GC_invoke_finalizers() calls.
|
||||
# In 5.0 this became runtime adjustable, and this only determines the
|
||||
# initial value of GC_finalize_on_demand.
|
||||
# -DATOMIC_UNCOLLECTABLE includes code for GC_malloc_atomic_uncollectable.
|
||||
# This is useful if either the vendor malloc implementation is poor,
|
||||
# or if REDIRECT_MALLOC is used.
|
||||
# -DHBLKSIZE=ddd, where ddd is a power of 2 between 512 and 16384, explicitly
|
||||
# sets the heap block size. Each heap block is devoted to a single size and
|
||||
# kind of object. For the incremental collector it makes sense to match
|
||||
# the most likely page size. Otherwise large values result in more
|
||||
# fragmentation, but generally better performance for large heaps.
|
||||
# -DUSE_MMAP use MMAP instead of sbrk to get new memory.
|
||||
# Works for Solaris and Irix.
|
||||
# -DUSE_MUNMAP causes memory to be returned to the OS under the right
|
||||
# circumstances. This currently disables VM-based incremental collection.
|
||||
# This is currently experimental, and works only under some Unix and
|
||||
# Linux versions.
|
||||
# -DMMAP_STACKS (for Solaris threads) Use mmap from /dev/zero rather than
|
||||
# GC_scratch_alloc() to get stack memory.
|
||||
# -DPRINT_BLACK_LIST Whenever a black list entry is added, i.e. whenever
|
||||
# the garbage collector detects a value that looks almost, but not quite,
|
||||
# like a pointer, print both the address containing the value, and the
|
||||
# value of the near-bogus-pointer. Can be used to identifiy regions of
|
||||
# memory that are likely to contribute misidentified pointers.
|
||||
# -DKEEP_BACK_PTRS Add code to save back pointers in debugging headers
|
||||
# for objects allocated with the debugging allocator. If all objects
|
||||
# through GC_MALLOC with GC_DEBUG defined, this allows the client
|
||||
# to determine how particular or randomly chosen objects are reachable
|
||||
# for debugging/profiling purposes. The gc_backptr.h interface is
|
||||
# implemented only if this is defined.
|
||||
# -DGC_ASSERTIONS Enable some internal GC assertion checking. Currently
|
||||
# this facility is only used in a few places. It is intended primarily
|
||||
# for debugging of the garbage collector itself, but could also
|
||||
# -DDBG_HDRS_ALL Make sure that all objects have debug headers. Increases
|
||||
# the reliability (from 99.9999% to 100%) of some of the debugging
|
||||
# code (especially KEEP_BACK_PTRS). Makes -DSHORT_DBG_HDRS possible.
|
||||
# Assumes that all client allocation is done through debugging
|
||||
# allocators.
|
||||
# -DSHORT_DBG_HDRS Assume that all objects have debug headers. Shorten
|
||||
# the headers to minimize object size, at the expense of checking for
|
||||
# writes past the end of an object. This is intended for environments
|
||||
# in which most client code is written in a "safe" language, such as
|
||||
# Scheme or Java. Assumes that all client allocation is done using
|
||||
# the GC_debug_ functions, or through the macros that expand to these,
|
||||
# or by redirecting malloc to GC_debug_malloc_replacement.
|
||||
# (Also eliminates the field for the requested object size.)
|
||||
# occasionally be useful for debugging of client code. Slows down the
|
||||
# collector somewhat, but not drastically.
|
||||
# -DSAVE_CALL_COUNT=<n> Set the number of call frames saved with objects
|
||||
# allocated through the debugging interface. Affects the amount of
|
||||
# information generated in leak reports. Only matters on platforms
|
||||
# on which we can quickly generate call stacks, currently Linux/(X86 & SPARC)
|
||||
# and Solaris/SPARC. Turns on call chain saving on X86. On X86, client
|
||||
# code should NOT be compiled with -fomit-frame-pointer.
|
||||
# -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
|
||||
# altered stubborn objects, at substantial performance cost.
|
||||
# Use only for debugging of the incremental collector.
|
||||
# -DGC_GCJ_SUPPORT includes support for gcj (and possibly other systems
|
||||
# that include a pointer to a type descriptor in each allocated object).
|
||||
# Building this way requires an ANSI C compiler.
|
||||
# -DUSE_I686_PREFETCH causes the collector to issue Pentium III style
|
||||
# prefetch instructions. No effect except on X86 Linux platforms.
|
||||
# Assumes a very recent gcc-compatible compiler and assembler.
|
||||
# (Gas prefetcht0 support was added around May 1999.)
|
||||
# Empirically the code appears to still run correctly on Pentium II
|
||||
# processors, though with no performance benefit. May not run on other
|
||||
# X86 processors? In some cases this improves performance by
|
||||
# 15% or so.
|
||||
# -DUSE_3DNOW_PREFETCH causes the collector to issue AMD 3DNow style
|
||||
# prefetch instructions. Same restrictions as USE_I686_PREFETCH.
|
||||
# Minimally tested. Didn't appear to be an obvious win on a K6-2/500.
|
||||
# -DGC_USE_LD_WRAP in combination with the old flags listed in README.linux
|
||||
# causes the collector some system and pthread calls in a more transparent
|
||||
# fashion than the usual macro-based approach. Requires GNU ld, and
|
||||
# currently probably works only with Linux.
|
||||
# -DTHREAD_LOCAL_ALLOC defines GC_local_malloc(), GC_local_malloc_atomic()
|
||||
# and GC_local_gcj_malloc(). Needed for gc_gcj.h interface. These allocate
|
||||
# in a way that usually does not involve acquisition of a global lock.
|
||||
# Currently requires -DGC_LINUX_THREADS, but should be easy to port to
|
||||
# other pthreads environments. Recommended for multiprocessors.
|
||||
# -DPARALLEL_MARK allows the marker to run in multiple threads. Recommended
|
||||
# for multiprocessors. Currently requires Linux on X86 or IA64, though
|
||||
# support for other Posix platforms should be fairly easy to add,
|
||||
# if the thread implementation is otherwise supported.
|
||||
# -DNO_GETENV prevents the collector from looking at environment variables.
|
||||
# These may otherwise alter its configuration, or turn off GC altogether.
|
||||
# I don't know of a reason to disable this, except possibly if the
|
||||
# resulting process runs as a privileged user?
|
||||
# -DSTUBBORN_ALLOC allows allocation of "hard to change" objects, and thus
|
||||
# makes incremental collection easier. Was enabled by default until 6.0.
|
||||
# Rarely used, to my knowledge.
|
||||
#
|
||||
|
||||
CXXFLAGS= $(CFLAGS)
|
||||
AR= ar
|
||||
RANLIB= ranlib
|
||||
|
||||
|
||||
OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dbg_mlc.o malloc.o stubborn.o checksums.o solaris_threads.o irix_threads.o linux_threads.o typd_mlc.o ptr_chck.o mallocx.o solaris_pthreads.o gcj_mlc.o specific.o gc_dlopen.o
|
||||
|
||||
CSRCS= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c malloc.c stubborn.c checksums.c solaris_threads.c irix_threads.c linux_threads.c typd_mlc.c ptr_chck.c mallocx.c solaris_pthreads.c gcj_mlc.c specific.c gc_dlopen.c
|
||||
|
||||
CORD_SRCS= cord/cordbscs.c cord/cordxtra.c cord/cordprnt.c cord/de.c cord/cordtest.c include/cord.h include/ec.h include/private/cord_pos.h cord/de_win.c cord/de_win.h cord/de_cmds.h cord/de_win.ICO cord/de_win.RC
|
||||
|
||||
CORD_OBJS= cord/cordbscs.o cord/cordxtra.o cord/cordprnt.o
|
||||
|
||||
SRCS= $(CSRCS) mips_sgi_mach_dep.s rs6000_mach_dep.s alpha_mach_dep.s \
|
||||
sparc_mach_dep.s include/gc.h include/gc_typed.h \
|
||||
include/private/gc_hdrs.h include/private/gc_priv.h \
|
||||
include/private/gcconfig.h include/private/gc_pmark.h \
|
||||
include/gc_inl.h include/gc_inline.h include/gc_mark.h \
|
||||
threadlibs.c if_mach.c if_not_there.c gc_cpp.cc include/gc_cpp.h \
|
||||
gcname.c include/weakpointer.h include/private/gc_locks.h \
|
||||
gcc_support.c mips_ultrix_mach_dep.s include/gc_alloc.h \
|
||||
include/new_gc_alloc.h include/javaxfc.h sparc_sunos4_mach_dep.s \
|
||||
sparc_netbsd_mach_dep.s \
|
||||
include/private/solaris_threads.h include/gc_backptr.h \
|
||||
hpux_test_and_clear.s include/gc_gcj.h \
|
||||
include/gc_local_alloc.h include/private/dbg_mlc.h \
|
||||
include/private/specific.h powerpc_macosx_mach_dep.s \
|
||||
include/leak_detector.h include/gc_amiga_redirects.h \
|
||||
include/gc_pthread_redirects.h ia64_save_regs_in_stack.s \
|
||||
$(CORD_SRCS)
|
||||
|
||||
DOC_FILES= README.QUICK doc/README.Mac doc/README.MacOSX doc/README.OS2 \
|
||||
doc/README.amiga doc/README.cords doc/debugging.html \
|
||||
doc/README.dj doc/README.hp doc/README.linux doc/README.rs6000 \
|
||||
doc/README.sgi doc/README.solaris2 doc/README.uts \
|
||||
doc/README.win32 doc/barrett_diagram doc/README \
|
||||
doc/README.contributors doc/README.changes doc/gc.man \
|
||||
doc/README.environment doc/tree.html doc/gcdescr.html \
|
||||
doc/README.autoconf doc/README.macros
|
||||
|
||||
TESTS= tests/test.c tests/test_cpp.cc tests/trace_test.c \
|
||||
tests/leak_test.c tests/thread_leak_test.c
|
||||
|
||||
GNU_BUILD_FILES= configure.in Makefile.am configure acinclude.m4 \
|
||||
libtool.m4 install-sh configure.host Makefile.in \
|
||||
aclocal.m4 config.sub config.guess ltconfig \
|
||||
ltmain.sh mkinstalldirs
|
||||
|
||||
OTHER_MAKEFILES= OS2_MAKEFILE NT_MAKEFILE NT_THREADS_MAKEFILE gc.mak \
|
||||
BCC_MAKEFILE EMX_MAKEFILE WCC_MAKEFILE Makefile.dj \
|
||||
PCR-Makefile SMakefile.amiga Makefile.DLLs \
|
||||
digimars.mak Makefile.direct
|
||||
# Makefile and Makefile.direct are copies of each other.
|
||||
|
||||
OTHER_FILES= Makefile setjmp_t.c callprocs pc_excludes \
|
||||
MacProjects.sit.hqx MacOS.c \
|
||||
Mac_files/datastart.c Mac_files/dataend.c \
|
||||
Mac_files/MacOS_config.h Mac_files/MacOS_Test_config.h \
|
||||
add_gc_prefix.c gc_cpp.cpp win32_threads.c \
|
||||
version.h AmigaOS.c \
|
||||
$(TESTS) $(GNU_BUILD_FILES) $(OTHER_MAKEFILES)
|
||||
|
||||
CORD_INCLUDE_FILES= $(srcdir)/include/gc.h $(srcdir)/include/cord.h \
|
||||
$(srcdir)/include/ec.h $(srcdir)/include/private/cord_pos.h
|
||||
|
||||
UTILS= if_mach if_not_there threadlibs
|
||||
|
||||
# Libraries needed for curses applications. Only needed for de.
|
||||
CURSES= -lcurses -ltermlib
|
||||
|
||||
# The following is irrelevant on most systems. But a few
|
||||
# versions of make otherwise fork the shell specified in
|
||||
# the SHELL environment variable.
|
||||
SHELL= /bin/sh
|
||||
|
||||
SPECIALCFLAGS = -I$(srcdir)/include
|
||||
# Alternative flags to the C compiler for mach_dep.c.
|
||||
# Mach_dep.c often doesn't like optimization, and it's
|
||||
# not time-critical anyway.
|
||||
# Set SPECIALCFLAGS to -q nodirect_code on Encore.
|
||||
|
||||
all: gc.a gctest
|
||||
|
||||
BSD-pkg-all: bsd-libgc.a
|
||||
|
||||
bsd-libgc.a:
|
||||
$(MAKE) CFLAGS="$(CFLAGS)" clean c++-t
|
||||
mv gc.a bsd-libgc.a
|
||||
|
||||
BSD-pkg-install: BSD-pkg-all
|
||||
${CP} bsd-libgc.a libgc.a
|
||||
${INSTALL_DATA} libgc.a ${PREFIX}/lib
|
||||
${INSTALL_DATA} gc.h gc_cpp.h ${PREFIX}/include
|
||||
|
||||
pcr: PCR-Makefile include/private/gc_private.h include/private/gc_hdrs.h \
|
||||
include/private/gc_locks.h include/gc.h include/private/gcconfig.h \
|
||||
mach_dep.o $(SRCS)
|
||||
$(MAKE) -f PCR-Makefile depend
|
||||
$(MAKE) -f PCR-Makefile
|
||||
|
||||
$(OBJS) tests/test.o dyn_load.o dyn_load_sunos53.o: \
|
||||
$(srcdir)/include/private/gc_priv.h \
|
||||
$(srcdir)/include/private/gc_hdrs.h $(srcdir)/include/private/gc_locks.h \
|
||||
$(srcdir)/include/gc.h \
|
||||
$(srcdir)/include/private/gcconfig.h $(srcdir)/include/gc_typed.h \
|
||||
Makefile
|
||||
# The dependency on Makefile is needed. Changing
|
||||
# options such as -DSILENT affects the size of GC_arrays,
|
||||
# invalidating all .o files that rely on gc_priv.h
|
||||
|
||||
mark.o typd_mlc.o finalize.o ptr_chck.o: $(srcdir)/include/gc_mark.h $(srcdir)/include/private/gc_pmark.h
|
||||
|
||||
specific.o linux_threads.o: $(srcdir)/include/private/specific.h
|
||||
|
||||
solaris_threads.o solaris_pthreads.o: $(srcdir)/include/private/solaris_threads.h
|
||||
|
||||
dbg_mlc.o gcj_mlc.o: $(srcdir)/include/private/dbg_mlc.h
|
||||
|
||||
tests/test.o: tests $(srcdir)/tests/test.c
|
||||
$(CC) $(CFLAGS) -c $(srcdir)/tests/test.c
|
||||
mv test.o tests/test.o
|
||||
|
||||
tests:
|
||||
mkdir tests
|
||||
|
||||
base_lib gc.a: $(OBJS) dyn_load.o $(UTILS)
|
||||
echo > base_lib
|
||||
rm -f dont_ar_1
|
||||
./if_mach SPARC SUNOS5 touch dont_ar_1
|
||||
./if_mach SPARC SUNOS5 $(AR) rus gc.a $(OBJS) dyn_load.o
|
||||
./if_mach M68K AMIGA touch dont_ar_1
|
||||
./if_mach M68K AMIGA $(AR) -vrus gc.a $(OBJS) dyn_load.o
|
||||
./if_not_there dont_ar_1 $(AR) ru gc.a $(OBJS) dyn_load.o
|
||||
./if_not_there dont_ar_1 $(RANLIB) gc.a || cat /dev/null
|
||||
# ignore ranlib failure; that usually means it doesn't exist, and isn't needed
|
||||
|
||||
cords: $(CORD_OBJS) cord/cordtest $(UTILS)
|
||||
rm -f dont_ar_3
|
||||
./if_mach SPARC SUNOS5 touch dont_ar_3
|
||||
./if_mach SPARC SUNOS5 $(AR) rus gc.a $(CORD_OBJS)
|
||||
./if_mach M68K AMIGA touch dont_ar_3
|
||||
./if_mach M68K AMIGA $(AR) -vrus gc.a $(CORD_OBJS)
|
||||
./if_not_there dont_ar_3 $(AR) ru gc.a $(CORD_OBJS)
|
||||
./if_not_there dont_ar_3 $(RANLIB) gc.a || cat /dev/null
|
||||
|
||||
gc_cpp.o: $(srcdir)/gc_cpp.cc $(srcdir)/include/gc_cpp.h $(srcdir)/include/gc.h Makefile
|
||||
$(CXX) -c $(CXXFLAGS) $(srcdir)/gc_cpp.cc
|
||||
|
||||
test_cpp: $(srcdir)/tests/test_cpp.cc $(srcdir)/include/gc_cpp.h gc_cpp.o $(srcdir)/include/gc.h \
|
||||
base_lib $(UTILS)
|
||||
rm -f test_cpp
|
||||
./if_mach HP_PA HPUX $(CXX) $(CXXFLAGS) -o test_cpp $(srcdir)/tests/test_cpp.cc gc_cpp.o gc.a -ldld `./threadlibs`
|
||||
./if_not_there test_cpp $(CXX) $(CXXFLAGS) -o test_cpp $(srcdir)/tests/test_cpp.cc gc_cpp.o gc.a `./threadlibs`
|
||||
|
||||
c++-t: c++
|
||||
./test_cpp 1
|
||||
|
||||
c++-nt: c++
|
||||
@echo "Use ./test_cpp 1 to test the leak library"
|
||||
|
||||
c++: gc_cpp.o $(srcdir)/include/gc_cpp.h test_cpp
|
||||
rm -f dont_ar_4
|
||||
./if_mach SPARC SUNOS5 touch dont_ar_4
|
||||
./if_mach SPARC SUNOS5 $(AR) rus gc.a gc_cpp.o
|
||||
./if_mach M68K AMIGA touch dont_ar_4
|
||||
./if_mach M68K AMIGA $(AR) -vrus gc.a gc_cpp.o
|
||||
./if_not_there dont_ar_4 $(AR) ru gc.a gc_cpp.o
|
||||
./if_not_there dont_ar_4 $(RANLIB) gc.a || cat /dev/null
|
||||
./test_cpp 1
|
||||
echo > c++
|
||||
|
||||
dyn_load_sunos53.o: dyn_load.c
|
||||
$(CC) $(CFLAGS) -DSUNOS53_SHARED_LIB -c $(srcdir)/dyn_load.c -o $@
|
||||
|
||||
# SunOS5 shared library version of the collector
|
||||
sunos5gc.so: $(OBJS) dyn_load_sunos53.o
|
||||
$(CC) -G -o sunos5gc.so $(OBJS) dyn_load_sunos53.o -ldl
|
||||
ln sunos5gc.so libgc.so
|
||||
|
||||
# Alpha/OSF shared library version of the collector
|
||||
libalphagc.so: $(OBJS)
|
||||
ld -shared -o libalphagc.so $(OBJS) dyn_load.o -lc
|
||||
ln libalphagc.so libgc.so
|
||||
|
||||
# IRIX shared library version of the collector
|
||||
libirixgc.so: $(OBJS) dyn_load.o
|
||||
ld -shared $(ABI_FLAG) -o libirixgc.so $(OBJS) dyn_load.o -lc
|
||||
ln libirixgc.so libgc.so
|
||||
|
||||
# Linux shared library version of the collector
|
||||
liblinuxgc.so: $(OBJS) dyn_load.o
|
||||
gcc -shared -o liblinuxgc.so $(OBJS) dyn_load.o
|
||||
ln liblinuxgc.so libgc.so
|
||||
|
||||
# Alternative Linux rule. This is preferable, but is likely to break the
|
||||
# Makefile for some non-linux platforms.
|
||||
# LIBOBJS= $(patsubst %.o, %.lo, $(OBJS))
|
||||
#
|
||||
#.SUFFIXES: .lo $(SUFFIXES)
|
||||
#
|
||||
#.c.lo:
|
||||
# $(CC) $(CFLAGS) $(CPPFLAGS) -fPIC -c $< -o $@
|
||||
#
|
||||
# liblinuxgc.so: $(LIBOBJS) dyn_load.lo
|
||||
# gcc -shared -Wl,-soname=libgc.so.0 -o libgc.so.0 $(LIBOBJS) dyn_load.lo
|
||||
# touch liblinuxgc.so
|
||||
|
||||
mach_dep.o: $(srcdir)/mach_dep.c $(srcdir)/mips_sgi_mach_dep.s $(srcdir)/mips_ultrix_mach_dep.s \
|
||||
$(srcdir)/rs6000_mach_dep.s $(srcdir)/powerpc_macosx_mach_dep.s $(UTILS)
|
||||
rm -f mach_dep.o
|
||||
./if_mach MIPS IRIX5 $(AS) -o mach_dep.o $(srcdir)/mips_sgi_mach_dep.s
|
||||
./if_mach MIPS RISCOS $(AS) -o mach_dep.o $(srcdir)/mips_ultrix_mach_dep.s
|
||||
./if_mach MIPS ULTRIX $(AS) -o mach_dep.o $(srcdir)/mips_ultrix_mach_dep.s
|
||||
./if_mach RS6000 "" $(AS) -o mach_dep.o $(srcdir)/rs6000_mach_dep.s
|
||||
./if_mach POWERPC MACOSX $(AS) -o mach_dep.o $(srcdir)/powerpc_macosx_mach_dep.s
|
||||
# ./if_mach ALPHA "" $(AS) -o mach_dep.o $(srcdir)/alpha_mach_dep.s
|
||||
# alpha_mach_dep.s assumes that pointers are not saved in fp registers.
|
||||
# Gcc on a 21264 can spill pointers to fp registers. Oops.
|
||||
./if_mach SPARC SUNOS5 $(AS) -o mach_dep.o $(srcdir)/sparc_mach_dep.s
|
||||
./if_mach SPARC SUNOS4 $(AS) -o mach_dep.o $(srcdir)/sparc_sunos4_mach_dep.s
|
||||
./if_mach SPARC OPENBSD $(AS) -o mach_dep.o $(srcdir)/sparc_sunos4_mach_dep.s
|
||||
./if_mach SPARC NETBSD $(AS) -o mach_dep.o $(srcdir)/sparc_netbsd_mach_dep.s
|
||||
./if_mach IA64 HPUX as $(AS_ABI_FLAG) -o ia64_save_regs_in_stack.o $(srcdir)/ia64_save_regs_in_stack.s
|
||||
./if_mach IA64 HPUX $(CC) -c -o mach_dep1.o $(SPECIALCFLAGS) $(srcdir)/mach_dep.c
|
||||
./if_mach IA64 HPUX ld -r -o mach_dep.o mach_dep1.o ia64_save_regs_in_stack.o
|
||||
./if_not_there mach_dep.o $(CC) -c $(SPECIALCFLAGS) $(srcdir)/mach_dep.c
|
||||
|
||||
mark_rts.o: $(srcdir)/mark_rts.c $(UTILS)
|
||||
rm -f mark_rts.o
|
||||
-./if_mach ALPHA OSF1 $(CC) -c $(CFLAGS) -Wo,-notail $(srcdir)/mark_rts.c
|
||||
./if_not_there mark_rts.o $(CC) -c $(CFLAGS) $(srcdir)/mark_rts.c
|
||||
# Work-around for DEC optimizer tail recursion elimination bug.
|
||||
# The ALPHA-specific line should be removed if gcc is used.
|
||||
|
||||
alloc.o: version.h
|
||||
|
||||
cord:
|
||||
mkdir cord
|
||||
|
||||
cord/cordbscs.o: cord $(srcdir)/cord/cordbscs.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordbscs.c
|
||||
mv cordbscs.o cord/cordbscs.o
|
||||
# not all compilers understand -o filename
|
||||
|
||||
cord/cordxtra.o: cord $(srcdir)/cord/cordxtra.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordxtra.c
|
||||
mv cordxtra.o cord/cordxtra.o
|
||||
|
||||
cord/cordprnt.o: cord $(srcdir)/cord/cordprnt.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordprnt.c
|
||||
mv cordprnt.o cord/cordprnt.o
|
||||
|
||||
cord/cordtest: $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a $(UTILS)
|
||||
rm -f cord/cordtest
|
||||
./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a -lucb
|
||||
./if_mach HP_PA HPUX $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a -ldld `./threadlibs`
|
||||
./if_mach M68K AMIGA $(CC) $(CFLAGS) -UGC_AMIGA_MAKINGLIB -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a `./threadlibs`
|
||||
./if_not_there cord/cordtest $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a `./threadlibs`
|
||||
|
||||
cord/de: $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(UTILS)
|
||||
rm -f cord/de
|
||||
./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) -lucb `./threadlibs`
|
||||
./if_mach HP_PA HPUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) -ldld `./threadlibs`
|
||||
./if_mach RS6000 "" $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses
|
||||
./if_mach POWERPC MACOSX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a
|
||||
./if_mach I386 LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses `./threadlibs`
|
||||
./if_mach ALPHA LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses `./threadlibs`
|
||||
./if_mach IA64 LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses `./threadlibs`
|
||||
./if_mach M68K AMIGA $(CC) $(CFLAGS) -UGC_AMIGA_MAKINGLIB -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses
|
||||
./if_not_there cord/de $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) `./threadlibs`
|
||||
|
||||
if_mach: $(srcdir)/if_mach.c $(srcdir)/include/private/gcconfig.h
|
||||
$(HOSTCC) $(HOSTCFLAGS) -o if_mach $(srcdir)/if_mach.c
|
||||
|
||||
threadlibs: $(srcdir)/threadlibs.c $(srcdir)/include/private/gcconfig.h Makefile
|
||||
$(HOSTCC) $(HOSTCFLAGS) -o threadlibs $(srcdir)/threadlibs.c
|
||||
|
||||
if_not_there: $(srcdir)/if_not_there.c
|
||||
$(HOSTCC) $(HOSTCFLAGS) -o if_not_there $(srcdir)/if_not_there.c
|
||||
|
||||
clean:
|
||||
rm -f gc.a *.o *.exe tests/*.o gctest gctest_dyn_link test_cpp \
|
||||
setjmp_test mon.out gmon.out a.out core if_not_there if_mach \
|
||||
threadlibs $(CORD_OBJS) cord/cordtest cord/de
|
||||
-rm -f *~
|
||||
|
||||
gctest: tests/test.o gc.a $(UTILS)
|
||||
rm -f gctest
|
||||
./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o gctest tests/test.o gc.a -lucb
|
||||
./if_mach HP_PA HPUX $(CC) $(CFLAGS) -o gctest tests/test.o gc.a -ldld `./threadlibs`
|
||||
./if_mach M68K AMIGA $(CC) $(CFLAGS) -UGC_AMIGA_MAKINGLIB -o gctest tests/test.o gc.a `./threadlibs`
|
||||
./if_not_there gctest $(CC) $(CFLAGS) -o gctest tests/test.o gc.a `./threadlibs`
|
||||
|
||||
# If an optimized setjmp_test generates a segmentation fault,
|
||||
# odds are your compiler is broken. Gctest may still work.
|
||||
# Try compiling setjmp_t.c unoptimized.
|
||||
setjmp_test: $(srcdir)/setjmp_t.c $(srcdir)/include/gc.h $(UTILS)
|
||||
$(CC) $(CFLAGS) -o setjmp_test $(srcdir)/setjmp_t.c
|
||||
|
||||
test: KandRtest cord/cordtest
|
||||
cord/cordtest
|
||||
|
||||
# Those tests that work even with a K&R C compiler:
|
||||
KandRtest: setjmp_test gctest
|
||||
./setjmp_test
|
||||
./gctest
|
||||
|
||||
add_gc_prefix: $(srcdir)/add_gc_prefix.c $(srcdir)/version.h
|
||||
$(CC) -o add_gc_prefix $(srcdir)/add_gc_prefix.c
|
||||
|
||||
gcname: $(srcdir)/gcname.c $(srcdir)/version.h
|
||||
$(CC) -o gcname $(srcdir)/gcname.c
|
||||
|
||||
gc.tar: $(SRCS) $(DOC_FILES) $(OTHER_FILES) add_gc_prefix gcname
|
||||
cp Makefile Makefile.old
|
||||
cp Makefile.direct Makefile
|
||||
rm -f `./gcname`
|
||||
ln -s . `./gcname`
|
||||
./add_gc_prefix $(SRCS) $(DOC_FILES) $(OTHER_FILES) > /tmp/gc.tar-files
|
||||
tar cvfh gc.tar `cat /tmp/gc.tar-files`
|
||||
cp gc.tar `./gcname`.tar
|
||||
gzip `./gcname`.tar
|
||||
rm `./gcname`
|
||||
|
||||
pc_gc.tar: $(SRCS) $(OTHER_FILES)
|
||||
tar cvfX pc_gc.tar pc_excludes $(SRCS) $(OTHER_FILES)
|
||||
|
||||
floppy: pc_gc.tar
|
||||
-mmd a:/cord
|
||||
-mmd a:/cord/private
|
||||
-mmd a:/include
|
||||
-mmd a:/include/private
|
||||
mkdir /tmp/pc_gc
|
||||
cat pc_gc.tar | (cd /tmp/pc_gc; tar xvf -)
|
||||
-mcopy -tmn /tmp/pc_gc/* a:
|
||||
-mcopy -tmn /tmp/pc_gc/cord/* a:/cord
|
||||
-mcopy -mn /tmp/pc_gc/cord/de_win.ICO a:/cord
|
||||
-mcopy -tmn /tmp/pc_gc/cord/private/* a:/cord/private
|
||||
-mcopy -tmn /tmp/pc_gc/include/* a:/include
|
||||
-mcopy -tmn /tmp/pc_gc/include/private/* a:/include/private
|
||||
rm -r /tmp/pc_gc
|
||||
|
||||
gc.tar.Z: gc.tar
|
||||
compress gc.tar
|
||||
|
||||
gc.tar.gz: gc.tar
|
||||
gzip gc.tar
|
||||
|
||||
lint: $(CSRCS) tests/test.c
|
||||
lint -DLINT $(CSRCS) tests/test.c | egrep -v "possible pointer alignment problem|abort|exit|sbrk|mprotect|syscall|change in ANSI|improper alignment"
|
||||
|
||||
# BTL: added to test shared library version of collector.
|
||||
# Currently works only under SunOS5. Requires GC_INIT call from statically
|
||||
# loaded client code.
|
||||
ABSDIR = `pwd`
|
||||
gctest_dyn_link: tests/test.o libgc.so
|
||||
$(CC) -L$(ABSDIR) -R$(ABSDIR) -o gctest_dyn_link tests/test.o -lgc -ldl -lthread
|
||||
|
||||
gctest_irix_dyn_link: tests/test.o libirixgc.so
|
||||
$(CC) -L$(ABSDIR) -o gctest_irix_dyn_link tests/test.o -lirixgc
|
||||
|
||||
# The following appear to be dead, especially since libgc_globals.h
|
||||
# is apparently lost.
|
||||
test_dll.o: tests/test.c libgc_globals.h
|
||||
$(CC) $(CFLAGS) -DGC_USE_DLL -c tests/test.c -o test_dll.o
|
||||
|
||||
test_dll: test_dll.o libgc_dll.a libgc.dll
|
||||
$(CC) test_dll.o -L$(ABSDIR) -lgc_dll -o test_dll
|
||||
|
||||
SYM_PREFIX-libgc=GC
|
||||
|
||||
# Uncomment the following line to build a GNU win32 DLL
|
||||
# include Makefile.DLLs
|
||||
|
||||
reserved_namespace: $(SRCS)
|
||||
for file in $(SRCS) tests/test.c tests/test_cpp.cc; do \
|
||||
sed s/GC_/_GC_/g < $$file > tmp; \
|
||||
cp tmp $$file; \
|
||||
done
|
||||
|
||||
user_namespace: $(SRCS)
|
||||
for file in $(SRCS) tests/test.c tests/test_cpp.cc; do \
|
||||
sed s/_GC_/GC_/g < $$file > tmp; \
|
||||
cp tmp $$file; \
|
||||
done
|
||||
@@ -1,575 +0,0 @@
|
||||
# This is the original manually generated Makefile. It may stil be used
|
||||
# to build the collector.
|
||||
#
|
||||
# Primary targets:
|
||||
# gc.a - builds basic library
|
||||
# c++ - adds C++ interface to library
|
||||
# cords - adds cords (heavyweight strings) to library
|
||||
# test - prints porting information, then builds basic version of gc.a,
|
||||
# and runs some tests of collector and cords. Does not add cords or
|
||||
# c++ interface to gc.a
|
||||
# cord/de - builds dumb editor based on cords.
|
||||
ABI_FLAG=
|
||||
CC=cc $(ABI_FLAG)
|
||||
CXX=g++ $(ABI_FLAG)
|
||||
AS=as $(ABI_FLAG)
|
||||
# The above doesn't work with gas, which doesn't run cpp.
|
||||
# Define AS as `gcc -c -x assembler-with-cpp' instead.
|
||||
# Under Irix 6, you will have to specify the ABI (-o32, -n32, or -64)
|
||||
# if you use something other than the default ABI on your machine.
|
||||
|
||||
# Redefining srcdir allows object code for the nonPCR version of the collector
|
||||
# to be generated in different directories.
|
||||
srcdir= .
|
||||
VPATH= $(srcdir)
|
||||
|
||||
CFLAGS= -O -I$(srcdir)/include -DATOMIC_UNCOLLECTABLE -DNO_SIGNALS -DNO_EXECUTE_PERMISSION -DSILENT -DALL_INTERIOR_POINTERS
|
||||
|
||||
# To build the parallel collector on Linux, add to the above:
|
||||
# -DGC_LINUX_THREADS -DPARALLEL_MARK -DTHREAD_LOCAL_ALLOC
|
||||
# To build the parallel collector n a static library on HP/UX, add to the above:
|
||||
# -DGC_HPUX_THREADS -DPARALLEL_MARK -DTHREAD_LOCAL_ALLOC -DUSE_HPUX_TLS -D_POSIX_C_SOURCE=199506L
|
||||
|
||||
# HOSTCC and HOSTCFLAGS are used to build executables that will be run as
|
||||
# part of the build process, i.e. on the build machine. These will usually
|
||||
# be the same as CC and CFLAGS, except in a cross-compilation environment.
|
||||
# Note that HOSTCFLAGS should include any -D flags that affect thread support.
|
||||
HOSTCC=$(CC)
|
||||
HOSTCFLAGS=$(CFLAGS)
|
||||
|
||||
# For dynamic library builds, it may be necessary to add flags to generate
|
||||
# PIC code, e.g. -fPIC on Linux.
|
||||
|
||||
# Setjmp_test may yield overly optimistic results when compiled
|
||||
# without optimization.
|
||||
|
||||
# These define arguments influence the collector configuration:
|
||||
# -DSILENT disables statistics printing, and improves performance.
|
||||
# -DFIND_LEAK causes GC_find_leak to be initially set.
|
||||
# This causes the collector to assume that all inaccessible
|
||||
# objects should have been explicitly deallocated, and reports exceptions.
|
||||
# Finalization and the test program are not usable in this mode.
|
||||
# -DGC_SOLARIS_THREADS enables support for Solaris (thr_) threads.
|
||||
# (Clients should also define GC_SOLARIS_THREADS and then include
|
||||
# gc.h before performing thr_ or dl* or GC_ operations.)
|
||||
# Must also define -D_REENTRANT.
|
||||
# -DGC_SOLARIS_PTHREADS enables support for Solaris pthreads.
|
||||
# Define SOLARIS_THREADS as well.
|
||||
# -DGC_IRIX_THREADS enables support for Irix pthreads. See README.irix.
|
||||
# -DGC_HPUX_THREADS enables support for HP/UX 11 pthreads.
|
||||
# Also requires -D_REENTRANT or -D_POSIX_C_SOURCE=199506L. See README.hp.
|
||||
# -DGC_LINUX_THREADS enables support for Xavier Leroy's Linux threads.
|
||||
# see README.linux. -D_REENTRANT may also be required.
|
||||
# -DALL_INTERIOR_POINTERS allows all pointers to the interior
|
||||
# of objects to be recognized. (See gc_priv.h for consequences.)
|
||||
# Alternatively, GC_all_interior_pointers can be set at process
|
||||
# initialization time.
|
||||
# -DSMALL_CONFIG tries to tune the collector for small heap sizes,
|
||||
# usually causing it to use less space in such situations.
|
||||
# Incremental collection no longer works in this case.
|
||||
# -DLARGE_CONFIG tunes the collector for unusually large heaps.
|
||||
# Necessary for heaps larger than about 500 MB on most machines.
|
||||
# Recommended for heaps larger than about 64 MB.
|
||||
# -DDONT_ADD_BYTE_AT_END is meaningful only with -DALL_INTERIOR_POINTERS or
|
||||
# GC_all_interior_pointers = 1. Normally -DALL_INTERIOR_POINTERS
|
||||
# causes all objects to be padded so that pointers just past the end of
|
||||
# an object can be recognized. This can be expensive. (The padding
|
||||
# is normally more than one byte due to alignment constraints.)
|
||||
# -DDONT_ADD_BYTE_AT_END disables the padding.
|
||||
# -DNO_SIGNALS does not disable signals during critical parts of
|
||||
# the GC process. This is no less correct than many malloc
|
||||
# implementations, and it sometimes has a significant performance
|
||||
# impact. However, it is dangerous for many not-quite-ANSI C
|
||||
# programs that call things like printf in asynchronous signal handlers.
|
||||
# This is on by default. Turning it off has not been extensively tested with
|
||||
# compilers that reorder stores. It should have been.
|
||||
# -DNO_EXECUTE_PERMISSION may cause some or all of the heap to not
|
||||
# have execute permission, i.e. it may be impossible to execute
|
||||
# code from the heap. Currently this only affects the incremental
|
||||
# collector on UNIX machines. It may greatly improve its performance,
|
||||
# since this may avoid some expensive cache synchronization.
|
||||
# -DOPERATOR_NEW_ARRAY declares that the C++ compiler supports the
|
||||
# new syntax "operator new[]" for allocating and deleting arrays.
|
||||
# See gc_cpp.h for details. No effect on the C part of the collector.
|
||||
# This is defined implicitly in a few environments.
|
||||
# -DREDIRECT_MALLOC=X causes malloc, realloc, and free to be defined
|
||||
# as aliases for X, GC_realloc, and GC_free, respectively.
|
||||
# Calloc is redefined in terms of the new malloc. X should
|
||||
# be either GC_malloc or GC_malloc_uncollectable, or
|
||||
# GC_debug_malloc_replacement. (The latter invokes GC_debug_malloc
|
||||
# with dummy source location information, but still results in
|
||||
# properly remembered call stacks on Linux/X86 and Solaris/SPARC.)
|
||||
# The former is occasionally useful for working around leaks in code
|
||||
# you don't want to (or can't) look at. It may not work for
|
||||
# existing code, but it often does. Neither works on all platforms,
|
||||
# since some ports use malloc or calloc to obtain system memory.
|
||||
# (Probably works for UNIX, and win32.)
|
||||
# -DREDIRECT_REALLOC=X causes GC_realloc to be redirected to X.
|
||||
# The canonical use is -DREDIRECT_REALLOC=GC_debug_realloc_replacement,
|
||||
# together with -DREDIRECT_MALLOC=GC_debug_malloc_replacement to
|
||||
# generate leak reports with call stacks for both malloc and realloc.
|
||||
# -DIGNORE_FREE turns calls to free into a noop. Only useful with
|
||||
# -DREDIRECT_MALLOC.
|
||||
# -DNO_DEBUGGING removes GC_dump and the debugging routines it calls.
|
||||
# Reduces code size slightly at the expense of debuggability.
|
||||
# -DJAVA_FINALIZATION makes it somewhat safer to finalize objects out of
|
||||
# order by specifying a nonstandard finalization mark procedure (see
|
||||
# finalize.c). Objects reachable from finalizable objects will be marked
|
||||
# in a sepearte postpass, and hence their memory won't be reclaimed.
|
||||
# Not recommended unless you are implementing a language that specifies
|
||||
# these semantics. Since 5.0, determines only only the initial value
|
||||
# of GC_java_finalization variable.
|
||||
# -DFINALIZE_ON_DEMAND causes finalizers to be run only in response
|
||||
# to explicit GC_invoke_finalizers() calls.
|
||||
# In 5.0 this became runtime adjustable, and this only determines the
|
||||
# initial value of GC_finalize_on_demand.
|
||||
# -DATOMIC_UNCOLLECTABLE includes code for GC_malloc_atomic_uncollectable.
|
||||
# This is useful if either the vendor malloc implementation is poor,
|
||||
# or if REDIRECT_MALLOC is used.
|
||||
# -DHBLKSIZE=ddd, where ddd is a power of 2 between 512 and 16384, explicitly
|
||||
# sets the heap block size. Each heap block is devoted to a single size and
|
||||
# kind of object. For the incremental collector it makes sense to match
|
||||
# the most likely page size. Otherwise large values result in more
|
||||
# fragmentation, but generally better performance for large heaps.
|
||||
# -DUSE_MMAP use MMAP instead of sbrk to get new memory.
|
||||
# Works for Solaris and Irix.
|
||||
# -DUSE_MUNMAP causes memory to be returned to the OS under the right
|
||||
# circumstances. This currently disables VM-based incremental collection.
|
||||
# This is currently experimental, and works only under some Unix and
|
||||
# Linux versions.
|
||||
# -DMMAP_STACKS (for Solaris threads) Use mmap from /dev/zero rather than
|
||||
# GC_scratch_alloc() to get stack memory.
|
||||
# -DPRINT_BLACK_LIST Whenever a black list entry is added, i.e. whenever
|
||||
# the garbage collector detects a value that looks almost, but not quite,
|
||||
# like a pointer, print both the address containing the value, and the
|
||||
# value of the near-bogus-pointer. Can be used to identifiy regions of
|
||||
# memory that are likely to contribute misidentified pointers.
|
||||
# -DKEEP_BACK_PTRS Add code to save back pointers in debugging headers
|
||||
# for objects allocated with the debugging allocator. If all objects
|
||||
# through GC_MALLOC with GC_DEBUG defined, this allows the client
|
||||
# to determine how particular or randomly chosen objects are reachable
|
||||
# for debugging/profiling purposes. The gc_backptr.h interface is
|
||||
# implemented only if this is defined.
|
||||
# -DGC_ASSERTIONS Enable some internal GC assertion checking. Currently
|
||||
# this facility is only used in a few places. It is intended primarily
|
||||
# for debugging of the garbage collector itself, but could also
|
||||
# -DDBG_HDRS_ALL Make sure that all objects have debug headers. Increases
|
||||
# the reliability (from 99.9999% to 100%) of some of the debugging
|
||||
# code (especially KEEP_BACK_PTRS). Makes -DSHORT_DBG_HDRS possible.
|
||||
# Assumes that all client allocation is done through debugging
|
||||
# allocators.
|
||||
# -DSHORT_DBG_HDRS Assume that all objects have debug headers. Shorten
|
||||
# the headers to minimize object size, at the expense of checking for
|
||||
# writes past the end of an object. This is intended for environments
|
||||
# in which most client code is written in a "safe" language, such as
|
||||
# Scheme or Java. Assumes that all client allocation is done using
|
||||
# the GC_debug_ functions, or through the macros that expand to these,
|
||||
# or by redirecting malloc to GC_debug_malloc_replacement.
|
||||
# (Also eliminates the field for the requested object size.)
|
||||
# occasionally be useful for debugging of client code. Slows down the
|
||||
# collector somewhat, but not drastically.
|
||||
# -DSAVE_CALL_COUNT=<n> Set the number of call frames saved with objects
|
||||
# allocated through the debugging interface. Affects the amount of
|
||||
# information generated in leak reports. Only matters on platforms
|
||||
# on which we can quickly generate call stacks, currently Linux/(X86 & SPARC)
|
||||
# and Solaris/SPARC. Turns on call chain saving on X86. On X86, client
|
||||
# code should NOT be compiled with -fomit-frame-pointer.
|
||||
# -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
|
||||
# altered stubborn objects, at substantial performance cost.
|
||||
# Use only for debugging of the incremental collector.
|
||||
# -DGC_GCJ_SUPPORT includes support for gcj (and possibly other systems
|
||||
# that include a pointer to a type descriptor in each allocated object).
|
||||
# Building this way requires an ANSI C compiler.
|
||||
# -DUSE_I686_PREFETCH causes the collector to issue Pentium III style
|
||||
# prefetch instructions. No effect except on X86 Linux platforms.
|
||||
# Assumes a very recent gcc-compatible compiler and assembler.
|
||||
# (Gas prefetcht0 support was added around May 1999.)
|
||||
# Empirically the code appears to still run correctly on Pentium II
|
||||
# processors, though with no performance benefit. May not run on other
|
||||
# X86 processors? In some cases this improves performance by
|
||||
# 15% or so.
|
||||
# -DUSE_3DNOW_PREFETCH causes the collector to issue AMD 3DNow style
|
||||
# prefetch instructions. Same restrictions as USE_I686_PREFETCH.
|
||||
# UNTESTED!!
|
||||
# -DGC_USE_LD_WRAP in combination with the gld flags listed in README.linux
|
||||
# causes the collector some system and pthread calls in a more transparent
|
||||
# fashion than the usual macro-based approach. Requires GNU ld, and
|
||||
# currently probably works only with Linux.
|
||||
# -DTHREAD_LOCAL_ALLOC defines GC_local_malloc(), GC_local_malloc_atomic()
|
||||
# and GC_local_gcj_malloc(). Needed for gc_gcj.h interface. These allocate
|
||||
# in a way that usually does not involve acquisition of a global lock.
|
||||
# Currently requires -DGC_LINUX_THREADS, but should be easy to port to
|
||||
# other pthreads environments. Recommended for multiprocessors.
|
||||
# -DPARALLEL_MARK allows the marker to run in multiple threads. Recommended
|
||||
# for multiprocessors. Currently requires Linux on X86 or IA64, though
|
||||
# support for other Posix platforms should be fairly easy to add,
|
||||
# if the thread implementation is otherwise supported.
|
||||
# -DNO_GETENV prevents the collector from looking at environment variables.
|
||||
# These may otherwise alter its configuration, or turn off GC altogether.
|
||||
# I don't know of a reason to disable this, except possibly if the
|
||||
# resulting process runs as a privileged user?
|
||||
# -DSTUBBORN_ALLOC allows allocation of "hard to change" objects, and thus
|
||||
# makes incremental collection easier. Was enabled by default until 6.0.
|
||||
# Rarely used, to my knowledge.
|
||||
#
|
||||
|
||||
CXXFLAGS= $(CFLAGS)
|
||||
AR= ar
|
||||
RANLIB= ranlib
|
||||
|
||||
|
||||
OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dbg_mlc.o malloc.o stubborn.o checksums.o solaris_threads.o irix_threads.o linux_threads.o typd_mlc.o ptr_chck.o mallocx.o solaris_pthreads.o gcj_mlc.o specific.o gc_dlopen.o
|
||||
|
||||
CSRCS= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c malloc.c stubborn.c checksums.c solaris_threads.c irix_threads.c linux_threads.c typd_mlc.c ptr_chck.c mallocx.c solaris_pthreads.c gcj_mlc.c specific.c gc_dlopen.c
|
||||
|
||||
CORD_SRCS= cord/cordbscs.c cord/cordxtra.c cord/cordprnt.c cord/de.c cord/cordtest.c include/cord.h include/ec.h include/private/cord_pos.h cord/de_win.c cord/de_win.h cord/de_cmds.h cord/de_win.ICO cord/de_win.RC
|
||||
|
||||
CORD_OBJS= cord/cordbscs.o cord/cordxtra.o cord/cordprnt.o
|
||||
|
||||
SRCS= $(CSRCS) mips_sgi_mach_dep.s rs6000_mach_dep.s alpha_mach_dep.s \
|
||||
sparc_mach_dep.s include/gc.h include/gc_typed.h \
|
||||
include/private/gc_hdrs.h include/private/gc_priv.h \
|
||||
include/private/gcconfig.h include/private/gc_pmark.h \
|
||||
include/gc_inl.h include/gc_inline.h include/gc_mark.h \
|
||||
threadlibs.c if_mach.c if_not_there.c gc_cpp.cc include/gc_cpp.h \
|
||||
include/weakpointer.h include/private/gc_locks.h \
|
||||
gcc_support.c mips_ultrix_mach_dep.s include/gc_alloc.h \
|
||||
include/new_gc_alloc.h include/javaxfc.h sparc_sunos4_mach_dep.s \
|
||||
sparc_netbsd_mach_dep.s \
|
||||
include/private/solaris_threads.h include/gc_backptr.h \
|
||||
hpux_test_and_clear.s include/gc_gcj.h \
|
||||
include/gc_local_alloc.h include/private/dbg_mlc.h \
|
||||
include/private/specific.h powerpc_macosx_mach_dep.s \
|
||||
include/leak_detector.h include/gc_amiga_redirects.h \
|
||||
include/gc_pthread_redirects.h $(CORD_SRCS)
|
||||
|
||||
DOC_FILES= README.QUICK doc/README.Mac doc/README.MacOSX doc/README.OS2 \
|
||||
doc/README.amiga doc/README.cords doc/README.debugging \
|
||||
doc/README.dj doc/README.hp doc/README.linux doc/README.rs6000 \
|
||||
doc/README.sgi doc/README.solaris2 doc/README.uts \
|
||||
doc/README.win32 doc/barrett_diagram doc/README \
|
||||
doc/README.contributors doc/README.changes doc/gc.man \
|
||||
doc/README.environment
|
||||
|
||||
TESTS= tests/test.c tests/test_cpp.cc tests/trace_test.c \
|
||||
tests/leak_test.c tests/thread_leak_test.c
|
||||
OTHER_FILES= Makefile PCR-Makefile OS2_MAKEFILE NT_MAKEFILE BCC_MAKEFILE \
|
||||
setjmp_t.c SMakefile.amiga configure.in Makefile.am \
|
||||
callprocs pc_excludes \
|
||||
MacProjects.sit.hqx MacOS.c EMX_MAKEFILE \
|
||||
Mac_files/datastart.c Mac_files/dataend.c \
|
||||
Mac_files/MacOS_config.h Mac_files/MacOS_Test_config.h \
|
||||
add_gc_prefix.c gc_cpp.cpp \
|
||||
win32_threads.c NT_THREADS_MAKEFILE gc.mak Makefile.dj \
|
||||
version.h Makefile.DLLs WCC_MAKEFILE AmigaOS.c $(TESTS)
|
||||
|
||||
CORD_INCLUDE_FILES= $(srcdir)/include/gc.h $(srcdir)/include/cord.h \
|
||||
$(srcdir)/include/ec.h $(srcdir)/include/private/cord_pos.h
|
||||
|
||||
UTILS= if_mach if_not_there threadlibs
|
||||
|
||||
# Libraries needed for curses applications. Only needed for de.
|
||||
CURSES= -lcurses -ltermlib
|
||||
|
||||
# The following is irrelevant on most systems. But a few
|
||||
# versions of make otherwise fork the shell specified in
|
||||
# the SHELL environment variable.
|
||||
SHELL= /bin/sh
|
||||
|
||||
SPECIALCFLAGS = -I$(srcdir)/include
|
||||
# Alternative flags to the C compiler for mach_dep.c.
|
||||
# Mach_dep.c often doesn't like optimization, and it's
|
||||
# not time-critical anyway.
|
||||
# Set SPECIALCFLAGS to -q nodirect_code on Encore.
|
||||
|
||||
all: gc.a gctest
|
||||
|
||||
BSD-pkg-all: bsd-libgc.a
|
||||
|
||||
bsd-libgc.a:
|
||||
$(MAKE) CFLAGS="$(CFLAGS)" clean c++-t
|
||||
mv gc.a bsd-libgc.a
|
||||
|
||||
BSD-pkg-install: BSD-pkg-all
|
||||
${CP} bsd-libgc.a libgc.a
|
||||
${INSTALL_DATA} libgc.a ${PREFIX}/lib
|
||||
${INSTALL_DATA} gc.h gc_cpp.h ${PREFIX}/include
|
||||
|
||||
pcr: PCR-Makefile include/private/gc_private.h include/private/gc_hdrs.h \
|
||||
include/private/gc_locks.h include/gc.h include/private/gcconfig.h \
|
||||
mach_dep.o $(SRCS)
|
||||
$(MAKE) -f PCR-Makefile depend
|
||||
$(MAKE) -f PCR-Makefile
|
||||
|
||||
$(OBJS) tests/test.o dyn_load.o dyn_load_sunos53.o: \
|
||||
$(srcdir)/include/private/gc_priv.h \
|
||||
$(srcdir)/include/private/gc_hdrs.h $(srcdir)/include/private/gc_locks.h \
|
||||
$(srcdir)/include/gc.h \
|
||||
$(srcdir)/include/private/gcconfig.h $(srcdir)/include/gc_typed.h \
|
||||
Makefile
|
||||
# The dependency on Makefile is needed. Changing
|
||||
# options such as -DSILENT affects the size of GC_arrays,
|
||||
# invalidating all .o files that rely on gc_priv.h
|
||||
|
||||
mark.o typd_mlc.o finalize.o ptr_chck.o: $(srcdir)/include/gc_mark.h $(srcdir)/include/private/gc_pmark.h
|
||||
|
||||
specific.o linux_threads.o: $(srcdir)/include/private/specific.h
|
||||
|
||||
solaris_threads.o solaris_pthreads.o: $(srcdir)/include/private/solaris_threads.h
|
||||
|
||||
dbg_mlc.o gcj_mlc.o: $(srcdir)/include/private/dbg_mlc.h
|
||||
|
||||
tests/test.o: tests $(srcdir)/tests/test.c
|
||||
$(CC) $(CFLAGS) -c $(srcdir)/tests/test.c
|
||||
mv test.o tests/test.o
|
||||
|
||||
tests:
|
||||
mkdir tests
|
||||
|
||||
base_lib gc.a: $(OBJS) dyn_load.o $(UTILS)
|
||||
echo > base_lib
|
||||
rm -f dont_ar_1
|
||||
./if_mach SPARC SUNOS5 touch dont_ar_1
|
||||
./if_mach SPARC SUNOS5 $(AR) rus gc.a $(OBJS) dyn_load.o
|
||||
./if_mach M68K AMIGA touch dont_ar_1
|
||||
./if_mach M68K AMIGA $(AR) -vrus gc.a $(OBJS) dyn_load.o
|
||||
./if_not_there dont_ar_1 $(AR) ru gc.a $(OBJS) dyn_load.o
|
||||
./if_not_there dont_ar_1 $(RANLIB) gc.a || cat /dev/null
|
||||
# ignore ranlib failure; that usually means it doesn't exist, and isn't needed
|
||||
|
||||
cords: $(CORD_OBJS) cord/cordtest $(UTILS)
|
||||
rm -f dont_ar_3
|
||||
./if_mach SPARC SUNOS5 touch dont_ar_3
|
||||
./if_mach SPARC SUNOS5 $(AR) rus gc.a $(CORD_OBJS)
|
||||
./if_mach M68K AMIGA touch dont_ar_3
|
||||
./if_mach M68K AMIGA $(AR) -vrus gc.a $(CORD_OBJS)
|
||||
./if_not_there dont_ar_3 $(AR) ru gc.a $(CORD_OBJS)
|
||||
./if_not_there dont_ar_3 $(RANLIB) gc.a || cat /dev/null
|
||||
|
||||
gc_cpp.o: $(srcdir)/gc_cpp.cc $(srcdir)/include/gc_cpp.h $(srcdir)/include/gc.h Makefile
|
||||
$(CXX) -c $(CXXFLAGS) $(srcdir)/gc_cpp.cc
|
||||
|
||||
test_cpp: $(srcdir)/tests/test_cpp.cc $(srcdir)/include/gc_cpp.h gc_cpp.o $(srcdir)/include/gc.h \
|
||||
base_lib $(UTILS)
|
||||
rm -f test_cpp
|
||||
./if_mach HP_PA HPUX $(CXX) $(CXXFLAGS) -o test_cpp $(srcdir)/tests/test_cpp.cc gc_cpp.o gc.a -ldld `./threadlibs`
|
||||
./if_not_there test_cpp $(CXX) $(CXXFLAGS) -o test_cpp $(srcdir)/tests/test_cpp.cc gc_cpp.o gc.a `./threadlibs`
|
||||
|
||||
c++-t: c++
|
||||
./test_cpp 1
|
||||
|
||||
c++-nt: c++
|
||||
@echo "Use ./test_cpp 1 to test the leak library"
|
||||
|
||||
c++: gc_cpp.o $(srcdir)/include/gc_cpp.h test_cpp
|
||||
rm -f dont_ar_4
|
||||
./if_mach SPARC SUNOS5 touch dont_ar_4
|
||||
./if_mach SPARC SUNOS5 $(AR) rus gc.a gc_cpp.o
|
||||
./if_mach M68K AMIGA touch dont_ar_4
|
||||
./if_mach M68K AMIGA $(AR) -vrus gc.a gc_cpp.o
|
||||
./if_not_there dont_ar_4 $(AR) ru gc.a gc_cpp.o
|
||||
./if_not_there dont_ar_4 $(RANLIB) gc.a || cat /dev/null
|
||||
./test_cpp 1
|
||||
echo > c++
|
||||
|
||||
dyn_load_sunos53.o: dyn_load.c
|
||||
$(CC) $(CFLAGS) -DSUNOS53_SHARED_LIB -c $(srcdir)/dyn_load.c -o $@
|
||||
|
||||
# SunOS5 shared library version of the collector
|
||||
sunos5gc.so: $(OBJS) dyn_load_sunos53.o
|
||||
$(CC) -G -o sunos5gc.so $(OBJS) dyn_load_sunos53.o -ldl
|
||||
ln sunos5gc.so libgc.so
|
||||
|
||||
# Alpha/OSF shared library version of the collector
|
||||
libalphagc.so: $(OBJS)
|
||||
ld -shared -o libalphagc.so $(OBJS) dyn_load.o -lc
|
||||
ln libalphagc.so libgc.so
|
||||
|
||||
# IRIX shared library version of the collector
|
||||
libirixgc.so: $(OBJS) dyn_load.o
|
||||
ld -shared $(ABI_FLAG) -o libirixgc.so $(OBJS) dyn_load.o -lc
|
||||
ln libirixgc.so libgc.so
|
||||
|
||||
# Linux shared library version of the collector
|
||||
liblinuxgc.so: $(OBJS) dyn_load.o
|
||||
gcc -shared -o liblinuxgc.so $(OBJS) dyn_load.o
|
||||
ln liblinuxgc.so libgc.so
|
||||
|
||||
# Alternative Linux rule. This is preferable, but is likely to break the
|
||||
# Makefile for some non-linux platforms.
|
||||
# LIBOBJS= $(patsubst %.o, %.lo, $(OBJS))
|
||||
#
|
||||
#.SUFFIXES: .lo $(SUFFIXES)
|
||||
#
|
||||
#.c.lo:
|
||||
# $(CC) $(CFLAGS) $(CPPFLAGS) -fPIC -c $< -o $@
|
||||
#
|
||||
# liblinuxgc.so: $(LIBOBJS) dyn_load.lo
|
||||
# gcc -shared -Wl,-soname=libgc.so.0 -o libgc.so.0 $(LIBOBJS) dyn_load.lo
|
||||
# touch liblinuxgc.so
|
||||
|
||||
mach_dep.o: $(srcdir)/mach_dep.c $(srcdir)/mips_sgi_mach_dep.s $(srcdir)/mips_ultrix_mach_dep.s \
|
||||
$(srcdir)/rs6000_mach_dep.s $(srcdir)/powerpc_macosx_mach_dep.s $(UTILS)
|
||||
rm -f mach_dep.o
|
||||
./if_mach MIPS IRIX5 $(AS) -o mach_dep.o $(srcdir)/mips_sgi_mach_dep.s
|
||||
./if_mach MIPS RISCOS $(AS) -o mach_dep.o $(srcdir)/mips_ultrix_mach_dep.s
|
||||
./if_mach MIPS ULTRIX $(AS) -o mach_dep.o $(srcdir)/mips_ultrix_mach_dep.s
|
||||
./if_mach RS6000 "" $(AS) -o mach_dep.o $(srcdir)/rs6000_mach_dep.s
|
||||
./if_mach POWERPC MACOSX $(AS) -o mach_dep.o $(srcdir)/powerpc_macosx_mach_dep.s
|
||||
# ./if_mach ALPHA "" $(AS) -o mach_dep.o $(srcdir)/alpha_mach_dep.s
|
||||
# alpha_mach_dep.s assumes that pointers are not saved in fp registers.
|
||||
# Gcc on a 21264 can spill pointers to fp registers. Oops.
|
||||
./if_mach SPARC SUNOS5 $(AS) -o mach_dep.o $(srcdir)/sparc_mach_dep.s
|
||||
./if_mach SPARC SUNOS4 $(AS) -o mach_dep.o $(srcdir)/sparc_sunos4_mach_dep.s
|
||||
./if_mach SPARC OPENBSD $(AS) -o mach_dep.o $(srcdir)/sparc_sunos4_mach_dep.s
|
||||
./if_mach SPARC NETBSD $(AS) -o mach_dep.o $(srcdir)/sparc_netbsd_mach_dep.s
|
||||
./if_not_there mach_dep.o $(CC) -c $(SPECIALCFLAGS) $(srcdir)/mach_dep.c
|
||||
|
||||
mark_rts.o: $(srcdir)/mark_rts.c $(UTILS)
|
||||
rm -f mark_rts.o
|
||||
-./if_mach ALPHA OSF1 $(CC) -c $(CFLAGS) -Wo,-notail $(srcdir)/mark_rts.c
|
||||
./if_not_there mark_rts.o $(CC) -c $(CFLAGS) $(srcdir)/mark_rts.c
|
||||
# Work-around for DEC optimizer tail recursion elimination bug.
|
||||
# The ALPHA-specific line should be removed if gcc is used.
|
||||
|
||||
alloc.o: version.h
|
||||
|
||||
cord:
|
||||
mkdir cord
|
||||
|
||||
cord/cordbscs.o: cord $(srcdir)/cord/cordbscs.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordbscs.c
|
||||
mv cordbscs.o cord/cordbscs.o
|
||||
# not all compilers understand -o filename
|
||||
|
||||
cord/cordxtra.o: cord $(srcdir)/cord/cordxtra.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordxtra.c
|
||||
mv cordxtra.o cord/cordxtra.o
|
||||
|
||||
cord/cordprnt.o: cord $(srcdir)/cord/cordprnt.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordprnt.c
|
||||
mv cordprnt.o cord/cordprnt.o
|
||||
|
||||
cord/cordtest: $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a $(UTILS)
|
||||
rm -f cord/cordtest
|
||||
./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a -lucb
|
||||
./if_mach HP_PA HPUX $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a -ldld `./threadlibs`
|
||||
./if_mach M68K AMIGA $(CC) $(CFLAGS) -UGC_AMIGA_MAKINGLIB -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a `./threadlibs`
|
||||
./if_not_there cord/cordtest $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a `./threadlibs`
|
||||
|
||||
cord/de: $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(UTILS)
|
||||
rm -f cord/de
|
||||
./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) -lucb `./threadlibs`
|
||||
./if_mach HP_PA HPUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) -ldld `./threadlibs`
|
||||
./if_mach RS6000 "" $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses
|
||||
./if_mach POWERPC MACOSX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a
|
||||
./if_mach I386 LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses `./threadlibs`
|
||||
./if_mach ALPHA LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses `./threadlibs`
|
||||
./if_mach IA64 LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses `./threadlibs`
|
||||
./if_mach M68K AMIGA $(CC) $(CFLAGS) -UGC_AMIGA_MAKINGLIB -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses
|
||||
./if_not_there cord/de $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) `./threadlibs`
|
||||
|
||||
if_mach: $(srcdir)/if_mach.c $(srcdir)/include/private/gcconfig.h
|
||||
$(HOSTCC) $(HOSTCFLAGS) -o if_mach $(srcdir)/if_mach.c
|
||||
|
||||
threadlibs: $(srcdir)/threadlibs.c $(srcdir)/include/private/gcconfig.h Makefile
|
||||
$(HOSTCC) $(HOSTCFLAGS) -o threadlibs $(srcdir)/threadlibs.c
|
||||
|
||||
if_not_there: $(srcdir)/if_not_there.c
|
||||
$(HOSTCC) $(HOSTCFLAGS) -o if_not_there $(srcdir)/if_not_there.c
|
||||
|
||||
clean:
|
||||
rm -f gc.a *.o *.exe tests/*.o gctest gctest_dyn_link test_cpp \
|
||||
setjmp_test mon.out gmon.out a.out core if_not_there if_mach \
|
||||
threadlibs $(CORD_OBJS) cord/cordtest cord/de
|
||||
-rm -f *~
|
||||
|
||||
gctest: tests/test.o gc.a $(UTILS)
|
||||
rm -f gctest
|
||||
./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o gctest tests/test.o gc.a -lucb
|
||||
./if_mach HP_PA HPUX $(CC) $(CFLAGS) -o gctest tests/test.o gc.a -ldld `./threadlibs`
|
||||
./if_mach M68K AMIGA $(CC) $(CFLAGS) -UGC_AMIGA_MAKINGLIB -o gctest tests/test.o gc.a `./threadlibs`
|
||||
./if_not_there gctest $(CC) $(CFLAGS) -o gctest tests/test.o gc.a `./threadlibs`
|
||||
|
||||
# If an optimized setjmp_test generates a segmentation fault,
|
||||
# odds are your compiler is broken. Gctest may still work.
|
||||
# Try compiling setjmp_t.c unoptimized.
|
||||
setjmp_test: $(srcdir)/setjmp_t.c $(srcdir)/include/gc.h $(UTILS)
|
||||
$(CC) $(CFLAGS) -o setjmp_test $(srcdir)/setjmp_t.c
|
||||
|
||||
test: KandRtest cord/cordtest
|
||||
cord/cordtest
|
||||
|
||||
# Those tests that work even with a K&R C compiler:
|
||||
KandRtest: setjmp_test gctest
|
||||
./setjmp_test
|
||||
./gctest
|
||||
|
||||
add_gc_prefix: add_gc_prefix.c
|
||||
$(CC) -o add_gc_prefix $(srcdir)/add_gc_prefix.c
|
||||
|
||||
gc.tar: $(SRCS) $(DOC_FILES) $(OTHER_FILES) add_gc_prefix
|
||||
./add_gc_prefix $(SRCS) $(DOC_FILES) $(OTHER_FILES) > /tmp/gc.tar-files
|
||||
tar cvfh gc.tar `cat /tmp/gc.tar-files`
|
||||
|
||||
pc_gc.tar: $(SRCS) $(OTHER_FILES)
|
||||
tar cvfX pc_gc.tar pc_excludes $(SRCS) $(OTHER_FILES)
|
||||
|
||||
floppy: pc_gc.tar
|
||||
-mmd a:/cord
|
||||
-mmd a:/cord/private
|
||||
-mmd a:/include
|
||||
-mmd a:/include/private
|
||||
mkdir /tmp/pc_gc
|
||||
cat pc_gc.tar | (cd /tmp/pc_gc; tar xvf -)
|
||||
-mcopy -tmn /tmp/pc_gc/* a:
|
||||
-mcopy -tmn /tmp/pc_gc/cord/* a:/cord
|
||||
-mcopy -mn /tmp/pc_gc/cord/de_win.ICO a:/cord
|
||||
-mcopy -tmn /tmp/pc_gc/cord/private/* a:/cord/private
|
||||
-mcopy -tmn /tmp/pc_gc/include/* a:/include
|
||||
-mcopy -tmn /tmp/pc_gc/include/private/* a:/include/private
|
||||
rm -r /tmp/pc_gc
|
||||
|
||||
gc.tar.Z: gc.tar
|
||||
compress gc.tar
|
||||
|
||||
gc.tar.gz: gc.tar
|
||||
gzip gc.tar
|
||||
|
||||
lint: $(CSRCS) tests/test.c
|
||||
lint -DLINT $(CSRCS) tests/test.c | egrep -v "possible pointer alignment problem|abort|exit|sbrk|mprotect|syscall|change in ANSI|improper alignment"
|
||||
|
||||
# BTL: added to test shared library version of collector.
|
||||
# Currently works only under SunOS5. Requires GC_INIT call from statically
|
||||
# loaded client code.
|
||||
ABSDIR = `pwd`
|
||||
gctest_dyn_link: tests/test.o libgc.so
|
||||
$(CC) -L$(ABSDIR) -R$(ABSDIR) -o gctest_dyn_link tests/test.o -lgc -ldl -lthread
|
||||
|
||||
gctest_irix_dyn_link: tests/test.o libirixgc.so
|
||||
$(CC) -L$(ABSDIR) -o gctest_irix_dyn_link tests/test.o -lirixgc
|
||||
|
||||
# The following appear to be dead, especially since libgc_globals.h
|
||||
# is apparently lost.
|
||||
test_dll.o: tests/test.c libgc_globals.h
|
||||
$(CC) $(CFLAGS) -DGC_USE_DLL -c tests/test.c -o test_dll.o
|
||||
|
||||
test_dll: test_dll.o libgc_dll.a libgc.dll
|
||||
$(CC) test_dll.o -L$(ABSDIR) -lgc_dll -o test_dll
|
||||
|
||||
SYM_PREFIX-libgc=GC
|
||||
|
||||
# Uncomment the following line to build a GNU win32 DLL
|
||||
# include Makefile.DLLs
|
||||
|
||||
reserved_namespace: $(SRCS)
|
||||
for file in $(SRCS) tests/test.c tests/test_cpp.cc; do \
|
||||
sed s/GC_/_GC_/g < $$file > tmp; \
|
||||
cp tmp $$file; \
|
||||
done
|
||||
|
||||
user_namespace: $(SRCS)
|
||||
for file in $(SRCS) tests/test.c tests/test_cpp.cc; do \
|
||||
sed s/_GC_/GC_/g < $$file > tmp; \
|
||||
cp tmp $$file; \
|
||||
done
|
||||
@@ -1,430 +0,0 @@
|
||||
# This Makefile is intended only for DJGPP use.
|
||||
# It is mainly a copy of the main Makefile, but tends to get out of sync
|
||||
# with it. A merge would probably be appropriate.
|
||||
|
||||
# Primary targets:
|
||||
# gc.a - builds basic library
|
||||
# libgc.a - builds library for use with g++ "-fgc-keyword" extension
|
||||
# -fgc-keyword was never really available. Historical
|
||||
# interest only.
|
||||
# c++ - adds C++ interface to library
|
||||
# cords - adds cords (heavyweight strings) to library
|
||||
# test - prints porting information, then builds basic version of gc.a,
|
||||
# and runs some tests of collector and cords. Does not add cords or
|
||||
# c++ interface to gc.a
|
||||
# cord/de$(EXE_SUFFIX) - builds dumb editor based on cords.
|
||||
ABI_FLAG=
|
||||
CC=gcc $(ABI_FLAG)
|
||||
CXX=gxx $(ABI_FLAG)
|
||||
AS=gcc -c -x assembler-with-cpp $(ABI_FLAG)
|
||||
# The above doesn't work with gas, which doesn't run cpp.
|
||||
# Define AS as `gcc -c -x assembler-with-cpp' instead.
|
||||
# Under Irix 6, you will have to specify the ABI (-o32, -n32, or -64)
|
||||
# if you use something other than the default ABI on your machine.
|
||||
|
||||
# special defines for DJGPP
|
||||
CXXLD=gxx $(ABI_FLAG)
|
||||
EXE_SUFFIX=.exe
|
||||
|
||||
srcdir= .
|
||||
VPATH= $(srcdir)
|
||||
|
||||
CFLAGS= -O -I$(srcdir)/include -DATOMIC_UNCOLLECTABLE -DNO_SIGNALS -DALL_INTERIOR_POINTERS -DNO_EXECUTE_PERMISSION -DSILENT
|
||||
|
||||
# Setjmp_test may yield overly optimistic results when compiled
|
||||
# without optimization.
|
||||
# -DSILENT disables statistics printing, and improves performance.
|
||||
# -DFIND_LEAK causes GC_find_leak to be initially set.
|
||||
# This causes the collector to assume that all inaccessible
|
||||
# objects should have been explicitly deallocated, and reports exceptions.
|
||||
# Finalization and the test program are not usable in this mode.
|
||||
# -DALL_INTERIOR_POINTERS allows all pointers to the interior
|
||||
# of objects to be recognized. (See gc_priv.h for consequences.)
|
||||
# -DSMALL_CONFIG tries to tune the collector for small heap sizes,
|
||||
# usually causing it to use less space in such situations.
|
||||
# Incremental collection no longer works in this case.
|
||||
# -DLARGE_CONFIG tunes the collector for unusually large heaps.
|
||||
# Necessary for heaps larger than about 500 MB on most machines.
|
||||
# Recommended for heaps larger than about 64 MB.
|
||||
# -DDONT_ADD_BYTE_AT_END is meaningful only with
|
||||
# -DALL_INTERIOR_POINTERS. Normally -DALL_INTERIOR_POINTERS
|
||||
# causes all objects to be padded so that pointers just past the end of
|
||||
# an object can be recognized. This can be expensive. (The padding
|
||||
# is normally more than one byte due to alignment constraints.)
|
||||
# -DDONT_ADD_BYTE_AT_END disables the padding.
|
||||
# -DNO_SIGNALS does not disable signals during critical parts of
|
||||
# the GC process. This is no less correct than many malloc
|
||||
# implementations, and it sometimes has a significant performance
|
||||
# impact. However, it is dangerous for many not-quite-ANSI C
|
||||
# programs that call things like printf in asynchronous signal handlers.
|
||||
# This is on by default. Turning it off has not been extensively tested with
|
||||
# compilers that reorder stores. It should have been.
|
||||
# -DNO_EXECUTE_PERMISSION may cause some or all of the heap to not
|
||||
# have execute permission, i.e. it may be impossible to execute
|
||||
# code from the heap. Currently this only affects the incremental
|
||||
# collector on UNIX machines. It may greatly improve its performance,
|
||||
# since this may avoid some expensive cache synchronization.
|
||||
# -DGC_NO_OPERATOR_NEW_ARRAY declares that the C++ compiler does not support
|
||||
# the new syntax "operator new[]" for allocating and deleting arrays.
|
||||
# See gc_cpp.h for details. No effect on the C part of the collector.
|
||||
# This is defined implicitly in a few environments. Must also be defined
|
||||
# by clients that use gc_cpp.h.
|
||||
# -DREDIRECT_MALLOC=X causes malloc, realloc, and free to be defined
|
||||
# as aliases for X, GC_realloc, and GC_free, respectively.
|
||||
# Calloc is redefined in terms of the new malloc. X should
|
||||
# be either GC_malloc or GC_malloc_uncollectable.
|
||||
# The former is occasionally useful for working around leaks in code
|
||||
# you don't want to (or can't) look at. It may not work for
|
||||
# existing code, but it often does. Neither works on all platforms,
|
||||
# since some ports use malloc or calloc to obtain system memory.
|
||||
# (Probably works for UNIX, and win32.)
|
||||
# -DIGNORE_FREE turns calls to free into a noop. Only useful with
|
||||
# -DREDIRECT_MALLOC.
|
||||
# -DNO_DEBUGGING removes GC_dump and the debugging routines it calls.
|
||||
# Reduces code size slightly at the expense of debuggability.
|
||||
# -DJAVA_FINALIZATION makes it somewhat safer to finalize objects out of
|
||||
# order by specifying a nonstandard finalization mark procedure (see
|
||||
# finalize.c). Objects reachable from finalizable objects will be marked
|
||||
# in a sepearte postpass, and hence their memory won't be reclaimed.
|
||||
# Not recommended unless you are implementing a language that specifies
|
||||
# these semantics. Since 5.0, determines only only the initial value
|
||||
# of GC_java_finalization variable.
|
||||
# -DFINALIZE_ON_DEMAND causes finalizers to be run only in response
|
||||
# to explicit GC_invoke_finalizers() calls.
|
||||
# In 5.0 this became runtime adjustable, and this only determines the
|
||||
# initial value of GC_finalize_on_demand.
|
||||
# -DATOMIC_UNCOLLECTABLE includes code for GC_malloc_atomic_uncollectable.
|
||||
# This is useful if either the vendor malloc implementation is poor,
|
||||
# or if REDIRECT_MALLOC is used.
|
||||
# -DHBLKSIZE=ddd, where ddd is a power of 2 between 512 and 16384, explicitly
|
||||
# sets the heap block size. Each heap block is devoted to a single size and
|
||||
# kind of object. For the incremental collector it makes sense to match
|
||||
# the most likely page size. Otherwise large values result in more
|
||||
# fragmentation, but generally better performance for large heaps.
|
||||
# -DPRINT_BLACK_LIST Whenever a black list entry is added, i.e. whenever
|
||||
# the garbage collector detects a value that looks almost, but not quite,
|
||||
# like a pointer, print both the address containing the value, and the
|
||||
# value of the near-bogus-pointer. Can be used to identifiy regions of
|
||||
# memory that are likely to contribute misidentified pointers.
|
||||
# -DKEEP_BACK_PTRS Add code to save back pointers in debugging headers
|
||||
# for objects allocated with the debugging allocator. If all objects
|
||||
# through GC_MALLOC with GC_DEBUG defined, this allows the client
|
||||
# to determine how particular or randomly chosen objects are reachable
|
||||
# for debugging/profiling purposes. The gc_backptr.h interface is
|
||||
# implemented only if this is defined.
|
||||
# -DGC_ASSERTIONS Enable some internal GC assertion checking. Currently
|
||||
# this facility is only used in a few places. It is intended primarily
|
||||
# for debugging of the garbage collector itself, but could also
|
||||
# -DDBG_HDRS_ALL Make sure that all objects have debug headers. Increases
|
||||
# the reliability (from 99.9999% to 100%) of some of the debugging
|
||||
# code (especially KEEP_BACK_PTRS). Makes -DSHORT_DBG_HDRS possible.
|
||||
# Assumes that all client allocation is done through debugging
|
||||
# allocators.
|
||||
# -DSHORT_DBG_HDRS Assume that all objects have debug headers. Shorten
|
||||
# the headers to minimize object size, at the expense of checking for
|
||||
# writes past the end of an object. This is intended for environments
|
||||
# in which most client code is written in a "safe" language, such as
|
||||
# Scheme or Java. Assumes that all client allocation is done using
|
||||
# the GC_debug_ functions (or through the macros that expand to these.
|
||||
# (Also eliminates the field for the requested object size.)
|
||||
# occasionally be useful for debugging of client code. Slows down the
|
||||
# collector somewhat, but not drastically.
|
||||
# -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
|
||||
# altered stubborn objects, at substantial performance cost.
|
||||
# Use only for debugging of the incremental collector.
|
||||
# -DGC_GCJ_SUPPORT includes support for gcj (and possibly other systems
|
||||
# that include a pointer to a type descriptor in each allocated object).
|
||||
# Building this way requires an ANSI C compiler.
|
||||
# -DUSE_I686_PREFETCH causes the collector to issue Pentium III style
|
||||
# prefetch instructions. No effect except on X86 Linux platforms.
|
||||
# Assumes a very recent gcc-compatible compiler and assembler.
|
||||
# (Gas prefetcht0 support was added around May 1999.)
|
||||
# Empirically the code appears to still run correctly on Pentium II
|
||||
# processors, though with no performance benefit. May not run on other
|
||||
# X86 processors? In some cases this improves performance by
|
||||
# 15% or so.
|
||||
# -DUSE_3DNOW_PREFETCH causes the collector to issue AMD 3DNow style
|
||||
# prefetch instructions. Same restrictions as USE_I686_PREFETCH.
|
||||
# UNTESTED!!
|
||||
# -DGC_USE_LD_WRAP in combination with the gld flags listed in README.linux
|
||||
# causes the collector some system and pthread calls in a more transparent
|
||||
# fashion than the usual macro-based approach. Requires GNU ld, and
|
||||
# currently probably works only with Linux.
|
||||
|
||||
|
||||
CXXFLAGS= $(CFLAGS) -DOPERATOR_NEW_ARRAY
|
||||
AR= ar
|
||||
RANLIB= ranlib
|
||||
|
||||
|
||||
OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dbg_mlc.o malloc.o stubborn.o checksums.o solaris_threads.o hpux_irix_threads.o linux_threads.o typd_mlc.o ptr_chck.o mallocx.o solaris_pthreads.o gcj_mlc.o specific.o
|
||||
|
||||
CSRCS= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c malloc.c stubborn.c checksums.c solaris_threads.c hpux_irix_threads.c linux_threads.c typd_mlc.c ptr_chck.c mallocx.c solaris_pthreads.c gcj_mlc.c specific.c
|
||||
|
||||
CORD_SRCS= cord/cordbscs.c cord/cordxtra.c cord/cordprnt.c cord/de.c cord/cordtest.c include/cord.h include/ec.h include/private/cord_pos.h cord/de_win.c cord/de_win.h cord/de_cmds.h cord/de_win.ICO cord/de_win.RC cord/SCOPTIONS.amiga cord/SMakefile.amiga
|
||||
|
||||
CORD_OBJS= cord/cordbscs.o cord/cordxtra.o cord/cordprnt.o
|
||||
|
||||
SRCS= $(CSRCS) mips_sgi_mach_dep.s rs6000_mach_dep.s alpha_mach_dep.s \
|
||||
sparc_mach_dep.s include/gc.h include/gc_typed.h \
|
||||
include/private/gc_hdrs.h include/private/gc_priv.h \
|
||||
include/private/gcconfig.h include/private/gc_mark.h \
|
||||
include/gc_inl.h include/gc_inline.h gc.man \
|
||||
threadlibs.c if_mach.c if_not_there.c gc_cpp.cc include/gc_cpp.h \
|
||||
include/weakpointer.h include/private/gc_locks.h \
|
||||
gcc_support.c mips_ultrix_mach_dep.s include/gc_alloc.h \
|
||||
include/new_gc_alloc.h include/javaxfc.h sparc_sunos4_mach_dep.s \
|
||||
include/private/solaris_threads.h include/gc_backptr.h \
|
||||
hpux_test_and_clear.s include/gc_gcj.h \
|
||||
include/gc_local_alloc.h include/private/dbg_mlc.h \
|
||||
include/private/specific.h powerpc_macosx_mach_dep.s \
|
||||
include/leak_detector.h $(CORD_SRCS)
|
||||
|
||||
OTHER_FILES= Makefile PCR-Makefile OS2_MAKEFILE NT_MAKEFILE BCC_MAKEFILE \
|
||||
README test.c test_cpp.cc setjmp_t.c SMakefile.amiga \
|
||||
SCoptions.amiga README.amiga README.win32 cord/README \
|
||||
README.rs6000 README.QUICK callprocs pc_excludes \
|
||||
barrett_diagram README.OS2 README.Mac MacProjects.sit.hqx \
|
||||
MacOS.c EMX_MAKEFILE README.debugging \
|
||||
Mac_files/datastart.c Mac_files/dataend.c \
|
||||
Mac_files/MacOS_config.h Mac_files/MacOS_Test_config.h \
|
||||
add_gc_prefix.c README.solaris2 README.sgi README.hp README.uts \
|
||||
win32_threads.c NT_THREADS_MAKEFILE gc.mak README.dj Makefile.dj \
|
||||
README.alpha README.linux README.MacOSX version.h Makefile.DLLs \
|
||||
WCC_MAKEFILE nursery.c include/gc_nursery.h include/gc_copy_descr.h
|
||||
|
||||
CORD_INCLUDE_FILES= $(srcdir)/include/gc.h $(srcdir)/include/cord.h \
|
||||
$(srcdir)/include/ec.h $(srcdir)/include/private/cord_pos.h
|
||||
|
||||
UTILS= if_mach$(EXE_SUFFIX) if_not_there$(EXE_SUFFIX)
|
||||
|
||||
# Libraries needed for curses applications. Only needed for de.
|
||||
CURSES= -lcurses -ltermlib
|
||||
|
||||
# The following is irrelevant on most systems. But a few
|
||||
# versions of make otherwise fork the shell specified in
|
||||
# the SHELL environment variable.
|
||||
SHELL= /bin/sh
|
||||
|
||||
SPECIALCFLAGS =
|
||||
# Alternative flags to the C compiler for mach_dep.c.
|
||||
# Mach_dep.c often doesn't like optimization, and it's
|
||||
# not time-critical anyway.
|
||||
# Set SPECIALCFLAGS to -q nodirect_code on Encore.
|
||||
|
||||
all: gc.a gctest$(EXE_SUFFIX)
|
||||
|
||||
$(OBJS) test.o dyn_load.o dyn_load_sunos53.o: \
|
||||
$(srcdir)/include/private/gc_priv.h \
|
||||
$(srcdir)/include/private/gc_hdrs.h $(srcdir)/include/private/gc_locks.h \
|
||||
$(srcdir)/include/gc.h \
|
||||
$(srcdir)/include/private/gcconfig.h $(srcdir)/include/gc_typed.h \
|
||||
Makefile
|
||||
# The dependency on Makefile is needed. Changing
|
||||
# options such as -DSILENT affects the size of GC_arrays,
|
||||
# invalidating all .o files that rely on gc_priv.h
|
||||
|
||||
mark.o typd_mlc.o finalize.o: $(srcdir)/gc_mark.h
|
||||
|
||||
base_lib gc.a: $(OBJS) dyn_load.o $(UTILS)
|
||||
echo > base_lib
|
||||
rm -f on_sparc_sunos5_1
|
||||
./if_mach SPARC SUNOS5 touch on_sparc_sunos5_1
|
||||
./if_mach SPARC SUNOS5 $(AR) rus gc.a $(OBJS) dyn_load.o
|
||||
./if_not_there on_sparc_sunos5_1 $(AR) ru gc.a $(OBJS) dyn_load.o
|
||||
-./if_not_there on_sparc_sunos5_1 $(RANLIB) gc.a
|
||||
# ignore ranlib failure; that usually means it doesn't exist, and isn't needed
|
||||
|
||||
cords: $(CORD_OBJS) cord/cordtest$(EXE_SUFFIX) $(UTILS)
|
||||
rm -f on_sparc_sunos5_3
|
||||
./if_mach SPARC SUNOS5 touch on_sparc_sunos5_3
|
||||
./if_mach SPARC SUNOS5 $(AR) rus gc.a $(CORD_OBJS)
|
||||
./if_not_there on_sparc_sunos5_3 $(AR) ru gc.a $(CORD_OBJS)
|
||||
-./if_not_there on_sparc_sunos5_3 $(RANLIB) gc.a
|
||||
|
||||
gc_cpp.o: $(srcdir)/gc_cpp.cc $(srcdir)/include/gc_cpp.h $(srcdir)/include/gc.h Makefile
|
||||
$(CXX) -c $(CXXFLAGS) $(srcdir)/gc_cpp.cc
|
||||
|
||||
test_cpp$(EXE_SUFFIX): $(srcdir)/test_cpp.cc $(srcdir)/include/gc_cpp.h gc_cpp.o $(srcdir)/include/gc.h \
|
||||
base_lib $(UTILS)
|
||||
rm -f test_cpp test_cpp$(EXE_SUFFIX)
|
||||
./if_mach HP_PA "" $(CXX) $(CXXFLAGS) -o test_cpp $(srcdir)/test_cpp.cc gc_cpp.o gc.a -ldld
|
||||
./if_not_there test_cpp$(EXE_SUFFIX) $(CXXLD) $(CXXFLAGS) -o test_cpp$(EXE_SUFFIX) $(srcdir)/test_cpp.cc gc_cpp.o gc.a
|
||||
rm -f test_cpp
|
||||
|
||||
c++: gc_cpp.o $(srcdir)/include/gc_cpp.h test_cpp$(EXE_SUFFIX)
|
||||
rm -f on_sparc_sunos5_4
|
||||
./if_mach SPARC SUNOS5 touch on_sparc_sunos5_4
|
||||
./if_mach SPARC SUNOS5 $(AR) rus gc.a gc_cpp.o
|
||||
./if_not_there on_sparc_sunos5_4 $(AR) ru gc.a gc_cpp.o
|
||||
-./if_not_there on_sparc_sunos5_4 $(RANLIB) gc.a
|
||||
./test_cpp$(EXE_SUFFIX) 1
|
||||
echo > c++
|
||||
|
||||
dyn_load_sunos53.o: dyn_load.c
|
||||
$(CC) $(CFLAGS) -DSUNOS53_SHARED_LIB -c $(srcdir)/dyn_load.c -o $@
|
||||
|
||||
# SunOS5 shared library version of the collector
|
||||
sunos5gc.so: $(OBJS) dyn_load_sunos53.o
|
||||
$(CC) -G -o sunos5gc.so $(OBJS) dyn_load_sunos53.o -ldl
|
||||
ln sunos5gc.so libgc.so
|
||||
|
||||
# Alpha/OSF shared library version of the collector
|
||||
libalphagc.so: $(OBJS)
|
||||
ld -shared -o libalphagc.so $(OBJS) dyn_load.o -lc
|
||||
ln libalphagc.so libgc.so
|
||||
|
||||
# IRIX shared library version of the collector
|
||||
libirixgc.so: $(OBJS) dyn_load.o
|
||||
ld -shared $(ABI_FLAG) -o libirixgc.so $(OBJS) dyn_load.o -lc
|
||||
ln libirixgc.so libgc.so
|
||||
|
||||
# Linux shared library version of the collector
|
||||
liblinuxgc.so: $(OBJS) dyn_load.o
|
||||
gcc -shared -o liblinuxgc.so $(OBJS) dyn_load.o -lo
|
||||
ln liblinuxgc.so libgc.so
|
||||
|
||||
mach_dep.o: $(srcdir)/mach_dep.c $(srcdir)/mips_sgi_mach_dep.s $(srcdir)/mips_ultrix_mach_dep.s \
|
||||
$(srcdir)/rs6000_mach_dep.s $(srcdir)/powerpc_macosx_mach_dep.s $(UTILS)
|
||||
rm -f mach_dep.o
|
||||
./if_mach MIPS IRIX5 $(AS) -o mach_dep.o $(srcdir)/mips_sgi_mach_dep.s
|
||||
./if_mach MIPS RISCOS $(AS) -o mach_dep.o $(srcdir)/mips_ultrix_mach_dep.s
|
||||
./if_mach MIPS ULTRIX $(AS) -o mach_dep.o $(srcdir)/mips_ultrix_mach_dep.s
|
||||
./if_mach RS6000 "" $(AS) -o mach_dep.o $(srcdir)/rs6000_mach_dep.s
|
||||
./if_mach POWERPC MACOSX $(AS) -o mach_dep.o $(srcdir)/powerpc_macosx_mach_dep.s
|
||||
./if_mach ALPHA "" $(AS) -o mach_dep.o $(srcdir)/alpha_mach_dep.s
|
||||
./if_mach SPARC SUNOS5 $(AS) -o mach_dep.o $(srcdir)/sparc_mach_dep.s
|
||||
./if_mach SPARC SUNOS4 $(AS) -o mach_dep.o $(srcdir)/sparc_sunos4_mach_dep.s
|
||||
./if_not_there mach_dep.o $(CC) -c $(SPECIALCFLAGS) $(srcdir)/mach_dep.c
|
||||
|
||||
mark_rts.o: $(srcdir)/mark_rts.c if_mach if_not_there $(UTILS)
|
||||
rm -f mark_rts.o
|
||||
-./if_mach ALPHA OSF1 $(CC) -c $(CFLAGS) -Wo,-notail $(srcdir)/mark_rts.c
|
||||
./if_not_there mark_rts.o $(CC) -c $(CFLAGS) $(srcdir)/mark_rts.c
|
||||
# Work-around for DEC optimizer tail recursion elimination bug.
|
||||
# The ALPHA-specific line should be removed if gcc is used.
|
||||
|
||||
alloc.o: version.h
|
||||
|
||||
cord/cordbscs.o: $(srcdir)/cord/cordbscs.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordbscs.c
|
||||
mv cordbscs.o cord/cordbscs.o
|
||||
# not all compilers understand -o filename
|
||||
|
||||
cord/cordxtra.o: $(srcdir)/cord/cordxtra.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordxtra.c
|
||||
mv cordxtra.o cord/cordxtra.o
|
||||
|
||||
cord/cordprnt.o: $(srcdir)/cord/cordprnt.c $(CORD_INCLUDE_FILES)
|
||||
$(CC) $(CFLAGS) -c -I$(srcdir) $(srcdir)/cord/cordprnt.c
|
||||
mv cordprnt.o cord/cordprnt.o
|
||||
|
||||
cord/cordtest$(EXE_SUFFIX): $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a $(UTILS) /tmp
|
||||
rm -f cord/cordtest$(EXE_SUFFIX)
|
||||
./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o cord/cordtest$(EXE_SUFFIX) $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a -lucb
|
||||
./if_mach HP_PA "" $(CC) $(CFLAGS) -o cord/cordtest$(EXE_SUFFIX) $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a -ldld
|
||||
./if_not_there cord/cordtest$(EXE_SUFFIX) $(CC) $(CFLAGS) -o cord/cordtest $(srcdir)/cord/cordtest.c $(CORD_OBJS) gc.a
|
||||
rm -f cord/cordtest cordtest
|
||||
-mv cordtest$(EXE_SUFFIX) cord/
|
||||
|
||||
/tmp: $(UTILS)
|
||||
./if_not_there /tmp mkdir /tmp
|
||||
|
||||
cord/de$(EXE_SUFFIX): $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(UTILS)
|
||||
rm -f cord/de cord/de$(EXE_SUFFIX)
|
||||
./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) -lucb `./threadlibs`
|
||||
./if_mach HP_PA "" $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES) -ldld
|
||||
./if_mach RS6000 "" $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses
|
||||
./if_mach I386 LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses `./threadlibs`
|
||||
./if_mach ALPHA LINUX $(CC) $(CFLAGS) -o cord/de $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a -lcurses
|
||||
./if_not_there cord/de$(EXE_SUFFIX) $(CC) $(CFLAGS) -o cord/de$(EXE_SUFFIX) $(srcdir)/cord/de.c cord/cordbscs.o cord/cordxtra.o gc.a $(CURSES)
|
||||
|
||||
if_mach$(EXE_SUFFIX): $(srcdir)/if_mach.c $(srcdir)/include/private/gcconfig.h
|
||||
rm -f if_mach if_mach$(EXE_SUFFIX)
|
||||
$(CC) $(CFLAGS) -o if_mach $(srcdir)/if_mach.c
|
||||
|
||||
threadlibs$(EXE_SUFFIX): $(srcdir)/threadlibs.c $(srcdir)include/private/gcconfig.h Makefile
|
||||
rm -f threadlibs threadlibs$(EXE_SUFFIX)
|
||||
$(CC) $(CFLAGS) -o threadlibs $(srcdir)/threadlibs.c
|
||||
|
||||
if_not_there$(EXE_SUFFIX): $(srcdir)/if_not_there.c
|
||||
rm -f if_not_there if_not_there$(EXE_SUFFIX)
|
||||
$(CC) $(CFLAGS) -o if_not_there $(srcdir)/if_not_there.c
|
||||
|
||||
# Clean removes *.o several times,
|
||||
# because as the first one doesn't seem to get them all!
|
||||
clean:
|
||||
rm -f gc.a *.o
|
||||
rm -f *.o
|
||||
rm -f *.o
|
||||
rm -f cord/*.o
|
||||
rm -f gctest gctest_dyn_link test_cpp
|
||||
rm -f setjmp_test mon.out gmon.out a.out core if_not_there if_mach
|
||||
rm -f threadlibs $(CORD_OBJS) cordtest cord/cordtest de cord/de
|
||||
rm -f gctest$(EXE_SUFFIX) gctest_dyn_link$(EXE_SUFFIX) test_cpp$(EXE_SUFFIX)
|
||||
rm -f setjmp_test$(EXE_SUFFIX) if_not_there$(EXE_SUFFIX) if_mach$(EXE_SUFFIX)
|
||||
rm -f threadlibs$(EXE_SUFFIX) cord/cordtest$(EXE_SUFFIX)
|
||||
-rm -f *~
|
||||
|
||||
gctest$(EXE_SUFFIX): test.o gc.a if_mach$(EXE_SUFFIX) if_not_there$(EXE_SUFFIX)
|
||||
rm -f gctest gctest$(EXE_SUFFIX)
|
||||
./if_mach SPARC DRSNX $(CC) $(CFLAGS) -o gctest test.o gc.a -lucb
|
||||
./if_mach HP_PA "" $(CC) $(CFLAGS) -o gctest test.o gc.a -ldld
|
||||
./if_not_there gctest$(EXE_SUFFIX) $(CC) $(CFLAGS) -o gctest$(EXE_SUFFIX) test.o gc.a
|
||||
rm -f gctest
|
||||
|
||||
# If an optimized setjmp_test generates a segmentation fault,
|
||||
# odds are your compiler is broken. Gctest may still work.
|
||||
# Try compiling setjmp_t.c unoptimized.
|
||||
setjmp_test$(EXE_SUFFIX): $(srcdir)/setjmp_t.c $(srcdir)/include/gc.h \
|
||||
if_mach$(EXE_SUFFIX) if_not_there$(EXE_SUFFIX)
|
||||
rm -f setjmp_test$(EXE_SUFFIX)
|
||||
$(CC) $(CFLAGS) -o setjmp_test $(srcdir)/setjmp_t.c
|
||||
rm -f setjmp_test
|
||||
|
||||
test: KandRtest cord/cordtest$(EXE_SUFFIX)
|
||||
./cord/cordtest$(EXE_SUFFIX)
|
||||
|
||||
# Those tests that work even with a K&R C compiler:
|
||||
KandRtest: setjmp_test$(EXE_SUFFIX) gctest$(EXE_SUFFIX)
|
||||
./setjmp_test$(EXE_SUFFIX)
|
||||
./gctest$(EXE_SUFFIX)
|
||||
|
||||
add_gc_prefix$(EXE_SUFFIX): add_gc_prefix.c
|
||||
$(CC) -o add_gc_prefix$(EXE_SUFFIX) $(srcdir)/add_gc_prefix.c
|
||||
rm -f add_gc_prefix
|
||||
|
||||
gc.tar: $(SRCS) $(OTHER_FILES) add_gc_prefix
|
||||
./add_gc_prefix$(EXE_SUFFIX) $(SRCS) $(OTHER_FILES) > /tmp/gc.tar-files
|
||||
(cd $(srcdir)/.. ; tar cvfh - `cat /tmp/gc.tar-files`) > gc.tar
|
||||
|
||||
pc_gc.tar: $(SRCS) $(OTHER_FILES)
|
||||
tar cvfX pc_gc.tar pc_excludes $(SRCS) $(OTHER_FILES)
|
||||
|
||||
gc.tar.Z: gc.tar
|
||||
compress gc.tar
|
||||
|
||||
gc.tar.gz: gc.tar
|
||||
gzip gc.tar
|
||||
|
||||
lint: $(CSRCS) test.c
|
||||
lint -DLINT $(CSRCS) test.c | egrep -v "possible pointer alignment problem|abort|exit|sbrk|mprotect|syscall"
|
||||
|
||||
# BTL: added to test shared library version of collector.
|
||||
# Currently works only under SunOS5. Requires GC_INIT call from statically
|
||||
# loaded client code.
|
||||
ABSDIR = `pwd`
|
||||
gctest_dyn_link: test.o libgc.so
|
||||
$(CC) -L$(ABSDIR) -R$(ABSDIR) -o gctest_dyn_link test.o -lgc -ldl -lthread
|
||||
|
||||
test_dll.o: test.c libgc_globals.h
|
||||
$(CC) $(CFLAGS) -DGC_USE_DLL -c test.c -o test_dll.o
|
||||
|
||||
test_dll: test_dll.o libgc_dll.a libgc.dll
|
||||
$(CC) test_dll.o -L$(ABSDIR) -lgc_dll -o test_dll
|
||||
|
||||
SYM_PREFIX-libgc=GC
|
||||
|
||||
# Uncomment the following line to build a GNU win32 DLL
|
||||
# include Makefile.DLLs
|
||||
|
||||
@@ -1,586 +0,0 @@
|
||||
# Makefile.in generated automatically by automake 1.4 from Makefile.am
|
||||
|
||||
# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
|
||||
# This Makefile.in is free software; the Free Software Foundation
|
||||
# gives unlimited permission to copy and/or distribute it,
|
||||
# with or without modifications, as long as this notice is preserved.
|
||||
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
|
||||
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
||||
# PARTICULAR PURPOSE.
|
||||
|
||||
|
||||
SHELL = @SHELL@
|
||||
|
||||
srcdir = @srcdir@
|
||||
top_srcdir = @top_srcdir@
|
||||
VPATH = @srcdir@
|
||||
prefix = @prefix@
|
||||
exec_prefix = @exec_prefix@
|
||||
|
||||
bindir = @bindir@
|
||||
sbindir = @sbindir@
|
||||
libexecdir = @libexecdir@
|
||||
datadir = @datadir@
|
||||
sysconfdir = @sysconfdir@
|
||||
sharedstatedir = @sharedstatedir@
|
||||
localstatedir = @localstatedir@
|
||||
libdir = @libdir@
|
||||
infodir = @infodir@
|
||||
mandir = @mandir@
|
||||
includedir = @includedir@
|
||||
oldincludedir = /usr/include
|
||||
|
||||
DESTDIR =
|
||||
|
||||
pkgdatadir = $(datadir)/@PACKAGE@
|
||||
pkglibdir = $(libdir)/@PACKAGE@
|
||||
pkgincludedir = $(includedir)/@PACKAGE@
|
||||
|
||||
top_builddir = .
|
||||
|
||||
ACLOCAL = @ACLOCAL@
|
||||
AUTOCONF = @AUTOCONF@
|
||||
AUTOMAKE = @AUTOMAKE@
|
||||
AUTOHEADER = @AUTOHEADER@
|
||||
|
||||
INSTALL = @INSTALL@
|
||||
INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS)
|
||||
INSTALL_DATA = @INSTALL_DATA@
|
||||
INSTALL_SCRIPT = @INSTALL_SCRIPT@
|
||||
transform = @program_transform_name@
|
||||
|
||||
NORMAL_INSTALL = :
|
||||
PRE_INSTALL = :
|
||||
POST_INSTALL = :
|
||||
NORMAL_UNINSTALL = :
|
||||
PRE_UNINSTALL = :
|
||||
POST_UNINSTALL = :
|
||||
build_alias = @build_alias@
|
||||
build_triplet = @build@
|
||||
host_alias = @host_alias@
|
||||
host_triplet = @host@
|
||||
target_alias = @target_alias@
|
||||
target_triplet = @target@
|
||||
AR = @AR@
|
||||
AS = @AS@
|
||||
CC = @CC@
|
||||
CPP = @CPP@
|
||||
CXX = @CXX@
|
||||
CXXCPP = @CXXCPP@
|
||||
CXXINCLUDES = @CXXINCLUDES@
|
||||
DLLTOOL = @DLLTOOL@
|
||||
EXEEXT = @EXEEXT@
|
||||
EXTRA_TEST_LIBS = @EXTRA_TEST_LIBS@
|
||||
GCJ = @GCJ@
|
||||
GCJFLAGS = @GCJFLAGS@
|
||||
GC_CFLAGS = @GC_CFLAGS@
|
||||
INCLUDES = @INCLUDES@
|
||||
LIBTOOL = @LIBTOOL@
|
||||
LN_S = @LN_S@
|
||||
MAINT = @MAINT@
|
||||
MAKEINFO = @MAKEINFO@
|
||||
MY_CFLAGS = @MY_CFLAGS@
|
||||
OBJDUMP = @OBJDUMP@
|
||||
OBJEXT = @OBJEXT@
|
||||
PACKAGE = @PACKAGE@
|
||||
RANLIB = @RANLIB@
|
||||
STRIP = @STRIP@
|
||||
THREADLIBS = @THREADLIBS@
|
||||
VERSION = @VERSION@
|
||||
addobjs = @addobjs@
|
||||
gc_basedir = @gc_basedir@
|
||||
mkinstalldirs = @mkinstalldirs@
|
||||
target_all = @target_all@
|
||||
|
||||
AUTOMAKE_OPTIONS = cygnus
|
||||
|
||||
SUBDIRS = include
|
||||
|
||||
# Multilib support variables.
|
||||
MULTISRCTOP =
|
||||
MULTIBUILDTOP =
|
||||
MULTIDIRS =
|
||||
MULTISUBDIR =
|
||||
MULTIDO = true
|
||||
MULTICLEAN = true
|
||||
@USE_LIBDIR_TRUE@toolexeclibdir = $(libdir)$(MULTISUBDIR)
|
||||
@USE_LIBDIR_FALSE@toolexeclibdir = $(toolexecdir)/lib$(MULTISUBDIR)
|
||||
@USE_LIBDIR_FALSE@toolexecdir = $(exec_prefix)/$(target_alias)
|
||||
|
||||
toolexeclib_LTLIBRARIES = $(target_all)
|
||||
EXTRA_LTLIBRARIES = libgcjgc.la
|
||||
libgcjgc_la_SOURCES = allchblk.c alloc.c blacklst.c checksums.c dbg_mlc.c dyn_load.c finalize.c gc_dlopen.c gcj_mlc.c headers.c irix_threads.c linux_threads.c malloc.c mallocx.c mark.c mark_rts.c misc.c new_hblk.c obj_map.c os_dep.c pcr_interface.c ptr_chck.c real_malloc.c reclaim.c solaris_pthreads.c solaris_threads.c specific.c stubborn.c typd_mlc.c
|
||||
|
||||
|
||||
# Include THREADLIBS here to ensure that the correct versions of
|
||||
# linuxthread semaphore functions get linked:
|
||||
libgcjgc_la_LIBADD = @addobjs@ $(THREADLIBS)
|
||||
libgcjgc_la_DEPENDENCIES = @addobjs@
|
||||
libgcjgc_la_LDFLAGS = -version-info 1:1:0 -rpath $(toolexeclibdir)
|
||||
|
||||
EXTRA_libgcjgc_la_SOURCES = alpha_mach_dep.s mips_sgi_mach_dep.s mips_ultrix_mach_dep.s powerpc_macosx_mach_dep.s rs6000_mach_dep.s sparc_mach_dep.s sparc_netbsd_mach_dep.s sparc_sunos4_mach_dep.s ia64_save_regs_in_stack.s
|
||||
|
||||
|
||||
AM_CXXFLAGS = @GC_CFLAGS@
|
||||
|
||||
AM_CFLAGS = @GC_CFLAGS@
|
||||
|
||||
check_PROGRAMS = gctest
|
||||
# Using $< in the above seems to fail with the HP/UX on Itanium make.
|
||||
|
||||
gctest_OBJECTS = test.o
|
||||
gctest_LDADD = ./libgcjgc.la $(THREADLIBS) $(EXTRA_TEST_LIBS)
|
||||
gctest_LDFLAGS = -shared-libgcc
|
||||
TESTS_ENVIRONMENT = LD_LIBRARY_PATH=../../$(MULTIBUILDTOP)gcc
|
||||
TESTS = gctest
|
||||
|
||||
all_objs = @addobjs@ $(libgcjgc_la_OBJECTS)
|
||||
|
||||
LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(MY_CFLAGS) $(GC_CFLAGS)
|
||||
|
||||
LINK = $(LIBTOOL) --mode=link $(CC) $(AM_CFLAGS) $(MY_CFLAGS) $(LDFLAGS) -o $@
|
||||
|
||||
# Work around what appears to be a GNU make bug handling MAKEFLAGS
|
||||
# values defined in terms of make variables, as is the case for CC and
|
||||
# friends when we are called from the top level Makefile.
|
||||
AM_MAKEFLAGS = "AR_FLAGS=$(AR_FLAGS)" "CC_FOR_BUILD=$(CC_FOR_BUILD)" "CFLAGS=$(CFLAGS)" "CXXFLAGS=$(CXXFLAGS)" "CFLAGS_FOR_BUILD=$(CFLAGS_FOR_BUILD)" "CFLAGS_FOR_TARGET=$(CFLAGS_FOR_TARGET)" "INSTALL=$(INSTALL)" "INSTALL_DATA=$(INSTALL_DATA)" "INSTALL_PROGRAM=$(INSTALL_PROGRAM)" "INSTALL_SCRIPT=$(INSTALL_SCRIPT)" "LDFLAGS=$(LDFLAGS)" "LIBCFLAGS=$(LIBCFLAGS)" "LIBCFLAGS_FOR_TARGET=$(LIBCFLAGS_FOR_TARGET)" "MAKE=$(MAKE)" "MAKEINFO=$(MAKEINFO) $(MAKEINFOFLAGS)" "PICFLAG=$(PICFLAG)" "PICFLAG_FOR_TARGET=$(PICFLAG_FOR_TARGET)" "SHELL=$(SHELL)" "EXPECT=$(EXPECT)" "RUNTEST=$(RUNTEST)" "RUNTESTFLAGS=$(RUNTESTFLAGS)" "exec_prefix=$(exec_prefix)" "infodir=$(infodir)" "libdir=$(libdir)" "prefix=$(prefix)" "tooldir=$(tooldir)" "AR=$(AR)" "AS=$(AS)" "CC=$(CC)" "CXX=$(CXX)" "LD=$(LD)" "LIBCFLAGS=$(LIBCFLAGS)" "NM=$(NM)" "PICFLAG=$(PICFLAG)" "RANLIB=$(RANLIB)" "DESTDIR=$(DESTDIR)"
|
||||
|
||||
|
||||
CONFIG_STATUS_DEPENDENCIES = $(srcdir)/configure.host
|
||||
|
||||
MAKEOVERRIDES =
|
||||
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
|
||||
CONFIG_CLEAN_FILES =
|
||||
LTLIBRARIES = $(toolexeclib_LTLIBRARIES)
|
||||
|
||||
|
||||
DEFS = @DEFS@ -I. -I$(srcdir)
|
||||
CPPFLAGS = @CPPFLAGS@
|
||||
LDFLAGS = @LDFLAGS@
|
||||
LIBS = @LIBS@
|
||||
libgcjgc_la_OBJECTS = allchblk.lo alloc.lo blacklst.lo checksums.lo \
|
||||
dbg_mlc.lo dyn_load.lo finalize.lo gc_dlopen.lo gcj_mlc.lo headers.lo \
|
||||
irix_threads.lo linux_threads.lo malloc.lo mallocx.lo mark.lo \
|
||||
mark_rts.lo misc.lo new_hblk.lo obj_map.lo os_dep.lo pcr_interface.lo \
|
||||
ptr_chck.lo real_malloc.lo reclaim.lo solaris_pthreads.lo \
|
||||
solaris_threads.lo specific.lo stubborn.lo typd_mlc.lo
|
||||
check_PROGRAMS = gctest$(EXEEXT)
|
||||
gctest_DEPENDENCIES = ./libgcjgc.la
|
||||
CFLAGS = @CFLAGS@
|
||||
COMPILE = $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
|
||||
CCLD = $(CC)
|
||||
DIST_COMMON = ChangeLog Makefile.am Makefile.in acinclude.m4 aclocal.m4 \
|
||||
config.guess config.sub configure configure.in install-sh ltconfig \
|
||||
ltmain.sh mkinstalldirs
|
||||
|
||||
|
||||
DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
|
||||
|
||||
TAR = gtar
|
||||
GZIP_ENV = --best
|
||||
SOURCES = $(libgcjgc_la_SOURCES) $(EXTRA_libgcjgc_la_SOURCES)
|
||||
OBJECTS = $(libgcjgc_la_OBJECTS)
|
||||
|
||||
all: all-redirect
|
||||
.SUFFIXES:
|
||||
.SUFFIXES: .S .c .lo .o .obj .s
|
||||
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4)
|
||||
cd $(top_srcdir) && $(AUTOMAKE) --cygnus Makefile
|
||||
|
||||
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
|
||||
cd $(top_builddir) \
|
||||
&& CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status
|
||||
|
||||
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ configure.in acinclude.m4
|
||||
cd $(srcdir) && $(ACLOCAL)
|
||||
|
||||
config.status: $(srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
|
||||
$(SHELL) ./config.status --recheck
|
||||
$(srcdir)/configure: @MAINTAINER_MODE_TRUE@$(srcdir)/configure.in $(ACLOCAL_M4) $(CONFIGURE_DEPENDENCIES)
|
||||
cd $(srcdir) && $(AUTOCONF)
|
||||
|
||||
mostlyclean-toolexeclibLTLIBRARIES:
|
||||
|
||||
clean-toolexeclibLTLIBRARIES:
|
||||
-test -z "$(toolexeclib_LTLIBRARIES)" || rm -f $(toolexeclib_LTLIBRARIES)
|
||||
|
||||
distclean-toolexeclibLTLIBRARIES:
|
||||
|
||||
maintainer-clean-toolexeclibLTLIBRARIES:
|
||||
|
||||
install-toolexeclibLTLIBRARIES: $(toolexeclib_LTLIBRARIES)
|
||||
@$(NORMAL_INSTALL)
|
||||
$(mkinstalldirs) $(DESTDIR)$(toolexeclibdir)
|
||||
@list='$(toolexeclib_LTLIBRARIES)'; for p in $$list; do \
|
||||
if test -f $$p; then \
|
||||
echo "$(LIBTOOL) --mode=install $(INSTALL) $$p $(DESTDIR)$(toolexeclibdir)/$$p"; \
|
||||
$(LIBTOOL) --mode=install $(INSTALL) $$p $(DESTDIR)$(toolexeclibdir)/$$p; \
|
||||
else :; fi; \
|
||||
done
|
||||
|
||||
uninstall-toolexeclibLTLIBRARIES:
|
||||
@$(NORMAL_UNINSTALL)
|
||||
list='$(toolexeclib_LTLIBRARIES)'; for p in $$list; do \
|
||||
$(LIBTOOL) --mode=uninstall rm -f $(DESTDIR)$(toolexeclibdir)/$$p; \
|
||||
done
|
||||
|
||||
.c.o:
|
||||
$(COMPILE) -c $<
|
||||
|
||||
# FIXME: We should only use cygpath when building on Windows,
|
||||
# and only if it is available.
|
||||
.c.obj:
|
||||
$(COMPILE) -c `cygpath -w $<`
|
||||
|
||||
.s.o:
|
||||
$(COMPILE) -c $<
|
||||
|
||||
.S.o:
|
||||
$(COMPILE) -c $<
|
||||
|
||||
mostlyclean-compile:
|
||||
-rm -f *.o core *.core
|
||||
-rm -f *.$(OBJEXT)
|
||||
|
||||
clean-compile:
|
||||
|
||||
distclean-compile:
|
||||
-rm -f *.tab.c
|
||||
|
||||
maintainer-clean-compile:
|
||||
|
||||
.c.lo:
|
||||
$(LIBTOOL) --mode=compile $(COMPILE) -c $<
|
||||
|
||||
.S.lo:
|
||||
$(LIBTOOL) --mode=compile $(COMPILE) -c $<
|
||||
|
||||
mostlyclean-libtool:
|
||||
-rm -f *.lo
|
||||
|
||||
clean-libtool:
|
||||
-rm -rf .libs _libs
|
||||
|
||||
distclean-libtool:
|
||||
|
||||
maintainer-clean-libtool:
|
||||
|
||||
libgcjgc.la: $(libgcjgc_la_OBJECTS) $(libgcjgc_la_DEPENDENCIES)
|
||||
$(LINK) $(libgcjgc_la_LDFLAGS) $(libgcjgc_la_OBJECTS) $(libgcjgc_la_LIBADD) $(LIBS)
|
||||
|
||||
mostlyclean-checkPROGRAMS:
|
||||
|
||||
clean-checkPROGRAMS:
|
||||
-test -z "$(check_PROGRAMS)" || rm -f $(check_PROGRAMS)
|
||||
|
||||
distclean-checkPROGRAMS:
|
||||
|
||||
maintainer-clean-checkPROGRAMS:
|
||||
|
||||
gctest$(EXEEXT): $(gctest_OBJECTS) $(gctest_DEPENDENCIES)
|
||||
@rm -f gctest$(EXEEXT)
|
||||
$(LINK) $(gctest_LDFLAGS) $(gctest_OBJECTS) $(gctest_LDADD) $(LIBS)
|
||||
|
||||
# This directory's subdirectories are mostly independent; you can cd
|
||||
# into them and run `make' without going through this Makefile.
|
||||
# To change the values of `make' variables: instead of editing Makefiles,
|
||||
# (1) if the variable is set in `config.status', edit `config.status'
|
||||
# (which will cause the Makefiles to be regenerated when you run `make');
|
||||
# (2) otherwise, pass the desired values on the `make' command line.
|
||||
|
||||
@SET_MAKE@
|
||||
|
||||
all-recursive install-data-recursive install-exec-recursive \
|
||||
installdirs-recursive install-recursive uninstall-recursive install-info-recursive \
|
||||
check-recursive installcheck-recursive info-recursive dvi-recursive:
|
||||
@set fnord $(MAKEFLAGS); amf=$$2; \
|
||||
dot_seen=no; \
|
||||
target=`echo $@ | sed s/-recursive//`; \
|
||||
list='$(SUBDIRS)'; for subdir in $$list; do \
|
||||
echo "Making $$target in $$subdir"; \
|
||||
if test "$$subdir" = "."; then \
|
||||
dot_seen=yes; \
|
||||
local_target="$$target-am"; \
|
||||
else \
|
||||
local_target="$$target"; \
|
||||
fi; \
|
||||
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|
||||
|| case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \
|
||||
done; \
|
||||
if test "$$dot_seen" = "no"; then \
|
||||
$(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
|
||||
fi; test -z "$$fail"
|
||||
|
||||
mostlyclean-recursive clean-recursive distclean-recursive \
|
||||
maintainer-clean-recursive:
|
||||
@set fnord $(MAKEFLAGS); amf=$$2; \
|
||||
dot_seen=no; \
|
||||
rev=''; list='$(SUBDIRS)'; for subdir in $$list; do \
|
||||
rev="$$subdir $$rev"; \
|
||||
test "$$subdir" = "." && dot_seen=yes; \
|
||||
done; \
|
||||
test "$$dot_seen" = "no" && rev=". $$rev"; \
|
||||
target=`echo $@ | sed s/-recursive//`; \
|
||||
for subdir in $$rev; do \
|
||||
echo "Making $$target in $$subdir"; \
|
||||
if test "$$subdir" = "."; then \
|
||||
local_target="$$target-am"; \
|
||||
else \
|
||||
local_target="$$target"; \
|
||||
fi; \
|
||||
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|
||||
|| case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \
|
||||
done && test -z "$$fail"
|
||||
tags-recursive:
|
||||
list='$(SUBDIRS)'; for subdir in $$list; do \
|
||||
test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
|
||||
done
|
||||
|
||||
tags: TAGS
|
||||
|
||||
ID: $(HEADERS) $(SOURCES) $(LISP)
|
||||
list='$(SOURCES) $(HEADERS)'; \
|
||||
unique=`for i in $$list; do echo $$i; done | \
|
||||
awk ' { files[$$0] = 1; } \
|
||||
END { for (i in files) print i; }'`; \
|
||||
here=`pwd` && cd $(srcdir) \
|
||||
&& mkid -f$$here/ID $$unique $(LISP)
|
||||
|
||||
TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) $(LISP)
|
||||
tags=; \
|
||||
here=`pwd`; \
|
||||
list='$(SUBDIRS)'; for subdir in $$list; do \
|
||||
if test "$$subdir" = .; then :; else \
|
||||
test -f $$subdir/TAGS && tags="$$tags -i $$here/$$subdir/TAGS"; \
|
||||
fi; \
|
||||
done; \
|
||||
list='$(SOURCES) $(HEADERS)'; \
|
||||
unique=`for i in $$list; do echo $$i; done | \
|
||||
awk ' { files[$$0] = 1; } \
|
||||
END { for (i in files) print i; }'`; \
|
||||
test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \
|
||||
|| (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags $$unique $(LISP) -o $$here/TAGS)
|
||||
|
||||
mostlyclean-tags:
|
||||
|
||||
clean-tags:
|
||||
|
||||
distclean-tags:
|
||||
-rm -f TAGS ID
|
||||
|
||||
maintainer-clean-tags:
|
||||
|
||||
distdir = $(PACKAGE)-$(VERSION)
|
||||
top_distdir = $(distdir)
|
||||
|
||||
# This target untars the dist file and tries a VPATH configuration. Then
|
||||
# it guarantees that the distribution is self-contained by making another
|
||||
# tarfile.
|
||||
distcheck: dist
|
||||
-rm -rf $(distdir)
|
||||
GZIP=$(GZIP_ENV) $(TAR) zxf $(distdir).tar.gz
|
||||
mkdir $(distdir)/=build
|
||||
mkdir $(distdir)/=inst
|
||||
dc_install_base=`cd $(distdir)/=inst && pwd`; \
|
||||
cd $(distdir)/=build \
|
||||
&& ../configure --srcdir=.. --prefix=$$dc_install_base \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) dvi \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) check \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) install \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) installcheck \
|
||||
&& $(MAKE) $(AM_MAKEFLAGS) dist
|
||||
-rm -rf $(distdir)
|
||||
@banner="$(distdir).tar.gz is ready for distribution"; \
|
||||
dashes=`echo "$$banner" | sed s/./=/g`; \
|
||||
echo "$$dashes"; \
|
||||
echo "$$banner"; \
|
||||
echo "$$dashes"
|
||||
dist: distdir
|
||||
-chmod -R a+r $(distdir)
|
||||
GZIP=$(GZIP_ENV) $(TAR) chozf $(distdir).tar.gz $(distdir)
|
||||
-rm -rf $(distdir)
|
||||
dist-all: distdir
|
||||
-chmod -R a+r $(distdir)
|
||||
GZIP=$(GZIP_ENV) $(TAR) chozf $(distdir).tar.gz $(distdir)
|
||||
-rm -rf $(distdir)
|
||||
distdir: $(DISTFILES)
|
||||
-rm -rf $(distdir)
|
||||
mkdir $(distdir)
|
||||
-chmod 777 $(distdir)
|
||||
@for file in $(DISTFILES); do \
|
||||
if test -f $$file; then d=.; else d=$(srcdir); fi; \
|
||||
if test -d $$d/$$file; then \
|
||||
cp -pr $$d/$$file $(distdir)/$$file; \
|
||||
else \
|
||||
test -f $(distdir)/$$file \
|
||||
|| ln $$d/$$file $(distdir)/$$file 2> /dev/null \
|
||||
|| cp -p $$d/$$file $(distdir)/$$file || :; \
|
||||
fi; \
|
||||
done
|
||||
for subdir in $(SUBDIRS); do \
|
||||
if test "$$subdir" = .; then :; else \
|
||||
test -d $(distdir)/$$subdir \
|
||||
|| mkdir $(distdir)/$$subdir \
|
||||
|| exit 1; \
|
||||
chmod 777 $(distdir)/$$subdir; \
|
||||
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir=../$(distdir) distdir=../$(distdir)/$$subdir distdir) \
|
||||
|| exit 1; \
|
||||
fi; \
|
||||
done
|
||||
check-TESTS: $(TESTS)
|
||||
@failed=0; all=0; \
|
||||
srcdir=$(srcdir); export srcdir; \
|
||||
for tst in $(TESTS); do \
|
||||
if test -f $$tst; then dir=.; \
|
||||
else dir="$(srcdir)"; fi; \
|
||||
if $(TESTS_ENVIRONMENT) $$dir/$$tst; then \
|
||||
all=`expr $$all + 1`; \
|
||||
echo "PASS: $$tst"; \
|
||||
elif test $$? -ne 77; then \
|
||||
all=`expr $$all + 1`; \
|
||||
failed=`expr $$failed + 1`; \
|
||||
echo "FAIL: $$tst"; \
|
||||
fi; \
|
||||
done; \
|
||||
if test "$$failed" -eq 0; then \
|
||||
banner="All $$all tests passed"; \
|
||||
else \
|
||||
banner="$$failed of $$all tests failed"; \
|
||||
fi; \
|
||||
dashes=`echo "$$banner" | sed s/./=/g`; \
|
||||
echo "$$dashes"; \
|
||||
echo "$$banner"; \
|
||||
echo "$$dashes"; \
|
||||
test "$$failed" -eq 0
|
||||
info-am:
|
||||
info: info-recursive
|
||||
dvi-am:
|
||||
dvi: dvi-recursive
|
||||
check-am: $(check_PROGRAMS)
|
||||
$(MAKE) $(AM_MAKEFLAGS) check-TESTS
|
||||
check: check-recursive
|
||||
installcheck-am:
|
||||
installcheck: installcheck-recursive
|
||||
install-info-am:
|
||||
install-info: install-info-recursive
|
||||
install-exec-am: install-toolexeclibLTLIBRARIES
|
||||
install-exec: install-exec-recursive
|
||||
|
||||
install-data-am:
|
||||
install-data: install-data-recursive
|
||||
|
||||
install-am: all-am
|
||||
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
|
||||
install: install-recursive
|
||||
uninstall-am: uninstall-toolexeclibLTLIBRARIES
|
||||
uninstall: uninstall-recursive
|
||||
all-am: Makefile $(LTLIBRARIES)
|
||||
all-redirect: all-recursive
|
||||
install-strip:
|
||||
$(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install
|
||||
installdirs: installdirs-recursive
|
||||
installdirs-am:
|
||||
$(mkinstalldirs) $(DESTDIR)$(toolexeclibdir)
|
||||
|
||||
|
||||
mostlyclean-generic:
|
||||
|
||||
clean-generic:
|
||||
|
||||
distclean-generic:
|
||||
-rm -f Makefile $(CONFIG_CLEAN_FILES)
|
||||
-rm -f config.cache config.log stamp-h stamp-h[0-9]*
|
||||
|
||||
maintainer-clean-generic:
|
||||
mostlyclean-am: mostlyclean-toolexeclibLTLIBRARIES mostlyclean-compile \
|
||||
mostlyclean-libtool mostlyclean-checkPROGRAMS \
|
||||
mostlyclean-tags mostlyclean-generic
|
||||
|
||||
mostlyclean: mostlyclean-recursive
|
||||
|
||||
clean-am: clean-toolexeclibLTLIBRARIES clean-compile clean-libtool \
|
||||
clean-checkPROGRAMS clean-tags clean-generic \
|
||||
mostlyclean-am
|
||||
|
||||
clean: clean-recursive
|
||||
|
||||
distclean-am: distclean-toolexeclibLTLIBRARIES distclean-compile \
|
||||
distclean-libtool distclean-checkPROGRAMS \
|
||||
distclean-tags distclean-generic clean-am
|
||||
-rm -f libtool
|
||||
|
||||
distclean: distclean-recursive
|
||||
-rm -f config.status
|
||||
|
||||
maintainer-clean-am: maintainer-clean-toolexeclibLTLIBRARIES \
|
||||
maintainer-clean-compile maintainer-clean-libtool \
|
||||
maintainer-clean-checkPROGRAMS maintainer-clean-tags \
|
||||
maintainer-clean-generic distclean-am
|
||||
@echo "This command is intended for maintainers to use;"
|
||||
@echo "it deletes files that may require special tools to rebuild."
|
||||
|
||||
maintainer-clean: maintainer-clean-recursive
|
||||
-rm -f config.status
|
||||
|
||||
.PHONY: mostlyclean-toolexeclibLTLIBRARIES \
|
||||
distclean-toolexeclibLTLIBRARIES clean-toolexeclibLTLIBRARIES \
|
||||
maintainer-clean-toolexeclibLTLIBRARIES \
|
||||
uninstall-toolexeclibLTLIBRARIES install-toolexeclibLTLIBRARIES \
|
||||
mostlyclean-compile distclean-compile clean-compile \
|
||||
maintainer-clean-compile mostlyclean-libtool distclean-libtool \
|
||||
clean-libtool maintainer-clean-libtool mostlyclean-checkPROGRAMS \
|
||||
distclean-checkPROGRAMS clean-checkPROGRAMS \
|
||||
maintainer-clean-checkPROGRAMS install-data-recursive \
|
||||
uninstall-data-recursive install-exec-recursive \
|
||||
uninstall-exec-recursive installdirs-recursive uninstalldirs-recursive \
|
||||
all-recursive check-recursive installcheck-recursive info-recursive \
|
||||
dvi-recursive mostlyclean-recursive distclean-recursive clean-recursive \
|
||||
maintainer-clean-recursive tags tags-recursive mostlyclean-tags \
|
||||
distclean-tags clean-tags maintainer-clean-tags distdir check-TESTS \
|
||||
info-am info dvi-am dvi check check-am installcheck-am installcheck \
|
||||
install-info-am install-info install-exec-am install-exec \
|
||||
install-data-am install-data install-am install uninstall-am uninstall \
|
||||
all-redirect all-am all installdirs-am installdirs mostlyclean-generic \
|
||||
distclean-generic clean-generic maintainer-clean-generic clean \
|
||||
mostlyclean distclean maintainer-clean
|
||||
|
||||
# The following hack produces a warning from automake, but we need it in order
|
||||
# to build a file from a subdirectory. FIXME.
|
||||
test.o: tests/test.c
|
||||
$(COMPILE) -c $(srcdir)/tests/test.c
|
||||
$(all_objs) : include/private/gcconfig.h include/private/gc_priv.h \
|
||||
include/private/gc_hdrs.h include/gc.h include/gc_gcj.h include/gc_mark.h
|
||||
|
||||
.s.lo:
|
||||
$(LTCOMPILE) -Wp,-P -x assembler-with-cpp -c $<
|
||||
|
||||
# Multilib support.
|
||||
.PHONY: all-multi mostlyclean-multi clean-multi distclean-multi \
|
||||
maintainer-clean-multi
|
||||
|
||||
all-am: all-multi
|
||||
install-am: install-multi
|
||||
mostlyclean-am: mostlyclean-multi
|
||||
clean-am: clean-multi
|
||||
distclean-am: distclean-multi
|
||||
maintainer-clean-am: maintainer-clean-multi
|
||||
|
||||
all-multi:
|
||||
$(MULTIDO) $(AM_MAKEFLAGS) DO=all multi-do
|
||||
install-multi:
|
||||
$(MULTIDO) $(AM_MAKEFLAGS) DO=install multi-do
|
||||
mostlyclean-multi:
|
||||
$(MULTICLEAN) $(AM_MAKEFLAGS) DO=mostlyclean multi-clean
|
||||
clean-multi:
|
||||
$(MULTICLEAN) $(AM_MAKEFLAGS) DO=clean multi-clean
|
||||
distclean-multi:
|
||||
$(MULTICLEAN) $(AM_MAKEFLAGS) DO=distclean multi-clean
|
||||
maintainer-clean-multi:
|
||||
$(MULTICLEAN) $(AM_MAKEFLAGS) DO=maintainer-clean multi-clean
|
||||
|
||||
# Tell versions [3.59,3.63) of GNU make to not export all variables.
|
||||
# Otherwise a system limit (for SysV at least) may be exceeded.
|
||||
.NOEXPORT:
|
||||
@@ -1,59 +0,0 @@
|
||||
# Makefile for Windows NT. Assumes Microsoft compiler, and a single thread.
|
||||
# DLLs are included in the root set under NT, but not under win32S.
|
||||
# Use "nmake nodebug=1 all" for optimized versions of library, gctest and editor.
|
||||
|
||||
CPU= i386
|
||||
!include <ntwin32.mak>
|
||||
|
||||
OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj obj_map.obj blacklst.obj finalize.obj new_hblk.obj dbg_mlc.obj malloc.obj stubborn.obj dyn_load.obj typd_mlc.obj ptr_chck.obj gc_cpp.obj mallocx.obj
|
||||
|
||||
all: gctest.exe cord\de.exe test_cpp.exe
|
||||
|
||||
.c.obj:
|
||||
$(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DSILENT -DALL_INTERIOR_POINTERS -D__STDC__ -DGC_NOT_DLL $*.c /Fo$*.obj
|
||||
|
||||
.cpp.obj:
|
||||
$(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DSILENT -DALL_INTERIOR_POINTERS -DGC_NOT_DLL $*.CPP /Fo$*.obj
|
||||
|
||||
$(OBJS) tests\test.obj: include\private\gc_priv.h include\private\gc_hdrs.h include\gc.h include\private\gcconfig.h include\private\gc_locks.h include\private\gc_pmark.h include\gc_mark.h
|
||||
|
||||
gc.lib: $(OBJS)
|
||||
lib /MACHINE:i386 /out:gc.lib $(OBJS)
|
||||
# The original NT SDK used lib32 instead of lib
|
||||
|
||||
gctest.exe: tests\test.obj gc.lib
|
||||
# The following works for win32 debugging. For win32s debugging use debugtype:coff
|
||||
# and add mapsympe line.
|
||||
# This produces a "GUI" applications that opens no windows and writes to the log file
|
||||
# "gc.log". This is done to make the result runnable under win32s.
|
||||
$(link) -debug:full -debugtype:cv $(guiflags) -stack:131072 -out:$*.exe tests\test.obj $(guilibs) gc.lib
|
||||
# mapsympe -n -o gctest.sym gctest.exe
|
||||
|
||||
cord\de_win.rbj: cord\de_win.res
|
||||
cvtres -$(CPU) cord\de_win.res -o cord\de_win.rbj
|
||||
|
||||
cord\de.obj cord\de_win.obj: include\cord.h include\private\cord_pos.h cord\de_win.h cord\de_cmds.h
|
||||
|
||||
cord\de_win.res: cord\de_win.rc cord\de_win.h cord\de_cmds.h
|
||||
$(rc) $(rcvars) -r -fo cord\de_win.res $(cvars) cord\de_win.rc
|
||||
|
||||
# Cord/de is a real win32 gui application.
|
||||
cord\de.exe: cord\cordbscs.obj cord\cordxtra.obj cord\de.obj cord\de_win.obj cord\de_win.rbj gc.lib
|
||||
$(link) -debug:full -debugtype:cv $(guiflags) -stack:16384 -out:cord\de.exe cord\cordbscs.obj cord\cordxtra.obj cord\de.obj cord\de_win.obj cord\de_win.rbj gc.lib $(guilibs)
|
||||
|
||||
gc_cpp.obj: include\gc_cpp.h include\gc.h
|
||||
|
||||
gc_cpp.cpp: gc_cpp.cc
|
||||
copy gc_cpp.cc gc_cpp.cpp
|
||||
|
||||
test_cpp.cpp: tests\test_cpp.cc
|
||||
copy tests\test_cpp.cc test_cpp.cpp
|
||||
|
||||
# This generates the C++ test executable. The executable expects
|
||||
# a single numeric argument, which is the number of iterations.
|
||||
# The output appears in the file "gc.log".
|
||||
test_cpp.exe: test_cpp.obj include\gc_cpp.h include\gc.h gc.lib
|
||||
$(link) -debug:full -debugtype:cv $(guiflags) -stack:16384 -out:test_cpp.exe test_cpp.obj gc.lib $(guilibs)
|
||||
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,45 +0,0 @@
|
||||
# Makefile for OS/2. Assumes IBM's compiler, static linking, and a single thread.
|
||||
# Adding dynamic linking support seems easy, but takes a little bit of work.
|
||||
# Adding thread support may be nontrivial, since we haven't yet figured out how to
|
||||
# look at another thread's registers.
|
||||
|
||||
# Significantly revised for GC version 4.4 by Mark Boulter (Jan 1994).
|
||||
|
||||
OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj obj_map.obj blacklst.obj finalize.obj new_hblk.obj dbg_mlc.obj malloc.obj stubborn.obj typd_mlc.obj ptr_chck.obj mallocx.obj
|
||||
|
||||
CORDOBJS= cord\cordbscs.obj cord\cordxtra.obj cord\cordprnt.obj
|
||||
|
||||
CC= icc
|
||||
CFLAGS= /O /Q /DSILENT /DSMALL_CONFIG /DALL_INTERIOR_POINTERS
|
||||
# Use /Ti instead of /O for debugging
|
||||
# Setjmp_test may yield overly optimistic results when compiled
|
||||
# without optimization.
|
||||
|
||||
all: $(OBJS) gctest.exe cord\cordtest.exe
|
||||
|
||||
$(OBJS) test.obj: include\private\gc_priv.h include\private\gc_hdrs.h include\gc.h include\private\gcconfig.h
|
||||
|
||||
## ERASE THE LIB FIRST - if it is already there then this command will fail
|
||||
## (make sure its there or erase will fail!)
|
||||
gc.lib: $(OBJS)
|
||||
echo . > gc.lib
|
||||
erase gc.lib
|
||||
LIB gc.lib $(OBJS), gc.lst
|
||||
|
||||
mach_dep.obj: mach_dep.c
|
||||
$(CC) $(CFLAGS) /C mach_dep.c
|
||||
|
||||
gctest.exe: test.obj gc.lib
|
||||
$(CC) $(CFLAGS) /B"/STACK:524288" /Fegctest test.obj gc.lib
|
||||
|
||||
cord\cordbscs.obj: cord\cordbscs.c include\cord.h include\private\cord_pos.h
|
||||
$(CC) $(CFLAGS) /C /Focord\cordbscs cord\cordbscs.c
|
||||
|
||||
cord\cordxtra.obj: cord\cordxtra.c include\cord.h include\private\cord_pos.h include\ec.h
|
||||
$(CC) $(CFLAGS) /C /Focord\cordxtra cord\cordxtra.c
|
||||
|
||||
cord\cordprnt.obj: cord\cordprnt.c include\cord.h include\private\cord_pos.h include\ec.h
|
||||
$(CC) $(CFLAGS) /C /Focord\cordprnt cord\cordprnt.c
|
||||
|
||||
cord\cordtest.exe: cord\cordtest.c include\cord.h include\private\cord_pos.h include\ec.h $(CORDOBJS) gc.lib
|
||||
$(CC) $(CFLAGS) /B"/STACK:65536" /Fecord\cordtest cord\cordtest.c gc.lib $(CORDOBJS)
|
||||
@@ -1,68 +0,0 @@
|
||||
#
|
||||
# Default target
|
||||
#
|
||||
|
||||
default: gc.o
|
||||
|
||||
include ../config/common.mk
|
||||
|
||||
#
|
||||
# compilation flags, etc.
|
||||
#
|
||||
|
||||
|
||||
CPPFLAGS = $(INCLUDE) $(CONFIG_CPPFLAGS) \
|
||||
-DPCR_NO_RENAME -DPCR_NO_HOSTDEP_ERR
|
||||
#CFLAGS = -DPCR -DSILENT $(CONFIG_CFLAGS)
|
||||
CFLAGS = -DPCR $(CONFIG_CFLAGS)
|
||||
SPECIALCFLAGS = # For code involving asm's
|
||||
|
||||
ASPPFLAGS = $(INCLUDE) $(CONFIG_ASPPFLAGS) \
|
||||
-DPCR_NO_RENAME -DPCR_NO_HOSTDEP_ERR -DASM
|
||||
|
||||
ASFLAGS = $(CONFIG_ASFLAGS)
|
||||
|
||||
LDRFLAGS = $(CONFIG_LDRFLAGS)
|
||||
|
||||
LDFLAGS = $(CONFIG_LDFLAGS)
|
||||
|
||||
#
|
||||
#
|
||||
#
|
||||
#
|
||||
# BEGIN PACKAGE-SPECIFIC PART
|
||||
#
|
||||
#
|
||||
#
|
||||
#
|
||||
|
||||
# Fix to point to local pcr installation directory.
|
||||
PCRDIR= ..
|
||||
|
||||
COBJ= alloc.o reclaim.o allchblk.o misc.o os_dep.o mark_rts.o headers.o mark.o obj_map.o pcr_interface.o blacklst.o finalize.o new_hblk.o real_malloc.o dyn_load.o dbg_mlc.o malloc.o stubborn.o checksums.o solaris_threads.o typd_mlc.o ptr_chck.o mallocx.o
|
||||
|
||||
CSRC= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c malloc.c stubborn.c checksums.c solaris_threads.c typd_mlc.c ptr_chck.c mallocx.c
|
||||
|
||||
SHELL= /bin/sh
|
||||
|
||||
default: gc.o
|
||||
|
||||
gc.o: $(COBJ) mach_dep.o
|
||||
$(LDR) $(CONFIG_LDRFLAGS) -o gc.o $(COBJ) mach_dep.o
|
||||
|
||||
|
||||
mach_dep.o: mach_dep.c mips_mach_dep.s rs6000_mach_dep.s if_mach if_not_there
|
||||
rm -f mach_dep.o
|
||||
./if_mach MIPS "" as -o mach_dep.o mips_mach_dep.s
|
||||
./if_mach RS6000 "" as -o mach_dep.o rs6000_mach_dep.s
|
||||
./if_mach ALPHA "" as -o mach_dep.o alpha_mach_dep.s
|
||||
./if_mach SPARC SUNOS5 as -o mach_dep.o sparc_mach_dep.s
|
||||
./if_not_there mach_dep.o $(CC) -c $(SPECIALCFLAGS) mach_dep.c
|
||||
|
||||
if_mach: if_mach.c gcconfig.h
|
||||
$(CC) $(CFLAGS) -o if_mach if_mach.c
|
||||
|
||||
if_not_there: if_not_there.c
|
||||
$(CC) $(CFLAGS) -o if_not_there if_not_there.c
|
||||
|
||||
|
||||
@@ -1,178 +0,0 @@
|
||||
|
||||
# Rewritten smakefile for amiga / sas/c. -Kjetil M.
|
||||
# Dont use the cord-package if you define parm=both or parm=reg.
|
||||
|
||||
|
||||
#----------------TOOLS--------------------------------
|
||||
CC=sc
|
||||
LINKER=slink
|
||||
LIBER=oml
|
||||
|
||||
#----------------CPU OPTIONS--------------------------
|
||||
|
||||
CPU=68060
|
||||
|
||||
#----------------FPU OPTIONS--------------------------
|
||||
|
||||
MATH=8
|
||||
MATHLIB=LIB:scm881.lib
|
||||
|
||||
#----------------COMPILER OPTIONS---------------------
|
||||
|
||||
IGNORE= IGNORE=85 IGNORE=154 IGNORE=161 IGNORE=100
|
||||
|
||||
OPTIMIZE=optimize optimizetime optglobal optimizerdepth=100 optimizerpeephole optloop OPTSCHED optimizerinlocal optimizerrecurdepth=100
|
||||
# optimizerinline optimizercomplexity=100
|
||||
|
||||
OPT= $(OPTIMIZE) CPU=$(CPU) math=$(MATH) NOSTACKCHECK VERBOSE \
|
||||
MAPHUNK NOVERSION NOICONS nodebug \
|
||||
DEFINE SILENT \
|
||||
parm=reg \
|
||||
DEFINE __USE_SYSBASE
|
||||
|
||||
|
||||
SOPT= $(OPT) $(IGNORE) \
|
||||
DEFINE AMIGA_SKIP_SEG \
|
||||
DEFINE ATOMIC_UNCOLLECTABLE \
|
||||
DEFINE GC_AMIGA_FASTALLOC \
|
||||
DEFINE GC_AMIGA_RETRY \
|
||||
DEFINE GC_AMIGA_PRINTSTATS \
|
||||
DEFINE GC_AMIGA_GC
|
||||
|
||||
|
||||
#DEFINE ALL_INTERIOR_POINTERS \
|
||||
|
||||
|
||||
SCOPT= $(SOPT) define GC_AMIGA_MAKINGLIB
|
||||
|
||||
CSCOPT= $(OPT) DEFINE AMIGA IGNORE=100 IGNORE=161
|
||||
|
||||
#------------------LINKING----------------------------
|
||||
|
||||
|
||||
all: gctest setjmp_t cord/cordtest
|
||||
|
||||
clean:
|
||||
delete *.lib gctest setjmp_t *.o *.lnk cord/*.o cord/*.lib cord/*.lnk cord/cordtest
|
||||
smake
|
||||
|
||||
test: setjmp_t gctest cord/cordtest
|
||||
setjmp_t
|
||||
gctest
|
||||
cord/cordtest
|
||||
|
||||
gctest: gc$(CPU).lib GCAmigaOS$(CPU).lib test.o
|
||||
$(LINKER) LIB:c.o test.o TO gctest LIB gc$(CPU).lib LIB:sc.lib $(MATHLIB)
|
||||
|
||||
setjmp_t: setjmp_t.o gc.h
|
||||
$(LINKER) LIB:c.o setjmp_t.o to setjmp_t lib LIB:sc.lib
|
||||
|
||||
cord/cordtest: cord/cordtest.o cord/cord$(CPU).lib gc$(CPU).lib
|
||||
slink LIB:c.o cord/cordtest.o LIB $(MATHLIB) gc$(CPU).lib cord/cord$(CPU).lib LIB:sc.lib TO cord/cordtest
|
||||
|
||||
|
||||
#------------------LIBBING----------------------------
|
||||
|
||||
OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o real_malloc.o dyn_load.o dbg_mlc.o malloc.o stubborn.o checksums.o typd_mlc.o ptr_chck.o mallocx.o
|
||||
|
||||
gc$(CPU).lib: $(OBJS)
|
||||
$(LIBER) gc$(CPU).lib r $(OBJS)
|
||||
|
||||
|
||||
COBJS = cord/cordbscs.o cord/cordprnt.o cord/cordxtra.o
|
||||
|
||||
cord/cord$(CPU).lib: $(COBJS)
|
||||
oml cord/cord$(CPU).lib r $(COBJS)
|
||||
|
||||
#------------------COMPILING--------------------------
|
||||
|
||||
INC= gc_private.h gc_hdrs.h gc.h gcconfig.h
|
||||
|
||||
alloc.o : alloc.c $(INC)
|
||||
$(CC) alloc.c $(SCOPT) ignore=7
|
||||
|
||||
reclaim.o : reclaim.c $(INC)
|
||||
$(CC) reclaim.c $(SCOPT)
|
||||
|
||||
allchblk.o : allchblk.c $(INC)
|
||||
$(CC) allchblk.c $(SCOPT)
|
||||
|
||||
misc.o : misc.c $(INC)
|
||||
$(CC) misc.c $(SCOPT)
|
||||
|
||||
os_dep.o : os_dep.c $(INC) AmigaOS.c
|
||||
$(CC) os_dep.c $(SCOPT)
|
||||
|
||||
mark_rts.o : mark_rts.c $(INC)
|
||||
$(CC) mark_rts.c $(SCOPT)
|
||||
|
||||
headers.o : headers.c $(INC)
|
||||
$(CC) headers.c $(SCOPT)
|
||||
|
||||
mark.o : mark.c $(INC)
|
||||
$(CC) mark.c $(SCOPT)
|
||||
|
||||
obj_map.o : obj_map.c $(INC)
|
||||
$(CC) obj_map.c $(SCOPT)
|
||||
|
||||
blacklst.o : blacklst.c $(INC)
|
||||
$(CC) blacklst.c $(SCOPT)
|
||||
|
||||
finalize.o : finalize.c $(INC)
|
||||
$(CC) finalize.c $(SCOPT) noopt #Could sas/c still have problems with this one? Gctest sometimes fails to finalize all.
|
||||
|
||||
new_hblk.o : new_hblk.c $(INC)
|
||||
$(CC) new_hblk.c $(SCOPT)
|
||||
|
||||
real_malloc.o : real_malloc.c $(INC)
|
||||
$(CC) real_malloc.c $(SCOPT)
|
||||
|
||||
dyn_load.o : dyn_load.c $(INC)
|
||||
$(CC) dyn_load.c $(SCOPT)
|
||||
|
||||
dbg_mlc.o : dbg_mlc.c $(INC)
|
||||
$(CC) dbg_mlc.c $(SCOPT)
|
||||
|
||||
malloc.o : malloc.c $(INC)
|
||||
$(CC) malloc.c $(SCOPT)
|
||||
|
||||
mallocx.o : mallocx.c $(INC)
|
||||
$(CC) mallocx.c $(SCOPT)
|
||||
|
||||
stubborn.o : stubborn.c $(INC)
|
||||
$(CC) stubborn.c $(SCOPT)
|
||||
|
||||
checksums.o : checksums.c $(INC)
|
||||
$(CC) checksums.c $(SCOPT)
|
||||
|
||||
typd_mlc.o: typd_mlc.c $(INC)
|
||||
$(CC) typd_mlc.c $(SCOPT)
|
||||
|
||||
mach_dep.o : mach_dep.c $(INC)
|
||||
$(CC) mach_dep.c $(SCOPT)
|
||||
|
||||
ptr_chck.o: ptr_chck.c $(INC)
|
||||
$(CC) ptr_chck.c $(SCOPT)
|
||||
|
||||
test.o : test.c $(INC)
|
||||
$(CC) test.c $(SOPT)
|
||||
|
||||
setjmp_t: setjmp_t.c gc.h
|
||||
$(CC) setjmp_t.c $(SOPT)
|
||||
|
||||
|
||||
# cords:
|
||||
|
||||
cord/cordbscs.o: cord/cordbscs.c
|
||||
sc cord/cordbscs.c $(CSCOPT)
|
||||
|
||||
cord/cordprnt.o: cord/cordprnt.c
|
||||
sc cord/cordprnt.c $(CSCOPT)
|
||||
|
||||
cord/cordxtra.o: cord/cordxtra.c
|
||||
sc cord/cordxtra.c $(CSCOPT)
|
||||
|
||||
cord/cordtest.o: cord/cordtest.c
|
||||
sc cord/cordtest.c $(CSCOPT)
|
||||
|
||||
|
||||
@@ -1,196 +0,0 @@
|
||||
# Makefile for Watcom C/C++ 10.5, 10.6, 11.0 on NT, OS2 and DOS4GW.
|
||||
# May work with Watcom 10.0.
|
||||
|
||||
# Uncoment one of the lines below for cross compilation.
|
||||
SYSTEM=MSWIN32
|
||||
#SYSTEM=DOS4GW
|
||||
#SYSTEM=OS2
|
||||
|
||||
# The collector can be built either as dynamic or as static library.
|
||||
# Select the library type you need.
|
||||
#MAKE_AS_DLL=1
|
||||
MAKE_AS_LIB=1
|
||||
|
||||
# Select calling conventions.
|
||||
# Possible choices are r and s.
|
||||
CALLING=s
|
||||
|
||||
# Select target CPU.
|
||||
# Possible choices are 3, 4, 5, and 6.
|
||||
# The last choice available only since version 11.0.
|
||||
CPU=5
|
||||
|
||||
# Set optimization options.
|
||||
# Watcom before 11.0 does not support option "-oh".
|
||||
OPTIM=-oneatx -s
|
||||
#OPTIM=-ohneatx -s
|
||||
|
||||
DEFS=-DALL_INTERIOR_POINTERS -DSILENT -DNO_SIGNALS #-DSMALL_CONFIG #-DGC_DEBUG
|
||||
|
||||
|
||||
#####
|
||||
|
||||
!ifndef SYSTEM
|
||||
!ifdef __MSDOS__
|
||||
SYSTEM=DOS4GW
|
||||
!else ifdef __NT__
|
||||
SYSTEM=MSWIN32
|
||||
!else ifdef __OS2__
|
||||
SYSTEM=OS2
|
||||
!else
|
||||
SYSTEM=Unknown
|
||||
!endif
|
||||
!endif
|
||||
|
||||
!define $(SYSTEM)
|
||||
|
||||
!ifdef DOS4GW
|
||||
SYSFLAG=-DDOS4GW -bt=dos
|
||||
!else ifdef MSWIN32
|
||||
SYSFLAG=-DMSWIN32 -bt=nt
|
||||
!else ifdef OS2
|
||||
SYSFLAG=-DOS2 -bt=os2
|
||||
!else
|
||||
!error undefined or unsupported target platform: $(SYSTEM)
|
||||
!endif
|
||||
!ifdef MAKE_AS_DLL
|
||||
DLLFLAG=-bd -DGC_DLL
|
||||
TEST_DLLFLAG=-DGC_DLL
|
||||
!else ifdef MAKE_AS_LIB
|
||||
DLLFLAG=
|
||||
TEST_DLLFLAG=
|
||||
!else
|
||||
!error Either MAKE_AS_LIB or MAKE_AS_DLL should be defined
|
||||
!endif
|
||||
|
||||
CC=wcc386
|
||||
CXX=wpp386
|
||||
|
||||
# -DUSE_GENERIC is required !
|
||||
CFLAGS=-$(CPU)$(CALLING) $(OPTIM) -zp4 -zc $(SYSFLAG) $(DLLFLAG) -DGC_BUILD -DUSE_GENERIC $(DEFS)
|
||||
CXXFLAGS= $(CFLAGS)
|
||||
TEST_CFLAGS=-$(CPU)$(CALLING) $(OPTIM) -zp4 -zc $(SYSFLAG) $(TEST_DLLFLAG) $(DEFS)
|
||||
TEST_CXXFLAGS= $(TEST_CFLAGS)
|
||||
|
||||
OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj &
|
||||
mach_dep.obj os_dep.obj mark_rts.obj headers.obj mark.obj &
|
||||
obj_map.obj blacklst.obj finalize.obj new_hblk.obj &
|
||||
dbg_mlc.obj malloc.obj stubborn.obj dyn_load.obj &
|
||||
typd_mlc.obj ptr_chck.obj mallocx.obj
|
||||
|
||||
all: gc.lib gctest.exe test_cpp.exe
|
||||
|
||||
!ifdef MAKE_AS_DLL
|
||||
|
||||
gc.lib: gc.dll gc_cpp.obj
|
||||
*wlib -b -c -n -p=512 $@ +gc.dll +gc_cpp.obj
|
||||
|
||||
gc.dll: $(OBJS) .AUTODEPEND
|
||||
@%create $*.lnk
|
||||
!ifdef DOS4GW
|
||||
@%append $*.lnk sys os2v2_dll
|
||||
!else ifdef MSWIN32
|
||||
@%append $*.lnk sys nt_dll
|
||||
!else ifdef OS2
|
||||
@%append $*.lnk sys os2v2_dll
|
||||
!endif
|
||||
@%append $*.lnk name $*
|
||||
@for %i in ($(OBJS)) do @%append $*.lnk file '%i'
|
||||
!ifeq CALLING s
|
||||
@%append $*.lnk export GC_is_marked
|
||||
@%append $*.lnk export GC_incr_words_allocd
|
||||
@%append $*.lnk export GC_incr_mem_freed
|
||||
@%append $*.lnk export GC_generic_malloc_words_small
|
||||
!else
|
||||
@%append $*.lnk export GC_is_marked_
|
||||
@%append $*.lnk export GC_incr_words_allocd_
|
||||
@%append $*.lnk export GC_incr_mem_freed_
|
||||
@%append $*.lnk export GC_generic_malloc_words_small_
|
||||
!endif
|
||||
*wlink @$*.lnk
|
||||
!else
|
||||
gc.lib: $(OBJS) gc_cpp.obj
|
||||
@%create $*.lb1
|
||||
@for %i in ($(OBJS)) do @%append $*.lb1 +'%i'
|
||||
@%append $*.lb1 +'gc_cpp.obj'
|
||||
*wlib -b -c -n -p=512 $@ @$*.lb1
|
||||
|
||||
!endif
|
||||
|
||||
|
||||
gctest.exe: test.obj gc.lib
|
||||
%create $*.lnk
|
||||
!ifdef DOS4GW
|
||||
@%append $*.lnk sys dos4g
|
||||
!else ifdef MSWIN32
|
||||
@%append $*.lnk sys nt
|
||||
!else ifdef OS2
|
||||
@%append $*.lnk sys os2v2
|
||||
!endif
|
||||
@%append $*.lnk op case
|
||||
@%append $*.lnk op stack=256K
|
||||
@%append $*.lnk name $*
|
||||
@%append $*.lnk file test.obj
|
||||
@%append $*.lnk library gc.lib
|
||||
!ifdef MAKE_AS_DLL
|
||||
!ifeq CALLING s
|
||||
@%append $*.lnk import GC_is_marked gc
|
||||
!else
|
||||
@%append $*.lnk import GC_is_marked_ gc
|
||||
!endif
|
||||
!endif
|
||||
*wlink @$*.lnk
|
||||
test_cpp.exe: test_cpp.obj gc.lib
|
||||
%create $*.lnk
|
||||
!ifdef DOS4GW
|
||||
@%append $*.lnk sys dos4g
|
||||
!else ifdef MSWIN32
|
||||
@%append $*.lnk sys nt
|
||||
!else ifdef OS2
|
||||
@%append $*.lnk sys os2v2
|
||||
!endif
|
||||
@%append $*.lnk op case
|
||||
@%append $*.lnk op stack=256K
|
||||
@%append $*.lnk name $*
|
||||
@%append $*.lnk file test_cpp.obj
|
||||
@%append $*.lnk library gc.lib
|
||||
!ifdef MAKE_AS_DLL
|
||||
!ifeq CALLING s
|
||||
@%append $*.lnk import GC_incr_words_allocd gc
|
||||
@%append $*.lnk import GC_incr_mem_freed gc
|
||||
@%append $*.lnk import GC_generic_malloc_words_small gc
|
||||
!else
|
||||
@%append $*.lnk import GC_incr_words_allocd_ gc
|
||||
@%append $*.lnk import GC_incr_mem_freed_ gc
|
||||
@%append $*.lnk import GC_generic_malloc_words_small_ gc
|
||||
!endif
|
||||
!endif
|
||||
*wlink @$*.lnk
|
||||
|
||||
gc_cpp.obj: gc_cpp.cc .AUTODEPEND
|
||||
$(CXX) $(TEST_CXXFLAGS) -iinclude $*.cc
|
||||
test.obj: tests\test.c .AUTODEPEND
|
||||
$(CC) $(TEST_CFLAGS) $*.c
|
||||
test_cpp.obj: tests\test_cpp.cc .AUTODEPEND
|
||||
$(CXX) $(TEST_CXXFLAGS) -iinclude $*.cc
|
||||
|
||||
|
||||
.c.obj: .AUTODEPEND
|
||||
$(CC) $(CFLAGS) $*.c
|
||||
|
||||
.cc.obj: .AUTODEPEND
|
||||
$(CXX) $(CXXFLAGS) $*.cc
|
||||
|
||||
clean : .SYMBOLIC
|
||||
@if exist *.obj del *.obj
|
||||
@if exist *.map del *.map
|
||||
@if exist *.lnk del *.lnk
|
||||
@if exist *.lb1 del *.lb1
|
||||
@if exist *.sym del *.sym
|
||||
@if exist *.err del *.err
|
||||
@if exist *.tmp del *.tmp
|
||||
@if exist *.lst del *.lst
|
||||
@if exist *.exe del *.exe
|
||||
@if exist *.log del *.log
|
||||
@if exist *.lib del *.lib
|
||||
@if exist *.dll del *.dll
|
||||
@@ -1,191 +0,0 @@
|
||||
# Copyright (c) 1999-2001 by Red Hat, Inc. All rights reserved.
|
||||
#
|
||||
# THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
# OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
#
|
||||
# Permission is hereby granted to use or copy this program
|
||||
# for any purpose, provided the above notices are retained on all copies.
|
||||
# Permission to modify the code and to distribute modified code is granted,
|
||||
# provided the above notices are retained, and a notice that the code was
|
||||
# modified is included with the above copyright notice.
|
||||
#
|
||||
# Original author: Tom Tromey
|
||||
|
||||
# FIXME: We temporarily define our own version of AC_PROG_CC. This is
|
||||
# copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We
|
||||
# are probably using a cross compiler, which will not be able to fully
|
||||
# link an executable. This should really be fixed in autoconf
|
||||
# itself.
|
||||
|
||||
AC_DEFUN(GC_CONFIGURE,
|
||||
[
|
||||
dnl Default to --enable-multilib
|
||||
AC_ARG_ENABLE(multilib,
|
||||
[ --enable-multilib build many library versions (default)],
|
||||
[case "${enableval}" in
|
||||
yes) multilib=yes ;;
|
||||
no) multilib=no ;;
|
||||
*) AC_MSG_ERROR(bad value ${enableval} for multilib option) ;;
|
||||
esac], [multilib=yes])dnl
|
||||
|
||||
dnl We may get other options which we don't document:
|
||||
dnl --with-target-subdir, --with-multisrctop, --with-multisubdir
|
||||
|
||||
dnl I needed to add the -n test to allow configuration in src directory - HB
|
||||
if test "[$]{srcdir}" = "."; then
|
||||
if test "[$]{with_target_subdir}" != "." -a -n "[$]{with_target_subdir}"; then
|
||||
gc_basedir="[$]{srcdir}/[$]{with_multisrctop}../$1"
|
||||
else
|
||||
gc_basedir="[$]{srcdir}/[$]{with_multisrctop}$1"
|
||||
fi
|
||||
else
|
||||
gc_basedir="[$]{srcdir}/$1"
|
||||
fi
|
||||
AC_SUBST(gc_basedir)
|
||||
AC_CONFIG_AUX_DIR($gc_basedir/..)
|
||||
if :; then :; else
|
||||
# This overrides the previous occurrence for automake, but not for
|
||||
# autoconf, which is exactly what we want.
|
||||
AC_CONFIG_AUX_DIR(..)
|
||||
fi
|
||||
|
||||
AC_CANONICAL_SYSTEM
|
||||
|
||||
# This works around an automake problem.
|
||||
mkinstalldirs="`cd $ac_aux_dir && pwd`/mkinstalldirs"
|
||||
AC_SUBST(mkinstalldirs)
|
||||
|
||||
AM_INIT_AUTOMAKE(gc, 6.1a1, no-define)
|
||||
|
||||
# FIXME: We temporarily define our own version of AC_PROG_CC. This is
|
||||
# copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We
|
||||
# are probably using a cross compiler, which will not be able to fully
|
||||
# link an executable. This should really be fixed in autoconf
|
||||
# itself.
|
||||
|
||||
AC_DEFUN(LIB_AC_PROG_CC,
|
||||
[AC_BEFORE([$0], [AC_PROG_CPP])dnl
|
||||
dnl Fool anybody using AC_PROG_CC.
|
||||
AC_PROVIDE([AC_PROG_CC])
|
||||
AC_CHECK_PROG(CC, gcc, gcc)
|
||||
if test -z "$CC"; then
|
||||
AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
|
||||
test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
|
||||
fi
|
||||
|
||||
AC_PROG_CC_GNU
|
||||
|
||||
if test $ac_cv_prog_gcc = yes; then
|
||||
GCC=yes
|
||||
dnl Check whether -g works, even if CFLAGS is set, in case the package
|
||||
dnl plays around with CFLAGS (such as to build both debugging and
|
||||
dnl normal versions of a library), tasteless as that idea is.
|
||||
ac_test_CFLAGS="${CFLAGS+set}"
|
||||
ac_save_CFLAGS="$CFLAGS"
|
||||
CFLAGS=
|
||||
AC_PROG_CC_G
|
||||
if test "$ac_test_CFLAGS" = set; then
|
||||
CFLAGS="$ac_save_CFLAGS"
|
||||
elif test $ac_cv_prog_cc_g = yes; then
|
||||
CFLAGS="-g -O2"
|
||||
else
|
||||
CFLAGS="-O2"
|
||||
fi
|
||||
else
|
||||
GCC=
|
||||
test "${CFLAGS+set}" = set || CFLAGS="-g"
|
||||
fi
|
||||
])
|
||||
|
||||
LIB_AC_PROG_CC
|
||||
|
||||
# Likewise for AC_PROG_CXX.
|
||||
AC_DEFUN(LIB_AC_PROG_CXX,
|
||||
[AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl
|
||||
dnl Fool anybody using AC_PROG_CXX.
|
||||
AC_PROVIDE([AC_PROG_CXX])
|
||||
AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++, gcc)
|
||||
test -z "$CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH])
|
||||
|
||||
AC_PROG_CXX_GNU
|
||||
|
||||
if test $ac_cv_prog_gxx = yes; then
|
||||
GXX=yes
|
||||
dnl Check whether -g works, even if CXXFLAGS is set, in case the package
|
||||
dnl plays around with CXXFLAGS (such as to build both debugging and
|
||||
dnl normal versions of a library), tasteless as that idea is.
|
||||
ac_test_CXXFLAGS="${CXXFLAGS+set}"
|
||||
ac_save_CXXFLAGS="$CXXFLAGS"
|
||||
CXXFLAGS=
|
||||
AC_PROG_CXX_G
|
||||
if test "$ac_test_CXXFLAGS" = set; then
|
||||
CXXFLAGS="$ac_save_CXXFLAGS"
|
||||
elif test $ac_cv_prog_cxx_g = yes; then
|
||||
CXXFLAGS="-g -O2"
|
||||
else
|
||||
CXXFLAGS="-O2"
|
||||
fi
|
||||
else
|
||||
GXX=
|
||||
test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
|
||||
fi
|
||||
])
|
||||
|
||||
LIB_AC_PROG_CXX
|
||||
|
||||
# AC_CHECK_TOOL does AC_REQUIRE (AC_CANONICAL_BUILD). If we don't
|
||||
# run it explicitly here, it will be run implicitly before
|
||||
# NEWLIB_CONFIGURE, which doesn't work because that means that it will
|
||||
# be run before AC_CANONICAL_HOST.
|
||||
AC_CANONICAL_BUILD
|
||||
|
||||
AC_CHECK_TOOL(AS, as)
|
||||
AC_CHECK_TOOL(AR, ar)
|
||||
AC_CHECK_TOOL(RANLIB, ranlib, :)
|
||||
|
||||
AC_PROG_INSTALL
|
||||
|
||||
AM_MAINTAINER_MODE
|
||||
|
||||
# We need AC_EXEEXT to keep automake happy in cygnus mode. However,
|
||||
# at least currently, we never actually build a program, so we never
|
||||
# need to use $(EXEEXT). Moreover, the test for EXEEXT normally
|
||||
# fails, because we are probably configuring with a cross compiler
|
||||
# which can't create executables. So we include AC_EXEEXT to keep
|
||||
# automake happy, but we don't execute it, since we don't care about
|
||||
# the result.
|
||||
if false; then
|
||||
# autoconf 2.50 runs AC_EXEEXT by default, and the macro expands
|
||||
# to nothing, so nothing would remain between `then' and `fi' if it
|
||||
# were not for the `:' below.
|
||||
:
|
||||
AC_EXEEXT
|
||||
fi
|
||||
|
||||
. [$]{srcdir}/configure.host
|
||||
|
||||
case [$]{gc_basedir} in
|
||||
/* | [A-Za-z]:[/\\]*) gc_flagbasedir=[$]{gc_basedir} ;;
|
||||
*) gc_flagbasedir='[$](top_builddir)/'[$]{gc_basedir} ;;
|
||||
esac
|
||||
|
||||
gc_cflags="[$]{gc_cflags} -I"'[$](top_builddir)'"/$1/targ-include -I[$]{gc_flagbasedir}/libc/include"
|
||||
case "${host}" in
|
||||
*-*-cygwin32*)
|
||||
gc_cflags="[$]{gc_cflags} -I[$]{gc_flagbasedir}/../winsup/include"
|
||||
;;
|
||||
esac
|
||||
|
||||
dnl gc_cflags="[$]{gc_cflags} -fno-builtin"
|
||||
|
||||
GC_CFLAGS=${gc_cflags}
|
||||
AC_SUBST(GC_CFLAGS)
|
||||
]))
|
||||
|
||||
))))
|
||||
|
||||
sinclude(../libtool.m4)
|
||||
dnl The line below arranges for aclocal not to bring a definition of
|
||||
dnl AM_PROG_LIBTOOL into aclocal.m4, while still arranging for automake
|
||||
dnl to add a definition of LIBTOOL to Makefile.in.
|
||||
ifelse(yes,no,[AC_DEFUN([AM_PROG_LIBTOOL],[AC_SUBST(LIBTOOL)])])
|
||||
329
boehm-gc/aclocal.m4
vendored
329
boehm-gc/aclocal.m4
vendored
@@ -1,329 +0,0 @@
|
||||
dnl aclocal.m4 generated automatically by aclocal 1.4
|
||||
|
||||
dnl Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
|
||||
dnl This file is free software; the Free Software Foundation
|
||||
dnl gives unlimited permission to copy and/or distribute it,
|
||||
dnl with or without modifications, as long as this notice is preserved.
|
||||
|
||||
dnl This program is distributed in the hope that it will be useful,
|
||||
dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without
|
||||
dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
||||
dnl PARTICULAR PURPOSE.
|
||||
|
||||
# Copyright (c) 1999-2001 by Red Hat, Inc. All rights reserved.
|
||||
#
|
||||
# THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
# OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
#
|
||||
# Permission is hereby granted to use or copy this program
|
||||
# for any purpose, provided the above notices are retained on all copies.
|
||||
# Permission to modify the code and to distribute modified code is granted,
|
||||
# provided the above notices are retained, and a notice that the code was
|
||||
# modified is included with the above copyright notice.
|
||||
#
|
||||
# Original author: Tom Tromey
|
||||
|
||||
# FIXME: We temporarily define our own version of AC_PROG_CC. This is
|
||||
# copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We
|
||||
# are probably using a cross compiler, which will not be able to fully
|
||||
# link an executable. This should really be fixed in autoconf
|
||||
# itself.
|
||||
|
||||
AC_DEFUN(GC_CONFIGURE,
|
||||
[
|
||||
dnl Default to --enable-multilib
|
||||
AC_ARG_ENABLE(multilib,
|
||||
[ --enable-multilib build many library versions (default)],
|
||||
[case "${enableval}" in
|
||||
yes) multilib=yes ;;
|
||||
no) multilib=no ;;
|
||||
*) AC_MSG_ERROR(bad value ${enableval} for multilib option) ;;
|
||||
esac], [multilib=yes])dnl
|
||||
|
||||
dnl We may get other options which we don't document:
|
||||
dnl --with-target-subdir, --with-multisrctop, --with-multisubdir
|
||||
|
||||
dnl I needed to add the -n test to allow configuration in src directory - HB
|
||||
if test "[$]{srcdir}" = "."; then
|
||||
if test "[$]{with_target_subdir}" != "." -a -n "[$]{with_target_subdir}"; then
|
||||
gc_basedir="[$]{srcdir}/[$]{with_multisrctop}../$1"
|
||||
else
|
||||
gc_basedir="[$]{srcdir}/[$]{with_multisrctop}$1"
|
||||
fi
|
||||
else
|
||||
gc_basedir="[$]{srcdir}/$1"
|
||||
fi
|
||||
AC_SUBST(gc_basedir)
|
||||
AC_CONFIG_AUX_DIR($gc_basedir/..)
|
||||
if :; then :; else
|
||||
# This overrides the previous occurrence for automake, but not for
|
||||
# autoconf, which is exactly what we want.
|
||||
AC_CONFIG_AUX_DIR(..)
|
||||
fi
|
||||
|
||||
AC_CANONICAL_SYSTEM
|
||||
|
||||
# This works around an automake problem.
|
||||
mkinstalldirs="`cd $ac_aux_dir && pwd`/mkinstalldirs"
|
||||
AC_SUBST(mkinstalldirs)
|
||||
|
||||
AM_INIT_AUTOMAKE(gc, 6.0, no-define)
|
||||
|
||||
# FIXME: We temporarily define our own version of AC_PROG_CC. This is
|
||||
# copied from autoconf 2.12, but does not call AC_PROG_CC_WORKS. We
|
||||
# are probably using a cross compiler, which will not be able to fully
|
||||
# link an executable. This should really be fixed in autoconf
|
||||
# itself.
|
||||
|
||||
AC_DEFUN(LIB_AC_PROG_CC,
|
||||
[AC_BEFORE([$0], [AC_PROG_CPP])dnl
|
||||
dnl Fool anybody using AC_PROG_CC.
|
||||
AC_PROVIDE([AC_PROG_CC])
|
||||
AC_CHECK_PROG(CC, gcc, gcc)
|
||||
if test -z "$CC"; then
|
||||
AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
|
||||
test -z "$CC" && AC_MSG_ERROR([no acceptable cc found in \$PATH])
|
||||
fi
|
||||
|
||||
AC_PROG_CC_GNU
|
||||
|
||||
if test $ac_cv_prog_gcc = yes; then
|
||||
GCC=yes
|
||||
dnl Check whether -g works, even if CFLAGS is set, in case the package
|
||||
dnl plays around with CFLAGS (such as to build both debugging and
|
||||
dnl normal versions of a library), tasteless as that idea is.
|
||||
ac_test_CFLAGS="${CFLAGS+set}"
|
||||
ac_save_CFLAGS="$CFLAGS"
|
||||
CFLAGS=
|
||||
AC_PROG_CC_G
|
||||
if test "$ac_test_CFLAGS" = set; then
|
||||
CFLAGS="$ac_save_CFLAGS"
|
||||
elif test $ac_cv_prog_cc_g = yes; then
|
||||
CFLAGS="-g -O2"
|
||||
else
|
||||
CFLAGS="-O2"
|
||||
fi
|
||||
else
|
||||
GCC=
|
||||
test "${CFLAGS+set}" = set || CFLAGS="-g"
|
||||
fi
|
||||
])
|
||||
|
||||
LIB_AC_PROG_CC
|
||||
|
||||
# Likewise for AC_PROG_CXX.
|
||||
AC_DEFUN(LIB_AC_PROG_CXX,
|
||||
[AC_BEFORE([$0], [AC_PROG_CXXCPP])dnl
|
||||
dnl Fool anybody using AC_PROG_CXX.
|
||||
AC_PROVIDE([AC_PROG_CXX])
|
||||
AC_CHECK_PROGS(CXX, $CCC c++ g++ gcc CC cxx cc++, gcc)
|
||||
test -z "$CXX" && AC_MSG_ERROR([no acceptable c++ found in \$PATH])
|
||||
|
||||
AC_PROG_CXX_GNU
|
||||
|
||||
if test $ac_cv_prog_gxx = yes; then
|
||||
GXX=yes
|
||||
dnl Check whether -g works, even if CXXFLAGS is set, in case the package
|
||||
dnl plays around with CXXFLAGS (such as to build both debugging and
|
||||
dnl normal versions of a library), tasteless as that idea is.
|
||||
ac_test_CXXFLAGS="${CXXFLAGS+set}"
|
||||
ac_save_CXXFLAGS="$CXXFLAGS"
|
||||
CXXFLAGS=
|
||||
AC_PROG_CXX_G
|
||||
if test "$ac_test_CXXFLAGS" = set; then
|
||||
CXXFLAGS="$ac_save_CXXFLAGS"
|
||||
elif test $ac_cv_prog_cxx_g = yes; then
|
||||
CXXFLAGS="-g -O2"
|
||||
else
|
||||
CXXFLAGS="-O2"
|
||||
fi
|
||||
else
|
||||
GXX=
|
||||
test "${CXXFLAGS+set}" = set || CXXFLAGS="-g"
|
||||
fi
|
||||
])
|
||||
|
||||
LIB_AC_PROG_CXX
|
||||
|
||||
# AC_CHECK_TOOL does AC_REQUIRE (AC_CANONICAL_BUILD). If we don't
|
||||
# run it explicitly here, it will be run implicitly before
|
||||
# NEWLIB_CONFIGURE, which doesn't work because that means that it will
|
||||
# be run before AC_CANONICAL_HOST.
|
||||
AC_CANONICAL_BUILD
|
||||
|
||||
AC_CHECK_TOOL(AS, as)
|
||||
AC_CHECK_TOOL(AR, ar)
|
||||
AC_CHECK_TOOL(RANLIB, ranlib, :)
|
||||
|
||||
AC_PROG_INSTALL
|
||||
|
||||
AM_MAINTAINER_MODE
|
||||
|
||||
# We need AC_EXEEXT to keep automake happy in cygnus mode. However,
|
||||
# at least currently, we never actually build a program, so we never
|
||||
# need to use $(EXEEXT). Moreover, the test for EXEEXT normally
|
||||
# fails, because we are probably configuring with a cross compiler
|
||||
# which can't create executables. So we include AC_EXEEXT to keep
|
||||
# automake happy, but we don't execute it, since we don't care about
|
||||
# the result.
|
||||
if false; then
|
||||
# autoconf 2.50 runs AC_EXEEXT by default, and the macro expands
|
||||
# to nothing, so nothing would remain between `then' and `fi' if it
|
||||
# were not for the `:' below.
|
||||
:
|
||||
AC_EXEEXT
|
||||
fi
|
||||
|
||||
. [$]{srcdir}/configure.host
|
||||
|
||||
case [$]{gc_basedir} in
|
||||
/* | [A-Za-z]:[/\\]*) gc_flagbasedir=[$]{gc_basedir} ;;
|
||||
*) gc_flagbasedir='[$](top_builddir)/'[$]{gc_basedir} ;;
|
||||
esac
|
||||
|
||||
gc_cflags="[$]{gc_cflags} -I"'[$](top_builddir)'"/$1/targ-include -I[$]{gc_flagbasedir}/libc/include"
|
||||
case "${host}" in
|
||||
*-*-cygwin32*)
|
||||
gc_cflags="[$]{gc_cflags} -I[$]{gc_flagbasedir}/../winsup/include"
|
||||
;;
|
||||
esac
|
||||
|
||||
dnl gc_cflags="[$]{gc_cflags} -fno-builtin"
|
||||
|
||||
GC_CFLAGS=${gc_cflags}
|
||||
AC_SUBST(GC_CFLAGS)
|
||||
]))
|
||||
|
||||
))))
|
||||
|
||||
sinclude(../libtool.m4)
|
||||
dnl The line below arranges for aclocal not to bring a definition of
|
||||
dnl AM_PROG_LIBTOOL into aclocal.m4, while still arranging for automake
|
||||
dnl to add a definition of LIBTOOL to Makefile.in.
|
||||
ifelse(yes,no,[AC_DEFUN([AM_PROG_LIBTOOL],[AC_SUBST(LIBTOOL)])])
|
||||
|
||||
# Do all the work for Automake. This macro actually does too much --
|
||||
# some checks are only needed if your package does certain things.
|
||||
# But this isn't really a big deal.
|
||||
|
||||
# serial 1
|
||||
|
||||
dnl Usage:
|
||||
dnl AM_INIT_AUTOMAKE(package,version, [no-define])
|
||||
|
||||
AC_DEFUN(AM_INIT_AUTOMAKE,
|
||||
[AC_REQUIRE([AC_PROG_INSTALL])
|
||||
PACKAGE=[$1]
|
||||
AC_SUBST(PACKAGE)
|
||||
VERSION=[$2]
|
||||
AC_SUBST(VERSION)
|
||||
dnl test to see if srcdir already configured
|
||||
if test "`cd $srcdir && pwd`" != "`pwd`" && test -f $srcdir/config.status; then
|
||||
AC_MSG_ERROR([source directory already configured; run "make distclean" there first])
|
||||
fi
|
||||
ifelse([$3],,
|
||||
AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", [Name of package])
|
||||
AC_DEFINE_UNQUOTED(VERSION, "$VERSION", [Version number of package]))
|
||||
AC_REQUIRE([AM_SANITY_CHECK])
|
||||
AC_REQUIRE([AC_ARG_PROGRAM])
|
||||
dnl FIXME This is truly gross.
|
||||
missing_dir=`cd $ac_aux_dir && pwd`
|
||||
AM_MISSING_PROG(ACLOCAL, aclocal, $missing_dir)
|
||||
AM_MISSING_PROG(AUTOCONF, autoconf, $missing_dir)
|
||||
AM_MISSING_PROG(AUTOMAKE, automake, $missing_dir)
|
||||
AM_MISSING_PROG(AUTOHEADER, autoheader, $missing_dir)
|
||||
AM_MISSING_PROG(MAKEINFO, makeinfo, $missing_dir)
|
||||
AC_REQUIRE([AC_PROG_MAKE_SET])])
|
||||
|
||||
#
|
||||
# Check to make sure that the build environment is sane.
|
||||
#
|
||||
|
||||
AC_DEFUN(AM_SANITY_CHECK,
|
||||
[AC_MSG_CHECKING([whether build environment is sane])
|
||||
# Just in case
|
||||
sleep 1
|
||||
echo timestamp > conftestfile
|
||||
# Do `set' in a subshell so we don't clobber the current shell's
|
||||
# arguments. Must try -L first in case configure is actually a
|
||||
# symlink; some systems play weird games with the mod time of symlinks
|
||||
# (eg FreeBSD returns the mod time of the symlink's containing
|
||||
# directory).
|
||||
if (
|
||||
set X `ls -Lt $srcdir/configure conftestfile 2> /dev/null`
|
||||
if test "[$]*" = "X"; then
|
||||
# -L didn't work.
|
||||
set X `ls -t $srcdir/configure conftestfile`
|
||||
fi
|
||||
if test "[$]*" != "X $srcdir/configure conftestfile" \
|
||||
&& test "[$]*" != "X conftestfile $srcdir/configure"; then
|
||||
|
||||
# If neither matched, then we have a broken ls. This can happen
|
||||
# if, for instance, CONFIG_SHELL is bash and it inherits a
|
||||
# broken ls alias from the environment. This has actually
|
||||
# happened. Such a system could not be considered "sane".
|
||||
AC_MSG_ERROR([ls -t appears to fail. Make sure there is not a broken
|
||||
alias in your environment])
|
||||
fi
|
||||
|
||||
test "[$]2" = conftestfile
|
||||
)
|
||||
then
|
||||
# Ok.
|
||||
:
|
||||
else
|
||||
AC_MSG_ERROR([newly created file is older than distributed files!
|
||||
Check your system clock])
|
||||
fi
|
||||
rm -f conftest*
|
||||
AC_MSG_RESULT(yes)])
|
||||
|
||||
dnl AM_MISSING_PROG(NAME, PROGRAM, DIRECTORY)
|
||||
dnl The program must properly implement --version.
|
||||
AC_DEFUN(AM_MISSING_PROG,
|
||||
[AC_MSG_CHECKING(for working $2)
|
||||
# Run test in a subshell; some versions of sh will print an error if
|
||||
# an executable is not found, even if stderr is redirected.
|
||||
# Redirect stdin to placate older versions of autoconf. Sigh.
|
||||
if ($2 --version) < /dev/null > /dev/null 2>&1; then
|
||||
$1=$2
|
||||
AC_MSG_RESULT(found)
|
||||
else
|
||||
$1="$3/missing $2"
|
||||
AC_MSG_RESULT(missing)
|
||||
fi
|
||||
AC_SUBST($1)])
|
||||
|
||||
# Add --enable-maintainer-mode option to configure.
|
||||
# From Jim Meyering
|
||||
|
||||
# serial 1
|
||||
|
||||
AC_DEFUN(AM_MAINTAINER_MODE,
|
||||
[AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
|
||||
dnl maintainer-mode is disabled by default
|
||||
AC_ARG_ENABLE(maintainer-mode,
|
||||
[ --enable-maintainer-mode enable make rules and dependencies not useful
|
||||
(and sometimes confusing) to the casual installer],
|
||||
USE_MAINTAINER_MODE=$enableval,
|
||||
USE_MAINTAINER_MODE=no)
|
||||
AC_MSG_RESULT($USE_MAINTAINER_MODE)
|
||||
AM_CONDITIONAL(MAINTAINER_MODE, test $USE_MAINTAINER_MODE = yes)
|
||||
MAINT=$MAINTAINER_MODE_TRUE
|
||||
AC_SUBST(MAINT)dnl
|
||||
]
|
||||
)
|
||||
|
||||
# Define a conditional.
|
||||
|
||||
AC_DEFUN(AM_CONDITIONAL,
|
||||
[AC_SUBST($1_TRUE)
|
||||
AC_SUBST($1_FALSE)
|
||||
if $2; then
|
||||
$1_TRUE=
|
||||
$1_FALSE='#'
|
||||
else
|
||||
$1_TRUE='#'
|
||||
$1_FALSE=
|
||||
fi])
|
||||
|
||||
@@ -1,20 +0,0 @@
|
||||
# include <stdio.h>
|
||||
# include "version.h"
|
||||
|
||||
int main(argc, argv, envp)
|
||||
int argc;
|
||||
char ** argv;
|
||||
char ** envp;
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 1; i < argc; i++) {
|
||||
if (GC_ALPHA_VERSION == GC_NOT_ALPHA) {
|
||||
printf("gc%d.%d/%s ", GC_VERSION_MAJOR, GC_VERSION_MINOR, argv[i]);
|
||||
} else {
|
||||
printf("gc%d.%dalpha%d/%s ", GC_VERSION_MAJOR,
|
||||
GC_VERSION_MINOR, GC_ALPHA_VERSION, argv[i]);
|
||||
}
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
@@ -1,806 +0,0 @@
|
||||
/*
|
||||
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
|
||||
* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
|
||||
* Copyright (c) 1998-1999 by Silicon Graphics. All rights reserved.
|
||||
* Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
|
||||
/* #define DEBUG */
|
||||
#include <stdio.h>
|
||||
#include "private/gc_priv.h"
|
||||
|
||||
GC_bool GC_use_entire_heap = 0;
|
||||
|
||||
/*
|
||||
* Free heap blocks are kept on one of several free lists,
|
||||
* depending on the size of the block. Each free list is doubly linked.
|
||||
* Adjacent free blocks are coalesced.
|
||||
*/
|
||||
|
||||
|
||||
# define MAX_BLACK_LIST_ALLOC (2*HBLKSIZE)
|
||||
/* largest block we will allocate starting on a black */
|
||||
/* listed block. Must be >= HBLKSIZE. */
|
||||
|
||||
|
||||
# define UNIQUE_THRESHOLD 32
|
||||
/* Sizes up to this many HBLKs each have their own free list */
|
||||
# define HUGE_THRESHOLD 256
|
||||
/* Sizes of at least this many heap blocks are mapped to a */
|
||||
/* single free list. */
|
||||
# define FL_COMPRESSION 8
|
||||
/* In between sizes map this many distinct sizes to a single */
|
||||
/* bin. */
|
||||
|
||||
# define N_HBLK_FLS (HUGE_THRESHOLD - UNIQUE_THRESHOLD)/FL_COMPRESSION \
|
||||
+ UNIQUE_THRESHOLD
|
||||
|
||||
struct hblk * GC_hblkfreelist[N_HBLK_FLS+1] = { 0 };
|
||||
|
||||
#ifndef USE_MUNMAP
|
||||
word GC_free_bytes[N_HBLK_FLS+1] = { 0 };
|
||||
/* Number of free bytes on each list. */
|
||||
|
||||
/* Is bytes + the number of free bytes on lists n .. N_HBLK_FLS */
|
||||
/* > GC_max_large_allocd_bytes? */
|
||||
GC_bool GC_enough_large_bytes_left(bytes,n)
|
||||
word bytes;
|
||||
int n;
|
||||
{
|
||||
int i;
|
||||
for (i = N_HBLK_FLS; i >= n; --i) {
|
||||
bytes += GC_free_bytes[i];
|
||||
if (bytes > GC_max_large_allocd_bytes) return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
# define INCR_FREE_BYTES(n, b) GC_free_bytes[n] += (b);
|
||||
|
||||
# define FREE_ASSERT(e) GC_ASSERT(e)
|
||||
|
||||
#else /* USE_MUNMAP */
|
||||
|
||||
# define INCR_FREE_BYTES(n, b)
|
||||
# define FREE_ASSERT(e)
|
||||
|
||||
#endif /* USE_MUNMAP */
|
||||
|
||||
/* Map a number of blocks to the appropriate large block free list index. */
|
||||
int GC_hblk_fl_from_blocks(blocks_needed)
|
||||
word blocks_needed;
|
||||
{
|
||||
if (blocks_needed <= UNIQUE_THRESHOLD) return blocks_needed;
|
||||
if (blocks_needed >= HUGE_THRESHOLD) return N_HBLK_FLS;
|
||||
return (blocks_needed - UNIQUE_THRESHOLD)/FL_COMPRESSION
|
||||
+ UNIQUE_THRESHOLD;
|
||||
|
||||
}
|
||||
|
||||
# define HBLK_IS_FREE(hdr) ((hdr) -> hb_map == GC_invalid_map)
|
||||
# define PHDR(hhdr) HDR(hhdr -> hb_prev)
|
||||
# define NHDR(hhdr) HDR(hhdr -> hb_next)
|
||||
|
||||
# ifdef USE_MUNMAP
|
||||
# define IS_MAPPED(hhdr) (((hhdr) -> hb_flags & WAS_UNMAPPED) == 0)
|
||||
# else /* !USE_MMAP */
|
||||
# define IS_MAPPED(hhdr) 1
|
||||
# endif /* USE_MUNMAP */
|
||||
|
||||
# if !defined(NO_DEBUGGING)
|
||||
void GC_print_hblkfreelist()
|
||||
{
|
||||
struct hblk * h;
|
||||
word total_free = 0;
|
||||
hdr * hhdr;
|
||||
word sz;
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= N_HBLK_FLS; ++i) {
|
||||
h = GC_hblkfreelist[i];
|
||||
# ifdef USE_MUNMAP
|
||||
if (0 != h) GC_printf1("Free list %ld (Total size %ld):\n",
|
||||
(unsigned long)i);
|
||||
# else
|
||||
if (0 != h) GC_printf2("Free list %ld (Total size %ld):\n",
|
||||
(unsigned long)i,
|
||||
(unsigned long)GC_free_bytes[i]);
|
||||
# endif
|
||||
while (h != 0) {
|
||||
hhdr = HDR(h);
|
||||
sz = hhdr -> hb_sz;
|
||||
GC_printf2("\t0x%lx size %lu ", (unsigned long)h, (unsigned long)sz);
|
||||
total_free += sz;
|
||||
if (GC_is_black_listed(h, HBLKSIZE) != 0) {
|
||||
GC_printf0("start black listed\n");
|
||||
} else if (GC_is_black_listed(h, hhdr -> hb_sz) != 0) {
|
||||
GC_printf0("partially black listed\n");
|
||||
} else {
|
||||
GC_printf0("not black listed\n");
|
||||
}
|
||||
h = hhdr -> hb_next;
|
||||
}
|
||||
}
|
||||
if (total_free != GC_large_free_bytes) {
|
||||
GC_printf1("GC_large_free_bytes = %lu (INCONSISTENT!!)\n",
|
||||
(unsigned long) GC_large_free_bytes);
|
||||
}
|
||||
GC_printf1("Total of %lu bytes on free list\n", (unsigned long)total_free);
|
||||
}
|
||||
|
||||
/* Return the free list index on which the block described by the header */
|
||||
/* appears, or -1 if it appears nowhere. */
|
||||
int free_list_index_of(wanted)
|
||||
hdr * wanted;
|
||||
{
|
||||
struct hblk * h;
|
||||
hdr * hhdr;
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= N_HBLK_FLS; ++i) {
|
||||
h = GC_hblkfreelist[i];
|
||||
while (h != 0) {
|
||||
hhdr = HDR(h);
|
||||
if (hhdr == wanted) return i;
|
||||
h = hhdr -> hb_next;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
void GC_dump_regions()
|
||||
{
|
||||
unsigned i;
|
||||
ptr_t start, end;
|
||||
ptr_t p;
|
||||
size_t bytes;
|
||||
hdr *hhdr;
|
||||
for (i = 0; i < GC_n_heap_sects; ++i) {
|
||||
start = GC_heap_sects[i].hs_start;
|
||||
bytes = GC_heap_sects[i].hs_bytes;
|
||||
end = start + bytes;
|
||||
/* Merge in contiguous sections. */
|
||||
while (i+1 < GC_n_heap_sects && GC_heap_sects[i+1].hs_start == end) {
|
||||
++i;
|
||||
end = GC_heap_sects[i].hs_start + GC_heap_sects[i].hs_bytes;
|
||||
}
|
||||
GC_printf2("***Section from 0x%lx to 0x%lx\n", start, end);
|
||||
for (p = start; p < end;) {
|
||||
hhdr = HDR(p);
|
||||
GC_printf1("\t0x%lx ", (unsigned long)p);
|
||||
if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
|
||||
GC_printf1("Missing header!!\n", hhdr);
|
||||
p += HBLKSIZE;
|
||||
continue;
|
||||
}
|
||||
if (HBLK_IS_FREE(hhdr)) {
|
||||
int correct_index = GC_hblk_fl_from_blocks(
|
||||
divHBLKSZ(hhdr -> hb_sz));
|
||||
int actual_index;
|
||||
|
||||
GC_printf1("\tfree block of size 0x%lx bytes",
|
||||
(unsigned long)(hhdr -> hb_sz));
|
||||
if (IS_MAPPED(hhdr)) {
|
||||
GC_printf0("\n");
|
||||
} else {
|
||||
GC_printf0("(unmapped)\n");
|
||||
}
|
||||
actual_index = free_list_index_of(hhdr);
|
||||
if (-1 == actual_index) {
|
||||
GC_printf1("\t\tBlock not on free list %ld!!\n",
|
||||
correct_index);
|
||||
} else if (correct_index != actual_index) {
|
||||
GC_printf2("\t\tBlock on list %ld, should be on %ld!!\n",
|
||||
actual_index, correct_index);
|
||||
}
|
||||
p += hhdr -> hb_sz;
|
||||
} else {
|
||||
GC_printf1("\tused for blocks of size 0x%lx bytes\n",
|
||||
(unsigned long)WORDS_TO_BYTES(hhdr -> hb_sz));
|
||||
p += HBLKSIZE * OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
# endif /* NO_DEBUGGING */
|
||||
|
||||
/* Initialize hdr for a block containing the indicated size and */
|
||||
/* kind of objects. */
|
||||
/* Return FALSE on failure. */
|
||||
static GC_bool setup_header(hhdr, sz, kind, flags)
|
||||
register hdr * hhdr;
|
||||
word sz; /* object size in words */
|
||||
int kind;
|
||||
unsigned char flags;
|
||||
{
|
||||
register word descr;
|
||||
|
||||
/* Add description of valid object pointers */
|
||||
if (!GC_add_map_entry(sz)) return(FALSE);
|
||||
hhdr -> hb_map = GC_obj_map[sz > MAXOBJSZ? 0 : sz];
|
||||
|
||||
/* Set size, kind and mark proc fields */
|
||||
hhdr -> hb_sz = sz;
|
||||
hhdr -> hb_obj_kind = kind;
|
||||
hhdr -> hb_flags = flags;
|
||||
descr = GC_obj_kinds[kind].ok_descriptor;
|
||||
if (GC_obj_kinds[kind].ok_relocate_descr) descr += WORDS_TO_BYTES(sz);
|
||||
hhdr -> hb_descr = descr;
|
||||
|
||||
/* Clear mark bits */
|
||||
GC_clear_hdr_marks(hhdr);
|
||||
|
||||
hhdr -> hb_last_reclaimed = (unsigned short)GC_gc_no;
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
#define FL_UNKNOWN -1
|
||||
/*
|
||||
* Remove hhdr from the appropriate free list.
|
||||
* We assume it is on the nth free list, or on the size
|
||||
* appropriate free list if n is FL_UNKNOWN.
|
||||
*/
|
||||
void GC_remove_from_fl(hhdr, n)
|
||||
hdr * hhdr;
|
||||
int n;
|
||||
{
|
||||
int index;
|
||||
|
||||
GC_ASSERT(((hhdr -> hb_sz) & (HBLKSIZE-1)) == 0);
|
||||
# ifndef USE_MUNMAP
|
||||
/* We always need index to mainatin free counts. */
|
||||
if (FL_UNKNOWN == n) {
|
||||
index = GC_hblk_fl_from_blocks(divHBLKSZ(hhdr -> hb_sz));
|
||||
} else {
|
||||
index = n;
|
||||
}
|
||||
# endif
|
||||
if (hhdr -> hb_prev == 0) {
|
||||
# ifdef USE_MUNMAP
|
||||
if (FL_UNKNOWN == n) {
|
||||
index = GC_hblk_fl_from_blocks(divHBLKSZ(hhdr -> hb_sz));
|
||||
} else {
|
||||
index = n;
|
||||
}
|
||||
# endif
|
||||
GC_ASSERT(HDR(GC_hblkfreelist[index]) == hhdr);
|
||||
GC_hblkfreelist[index] = hhdr -> hb_next;
|
||||
} else {
|
||||
hdr *phdr;
|
||||
GET_HDR(hhdr -> hb_prev, phdr);
|
||||
phdr -> hb_next = hhdr -> hb_next;
|
||||
}
|
||||
INCR_FREE_BYTES(index, - (signed_word)(hhdr -> hb_sz));
|
||||
FREE_ASSERT(GC_free_bytes[index] >= 0);
|
||||
if (0 != hhdr -> hb_next) {
|
||||
hdr * nhdr;
|
||||
GC_ASSERT(!IS_FORWARDING_ADDR_OR_NIL(NHDR(hhdr)));
|
||||
GET_HDR(hhdr -> hb_next, nhdr);
|
||||
nhdr -> hb_prev = hhdr -> hb_prev;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Return a pointer to the free block ending just before h, if any.
|
||||
*/
|
||||
struct hblk * GC_free_block_ending_at(h)
|
||||
struct hblk *h;
|
||||
{
|
||||
struct hblk * p = h - 1;
|
||||
hdr * phdr;
|
||||
|
||||
GET_HDR(p, phdr);
|
||||
while (0 != phdr && IS_FORWARDING_ADDR_OR_NIL(phdr)) {
|
||||
p = FORWARDED_ADDR(p,phdr);
|
||||
phdr = HDR(p);
|
||||
}
|
||||
if (0 != phdr) {
|
||||
if(HBLK_IS_FREE(phdr)) {
|
||||
return p;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
p = GC_prev_block(h - 1);
|
||||
if (0 != p) {
|
||||
phdr = HDR(p);
|
||||
if (HBLK_IS_FREE(phdr) && (ptr_t)p + phdr -> hb_sz == (ptr_t)h) {
|
||||
return p;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Add hhdr to the appropriate free list.
|
||||
* We maintain individual free lists sorted by address.
|
||||
*/
|
||||
void GC_add_to_fl(h, hhdr)
|
||||
struct hblk *h;
|
||||
hdr * hhdr;
|
||||
{
|
||||
int index = GC_hblk_fl_from_blocks(divHBLKSZ(hhdr -> hb_sz));
|
||||
struct hblk *second = GC_hblkfreelist[index];
|
||||
hdr * second_hdr;
|
||||
# ifdef GC_ASSERTIONS
|
||||
struct hblk *next = (struct hblk *)((word)h + hhdr -> hb_sz);
|
||||
hdr * nexthdr = HDR(next);
|
||||
struct hblk *prev = GC_free_block_ending_at(h);
|
||||
hdr * prevhdr = HDR(prev);
|
||||
GC_ASSERT(nexthdr == 0 || !HBLK_IS_FREE(nexthdr) || !IS_MAPPED(nexthdr));
|
||||
GC_ASSERT(prev == 0 || !HBLK_IS_FREE(prevhdr) || !IS_MAPPED(prevhdr));
|
||||
# endif
|
||||
GC_ASSERT(((hhdr -> hb_sz) & (HBLKSIZE-1)) == 0);
|
||||
GC_hblkfreelist[index] = h;
|
||||
INCR_FREE_BYTES(index, hhdr -> hb_sz);
|
||||
FREE_ASSERT(GC_free_bytes[index] <= GC_large_free_bytes)
|
||||
hhdr -> hb_next = second;
|
||||
hhdr -> hb_prev = 0;
|
||||
if (0 != second) {
|
||||
GET_HDR(second, second_hdr);
|
||||
second_hdr -> hb_prev = h;
|
||||
}
|
||||
GC_invalidate_map(hhdr);
|
||||
}
|
||||
|
||||
#ifdef USE_MUNMAP
|
||||
|
||||
/* Unmap blocks that haven't been recently touched. This is the only way */
|
||||
/* way blocks are ever unmapped. */
|
||||
void GC_unmap_old(void)
|
||||
{
|
||||
struct hblk * h;
|
||||
hdr * hhdr;
|
||||
word sz;
|
||||
unsigned short last_rec, threshold;
|
||||
int i;
|
||||
# define UNMAP_THRESHOLD 6
|
||||
|
||||
for (i = 0; i <= N_HBLK_FLS; ++i) {
|
||||
for (h = GC_hblkfreelist[i]; 0 != h; h = hhdr -> hb_next) {
|
||||
hhdr = HDR(h);
|
||||
if (!IS_MAPPED(hhdr)) continue;
|
||||
threshold = (unsigned short)(GC_gc_no - UNMAP_THRESHOLD);
|
||||
last_rec = hhdr -> hb_last_reclaimed;
|
||||
if (last_rec > GC_gc_no
|
||||
|| last_rec < threshold && threshold < GC_gc_no
|
||||
/* not recently wrapped */) {
|
||||
sz = hhdr -> hb_sz;
|
||||
GC_unmap((ptr_t)h, sz);
|
||||
hhdr -> hb_flags |= WAS_UNMAPPED;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Merge all unmapped blocks that are adjacent to other free */
|
||||
/* blocks. This may involve remapping, since all blocks are either */
|
||||
/* fully mapped or fully unmapped. */
|
||||
void GC_merge_unmapped(void)
|
||||
{
|
||||
struct hblk * h, *next;
|
||||
hdr * hhdr, *nexthdr;
|
||||
word size, nextsize;
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= N_HBLK_FLS; ++i) {
|
||||
h = GC_hblkfreelist[i];
|
||||
while (h != 0) {
|
||||
GET_HDR(h, hhdr);
|
||||
size = hhdr->hb_sz;
|
||||
next = (struct hblk *)((word)h + size);
|
||||
GET_HDR(next, nexthdr);
|
||||
/* Coalesce with successor, if possible */
|
||||
if (0 != nexthdr && HBLK_IS_FREE(nexthdr)) {
|
||||
nextsize = nexthdr -> hb_sz;
|
||||
if (IS_MAPPED(hhdr)) {
|
||||
GC_ASSERT(!IS_MAPPED(nexthdr));
|
||||
/* make both consistent, so that we can merge */
|
||||
if (size > nextsize) {
|
||||
GC_remap((ptr_t)next, nextsize);
|
||||
} else {
|
||||
GC_unmap((ptr_t)h, size);
|
||||
hhdr -> hb_flags |= WAS_UNMAPPED;
|
||||
}
|
||||
} else if (IS_MAPPED(nexthdr)) {
|
||||
GC_ASSERT(!IS_MAPPED(hhdr));
|
||||
if (size > nextsize) {
|
||||
GC_unmap((ptr_t)next, nextsize);
|
||||
} else {
|
||||
GC_remap((ptr_t)h, size);
|
||||
hhdr -> hb_flags &= ~WAS_UNMAPPED;
|
||||
}
|
||||
} else {
|
||||
/* Unmap any gap in the middle */
|
||||
GC_unmap_gap((ptr_t)h, size, (ptr_t)next, nexthdr -> hb_sz);
|
||||
}
|
||||
/* If they are both unmapped, we merge, but leave unmapped. */
|
||||
GC_remove_from_fl(hhdr, i);
|
||||
GC_remove_from_fl(nexthdr, FL_UNKNOWN);
|
||||
hhdr -> hb_sz += nexthdr -> hb_sz;
|
||||
GC_remove_header(next);
|
||||
GC_add_to_fl(h, hhdr);
|
||||
/* Start over at beginning of list */
|
||||
h = GC_hblkfreelist[i];
|
||||
} else /* not mergable with successor */ {
|
||||
h = hhdr -> hb_next;
|
||||
}
|
||||
} /* while (h != 0) ... */
|
||||
} /* for ... */
|
||||
}
|
||||
|
||||
#endif /* USE_MUNMAP */
|
||||
|
||||
/*
|
||||
* Return a pointer to a block starting at h of length bytes.
|
||||
* Memory for the block is mapped.
|
||||
* Remove the block from its free list, and return the remainder (if any)
|
||||
* to its appropriate free list.
|
||||
* May fail by returning 0.
|
||||
* The header for the returned block must be set up by the caller.
|
||||
* If the return value is not 0, then hhdr is the header for it.
|
||||
*/
|
||||
struct hblk * GC_get_first_part(h, hhdr, bytes, index)
|
||||
struct hblk *h;
|
||||
hdr * hhdr;
|
||||
word bytes;
|
||||
int index;
|
||||
{
|
||||
word total_size = hhdr -> hb_sz;
|
||||
struct hblk * rest;
|
||||
hdr * rest_hdr;
|
||||
|
||||
GC_ASSERT((total_size & (HBLKSIZE-1)) == 0);
|
||||
GC_remove_from_fl(hhdr, index);
|
||||
if (total_size == bytes) return h;
|
||||
rest = (struct hblk *)((word)h + bytes);
|
||||
rest_hdr = GC_install_header(rest);
|
||||
if (0 == rest_hdr) return(0);
|
||||
rest_hdr -> hb_sz = total_size - bytes;
|
||||
rest_hdr -> hb_flags = 0;
|
||||
# ifdef GC_ASSERTIONS
|
||||
/* Mark h not free, to avoid assertion about adjacent free blocks. */
|
||||
hhdr -> hb_map = 0;
|
||||
# endif
|
||||
GC_add_to_fl(rest, rest_hdr);
|
||||
return h;
|
||||
}
|
||||
|
||||
/*
|
||||
* H is a free block. N points at an address inside it.
|
||||
* A new header for n has already been set up. Fix up h's header
|
||||
* to reflect the fact that it is being split, move it to the
|
||||
* appropriate free list.
|
||||
* N replaces h in the original free list.
|
||||
*
|
||||
* Nhdr is not completely filled in, since it is about to allocated.
|
||||
* It may in fact end up on the wrong free list for its size.
|
||||
* (Hence adding it to a free list is silly. But this path is hopefully
|
||||
* rare enough that it doesn't matter. The code is cleaner this way.)
|
||||
*/
|
||||
void GC_split_block(h, hhdr, n, nhdr, index)
|
||||
struct hblk *h;
|
||||
hdr * hhdr;
|
||||
struct hblk *n;
|
||||
hdr * nhdr;
|
||||
int index; /* Index of free list */
|
||||
{
|
||||
word total_size = hhdr -> hb_sz;
|
||||
word h_size = (word)n - (word)h;
|
||||
struct hblk *prev = hhdr -> hb_prev;
|
||||
struct hblk *next = hhdr -> hb_next;
|
||||
|
||||
/* Replace h with n on its freelist */
|
||||
nhdr -> hb_prev = prev;
|
||||
nhdr -> hb_next = next;
|
||||
nhdr -> hb_sz = total_size - h_size;
|
||||
nhdr -> hb_flags = 0;
|
||||
if (0 != prev) {
|
||||
HDR(prev) -> hb_next = n;
|
||||
} else {
|
||||
GC_hblkfreelist[index] = n;
|
||||
}
|
||||
if (0 != next) {
|
||||
HDR(next) -> hb_prev = n;
|
||||
}
|
||||
INCR_FREE_BYTES(index, -(signed_word)h_size);
|
||||
FREE_ASSERT(GC_free_bytes[index] > 0);
|
||||
# ifdef GC_ASSERTIONS
|
||||
nhdr -> hb_map = 0; /* Don't fail test for consecutive */
|
||||
/* free blocks in GC_add_to_fl. */
|
||||
# endif
|
||||
# ifdef USE_MUNMAP
|
||||
hhdr -> hb_last_reclaimed = GC_gc_no;
|
||||
# endif
|
||||
hhdr -> hb_sz = h_size;
|
||||
GC_add_to_fl(h, hhdr);
|
||||
GC_invalidate_map(nhdr);
|
||||
}
|
||||
|
||||
struct hblk * GC_allochblk_nth();
|
||||
|
||||
/*
|
||||
* Allocate (and return pointer to) a heap block
|
||||
* for objects of size sz words, searching the nth free list.
|
||||
*
|
||||
* NOTE: We set obj_map field in header correctly.
|
||||
* Caller is responsible for building an object freelist in block.
|
||||
*
|
||||
* Unlike older versions of the collectors, the client is responsible
|
||||
* for clearing the block, if necessary.
|
||||
*/
|
||||
struct hblk *
|
||||
GC_allochblk(sz, kind, flags)
|
||||
word sz;
|
||||
int kind;
|
||||
unsigned flags; /* IGNORE_OFF_PAGE or 0 */
|
||||
{
|
||||
word blocks = OBJ_SZ_TO_BLOCKS(sz);
|
||||
int start_list = GC_hblk_fl_from_blocks(blocks);
|
||||
int i;
|
||||
for (i = start_list; i <= N_HBLK_FLS; ++i) {
|
||||
struct hblk * result = GC_allochblk_nth(sz, kind, flags, i);
|
||||
if (0 != result) {
|
||||
return result;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
/*
|
||||
* The same, but with search restricted to nth free list.
|
||||
*/
|
||||
struct hblk *
|
||||
GC_allochblk_nth(sz, kind, flags, n)
|
||||
word sz;
|
||||
int kind;
|
||||
unsigned char flags; /* IGNORE_OFF_PAGE or 0 */
|
||||
int n;
|
||||
{
|
||||
register struct hblk *hbp;
|
||||
register hdr * hhdr; /* Header corr. to hbp */
|
||||
register struct hblk *thishbp;
|
||||
register hdr * thishdr; /* Header corr. to hbp */
|
||||
signed_word size_needed; /* number of bytes in requested objects */
|
||||
signed_word size_avail; /* bytes available in this block */
|
||||
|
||||
size_needed = HBLKSIZE * OBJ_SZ_TO_BLOCKS(sz);
|
||||
|
||||
/* search for a big enough block in free list */
|
||||
hbp = GC_hblkfreelist[n];
|
||||
for(; 0 != hbp; hbp = hhdr -> hb_next) {
|
||||
GET_HDR(hbp, hhdr);
|
||||
size_avail = hhdr->hb_sz;
|
||||
if (size_avail < size_needed) continue;
|
||||
if (!GC_use_entire_heap
|
||||
&& size_avail != size_needed
|
||||
&& USED_HEAP_SIZE >= GC_requested_heapsize
|
||||
&& !GC_incremental && GC_should_collect()) {
|
||||
# ifdef USE_MUNMAP
|
||||
continue;
|
||||
# else
|
||||
/* If we enough large blocks left to cover any */
|
||||
/* previous request for large blocks, we go ahead */
|
||||
/* and split. Assuming a steady state, that should */
|
||||
/* be safe. It means that we can use the full */
|
||||
/* heap if we allocate only small objects. */
|
||||
if (!GC_enough_large_bytes_left(GC_large_allocd_bytes, n)) {
|
||||
continue;
|
||||
}
|
||||
# endif /* !USE_MUNMAP */
|
||||
}
|
||||
/* If the next heap block is obviously better, go on. */
|
||||
/* This prevents us from disassembling a single large block */
|
||||
/* to get tiny blocks. */
|
||||
{
|
||||
signed_word next_size;
|
||||
|
||||
thishbp = hhdr -> hb_next;
|
||||
if (thishbp != 0) {
|
||||
GET_HDR(thishbp, thishdr);
|
||||
next_size = (signed_word)(thishdr -> hb_sz);
|
||||
if (next_size < size_avail
|
||||
&& next_size >= size_needed
|
||||
&& !GC_is_black_listed(thishbp, (word)size_needed)) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
if ( !IS_UNCOLLECTABLE(kind) &&
|
||||
(kind != PTRFREE || size_needed > MAX_BLACK_LIST_ALLOC)) {
|
||||
struct hblk * lasthbp = hbp;
|
||||
ptr_t search_end = (ptr_t)hbp + size_avail - size_needed;
|
||||
signed_word orig_avail = size_avail;
|
||||
signed_word eff_size_needed = ((flags & IGNORE_OFF_PAGE)?
|
||||
HBLKSIZE
|
||||
: size_needed);
|
||||
|
||||
|
||||
while ((ptr_t)lasthbp <= search_end
|
||||
&& (thishbp = GC_is_black_listed(lasthbp,
|
||||
(word)eff_size_needed))
|
||||
!= 0) {
|
||||
lasthbp = thishbp;
|
||||
}
|
||||
size_avail -= (ptr_t)lasthbp - (ptr_t)hbp;
|
||||
thishbp = lasthbp;
|
||||
if (size_avail >= size_needed) {
|
||||
if (thishbp != hbp &&
|
||||
0 != (thishdr = GC_install_header(thishbp))) {
|
||||
/* Make sure it's mapped before we mangle it. */
|
||||
# ifdef USE_MUNMAP
|
||||
if (!IS_MAPPED(hhdr)) {
|
||||
GC_remap((ptr_t)hbp, hhdr -> hb_sz);
|
||||
hhdr -> hb_flags &= ~WAS_UNMAPPED;
|
||||
}
|
||||
# endif
|
||||
/* Split the block at thishbp */
|
||||
GC_split_block(hbp, hhdr, thishbp, thishdr, n);
|
||||
/* Advance to thishbp */
|
||||
hbp = thishbp;
|
||||
hhdr = thishdr;
|
||||
/* We must now allocate thishbp, since it may */
|
||||
/* be on the wrong free list. */
|
||||
}
|
||||
} else if (size_needed > (signed_word)BL_LIMIT
|
||||
&& orig_avail - size_needed
|
||||
> (signed_word)BL_LIMIT) {
|
||||
/* Punt, since anything else risks unreasonable heap growth. */
|
||||
if (0 == GETENV("GC_NO_BLACKLIST_WARNING")) {
|
||||
WARN("Needed to allocate blacklisted block at 0x%lx\n",
|
||||
(word)hbp);
|
||||
}
|
||||
size_avail = orig_avail;
|
||||
} else if (size_avail == 0 && size_needed == HBLKSIZE
|
||||
&& IS_MAPPED(hhdr)) {
|
||||
if (!GC_find_leak) {
|
||||
static unsigned count = 0;
|
||||
|
||||
/* The block is completely blacklisted. We need */
|
||||
/* to drop some such blocks, since otherwise we spend */
|
||||
/* all our time traversing them if pointerfree */
|
||||
/* blocks are unpopular. */
|
||||
/* A dropped block will be reconsidered at next GC. */
|
||||
if ((++count & 3) == 0) {
|
||||
/* Allocate and drop the block in small chunks, to */
|
||||
/* maximize the chance that we will recover some */
|
||||
/* later. */
|
||||
word total_size = hhdr -> hb_sz;
|
||||
struct hblk * limit = hbp + divHBLKSZ(total_size);
|
||||
struct hblk * h;
|
||||
struct hblk * prev = hhdr -> hb_prev;
|
||||
|
||||
GC_words_wasted += total_size;
|
||||
GC_large_free_bytes -= total_size;
|
||||
GC_remove_from_fl(hhdr, n);
|
||||
for (h = hbp; h < limit; h++) {
|
||||
if (h == hbp || 0 != (hhdr = GC_install_header(h))) {
|
||||
(void) setup_header(
|
||||
hhdr,
|
||||
BYTES_TO_WORDS(HBLKSIZE),
|
||||
PTRFREE, 0); /* Cant fail */
|
||||
if (GC_debugging_started) {
|
||||
BZERO(h, HBLKSIZE);
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Restore hbp to point at free block */
|
||||
hbp = prev;
|
||||
if (0 == hbp) {
|
||||
return GC_allochblk_nth(sz, kind, flags, n);
|
||||
}
|
||||
hhdr = HDR(hbp);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if( size_avail >= size_needed ) {
|
||||
# ifdef USE_MUNMAP
|
||||
if (!IS_MAPPED(hhdr)) {
|
||||
GC_remap((ptr_t)hbp, hhdr -> hb_sz);
|
||||
hhdr -> hb_flags &= ~WAS_UNMAPPED;
|
||||
}
|
||||
# endif
|
||||
/* hbp may be on the wrong freelist; the parameter n */
|
||||
/* is important. */
|
||||
hbp = GC_get_first_part(hbp, hhdr, size_needed, n);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (0 == hbp) return 0;
|
||||
|
||||
/* Notify virtual dirty bit implementation that we are about to write. */
|
||||
GC_write_hint(hbp);
|
||||
|
||||
/* Add it to map of valid blocks */
|
||||
if (!GC_install_counts(hbp, (word)size_needed)) return(0);
|
||||
/* This leaks memory under very rare conditions. */
|
||||
|
||||
/* Set up header */
|
||||
if (!setup_header(hhdr, sz, kind, flags)) {
|
||||
GC_remove_counts(hbp, (word)size_needed);
|
||||
return(0); /* ditto */
|
||||
}
|
||||
|
||||
/* We just successfully allocated a block. Restart count of */
|
||||
/* consecutive failures. */
|
||||
{
|
||||
extern unsigned GC_fail_count;
|
||||
|
||||
GC_fail_count = 0;
|
||||
}
|
||||
|
||||
GC_large_free_bytes -= size_needed;
|
||||
|
||||
GC_ASSERT(IS_MAPPED(hhdr));
|
||||
return( hbp );
|
||||
}
|
||||
|
||||
struct hblk * GC_freehblk_ptr = 0; /* Search position hint for GC_freehblk */
|
||||
|
||||
/*
|
||||
* Free a heap block.
|
||||
*
|
||||
* Coalesce the block with its neighbors if possible.
|
||||
*
|
||||
* All mark words are assumed to be cleared.
|
||||
*/
|
||||
void
|
||||
GC_freehblk(hbp)
|
||||
struct hblk *hbp;
|
||||
{
|
||||
struct hblk *next, *prev;
|
||||
hdr *hhdr, *prevhdr, *nexthdr;
|
||||
signed_word size;
|
||||
|
||||
|
||||
GET_HDR(hbp, hhdr);
|
||||
size = hhdr->hb_sz;
|
||||
size = HBLKSIZE * OBJ_SZ_TO_BLOCKS(size);
|
||||
GC_remove_counts(hbp, (word)size);
|
||||
hhdr->hb_sz = size;
|
||||
|
||||
/* Check for duplicate deallocation in the easy case */
|
||||
if (HBLK_IS_FREE(hhdr)) {
|
||||
GC_printf1("Duplicate large block deallocation of 0x%lx\n",
|
||||
(unsigned long) hbp);
|
||||
ABORT("Duplicate large block deallocation");
|
||||
}
|
||||
|
||||
GC_ASSERT(IS_MAPPED(hhdr));
|
||||
GC_invalidate_map(hhdr);
|
||||
next = (struct hblk *)((word)hbp + size);
|
||||
GET_HDR(next, nexthdr);
|
||||
prev = GC_free_block_ending_at(hbp);
|
||||
/* Coalesce with successor, if possible */
|
||||
if(0 != nexthdr && HBLK_IS_FREE(nexthdr) && IS_MAPPED(nexthdr)) {
|
||||
GC_remove_from_fl(nexthdr, FL_UNKNOWN);
|
||||
hhdr -> hb_sz += nexthdr -> hb_sz;
|
||||
GC_remove_header(next);
|
||||
}
|
||||
/* Coalesce with predecessor, if possible. */
|
||||
if (0 != prev) {
|
||||
prevhdr = HDR(prev);
|
||||
if (IS_MAPPED(prevhdr)) {
|
||||
GC_remove_from_fl(prevhdr, FL_UNKNOWN);
|
||||
prevhdr -> hb_sz += hhdr -> hb_sz;
|
||||
GC_remove_header(hbp);
|
||||
hbp = prev;
|
||||
hhdr = prevhdr;
|
||||
}
|
||||
}
|
||||
|
||||
GC_large_free_bytes += size;
|
||||
GC_add_to_fl(hbp, hhdr);
|
||||
}
|
||||
|
||||
995
boehm-gc/alloc.c
995
boehm-gc/alloc.c
@@ -1,995 +0,0 @@
|
||||
/*
|
||||
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
|
||||
* Copyright (c) 1991-1996 by Xerox Corporation. All rights reserved.
|
||||
* Copyright (c) 1998 by Silicon Graphics. All rights reserved.
|
||||
* Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
# include "private/gc_priv.h"
|
||||
|
||||
# include <stdio.h>
|
||||
# if !defined(MACOS) && !defined(MSWINCE)
|
||||
# include <signal.h>
|
||||
# include <sys/types.h>
|
||||
# endif
|
||||
|
||||
/*
|
||||
* Separate free lists are maintained for different sized objects
|
||||
* up to MAXOBJSZ.
|
||||
* The call GC_allocobj(i,k) ensures that the freelist for
|
||||
* kind k objects of size i points to a non-empty
|
||||
* free list. It returns a pointer to the first entry on the free list.
|
||||
* In a single-threaded world, GC_allocobj may be called to allocate
|
||||
* an object of (small) size i as follows:
|
||||
*
|
||||
* opp = &(GC_objfreelist[i]);
|
||||
* if (*opp == 0) GC_allocobj(i, NORMAL);
|
||||
* ptr = *opp;
|
||||
* *opp = obj_link(ptr);
|
||||
*
|
||||
* Note that this is very fast if the free list is non-empty; it should
|
||||
* only involve the execution of 4 or 5 simple instructions.
|
||||
* All composite objects on freelists are cleared, except for
|
||||
* their first word.
|
||||
*/
|
||||
|
||||
/*
|
||||
* The allocator uses GC_allochblk to allocate large chunks of objects.
|
||||
* These chunks all start on addresses which are multiples of
|
||||
* HBLKSZ. Each allocated chunk has an associated header,
|
||||
* which can be located quickly based on the address of the chunk.
|
||||
* (See headers.c for details.)
|
||||
* This makes it possible to check quickly whether an
|
||||
* arbitrary address corresponds to an object administered by the
|
||||
* allocator.
|
||||
*/
|
||||
|
||||
word GC_non_gc_bytes = 0; /* Number of bytes not intended to be collected */
|
||||
|
||||
word GC_gc_no = 0;
|
||||
|
||||
#ifndef SMALL_CONFIG
|
||||
int GC_incremental = 0; /* By default, stop the world. */
|
||||
#endif
|
||||
|
||||
int GC_parallel = FALSE; /* By default, parallel GC is off. */
|
||||
|
||||
int GC_full_freq = 19; /* Every 20th collection is a full */
|
||||
/* collection, whether we need it */
|
||||
/* or not. */
|
||||
|
||||
GC_bool GC_need_full_gc = FALSE;
|
||||
/* Need full GC do to heap growth. */
|
||||
|
||||
word GC_used_heap_size_after_full = 0;
|
||||
|
||||
char * GC_copyright[] =
|
||||
{"Copyright 1988,1989 Hans-J. Boehm and Alan J. Demers ",
|
||||
"Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. ",
|
||||
"Copyright (c) 1996-1998 by Silicon Graphics. All rights reserved. ",
|
||||
"Copyright (c) 1999-2000 by Hewlett-Packard Company. All rights reserved. ",
|
||||
"THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY",
|
||||
" EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK.",
|
||||
"See source code for details." };
|
||||
|
||||
# include "version.h"
|
||||
|
||||
/* some more variables */
|
||||
|
||||
extern signed_word GC_mem_found; /* Number of reclaimed longwords */
|
||||
/* after garbage collection */
|
||||
|
||||
GC_bool GC_dont_expand = 0;
|
||||
|
||||
word GC_free_space_divisor = 3;
|
||||
|
||||
extern GC_bool GC_collection_in_progress();
|
||||
/* Collection is in progress, or was abandoned. */
|
||||
|
||||
int GC_never_stop_func GC_PROTO((void)) { return(0); }
|
||||
|
||||
CLOCK_TYPE GC_start_time; /* Time at which we stopped world. */
|
||||
/* used only in GC_timeout_stop_func. */
|
||||
|
||||
int GC_n_attempts = 0; /* Number of attempts at finishing */
|
||||
/* collection within TIME_LIMIT */
|
||||
|
||||
#if defined(SMALL_CONFIG) || defined(NO_CLOCK)
|
||||
# define GC_timeout_stop_func GC_never_stop_func
|
||||
#else
|
||||
int GC_timeout_stop_func GC_PROTO((void))
|
||||
{
|
||||
CLOCK_TYPE current_time;
|
||||
static unsigned count = 0;
|
||||
unsigned long time_diff;
|
||||
|
||||
if ((count++ & 3) != 0) return(0);
|
||||
#ifndef NO_CLOCK
|
||||
GET_TIME(current_time);
|
||||
time_diff = MS_TIME_DIFF(current_time,GC_start_time);
|
||||
if (time_diff >= TIME_LIMIT) {
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf0("Abandoning stopped marking after ");
|
||||
GC_printf1("%lu msecs", (unsigned long)time_diff);
|
||||
GC_printf1("(attempt %d)\n", (unsigned long) GC_n_attempts);
|
||||
}
|
||||
# endif
|
||||
return(1);
|
||||
}
|
||||
#endif
|
||||
return(0);
|
||||
}
|
||||
#endif /* !SMALL_CONFIG */
|
||||
|
||||
/* Return the minimum number of words that must be allocated between */
|
||||
/* collections to amortize the collection cost. */
|
||||
static word min_words_allocd()
|
||||
{
|
||||
# ifdef THREADS
|
||||
/* We punt, for now. */
|
||||
register signed_word stack_size = 10000;
|
||||
# else
|
||||
int dummy;
|
||||
register signed_word stack_size = (ptr_t)(&dummy) - GC_stackbottom;
|
||||
# endif
|
||||
word total_root_size; /* includes double stack size, */
|
||||
/* since the stack is expensive */
|
||||
/* to scan. */
|
||||
word scan_size; /* Estimate of memory to be scanned */
|
||||
/* during normal GC. */
|
||||
|
||||
if (stack_size < 0) stack_size = -stack_size;
|
||||
total_root_size = 2 * stack_size + GC_root_size;
|
||||
scan_size = BYTES_TO_WORDS(GC_heapsize - GC_large_free_bytes
|
||||
+ (GC_large_free_bytes >> 2)
|
||||
/* use a bit more of large empty heap */
|
||||
+ total_root_size);
|
||||
if (GC_incremental) {
|
||||
return scan_size / (2 * GC_free_space_divisor);
|
||||
} else {
|
||||
return scan_size / GC_free_space_divisor;
|
||||
}
|
||||
}
|
||||
|
||||
/* Return the number of words allocated, adjusted for explicit storage */
|
||||
/* management, etc.. This number is used in deciding when to trigger */
|
||||
/* collections. */
|
||||
word GC_adj_words_allocd()
|
||||
{
|
||||
register signed_word result;
|
||||
register signed_word expl_managed =
|
||||
BYTES_TO_WORDS((long)GC_non_gc_bytes
|
||||
- (long)GC_non_gc_bytes_at_gc);
|
||||
|
||||
/* Don't count what was explicitly freed, or newly allocated for */
|
||||
/* explicit management. Note that deallocating an explicitly */
|
||||
/* managed object should not alter result, assuming the client */
|
||||
/* is playing by the rules. */
|
||||
result = (signed_word)GC_words_allocd
|
||||
- (signed_word)GC_mem_freed - expl_managed;
|
||||
if (result > (signed_word)GC_words_allocd) {
|
||||
result = GC_words_allocd;
|
||||
/* probably client bug or unfortunate scheduling */
|
||||
}
|
||||
result += GC_words_finalized;
|
||||
/* We count objects enqueued for finalization as though they */
|
||||
/* had been reallocated this round. Finalization is user */
|
||||
/* visible progress. And if we don't count this, we have */
|
||||
/* stability problems for programs that finalize all objects. */
|
||||
result += GC_words_wasted;
|
||||
/* This doesn't reflect useful work. But if there is lots of */
|
||||
/* new fragmentation, the same is probably true of the heap, */
|
||||
/* and the collection will be correspondingly cheaper. */
|
||||
if (result < (signed_word)(GC_words_allocd >> 3)) {
|
||||
/* Always count at least 1/8 of the allocations. We don't want */
|
||||
/* to collect too infrequently, since that would inhibit */
|
||||
/* coalescing of free storage blocks. */
|
||||
/* This also makes us partially robust against client bugs. */
|
||||
return(GC_words_allocd >> 3);
|
||||
} else {
|
||||
return(result);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Clear up a few frames worth of garbage left at the top of the stack. */
|
||||
/* This is used to prevent us from accidentally treating garbade left */
|
||||
/* on the stack by other parts of the collector as roots. This */
|
||||
/* differs from the code in misc.c, which actually tries to keep the */
|
||||
/* stack clear of long-lived, client-generated garbage. */
|
||||
void GC_clear_a_few_frames()
|
||||
{
|
||||
# define NWORDS 64
|
||||
word frames[NWORDS];
|
||||
register int i;
|
||||
|
||||
for (i = 0; i < NWORDS; i++) frames[i] = 0;
|
||||
}
|
||||
|
||||
/* Have we allocated enough to amortize a collection? */
|
||||
GC_bool GC_should_collect()
|
||||
{
|
||||
return(GC_adj_words_allocd() >= min_words_allocd());
|
||||
}
|
||||
|
||||
|
||||
void GC_notify_full_gc()
|
||||
{
|
||||
if (GC_start_call_back != (void (*) GC_PROTO((void)))0) {
|
||||
(*GC_start_call_back)();
|
||||
}
|
||||
}
|
||||
|
||||
GC_bool GC_is_full_gc = FALSE;
|
||||
|
||||
/*
|
||||
* Initiate a garbage collection if appropriate.
|
||||
* Choose judiciously
|
||||
* between partial, full, and stop-world collections.
|
||||
* Assumes lock held, signals disabled.
|
||||
*/
|
||||
void GC_maybe_gc()
|
||||
{
|
||||
static int n_partial_gcs = 0;
|
||||
|
||||
if (GC_should_collect()) {
|
||||
if (!GC_incremental) {
|
||||
GC_notify_full_gc();
|
||||
GC_gcollect_inner();
|
||||
n_partial_gcs = 0;
|
||||
return;
|
||||
} else {
|
||||
# ifdef PARALLEL_MARK
|
||||
GC_wait_for_reclaim();
|
||||
# endif
|
||||
if (GC_need_full_gc || n_partial_gcs >= GC_full_freq) {
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf2(
|
||||
"***>Full mark for collection %lu after %ld allocd bytes\n",
|
||||
(unsigned long) GC_gc_no+1,
|
||||
(long)WORDS_TO_BYTES(GC_words_allocd));
|
||||
}
|
||||
# endif
|
||||
GC_promote_black_lists();
|
||||
(void)GC_reclaim_all((GC_stop_func)0, TRUE);
|
||||
GC_clear_marks();
|
||||
n_partial_gcs = 0;
|
||||
GC_notify_full_gc();
|
||||
GC_is_full_gc = TRUE;
|
||||
} else {
|
||||
n_partial_gcs++;
|
||||
}
|
||||
}
|
||||
/* We try to mark with the world stopped. */
|
||||
/* If we run out of time, this turns into */
|
||||
/* incremental marking. */
|
||||
# ifndef NO_CLOCK
|
||||
GET_TIME(GC_start_time);
|
||||
# endif
|
||||
if (GC_stopped_mark(GC_timeout_stop_func)) {
|
||||
# ifdef SAVE_CALL_CHAIN
|
||||
GC_save_callers(GC_last_stack);
|
||||
# endif
|
||||
GC_finish_collection();
|
||||
} else {
|
||||
if (!GC_is_full_gc) {
|
||||
/* Count this as the first attempt */
|
||||
GC_n_attempts++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Stop the world garbage collection. Assumes lock held, signals disabled.
|
||||
* If stop_func is not GC_never_stop_func, then abort if stop_func returns TRUE.
|
||||
*/
|
||||
GC_bool GC_try_to_collect_inner(stop_func)
|
||||
GC_stop_func stop_func;
|
||||
{
|
||||
if (GC_incremental && GC_collection_in_progress()) {
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf0(
|
||||
"GC_try_to_collect_inner: finishing collection in progress\n");
|
||||
}
|
||||
# endif /* CONDPRINT */
|
||||
/* Just finish collection already in progress. */
|
||||
while(GC_collection_in_progress()) {
|
||||
if (stop_func()) return(FALSE);
|
||||
GC_collect_a_little_inner(1);
|
||||
}
|
||||
}
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf2(
|
||||
"Initiating full world-stop collection %lu after %ld allocd bytes\n",
|
||||
(unsigned long) GC_gc_no+1,
|
||||
(long)WORDS_TO_BYTES(GC_words_allocd));
|
||||
}
|
||||
# endif
|
||||
GC_promote_black_lists();
|
||||
/* Make sure all blocks have been reclaimed, so sweep routines */
|
||||
/* don't see cleared mark bits. */
|
||||
/* If we're guaranteed to finish, then this is unnecessary. */
|
||||
/* In the find_leak case, we have to finish to guarantee that */
|
||||
/* previously unmarked objects are not reported as leaks. */
|
||||
# ifdef PARALLEL_MARK
|
||||
GC_wait_for_reclaim();
|
||||
# endif
|
||||
if ((GC_find_leak || stop_func != GC_never_stop_func)
|
||||
&& !GC_reclaim_all(stop_func, FALSE)) {
|
||||
/* Aborted. So far everything is still consistent. */
|
||||
return(FALSE);
|
||||
}
|
||||
GC_invalidate_mark_state(); /* Flush mark stack. */
|
||||
GC_clear_marks();
|
||||
# ifdef SAVE_CALL_CHAIN
|
||||
GC_save_callers(GC_last_stack);
|
||||
# endif
|
||||
GC_is_full_gc = TRUE;
|
||||
if (!GC_stopped_mark(stop_func)) {
|
||||
if (!GC_incremental) {
|
||||
/* We're partially done and have no way to complete or use */
|
||||
/* current work. Reestablish invariants as cheaply as */
|
||||
/* possible. */
|
||||
GC_invalidate_mark_state();
|
||||
GC_unpromote_black_lists();
|
||||
} /* else we claim the world is already still consistent. We'll */
|
||||
/* finish incrementally. */
|
||||
return(FALSE);
|
||||
}
|
||||
GC_finish_collection();
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Perform n units of garbage collection work. A unit is intended to touch
|
||||
* roughly GC_RATE pages. Every once in a while, we do more than that.
|
||||
* This needa to be a fairly large number with our current incremental
|
||||
* GC strategy, since otherwise we allocate too much during GC, and the
|
||||
* cleanup gets expensive.
|
||||
*/
|
||||
# define GC_RATE 10
|
||||
# define MAX_PRIOR_ATTEMPTS 1
|
||||
/* Maximum number of prior attempts at world stop marking */
|
||||
/* A value of 1 means that we finish the second time, no matter */
|
||||
/* how long it takes. Doesn't count the initial root scan */
|
||||
/* for a full GC. */
|
||||
|
||||
int GC_deficit = 0; /* The number of extra calls to GC_mark_some */
|
||||
/* that we have made. */
|
||||
|
||||
void GC_collect_a_little_inner(n)
|
||||
int n;
|
||||
{
|
||||
register int i;
|
||||
|
||||
if (GC_incremental && GC_collection_in_progress()) {
|
||||
for (i = GC_deficit; i < GC_RATE*n; i++) {
|
||||
if (GC_mark_some((ptr_t)0)) {
|
||||
/* Need to finish a collection */
|
||||
# ifdef SAVE_CALL_CHAIN
|
||||
GC_save_callers(GC_last_stack);
|
||||
# endif
|
||||
# ifdef PARALLEL_MARK
|
||||
GC_wait_for_reclaim();
|
||||
# endif
|
||||
if (GC_n_attempts < MAX_PRIOR_ATTEMPTS) {
|
||||
GET_TIME(GC_start_time);
|
||||
if (!GC_stopped_mark(GC_timeout_stop_func)) {
|
||||
GC_n_attempts++;
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
(void)GC_stopped_mark(GC_never_stop_func);
|
||||
}
|
||||
GC_finish_collection();
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (GC_deficit > 0) GC_deficit -= GC_RATE*n;
|
||||
if (GC_deficit < 0) GC_deficit = 0;
|
||||
} else {
|
||||
GC_maybe_gc();
|
||||
}
|
||||
}
|
||||
|
||||
int GC_collect_a_little GC_PROTO(())
|
||||
{
|
||||
int result;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
GC_collect_a_little_inner(1);
|
||||
result = (int)GC_collection_in_progress();
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
return(result);
|
||||
}
|
||||
|
||||
/*
|
||||
* Assumes lock is held, signals are disabled.
|
||||
* We stop the world.
|
||||
* If stop_func() ever returns TRUE, we may fail and return FALSE.
|
||||
* Increment GC_gc_no if we succeed.
|
||||
*/
|
||||
GC_bool GC_stopped_mark(stop_func)
|
||||
GC_stop_func stop_func;
|
||||
{
|
||||
register int i;
|
||||
int dummy;
|
||||
# ifdef PRINTTIMES
|
||||
CLOCK_TYPE start_time, current_time;
|
||||
# endif
|
||||
|
||||
STOP_WORLD();
|
||||
# ifdef PRINTTIMES
|
||||
GET_TIME(start_time);
|
||||
# endif
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf1("--> Marking for collection %lu ",
|
||||
(unsigned long) GC_gc_no + 1);
|
||||
GC_printf2("after %lu allocd bytes + %lu wasted bytes\n",
|
||||
(unsigned long) WORDS_TO_BYTES(GC_words_allocd),
|
||||
(unsigned long) WORDS_TO_BYTES(GC_words_wasted));
|
||||
}
|
||||
# endif
|
||||
|
||||
/* Mark from all roots. */
|
||||
/* Minimize junk left in my registers and on the stack */
|
||||
GC_clear_a_few_frames();
|
||||
GC_noop(0,0,0,0,0,0);
|
||||
GC_initiate_gc();
|
||||
for(i = 0;;i++) {
|
||||
if ((*stop_func)()) {
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf0("Abandoned stopped marking after ");
|
||||
GC_printf1("%lu iterations\n",
|
||||
(unsigned long)i);
|
||||
}
|
||||
# endif
|
||||
GC_deficit = i; /* Give the mutator a chance. */
|
||||
START_WORLD();
|
||||
return(FALSE);
|
||||
}
|
||||
if (GC_mark_some((ptr_t)(&dummy))) break;
|
||||
}
|
||||
|
||||
GC_gc_no++;
|
||||
# ifdef PRINTSTATS
|
||||
GC_printf2("Collection %lu reclaimed %ld bytes",
|
||||
(unsigned long) GC_gc_no - 1,
|
||||
(long)WORDS_TO_BYTES(GC_mem_found));
|
||||
# else
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf1("Collection %lu finished", (unsigned long) GC_gc_no - 1);
|
||||
}
|
||||
# endif
|
||||
# endif /* !PRINTSTATS */
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf1(" ---> heapsize = %lu bytes\n",
|
||||
(unsigned long) GC_heapsize);
|
||||
/* Printf arguments may be pushed in funny places. Clear the */
|
||||
/* space. */
|
||||
GC_printf0("");
|
||||
}
|
||||
# endif /* CONDPRINT */
|
||||
|
||||
/* Check all debugged objects for consistency */
|
||||
if (GC_debugging_started) {
|
||||
(*GC_check_heap)();
|
||||
}
|
||||
|
||||
# ifdef PRINTTIMES
|
||||
GET_TIME(current_time);
|
||||
GC_printf1("World-stopped marking took %lu msecs\n",
|
||||
MS_TIME_DIFF(current_time,start_time));
|
||||
# endif
|
||||
START_WORLD();
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/* Set all mark bits for the free list whose first entry is q */
|
||||
#ifdef __STDC__
|
||||
void GC_set_fl_marks(ptr_t q)
|
||||
#else
|
||||
void GC_set_fl_marks(q)
|
||||
ptr_t q;
|
||||
#endif
|
||||
{
|
||||
ptr_t p;
|
||||
struct hblk * h, * last_h = 0;
|
||||
hdr *hhdr;
|
||||
int word_no;
|
||||
|
||||
for (p = q; p != 0; p = obj_link(p)){
|
||||
h = HBLKPTR(p);
|
||||
if (h != last_h) {
|
||||
last_h = h;
|
||||
hhdr = HDR(h);
|
||||
}
|
||||
word_no = (((word *)p) - ((word *)h));
|
||||
set_mark_bit_from_hdr(hhdr, word_no);
|
||||
}
|
||||
}
|
||||
|
||||
/* Clear all mark bits for the free list whose first entry is q */
|
||||
/* Decrement GC_mem_found by number of words on free list. */
|
||||
#ifdef __STDC__
|
||||
void GC_clear_fl_marks(ptr_t q)
|
||||
#else
|
||||
void GC_clear_fl_marks(q)
|
||||
ptr_t q;
|
||||
#endif
|
||||
{
|
||||
ptr_t p;
|
||||
struct hblk * h, * last_h = 0;
|
||||
hdr *hhdr;
|
||||
int word_no;
|
||||
|
||||
for (p = q; p != 0; p = obj_link(p)){
|
||||
h = HBLKPTR(p);
|
||||
if (h != last_h) {
|
||||
last_h = h;
|
||||
hhdr = HDR(h);
|
||||
}
|
||||
word_no = (((word *)p) - ((word *)h));
|
||||
clear_mark_bit_from_hdr(hhdr, word_no);
|
||||
# ifdef GATHERSTATS
|
||||
GC_mem_found -= hhdr -> hb_sz;
|
||||
# endif
|
||||
}
|
||||
}
|
||||
|
||||
/* Finish up a collection. Assumes lock is held, signals are disabled, */
|
||||
/* but the world is otherwise running. */
|
||||
void GC_finish_collection()
|
||||
{
|
||||
# ifdef PRINTTIMES
|
||||
CLOCK_TYPE start_time;
|
||||
CLOCK_TYPE finalize_time;
|
||||
CLOCK_TYPE done_time;
|
||||
|
||||
GET_TIME(start_time);
|
||||
finalize_time = start_time;
|
||||
# endif
|
||||
|
||||
# ifdef GATHERSTATS
|
||||
GC_mem_found = 0;
|
||||
# endif
|
||||
# if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG)
|
||||
if (getenv("GC_PRINT_ADDRESS_MAP") != 0) {
|
||||
GC_print_address_map();
|
||||
}
|
||||
# endif
|
||||
if (GC_find_leak) {
|
||||
/* Mark all objects on the free list. All objects should be */
|
||||
/* marked when we're done. */
|
||||
{
|
||||
register word size; /* current object size */
|
||||
int kind;
|
||||
ptr_t q;
|
||||
|
||||
for (kind = 0; kind < GC_n_kinds; kind++) {
|
||||
for (size = 1; size <= MAXOBJSZ; size++) {
|
||||
q = GC_obj_kinds[kind].ok_freelist[size];
|
||||
if (q != 0) GC_set_fl_marks(q);
|
||||
}
|
||||
}
|
||||
}
|
||||
GC_start_reclaim(TRUE);
|
||||
/* The above just checks; it doesn't really reclaim anything. */
|
||||
}
|
||||
|
||||
GC_finalize();
|
||||
# ifdef STUBBORN_ALLOC
|
||||
GC_clean_changing_list();
|
||||
# endif
|
||||
|
||||
# ifdef PRINTTIMES
|
||||
GET_TIME(finalize_time);
|
||||
# endif
|
||||
|
||||
/* Clear free list mark bits, in case they got accidentally marked */
|
||||
/* (or GC_find_leak is set and they were intentionally marked). */
|
||||
/* Also subtract memory remaining from GC_mem_found count. */
|
||||
/* Note that composite objects on free list are cleared. */
|
||||
/* Thus accidentally marking a free list is not a problem; only */
|
||||
/* objects on the list itself will be marked, and that's fixed here. */
|
||||
{
|
||||
register word size; /* current object size */
|
||||
register ptr_t q; /* pointer to current object */
|
||||
int kind;
|
||||
|
||||
for (kind = 0; kind < GC_n_kinds; kind++) {
|
||||
for (size = 1; size <= MAXOBJSZ; size++) {
|
||||
q = GC_obj_kinds[kind].ok_freelist[size];
|
||||
if (q != 0) GC_clear_fl_marks(q);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
# ifdef PRINTSTATS
|
||||
GC_printf1("Bytes recovered before sweep - f.l. count = %ld\n",
|
||||
(long)WORDS_TO_BYTES(GC_mem_found));
|
||||
# endif
|
||||
/* Reconstruct free lists to contain everything not marked */
|
||||
GC_start_reclaim(FALSE);
|
||||
if (GC_is_full_gc) {
|
||||
GC_used_heap_size_after_full = USED_HEAP_SIZE;
|
||||
GC_need_full_gc = FALSE;
|
||||
} else {
|
||||
GC_need_full_gc =
|
||||
BYTES_TO_WORDS(USED_HEAP_SIZE - GC_used_heap_size_after_full)
|
||||
> min_words_allocd();
|
||||
}
|
||||
|
||||
# ifdef PRINTSTATS
|
||||
GC_printf2(
|
||||
"Immediately reclaimed %ld bytes in heap of size %lu bytes",
|
||||
(long)WORDS_TO_BYTES(GC_mem_found),
|
||||
(unsigned long)GC_heapsize);
|
||||
# ifdef USE_MUNMAP
|
||||
GC_printf1("(%lu unmapped)", GC_unmapped_bytes);
|
||||
# endif
|
||||
GC_printf2(
|
||||
"\n%lu (atomic) + %lu (composite) collectable bytes in use\n",
|
||||
(unsigned long)WORDS_TO_BYTES(GC_atomic_in_use),
|
||||
(unsigned long)WORDS_TO_BYTES(GC_composite_in_use));
|
||||
# endif
|
||||
|
||||
GC_n_attempts = 0;
|
||||
GC_is_full_gc = FALSE;
|
||||
/* Reset or increment counters for next cycle */
|
||||
GC_words_allocd_before_gc += GC_words_allocd;
|
||||
GC_non_gc_bytes_at_gc = GC_non_gc_bytes;
|
||||
GC_words_allocd = 0;
|
||||
GC_words_wasted = 0;
|
||||
GC_mem_freed = 0;
|
||||
|
||||
# ifdef USE_MUNMAP
|
||||
GC_unmap_old();
|
||||
# endif
|
||||
# ifdef PRINTTIMES
|
||||
GET_TIME(done_time);
|
||||
GC_printf2("Finalize + initiate sweep took %lu + %lu msecs\n",
|
||||
MS_TIME_DIFF(finalize_time,start_time),
|
||||
MS_TIME_DIFF(done_time,finalize_time));
|
||||
# endif
|
||||
}
|
||||
|
||||
/* Externally callable routine to invoke full, stop-world collection */
|
||||
# if defined(__STDC__) || defined(__cplusplus)
|
||||
int GC_try_to_collect(GC_stop_func stop_func)
|
||||
# else
|
||||
int GC_try_to_collect(stop_func)
|
||||
GC_stop_func stop_func;
|
||||
# endif
|
||||
{
|
||||
int result;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
GC_INVOKE_FINALIZERS();
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
ENTER_GC();
|
||||
if (!GC_is_initialized) GC_init_inner();
|
||||
/* Minimize junk left in my registers */
|
||||
GC_noop(0,0,0,0,0,0);
|
||||
result = (int)GC_try_to_collect_inner(stop_func);
|
||||
EXIT_GC();
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
if(result) GC_INVOKE_FINALIZERS();
|
||||
return(result);
|
||||
}
|
||||
|
||||
void GC_gcollect GC_PROTO(())
|
||||
{
|
||||
GC_notify_full_gc();
|
||||
(void)GC_try_to_collect(GC_never_stop_func);
|
||||
}
|
||||
|
||||
word GC_n_heap_sects = 0; /* Number of sections currently in heap. */
|
||||
|
||||
/*
|
||||
* Use the chunk of memory starting at p of size bytes as part of the heap.
|
||||
* Assumes p is HBLKSIZE aligned, and bytes is a multiple of HBLKSIZE.
|
||||
*/
|
||||
void GC_add_to_heap(p, bytes)
|
||||
struct hblk *p;
|
||||
word bytes;
|
||||
{
|
||||
word words;
|
||||
hdr * phdr;
|
||||
|
||||
if (GC_n_heap_sects >= MAX_HEAP_SECTS) {
|
||||
ABORT("Too many heap sections: Increase MAXHINCR or MAX_HEAP_SECTS");
|
||||
}
|
||||
phdr = GC_install_header(p);
|
||||
if (0 == phdr) {
|
||||
/* This is extremely unlikely. Can't add it. This will */
|
||||
/* almost certainly result in a 0 return from the allocator, */
|
||||
/* which is entirely appropriate. */
|
||||
return;
|
||||
}
|
||||
GC_heap_sects[GC_n_heap_sects].hs_start = (ptr_t)p;
|
||||
GC_heap_sects[GC_n_heap_sects].hs_bytes = bytes;
|
||||
GC_n_heap_sects++;
|
||||
words = BYTES_TO_WORDS(bytes);
|
||||
phdr -> hb_sz = words;
|
||||
phdr -> hb_map = (unsigned char *)1; /* A value != GC_invalid_map */
|
||||
phdr -> hb_flags = 0;
|
||||
GC_freehblk(p);
|
||||
GC_heapsize += bytes;
|
||||
if ((ptr_t)p <= (ptr_t)GC_least_plausible_heap_addr
|
||||
|| GC_least_plausible_heap_addr == 0) {
|
||||
GC_least_plausible_heap_addr = (GC_PTR)((ptr_t)p - sizeof(word));
|
||||
/* Making it a little smaller than necessary prevents */
|
||||
/* us from getting a false hit from the variable */
|
||||
/* itself. There's some unintentional reflection */
|
||||
/* here. */
|
||||
}
|
||||
if ((ptr_t)p + bytes >= (ptr_t)GC_greatest_plausible_heap_addr) {
|
||||
GC_greatest_plausible_heap_addr = (GC_PTR)((ptr_t)p + bytes);
|
||||
}
|
||||
}
|
||||
|
||||
# if !defined(NO_DEBUGGING)
|
||||
void GC_print_heap_sects()
|
||||
{
|
||||
register unsigned i;
|
||||
|
||||
GC_printf1("Total heap size: %lu\n", (unsigned long) GC_heapsize);
|
||||
for (i = 0; i < GC_n_heap_sects; i++) {
|
||||
unsigned long start = (unsigned long) GC_heap_sects[i].hs_start;
|
||||
unsigned long len = (unsigned long) GC_heap_sects[i].hs_bytes;
|
||||
struct hblk *h;
|
||||
unsigned nbl = 0;
|
||||
|
||||
GC_printf3("Section %ld from 0x%lx to 0x%lx ", (unsigned long)i,
|
||||
start, (unsigned long)(start + len));
|
||||
for (h = (struct hblk *)start; h < (struct hblk *)(start + len); h++) {
|
||||
if (GC_is_black_listed(h, HBLKSIZE)) nbl++;
|
||||
}
|
||||
GC_printf2("%lu/%lu blacklisted\n", (unsigned long)nbl,
|
||||
(unsigned long)(len/HBLKSIZE));
|
||||
}
|
||||
}
|
||||
# endif
|
||||
|
||||
GC_PTR GC_least_plausible_heap_addr = (GC_PTR)ONES;
|
||||
GC_PTR GC_greatest_plausible_heap_addr = 0;
|
||||
|
||||
ptr_t GC_max(x,y)
|
||||
ptr_t x, y;
|
||||
{
|
||||
return(x > y? x : y);
|
||||
}
|
||||
|
||||
ptr_t GC_min(x,y)
|
||||
ptr_t x, y;
|
||||
{
|
||||
return(x < y? x : y);
|
||||
}
|
||||
|
||||
# if defined(__STDC__) || defined(__cplusplus)
|
||||
void GC_set_max_heap_size(GC_word n)
|
||||
# else
|
||||
void GC_set_max_heap_size(n)
|
||||
GC_word n;
|
||||
# endif
|
||||
{
|
||||
GC_max_heapsize = n;
|
||||
}
|
||||
|
||||
GC_word GC_max_retries = 0;
|
||||
|
||||
/*
|
||||
* this explicitly increases the size of the heap. It is used
|
||||
* internally, but may also be invoked from GC_expand_hp by the user.
|
||||
* The argument is in units of HBLKSIZE.
|
||||
* Tiny values of n are rounded up.
|
||||
* Returns FALSE on failure.
|
||||
*/
|
||||
GC_bool GC_expand_hp_inner(n)
|
||||
word n;
|
||||
{
|
||||
word bytes;
|
||||
struct hblk * space;
|
||||
word expansion_slop; /* Number of bytes by which we expect the */
|
||||
/* heap to expand soon. */
|
||||
|
||||
if (n < MINHINCR) n = MINHINCR;
|
||||
bytes = n * HBLKSIZE;
|
||||
/* Make sure bytes is a multiple of GC_page_size */
|
||||
{
|
||||
word mask = GC_page_size - 1;
|
||||
bytes += mask;
|
||||
bytes &= ~mask;
|
||||
}
|
||||
|
||||
if (GC_max_heapsize != 0 && GC_heapsize + bytes > GC_max_heapsize) {
|
||||
/* Exceeded self-imposed limit */
|
||||
return(FALSE);
|
||||
}
|
||||
space = GET_MEM(bytes);
|
||||
if( space == 0 ) {
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf1("Failed to expand heap by %ld bytes\n",
|
||||
(unsigned long)bytes);
|
||||
}
|
||||
# endif
|
||||
return(FALSE);
|
||||
}
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf2("Increasing heap size by %lu after %lu allocated bytes\n",
|
||||
(unsigned long)bytes,
|
||||
(unsigned long)WORDS_TO_BYTES(GC_words_allocd));
|
||||
# ifdef UNDEFINED
|
||||
GC_printf1("Root size = %lu\n", GC_root_size);
|
||||
GC_print_block_list(); GC_print_hblkfreelist();
|
||||
GC_printf0("\n");
|
||||
# endif
|
||||
}
|
||||
# endif
|
||||
expansion_slop = 8 * WORDS_TO_BYTES(min_words_allocd());
|
||||
if (5 * HBLKSIZE * MAXHINCR > expansion_slop) {
|
||||
expansion_slop = 5 * HBLKSIZE * MAXHINCR;
|
||||
}
|
||||
if (GC_last_heap_addr == 0 && !((word)space & SIGNB)
|
||||
|| GC_last_heap_addr != 0 && GC_last_heap_addr < (ptr_t)space) {
|
||||
/* Assume the heap is growing up */
|
||||
GC_greatest_plausible_heap_addr =
|
||||
GC_max(GC_greatest_plausible_heap_addr,
|
||||
(ptr_t)space + bytes + expansion_slop);
|
||||
} else {
|
||||
/* Heap is growing down */
|
||||
GC_least_plausible_heap_addr =
|
||||
GC_min(GC_least_plausible_heap_addr,
|
||||
(ptr_t)space - expansion_slop);
|
||||
}
|
||||
GC_prev_heap_addr = GC_last_heap_addr;
|
||||
GC_last_heap_addr = (ptr_t)space;
|
||||
GC_add_to_heap(space, bytes);
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/* Really returns a bool, but it's externally visible, so that's clumsy. */
|
||||
/* Arguments is in bytes. */
|
||||
# if defined(__STDC__) || defined(__cplusplus)
|
||||
int GC_expand_hp(size_t bytes)
|
||||
# else
|
||||
int GC_expand_hp(bytes)
|
||||
size_t bytes;
|
||||
# endif
|
||||
{
|
||||
int result;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
if (!GC_is_initialized) GC_init_inner();
|
||||
result = (int)GC_expand_hp_inner(divHBLKSZ((word)bytes));
|
||||
if (result) GC_requested_heapsize += bytes;
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
return(result);
|
||||
}
|
||||
|
||||
unsigned GC_fail_count = 0;
|
||||
/* How many consecutive GC/expansion failures? */
|
||||
/* Reset by GC_allochblk. */
|
||||
|
||||
GC_bool GC_collect_or_expand(needed_blocks, ignore_off_page)
|
||||
word needed_blocks;
|
||||
GC_bool ignore_off_page;
|
||||
{
|
||||
if (!GC_incremental && !GC_dont_gc &&
|
||||
(GC_dont_expand && GC_words_allocd > 0 || GC_should_collect())) {
|
||||
GC_notify_full_gc();
|
||||
GC_gcollect_inner();
|
||||
} else {
|
||||
word blocks_to_get = GC_heapsize/(HBLKSIZE*GC_free_space_divisor)
|
||||
+ needed_blocks;
|
||||
|
||||
if (blocks_to_get > MAXHINCR) {
|
||||
word slop;
|
||||
|
||||
if (ignore_off_page) {
|
||||
slop = 4;
|
||||
} else {
|
||||
slop = 2*divHBLKSZ(BL_LIMIT);
|
||||
if (slop > needed_blocks) slop = needed_blocks;
|
||||
}
|
||||
if (needed_blocks + slop > MAXHINCR) {
|
||||
blocks_to_get = needed_blocks + slop;
|
||||
} else {
|
||||
blocks_to_get = MAXHINCR;
|
||||
}
|
||||
}
|
||||
if (!GC_expand_hp_inner(blocks_to_get)
|
||||
&& !GC_expand_hp_inner(needed_blocks)) {
|
||||
if (GC_fail_count++ < GC_max_retries) {
|
||||
WARN("Out of Memory! Trying to continue ...\n", 0);
|
||||
GC_notify_full_gc();
|
||||
GC_gcollect_inner();
|
||||
} else {
|
||||
# if !defined(AMIGA) || !defined(GC_AMIGA_FASTALLOC)
|
||||
WARN("Out of Memory! Returning NIL!\n", 0);
|
||||
# endif
|
||||
return(FALSE);
|
||||
}
|
||||
} else {
|
||||
# ifdef CONDPRINT
|
||||
if (GC_fail_count && GC_print_stats) {
|
||||
GC_printf0("Memory available again ...\n");
|
||||
}
|
||||
# endif
|
||||
}
|
||||
}
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Make sure the object free list for sz is not empty.
|
||||
* Return a pointer to the first object on the free list.
|
||||
* The object MUST BE REMOVED FROM THE FREE LIST BY THE CALLER.
|
||||
* Assumes we hold the allocator lock and signals are disabled.
|
||||
*
|
||||
*/
|
||||
ptr_t GC_allocobj(sz, kind)
|
||||
word sz;
|
||||
int kind;
|
||||
{
|
||||
register ptr_t * flh = &(GC_obj_kinds[kind].ok_freelist[sz]);
|
||||
|
||||
if (sz == 0) return(0);
|
||||
|
||||
while (*flh == 0) {
|
||||
ENTER_GC();
|
||||
/* Do our share of marking work */
|
||||
if(GC_incremental && !GC_dont_gc) GC_collect_a_little_inner(1);
|
||||
/* Sweep blocks for objects of this size */
|
||||
GC_continue_reclaim(sz, kind);
|
||||
EXIT_GC();
|
||||
if (*flh == 0) {
|
||||
GC_new_hblk(sz, kind);
|
||||
}
|
||||
if (*flh == 0) {
|
||||
ENTER_GC();
|
||||
if (!GC_collect_or_expand((word)1,FALSE)) {
|
||||
EXIT_GC();
|
||||
return(0);
|
||||
}
|
||||
EXIT_GC();
|
||||
}
|
||||
}
|
||||
|
||||
return(*flh);
|
||||
}
|
||||
@@ -1,86 +0,0 @@
|
||||
.arch ev6
|
||||
|
||||
.text
|
||||
.align 4
|
||||
.globl GC_push_regs
|
||||
.ent GC_push_regs 2
|
||||
GC_push_regs:
|
||||
ldgp $gp, 0($27)
|
||||
lda $sp, -16($sp)
|
||||
stq $26, 0($sp)
|
||||
.mask 0x04000000, 0
|
||||
.frame $sp, 16, $26, 0
|
||||
|
||||
# $0 integer result
|
||||
# $1-$8 temp regs - not preserved cross calls
|
||||
# $9-$15 call saved regs
|
||||
# $16-$21 argument regs - not preserved cross calls
|
||||
# $22-$28 temp regs - not preserved cross calls
|
||||
# $29 global pointer - not preserved cross calls
|
||||
# $30 stack pointer
|
||||
|
||||
# define call_push(x) \
|
||||
mov x, $16; \
|
||||
jsr $26, GC_push_one; \
|
||||
ldgp $gp, 0($26)
|
||||
|
||||
call_push($9)
|
||||
call_push($10)
|
||||
call_push($11)
|
||||
call_push($12)
|
||||
call_push($13)
|
||||
call_push($14)
|
||||
call_push($15)
|
||||
|
||||
# $f0-$f1 floating point results
|
||||
# $f2-$f9 call saved regs
|
||||
# $f10-$f30 temp regs - not preserved cross calls
|
||||
|
||||
# Use the most efficient transfer method for this hardware.
|
||||
# Bit 1 detects the FIX extension, which includes ftoit.
|
||||
amask 2, $0
|
||||
bne $0, $use_stack
|
||||
|
||||
#undef call_push
|
||||
#define call_push(x) \
|
||||
ftoit x, $16; \
|
||||
jsr $26, GC_push_one; \
|
||||
ldgp $gp, 0($26)
|
||||
|
||||
call_push($f2)
|
||||
call_push($f3)
|
||||
call_push($f4)
|
||||
call_push($f5)
|
||||
call_push($f6)
|
||||
call_push($f7)
|
||||
call_push($f8)
|
||||
call_push($f9)
|
||||
|
||||
ldq $26, 0($sp)
|
||||
lda $sp, 16($sp)
|
||||
ret $31, ($26), 1
|
||||
|
||||
.align 4
|
||||
$use_stack:
|
||||
|
||||
#undef call_push
|
||||
#define call_push(x) \
|
||||
stt x, 8($sp); \
|
||||
ldq $16, 8($sp); \
|
||||
jsr $26, GC_push_one; \
|
||||
ldgp $gp, 0($26)
|
||||
|
||||
call_push($f2)
|
||||
call_push($f3)
|
||||
call_push($f4)
|
||||
call_push($f5)
|
||||
call_push($f6)
|
||||
call_push($f7)
|
||||
call_push($f8)
|
||||
call_push($f9)
|
||||
|
||||
ldq $26, 0($sp)
|
||||
lda $sp, 16($sp)
|
||||
ret $31, ($26), 1
|
||||
|
||||
.end GC_push_regs
|
||||
@@ -1,300 +0,0 @@
|
||||
/*
|
||||
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
|
||||
* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
/* Boehm, August 9, 1995 6:09 pm PDT */
|
||||
# include "private/gc_priv.h"
|
||||
|
||||
/*
|
||||
* We maintain several hash tables of hblks that have had false hits.
|
||||
* Each contains one bit per hash bucket; If any page in the bucket
|
||||
* has had a false hit, we assume that all of them have.
|
||||
* See the definition of page_hash_table in gc_private.h.
|
||||
* False hits from the stack(s) are much more dangerous than false hits
|
||||
* from elsewhere, since the former can pin a large object that spans the
|
||||
* block, eventhough it does not start on the dangerous block.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Externally callable routines are:
|
||||
|
||||
* GC_add_to_black_list_normal
|
||||
* GC_add_to_black_list_stack
|
||||
* GC_promote_black_lists
|
||||
* GC_is_black_listed
|
||||
*
|
||||
* All require that the allocator lock is held.
|
||||
*/
|
||||
|
||||
/* Pointers to individual tables. We replace one table by another by */
|
||||
/* switching these pointers. */
|
||||
word * GC_old_normal_bl;
|
||||
/* Nonstack false references seen at last full */
|
||||
/* collection. */
|
||||
word * GC_incomplete_normal_bl;
|
||||
/* Nonstack false references seen since last */
|
||||
/* full collection. */
|
||||
word * GC_old_stack_bl;
|
||||
word * GC_incomplete_stack_bl;
|
||||
|
||||
word GC_total_stack_black_listed;
|
||||
|
||||
word GC_black_list_spacing = MINHINCR*HBLKSIZE; /* Initial rough guess */
|
||||
|
||||
void GC_clear_bl();
|
||||
|
||||
# if defined(__STDC__) || defined(__cplusplus)
|
||||
void GC_default_print_heap_obj_proc(ptr_t p)
|
||||
# else
|
||||
void GC_default_print_heap_obj_proc(p)
|
||||
ptr_t p;
|
||||
# endif
|
||||
{
|
||||
ptr_t base = GC_base(p);
|
||||
|
||||
GC_err_printf2("start: 0x%lx, appr. length: %ld", base, GC_size(base));
|
||||
}
|
||||
|
||||
void (*GC_print_heap_obj) GC_PROTO((ptr_t p)) =
|
||||
GC_default_print_heap_obj_proc;
|
||||
|
||||
void GC_print_source_ptr(p)
|
||||
ptr_t p;
|
||||
{
|
||||
ptr_t base = GC_base(p);
|
||||
if (0 == base) {
|
||||
if (0 == p) {
|
||||
GC_err_printf0("in register");
|
||||
} else {
|
||||
GC_err_printf0("in root set");
|
||||
}
|
||||
} else {
|
||||
GC_err_printf0("in object at ");
|
||||
(*GC_print_heap_obj)(base);
|
||||
}
|
||||
}
|
||||
|
||||
void GC_bl_init()
|
||||
{
|
||||
if (!GC_all_interior_pointers) {
|
||||
GC_old_normal_bl = (word *)
|
||||
GC_scratch_alloc((word)(sizeof (page_hash_table)));
|
||||
GC_incomplete_normal_bl = (word *)GC_scratch_alloc
|
||||
((word)(sizeof(page_hash_table)));
|
||||
if (GC_old_normal_bl == 0 || GC_incomplete_normal_bl == 0) {
|
||||
GC_err_printf0("Insufficient memory for black list\n");
|
||||
EXIT();
|
||||
}
|
||||
GC_clear_bl(GC_old_normal_bl);
|
||||
GC_clear_bl(GC_incomplete_normal_bl);
|
||||
}
|
||||
GC_old_stack_bl = (word *)GC_scratch_alloc((word)(sizeof(page_hash_table)));
|
||||
GC_incomplete_stack_bl = (word *)GC_scratch_alloc
|
||||
((word)(sizeof(page_hash_table)));
|
||||
if (GC_old_stack_bl == 0 || GC_incomplete_stack_bl == 0) {
|
||||
GC_err_printf0("Insufficient memory for black list\n");
|
||||
EXIT();
|
||||
}
|
||||
GC_clear_bl(GC_old_stack_bl);
|
||||
GC_clear_bl(GC_incomplete_stack_bl);
|
||||
}
|
||||
|
||||
void GC_clear_bl(doomed)
|
||||
word *doomed;
|
||||
{
|
||||
BZERO(doomed, sizeof(page_hash_table));
|
||||
}
|
||||
|
||||
void GC_copy_bl(old, new)
|
||||
word *new, *old;
|
||||
{
|
||||
BCOPY(old, new, sizeof(page_hash_table));
|
||||
}
|
||||
|
||||
static word total_stack_black_listed();
|
||||
|
||||
/* Signal the completion of a collection. Turn the incomplete black */
|
||||
/* lists into new black lists, etc. */
|
||||
void GC_promote_black_lists()
|
||||
{
|
||||
word * very_old_normal_bl = GC_old_normal_bl;
|
||||
word * very_old_stack_bl = GC_old_stack_bl;
|
||||
|
||||
GC_old_normal_bl = GC_incomplete_normal_bl;
|
||||
GC_old_stack_bl = GC_incomplete_stack_bl;
|
||||
if (!GC_all_interior_pointers) {
|
||||
GC_clear_bl(very_old_normal_bl);
|
||||
}
|
||||
GC_clear_bl(very_old_stack_bl);
|
||||
GC_incomplete_normal_bl = very_old_normal_bl;
|
||||
GC_incomplete_stack_bl = very_old_stack_bl;
|
||||
GC_total_stack_black_listed = total_stack_black_listed();
|
||||
# ifdef PRINTSTATS
|
||||
GC_printf1("%ld bytes in heap blacklisted for interior pointers\n",
|
||||
(unsigned long)GC_total_stack_black_listed);
|
||||
# endif
|
||||
if (GC_total_stack_black_listed != 0) {
|
||||
GC_black_list_spacing =
|
||||
HBLKSIZE*(GC_heapsize/GC_total_stack_black_listed);
|
||||
}
|
||||
if (GC_black_list_spacing < 3 * HBLKSIZE) {
|
||||
GC_black_list_spacing = 3 * HBLKSIZE;
|
||||
}
|
||||
if (GC_black_list_spacing > MAXHINCR * HBLKSIZE) {
|
||||
GC_black_list_spacing = MAXHINCR * HBLKSIZE;
|
||||
/* Makes it easier to allocate really huge blocks, which otherwise */
|
||||
/* may have problems with nonuniform blacklist distributions. */
|
||||
/* This way we should always succeed immediately after growing the */
|
||||
/* heap. */
|
||||
}
|
||||
}
|
||||
|
||||
void GC_unpromote_black_lists()
|
||||
{
|
||||
if (!GC_all_interior_pointers) {
|
||||
GC_copy_bl(GC_old_normal_bl, GC_incomplete_normal_bl);
|
||||
}
|
||||
GC_copy_bl(GC_old_stack_bl, GC_incomplete_stack_bl);
|
||||
}
|
||||
|
||||
/* P is not a valid pointer reference, but it falls inside */
|
||||
/* the plausible heap bounds. */
|
||||
/* Add it to the normal incomplete black list if appropriate. */
|
||||
#ifdef PRINT_BLACK_LIST
|
||||
void GC_add_to_black_list_normal(p, source)
|
||||
ptr_t source;
|
||||
#else
|
||||
void GC_add_to_black_list_normal(p)
|
||||
#endif
|
||||
word p;
|
||||
{
|
||||
if (!(GC_modws_valid_offsets[p & (sizeof(word)-1)])) return;
|
||||
{
|
||||
register int index = PHT_HASH(p);
|
||||
|
||||
if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_normal_bl, index)) {
|
||||
# ifdef PRINT_BLACK_LIST
|
||||
if (!get_pht_entry_from_index(GC_incomplete_normal_bl, index)) {
|
||||
GC_err_printf2(
|
||||
"Black listing (normal) 0x%lx referenced from 0x%lx ",
|
||||
(unsigned long) p, (unsigned long) source);
|
||||
GC_print_source_ptr(source);
|
||||
GC_err_puts("\n");
|
||||
}
|
||||
# endif
|
||||
set_pht_entry_from_index(GC_incomplete_normal_bl, index);
|
||||
} /* else this is probably just an interior pointer to an allocated */
|
||||
/* object, and isn't worth black listing. */
|
||||
}
|
||||
}
|
||||
|
||||
/* And the same for false pointers from the stack. */
|
||||
#ifdef PRINT_BLACK_LIST
|
||||
void GC_add_to_black_list_stack(p, source)
|
||||
ptr_t source;
|
||||
#else
|
||||
void GC_add_to_black_list_stack(p)
|
||||
#endif
|
||||
word p;
|
||||
{
|
||||
register int index = PHT_HASH(p);
|
||||
|
||||
if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_stack_bl, index)) {
|
||||
# ifdef PRINT_BLACK_LIST
|
||||
if (!get_pht_entry_from_index(GC_incomplete_stack_bl, index)) {
|
||||
GC_err_printf2(
|
||||
"Black listing (stack) 0x%lx referenced from 0x%lx ",
|
||||
(unsigned long)p, (unsigned long)source);
|
||||
GC_print_source_ptr(source);
|
||||
GC_err_puts("\n");
|
||||
}
|
||||
# endif
|
||||
set_pht_entry_from_index(GC_incomplete_stack_bl, index);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Is the block starting at h of size len bytes black listed? If so,
|
||||
* return the address of the next plausible r such that (r, len) might not
|
||||
* be black listed. (R may not actually be in the heap. We guarantee only
|
||||
* that every smaller value of r after h is also black listed.)
|
||||
* If (h,len) is not black listed, return 0.
|
||||
* Knows about the structure of the black list hash tables.
|
||||
*/
|
||||
struct hblk * GC_is_black_listed(h, len)
|
||||
struct hblk * h;
|
||||
word len;
|
||||
{
|
||||
register int index = PHT_HASH((word)h);
|
||||
register word i;
|
||||
word nblocks = divHBLKSZ(len);
|
||||
|
||||
if (!GC_all_interior_pointers) {
|
||||
if (get_pht_entry_from_index(GC_old_normal_bl, index)
|
||||
|| get_pht_entry_from_index(GC_incomplete_normal_bl, index)) {
|
||||
return(h+1);
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; ; ) {
|
||||
if (GC_old_stack_bl[divWORDSZ(index)] == 0
|
||||
&& GC_incomplete_stack_bl[divWORDSZ(index)] == 0) {
|
||||
/* An easy case */
|
||||
i += WORDSZ - modWORDSZ(index);
|
||||
} else {
|
||||
if (get_pht_entry_from_index(GC_old_stack_bl, index)
|
||||
|| get_pht_entry_from_index(GC_incomplete_stack_bl, index)) {
|
||||
return(h+i+1);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
if (i >= nblocks) break;
|
||||
index = PHT_HASH((word)(h+i));
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
|
||||
/* Return the number of blacklisted blocks in a given range. */
|
||||
/* Used only for statistical purposes. */
|
||||
/* Looks only at the GC_incomplete_stack_bl. */
|
||||
word GC_number_stack_black_listed(start, endp1)
|
||||
struct hblk *start, *endp1;
|
||||
{
|
||||
register struct hblk * h;
|
||||
word result = 0;
|
||||
|
||||
for (h = start; h < endp1; h++) {
|
||||
register int index = PHT_HASH((word)h);
|
||||
|
||||
if (get_pht_entry_from_index(GC_old_stack_bl, index)) result++;
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
|
||||
/* Return the total number of (stack) black-listed bytes. */
|
||||
static word total_stack_black_listed()
|
||||
{
|
||||
register unsigned i;
|
||||
word total = 0;
|
||||
|
||||
for (i = 0; i < GC_n_heap_sects; i++) {
|
||||
struct hblk * start = (struct hblk *) GC_heap_sects[i].hs_start;
|
||||
word len = (word) GC_heap_sects[i].hs_bytes;
|
||||
struct hblk * endp1 = start + len/HBLKSIZE;
|
||||
|
||||
total += GC_number_stack_black_listed(start, endp1);
|
||||
}
|
||||
return(total * HBLKSIZE);
|
||||
}
|
||||
|
||||
@@ -1,4 +0,0 @@
|
||||
#!/bin/sh
|
||||
GC_DEBUG=1
|
||||
export GC_DEBUG
|
||||
$* 2>&1 | awk '{print "0x3e=c\""$0"\""};/^\t##PC##=/ {if ($2 != 0) {print $2"?i"}}' | adb $1 | sed "s/^ >/>/"
|
||||
@@ -1,201 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1992-1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
/* Boehm, March 29, 1995 12:51 pm PST */
|
||||
# ifdef CHECKSUMS
|
||||
|
||||
# include "gc_priv.h"
|
||||
|
||||
/* This is debugging code intended to verify the results of dirty bit */
|
||||
/* computations. Works only in a single threaded environment. */
|
||||
/* We assume that stubborn objects are changed only when they are */
|
||||
/* enabled for writing. (Certain kinds of writing are actually */
|
||||
/* safe under other conditions.) */
|
||||
# define NSUMS 2000
|
||||
|
||||
# define OFFSET 0x10000
|
||||
|
||||
typedef struct {
|
||||
GC_bool new_valid;
|
||||
word old_sum;
|
||||
word new_sum;
|
||||
struct hblk * block; /* Block to which this refers + OFFSET */
|
||||
/* to hide it from colector. */
|
||||
} page_entry;
|
||||
|
||||
page_entry GC_sums [NSUMS];
|
||||
|
||||
word GC_checksum(h)
|
||||
struct hblk *h;
|
||||
{
|
||||
register word *p = (word *)h;
|
||||
register word *lim = (word *)(h+1);
|
||||
register word result = 0;
|
||||
|
||||
while (p < lim) {
|
||||
result += *p++;
|
||||
}
|
||||
return(result | 0x80000000 /* doesn't look like pointer */);
|
||||
}
|
||||
|
||||
# ifdef STUBBORN_ALLOC
|
||||
/* Check whether a stubborn object from the given block appears on */
|
||||
/* the appropriate free list. */
|
||||
GC_bool GC_on_free_list(h)
|
||||
struct hblk *h;
|
||||
{
|
||||
register hdr * hhdr = HDR(h);
|
||||
register int sz = hhdr -> hb_sz;
|
||||
ptr_t p;
|
||||
|
||||
if (sz > MAXOBJSZ) return(FALSE);
|
||||
for (p = GC_sobjfreelist[sz]; p != 0; p = obj_link(p)) {
|
||||
if (HBLKPTR(p) == h) return(TRUE);
|
||||
}
|
||||
return(FALSE);
|
||||
}
|
||||
# endif
|
||||
|
||||
int GC_n_dirty_errors;
|
||||
int GC_n_changed_errors;
|
||||
int GC_n_clean;
|
||||
int GC_n_dirty;
|
||||
|
||||
void GC_update_check_page(h, index)
|
||||
struct hblk *h;
|
||||
int index;
|
||||
{
|
||||
page_entry *pe = GC_sums + index;
|
||||
register hdr * hhdr = HDR(h);
|
||||
|
||||
if (pe -> block != 0 && pe -> block != h + OFFSET) ABORT("goofed");
|
||||
pe -> old_sum = pe -> new_sum;
|
||||
pe -> new_sum = GC_checksum(h);
|
||||
# if !defined(MSWIN32) && !defined(MSWINCE)
|
||||
if (pe -> new_sum != 0 && !GC_page_was_ever_dirty(h)) {
|
||||
GC_printf1("GC_page_was_ever_dirty(0x%lx) is wrong\n",
|
||||
(unsigned long)h);
|
||||
}
|
||||
# endif
|
||||
if (GC_page_was_dirty(h)) {
|
||||
GC_n_dirty++;
|
||||
} else {
|
||||
GC_n_clean++;
|
||||
}
|
||||
if (pe -> new_valid && pe -> old_sum != pe -> new_sum) {
|
||||
if (!GC_page_was_dirty(h) || !GC_page_was_ever_dirty(h)) {
|
||||
/* Set breakpoint here */GC_n_dirty_errors++;
|
||||
}
|
||||
# ifdef STUBBORN_ALLOC
|
||||
if (!IS_FORWARDING_ADDR_OR_NIL(hhdr)
|
||||
&& hhdr -> hb_map != GC_invalid_map
|
||||
&& hhdr -> hb_obj_kind == STUBBORN
|
||||
&& !GC_page_was_changed(h)
|
||||
&& !GC_on_free_list(h)) {
|
||||
/* if GC_on_free_list(h) then reclaim may have touched it */
|
||||
/* without any allocations taking place. */
|
||||
/* Set breakpoint here */GC_n_changed_errors++;
|
||||
}
|
||||
# endif
|
||||
}
|
||||
pe -> new_valid = TRUE;
|
||||
pe -> block = h + OFFSET;
|
||||
}
|
||||
|
||||
word GC_bytes_in_used_blocks;
|
||||
|
||||
void GC_add_block(h, dummy)
|
||||
struct hblk *h;
|
||||
word dummy;
|
||||
{
|
||||
register hdr * hhdr = HDR(h);
|
||||
register bytes = WORDS_TO_BYTES(hhdr -> hb_sz);
|
||||
|
||||
bytes += HDR_BYTES + HBLKSIZE-1;
|
||||
bytes &= ~(HBLKSIZE-1);
|
||||
GC_bytes_in_used_blocks += bytes;
|
||||
}
|
||||
|
||||
void GC_check_blocks()
|
||||
{
|
||||
word bytes_in_free_blocks = 0;
|
||||
struct hblk * h = GC_hblkfreelist;
|
||||
hdr * hhdr = HDR(h);
|
||||
word sz;
|
||||
|
||||
GC_bytes_in_used_blocks = 0;
|
||||
GC_apply_to_all_blocks(GC_add_block, (word)0);
|
||||
while (h != 0) {
|
||||
sz = hhdr -> hb_sz;
|
||||
bytes_in_free_blocks += sz;
|
||||
h = hhdr -> hb_next;
|
||||
hhdr = HDR(h);
|
||||
}
|
||||
GC_printf2("GC_bytes_in_used_blocks = %ld, bytes_in_free_blocks = %ld ",
|
||||
GC_bytes_in_used_blocks, bytes_in_free_blocks);
|
||||
GC_printf1("GC_heapsize = %ld\n", GC_heapsize);
|
||||
if (GC_bytes_in_used_blocks + bytes_in_free_blocks != GC_heapsize) {
|
||||
GC_printf0("LOST SOME BLOCKS!!\n");
|
||||
}
|
||||
}
|
||||
|
||||
/* Should be called immediately after GC_read_dirty and GC_read_changed. */
|
||||
void GC_check_dirty()
|
||||
{
|
||||
register int index;
|
||||
register unsigned i;
|
||||
register struct hblk *h;
|
||||
register ptr_t start;
|
||||
|
||||
GC_check_blocks();
|
||||
|
||||
GC_n_dirty_errors = 0;
|
||||
GC_n_changed_errors = 0;
|
||||
GC_n_clean = 0;
|
||||
GC_n_dirty = 0;
|
||||
|
||||
index = 0;
|
||||
for (i = 0; i < GC_n_heap_sects; i++) {
|
||||
start = GC_heap_sects[i].hs_start;
|
||||
for (h = (struct hblk *)start;
|
||||
h < (struct hblk *)(start + GC_heap_sects[i].hs_bytes);
|
||||
h++) {
|
||||
GC_update_check_page(h, index);
|
||||
index++;
|
||||
if (index >= NSUMS) goto out;
|
||||
}
|
||||
}
|
||||
out:
|
||||
GC_printf2("Checked %lu clean and %lu dirty pages\n",
|
||||
(unsigned long) GC_n_clean, (unsigned long) GC_n_dirty);
|
||||
if (GC_n_dirty_errors > 0) {
|
||||
GC_printf1("Found %lu dirty bit errors\n",
|
||||
(unsigned long)GC_n_dirty_errors);
|
||||
}
|
||||
if (GC_n_changed_errors > 0) {
|
||||
GC_printf1("Found %lu changed bit errors\n",
|
||||
(unsigned long)GC_n_changed_errors);
|
||||
GC_printf0("These may be benign (provoked by nonpointer changes)\n");
|
||||
# ifdef THREADS
|
||||
GC_printf0(
|
||||
"Also expect 1 per thread currently allocating a stubborn obj.\n");
|
||||
# endif
|
||||
}
|
||||
}
|
||||
|
||||
# else
|
||||
|
||||
extern int GC_quiet;
|
||||
/* ANSI C doesn't allow translation units to be empty. */
|
||||
/* So we guarantee this one is nonempty. */
|
||||
|
||||
# endif /* CHECKSUMS */
|
||||
1121
boehm-gc/config.guess
vendored
1121
boehm-gc/config.guess
vendored
File diff suppressed because it is too large
Load Diff
1232
boehm-gc/config.sub
vendored
1232
boehm-gc/config.sub
vendored
File diff suppressed because it is too large
Load Diff
3319
boehm-gc/configure
vendored
3319
boehm-gc/configure
vendored
File diff suppressed because it is too large
Load Diff
@@ -1,53 +0,0 @@
|
||||
# configure.host
|
||||
|
||||
# This shell script handles all host based configuration for the garbage
|
||||
# collector.
|
||||
# It sets various shell variables based on the the host and the
|
||||
# configuration options. You can modify this shell script without
|
||||
# needing to rerun autoconf.
|
||||
|
||||
# This shell script should be invoked as
|
||||
# . configure.host
|
||||
# If it encounters an error, it will exit with a message.
|
||||
|
||||
# It uses the following shell variables:
|
||||
# host The configuration host
|
||||
# host_cpu The configuration host CPU
|
||||
# target_optspace --enable-target-optspace ("yes", "no", "")
|
||||
|
||||
# It sets the following shell variables:
|
||||
# gc_cflags Special CFLAGS to use when building
|
||||
|
||||
# We should set -fexceptions if we are using gcc and might be used
|
||||
# inside something like gcj. This is the zeroth approximation:
|
||||
case "$host" in
|
||||
*-*-linux* )
|
||||
gc_cflags=-fexceptions
|
||||
;;
|
||||
*-*-hpux* )
|
||||
gc_cflags=+ESdbgasm
|
||||
;;
|
||||
esac
|
||||
|
||||
case "${target_optspace}:${host}" in
|
||||
yes:*)
|
||||
gc_cflags="${gc_cflags} -Os"
|
||||
;;
|
||||
:m32r-* | :d10v-* | :d30v-*)
|
||||
gc_cflags="${gc_cflags} -Os"
|
||||
;;
|
||||
no:* | :*)
|
||||
# Nothing.
|
||||
;;
|
||||
esac
|
||||
|
||||
# Set any host dependent compiler flags.
|
||||
# THIS TABLE IS SORTED. KEEP IT THAT WAY.
|
||||
|
||||
case "${host}" in
|
||||
mips-tx39-*|mipstx39-unknown-*)
|
||||
boehm_gc_cflags="${boehm_gc_cflags} -G 0"
|
||||
;;
|
||||
*)
|
||||
;;
|
||||
esac
|
||||
@@ -1,276 +0,0 @@
|
||||
# Copyright (c) 1999-2001 by Red Hat, Inc. All rights reserved.
|
||||
#
|
||||
# THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
# OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
#
|
||||
# Permission is hereby granted to use or copy this program
|
||||
# for any purpose, provided the above notices are retained on all copies.
|
||||
# Permission to modify the code and to distribute modified code is granted,
|
||||
# provided the above notices are retained, and a notice that the code was
|
||||
# modified is included with the above copyright notice.
|
||||
#
|
||||
# Original author: Tom Tromey
|
||||
|
||||
dnl Process this file with autoconf to produce configure.
|
||||
|
||||
AC_INIT(gcj_mlc.c)
|
||||
|
||||
dnl Can't be done in GC_CONFIGURE because that confuses automake.
|
||||
AC_CONFIG_AUX_DIR(.)
|
||||
|
||||
GC_CONFIGURE(.)
|
||||
|
||||
AM_PROG_LIBTOOL
|
||||
|
||||
dnl We use these options to decide which functions to include.
|
||||
AC_ARG_WITH(target-subdir,
|
||||
[ --with-target-subdir=SUBDIR
|
||||
configuring with a cross compiler])
|
||||
AC_ARG_WITH(cross-host,
|
||||
[ --with-cross-host=HOST configuring with a cross compiler])
|
||||
|
||||
AM_MAINTAINER_MODE
|
||||
# automake wants to see AC_EXEEXT. But we don't need it. And having
|
||||
# it is actually a problem, because the compiler we're passed can't
|
||||
# necessarily do a full link. So we fool automake here.
|
||||
if false; then
|
||||
# autoconf 2.50 runs AC_EXEEXT by default, and the macro expands
|
||||
# to nothing, so nothing would remain between `then' and `fi' if it
|
||||
# were not for the `:' below.
|
||||
:
|
||||
AC_EXEEXT
|
||||
fi
|
||||
|
||||
AC_MSG_CHECKING([for thread model used by GCC])
|
||||
THREADS=`$CC -v 2>&1 | sed -n 's/^Thread model: //p'`
|
||||
if test -z "$THREADS"; then
|
||||
THREADS=no
|
||||
fi
|
||||
AC_MSG_RESULT([$THREADS])
|
||||
|
||||
AC_ARG_ENABLE(parallel-mark,
|
||||
[ --enable-parallel-mark parallelize marking and free list construction],
|
||||
[case "$THREADS" in
|
||||
no | none | single)
|
||||
AC_MSG_ERROR([Parallel mark requires --enable-threads=x spec])
|
||||
;;
|
||||
esac]
|
||||
)
|
||||
|
||||
INCLUDES=-I${srcdir}/include
|
||||
THREADLIBS=
|
||||
case "$THREADS" in
|
||||
no | none | single)
|
||||
THREADS=none
|
||||
;;
|
||||
posix | pthreads)
|
||||
THREADS=posix
|
||||
THREADLIBS=-lpthread
|
||||
case "$host" in
|
||||
x86-*-linux* | ia64-*-linux* | i586-*-linux* | i686-*-linux*)
|
||||
AC_DEFINE(GC_LINUX_THREADS)
|
||||
AC_DEFINE(_REENTRANT)
|
||||
if test "${enable_parallel_mark}"; then
|
||||
AC_DEFINE(PARALLEL_MARK)
|
||||
fi
|
||||
AC_DEFINE(THREAD_LOCAL_ALLOC)
|
||||
;;
|
||||
*-*-linux*)
|
||||
AC_DEFINE(GC_LINUX_THREADS)
|
||||
AC_DEFINE(_REENTRANT)
|
||||
;;
|
||||
*-*-hpux*)
|
||||
AC_MSG_WARN("Only HP/UX 11 threads are supported.")
|
||||
AC_DEFINE(GC_HPUX_THREADS)
|
||||
AC_DEFINE(_POSIX_C_SOURCE,199506L)
|
||||
if test "${enable_parallel_mark}" = yes; then
|
||||
AC_DEFINE(PARALLEL_MARK)
|
||||
fi
|
||||
AC_DEFINE(THREAD_LOCAL_ALLOC)
|
||||
THREADLIBS="-lpthread -lrt"
|
||||
;;
|
||||
*-*-freebsd*)
|
||||
AC_MSG_WARN("Threaded GC is prone to deadlock before FreeBSD 4.5.")
|
||||
AC_MSG_WARN("Related symptom is pthread_join returns spurious EINTR.")
|
||||
AC_DEFINE(GC_FREEBSD_THREADS)
|
||||
INCLUDES="$INCLUDES -pthread"
|
||||
THREADLIBS=-pthread
|
||||
;;
|
||||
*-*-solaris*)
|
||||
AC_DEFINE(GC_SOLARIS_THREADS)
|
||||
AC_DEFINE(GC_SOLARIS_PTHREADS)
|
||||
;;
|
||||
*-*-irix*)
|
||||
AC_DEFINE(GC_IRIX_THREADS)
|
||||
;;
|
||||
*-*-cygwin*)
|
||||
THREADLIBS=
|
||||
;;
|
||||
esac
|
||||
;;
|
||||
decosf1 | irix | mach | os2 | solaris | win32 | dce | vxworks)
|
||||
AC_MSG_ERROR(thread package $THREADS not yet supported)
|
||||
;;
|
||||
*)
|
||||
AC_MSG_ERROR($THREADS is an unknown thread package)
|
||||
;;
|
||||
esac
|
||||
AC_SUBST(THREADLIBS)
|
||||
|
||||
AC_CHECK_LIB(dl, dlopen, EXTRA_TEST_LIBS="$EXTRA_TEST_LIBS -ldl")
|
||||
AC_SUBST(EXTRA_TEST_LIBS)
|
||||
|
||||
target_all=libgcjgc.la
|
||||
AC_SUBST(target_all)
|
||||
AC_SUBST(target_alias)
|
||||
|
||||
dnl If the target is an eCos system, use the appropriate eCos
|
||||
dnl I/O routines.
|
||||
dnl FIXME: this should not be a local option but a global target
|
||||
dnl system; at present there is no eCos target.
|
||||
TARGET_ECOS="no"
|
||||
AC_ARG_WITH(ecos,
|
||||
[ --with-ecos enable runtime eCos target support],
|
||||
TARGET_ECOS="$with_ecos"
|
||||
)
|
||||
|
||||
addobjs=
|
||||
CXXINCLUDES=
|
||||
case "$TARGET_ECOS" in
|
||||
no)
|
||||
;;
|
||||
*)
|
||||
AC_DEFINE(ECOS)
|
||||
CXXINCLUDES="-I${TARGET_ECOS}/include"
|
||||
addobjs="$addobjs ecos.lo"
|
||||
;;
|
||||
esac
|
||||
AC_SUBST(CXX)
|
||||
|
||||
AC_SUBST(INCLUDES)
|
||||
AC_SUBST(CXXINCLUDES)
|
||||
|
||||
machdep=
|
||||
case "$host" in
|
||||
alpha*-*-*)
|
||||
machdep="alpha_mach_dep.lo"
|
||||
;;
|
||||
alpha-*-openbsd*)
|
||||
if test x"${ac_cv_lib_dl_dlopen}" != xyes ; then
|
||||
AC_MSG_WARN(OpenBSD/Alpha without dlopen(). Shared library support is disabled)
|
||||
AM_DISABLE_SHARED
|
||||
fi
|
||||
;;
|
||||
i?86-*-solaris2.[[89]]*)
|
||||
AC_DEFINE(SOLARIS25_PROC_VDB_BUG_FIXED)
|
||||
;;
|
||||
mipstx39-*-elf*)
|
||||
machdep="mips_ultrix_mach_dep.lo"
|
||||
AC_DEFINE(STACKBASE, __stackbase)
|
||||
AC_DEFINE(DATASTART_IS_ETEXT)
|
||||
;;
|
||||
mips-dec-ultrix*)
|
||||
machdep="mips_ultrix_mach-dep.lo"
|
||||
;;
|
||||
mips-*-*)
|
||||
machdep="mips_sgi_mach_dep.lo"
|
||||
AC_DEFINE(NO_EXECUTE_PERMISSION)
|
||||
;;
|
||||
sparc-sun-solaris2.3*)
|
||||
AC_DEFINE(SUNOS53_SHARED_LIB)
|
||||
;;
|
||||
ia64-*-hpux*)
|
||||
machdep="mach_dep.lo ia64_save_regs_in_stack.lo"
|
||||
;;
|
||||
esac
|
||||
if test x"$machdep" = x; then
|
||||
machdep="mach_dep.lo"
|
||||
fi
|
||||
addobjs="$addobjs $machdep"
|
||||
AC_SUBST(addobjs)
|
||||
|
||||
dnl As of 4.13a2, the collector will not properly work on Solaris when
|
||||
dnl built with gcc and -O. So we remove -O in the appropriate case.
|
||||
case "$host" in
|
||||
sparc-sun-solaris2*)
|
||||
if test "$GCC" = yes; then
|
||||
new_CFLAGS=
|
||||
for i in $CFLAGS; do
|
||||
case "$i" in
|
||||
-O*)
|
||||
;;
|
||||
*)
|
||||
new_CFLAGS="$new_CFLAGS $i"
|
||||
;;
|
||||
esac
|
||||
done
|
||||
CFLAGS="$new_CFLAGS"
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
|
||||
dnl We need to override the top-level CFLAGS. This is how we do it.
|
||||
MY_CFLAGS="$CFLAGS"
|
||||
AC_SUBST(MY_CFLAGS)
|
||||
|
||||
dnl Include defines that have become de facto standard.
|
||||
dnl ALL_INTERIOR_POINTERS can be overridden in startup code.
|
||||
AC_DEFINE(SILENT)
|
||||
AC_DEFINE(NO_SIGNALS)
|
||||
AC_DEFINE(NO_EXECUTE_PERMISSION)
|
||||
AC_DEFINE(ALL_INTERIOR_POINTERS)
|
||||
|
||||
dnl By default, make the library as general as possible.
|
||||
AC_DEFINE(JAVA_FINALIZATION)
|
||||
AC_DEFINE(GC_GCJ_SUPPORT)
|
||||
AC_DEFINE(ATOMIC_UNCOLLECTABLE)
|
||||
|
||||
dnl This is something of a hack. When cross-compiling we turn off
|
||||
dnl some functionality. We also enable the "small" configuration.
|
||||
dnl These is only correct when targetting an embedded system. FIXME.
|
||||
if test -n "${with_cross_host}"; then
|
||||
AC_DEFINE(NO_SIGSET)
|
||||
AC_DEFINE(NO_CLOCK)
|
||||
AC_DEFINE(SMALL_CONFIG)
|
||||
AC_DEFINE(NO_DEBUGGING)
|
||||
fi
|
||||
|
||||
AC_ARG_ENABLE(full-debug,
|
||||
[ --enable-full-debug include full support for pointer backtracing etc.],
|
||||
[ if test "$enable_full_debug" = "yes"; then
|
||||
AC_MSG_WARN("Must define GC_DEBUG and use debug alloc. in clients.")
|
||||
AC_DEFINE(KEEP_BACK_PTRS)
|
||||
AC_DEFINE(DBG_HDRS_ALL)
|
||||
case $host in
|
||||
x86-*-linux* | i586-*-linux* | i686-*-linux* )
|
||||
AC_MSG_WARN("Client must not use -fomit-frame-pointer.")
|
||||
AC_DEFINE(SAVE_CALL_COUNT, 8)
|
||||
;;
|
||||
esac ]
|
||||
fi)
|
||||
|
||||
AM_CONDITIONAL(USE_LIBDIR, test -z "$with_cross_host")
|
||||
|
||||
if test "${multilib}" = "yes"; then
|
||||
multilib_arg="--enable-multilib"
|
||||
else
|
||||
multilib_arg=
|
||||
fi
|
||||
|
||||
AC_OUTPUT(Makefile include/Makefile, [
|
||||
dnl Put all the -D options in a file.
|
||||
echo "$DEFS" > boehm-cflags
|
||||
|
||||
if test -n "$CONFIG_FILES"; then
|
||||
ac_file=Makefile . ${gc_basedir}/../config-ml.in
|
||||
fi],
|
||||
srcdir=${srcdir}
|
||||
host=${host}
|
||||
target=${target}
|
||||
with_multisubdir=${with_multisubdir}
|
||||
ac_configure_args="${multilib_arg} ${ac_configure_args}"
|
||||
CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
|
||||
gc_basedir=${gc_basedir}
|
||||
CC="${CC}"
|
||||
DEFS="$DEFS"
|
||||
)
|
||||
@@ -1,915 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*
|
||||
* Author: Hans-J. Boehm (boehm@parc.xerox.com)
|
||||
*/
|
||||
/* Boehm, October 3, 1994 5:19 pm PDT */
|
||||
# include "gc.h"
|
||||
# include "cord.h"
|
||||
# include <stdlib.h>
|
||||
# include <stdio.h>
|
||||
# include <string.h>
|
||||
|
||||
/* An implementation of the cord primitives. These are the only */
|
||||
/* Functions that understand the representation. We perform only */
|
||||
/* minimal checks on arguments to these functions. Out of bounds */
|
||||
/* arguments to the iteration functions may result in client functions */
|
||||
/* invoked on garbage data. In most cases, client functions should be */
|
||||
/* programmed defensively enough that this does not result in memory */
|
||||
/* smashes. */
|
||||
|
||||
typedef void (* oom_fn)(void);
|
||||
|
||||
oom_fn CORD_oom_fn = (oom_fn) 0;
|
||||
|
||||
# define OUT_OF_MEMORY { if (CORD_oom_fn != (oom_fn) 0) (*CORD_oom_fn)(); \
|
||||
ABORT("Out of memory\n"); }
|
||||
# define ABORT(msg) { fprintf(stderr, "%s\n", msg); abort(); }
|
||||
|
||||
typedef unsigned long word;
|
||||
|
||||
typedef union {
|
||||
struct Concatenation {
|
||||
char null;
|
||||
char header;
|
||||
char depth; /* concatenation nesting depth. */
|
||||
unsigned char left_len;
|
||||
/* Length of left child if it is sufficiently */
|
||||
/* short; 0 otherwise. */
|
||||
# define MAX_LEFT_LEN 255
|
||||
word len;
|
||||
CORD left; /* length(left) > 0 */
|
||||
CORD right; /* length(right) > 0 */
|
||||
} concatenation;
|
||||
struct Function {
|
||||
char null;
|
||||
char header;
|
||||
char depth; /* always 0 */
|
||||
char left_len; /* always 0 */
|
||||
word len;
|
||||
CORD_fn fn;
|
||||
void * client_data;
|
||||
} function;
|
||||
struct Generic {
|
||||
char null;
|
||||
char header;
|
||||
char depth;
|
||||
char left_len;
|
||||
word len;
|
||||
} generic;
|
||||
char string[1];
|
||||
} CordRep;
|
||||
|
||||
# define CONCAT_HDR 1
|
||||
|
||||
# define FN_HDR 4
|
||||
# define SUBSTR_HDR 6
|
||||
/* Substring nodes are a special case of function nodes. */
|
||||
/* The client_data field is known to point to a substr_args */
|
||||
/* structure, and the function is either CORD_apply_access_fn */
|
||||
/* or CORD_index_access_fn. */
|
||||
|
||||
/* The following may be applied only to function and concatenation nodes: */
|
||||
#define IS_CONCATENATION(s) (((CordRep *)s)->generic.header == CONCAT_HDR)
|
||||
|
||||
#define IS_FUNCTION(s) ((((CordRep *)s)->generic.header & FN_HDR) != 0)
|
||||
|
||||
#define IS_SUBSTR(s) (((CordRep *)s)->generic.header == SUBSTR_HDR)
|
||||
|
||||
#define LEN(s) (((CordRep *)s) -> generic.len)
|
||||
#define DEPTH(s) (((CordRep *)s) -> generic.depth)
|
||||
#define GEN_LEN(s) (CORD_IS_STRING(s) ? strlen(s) : LEN(s))
|
||||
|
||||
#define LEFT_LEN(c) ((c) -> left_len != 0? \
|
||||
(c) -> left_len \
|
||||
: (CORD_IS_STRING((c) -> left) ? \
|
||||
(c) -> len - GEN_LEN((c) -> right) \
|
||||
: LEN((c) -> left)))
|
||||
|
||||
#define SHORT_LIMIT (sizeof(CordRep) - 1)
|
||||
/* Cords shorter than this are C strings */
|
||||
|
||||
|
||||
/* Dump the internal representation of x to stdout, with initial */
|
||||
/* indentation level n. */
|
||||
void CORD_dump_inner(CORD x, unsigned n)
|
||||
{
|
||||
register size_t i;
|
||||
|
||||
for (i = 0; i < (size_t)n; i++) {
|
||||
fputs(" ", stdout);
|
||||
}
|
||||
if (x == 0) {
|
||||
fputs("NIL\n", stdout);
|
||||
} else if (CORD_IS_STRING(x)) {
|
||||
for (i = 0; i <= SHORT_LIMIT; i++) {
|
||||
if (x[i] == '\0') break;
|
||||
putchar(x[i]);
|
||||
}
|
||||
if (x[i] != '\0') fputs("...", stdout);
|
||||
putchar('\n');
|
||||
} else if (IS_CONCATENATION(x)) {
|
||||
register struct Concatenation * conc =
|
||||
&(((CordRep *)x) -> concatenation);
|
||||
printf("Concatenation: %p (len: %d, depth: %d)\n",
|
||||
x, (int)(conc -> len), (int)(conc -> depth));
|
||||
CORD_dump_inner(conc -> left, n+1);
|
||||
CORD_dump_inner(conc -> right, n+1);
|
||||
} else /* function */{
|
||||
register struct Function * func =
|
||||
&(((CordRep *)x) -> function);
|
||||
if (IS_SUBSTR(x)) printf("(Substring) ");
|
||||
printf("Function: %p (len: %d): ", x, (int)(func -> len));
|
||||
for (i = 0; i < 20 && i < func -> len; i++) {
|
||||
putchar((*(func -> fn))(i, func -> client_data));
|
||||
}
|
||||
if (i < func -> len) fputs("...", stdout);
|
||||
putchar('\n');
|
||||
}
|
||||
}
|
||||
|
||||
/* Dump the internal representation of x to stdout */
|
||||
void CORD_dump(CORD x)
|
||||
{
|
||||
CORD_dump_inner(x, 0);
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
CORD CORD_cat_char_star(CORD x, const char * y, size_t leny)
|
||||
{
|
||||
register size_t result_len;
|
||||
register size_t lenx;
|
||||
register int depth;
|
||||
|
||||
if (x == CORD_EMPTY) return(y);
|
||||
if (leny == 0) return(x);
|
||||
if (CORD_IS_STRING(x)) {
|
||||
lenx = strlen(x);
|
||||
result_len = lenx + leny;
|
||||
if (result_len <= SHORT_LIMIT) {
|
||||
register char * result = GC_MALLOC_ATOMIC(result_len+1);
|
||||
|
||||
if (result == 0) OUT_OF_MEMORY;
|
||||
memcpy(result, x, lenx);
|
||||
memcpy(result + lenx, y, leny);
|
||||
result[result_len] = '\0';
|
||||
return((CORD) result);
|
||||
} else {
|
||||
depth = 1;
|
||||
}
|
||||
} else {
|
||||
register CORD right;
|
||||
register CORD left;
|
||||
register char * new_right;
|
||||
register size_t right_len;
|
||||
|
||||
lenx = LEN(x);
|
||||
|
||||
if (leny <= SHORT_LIMIT/2
|
||||
&& IS_CONCATENATION(x)
|
||||
&& CORD_IS_STRING(right = ((CordRep *)x) -> concatenation.right)) {
|
||||
/* Merge y into right part of x. */
|
||||
if (!CORD_IS_STRING(left = ((CordRep *)x) -> concatenation.left)) {
|
||||
right_len = lenx - LEN(left);
|
||||
} else if (((CordRep *)x) -> concatenation.left_len != 0) {
|
||||
right_len = lenx - ((CordRep *)x) -> concatenation.left_len;
|
||||
} else {
|
||||
right_len = strlen(right);
|
||||
}
|
||||
result_len = right_len + leny; /* length of new_right */
|
||||
if (result_len <= SHORT_LIMIT) {
|
||||
new_right = GC_MALLOC_ATOMIC(result_len + 1);
|
||||
memcpy(new_right, right, right_len);
|
||||
memcpy(new_right + right_len, y, leny);
|
||||
new_right[result_len] = '\0';
|
||||
y = new_right;
|
||||
leny = result_len;
|
||||
x = left;
|
||||
lenx -= right_len;
|
||||
/* Now fall through to concatenate the two pieces: */
|
||||
}
|
||||
if (CORD_IS_STRING(x)) {
|
||||
depth = 1;
|
||||
} else {
|
||||
depth = DEPTH(x) + 1;
|
||||
}
|
||||
} else {
|
||||
depth = DEPTH(x) + 1;
|
||||
}
|
||||
result_len = lenx + leny;
|
||||
}
|
||||
{
|
||||
/* The general case; lenx, result_len is known: */
|
||||
register struct Concatenation * result;
|
||||
|
||||
result = GC_NEW(struct Concatenation);
|
||||
if (result == 0) OUT_OF_MEMORY;
|
||||
result->header = CONCAT_HDR;
|
||||
result->depth = depth;
|
||||
if (lenx <= MAX_LEFT_LEN) result->left_len = lenx;
|
||||
result->len = result_len;
|
||||
result->left = x;
|
||||
result->right = y;
|
||||
if (depth > MAX_DEPTH) {
|
||||
return(CORD_balance((CORD)result));
|
||||
} else {
|
||||
return((CORD) result);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
CORD CORD_cat(CORD x, CORD y)
|
||||
{
|
||||
register size_t result_len;
|
||||
register int depth;
|
||||
register size_t lenx;
|
||||
|
||||
if (x == CORD_EMPTY) return(y);
|
||||
if (y == CORD_EMPTY) return(x);
|
||||
if (CORD_IS_STRING(y)) {
|
||||
return(CORD_cat_char_star(x, y, strlen(y)));
|
||||
} else if (CORD_IS_STRING(x)) {
|
||||
lenx = strlen(x);
|
||||
depth = DEPTH(y) + 1;
|
||||
} else {
|
||||
register int depthy = DEPTH(y);
|
||||
|
||||
lenx = LEN(x);
|
||||
depth = DEPTH(x) + 1;
|
||||
if (depthy >= depth) depth = depthy + 1;
|
||||
}
|
||||
result_len = lenx + LEN(y);
|
||||
{
|
||||
register struct Concatenation * result;
|
||||
|
||||
result = GC_NEW(struct Concatenation);
|
||||
if (result == 0) OUT_OF_MEMORY;
|
||||
result->header = CONCAT_HDR;
|
||||
result->depth = depth;
|
||||
if (lenx <= MAX_LEFT_LEN) result->left_len = lenx;
|
||||
result->len = result_len;
|
||||
result->left = x;
|
||||
result->right = y;
|
||||
return((CORD) result);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
CORD CORD_from_fn(CORD_fn fn, void * client_data, size_t len)
|
||||
{
|
||||
if (len <= 0) return(0);
|
||||
if (len <= SHORT_LIMIT) {
|
||||
register char * result;
|
||||
register size_t i;
|
||||
char buf[SHORT_LIMIT+1];
|
||||
register char c;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
c = (*fn)(i, client_data);
|
||||
if (c == '\0') goto gen_case;
|
||||
buf[i] = c;
|
||||
}
|
||||
buf[i] = '\0';
|
||||
result = GC_MALLOC_ATOMIC(len+1);
|
||||
if (result == 0) OUT_OF_MEMORY;
|
||||
strcpy(result, buf);
|
||||
result[len] = '\0';
|
||||
return((CORD) result);
|
||||
}
|
||||
gen_case:
|
||||
{
|
||||
register struct Function * result;
|
||||
|
||||
result = GC_NEW(struct Function);
|
||||
if (result == 0) OUT_OF_MEMORY;
|
||||
result->header = FN_HDR;
|
||||
/* depth is already 0 */
|
||||
result->len = len;
|
||||
result->fn = fn;
|
||||
result->client_data = client_data;
|
||||
return((CORD) result);
|
||||
}
|
||||
}
|
||||
|
||||
size_t CORD_len(CORD x)
|
||||
{
|
||||
if (x == 0) {
|
||||
return(0);
|
||||
} else {
|
||||
return(GEN_LEN(x));
|
||||
}
|
||||
}
|
||||
|
||||
struct substr_args {
|
||||
CordRep * sa_cord;
|
||||
size_t sa_index;
|
||||
};
|
||||
|
||||
char CORD_index_access_fn(size_t i, void * client_data)
|
||||
{
|
||||
register struct substr_args *descr = (struct substr_args *)client_data;
|
||||
|
||||
return(((char *)(descr->sa_cord))[i + descr->sa_index]);
|
||||
}
|
||||
|
||||
char CORD_apply_access_fn(size_t i, void * client_data)
|
||||
{
|
||||
register struct substr_args *descr = (struct substr_args *)client_data;
|
||||
register struct Function * fn_cord = &(descr->sa_cord->function);
|
||||
|
||||
return((*(fn_cord->fn))(i + descr->sa_index, fn_cord->client_data));
|
||||
}
|
||||
|
||||
/* A version of CORD_substr that simply returns a function node, thus */
|
||||
/* postponing its work. The fourth argument is a function that may */
|
||||
/* be used for efficient access to the ith character. */
|
||||
/* Assumes i >= 0 and i + n < length(x). */
|
||||
CORD CORD_substr_closure(CORD x, size_t i, size_t n, CORD_fn f)
|
||||
{
|
||||
register struct substr_args * sa = GC_NEW(struct substr_args);
|
||||
CORD result;
|
||||
|
||||
if (sa == 0) OUT_OF_MEMORY;
|
||||
sa->sa_cord = (CordRep *)x;
|
||||
sa->sa_index = i;
|
||||
result = CORD_from_fn(f, (void *)sa, n);
|
||||
((CordRep *)result) -> function.header = SUBSTR_HDR;
|
||||
return (result);
|
||||
}
|
||||
|
||||
# define SUBSTR_LIMIT (10 * SHORT_LIMIT)
|
||||
/* Substrings of function nodes and flat strings shorter than */
|
||||
/* this are flat strings. Othewise we use a functional */
|
||||
/* representation, which is significantly slower to access. */
|
||||
|
||||
/* A version of CORD_substr that assumes i >= 0, n > 0, and i + n < length(x).*/
|
||||
CORD CORD_substr_checked(CORD x, size_t i, size_t n)
|
||||
{
|
||||
if (CORD_IS_STRING(x)) {
|
||||
if (n > SUBSTR_LIMIT) {
|
||||
return(CORD_substr_closure(x, i, n, CORD_index_access_fn));
|
||||
} else {
|
||||
register char * result = GC_MALLOC_ATOMIC(n+1);
|
||||
|
||||
if (result == 0) OUT_OF_MEMORY;
|
||||
strncpy(result, x+i, n);
|
||||
result[n] = '\0';
|
||||
return(result);
|
||||
}
|
||||
} else if (IS_CONCATENATION(x)) {
|
||||
register struct Concatenation * conc
|
||||
= &(((CordRep *)x) -> concatenation);
|
||||
register size_t left_len;
|
||||
register size_t right_len;
|
||||
|
||||
left_len = LEFT_LEN(conc);
|
||||
right_len = conc -> len - left_len;
|
||||
if (i >= left_len) {
|
||||
if (n == right_len) return(conc -> right);
|
||||
return(CORD_substr_checked(conc -> right, i - left_len, n));
|
||||
} else if (i+n <= left_len) {
|
||||
if (n == left_len) return(conc -> left);
|
||||
return(CORD_substr_checked(conc -> left, i, n));
|
||||
} else {
|
||||
/* Need at least one character from each side. */
|
||||
register CORD left_part;
|
||||
register CORD right_part;
|
||||
register size_t left_part_len = left_len - i;
|
||||
|
||||
if (i == 0) {
|
||||
left_part = conc -> left;
|
||||
} else {
|
||||
left_part = CORD_substr_checked(conc -> left, i, left_part_len);
|
||||
}
|
||||
if (i + n == right_len + left_len) {
|
||||
right_part = conc -> right;
|
||||
} else {
|
||||
right_part = CORD_substr_checked(conc -> right, 0,
|
||||
n - left_part_len);
|
||||
}
|
||||
return(CORD_cat(left_part, right_part));
|
||||
}
|
||||
} else /* function */ {
|
||||
if (n > SUBSTR_LIMIT) {
|
||||
if (IS_SUBSTR(x)) {
|
||||
/* Avoid nesting substring nodes. */
|
||||
register struct Function * f = &(((CordRep *)x) -> function);
|
||||
register struct substr_args *descr =
|
||||
(struct substr_args *)(f -> client_data);
|
||||
|
||||
return(CORD_substr_closure((CORD)descr->sa_cord,
|
||||
i + descr->sa_index,
|
||||
n, f -> fn));
|
||||
} else {
|
||||
return(CORD_substr_closure(x, i, n, CORD_apply_access_fn));
|
||||
}
|
||||
} else {
|
||||
char * result;
|
||||
register struct Function * f = &(((CordRep *)x) -> function);
|
||||
char buf[SUBSTR_LIMIT+1];
|
||||
register char * p = buf;
|
||||
register char c;
|
||||
register int j;
|
||||
register int lim = i + n;
|
||||
|
||||
for (j = i; j < lim; j++) {
|
||||
c = (*(f -> fn))(j, f -> client_data);
|
||||
if (c == '\0') {
|
||||
return(CORD_substr_closure(x, i, n, CORD_apply_access_fn));
|
||||
}
|
||||
*p++ = c;
|
||||
}
|
||||
*p = '\0';
|
||||
result = GC_MALLOC_ATOMIC(n+1);
|
||||
if (result == 0) OUT_OF_MEMORY;
|
||||
strcpy(result, buf);
|
||||
return(result);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CORD CORD_substr(CORD x, size_t i, size_t n)
|
||||
{
|
||||
register size_t len = CORD_len(x);
|
||||
|
||||
if (i >= len || n <= 0) return(0);
|
||||
/* n < 0 is impossible in a correct C implementation, but */
|
||||
/* quite possible under SunOS 4.X. */
|
||||
if (i + n > len) n = len - i;
|
||||
# ifndef __STDC__
|
||||
if (i < 0) ABORT("CORD_substr: second arg. negative");
|
||||
/* Possible only if both client and C implementation are buggy. */
|
||||
/* But empirically this happens frequently. */
|
||||
# endif
|
||||
return(CORD_substr_checked(x, i, n));
|
||||
}
|
||||
|
||||
/* See cord.h for definition. We assume i is in range. */
|
||||
int CORD_iter5(CORD x, size_t i, CORD_iter_fn f1,
|
||||
CORD_batched_iter_fn f2, void * client_data)
|
||||
{
|
||||
if (x == 0) return(0);
|
||||
if (CORD_IS_STRING(x)) {
|
||||
register const char *p = x+i;
|
||||
|
||||
if (*p == '\0') ABORT("2nd arg to CORD_iter5 too big");
|
||||
if (f2 != CORD_NO_FN) {
|
||||
return((*f2)(p, client_data));
|
||||
} else {
|
||||
while (*p) {
|
||||
if ((*f1)(*p, client_data)) return(1);
|
||||
p++;
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
} else if (IS_CONCATENATION(x)) {
|
||||
register struct Concatenation * conc
|
||||
= &(((CordRep *)x) -> concatenation);
|
||||
|
||||
|
||||
if (i > 0) {
|
||||
register size_t left_len = LEFT_LEN(conc);
|
||||
|
||||
if (i >= left_len) {
|
||||
return(CORD_iter5(conc -> right, i - left_len, f1, f2,
|
||||
client_data));
|
||||
}
|
||||
}
|
||||
if (CORD_iter5(conc -> left, i, f1, f2, client_data)) {
|
||||
return(1);
|
||||
}
|
||||
return(CORD_iter5(conc -> right, 0, f1, f2, client_data));
|
||||
} else /* function */ {
|
||||
register struct Function * f = &(((CordRep *)x) -> function);
|
||||
register size_t j;
|
||||
register size_t lim = f -> len;
|
||||
|
||||
for (j = i; j < lim; j++) {
|
||||
if ((*f1)((*(f -> fn))(j, f -> client_data), client_data)) {
|
||||
return(1);
|
||||
}
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
|
||||
#undef CORD_iter
|
||||
int CORD_iter(CORD x, CORD_iter_fn f1, void * client_data)
|
||||
{
|
||||
return(CORD_iter5(x, 0, f1, CORD_NO_FN, client_data));
|
||||
}
|
||||
|
||||
int CORD_riter4(CORD x, size_t i, CORD_iter_fn f1, void * client_data)
|
||||
{
|
||||
if (x == 0) return(0);
|
||||
if (CORD_IS_STRING(x)) {
|
||||
register const char *p = x + i;
|
||||
register char c;
|
||||
|
||||
for(;;) {
|
||||
c = *p;
|
||||
if (c == '\0') ABORT("2nd arg to CORD_riter4 too big");
|
||||
if ((*f1)(c, client_data)) return(1);
|
||||
if (p == x) break;
|
||||
p--;
|
||||
}
|
||||
return(0);
|
||||
} else if (IS_CONCATENATION(x)) {
|
||||
register struct Concatenation * conc
|
||||
= &(((CordRep *)x) -> concatenation);
|
||||
register CORD left_part = conc -> left;
|
||||
register size_t left_len;
|
||||
|
||||
left_len = LEFT_LEN(conc);
|
||||
if (i >= left_len) {
|
||||
if (CORD_riter4(conc -> right, i - left_len, f1, client_data)) {
|
||||
return(1);
|
||||
}
|
||||
return(CORD_riter4(left_part, left_len - 1, f1, client_data));
|
||||
} else {
|
||||
return(CORD_riter4(left_part, i, f1, client_data));
|
||||
}
|
||||
} else /* function */ {
|
||||
register struct Function * f = &(((CordRep *)x) -> function);
|
||||
register size_t j;
|
||||
|
||||
for (j = i; ; j--) {
|
||||
if ((*f1)((*(f -> fn))(j, f -> client_data), client_data)) {
|
||||
return(1);
|
||||
}
|
||||
if (j == 0) return(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int CORD_riter(CORD x, CORD_iter_fn f1, void * client_data)
|
||||
{
|
||||
return(CORD_riter4(x, CORD_len(x) - 1, f1, client_data));
|
||||
}
|
||||
|
||||
/*
|
||||
* The following functions are concerned with balancing cords.
|
||||
* Strategy:
|
||||
* Scan the cord from left to right, keeping the cord scanned so far
|
||||
* as a forest of balanced trees of exponentialy decreasing length.
|
||||
* When a new subtree needs to be added to the forest, we concatenate all
|
||||
* shorter ones to the new tree in the appropriate order, and then insert
|
||||
* the result into the forest.
|
||||
* Crucial invariants:
|
||||
* 1. The concatenation of the forest (in decreasing order) with the
|
||||
* unscanned part of the rope is equal to the rope being balanced.
|
||||
* 2. All trees in the forest are balanced.
|
||||
* 3. forest[i] has depth at most i.
|
||||
*/
|
||||
|
||||
typedef struct {
|
||||
CORD c;
|
||||
size_t len; /* Actual length of c */
|
||||
} ForestElement;
|
||||
|
||||
static size_t min_len [ MAX_DEPTH ];
|
||||
|
||||
static int min_len_init = 0;
|
||||
|
||||
int CORD_max_len;
|
||||
|
||||
typedef ForestElement Forest [ MAX_DEPTH ];
|
||||
/* forest[i].len >= fib(i+1) */
|
||||
/* The string is the concatenation */
|
||||
/* of the forest in order of DECREASING */
|
||||
/* indices. */
|
||||
|
||||
void CORD_init_min_len()
|
||||
{
|
||||
register int i;
|
||||
register size_t last, previous, current;
|
||||
|
||||
min_len[0] = previous = 1;
|
||||
min_len[1] = last = 2;
|
||||
for (i = 2; i < MAX_DEPTH; i++) {
|
||||
current = last + previous;
|
||||
if (current < last) /* overflow */ current = last;
|
||||
min_len[i] = current;
|
||||
previous = last;
|
||||
last = current;
|
||||
}
|
||||
CORD_max_len = last - 1;
|
||||
min_len_init = 1;
|
||||
}
|
||||
|
||||
|
||||
void CORD_init_forest(ForestElement * forest, size_t max_len)
|
||||
{
|
||||
register int i;
|
||||
|
||||
for (i = 0; i < MAX_DEPTH; i++) {
|
||||
forest[i].c = 0;
|
||||
if (min_len[i] > max_len) return;
|
||||
}
|
||||
ABORT("Cord too long");
|
||||
}
|
||||
|
||||
/* Add a leaf to the appropriate level in the forest, cleaning */
|
||||
/* out lower levels as necessary. */
|
||||
/* Also works if x is a balanced tree of concatenations; however */
|
||||
/* in this case an extra concatenation node may be inserted above x; */
|
||||
/* This node should not be counted in the statement of the invariants. */
|
||||
void CORD_add_forest(ForestElement * forest, CORD x, size_t len)
|
||||
{
|
||||
register int i = 0;
|
||||
register CORD sum = CORD_EMPTY;
|
||||
register size_t sum_len = 0;
|
||||
|
||||
while (len > min_len[i + 1]) {
|
||||
if (forest[i].c != 0) {
|
||||
sum = CORD_cat(forest[i].c, sum);
|
||||
sum_len += forest[i].len;
|
||||
forest[i].c = 0;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
/* Sum has depth at most 1 greter than what would be required */
|
||||
/* for balance. */
|
||||
sum = CORD_cat(sum, x);
|
||||
sum_len += len;
|
||||
/* If x was a leaf, then sum is now balanced. To see this */
|
||||
/* consider the two cases in which forest[i-1] either is or is */
|
||||
/* not empty. */
|
||||
while (sum_len >= min_len[i]) {
|
||||
if (forest[i].c != 0) {
|
||||
sum = CORD_cat(forest[i].c, sum);
|
||||
sum_len += forest[i].len;
|
||||
/* This is again balanced, since sum was balanced, and has */
|
||||
/* allowable depth that differs from i by at most 1. */
|
||||
forest[i].c = 0;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
i--;
|
||||
forest[i].c = sum;
|
||||
forest[i].len = sum_len;
|
||||
}
|
||||
|
||||
CORD CORD_concat_forest(ForestElement * forest, size_t expected_len)
|
||||
{
|
||||
register int i = 0;
|
||||
CORD sum = 0;
|
||||
size_t sum_len = 0;
|
||||
|
||||
while (sum_len != expected_len) {
|
||||
if (forest[i].c != 0) {
|
||||
sum = CORD_cat(forest[i].c, sum);
|
||||
sum_len += forest[i].len;
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return(sum);
|
||||
}
|
||||
|
||||
/* Insert the frontier of x into forest. Balanced subtrees are */
|
||||
/* treated as leaves. This potentially adds one to the depth */
|
||||
/* of the final tree. */
|
||||
void CORD_balance_insert(CORD x, size_t len, ForestElement * forest)
|
||||
{
|
||||
register int depth;
|
||||
|
||||
if (CORD_IS_STRING(x)) {
|
||||
CORD_add_forest(forest, x, len);
|
||||
} else if (IS_CONCATENATION(x)
|
||||
&& ((depth = DEPTH(x)) >= MAX_DEPTH
|
||||
|| len < min_len[depth])) {
|
||||
register struct Concatenation * conc
|
||||
= &(((CordRep *)x) -> concatenation);
|
||||
size_t left_len = LEFT_LEN(conc);
|
||||
|
||||
CORD_balance_insert(conc -> left, left_len, forest);
|
||||
CORD_balance_insert(conc -> right, len - left_len, forest);
|
||||
} else /* function or balanced */ {
|
||||
CORD_add_forest(forest, x, len);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
CORD CORD_balance(CORD x)
|
||||
{
|
||||
Forest forest;
|
||||
register size_t len;
|
||||
|
||||
if (x == 0) return(0);
|
||||
if (CORD_IS_STRING(x)) return(x);
|
||||
if (!min_len_init) CORD_init_min_len();
|
||||
len = LEN(x);
|
||||
CORD_init_forest(forest, len);
|
||||
CORD_balance_insert(x, len, forest);
|
||||
return(CORD_concat_forest(forest, len));
|
||||
}
|
||||
|
||||
|
||||
/* Position primitives */
|
||||
|
||||
/* Private routines to deal with the hard cases only: */
|
||||
|
||||
/* P contains a prefix of the path to cur_pos. Extend it to a full */
|
||||
/* path and set up leaf info. */
|
||||
/* Return 0 if past the end of cord, 1 o.w. */
|
||||
void CORD__extend_path(register CORD_pos p)
|
||||
{
|
||||
register struct CORD_pe * current_pe = &(p[0].path[p[0].path_len]);
|
||||
register CORD top = current_pe -> pe_cord;
|
||||
register size_t pos = p[0].cur_pos;
|
||||
register size_t top_pos = current_pe -> pe_start_pos;
|
||||
register size_t top_len = GEN_LEN(top);
|
||||
|
||||
/* Fill in the rest of the path. */
|
||||
while(!CORD_IS_STRING(top) && IS_CONCATENATION(top)) {
|
||||
register struct Concatenation * conc =
|
||||
&(((CordRep *)top) -> concatenation);
|
||||
register size_t left_len;
|
||||
|
||||
left_len = LEFT_LEN(conc);
|
||||
current_pe++;
|
||||
if (pos >= top_pos + left_len) {
|
||||
current_pe -> pe_cord = top = conc -> right;
|
||||
current_pe -> pe_start_pos = top_pos = top_pos + left_len;
|
||||
top_len -= left_len;
|
||||
} else {
|
||||
current_pe -> pe_cord = top = conc -> left;
|
||||
current_pe -> pe_start_pos = top_pos;
|
||||
top_len = left_len;
|
||||
}
|
||||
p[0].path_len++;
|
||||
}
|
||||
/* Fill in leaf description for fast access. */
|
||||
if (CORD_IS_STRING(top)) {
|
||||
p[0].cur_leaf = top;
|
||||
p[0].cur_start = top_pos;
|
||||
p[0].cur_end = top_pos + top_len;
|
||||
} else {
|
||||
p[0].cur_end = 0;
|
||||
}
|
||||
if (pos >= top_pos + top_len) p[0].path_len = CORD_POS_INVALID;
|
||||
}
|
||||
|
||||
char CORD__pos_fetch(register CORD_pos p)
|
||||
{
|
||||
/* Leaf is a function node */
|
||||
struct CORD_pe * pe = &((p)[0].path[(p)[0].path_len]);
|
||||
CORD leaf = pe -> pe_cord;
|
||||
register struct Function * f = &(((CordRep *)leaf) -> function);
|
||||
|
||||
if (!IS_FUNCTION(leaf)) ABORT("CORD_pos_fetch: bad leaf");
|
||||
return ((*(f -> fn))(p[0].cur_pos - pe -> pe_start_pos, f -> client_data));
|
||||
}
|
||||
|
||||
void CORD__next(register CORD_pos p)
|
||||
{
|
||||
register size_t cur_pos = p[0].cur_pos + 1;
|
||||
register struct CORD_pe * current_pe = &((p)[0].path[(p)[0].path_len]);
|
||||
register CORD leaf = current_pe -> pe_cord;
|
||||
|
||||
/* Leaf is not a string or we're at end of leaf */
|
||||
p[0].cur_pos = cur_pos;
|
||||
if (!CORD_IS_STRING(leaf)) {
|
||||
/* Function leaf */
|
||||
register struct Function * f = &(((CordRep *)leaf) -> function);
|
||||
register size_t start_pos = current_pe -> pe_start_pos;
|
||||
register size_t end_pos = start_pos + f -> len;
|
||||
|
||||
if (cur_pos < end_pos) {
|
||||
/* Fill cache and return. */
|
||||
register size_t i;
|
||||
register size_t limit = cur_pos + FUNCTION_BUF_SZ;
|
||||
register CORD_fn fn = f -> fn;
|
||||
register void * client_data = f -> client_data;
|
||||
|
||||
if (limit > end_pos) {
|
||||
limit = end_pos;
|
||||
}
|
||||
for (i = cur_pos; i < limit; i++) {
|
||||
p[0].function_buf[i - cur_pos] =
|
||||
(*fn)(i - start_pos, client_data);
|
||||
}
|
||||
p[0].cur_start = cur_pos;
|
||||
p[0].cur_leaf = p[0].function_buf;
|
||||
p[0].cur_end = limit;
|
||||
return;
|
||||
}
|
||||
}
|
||||
/* End of leaf */
|
||||
/* Pop the stack until we find two concatenation nodes with the */
|
||||
/* same start position: this implies we were in left part. */
|
||||
{
|
||||
while (p[0].path_len > 0
|
||||
&& current_pe[0].pe_start_pos != current_pe[-1].pe_start_pos) {
|
||||
p[0].path_len--;
|
||||
current_pe--;
|
||||
}
|
||||
if (p[0].path_len == 0) {
|
||||
p[0].path_len = CORD_POS_INVALID;
|
||||
return;
|
||||
}
|
||||
}
|
||||
p[0].path_len--;
|
||||
CORD__extend_path(p);
|
||||
}
|
||||
|
||||
void CORD__prev(register CORD_pos p)
|
||||
{
|
||||
register struct CORD_pe * pe = &(p[0].path[p[0].path_len]);
|
||||
|
||||
if (p[0].cur_pos == 0) {
|
||||
p[0].path_len = CORD_POS_INVALID;
|
||||
return;
|
||||
}
|
||||
p[0].cur_pos--;
|
||||
if (p[0].cur_pos >= pe -> pe_start_pos) return;
|
||||
|
||||
/* Beginning of leaf */
|
||||
|
||||
/* Pop the stack until we find two concatenation nodes with the */
|
||||
/* different start position: this implies we were in right part. */
|
||||
{
|
||||
register struct CORD_pe * current_pe = &((p)[0].path[(p)[0].path_len]);
|
||||
|
||||
while (p[0].path_len > 0
|
||||
&& current_pe[0].pe_start_pos == current_pe[-1].pe_start_pos) {
|
||||
p[0].path_len--;
|
||||
current_pe--;
|
||||
}
|
||||
}
|
||||
p[0].path_len--;
|
||||
CORD__extend_path(p);
|
||||
}
|
||||
|
||||
#undef CORD_pos_fetch
|
||||
#undef CORD_next
|
||||
#undef CORD_prev
|
||||
#undef CORD_pos_to_index
|
||||
#undef CORD_pos_to_cord
|
||||
#undef CORD_pos_valid
|
||||
|
||||
char CORD_pos_fetch(register CORD_pos p)
|
||||
{
|
||||
if (p[0].cur_start <= p[0].cur_pos && p[0].cur_pos < p[0].cur_end) {
|
||||
return(p[0].cur_leaf[p[0].cur_pos - p[0].cur_start]);
|
||||
} else {
|
||||
return(CORD__pos_fetch(p));
|
||||
}
|
||||
}
|
||||
|
||||
void CORD_next(CORD_pos p)
|
||||
{
|
||||
if (p[0].cur_pos < p[0].cur_end - 1) {
|
||||
p[0].cur_pos++;
|
||||
} else {
|
||||
CORD__next(p);
|
||||
}
|
||||
}
|
||||
|
||||
void CORD_prev(CORD_pos p)
|
||||
{
|
||||
if (p[0].cur_end != 0 && p[0].cur_pos > p[0].cur_start) {
|
||||
p[0].cur_pos--;
|
||||
} else {
|
||||
CORD__prev(p);
|
||||
}
|
||||
}
|
||||
|
||||
size_t CORD_pos_to_index(CORD_pos p)
|
||||
{
|
||||
return(p[0].cur_pos);
|
||||
}
|
||||
|
||||
CORD CORD_pos_to_cord(CORD_pos p)
|
||||
{
|
||||
return(p[0].path[0].pe_cord);
|
||||
}
|
||||
|
||||
int CORD_pos_valid(CORD_pos p)
|
||||
{
|
||||
return(p[0].path_len != CORD_POS_INVALID);
|
||||
}
|
||||
|
||||
void CORD_set_pos(CORD_pos p, CORD x, size_t i)
|
||||
{
|
||||
if (x == CORD_EMPTY) {
|
||||
p[0].path_len = CORD_POS_INVALID;
|
||||
return;
|
||||
}
|
||||
p[0].path[0].pe_cord = x;
|
||||
p[0].path[0].pe_start_pos = 0;
|
||||
p[0].path_len = 0;
|
||||
p[0].cur_pos = i;
|
||||
CORD__extend_path(p);
|
||||
}
|
||||
@@ -1,390 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
/* An sprintf implementation that understands cords. This is probably */
|
||||
/* not terribly portable. It assumes an ANSI stdarg.h. It further */
|
||||
/* assumes that I can make copies of va_list variables, and read */
|
||||
/* arguments repeatedly by applyting va_arg to the copies. This */
|
||||
/* could be avoided at some performance cost. */
|
||||
/* We also assume that unsigned and signed integers of various kinds */
|
||||
/* have the same sizes, and can be cast back and forth. */
|
||||
/* We assume that void * and char * have the same size. */
|
||||
/* All this cruft is needed because we want to rely on the underlying */
|
||||
/* sprintf implementation whenever possible. */
|
||||
/* Boehm, September 21, 1995 6:00 pm PDT */
|
||||
|
||||
#include "cord.h"
|
||||
#include "ec.h"
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include <string.h>
|
||||
#include "gc.h"
|
||||
|
||||
#define CONV_SPEC_LEN 50 /* Maximum length of a single */
|
||||
/* conversion specification. */
|
||||
#define CONV_RESULT_LEN 50 /* Maximum length of any */
|
||||
/* conversion with default */
|
||||
/* width and prec. */
|
||||
|
||||
|
||||
static int ec_len(CORD_ec x)
|
||||
{
|
||||
return(CORD_len(x[0].ec_cord) + (x[0].ec_bufptr - x[0].ec_buf));
|
||||
}
|
||||
|
||||
/* Possible nonumeric precision values. */
|
||||
# define NONE -1
|
||||
# define VARIABLE -2
|
||||
/* Copy the conversion specification from CORD_pos into the buffer buf */
|
||||
/* Return negative on error. */
|
||||
/* Source initially points one past the leading %. */
|
||||
/* It is left pointing at the conversion type. */
|
||||
/* Assign field width and precision to *width and *prec. */
|
||||
/* If width or prec is *, VARIABLE is assigned. */
|
||||
/* Set *left to 1 if left adjustment flag is present. */
|
||||
/* Set *long_arg to 1 if long flag ('l' or 'L') is present, or to */
|
||||
/* -1 if 'h' is present. */
|
||||
static int extract_conv_spec(CORD_pos source, char *buf,
|
||||
int * width, int *prec, int *left, int * long_arg)
|
||||
{
|
||||
register int result = 0;
|
||||
register int current_number = 0;
|
||||
register int saw_period = 0;
|
||||
register int saw_number;
|
||||
register int chars_so_far = 0;
|
||||
register char current;
|
||||
|
||||
*width = NONE;
|
||||
buf[chars_so_far++] = '%';
|
||||
while(CORD_pos_valid(source)) {
|
||||
if (chars_so_far >= CONV_SPEC_LEN) return(-1);
|
||||
current = CORD_pos_fetch(source);
|
||||
buf[chars_so_far++] = current;
|
||||
switch(current) {
|
||||
case '*':
|
||||
saw_number = 1;
|
||||
current_number = VARIABLE;
|
||||
break;
|
||||
case '0':
|
||||
if (!saw_number) {
|
||||
/* Zero fill flag; ignore */
|
||||
break;
|
||||
} /* otherwise fall through: */
|
||||
case '1':
|
||||
case '2':
|
||||
case '3':
|
||||
case '4':
|
||||
case '5':
|
||||
case '6':
|
||||
case '7':
|
||||
case '8':
|
||||
case '9':
|
||||
saw_number = 1;
|
||||
current_number *= 10;
|
||||
current_number += current - '0';
|
||||
break;
|
||||
case '.':
|
||||
saw_period = 1;
|
||||
if(saw_number) {
|
||||
*width = current_number;
|
||||
saw_number = 0;
|
||||
}
|
||||
current_number = 0;
|
||||
break;
|
||||
case 'l':
|
||||
case 'L':
|
||||
*long_arg = 1;
|
||||
current_number = 0;
|
||||
break;
|
||||
case 'h':
|
||||
*long_arg = -1;
|
||||
current_number = 0;
|
||||
break;
|
||||
case ' ':
|
||||
case '+':
|
||||
case '#':
|
||||
current_number = 0;
|
||||
break;
|
||||
case '-':
|
||||
*left = 1;
|
||||
current_number = 0;
|
||||
break;
|
||||
case 'd':
|
||||
case 'i':
|
||||
case 'o':
|
||||
case 'u':
|
||||
case 'x':
|
||||
case 'X':
|
||||
case 'f':
|
||||
case 'e':
|
||||
case 'E':
|
||||
case 'g':
|
||||
case 'G':
|
||||
case 'c':
|
||||
case 'C':
|
||||
case 's':
|
||||
case 'S':
|
||||
case 'p':
|
||||
case 'n':
|
||||
case 'r':
|
||||
goto done;
|
||||
default:
|
||||
return(-1);
|
||||
}
|
||||
CORD_next(source);
|
||||
}
|
||||
return(-1);
|
||||
done:
|
||||
if (saw_number) {
|
||||
if (saw_period) {
|
||||
*prec = current_number;
|
||||
} else {
|
||||
*prec = NONE;
|
||||
*width = current_number;
|
||||
}
|
||||
} else {
|
||||
*prec = NONE;
|
||||
}
|
||||
buf[chars_so_far] = '\0';
|
||||
return(result);
|
||||
}
|
||||
|
||||
int CORD_vsprintf(CORD * out, CORD format, va_list args)
|
||||
{
|
||||
CORD_ec result;
|
||||
register int count;
|
||||
register char current;
|
||||
CORD_pos pos;
|
||||
char conv_spec[CONV_SPEC_LEN + 1];
|
||||
|
||||
CORD_ec_init(result);
|
||||
for (CORD_set_pos(pos, format, 0); CORD_pos_valid(pos); CORD_next(pos)) {
|
||||
current = CORD_pos_fetch(pos);
|
||||
if (current == '%') {
|
||||
CORD_next(pos);
|
||||
if (!CORD_pos_valid(pos)) return(-1);
|
||||
current = CORD_pos_fetch(pos);
|
||||
if (current == '%') {
|
||||
CORD_ec_append(result, current);
|
||||
} else {
|
||||
int width, prec;
|
||||
int left_adj = 0;
|
||||
int long_arg = 0;
|
||||
CORD arg;
|
||||
size_t len;
|
||||
|
||||
if (extract_conv_spec(pos, conv_spec,
|
||||
&width, &prec,
|
||||
&left_adj, &long_arg) < 0) {
|
||||
return(-1);
|
||||
}
|
||||
current = CORD_pos_fetch(pos);
|
||||
switch(current) {
|
||||
case 'n':
|
||||
/* Assign length to next arg */
|
||||
if (long_arg == 0) {
|
||||
int * pos_ptr;
|
||||
pos_ptr = va_arg(args, int *);
|
||||
*pos_ptr = ec_len(result);
|
||||
} else if (long_arg > 0) {
|
||||
long * pos_ptr;
|
||||
pos_ptr = va_arg(args, long *);
|
||||
*pos_ptr = ec_len(result);
|
||||
} else {
|
||||
short * pos_ptr;
|
||||
pos_ptr = va_arg(args, short *);
|
||||
*pos_ptr = ec_len(result);
|
||||
}
|
||||
goto done;
|
||||
case 'r':
|
||||
/* Append cord and any padding */
|
||||
if (width == VARIABLE) width = va_arg(args, int);
|
||||
if (prec == VARIABLE) prec = va_arg(args, int);
|
||||
arg = va_arg(args, CORD);
|
||||
len = CORD_len(arg);
|
||||
if (prec != NONE && len > prec) {
|
||||
if (prec < 0) return(-1);
|
||||
arg = CORD_substr(arg, 0, prec);
|
||||
len = prec;
|
||||
}
|
||||
if (width != NONE && len < width) {
|
||||
char * blanks = GC_MALLOC_ATOMIC(width-len+1);
|
||||
|
||||
memset(blanks, ' ', width-len);
|
||||
blanks[width-len] = '\0';
|
||||
if (left_adj) {
|
||||
arg = CORD_cat(arg, blanks);
|
||||
} else {
|
||||
arg = CORD_cat(blanks, arg);
|
||||
}
|
||||
}
|
||||
CORD_ec_append_cord(result, arg);
|
||||
goto done;
|
||||
case 'c':
|
||||
if (width == NONE && prec == NONE) {
|
||||
register char c;
|
||||
|
||||
c = va_arg(args, int);
|
||||
CORD_ec_append(result, c);
|
||||
goto done;
|
||||
}
|
||||
break;
|
||||
case 's':
|
||||
if (width == NONE && prec == NONE) {
|
||||
char * str = va_arg(args, char *);
|
||||
register char c;
|
||||
|
||||
while (c = *str++) {
|
||||
CORD_ec_append(result, c);
|
||||
}
|
||||
goto done;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
/* Use standard sprintf to perform conversion */
|
||||
{
|
||||
register char * buf;
|
||||
va_list vsprintf_args = args;
|
||||
/* The above does not appear to be sanctioned */
|
||||
/* by the ANSI C standard. */
|
||||
int max_size = 0;
|
||||
int res;
|
||||
|
||||
if (width == VARIABLE) width = va_arg(args, int);
|
||||
if (prec == VARIABLE) prec = va_arg(args, int);
|
||||
if (width != NONE) max_size = width;
|
||||
if (prec != NONE && prec > max_size) max_size = prec;
|
||||
max_size += CONV_RESULT_LEN;
|
||||
if (max_size >= CORD_BUFSZ) {
|
||||
buf = GC_MALLOC_ATOMIC(max_size + 1);
|
||||
} else {
|
||||
if (CORD_BUFSZ - (result[0].ec_bufptr-result[0].ec_buf)
|
||||
< max_size) {
|
||||
CORD_ec_flush_buf(result);
|
||||
}
|
||||
buf = result[0].ec_bufptr;
|
||||
}
|
||||
switch(current) {
|
||||
case 'd':
|
||||
case 'i':
|
||||
case 'o':
|
||||
case 'u':
|
||||
case 'x':
|
||||
case 'X':
|
||||
case 'c':
|
||||
if (long_arg <= 0) {
|
||||
(void) va_arg(args, int);
|
||||
} else if (long_arg > 0) {
|
||||
(void) va_arg(args, long);
|
||||
}
|
||||
break;
|
||||
case 's':
|
||||
case 'p':
|
||||
(void) va_arg(args, char *);
|
||||
break;
|
||||
case 'f':
|
||||
case 'e':
|
||||
case 'E':
|
||||
case 'g':
|
||||
case 'G':
|
||||
(void) va_arg(args, double);
|
||||
break;
|
||||
default:
|
||||
return(-1);
|
||||
}
|
||||
res = vsprintf(buf, conv_spec, vsprintf_args);
|
||||
len = (size_t)res;
|
||||
if ((char *)(GC_word)res == buf) {
|
||||
/* old style vsprintf */
|
||||
len = strlen(buf);
|
||||
} else if (res < 0) {
|
||||
return(-1);
|
||||
}
|
||||
if (buf != result[0].ec_bufptr) {
|
||||
register char c;
|
||||
|
||||
while (c = *buf++) {
|
||||
CORD_ec_append(result, c);
|
||||
}
|
||||
} else {
|
||||
result[0].ec_bufptr = buf + len;
|
||||
}
|
||||
}
|
||||
done:;
|
||||
}
|
||||
} else {
|
||||
CORD_ec_append(result, current);
|
||||
}
|
||||
}
|
||||
count = ec_len(result);
|
||||
*out = CORD_balance(CORD_ec_to_cord(result));
|
||||
return(count);
|
||||
}
|
||||
|
||||
int CORD_sprintf(CORD * out, CORD format, ...)
|
||||
{
|
||||
va_list args;
|
||||
int result;
|
||||
|
||||
va_start(args, format);
|
||||
result = CORD_vsprintf(out, format, args);
|
||||
va_end(args);
|
||||
return(result);
|
||||
}
|
||||
|
||||
int CORD_fprintf(FILE * f, CORD format, ...)
|
||||
{
|
||||
va_list args;
|
||||
int result;
|
||||
CORD out;
|
||||
|
||||
va_start(args, format);
|
||||
result = CORD_vsprintf(&out, format, args);
|
||||
va_end(args);
|
||||
if (result > 0) CORD_put(out, f);
|
||||
return(result);
|
||||
}
|
||||
|
||||
int CORD_vfprintf(FILE * f, CORD format, va_list args)
|
||||
{
|
||||
int result;
|
||||
CORD out;
|
||||
|
||||
result = CORD_vsprintf(&out, format, args);
|
||||
if (result > 0) CORD_put(out, f);
|
||||
return(result);
|
||||
}
|
||||
|
||||
int CORD_printf(CORD format, ...)
|
||||
{
|
||||
va_list args;
|
||||
int result;
|
||||
CORD out;
|
||||
|
||||
va_start(args, format);
|
||||
result = CORD_vsprintf(&out, format, args);
|
||||
va_end(args);
|
||||
if (result > 0) CORD_put(out, stdout);
|
||||
return(result);
|
||||
}
|
||||
|
||||
int CORD_vprintf(CORD format, va_list args)
|
||||
{
|
||||
int result;
|
||||
CORD out;
|
||||
|
||||
result = CORD_vsprintf(&out, format, args);
|
||||
if (result > 0) CORD_put(out, stdout);
|
||||
return(result);
|
||||
}
|
||||
@@ -1,229 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
/* Boehm, August 24, 1994 11:58 am PDT */
|
||||
# include "cord.h"
|
||||
# include <string.h>
|
||||
# include <stdio.h>
|
||||
# include <stdlib.h>
|
||||
/* This is a very incomplete test of the cord package. It knows about */
|
||||
/* a few internals of the package (e.g. when C strings are returned) */
|
||||
/* that real clients shouldn't rely on. */
|
||||
|
||||
# define ABORT(string) \
|
||||
{ int x = 0; fprintf(stderr, "FAILED: %s\n", string); x = 1 / x; abort(); }
|
||||
|
||||
int count;
|
||||
|
||||
int test_fn(char c, void * client_data)
|
||||
{
|
||||
if (client_data != (void *)13) ABORT("bad client data");
|
||||
if (count < 64*1024+1) {
|
||||
if ((count & 1) == 0) {
|
||||
if (c != 'b') ABORT("bad char");
|
||||
} else {
|
||||
if (c != 'a') ABORT("bad char");
|
||||
}
|
||||
count++;
|
||||
return(0);
|
||||
} else {
|
||||
if (c != 'c') ABORT("bad char");
|
||||
count++;
|
||||
return(1);
|
||||
}
|
||||
}
|
||||
|
||||
char id_cord_fn(size_t i, void * client_data)
|
||||
{
|
||||
return((char)i);
|
||||
}
|
||||
|
||||
void test_basics()
|
||||
{
|
||||
CORD x = CORD_from_char_star("ab");
|
||||
register int i;
|
||||
char c;
|
||||
CORD y;
|
||||
CORD_pos p;
|
||||
|
||||
x = CORD_cat(x,x);
|
||||
if (!CORD_IS_STRING(x)) ABORT("short cord should usually be a string");
|
||||
if (strcmp(x, "abab") != 0) ABORT("bad CORD_cat result");
|
||||
|
||||
for (i = 1; i < 16; i++) {
|
||||
x = CORD_cat(x,x);
|
||||
}
|
||||
x = CORD_cat(x,"c");
|
||||
if (CORD_len(x) != 128*1024+1) ABORT("bad length");
|
||||
|
||||
count = 0;
|
||||
if (CORD_iter5(x, 64*1024-1, test_fn, CORD_NO_FN, (void *)13) == 0) {
|
||||
ABORT("CORD_iter5 failed");
|
||||
}
|
||||
if (count != 64*1024 + 2) ABORT("CORD_iter5 failed");
|
||||
|
||||
count = 0;
|
||||
CORD_set_pos(p, x, 64*1024-1);
|
||||
while(CORD_pos_valid(p)) {
|
||||
(void) test_fn(CORD_pos_fetch(p), (void *)13);
|
||||
CORD_next(p);
|
||||
}
|
||||
if (count != 64*1024 + 2) ABORT("Position based iteration failed");
|
||||
|
||||
y = CORD_substr(x, 1023, 5);
|
||||
if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string");
|
||||
if (strcmp(y, "babab") != 0) ABORT("bad CORD_substr result");
|
||||
|
||||
y = CORD_substr(x, 1024, 8);
|
||||
if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string");
|
||||
if (strcmp(y, "abababab") != 0) ABORT("bad CORD_substr result");
|
||||
|
||||
y = CORD_substr(x, 128*1024-1, 8);
|
||||
if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string");
|
||||
if (strcmp(y, "bc") != 0) ABORT("bad CORD_substr result");
|
||||
|
||||
x = CORD_balance(x);
|
||||
if (CORD_len(x) != 128*1024+1) ABORT("bad length");
|
||||
|
||||
count = 0;
|
||||
if (CORD_iter5(x, 64*1024-1, test_fn, CORD_NO_FN, (void *)13) == 0) {
|
||||
ABORT("CORD_iter5 failed");
|
||||
}
|
||||
if (count != 64*1024 + 2) ABORT("CORD_iter5 failed");
|
||||
|
||||
y = CORD_substr(x, 1023, 5);
|
||||
if (!CORD_IS_STRING(y)) ABORT("short cord should usually be a string");
|
||||
if (strcmp(y, "babab") != 0) ABORT("bad CORD_substr result");
|
||||
y = CORD_from_fn(id_cord_fn, 0, 13);
|
||||
i = 0;
|
||||
CORD_set_pos(p, y, i);
|
||||
while(CORD_pos_valid(p)) {
|
||||
c = CORD_pos_fetch(p);
|
||||
if(c != i) ABORT("Traversal of function node failed");
|
||||
CORD_next(p); i++;
|
||||
}
|
||||
if (i != 13) ABORT("Bad apparent length for function node");
|
||||
}
|
||||
|
||||
void test_extras()
|
||||
{
|
||||
# if defined(__OS2__)
|
||||
# define FNAME1 "tmp1"
|
||||
# define FNAME2 "tmp2"
|
||||
# elif defined(AMIGA)
|
||||
# define FNAME1 "T:tmp1"
|
||||
# define FNAME2 "T:tmp2"
|
||||
# else
|
||||
# define FNAME1 "/tmp/cord_test"
|
||||
# define FNAME2 "/tmp/cord_test2"
|
||||
# endif
|
||||
register int i;
|
||||
CORD y = "abcdefghijklmnopqrstuvwxyz0123456789";
|
||||
CORD x = "{}";
|
||||
CORD w, z;
|
||||
FILE *f;
|
||||
FILE *f1a, *f1b, *f2;
|
||||
|
||||
w = CORD_cat(CORD_cat(y,y),y);
|
||||
z = CORD_catn(3,y,y,y);
|
||||
if (CORD_cmp(w,z) != 0) ABORT("CORD_catn comparison wrong");
|
||||
for (i = 1; i < 100; i++) {
|
||||
x = CORD_cat(x, y);
|
||||
}
|
||||
z = CORD_balance(x);
|
||||
if (CORD_cmp(x,z) != 0) ABORT("balanced string comparison wrong");
|
||||
if (CORD_cmp(x,CORD_cat(z, CORD_nul(13))) >= 0) ABORT("comparison 2");
|
||||
if (CORD_cmp(CORD_cat(x, CORD_nul(13)), z) <= 0) ABORT("comparison 3");
|
||||
if (CORD_cmp(x,CORD_cat(z, "13")) >= 0) ABORT("comparison 4");
|
||||
if ((f = fopen(FNAME1, "w")) == 0) ABORT("open failed");
|
||||
if (CORD_put(z,f) == EOF) ABORT("CORD_put failed");
|
||||
if (fclose(f) == EOF) ABORT("fclose failed");
|
||||
w = CORD_from_file(f1a = fopen(FNAME1, "rb"));
|
||||
if (CORD_len(w) != CORD_len(z)) ABORT("file length wrong");
|
||||
if (CORD_cmp(w,z) != 0) ABORT("file comparison wrong");
|
||||
if (CORD_cmp(CORD_substr(w, 50*36+2, 36), y) != 0)
|
||||
ABORT("file substr wrong");
|
||||
z = CORD_from_file_lazy(f1b = fopen(FNAME1, "rb"));
|
||||
if (CORD_cmp(w,z) != 0) ABORT("File conversions differ");
|
||||
if (CORD_chr(w, 0, '9') != 37) ABORT("CORD_chr failed 1");
|
||||
if (CORD_chr(w, 3, 'a') != 38) ABORT("CORD_chr failed 2");
|
||||
if (CORD_rchr(w, CORD_len(w) - 1, '}') != 1) ABORT("CORD_rchr failed");
|
||||
x = y;
|
||||
for (i = 1; i < 14; i++) {
|
||||
x = CORD_cat(x,x);
|
||||
}
|
||||
if ((f = fopen(FNAME2, "w")) == 0) ABORT("2nd open failed");
|
||||
if (CORD_put(x,f) == EOF) ABORT("CORD_put failed");
|
||||
if (fclose(f) == EOF) ABORT("fclose failed");
|
||||
w = CORD_from_file(f2 = fopen(FNAME2, "rb"));
|
||||
if (CORD_len(w) != CORD_len(x)) ABORT("file length wrong");
|
||||
if (CORD_cmp(w,x) != 0) ABORT("file comparison wrong");
|
||||
if (CORD_cmp(CORD_substr(w, 1000*36, 36), y) != 0)
|
||||
ABORT("file substr wrong");
|
||||
if (strcmp(CORD_to_char_star(CORD_substr(w, 1000*36, 36)), y) != 0)
|
||||
ABORT("char * file substr wrong");
|
||||
if (strcmp(CORD_substr(w, 1000*36, 2), "ab") != 0)
|
||||
ABORT("short file substr wrong");
|
||||
if (CORD_str(x,1,"9a") != 35) ABORT("CORD_str failed 1");
|
||||
if (CORD_str(x,0,"9abcdefghijk") != 35) ABORT("CORD_str failed 2");
|
||||
if (CORD_str(x,0,"9abcdefghijx") != CORD_NOT_FOUND)
|
||||
ABORT("CORD_str failed 3");
|
||||
if (CORD_str(x,0,"9>") != CORD_NOT_FOUND) ABORT("CORD_str failed 4");
|
||||
if (remove(FNAME1) != 0) {
|
||||
/* On some systems, e.g. OS2, this may fail if f1 is still open. */
|
||||
if ((fclose(f1a) == EOF) & (fclose(f1b) == EOF))
|
||||
ABORT("fclose(f1) failed");
|
||||
if (remove(FNAME1) != 0) ABORT("remove 1 failed");
|
||||
}
|
||||
if (remove(FNAME2) != 0) {
|
||||
if (fclose(f2) == EOF) ABORT("fclose(f2) failed");
|
||||
if (remove(FNAME2) != 0) ABORT("remove 2 failed");
|
||||
}
|
||||
}
|
||||
|
||||
void test_printf()
|
||||
{
|
||||
CORD result;
|
||||
char result2[200];
|
||||
long l;
|
||||
short s;
|
||||
CORD x;
|
||||
|
||||
if (CORD_sprintf(&result, "%7.2f%ln", 3.14159F, &l) != 7)
|
||||
ABORT("CORD_sprintf failed 1");
|
||||
if (CORD_cmp(result, " 3.14") != 0)ABORT("CORD_sprintf goofed 1");
|
||||
if (l != 7) ABORT("CORD_sprintf goofed 2");
|
||||
if (CORD_sprintf(&result, "%-7.2s%hn%c%s", "abcd", &s, 'x', "yz") != 10)
|
||||
ABORT("CORD_sprintf failed 2");
|
||||
if (CORD_cmp(result, "ab xyz") != 0)ABORT("CORD_sprintf goofed 3");
|
||||
if (s != 7) ABORT("CORD_sprintf goofed 4");
|
||||
x = "abcdefghij";
|
||||
x = CORD_cat(x,x);
|
||||
x = CORD_cat(x,x);
|
||||
x = CORD_cat(x,x);
|
||||
if (CORD_sprintf(&result, "->%-120.78r!\n", x) != 124)
|
||||
ABORT("CORD_sprintf failed 3");
|
||||
(void) sprintf(result2, "->%-120.78s!\n", CORD_to_char_star(x));
|
||||
if (CORD_cmp(result, result2) != 0)ABORT("CORD_sprintf goofed 5");
|
||||
}
|
||||
|
||||
main()
|
||||
{
|
||||
# ifdef THINK_C
|
||||
printf("cordtest:\n");
|
||||
# endif
|
||||
test_basics();
|
||||
test_extras();
|
||||
test_printf();
|
||||
CORD_fprintf(stderr, "SUCCEEDED\n");
|
||||
return(0);
|
||||
}
|
||||
@@ -1,621 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*
|
||||
* Author: Hans-J. Boehm (boehm@parc.xerox.com)
|
||||
*/
|
||||
/*
|
||||
* These are functions on cords that do not need to understand their
|
||||
* implementation. They serve also serve as example client code for
|
||||
* cord_basics.
|
||||
*/
|
||||
/* Boehm, December 8, 1995 1:53 pm PST */
|
||||
# include <stdio.h>
|
||||
# include <string.h>
|
||||
# include <stdlib.h>
|
||||
# include <stdarg.h>
|
||||
# include "cord.h"
|
||||
# include "ec.h"
|
||||
# define I_HIDE_POINTERS /* So we get access to allocation lock. */
|
||||
/* We use this for lazy file reading, */
|
||||
/* so that we remain independent */
|
||||
/* of the threads primitives. */
|
||||
# include "gc.h"
|
||||
|
||||
/* For now we assume that pointer reads and writes are atomic, */
|
||||
/* i.e. another thread always sees the state before or after */
|
||||
/* a write. This might be false on a Motorola M68K with */
|
||||
/* pointers that are not 32-bit aligned. But there probably */
|
||||
/* aren't too many threads packages running on those. */
|
||||
# define ATOMIC_WRITE(x,y) (x) = (y)
|
||||
# define ATOMIC_READ(x) (*(x))
|
||||
|
||||
/* The standard says these are in stdio.h, but they aren't always: */
|
||||
# ifndef SEEK_SET
|
||||
# define SEEK_SET 0
|
||||
# endif
|
||||
# ifndef SEEK_END
|
||||
# define SEEK_END 2
|
||||
# endif
|
||||
|
||||
# define BUFSZ 2048 /* Size of stack allocated buffers when */
|
||||
/* we want large buffers. */
|
||||
|
||||
typedef void (* oom_fn)(void);
|
||||
|
||||
# define OUT_OF_MEMORY { if (CORD_oom_fn != (oom_fn) 0) (*CORD_oom_fn)(); \
|
||||
ABORT("Out of memory\n"); }
|
||||
# define ABORT(msg) { fprintf(stderr, "%s\n", msg); abort(); }
|
||||
|
||||
CORD CORD_cat_char(CORD x, char c)
|
||||
{
|
||||
register char * string;
|
||||
|
||||
if (c == '\0') return(CORD_cat(x, CORD_nul(1)));
|
||||
string = GC_MALLOC_ATOMIC(2);
|
||||
if (string == 0) OUT_OF_MEMORY;
|
||||
string[0] = c;
|
||||
string[1] = '\0';
|
||||
return(CORD_cat_char_star(x, string, 1));
|
||||
}
|
||||
|
||||
CORD CORD_catn(int nargs, ...)
|
||||
{
|
||||
register CORD result = CORD_EMPTY;
|
||||
va_list args;
|
||||
register int i;
|
||||
|
||||
va_start(args, nargs);
|
||||
for (i = 0; i < nargs; i++) {
|
||||
register CORD next = va_arg(args, CORD);
|
||||
result = CORD_cat(result, next);
|
||||
}
|
||||
va_end(args);
|
||||
return(result);
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
size_t len;
|
||||
size_t count;
|
||||
char * buf;
|
||||
} CORD_fill_data;
|
||||
|
||||
int CORD_fill_proc(char c, void * client_data)
|
||||
{
|
||||
register CORD_fill_data * d = (CORD_fill_data *)client_data;
|
||||
register size_t count = d -> count;
|
||||
|
||||
(d -> buf)[count] = c;
|
||||
d -> count = ++count;
|
||||
if (count >= d -> len) {
|
||||
return(1);
|
||||
} else {
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
|
||||
int CORD_batched_fill_proc(const char * s, void * client_data)
|
||||
{
|
||||
register CORD_fill_data * d = (CORD_fill_data *)client_data;
|
||||
register size_t count = d -> count;
|
||||
register size_t max = d -> len;
|
||||
register char * buf = d -> buf;
|
||||
register const char * t = s;
|
||||
|
||||
while((buf[count] = *t++) != '\0') {
|
||||
count++;
|
||||
if (count >= max) {
|
||||
d -> count = count;
|
||||
return(1);
|
||||
}
|
||||
}
|
||||
d -> count = count;
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Fill buf with len characters starting at i. */
|
||||
/* Assumes len characters are available. */
|
||||
void CORD_fill_buf(CORD x, size_t i, size_t len, char * buf)
|
||||
{
|
||||
CORD_fill_data fd;
|
||||
|
||||
fd.len = len;
|
||||
fd.buf = buf;
|
||||
fd.count = 0;
|
||||
(void)CORD_iter5(x, i, CORD_fill_proc, CORD_batched_fill_proc, &fd);
|
||||
}
|
||||
|
||||
int CORD_cmp(CORD x, CORD y)
|
||||
{
|
||||
CORD_pos xpos;
|
||||
CORD_pos ypos;
|
||||
register size_t avail, yavail;
|
||||
|
||||
if (y == CORD_EMPTY) return(x != CORD_EMPTY);
|
||||
if (x == CORD_EMPTY) return(-1);
|
||||
if (CORD_IS_STRING(y) && CORD_IS_STRING(x)) return(strcmp(x,y));
|
||||
CORD_set_pos(xpos, x, 0);
|
||||
CORD_set_pos(ypos, y, 0);
|
||||
for(;;) {
|
||||
if (!CORD_pos_valid(xpos)) {
|
||||
if (CORD_pos_valid(ypos)) {
|
||||
return(-1);
|
||||
} else {
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
if (!CORD_pos_valid(ypos)) {
|
||||
return(1);
|
||||
}
|
||||
if ((avail = CORD_pos_chars_left(xpos)) <= 0
|
||||
|| (yavail = CORD_pos_chars_left(ypos)) <= 0) {
|
||||
register char xcurrent = CORD_pos_fetch(xpos);
|
||||
register char ycurrent = CORD_pos_fetch(ypos);
|
||||
if (xcurrent != ycurrent) return(xcurrent - ycurrent);
|
||||
CORD_next(xpos);
|
||||
CORD_next(ypos);
|
||||
} else {
|
||||
/* process as many characters as we can */
|
||||
register int result;
|
||||
|
||||
if (avail > yavail) avail = yavail;
|
||||
result = strncmp(CORD_pos_cur_char_addr(xpos),
|
||||
CORD_pos_cur_char_addr(ypos), avail);
|
||||
if (result != 0) return(result);
|
||||
CORD_pos_advance(xpos, avail);
|
||||
CORD_pos_advance(ypos, avail);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int CORD_ncmp(CORD x, size_t x_start, CORD y, size_t y_start, size_t len)
|
||||
{
|
||||
CORD_pos xpos;
|
||||
CORD_pos ypos;
|
||||
register size_t count;
|
||||
register long avail, yavail;
|
||||
|
||||
CORD_set_pos(xpos, x, x_start);
|
||||
CORD_set_pos(ypos, y, y_start);
|
||||
for(count = 0; count < len;) {
|
||||
if (!CORD_pos_valid(xpos)) {
|
||||
if (CORD_pos_valid(ypos)) {
|
||||
return(-1);
|
||||
} else {
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
if (!CORD_pos_valid(ypos)) {
|
||||
return(1);
|
||||
}
|
||||
if ((avail = CORD_pos_chars_left(xpos)) <= 0
|
||||
|| (yavail = CORD_pos_chars_left(ypos)) <= 0) {
|
||||
register char xcurrent = CORD_pos_fetch(xpos);
|
||||
register char ycurrent = CORD_pos_fetch(ypos);
|
||||
if (xcurrent != ycurrent) return(xcurrent - ycurrent);
|
||||
CORD_next(xpos);
|
||||
CORD_next(ypos);
|
||||
count++;
|
||||
} else {
|
||||
/* process as many characters as we can */
|
||||
register int result;
|
||||
|
||||
if (avail > yavail) avail = yavail;
|
||||
count += avail;
|
||||
if (count > len) avail -= (count - len);
|
||||
result = strncmp(CORD_pos_cur_char_addr(xpos),
|
||||
CORD_pos_cur_char_addr(ypos), (size_t)avail);
|
||||
if (result != 0) return(result);
|
||||
CORD_pos_advance(xpos, (size_t)avail);
|
||||
CORD_pos_advance(ypos, (size_t)avail);
|
||||
}
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
char * CORD_to_char_star(CORD x)
|
||||
{
|
||||
register size_t len = CORD_len(x);
|
||||
char * result = GC_MALLOC_ATOMIC(len + 1);
|
||||
|
||||
if (result == 0) OUT_OF_MEMORY;
|
||||
CORD_fill_buf(x, 0, len, result);
|
||||
result[len] = '\0';
|
||||
return(result);
|
||||
}
|
||||
|
||||
CORD CORD_from_char_star(const char *s)
|
||||
{
|
||||
char * result;
|
||||
size_t len = strlen(s);
|
||||
|
||||
if (0 == len) return(CORD_EMPTY);
|
||||
result = GC_MALLOC_ATOMIC(len + 1);
|
||||
if (result == 0) OUT_OF_MEMORY;
|
||||
memcpy(result, s, len+1);
|
||||
return(result);
|
||||
}
|
||||
|
||||
const char * CORD_to_const_char_star(CORD x)
|
||||
{
|
||||
if (x == 0) return("");
|
||||
if (CORD_IS_STRING(x)) return((const char *)x);
|
||||
return(CORD_to_char_star(x));
|
||||
}
|
||||
|
||||
char CORD_fetch(CORD x, size_t i)
|
||||
{
|
||||
CORD_pos xpos;
|
||||
|
||||
CORD_set_pos(xpos, x, i);
|
||||
if (!CORD_pos_valid(xpos)) ABORT("bad index?");
|
||||
return(CORD_pos_fetch(xpos));
|
||||
}
|
||||
|
||||
|
||||
int CORD_put_proc(char c, void * client_data)
|
||||
{
|
||||
register FILE * f = (FILE *)client_data;
|
||||
|
||||
return(putc(c, f) == EOF);
|
||||
}
|
||||
|
||||
int CORD_batched_put_proc(const char * s, void * client_data)
|
||||
{
|
||||
register FILE * f = (FILE *)client_data;
|
||||
|
||||
return(fputs(s, f) == EOF);
|
||||
}
|
||||
|
||||
|
||||
int CORD_put(CORD x, FILE * f)
|
||||
{
|
||||
if (CORD_iter5(x, 0, CORD_put_proc, CORD_batched_put_proc, f)) {
|
||||
return(EOF);
|
||||
} else {
|
||||
return(1);
|
||||
}
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
size_t pos; /* Current position in the cord */
|
||||
char target; /* Character we're looking for */
|
||||
} chr_data;
|
||||
|
||||
int CORD_chr_proc(char c, void * client_data)
|
||||
{
|
||||
register chr_data * d = (chr_data *)client_data;
|
||||
|
||||
if (c == d -> target) return(1);
|
||||
(d -> pos) ++;
|
||||
return(0);
|
||||
}
|
||||
|
||||
int CORD_rchr_proc(char c, void * client_data)
|
||||
{
|
||||
register chr_data * d = (chr_data *)client_data;
|
||||
|
||||
if (c == d -> target) return(1);
|
||||
(d -> pos) --;
|
||||
return(0);
|
||||
}
|
||||
|
||||
int CORD_batched_chr_proc(const char *s, void * client_data)
|
||||
{
|
||||
register chr_data * d = (chr_data *)client_data;
|
||||
register char * occ = strchr(s, d -> target);
|
||||
|
||||
if (occ == 0) {
|
||||
d -> pos += strlen(s);
|
||||
return(0);
|
||||
} else {
|
||||
d -> pos += occ - s;
|
||||
return(1);
|
||||
}
|
||||
}
|
||||
|
||||
size_t CORD_chr(CORD x, size_t i, int c)
|
||||
{
|
||||
chr_data d;
|
||||
|
||||
d.pos = i;
|
||||
d.target = c;
|
||||
if (CORD_iter5(x, i, CORD_chr_proc, CORD_batched_chr_proc, &d)) {
|
||||
return(d.pos);
|
||||
} else {
|
||||
return(CORD_NOT_FOUND);
|
||||
}
|
||||
}
|
||||
|
||||
size_t CORD_rchr(CORD x, size_t i, int c)
|
||||
{
|
||||
chr_data d;
|
||||
|
||||
d.pos = i;
|
||||
d.target = c;
|
||||
if (CORD_riter4(x, i, CORD_rchr_proc, &d)) {
|
||||
return(d.pos);
|
||||
} else {
|
||||
return(CORD_NOT_FOUND);
|
||||
}
|
||||
}
|
||||
|
||||
/* Find the first occurrence of s in x at position start or later. */
|
||||
/* This uses an asymptotically poor algorithm, which should typically */
|
||||
/* perform acceptably. We compare the first few characters directly, */
|
||||
/* and call CORD_ncmp whenever there is a partial match. */
|
||||
/* This has the advantage that we allocate very little, or not at all. */
|
||||
/* It's very fast if there are few close misses. */
|
||||
size_t CORD_str(CORD x, size_t start, CORD s)
|
||||
{
|
||||
CORD_pos xpos;
|
||||
size_t xlen = CORD_len(x);
|
||||
size_t slen;
|
||||
register size_t start_len;
|
||||
const char * s_start;
|
||||
unsigned long s_buf = 0; /* The first few characters of s */
|
||||
unsigned long x_buf = 0; /* Start of candidate substring. */
|
||||
/* Initialized only to make compilers */
|
||||
/* happy. */
|
||||
unsigned long mask = 0;
|
||||
register size_t i;
|
||||
register size_t match_pos;
|
||||
|
||||
if (s == CORD_EMPTY) return(start);
|
||||
if (CORD_IS_STRING(s)) {
|
||||
s_start = s;
|
||||
slen = strlen(s);
|
||||
} else {
|
||||
s_start = CORD_to_char_star(CORD_substr(s, 0, sizeof(unsigned long)));
|
||||
slen = CORD_len(s);
|
||||
}
|
||||
if (xlen < start || xlen - start < slen) return(CORD_NOT_FOUND);
|
||||
start_len = slen;
|
||||
if (start_len > sizeof(unsigned long)) start_len = sizeof(unsigned long);
|
||||
CORD_set_pos(xpos, x, start);
|
||||
for (i = 0; i < start_len; i++) {
|
||||
mask <<= 8;
|
||||
mask |= 0xff;
|
||||
s_buf <<= 8;
|
||||
s_buf |= s_start[i];
|
||||
x_buf <<= 8;
|
||||
x_buf |= CORD_pos_fetch(xpos);
|
||||
CORD_next(xpos);
|
||||
}
|
||||
for (match_pos = start; ; match_pos++) {
|
||||
if ((x_buf & mask) == s_buf) {
|
||||
if (slen == start_len ||
|
||||
CORD_ncmp(x, match_pos + start_len,
|
||||
s, start_len, slen - start_len) == 0) {
|
||||
return(match_pos);
|
||||
}
|
||||
}
|
||||
if ( match_pos == xlen - slen ) {
|
||||
return(CORD_NOT_FOUND);
|
||||
}
|
||||
x_buf <<= 8;
|
||||
x_buf |= CORD_pos_fetch(xpos);
|
||||
CORD_next(xpos);
|
||||
}
|
||||
}
|
||||
|
||||
void CORD_ec_flush_buf(CORD_ec x)
|
||||
{
|
||||
register size_t len = x[0].ec_bufptr - x[0].ec_buf;
|
||||
char * s;
|
||||
|
||||
if (len == 0) return;
|
||||
s = GC_MALLOC_ATOMIC(len+1);
|
||||
memcpy(s, x[0].ec_buf, len);
|
||||
s[len] = '\0';
|
||||
x[0].ec_cord = CORD_cat_char_star(x[0].ec_cord, s, len);
|
||||
x[0].ec_bufptr = x[0].ec_buf;
|
||||
}
|
||||
|
||||
void CORD_ec_append_cord(CORD_ec x, CORD s)
|
||||
{
|
||||
CORD_ec_flush_buf(x);
|
||||
x[0].ec_cord = CORD_cat(x[0].ec_cord, s);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
char CORD_nul_func(size_t i, void * client_data)
|
||||
{
|
||||
return((char)(unsigned long)client_data);
|
||||
}
|
||||
|
||||
|
||||
CORD CORD_chars(char c, size_t i)
|
||||
{
|
||||
return(CORD_from_fn(CORD_nul_func, (void *)(unsigned long)c, i));
|
||||
}
|
||||
|
||||
CORD CORD_from_file_eager(FILE * f)
|
||||
{
|
||||
register int c;
|
||||
CORD_ec ecord;
|
||||
|
||||
CORD_ec_init(ecord);
|
||||
for(;;) {
|
||||
c = getc(f);
|
||||
if (c == 0) {
|
||||
/* Append the right number of NULs */
|
||||
/* Note that any string of NULs is rpresented in 4 words, */
|
||||
/* independent of its length. */
|
||||
register size_t count = 1;
|
||||
|
||||
CORD_ec_flush_buf(ecord);
|
||||
while ((c = getc(f)) == 0) count++;
|
||||
ecord[0].ec_cord = CORD_cat(ecord[0].ec_cord, CORD_nul(count));
|
||||
}
|
||||
if (c == EOF) break;
|
||||
CORD_ec_append(ecord, c);
|
||||
}
|
||||
(void) fclose(f);
|
||||
return(CORD_balance(CORD_ec_to_cord(ecord)));
|
||||
}
|
||||
|
||||
/* The state maintained for a lazily read file consists primarily */
|
||||
/* of a large direct-mapped cache of previously read values. */
|
||||
/* We could rely more on stdio buffering. That would have 2 */
|
||||
/* disadvantages: */
|
||||
/* 1) Empirically, not all fseek implementations preserve the */
|
||||
/* buffer whenever they could. */
|
||||
/* 2) It would fail if 2 different sections of a long cord */
|
||||
/* were being read alternately. */
|
||||
/* We do use the stdio buffer for read ahead. */
|
||||
/* To guarantee thread safety in the presence of atomic pointer */
|
||||
/* writes, cache lines are always replaced, and never modified in */
|
||||
/* place. */
|
||||
|
||||
# define LOG_CACHE_SZ 14
|
||||
# define CACHE_SZ (1 << LOG_CACHE_SZ)
|
||||
# define LOG_LINE_SZ 9
|
||||
# define LINE_SZ (1 << LOG_LINE_SZ)
|
||||
|
||||
typedef struct {
|
||||
size_t tag;
|
||||
char data[LINE_SZ];
|
||||
/* data[i%LINE_SZ] = ith char in file if tag = i/LINE_SZ */
|
||||
} cache_line;
|
||||
|
||||
typedef struct {
|
||||
FILE * lf_file;
|
||||
size_t lf_current; /* Current file pointer value */
|
||||
cache_line * volatile lf_cache[CACHE_SZ/LINE_SZ];
|
||||
} lf_state;
|
||||
|
||||
# define MOD_CACHE_SZ(n) ((n) & (CACHE_SZ - 1))
|
||||
# define DIV_CACHE_SZ(n) ((n) >> LOG_CACHE_SZ)
|
||||
# define MOD_LINE_SZ(n) ((n) & (LINE_SZ - 1))
|
||||
# define DIV_LINE_SZ(n) ((n) >> LOG_LINE_SZ)
|
||||
# define LINE_START(n) ((n) & ~(LINE_SZ - 1))
|
||||
|
||||
typedef struct {
|
||||
lf_state * state;
|
||||
size_t file_pos; /* Position of needed character. */
|
||||
cache_line * new_cache;
|
||||
} refill_data;
|
||||
|
||||
/* Executed with allocation lock. */
|
||||
static char refill_cache(client_data)
|
||||
refill_data * client_data;
|
||||
{
|
||||
register lf_state * state = client_data -> state;
|
||||
register size_t file_pos = client_data -> file_pos;
|
||||
FILE *f = state -> lf_file;
|
||||
size_t line_start = LINE_START(file_pos);
|
||||
size_t line_no = DIV_LINE_SZ(MOD_CACHE_SZ(file_pos));
|
||||
cache_line * new_cache = client_data -> new_cache;
|
||||
|
||||
if (line_start != state -> lf_current
|
||||
&& fseek(f, line_start, SEEK_SET) != 0) {
|
||||
ABORT("fseek failed");
|
||||
}
|
||||
if (fread(new_cache -> data, sizeof(char), LINE_SZ, f)
|
||||
<= file_pos - line_start) {
|
||||
ABORT("fread failed");
|
||||
}
|
||||
new_cache -> tag = DIV_LINE_SZ(file_pos);
|
||||
/* Store barrier goes here. */
|
||||
ATOMIC_WRITE(state -> lf_cache[line_no], new_cache);
|
||||
state -> lf_current = line_start + LINE_SZ;
|
||||
return(new_cache->data[MOD_LINE_SZ(file_pos)]);
|
||||
}
|
||||
|
||||
char CORD_lf_func(size_t i, void * client_data)
|
||||
{
|
||||
register lf_state * state = (lf_state *)client_data;
|
||||
register cache_line * volatile * cl_addr =
|
||||
&(state -> lf_cache[DIV_LINE_SZ(MOD_CACHE_SZ(i))]);
|
||||
register cache_line * cl = (cache_line *)ATOMIC_READ(cl_addr);
|
||||
|
||||
if (cl == 0 || cl -> tag != DIV_LINE_SZ(i)) {
|
||||
/* Cache miss */
|
||||
refill_data rd;
|
||||
|
||||
rd.state = state;
|
||||
rd.file_pos = i;
|
||||
rd.new_cache = GC_NEW_ATOMIC(cache_line);
|
||||
if (rd.new_cache == 0) OUT_OF_MEMORY;
|
||||
return((char)(GC_word)
|
||||
GC_call_with_alloc_lock((GC_fn_type) refill_cache, &rd));
|
||||
}
|
||||
return(cl -> data[MOD_LINE_SZ(i)]);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
void CORD_lf_close_proc(void * obj, void * client_data)
|
||||
{
|
||||
if (fclose(((lf_state *)obj) -> lf_file) != 0) {
|
||||
ABORT("CORD_lf_close_proc: fclose failed");
|
||||
}
|
||||
}
|
||||
|
||||
CORD CORD_from_file_lazy_inner(FILE * f, size_t len)
|
||||
{
|
||||
register lf_state * state = GC_NEW(lf_state);
|
||||
register int i;
|
||||
|
||||
if (state == 0) OUT_OF_MEMORY;
|
||||
if (len != 0) {
|
||||
/* Dummy read to force buffer allocation. */
|
||||
/* This greatly increases the probability */
|
||||
/* of avoiding deadlock if buffer allocation */
|
||||
/* is redirected to GC_malloc and the */
|
||||
/* world is multithreaded. */
|
||||
char buf[1];
|
||||
|
||||
(void) fread(buf, 1, 1, f);
|
||||
rewind(f);
|
||||
}
|
||||
state -> lf_file = f;
|
||||
for (i = 0; i < CACHE_SZ/LINE_SZ; i++) {
|
||||
state -> lf_cache[i] = 0;
|
||||
}
|
||||
state -> lf_current = 0;
|
||||
GC_REGISTER_FINALIZER(state, CORD_lf_close_proc, 0, 0, 0);
|
||||
return(CORD_from_fn(CORD_lf_func, state, len));
|
||||
}
|
||||
|
||||
CORD CORD_from_file_lazy(FILE * f)
|
||||
{
|
||||
register long len;
|
||||
|
||||
if (fseek(f, 0l, SEEK_END) != 0) {
|
||||
ABORT("Bad fd argument - fseek failed");
|
||||
}
|
||||
if ((len = ftell(f)) < 0) {
|
||||
ABORT("Bad fd argument - ftell failed");
|
||||
}
|
||||
rewind(f);
|
||||
return(CORD_from_file_lazy_inner(f, (size_t)len));
|
||||
}
|
||||
|
||||
# define LAZY_THRESHOLD (128*1024 + 1)
|
||||
|
||||
CORD CORD_from_file(FILE * f)
|
||||
{
|
||||
register long len;
|
||||
|
||||
if (fseek(f, 0l, SEEK_END) != 0) {
|
||||
ABORT("Bad fd argument - fseek failed");
|
||||
}
|
||||
if ((len = ftell(f)) < 0) {
|
||||
ABORT("Bad fd argument - ftell failed");
|
||||
}
|
||||
rewind(f);
|
||||
if (len < LAZY_THRESHOLD) {
|
||||
return(CORD_from_file_eager(f));
|
||||
} else {
|
||||
return(CORD_from_file_lazy_inner(f, (size_t)len));
|
||||
}
|
||||
}
|
||||
@@ -1,603 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*
|
||||
* Author: Hans-J. Boehm (boehm@parc.xerox.com)
|
||||
*/
|
||||
/*
|
||||
* A really simple-minded text editor based on cords.
|
||||
* Things it does right:
|
||||
* No size bounds.
|
||||
* Inbounded undo.
|
||||
* Shouldn't crash no matter what file you invoke it on (e.g. /vmunix)
|
||||
* (Make sure /vmunix is not writable before you try this.)
|
||||
* Scrolls horizontally.
|
||||
* Things it does wrong:
|
||||
* It doesn't handle tabs reasonably (use "expand" first).
|
||||
* The command set is MUCH too small.
|
||||
* The redisplay algorithm doesn't let curses do the scrolling.
|
||||
* The rule for moving the window over the file is suboptimal.
|
||||
*/
|
||||
/* Boehm, February 6, 1995 12:27 pm PST */
|
||||
|
||||
/* Boehm, May 19, 1994 2:20 pm PDT */
|
||||
#include <stdio.h>
|
||||
#include "gc.h"
|
||||
#include "cord.h"
|
||||
|
||||
#ifdef THINK_C
|
||||
#define MACINTOSH
|
||||
#include <ctype.h>
|
||||
#endif
|
||||
|
||||
#if defined(__BORLANDC__) && !defined(WIN32)
|
||||
/* If this is DOS or win16, we'll fail anyway. */
|
||||
/* Might as well assume win32. */
|
||||
# define WIN32
|
||||
#endif
|
||||
|
||||
#if defined(WIN32)
|
||||
# include <windows.h>
|
||||
# include "de_win.h"
|
||||
#elif defined(MACINTOSH)
|
||||
# include <console.h>
|
||||
/* curses emulation. */
|
||||
# define initscr()
|
||||
# define endwin()
|
||||
# define nonl()
|
||||
# define noecho() csetmode(C_NOECHO, stdout)
|
||||
# define cbreak() csetmode(C_CBREAK, stdout)
|
||||
# define refresh()
|
||||
# define addch(c) putchar(c)
|
||||
# define standout() cinverse(1, stdout)
|
||||
# define standend() cinverse(0, stdout)
|
||||
# define move(line,col) cgotoxy(col + 1, line + 1, stdout)
|
||||
# define clrtoeol() ccleol(stdout)
|
||||
# define de_error(s) { fprintf(stderr, s); getchar(); }
|
||||
# define LINES 25
|
||||
# define COLS 80
|
||||
#else
|
||||
# include <curses.h>
|
||||
# define de_error(s) { fprintf(stderr, s); sleep(2); }
|
||||
#endif
|
||||
#include "de_cmds.h"
|
||||
|
||||
/* List of line number to position mappings, in descending order. */
|
||||
/* There may be holes. */
|
||||
typedef struct LineMapRep {
|
||||
int line;
|
||||
size_t pos;
|
||||
struct LineMapRep * previous;
|
||||
} * line_map;
|
||||
|
||||
/* List of file versions, one per edit operation */
|
||||
typedef struct HistoryRep {
|
||||
CORD file_contents;
|
||||
struct HistoryRep * previous;
|
||||
line_map map; /* Invalid for first record "now" */
|
||||
} * history;
|
||||
|
||||
history now = 0;
|
||||
CORD current; /* == now -> file_contents. */
|
||||
size_t current_len; /* Current file length. */
|
||||
line_map current_map = 0; /* Current line no. to pos. map */
|
||||
size_t current_map_size = 0; /* Number of current_map entries. */
|
||||
/* Not always accurate, but reset */
|
||||
/* by prune_map. */
|
||||
# define MAX_MAP_SIZE 3000
|
||||
|
||||
/* Current display position */
|
||||
int dis_line = 0;
|
||||
int dis_col = 0;
|
||||
|
||||
# define ALL -1
|
||||
# define NONE - 2
|
||||
int need_redisplay = 0; /* Line that needs to be redisplayed. */
|
||||
|
||||
|
||||
/* Current cursor position. Always within file. */
|
||||
int line = 0;
|
||||
int col = 0;
|
||||
size_t file_pos = 0; /* Character position corresponding to cursor. */
|
||||
|
||||
/* Invalidate line map for lines > i */
|
||||
void invalidate_map(int i)
|
||||
{
|
||||
while(current_map -> line > i) {
|
||||
current_map = current_map -> previous;
|
||||
current_map_size--;
|
||||
}
|
||||
}
|
||||
|
||||
/* Reduce the number of map entries to save space for huge files. */
|
||||
/* This also affects maps in histories. */
|
||||
void prune_map()
|
||||
{
|
||||
line_map map = current_map;
|
||||
int start_line = map -> line;
|
||||
|
||||
current_map_size = 0;
|
||||
for(; map != 0; map = map -> previous) {
|
||||
current_map_size++;
|
||||
if (map -> line < start_line - LINES && map -> previous != 0) {
|
||||
map -> previous = map -> previous -> previous;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Add mapping entry */
|
||||
void add_map(int line, size_t pos)
|
||||
{
|
||||
line_map new_map = GC_NEW(struct LineMapRep);
|
||||
|
||||
if (current_map_size >= MAX_MAP_SIZE) prune_map();
|
||||
new_map -> line = line;
|
||||
new_map -> pos = pos;
|
||||
new_map -> previous = current_map;
|
||||
current_map = new_map;
|
||||
current_map_size++;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Return position of column *c of ith line in */
|
||||
/* current file. Adjust *c to be within the line.*/
|
||||
/* A 0 pointer is taken as 0 column. */
|
||||
/* Returns CORD_NOT_FOUND if i is too big. */
|
||||
/* Assumes i > dis_line. */
|
||||
size_t line_pos(int i, int *c)
|
||||
{
|
||||
int j;
|
||||
size_t cur;
|
||||
size_t next;
|
||||
line_map map = current_map;
|
||||
|
||||
while (map -> line > i) map = map -> previous;
|
||||
if (map -> line < i - 2) /* rebuild */ invalidate_map(i);
|
||||
for (j = map -> line, cur = map -> pos; j < i;) {
|
||||
cur = CORD_chr(current, cur, '\n');
|
||||
if (cur == current_len-1) return(CORD_NOT_FOUND);
|
||||
cur++;
|
||||
if (++j > current_map -> line) add_map(j, cur);
|
||||
}
|
||||
if (c != 0) {
|
||||
next = CORD_chr(current, cur, '\n');
|
||||
if (next == CORD_NOT_FOUND) next = current_len - 1;
|
||||
if (next < cur + *c) {
|
||||
*c = next - cur;
|
||||
}
|
||||
cur += *c;
|
||||
}
|
||||
return(cur);
|
||||
}
|
||||
|
||||
void add_hist(CORD s)
|
||||
{
|
||||
history new_file = GC_NEW(struct HistoryRep);
|
||||
|
||||
new_file -> file_contents = current = s;
|
||||
current_len = CORD_len(s);
|
||||
new_file -> previous = now;
|
||||
if (now != 0) now -> map = current_map;
|
||||
now = new_file;
|
||||
}
|
||||
|
||||
void del_hist(void)
|
||||
{
|
||||
now = now -> previous;
|
||||
current = now -> file_contents;
|
||||
current_map = now -> map;
|
||||
current_len = CORD_len(current);
|
||||
}
|
||||
|
||||
/* Current screen_contents; a dynamically allocated array of CORDs */
|
||||
CORD * screen = 0;
|
||||
int screen_size = 0;
|
||||
|
||||
# ifndef WIN32
|
||||
/* Replace a line in the curses stdscr. All control characters are */
|
||||
/* displayed as upper case characters in standout mode. This isn't */
|
||||
/* terribly appropriate for tabs. */
|
||||
void replace_line(int i, CORD s)
|
||||
{
|
||||
register int c;
|
||||
CORD_pos p;
|
||||
size_t len = CORD_len(s);
|
||||
|
||||
if (screen == 0 || LINES > screen_size) {
|
||||
screen_size = LINES;
|
||||
screen = (CORD *)GC_MALLOC(screen_size * sizeof(CORD));
|
||||
}
|
||||
# if !defined(MACINTOSH)
|
||||
/* A gross workaround for an apparent curses bug: */
|
||||
if (i == LINES-1 && len == COLS) {
|
||||
s = CORD_substr(s, 0, CORD_len(s) - 1);
|
||||
}
|
||||
# endif
|
||||
if (CORD_cmp(screen[i], s) != 0) {
|
||||
move(i, 0); clrtoeol(); move(i,0);
|
||||
|
||||
CORD_FOR (p, s) {
|
||||
c = CORD_pos_fetch(p) & 0x7f;
|
||||
if (iscntrl(c)) {
|
||||
standout(); addch(c + 0x40); standend();
|
||||
} else {
|
||||
addch(c);
|
||||
}
|
||||
}
|
||||
screen[i] = s;
|
||||
}
|
||||
}
|
||||
#else
|
||||
# define replace_line(i,s) invalidate_line(i)
|
||||
#endif
|
||||
|
||||
/* Return up to COLS characters of the line of s starting at pos, */
|
||||
/* returning only characters after the given column. */
|
||||
CORD retrieve_line(CORD s, size_t pos, unsigned column)
|
||||
{
|
||||
CORD candidate = CORD_substr(s, pos, column + COLS);
|
||||
/* avoids scanning very long lines */
|
||||
int eol = CORD_chr(candidate, 0, '\n');
|
||||
int len;
|
||||
|
||||
if (eol == CORD_NOT_FOUND) eol = CORD_len(candidate);
|
||||
len = (int)eol - (int)column;
|
||||
if (len < 0) len = 0;
|
||||
return(CORD_substr(s, pos + column, len));
|
||||
}
|
||||
|
||||
# ifdef WIN32
|
||||
# define refresh();
|
||||
|
||||
CORD retrieve_screen_line(int i)
|
||||
{
|
||||
register size_t pos;
|
||||
|
||||
invalidate_map(dis_line + LINES); /* Prune search */
|
||||
pos = line_pos(dis_line + i, 0);
|
||||
if (pos == CORD_NOT_FOUND) return(CORD_EMPTY);
|
||||
return(retrieve_line(current, pos, dis_col));
|
||||
}
|
||||
# endif
|
||||
|
||||
/* Display the visible section of the current file */
|
||||
void redisplay(void)
|
||||
{
|
||||
register int i;
|
||||
|
||||
invalidate_map(dis_line + LINES); /* Prune search */
|
||||
for (i = 0; i < LINES; i++) {
|
||||
if (need_redisplay == ALL || need_redisplay == i) {
|
||||
register size_t pos = line_pos(dis_line + i, 0);
|
||||
|
||||
if (pos == CORD_NOT_FOUND) break;
|
||||
replace_line(i, retrieve_line(current, pos, dis_col));
|
||||
if (need_redisplay == i) goto done;
|
||||
}
|
||||
}
|
||||
for (; i < LINES; i++) replace_line(i, CORD_EMPTY);
|
||||
done:
|
||||
refresh();
|
||||
need_redisplay = NONE;
|
||||
}
|
||||
|
||||
int dis_granularity;
|
||||
|
||||
/* Update dis_line, dis_col, and dis_pos to make cursor visible. */
|
||||
/* Assumes line, col, dis_line, dis_pos are in bounds. */
|
||||
void normalize_display()
|
||||
{
|
||||
int old_line = dis_line;
|
||||
int old_col = dis_col;
|
||||
|
||||
dis_granularity = 1;
|
||||
if (LINES > 15 && COLS > 15) dis_granularity = 2;
|
||||
while (dis_line > line) dis_line -= dis_granularity;
|
||||
while (dis_col > col) dis_col -= dis_granularity;
|
||||
while (line >= dis_line + LINES) dis_line += dis_granularity;
|
||||
while (col >= dis_col + COLS) dis_col += dis_granularity;
|
||||
if (old_line != dis_line || old_col != dis_col) {
|
||||
need_redisplay = ALL;
|
||||
}
|
||||
}
|
||||
|
||||
# if defined(WIN32)
|
||||
# elif defined(MACINTOSH)
|
||||
# define move_cursor(x,y) cgotoxy(x + 1, y + 1, stdout)
|
||||
# else
|
||||
# define move_cursor(x,y) move(y,x)
|
||||
# endif
|
||||
|
||||
/* Adjust display so that cursor is visible; move cursor into position */
|
||||
/* Update screen if necessary. */
|
||||
void fix_cursor(void)
|
||||
{
|
||||
normalize_display();
|
||||
if (need_redisplay != NONE) redisplay();
|
||||
move_cursor(col - dis_col, line - dis_line);
|
||||
refresh();
|
||||
# ifndef WIN32
|
||||
fflush(stdout);
|
||||
# endif
|
||||
}
|
||||
|
||||
/* Make sure line, col, and dis_pos are somewhere inside file. */
|
||||
/* Recompute file_pos. Assumes dis_pos is accurate or past eof */
|
||||
void fix_pos()
|
||||
{
|
||||
int my_col = col;
|
||||
|
||||
if ((size_t)line > current_len) line = current_len;
|
||||
file_pos = line_pos(line, &my_col);
|
||||
if (file_pos == CORD_NOT_FOUND) {
|
||||
for (line = current_map -> line, file_pos = current_map -> pos;
|
||||
file_pos < current_len;
|
||||
line++, file_pos = CORD_chr(current, file_pos, '\n') + 1);
|
||||
line--;
|
||||
file_pos = line_pos(line, &col);
|
||||
} else {
|
||||
col = my_col;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined(WIN32)
|
||||
# define beep() Beep(1000 /* Hz */, 300 /* msecs */)
|
||||
#elif defined(MACINTOSH)
|
||||
# define beep() SysBeep(1)
|
||||
#else
|
||||
/*
|
||||
* beep() is part of some curses packages and not others.
|
||||
* We try to match the type of the builtin one, if any.
|
||||
*/
|
||||
#ifdef __STDC__
|
||||
int beep(void)
|
||||
#else
|
||||
int beep()
|
||||
#endif
|
||||
{
|
||||
putc('\007', stderr);
|
||||
return(0);
|
||||
}
|
||||
#endif
|
||||
|
||||
# define NO_PREFIX -1
|
||||
# define BARE_PREFIX -2
|
||||
int repeat_count = NO_PREFIX; /* Current command prefix. */
|
||||
|
||||
int locate_mode = 0; /* Currently between 2 ^Ls */
|
||||
CORD locate_string = CORD_EMPTY; /* Current search string. */
|
||||
|
||||
char * arg_file_name;
|
||||
|
||||
#ifdef WIN32
|
||||
/* Change the current position to whatever is currently displayed at */
|
||||
/* the given SCREEN coordinates. */
|
||||
void set_position(int c, int l)
|
||||
{
|
||||
line = l + dis_line;
|
||||
col = c + dis_col;
|
||||
fix_pos();
|
||||
move_cursor(col - dis_col, line - dis_line);
|
||||
}
|
||||
#endif /* WIN32 */
|
||||
|
||||
/* Perform the command associated with character c. C may be an */
|
||||
/* integer > 256 denoting a windows command, one of the above control */
|
||||
/* characters, or another ASCII character to be used as either a */
|
||||
/* character to be inserted, a repeat count, or a search string, */
|
||||
/* depending on the current state. */
|
||||
void do_command(int c)
|
||||
{
|
||||
int i;
|
||||
int need_fix_pos;
|
||||
FILE * out;
|
||||
|
||||
if ( c == '\r') c = '\n';
|
||||
if (locate_mode) {
|
||||
size_t new_pos;
|
||||
|
||||
if (c == LOCATE) {
|
||||
locate_mode = 0;
|
||||
locate_string = CORD_EMPTY;
|
||||
return;
|
||||
}
|
||||
locate_string = CORD_cat_char(locate_string, (char)c);
|
||||
new_pos = CORD_str(current, file_pos - CORD_len(locate_string) + 1,
|
||||
locate_string);
|
||||
if (new_pos != CORD_NOT_FOUND) {
|
||||
need_redisplay = ALL;
|
||||
new_pos += CORD_len(locate_string);
|
||||
for (;;) {
|
||||
file_pos = line_pos(line + 1, 0);
|
||||
if (file_pos > new_pos) break;
|
||||
line++;
|
||||
}
|
||||
col = new_pos - line_pos(line, 0);
|
||||
file_pos = new_pos;
|
||||
fix_cursor();
|
||||
} else {
|
||||
locate_string = CORD_substr(locate_string, 0,
|
||||
CORD_len(locate_string) - 1);
|
||||
beep();
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (c == REPEAT) {
|
||||
repeat_count = BARE_PREFIX; return;
|
||||
} else if (c < 0x100 && isdigit(c)){
|
||||
if (repeat_count == BARE_PREFIX) {
|
||||
repeat_count = c - '0'; return;
|
||||
} else if (repeat_count != NO_PREFIX) {
|
||||
repeat_count = 10 * repeat_count + c - '0'; return;
|
||||
}
|
||||
}
|
||||
if (repeat_count == NO_PREFIX) repeat_count = 1;
|
||||
if (repeat_count == BARE_PREFIX && (c == UP || c == DOWN)) {
|
||||
repeat_count = LINES - dis_granularity;
|
||||
}
|
||||
if (repeat_count == BARE_PREFIX) repeat_count = 8;
|
||||
need_fix_pos = 0;
|
||||
for (i = 0; i < repeat_count; i++) {
|
||||
switch(c) {
|
||||
case LOCATE:
|
||||
locate_mode = 1;
|
||||
break;
|
||||
case TOP:
|
||||
line = col = file_pos = 0;
|
||||
break;
|
||||
case UP:
|
||||
if (line != 0) {
|
||||
line--;
|
||||
need_fix_pos = 1;
|
||||
}
|
||||
break;
|
||||
case DOWN:
|
||||
line++;
|
||||
need_fix_pos = 1;
|
||||
break;
|
||||
case LEFT:
|
||||
if (col != 0) {
|
||||
col--; file_pos--;
|
||||
}
|
||||
break;
|
||||
case RIGHT:
|
||||
if (CORD_fetch(current, file_pos) == '\n') break;
|
||||
col++; file_pos++;
|
||||
break;
|
||||
case UNDO:
|
||||
del_hist();
|
||||
need_redisplay = ALL; need_fix_pos = 1;
|
||||
break;
|
||||
case BS:
|
||||
if (col == 0) {
|
||||
beep();
|
||||
break;
|
||||
}
|
||||
col--; file_pos--;
|
||||
/* fall through: */
|
||||
case DEL:
|
||||
if (file_pos == current_len-1) break;
|
||||
/* Can't delete trailing newline */
|
||||
if (CORD_fetch(current, file_pos) == '\n') {
|
||||
need_redisplay = ALL; need_fix_pos = 1;
|
||||
} else {
|
||||
need_redisplay = line - dis_line;
|
||||
}
|
||||
add_hist(CORD_cat(
|
||||
CORD_substr(current, 0, file_pos),
|
||||
CORD_substr(current, file_pos+1, current_len)));
|
||||
invalidate_map(line);
|
||||
break;
|
||||
case WRITE:
|
||||
{
|
||||
CORD name = CORD_cat(CORD_from_char_star(arg_file_name),
|
||||
".new");
|
||||
|
||||
if ((out = fopen(CORD_to_const_char_star(name), "wb")) == NULL
|
||||
|| CORD_put(current, out) == EOF) {
|
||||
de_error("Write failed\n");
|
||||
need_redisplay = ALL;
|
||||
} else {
|
||||
fclose(out);
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
{
|
||||
CORD left_part = CORD_substr(current, 0, file_pos);
|
||||
CORD right_part = CORD_substr(current, file_pos, current_len);
|
||||
|
||||
add_hist(CORD_cat(CORD_cat_char(left_part, (char)c),
|
||||
right_part));
|
||||
invalidate_map(line);
|
||||
if (c == '\n') {
|
||||
col = 0; line++; file_pos++;
|
||||
need_redisplay = ALL;
|
||||
} else {
|
||||
col++; file_pos++;
|
||||
need_redisplay = line - dis_line;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (need_fix_pos) fix_pos();
|
||||
fix_cursor();
|
||||
repeat_count = NO_PREFIX;
|
||||
}
|
||||
|
||||
/* OS independent initialization */
|
||||
|
||||
void generic_init(void)
|
||||
{
|
||||
FILE * f;
|
||||
CORD initial;
|
||||
|
||||
if ((f = fopen(arg_file_name, "rb")) == NULL) {
|
||||
initial = "\n";
|
||||
} else {
|
||||
initial = CORD_from_file(f);
|
||||
if (initial == CORD_EMPTY
|
||||
|| CORD_fetch(initial, CORD_len(initial)-1) != '\n') {
|
||||
initial = CORD_cat(initial, "\n");
|
||||
}
|
||||
}
|
||||
add_map(0,0);
|
||||
add_hist(initial);
|
||||
now -> map = current_map;
|
||||
now -> previous = now; /* Can't back up further: beginning of the world */
|
||||
need_redisplay = ALL;
|
||||
fix_cursor();
|
||||
}
|
||||
|
||||
#ifndef WIN32
|
||||
|
||||
main(argc, argv)
|
||||
int argc;
|
||||
char ** argv;
|
||||
{
|
||||
int c;
|
||||
|
||||
#if defined(MACINTOSH)
|
||||
console_options.title = "\pDumb Editor";
|
||||
cshow(stdout);
|
||||
GC_init();
|
||||
argc = ccommand(&argv);
|
||||
#endif
|
||||
|
||||
if (argc != 2) goto usage;
|
||||
arg_file_name = argv[1];
|
||||
setvbuf(stdout, GC_MALLOC_ATOMIC(8192), _IOFBF, 8192);
|
||||
initscr();
|
||||
noecho(); nonl(); cbreak();
|
||||
generic_init();
|
||||
while ((c = getchar()) != QUIT) {
|
||||
if (c == EOF) break;
|
||||
do_command(c);
|
||||
}
|
||||
done:
|
||||
move(LINES-1, 0);
|
||||
clrtoeol();
|
||||
refresh();
|
||||
nl();
|
||||
echo();
|
||||
endwin();
|
||||
exit(0);
|
||||
usage:
|
||||
fprintf(stderr, "Usage: %s file\n", argv[0]);
|
||||
fprintf(stderr, "Cursor keys: ^B(left) ^F(right) ^P(up) ^N(down)\n");
|
||||
fprintf(stderr, "Undo: ^U Write to <file>.new: ^W");
|
||||
fprintf(stderr, "Quit:^D Repeat count: ^R[n]\n");
|
||||
fprintf(stderr, "Top: ^T Locate (search, find): ^L text ^L\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
#endif /* !WIN32 */
|
||||
@@ -1,33 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
/* Boehm, May 19, 1994 2:24 pm PDT */
|
||||
|
||||
#ifndef DE_CMDS_H
|
||||
|
||||
# define DE_CMDS_H
|
||||
|
||||
# define UP 16 /* ^P */
|
||||
# define DOWN 14 /* ^N */
|
||||
# define LEFT 2 /* ^B */
|
||||
# define RIGHT 6 /* ^F */
|
||||
# define DEL 127 /* ^? */
|
||||
# define BS 8 /* ^H */
|
||||
# define UNDO 21 /* ^U */
|
||||
# define WRITE 23 /* ^W */
|
||||
# define QUIT 4 /* ^D */
|
||||
# define REPEAT 18 /* ^R */
|
||||
# define LOCATE 12 /* ^L */
|
||||
# define TOP 20 /* ^T */
|
||||
|
||||
#endif
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 766 B |
@@ -1,78 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to copy this garbage collector for any purpose,
|
||||
* provided the above notices are retained on all copies.
|
||||
*/
|
||||
/* Boehm, May 13, 1994 9:50 am PDT */
|
||||
|
||||
#include "windows.h"
|
||||
#include "de_cmds.h"
|
||||
#include "de_win.h"
|
||||
|
||||
|
||||
|
||||
ABOUTBOX DIALOG 19, 21, 163, 47
|
||||
STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
|
||||
CAPTION "About Demonstration Text Editor"
|
||||
BEGIN
|
||||
ICON "DE", -1, 8, 8, 13, 13, WS_CHILD | WS_VISIBLE
|
||||
LTEXT "Demonstration Text Editor", -1, 44, 8, 118, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
|
||||
LTEXT "Version 4.1", -1, 44, 16, 60, 8, WS_CHILD | WS_VISIBLE | WS_GROUP
|
||||
PUSHBUTTON "OK", IDOK, 118, 27, 24, 14, WS_CHILD | WS_VISIBLE | WS_TABSTOP
|
||||
END
|
||||
|
||||
|
||||
DE MENU
|
||||
BEGIN
|
||||
POPUP "&File"
|
||||
BEGIN
|
||||
MENUITEM "&Save\t^W", IDM_FILESAVE
|
||||
MENUITEM "E&xit\t^D", IDM_FILEEXIT
|
||||
END
|
||||
|
||||
POPUP "&Edit"
|
||||
BEGIN
|
||||
MENUITEM "Page &Down\t^R^N", IDM_EDITPDOWN
|
||||
MENUITEM "Page &Up\t^R^P", IDM_EDITPUP
|
||||
MENUITEM "U&ndo\t^U", IDM_EDITUNDO
|
||||
MENUITEM "&Locate\t^L ... ^L", IDM_EDITLOCATE
|
||||
MENUITEM "D&own\t^N", IDM_EDITDOWN
|
||||
MENUITEM "U&p\t^P", IDM_EDITUP
|
||||
MENUITEM "Le&ft\t^B", IDM_EDITLEFT
|
||||
MENUITEM "&Right\t^F", IDM_EDITRIGHT
|
||||
MENUITEM "Delete &Backward\tBS", IDM_EDITBS
|
||||
MENUITEM "Delete F&orward\tDEL", IDM_EDITDEL
|
||||
MENUITEM "&Top\t^T", IDM_EDITTOP
|
||||
END
|
||||
|
||||
POPUP "&Help"
|
||||
BEGIN
|
||||
MENUITEM "&Contents", IDM_HELPCONTENTS
|
||||
MENUITEM "&About...", IDM_HELPABOUT
|
||||
END
|
||||
|
||||
MENUITEM "Page_&Down", IDM_EDITPDOWN
|
||||
MENUITEM "Page_&Up", IDM_EDITPUP
|
||||
END
|
||||
|
||||
|
||||
DE ACCELERATORS
|
||||
BEGIN
|
||||
"^R", IDM_EDITREPEAT
|
||||
"^N", IDM_EDITDOWN
|
||||
"^P", IDM_EDITUP
|
||||
"^L", IDM_EDITLOCATE
|
||||
"^B", IDM_EDITLEFT
|
||||
"^F", IDM_EDITRIGHT
|
||||
"^T", IDM_EDITTOP
|
||||
VK_DELETE, IDM_EDITDEL, VIRTKEY
|
||||
VK_BACK, IDM_EDITBS, VIRTKEY
|
||||
END
|
||||
|
||||
|
||||
DE ICON cord\de_win.ICO
|
||||
|
||||
@@ -1,366 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
/* Boehm, February 6, 1995 12:29 pm PST */
|
||||
|
||||
/*
|
||||
* The MS Windows specific part of de.
|
||||
* This started as the generic Windows application template
|
||||
* made available by Rob Haack (rhaack@polaris.unm.edu), but
|
||||
* significant parts didn't survive to the final version.
|
||||
*
|
||||
* This was written by a nonexpert windows programmer.
|
||||
*/
|
||||
|
||||
|
||||
#include "windows.h"
|
||||
#include "gc.h"
|
||||
#include "cord.h"
|
||||
#include "de_cmds.h"
|
||||
#include "de_win.h"
|
||||
|
||||
int LINES = 0;
|
||||
int COLS = 0;
|
||||
|
||||
char szAppName[] = "DE";
|
||||
char FullAppName[] = "Demonstration Editor";
|
||||
|
||||
HWND hwnd;
|
||||
|
||||
void de_error(char *s)
|
||||
{
|
||||
MessageBox( hwnd, (LPSTR) s,
|
||||
(LPSTR) FullAppName,
|
||||
MB_ICONINFORMATION | MB_OK );
|
||||
InvalidateRect(hwnd, NULL, TRUE);
|
||||
}
|
||||
|
||||
int APIENTRY WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance,
|
||||
LPSTR command_line, int nCmdShow)
|
||||
{
|
||||
MSG msg;
|
||||
WNDCLASS wndclass;
|
||||
HANDLE hAccel;
|
||||
|
||||
if (!hPrevInstance)
|
||||
{
|
||||
wndclass.style = CS_HREDRAW | CS_VREDRAW;
|
||||
wndclass.lpfnWndProc = WndProc;
|
||||
wndclass.cbClsExtra = 0;
|
||||
wndclass.cbWndExtra = DLGWINDOWEXTRA;
|
||||
wndclass.hInstance = hInstance;
|
||||
wndclass.hIcon = LoadIcon (hInstance, szAppName);
|
||||
wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
|
||||
wndclass.hbrBackground = GetStockObject(WHITE_BRUSH);
|
||||
wndclass.lpszMenuName = "DE";
|
||||
wndclass.lpszClassName = szAppName;
|
||||
|
||||
if (RegisterClass (&wndclass) == 0) {
|
||||
char buf[50];
|
||||
|
||||
sprintf(buf, "RegisterClass: error code: 0x%X", GetLastError());
|
||||
de_error(buf);
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Empirically, the command line does not include the command name ...
|
||||
if (command_line != 0) {
|
||||
while (isspace(*command_line)) command_line++;
|
||||
while (*command_line != 0 && !isspace(*command_line)) command_line++;
|
||||
while (isspace(*command_line)) command_line++;
|
||||
} */
|
||||
|
||||
if (command_line == 0 || *command_line == 0) {
|
||||
de_error("File name argument required");
|
||||
return( 0 );
|
||||
} else {
|
||||
char *p = command_line;
|
||||
|
||||
while (*p != 0 && !isspace(*p)) p++;
|
||||
arg_file_name = CORD_to_char_star(
|
||||
CORD_substr(command_line, 0, p - command_line));
|
||||
}
|
||||
|
||||
hwnd = CreateWindow (szAppName,
|
||||
FullAppName,
|
||||
WS_OVERLAPPEDWINDOW | WS_CAPTION, /* Window style */
|
||||
CW_USEDEFAULT, 0, /* default pos. */
|
||||
CW_USEDEFAULT, 0, /* default width, height */
|
||||
NULL, /* No parent */
|
||||
NULL, /* Window class menu */
|
||||
hInstance, NULL);
|
||||
if (hwnd == NULL) {
|
||||
char buf[50];
|
||||
|
||||
sprintf(buf, "CreateWindow: error code: 0x%X", GetLastError());
|
||||
de_error(buf);
|
||||
return(0);
|
||||
}
|
||||
|
||||
ShowWindow (hwnd, nCmdShow);
|
||||
|
||||
hAccel = LoadAccelerators( hInstance, szAppName );
|
||||
|
||||
while (GetMessage (&msg, NULL, 0, 0))
|
||||
{
|
||||
if( !TranslateAccelerator( hwnd, hAccel, &msg ) )
|
||||
{
|
||||
TranslateMessage (&msg);
|
||||
DispatchMessage (&msg);
|
||||
}
|
||||
}
|
||||
return msg.wParam;
|
||||
}
|
||||
|
||||
/* Return the argument with all control characters replaced by blanks. */
|
||||
char * plain_chars(char * text, size_t len)
|
||||
{
|
||||
char * result = GC_MALLOC_ATOMIC(len + 1);
|
||||
register size_t i;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
if (iscntrl(text[i])) {
|
||||
result[i] = ' ';
|
||||
} else {
|
||||
result[i] = text[i];
|
||||
}
|
||||
}
|
||||
result[len] = '\0';
|
||||
return(result);
|
||||
}
|
||||
|
||||
/* Return the argument with all non-control-characters replaced by */
|
||||
/* blank, and all control characters c replaced by c + 32. */
|
||||
char * control_chars(char * text, size_t len)
|
||||
{
|
||||
char * result = GC_MALLOC_ATOMIC(len + 1);
|
||||
register size_t i;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
if (iscntrl(text[i])) {
|
||||
result[i] = text[i] + 0x40;
|
||||
} else {
|
||||
result[i] = ' ';
|
||||
}
|
||||
}
|
||||
result[len] = '\0';
|
||||
return(result);
|
||||
}
|
||||
|
||||
int char_width;
|
||||
int char_height;
|
||||
|
||||
void get_line_rect(int line, int win_width, RECT * rectp)
|
||||
{
|
||||
rectp -> top = line * char_height;
|
||||
rectp -> bottom = rectp->top + char_height;
|
||||
rectp -> left = 0;
|
||||
rectp -> right = win_width;
|
||||
}
|
||||
|
||||
int caret_visible = 0; /* Caret is currently visible. */
|
||||
|
||||
int screen_was_painted = 0;/* Screen has been painted at least once. */
|
||||
|
||||
void update_cursor(void);
|
||||
|
||||
LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
|
||||
WPARAM wParam, LPARAM lParam)
|
||||
{
|
||||
static FARPROC lpfnAboutBox;
|
||||
static HANDLE hInstance;
|
||||
HDC dc;
|
||||
PAINTSTRUCT ps;
|
||||
RECT client_area;
|
||||
RECT this_line;
|
||||
RECT dummy;
|
||||
TEXTMETRIC tm;
|
||||
register int i;
|
||||
int id;
|
||||
|
||||
switch (message)
|
||||
{
|
||||
case WM_CREATE:
|
||||
hInstance = ( (LPCREATESTRUCT) lParam)->hInstance;
|
||||
lpfnAboutBox = MakeProcInstance( (FARPROC) AboutBox, hInstance );
|
||||
dc = GetDC(hwnd);
|
||||
SelectObject(dc, GetStockObject(SYSTEM_FIXED_FONT));
|
||||
GetTextMetrics(dc, &tm);
|
||||
ReleaseDC(hwnd, dc);
|
||||
char_width = tm.tmAveCharWidth;
|
||||
char_height = tm.tmHeight + tm.tmExternalLeading;
|
||||
GetClientRect(hwnd, &client_area);
|
||||
COLS = (client_area.right - client_area.left)/char_width;
|
||||
LINES = (client_area.bottom - client_area.top)/char_height;
|
||||
generic_init();
|
||||
return(0);
|
||||
|
||||
case WM_CHAR:
|
||||
if (wParam == QUIT) {
|
||||
SendMessage( hwnd, WM_CLOSE, 0, 0L );
|
||||
} else {
|
||||
do_command(wParam);
|
||||
}
|
||||
return(0);
|
||||
|
||||
case WM_SETFOCUS:
|
||||
CreateCaret(hwnd, NULL, char_width, char_height);
|
||||
ShowCaret(hwnd);
|
||||
caret_visible = 1;
|
||||
update_cursor();
|
||||
return(0);
|
||||
|
||||
case WM_KILLFOCUS:
|
||||
HideCaret(hwnd);
|
||||
DestroyCaret();
|
||||
caret_visible = 0;
|
||||
return(0);
|
||||
|
||||
case WM_LBUTTONUP:
|
||||
{
|
||||
unsigned xpos = LOWORD(lParam); /* From left */
|
||||
unsigned ypos = HIWORD(lParam); /* from top */
|
||||
|
||||
set_position( xpos/char_width, ypos/char_height );
|
||||
return(0);
|
||||
}
|
||||
|
||||
case WM_COMMAND:
|
||||
id = LOWORD(wParam);
|
||||
if (id & EDIT_CMD_FLAG) {
|
||||
if (id & REPEAT_FLAG) do_command(REPEAT);
|
||||
do_command(CHAR_CMD(id));
|
||||
return( 0 );
|
||||
} else {
|
||||
switch(id) {
|
||||
case IDM_FILEEXIT:
|
||||
SendMessage( hwnd, WM_CLOSE, 0, 0L );
|
||||
return( 0 );
|
||||
|
||||
case IDM_HELPABOUT:
|
||||
if( DialogBox( hInstance, "ABOUTBOX",
|
||||
hwnd, lpfnAboutBox ) );
|
||||
InvalidateRect( hwnd, NULL, TRUE );
|
||||
return( 0 );
|
||||
case IDM_HELPCONTENTS:
|
||||
de_error(
|
||||
"Cursor keys: ^B(left) ^F(right) ^P(up) ^N(down)\n"
|
||||
"Undo: ^U Write: ^W Quit:^D Repeat count: ^R[n]\n"
|
||||
"Top: ^T Locate (search, find): ^L text ^L\n");
|
||||
return( 0 );
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case WM_CLOSE:
|
||||
DestroyWindow( hwnd );
|
||||
return 0;
|
||||
|
||||
case WM_DESTROY:
|
||||
PostQuitMessage (0);
|
||||
GC_win32_free_heap();
|
||||
return 0;
|
||||
|
||||
case WM_PAINT:
|
||||
dc = BeginPaint(hwnd, &ps);
|
||||
GetClientRect(hwnd, &client_area);
|
||||
COLS = (client_area.right - client_area.left)/char_width;
|
||||
LINES = (client_area.bottom - client_area.top)/char_height;
|
||||
SelectObject(dc, GetStockObject(SYSTEM_FIXED_FONT));
|
||||
for (i = 0; i < LINES; i++) {
|
||||
get_line_rect(i, client_area.right, &this_line);
|
||||
if (IntersectRect(&dummy, &this_line, &ps.rcPaint)) {
|
||||
CORD raw_line = retrieve_screen_line(i);
|
||||
size_t len = CORD_len(raw_line);
|
||||
char * text = CORD_to_char_star(raw_line);
|
||||
/* May contain embedded NULLs */
|
||||
char * plain = plain_chars(text, len);
|
||||
char * blanks = CORD_to_char_star(CORD_chars(' ',
|
||||
COLS - len));
|
||||
char * control = control_chars(text, len);
|
||||
# define RED RGB(255,0,0)
|
||||
|
||||
SetBkMode(dc, OPAQUE);
|
||||
SetTextColor(dc, GetSysColor(COLOR_WINDOWTEXT));
|
||||
|
||||
TextOut(dc, this_line.left, this_line.top,
|
||||
plain, len);
|
||||
TextOut(dc, this_line.left + len * char_width, this_line.top,
|
||||
blanks, COLS - len);
|
||||
SetBkMode(dc, TRANSPARENT);
|
||||
SetTextColor(dc, RED);
|
||||
TextOut(dc, this_line.left, this_line.top,
|
||||
control, strlen(control));
|
||||
}
|
||||
}
|
||||
EndPaint(hwnd, &ps);
|
||||
screen_was_painted = 1;
|
||||
return 0;
|
||||
}
|
||||
return DefWindowProc (hwnd, message, wParam, lParam);
|
||||
}
|
||||
|
||||
int last_col;
|
||||
int last_line;
|
||||
|
||||
void move_cursor(int c, int l)
|
||||
{
|
||||
last_col = c;
|
||||
last_line = l;
|
||||
|
||||
if (caret_visible) update_cursor();
|
||||
}
|
||||
|
||||
void update_cursor(void)
|
||||
{
|
||||
SetCaretPos(last_col * char_width, last_line * char_height);
|
||||
ShowCaret(hwnd);
|
||||
}
|
||||
|
||||
void invalidate_line(int i)
|
||||
{
|
||||
RECT line;
|
||||
|
||||
if (!screen_was_painted) return;
|
||||
/* Invalidating a rectangle before painting seems result in a */
|
||||
/* major performance problem. */
|
||||
get_line_rect(i, COLS*char_width, &line);
|
||||
InvalidateRect(hwnd, &line, FALSE);
|
||||
}
|
||||
|
||||
LRESULT CALLBACK AboutBox( HWND hDlg, UINT message,
|
||||
WPARAM wParam, LPARAM lParam )
|
||||
{
|
||||
switch( message )
|
||||
{
|
||||
case WM_INITDIALOG:
|
||||
SetFocus( GetDlgItem( hDlg, IDOK ) );
|
||||
break;
|
||||
|
||||
case WM_COMMAND:
|
||||
switch( wParam )
|
||||
{
|
||||
case IDOK:
|
||||
EndDialog( hDlg, TRUE );
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
case WM_CLOSE:
|
||||
EndDialog( hDlg, TRUE );
|
||||
return TRUE;
|
||||
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
@@ -1,103 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
/* Boehm, May 19, 1994 2:25 pm PDT */
|
||||
|
||||
/* cord.h, de_cmds.h, and windows.h should be included before this. */
|
||||
|
||||
|
||||
# define OTHER_FLAG 0x100
|
||||
# define EDIT_CMD_FLAG 0x200
|
||||
# define REPEAT_FLAG 0x400
|
||||
|
||||
# define CHAR_CMD(i) ((i) & 0xff)
|
||||
|
||||
/* MENU: DE */
|
||||
#define IDM_FILESAVE (EDIT_CMD_FLAG + WRITE)
|
||||
#define IDM_FILEEXIT (OTHER_FLAG + 1)
|
||||
#define IDM_HELPABOUT (OTHER_FLAG + 2)
|
||||
#define IDM_HELPCONTENTS (OTHER_FLAG + 3)
|
||||
|
||||
#define IDM_EDITPDOWN (REPEAT_FLAG + EDIT_CMD_FLAG + DOWN)
|
||||
#define IDM_EDITPUP (REPEAT_FLAG + EDIT_CMD_FLAG + UP)
|
||||
#define IDM_EDITUNDO (EDIT_CMD_FLAG + UNDO)
|
||||
#define IDM_EDITLOCATE (EDIT_CMD_FLAG + LOCATE)
|
||||
#define IDM_EDITDOWN (EDIT_CMD_FLAG + DOWN)
|
||||
#define IDM_EDITUP (EDIT_CMD_FLAG + UP)
|
||||
#define IDM_EDITLEFT (EDIT_CMD_FLAG + LEFT)
|
||||
#define IDM_EDITRIGHT (EDIT_CMD_FLAG + RIGHT)
|
||||
#define IDM_EDITBS (EDIT_CMD_FLAG + BS)
|
||||
#define IDM_EDITDEL (EDIT_CMD_FLAG + DEL)
|
||||
#define IDM_EDITREPEAT (EDIT_CMD_FLAG + REPEAT)
|
||||
#define IDM_EDITTOP (EDIT_CMD_FLAG + TOP)
|
||||
|
||||
|
||||
|
||||
|
||||
/* Windows UI stuff */
|
||||
|
||||
LRESULT CALLBACK WndProc (HWND hwnd, UINT message,
|
||||
UINT wParam, LONG lParam);
|
||||
|
||||
LRESULT CALLBACK AboutBox( HWND hDlg, UINT message,
|
||||
UINT wParam, LONG lParam );
|
||||
|
||||
|
||||
/* Screen dimensions. Maintained by de_win.c. */
|
||||
extern int LINES;
|
||||
extern int COLS;
|
||||
|
||||
/* File being edited. */
|
||||
extern char * arg_file_name;
|
||||
|
||||
/* Current display position in file. Maintained by de.c */
|
||||
extern int dis_line;
|
||||
extern int dis_col;
|
||||
|
||||
/* Current cursor position in file. */
|
||||
extern int line;
|
||||
extern int col;
|
||||
|
||||
/*
|
||||
* Calls from de_win.c to de.c
|
||||
*/
|
||||
|
||||
CORD retrieve_screen_line(int i);
|
||||
/* Get the contents of i'th screen line. */
|
||||
/* Relies on COLS. */
|
||||
|
||||
void set_position(int x, int y);
|
||||
/* Set column, row. Upper left of window = (0,0). */
|
||||
|
||||
void do_command(int);
|
||||
/* Execute an editor command. */
|
||||
/* Agument is a command character or one */
|
||||
/* of the IDM_ commands. */
|
||||
|
||||
void generic_init(void);
|
||||
/* OS independent initialization */
|
||||
|
||||
|
||||
/*
|
||||
* Calls from de.c to de_win.c
|
||||
*/
|
||||
|
||||
void move_cursor(int column, int line);
|
||||
/* Physically move the cursor on the display, */
|
||||
/* so that it appears at */
|
||||
/* (column, line). */
|
||||
|
||||
void invalidate_line(int line);
|
||||
/* Invalidate line i on the screen. */
|
||||
|
||||
void de_error(char *s);
|
||||
/* Display error message. */
|
||||
1029
boehm-gc/dbg_mlc.c
1029
boehm-gc/dbg_mlc.c
File diff suppressed because it is too large
Load Diff
@@ -1,90 +0,0 @@
|
||||
# Makefile to build Hans Boehm garbage collector using the Digital Mars
|
||||
# compiler from www.digitalmars.com
|
||||
# Written by Walter Bright
|
||||
|
||||
|
||||
DEFINES=-DNDEBUG -DSILENT -DGC_BUILD -D_WINDOWS -DGC_DLL -DALL_INTERIOR_POINTERS -D__STDC__ -DWIN32_THREADS
|
||||
CFLAGS=-Iinclude $(DEFINES) -wx -g
|
||||
LFLAGS=/ma/implib/co
|
||||
CC=sc
|
||||
|
||||
.c.obj:
|
||||
$(CC) -c $(CFLAGS) $*
|
||||
|
||||
.cpp.obj:
|
||||
$(CC) -c $(CFLAGS) -Aa $*
|
||||
|
||||
OBJS= \
|
||||
allchblk.obj\
|
||||
alloc.obj\
|
||||
blacklst.obj\
|
||||
checksums.obj\
|
||||
dbg_mlc.obj\
|
||||
dyn_load.obj\
|
||||
finalize.obj\
|
||||
gc_cpp.obj\
|
||||
headers.obj\
|
||||
mach_dep.obj\
|
||||
malloc.obj\
|
||||
mallocx.obj\
|
||||
mark.obj\
|
||||
mark_rts.obj\
|
||||
misc.obj\
|
||||
new_hblk.obj\
|
||||
obj_map.obj\
|
||||
os_dep.obj\
|
||||
ptr_chck.obj\
|
||||
reclaim.obj\
|
||||
stubborn.obj\
|
||||
typd_mlc.obj\
|
||||
win32_threads.obj
|
||||
|
||||
targets: gc.dll gc.lib gctest.exe
|
||||
|
||||
gc.dll: $(OBJS) gc.def digimars.mak
|
||||
sc -ogc.dll $(OBJS) -L$(LFLAGS) gc.def kernel32.lib user32.lib
|
||||
|
||||
gc.def: digimars.mak
|
||||
echo LIBRARY GC >gc.def
|
||||
echo DESCRIPTION "Hans Boehm Garbage Collector" >>gc.def
|
||||
echo EXETYPE NT >>gc.def
|
||||
echo EXPORTS >>gc.def
|
||||
echo GC_is_visible_print_proc >>gc.def
|
||||
echo GC_is_valid_displacement_print_proc >>gc.def
|
||||
|
||||
clean:
|
||||
del gc.def
|
||||
del $(OBJS)
|
||||
|
||||
|
||||
gctest.exe : gc.lib tests\test.obj
|
||||
sc -ogctest.exe tests\test.obj gc.lib
|
||||
|
||||
tests\test.obj : tests\test.c
|
||||
$(CC) -c -g -DNDEBUG -DSILENT -DGC_BUILD -D_WINDOWS -DGC_DLL \
|
||||
-DALL_INTERIOR_POINTERS -DWIN32_THREADS \
|
||||
-Iinclude tests\test.c -otests\test.obj
|
||||
|
||||
allchblk.obj: allchblk.c
|
||||
alloc.obj: alloc.c
|
||||
blacklst.obj: blacklst.c
|
||||
checksums.obj: checksums.c
|
||||
dbg_mlc.obj: dbg_mlc.c
|
||||
dyn_load.obj: dyn_load.c
|
||||
finalize.obj: finalize.c
|
||||
gc_cpp.obj: gc_cpp.cpp
|
||||
headers.obj: headers.c
|
||||
mach_dep.obj: mach_dep.c
|
||||
malloc.obj: malloc.c
|
||||
mallocx.obj: mallocx.c
|
||||
mark.obj: mark.c
|
||||
mark_rts.obj: mark_rts.c
|
||||
misc.obj: misc.c
|
||||
new_hblk.obj: new_hblk.c
|
||||
obj_map.obj: obj_map.c
|
||||
os_dep.obj: os_dep.c
|
||||
ptr_chck.obj: ptr_chck.c
|
||||
reclaim.obj: reclaim.c
|
||||
stubborn.obj: stubborn.c
|
||||
typd_mlc.obj: typd_mlc.c
|
||||
win32_threads.obj: win32_threads.c
|
||||
@@ -1,617 +0,0 @@
|
||||
Copyright (c) 1988, 1989 Hans-J. Boehm, Alan J. Demers
|
||||
Copyright (c) 1991-1996 by Xerox Corporation. All rights reserved.
|
||||
Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved.
|
||||
Copyright (c) 1999-2001 by Hewlett-Packard Company. All rights reserved.
|
||||
|
||||
The file linux_threads.c is also
|
||||
Copyright (c) 1998 by Fergus Henderson. All rights reserved.
|
||||
|
||||
The files Makefile.am, and configure.in are
|
||||
Copyright (c) 2001 by Red Hat Inc. All rights reserved.
|
||||
|
||||
The files config.guess and a few others are copyrighted by the Free
|
||||
Software Foundation.
|
||||
|
||||
THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
|
||||
Permission is hereby granted to use or copy this program
|
||||
for any purpose, provided the above notices are retained on all copies.
|
||||
Permission to modify the code and to distribute modified code is granted,
|
||||
provided the above notices are retained, and a notice that the code was
|
||||
modified is included with the above copyright notice.
|
||||
|
||||
A few of the files needed to use the GNU-style build procedure come with
|
||||
slightly different licenses, though they are all similar in spirit. A few
|
||||
are GPL'ed, but with an exception that should cover all uses in the
|
||||
collector. (If you are concerned about such things, I recommend you look
|
||||
at the notice in config.guess or ltmain.sh.)
|
||||
|
||||
This is version 6.1alpha1 of a conservative garbage collector for C and C++.
|
||||
|
||||
You might find a more recent version of this at
|
||||
|
||||
http://www.hpl.hp.com/personal/Hans_Boehm/gc
|
||||
|
||||
OVERVIEW
|
||||
|
||||
This is intended to be a general purpose, garbage collecting storage
|
||||
allocator. The algorithms used are described in:
|
||||
|
||||
Boehm, H., and M. Weiser, "Garbage Collection in an Uncooperative Environment",
|
||||
Software Practice & Experience, September 1988, pp. 807-820.
|
||||
|
||||
Boehm, H., A. Demers, and S. Shenker, "Mostly Parallel Garbage Collection",
|
||||
Proceedings of the ACM SIGPLAN '91 Conference on Programming Language Design
|
||||
and Implementation, SIGPLAN Notices 26, 6 (June 1991), pp. 157-164.
|
||||
|
||||
Boehm, H., "Space Efficient Conservative Garbage Collection", Proceedings
|
||||
of the ACM SIGPLAN '91 Conference on Programming Language Design and
|
||||
Implementation, SIGPLAN Notices 28, 6 (June 1993), pp. 197-206.
|
||||
|
||||
Boehm H., "Reducing Garbage Collector Cache Misses", Proceedings of the
|
||||
2000 International Symposium on Memory Management.
|
||||
|
||||
Possible interactions between the collector and optimizing compilers are
|
||||
discussed in
|
||||
|
||||
Boehm, H., and D. Chase, "A Proposal for GC-safe C Compilation",
|
||||
The Journal of C Language Translation 4, 2 (December 1992).
|
||||
|
||||
and
|
||||
|
||||
Boehm H., "Simple GC-safe Compilation", Proceedings
|
||||
of the ACM SIGPLAN '96 Conference on Programming Language Design and
|
||||
Implementation.
|
||||
|
||||
(Some of these are also available from
|
||||
http://www.hpl.hp.com/personal/Hans_Boehm/papers/, among other places.)
|
||||
|
||||
Unlike the collector described in the second reference, this collector
|
||||
operates either with the mutator stopped during the entire collection
|
||||
(default) or incrementally during allocations. (The latter is supported
|
||||
on only a few machines.) On the most common platforms, it can be built
|
||||
with or without thread support. On a few platforms, it can take advantage
|
||||
of a multiprocessor to speed up garbage collection.
|
||||
|
||||
Many of the ideas underlying the collector have previously been explored
|
||||
by others. Notably, some of the run-time systems developed at Xerox PARC
|
||||
in the early 1980s conservatively scanned thread stacks to locate possible
|
||||
pointers (cf. Paul Rovner, "On Adding Garbage Collection and Runtime Types
|
||||
to a Strongly-Typed Statically Checked, Concurrent Language" Xerox PARC
|
||||
CSL 84-7). Doug McIlroy wrote a simpler fully conservative collector that
|
||||
was part of version 8 UNIX (tm), but appears to not have received
|
||||
widespread use.
|
||||
|
||||
Rudimentary tools for use of the collector as a leak detector are included
|
||||
(see http://www.hpl.hp.com/personal/Hans_Boehm/gc/leak.html),
|
||||
as is a fairly sophisticated string package "cord" that makes use of the
|
||||
collector. (See doc/README.cords and H.-J. Boehm, R. Atkinson, and M. Plass,
|
||||
"Ropes: An Alternative to Strings", Software Practice and Experience 25, 12
|
||||
(December 1995), pp. 1315-1330. This is very similar to the "rope" package
|
||||
in Xerox Cedar, or the "rope" package in the SGI STL or the g++ distribution.)
|
||||
|
||||
Further collector documantation can be found at
|
||||
|
||||
http://www.hpl.hp.com/personal/Hans_Boehm/gc
|
||||
|
||||
|
||||
GENERAL DESCRIPTION
|
||||
|
||||
This is a garbage collecting storage allocator that is intended to be
|
||||
used as a plug-in replacement for C's malloc.
|
||||
|
||||
Since the collector does not require pointers to be tagged, it does not
|
||||
attempt to ensure that all inaccessible storage is reclaimed. However,
|
||||
in our experience, it is typically more successful at reclaiming unused
|
||||
memory than most C programs using explicit deallocation. Unlike manually
|
||||
introduced leaks, the amount of unreclaimed memory typically stays
|
||||
bounded.
|
||||
|
||||
In the following, an "object" is defined to be a region of memory allocated
|
||||
by the routines described below.
|
||||
|
||||
Any objects not intended to be collected must be pointed to either
|
||||
from other such accessible objects, or from the registers,
|
||||
stack, data, or statically allocated bss segments. Pointers from
|
||||
the stack or registers may point to anywhere inside an object.
|
||||
The same is true for heap pointers if the collector is compiled with
|
||||
ALL_INTERIOR_POINTERS defined, as is now the default.
|
||||
|
||||
Compiling without ALL_INTERIOR_POINTERS may reduce accidental retention
|
||||
of garbage objects, by requiring pointers from the heap to to the beginning
|
||||
of an object. But this no longer appears to be a significant
|
||||
issue for most programs.
|
||||
|
||||
There are a number of routines which modify the pointer recognition
|
||||
algorithm. GC_register_displacement allows certain interior pointers
|
||||
to be recognized even if ALL_INTERIOR_POINTERS is nor defined.
|
||||
GC_malloc_ignore_off_page allows some pointers into the middle of large objects
|
||||
to be disregarded, greatly reducing the probablility of accidental
|
||||
retention of large objects. For most purposes it seems best to compile
|
||||
with ALL_INTERIOR_POINTERS and to use GC_malloc_ignore_off_page if
|
||||
you get collector warnings from allocations of very large objects.
|
||||
See README.debugging for details.
|
||||
|
||||
WARNING: pointers inside memory allocated by the standard "malloc" are not
|
||||
seen by the garbage collector. Thus objects pointed to only from such a
|
||||
region may be prematurely deallocated. It is thus suggested that the
|
||||
standard "malloc" be used only for memory regions, such as I/O buffers, that
|
||||
are guaranteed not to contain pointers to garbage collectable memory.
|
||||
Pointers in C language automatic, static, or register variables,
|
||||
are correctly recognized. (Note that GC_malloc_uncollectable has semantics
|
||||
similar to standard malloc, but allocates objects that are traced by the
|
||||
collector.)
|
||||
|
||||
WARNING: the collector does not always know how to find pointers in data
|
||||
areas that are associated with dynamic libraries. This is easy to
|
||||
remedy IF you know how to find those data areas on your operating
|
||||
system (see GC_add_roots). Code for doing this under SunOS, IRIX 5.X and 6.X,
|
||||
HP/UX, Alpha OSF/1, Linux, and win32 is included and used by default. (See
|
||||
README.win32 for win32 details.) On other systems pointers from dynamic
|
||||
library data areas may not be considered by the collector.
|
||||
If you're writing a program that depends on the collector scanning
|
||||
dynamic library data areas, it may be a good idea to include at least
|
||||
one call to GC_is_visible() to ensure that those areas are visible
|
||||
to the collector.
|
||||
|
||||
Note that the garbage collector does not need to be informed of shared
|
||||
read-only data. However if the shared library mechanism can introduce
|
||||
discontiguous data areas that may contain pointers, then the collector does
|
||||
need to be informed.
|
||||
|
||||
Signal processing for most signals may be deferred during collection,
|
||||
and during uninterruptible parts of the allocation process.
|
||||
Like standard ANSI C mallocs, by default it is unsafe to invoke
|
||||
malloc (and other GC routines) from a signal handler while another
|
||||
malloc call may be in progress. Removing -DNO_SIGNALS from Makefile
|
||||
attempts to remedy that. But that may not be reliable with a compiler that
|
||||
substantially reorders memory operations inside GC_malloc.
|
||||
|
||||
The allocator/collector can also be configured for thread-safe operation.
|
||||
(Full signal safety can also be achieved, but only at the cost of two system
|
||||
calls per malloc, which is usually unacceptable.)
|
||||
WARNING: the collector does not guarantee to scan thread-local storage
|
||||
(e.g. of the kind accessed with pthread_getspecific()). The collector
|
||||
does scan thread stacks, though, so generally the best solution is to
|
||||
ensure that any pointers stored in thread-local storage are also
|
||||
stored on the thread's stack for the duration of their lifetime.
|
||||
(This is arguably a longstanding bug, but it hasn't been fixed yet.)
|
||||
|
||||
INSTALLATION AND PORTABILITY
|
||||
|
||||
As distributed, the macro SILENT is defined in Makefile.
|
||||
In the event of problems, this can be removed to obtain a moderate
|
||||
amount of descriptive output for each collection.
|
||||
(The given statistics exhibit a few peculiarities.
|
||||
Things don't appear to add up for a variety of reasons, most notably
|
||||
fragmentation losses. These are probably much more significant for the
|
||||
contrived program "test.c" than for your application.)
|
||||
|
||||
Note that typing "make test" will automatically build the collector
|
||||
and then run setjmp_test and gctest. Setjmp_test will give you information
|
||||
about configuring the collector, which is useful primarily if you have
|
||||
a machine that's not already supported. Gctest is a somewhat superficial
|
||||
test of collector functionality. Failure is indicated by a core dump or
|
||||
a message to the effect that the collector is broken. Gctest takes about
|
||||
35 seconds to run on a SPARCstation 2. It may use up to 8 MB of memory. (The
|
||||
multi-threaded version will use more. 64-bit versions may use more.)
|
||||
"Make test" will also, as its last step, attempt to build and test the
|
||||
"cord" string library. This will fail without an ANSI C compiler, but
|
||||
the garbage collector itself should still be usable.
|
||||
|
||||
The Makefile will generate a library gc.a which you should link against.
|
||||
Typing "make cords" will add the cord library to gc.a.
|
||||
Note that this requires an ANSI C compiler.
|
||||
|
||||
It is suggested that if you need to replace a piece of the collector
|
||||
(e.g. GC_mark_rts.c) you simply list your version ahead of gc.a on the
|
||||
ld command line, rather than replacing the one in gc.a. (This will
|
||||
generate numerous warnings under some versions of AIX, but it still
|
||||
works.)
|
||||
|
||||
All include files that need to be used by clients will be put in the
|
||||
include subdirectory. (Normally this is just gc.h. "Make cords" adds
|
||||
"cord.h" and "ec.h".)
|
||||
|
||||
The collector currently is designed to run essentially unmodified on
|
||||
machines that use a flat 32-bit or 64-bit address space.
|
||||
That includes the vast majority of Workstations and X86 (X >= 3) PCs.
|
||||
(The list here was deleted because it was getting too long and constantly
|
||||
out of date.)
|
||||
It does NOT run under plain 16-bit DOS or Windows 3.X. There are however
|
||||
various packages (e.g. win32s, djgpp) that allow flat 32-bit address
|
||||
applications to run under those systemsif the have at least an 80386 processor,
|
||||
and several of those are compatible with the collector.
|
||||
|
||||
In a few cases (Amiga, OS/2, Win32, MacOS) a separate makefile
|
||||
or equivalent is supplied. Many of these have separate README.system
|
||||
files.
|
||||
|
||||
Dynamic libraries are completely supported only under SunOS
|
||||
(and even that support is not functional on the last Sun 3 release),
|
||||
Linux, IRIX 5&6, HP-PA, Win32 (not Win32S) and OSF/1 on DEC AXP machines.
|
||||
On other machines we recommend that you do one of the following:
|
||||
|
||||
1) Add dynamic library support (and send us the code).
|
||||
2) Use static versions of the libraries.
|
||||
3) Arrange for dynamic libraries to use the standard malloc.
|
||||
This is still dangerous if the library stores a pointer to a
|
||||
garbage collected object. But nearly all standard interfaces
|
||||
prohibit this, because they deal correctly with pointers
|
||||
to stack allocated objects. (Strtok is an exception. Don't
|
||||
use it.)
|
||||
|
||||
In all cases we assume that pointer alignment is consistent with that
|
||||
enforced by the standard C compilers. If you use a nonstandard compiler
|
||||
you may have to adjust the alignment parameters defined in gc_priv.h.
|
||||
|
||||
A port to a machine that is not byte addressed, or does not use 32 bit
|
||||
or 64 bit addresses will require a major effort. A port to plain MSDOS
|
||||
or win16 is hard.
|
||||
|
||||
For machines not already mentioned, or for nonstandard compilers, the
|
||||
following are likely to require change:
|
||||
|
||||
1. The parameters in gcconfig.h.
|
||||
The parameters that will usually require adjustment are
|
||||
STACKBOTTOM, ALIGNMENT and DATASTART. Setjmp_test
|
||||
prints its guesses of the first two.
|
||||
DATASTART should be an expression for computing the
|
||||
address of the beginning of the data segment. This can often be
|
||||
&etext. But some memory management units require that there be
|
||||
some unmapped space between the text and the data segment. Thus
|
||||
it may be more complicated. On UNIX systems, this is rarely
|
||||
documented. But the adb "$m" command may be helpful. (Note
|
||||
that DATASTART will usually be a function of &etext. Thus a
|
||||
single experiment is usually insufficient.)
|
||||
STACKBOTTOM is used to initialize GC_stackbottom, which
|
||||
should be a sufficient approximation to the coldest stack address.
|
||||
On some machines, it is difficult to obtain such a value that is
|
||||
valid across a variety of MMUs, OS releases, etc. A number of
|
||||
alternatives exist for using the collector in spite of this. See the
|
||||
discussion in gcconfig.h immediately preceding the various
|
||||
definitions of STACKBOTTOM.
|
||||
|
||||
2. mach_dep.c.
|
||||
The most important routine here is one to mark from registers.
|
||||
The distributed file includes a generic hack (based on setjmp) that
|
||||
happens to work on many machines, and may work on yours. Try
|
||||
compiling and running setjmp_t.c to see whether it has a chance of
|
||||
working. (This is not correct C, so don't blame your compiler if it
|
||||
doesn't work. Based on limited experience, register window machines
|
||||
are likely to cause trouble. If your version of setjmp claims that
|
||||
all accessible variables, including registers, have the value they
|
||||
had at the time of the longjmp, it also will not work. Vanilla 4.2 BSD
|
||||
on Vaxen makes such a claim. SunOS does not.)
|
||||
If your compiler does not allow in-line assembly code, or if you prefer
|
||||
not to use such a facility, mach_dep.c may be replaced by a .s file
|
||||
(as we did for the MIPS machine and the PC/RT).
|
||||
At this point enough architectures are supported by mach_dep.c
|
||||
that you will rarely need to do more than adjust for assembler
|
||||
syntax.
|
||||
|
||||
3. os_dep.c (and gc_priv.h).
|
||||
Several kinds of operating system dependent routines reside here.
|
||||
Many are optional. Several are invoked only through corresponding
|
||||
macros in gc_priv.h, which may also be redefined as appropriate.
|
||||
The routine GC_register_data_segments is crucial. It registers static
|
||||
data areas that must be traversed by the collector. (User calls to
|
||||
GC_add_roots may sometimes be used for similar effect.)
|
||||
Routines to obtain memory from the OS also reside here.
|
||||
Alternatively this can be done entirely by the macro GET_MEM
|
||||
defined in gc_priv.h. Routines to disable and reenable signals
|
||||
also reside here if they are need by the macros DISABLE_SIGNALS
|
||||
and ENABLE_SIGNALS defined in gc_priv.h.
|
||||
In a multithreaded environment, the macros LOCK and UNLOCK
|
||||
in gc_priv.h will need to be suitably redefined.
|
||||
The incremental collector requires page dirty information, which
|
||||
is acquired through routines defined in os_dep.c. Unless directed
|
||||
otherwise by gcconfig.h, these are implemented as stubs that simply
|
||||
treat all pages as dirty. (This of course makes the incremental
|
||||
collector much less useful.)
|
||||
|
||||
4. dyn_load.c
|
||||
This provides a routine that allows the collector to scan data
|
||||
segments associated with dynamic libraries. Often it is not
|
||||
necessary to provide this routine unless user-written dynamic
|
||||
libraries are used.
|
||||
|
||||
For a different version of UN*X or different machines using the
|
||||
Motorola 68000, Vax, SPARC, 80386, NS 32000, PC/RT, or MIPS architecture,
|
||||
it should frequently suffice to change definitions in gcconfig.h.
|
||||
|
||||
|
||||
THE C INTERFACE TO THE ALLOCATOR
|
||||
|
||||
The following routines are intended to be directly called by the user.
|
||||
Note that usually only GC_malloc is necessary. GC_clear_roots and GC_add_roots
|
||||
calls may be required if the collector has to trace from nonstandard places
|
||||
(e.g. from dynamic library data areas on a machine on which the
|
||||
collector doesn't already understand them.) On some machines, it may
|
||||
be desirable to set GC_stacktop to a good approximation of the stack base.
|
||||
(This enhances code portability on HP PA machines, since there is no
|
||||
good way for the collector to compute this value.) Client code may include
|
||||
"gc.h", which defines all of the following, plus many others.
|
||||
|
||||
1) GC_malloc(nbytes)
|
||||
- allocate an object of size nbytes. Unlike malloc, the object is
|
||||
cleared before being returned to the user. Gc_malloc will
|
||||
invoke the garbage collector when it determines this to be appropriate.
|
||||
GC_malloc may return 0 if it is unable to acquire sufficient
|
||||
space from the operating system. This is the most probable
|
||||
consequence of running out of space. Other possible consequences
|
||||
are that a function call will fail due to lack of stack space,
|
||||
or that the collector will fail in other ways because it cannot
|
||||
maintain its internal data structures, or that a crucial system
|
||||
process will fail and take down the machine. Most of these
|
||||
possibilities are independent of the malloc implementation.
|
||||
|
||||
2) GC_malloc_atomic(nbytes)
|
||||
- allocate an object of size nbytes that is guaranteed not to contain any
|
||||
pointers. The returned object is not guaranteed to be cleared.
|
||||
(Can always be replaced by GC_malloc, but results in faster collection
|
||||
times. The collector will probably run faster if large character
|
||||
arrays, etc. are allocated with GC_malloc_atomic than if they are
|
||||
statically allocated.)
|
||||
|
||||
3) GC_realloc(object, new_size)
|
||||
- change the size of object to be new_size. Returns a pointer to the
|
||||
new object, which may, or may not, be the same as the pointer to
|
||||
the old object. The new object is taken to be atomic iff the old one
|
||||
was. If the new object is composite and larger than the original object,
|
||||
then the newly added bytes are cleared (we hope). This is very likely
|
||||
to allocate a new object, unless MERGE_SIZES is defined in gc_priv.h.
|
||||
Even then, it is likely to recycle the old object only if the object
|
||||
is grown in small additive increments (which, we claim, is generally bad
|
||||
coding practice.)
|
||||
|
||||
4) GC_free(object)
|
||||
- explicitly deallocate an object returned by GC_malloc or
|
||||
GC_malloc_atomic. Not necessary, but can be used to minimize
|
||||
collections if performance is critical. Probably a performance
|
||||
loss for very small objects (<= 8 bytes).
|
||||
|
||||
5) GC_expand_hp(bytes)
|
||||
- Explicitly increase the heap size. (This is normally done automatically
|
||||
if a garbage collection failed to GC_reclaim enough memory. Explicit
|
||||
calls to GC_expand_hp may prevent unnecessarily frequent collections at
|
||||
program startup.)
|
||||
|
||||
6) GC_malloc_ignore_off_page(bytes)
|
||||
- identical to GC_malloc, but the client promises to keep a pointer to
|
||||
the somewhere within the first 256 bytes of the object while it is
|
||||
live. (This pointer should nortmally be declared volatile to prevent
|
||||
interference from compiler optimizations.) This is the recommended
|
||||
way to allocate anything that is likely to be larger than 100Kbytes
|
||||
or so. (GC_malloc may result in failure to reclaim such objects.)
|
||||
|
||||
7) GC_set_warn_proc(proc)
|
||||
- Can be used to redirect warnings from the collector. Such warnings
|
||||
should be rare, and should not be ignored during code development.
|
||||
|
||||
8) GC_enable_incremental()
|
||||
- Enables generational and incremental collection. Useful for large
|
||||
heaps on machines that provide access to page dirty information.
|
||||
Some dirty bit implementations may interfere with debugging
|
||||
(by catching address faults) and place restrictions on heap arguments
|
||||
to system calls (since write faults inside a system call may not be
|
||||
handled well).
|
||||
|
||||
9) Several routines to allow for registration of finalization code.
|
||||
User supplied finalization code may be invoked when an object becomes
|
||||
unreachable. To call (*f)(obj, x) when obj becomes inaccessible, use
|
||||
GC_register_finalizer(obj, f, x, 0, 0);
|
||||
For more sophisticated uses, and for finalization ordering issues,
|
||||
see gc.h.
|
||||
|
||||
The global variable GC_free_space_divisor may be adjusted up from its
|
||||
default value of 4 to use less space and more collection time, or down for
|
||||
the opposite effect. Setting it to 1 or 0 will effectively disable collections
|
||||
and cause all allocations to simply grow the heap.
|
||||
|
||||
The variable GC_non_gc_bytes, which is normally 0, may be changed to reflect
|
||||
the amount of memory allocated by the above routines that should not be
|
||||
considered as a candidate for collection. Careless use may, of course, result
|
||||
in excessive memory consumption.
|
||||
|
||||
Some additional tuning is possible through the parameters defined
|
||||
near the top of gc_priv.h.
|
||||
|
||||
If only GC_malloc is intended to be used, it might be appropriate to define:
|
||||
|
||||
#define malloc(n) GC_malloc(n)
|
||||
#define calloc(m,n) GC_malloc((m)*(n))
|
||||
|
||||
For small pieces of VERY allocation intensive code, gc_inl.h
|
||||
includes some allocation macros that may be used in place of GC_malloc
|
||||
and friends.
|
||||
|
||||
All externally visible names in the garbage collector start with "GC_".
|
||||
To avoid name conflicts, client code should avoid this prefix, except when
|
||||
accessing garbage collector routines or variables.
|
||||
|
||||
There are provisions for allocation with explicit type information.
|
||||
This is rarely necessary. Details can be found in gc_typed.h.
|
||||
|
||||
THE C++ INTERFACE TO THE ALLOCATOR:
|
||||
|
||||
The Ellis-Hull C++ interface to the collector is included in
|
||||
the collector distribution. If you intend to use this, type
|
||||
"make c++" after the initial build of the collector is complete.
|
||||
See gc_cpp.h for the definition of the interface. This interface
|
||||
tries to approximate the Ellis-Detlefs C++ garbage collection
|
||||
proposal without compiler changes.
|
||||
|
||||
Cautions:
|
||||
1. Arrays allocated without new placement syntax are
|
||||
allocated as uncollectable objects. They are traced by the
|
||||
collector, but will not be reclaimed.
|
||||
|
||||
2. Failure to use "make c++" in combination with (1) will
|
||||
result in arrays allocated using the default new operator.
|
||||
This is likely to result in disaster without linker warnings.
|
||||
|
||||
3. If your compiler supports an overloaded new[] operator,
|
||||
then gc_cpp.cc and gc_cpp.h should be suitably modified.
|
||||
|
||||
4. Many current C++ compilers have deficiencies that
|
||||
break some of the functionality. See the comments in gc_cpp.h
|
||||
for suggested workarounds.
|
||||
|
||||
USE AS LEAK DETECTOR:
|
||||
|
||||
The collector may be used to track down leaks in C programs that are
|
||||
intended to run with malloc/free (e.g. code with extreme real-time or
|
||||
portability constraints). To do so define FIND_LEAK in Makefile
|
||||
This will cause the collector to invoke the report_leak
|
||||
routine defined near the top of reclaim.c whenever an inaccessible
|
||||
object is found that has not been explicitly freed. Such objects will
|
||||
also be automatically reclaimed.
|
||||
Productive use of this facility normally involves redefining report_leak
|
||||
to do something more intelligent. This typically requires annotating
|
||||
objects with additional information (e.g. creation time stack trace) that
|
||||
identifies their origin. Such code is typically not very portable, and is
|
||||
not included here, except on SPARC machines.
|
||||
If all objects are allocated with GC_DEBUG_MALLOC (see next section),
|
||||
then the default version of report_leak will report the source file
|
||||
and line number at which the leaked object was allocated. This may
|
||||
sometimes be sufficient. (On SPARC/SUNOS4 machines, it will also report
|
||||
a cryptic stack trace. This can often be turned into a sympolic stack
|
||||
trace by invoking program "foo" with "callprocs foo". Callprocs is
|
||||
a short shell script that invokes adb to expand program counter values
|
||||
to symbolic addresses. It was largely supplied by Scott Schwartz.)
|
||||
Note that the debugging facilities described in the next section can
|
||||
sometimes be slightly LESS effective in leak finding mode, since in
|
||||
leak finding mode, GC_debug_free actually results in reuse of the object.
|
||||
(Otherwise the object is simply marked invalid.) Also note that the test
|
||||
program is not designed to run meaningfully in FIND_LEAK mode.
|
||||
Use "make gc.a" to build the collector.
|
||||
|
||||
DEBUGGING FACILITIES:
|
||||
|
||||
The routines GC_debug_malloc, GC_debug_malloc_atomic, GC_debug_realloc,
|
||||
and GC_debug_free provide an alternate interface to the collector, which
|
||||
provides some help with memory overwrite errors, and the like.
|
||||
Objects allocated in this way are annotated with additional
|
||||
information. Some of this information is checked during garbage
|
||||
collections, and detected inconsistencies are reported to stderr.
|
||||
|
||||
Simple cases of writing past the end of an allocated object should
|
||||
be caught if the object is explicitly deallocated, or if the
|
||||
collector is invoked while the object is live. The first deallocation
|
||||
of an object will clear the debugging info associated with an
|
||||
object, so accidentally repeated calls to GC_debug_free will report the
|
||||
deallocation of an object without debugging information. Out of
|
||||
memory errors will be reported to stderr, in addition to returning
|
||||
NIL.
|
||||
|
||||
GC_debug_malloc checking during garbage collection is enabled
|
||||
with the first call to GC_debug_malloc. This will result in some
|
||||
slowdown during collections. If frequent heap checks are desired,
|
||||
this can be achieved by explicitly invoking GC_gcollect, e.g. from
|
||||
the debugger.
|
||||
|
||||
GC_debug_malloc allocated objects should not be passed to GC_realloc
|
||||
or GC_free, and conversely. It is however acceptable to allocate only
|
||||
some objects with GC_debug_malloc, and to use GC_malloc for other objects,
|
||||
provided the two pools are kept distinct. In this case, there is a very
|
||||
low probablility that GC_malloc allocated objects may be misidentified as
|
||||
having been overwritten. This should happen with probability at most
|
||||
one in 2**32. This probability is zero if GC_debug_malloc is never called.
|
||||
|
||||
GC_debug_malloc, GC_malloc_atomic, and GC_debug_realloc take two
|
||||
additional trailing arguments, a string and an integer. These are not
|
||||
interpreted by the allocator. They are stored in the object (the string is
|
||||
not copied). If an error involving the object is detected, they are printed.
|
||||
|
||||
The macros GC_MALLOC, GC_MALLOC_ATOMIC, GC_REALLOC, GC_FREE, and
|
||||
GC_REGISTER_FINALIZER are also provided. These require the same arguments
|
||||
as the corresponding (nondebugging) routines. If gc.h is included
|
||||
with GC_DEBUG defined, they call the debugging versions of these
|
||||
functions, passing the current file name and line number as the two
|
||||
extra arguments, where appropriate. If gc.h is included without GC_DEBUG
|
||||
defined, then all these macros will instead be defined to their nondebugging
|
||||
equivalents. (GC_REGISTER_FINALIZER is necessary, since pointers to
|
||||
objects with debugging information are really pointers to a displacement
|
||||
of 16 bytes form the object beginning, and some translation is necessary
|
||||
when finalization routines are invoked. For details, about what's stored
|
||||
in the header, see the definition of the type oh in debug_malloc.c)
|
||||
|
||||
INCREMENTAL/GENERATIONAL COLLECTION:
|
||||
|
||||
The collector normally interrupts client code for the duration of
|
||||
a garbage collection mark phase. This may be unacceptable if interactive
|
||||
response is needed for programs with large heaps. The collector
|
||||
can also run in a "generational" mode, in which it usually attempts to
|
||||
collect only objects allocated since the last garbage collection.
|
||||
Furthermore, in this mode, garbage collections run mostly incrementally,
|
||||
with a small amount of work performed in response to each of a large number of
|
||||
GC_malloc requests.
|
||||
|
||||
This mode is enabled by a call to GC_enable_incremental().
|
||||
|
||||
Incremental and generational collection is effective in reducing
|
||||
pause times only if the collector has some way to tell which objects
|
||||
or pages have been recently modified. The collector uses two sources
|
||||
of information:
|
||||
|
||||
1. Information provided by the VM system. This may be provided in
|
||||
one of several forms. Under Solaris 2.X (and potentially under other
|
||||
similar systems) information on dirty pages can be read from the
|
||||
/proc file system. Under other systems (currently SunOS4.X) it is
|
||||
possible to write-protect the heap, and catch the resulting faults.
|
||||
On these systems we require that system calls writing to the heap
|
||||
(other than read) be handled specially by client code.
|
||||
See os_dep.c for details.
|
||||
|
||||
2. Information supplied by the programmer. We define "stubborn"
|
||||
objects to be objects that are rarely changed. Such an object
|
||||
can be allocated (and enabled for writing) with GC_malloc_stubborn.
|
||||
Once it has been initialized, the collector should be informed with
|
||||
a call to GC_end_stubborn_change. Subsequent writes that store
|
||||
pointers into the object must be preceded by a call to
|
||||
GC_change_stubborn.
|
||||
|
||||
This mechanism performs best for objects that are written only for
|
||||
initialization, and such that only one stubborn object is writable
|
||||
at once. It is typically not worth using for short-lived
|
||||
objects. Stubborn objects are treated less efficiently than pointerfree
|
||||
(atomic) objects.
|
||||
|
||||
A rough rule of thumb is that, in the absence of VM information, garbage
|
||||
collection pauses are proportional to the amount of pointerful storage
|
||||
plus the amount of modified "stubborn" storage that is reachable during
|
||||
the collection.
|
||||
|
||||
Initial allocation of stubborn objects takes longer than allocation
|
||||
of other objects, since other data structures need to be maintained.
|
||||
|
||||
We recommend against random use of stubborn objects in client
|
||||
code, since bugs caused by inappropriate writes to stubborn objects
|
||||
are likely to be very infrequently observed and hard to trace.
|
||||
However, their use may be appropriate in a few carefully written
|
||||
library routines that do not make the objects themselves available
|
||||
for writing by client code.
|
||||
|
||||
|
||||
BUGS:
|
||||
|
||||
Any memory that does not have a recognizable pointer to it will be
|
||||
reclaimed. Exclusive-or'ing forward and backward links in a list
|
||||
doesn't cut it.
|
||||
Some C optimizers may lose the last undisguised pointer to a memory
|
||||
object as a consequence of clever optimizations. This has almost
|
||||
never been observed in practice. Send mail to boehm@acm.org
|
||||
for suggestions on how to fix your compiler.
|
||||
This is not a real-time collector. In the standard configuration,
|
||||
percentage of time required for collection should be constant across
|
||||
heap sizes. But collection pauses will increase for larger heaps.
|
||||
(On SPARCstation 2s collection times will be on the order of 300 msecs
|
||||
per MB of accessible memory that needs to be scanned. Your mileage
|
||||
may vary.) The incremental/generational collection facility helps,
|
||||
but is portable only if "stubborn" allocation is used.
|
||||
Please address bug reports to boehm@acm.org. If you are
|
||||
contemplating a major addition, you might also send mail to ask whether
|
||||
it's already been done (or whether we tried and discarded it).
|
||||
|
||||
@@ -1,385 +0,0 @@
|
||||
Patrick Beard's Notes for building GC v4.12 with CodeWarrior Pro 2:
|
||||
----------------------------------------------------------------------------
|
||||
The current build environment for the collector is CodeWarrior Pro 2.
|
||||
Projects for CodeWarrior Pro 2 (and for quite a few older versions)
|
||||
are distributed in the file Mac_projects.sit.hqx. The project file
|
||||
:Mac_projects:gc.prj builds static library versions of the collector.
|
||||
:Mac_projects:gctest.prj builds the GC test suite.
|
||||
|
||||
Configuring the collector is still done by editing the files
|
||||
:Mac_files:MacOS_config.h and :Mac_files:MacOS_Test_config.h.
|
||||
|
||||
Lars Farm's suggestions on building the collector:
|
||||
----------------------------------------------------------------------------
|
||||
Garbage Collection on MacOS - a manual 'MakeFile'
|
||||
-------------------------------------------------
|
||||
|
||||
Project files and IDE's are great on the Macintosh, but they do have
|
||||
problems when used as distribution media. This note tries to provide
|
||||
porting instructions in pure TEXT form to avoid those problems. A manual
|
||||
'makefile' if you like.
|
||||
|
||||
GC version: 4.12a2
|
||||
Codewarrior: CWPro1
|
||||
date: 18 July 1997
|
||||
|
||||
The notes may or may not apply to earlier or later versions of the
|
||||
GC/CWPro. Actually, they do apply to earlier versions of both except that
|
||||
until recently a project could only build one target so each target was a
|
||||
separate project. The notes will most likely apply to future versions too.
|
||||
Possibly with minor tweaks.
|
||||
|
||||
This is just to record my experiences. These notes do not mean I now
|
||||
provide a supported port of the GC to MacOS. It works for me. If it works
|
||||
for you, great. If it doesn't, sorry, try again...;-) Still, if you find
|
||||
errors, please let me know.
|
||||
|
||||
mailto: lars.farm@ite.mh.se
|
||||
|
||||
address: Lars Farm
|
||||
Krönvägen 33b
|
||||
856 44 Sundsvall
|
||||
Sweden
|
||||
|
||||
Porting to MacOS is a bit more complex than it first seems. Which MacOS?
|
||||
68K/PowerPC? Which compiler? Each supports both 68K and PowerPC and offer a
|
||||
large number of (unique to each environment) compiler settings. Each
|
||||
combination of compiler/68K/PPC/settings require a unique combination of
|
||||
standard libraries. And the IDE's does not select them for you. They don't
|
||||
even check that the library is built with compatible setting and this is
|
||||
the major source of problems when porting the GC (and otherwise too).
|
||||
|
||||
You will have to make choices when you configure the GC. I've made some
|
||||
choices here, but there are other combinations of settings and #defines
|
||||
that work too.
|
||||
|
||||
As for target settings the major obstacles may be:
|
||||
- 68K Processor: check "4-byte Ints".
|
||||
- PPC Processor: uncheck "Store Static Data in TOC".
|
||||
|
||||
What you need to do:
|
||||
===================
|
||||
|
||||
1) Build the GC as a library
|
||||
2) Test that the library works with 'test.c'.
|
||||
3) Test that the C++ interface 'gc_cpp.cc/h' works with 'test_cpp.cc'.
|
||||
|
||||
1) The Libraries:
|
||||
=================
|
||||
I made one project with four targets (68K/PPC tempmem or appheap). One target
|
||||
will suffice if you're able to decide which one you want. I wasn't...
|
||||
|
||||
Codewarrior allows a large number of compiler/linker settings. I used these:
|
||||
|
||||
Settings shared by all targets:
|
||||
------------------------------
|
||||
o Access Paths:
|
||||
- User Paths: the GC folder
|
||||
- System Paths: {Compiler}:Metrowerks Standard Library:
|
||||
{Compiler}:MacOS Support:Headers:
|
||||
{Compiler}:MacOS Support:MacHeaders:
|
||||
o C/C++ language:
|
||||
- inlining: normal
|
||||
- direct to SOM: off
|
||||
- enable/check: exceptions, RTTI, bool (and if you like pool strings)
|
||||
|
||||
PowerPC target settings
|
||||
-----------------------
|
||||
o Target Settings:
|
||||
- name of target
|
||||
- MacOS PPC Linker
|
||||
o PPC Target
|
||||
- name of library
|
||||
o C/C++ language
|
||||
- prefix file as described below
|
||||
o PPC Processor
|
||||
- Struct Alignment: PowerPC
|
||||
- uncheck "Store Static Data in TOC" -- important!
|
||||
I don't think the others matter, I use full optimization and its ok
|
||||
o PPC Linker
|
||||
- Factory Settings (SYM file with full paths, faster linking, dead-strip
|
||||
static init, Main: __start)
|
||||
|
||||
|
||||
68K target settings
|
||||
-------------------
|
||||
o Target Settings:
|
||||
- name of target
|
||||
- MacOS 68K Linker
|
||||
o 68K Target
|
||||
- name of library
|
||||
- A5 relative data
|
||||
o C/C++ language
|
||||
- prefix file as described below
|
||||
o 68K Processor
|
||||
- Code model: smart
|
||||
- Struct alignment: 68K
|
||||
- FP: SANE
|
||||
- enable 4-Byte Ints -- important!
|
||||
I don't think the others matter. I selected...
|
||||
- enable: 68020
|
||||
- enable: global register allocation
|
||||
o IR Optimizer
|
||||
- enable: Optimize Space, Optimize Speed
|
||||
I suppose the others would work too, but haven't tried...
|
||||
o 68K Linker
|
||||
- Factory Settings (New Style MacsBug,SYM file with full paths,
|
||||
A6 Frames, fast link, Merge compiler glue into segment 1,
|
||||
dead-strip static init)
|
||||
|
||||
Prefix Files to configure the GC sources
|
||||
----------------------------------------
|
||||
The Codewarrior equivalent of commandline compilers -DNAME=X is to use
|
||||
prefix-files. A TEXT file that is automatically #included before the first byte
|
||||
of every source file. I used these:
|
||||
|
||||
---- ( cut here ) ---- gc_prefix_tempmem.h -- 68K and PPC -----
|
||||
#include "gc_prefix_common.h"
|
||||
#undef USE_TEMPORARY_MEMORY
|
||||
#define USE_TEMPORARY_MEMORY
|
||||
---- ( cut here ) ---- gc_prefix_appmem.h -- 68K and PPC -----
|
||||
#include "gc_prefix_common.h"
|
||||
#undef USE_TEMPORARY_MEMORY
|
||||
// #define USE_TEMPORARY_MEMORY
|
||||
|
||||
---- ( cut here ) ---- gc_prefix_common.h --------------------
|
||||
// gc_prefix_common.h
|
||||
// ------------------
|
||||
// Codewarrior prefix file to configure the GC libraries
|
||||
//
|
||||
// prefix files are the Codewarrior equivalent of the
|
||||
// command line option -Dname=x frequently seen in makefiles
|
||||
|
||||
#if !__MWERKS__
|
||||
#error only tried this with Codewarrior
|
||||
#endif
|
||||
|
||||
#if macintosh
|
||||
#define MSL_USE_PRECOMPILED_HEADERS 0
|
||||
#include <ansi_prefix.mac.h>
|
||||
#ifndef __STDC__
|
||||
#define __STDC__ 0
|
||||
#endif
|
||||
|
||||
// See list of #defines to configure the library in: 'MakeFile'
|
||||
// see also README
|
||||
|
||||
#define SILENT // no collection messages. In case
|
||||
// of trouble you might want this off
|
||||
#define ALL_INTERIOR_POINTERS // follows interior pointers.
|
||||
//#define DONT_ADD_BYTE_AT_END // disables the padding if defined.
|
||||
//#define SMALL_CONFIG // whether to use a smaller heap.
|
||||
#define NO_SIGNALS // signals aren't real on the Macintosh.
|
||||
#define ATOMIC_UNCOLLECTABLE // GC_malloc_atomic_uncollectable()
|
||||
|
||||
// define either or none as per personal preference
|
||||
// used in malloc.c
|
||||
#define REDIRECT_MALLOC GC_malloc
|
||||
//#define REDIRECT_MALLOC GC_malloc_uncollectable
|
||||
// if REDIRECT_MALLOC is #defined make sure that the GC library
|
||||
// is listed before the ANSI/ISO libs in the Codewarrior
|
||||
// 'Link order' panel
|
||||
//#define IGNORE_FREE
|
||||
|
||||
// mac specific configs
|
||||
//#define USE_TEMPORARY_MEMORY // use Macintosh temporary memory.
|
||||
//#define SHARED_LIBRARY_BUILD // build for use in a shared library.
|
||||
|
||||
#else
|
||||
// could build Win32 here too, or in the future
|
||||
// Rhapsody PPC-mach, Rhapsody PPC-MacOS,
|
||||
// Rhapsody Intel-mach, Rhapsody Intel-Win32,...
|
||||
// ... ugh this will get messy ...
|
||||
#endif
|
||||
|
||||
// make sure ints are at least 32-bit
|
||||
// ( could be set to 16-bit by compiler settings (68K) )
|
||||
|
||||
struct gc_private_assert_intsize_{ char x[ sizeof(int)>=4 ? 1 : 0 ]; };
|
||||
|
||||
#if __powerc
|
||||
#if __option(toc_data)
|
||||
#error turn off "store static data in TOC" when using GC
|
||||
// ... or find a way to add TOC to the root set...(?)
|
||||
#endif
|
||||
#endif
|
||||
---- ( cut here ) ---- end of gc_prefix_common.h -----------------
|
||||
|
||||
Files to build the GC libraries:
|
||||
--------------------------------
|
||||
allchblk.c
|
||||
alloc.c
|
||||
blacklst.c
|
||||
checksums.c
|
||||
dbg_mlc.c
|
||||
finalize.c
|
||||
headers.c
|
||||
mach_dep.c
|
||||
MacOS.c -- contains MacOS code
|
||||
malloc.c
|
||||
mallocx.c
|
||||
mark.c
|
||||
mark_rts.c
|
||||
misc.c
|
||||
new_hblk.c
|
||||
obj_map.c
|
||||
os_dep.c -- contains MacOS code
|
||||
ptr_chck.c
|
||||
reclaim.c
|
||||
stubborn.c
|
||||
typd_mlc.c
|
||||
gc++.cc -- this is 'gc_cpp.cc' with less 'inline' and
|
||||
-- throw std::bad_alloc when out of memory
|
||||
-- gc_cpp.cc works just fine too
|
||||
|
||||
2) Test that the library works with 'test.c'.
|
||||
=============================================
|
||||
|
||||
The test app is just an ordinary ANSI-C console app. Make sure settings
|
||||
match the library you're testing.
|
||||
|
||||
Files
|
||||
-----
|
||||
test.c
|
||||
the GC library to test -- link order before ANSI libs
|
||||
suitable Mac+ANSI libraries
|
||||
|
||||
prefix:
|
||||
------
|
||||
---- ( cut here ) ---- gc_prefix_testlib.h -- all libs -----
|
||||
#define MSL_USE_PRECOMPILED_HEADERS 0
|
||||
#include <ansi_prefix.mac.h>
|
||||
#undef NDEBUG
|
||||
|
||||
#define ALL_INTERIOR_POINTERS /* for GC_priv.h */
|
||||
---- ( cut here ) ----
|
||||
|
||||
3) Test that the C++ interface 'gc_cpp.cc/h' works with 'test_cpp.cc'.
|
||||
|
||||
The test app is just an ordinary ANSI-C console app. Make sure settings match
|
||||
the library you're testing.
|
||||
|
||||
Files
|
||||
-----
|
||||
test_cpp.cc
|
||||
the GC library to test -- link order before ANSI libs
|
||||
suitable Mac+ANSI libraries
|
||||
|
||||
prefix:
|
||||
------
|
||||
same as for test.c
|
||||
|
||||
For convenience I used one test-project with several targets so that all
|
||||
test apps are build at once. Two for each library to test: test.c and
|
||||
gc_app.cc. When I was satisfied that the libraries were ok. I put the
|
||||
libraries + gc.h + the c++ interface-file in a folder that I then put into
|
||||
the MSL hierarchy so that I don't have to alter access-paths in projects
|
||||
that use the GC.
|
||||
|
||||
After that, just add the proper GC library to your project and the GC is in
|
||||
action! malloc will call GC_malloc and free GC_free, new/delete too. You
|
||||
don't have to call free or delete. You may have to be a bit cautious about
|
||||
delete if you're freeing other resources than RAM. See gc_cpp.h. You can
|
||||
also keep coding as always with delete/free. That works too. If you want,
|
||||
"include <gc.h> and tweak it's use a bit.
|
||||
|
||||
Symantec SPM
|
||||
============
|
||||
It has been a while since I tried the GC in SPM, but I think that the above
|
||||
instructions should be sufficient to guide you through in SPM too. SPM
|
||||
needs to know where the global data is. Use the files 'datastart.c' and
|
||||
'dataend.c'. Put 'datastart.c' at the top of your project and 'dataend.c'
|
||||
at the bottom of your project so that all data is surrounded. This is not
|
||||
needed in Codewarrior because it provides intrinsic variables
|
||||
__datastart__, __data_end__ that wraps all globals.
|
||||
|
||||
Source Changes (GC 4.12a2)
|
||||
==========================
|
||||
Very few. Just one tiny in the GC, not strictly needed.
|
||||
- MacOS.c line 131 in routine GC_MacFreeTemporaryMemory()
|
||||
change # if !defined(SHARED_LIBRARY_BUILD)
|
||||
to # if !defined(SILENT) && !defined(SHARED_LIBRARY_BUILD)
|
||||
To turn off a message when the application quits (actually, I faked
|
||||
this change by #defining SHARED_LIBRARY_BUILD in a statically linked
|
||||
library for more than a year without ill effects but perhaps this is
|
||||
better).
|
||||
|
||||
- test_cpp.cc
|
||||
made the first lines of main() look like this:
|
||||
------------
|
||||
int main( int argc, char* argv[] ) {
|
||||
#endif
|
||||
#if macintosh // MacOS
|
||||
char* argv_[] = {"test_cpp","10"}; // doesn't
|
||||
argv=argv_; // have a
|
||||
argc = sizeof(argv_)/sizeof(argv_[0]); // commandline
|
||||
#endif //
|
||||
|
||||
int i, iters, n;
|
||||
# ifndef __GNUC__
|
||||
alloc dummy_to_fool_the_compiler_into_doing_things_it_currently_cant_handle;
|
||||
------------
|
||||
|
||||
- config.h [now gcconfig.h]
|
||||
__MWERKS__ does not have to mean MACOS. You can use Codewarrior to
|
||||
build a Win32 or BeOS library and soon a Rhapsody library. You may
|
||||
have to change that #if...
|
||||
|
||||
|
||||
|
||||
It worked for me, hope it works for you.
|
||||
|
||||
Lars Farm
|
||||
18 July 1997
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
|
||||
Patrick Beard's instructions (may be dated):
|
||||
|
||||
v4.3 of the collector now runs under Symantec C++/THINK C v7.0.4, and
|
||||
Metrowerks C/C++ v4.5 both 68K and PowerPC. Project files are provided
|
||||
to build and test the collector under both development systems.
|
||||
|
||||
Configuration
|
||||
-------------
|
||||
|
||||
To configure the collector, under both development systems, a prefix file
|
||||
is used to set preprocessor directives. This file is called "MacOS_config.h".
|
||||
Also to test the collector, "MacOS_Test_config.h" is provided.
|
||||
|
||||
Testing
|
||||
-------
|
||||
|
||||
To test the collector (always a good idea), build one of the gctest projects,
|
||||
gctest.¹ (Symantec C++/THINK C), mw/gctest.68K.¹, or mw/gctest.PPC.¹. The
|
||||
test will ask you how many times to run; 1 should be sufficient.
|
||||
|
||||
Building
|
||||
--------
|
||||
|
||||
For your convenience project files for the major Macintosh development
|
||||
systems are provided.
|
||||
|
||||
For Symantec C++/THINK C, you must build the two projects gclib-1.¹ and
|
||||
gclib-2.¹. It has to be split up because the collector has more than 32k
|
||||
of static data and no library can have more than this in the Symantec
|
||||
environment. (Future versions will probably fix this.)
|
||||
|
||||
For Metrowerks C/C++ 4.5 you build gc.68K.¹/gc.PPC.¹ and the result will
|
||||
be a library called gc.68K.lib/gc.PPC.lib.
|
||||
|
||||
Using
|
||||
-----
|
||||
|
||||
Under Symantec C++/THINK C, you can just add the gclib-1.¹ and gclib-2.¹
|
||||
projects to your own project. Under Metrowerks, you add gc.68K.lib or
|
||||
gc.PPC.lib and two additional files. You add the files called datastart.c
|
||||
and dataend.c to your project, bracketing all files that use the collector.
|
||||
See mw/gctest.¹ for an example.
|
||||
|
||||
Include the projects/libraries you built above into your own project,
|
||||
#include "gc.h", and call GC_malloc. You don't have to call GC_free.
|
||||
|
||||
|
||||
Patrick C. Beard
|
||||
January 4, 1995
|
||||
@@ -1,27 +0,0 @@
|
||||
While the GC should work on MacOS X Server, MacOS X and Darwin, I only tested
|
||||
it on MacOS X Server.
|
||||
I've added a PPC assembly version of GC_push_regs(), thus the setjmp() hack is
|
||||
no longer necessary. Incremental collection is supported via mprotect/signal.
|
||||
The current solution isn't really optimal because the signal handler must decode
|
||||
the faulting PPC machine instruction in order to find the correct heap address.
|
||||
Further, it must poke around in the register state which the kernel saved away
|
||||
in some obscure register state structure before it calls the signal handler -
|
||||
needless to say the layout of this structure is no where documented.
|
||||
Threads and dynamic libraries are not yet supported (adding dynamic library
|
||||
support via the low-level dyld API shouldn't be that hard).
|
||||
|
||||
The original MacOS X port was brought to you by Andrew Stone.
|
||||
|
||||
|
||||
June, 1 2000
|
||||
|
||||
Dietmar Planitzer
|
||||
dave.pl@ping.at
|
||||
|
||||
Note from Andrew Begel:
|
||||
|
||||
One more fix to enable gc.a to link successfully into a shared library for
|
||||
MacOS X. You have to add -fno-common to the CFLAGS in the Makefile. MacOSX
|
||||
disallows common symbols in anything that eventually finds its way into a
|
||||
shared library. (I don't completely understand why, but -fno-common seems to
|
||||
work and doesn't mess up the garbage collector's functionality).
|
||||
@@ -1,6 +0,0 @@
|
||||
The code assumes static linking, and a single thread. The editor de has
|
||||
not been ported. The cord test program has. The supplied OS2_MAKEFILE
|
||||
assumes the IBM C Set/2 environment, but the code shouldn't.
|
||||
|
||||
Since we haven't figured out hoe to do perform partial links or to build static
|
||||
libraries, clients currently need to link against a long list of executables.
|
||||
@@ -1,322 +0,0 @@
|
||||
===========================================================================
|
||||
Kjetil S. Matheussen's notes (28-11-2000)
|
||||
===========================================================================
|
||||
Compiles under SAS/C again. Should allso still compile under other
|
||||
amiga compilers without big changes. I haven't checked if it still
|
||||
works under gcc, because I don't have gcc for amiga. But I have
|
||||
updated 'Makefile', and hope it compiles fine.
|
||||
|
||||
|
||||
WHATS NEW:
|
||||
|
||||
1.
|
||||
Made a pretty big effort in preventing GCs allocating-functions from returning
|
||||
chip-mem.
|
||||
|
||||
The lower part of the new file AmigaOS.c does this in various ways, mainly by
|
||||
wrapping GC_malloc, GC_malloc_atomic, GC_malloc_uncollectable,
|
||||
GC_malloc_atomic_uncollectable, GC_malloc_stubborn, GC_malloc_ignore_off_page
|
||||
and GC_malloc_atomic_ignore_off_page. GC_realloc is allso wrapped, but
|
||||
doesn't do the same effort in preventing to return chip-mem.
|
||||
Other allocating-functions (f.ex. GC_*_typed_) can probably be
|
||||
used without any problems, but beware that the warn hook will not be called.
|
||||
In case of problems, don't define GC_AMIGA_FASTALLOC.
|
||||
|
||||
Programs using more time actually using the memory allocated
|
||||
(instead of just allocate and free rapidly) have
|
||||
the most to earn on this, but even gctest now normally runs twice
|
||||
as fast and uses less memory, on my poor 8MB machine.
|
||||
|
||||
The changes have only effect when there is no more
|
||||
fast-mem left. But with the way GC works, it
|
||||
could happen quite often. Beware that an atexit handler had to be added,
|
||||
so using the abort() function will make a big memory-loss.
|
||||
If you absolutely must call abort() instead of exit(), try calling
|
||||
the GC_amiga_free_all_mem function before abort().
|
||||
|
||||
New amiga-spesific compilation flags:
|
||||
|
||||
GC_AMIGA_FASTALLOC - By NOT defining this option, GC will work like before,
|
||||
it will not try to force fast-mem out of the OS, and
|
||||
it will use normal calloc for allocation, and the rest
|
||||
of the following flags will have no effect.
|
||||
|
||||
GC_AMIGA_ONLYFAST - Makes GC never to return chip-mem. GC_AMIGA_RETRY have
|
||||
no effect if this flag is set.
|
||||
|
||||
GC_AMIGA_GC - If gc returns NULL, do a GC_gcollect, and try again. This
|
||||
usually is a success with the standard GC configuration.
|
||||
It is allso the most important flag to set to prevent
|
||||
GC from returning chip-mem. Beware that it slows down a lot
|
||||
when a program is rapidly allocating/deallocating when
|
||||
theres either very little fast-memory left or verly little
|
||||
chip-memory left. Its not a very common situation, but gctest
|
||||
sometimes (very rare) use many minutes because of this.
|
||||
|
||||
GC_AMIGA_RETRY - If gc succeed allocating memory, but it is chip-mem,
|
||||
try again and see if it is fast-mem. Most of the time,
|
||||
it will actually return fast-mem for the second try.
|
||||
I have set max number of retries to 9 or size/5000. You
|
||||
can change this if you like. (see GC_amiga_rec_alloc())
|
||||
|
||||
GC_AMIGA_PRINTSTATS - Gather some statistics during the execution of a
|
||||
program, and prints out the info when the atexit-handler
|
||||
is called.
|
||||
|
||||
My reccomendation is to set all this flags, except GC_AMIGA_PRINTSTATS and
|
||||
GC_AMIGA_ONLYFAST.
|
||||
|
||||
If your program demands high response-time, you should
|
||||
not define GC_AMIGA_GC, and possible allso define GC_AMIGA_ONLYFAST.
|
||||
GC_AMIGA_RETRY does not seem to slow down much.
|
||||
|
||||
Allso, when compiling up programs, and GC_AMIGA_FASTALLOC was not defined when
|
||||
compilling gc, you can define GC_AMIGA_MAKINGLIB to avoid having these allocation-
|
||||
functions wrapped. (see gc.h)
|
||||
|
||||
Note that GC_realloc must not be called before any of
|
||||
the other above mentioned allocating-functions have been called. (shouldn't be
|
||||
any programs doing so either, I hope).
|
||||
|
||||
Another note. The allocation-function is wrapped when defining
|
||||
GC_AMIGA_FASTALLOC by letting the function go thru the new
|
||||
GC_amiga_allocwrapper_do function-pointer (see gc.h). Means that
|
||||
sending function-pointers, such as GC_malloc, GC_malloc_atomic, etc.,
|
||||
for later to be called like f.ex this, (*GC_malloc_functionpointer)(size),
|
||||
will not wrap the function. This is normally not a big problem, unless
|
||||
all allocation function is called like this, which will cause the
|
||||
atexit un-allocating function never to be called. Then you either
|
||||
have to manually add the atexit handler, or call the allocation-
|
||||
functions function-pointer functions like this;
|
||||
(*GC_amiga_allocwrapper_do)(size,GC_malloc_functionpointer).
|
||||
There are probably better ways this problem could be handled, unfortunately,
|
||||
I didn't find any without rewriting or replacing a lot of the GC-code, which
|
||||
I really didn't want to. (Making new GC_malloc_* functions, and just
|
||||
define f.ex GC_malloc as GC_amiga_malloc should allso work).
|
||||
|
||||
|
||||
New amiga-spesific function:
|
||||
|
||||
void GC_amiga_set_toany(void (*func)(void));
|
||||
|
||||
'func' is a function that will be called right before gc has to change
|
||||
allocation-method from MEMF_FAST to MEMF_ANY. Ie. when it is likely
|
||||
it will return chip-mem.
|
||||
|
||||
|
||||
2. A few small compiler-spesific additions to make it compile with SAS/C again.
|
||||
|
||||
3. Updated and rewritten the smakefile, so that it works again and that
|
||||
the "unnecesarry" 'SCOPTIONS' files could be removed. Allso included
|
||||
the cord-smakefile stuff in the main smakefile, so that the cord smakefile
|
||||
could be removed too. By writing smake -f Smakefile.smk, both gc.lib and
|
||||
cord.lib will be made.
|
||||
|
||||
|
||||
|
||||
STILL MISSING:
|
||||
|
||||
Programs can not be started from workbench, at least not for SAS/C. (Martin
|
||||
Tauchmanns note about that it now works with workbench is definitely wrong
|
||||
when concerning SAS/C). I guess it works if you use the old "#if 0'ed"-code,
|
||||
but I haven't tested it. I think the reason for MT to replace the
|
||||
"#if 0'ed"-code was only because it was a bit to SAS/C-spesific. But I
|
||||
don't know. An iconx-script solves this problem anyway.
|
||||
|
||||
|
||||
BEWARE!
|
||||
|
||||
-To run gctest, set the stack to around 200000 bytes first.
|
||||
-SAS/C-spesific: cord will crash if you compile gc.lib with
|
||||
either parm=reg or parm=both. (missing legal prototypes for
|
||||
function-pointers someplace is the reason I guess.).
|
||||
|
||||
|
||||
tested with software: Radium, http://www.stud.ifi.uio.no/~ksvalast/radium/
|
||||
|
||||
tested with hardware: MC68060
|
||||
|
||||
|
||||
-ksvalast@ifi.uio.no
|
||||
|
||||
|
||||
===========================================================================
|
||||
Martin Tauchmann's notes (1-Apr-99)
|
||||
===========================================================================
|
||||
|
||||
Works now, also with the GNU-C compiler V2.7.2.1. <ftp://ftp.unina.it/pub/amiga/geekgadgets/amiga/m68k/snapshots/971125/amiga-bin/>
|
||||
Modify the `Makefile`
|
||||
CC=cc $(ABI_FLAG)
|
||||
to
|
||||
CC=gcc $(ABI_FLAG)
|
||||
|
||||
TECHNICAL NOTES
|
||||
|
||||
- `GC_get_stack_base()`, `GC_register_data_segments()` works now with every
|
||||
C compiler; also Workbench.
|
||||
|
||||
- Removed AMIGA_SKIP_SEG, but the Code-Segment must not be scanned by GC.
|
||||
|
||||
|
||||
PROBLEMS
|
||||
- When the Linker, does`t merge all Code-Segments to an single one. LD of GCC
|
||||
do it always.
|
||||
|
||||
- With ixemul.library V47.3, when an GC program launched from another program
|
||||
(example: `Make` or `if_mach M68K AMIGA gctest`), `GC_register_data_segments()`
|
||||
found the Segment-List of the caller program.
|
||||
Can be fixed, if the run-time initialization code (for C programs, usually *crt0*)
|
||||
support `__data` and `__bss`.
|
||||
|
||||
- PowerPC Amiga currently not supported.
|
||||
|
||||
- Dynamic libraries (dyn_load.c) not supported.
|
||||
|
||||
|
||||
TESTED WITH SOFTWARE
|
||||
|
||||
`Optimized Oberon 2 C` (oo2c) <http://cognac.informatik.uni-kl.de/download/index.html>
|
||||
|
||||
|
||||
TESTED WITH HARDWARE
|
||||
|
||||
MC68030
|
||||
|
||||
|
||||
CONTACT
|
||||
|
||||
Please, contact me at <martintauchmann@bigfoot.com>, when you change the
|
||||
Amiga port. <http://martintauchmann.home.pages.de>
|
||||
|
||||
===========================================================================
|
||||
Michel Schinz's notes
|
||||
===========================================================================
|
||||
WHO DID WHAT
|
||||
|
||||
The original Amiga port was made by Jesper Peterson. I (Michel Schinz)
|
||||
modified it slightly to reflect the changes made in the new official
|
||||
distributions, and to take advantage of the new SAS/C 6.x features. I also
|
||||
created a makefile to compile the "cord" package (see the cord
|
||||
subdirectory).
|
||||
|
||||
TECHNICAL NOTES
|
||||
|
||||
In addition to Jesper's notes, I have the following to say:
|
||||
|
||||
- Starting with version 4.3, gctest checks to see if the code segment is
|
||||
added to the root set or not, and complains if it is. Previous versions
|
||||
of this Amiga port added the code segment to the root set, so I tried to
|
||||
fix that. The only problem is that, as far as I know, it is impossible to
|
||||
know which segments are code segments and which are data segments (there
|
||||
are indeed solutions to this problem, like scanning the program on disk
|
||||
or patch the LoadSeg functions, but they are rather complicated). The
|
||||
solution I have chosen (see os_dep.c) is to test whether the program
|
||||
counter is in the segment we are about to add to the root set, and if it
|
||||
is, to skip the segment. The problems are that this solution is rather
|
||||
awkward and that it works only for one code segment. This means that if
|
||||
your program has more than one code segment, all of them but one will be
|
||||
added to the root set. This isn't a big problem in fact, since the
|
||||
collector will continue to work correctly, but it may be slower.
|
||||
|
||||
Anyway, the code which decides whether to skip a segment or not can be
|
||||
removed simply by not defining AMIGA_SKIP_SEG. But notice that if you do
|
||||
so, gctest will complain (it will say that "GC_is_visible produced wrong
|
||||
failure indication"). However, it may be useful if you happen to have
|
||||
pointers stored in a code segment (you really shouldn't).
|
||||
|
||||
If anyone has a good solution to the problem of finding, when a program
|
||||
is loaded in memory, whether a segment is a code or a data segment,
|
||||
please let me know.
|
||||
|
||||
PROBLEMS
|
||||
|
||||
If you have any problem with this version, please contact me at
|
||||
schinz@alphanet.ch (but do *not* send long files, since we pay for
|
||||
every mail!).
|
||||
|
||||
===========================================================================
|
||||
Jesper Peterson's notes
|
||||
===========================================================================
|
||||
|
||||
ADDITIONAL NOTES FOR AMIGA PORT
|
||||
|
||||
These notes assume some familiarity with Amiga internals.
|
||||
|
||||
WHY I PORTED TO THE AMIGA
|
||||
|
||||
The sole reason why I made this port was as a first step in getting
|
||||
the Sather(*) language on the Amiga. A port of this language will
|
||||
be done as soon as the Sather 1.0 sources are made available to me.
|
||||
Given this motivation, the garbage collection (GC) port is rather
|
||||
minimal.
|
||||
|
||||
(*) For information on Sather read the comp.lang.sather newsgroup.
|
||||
|
||||
LIMITATIONS
|
||||
|
||||
This port assumes that the startup code linked with target programs
|
||||
is that supplied with SAS/C versions 6.0 or later. This allows
|
||||
assumptions to be made about where to find the stack base pointer
|
||||
and data segments when programs are run from WorkBench, as opposed
|
||||
to running from the CLI. The compiler dependent code is all in the
|
||||
GC_get_stack_base() and GC_register_data_segments() functions, but
|
||||
may spread as I add Amiga specific features.
|
||||
|
||||
Given that SAS/C was assumed, the port is set up to be built with
|
||||
"smake" using the "SMakefile". Compiler options in "SCoptions" can
|
||||
be set with "scopts" program. Both "smake" and "scopts" are part of
|
||||
the SAS/C commercial development system.
|
||||
|
||||
In keeping with the porting philosophy outlined above, this port
|
||||
will not behave well with Amiga specific code. Especially not inter-
|
||||
process comms via messages, and setting up public structures like
|
||||
Intuition objects or anything else in the system lists. For the
|
||||
time being the use of this library is limited to single threaded
|
||||
ANSI/POSIX compliant or near-complient code. (ie. Stick to stdio
|
||||
for now). Given this limitation there is currently no mechanism for
|
||||
allocating "CHIP" or "PUBLIC" memory under the garbage collector.
|
||||
I'll add this after giving it considerable thought. The major
|
||||
problem is the entire physical address space may have to me scanned,
|
||||
since there is no telling who we may have passed memory to.
|
||||
|
||||
If you allocate your own stack in client code, you will have to
|
||||
assign the pointer plus stack size to GC_stackbottom.
|
||||
|
||||
The initial stack size of the target program can be compiled in by
|
||||
setting the __stack symbol (see SAS documentaion). It can be over-
|
||||
ridden from the CLI by running the AmigaDOS "stack" program, or from
|
||||
the WorkBench by setting the stack size in the tool types window.
|
||||
|
||||
SAS/C COMPILER OPTIONS (SCoptions)
|
||||
|
||||
You may wish to check the "CPU" code option is appropriate for your
|
||||
intended target system.
|
||||
|
||||
Under no circumstances set the "StackExtend" code option in either
|
||||
compiling the library or *ANY* client code.
|
||||
|
||||
All benign compiler warnings have been suppressed. These mainly
|
||||
involve lack of prototypes in the code, and dead assignments
|
||||
detected by the optimizer.
|
||||
|
||||
THE GOOD NEWS
|
||||
|
||||
The library as it stands is compatible with the GigaMem commercial
|
||||
virtual memory software, and probably similar PD software.
|
||||
|
||||
The performance of "gctest" on an Amiga 2630 (68030 @ 25Mhz)
|
||||
compares favourably with an HP9000 with similar architecture (a 325
|
||||
with a 68030 I think).
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
|
||||
The Amiga port has been brought to you by:
|
||||
|
||||
Jesper Peterson.
|
||||
|
||||
jep@mtiame.mtia.oz.au (preferred, but 1 week turnaround)
|
||||
jep@orca1.vic.design.telecom.au (that's orca<one>, 1 day turnaround)
|
||||
|
||||
At least one of these addresses should be around for a while, even
|
||||
though I don't work for either of the companies involved.
|
||||
|
||||
@@ -1,59 +0,0 @@
|
||||
As of GC6.0alpha8, we attempt to support GNU-style builds based on automake,
|
||||
autoconf and libtool. This is based almost entirely on Tom Tromey's work
|
||||
with gcj.
|
||||
|
||||
To build and install libraries use
|
||||
|
||||
configure; make; make install
|
||||
|
||||
The advantages of this process are:
|
||||
|
||||
1) It should eventually do a better job of automatically determining the
|
||||
right compiler to use, etc. It probably already does in some cases.
|
||||
|
||||
2) It tries to automatically set a good set of default GC parameters for
|
||||
the platform (e.g. thread support). It provides an easier way to configure
|
||||
some of the others.
|
||||
|
||||
3) It integrates better with other projects using a GNU-style build process.
|
||||
|
||||
4) It builds both dynamic and static libraries.
|
||||
|
||||
The known disadvantages are:
|
||||
|
||||
1) The build scripts are much more complex and harder to debug (though largely
|
||||
standard). I don't understand them all, and there's probably lots of redundant
|
||||
stuff.
|
||||
|
||||
2) It probably doesn't work on all Un*x-like platforms yet. It probably will
|
||||
never work on the rest.
|
||||
|
||||
3) The scripts are not yet complete. Some of the standard GNU targets don't
|
||||
yet work. (Corrections/additions are very welcome.)
|
||||
|
||||
The distribution should contain all files needed to run "configure" and "make",
|
||||
as well as the sources needed to regenerate the derived files. (If I missed
|
||||
some, please let me know.)
|
||||
|
||||
Note that the distribution comes with a "Makefile" which will be overwritten
|
||||
by "configure" with one that is not at all equiavelent to the original. The
|
||||
distribution contains a copy of the original "Makefile" in "Makefile.direct".
|
||||
|
||||
Important options to configure:
|
||||
|
||||
--prefix=PREFIX install architecture-independent files in PREFIX
|
||||
[/usr/local]
|
||||
--exec-prefix=EPREFIX install architecture-dependent files in EPREFIX
|
||||
[same as prefix]
|
||||
--enable-threads=TYPE choose threading package
|
||||
--enable-parallel-mark parallelize marking and free list construction
|
||||
--enable-full-debug include full support for pointer backtracing etc.
|
||||
|
||||
Unless --prefix is set (or --exec-prefix or one of the more obscure options),
|
||||
make install will install libgc.a and libgc.so in /usr/local/bin, which
|
||||
would typically require the "make install" to be run as root.
|
||||
|
||||
Most commonly --enable-threads=posix or will be needed. --enable-parallel-mark
|
||||
is recommended for multiprocessors if it is supported on the platform.
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,57 +0,0 @@
|
||||
This is an attempt to acknowledge early contributions to the garbage
|
||||
collector. Later contributions should instead be mentioned in
|
||||
README.changes.
|
||||
|
||||
HISTORY -
|
||||
|
||||
Early versions of this collector were developed as a part of research
|
||||
projects supported in part by the National Science Foundation
|
||||
and the Defense Advance Research Projects Agency.
|
||||
|
||||
The garbage collector originated as part of the run-time system for
|
||||
the Russell programming language implementation. The first version of the
|
||||
garbage collector was written primarily by Al Demers. It was then refined
|
||||
and mostly rewritten, primarily by Hans-J. Boehm, at Cornell U.,
|
||||
the University of Washington, Rice University (where it was first used for
|
||||
C and assembly code), Xerox PARC, SGI, and HP Labs. However, significant
|
||||
contributions have also been made by many others.
|
||||
|
||||
Some other contributors:
|
||||
|
||||
More recent contributors are mentioned in the modification history in
|
||||
README.changes. My apologies for any omissions.
|
||||
|
||||
The SPARC specific code was originally contributed by Mark Weiser.
|
||||
The Encore Multimax modifications were supplied by
|
||||
Kevin Kenny (kenny@m.cs.uiuc.edu). The adaptation to the IBM PC/RT is largely
|
||||
due to Vernon Lee, on machines made available to Rice by IBM.
|
||||
Much of the HP specific code and a number of good suggestions for improving the
|
||||
generic code are due to Walter Underwood.
|
||||
Robert Brazile (brazile@diamond.bbn.com) originally supplied the ULTRIX code.
|
||||
Al Dosser (dosser@src.dec.com) and Regis Cridlig (Regis.Cridlig@cl.cam.ac.uk)
|
||||
subsequently provided updates and information on variation between ULTRIX
|
||||
systems. Parag Patel (parag@netcom.com) supplied the A/UX code.
|
||||
Jesper Peterson(jep@mtiame.mtia.oz.au), Michel Schinz, and
|
||||
Martin Tauchmann (martintauchmann@bigfoot.com) supplied the Amiga port.
|
||||
Thomas Funke (thf@zelator.in-berlin.de(?)) and
|
||||
Brian D.Carlstrom (bdc@clark.lcs.mit.edu) supplied the NeXT ports.
|
||||
Douglas Steel (doug@wg.icl.co.uk) provided ICL DRS6000 code.
|
||||
Bill Janssen (janssen@parc.xerox.com) supplied the SunOS dynamic loader
|
||||
specific code. Manuel Serrano (serrano@cornas.inria.fr) supplied linux and
|
||||
Sony News specific code. Al Dosser provided Alpha/OSF/1 code. He and
|
||||
Dave Detlefs(detlefs@src.dec.com) also provided several generic bug fixes.
|
||||
Alistair G. Crooks(agc@uts.amdahl.com) supplied the NetBSD and 386BSD ports.
|
||||
Jeffrey Hsu (hsu@soda.berkeley.edu) provided the FreeBSD port.
|
||||
Brent Benson (brent@jade.ssd.csd.harris.com) ported the collector to
|
||||
a Motorola 88K processor running CX/UX (Harris NightHawk).
|
||||
Ari Huttunen (Ari.Huttunen@hut.fi) generalized the OS/2 port to
|
||||
nonIBM development environments (a nontrivial task).
|
||||
Patrick Beard (beard@cs.ucdavis.edu) provided the initial MacOS port.
|
||||
David Chase, then at Olivetti Research, suggested several improvements.
|
||||
Scott Schwartz (schwartz@groucho.cse.psu.edu) supplied some of the
|
||||
code to save and print call stacks for leak detection on a SPARC.
|
||||
Jesse Hull and John Ellis supplied the C++ interface code.
|
||||
Zhong Shao performed much of the experimentation that led to the
|
||||
current typed allocation facility. (His dynamic type inference code hasn't
|
||||
made it into the released version of the collector, yet.)
|
||||
|
||||
@@ -1,53 +0,0 @@
|
||||
Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved.
|
||||
|
||||
THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
|
||||
Permission is hereby granted to use or copy this program
|
||||
for any purpose, provided the above notices are retained on all copies.
|
||||
Permission to modify the code and to distribute modified code is granted,
|
||||
provided the above notices are retained, and a notice that the code was
|
||||
modified is included with the above copyright notice.
|
||||
|
||||
Please send bug reports to Hans-J. Boehm (Hans_Boehm@hp.com or
|
||||
boehm@acm.org).
|
||||
|
||||
This is a string packages that uses a tree-based representation.
|
||||
See cord.h for a description of the functions provided. Ec.h describes
|
||||
"extensible cords", which are essentially output streams that write
|
||||
to a cord. These allow for efficient construction of cords without
|
||||
requiring a bound on the size of a cord.
|
||||
|
||||
More details on the data structure can be found in
|
||||
|
||||
Boehm, Atkinson, and Plass, "Ropes: An Alternative to Strings",
|
||||
Software Practice and Experience 25, 12, December 1995, pp. 1315-1330.
|
||||
|
||||
A fundamentally similar "rope" data structure is also part of SGI's standard
|
||||
template library implementation, and its descendents, which include the
|
||||
GNU C++ library. That uses reference counting by default.
|
||||
There is a short description of that data structure at
|
||||
http://reality.sgi.com/boehm/ropeimpl.html . (The more official location
|
||||
http://www.sgi.com/tech/stl/ropeimpl.html is missing a figure.)
|
||||
|
||||
All of these are descendents of the "ropes" in Xerox Cedar.
|
||||
|
||||
de.c is a very dumb text editor that illustrates the use of cords.
|
||||
It maintains a list of file versions. Each version is simply a
|
||||
cord representing the file contents. Nonetheless, standard
|
||||
editing operations are efficient, even on very large files.
|
||||
(Its 3 line "user manual" can be obtained by invoking it without
|
||||
arguments. Note that ^R^N and ^R^P move the cursor by
|
||||
almost a screen. It does not understand tabs, which will show
|
||||
up as highlighred "I"s. Use the UNIX "expand" program first.)
|
||||
To build the editor, type "make cord/de" in the gc directory.
|
||||
|
||||
This package assumes an ANSI C compiler such as gcc. It will
|
||||
not compile with an old-style K&R compiler.
|
||||
|
||||
Note that CORD_printf iand friends use C functions with variable numbers
|
||||
of arguments in non-standard-conforming ways. This code is known to
|
||||
break on some platforms, notably PowerPC. It should be possible to
|
||||
build the remainder of the library (everything but cordprnt.c) on
|
||||
any platform that supports the collector.
|
||||
|
||||
@@ -1,12 +0,0 @@
|
||||
[Original version supplied by Xiaokun Zhu <xiaokun@aero.gla.ac.uk>]
|
||||
[This version came mostly from Gary Leavens. ]
|
||||
|
||||
Look first at Makefile.dj, and possibly change the definitions of
|
||||
RM and MV if you don't have rm and mv installed.
|
||||
Then use Makefile.dj to compile the garbage collector.
|
||||
For example, you can do:
|
||||
|
||||
make -f Makefile.dj test
|
||||
|
||||
All the tests should work fine.
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
The garbage collector looks at a number of environment variables which are
|
||||
the used to affect its operation. These are examined only on Un*x-like
|
||||
platforms.
|
||||
|
||||
GC_INITIAL_HEAP_SIZE=<bytes> - Initial heap size in bytes. May speed up
|
||||
process start-up.
|
||||
|
||||
GC_LOOP_ON_ABORT - Causes the collector abort routine to enter a tight loop.
|
||||
This may make it easier to debug, such a process, especially
|
||||
for multithreaded platforms that don't produce usable core
|
||||
files, or if a core file would be too large. On some
|
||||
platforms, this also causes SIGSEGV to be caught and
|
||||
result in an infinite loop in a handler, allowing
|
||||
similar debugging techniques.
|
||||
|
||||
GC_PRINT_STATS - Turn on as much logging as is easily feasible without
|
||||
adding signifcant runtime overhead. Doesn't work if
|
||||
the collector is built with SMALL_CONFIG. Overridden
|
||||
by setting GC_quiet. On by default if the collector
|
||||
was built without -DSILENT.
|
||||
|
||||
GC_PRINT_ADDRESS_MAP - Linux only. Dump /proc/self/maps, i.e. various address
|
||||
maps for the process, to stderr on every GC. Useful for
|
||||
mapping root addresses to source for deciphering leak
|
||||
reports.
|
||||
|
||||
GC_NPROCS=<n> - Linux w/threads only. Explicitly sets the number of processors
|
||||
that the GC should expect to use. Note that setting this to 1
|
||||
when multiple processors are available will preserve
|
||||
correctness, but may lead to really horrible performance.
|
||||
|
||||
GC_NO_BLACKLIST_WARNING - Prevents the collector from issuing
|
||||
"Needed to allocate blacklisted block at ..." warnings.
|
||||
|
||||
The following turn on runtime flags that are also program settable. Checked
|
||||
only during initialization. We expect that they will usually be set through
|
||||
other means, but this may help with debugging and testing:
|
||||
|
||||
GC_FIND_LEAK - Turns on GC_find_leak and thus leak detection.
|
||||
|
||||
GC_ALL_INTERIOR_POINTERS - Turns on GC_all_interior_pointers and thus interior
|
||||
pointer recognition.
|
||||
|
||||
GC_DONT_GC - Turns off garbage collection. Use cautiously.
|
||||
@@ -1,18 +0,0 @@
|
||||
Dynamic loading support requires that executables be linked with -ldld.
|
||||
The alternative is to build the collector without defining DYNAMIC_LOADING
|
||||
in gcconfig.h and ensuring that all garbage collectable objects are
|
||||
accessible without considering statically allocated variables in dynamic
|
||||
libraries.
|
||||
|
||||
The collector should compile with either plain cc or cc -Ae. Cc -Aa
|
||||
fails to define _HPUX_SOURCE and thus will not configure the collector
|
||||
correctly.
|
||||
|
||||
Incremental collection support was reccently added, and should now work.
|
||||
|
||||
In spite of past claims, pthread support under HP/UX 11 should now work.
|
||||
Define GC_HPUX_THREADS for the build. Incremental collection still does not
|
||||
work in combination with it.
|
||||
|
||||
The stack finding code can be confused by putenv calls before collector
|
||||
initialization. Call GC_malloc or GC_init before any putenv calls.
|
||||
@@ -1,135 +0,0 @@
|
||||
See README.alpha for Linux on DEC AXP info.
|
||||
|
||||
This file applies mostly to Linux/Intel IA32. Ports to Linux on an M68K
|
||||
and PowerPC are also integrated. They should behave similarly, except that
|
||||
the PowerPC port lacks incremental GC support, and it is unknown to what
|
||||
extent the Linux threads code is functional. See below for M68K specific
|
||||
notes.
|
||||
|
||||
Incremental GC is supported on Intel IA32 and M68K.
|
||||
|
||||
Dynamic libraries are supported on an ELF system. A static executable
|
||||
should be linked with the gcc option "-Wl,-defsym,_DYNAMIC=0".
|
||||
|
||||
The collector appears to work with Linux threads. We have seen
|
||||
intermittent hangs in sem_wait. So far we have been unable to reproduce
|
||||
these unless the process was being debugged or traced. Thus it's
|
||||
possible that the only real issue is that the debugger loses
|
||||
signals on rare occasions.
|
||||
|
||||
The garbage collector uses SIGPWR and SIGXCPU if it is used with
|
||||
Linux threads. These should not be touched by the client program.
|
||||
|
||||
To use threads, you need to abide by the following requirements:
|
||||
|
||||
1) You need to use LinuxThreads (which are included in libc6).
|
||||
|
||||
The collector relies on some implementation details of the LinuxThreads
|
||||
package. It is unlikely that this code will work on other
|
||||
pthread implementations (in particular it will *not* work with
|
||||
MIT pthreads).
|
||||
|
||||
2) You must compile the collector with -DGC_LINUX_THREADS and -D_REENTRANT
|
||||
specified in the Makefile.
|
||||
|
||||
3a) Every file that makes thread calls should define GC_LINUX_THREADS and
|
||||
_REENTRANT and then include gc.h. Gc.h redefines some of the
|
||||
pthread primitives as macros which also provide the collector with
|
||||
information it requires.
|
||||
|
||||
3b) A new alternative to (3a) is to build the collector and compile GC clients
|
||||
with -DGC_USE_LD_WRAP, and to link the final program with
|
||||
|
||||
(for ld) --wrap read --wrap dlopen --wrap pthread_create \
|
||||
--wrap pthread_join --wrap pthread_detach \
|
||||
--wrap pthread_sigmask --wrap sleep
|
||||
|
||||
(for gcc) -Wl,--wrap -Wl,read -Wl,--wrap -Wl,dlopen -Wl,--wrap \
|
||||
-Wl,pthread_create -Wl,--wrap -Wl,pthread_join -Wl,--wrap \
|
||||
-Wl,pthread_detach -Wl,--wrap -Wl,pthread_sigmask \
|
||||
-Wl,--wrap -Wl,sleep
|
||||
|
||||
In any case, _REENTRANT should be defined during compilation.
|
||||
|
||||
4) Dlopen() disables collection during its execution. (It can't run
|
||||
concurrently with the collector, since the collector looks at its
|
||||
data structures. It can't acquire the allocator lock, since arbitrary
|
||||
user startup code may run as part of dlopen().) Under unusual
|
||||
conditions, this may cause unexpected heap growth.
|
||||
|
||||
5) The combination of GC_LINUX_THREADS, REDIRECT_MALLOC, and incremental
|
||||
collection fails in seemingly random places. This hasn't been tracked
|
||||
down yet, but is perhaps not completely astonishing. The thread package
|
||||
uses malloc, and thus can presumably get SIGSEGVs while inside the
|
||||
package. There is no real guarantee that signals are handled properly
|
||||
at that point.
|
||||
|
||||
6) Thread local storage may not be viewed as part of the root set by the
|
||||
collector. This probably depends on the linuxthreads version. For the
|
||||
time being, any collectable memory referenced by thread local storage should
|
||||
also be referenced from elsewhere, or be allocated as uncollectable.
|
||||
(This is really a bug that should be fixed somehow.)
|
||||
|
||||
|
||||
M68K LINUX:
|
||||
(From Richard Zidlicky)
|
||||
The bad news is that it can crash every linux-m68k kernel on a 68040,
|
||||
so an additional test is needed somewhere on startup. I have meanwhile
|
||||
patches to correct the problem in 68040 buserror handler but it is not
|
||||
yet in any standard kernel.
|
||||
|
||||
Here is a simple test program to detect whether the kernel has the
|
||||
problem. It could be run as a separate check in configure or tested
|
||||
upon startup. If it fails (return !0) than mprotect can't be used
|
||||
on that system.
|
||||
|
||||
/*
|
||||
* test for bug that may crash 68040 based Linux
|
||||
*/
|
||||
|
||||
#include <sys/mman.h>
|
||||
#include <signal.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
|
||||
char *membase;
|
||||
int pagesize=4096;
|
||||
int pageshift=12;
|
||||
int x_taken=0;
|
||||
|
||||
int sighandler(int sig)
|
||||
{
|
||||
mprotect(membase,pagesize,PROT_READ|PROT_WRITE);
|
||||
x_taken=1;
|
||||
}
|
||||
|
||||
main()
|
||||
{
|
||||
long l;
|
||||
|
||||
signal(SIGSEGV,sighandler);
|
||||
l=(long)mmap(NULL,pagesize,PROT_READ,MAP_PRIVATE | MAP_ANON,-1,0);
|
||||
if (l==-1)
|
||||
{
|
||||
perror("mmap/malloc");
|
||||
abort();
|
||||
}
|
||||
membase=(char*)l;
|
||||
*(long*)(membase+sizeof(long))=123456789;
|
||||
if (*(long*)(membase+sizeof(long)) != 123456789 )
|
||||
{
|
||||
fprintf(stderr,"writeback failed !\n");
|
||||
exit(1);
|
||||
}
|
||||
if (!x_taken)
|
||||
{
|
||||
fprintf(stderr,"exception not taken !\n");
|
||||
exit(1);
|
||||
}
|
||||
fprintf(stderr,"vmtest Ok\n");
|
||||
exit(0);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,78 +0,0 @@
|
||||
The collector uses a large amount of conditional compilation in order to
|
||||
deal with platform dependencies. This violates a number of known coding
|
||||
standards. On the other hand, it seems to be the only practical way to
|
||||
support this many platforms without excessive code duplication.
|
||||
|
||||
A few guidelines have mostly been followed in order to keep this manageable:
|
||||
|
||||
1) #if and #ifdef directives are properly indented whenever easily possible.
|
||||
All known C compilers allow whitespace between the "#" and the "if" to make
|
||||
this possible. ANSI C also allows white space before the "#", though we
|
||||
avoid that. It has the known disadvantages that it differs from the normal
|
||||
GNU conventions, and that it makes patches larger than otherwise necessary.
|
||||
In my opinion, it's still well worth it, for the same reason that we indent
|
||||
ordinary "if" statements.
|
||||
|
||||
2) Whenever possible, tests are performed on the macros defined in gcconfig.h
|
||||
instead of directly testing patform-specific predefined macros. This makes it
|
||||
relatively easy to adapt to new compilers with a different set of predefined
|
||||
macros. Currently these macros generally identify platforms instead of
|
||||
features. In many cases, this is a mistake.
|
||||
|
||||
3) The code currently avoids #elif, eventhough that would make it more
|
||||
readable. This was done since #elif would need to be understood by ALL
|
||||
compilers used to build the collector, and that hasn't always been the case.
|
||||
It makes sense to reconsider this decision at some point, since #elif has been
|
||||
standardized at least since 1989.
|
||||
|
||||
Many of the tested configuration macros are at least somewhat defined in
|
||||
either include/private/gcconfig.h or in Makefile.direct. Here is an attempt
|
||||
at defining some of the remainder: (Thanks to Walter Bright for suggesting
|
||||
this. This is a work in progress)
|
||||
|
||||
MACRO EXPLANATION
|
||||
----- -----------
|
||||
|
||||
__DMC__ Always #define'd by the Digital Mars compiler. Expands
|
||||
to the compiler version number in hex, i.e. 0x810 is
|
||||
version 8.1b0
|
||||
|
||||
_ENABLE_ARRAYNEW
|
||||
#define'd by the Digital Mars C++ compiler when
|
||||
operator new[] and delete[] are separately
|
||||
overloadable. Used in gc_cpp.h.
|
||||
|
||||
_MSC_VER Expands to the Visual C++ compiler version. Assumed to
|
||||
not be defined for other compilers (at least if they behave
|
||||
appreciably differently).
|
||||
|
||||
_DLL Defined by Visual C++ if dynamic libraries are being built
|
||||
or used. Used to test whether __declspec(dllimport) or
|
||||
__declspec(dllexport) needs to be added to declarations
|
||||
to support the case in which the collector is in a dll.
|
||||
|
||||
GC_DLL User-settable macro that forces the effect of _DLL.
|
||||
|
||||
GC_NOT_DLL User-settable macro that overrides _DLL, e.g. if dynamic
|
||||
libraries are used, but the collector is in a static library.
|
||||
|
||||
__STDC__ Assumed to be defined only by compilers that understand
|
||||
prototypes and other C89 features. Its value is generally
|
||||
not used, since we are fine with most nonconforming extensions.
|
||||
|
||||
SUNOS5SIGS Solaris-like signal handling. This is probably misnamed,
|
||||
since it really doesn't guarantee much more than Posix.
|
||||
Currently set only for Solaris2.X, HPUX, and DRSNX. Should
|
||||
probably be set for some other platforms.
|
||||
|
||||
PCR Set if the collector is being built as part of the Xerox
|
||||
Portable Common Runtime.
|
||||
|
||||
SRC_M3 Set if the collector is being built as a replacement of the
|
||||
one in the DEC/Compaq SRC Modula-3 runtime. I suspect this
|
||||
was last used around 1994, and no doubt broke a long time ago.
|
||||
It's there primarily incase someone wants to port to a similar
|
||||
system.
|
||||
|
||||
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
We have so far failed to find a good way to determine the stack base.
|
||||
It is highly recommended that GC_stackbottom be set explicitly on program
|
||||
startup. The supplied value sometimes causes failure under AIX 4.1, though
|
||||
it appears to work under 3.X. HEURISTIC2 seems to work under 4.1, but
|
||||
involves a substantial performance penalty, and will fail if there is
|
||||
no limit on stack size.
|
||||
|
||||
There is no thread support. (I assume recent versions of AIX provide
|
||||
pthreads? I no longer have access to a machine ...)
|
||||
@@ -1,41 +0,0 @@
|
||||
Performance of the incremental collector can be greatly enhanced with
|
||||
-DNO_EXECUTE_PERMISSION.
|
||||
|
||||
The collector should run with all of the -32, -n32 and -64 ABIs. Remember to
|
||||
define the AS macro in the Makefile to be "as -64", or "as -n32".
|
||||
|
||||
If you use -DREDIRECT_MALLOC=GC_malloc with C++ code, your code should make
|
||||
at least one explicit call to malloc instead of new to ensure that the proper
|
||||
version of malloc is linked in.
|
||||
|
||||
Sproc threads are not supported in this version, though there may exist other
|
||||
ports.
|
||||
|
||||
Pthreads support is provided. This requires that:
|
||||
|
||||
1) You compile the collector with -DGC_IRIX_THREADS specified in the Makefile.
|
||||
|
||||
2) You have the latest pthreads patches installed.
|
||||
|
||||
(Though the collector makes only documented pthread calls,
|
||||
it relies on signal/threads interactions working just right in ways
|
||||
that are not required by the standard. It is unlikely that this code
|
||||
will run on other pthreads platforms. But please tell me if it does.)
|
||||
|
||||
3) Every file that makes thread calls should define IRIX_THREADS and then
|
||||
include gc.h. Gc.h redefines some of the pthread primitives as macros which
|
||||
also provide the collector with information it requires.
|
||||
|
||||
4) pthread_cond_wait and pthread_cond_timed_wait should be prepared for
|
||||
premature wakeups. (I believe the pthreads and realted standards require this
|
||||
anyway. Irix pthreads often terminate a wait if a signal arrives.
|
||||
The garbage collector uses signals to stop threads.)
|
||||
|
||||
5) It is expensive to stop a thread waiting in IO at the time the request is
|
||||
initiated. Applications with many such threads may not exhibit acceptable
|
||||
performance with the collector. (Increasing the heap size may help.)
|
||||
|
||||
6) The collector should not be compiled with -DREDIRECT_MALLOC. This
|
||||
confuses some library calls made by the pthreads implementation, which
|
||||
expect the standard malloc.
|
||||
|
||||
@@ -1,62 +0,0 @@
|
||||
The collector supports both incremental collection and threads under
|
||||
Solaris 2. The incremental collector normally retrieves page dirty information
|
||||
through the appropriate /proc calls. But it can also be configured
|
||||
(by defining MPROTECT_VDB instead of PROC_VDB in gcconfig.h) to use mprotect
|
||||
and signals. This may result in shorter pause times, but it is no longer
|
||||
safe to issue arbitrary system calls that write to the heap.
|
||||
|
||||
Under other UNIX versions,
|
||||
the collector normally obtains memory through sbrk. There is some reason
|
||||
to expect that this is not safe if the client program also calls the system
|
||||
malloc, or especially realloc. The sbrk man page strongly suggests this is
|
||||
not safe: "Many library routines use malloc() internally, so use brk()
|
||||
and sbrk() only when you know that malloc() definitely will not be used by
|
||||
any library routine." This doesn't make a lot of sense to me, since there
|
||||
seems to be no documentation as to which routines can transitively call malloc.
|
||||
Nonetheless, under Solaris2, the collector now (since 4.12) allocates
|
||||
memory using mmap by default. (It defines USE_MMAP in gcconfig.h.)
|
||||
You may want to reverse this decisions if you use -DREDIRECT_MALLOC=...
|
||||
|
||||
|
||||
SOLARIS THREADS:
|
||||
|
||||
The collector must be compiled with -DGC_SOLARIS_THREADS (thr_ functions)
|
||||
or -DGC_SOLARIS_PTHREADS (pthread_ functions) to be thread safe.
|
||||
It is also essential that gc.h be included in files that call thr_create,
|
||||
thr_join, thr_suspend, thr_continue, or dlopen. Gc.h macro defines
|
||||
these to also do GC bookkeeping, etc. Gc.h must be included with
|
||||
one or both of these macros defined, otherwise
|
||||
these replacements are not visible.
|
||||
A collector built in this way way only be used by programs that are
|
||||
linked with the threads library.
|
||||
|
||||
In this mode, the collector contains various workarounds for older Solaris
|
||||
bugs. Mostly, these should not be noticeable unless you look at system
|
||||
call traces. However, it cannot protect a guard page at the end of
|
||||
a thread stack. If you know that you will only be running Solaris2.5
|
||||
or later, it should be possible to fix this by compiling the collector
|
||||
with -DSOLARIS23_MPROTECT_BUG_FIXED.
|
||||
|
||||
Since 5.0 alpha5, dlopen disables collection temporarily,
|
||||
unless USE_PROC_FOR_LIBRARIES is defined. In some unlikely cases, this
|
||||
can result in unpleasant heap growth. But it seems better than the
|
||||
race/deadlock issues we had before.
|
||||
|
||||
If solaris_threads are used on an X86 processor with malloc redirected to
|
||||
GC_malloc, it is necessary to call GC_thr_init explicitly before forking the
|
||||
first thread. (This avoids a deadlock arising from calling GC_thr_init
|
||||
with the allocation lock held.)
|
||||
|
||||
It appears that there is a problem in using gc_cpp.h in conjunction with
|
||||
Solaris threads and Sun's C++ runtime. Apparently the overloaded new operator
|
||||
is invoked by some iostream initialization code before threads are correctly
|
||||
initialized. As a result, call to thr_self() in garbage collector
|
||||
initialization segfaults. Currently the only known workaround is to not
|
||||
invoke the garbage collector from a user defined global operator new, or to
|
||||
have it invoke the garbage-collector's allocators only after main has started.
|
||||
(Note that the latter requires a moderately expensive test in operator
|
||||
delete.)
|
||||
|
||||
Hans-J. Boehm
|
||||
(The above contains my personal opinions, which are probably not shared
|
||||
by anyone else.)
|
||||
@@ -1,2 +0,0 @@
|
||||
Alistair Crooks supplied the port. He used Lexa C version 2.1.3 with
|
||||
-Xa to compile.
|
||||
@@ -1,149 +0,0 @@
|
||||
The collector has at various times been compiled under Windows 95 & NT,
|
||||
with the original Microsoft SDK, with Visual C++ 2.0, 4.0, and 6, with
|
||||
the GNU win32 environment, with Borland 4.5, and recently with
|
||||
Watcom C. It is likely that some of these have been broken in the
|
||||
meantime. Patches are appreciated.
|
||||
|
||||
It runs under both win32s and win32, but with different semantics.
|
||||
Under win32, all writable pages outside of the heaps and stack are
|
||||
scanned for roots. Thus the collector sees pointers in DLL data
|
||||
segments. Under win32s, only the main data segment is scanned.
|
||||
(The main data segment should always be scanned. Under some
|
||||
versions of win32s, other regions may also be scanned.)
|
||||
Thus all accessible objects should be accessible from local variables
|
||||
or variables in the main data segment. Alternatively, other data
|
||||
segments (e.g. in DLLs) may be registered with the collector by
|
||||
calling GC_init() and then GC_register_root_section(a), where
|
||||
a is the address of some variable inside the data segment. (Duplicate
|
||||
registrations are ignored, but not terribly quickly.)
|
||||
|
||||
(There are two reasons for this. We didn't want to see many 16:16
|
||||
pointers. And the VirtualQuery call has different semantics under
|
||||
the two systems, and under different versions of win32s.)
|
||||
|
||||
The collector test program "gctest" is linked as a GUI application,
|
||||
but does not open any windows. Its output appears in the file
|
||||
"gc.log". It may be started from the file manager. The hour glass
|
||||
cursor may appear as long as it's running. If it is started from the
|
||||
command line, it will usually run in the background. Wait a few
|
||||
minutes (a few seconds on a modern machine) before you check the output.
|
||||
You should see either a failure indication or a "Collector appears to
|
||||
work" message.
|
||||
|
||||
The cord test program has not been ported (but should port
|
||||
easily). A toy editor (cord/de.exe) based on cords (heavyweight
|
||||
strings represented as trees) has been ported and is included.
|
||||
It runs fine under either win32 or win32S. It serves as an example
|
||||
of a true Windows application, except that it was written by a
|
||||
nonexpert Windows programmer. (There are some peculiarities
|
||||
in the way files are displayed. The <cr> is displayed explicitly
|
||||
for standard DOS text files. As in the UNIX version, control
|
||||
characters are displayed explicitly, but in this case as red text.
|
||||
This may be suboptimal for some tastes and/or sets of default
|
||||
window colors.)
|
||||
|
||||
In general -DREDIRECT_MALLOC is unlikely to work unless the
|
||||
application is completely statically linked.
|
||||
|
||||
For Microsoft development tools, rename NT_MAKEFILE as
|
||||
MAKEFILE. (Make sure that the CPU environment variable is defined
|
||||
to be i386.) In order to use the gc_cpp.h C++ interface, all
|
||||
client code should include gc_cpp.h.
|
||||
|
||||
Clients may need to define GC_NOT_DLL before including gc.h, if the
|
||||
collector was built as a static library (as it normally is in the
|
||||
absence of thread support).
|
||||
|
||||
For GNU-win32, use the regular makefile, possibly after uncommenting
|
||||
the line "include Makefile.DLLs". The latter should be necessary only
|
||||
if you want to package the collector as a DLL. The GNU-win32 port is
|
||||
believed to work only for b18, not b19, probably dues to linker changes
|
||||
in b19. This is probably fixable with a different definition of
|
||||
DATASTART and DATAEND in gcconfig.h.
|
||||
|
||||
For Borland tools, use BCC_MAKEFILE. Note that
|
||||
Borland's compiler defaults to 1 byte alignment in structures (-a1),
|
||||
whereas Visual C++ appears to default to 8 byte alignment (/Zp8).
|
||||
The garbage collector in its default configuration EXPECTS AT
|
||||
LEAST 4 BYTE ALIGNMENT. Thus the BORLAND DEFAULT MUST
|
||||
BE OVERRIDDEN. (In my opinion, it should usually be anyway.
|
||||
I expect that -a1 introduces major performance penalties on a
|
||||
486 or Pentium.) Note that this changes structure layouts. (As a last
|
||||
resort, gcconfig.h can be changed to allow 1 byte alignment. But
|
||||
this has significant negative performance implications.)
|
||||
The Makefile is set up to assume Borland 4.5. If you have another
|
||||
version, change the line near the top. By default, it does not
|
||||
require the assembler. If you do have the assembler, I recommend
|
||||
removing the -DUSE_GENERIC.
|
||||
|
||||
There is some support for incremental collection. This is
|
||||
currently pretty simple-minded. Pages are protected. Protection
|
||||
faults are caught by a handler installed at the bottom of the handler
|
||||
stack. This is both slow and interacts poorly with a debugger.
|
||||
Whenever possible, I recommend adding a call to
|
||||
GC_enable_incremental at the last possible moment, after most
|
||||
debugging is complete. Unlike the UNIX versions, no system
|
||||
calls are wrapped by the collector itself. It may be necessary
|
||||
to wrap ReadFile calls that use a buffer in the heap, so that the
|
||||
call does not encounter a protection fault while it's running.
|
||||
(As usual, none of this is an issue unless GC_enable_incremental
|
||||
is called.)
|
||||
|
||||
Note that incremental collection is disabled with -DSMALL_CONFIG.
|
||||
|
||||
James Clark has contributed the necessary code to support win32 threads.
|
||||
Use NT_THREADS_MAKEFILE (a.k.a gc.mak) instead of NT_MAKEFILE
|
||||
to build this version. Note that this requires some files whose names
|
||||
are more than 8 + 3 characters long. Thus you should unpack the tar file
|
||||
so that long file names are preserved. To build the garbage collector
|
||||
test with VC++ from the command line, use
|
||||
|
||||
nmake /F ".\gc.mak" CFG="gctest - Win32 Release"
|
||||
|
||||
This requires that the subdirectory gctest\Release exist.
|
||||
The test program and DLL will reside in the Release directory.
|
||||
|
||||
This version relies on the collector residing in a dll.
|
||||
|
||||
This version currently supports incremental collection only if it is
|
||||
enabled before any additional threads are created.
|
||||
Version 4.13 attempts to fix some of the earlier problems, but there
|
||||
may be other issues. If you need solid support for win32 threads, you
|
||||
might check with Geodesic Systems. Their collector must be licensed,
|
||||
but they have invested far more time in win32-specific issues.
|
||||
|
||||
Hans
|
||||
|
||||
Ivan V. Demakov's README for the Watcom port:
|
||||
|
||||
The collector has been compiled with Watcom C 10.6 and 11.0.
|
||||
It runs under win32, win32s, and even under msdos with dos4gw
|
||||
dos-extender. It should also run under OS/2, though this isn't
|
||||
tested. Under win32 the collector can be built either as dll
|
||||
or as static library.
|
||||
|
||||
Note that all compilations were done under Windows 95 or NT.
|
||||
For unknown reason compiling under Windows 3.11 for NT (one
|
||||
attempt has been made) leads to broken executables.
|
||||
|
||||
Incremental collection is not supported.
|
||||
|
||||
cord is not ported.
|
||||
|
||||
Before compiling you may need to edit WCC_MAKEFILE to set target
|
||||
platform, library type (dynamic or static), calling conventions, and
|
||||
optimization options.
|
||||
|
||||
To compile the collector and testing programs use the command:
|
||||
wmake -f WCC_MAKEFILE
|
||||
|
||||
All programs using gc should be compiled with 4-byte alignment.
|
||||
For further explanations on this see comments about Borland.
|
||||
|
||||
If gc compiled as dll, the macro ``GC_DLL'' should be defined before
|
||||
including "gc.h" (for example, with -DGC_DLL compiler option). It's
|
||||
important, otherwise resulting programs will not run.
|
||||
|
||||
Ivan Demakov (email: ivan@tgrad.nsk.su)
|
||||
|
||||
|
||||
@@ -1,106 +0,0 @@
|
||||
This is an ASCII diagram of the data structure used to check pointer
|
||||
validity. It was provided by Dave Barrett <barrett@asgard.cs.colorado.edu>,
|
||||
and should be of use to others attempting to understand the code.
|
||||
The data structure in GC4.X is essentially the same. -HB
|
||||
|
||||
|
||||
|
||||
|
||||
Data Structure used by GC_base in gc3.7:
|
||||
21-Apr-94
|
||||
|
||||
|
||||
|
||||
|
||||
63 LOG_TOP_SZ[11] LOG_BOTTOM_SZ[10] LOG_HBLKSIZE[13]
|
||||
+------------------+----------------+------------------+------------------+
|
||||
p:| | TL_HASH(hi) | | HBLKDISPL(p) |
|
||||
+------------------+----------------+------------------+------------------+
|
||||
\-----------------------HBLKPTR(p)-------------------/
|
||||
\------------hi-------------------/
|
||||
\______ ________/ \________ _______/ \________ _______/
|
||||
V V V
|
||||
| | |
|
||||
GC_top_index[] | | |
|
||||
--- +--------------+ | | |
|
||||
^ | | | | |
|
||||
| | | | | |
|
||||
TOP +--------------+<--+ | |
|
||||
_SZ +-<| [] | * | |
|
||||
(items)| +--------------+ if 0 < bi< HBLKSIZE | |
|
||||
| | | | then large object | |
|
||||
| | | | starts at the bi'th | |
|
||||
v | | | HBLK before p. | i |
|
||||
--- | +--------------+ | (word- |
|
||||
v | aligned) |
|
||||
bi= |GET_BI(p){->hash_link}->key==hi | |
|
||||
v | |
|
||||
| (bottom_index) \ scratch_alloc'd | |
|
||||
| ( struct bi ) / by get_index() | |
|
||||
--- +->+--------------+ | |
|
||||
^ | | | |
|
||||
^ | | | |
|
||||
BOTTOM | | ha=GET_HDR_ADDR(p) | |
|
||||
_SZ(items)+--------------+<----------------------+ +-------+
|
||||
| +--<| index[] | |
|
||||
| | +--------------+ GC_obj_map: v
|
||||
| | | | from / +-+-+-----+-+-+-+-+ ---
|
||||
v | | | GC_add < 0| | | | | | | | ^
|
||||
--- | +--------------+ _map_entry \ +-+-+-----+-+-+-+-+ |
|
||||
| | asc_link | +-+-+-----+-+-+-+-+ MAXOBJSZ
|
||||
| +--------------+ +-->| | | j | | | | | +1
|
||||
| | key | | +-+-+-----+-+-+-+-+ |
|
||||
| +--------------+ | +-+-+-----+-+-+-+-+ |
|
||||
| | hash_link | | | | | | | | | | v
|
||||
| +--------------+ | +-+-+-----+-+-+-+-+ ---
|
||||
| | |<--MAX_OFFSET--->|
|
||||
| | (bytes)
|
||||
HDR(p)| GC_find_header(p) | |<--MAP_ENTRIES-->|
|
||||
| \ from | =HBLKSIZE/WORDSZ
|
||||
| (hdr) (struct hblkhdr) / alloc_hdr() | (1024 on Alpha)
|
||||
+-->+----------------------+ | (8/16 bits each)
|
||||
GET_HDR(p)| word hb_sz (words) | |
|
||||
+----------------------+ |
|
||||
| struct hblk *hb_next | |
|
||||
+----------------------+ |
|
||||
|mark_proc hb_mark_proc| |
|
||||
+----------------------+ |
|
||||
| char * hb_map |>-------------+
|
||||
+----------------------+
|
||||
| ushort hb_obj_kind |
|
||||
+----------------------+
|
||||
| hb_last_reclaimed |
|
||||
--- +----------------------+
|
||||
^ | |
|
||||
MARK_BITS| hb_marks[] | *if hdr is free, hb_sz + DISCARD_WORDS
|
||||
_SZ(words)| | is the size of a heap chunk (struct hblk)
|
||||
v | | of at least MININCR*HBLKSIZE bytes (below),
|
||||
--- +----------------------+ otherwise, size of each object in chunk.
|
||||
|
||||
Dynamic data structures above are interleaved throughout the heap in blocks of
|
||||
size MININCR * HBLKSIZE bytes as done by gc_scratch_alloc which cannot be
|
||||
freed; free lists are used (e.g. alloc_hdr). HBLKs's below are collected.
|
||||
|
||||
(struct hblk)
|
||||
--- +----------------------+ < HBLKSIZE --- --- DISCARD_
|
||||
^ |garbage[DISCARD_WORDS]| aligned ^ ^ HDR_BYTES WORDS
|
||||
| | | | v (bytes) (words)
|
||||
| +-----hb_body----------+ < WORDSZ | --- ---
|
||||
| | | aligned | ^ ^
|
||||
| | Object 0 | | hb_sz |
|
||||
| | | i |(word- (words)|
|
||||
| | | (bytes)|aligned) v |
|
||||
| + - - - - - - - - - - -+ --- | --- |
|
||||
| | | ^ | ^ |
|
||||
n * | | j (words) | hb_sz BODY_SZ
|
||||
HBLKSIZE | Object 1 | v v | (words)
|
||||
(bytes) | |--------------- v MAX_OFFSET
|
||||
| + - - - - - - - - - - -+ --- (bytes)
|
||||
| | | !All_INTERIOR_PTRS ^ |
|
||||
| | | sets j only for hb_sz |
|
||||
| | Object N | valid object offsets. | |
|
||||
v | | All objects WORDSZ v v
|
||||
--- +----------------------+ aligned. --- ---
|
||||
|
||||
DISCARD_WORDS is normally zero. Indeed the collector has not been tested
|
||||
with another value in ages.
|
||||
@@ -1,289 +0,0 @@
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<TITLE>Debugging Garbage Collector Related Problems</title>
|
||||
</head>
|
||||
<BODY>
|
||||
<H1>Debugging Garbage Collector Related Problems</h1>
|
||||
This page contains some hints on
|
||||
debugging issues specific to
|
||||
the Boehm-Demers-Weiser conservative garbage collector.
|
||||
It applies both to debugging issues in client code that manifest themselves
|
||||
as collector misbehavior, and to debugging the collector itself.
|
||||
<P>
|
||||
If you suspect a bug in the collector itself, it is strongly recommended
|
||||
that you try the latest collector release, even if it is labelled as "alpha",
|
||||
before proceeding.
|
||||
<H2>Bus Errors and Segmentation Violations</h2>
|
||||
<P>
|
||||
If the fault occurred in GC_find_limit, or with incremental collection enabled,
|
||||
this is probably normal. The collector installs handlers to take care of
|
||||
these. You will not see these unless you are using a debugger.
|
||||
Your debugger <I>should</i> allow you to continue.
|
||||
It's often preferable to tell the debugger to ignore SIGBUS and SIGSEGV
|
||||
("<TT>handle SIGSEGV SIGBUS nostop noprint</tt>" in gdb,
|
||||
"<TT>ignore SIGSEGV SIGBUS</tt>" in most versions of dbx)
|
||||
and set a breakpoint in <TT>abort</tt>.
|
||||
The collector will call abort if the signal had another cause,
|
||||
and there was not other handler previously installed.
|
||||
<P>
|
||||
We recommend debugging without incremental collection if possible.
|
||||
(This applies directly to UNIX systems.
|
||||
Debugging with incremental collection under win32 is worse. See README.win32.)
|
||||
<P>
|
||||
If the application generates an unhandled SIGSEGV or equivalent, it may
|
||||
often be easiest to set the environment variable GC_LOOP_ON_ABORT. On many
|
||||
platforms, this will cause the collector to loop in a handler when the
|
||||
SIGSEGV is encountered (or when the collector aborts for some other reason),
|
||||
and a debugger can then be attached to the looping
|
||||
process. This sidesteps common operating system problems related
|
||||
to incomplete core files for multithreaded applications, etc.
|
||||
<H2>Other Signals</h2>
|
||||
On most platforms, the multithreaded version of the collector needs one or
|
||||
two other signals for internal use by the collector in stopping threads.
|
||||
It is normally wise to tell the debugger to ignore these. On Linux,
|
||||
the collector currently uses SIGPWR and SIGXCPU by default.
|
||||
<H2>Warning Messages About Needing to Allocate Blacklisted Blocks</h2>
|
||||
The garbage collector generates warning messages of the form
|
||||
<PRE>
|
||||
Needed to allocate blacklisted block at 0x...
|
||||
</pre>
|
||||
when it needs to allocate a block at a location that it knows to be
|
||||
referenced by a false pointer. These false pointers can be either permanent
|
||||
(<I>e.g.</i> a static integer variable that never changes) or temporary.
|
||||
In the latter case, the warning is largely spurious, and the block will
|
||||
eventually be reclaimed normally.
|
||||
In the former case, the program will still run correctly, but the block
|
||||
will never be reclaimed. Unless the block is intended to be
|
||||
permanent, the warning indicates a memory leak.
|
||||
<OL>
|
||||
<LI>Ignore these warnings while you are using GC_DEBUG. Some of the routines
|
||||
mentioned below don't have debugging equivalents. (Alternatively, write
|
||||
the missing routines and send them to me.)
|
||||
<LI>Replace allocator calls that request large blocks with calls to
|
||||
<TT>GC_malloc_ignore_off_page</tt> or
|
||||
<TT>GC_malloc_atomic_ignore_off_page</tt>. You may want to set a
|
||||
breakpoint in <TT>GC_default_warn_proc</tt> to help you identify such calls.
|
||||
Make sure that a pointer to somewhere near the beginning of the resulting block
|
||||
is maintained in a (preferably volatile) variable as long as
|
||||
the block is needed.
|
||||
<LI>
|
||||
If the large blocks are allocated with realloc, we suggest instead allocating
|
||||
them with something like the following. Note that the realloc size increment
|
||||
should be fairly large (e.g. a factor of 3/2) for this to exhibit reasonable
|
||||
performance. But we all know we should do that anyway.
|
||||
<PRE>
|
||||
void * big_realloc(void *p, size_t new_size)
|
||||
{
|
||||
size_t old_size = GC_size(p);
|
||||
void * result;
|
||||
|
||||
if (new_size <= 10000) return(GC_realloc(p, new_size));
|
||||
if (new_size <= old_size) return(p);
|
||||
result = GC_malloc_ignore_off_page(new_size);
|
||||
if (result == 0) return(0);
|
||||
memcpy(result,p,old_size);
|
||||
GC_free(p);
|
||||
return(result);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<LI> In the unlikely case that even relatively small object
|
||||
(<20KB) allocations are triggering these warnings, then your address
|
||||
space contains lots of "bogus pointers", i.e. values that appear to
|
||||
be pointers but aren't. Usually this can be solved by using GC_malloc_atomic
|
||||
or the routines in gc_typed.h to allocate large pointer-free regions of bitmaps, etc. Sometimes the problem can be solved with trivial changes of encoding
|
||||
in certain values. It is possible, to identify the source of the bogus
|
||||
pointers by building the collector with <TT>-DPRINT_BLACK_LIST</tt>,
|
||||
which will cause it to print the "bogus pointers", along with their location.
|
||||
|
||||
<LI> If you get only a fixed number of these warnings, you are probably only
|
||||
introducing a bounded leak by ignoring them. If the data structures being
|
||||
allocated are intended to be permanent, then it is also safe to ignore them.
|
||||
The warnings can be turned off by calling GC_set_warn_proc with a procedure
|
||||
that ignores these warnings (e.g. by doing absolutely nothing).
|
||||
</ol>
|
||||
|
||||
<H2>The Collector References a Bad Address in <TT>GC_malloc</tt></h2>
|
||||
|
||||
This typically happens while the collector is trying to remove an entry from
|
||||
its free list, and the free list pointer is bad because the free list link
|
||||
in the last allocated object was bad.
|
||||
<P>
|
||||
With > 99% probability, you wrote past the end of an allocated object.
|
||||
Try setting <TT>GC_DEBUG</tt> before including <TT>gc.h</tt> and
|
||||
allocating with <TT>GC_MALLOC</tt>. This will try to detect such
|
||||
overwrite errors.
|
||||
|
||||
<H2>Unexpectedly Large Heap</h2>
|
||||
|
||||
Unexpected heap growth can be due to one of the following:
|
||||
<OL>
|
||||
<LI> Data structures that are being unintentionally retained. This
|
||||
is commonly caused by data structures that are no longer being used,
|
||||
but were not cleared, or by caches growing without bounds.
|
||||
<LI> Pointer misidentification. The garbage collector is interpreting
|
||||
integers or other data as pointers and retaining the "referenced"
|
||||
objects.
|
||||
<LI> Heap fragmentation. This should never result in unbounded growth,
|
||||
but it may account for larger heaps. This is most commonly caused
|
||||
by allocation of large objects. On some platforms it can be reduced
|
||||
by building with -DUSE_MUNMAP, which will cause the collector to unmap
|
||||
memory corresponding to pages that have not been recently used.
|
||||
<LI> Per object overhead. This is usually a relatively minor effect, but
|
||||
it may be worth considering. If the collector recognizes interior
|
||||
pointers, object sizes are increased, so that one-past-the-end pointers
|
||||
are correctly recognized. The collector can be configured not to do this
|
||||
(<TT>-DDONT_ADD_BYTE_AT_END</tt>).
|
||||
<P>
|
||||
The collector rounds up object sizes so the result fits well into the
|
||||
chunk size (<TT>HBLKSIZE</tt>, normally 4K on 32 bit machines, 8K
|
||||
on 64 bit machines) used by the collector. Thus it may be worth avoiding
|
||||
objects of size 2K + 1 (or 2K if a byte is being added at the end.)
|
||||
</ol>
|
||||
The last two cases can often be identified by looking at the output
|
||||
of a call to <TT>GC_dump()</tt>. Among other things, it will print the
|
||||
list of free heap blocks, and a very brief description of all chunks in
|
||||
the heap, the object sizes they correspond to, and how many live objects
|
||||
were found in the chunk at the last collection.
|
||||
<P>
|
||||
Growing data structures can usually be identified by
|
||||
<OL>
|
||||
<LI> Building the collector with <TT>-DKEEP_BACK_PTRS</tt>,
|
||||
<LI> Preferably using debugging allocation (defining <TT>GC_DEBUG</tt>
|
||||
before including <TT>gc.h</tt> and allocating with <TT>GC_MALLOC</tt>),
|
||||
so that objects will be identified by their allocation site,
|
||||
<LI> Running the application long enough so
|
||||
that most of the heap is composed of "leaked" memory, and
|
||||
<LI> Then calling <TT>GC_generate_random_backtrace()</tt> from backptr.h
|
||||
a few times to determine why some randomly sampled objects in the heap are
|
||||
being retained.
|
||||
</ol>
|
||||
<P>
|
||||
The same technique can often be used to identify problems with false
|
||||
pointers, by noting whether the reference chains printed by
|
||||
<TT>GC_generate_random_backtrace()</tt> involve any misidentified pointers.
|
||||
An alternate technique is to build the collector with
|
||||
<TT>-DPRINT_BLACK_LIST</tt> which will cause it to report values that
|
||||
are almost, but not quite, look like heap pointers. It is very likely that
|
||||
actual false pointers will come from similar sources.
|
||||
<P>
|
||||
In the unlikely case that false pointers are an issue, it can usually
|
||||
be resolved using one or more of the following techniques:
|
||||
<OL>
|
||||
<LI> Use <TT>GC_malloc_atomic</tt> for objects containing no pointers.
|
||||
This is especially important for large arrays containing compressed data,
|
||||
pseudo-random numbers, and the like. It is also likely to improve GC
|
||||
performance, perhaps drastically so if the application is paging.
|
||||
<LI> If you allocate large objects containing only
|
||||
one or two pointers at the beginning, either try the typed allocation
|
||||
primitives is <TT>gc_typed.h</tt>, or separate out the pointerfree component.
|
||||
<LI> Consider using <TT>GC_malloc_ignore_off_page()</tt>
|
||||
to allocate large objects. (See <TT>gc.h</tt> and above for details.
|
||||
Large means > 100K in most environments.)
|
||||
</ol>
|
||||
<H2>Prematurely Reclaimed Objects</h2>
|
||||
The usual symptom of this is a segmentation fault, or an obviously overwritten
|
||||
value in a heap object. This should, of course, be impossible. In practice,
|
||||
it may happen for reasons like the following:
|
||||
<OL>
|
||||
<LI> The collector did not intercept the creation of threads correctly in
|
||||
a multithreaded application, <I>e.g.</i> because the client called
|
||||
<TT>pthread_create</tt> without including <TT>gc.h</tt>, which redefines it.
|
||||
<LI> The last pointer to an object in the garbage collected heap was stored
|
||||
somewhere were the collector couldn't see it, <I>e.g.</i> in an
|
||||
object allocated with system <TT>malloc</tt>, in certain types of
|
||||
<TT>mmap</tt>ed files,
|
||||
or in some data structure visible only to the OS. (On some platforms,
|
||||
thread-local storage is one of these.)
|
||||
<LI> The last pointer to an object was somehow disguised, <I>e.g.</i> by
|
||||
XORing it with another pointer.
|
||||
<LI> Incorrect use of <TT>GC_malloc_atomic</tt> or typed allocation.
|
||||
<LI> An incorrect <TT>GC_free</tt> call.
|
||||
<LI> The client program overwrote an internal garbage collector data structure.
|
||||
<LI> A garbage collector bug.
|
||||
<LI> (Empirically less likely than any of the above.) A compiler optimization
|
||||
that disguised the last pointer.
|
||||
</ol>
|
||||
The following relatively simple techniques should be tried first to narrow
|
||||
down the problem:
|
||||
<OL>
|
||||
<LI> If you are using the incremental collector try turning it off for
|
||||
debugging.
|
||||
<LI> Try to reproduce the problem with fully debuggable unoptimized code.
|
||||
This will eliminate the last possibility, as well as making debugging easier.
|
||||
<LI> Try replacing any suspect typed allocation and <TT>GC_malloc_atomic</tt>
|
||||
calls with calls to <TT>GC_malloc</tt>.
|
||||
<LI> Try removing any GC_free calls (<I>e.g.</i> with a suitable
|
||||
<TT>#define</tt>).
|
||||
<LI> Rebuild the collector with <TT>-DGC_ASSERTIONS</tt>.
|
||||
<LI> If the following works on your platform (i.e. if gctest still works
|
||||
if you do this), try building the collector with
|
||||
<TT>-DREDIRECT_MALLOC=GC_malloc_uncollectable</tt>. This will cause
|
||||
the collector to scan memory allocated with malloc.
|
||||
</ol>
|
||||
If all else fails, you will have to attack this with a debugger.
|
||||
Suggested steps:
|
||||
<OL>
|
||||
<LI> Call <TT>GC_dump()</tt> from the debugger around the time of the failure. Verify
|
||||
that the collectors idea of the root set (i.e. static data regions which
|
||||
it should scan for pointers) looks plausible. If not, i.e. if it doesn't
|
||||
include some static variables, report this as
|
||||
a collector bug. Be sure to describe your platform precisely, since this sort
|
||||
of problem is nearly always very platform dependent.
|
||||
<LI> Especially if the failure is not deterministic, try to isolate it to
|
||||
a relatively small test case.
|
||||
<LI> Set a break point in <TT>GC_finish_collection</tt>. This is a good
|
||||
point to examine what has been marked, i.e. found reachable, by the
|
||||
collector.
|
||||
<LI> If the failure is deterministic, run the process
|
||||
up to the last collection before the failure.
|
||||
Note that the variable <TT>GC_gc_no</tt> counts collections and can be used
|
||||
to set a conditional breakpoint in the right one. It is incremented just
|
||||
before the call to GC_finish_collection.
|
||||
If object <TT>p</tt> was prematurely recycled, it may be helpful to
|
||||
look at <TT>*GC_find_header(p)</tt> at the failure point.
|
||||
The <TT>hb_last_reclaimed</tt> field will identify the collection number
|
||||
during which its block was last swept.
|
||||
<LI> Verify that the offending object still has its correct contents at
|
||||
this point.
|
||||
The call <TT>GC_is_marked(p)</tt> from the debugger to verify that the
|
||||
object has not been marked, and is about to be reclaimed.
|
||||
<LI> Determine a path from a root, i.e. static variable, stack, or
|
||||
register variable,
|
||||
to the reclaimed object. Call <TT>GC_is_marked(q)</tt> for each object
|
||||
<TT>q</tt> along the path, trying to locate the first unmarked object, say
|
||||
<TT>r</tt>.
|
||||
<LI> If <TT>r</tt> is pointed to by a static root,
|
||||
verify that the location
|
||||
pointing to it is part of the root set printed by <TT>GC_dump()</tt>. If it
|
||||
is on the stack in the main (or only) thread, verify that
|
||||
<TT>GC_stackbottom</tt> is set correctly to the base of the stack. If it is
|
||||
in another thread stack, check the collector's thread data structure
|
||||
(<TT>GC_thread[]</tt> on several platforms) to make sure that stack bounds
|
||||
are set correctly.
|
||||
<LI> If <TT>r</tt> is pointed to by heap object <TT>s</tt>, check that the
|
||||
collector's layout description for <TT>s</tt> is such that the pointer field
|
||||
will be scanned. Call <TT>*GC_find_header(s)</tt> to look at the descriptor
|
||||
for the heap chunk. The <TT>hb_descr</tt> field specifies the layout
|
||||
of objects in that chunk. See gc_mark.h for the meaning of the descriptor.
|
||||
(If it's low order 2 bits are zero, then it is just the length of the
|
||||
object prefix to be scanned. This form is always used for objects allocated
|
||||
with <TT>GC_malloc</tt> or <TT>GC_malloc_atomic</tt>.)
|
||||
<LI> If the failure is not deterministic, you may still be able to apply some
|
||||
of the above technique at the point of failure. But remember that objects
|
||||
allocated since the last collection will not have been marked, even if the
|
||||
collector is functioning properly. On some platforms, the collector
|
||||
can be configured to save call chains in objects for debugging.
|
||||
Enabling this feature will also cause it to save the call stack at the
|
||||
point of the last GC in GC_arrays._last_stack.
|
||||
<LI> When looking at GC internal data structures remember that a number
|
||||
of <TT>GC_</tt><I>xxx</i> variables are really macro defined to
|
||||
<TT>GC_arrays._</tt><I>xxx</i>, so that
|
||||
the collector can avoid scanning them.
|
||||
</ol>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,80 +0,0 @@
|
||||
.TH GC_MALLOC 1L "12 February 1996"
|
||||
.SH NAME
|
||||
GC_malloc, GC_malloc_atomic, GC_free, GC_realloc, GC_enable_incremental, GC_register_finalizer, GC_malloc_ignore_off_page, GC_malloc_atomic_ignore_off_page, GC_set_warn_proc \- Garbage collecting malloc replacement
|
||||
.SH SYNOPSIS
|
||||
#include "gc.h"
|
||||
.br
|
||||
# define malloc(n) GC_malloc(n)
|
||||
.br
|
||||
... malloc(...) ...
|
||||
.br
|
||||
.sp
|
||||
cc ... gc.a
|
||||
.LP
|
||||
.SH DESCRIPTION
|
||||
.I GC_malloc
|
||||
and
|
||||
.I GC_free
|
||||
are plug-in replacements for standard malloc and free. However,
|
||||
.I
|
||||
GC_malloc
|
||||
will attempt to reclaim inaccessible space automatically by invoking a conservative garbage collector at appropriate points. The collector traverses all data structures accessible by following pointers from the machines registers, stack(s), data, and bss segments. Inaccessible structures will be reclaimed. A machine word is considered to be a valid pointer if it is an address inside an object allocated by
|
||||
.I
|
||||
GC_malloc
|
||||
or friends.
|
||||
.LP
|
||||
See the documentation in the include file gc_cpp.h for an alternate, C++ specific interface to the garbage collector.
|
||||
.LP
|
||||
Unlike the standard implementations of malloc,
|
||||
.I
|
||||
GC_malloc
|
||||
clears the newly allocated storage.
|
||||
.I
|
||||
GC_malloc_atomic
|
||||
does not. Furthermore, it informs the collector that the resulting object will never contain any pointers, and should therefore not be scanned by the collector.
|
||||
.LP
|
||||
.I
|
||||
GC_free
|
||||
can be used to deallocate objects, but its use is optional, and generally discouraged.
|
||||
.I
|
||||
GC_realloc
|
||||
has the standard realloc semantics. It preserves pointer-free-ness.
|
||||
.I
|
||||
GC_register_finalizer
|
||||
allows for registration of functions that are invoked when an object becomes inaccessible.
|
||||
.LP
|
||||
The garbage collector tries to avoid allocating memory at locations that already appear to be referenced before allocation. (Such apparent ``pointers'' are usually large integers and the like that just happen to look like an address.) This may make it hard to allocate very large objects. An attempt to do so may generate a warning.
|
||||
.LP
|
||||
.I
|
||||
GC_malloc_ignore_off_page
|
||||
and
|
||||
.I
|
||||
GC_malloc_atomic_ignore_off_page
|
||||
inform the collector that the client code will always maintain a pointer to near the beginning of the object (within the first 512 bytes), and that pointers beyond that can be ignored by the collector. This makes it much easier for the collector to place large objects. These are recommended for large object allocation. (Objects expected to be larger than about 100KBytes should be allocated this way.)
|
||||
.LP
|
||||
It is also possible to use the collector to find storage leaks in programs destined to be run with standard malloc/free. The collector can be compiled for thread-safe operation. Unlike standard malloc, it is safe to call malloc after a previous malloc call was interrupted by a signal, provided the original malloc call is not resumed.
|
||||
.LP
|
||||
The collector may, on rare occasion produce warning messages. On UNIX machines these appear on stderr. Warning messages can be filtered, redirected, or ignored with
|
||||
.I
|
||||
GC_set_warn_proc.
|
||||
This is recommended for production code. See gc.h for details.
|
||||
.LP
|
||||
Debugging versions of many of the above routines are provided as macros. Their names are identical to the above, but consist of all capital letters. If GC_DEBUG is defined before gc.h is included, these routines do additional checking, and allow the leak detecting version of the collector to produce slightly more useful output. Without GC_DEBUG defined, they behave exactly like the lower-case versions.
|
||||
.LP
|
||||
On some machines, collection will be performed incrementally after a call to
|
||||
.I
|
||||
GC_enable_incremental.
|
||||
This may temporarily write protect pages in the heap. See the README file for more information on how this interacts with system calls that write to the heap.
|
||||
.LP
|
||||
Other facilities not discussed here include limited facilities to support incremental collection on machines without appropriate VM support, provisions for providing more explicit object layout information to the garbage collector, more direct support for ``weak'' pointers, support for ``abortable'' garbage collections during idle time, etc.
|
||||
.LP
|
||||
.SH "SEE ALSO"
|
||||
The README and gc.h files in the distribution. More detailed definitions of the functions exported by the collector are given there. (The above list is not complete.)
|
||||
.LP
|
||||
Boehm, H., and M. Weiser, "Garbage Collection in an Uncooperative Environment",
|
||||
\fISoftware Practice & Experience\fP, September 1988, pp. 807-820.
|
||||
.LP
|
||||
The malloc(3) man page.
|
||||
.LP
|
||||
.SH AUTHOR
|
||||
Hans-J. Boehm (boehm@parc.xerox.com). Some of the code was written by others, most notably Alan Demers.
|
||||
@@ -1,438 +0,0 @@
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<TITLE> Conservative GC Algorithmic Overview </TITLE>
|
||||
<AUTHOR> Hans-J. Boehm, Silicon Graphics</author>
|
||||
</HEAD>
|
||||
<BODY>
|
||||
<H1> <I>This is under construction</i> </h1>
|
||||
<H1> Conservative GC Algorithmic Overview </h1>
|
||||
<P>
|
||||
This is a description of the algorithms and data structures used in our
|
||||
conservative garbage collector. I expect the level of detail to increase
|
||||
with time. For a survey of GC algorithms, see for example
|
||||
<A HREF="ftp://ftp.cs.utexas.edu/pub/garbage/gcsurvey.ps"> Paul Wilson's
|
||||
excellent paper</a>. For an overview of the collector interface,
|
||||
see <A HREF="gcinterface.html">here</a>.
|
||||
<P>
|
||||
This description is targeted primarily at someone trying to understand the
|
||||
source code. It specifically refers to variable and function names.
|
||||
It may also be useful for understanding the algorithms at a higher level.
|
||||
<P>
|
||||
The description here assumes that the collector is used in default mode.
|
||||
In particular, we assume that it used as a garbage collector, and not just
|
||||
a leak detector. We initially assume that it is used in stop-the-world,
|
||||
non-incremental mode, though the presence of the incremental collector
|
||||
will be apparent in the design.
|
||||
We assume the default finalization model, but the code affected by that
|
||||
is very localized.
|
||||
<H2> Introduction </h2>
|
||||
The garbage collector uses a modified mark-sweep algorithm. Conceptually
|
||||
it operates roughly in four phases:
|
||||
|
||||
<OL>
|
||||
|
||||
<LI>
|
||||
<I>Preparation</i> Clear all mark bits, indicating that all objects
|
||||
are potentially unreachable.
|
||||
|
||||
<LI>
|
||||
<I>Mark phase</i> Marks all objects that can be reachable via chains of
|
||||
pointers from variables. Normally the collector has no real information
|
||||
about the location of pointer variables in the heap, so it
|
||||
views all static data areas, stacks and registers as potentially containing
|
||||
containing pointers. Any bit patterns that represent addresses inside
|
||||
heap objects managed by the collector are viewed as pointers.
|
||||
Unless the client program has made heap object layout information
|
||||
available to the collector, any heap objects found to be reachable from
|
||||
variables are again scanned similarly.
|
||||
|
||||
<LI>
|
||||
<I>Sweep phase</i> Scans the heap for inaccessible, and hence unmarked,
|
||||
objects, and returns them to an appropriate free list for reuse. This is
|
||||
not really a separate phase; even in non incremental mode this is operation
|
||||
is usually performed on demand during an allocation that discovers an empty
|
||||
free list. Thus the sweep phase is very unlikely to touch a page that
|
||||
would not have been touched shortly thereafter anyway.
|
||||
|
||||
<LI>
|
||||
<I>Finalization phase</i> Unreachable objects which had been registered
|
||||
for finalization are enqueued for finalization outside the collector.
|
||||
|
||||
</ol>
|
||||
|
||||
<P>
|
||||
The remaining sections describe the memory allocation data structures,
|
||||
and then the last 3 collection phases in more detail. We conclude by
|
||||
outlining some of the additional features implemented in the collector.
|
||||
|
||||
<H2>Allocation</h2>
|
||||
The collector includes its own memory allocator. The allocator obtains
|
||||
memory from the system in a platform-dependent way. Under UNIX, it
|
||||
uses either <TT>malloc</tt>, <TT>sbrk</tt>, or <TT>mmap</tt>.
|
||||
<P>
|
||||
Most static data used by the allocator, as well as that needed by the
|
||||
rest of the garbage collector is stored inside the
|
||||
<TT>_GC_arrays</tt> structure.
|
||||
This allows the garbage collector to easily ignore the collectors own
|
||||
data structures when it searches for root pointers. Other allocator
|
||||
and collector internal data structures are allocated dynamically
|
||||
with <TT>GC_scratch_alloc</tt>. <TT>GC_scratch_alloc</tt> does not
|
||||
allow for deallocation, and is therefore used only for permanent data
|
||||
structures.
|
||||
<P>
|
||||
The allocator allocates objects of different <I>kinds</i>.
|
||||
Different kinds are handled somewhat differently by certain parts
|
||||
of the garbage collector. Certain kinds are scanned for pointers,
|
||||
others are not. Some may have per-object type descriptors that
|
||||
determine pointer locations. Or a specific kind may correspond
|
||||
to one specific object layout. Two built-in kinds are uncollectable.
|
||||
One (<TT>STUBBORN</tt>) is immutable without special precautions.
|
||||
In spite of that, it is very likely that most applications currently
|
||||
use at most two kinds: <TT>NORMAL</tt> and <TT>PTRFREE</tt> objects.
|
||||
<P>
|
||||
The collector uses a two level allocator. A large block is defined to
|
||||
be one larger than half of <TT>HBLKSIZE</tt>, which is a power of 2,
|
||||
typically on the order of the page size.
|
||||
<P>
|
||||
Large block sizes are rounded up to
|
||||
the next multiple of <TT>HBLKSIZE</tt> and then allocated by
|
||||
<TT>GC_allochblk</tt>. This uses roughly what Paul Wilson has termed
|
||||
a "next fit" algorithm, i.e. first-fit with a rotating pointer.
|
||||
The implementation does check for a better fitting immediately
|
||||
adjacent block, which gives it somewhat better fragmentation characteristics.
|
||||
I'm now convinced it should use a best fit algorithm. The actual
|
||||
implementation of <TT>GC_allochblk</tt>
|
||||
is significantly complicated by black-listing issues
|
||||
(see below).
|
||||
<P>
|
||||
Small blocks are allocated in blocks of size <TT>HBLKSIZE</tt>.
|
||||
Each block is
|
||||
dedicated to only one object size and kind. The allocator maintains
|
||||
separate free lists for each size and kind of object.
|
||||
<P>
|
||||
In order to avoid allocating blocks for too many distinct object sizes,
|
||||
the collector normally does not directly allocate objects of every possible
|
||||
request size. Instead request are rounded up to one of a smaller number
|
||||
of allocated sizes, for which free lists are maintained. The exact
|
||||
allocated sizes are computed on demand, but subject to the constraint
|
||||
that they increase roughly in geometric progression. Thus objects
|
||||
requested early in the execution are likely to be allocated with exactly
|
||||
the requested size, subject to alignment constraints.
|
||||
See <TT>GC_init_size_map</tt> for details.
|
||||
<P>
|
||||
The actual size rounding operation during small object allocation is
|
||||
implemented as a table lookup in <TT>GC_size_map</tt>.
|
||||
<P>
|
||||
Both collector initialization and computation of allocated sizes are
|
||||
handled carefully so that they do not slow down the small object fast
|
||||
allocation path. An attempt to allocate before the collector is initialized,
|
||||
or before the appropriate <TT>GC_size_map</tt> entry is computed,
|
||||
will take the same path as an allocation attempt with an empty free list.
|
||||
This results in a call to the slow path code (<TT>GC_generic_malloc_inner</tt>)
|
||||
which performs the appropriate initialization checks.
|
||||
<P>
|
||||
In non-incremental mode, we make a decision about whether to garbage collect
|
||||
whenever an allocation would otherwise have failed with the current heap size.
|
||||
If the total amount of allocation since the last collection is less than
|
||||
the heap size divided by <TT>GC_free_space_divisor</tt>, we try to
|
||||
expand the heap. Otherwise, we initiate a garbage collection. This ensures
|
||||
that the amount of garbage collection work per allocated byte remains
|
||||
constant.
|
||||
<P>
|
||||
The above is in fat an oversimplification of the real heap expansion
|
||||
heuristic, which adjusts slightly for root size and certain kinds of
|
||||
fragmentation. In particular, programs with a large root set size and
|
||||
little live heap memory will expand the heap to amortize the cost of
|
||||
scanning the roots.
|
||||
<P>
|
||||
Versions 5.x of the collector actually collect more frequently in
|
||||
nonincremental mode. The large block allocator usually refuses to split
|
||||
large heap blocks once the garbage collection threshold is
|
||||
reached. This often has the effect of collecting well before the
|
||||
heap fills up, thus reducing fragmentation and working set size at the
|
||||
expense of GC time. 6.x will chose an intermediate strategy depending
|
||||
on how much large object allocation has taken place in the past.
|
||||
(If the collector is configured to unmap unused pages, versions 6.x
|
||||
will use the 5.x strategy.)
|
||||
<P>
|
||||
(It has been suggested that this should be adjusted so that we favor
|
||||
expansion if the resulting heap still fits into physical memory.
|
||||
In many cases, that would no doubt help. But it is tricky to do this
|
||||
in a way that remains robust if multiple application are contending
|
||||
for a single pool of physical memory.)
|
||||
|
||||
<H2>Mark phase</h2>
|
||||
|
||||
The marker maintains an explicit stack of memory regions that are known
|
||||
to be accessible, but that have not yet been searched for contained pointers.
|
||||
Each stack entry contains the starting address of the block to be scanned,
|
||||
as well as a descriptor of the block. If no layout information is
|
||||
available for the block, then the descriptor is simply a length.
|
||||
(For other possibilities, see <TT>gc_mark.h</tt>.)
|
||||
<P>
|
||||
At the beginning of the mark phase, all root segments are pushed on the
|
||||
stack by <TT>GC_push_roots</tt>. If <TT>ALL_INTERIOR_PTRS</tt> is not
|
||||
defined, then stack roots require special treatment. In this case, the
|
||||
normal marking code ignores interior pointers, but <TT>GC_push_all_stack</tt>
|
||||
explicitly checks for interior pointers and pushes descriptors for target
|
||||
objects.
|
||||
<P>
|
||||
The marker is structured to allow incremental marking.
|
||||
Each call to <TT>GC_mark_some</tt> performs a small amount of
|
||||
work towards marking the heap.
|
||||
It maintains
|
||||
explicit state in the form of <TT>GC_mark_state</tt>, which
|
||||
identifies a particular sub-phase. Some other pieces of state, most
|
||||
notably the mark stack, identify how much work remains to be done
|
||||
in each sub-phase. The normal progression of mark states for
|
||||
a stop-the-world collection is:
|
||||
<OL>
|
||||
<LI> <TT>MS_INVALID</tt> indicating that there may be accessible unmarked
|
||||
objects. In this case <TT>GC_objects_are_marked</tt> will simultaneously
|
||||
be false, so the mark state is advanced to
|
||||
<LI> <TT>MS_PUSH_UNCOLLECTABLE</tt> indicating that it suffices to push
|
||||
uncollectable objects, roots, and then mark everything reachable from them.
|
||||
<TT>Scan_ptr</tt> is advanced through the heap until all uncollectable
|
||||
objects are pushed, and objects reachable from them are marked.
|
||||
At that point, the next call to <TT>GC_mark_some</tt> calls
|
||||
<TT>GC_push_roots</tt> to push the roots. It the advances the
|
||||
mark state to
|
||||
<LI> <TT>MS_ROOTS_PUSHED</tt> asserting that once the mark stack is
|
||||
empty, all reachable objects are marked. Once in this state, we work
|
||||
only on emptying the mark stack. Once this is completed, the state
|
||||
changes to
|
||||
<LI> <TT>MS_NONE</tt> indicating that reachable objects are marked.
|
||||
</ol>
|
||||
|
||||
The core mark routine <TT>GC_mark_from_mark_stack</tt>, is called
|
||||
repeatedly by several of the sub-phases when the mark stack starts to fill
|
||||
up. It is also called repeatedly in <TT>MS_ROOTS_PUSHED</tt> state
|
||||
to empty the mark stack.
|
||||
The routine is designed to only perform a limited amount of marking at
|
||||
each call, so that it can also be used by the incremental collector.
|
||||
It is fairly carefully tuned, since it usually consumes a large majority
|
||||
of the garbage collection time.
|
||||
<P>
|
||||
The marker correctly handles mark stack overflows. Whenever the mark stack
|
||||
overflows, the mark state is reset to <TT>MS_INVALID</tt>.
|
||||
Since there are already marked objects in the heap,
|
||||
this eventually forces a complete
|
||||
scan of the heap, searching for pointers, during which any unmarked objects
|
||||
referenced by marked objects are again pushed on the mark stack. This
|
||||
process is repeated until the mark phase completes without a stack overflow.
|
||||
Each time the stack overflows, an attempt is made to grow the mark stack.
|
||||
All pieces of the collector that push regions onto the mark stack have to be
|
||||
careful to ensure forward progress, even in case of repeated mark stack
|
||||
overflows. Every mark attempt results in additional marked objects.
|
||||
<P>
|
||||
Each mark stack entry is processed by examining all candidate pointers
|
||||
in the range described by the entry. If the region has no associated
|
||||
type information, then this typically requires that each 4-byte aligned
|
||||
quantity (8-byte aligned with 64-bit pointers) be considered a candidate
|
||||
pointer.
|
||||
<P>
|
||||
We determine whether a candidate pointer is actually the address of
|
||||
a heap block. This is done in the following steps:
|
||||
<NL>
|
||||
<LI> The candidate pointer is checked against rough heap bounds.
|
||||
These heap bounds are maintained such that all actual heap objects
|
||||
fall between them. In order to facilitate black-listing (see below)
|
||||
we also include address regions that the heap is likely to expand into.
|
||||
Most non-pointers fail this initial test.
|
||||
<LI> The candidate pointer is divided into two pieces; the most significant
|
||||
bits identify a <TT>HBLKSIZE</tt>-sized page in the address space, and
|
||||
the least significant bits specify an offset within that page.
|
||||
(A hardware page may actually consist of multiple such pages.
|
||||
HBLKSIZE is usually the page size divided by a small power of two.)
|
||||
<LI>
|
||||
The page address part of the candidate pointer is looked up in a
|
||||
<A HREF="tree.html">table</a>.
|
||||
Each table entry contains either 0, indicating that the page is not part
|
||||
of the garbage collected heap, a small integer <I>n</i>, indicating
|
||||
that the page is part of large object, starting at least <I>n</i> pages
|
||||
back, or a pointer to a descriptor for the page. In the first case,
|
||||
the candidate pointer i not a true pointer and can be safely ignored.
|
||||
In the last two cases, we can obtain a descriptor for the page containing
|
||||
the beginning of the object.
|
||||
<LI>
|
||||
The starting address of the referenced object is computed.
|
||||
The page descriptor contains the size of the object(s)
|
||||
in that page, the object kind, and the necessary mark bits for those
|
||||
objects. The size information can be used to map the candidate pointer
|
||||
to the object starting address. To accelerate this process, the page header
|
||||
also contains a pointer to a precomputed map of page offsets to displacements
|
||||
from the beginning of an object. The use of this map avoids a
|
||||
potentially slow integer remainder operation in computing the object
|
||||
start address.
|
||||
<LI>
|
||||
The mark bit for the target object is checked and set. If the object
|
||||
was previously unmarked, the object is pushed on the mark stack.
|
||||
The descriptor is read from the page descriptor. (This is computed
|
||||
from information <TT>GC_obj_kinds</tt> when the page is first allocated.)
|
||||
</nl>
|
||||
<P>
|
||||
At the end of the mark phase, mark bits for left-over free lists are cleared,
|
||||
in case a free list was accidentally marked due to a stray pointer.
|
||||
|
||||
<H2>Sweep phase</h2>
|
||||
|
||||
At the end of the mark phase, all blocks in the heap are examined.
|
||||
Unmarked large objects are immediately returned to the large object free list.
|
||||
Each small object page is checked to see if all mark bits are clear.
|
||||
If so, the entire page is returned to the large object free list.
|
||||
Small object pages containing some reachable object are queued for later
|
||||
sweeping.
|
||||
<P>
|
||||
This initial sweep pass touches only block headers, not
|
||||
the blocks themselves. Thus it does not require significant paging, even
|
||||
if large sections of the heap are not in physical memory.
|
||||
<P>
|
||||
Nonempty small object pages are swept when an allocation attempt
|
||||
encounters an empty free list for that object size and kind.
|
||||
Pages for the correct size and kind are repeatedly swept until at
|
||||
least one empty block is found. Sweeping such a page involves
|
||||
scanning the mark bit array in the page header, and building a free
|
||||
list linked through the first words in the objects themselves.
|
||||
This does involve touching the appropriate data page, but in most cases
|
||||
it will be touched only just before it is used for allocation.
|
||||
Hence any paging is essentially unavoidable.
|
||||
<P>
|
||||
Except in the case of pointer-free objects, we maintain the invariant
|
||||
that any object in a small object free list is cleared (except possibly
|
||||
for the link field). Thus it becomes the burden of the small object
|
||||
sweep routine to clear objects. This has the advantage that we can
|
||||
easily recover from accidentally marking a free list, though that could
|
||||
also be handled by other means. The collector currently spends a fair
|
||||
amount of time clearing objects, and this approach should probably be
|
||||
revisited.
|
||||
<P>
|
||||
In most configurations, we use specialized sweep routines to handle common
|
||||
small object sizes. Since we allocate one mark bit per word, it becomes
|
||||
easier to examine the relevant mark bits if the object size divides
|
||||
the word length evenly. We also suitably unroll the inner sweep loop
|
||||
in each case. (It is conceivable that profile-based procedure cloning
|
||||
in the compiler could make this unnecessary and counterproductive. I
|
||||
know of no existing compiler to which this applies.)
|
||||
<P>
|
||||
The sweeping of small object pages could be avoided completely at the expense
|
||||
of examining mark bits directly in the allocator. This would probably
|
||||
be more expensive, since each allocation call would have to reload
|
||||
a large amount of state (e.g. next object address to be swept, position
|
||||
in mark bit table) before it could do its work. The current scheme
|
||||
keeps the allocator simple and allows useful optimizations in the sweeper.
|
||||
|
||||
<H2>Finalization</h2>
|
||||
Both <TT>GC_register_disappearing_link</tt> and
|
||||
<TT>GC_register_finalizer</tt> add the request to a corresponding hash
|
||||
table. The hash table is allocated out of collected memory, but
|
||||
the reference to the finalizable object is hidden from the collector.
|
||||
Currently finalization requests are processed non-incrementally at the
|
||||
end of a mark cycle.
|
||||
<P>
|
||||
The collector makes an initial pass over the table of finalizable objects,
|
||||
pushing the contents of unmarked objects onto the mark stack.
|
||||
After pushing each object, the marker is invoked to mark all objects
|
||||
reachable from it. The object itself is not explicitly marked.
|
||||
This assures that objects on which a finalizer depends are neither
|
||||
collected nor finalized.
|
||||
<P>
|
||||
If in the process of marking from an object the
|
||||
object itself becomes marked, we have uncovered
|
||||
a cycle involving the object. This usually results in a warning from the
|
||||
collector. Such objects are not finalized, since it may be
|
||||
unsafe to do so. See the more detailed
|
||||
<A HREF="finalization.html"> discussion of finalization semantics</a>.
|
||||
<P>
|
||||
Any objects remaining unmarked at the end of this process are added to
|
||||
a queue of objects whose finalizers can be run. Depending on collector
|
||||
configuration, finalizers are dequeued and run either implicitly during
|
||||
allocation calls, or explicitly in response to a user request.
|
||||
<P>
|
||||
The collector provides a mechanism for replacing the procedure that is
|
||||
used to mark through objects. This is used both to provide support for
|
||||
Java-style unordered finalization, and to ignore certain kinds of cycles,
|
||||
<I>e.g.</i> those arising from C++ implementations of virtual inheritance.
|
||||
|
||||
<H2>Generational Collection and Dirty Bits</h2>
|
||||
We basically use the parallel and generational GC algorithm described in
|
||||
<A HREF="papers/pldi91.ps.gz">"Mostly Parallel Garbage Collection"</a>,
|
||||
by Boehm, Demers, and Shenker.
|
||||
<P>
|
||||
The most significant modification is that
|
||||
the collector always runs in the allocating thread.
|
||||
There is no separate garbage collector thread.
|
||||
If an allocation attempt either requests a large object, or encounters
|
||||
an empty small object free list, and notices that there is a collection
|
||||
in progress, it immediately performs a small amount of marking work
|
||||
as described above.
|
||||
<P>
|
||||
This change was made both because we wanted to easily accommodate
|
||||
single-threaded environments, and because a separate GC thread requires
|
||||
very careful control over the scheduler to prevent the mutator from
|
||||
out-running the collector, and hence provoking unneeded heap growth.
|
||||
<P>
|
||||
In incremental mode, the heap is always expanded when we encounter
|
||||
insufficient space for an allocation. Garbage collection is triggered
|
||||
whenever we notice that more than
|
||||
<TT>GC_heap_size</tt>/2 * <TT>GC_free_space_divisor</tt>
|
||||
bytes of allocation have taken place.
|
||||
After <TT>GC_full_freq</tt> minor collections a major collection
|
||||
is started.
|
||||
<P>
|
||||
All collections initially run interrupted until a predetermined
|
||||
amount of time (50 msecs by default) has expired. If this allows
|
||||
the collection to complete entirely, we can avoid correcting
|
||||
for data structure modifications during the collection. If it does
|
||||
not complete, we return control to the mutator, and perform small
|
||||
amounts of additional GC work during those later allocations that
|
||||
cannot be satisfied from small object free lists. When marking completes,
|
||||
the set of modified pages is retrieved, and we mark once again from
|
||||
marked objects on those pages, this time with the mutator stopped.
|
||||
<P>
|
||||
We keep track of modified pages using one of three distinct mechanisms:
|
||||
<OL>
|
||||
<LI>
|
||||
Through explicit mutator cooperation. Currently this requires
|
||||
the use of <TT>GC_malloc_stubborn</tt>.
|
||||
<LI>
|
||||
By write-protecting physical pages and catching write faults. This is
|
||||
implemented for many Unix-like systems and for win32. It is not possible
|
||||
in a few environments.
|
||||
<LI>
|
||||
By retrieving dirty bit information from /proc. (Currently only Sun's
|
||||
Solaris supports this. Though this is considerably cleaner, performance
|
||||
may actually be better with mprotect and signals.)
|
||||
</ol>
|
||||
|
||||
<H2>Thread support</h2>
|
||||
We support several different threading models. Unfortunately Pthreads,
|
||||
the only reasonably well standardized thread model, supports too narrow
|
||||
an interface for conservative garbage collection. There appears to be
|
||||
no portable way to allow the collector to coexist with various Pthreads
|
||||
implementations. Hence we currently support only a few of the more
|
||||
common Pthreads implementations.
|
||||
<P>
|
||||
In particular, it is very difficult for the collector to stop all other
|
||||
threads in the system and examine the register contents. This is currently
|
||||
accomplished with very different mechanisms for different Pthreads
|
||||
implementations. The Solaris implementation temporarily disables much
|
||||
of the user-level threads implementation by stopping kernel-level threads
|
||||
("lwp"s). The Irix implementation sends signals to individual Pthreads
|
||||
and has them wait in the signal handler. The Linux implementation
|
||||
is similar in spirit to the Irix one.
|
||||
<P>
|
||||
The Irix implementation uses
|
||||
only documented Pthreads calls, but relies on extensions to their semantics,
|
||||
notably the use of mutexes and condition variables from signal
|
||||
handlers. The Linux implementation should be far closer to
|
||||
portable, though impirically it is not completely portable.
|
||||
<P>
|
||||
All implementations must
|
||||
intercept thread creation and a few other thread-specific calls to allow
|
||||
enumeration of threads and location of thread stacks. This is current
|
||||
accomplished with <TT># define</tt>'s in <TT>gc.h</tt>, or optionally
|
||||
by using ld's function call wrapping mechanism under Linux.
|
||||
<P>
|
||||
Comments are appreciated. Please send mail to
|
||||
<A HREF="mailto:boehm@acm.org"><TT>boehm@acm.org</tt></a>
|
||||
</body>
|
||||
@@ -1,198 +0,0 @@
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<TITLE> Two-Level Tree Structure for Fast Pointer Lookup</TITLE>
|
||||
<AUTHOR> Hans-J. Boehm, Silicon Graphics</author>
|
||||
</HEAD>
|
||||
<BODY>
|
||||
<H1>Two-Level Tree Structure for Fast Pointer Lookup</h1>
|
||||
<P>
|
||||
The conservative garbage collector described
|
||||
<A HREF="gc.html">here</a> uses a 2-level tree
|
||||
data structure to aid in fast pointer identification.
|
||||
This data structure is described in a bit more detail here, since
|
||||
<OL>
|
||||
<LI> Variations of the data structure are more generally useful.
|
||||
<LI> It appears to be hard to understand by reading the code.
|
||||
<LI> Some other collectors appear to use inferior data structures to
|
||||
solve the same problem.
|
||||
<LI> It is central to fast collector operation.
|
||||
</ol>
|
||||
A candidate pointer is divided into three sections, the <I>high</i>,
|
||||
<I>middle</i>, and <I>low</i> bits. The exact division between these
|
||||
three groups of bits is dependent on the detailed collector configuration.
|
||||
<P>
|
||||
The high and middle bits are used to look up an entry in the table described
|
||||
here. The resulting table entry consists of either a block descriptor
|
||||
(<TT>struct hblkhdr *</tt> or <TT>hdr *</tt>)
|
||||
identifying the layout of objects in the block, or an indication that this
|
||||
address range corresponds to the middle of a large block, together with a
|
||||
hint for locating the actual block descriptor. Such a hint consist
|
||||
of a displacement that can be subtracted from the middle bits of the candidate
|
||||
pointer without leaving the object.
|
||||
<P>
|
||||
In either case, the block descriptor (<TT>struct hblkhdr</tt>)
|
||||
refers to a table of object starting addresses (the <TT>hb_map</tt> field).
|
||||
The starting address table is indexed by the low bits if the candidate pointer.
|
||||
The resulting entry contains a displacement to the beginning of the object,
|
||||
or an indication that this cannot be a valid object pointer.
|
||||
(If all interior pointer are recognized, pointers into large objects
|
||||
are handled specially, as appropriate.)
|
||||
|
||||
<H2>The Tree</h2>
|
||||
<P>
|
||||
The rest of this discussion focuses on the two level data structure
|
||||
used to map the high and middle bits to the block descriptor.
|
||||
<P>
|
||||
The high bits are used as an index into the <TT>GC_top_index</tt> (really
|
||||
<TT>GC_arrays._top_index</tt>) array. Each entry points to a
|
||||
<TT>bottom_index</tt> data structure. This structure in turn consists
|
||||
mostly of an array <TT>index</tt> indexed by the middle bits of
|
||||
the candidate pointer. The <TT>index</tt> array contains the actual
|
||||
<TT>hdr</tt> pointers.
|
||||
<P>
|
||||
Thus a pointer lookup consists primarily of a handful of memory references,
|
||||
and can be quite fast:
|
||||
<OL>
|
||||
<LI> The appropriate <TT>bottom_index</tt> pointer is looked up in
|
||||
<TT>GC_top_index</tt>, based on the high bits of the candidate pointer.
|
||||
<LI> The appropriate <TT>hdr</tt> pointer is looked up in the
|
||||
<TT>bottom_index</tt> structure, based on the middle bits.
|
||||
<LI> The block layout map pointer is retrieved from the <TT>hdr</tt>
|
||||
structure. (This memory reference is necessary since we try to share
|
||||
block layout maps.)
|
||||
<LI> The displacement to the beginning of the object is retrieved from the
|
||||
above map.
|
||||
</ol>
|
||||
<P>
|
||||
In order to conserve space, not all <TT>GC_top_index</tt> entries in fact
|
||||
point to distinct <TT>bottom_index</tt> structures. If no address with
|
||||
the corresponding high bits is part of the heap, then the entry points
|
||||
to <TT>GC_all_nils</tt>, a single <TT>bottom_index</tt> structure consisting
|
||||
only of NULL <TT>hdr</tt> pointers.
|
||||
<P>
|
||||
<TT>Bottom_index</tt> structures contain slightly more information than
|
||||
just <TT>hdr</tt> pointers. The <TT>asc_link</tt> field is used to link
|
||||
all <TT>bottom_index</tt> structures in ascending order for fast traversal.
|
||||
This list is pointed to be <TT>GC_all_bottom_indices</tt>.
|
||||
It is maintained with the aid of <TT>key</tt> field that contains the
|
||||
high bits corresponding to the <TT>bottom_index</tt>.
|
||||
|
||||
<H2>64 bit addresses</h2>
|
||||
<P>
|
||||
In the case of 64 bit addresses, this picture is complicated slightly
|
||||
by the fact that one of the index structures would have to be huge to
|
||||
cover the entire address space with a two level tree. We deal with this
|
||||
by turning <TT>GC_top_index</tt> into a chained hash table, instead of
|
||||
a simple array. This adds a <TT>hash_link</tt> field to the
|
||||
<TT>bottom_index</tt> structure.
|
||||
<P>
|
||||
The "hash function" consists of dropping the high bits. This is cheap to
|
||||
compute, and guarantees that there will be no collisions if the heap
|
||||
is contiguous and not excessively large.
|
||||
|
||||
<H2>A picture</h2>
|
||||
<P>
|
||||
The following is an ASCII diagram of the data structure.
|
||||
This was contributed by Dave Barrett several years ago.
|
||||
<PRE>
|
||||
|
||||
Data Structure used by GC_base in gc3.7:
|
||||
21-Apr-94
|
||||
|
||||
|
||||
|
||||
|
||||
63 LOG_TOP_SZ[11] LOG_BOTTOM_SZ[10] LOG_HBLKSIZE[13]
|
||||
+------------------+----------------+------------------+------------------+
|
||||
p:| | TL_HASH(hi) | | HBLKDISPL(p) |
|
||||
+------------------+----------------+------------------+------------------+
|
||||
\-----------------------HBLKPTR(p)-------------------/
|
||||
\------------hi-------------------/
|
||||
\______ ________/ \________ _______/ \________ _______/
|
||||
V V V
|
||||
| | |
|
||||
GC_top_index[] | | |
|
||||
--- +--------------+ | | |
|
||||
^ | | | | |
|
||||
| | | | | |
|
||||
TOP +--------------+<--+ | |
|
||||
_SZ +-<| [] | * | |
|
||||
(items)| +--------------+ if 0 < bi< HBLKSIZE | |
|
||||
| | | | then large object | |
|
||||
| | | | starts at the bi'th | |
|
||||
v | | | HBLK before p. | i |
|
||||
--- | +--------------+ | (word- |
|
||||
v | aligned) |
|
||||
bi= |GET_BI(p){->hash_link}->key==hi | |
|
||||
v | |
|
||||
| (bottom_index) \ scratch_alloc'd | |
|
||||
| ( struct bi ) / by get_index() | |
|
||||
--- +->+--------------+ | |
|
||||
^ | | | |
|
||||
^ | | | |
|
||||
BOTTOM | | ha=GET_HDR_ADDR(p) | |
|
||||
_SZ(items)+--------------+<----------------------+ +-------+
|
||||
| +--<| index[] | |
|
||||
| | +--------------+ GC_obj_map: v
|
||||
| | | | from / +-+-+-----+-+-+-+-+ ---
|
||||
v | | | GC_add < 0| | | | | | | | ^
|
||||
--- | +--------------+ _map_entry \ +-+-+-----+-+-+-+-+ |
|
||||
| | asc_link | +-+-+-----+-+-+-+-+ MAXOBJSZ
|
||||
| +--------------+ +-->| | | j | | | | | +1
|
||||
| | key | | +-+-+-----+-+-+-+-+ |
|
||||
| +--------------+ | +-+-+-----+-+-+-+-+ |
|
||||
| | hash_link | | | | | | | | | | v
|
||||
| +--------------+ | +-+-+-----+-+-+-+-+ ---
|
||||
| | |<--MAX_OFFSET--->|
|
||||
| | (bytes)
|
||||
HDR(p)| GC_find_header(p) | |<--MAP_ENTRIES-->|
|
||||
| \ from | =HBLKSIZE/WORDSZ
|
||||
| (hdr) (struct hblkhdr) / alloc_hdr() | (1024 on Alpha)
|
||||
+-->+----------------------+ | (8/16 bits each)
|
||||
GET_HDR(p)| word hb_sz (words) | |
|
||||
+----------------------+ |
|
||||
| struct hblk *hb_next | |
|
||||
+----------------------+ |
|
||||
|mark_proc hb_mark_proc| |
|
||||
+----------------------+ |
|
||||
| char * hb_map |>-------------+
|
||||
+----------------------+
|
||||
| ushort hb_obj_kind |
|
||||
+----------------------+
|
||||
| hb_last_reclaimed |
|
||||
--- +----------------------+
|
||||
^ | |
|
||||
MARK_BITS| hb_marks[] | *if hdr is free, hb_sz + DISCARD_WORDS
|
||||
_SZ(words)| | is the size of a heap chunk (struct hblk)
|
||||
v | | of at least MININCR*HBLKSIZE bytes (below),
|
||||
--- +----------------------+ otherwise, size of each object in chunk.
|
||||
|
||||
Dynamic data structures above are interleaved throughout the heap in blocks of
|
||||
size MININCR * HBLKSIZE bytes as done by gc_scratch_alloc which cannot be
|
||||
freed; free lists are used (e.g. alloc_hdr). HBLK's below are collected.
|
||||
|
||||
(struct hblk)
|
||||
--- +----------------------+ < HBLKSIZE --- --- DISCARD_
|
||||
^ |garbage[DISCARD_WORDS]| aligned ^ ^ HDR_BYTES WORDS
|
||||
| | | | v (bytes) (words)
|
||||
| +-----hb_body----------+ < WORDSZ | --- ---
|
||||
| | | aligned | ^ ^
|
||||
| | Object 0 | | hb_sz |
|
||||
| | | i |(word- (words)|
|
||||
| | | (bytes)|aligned) v |
|
||||
| + - - - - - - - - - - -+ --- | --- |
|
||||
| | | ^ | ^ |
|
||||
n * | | j (words) | hb_sz BODY_SZ
|
||||
HBLKSIZE | Object 1 | v v | (words)
|
||||
(bytes) | |--------------- v MAX_OFFSET
|
||||
| + - - - - - - - - - - -+ --- (bytes)
|
||||
| | | !All_INTERIOR_PTRS ^ |
|
||||
| | | sets j only for hb_sz |
|
||||
| | Object N | valid object offsets. | |
|
||||
v | | All objects WORDSZ v v
|
||||
--- +----------------------+ aligned. --- ---
|
||||
|
||||
DISCARD_WORDS is normally zero. Indeed the collector has not been tested
|
||||
with another value in ages.
|
||||
</pre>
|
||||
</body>
|
||||
1077
boehm-gc/dyn_load.c
1077
boehm-gc/dyn_load.c
File diff suppressed because it is too large
Load Diff
@@ -1,840 +0,0 @@
|
||||
/*
|
||||
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
|
||||
* Copyright (c) 1991-1996 by Xerox Corporation. All rights reserved.
|
||||
* Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved.
|
||||
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
/* Boehm, February 1, 1996 1:19 pm PST */
|
||||
# define I_HIDE_POINTERS
|
||||
# include "private/gc_pmark.h"
|
||||
|
||||
# ifdef FINALIZE_ON_DEMAND
|
||||
int GC_finalize_on_demand = 1;
|
||||
# else
|
||||
int GC_finalize_on_demand = 0;
|
||||
# endif
|
||||
|
||||
# ifdef JAVA_FINALIZATION
|
||||
int GC_java_finalization = 1;
|
||||
# else
|
||||
int GC_java_finalization = 0;
|
||||
# endif
|
||||
|
||||
/* Type of mark procedure used for marking from finalizable object. */
|
||||
/* This procedure normally does not mark the object, only its */
|
||||
/* descendents. */
|
||||
typedef void finalization_mark_proc(/* ptr_t finalizable_obj_ptr */);
|
||||
|
||||
# define HASH3(addr,size,log_size) \
|
||||
((((word)(addr) >> 3) ^ ((word)(addr) >> (3+(log_size)))) \
|
||||
& ((size) - 1))
|
||||
#define HASH2(addr,log_size) HASH3(addr, 1 << log_size, log_size)
|
||||
|
||||
struct hash_chain_entry {
|
||||
word hidden_key;
|
||||
struct hash_chain_entry * next;
|
||||
};
|
||||
|
||||
unsigned GC_finalization_failures = 0;
|
||||
/* Number of finalization requests that failed for lack of memory. */
|
||||
|
||||
static struct disappearing_link {
|
||||
struct hash_chain_entry prolog;
|
||||
# define dl_hidden_link prolog.hidden_key
|
||||
/* Field to be cleared. */
|
||||
# define dl_next(x) (struct disappearing_link *)((x) -> prolog.next)
|
||||
# define dl_set_next(x,y) (x) -> prolog.next = (struct hash_chain_entry *)(y)
|
||||
|
||||
word dl_hidden_obj; /* Pointer to object base */
|
||||
} **dl_head = 0;
|
||||
|
||||
static signed_word log_dl_table_size = -1;
|
||||
/* Binary log of */
|
||||
/* current size of array pointed to by dl_head. */
|
||||
/* -1 ==> size is 0. */
|
||||
|
||||
word GC_dl_entries = 0; /* Number of entries currently in disappearing */
|
||||
/* link table. */
|
||||
|
||||
static struct finalizable_object {
|
||||
struct hash_chain_entry prolog;
|
||||
# define fo_hidden_base prolog.hidden_key
|
||||
/* Pointer to object base. */
|
||||
/* No longer hidden once object */
|
||||
/* is on finalize_now queue. */
|
||||
# define fo_next(x) (struct finalizable_object *)((x) -> prolog.next)
|
||||
# define fo_set_next(x,y) (x) -> prolog.next = (struct hash_chain_entry *)(y)
|
||||
GC_finalization_proc fo_fn; /* Finalizer. */
|
||||
ptr_t fo_client_data;
|
||||
word fo_object_size; /* In bytes. */
|
||||
finalization_mark_proc * fo_mark_proc; /* Mark-through procedure */
|
||||
} **fo_head = 0;
|
||||
|
||||
struct finalizable_object * GC_finalize_now = 0;
|
||||
/* LIst of objects that should be finalized now. */
|
||||
|
||||
static signed_word log_fo_table_size = -1;
|
||||
|
||||
word GC_fo_entries = 0;
|
||||
|
||||
void GC_push_finalizer_structures GC_PROTO((void))
|
||||
{
|
||||
GC_push_all((ptr_t)(&dl_head), (ptr_t)(&dl_head) + sizeof(word));
|
||||
GC_push_all((ptr_t)(&fo_head), (ptr_t)(&fo_head) + sizeof(word));
|
||||
GC_push_all((ptr_t)(&GC_finalize_now),
|
||||
(ptr_t)(&GC_finalize_now) + sizeof(word));
|
||||
}
|
||||
|
||||
/* Double the size of a hash table. *size_ptr is the log of its current */
|
||||
/* size. May be a noop. */
|
||||
/* *table is a pointer to an array of hash headers. If we succeed, we */
|
||||
/* update both *table and *log_size_ptr. */
|
||||
/* Lock is held. Signals are disabled. */
|
||||
void GC_grow_table(table, log_size_ptr)
|
||||
struct hash_chain_entry ***table;
|
||||
signed_word * log_size_ptr;
|
||||
{
|
||||
register word i;
|
||||
register struct hash_chain_entry *p;
|
||||
int log_old_size = *log_size_ptr;
|
||||
register int log_new_size = log_old_size + 1;
|
||||
word old_size = ((log_old_size == -1)? 0: (1 << log_old_size));
|
||||
register word new_size = 1 << log_new_size;
|
||||
struct hash_chain_entry **new_table = (struct hash_chain_entry **)
|
||||
GC_INTERNAL_MALLOC_IGNORE_OFF_PAGE(
|
||||
(size_t)new_size * sizeof(struct hash_chain_entry *), NORMAL);
|
||||
|
||||
if (new_table == 0) {
|
||||
if (table == 0) {
|
||||
ABORT("Insufficient space for initial table allocation");
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
}
|
||||
for (i = 0; i < old_size; i++) {
|
||||
p = (*table)[i];
|
||||
while (p != 0) {
|
||||
register ptr_t real_key = (ptr_t)REVEAL_POINTER(p -> hidden_key);
|
||||
register struct hash_chain_entry *next = p -> next;
|
||||
register int new_hash = HASH3(real_key, new_size, log_new_size);
|
||||
|
||||
p -> next = new_table[new_hash];
|
||||
new_table[new_hash] = p;
|
||||
p = next;
|
||||
}
|
||||
}
|
||||
*log_size_ptr = log_new_size;
|
||||
*table = new_table;
|
||||
}
|
||||
|
||||
# if defined(__STDC__) || defined(__cplusplus)
|
||||
int GC_register_disappearing_link(GC_PTR * link)
|
||||
# else
|
||||
int GC_register_disappearing_link(link)
|
||||
GC_PTR * link;
|
||||
# endif
|
||||
{
|
||||
ptr_t base;
|
||||
|
||||
base = (ptr_t)GC_base((GC_PTR)link);
|
||||
if (base == 0)
|
||||
ABORT("Bad arg to GC_register_disappearing_link");
|
||||
return(GC_general_register_disappearing_link(link, base));
|
||||
}
|
||||
|
||||
# if defined(__STDC__) || defined(__cplusplus)
|
||||
int GC_general_register_disappearing_link(GC_PTR * link,
|
||||
GC_PTR obj)
|
||||
# else
|
||||
int GC_general_register_disappearing_link(link, obj)
|
||||
GC_PTR * link;
|
||||
GC_PTR obj;
|
||||
# endif
|
||||
|
||||
{
|
||||
struct disappearing_link *curr_dl;
|
||||
int index;
|
||||
struct disappearing_link * new_dl;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
if ((word)link & (ALIGNMENT-1))
|
||||
ABORT("Bad arg to GC_general_register_disappearing_link");
|
||||
# ifdef THREADS
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
# endif
|
||||
if (log_dl_table_size == -1
|
||||
|| GC_dl_entries > ((word)1 << log_dl_table_size)) {
|
||||
# ifndef THREADS
|
||||
DISABLE_SIGNALS();
|
||||
# endif
|
||||
GC_grow_table((struct hash_chain_entry ***)(&dl_head),
|
||||
&log_dl_table_size);
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf1("Grew dl table to %lu entries\n",
|
||||
(unsigned long)(1 << log_dl_table_size));
|
||||
}
|
||||
# endif
|
||||
# ifndef THREADS
|
||||
ENABLE_SIGNALS();
|
||||
# endif
|
||||
}
|
||||
index = HASH2(link, log_dl_table_size);
|
||||
curr_dl = dl_head[index];
|
||||
for (curr_dl = dl_head[index]; curr_dl != 0; curr_dl = dl_next(curr_dl)) {
|
||||
if (curr_dl -> dl_hidden_link == HIDE_POINTER(link)) {
|
||||
curr_dl -> dl_hidden_obj = HIDE_POINTER(obj);
|
||||
# ifdef THREADS
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
# endif
|
||||
return(1);
|
||||
}
|
||||
}
|
||||
new_dl = (struct disappearing_link *)
|
||||
GC_INTERNAL_MALLOC(sizeof(struct disappearing_link),NORMAL);
|
||||
if (0 == new_dl) {
|
||||
# ifdef THREADS
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
# endif
|
||||
new_dl = GC_oom_fn(sizeof(struct disappearing_link));
|
||||
if (0 == new_dl) {
|
||||
GC_finalization_failures++;
|
||||
return(0);
|
||||
}
|
||||
/* It's not likely we'll make it here, but ... */
|
||||
# ifdef THREADS
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
# endif
|
||||
}
|
||||
new_dl -> dl_hidden_obj = HIDE_POINTER(obj);
|
||||
new_dl -> dl_hidden_link = HIDE_POINTER(link);
|
||||
dl_set_next(new_dl, dl_head[index]);
|
||||
dl_head[index] = new_dl;
|
||||
GC_dl_entries++;
|
||||
# ifdef THREADS
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
# endif
|
||||
return(0);
|
||||
}
|
||||
|
||||
# if defined(__STDC__) || defined(__cplusplus)
|
||||
int GC_unregister_disappearing_link(GC_PTR * link)
|
||||
# else
|
||||
int GC_unregister_disappearing_link(link)
|
||||
GC_PTR * link;
|
||||
# endif
|
||||
{
|
||||
struct disappearing_link *curr_dl, *prev_dl;
|
||||
int index;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
index = HASH2(link, log_dl_table_size);
|
||||
if (((unsigned long)link & (ALIGNMENT-1))) goto out;
|
||||
prev_dl = 0; curr_dl = dl_head[index];
|
||||
while (curr_dl != 0) {
|
||||
if (curr_dl -> dl_hidden_link == HIDE_POINTER(link)) {
|
||||
if (prev_dl == 0) {
|
||||
dl_head[index] = dl_next(curr_dl);
|
||||
} else {
|
||||
dl_set_next(prev_dl, dl_next(curr_dl));
|
||||
}
|
||||
GC_dl_entries--;
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
# ifdef DBG_HDRS_ALL
|
||||
dl_set_next(curr_dl, 0);
|
||||
# else
|
||||
GC_free((GC_PTR)curr_dl);
|
||||
# endif
|
||||
return(1);
|
||||
}
|
||||
prev_dl = curr_dl;
|
||||
curr_dl = dl_next(curr_dl);
|
||||
}
|
||||
out:
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Possible finalization_marker procedures. Note that mark stack */
|
||||
/* overflow is handled by the caller, and is not a disaster. */
|
||||
GC_API void GC_normal_finalize_mark_proc(p)
|
||||
ptr_t p;
|
||||
{
|
||||
hdr * hhdr = HDR(p);
|
||||
|
||||
PUSH_OBJ((word *)p, hhdr, GC_mark_stack_top,
|
||||
&(GC_mark_stack[GC_mark_stack_size]));
|
||||
}
|
||||
|
||||
/* This only pays very partial attention to the mark descriptor. */
|
||||
/* It does the right thing for normal and atomic objects, and treats */
|
||||
/* most others as normal. */
|
||||
GC_API void GC_ignore_self_finalize_mark_proc(p)
|
||||
ptr_t p;
|
||||
{
|
||||
hdr * hhdr = HDR(p);
|
||||
word descr = hhdr -> hb_descr;
|
||||
ptr_t q, r;
|
||||
ptr_t scan_limit;
|
||||
ptr_t target_limit = p + WORDS_TO_BYTES(hhdr -> hb_sz) - 1;
|
||||
|
||||
if ((descr & GC_DS_TAGS) == GC_DS_LENGTH) {
|
||||
scan_limit = p + descr - sizeof(word);
|
||||
} else {
|
||||
scan_limit = target_limit + 1 - sizeof(word);
|
||||
}
|
||||
for (q = p; q <= scan_limit; q += ALIGNMENT) {
|
||||
r = *(ptr_t *)q;
|
||||
if (r < p || r > target_limit) {
|
||||
GC_PUSH_ONE_HEAP((word)r, q);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
GC_API void GC_null_finalize_mark_proc(p)
|
||||
ptr_t p;
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Register a finalization function. See gc.h for details. */
|
||||
/* in the nonthreads case, we try to avoid disabling signals, */
|
||||
/* since it can be expensive. Threads packages typically */
|
||||
/* make it cheaper. */
|
||||
/* The last parameter is a procedure that determines */
|
||||
/* marking for finalization ordering. Any objects marked */
|
||||
/* by that procedure will be guaranteed to not have been */
|
||||
/* finalized when this finalizer is invoked. */
|
||||
GC_API void GC_register_finalizer_inner(obj, fn, cd, ofn, ocd, mp)
|
||||
GC_PTR obj;
|
||||
GC_finalization_proc fn;
|
||||
GC_PTR cd;
|
||||
GC_finalization_proc * ofn;
|
||||
GC_PTR * ocd;
|
||||
finalization_mark_proc * mp;
|
||||
{
|
||||
ptr_t base;
|
||||
struct finalizable_object * curr_fo, * prev_fo;
|
||||
int index;
|
||||
struct finalizable_object *new_fo;
|
||||
hdr *hhdr;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
# ifdef THREADS
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
# endif
|
||||
if (log_fo_table_size == -1
|
||||
|| GC_fo_entries > ((word)1 << log_fo_table_size)) {
|
||||
# ifndef THREADS
|
||||
DISABLE_SIGNALS();
|
||||
# endif
|
||||
GC_grow_table((struct hash_chain_entry ***)(&fo_head),
|
||||
&log_fo_table_size);
|
||||
# ifdef CONDPRINT
|
||||
if (GC_print_stats) {
|
||||
GC_printf1("Grew fo table to %lu entries\n",
|
||||
(unsigned long)(1 << log_fo_table_size));
|
||||
}
|
||||
# endif
|
||||
# ifndef THREADS
|
||||
ENABLE_SIGNALS();
|
||||
# endif
|
||||
}
|
||||
/* in the THREADS case signals are disabled and we hold allocation */
|
||||
/* lock; otherwise neither is true. Proceed carefully. */
|
||||
base = (ptr_t)obj;
|
||||
index = HASH2(base, log_fo_table_size);
|
||||
prev_fo = 0; curr_fo = fo_head[index];
|
||||
while (curr_fo != 0) {
|
||||
if (curr_fo -> fo_hidden_base == HIDE_POINTER(base)) {
|
||||
/* Interruption by a signal in the middle of this */
|
||||
/* should be safe. The client may see only *ocd */
|
||||
/* updated, but we'll declare that to be his */
|
||||
/* problem. */
|
||||
if (ocd) *ocd = (GC_PTR) curr_fo -> fo_client_data;
|
||||
if (ofn) *ofn = curr_fo -> fo_fn;
|
||||
/* Delete the structure for base. */
|
||||
if (prev_fo == 0) {
|
||||
fo_head[index] = fo_next(curr_fo);
|
||||
} else {
|
||||
fo_set_next(prev_fo, fo_next(curr_fo));
|
||||
}
|
||||
if (fn == 0) {
|
||||
GC_fo_entries--;
|
||||
/* May not happen if we get a signal. But a high */
|
||||
/* estimate will only make the table larger than */
|
||||
/* necessary. */
|
||||
# if !defined(THREADS) && !defined(DBG_HDRS_ALL)
|
||||
GC_free((GC_PTR)curr_fo);
|
||||
# endif
|
||||
} else {
|
||||
curr_fo -> fo_fn = fn;
|
||||
curr_fo -> fo_client_data = (ptr_t)cd;
|
||||
curr_fo -> fo_mark_proc = mp;
|
||||
/* Reinsert it. We deleted it first to maintain */
|
||||
/* consistency in the event of a signal. */
|
||||
if (prev_fo == 0) {
|
||||
fo_head[index] = curr_fo;
|
||||
} else {
|
||||
fo_set_next(prev_fo, curr_fo);
|
||||
}
|
||||
}
|
||||
# ifdef THREADS
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
# endif
|
||||
return;
|
||||
}
|
||||
prev_fo = curr_fo;
|
||||
curr_fo = fo_next(curr_fo);
|
||||
}
|
||||
if (ofn) *ofn = 0;
|
||||
if (ocd) *ocd = 0;
|
||||
if (fn == 0) {
|
||||
# ifdef THREADS
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
# endif
|
||||
return;
|
||||
}
|
||||
GET_HDR(base, hhdr);
|
||||
if (0 == hhdr) {
|
||||
/* We won't collect it, hence finalizer wouldn't be run. */
|
||||
# ifdef THREADS
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
# endif
|
||||
return;
|
||||
}
|
||||
new_fo = (struct finalizable_object *)
|
||||
GC_INTERNAL_MALLOC(sizeof(struct finalizable_object),NORMAL);
|
||||
if (0 == new_fo) {
|
||||
# ifdef THREADS
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
# endif
|
||||
new_fo = GC_oom_fn(sizeof(struct finalizable_object));
|
||||
if (0 == new_fo) {
|
||||
GC_finalization_failures++;
|
||||
return;
|
||||
}
|
||||
/* It's not likely we'll make it here, but ... */
|
||||
# ifdef THREADS
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
# endif
|
||||
}
|
||||
new_fo -> fo_hidden_base = (word)HIDE_POINTER(base);
|
||||
new_fo -> fo_fn = fn;
|
||||
new_fo -> fo_client_data = (ptr_t)cd;
|
||||
new_fo -> fo_object_size = hhdr -> hb_sz;
|
||||
new_fo -> fo_mark_proc = mp;
|
||||
fo_set_next(new_fo, fo_head[index]);
|
||||
GC_fo_entries++;
|
||||
fo_head[index] = new_fo;
|
||||
# ifdef THREADS
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
# endif
|
||||
}
|
||||
|
||||
# if defined(__STDC__)
|
||||
void GC_register_finalizer(void * obj,
|
||||
GC_finalization_proc fn, void * cd,
|
||||
GC_finalization_proc *ofn, void ** ocd)
|
||||
# else
|
||||
void GC_register_finalizer(obj, fn, cd, ofn, ocd)
|
||||
GC_PTR obj;
|
||||
GC_finalization_proc fn;
|
||||
GC_PTR cd;
|
||||
GC_finalization_proc * ofn;
|
||||
GC_PTR * ocd;
|
||||
# endif
|
||||
{
|
||||
GC_register_finalizer_inner(obj, fn, cd, ofn,
|
||||
ocd, GC_normal_finalize_mark_proc);
|
||||
}
|
||||
|
||||
# if defined(__STDC__)
|
||||
void GC_register_finalizer_ignore_self(void * obj,
|
||||
GC_finalization_proc fn, void * cd,
|
||||
GC_finalization_proc *ofn, void ** ocd)
|
||||
# else
|
||||
void GC_register_finalizer_ignore_self(obj, fn, cd, ofn, ocd)
|
||||
GC_PTR obj;
|
||||
GC_finalization_proc fn;
|
||||
GC_PTR cd;
|
||||
GC_finalization_proc * ofn;
|
||||
GC_PTR * ocd;
|
||||
# endif
|
||||
{
|
||||
GC_register_finalizer_inner(obj, fn, cd, ofn,
|
||||
ocd, GC_ignore_self_finalize_mark_proc);
|
||||
}
|
||||
|
||||
# if defined(__STDC__)
|
||||
void GC_register_finalizer_no_order(void * obj,
|
||||
GC_finalization_proc fn, void * cd,
|
||||
GC_finalization_proc *ofn, void ** ocd)
|
||||
# else
|
||||
void GC_register_finalizer_no_order(obj, fn, cd, ofn, ocd)
|
||||
GC_PTR obj;
|
||||
GC_finalization_proc fn;
|
||||
GC_PTR cd;
|
||||
GC_finalization_proc * ofn;
|
||||
GC_PTR * ocd;
|
||||
# endif
|
||||
{
|
||||
GC_register_finalizer_inner(obj, fn, cd, ofn,
|
||||
ocd, GC_null_finalize_mark_proc);
|
||||
}
|
||||
|
||||
#ifndef NO_DEBUGGING
|
||||
void GC_dump_finalization()
|
||||
{
|
||||
struct disappearing_link * curr_dl;
|
||||
struct finalizable_object * curr_fo;
|
||||
ptr_t real_ptr, real_link;
|
||||
int dl_size = (log_dl_table_size == -1 ) ? 0 : (1 << log_dl_table_size);
|
||||
int fo_size = (log_fo_table_size == -1 ) ? 0 : (1 << log_fo_table_size);
|
||||
int i;
|
||||
|
||||
GC_printf0("Disappearing links:\n");
|
||||
for (i = 0; i < dl_size; i++) {
|
||||
for (curr_dl = dl_head[i]; curr_dl != 0; curr_dl = dl_next(curr_dl)) {
|
||||
real_ptr = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_obj);
|
||||
real_link = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_link);
|
||||
GC_printf2("Object: 0x%lx, Link:0x%lx\n", real_ptr, real_link);
|
||||
}
|
||||
}
|
||||
GC_printf0("Finalizers:\n");
|
||||
for (i = 0; i < fo_size; i++) {
|
||||
for (curr_fo = fo_head[i]; curr_fo != 0; curr_fo = fo_next(curr_fo)) {
|
||||
real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
|
||||
GC_printf1("Finalizable object: 0x%lx\n", real_ptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Called with world stopped. Cause disappearing links to disappear, */
|
||||
/* and invoke finalizers. */
|
||||
void GC_finalize()
|
||||
{
|
||||
struct disappearing_link * curr_dl, * prev_dl, * next_dl;
|
||||
struct finalizable_object * curr_fo, * prev_fo, * next_fo;
|
||||
ptr_t real_ptr, real_link;
|
||||
register int i;
|
||||
int dl_size = (log_dl_table_size == -1 ) ? 0 : (1 << log_dl_table_size);
|
||||
int fo_size = (log_fo_table_size == -1 ) ? 0 : (1 << log_fo_table_size);
|
||||
|
||||
/* Make disappearing links disappear */
|
||||
for (i = 0; i < dl_size; i++) {
|
||||
curr_dl = dl_head[i];
|
||||
prev_dl = 0;
|
||||
while (curr_dl != 0) {
|
||||
real_ptr = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_obj);
|
||||
real_link = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_link);
|
||||
if (!GC_is_marked(real_ptr)) {
|
||||
*(word *)real_link = 0;
|
||||
next_dl = dl_next(curr_dl);
|
||||
if (prev_dl == 0) {
|
||||
dl_head[i] = next_dl;
|
||||
} else {
|
||||
dl_set_next(prev_dl, next_dl);
|
||||
}
|
||||
GC_clear_mark_bit((ptr_t)curr_dl);
|
||||
GC_dl_entries--;
|
||||
curr_dl = next_dl;
|
||||
} else {
|
||||
prev_dl = curr_dl;
|
||||
curr_dl = dl_next(curr_dl);
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Mark all objects reachable via chains of 1 or more pointers */
|
||||
/* from finalizable objects. */
|
||||
GC_ASSERT(GC_mark_state == MS_NONE);
|
||||
for (i = 0; i < fo_size; i++) {
|
||||
for (curr_fo = fo_head[i]; curr_fo != 0; curr_fo = fo_next(curr_fo)) {
|
||||
real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
|
||||
if (!GC_is_marked(real_ptr)) {
|
||||
GC_MARKED_FOR_FINALIZATION(real_ptr);
|
||||
GC_MARK_FO(real_ptr, curr_fo -> fo_mark_proc);
|
||||
if (GC_is_marked(real_ptr)) {
|
||||
WARN("Finalization cycle involving %lx\n", real_ptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/* Enqueue for finalization all objects that are still */
|
||||
/* unreachable. */
|
||||
GC_words_finalized = 0;
|
||||
for (i = 0; i < fo_size; i++) {
|
||||
curr_fo = fo_head[i];
|
||||
prev_fo = 0;
|
||||
while (curr_fo != 0) {
|
||||
real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
|
||||
if (!GC_is_marked(real_ptr)) {
|
||||
if (!GC_java_finalization) {
|
||||
GC_set_mark_bit(real_ptr);
|
||||
}
|
||||
/* Delete from hash table */
|
||||
next_fo = fo_next(curr_fo);
|
||||
if (prev_fo == 0) {
|
||||
fo_head[i] = next_fo;
|
||||
} else {
|
||||
fo_set_next(prev_fo, next_fo);
|
||||
}
|
||||
GC_fo_entries--;
|
||||
/* Add to list of objects awaiting finalization. */
|
||||
fo_set_next(curr_fo, GC_finalize_now);
|
||||
GC_finalize_now = curr_fo;
|
||||
/* unhide object pointer so any future collections will */
|
||||
/* see it. */
|
||||
curr_fo -> fo_hidden_base =
|
||||
(word) REVEAL_POINTER(curr_fo -> fo_hidden_base);
|
||||
GC_words_finalized +=
|
||||
ALIGNED_WORDS(curr_fo -> fo_object_size)
|
||||
+ ALIGNED_WORDS(sizeof(struct finalizable_object));
|
||||
GC_ASSERT(GC_is_marked(GC_base((ptr_t)curr_fo)));
|
||||
curr_fo = next_fo;
|
||||
} else {
|
||||
prev_fo = curr_fo;
|
||||
curr_fo = fo_next(curr_fo);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (GC_java_finalization) {
|
||||
/* make sure we mark everything reachable from objects finalized
|
||||
using the no_order mark_proc */
|
||||
for (curr_fo = GC_finalize_now;
|
||||
curr_fo != NULL; curr_fo = fo_next(curr_fo)) {
|
||||
real_ptr = (ptr_t)curr_fo -> fo_hidden_base;
|
||||
if (!GC_is_marked(real_ptr)) {
|
||||
if (curr_fo -> fo_mark_proc == GC_null_finalize_mark_proc) {
|
||||
GC_MARK_FO(real_ptr, GC_normal_finalize_mark_proc);
|
||||
}
|
||||
GC_set_mark_bit(real_ptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Remove dangling disappearing links. */
|
||||
for (i = 0; i < dl_size; i++) {
|
||||
curr_dl = dl_head[i];
|
||||
prev_dl = 0;
|
||||
while (curr_dl != 0) {
|
||||
real_link = GC_base((ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_link));
|
||||
if (real_link != 0 && !GC_is_marked(real_link)) {
|
||||
next_dl = dl_next(curr_dl);
|
||||
if (prev_dl == 0) {
|
||||
dl_head[i] = next_dl;
|
||||
} else {
|
||||
dl_set_next(prev_dl, next_dl);
|
||||
}
|
||||
GC_clear_mark_bit((ptr_t)curr_dl);
|
||||
GC_dl_entries--;
|
||||
curr_dl = next_dl;
|
||||
} else {
|
||||
prev_dl = curr_dl;
|
||||
curr_dl = dl_next(curr_dl);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef JAVA_FINALIZATION_NOT_NEEDED
|
||||
|
||||
/* Enqueue all remaining finalizers to be run - Assumes lock is
|
||||
* held, and signals are disabled */
|
||||
void GC_enqueue_all_finalizers()
|
||||
{
|
||||
struct finalizable_object * curr_fo, * prev_fo, * next_fo;
|
||||
ptr_t real_ptr;
|
||||
register int i;
|
||||
int fo_size;
|
||||
|
||||
fo_size = (log_fo_table_size == -1 ) ? 0 : (1 << log_fo_table_size);
|
||||
GC_words_finalized = 0;
|
||||
for (i = 0; i < fo_size; i++) {
|
||||
curr_fo = fo_head[i];
|
||||
prev_fo = 0;
|
||||
while (curr_fo != 0) {
|
||||
real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
|
||||
GC_MARK_FO(real_ptr, GC_normal_finalize_mark_proc);
|
||||
GC_set_mark_bit(real_ptr);
|
||||
|
||||
/* Delete from hash table */
|
||||
next_fo = fo_next(curr_fo);
|
||||
if (prev_fo == 0) {
|
||||
fo_head[i] = next_fo;
|
||||
} else {
|
||||
fo_set_next(prev_fo, next_fo);
|
||||
}
|
||||
GC_fo_entries--;
|
||||
|
||||
/* Add to list of objects awaiting finalization. */
|
||||
fo_set_next(curr_fo, GC_finalize_now);
|
||||
GC_finalize_now = curr_fo;
|
||||
|
||||
/* unhide object pointer so any future collections will */
|
||||
/* see it. */
|
||||
curr_fo -> fo_hidden_base =
|
||||
(word) REVEAL_POINTER(curr_fo -> fo_hidden_base);
|
||||
|
||||
GC_words_finalized +=
|
||||
ALIGNED_WORDS(curr_fo -> fo_object_size)
|
||||
+ ALIGNED_WORDS(sizeof(struct finalizable_object));
|
||||
curr_fo = next_fo;
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* Invoke all remaining finalizers that haven't yet been run.
|
||||
* This is needed for strict compliance with the Java standard,
|
||||
* which can make the runtime guarantee that all finalizers are run.
|
||||
* Unfortunately, the Java standard implies we have to keep running
|
||||
* finalizers until there are no more left, a potential infinite loop.
|
||||
* YUCK.
|
||||
* Note that this is even more dangerous than the usual Java
|
||||
* finalizers, in that objects reachable from static variables
|
||||
* may have been finalized when these finalizers are run.
|
||||
* Finalizers run at this point must be prepared to deal with a
|
||||
* mostly broken world.
|
||||
* This routine is externally callable, so is called without
|
||||
* the allocation lock.
|
||||
*/
|
||||
GC_API void GC_finalize_all()
|
||||
{
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
while (GC_fo_entries > 0) {
|
||||
GC_enqueue_all_finalizers();
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
GC_INVOKE_FINALIZERS();
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
}
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Returns true if it is worth calling GC_invoke_finalizers. (Useful if */
|
||||
/* finalizers can only be called from some kind of `safe state' and */
|
||||
/* getting into that safe state is expensive.) */
|
||||
int GC_should_invoke_finalizers GC_PROTO((void))
|
||||
{
|
||||
return GC_finalize_now != 0;
|
||||
}
|
||||
|
||||
/* Invoke finalizers for all objects that are ready to be finalized. */
|
||||
/* Should be called without allocation lock. */
|
||||
int GC_invoke_finalizers()
|
||||
{
|
||||
register struct finalizable_object * curr_fo;
|
||||
register int count = 0;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
while (GC_finalize_now != 0) {
|
||||
# ifdef THREADS
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
# endif
|
||||
curr_fo = GC_finalize_now;
|
||||
# ifdef THREADS
|
||||
if (curr_fo != 0) GC_finalize_now = fo_next(curr_fo);
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
if (curr_fo == 0) break;
|
||||
# else
|
||||
GC_finalize_now = fo_next(curr_fo);
|
||||
# endif
|
||||
fo_set_next(curr_fo, 0);
|
||||
(*(curr_fo -> fo_fn))((ptr_t)(curr_fo -> fo_hidden_base),
|
||||
curr_fo -> fo_client_data);
|
||||
curr_fo -> fo_client_data = 0;
|
||||
++count;
|
||||
# ifdef UNDEFINED
|
||||
/* This is probably a bad idea. It throws off accounting if */
|
||||
/* nearly all objects are finalizable. O.w. it shouldn't */
|
||||
/* matter. */
|
||||
GC_free((GC_PTR)curr_fo);
|
||||
# endif
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
void (* GC_finalizer_notifier)() = (void (*) GC_PROTO((void)))0;
|
||||
|
||||
static GC_word last_finalizer_notification = 0;
|
||||
|
||||
void GC_notify_or_invoke_finalizers GC_PROTO((void))
|
||||
{
|
||||
if (GC_finalize_now == 0) return;
|
||||
if (!GC_finalize_on_demand) {
|
||||
(void) GC_invoke_finalizers();
|
||||
GC_ASSERT(GC_finalize_now == 0);
|
||||
return;
|
||||
}
|
||||
if (GC_finalizer_notifier != (void (*) GC_PROTO((void)))0
|
||||
&& last_finalizer_notification != GC_gc_no) {
|
||||
last_finalizer_notification = GC_gc_no;
|
||||
GC_finalizer_notifier();
|
||||
}
|
||||
}
|
||||
|
||||
# ifdef __STDC__
|
||||
GC_PTR GC_call_with_alloc_lock(GC_fn_type fn,
|
||||
GC_PTR client_data)
|
||||
# else
|
||||
GC_PTR GC_call_with_alloc_lock(fn, client_data)
|
||||
GC_fn_type fn;
|
||||
GC_PTR client_data;
|
||||
# endif
|
||||
{
|
||||
GC_PTR result;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
# ifdef THREADS
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
SET_LOCK_HOLDER();
|
||||
# endif
|
||||
result = (*fn)(client_data);
|
||||
# ifdef THREADS
|
||||
# ifndef GC_ASSERTIONS
|
||||
UNSET_LOCK_HOLDER();
|
||||
# endif /* o.w. UNLOCK() does it implicitly */
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
# endif
|
||||
return(result);
|
||||
}
|
||||
2158
boehm-gc/gc.mak
2158
boehm-gc/gc.mak
File diff suppressed because it is too large
Load Diff
@@ -1,49 +0,0 @@
|
||||
/*************************************************************************
|
||||
Copyright (c) 1994 by Xerox Corporation. All rights reserved.
|
||||
|
||||
THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
|
||||
Last modified on Sat Nov 19 19:31:14 PST 1994 by ellis
|
||||
on Sat Jun 8 15:10:00 PST 1994 by boehm
|
||||
|
||||
Permission is hereby granted to copy this code for any purpose,
|
||||
provided the above notices are retained on all copies.
|
||||
|
||||
This implementation module for gc_c++.h provides an implementation of
|
||||
the global operators "new" and "delete" that calls the Boehm
|
||||
allocator. All objects allocated by this implementation will be
|
||||
non-collectable but part of the root set of the collector.
|
||||
|
||||
You should ensure (using implementation-dependent techniques) that the
|
||||
linker finds this module before the library that defines the default
|
||||
built-in "new" and "delete".
|
||||
|
||||
Authors: John R. Ellis and Jesse Hull
|
||||
|
||||
**************************************************************************/
|
||||
/* Boehm, December 20, 1994 7:26 pm PST */
|
||||
|
||||
#include "gc_cpp.h"
|
||||
|
||||
#ifndef _MSC_VER
|
||||
/* In the Visual C++ case, we moved this into the header. */
|
||||
void* operator new( size_t size ) {
|
||||
return GC_MALLOC_UNCOLLECTABLE( size );}
|
||||
|
||||
void operator delete( void* obj ) {
|
||||
GC_FREE( obj );}
|
||||
|
||||
#ifdef OPERATOR_NEW_ARRAY
|
||||
|
||||
void* operator new[]( size_t size ) {
|
||||
return GC_MALLOC_UNCOLLECTABLE( size );}
|
||||
|
||||
void operator delete[]( void* obj ) {
|
||||
GC_FREE( obj );}
|
||||
|
||||
#endif /* OPERATOR_NEW_ARRAY */
|
||||
|
||||
#endif /* _MSC_VER */
|
||||
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
// Visual C++ seems to prefer a .cpp extension to .cc
|
||||
#include "gc_cpp.cc"
|
||||
@@ -1,95 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
|
||||
* Copyright (c) 1997 by Silicon Graphics. All rights reserved.
|
||||
* Copyright (c) 2000 by Hewlett-Packard Company. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*
|
||||
* Original author: Bill Janssen
|
||||
* Heavily modified by Hans Boehm and others
|
||||
*/
|
||||
|
||||
/*
|
||||
* This used to be in dyn_load.c. It was extracted into a separate file
|
||||
* to avoid having to link against libdl.{a,so} if the client doesn't call
|
||||
* dlopen. -HB
|
||||
*/
|
||||
|
||||
#include "private/gc_priv.h"
|
||||
|
||||
# if defined(GC_PTHREADS) || defined(GC_SOLARIS_THREADS)
|
||||
|
||||
# if defined(dlopen) && !defined(GC_USE_LD_WRAP)
|
||||
/* To support various threads pkgs, gc.h interposes on dlopen by */
|
||||
/* defining "dlopen" to be "GC_dlopen", which is implemented below. */
|
||||
/* However, both GC_FirstDLOpenedLinkMap() and GC_dlopen() use the */
|
||||
/* real system dlopen() in their implementation. We first remove */
|
||||
/* gc.h's dlopen definition and restore it later, after GC_dlopen(). */
|
||||
# undef dlopen
|
||||
# endif
|
||||
|
||||
/* Make sure we're not in the middle of a collection, and make */
|
||||
/* sure we don't start any. Returns previous value of GC_dont_gc. */
|
||||
/* This is invoked prior to a dlopen call to avoid synchronization */
|
||||
/* issues. We can't just acquire the allocation lock, since startup */
|
||||
/* code in dlopen may try to allocate. */
|
||||
/* This solution risks heap growth in the presence of many dlopen */
|
||||
/* calls in either a multithreaded environment, or if the library */
|
||||
/* initialization code allocates substantial amounts of GC'ed memory. */
|
||||
/* But I don't know of a better solution. */
|
||||
/* This can still deadlock if the client explicitly starts a GC */
|
||||
/* during the dlopen. He shouldn't do that. */
|
||||
static GC_bool disable_gc_for_dlopen()
|
||||
{
|
||||
GC_bool result;
|
||||
LOCK();
|
||||
result = GC_dont_gc;
|
||||
while (GC_incremental && GC_collection_in_progress()) {
|
||||
GC_collect_a_little_inner(1000);
|
||||
}
|
||||
GC_dont_gc = TRUE;
|
||||
UNLOCK();
|
||||
return(result);
|
||||
}
|
||||
|
||||
/* Redefine dlopen to guarantee mutual exclusion with */
|
||||
/* GC_register_dynamic_libraries. */
|
||||
/* Should probably happen for other operating systems, too. */
|
||||
|
||||
#include <dlfcn.h>
|
||||
|
||||
#ifdef GC_USE_LD_WRAP
|
||||
void * __wrap_dlopen(const char *path, int mode)
|
||||
#else
|
||||
void * GC_dlopen(path, mode)
|
||||
GC_CONST char * path;
|
||||
int mode;
|
||||
#endif
|
||||
{
|
||||
void * result;
|
||||
GC_bool dont_gc_save;
|
||||
|
||||
# ifndef USE_PROC_FOR_LIBRARIES
|
||||
dont_gc_save = disable_gc_for_dlopen();
|
||||
# endif
|
||||
# ifdef GC_USE_LD_WRAP
|
||||
result = (void *)__real_dlopen(path, mode);
|
||||
# else
|
||||
result = dlopen(path, mode);
|
||||
# endif
|
||||
# ifndef USE_PROC_FOR_LIBRARIES
|
||||
GC_dont_gc = dont_gc_save;
|
||||
# endif
|
||||
return(result);
|
||||
}
|
||||
# endif /* GC_PTHREADS || GC_SOLARIS_THREADS ... */
|
||||
|
||||
|
||||
|
||||
@@ -1,516 +0,0 @@
|
||||
/***************************************************************************
|
||||
|
||||
Interface between g++ and Boehm GC
|
||||
|
||||
Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved.
|
||||
|
||||
THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
|
||||
Permission is hereby granted to copy this code for any purpose,
|
||||
provided the above notices are retained on all copies.
|
||||
|
||||
Last modified on Sun Jul 16 23:21:14 PDT 1995 by ellis
|
||||
|
||||
This module provides runtime support for implementing the
|
||||
Ellis/Detlefs GC proposal, "Safe, Efficient Garbage Collection for
|
||||
C++", within g++, using its -fgc-keyword extension. It defines
|
||||
versions of __builtin_new, __builtin_new_gc, __builtin_vec_new,
|
||||
__builtin_vec_new_gc, __builtin_delete, and __builtin_vec_delete that
|
||||
invoke the Bohem GC. It also implements the WeakPointer.h interface.
|
||||
|
||||
This module assumes the following configuration options of the Boehm GC:
|
||||
|
||||
-DALL_INTERIOR_POINTERS
|
||||
-DDONT_ADD_BYTE_AT_END
|
||||
|
||||
This module adds its own required padding to the end of objects to
|
||||
support C/C++ "one-past-the-object" pointer semantics.
|
||||
|
||||
****************************************************************************/
|
||||
|
||||
#include <stddef.h>
|
||||
#include "gc.h"
|
||||
|
||||
#if defined(__STDC__)
|
||||
# define PROTO( args ) args
|
||||
#else
|
||||
# define PROTO( args ) ()
|
||||
# endif
|
||||
|
||||
#define BITSPERBYTE 8
|
||||
/* What's the portable way to do this? */
|
||||
|
||||
|
||||
typedef void (*vfp) PROTO(( void ));
|
||||
extern vfp __new_handler;
|
||||
extern void __default_new_handler PROTO(( void ));
|
||||
|
||||
|
||||
/* A destructor_proc is the compiler generated procedure representing a
|
||||
C++ destructor. The "flag" argument is a hidden argument following some
|
||||
compiler convention. */
|
||||
|
||||
typedef (*destructor_proc) PROTO(( void* this, int flag ));
|
||||
|
||||
|
||||
/***************************************************************************
|
||||
|
||||
A BI_header is the header the compiler adds to the front of
|
||||
new-allocated arrays of objects with destructors. The header is
|
||||
padded out to a double, because that's what the compiler does to
|
||||
ensure proper alignment of array elements on some architectures.
|
||||
|
||||
int NUM_ARRAY_ELEMENTS (void* o)
|
||||
returns the number of array elements for array object o.
|
||||
|
||||
char* FIRST_ELEMENT_P (void* o)
|
||||
returns the address of the first element of array object o.
|
||||
|
||||
***************************************************************************/
|
||||
|
||||
typedef struct BI_header {
|
||||
int nelts;
|
||||
char padding [sizeof( double ) - sizeof( int )];
|
||||
/* Better way to do this? */
|
||||
} BI_header;
|
||||
|
||||
#define NUM_ARRAY_ELEMENTS( o ) \
|
||||
(((BI_header*) o)->nelts)
|
||||
|
||||
#define FIRST_ELEMENT_P( o ) \
|
||||
((char*) o + sizeof( BI_header ))
|
||||
|
||||
|
||||
/***************************************************************************
|
||||
|
||||
The __builtin_new routines add a descriptor word to the end of each
|
||||
object. The descriptor serves two purposes.
|
||||
|
||||
First, the descriptor acts as padding, implementing C/C++ pointer
|
||||
semantics. C and C++ allow a valid array pointer to be incremented
|
||||
one past the end of an object. The extra padding ensures that the
|
||||
collector will recognize that such a pointer points to the object and
|
||||
not the next object in memory.
|
||||
|
||||
Second, the descriptor stores three extra pieces of information,
|
||||
whether an object has a registered finalizer (destructor), whether it
|
||||
may have any weak pointers referencing it, and for collectible arrays,
|
||||
the element size of the array. The element size is required for the
|
||||
array's finalizer to iterate through the elements of the array. (An
|
||||
alternative design would have the compiler generate a finalizer
|
||||
procedure for each different array type. But given the overhead of
|
||||
finalization, there isn't any efficiency to be gained by that.)
|
||||
|
||||
The descriptor must be added to non-collectible as well as collectible
|
||||
objects, since the Ellis/Detlefs proposal allows "pointer to gc T" to
|
||||
be assigned to a "pointer to T", which could then be deleted. Thus,
|
||||
__builtin_delete must determine at runtime whether an object is
|
||||
collectible, whether it has weak pointers referencing it, and whether
|
||||
it may have a finalizer that needs unregistering. Though
|
||||
GC_REGISTER_FINALIZER doesn't care if you ask it to unregister a
|
||||
finalizer for an object that doesn't have one, it is a non-trivial
|
||||
procedure that does a hash look-up, etc. The descriptor trades a
|
||||
little extra space for a significant increase in time on the fast path
|
||||
through delete. (A similar argument applies to
|
||||
GC_UNREGISTER_DISAPPEARING_LINK).
|
||||
|
||||
For non-array types, the space for the descriptor could be shrunk to a
|
||||
single byte for storing the "has finalizer" flag. But this would save
|
||||
space only on arrays of char (whose size is not a multiple of the word
|
||||
size) and structs whose largest member is less than a word in size
|
||||
(very infrequent). And it would require that programmers actually
|
||||
remember to call "delete[]" instead of "delete" (which they should,
|
||||
but there are probably lots of buggy programs out there). For the
|
||||
moment, the space savings seems not worthwhile, especially considering
|
||||
that the Boehm GC is already quite space competitive with other
|
||||
malloc's.
|
||||
|
||||
|
||||
Given a pointer o to the base of an object:
|
||||
|
||||
Descriptor* DESCRIPTOR (void* o)
|
||||
returns a pointer to the descriptor for o.
|
||||
|
||||
The implementation of descriptors relies on the fact that the GC
|
||||
implementation allocates objects in units of the machine's natural
|
||||
word size (e.g. 32 bits on a SPARC, 64 bits on an Alpha).
|
||||
|
||||
**************************************************************************/
|
||||
|
||||
typedef struct Descriptor {
|
||||
unsigned has_weak_pointers: 1;
|
||||
unsigned has_finalizer: 1;
|
||||
unsigned element_size: BITSPERBYTE * sizeof( unsigned ) - 2;
|
||||
} Descriptor;
|
||||
|
||||
#define DESCRIPTOR( o ) \
|
||||
((Descriptor*) ((char*)(o) + GC_size( o ) - sizeof( Descriptor )))
|
||||
|
||||
|
||||
/**************************************************************************
|
||||
|
||||
Implementations of global operator new() and operator delete()
|
||||
|
||||
***************************************************************************/
|
||||
|
||||
|
||||
void* __builtin_new( size )
|
||||
size_t size;
|
||||
/*
|
||||
For non-gc non-array types, the compiler generates calls to
|
||||
__builtin_new, which allocates non-collected storage via
|
||||
GC_MALLOC_UNCOLLECTABLE. This ensures that the non-collected
|
||||
storage will be part of the collector's root set, required by the
|
||||
Ellis/Detlefs semantics. */
|
||||
{
|
||||
vfp handler = __new_handler ? __new_handler : __default_new_handler;
|
||||
|
||||
while (1) {
|
||||
void* o = GC_MALLOC_UNCOLLECTABLE( size + sizeof( Descriptor ) );
|
||||
if (o != 0) return o;
|
||||
(*handler) ();}}
|
||||
|
||||
|
||||
void* __builtin_vec_new( size )
|
||||
size_t size;
|
||||
/*
|
||||
For non-gc array types, the compiler generates calls to
|
||||
__builtin_vec_new. */
|
||||
{
|
||||
return __builtin_new( size );}
|
||||
|
||||
|
||||
void* __builtin_new_gc( size )
|
||||
size_t size;
|
||||
/*
|
||||
For gc non-array types, the compiler generates calls to
|
||||
__builtin_new_gc, which allocates collected storage via
|
||||
GC_MALLOC. */
|
||||
{
|
||||
vfp handler = __new_handler ? __new_handler : __default_new_handler;
|
||||
|
||||
while (1) {
|
||||
void* o = GC_MALLOC( size + sizeof( Descriptor ) );
|
||||
if (o != 0) return o;
|
||||
(*handler) ();}}
|
||||
|
||||
|
||||
void* __builtin_new_gc_a( size )
|
||||
size_t size;
|
||||
/*
|
||||
For non-pointer-containing gc non-array types, the compiler
|
||||
generates calls to __builtin_new_gc_a, which allocates collected
|
||||
storage via GC_MALLOC_ATOMIC. */
|
||||
{
|
||||
vfp handler = __new_handler ? __new_handler : __default_new_handler;
|
||||
|
||||
while (1) {
|
||||
void* o = GC_MALLOC_ATOMIC( size + sizeof( Descriptor ) );
|
||||
if (o != 0) return o;
|
||||
(*handler) ();}}
|
||||
|
||||
|
||||
void* __builtin_vec_new_gc( size )
|
||||
size_t size;
|
||||
/*
|
||||
For gc array types, the compiler generates calls to
|
||||
__builtin_vec_new_gc. */
|
||||
{
|
||||
return __builtin_new_gc( size );}
|
||||
|
||||
|
||||
void* __builtin_vec_new_gc_a( size )
|
||||
size_t size;
|
||||
/*
|
||||
For non-pointer-containing gc array types, the compiler generates
|
||||
calls to __builtin_vec_new_gc_a. */
|
||||
{
|
||||
return __builtin_new_gc_a( size );}
|
||||
|
||||
|
||||
static void call_destructor( o, data )
|
||||
void* o;
|
||||
void* data;
|
||||
/*
|
||||
call_destructor is the GC finalizer proc registered for non-array
|
||||
gc objects with destructors. Its client data is the destructor
|
||||
proc, which it calls with the magic integer 2, a special flag
|
||||
obeying the compiler convention for destructors. */
|
||||
{
|
||||
((destructor_proc) data)( o, 2 );}
|
||||
|
||||
|
||||
void* __builtin_new_gc_dtor( o, d )
|
||||
void* o;
|
||||
destructor_proc d;
|
||||
/*
|
||||
The compiler generates a call to __builtin_new_gc_dtor to register
|
||||
the destructor "d" of a non-array gc object "o" as a GC finalizer.
|
||||
The destructor is registered via
|
||||
GC_REGISTER_FINALIZER_IGNORE_SELF, which causes the collector to
|
||||
ignore pointers from the object to itself when determining when
|
||||
the object can be finalized. This is necessary due to the self
|
||||
pointers used in the internal representation of multiply-inherited
|
||||
objects. */
|
||||
{
|
||||
Descriptor* desc = DESCRIPTOR( o );
|
||||
|
||||
GC_REGISTER_FINALIZER_IGNORE_SELF( o, call_destructor, d, 0, 0 );
|
||||
desc->has_finalizer = 1;}
|
||||
|
||||
|
||||
static void call_array_destructor( o, data )
|
||||
void* o;
|
||||
void* data;
|
||||
/*
|
||||
call_array_destructor is the GC finalizer proc registered for gc
|
||||
array objects whose elements have destructors. Its client data is
|
||||
the destructor proc. It iterates through the elements of the
|
||||
array in reverse order, calling the destructor on each. */
|
||||
{
|
||||
int num = NUM_ARRAY_ELEMENTS( o );
|
||||
Descriptor* desc = DESCRIPTOR( o );
|
||||
size_t size = desc->element_size;
|
||||
char* first_p = FIRST_ELEMENT_P( o );
|
||||
char* p = first_p + (num - 1) * size;
|
||||
|
||||
if (num > 0) {
|
||||
while (1) {
|
||||
((destructor_proc) data)( p, 2 );
|
||||
if (p == first_p) break;
|
||||
p -= size;}}}
|
||||
|
||||
|
||||
void* __builtin_vec_new_gc_dtor( first_elem, d, element_size )
|
||||
void* first_elem;
|
||||
destructor_proc d;
|
||||
size_t element_size;
|
||||
/*
|
||||
The compiler generates a call to __builtin_vec_new_gc_dtor to
|
||||
register the destructor "d" of a gc array object as a GC
|
||||
finalizer. "first_elem" points to the first element of the array,
|
||||
*not* the beginning of the object (this makes the generated call
|
||||
to this function smaller). The elements of the array are of size
|
||||
"element_size". The destructor is registered as in
|
||||
_builtin_new_gc_dtor. */
|
||||
{
|
||||
void* o = (char*) first_elem - sizeof( BI_header );
|
||||
Descriptor* desc = DESCRIPTOR( o );
|
||||
|
||||
GC_REGISTER_FINALIZER_IGNORE_SELF( o, call_array_destructor, d, 0, 0 );
|
||||
desc->element_size = element_size;
|
||||
desc->has_finalizer = 1;}
|
||||
|
||||
|
||||
void __builtin_delete( o )
|
||||
void* o;
|
||||
/*
|
||||
The compiler generates calls to __builtin_delete for operator
|
||||
delete(). The GC currently requires that any registered
|
||||
finalizers be unregistered before explicitly freeing an object.
|
||||
If the object has any weak pointers referencing it, we can't
|
||||
actually free it now. */
|
||||
{
|
||||
if (o != 0) {
|
||||
Descriptor* desc = DESCRIPTOR( o );
|
||||
if (desc->has_finalizer) GC_REGISTER_FINALIZER( o, 0, 0, 0, 0 );
|
||||
if (! desc->has_weak_pointers) GC_FREE( o );}}
|
||||
|
||||
|
||||
void __builtin_vec_delete( o )
|
||||
void* o;
|
||||
/*
|
||||
The compiler generates calls to __builitn_vec_delete for operator
|
||||
delete[](). */
|
||||
{
|
||||
__builtin_delete( o );}
|
||||
|
||||
|
||||
/**************************************************************************
|
||||
|
||||
Implementations of the template class WeakPointer from WeakPointer.h
|
||||
|
||||
***************************************************************************/
|
||||
|
||||
typedef struct WeakPointer {
|
||||
void* pointer;
|
||||
} WeakPointer;
|
||||
|
||||
|
||||
void* _WeakPointer_New( t )
|
||||
void* t;
|
||||
{
|
||||
if (t == 0) {
|
||||
return 0;}
|
||||
else {
|
||||
void* base = GC_base( t );
|
||||
WeakPointer* wp =
|
||||
(WeakPointer*) GC_MALLOC_ATOMIC( sizeof( WeakPointer ) );
|
||||
Descriptor* desc = DESCRIPTOR( base );
|
||||
|
||||
wp->pointer = t;
|
||||
desc->has_weak_pointers = 1;
|
||||
GC_general_register_disappearing_link( &wp->pointer, base );
|
||||
return wp;}}
|
||||
|
||||
|
||||
static void* PointerWithLock( wp )
|
||||
WeakPointer* wp;
|
||||
{
|
||||
if (wp == 0 || wp->pointer == 0) {
|
||||
return 0;}
|
||||
else {
|
||||
return (void*) wp->pointer;}}
|
||||
|
||||
|
||||
void* _WeakPointer_Pointer( wp )
|
||||
WeakPointer* wp;
|
||||
{
|
||||
return (void*) GC_call_with_alloc_lock( PointerWithLock, wp );}
|
||||
|
||||
|
||||
typedef struct EqualClosure {
|
||||
WeakPointer* wp1;
|
||||
WeakPointer* wp2;
|
||||
} EqualClosure;
|
||||
|
||||
|
||||
static void* EqualWithLock( ec )
|
||||
EqualClosure* ec;
|
||||
{
|
||||
if (ec->wp1 == 0 || ec->wp2 == 0) {
|
||||
return (void*) (ec->wp1 == ec->wp2);}
|
||||
else {
|
||||
return (void*) (ec->wp1->pointer == ec->wp2->pointer);}}
|
||||
|
||||
|
||||
int _WeakPointer_Equal( wp1, wp2 )
|
||||
WeakPointer* wp1;
|
||||
WeakPointer* wp2;
|
||||
{
|
||||
EqualClosure ec;
|
||||
|
||||
ec.wp1 = wp1;
|
||||
ec.wp2 = wp2;
|
||||
return (int) GC_call_with_alloc_lock( EqualWithLock, &ec );}
|
||||
|
||||
|
||||
int _WeakPointer_Hash( wp )
|
||||
WeakPointer* wp;
|
||||
{
|
||||
return (int) _WeakPointer_Pointer( wp );}
|
||||
|
||||
|
||||
/**************************************************************************
|
||||
|
||||
Implementations of the template class CleanUp from WeakPointer.h
|
||||
|
||||
***************************************************************************/
|
||||
|
||||
typedef struct Closure {
|
||||
void (*c) PROTO(( void* d, void* t ));
|
||||
ptrdiff_t t_offset;
|
||||
void* d;
|
||||
} Closure;
|
||||
|
||||
|
||||
static void _CleanUp_CallClosure( obj, data )
|
||||
void* obj;
|
||||
void* data;
|
||||
{
|
||||
Closure* closure = (Closure*) data;
|
||||
closure->c( closure->d, (char*) obj + closure->t_offset );}
|
||||
|
||||
|
||||
void _CleanUp_Set( t, c, d )
|
||||
void* t;
|
||||
void (*c) PROTO(( void* d, void* t ));
|
||||
void* d;
|
||||
{
|
||||
void* base = GC_base( t );
|
||||
Descriptor* desc = DESCRIPTOR( t );
|
||||
|
||||
if (c == 0) {
|
||||
GC_REGISTER_FINALIZER_IGNORE_SELF( base, 0, 0, 0, 0 );
|
||||
desc->has_finalizer = 0;}
|
||||
else {
|
||||
Closure* closure = (Closure*) GC_MALLOC( sizeof( Closure ) );
|
||||
closure->c = c;
|
||||
closure->t_offset = (char*) t - (char*) base;
|
||||
closure->d = d;
|
||||
GC_REGISTER_FINALIZER_IGNORE_SELF( base, _CleanUp_CallClosure,
|
||||
closure, 0, 0 );
|
||||
desc->has_finalizer = 1;}}
|
||||
|
||||
|
||||
void _CleanUp_Call( t )
|
||||
void* t;
|
||||
{
|
||||
/* ? Aren't we supposed to deactivate weak pointers to t too?
|
||||
Why? */
|
||||
void* base = GC_base( t );
|
||||
void* d;
|
||||
GC_finalization_proc f;
|
||||
|
||||
GC_REGISTER_FINALIZER( base, 0, 0, &f, &d );
|
||||
f( base, d );}
|
||||
|
||||
|
||||
typedef struct QueueElem {
|
||||
void* o;
|
||||
GC_finalization_proc f;
|
||||
void* d;
|
||||
struct QueueElem* next;
|
||||
} QueueElem;
|
||||
|
||||
|
||||
void* _CleanUp_Queue_NewHead()
|
||||
{
|
||||
return GC_MALLOC( sizeof( QueueElem ) );}
|
||||
|
||||
|
||||
static void _CleanUp_Queue_Enqueue( obj, data )
|
||||
void* obj;
|
||||
void* data;
|
||||
{
|
||||
QueueElem* q = (QueueElem*) data;
|
||||
QueueElem* head = q->next;
|
||||
|
||||
q->o = obj;
|
||||
q->next = head->next;
|
||||
head->next = q;}
|
||||
|
||||
|
||||
void _CleanUp_Queue_Set( h, t )
|
||||
void* h;
|
||||
void* t;
|
||||
{
|
||||
QueueElem* head = (QueueElem*) h;
|
||||
void* base = GC_base( t );
|
||||
void* d;
|
||||
GC_finalization_proc f;
|
||||
QueueElem* q = (QueueElem*) GC_MALLOC( sizeof( QueueElem ) );
|
||||
|
||||
GC_REGISTER_FINALIZER( base, _CleanUp_Queue_Enqueue, q, &f, &d );
|
||||
q->f = f;
|
||||
q->d = d;
|
||||
q->next = head;}
|
||||
|
||||
|
||||
int _CleanUp_Queue_Call( h )
|
||||
void* h;
|
||||
{
|
||||
QueueElem* head = (QueueElem*) h;
|
||||
QueueElem* q = head->next;
|
||||
|
||||
if (q == 0) {
|
||||
return 0;}
|
||||
else {
|
||||
head->next = q->next;
|
||||
q->next = 0;
|
||||
if (q->f != 0) q->f( q->o, q->d );
|
||||
return 1;}}
|
||||
|
||||
|
||||
|
||||
@@ -1,284 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
|
||||
* Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*
|
||||
*/
|
||||
/* Boehm, July 31, 1995 5:02 pm PDT */
|
||||
|
||||
#ifdef GC_GCJ_SUPPORT
|
||||
|
||||
/*
|
||||
* This is an allocator interface tuned for gcj (the GNU static
|
||||
* java compiler).
|
||||
*
|
||||
* Each allocated object has a pointer in its first word to a vtable,
|
||||
* which for our purposes is simply a structure describing the type of
|
||||
* the object.
|
||||
* This descriptor structure contains a GC marking descriptor at offset
|
||||
* MARK_DESCR_OFFSET.
|
||||
*
|
||||
* It is hoped that this interface may also be useful for other systems,
|
||||
* possibly with some tuning of the constants. But the immediate goal
|
||||
* is to get better gcj performance.
|
||||
*
|
||||
* We assume:
|
||||
* 1) We have an ANSI conforming C compiler.
|
||||
* 2) Counting on explicit initialization of this interface is OK.
|
||||
* 3) FASTLOCK is not a significant win.
|
||||
*/
|
||||
|
||||
#include "private/gc_pmark.h"
|
||||
#include "gc_gcj.h"
|
||||
#include "private/dbg_mlc.h"
|
||||
|
||||
GC_bool GC_gcj_malloc_initialized = FALSE;
|
||||
|
||||
int GC_gcj_kind; /* Object kind for objects with descriptors */
|
||||
/* in "vtable". */
|
||||
int GC_gcj_debug_kind; /* The kind of objects that is always marked */
|
||||
/* with a mark proc call. */
|
||||
|
||||
ptr_t * GC_gcjobjfreelist;
|
||||
ptr_t * GC_gcjdebugobjfreelist;
|
||||
|
||||
/* Caller does not hold allocation lock. */
|
||||
void GC_init_gcj_malloc(int mp_index, void * /* really GC_mark_proc */mp)
|
||||
{
|
||||
register int i;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
GC_init(); /* In case it's not already done. */
|
||||
DISABLE_SIGNALS();
|
||||
LOCK();
|
||||
if (GC_gcj_malloc_initialized) {
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
return;
|
||||
}
|
||||
GC_gcj_malloc_initialized = TRUE;
|
||||
GC_mark_procs[mp_index] = (GC_mark_proc)mp;
|
||||
if (mp_index >= GC_n_mark_procs) ABORT("GC_init_gcj_malloc: bad index");
|
||||
/* Set up object kind gcj-style indirect descriptor. */
|
||||
GC_gcjobjfreelist = (ptr_t *)
|
||||
GC_INTERNAL_MALLOC((MAXOBJSZ+1)*sizeof(ptr_t), PTRFREE);
|
||||
if (GC_gcjobjfreelist == 0) ABORT("Couldn't allocate GC_gcjobjfreelist");
|
||||
BZERO(GC_gcjobjfreelist, (MAXOBJSZ+1)*sizeof(ptr_t));
|
||||
GC_gcj_kind = GC_n_kinds++;
|
||||
GC_obj_kinds[GC_gcj_kind].ok_freelist = GC_gcjobjfreelist;
|
||||
GC_obj_kinds[GC_gcj_kind].ok_reclaim_list = 0;
|
||||
GC_obj_kinds[GC_gcj_kind].ok_descriptor =
|
||||
(((word)(-MARK_DESCR_OFFSET - GC_INDIR_PER_OBJ_BIAS)) | GC_DS_PER_OBJECT);
|
||||
GC_obj_kinds[GC_gcj_kind].ok_relocate_descr = FALSE;
|
||||
GC_obj_kinds[GC_gcj_kind].ok_init = TRUE;
|
||||
/* Set up object kind for objects that require mark proc call. */
|
||||
GC_gcjdebugobjfreelist = (ptr_t *)
|
||||
GC_INTERNAL_MALLOC((MAXOBJSZ+1)*sizeof(ptr_t), PTRFREE);
|
||||
if (GC_gcjdebugobjfreelist == 0)
|
||||
ABORT("Couldn't allocate GC_gcjdebugobjfreelist");
|
||||
BZERO(GC_gcjdebugobjfreelist, (MAXOBJSZ+1)*sizeof(ptr_t));
|
||||
GC_gcj_debug_kind = GC_n_kinds++;
|
||||
GC_obj_kinds[GC_gcj_debug_kind].ok_freelist = GC_gcjdebugobjfreelist;
|
||||
GC_obj_kinds[GC_gcj_debug_kind].ok_reclaim_list = 0;
|
||||
GC_obj_kinds[GC_gcj_debug_kind].ok_descriptor =
|
||||
GC_MAKE_PROC(mp_index, 1 /* allocated with debug info */);
|
||||
GC_obj_kinds[GC_gcj_debug_kind].ok_relocate_descr = FALSE;
|
||||
GC_obj_kinds[GC_gcj_debug_kind].ok_init = TRUE;
|
||||
UNLOCK();
|
||||
ENABLE_SIGNALS();
|
||||
}
|
||||
|
||||
ptr_t GC_clear_stack();
|
||||
|
||||
#define GENERAL_MALLOC(lb,k) \
|
||||
(GC_PTR)GC_clear_stack(GC_generic_malloc_inner((word)lb, k))
|
||||
|
||||
#define GENERAL_MALLOC_IOP(lb,k) \
|
||||
(GC_PTR)GC_clear_stack(GC_generic_malloc_inner_ignore_off_page(lb, k))
|
||||
|
||||
/* Allocate an object, clear it, and store the pointer to the */
|
||||
/* type structure (vtable in gcj). */
|
||||
/* This adds a byte at the end of the object if GC_malloc would.*/
|
||||
void * GC_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr)
|
||||
{
|
||||
register ptr_t op;
|
||||
register ptr_t * opp;
|
||||
register word lw;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
if( EXPECT(SMALL_OBJ(lb), 1) ) {
|
||||
# ifdef MERGE_SIZES
|
||||
lw = GC_size_map[lb];
|
||||
# else
|
||||
lw = ALIGNED_WORDS(lb);
|
||||
# endif
|
||||
opp = &(GC_gcjobjfreelist[lw]);
|
||||
LOCK();
|
||||
op = *opp;
|
||||
if( EXPECT(op == 0, 0)) {
|
||||
op = (ptr_t)GENERAL_MALLOC((word)lb, GC_gcj_kind);
|
||||
if (0 == op) {
|
||||
UNLOCK();
|
||||
return(GC_oom_fn(lb));
|
||||
}
|
||||
# ifdef MERGE_SIZES
|
||||
lw = GC_size_map[lb]; /* May have been uninitialized. */
|
||||
# endif
|
||||
} else {
|
||||
*opp = obj_link(op);
|
||||
GC_words_allocd += lw;
|
||||
}
|
||||
*(void **)op = ptr_to_struct_containing_descr;
|
||||
UNLOCK();
|
||||
} else {
|
||||
LOCK();
|
||||
op = (ptr_t)GENERAL_MALLOC((word)lb, GC_gcj_kind);
|
||||
if (0 == op) {
|
||||
UNLOCK();
|
||||
return(GC_oom_fn(lb));
|
||||
}
|
||||
*(void **)op = ptr_to_struct_containing_descr;
|
||||
UNLOCK();
|
||||
}
|
||||
return((GC_PTR) op);
|
||||
}
|
||||
|
||||
/* Similar to GC_gcj_malloc, but add debug info. This is allocated */
|
||||
/* with GC_gcj_debug_kind. */
|
||||
GC_PTR GC_debug_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr,
|
||||
GC_EXTRA_PARAMS)
|
||||
{
|
||||
GC_PTR result;
|
||||
|
||||
/* We clone the code from GC_debug_gcj_malloc, so that we */
|
||||
/* dont end up with extra frames on the stack, which could */
|
||||
/* confuse the backtrace. */
|
||||
LOCK();
|
||||
result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind);
|
||||
if (result == 0) {
|
||||
UNLOCK();
|
||||
GC_err_printf2("GC_debug_gcj_malloc(%ld, 0x%lx) returning NIL (",
|
||||
(unsigned long) lb,
|
||||
(unsigned long) ptr_to_struct_containing_descr);
|
||||
GC_err_puts(s);
|
||||
GC_err_printf1(":%ld)\n", (unsigned long)i);
|
||||
return(GC_oom_fn(lb));
|
||||
}
|
||||
*((void **)((ptr_t)result + sizeof(oh))) = ptr_to_struct_containing_descr;
|
||||
UNLOCK();
|
||||
if (!GC_debugging_started) {
|
||||
GC_start_debugging();
|
||||
}
|
||||
ADD_CALL_CHAIN(result, ra);
|
||||
return (GC_store_debug_info(result, (word)lb, s, (word)i));
|
||||
}
|
||||
|
||||
/* Similar to GC_gcj_malloc, but the size is in words, and we don't */
|
||||
/* adjust it. The size is assumed to be such that it can be */
|
||||
/* allocated as a small object. */
|
||||
void * GC_gcj_fast_malloc(size_t lw, void * ptr_to_struct_containing_descr)
|
||||
{
|
||||
ptr_t op;
|
||||
ptr_t * opp;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
opp = &(GC_gcjobjfreelist[lw]);
|
||||
LOCK();
|
||||
op = *opp;
|
||||
if( EXPECT(op == 0, 0) ) {
|
||||
op = (ptr_t)GC_clear_stack(
|
||||
GC_generic_malloc_words_small_inner(lw, GC_gcj_kind));
|
||||
if (0 == op) {
|
||||
UNLOCK();
|
||||
return GC_oom_fn(WORDS_TO_BYTES(lw));
|
||||
}
|
||||
} else {
|
||||
*opp = obj_link(op);
|
||||
GC_words_allocd += lw;
|
||||
}
|
||||
*(void **)op = ptr_to_struct_containing_descr;
|
||||
UNLOCK();
|
||||
return((GC_PTR) op);
|
||||
}
|
||||
|
||||
/* And a debugging version of the above: */
|
||||
void * GC_debug_gcj_fast_malloc(size_t lw,
|
||||
void * ptr_to_struct_containing_descr,
|
||||
GC_EXTRA_PARAMS)
|
||||
{
|
||||
GC_PTR result;
|
||||
size_t lb = WORDS_TO_BYTES(lw);
|
||||
|
||||
/* We clone the code from GC_debug_gcj_malloc, so that we */
|
||||
/* dont end up with extra frames on the stack, which could */
|
||||
/* confuse the backtrace. */
|
||||
LOCK();
|
||||
result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind);
|
||||
if (result == 0) {
|
||||
UNLOCK();
|
||||
GC_err_printf2("GC_debug_gcj_fast_malloc(%ld, 0x%lx) returning NIL (",
|
||||
(unsigned long) lw,
|
||||
(unsigned long) ptr_to_struct_containing_descr);
|
||||
GC_err_puts(s);
|
||||
GC_err_printf1(":%ld)\n", (unsigned long)i);
|
||||
return GC_oom_fn(WORDS_TO_BYTES(lw));
|
||||
}
|
||||
*((void **)((ptr_t)result + sizeof(oh))) = ptr_to_struct_containing_descr;
|
||||
UNLOCK();
|
||||
if (!GC_debugging_started) {
|
||||
GC_start_debugging();
|
||||
}
|
||||
ADD_CALL_CHAIN(result, ra);
|
||||
return (GC_store_debug_info(result, (word)lb, s, (word)i));
|
||||
}
|
||||
|
||||
void * GC_gcj_malloc_ignore_off_page(size_t lb,
|
||||
void * ptr_to_struct_containing_descr)
|
||||
{
|
||||
register ptr_t op;
|
||||
register ptr_t * opp;
|
||||
register word lw;
|
||||
DCL_LOCK_STATE;
|
||||
|
||||
if( SMALL_OBJ(lb) ) {
|
||||
# ifdef MERGE_SIZES
|
||||
lw = GC_size_map[lb];
|
||||
# else
|
||||
lw = ALIGNED_WORDS(lb);
|
||||
# endif
|
||||
opp = &(GC_gcjobjfreelist[lw]);
|
||||
LOCK();
|
||||
if( (op = *opp) == 0 ) {
|
||||
op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_gcj_kind);
|
||||
# ifdef MERGE_SIZES
|
||||
lw = GC_size_map[lb]; /* May have been uninitialized. */
|
||||
# endif
|
||||
} else {
|
||||
*opp = obj_link(op);
|
||||
GC_words_allocd += lw;
|
||||
}
|
||||
*(void **)op = ptr_to_struct_containing_descr;
|
||||
UNLOCK();
|
||||
} else {
|
||||
op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_gcj_kind);
|
||||
if (0 != op) {
|
||||
*(void **)op = ptr_to_struct_containing_descr;
|
||||
}
|
||||
UNLOCK();
|
||||
}
|
||||
return((GC_PTR) op);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
char GC_no_gcj_support;
|
||||
|
||||
#endif /* GC_GCJ_SUPPORT */
|
||||
@@ -1,13 +0,0 @@
|
||||
#include <stdio.h>
|
||||
#include "version.h"
|
||||
|
||||
int main()
|
||||
{
|
||||
if (GC_ALPHA_VERSION == GC_NOT_ALPHA) {
|
||||
printf("gc%d.%d", GC_VERSION_MAJOR, GC_VERSION_MINOR);
|
||||
} else {
|
||||
printf("gc%d.%dalpha%d", GC_VERSION_MAJOR,
|
||||
GC_VERSION_MINOR, GC_ALPHA_VERSION);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -1,358 +0,0 @@
|
||||
/*
|
||||
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
|
||||
* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
|
||||
* Copyright (c) 1996 by Silicon Graphics. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This implements:
|
||||
* 1. allocation of heap block headers
|
||||
* 2. A map from addresses to heap block addresses to heap block headers
|
||||
*
|
||||
* Access speed is crucial. We implement an index structure based on a 2
|
||||
* level tree.
|
||||
*/
|
||||
|
||||
# include "private/gc_priv.h"
|
||||
|
||||
bottom_index * GC_all_bottom_indices = 0;
|
||||
/* Pointer to first (lowest addr) */
|
||||
/* bottom_index. */
|
||||
|
||||
bottom_index * GC_all_bottom_indices_end = 0;
|
||||
/* Pointer to last (highest addr) */
|
||||
/* bottom_index. */
|
||||
|
||||
/* Non-macro version of header location routine */
|
||||
hdr * GC_find_header(h)
|
||||
ptr_t h;
|
||||
{
|
||||
# ifdef HASH_TL
|
||||
register hdr * result;
|
||||
GET_HDR(h, result);
|
||||
return(result);
|
||||
# else
|
||||
return(HDR_INNER(h));
|
||||
# endif
|
||||
}
|
||||
|
||||
/* Routines to dynamically allocate collector data structures that will */
|
||||
/* never be freed. */
|
||||
|
||||
static ptr_t scratch_free_ptr = 0;
|
||||
|
||||
/* GC_scratch_last_end_ptr is end point of last obtained scratch area. */
|
||||
/* GC_scratch_end_ptr is end point of current scratch area. */
|
||||
|
||||
ptr_t GC_scratch_alloc(bytes)
|
||||
register word bytes;
|
||||
{
|
||||
register ptr_t result = scratch_free_ptr;
|
||||
|
||||
# ifdef ALIGN_DOUBLE
|
||||
# define GRANULARITY (2 * sizeof(word))
|
||||
# else
|
||||
# define GRANULARITY sizeof(word)
|
||||
# endif
|
||||
bytes += GRANULARITY-1;
|
||||
bytes &= ~(GRANULARITY-1);
|
||||
scratch_free_ptr += bytes;
|
||||
if (scratch_free_ptr <= GC_scratch_end_ptr) {
|
||||
return(result);
|
||||
}
|
||||
{
|
||||
word bytes_to_get = MINHINCR * HBLKSIZE;
|
||||
|
||||
if (bytes_to_get <= bytes) {
|
||||
/* Undo the damage, and get memory directly */
|
||||
bytes_to_get = bytes;
|
||||
# ifdef USE_MMAP
|
||||
bytes_to_get += GC_page_size - 1;
|
||||
bytes_to_get &= ~(GC_page_size - 1);
|
||||
# endif
|
||||
result = (ptr_t)GET_MEM(bytes_to_get);
|
||||
scratch_free_ptr -= bytes;
|
||||
GC_scratch_last_end_ptr = result + bytes;
|
||||
return(result);
|
||||
}
|
||||
result = (ptr_t)GET_MEM(bytes_to_get);
|
||||
if (result == 0) {
|
||||
# ifdef PRINTSTATS
|
||||
GC_printf0("Out of memory - trying to allocate less\n");
|
||||
# endif
|
||||
scratch_free_ptr -= bytes;
|
||||
bytes_to_get = bytes;
|
||||
# ifdef USE_MMAP
|
||||
bytes_to_get += GC_page_size - 1;
|
||||
bytes_to_get &= ~(GC_page_size - 1);
|
||||
# endif
|
||||
return((ptr_t)GET_MEM(bytes_to_get));
|
||||
}
|
||||
scratch_free_ptr = result;
|
||||
GC_scratch_end_ptr = scratch_free_ptr + bytes_to_get;
|
||||
GC_scratch_last_end_ptr = GC_scratch_end_ptr;
|
||||
return(GC_scratch_alloc(bytes));
|
||||
}
|
||||
}
|
||||
|
||||
static hdr * hdr_free_list = 0;
|
||||
|
||||
/* Return an uninitialized header */
|
||||
static hdr * alloc_hdr()
|
||||
{
|
||||
register hdr * result;
|
||||
|
||||
if (hdr_free_list == 0) {
|
||||
result = (hdr *) GC_scratch_alloc((word)(sizeof(hdr)));
|
||||
} else {
|
||||
result = hdr_free_list;
|
||||
hdr_free_list = (hdr *) (result -> hb_next);
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
static void free_hdr(hhdr)
|
||||
hdr * hhdr;
|
||||
{
|
||||
hhdr -> hb_next = (struct hblk *) hdr_free_list;
|
||||
hdr_free_list = hhdr;
|
||||
}
|
||||
|
||||
hdr * GC_invalid_header;
|
||||
|
||||
#ifdef USE_HDR_CACHE
|
||||
word GC_hdr_cache_hits = 0;
|
||||
word GC_hdr_cache_misses = 0;
|
||||
#endif
|
||||
|
||||
void GC_init_headers()
|
||||
{
|
||||
register unsigned i;
|
||||
|
||||
GC_all_nils = (bottom_index *)GC_scratch_alloc((word)sizeof(bottom_index));
|
||||
BZERO(GC_all_nils, sizeof(bottom_index));
|
||||
for (i = 0; i < TOP_SZ; i++) {
|
||||
GC_top_index[i] = GC_all_nils;
|
||||
}
|
||||
GC_invalid_header = alloc_hdr();
|
||||
GC_invalidate_map(GC_invalid_header);
|
||||
}
|
||||
|
||||
/* Make sure that there is a bottom level index block for address addr */
|
||||
/* Return FALSE on failure. */
|
||||
static GC_bool get_index(addr)
|
||||
word addr;
|
||||
{
|
||||
word hi = (word)(addr) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE);
|
||||
bottom_index * r;
|
||||
bottom_index * p;
|
||||
bottom_index ** prev;
|
||||
bottom_index *pi;
|
||||
|
||||
# ifdef HASH_TL
|
||||
unsigned i = TL_HASH(hi);
|
||||
bottom_index * old;
|
||||
|
||||
old = p = GC_top_index[i];
|
||||
while(p != GC_all_nils) {
|
||||
if (p -> key == hi) return(TRUE);
|
||||
p = p -> hash_link;
|
||||
}
|
||||
r = (bottom_index*)GC_scratch_alloc((word)(sizeof (bottom_index)));
|
||||
if (r == 0) return(FALSE);
|
||||
BZERO(r, sizeof (bottom_index));
|
||||
r -> hash_link = old;
|
||||
GC_top_index[i] = r;
|
||||
# else
|
||||
if (GC_top_index[hi] != GC_all_nils) return(TRUE);
|
||||
r = (bottom_index*)GC_scratch_alloc((word)(sizeof (bottom_index)));
|
||||
if (r == 0) return(FALSE);
|
||||
GC_top_index[hi] = r;
|
||||
BZERO(r, sizeof (bottom_index));
|
||||
# endif
|
||||
r -> key = hi;
|
||||
/* Add it to the list of bottom indices */
|
||||
prev = &GC_all_bottom_indices; /* pointer to p */
|
||||
pi = 0; /* bottom_index preceding p */
|
||||
while ((p = *prev) != 0 && p -> key < hi) {
|
||||
pi = p;
|
||||
prev = &(p -> asc_link);
|
||||
}
|
||||
r -> desc_link = pi;
|
||||
if (0 == p) {
|
||||
GC_all_bottom_indices_end = r;
|
||||
} else {
|
||||
p -> desc_link = r;
|
||||
}
|
||||
r -> asc_link = p;
|
||||
*prev = r;
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/* Install a header for block h. */
|
||||
/* The header is uninitialized. */
|
||||
/* Returns the header or 0 on failure. */
|
||||
struct hblkhdr * GC_install_header(h)
|
||||
register struct hblk * h;
|
||||
{
|
||||
hdr * result;
|
||||
|
||||
if (!get_index((word) h)) return(FALSE);
|
||||
result = alloc_hdr();
|
||||
SET_HDR(h, result);
|
||||
# ifdef USE_MUNMAP
|
||||
result -> hb_last_reclaimed = GC_gc_no;
|
||||
# endif
|
||||
return(result);
|
||||
}
|
||||
|
||||
/* Set up forwarding counts for block h of size sz */
|
||||
GC_bool GC_install_counts(h, sz)
|
||||
register struct hblk * h;
|
||||
register word sz; /* bytes */
|
||||
{
|
||||
register struct hblk * hbp;
|
||||
register int i;
|
||||
|
||||
for (hbp = h; (char *)hbp < (char *)h + sz; hbp += BOTTOM_SZ) {
|
||||
if (!get_index((word) hbp)) return(FALSE);
|
||||
}
|
||||
if (!get_index((word)h + sz - 1)) return(FALSE);
|
||||
for (hbp = h + 1; (char *)hbp < (char *)h + sz; hbp += 1) {
|
||||
i = HBLK_PTR_DIFF(hbp, h);
|
||||
SET_HDR(hbp, (hdr *)(i > MAX_JUMP? MAX_JUMP : i));
|
||||
}
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/* Remove the header for block h */
|
||||
void GC_remove_header(h)
|
||||
register struct hblk * h;
|
||||
{
|
||||
hdr ** ha;
|
||||
|
||||
GET_HDR_ADDR(h, ha);
|
||||
free_hdr(*ha);
|
||||
*ha = 0;
|
||||
}
|
||||
|
||||
/* Remove forwarding counts for h */
|
||||
void GC_remove_counts(h, sz)
|
||||
register struct hblk * h;
|
||||
register word sz; /* bytes */
|
||||
{
|
||||
register struct hblk * hbp;
|
||||
|
||||
for (hbp = h+1; (char *)hbp < (char *)h + sz; hbp += 1) {
|
||||
SET_HDR(hbp, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Apply fn to all allocated blocks */
|
||||
/*VARARGS1*/
|
||||
void GC_apply_to_all_blocks(fn, client_data)
|
||||
void (*fn) GC_PROTO((struct hblk *h, word client_data));
|
||||
word client_data;
|
||||
{
|
||||
register int j;
|
||||
register bottom_index * index_p;
|
||||
|
||||
for (index_p = GC_all_bottom_indices; index_p != 0;
|
||||
index_p = index_p -> asc_link) {
|
||||
for (j = BOTTOM_SZ-1; j >= 0;) {
|
||||
if (!IS_FORWARDING_ADDR_OR_NIL(index_p->index[j])) {
|
||||
if (index_p->index[j]->hb_map != GC_invalid_map) {
|
||||
(*fn)(((struct hblk *)
|
||||
(((index_p->key << LOG_BOTTOM_SZ) + (word)j)
|
||||
<< LOG_HBLKSIZE)),
|
||||
client_data);
|
||||
}
|
||||
j--;
|
||||
} else if (index_p->index[j] == 0) {
|
||||
j--;
|
||||
} else {
|
||||
j -= (word)(index_p->index[j]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Get the next valid block whose address is at least h */
|
||||
/* Return 0 if there is none. */
|
||||
struct hblk * GC_next_used_block(h)
|
||||
struct hblk * h;
|
||||
{
|
||||
register bottom_index * bi;
|
||||
register word j = ((word)h >> LOG_HBLKSIZE) & (BOTTOM_SZ-1);
|
||||
|
||||
GET_BI(h, bi);
|
||||
if (bi == GC_all_nils) {
|
||||
register word hi = (word)h >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE);
|
||||
bi = GC_all_bottom_indices;
|
||||
while (bi != 0 && bi -> key < hi) bi = bi -> asc_link;
|
||||
j = 0;
|
||||
}
|
||||
while(bi != 0) {
|
||||
while (j < BOTTOM_SZ) {
|
||||
hdr * hhdr = bi -> index[j];
|
||||
if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
|
||||
j++;
|
||||
} else {
|
||||
if (hhdr->hb_map != GC_invalid_map) {
|
||||
return((struct hblk *)
|
||||
(((bi -> key << LOG_BOTTOM_SZ) + j)
|
||||
<< LOG_HBLKSIZE));
|
||||
} else {
|
||||
j += divHBLKSZ(hhdr -> hb_sz);
|
||||
}
|
||||
}
|
||||
}
|
||||
j = 0;
|
||||
bi = bi -> asc_link;
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Get the last (highest address) block whose address is */
|
||||
/* at most h. Return 0 if there is none. */
|
||||
/* Unlike the above, this may return a free block. */
|
||||
struct hblk * GC_prev_block(h)
|
||||
struct hblk * h;
|
||||
{
|
||||
register bottom_index * bi;
|
||||
register signed_word j = ((word)h >> LOG_HBLKSIZE) & (BOTTOM_SZ-1);
|
||||
|
||||
GET_BI(h, bi);
|
||||
if (bi == GC_all_nils) {
|
||||
register word hi = (word)h >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE);
|
||||
bi = GC_all_bottom_indices_end;
|
||||
while (bi != 0 && bi -> key > hi) bi = bi -> desc_link;
|
||||
j = BOTTOM_SZ - 1;
|
||||
}
|
||||
while(bi != 0) {
|
||||
while (j >= 0) {
|
||||
hdr * hhdr = bi -> index[j];
|
||||
if (0 == hhdr) {
|
||||
--j;
|
||||
} else if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
|
||||
j -= (signed_word)hhdr;
|
||||
} else {
|
||||
return((struct hblk *)
|
||||
(((bi -> key << LOG_BOTTOM_SZ) + j)
|
||||
<< LOG_HBLKSIZE));
|
||||
}
|
||||
}
|
||||
j = BOTTOM_SZ - 1;
|
||||
bi = bi -> desc_link;
|
||||
}
|
||||
return(0);
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
.SPACE $PRIVATE$
|
||||
.SUBSPA $DATA$,QUAD=1,ALIGN=8,ACCESS=31
|
||||
.SUBSPA $BSS$,QUAD=1,ALIGN=8,ACCESS=31,ZERO,SORT=82
|
||||
.SPACE $TEXT$
|
||||
.SUBSPA $LIT$,QUAD=0,ALIGN=8,ACCESS=44
|
||||
.SUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,CODE_ONLY
|
||||
.IMPORT $global$,DATA
|
||||
.IMPORT $$dyncall,MILLICODE
|
||||
.SPACE $TEXT$
|
||||
.SUBSPA $CODE$
|
||||
|
||||
.align 4
|
||||
.EXPORT GC_test_and_clear,ENTRY,PRIV_LEV=3,ARGW0=GR,RTNVAL=GR
|
||||
GC_test_and_clear
|
||||
.PROC
|
||||
.CALLINFO FRAME=0,NO_CALLS
|
||||
.ENTRY
|
||||
ldcw,co (%r26),%r28
|
||||
bv,n 0(%r2)
|
||||
.EXIT
|
||||
.PROCEND
|
||||
@@ -1,12 +0,0 @@
|
||||
.text
|
||||
.align 16
|
||||
.global GC_save_regs_in_stack
|
||||
.proc GC_save_regs_in_stack
|
||||
GC_save_regs_in_stack:
|
||||
.body
|
||||
flushrs
|
||||
;;
|
||||
mov r8=ar.bsp
|
||||
br.ret.sptk.few rp
|
||||
.endp GC_save_regs_in_stack
|
||||
|
||||
@@ -1,28 +0,0 @@
|
||||
/* Conditionally execute a command based on machine and OS from gcconfig.h */
|
||||
|
||||
# include "private/gcconfig.h"
|
||||
# include <stdio.h>
|
||||
# include <string.h>
|
||||
# include <unistd.h>
|
||||
|
||||
int main(argc, argv, envp)
|
||||
int argc;
|
||||
char ** argv;
|
||||
char ** envp;
|
||||
{
|
||||
if (argc < 4) goto Usage;
|
||||
if (strcmp(MACH_TYPE, argv[1]) != 0) return(0);
|
||||
if (strcmp(OS_TYPE, "") != 0 && strcmp(argv[2], "") != 0
|
||||
&& strcmp(OS_TYPE, argv[2]) != 0) return(0);
|
||||
printf("^^^^Starting command^^^^\n");
|
||||
fflush(stdout);
|
||||
execvp(argv[3], argv+3);
|
||||
perror("Couldn't execute");
|
||||
|
||||
Usage:
|
||||
fprintf(stderr, "Usage: %s mach_type os_type command\n", argv[0]);
|
||||
fprintf(stderr, "Currently mach_type = %s, os_type = %s\n",
|
||||
MACH_TYPE, OS_TYPE);
|
||||
return(1);
|
||||
}
|
||||
|
||||
@@ -1,29 +0,0 @@
|
||||
/* Conditionally execute a command based if the file argv[1] doesn't exist */
|
||||
/* Except for execvp, we stick to ANSI C. */
|
||||
# include "private/gcconfig.h"
|
||||
# include <stdio.h>
|
||||
# include <stdlib.h>
|
||||
# include <unistd.h>
|
||||
|
||||
int main(argc, argv, envp)
|
||||
int argc;
|
||||
char ** argv;
|
||||
char ** envp;
|
||||
{
|
||||
FILE * f;
|
||||
if (argc < 3) goto Usage;
|
||||
if ((f = fopen(argv[1], "rb")) != 0
|
||||
|| (f = fopen(argv[1], "r")) != 0) {
|
||||
fclose(f);
|
||||
return(0);
|
||||
}
|
||||
printf("^^^^Starting command^^^^\n");
|
||||
fflush(stdout);
|
||||
execvp(argv[2], argv+2);
|
||||
exit(1);
|
||||
|
||||
Usage:
|
||||
fprintf(stderr, "Usage: %s file_name command\n", argv[0]);
|
||||
return(1);
|
||||
}
|
||||
|
||||
@@ -1,7 +0,0 @@
|
||||
AUTOMAKE_OPTIONS = foreign
|
||||
|
||||
include_HEADERS = gc.h gc_backptr.h gc_local_alloc.h \
|
||||
gc_pthread_redirects.h gc_cpp.h
|
||||
|
||||
|
||||
|
||||
@@ -1,250 +0,0 @@
|
||||
# Makefile.in generated automatically by automake 1.4-p1 from Makefile.am
|
||||
|
||||
# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
|
||||
# This Makefile.in is free software; the Free Software Foundation
|
||||
# gives unlimited permission to copy and/or distribute it,
|
||||
# with or without modifications, as long as this notice is preserved.
|
||||
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
|
||||
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
|
||||
# PARTICULAR PURPOSE.
|
||||
|
||||
|
||||
SHELL = @SHELL@
|
||||
|
||||
srcdir = @srcdir@
|
||||
top_srcdir = @top_srcdir@
|
||||
VPATH = @srcdir@
|
||||
prefix = @prefix@
|
||||
exec_prefix = @exec_prefix@
|
||||
|
||||
bindir = @bindir@
|
||||
sbindir = @sbindir@
|
||||
libexecdir = @libexecdir@
|
||||
datadir = @datadir@
|
||||
sysconfdir = @sysconfdir@
|
||||
sharedstatedir = @sharedstatedir@
|
||||
localstatedir = @localstatedir@
|
||||
libdir = @libdir@
|
||||
infodir = @infodir@
|
||||
mandir = @mandir@
|
||||
includedir = @includedir@
|
||||
oldincludedir = /usr/include
|
||||
|
||||
DESTDIR =
|
||||
|
||||
pkgdatadir = $(datadir)/@PACKAGE@
|
||||
pkglibdir = $(libdir)/@PACKAGE@
|
||||
pkgincludedir = $(includedir)/@PACKAGE@
|
||||
|
||||
top_builddir = ..
|
||||
|
||||
ACLOCAL = @ACLOCAL@
|
||||
AUTOCONF = @AUTOCONF@
|
||||
AUTOMAKE = @AUTOMAKE@
|
||||
AUTOHEADER = @AUTOHEADER@
|
||||
|
||||
INSTALL = @INSTALL@
|
||||
INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS)
|
||||
INSTALL_DATA = @INSTALL_DATA@
|
||||
INSTALL_SCRIPT = @INSTALL_SCRIPT@
|
||||
transform = @program_transform_name@
|
||||
|
||||
NORMAL_INSTALL = :
|
||||
PRE_INSTALL = :
|
||||
POST_INSTALL = :
|
||||
NORMAL_UNINSTALL = :
|
||||
PRE_UNINSTALL = :
|
||||
POST_UNINSTALL = :
|
||||
build_alias = @build_alias@
|
||||
build_triplet = @build@
|
||||
host_alias = @host_alias@
|
||||
host_triplet = @host@
|
||||
target_alias = @target_alias@
|
||||
target_triplet = @target@
|
||||
AR = @AR@
|
||||
AS = @AS@
|
||||
CC = @CC@
|
||||
CPP = @CPP@
|
||||
CXX = @CXX@
|
||||
CXXCPP = @CXXCPP@
|
||||
CXXINCLUDES = @CXXINCLUDES@
|
||||
DLLTOOL = @DLLTOOL@
|
||||
EXEEXT = @EXEEXT@
|
||||
EXTRA_TEST_LIBS = @EXTRA_TEST_LIBS@
|
||||
GCJ = @GCJ@
|
||||
GCJFLAGS = @GCJFLAGS@
|
||||
GC_CFLAGS = @GC_CFLAGS@
|
||||
INCLUDES = @INCLUDES@
|
||||
LIBTOOL = @LIBTOOL@
|
||||
LN_S = @LN_S@
|
||||
MAINT = @MAINT@
|
||||
MAKEINFO = @MAKEINFO@
|
||||
MY_CFLAGS = @MY_CFLAGS@
|
||||
OBJDUMP = @OBJDUMP@
|
||||
OBJEXT = @OBJEXT@
|
||||
PACKAGE = @PACKAGE@
|
||||
RANLIB = @RANLIB@
|
||||
STRIP = @STRIP@
|
||||
THREADLIBS = @THREADLIBS@
|
||||
VERSION = @VERSION@
|
||||
addobjs = @addobjs@
|
||||
gc_basedir = @gc_basedir@
|
||||
mkinstalldirs = @mkinstalldirs@
|
||||
target_all = @target_all@
|
||||
|
||||
AUTOMAKE_OPTIONS = foreign
|
||||
|
||||
include_HEADERS = gc.h gc_backptr.h gc_local_alloc.h gc_pthread_redirects.h gc_cpp.h
|
||||
|
||||
CONFIG_CLEAN_FILES =
|
||||
HEADERS = $(include_HEADERS)
|
||||
|
||||
DIST_COMMON = Makefile.am Makefile.in
|
||||
|
||||
|
||||
DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
|
||||
|
||||
TAR = gtar
|
||||
GZIP_ENV = --best
|
||||
all: all-redirect
|
||||
.SUFFIXES:
|
||||
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4)
|
||||
cd $(top_srcdir) && $(AUTOMAKE) --cygnus include/Makefile
|
||||
|
||||
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
|
||||
cd $(top_builddir) \
|
||||
&& CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
|
||||
|
||||
|
||||
install-includeHEADERS: $(include_HEADERS)
|
||||
@$(NORMAL_INSTALL)
|
||||
$(mkinstalldirs) $(DESTDIR)$(includedir)
|
||||
@list='$(include_HEADERS)'; for p in $$list; do \
|
||||
if test -f "$$p"; then d= ; else d="$(srcdir)/"; fi; \
|
||||
echo " $(INSTALL_DATA) $$d$$p $(DESTDIR)$(includedir)/$$p"; \
|
||||
$(INSTALL_DATA) $$d$$p $(DESTDIR)$(includedir)/$$p; \
|
||||
done
|
||||
|
||||
uninstall-includeHEADERS:
|
||||
@$(NORMAL_UNINSTALL)
|
||||
list='$(include_HEADERS)'; for p in $$list; do \
|
||||
rm -f $(DESTDIR)$(includedir)/$$p; \
|
||||
done
|
||||
|
||||
tags: TAGS
|
||||
|
||||
ID: $(HEADERS) $(SOURCES) $(LISP)
|
||||
list='$(SOURCES) $(HEADERS)'; \
|
||||
unique=`for i in $$list; do echo $$i; done | \
|
||||
awk ' { files[$$0] = 1; } \
|
||||
END { for (i in files) print i; }'`; \
|
||||
here=`pwd` && cd $(srcdir) \
|
||||
&& mkid -f$$here/ID $$unique $(LISP)
|
||||
|
||||
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) $(LISP)
|
||||
tags=; \
|
||||
here=`pwd`; \
|
||||
list='$(SOURCES) $(HEADERS)'; \
|
||||
unique=`for i in $$list; do echo $$i; done | \
|
||||
awk ' { files[$$0] = 1; } \
|
||||
END { for (i in files) print i; }'`; \
|
||||
test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \
|
||||
|| (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags $$unique $(LISP) -o $$here/TAGS)
|
||||
|
||||
mostlyclean-tags:
|
||||
|
||||
clean-tags:
|
||||
|
||||
distclean-tags:
|
||||
-rm -f TAGS ID
|
||||
|
||||
maintainer-clean-tags:
|
||||
|
||||
distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)
|
||||
|
||||
subdir = include
|
||||
|
||||
distdir: $(DISTFILES)
|
||||
@for file in $(DISTFILES); do \
|
||||
if test -f $$file; then d=.; else d=$(srcdir); fi; \
|
||||
if test -d $$d/$$file; then \
|
||||
cp -pr $$d/$$file $(distdir)/$$file; \
|
||||
else \
|
||||
test -f $(distdir)/$$file \
|
||||
|| ln $$d/$$file $(distdir)/$$file 2> /dev/null \
|
||||
|| cp -p $$d/$$file $(distdir)/$$file || :; \
|
||||
fi; \
|
||||
done
|
||||
info-am:
|
||||
info: info-am
|
||||
dvi-am:
|
||||
dvi: dvi-am
|
||||
check-am:
|
||||
check: check-am
|
||||
installcheck-am:
|
||||
installcheck: installcheck-am
|
||||
install-info-am:
|
||||
install-info: install-info-am
|
||||
install-exec-am:
|
||||
install-exec: install-exec-am
|
||||
|
||||
install-data-am: install-includeHEADERS
|
||||
install-data: install-data-am
|
||||
|
||||
install-am: all-am
|
||||
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
|
||||
install: install-am
|
||||
uninstall-am: uninstall-includeHEADERS
|
||||
uninstall: uninstall-am
|
||||
all-am: Makefile $(HEADERS)
|
||||
all-redirect: all-am
|
||||
install-strip:
|
||||
$(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install
|
||||
installdirs:
|
||||
$(mkinstalldirs) $(DESTDIR)$(includedir)
|
||||
|
||||
|
||||
mostlyclean-generic:
|
||||
|
||||
clean-generic:
|
||||
|
||||
distclean-generic:
|
||||
-rm -f Makefile $(CONFIG_CLEAN_FILES)
|
||||
-rm -f config.cache config.log stamp-h stamp-h[0-9]*
|
||||
|
||||
maintainer-clean-generic:
|
||||
mostlyclean-am: mostlyclean-tags mostlyclean-generic
|
||||
|
||||
mostlyclean: mostlyclean-am
|
||||
|
||||
clean-am: clean-tags clean-generic mostlyclean-am
|
||||
|
||||
clean: clean-am
|
||||
|
||||
distclean-am: distclean-tags distclean-generic clean-am
|
||||
-rm -f libtool
|
||||
|
||||
distclean: distclean-am
|
||||
|
||||
maintainer-clean-am: maintainer-clean-tags maintainer-clean-generic \
|
||||
distclean-am
|
||||
@echo "This command is intended for maintainers to use;"
|
||||
@echo "it deletes files that may require special tools to rebuild."
|
||||
|
||||
maintainer-clean: maintainer-clean-am
|
||||
|
||||
.PHONY: uninstall-includeHEADERS install-includeHEADERS tags \
|
||||
mostlyclean-tags distclean-tags clean-tags maintainer-clean-tags \
|
||||
distdir info-am info dvi-am dvi check check-am installcheck-am \
|
||||
installcheck install-info-am install-info install-exec-am install-exec \
|
||||
install-data-am install-data install-am install uninstall-am uninstall \
|
||||
all-redirect all-am all installdirs mostlyclean-generic \
|
||||
distclean-generic clean-generic maintainer-clean-generic clean \
|
||||
mostlyclean distclean maintainer-clean
|
||||
|
||||
|
||||
# Tell versions [3.59,3.63) of GNU make to not export all variables.
|
||||
# Otherwise a system limit (for SysV at least) may be exceeded.
|
||||
.NOEXPORT:
|
||||
@@ -1,327 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*
|
||||
* Author: Hans-J. Boehm (boehm@parc.xerox.com)
|
||||
*/
|
||||
/* Boehm, October 5, 1995 4:20 pm PDT */
|
||||
|
||||
/*
|
||||
* Cords are immutable character strings. A number of operations
|
||||
* on long cords are much more efficient than their strings.h counterpart.
|
||||
* In particular, concatenation takes constant time independent of the length
|
||||
* of the arguments. (Cords are represented as trees, with internal
|
||||
* nodes representing concatenation and leaves consisting of either C
|
||||
* strings or a functional description of the string.)
|
||||
*
|
||||
* The following are reasonable applications of cords. They would perform
|
||||
* unacceptably if C strings were used:
|
||||
* - A compiler that produces assembly language output by repeatedly
|
||||
* concatenating instructions onto a cord representing the output file.
|
||||
* - A text editor that converts the input file to a cord, and then
|
||||
* performs editing operations by producing a new cord representing
|
||||
* the file after echa character change (and keeping the old ones in an
|
||||
* edit history)
|
||||
*
|
||||
* For optimal performance, cords should be built by
|
||||
* concatenating short sections.
|
||||
* This interface is designed for maximum compatibility with C strings.
|
||||
* ASCII NUL characters may be embedded in cords using CORD_from_fn.
|
||||
* This is handled correctly, but CORD_to_char_star will produce a string
|
||||
* with embedded NULs when given such a cord.
|
||||
*
|
||||
* This interface is fairly big, largely for performance reasons.
|
||||
* The most basic constants and functions:
|
||||
*
|
||||
* CORD - the type of a cord;
|
||||
* CORD_EMPTY - empty cord;
|
||||
* CORD_len(cord) - length of a cord;
|
||||
* CORD_cat(cord1,cord2) - concatenation of two cords;
|
||||
* CORD_substr(cord, start, len) - substring (or subcord);
|
||||
* CORD_pos i; CORD_FOR(i, cord) { ... CORD_pos_fetch(i) ... } -
|
||||
* examine each character in a cord. CORD_pos_fetch(i) is the char.
|
||||
* CORD_fetch(int i) - Retrieve i'th character (slowly).
|
||||
* CORD_cmp(cord1, cord2) - compare two cords.
|
||||
* CORD_from_file(FILE * f) - turn a read-only file into a cord.
|
||||
* CORD_to_char_star(cord) - convert to C string.
|
||||
* (Non-NULL C constant strings are cords.)
|
||||
* CORD_printf (etc.) - cord version of printf. Use %r for cords.
|
||||
*/
|
||||
# ifndef CORD_H
|
||||
|
||||
# define CORD_H
|
||||
# include <stddef.h>
|
||||
# include <stdio.h>
|
||||
/* Cords have type const char *. This is cheating quite a bit, and not */
|
||||
/* 100% portable. But it means that nonempty character string */
|
||||
/* constants may be used as cords directly, provided the string is */
|
||||
/* never modified in place. The empty cord is represented by, and */
|
||||
/* can be written as, 0. */
|
||||
|
||||
typedef const char * CORD;
|
||||
|
||||
/* An empty cord is always represented as nil */
|
||||
# define CORD_EMPTY 0
|
||||
|
||||
/* Is a nonempty cord represented as a C string? */
|
||||
#define CORD_IS_STRING(s) (*(s) != '\0')
|
||||
|
||||
/* Concatenate two cords. If the arguments are C strings, they may */
|
||||
/* not be subsequently altered. */
|
||||
CORD CORD_cat(CORD x, CORD y);
|
||||
|
||||
/* Concatenate a cord and a C string with known length. Except for the */
|
||||
/* empty string case, this is a special case of CORD_cat. Since the */
|
||||
/* length is known, it can be faster. */
|
||||
/* The string y is shared with the resulting CORD. Hence it should */
|
||||
/* not be altered by the caller. */
|
||||
CORD CORD_cat_char_star(CORD x, const char * y, size_t leny);
|
||||
|
||||
/* Compute the length of a cord */
|
||||
size_t CORD_len(CORD x);
|
||||
|
||||
/* Cords may be represented by functions defining the ith character */
|
||||
typedef char (* CORD_fn)(size_t i, void * client_data);
|
||||
|
||||
/* Turn a functional description into a cord. */
|
||||
CORD CORD_from_fn(CORD_fn fn, void * client_data, size_t len);
|
||||
|
||||
/* Return the substring (subcord really) of x with length at most n, */
|
||||
/* starting at position i. (The initial character has position 0.) */
|
||||
CORD CORD_substr(CORD x, size_t i, size_t n);
|
||||
|
||||
/* Return the argument, but rebalanced to allow more efficient */
|
||||
/* character retrieval, substring operations, and comparisons. */
|
||||
/* This is useful only for cords that were built using repeated */
|
||||
/* concatenation. Guarantees log time access to the result, unless */
|
||||
/* x was obtained through a large number of repeated substring ops */
|
||||
/* or the embedded functional descriptions take longer to evaluate. */
|
||||
/* May reallocate significant parts of the cord. The argument is not */
|
||||
/* modified; only the result is balanced. */
|
||||
CORD CORD_balance(CORD x);
|
||||
|
||||
/* The following traverse a cord by applying a function to each */
|
||||
/* character. This is occasionally appropriate, especially where */
|
||||
/* speed is crucial. But, since C doesn't have nested functions, */
|
||||
/* clients of this sort of traversal are clumsy to write. Consider */
|
||||
/* the functions that operate on cord positions instead. */
|
||||
|
||||
/* Function to iteratively apply to individual characters in cord. */
|
||||
typedef int (* CORD_iter_fn)(char c, void * client_data);
|
||||
|
||||
/* Function to apply to substrings of a cord. Each substring is a */
|
||||
/* a C character string, not a general cord. */
|
||||
typedef int (* CORD_batched_iter_fn)(const char * s, void * client_data);
|
||||
# define CORD_NO_FN ((CORD_batched_iter_fn)0)
|
||||
|
||||
/* Apply f1 to each character in the cord, in ascending order, */
|
||||
/* starting at position i. If */
|
||||
/* f2 is not CORD_NO_FN, then multiple calls to f1 may be replaced by */
|
||||
/* a single call to f2. The parameter f2 is provided only to allow */
|
||||
/* some optimization by the client. This terminates when the right */
|
||||
/* end of this string is reached, or when f1 or f2 return != 0. In the */
|
||||
/* latter case CORD_iter returns != 0. Otherwise it returns 0. */
|
||||
/* The specified value of i must be < CORD_len(x). */
|
||||
int CORD_iter5(CORD x, size_t i, CORD_iter_fn f1,
|
||||
CORD_batched_iter_fn f2, void * client_data);
|
||||
|
||||
/* A simpler version that starts at 0, and without f2: */
|
||||
int CORD_iter(CORD x, CORD_iter_fn f1, void * client_data);
|
||||
# define CORD_iter(x, f1, cd) CORD_iter5(x, 0, f1, CORD_NO_FN, cd)
|
||||
|
||||
/* Similar to CORD_iter5, but end-to-beginning. No provisions for */
|
||||
/* CORD_batched_iter_fn. */
|
||||
int CORD_riter4(CORD x, size_t i, CORD_iter_fn f1, void * client_data);
|
||||
|
||||
/* A simpler version that starts at the end: */
|
||||
int CORD_riter(CORD x, CORD_iter_fn f1, void * client_data);
|
||||
|
||||
/* Functions that operate on cord positions. The easy way to traverse */
|
||||
/* cords. A cord position is logically a pair consisting of a cord */
|
||||
/* and an index into that cord. But it is much faster to retrieve a */
|
||||
/* charcter based on a position than on an index. Unfortunately, */
|
||||
/* positions are big (order of a few 100 bytes), so allocate them with */
|
||||
/* caution. */
|
||||
/* Things in cord_pos.h should be treated as opaque, except as */
|
||||
/* described below. Also note that */
|
||||
/* CORD_pos_fetch, CORD_next and CORD_prev have both macro and function */
|
||||
/* definitions. The former may evaluate their argument more than once. */
|
||||
# include "private/cord_pos.h"
|
||||
|
||||
/*
|
||||
Visible definitions from above:
|
||||
|
||||
typedef <OPAQUE but fairly big> CORD_pos[1];
|
||||
|
||||
* Extract the cord from a position:
|
||||
CORD CORD_pos_to_cord(CORD_pos p);
|
||||
|
||||
* Extract the current index from a position:
|
||||
size_t CORD_pos_to_index(CORD_pos p);
|
||||
|
||||
* Fetch the character located at the given position:
|
||||
char CORD_pos_fetch(CORD_pos p);
|
||||
|
||||
* Initialize the position to refer to the given cord and index.
|
||||
* Note that this is the most expensive function on positions:
|
||||
void CORD_set_pos(CORD_pos p, CORD x, size_t i);
|
||||
|
||||
* Advance the position to the next character.
|
||||
* P must be initialized and valid.
|
||||
* Invalidates p if past end:
|
||||
void CORD_next(CORD_pos p);
|
||||
|
||||
* Move the position to the preceding character.
|
||||
* P must be initialized and valid.
|
||||
* Invalidates p if past beginning:
|
||||
void CORD_prev(CORD_pos p);
|
||||
|
||||
* Is the position valid, i.e. inside the cord?
|
||||
int CORD_pos_valid(CORD_pos p);
|
||||
*/
|
||||
# define CORD_FOR(pos, cord) \
|
||||
for (CORD_set_pos(pos, cord, 0); CORD_pos_valid(pos); CORD_next(pos))
|
||||
|
||||
|
||||
/* An out of memory handler to call. May be supplied by client. */
|
||||
/* Must not return. */
|
||||
extern void (* CORD_oom_fn)(void);
|
||||
|
||||
/* Dump the representation of x to stdout in an implementation defined */
|
||||
/* manner. Intended for debugging only. */
|
||||
void CORD_dump(CORD x);
|
||||
|
||||
/* The following could easily be implemented by the client. They are */
|
||||
/* provided in cordxtra.c for convenience. */
|
||||
|
||||
/* Concatenate a character to the end of a cord. */
|
||||
CORD CORD_cat_char(CORD x, char c);
|
||||
|
||||
/* Concatenate n cords. */
|
||||
CORD CORD_catn(int n, /* CORD */ ...);
|
||||
|
||||
/* Return the character in CORD_substr(x, i, 1) */
|
||||
char CORD_fetch(CORD x, size_t i);
|
||||
|
||||
/* Return < 0, 0, or > 0, depending on whether x < y, x = y, x > y */
|
||||
int CORD_cmp(CORD x, CORD y);
|
||||
|
||||
/* A generalization that takes both starting positions for the */
|
||||
/* comparison, and a limit on the number of characters to be compared. */
|
||||
int CORD_ncmp(CORD x, size_t x_start, CORD y, size_t y_start, size_t len);
|
||||
|
||||
/* Find the first occurrence of s in x at position start or later. */
|
||||
/* Return the position of the first character of s in x, or */
|
||||
/* CORD_NOT_FOUND if there is none. */
|
||||
size_t CORD_str(CORD x, size_t start, CORD s);
|
||||
|
||||
/* Return a cord consisting of i copies of (possibly NUL) c. Dangerous */
|
||||
/* in conjunction with CORD_to_char_star. */
|
||||
/* The resulting representation takes constant space, independent of i. */
|
||||
CORD CORD_chars(char c, size_t i);
|
||||
# define CORD_nul(i) CORD_chars('\0', (i))
|
||||
|
||||
/* Turn a file into cord. The file must be seekable. Its contents */
|
||||
/* must remain constant. The file may be accessed as an immediate */
|
||||
/* result of this call and/or as a result of subsequent accesses to */
|
||||
/* the cord. Short files are likely to be immediately read, but */
|
||||
/* long files are likely to be read on demand, possibly relying on */
|
||||
/* stdio for buffering. */
|
||||
/* We must have exclusive access to the descriptor f, i.e. we may */
|
||||
/* read it at any time, and expect the file pointer to be */
|
||||
/* where we left it. Normally this should be invoked as */
|
||||
/* CORD_from_file(fopen(...)) */
|
||||
/* CORD_from_file arranges to close the file descriptor when it is no */
|
||||
/* longer needed (e.g. when the result becomes inaccessible). */
|
||||
/* The file f must be such that ftell reflects the actual character */
|
||||
/* position in the file, i.e. the number of characters that can be */
|
||||
/* or were read with fread. On UNIX systems this is always true. On */
|
||||
/* MS Windows systems, f must be opened in binary mode. */
|
||||
CORD CORD_from_file(FILE * f);
|
||||
|
||||
/* Equivalent to the above, except that the entire file will be read */
|
||||
/* and the file pointer will be closed immediately. */
|
||||
/* The binary mode restriction from above does not apply. */
|
||||
CORD CORD_from_file_eager(FILE * f);
|
||||
|
||||
/* Equivalent to the above, except that the file will be read on demand.*/
|
||||
/* The binary mode restriction applies. */
|
||||
CORD CORD_from_file_lazy(FILE * f);
|
||||
|
||||
/* Turn a cord into a C string. The result shares no structure with */
|
||||
/* x, and is thus modifiable. */
|
||||
char * CORD_to_char_star(CORD x);
|
||||
|
||||
/* Turn a C string into a CORD. The C string is copied, and so may */
|
||||
/* subsequently be modified. */
|
||||
CORD CORD_from_char_star(const char *s);
|
||||
|
||||
/* Identical to the above, but the result may share structure with */
|
||||
/* the argument and is thus not modifiable. */
|
||||
const char * CORD_to_const_char_star(CORD x);
|
||||
|
||||
/* Write a cord to a file, starting at the current position. No */
|
||||
/* trailing NULs are newlines are added. */
|
||||
/* Returns EOF if a write error occurs, 1 otherwise. */
|
||||
int CORD_put(CORD x, FILE * f);
|
||||
|
||||
/* "Not found" result for the following two functions. */
|
||||
# define CORD_NOT_FOUND ((size_t)(-1))
|
||||
|
||||
/* A vague analog of strchr. Returns the position (an integer, not */
|
||||
/* a pointer) of the first occurrence of (char) c inside x at position */
|
||||
/* i or later. The value i must be < CORD_len(x). */
|
||||
size_t CORD_chr(CORD x, size_t i, int c);
|
||||
|
||||
/* A vague analog of strrchr. Returns index of the last occurrence */
|
||||
/* of (char) c inside x at position i or earlier. The value i */
|
||||
/* must be < CORD_len(x). */
|
||||
size_t CORD_rchr(CORD x, size_t i, int c);
|
||||
|
||||
|
||||
/* The following are also not primitive, but are implemented in */
|
||||
/* cordprnt.c. They provide functionality similar to the ANSI C */
|
||||
/* functions with corresponding names, but with the following */
|
||||
/* additions and changes: */
|
||||
/* 1. A %r conversion specification specifies a CORD argument. Field */
|
||||
/* width, precision, etc. have the same semantics as for %s. */
|
||||
/* (Note that %c,%C, and %S were already taken.) */
|
||||
/* 2. The format string is represented as a CORD. */
|
||||
/* 3. CORD_sprintf and CORD_vsprintf assign the result through the 1st */ /* argument. Unlike their ANSI C versions, there is no need to guess */
|
||||
/* the correct buffer size. */
|
||||
/* 4. Most of the conversions are implement through the native */
|
||||
/* vsprintf. Hence they are usually no faster, and */
|
||||
/* idiosyncracies of the native printf are preserved. However, */
|
||||
/* CORD arguments to CORD_sprintf and CORD_vsprintf are NOT copied; */
|
||||
/* the result shares the original structure. This may make them */
|
||||
/* very efficient in some unusual applications. */
|
||||
/* The format string is copied. */
|
||||
/* All functions return the number of characters generated or -1 on */
|
||||
/* error. This complies with the ANSI standard, but is inconsistent */
|
||||
/* with some older implementations of sprintf. */
|
||||
|
||||
/* The implementation of these is probably less portable than the rest */
|
||||
/* of this package. */
|
||||
|
||||
#ifndef CORD_NO_IO
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
int CORD_sprintf(CORD * out, CORD format, ...);
|
||||
int CORD_vsprintf(CORD * out, CORD format, va_list args);
|
||||
int CORD_fprintf(FILE * f, CORD format, ...);
|
||||
int CORD_vfprintf(FILE * f, CORD format, va_list args);
|
||||
int CORD_printf(CORD format, ...);
|
||||
int CORD_vprintf(CORD format, va_list args);
|
||||
|
||||
#endif /* CORD_NO_IO */
|
||||
|
||||
# endif /* CORD_H */
|
||||
@@ -1,70 +0,0 @@
|
||||
# ifndef EC_H
|
||||
# define EC_H
|
||||
|
||||
# ifndef CORD_H
|
||||
# include "cord.h"
|
||||
# endif
|
||||
|
||||
/* Extensible cords are strings that may be destructively appended to. */
|
||||
/* They allow fast construction of cords from characters that are */
|
||||
/* being read from a stream. */
|
||||
/*
|
||||
* A client might look like:
|
||||
*
|
||||
* {
|
||||
* CORD_ec x;
|
||||
* CORD result;
|
||||
* char c;
|
||||
* FILE *f;
|
||||
*
|
||||
* ...
|
||||
* CORD_ec_init(x);
|
||||
* while(...) {
|
||||
* c = getc(f);
|
||||
* ...
|
||||
* CORD_ec_append(x, c);
|
||||
* }
|
||||
* result = CORD_balance(CORD_ec_to_cord(x));
|
||||
*
|
||||
* If a C string is desired as the final result, the call to CORD_balance
|
||||
* may be replaced by a call to CORD_to_char_star.
|
||||
*/
|
||||
|
||||
# ifndef CORD_BUFSZ
|
||||
# define CORD_BUFSZ 128
|
||||
# endif
|
||||
|
||||
typedef struct CORD_ec_struct {
|
||||
CORD ec_cord;
|
||||
char * ec_bufptr;
|
||||
char ec_buf[CORD_BUFSZ+1];
|
||||
} CORD_ec[1];
|
||||
|
||||
/* This structure represents the concatenation of ec_cord with */
|
||||
/* ec_buf[0 ... (ec_bufptr-ec_buf-1)] */
|
||||
|
||||
/* Flush the buffer part of the extended chord into ec_cord. */
|
||||
/* Note that this is almost the only real function, and it is */
|
||||
/* implemented in 6 lines in cordxtra.c */
|
||||
void CORD_ec_flush_buf(CORD_ec x);
|
||||
|
||||
/* Convert an extensible cord to a cord. */
|
||||
# define CORD_ec_to_cord(x) (CORD_ec_flush_buf(x), (x)[0].ec_cord)
|
||||
|
||||
/* Initialize an extensible cord. */
|
||||
# define CORD_ec_init(x) ((x)[0].ec_cord = 0, (x)[0].ec_bufptr = (x)[0].ec_buf)
|
||||
|
||||
/* Append a character to an extensible cord. */
|
||||
# define CORD_ec_append(x, c) \
|
||||
{ \
|
||||
if ((x)[0].ec_bufptr == (x)[0].ec_buf + CORD_BUFSZ) { \
|
||||
CORD_ec_flush_buf(x); \
|
||||
} \
|
||||
*((x)[0].ec_bufptr)++ = (c); \
|
||||
}
|
||||
|
||||
/* Append a cord to an extensible cord. Structure remains shared with */
|
||||
/* original. */
|
||||
void CORD_ec_append_cord(CORD_ec x, CORD s);
|
||||
|
||||
# endif /* EC_H */
|
||||
@@ -1,922 +0,0 @@
|
||||
/*
|
||||
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
|
||||
* Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved.
|
||||
* Copyright 1996-1999 by Silicon Graphics. All rights reserved.
|
||||
* Copyright 1999 by Hewlett-Packard Company. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Note that this defines a large number of tuning hooks, which can
|
||||
* safely be ignored in nearly all cases. For normal use it suffices
|
||||
* to call only GC_MALLOC and perhaps GC_REALLOC.
|
||||
* For better performance, also look at GC_MALLOC_ATOMIC, and
|
||||
* GC_enable_incremental. If you need an action to be performed
|
||||
* immediately before an object is collected, look at GC_register_finalizer.
|
||||
* If you are using Solaris threads, look at the end of this file.
|
||||
* Everything else is best ignored unless you encounter performance
|
||||
* problems.
|
||||
*/
|
||||
|
||||
#ifndef _GC_H
|
||||
|
||||
# define _GC_H
|
||||
|
||||
/*
|
||||
* Some tests for old macros. These violate our namespace rules and will
|
||||
* disappear shortly. Use the GC_ names.
|
||||
*/
|
||||
#if defined(SOLARIS_THREADS) || defined(_SOLARIS_THREADS)
|
||||
# define GC_SOLARIS_THREADS
|
||||
#endif
|
||||
#if defined(_SOLARIS_PTHREADS)
|
||||
# define GC_SOLARIS_PTHREADS
|
||||
#endif
|
||||
#if defined(IRIX_THREADS)
|
||||
# define GC_IRIX_THREADS
|
||||
#endif
|
||||
#if defined(HPUX_THREADS)
|
||||
# define GC_HPUX_THREADS
|
||||
#endif
|
||||
#if defined(OSF1_THREADS)
|
||||
# define GC_OSF1_THREADS
|
||||
#endif
|
||||
#if defined(LINUX_THREADS)
|
||||
# define GC_LINUX_THREADS
|
||||
#endif
|
||||
#if defined(WIN32_THREADS)
|
||||
# define GC_WIN32_THREADS
|
||||
#endif
|
||||
#if defined(USE_LD_WRAP)
|
||||
# define GC_USE_LD_WRAP
|
||||
#endif
|
||||
|
||||
#if !defined(_REENTRANT) && (defined(GC_SOLARIS_THREADS) \
|
||||
|| defined(GC_SOLARIS_PTHREADS) \
|
||||
|| defined(GC_HPUX_THREADS) \
|
||||
|| defined(GC_LINUX_THREADS))
|
||||
# define _REENTRANT
|
||||
/* Better late than never. This fails if system headers that */
|
||||
/* depend on this were previously included. */
|
||||
#endif
|
||||
|
||||
#if defined(GC_SOLARIS_PTHREADS) && !defined(GC_SOLARIS_THREADS)
|
||||
# define GC_SOLARIS_THREADS
|
||||
#endif
|
||||
|
||||
# if defined(GC_SOLARIS_PTHREADS) || defined(GC_FREEBSD_THREADS) || \
|
||||
defined(GC_IRIX_THREADS) || defined(GC_LINUX_THREADS) || \
|
||||
defined(GC_HPUX_THREADS) || defined(GC_OSF1_THREADS)
|
||||
# define GC_PTHREADS
|
||||
# endif
|
||||
|
||||
# define __GC
|
||||
# include <stddef.h>
|
||||
# ifdef _WIN32_WCE
|
||||
/* Yet more kluges for WinCE */
|
||||
# include <stdlib.h> /* size_t is defined here */
|
||||
typedef long ptrdiff_t; /* ptrdiff_t is not defined */
|
||||
# endif
|
||||
|
||||
#if defined(__MINGW32__) && defined(GC_WIN32_THREADS)
|
||||
# ifdef GC_BUILD
|
||||
# define GC_API __declspec(dllexport)
|
||||
# else
|
||||
# define GC_API __declspec(dllimport)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if (defined(__DMC__) || defined(_MSC_VER)) \
|
||||
&& (defined(_DLL) && !defined(GC_NOT_DLL) \
|
||||
|| defined(GC_DLL))
|
||||
# ifdef GC_BUILD
|
||||
# define GC_API extern __declspec(dllexport)
|
||||
# else
|
||||
# define GC_API __declspec(dllimport)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if defined(__WATCOMC__) && defined(GC_DLL)
|
||||
# ifdef GC_BUILD
|
||||
# define GC_API extern __declspec(dllexport)
|
||||
# else
|
||||
# define GC_API extern __declspec(dllimport)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef GC_API
|
||||
#define GC_API extern
|
||||
#endif
|
||||
|
||||
# if defined(__STDC__) || defined(__cplusplus)
|
||||
# define GC_PROTO(args) args
|
||||
typedef void * GC_PTR;
|
||||
# define GC_CONST const
|
||||
# else
|
||||
# define GC_PROTO(args) ()
|
||||
typedef char * GC_PTR;
|
||||
# define GC_CONST
|
||||
# endif
|
||||
|
||||
# ifdef __cplusplus
|
||||
extern "C" {
|
||||
# endif
|
||||
|
||||
|
||||
/* Define word and signed_word to be unsigned and signed types of the */
|
||||
/* size as char * or void *. There seems to be no way to do this */
|
||||
/* even semi-portably. The following is probably no better/worse */
|
||||
/* than almost anything else. */
|
||||
/* The ANSI standard suggests that size_t and ptr_diff_t might be */
|
||||
/* better choices. But those appear to have incorrect definitions */
|
||||
/* on may systems. Notably "typedef int size_t" seems to be both */
|
||||
/* frequent and WRONG. */
|
||||
typedef unsigned long GC_word;
|
||||
typedef long GC_signed_word;
|
||||
|
||||
/* Public read-only variables */
|
||||
|
||||
GC_API GC_word GC_gc_no;/* Counter incremented per collection. */
|
||||
/* Includes empty GCs at startup. */
|
||||
|
||||
GC_API int GC_parallel; /* GC is parallelized for performance on */
|
||||
/* multiprocessors. Currently set only */
|
||||
/* implicitly if collector is built with */
|
||||
/* -DPARALLEL_MARK and if either: */
|
||||
/* Env variable GC_NPROC is set to > 1, or */
|
||||
/* GC_NPROC is not set and this is an MP. */
|
||||
/* If GC_parallel is set, incremental */
|
||||
/* collection is aonly partially functional, */
|
||||
/* and may not be desirable. */
|
||||
|
||||
|
||||
/* Public R/W variables */
|
||||
|
||||
GC_API GC_PTR (*GC_oom_fn) GC_PROTO((size_t bytes_requested));
|
||||
/* When there is insufficient memory to satisfy */
|
||||
/* an allocation request, we return */
|
||||
/* (*GC_oom_fn)(). By default this just */
|
||||
/* returns 0. */
|
||||
/* If it returns, it must return 0 or a valid */
|
||||
/* pointer to a previously allocated heap */
|
||||
/* object. */
|
||||
|
||||
GC_API int GC_find_leak;
|
||||
/* Do not actually garbage collect, but simply */
|
||||
/* report inaccessible memory that was not */
|
||||
/* deallocated with GC_free. Initial value */
|
||||
/* is determined by FIND_LEAK macro. */
|
||||
|
||||
GC_API int GC_all_interior_pointers;
|
||||
/* Arrange for pointers to object interiors to */
|
||||
/* be recognized as valid. May not be changed */
|
||||
/* after GC initialization. */
|
||||
/* Initial value is determined by */
|
||||
/* -DALL_INTERIOR_POINTERS. */
|
||||
/* Unless DONT_ADD_BYTE_AT_END is defined, this */
|
||||
/* also affects whether sizes are increased by */
|
||||
/* at least a byte to allow "off the end" */
|
||||
/* pointer recognition. */
|
||||
/* MUST BE 0 or 1. */
|
||||
|
||||
GC_API int GC_quiet; /* Disable statistics output. Only matters if */
|
||||
/* collector has been compiled with statistics */
|
||||
/* enabled. This involves a performance cost, */
|
||||
/* and is thus not the default. */
|
||||
|
||||
GC_API int GC_finalize_on_demand;
|
||||
/* If nonzero, finalizers will only be run in */
|
||||
/* response to an explicit GC_invoke_finalizers */
|
||||
/* call. The default is determined by whether */
|
||||
/* the FINALIZE_ON_DEMAND macro is defined */
|
||||
/* when the collector is built. */
|
||||
|
||||
GC_API int GC_java_finalization;
|
||||
/* Mark objects reachable from finalizable */
|
||||
/* objects in a separate postpass. This makes */
|
||||
/* it a bit safer to use non-topologically- */
|
||||
/* ordered finalization. Default value is */
|
||||
/* determined by JAVA_FINALIZATION macro. */
|
||||
|
||||
GC_API void (* GC_finalizer_notifier)();
|
||||
/* Invoked by the collector when there are */
|
||||
/* objects to be finalized. Invoked at most */
|
||||
/* once per GC cycle. Never invoked unless */
|
||||
/* GC_finalize_on_demand is set. */
|
||||
/* Typically this will notify a finalization */
|
||||
/* thread, which will call GC_invoke_finalizers */
|
||||
/* in response. */
|
||||
|
||||
GC_API int GC_dont_gc; /* Dont collect unless explicitly requested, e.g. */
|
||||
/* because it's not safe. */
|
||||
|
||||
GC_API int GC_dont_expand;
|
||||
/* Dont expand heap unless explicitly requested */
|
||||
/* or forced to. */
|
||||
|
||||
GC_API int GC_use_entire_heap;
|
||||
/* Causes the nonincremental collector to use the */
|
||||
/* entire heap before collecting. This was the only */
|
||||
/* option for GC versions < 5.0. This sometimes */
|
||||
/* results in more large block fragmentation, since */
|
||||
/* very larg blocks will tend to get broken up */
|
||||
/* during each GC cycle. It is likely to result in a */
|
||||
/* larger working set, but lower collection */
|
||||
/* frequencies, and hence fewer instructions executed */
|
||||
/* in the collector. */
|
||||
|
||||
GC_API int GC_full_freq; /* Number of partial collections between */
|
||||
/* full collections. Matters only if */
|
||||
/* GC_incremental is set. */
|
||||
/* Full collections are also triggered if */
|
||||
/* the collector detects a substantial */
|
||||
/* increase in the number of in-use heap */
|
||||
/* blocks. Values in the tens are now */
|
||||
/* perfectly reasonable, unlike for */
|
||||
/* earlier GC versions. */
|
||||
|
||||
GC_API GC_word GC_non_gc_bytes;
|
||||
/* Bytes not considered candidates for collection. */
|
||||
/* Used only to control scheduling of collections. */
|
||||
/* Updated by GC_malloc_uncollectable and GC_free. */
|
||||
/* Wizards only. */
|
||||
|
||||
GC_API int GC_no_dls;
|
||||
/* Don't register dynamic library data segments. */
|
||||
/* Wizards only. Should be used only if the */
|
||||
/* application explicitly registers all roots. */
|
||||
/* In Microsoft Windows environments, this will */
|
||||
/* usually also prevent registration of the */
|
||||
/* main data segment as part of the root set. */
|
||||
|
||||
GC_API GC_word GC_free_space_divisor;
|
||||
/* We try to make sure that we allocate at */
|
||||
/* least N/GC_free_space_divisor bytes between */
|
||||
/* collections, where N is the heap size plus */
|
||||
/* a rough estimate of the root set size. */
|
||||
/* Initially, GC_free_space_divisor = 4. */
|
||||
/* Increasing its value will use less space */
|
||||
/* but more collection time. Decreasing it */
|
||||
/* will appreciably decrease collection time */
|
||||
/* at the expense of space. */
|
||||
/* GC_free_space_divisor = 1 will effectively */
|
||||
/* disable collections. */
|
||||
|
||||
GC_API GC_word GC_max_retries;
|
||||
/* The maximum number of GCs attempted before */
|
||||
/* reporting out of memory after heap */
|
||||
/* expansion fails. Initially 0. */
|
||||
|
||||
|
||||
GC_API char *GC_stackbottom; /* Cool end of user stack. */
|
||||
/* May be set in the client prior to */
|
||||
/* calling any GC_ routines. This */
|
||||
/* avoids some overhead, and */
|
||||
/* potentially some signals that can */
|
||||
/* confuse debuggers. Otherwise the */
|
||||
/* collector attempts to set it */
|
||||
/* automatically. */
|
||||
/* For multithreaded code, this is the */
|
||||
/* cold end of the stack for the */
|
||||
/* primordial thread. */
|
||||
|
||||
GC_API int GC_dont_precollect; /* Don't collect as part of */
|
||||
/* initialization. Should be set only */
|
||||
/* if the client wants a chance to */
|
||||
/* manually initialize the root set */
|
||||
/* before the first collection. */
|
||||
/* Interferes with blacklisting. */
|
||||
/* Wizards only. */
|
||||
|
||||
/* Public procedures */
|
||||
|
||||
/* Initialize the collector. This is only required when using thread-local
|
||||
* allocation, since unlike the regular allocation routines, GC_local_malloc
|
||||
* is not self-initializing. If you use GC_local_malloc you should arrange
|
||||
* to call this somehow (e.g. from a constructor) before doing any allocation.
|
||||
*/
|
||||
GC_API void GC_init GC_PROTO((void));
|
||||
|
||||
/*
|
||||
* general purpose allocation routines, with roughly malloc calling conv.
|
||||
* The atomic versions promise that no relevant pointers are contained
|
||||
* in the object. The nonatomic versions guarantee that the new object
|
||||
* is cleared. GC_malloc_stubborn promises that no changes to the object
|
||||
* will occur after GC_end_stubborn_change has been called on the
|
||||
* result of GC_malloc_stubborn. GC_malloc_uncollectable allocates an object
|
||||
* that is scanned for pointers to collectable objects, but is not itself
|
||||
* collectable. The object is scanned even if it does not appear to
|
||||
* be reachable. GC_malloc_uncollectable and GC_free called on the resulting
|
||||
* object implicitly update GC_non_gc_bytes appropriately.
|
||||
*
|
||||
* Note that the GC_malloc_stubborn support is stubbed out by default
|
||||
* starting in 6.0. GC_malloc_stubborn is an alias for GC_malloc unless
|
||||
* the collector is built with STUBBORN_ALLOC defined.
|
||||
*/
|
||||
GC_API GC_PTR GC_malloc GC_PROTO((size_t size_in_bytes));
|
||||
GC_API GC_PTR GC_malloc_atomic GC_PROTO((size_t size_in_bytes));
|
||||
GC_API GC_PTR GC_malloc_uncollectable GC_PROTO((size_t size_in_bytes));
|
||||
GC_API GC_PTR GC_malloc_stubborn GC_PROTO((size_t size_in_bytes));
|
||||
|
||||
/* The following is only defined if the library has been suitably */
|
||||
/* compiled: */
|
||||
GC_API GC_PTR GC_malloc_atomic_uncollectable GC_PROTO((size_t size_in_bytes));
|
||||
|
||||
/* Explicitly deallocate an object. Dangerous if used incorrectly. */
|
||||
/* Requires a pointer to the base of an object. */
|
||||
/* If the argument is stubborn, it should not be changeable when freed. */
|
||||
/* An object should not be enable for finalization when it is */
|
||||
/* explicitly deallocated. */
|
||||
/* GC_free(0) is a no-op, as required by ANSI C for free. */
|
||||
GC_API void GC_free GC_PROTO((GC_PTR object_addr));
|
||||
|
||||
/*
|
||||
* Stubborn objects may be changed only if the collector is explicitly informed.
|
||||
* The collector is implicitly informed of coming change when such
|
||||
* an object is first allocated. The following routines inform the
|
||||
* collector that an object will no longer be changed, or that it will
|
||||
* once again be changed. Only nonNIL pointer stores into the object
|
||||
* are considered to be changes. The argument to GC_end_stubborn_change
|
||||
* must be exacly the value returned by GC_malloc_stubborn or passed to
|
||||
* GC_change_stubborn. (In the second case it may be an interior pointer
|
||||
* within 512 bytes of the beginning of the objects.)
|
||||
* There is a performance penalty for allowing more than
|
||||
* one stubborn object to be changed at once, but it is acceptable to
|
||||
* do so. The same applies to dropping stubborn objects that are still
|
||||
* changeable.
|
||||
*/
|
||||
GC_API void GC_change_stubborn GC_PROTO((GC_PTR));
|
||||
GC_API void GC_end_stubborn_change GC_PROTO((GC_PTR));
|
||||
|
||||
/* Return a pointer to the base (lowest address) of an object given */
|
||||
/* a pointer to a location within the object. */
|
||||
/* I.e. map an interior pointer to the corresponding bas pointer. */
|
||||
/* Note that with debugging allocation, this returns a pointer to the */
|
||||
/* actual base of the object, i.e. the debug information, not to */
|
||||
/* the base of the user object. */
|
||||
/* Return 0 if displaced_pointer doesn't point to within a valid */
|
||||
/* object. */
|
||||
GC_API GC_PTR GC_base GC_PROTO((GC_PTR displaced_pointer));
|
||||
|
||||
/* Given a pointer to the base of an object, return its size in bytes. */
|
||||
/* The returned size may be slightly larger than what was originally */
|
||||
/* requested. */
|
||||
GC_API size_t GC_size GC_PROTO((GC_PTR object_addr));
|
||||
|
||||
/* For compatibility with C library. This is occasionally faster than */
|
||||
/* a malloc followed by a bcopy. But if you rely on that, either here */
|
||||
/* or with the standard C library, your code is broken. In my */
|
||||
/* opinion, it shouldn't have been invented, but now we're stuck. -HB */
|
||||
/* The resulting object has the same kind as the original. */
|
||||
/* If the argument is stubborn, the result will have changes enabled. */
|
||||
/* It is an error to have changes enabled for the original object. */
|
||||
/* Follows ANSI comventions for NULL old_object. */
|
||||
GC_API GC_PTR GC_realloc
|
||||
GC_PROTO((GC_PTR old_object, size_t new_size_in_bytes));
|
||||
|
||||
/* Explicitly increase the heap size. */
|
||||
/* Returns 0 on failure, 1 on success. */
|
||||
GC_API int GC_expand_hp GC_PROTO((size_t number_of_bytes));
|
||||
|
||||
/* Limit the heap size to n bytes. Useful when you're debugging, */
|
||||
/* especially on systems that don't handle running out of memory well. */
|
||||
/* n == 0 ==> unbounded. This is the default. */
|
||||
GC_API void GC_set_max_heap_size GC_PROTO((GC_word n));
|
||||
|
||||
/* Inform the collector that a certain section of statically allocated */
|
||||
/* memory contains no pointers to garbage collected memory. Thus it */
|
||||
/* need not be scanned. This is sometimes important if the application */
|
||||
/* maps large read/write files into the address space, which could be */
|
||||
/* mistaken for dynamic library data segments on some systems. */
|
||||
GC_API void GC_exclude_static_roots GC_PROTO((GC_PTR start, GC_PTR finish));
|
||||
|
||||
/* Clear the set of root segments. Wizards only. */
|
||||
GC_API void GC_clear_roots GC_PROTO((void));
|
||||
|
||||
/* Add a root segment. Wizards only. */
|
||||
GC_API void GC_add_roots GC_PROTO((char * low_address,
|
||||
char * high_address_plus_1));
|
||||
|
||||
/* Add a displacement to the set of those considered valid by the */
|
||||
/* collector. GC_register_displacement(n) means that if p was returned */
|
||||
/* by GC_malloc, then (char *)p + n will be considered to be a valid */
|
||||
/* pointer to n. N must be small and less than the size of p. */
|
||||
/* (All pointers to the interior of objects from the stack are */
|
||||
/* considered valid in any case. This applies to heap objects and */
|
||||
/* static data.) */
|
||||
/* Preferably, this should be called before any other GC procedures. */
|
||||
/* Calling it later adds to the probability of excess memory */
|
||||
/* retention. */
|
||||
/* This is a no-op if the collector was compiled with recognition of */
|
||||
/* arbitrary interior pointers enabled, which is now the default. */
|
||||
GC_API void GC_register_displacement GC_PROTO((GC_word n));
|
||||
|
||||
/* The following version should be used if any debugging allocation is */
|
||||
/* being done. */
|
||||
GC_API void GC_debug_register_displacement GC_PROTO((GC_word n));
|
||||
|
||||
/* Explicitly trigger a full, world-stop collection. */
|
||||
GC_API void GC_gcollect GC_PROTO((void));
|
||||
|
||||
/* Trigger a full world-stopped collection. Abort the collection if */
|
||||
/* and when stop_func returns a nonzero value. Stop_func will be */
|
||||
/* called frequently, and should be reasonably fast. This works even */
|
||||
/* if virtual dirty bits, and hence incremental collection is not */
|
||||
/* available for this architecture. Collections can be aborted faster */
|
||||
/* than normal pause times for incremental collection. However, */
|
||||
/* aborted collections do no useful work; the next collection needs */
|
||||
/* to start from the beginning. */
|
||||
/* Return 0 if the collection was aborted, 1 if it succeeded. */
|
||||
typedef int (* GC_stop_func) GC_PROTO((void));
|
||||
GC_API int GC_try_to_collect GC_PROTO((GC_stop_func stop_func));
|
||||
|
||||
/* Return the number of bytes in the heap. Excludes collector private */
|
||||
/* data structures. Includes empty blocks and fragmentation loss. */
|
||||
/* Includes some pages that were allocated but never written. */
|
||||
GC_API size_t GC_get_heap_size GC_PROTO((void));
|
||||
|
||||
/* Return a lower bound on the number of free bytes in the heap. */
|
||||
GC_API size_t GC_get_free_bytes GC_PROTO((void));
|
||||
|
||||
/* Return the number of bytes allocated since the last collection. */
|
||||
GC_API size_t GC_get_bytes_since_gc GC_PROTO((void));
|
||||
|
||||
/* Return the total number of bytes allocated in this process. */
|
||||
/* Never decreases. */
|
||||
GC_API size_t GC_get_total_bytes GC_PROTO((void));
|
||||
|
||||
/* Enable incremental/generational collection. */
|
||||
/* Not advisable unless dirty bits are */
|
||||
/* available or most heap objects are */
|
||||
/* pointerfree(atomic) or immutable. */
|
||||
/* Don't use in leak finding mode. */
|
||||
/* Ignored if GC_dont_gc is true. */
|
||||
/* Only the generational piece of this is */
|
||||
/* functional if GC_parallel is TRUE. */
|
||||
GC_API void GC_enable_incremental GC_PROTO((void));
|
||||
|
||||
/* Perform some garbage collection work, if appropriate. */
|
||||
/* Return 0 if there is no more work to be done. */
|
||||
/* Typically performs an amount of work corresponding roughly */
|
||||
/* to marking from one page. May do more work if further */
|
||||
/* progress requires it, e.g. if incremental collection is */
|
||||
/* disabled. It is reasonable to call this in a wait loop */
|
||||
/* until it returns 0. */
|
||||
GC_API int GC_collect_a_little GC_PROTO((void));
|
||||
|
||||
/* Allocate an object of size lb bytes. The client guarantees that */
|
||||
/* as long as the object is live, it will be referenced by a pointer */
|
||||
/* that points to somewhere within the first 256 bytes of the object. */
|
||||
/* (This should normally be declared volatile to prevent the compiler */
|
||||
/* from invalidating this assertion.) This routine is only useful */
|
||||
/* if a large array is being allocated. It reduces the chance of */
|
||||
/* accidentally retaining such an array as a result of scanning an */
|
||||
/* integer that happens to be an address inside the array. (Actually, */
|
||||
/* it reduces the chance of the allocator not finding space for such */
|
||||
/* an array, since it will try hard to avoid introducing such a false */
|
||||
/* reference.) On a SunOS 4.X or MS Windows system this is recommended */
|
||||
/* for arrays likely to be larger than 100K or so. For other systems, */
|
||||
/* or if the collector is not configured to recognize all interior */
|
||||
/* pointers, the threshold is normally much higher. */
|
||||
GC_API GC_PTR GC_malloc_ignore_off_page GC_PROTO((size_t lb));
|
||||
GC_API GC_PTR GC_malloc_atomic_ignore_off_page GC_PROTO((size_t lb));
|
||||
|
||||
#if defined(__sgi) && !defined(__GNUC__) && _COMPILER_VERSION >= 720
|
||||
# define GC_ADD_CALLER
|
||||
# define GC_RETURN_ADDR (GC_word)__return_address
|
||||
#endif
|
||||
|
||||
#ifdef GC_ADD_CALLER
|
||||
# define GC_EXTRAS GC_RETURN_ADDR, __FILE__, __LINE__
|
||||
# define GC_EXTRA_PARAMS GC_word ra, GC_CONST char * s, int i
|
||||
#else
|
||||
# define GC_EXTRAS __FILE__, __LINE__
|
||||
# define GC_EXTRA_PARAMS GC_CONST char * s, int i
|
||||
#endif
|
||||
|
||||
/* Debugging (annotated) allocation. GC_gcollect will check */
|
||||
/* objects allocated in this way for overwrites, etc. */
|
||||
GC_API GC_PTR GC_debug_malloc
|
||||
GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS));
|
||||
GC_API GC_PTR GC_debug_malloc_atomic
|
||||
GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS));
|
||||
GC_API GC_PTR GC_debug_malloc_uncollectable
|
||||
GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS));
|
||||
GC_API GC_PTR GC_debug_malloc_stubborn
|
||||
GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS));
|
||||
GC_API void GC_debug_free GC_PROTO((GC_PTR object_addr));
|
||||
GC_API GC_PTR GC_debug_realloc
|
||||
GC_PROTO((GC_PTR old_object, size_t new_size_in_bytes,
|
||||
GC_EXTRA_PARAMS));
|
||||
|
||||
GC_API void GC_debug_change_stubborn GC_PROTO((GC_PTR));
|
||||
GC_API void GC_debug_end_stubborn_change GC_PROTO((GC_PTR));
|
||||
# ifdef GC_DEBUG
|
||||
# define GC_MALLOC(sz) GC_debug_malloc(sz, GC_EXTRAS)
|
||||
# define GC_MALLOC_ATOMIC(sz) GC_debug_malloc_atomic(sz, GC_EXTRAS)
|
||||
# define GC_MALLOC_UNCOLLECTABLE(sz) GC_debug_malloc_uncollectable(sz, \
|
||||
GC_EXTRAS)
|
||||
# define GC_REALLOC(old, sz) GC_debug_realloc(old, sz, GC_EXTRAS)
|
||||
# define GC_FREE(p) GC_debug_free(p)
|
||||
# define GC_REGISTER_FINALIZER(p, f, d, of, od) \
|
||||
GC_debug_register_finalizer(p, f, d, of, od)
|
||||
# define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \
|
||||
GC_debug_register_finalizer_ignore_self(p, f, d, of, od)
|
||||
# define GC_REGISTER_FINALIZER_NO_ORDER(p, f, d, of, od) \
|
||||
GC_debug_register_finalizer_no_order(p, f, d, of, od)
|
||||
# define GC_MALLOC_STUBBORN(sz) GC_debug_malloc_stubborn(sz, GC_EXTRAS);
|
||||
# define GC_CHANGE_STUBBORN(p) GC_debug_change_stubborn(p)
|
||||
# define GC_END_STUBBORN_CHANGE(p) GC_debug_end_stubborn_change(p)
|
||||
# define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \
|
||||
GC_general_register_disappearing_link(link, GC_base(obj))
|
||||
# define GC_REGISTER_DISPLACEMENT(n) GC_debug_register_displacement(n)
|
||||
# else
|
||||
# define GC_MALLOC(sz) GC_malloc(sz)
|
||||
# define GC_MALLOC_ATOMIC(sz) GC_malloc_atomic(sz)
|
||||
# define GC_MALLOC_UNCOLLECTABLE(sz) GC_malloc_uncollectable(sz)
|
||||
# define GC_REALLOC(old, sz) GC_realloc(old, sz)
|
||||
# define GC_FREE(p) GC_free(p)
|
||||
# define GC_REGISTER_FINALIZER(p, f, d, of, od) \
|
||||
GC_register_finalizer(p, f, d, of, od)
|
||||
# define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \
|
||||
GC_register_finalizer_ignore_self(p, f, d, of, od)
|
||||
# define GC_REGISTER_FINALIZER_NO_ORDER(p, f, d, of, od) \
|
||||
GC_register_finalizer_no_order(p, f, d, of, od)
|
||||
# define GC_MALLOC_STUBBORN(sz) GC_malloc_stubborn(sz)
|
||||
# define GC_CHANGE_STUBBORN(p) GC_change_stubborn(p)
|
||||
# define GC_END_STUBBORN_CHANGE(p) GC_end_stubborn_change(p)
|
||||
# define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \
|
||||
GC_general_register_disappearing_link(link, obj)
|
||||
# define GC_REGISTER_DISPLACEMENT(n) GC_register_displacement(n)
|
||||
# endif
|
||||
/* The following are included because they are often convenient, and */
|
||||
/* reduce the chance for a misspecifed size argument. But calls may */
|
||||
/* expand to something syntactically incorrect if t is a complicated */
|
||||
/* type expression. */
|
||||
# define GC_NEW(t) (t *)GC_MALLOC(sizeof (t))
|
||||
# define GC_NEW_ATOMIC(t) (t *)GC_MALLOC_ATOMIC(sizeof (t))
|
||||
# define GC_NEW_STUBBORN(t) (t *)GC_MALLOC_STUBBORN(sizeof (t))
|
||||
# define GC_NEW_UNCOLLECTABLE(t) (t *)GC_MALLOC_UNCOLLECTABLE(sizeof (t))
|
||||
|
||||
/* Finalization. Some of these primitives are grossly unsafe. */
|
||||
/* The idea is to make them both cheap, and sufficient to build */
|
||||
/* a safer layer, closer to PCedar finalization. */
|
||||
/* The interface represents my conclusions from a long discussion */
|
||||
/* with Alan Demers, Dan Greene, Carl Hauser, Barry Hayes, */
|
||||
/* Christian Jacobi, and Russ Atkinson. It's not perfect, and */
|
||||
/* probably nobody else agrees with it. Hans-J. Boehm 3/13/92 */
|
||||
typedef void (*GC_finalization_proc)
|
||||
GC_PROTO((GC_PTR obj, GC_PTR client_data));
|
||||
|
||||
GC_API void GC_register_finalizer
|
||||
GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
|
||||
GC_finalization_proc *ofn, GC_PTR *ocd));
|
||||
GC_API void GC_debug_register_finalizer
|
||||
GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
|
||||
GC_finalization_proc *ofn, GC_PTR *ocd));
|
||||
/* When obj is no longer accessible, invoke */
|
||||
/* (*fn)(obj, cd). If a and b are inaccessible, and */
|
||||
/* a points to b (after disappearing links have been */
|
||||
/* made to disappear), then only a will be */
|
||||
/* finalized. (If this does not create any new */
|
||||
/* pointers to b, then b will be finalized after the */
|
||||
/* next collection.) Any finalizable object that */
|
||||
/* is reachable from itself by following one or more */
|
||||
/* pointers will not be finalized (or collected). */
|
||||
/* Thus cycles involving finalizable objects should */
|
||||
/* be avoided, or broken by disappearing links. */
|
||||
/* All but the last finalizer registered for an object */
|
||||
/* is ignored. */
|
||||
/* Finalization may be removed by passing 0 as fn. */
|
||||
/* Finalizers are implicitly unregistered just before */
|
||||
/* they are invoked. */
|
||||
/* The old finalizer and client data are stored in */
|
||||
/* *ofn and *ocd. */
|
||||
/* Fn is never invoked on an accessible object, */
|
||||
/* provided hidden pointers are converted to real */
|
||||
/* pointers only if the allocation lock is held, and */
|
||||
/* such conversions are not performed by finalization */
|
||||
/* routines. */
|
||||
/* If GC_register_finalizer is aborted as a result of */
|
||||
/* a signal, the object may be left with no */
|
||||
/* finalization, even if neither the old nor new */
|
||||
/* finalizer were NULL. */
|
||||
/* Obj should be the nonNULL starting address of an */
|
||||
/* object allocated by GC_malloc or friends. */
|
||||
/* Note that any garbage collectable object referenced */
|
||||
/* by cd will be considered accessible until the */
|
||||
/* finalizer is invoked. */
|
||||
|
||||
/* Another versions of the above follow. It ignores */
|
||||
/* self-cycles, i.e. pointers from a finalizable object to */
|
||||
/* itself. There is a stylistic argument that this is wrong, */
|
||||
/* but it's unavoidable for C++, since the compiler may */
|
||||
/* silently introduce these. It's also benign in that specific */
|
||||
/* case. */
|
||||
/* Note that cd will still be viewed as accessible, even if it */
|
||||
/* refers to the object itself. */
|
||||
GC_API void GC_register_finalizer_ignore_self
|
||||
GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
|
||||
GC_finalization_proc *ofn, GC_PTR *ocd));
|
||||
GC_API void GC_debug_register_finalizer_ignore_self
|
||||
GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
|
||||
GC_finalization_proc *ofn, GC_PTR *ocd));
|
||||
|
||||
/* Another version of the above. It ignores all cycles. */
|
||||
/* It should probably only be used by Java implementations. */
|
||||
/* Note that cd will still be viewed as accessible, even if it */
|
||||
/* refers to the object itself. */
|
||||
GC_API void GC_register_finalizer_no_order
|
||||
GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
|
||||
GC_finalization_proc *ofn, GC_PTR *ocd));
|
||||
GC_API void GC_debug_register_finalizer_no_order
|
||||
GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
|
||||
GC_finalization_proc *ofn, GC_PTR *ocd));
|
||||
|
||||
|
||||
/* The following routine may be used to break cycles between */
|
||||
/* finalizable objects, thus causing cyclic finalizable */
|
||||
/* objects to be finalized in the correct order. Standard */
|
||||
/* use involves calling GC_register_disappearing_link(&p), */
|
||||
/* where p is a pointer that is not followed by finalization */
|
||||
/* code, and should not be considered in determining */
|
||||
/* finalization order. */
|
||||
GC_API int GC_register_disappearing_link GC_PROTO((GC_PTR * /* link */));
|
||||
/* Link should point to a field of a heap allocated */
|
||||
/* object obj. *link will be cleared when obj is */
|
||||
/* found to be inaccessible. This happens BEFORE any */
|
||||
/* finalization code is invoked, and BEFORE any */
|
||||
/* decisions about finalization order are made. */
|
||||
/* This is useful in telling the finalizer that */
|
||||
/* some pointers are not essential for proper */
|
||||
/* finalization. This may avoid finalization cycles. */
|
||||
/* Note that obj may be resurrected by another */
|
||||
/* finalizer, and thus the clearing of *link may */
|
||||
/* be visible to non-finalization code. */
|
||||
/* There's an argument that an arbitrary action should */
|
||||
/* be allowed here, instead of just clearing a pointer. */
|
||||
/* But this causes problems if that action alters, or */
|
||||
/* examines connectivity. */
|
||||
/* Returns 1 if link was already registered, 0 */
|
||||
/* otherwise. */
|
||||
/* Only exists for backward compatibility. See below: */
|
||||
|
||||
GC_API int GC_general_register_disappearing_link
|
||||
GC_PROTO((GC_PTR * /* link */, GC_PTR obj));
|
||||
/* A slight generalization of the above. *link is */
|
||||
/* cleared when obj first becomes inaccessible. This */
|
||||
/* can be used to implement weak pointers easily and */
|
||||
/* safely. Typically link will point to a location */
|
||||
/* holding a disguised pointer to obj. (A pointer */
|
||||
/* inside an "atomic" object is effectively */
|
||||
/* disguised.) In this way soft */
|
||||
/* pointers are broken before any object */
|
||||
/* reachable from them are finalized. Each link */
|
||||
/* May be registered only once, i.e. with one obj */
|
||||
/* value. This was added after a long email discussion */
|
||||
/* with John Ellis. */
|
||||
/* Obj must be a pointer to the first word of an object */
|
||||
/* we allocated. It is unsafe to explicitly deallocate */
|
||||
/* the object containing link. Explicitly deallocating */
|
||||
/* obj may or may not cause link to eventually be */
|
||||
/* cleared. */
|
||||
GC_API int GC_unregister_disappearing_link GC_PROTO((GC_PTR * /* link */));
|
||||
/* Returns 0 if link was not actually registered. */
|
||||
/* Undoes a registration by either of the above two */
|
||||
/* routines. */
|
||||
|
||||
/* Auxiliary fns to make finalization work correctly with displaced */
|
||||
/* pointers introduced by the debugging allocators. */
|
||||
GC_API GC_PTR GC_make_closure GC_PROTO((GC_finalization_proc fn, GC_PTR data));
|
||||
GC_API void GC_debug_invoke_finalizer GC_PROTO((GC_PTR obj, GC_PTR data));
|
||||
|
||||
/* Returns !=0 if GC_invoke_finalizers has something to do. */
|
||||
GC_API int GC_should_invoke_finalizers GC_PROTO((void));
|
||||
|
||||
GC_API int GC_invoke_finalizers GC_PROTO((void));
|
||||
/* Run finalizers for all objects that are ready to */
|
||||
/* be finalized. Return the number of finalizers */
|
||||
/* that were run. Normally this is also called */
|
||||
/* implicitly during some allocations. If */
|
||||
/* GC-finalize_on_demand is nonzero, it must be called */
|
||||
/* explicitly. */
|
||||
|
||||
/* GC_set_warn_proc can be used to redirect or filter warning messages. */
|
||||
/* p may not be a NULL pointer. */
|
||||
typedef void (*GC_warn_proc) GC_PROTO((char *msg, GC_word arg));
|
||||
GC_API GC_warn_proc GC_set_warn_proc GC_PROTO((GC_warn_proc p));
|
||||
/* Returns old warning procedure. */
|
||||
|
||||
/* The following is intended to be used by a higher level */
|
||||
/* (e.g. Java-like) finalization facility. It is expected */
|
||||
/* that finalization code will arrange for hidden pointers to */
|
||||
/* disappear. Otherwise objects can be accessed after they */
|
||||
/* have been collected. */
|
||||
/* Note that putting pointers in atomic objects or in */
|
||||
/* nonpointer slots of "typed" objects is equivalent to */
|
||||
/* disguising them in this way, and may have other advantages. */
|
||||
# if defined(I_HIDE_POINTERS) || defined(GC_I_HIDE_POINTERS)
|
||||
typedef GC_word GC_hidden_pointer;
|
||||
# define HIDE_POINTER(p) (~(GC_hidden_pointer)(p))
|
||||
# define REVEAL_POINTER(p) ((GC_PTR)(HIDE_POINTER(p)))
|
||||
/* Converting a hidden pointer to a real pointer requires verifying */
|
||||
/* that the object still exists. This involves acquiring the */
|
||||
/* allocator lock to avoid a race with the collector. */
|
||||
# endif /* I_HIDE_POINTERS */
|
||||
|
||||
typedef GC_PTR (*GC_fn_type) GC_PROTO((GC_PTR client_data));
|
||||
GC_API GC_PTR GC_call_with_alloc_lock
|
||||
GC_PROTO((GC_fn_type fn, GC_PTR client_data));
|
||||
|
||||
/* The following routines are primarily intended for use with a */
|
||||
/* preprocessor which inserts calls to check C pointer arithmetic. */
|
||||
|
||||
/* Check that p and q point to the same object. */
|
||||
/* Fail conspicuously if they don't. */
|
||||
/* Returns the first argument. */
|
||||
/* Succeeds if neither p nor q points to the heap. */
|
||||
/* May succeed if both p and q point to between heap objects. */
|
||||
GC_API GC_PTR GC_same_obj GC_PROTO((GC_PTR p, GC_PTR q));
|
||||
|
||||
/* Checked pointer pre- and post- increment operations. Note that */
|
||||
/* the second argument is in units of bytes, not multiples of the */
|
||||
/* object size. This should either be invoked from a macro, or the */
|
||||
/* call should be automatically generated. */
|
||||
GC_API GC_PTR GC_pre_incr GC_PROTO((GC_PTR *p, size_t how_much));
|
||||
GC_API GC_PTR GC_post_incr GC_PROTO((GC_PTR *p, size_t how_much));
|
||||
|
||||
/* Check that p is visible */
|
||||
/* to the collector as a possibly pointer containing location. */
|
||||
/* If it isn't fail conspicuously. */
|
||||
/* Returns the argument in all cases. May erroneously succeed */
|
||||
/* in hard cases. (This is intended for debugging use with */
|
||||
/* untyped allocations. The idea is that it should be possible, though */
|
||||
/* slow, to add such a call to all indirect pointer stores.) */
|
||||
/* Currently useless for multithreaded worlds. */
|
||||
GC_API GC_PTR GC_is_visible GC_PROTO((GC_PTR p));
|
||||
|
||||
/* Check that if p is a pointer to a heap page, then it points to */
|
||||
/* a valid displacement within a heap object. */
|
||||
/* Fail conspicuously if this property does not hold. */
|
||||
/* Uninteresting with GC_all_interior_pointers. */
|
||||
/* Always returns its argument. */
|
||||
GC_API GC_PTR GC_is_valid_displacement GC_PROTO((GC_PTR p));
|
||||
|
||||
/* Safer, but slow, pointer addition. Probably useful mainly with */
|
||||
/* a preprocessor. Useful only for heap pointers. */
|
||||
#ifdef GC_DEBUG
|
||||
# define GC_PTR_ADD3(x, n, type_of_result) \
|
||||
((type_of_result)GC_same_obj((x)+(n), (x)))
|
||||
# define GC_PRE_INCR3(x, n, type_of_result) \
|
||||
((type_of_result)GC_pre_incr(&(x), (n)*sizeof(*x))
|
||||
# define GC_POST_INCR2(x, type_of_result) \
|
||||
((type_of_result)GC_post_incr(&(x), sizeof(*x))
|
||||
# ifdef __GNUC__
|
||||
# define GC_PTR_ADD(x, n) \
|
||||
GC_PTR_ADD3(x, n, typeof(x))
|
||||
# define GC_PRE_INCR(x, n) \
|
||||
GC_PRE_INCR3(x, n, typeof(x))
|
||||
# define GC_POST_INCR(x, n) \
|
||||
GC_POST_INCR3(x, typeof(x))
|
||||
# else
|
||||
/* We can't do this right without typeof, which ANSI */
|
||||
/* decided was not sufficiently useful. Repeatedly */
|
||||
/* mentioning the arguments seems too dangerous to be */
|
||||
/* useful. So does not casting the result. */
|
||||
# define GC_PTR_ADD(x, n) ((x)+(n))
|
||||
# endif
|
||||
#else /* !GC_DEBUG */
|
||||
# define GC_PTR_ADD3(x, n, type_of_result) ((x)+(n))
|
||||
# define GC_PTR_ADD(x, n) ((x)+(n))
|
||||
# define GC_PRE_INCR3(x, n, type_of_result) ((x) += (n))
|
||||
# define GC_PRE_INCR(x, n) ((x) += (n))
|
||||
# define GC_POST_INCR2(x, n, type_of_result) ((x)++)
|
||||
# define GC_POST_INCR(x, n) ((x)++)
|
||||
#endif
|
||||
|
||||
/* Safer assignment of a pointer to a nonstack location. */
|
||||
#ifdef GC_DEBUG
|
||||
# ifdef __STDC__
|
||||
# define GC_PTR_STORE(p, q) \
|
||||
(*(void **)GC_is_visible(p) = GC_is_valid_displacement(q))
|
||||
# else
|
||||
# define GC_PTR_STORE(p, q) \
|
||||
(*(char **)GC_is_visible(p) = GC_is_valid_displacement(q))
|
||||
# endif
|
||||
#else /* !GC_DEBUG */
|
||||
# define GC_PTR_STORE(p, q) *((p) = (q))
|
||||
#endif
|
||||
|
||||
/* Fynctions called to report pointer checking errors */
|
||||
GC_API void (*GC_same_obj_print_proc) GC_PROTO((GC_PTR p, GC_PTR q));
|
||||
|
||||
GC_API void (*GC_is_valid_displacement_print_proc)
|
||||
GC_PROTO((GC_PTR p));
|
||||
|
||||
GC_API void (*GC_is_visible_print_proc)
|
||||
GC_PROTO((GC_PTR p));
|
||||
|
||||
|
||||
/* For pthread support, we generally need to intercept a number of */
|
||||
/* thread library calls. We do that here by macro defining them. */
|
||||
|
||||
#if !defined(GC_USE_LD_WRAP) && \
|
||||
(defined(GC_PTHREADS) || defined(GC_SOLARIS_THREADS))
|
||||
# include "gc_pthread_redirects.h"
|
||||
#endif
|
||||
|
||||
# if defined(PCR) || defined(GC_SOLARIS_THREADS) || \
|
||||
defined(GC_PTHREADS) || defined(GC_WIN32_THREADS)
|
||||
/* Any flavor of threads except SRC_M3. */
|
||||
/* This returns a list of objects, linked through their first */
|
||||
/* word. Its use can greatly reduce lock contention problems, since */
|
||||
/* the allocation lock can be acquired and released many fewer times. */
|
||||
/* lb must be large enough to hold the pointer field. */
|
||||
/* It is used internally by gc_local_alloc.h, which provides a simpler */
|
||||
/* programming interface on Linux. */
|
||||
GC_PTR GC_malloc_many(size_t lb);
|
||||
#define GC_NEXT(p) (*(GC_PTR *)(p)) /* Retrieve the next element */
|
||||
/* in returned list. */
|
||||
extern void GC_thr_init(); /* Needed for Solaris/X86 */
|
||||
|
||||
#endif /* THREADS && !SRC_M3 */
|
||||
|
||||
#if defined(GC_WIN32_THREADS) && defined(_WIN32_WCE)
|
||||
# include <windows.h>
|
||||
|
||||
/*
|
||||
* win32_threads.c implements the real WinMain, which will start a new thread
|
||||
* to call GC_WinMain after initializing the garbage collector.
|
||||
*/
|
||||
int WINAPI GC_WinMain(
|
||||
HINSTANCE hInstance,
|
||||
HINSTANCE hPrevInstance,
|
||||
LPWSTR lpCmdLine,
|
||||
int nCmdShow );
|
||||
|
||||
/*
|
||||
* All threads must be created using GC_CreateThread, so that they will be
|
||||
* recorded in the thread table.
|
||||
*/
|
||||
HANDLE WINAPI GC_CreateThread(
|
||||
LPSECURITY_ATTRIBUTES lpThreadAttributes,
|
||||
DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress,
|
||||
LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId );
|
||||
|
||||
# ifndef GC_BUILD
|
||||
# define WinMain GC_WinMain
|
||||
# define CreateThread GC_CreateThread
|
||||
# endif
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
* If you are planning on putting
|
||||
* the collector in a SunOS 5 dynamic library, you need to call GC_INIT()
|
||||
* from the statically loaded program section.
|
||||
* This circumvents a Solaris 2.X (X<=4) linker bug.
|
||||
*/
|
||||
#if defined(sparc) || defined(__sparc)
|
||||
# define GC_INIT() { extern end, etext; \
|
||||
GC_noop(&end, &etext); }
|
||||
#else
|
||||
# if defined(__CYGWIN32__) && defined(GC_USE_DLL)
|
||||
/*
|
||||
* Similarly gnu-win32 DLLs need explicit initialization
|
||||
*/
|
||||
# define GC_INIT() { GC_add_roots(DATASTART, DATAEND); }
|
||||
# else
|
||||
# define GC_INIT()
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if !defined(_WIN32_WCE) \
|
||||
&& ((defined(_MSDOS) || defined(_MSC_VER)) && (_M_IX86 >= 300) \
|
||||
|| defined(_WIN32) && !defined(__CYGWIN32__) && !defined(__CYGWIN__))
|
||||
/* win32S may not free all resources on process exit. */
|
||||
/* This explicitly deallocates the heap. */
|
||||
GC_API void GC_win32_free_heap ();
|
||||
#endif
|
||||
|
||||
#if ( defined(_AMIGA) && !defined(GC_AMIGA_MAKINGLIB) )
|
||||
/* Allocation really goes through GC_amiga_allocwrapper_do */
|
||||
# include "gc_amiga_redirects.h"
|
||||
#endif
|
||||
|
||||
#if defined(GC_REDIRECT_TO_LOCAL) && !defined(GC_LOCAL_ALLOC_H)
|
||||
# include "gc_local_alloc.h"
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* end of extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* _GC_H */
|
||||
@@ -1,383 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 1996-1998 by Silicon Graphics. All rights reserved.
|
||||
*
|
||||
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
|
||||
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
|
||||
*
|
||||
* Permission is hereby granted to use or copy this program
|
||||
* for any purpose, provided the above notices are retained on all copies.
|
||||
* Permission to modify the code and to distribute modified code is granted,
|
||||
* provided the above notices are retained, and a notice that the code was
|
||||
* modified is included with the above copyright notice.
|
||||
*/
|
||||
|
||||
//
|
||||
// This is a C++ header file that is intended to replace the SGI STL
|
||||
// alloc.h. This assumes SGI STL version < 3.0.
|
||||
//
|
||||
// This assumes the collector has been compiled with -DATOMIC_UNCOLLECTABLE
|
||||
// and -DALL_INTERIOR_POINTERS. We also recommend
|
||||
// -DREDIRECT_MALLOC=GC_uncollectable_malloc.
|
||||
//
|
||||
// Some of this could be faster in the explicit deallocation case. In particular,
|
||||
// we spend too much time clearing objects on the free lists. That could be avoided.
|
||||
//
|
||||
// This uses template classes with static members, and hence does not work
|
||||
// with g++ 2.7.2 and earlier.
|
||||
//
|
||||
// This code assumes that the collector itself has been compiled with a
|
||||
// compiler that defines __STDC__ .
|
||||
//
|
||||
|
||||
#include "gc.h"
|
||||
|
||||
#ifndef GC_ALLOC_H
|
||||
|
||||
#define GC_ALLOC_H
|
||||
#define __ALLOC_H // Prevent inclusion of the default version. Ugly.
|
||||
#define __SGI_STL_ALLOC_H
|
||||
#define __SGI_STL_INTERNAL_ALLOC_H
|
||||
|
||||
#ifndef __ALLOC
|
||||
# define __ALLOC alloc
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
|
||||
// The following is just replicated from the conventional SGI alloc.h:
|
||||
|
||||
template<class T, class alloc>
|
||||
class simple_alloc {
|
||||
|
||||
public:
|
||||
static T *allocate(size_t n)
|
||||
{ return 0 == n? 0 : (T*) alloc::allocate(n * sizeof (T)); }
|
||||
static T *allocate(void)
|
||||
{ return (T*) alloc::allocate(sizeof (T)); }
|
||||
static void deallocate(T *p, size_t n)
|
||||
{ if (0 != n) alloc::deallocate(p, n * sizeof (T)); }
|
||||
static void deallocate(T *p)
|
||||
{ alloc::deallocate(p, sizeof (T)); }
|
||||
};
|
||||
|
||||
#include "gc.h"
|
||||
|
||||
// The following need to match collector data structures.
|
||||
// We can't include gc_priv.h, since that pulls in way too much stuff.
|
||||
// This should eventually be factored out into another include file.
|
||||
|
||||
extern "C" {
|
||||
extern void ** const GC_objfreelist_ptr;
|
||||
extern void ** const GC_aobjfreelist_ptr;
|
||||
extern void ** const GC_uobjfreelist_ptr;
|
||||
extern void ** const GC_auobjfreelist_ptr;
|
||||
|
||||
extern void GC_incr_words_allocd(size_t words);
|
||||
extern void GC_incr_mem_freed(size_t words);
|
||||
|
||||
extern char * GC_generic_malloc_words_small(size_t word, int kind);
|
||||
}
|
||||
|
||||
// Object kinds; must match PTRFREE, NORMAL, UNCOLLECTABLE, and
|
||||
// AUNCOLLECTABLE in gc_priv.h.
|
||||
|
||||
enum { GC_PTRFREE = 0, GC_NORMAL = 1, GC_UNCOLLECTABLE = 2,
|
||||
GC_AUNCOLLECTABLE = 3 };
|
||||
|
||||
enum { GC_max_fast_bytes = 255 };
|
||||
|
||||
enum { GC_bytes_per_word = sizeof(char *) };
|
||||
|
||||
enum { GC_byte_alignment = 8 };
|
||||
|
||||
enum { GC_word_alignment = GC_byte_alignment/GC_bytes_per_word };
|
||||
|
||||
inline void * &GC_obj_link(void * p)
|
||||
{ return *(void **)p; }
|
||||
|
||||
// Compute a number of words >= n+1 bytes.
|
||||
// The +1 allows for pointers one past the end.
|
||||
inline size_t GC_round_up(size_t n)
|
||||
{
|
||||
return ((n + GC_byte_alignment)/GC_byte_alignment)*GC_word_alignment;
|
||||
}
|
||||
|
||||
// The same but don't allow for extra byte.
|
||||
inline size_t GC_round_up_uncollectable(size_t n)
|
||||
{
|
||||
return ((n + GC_byte_alignment - 1)/GC_byte_alignment)*GC_word_alignment;
|
||||
}
|
||||
|
||||
template <int dummy>
|
||||
class GC_aux_template {
|
||||
public:
|
||||
// File local count of allocated words. Occasionally this is
|
||||
// added into the global count. A separate count is necessary since the
|
||||
// real one must be updated with a procedure call.
|
||||
static size_t GC_words_recently_allocd;
|
||||
|
||||
// Same for uncollectable mmory. Not yet reflected in either
|
||||
// GC_words_recently_allocd or GC_non_gc_bytes.
|
||||
static size_t GC_uncollectable_words_recently_allocd;
|
||||
|
||||
// Similar counter for explicitly deallocated memory.
|
||||
static size_t GC_mem_recently_freed;
|
||||
|
||||
// Again for uncollectable memory.
|
||||
static size_t GC_uncollectable_mem_recently_freed;
|
||||
|
||||
static void * GC_out_of_line_malloc(size_t nwords, int kind);
|
||||
};
|
||||
|
||||
template <int dummy>
|
||||
size_t GC_aux_template<dummy>::GC_words_recently_allocd = 0;
|
||||
|
||||
template <int dummy>
|
||||
size_t GC_aux_template<dummy>::GC_uncollectable_words_recently_allocd = 0;
|
||||
|
||||
template <int dummy>
|
||||
size_t GC_aux_template<dummy>::GC_mem_recently_freed = 0;
|
||||
|
||||
template <int dummy>
|
||||
size_t GC_aux_template<dummy>::GC_uncollectable_mem_recently_freed = 0;
|
||||
|
||||
template <int dummy>
|
||||
void * GC_aux_template<dummy>::GC_out_of_line_malloc(size_t nwords, int kind)
|
||||
{
|
||||
GC_words_recently_allocd += GC_uncollectable_words_recently_allocd;
|
||||
GC_non_gc_bytes +=
|
||||
GC_bytes_per_word * GC_uncollectable_words_recently_allocd;
|
||||
GC_uncollectable_words_recently_allocd = 0;
|
||||
|
||||
GC_mem_recently_freed += GC_uncollectable_mem_recently_freed;
|
||||
GC_non_gc_bytes -=
|
||||
GC_bytes_per_word * GC_uncollectable_mem_recently_freed;
|
||||
GC_uncollectable_mem_recently_freed = 0;
|
||||
|
||||
GC_incr_words_allocd(GC_words_recently_allocd);
|
||||
GC_words_recently_allocd = 0;
|
||||
|
||||
GC_incr_mem_freed(GC_mem_recently_freed);
|
||||
GC_mem_recently_freed = 0;
|
||||
|
||||
return GC_generic_malloc_words_small(nwords, kind);
|
||||
}
|
||||
|
||||
typedef GC_aux_template<0> GC_aux;
|
||||
|
||||
// A fast, single-threaded, garbage-collected allocator
|
||||
// We assume the first word will be immediately overwritten.
|
||||
// In this version, deallocation is not a noop, and explicit
|
||||
// deallocation is likely to help performance.
|
||||
template <int dummy>
|
||||
class single_client_gc_alloc_template {
|
||||
public:
|
||||
static void * allocate(size_t n)
|
||||
{
|
||||
size_t nwords = GC_round_up(n);
|
||||
void ** flh;
|
||||
void * op;
|
||||
|
||||
if (n > GC_max_fast_bytes) return GC_malloc(n);
|
||||
flh = GC_objfreelist_ptr + nwords;
|
||||
if (0 == (op = *flh)) {
|
||||
return GC_aux::GC_out_of_line_malloc(nwords, GC_NORMAL);
|
||||
}
|
||||
*flh = GC_obj_link(op);
|
||||
GC_aux::GC_words_recently_allocd += nwords;
|
||||
return op;
|
||||
}
|
||||
static void * ptr_free_allocate(size_t n)
|
||||
{
|
||||
size_t nwords = GC_round_up(n);
|
||||
void ** flh;
|
||||
void * op;
|
||||
|
||||
if (n > GC_max_fast_bytes) return GC_malloc_atomic(n);
|
||||
flh = GC_aobjfreelist_ptr + nwords;
|
||||
if (0 == (op = *flh)) {
|
||||
return GC_aux::GC_out_of_line_malloc(nwords, GC_PTRFREE);
|
||||
}
|
||||
*flh = GC_obj_link(op);
|
||||
GC_aux::GC_words_recently_allocd += nwords;
|
||||
return op;
|
||||
}
|
||||
static void deallocate(void *p, size_t n)
|
||||
{
|
||||
size_t nwords = GC_round_up(n);
|
||||
void ** flh;
|
||||
|
||||
if (n > GC_max_fast_bytes) {
|
||||
GC_free(p);
|
||||
} else {
|
||||
flh = GC_objfreelist_ptr + nwords;
|
||||
GC_obj_link(p) = *flh;
|
||||
memset((char *)p + GC_bytes_per_word, 0,
|
||||
GC_bytes_per_word * (nwords - 1));
|
||||
*flh = p;
|
||||
GC_aux::GC_mem_recently_freed += nwords;
|
||||
}
|
||||
}
|
||||
static void ptr_free_deallocate(void *p, size_t n)
|
||||
{
|
||||
size_t nwords = GC_round_up(n);
|
||||
void ** flh;
|
||||
|
||||
if (n > GC_max_fast_bytes) {
|
||||
GC_free(p);
|
||||
} else {
|
||||
flh = GC_aobjfreelist_ptr + nwords;
|
||||
GC_obj_link(p) = *flh;
|
||||
*flh = p;
|
||||
GC_aux::GC_mem_recently_freed += nwords;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
typedef single_client_gc_alloc_template<0> single_client_gc_alloc;
|
||||
|
||||
// Once more, for uncollectable objects.
|
||||
template <int dummy>
|
||||
class single_client_alloc_template {
|
||||
public:
|
||||
static void * allocate(size_t n)
|
||||
{
|
||||
size_t nwords = GC_round_up_uncollectable(n);
|
||||
void ** flh;
|
||||
void * op;
|
||||
|
||||
if (n > GC_max_fast_bytes) return GC_malloc_uncollectable(n);
|
||||
flh = GC_uobjfreelist_ptr + nwords;
|
||||
if (0 == (op = *flh)) {
|
||||
return GC_aux::GC_out_of_line_malloc(nwords, GC_UNCOLLECTABLE);
|
||||
}
|
||||
*flh = GC_obj_link(op);
|
||||
GC_aux::GC_uncollectable_words_recently_allocd += nwords;
|
||||
return op;
|
||||
}
|
||||
static void * ptr_free_allocate(size_t n)
|
||||
{
|
||||
size_t nwords = GC_round_up_uncollectable(n);
|
||||
void ** flh;
|
||||
void * op;
|
||||
|
||||
if (n > GC_max_fast_bytes) return GC_malloc_atomic_uncollectable(n);
|
||||
flh = GC_auobjfreelist_ptr + nwords;
|
||||
if (0 == (op = *flh)) {
|
||||
return GC_aux::GC_out_of_line_malloc(nwords, GC_AUNCOLLECTABLE);
|
||||
}
|
||||
*flh = GC_obj_link(op);
|
||||
GC_aux::GC_uncollectable_words_recently_allocd += nwords;
|
||||
return op;
|
||||
}
|
||||
static void deallocate(void *p, size_t n)
|
||||
{
|
||||
size_t nwords = GC_round_up_uncollectable(n);
|
||||
void ** flh;
|
||||
|
||||
if (n > GC_max_fast_bytes) {
|
||||
GC_free(p);
|
||||
} else {
|
||||
flh = GC_uobjfreelist_ptr + nwords;
|
||||
GC_obj_link(p) = *flh;
|
||||
*flh = p;
|
||||
GC_aux::GC_uncollectable_mem_recently_freed += nwords;
|
||||
}
|
||||
}
|
||||
static void ptr_free_deallocate(void *p, size_t n)
|
||||
{
|
||||
size_t nwords = GC_round_up_uncollectable(n);
|
||||
void ** flh;
|
||||
|
||||
if (n > GC_max_fast_bytes) {
|
||||
GC_free(p);
|
||||
} else {
|
||||
flh = GC_auobjfreelist_ptr + nwords;
|
||||
GC_obj_link(p) = *flh;
|
||||
*flh = p;
|
||||
GC_aux::GC_uncollectable_mem_recently_freed += nwords;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
typedef single_client_alloc_template<0> single_client_alloc;
|
||||
|
||||
template < int dummy >
|
||||
class gc_alloc_template {
|
||||
public:
|
||||
static void * allocate(size_t n) { return GC_malloc(n); }
|
||||
static void * ptr_free_allocate(size_t n)
|
||||
{ return GC_malloc_atomic(n); }
|
||||
static void deallocate(void *, size_t) { }
|
||||
static void ptr_free_deallocate(void *, size_t) { }
|
||||
};
|
||||
|
||||
typedef gc_alloc_template < 0 > gc_alloc;
|
||||
|
||||
template < int dummy >
|
||||
class alloc_template {
|
||||
public:
|
||||
static void * allocate(size_t n) { return GC_malloc_uncollectable(n); }
|
||||
static void * ptr_free_allocate(size_t n)
|
||||
{ return GC_malloc_atomic_uncollectable(n); }
|
||||
static void deallocate(void *p, size_t) { GC_free(p); }
|
||||
static void ptr_free_deallocate(void *p, size_t) { GC_free(p); }
|
||||
};
|
||||
|
||||
typedef alloc_template < 0 > alloc;
|
||||
|
||||
#ifdef _SGI_SOURCE
|
||||
|
||||
// We want to specialize simple_alloc so that it does the right thing
|
||||
// for all pointerfree types. At the moment there is no portable way to
|
||||
// even approximate that. The following approximation should work for
|
||||
// SGI compilers, and perhaps some others.
|
||||
|
||||
# define __GC_SPECIALIZE(T,alloc) \
|
||||
class simple_alloc<T, alloc> { \
|
||||
public: \
|
||||
static T *allocate(size_t n) \
|
||||
{ return 0 == n? 0 : \
|
||||
(T*) alloc::ptr_free_allocate(n * sizeof (T)); } \
|
||||
static T *allocate(void) \
|
||||
{ return (T*) alloc::ptr_free_allocate(sizeof (T)); } \
|
||||
static void deallocate(T *p, size_t n) \
|
||||
{ if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
|
||||
static void deallocate(T *p) \
|
||||
{ alloc::ptr_free_deallocate(p, sizeof (T)); } \
|
||||
};
|
||||
|
||||
__GC_SPECIALIZE(char, gc_alloc)
|
||||
__GC_SPECIALIZE(int, gc_alloc)
|
||||
__GC_SPECIALIZE(unsigned, gc_alloc)
|
||||
__GC_SPECIALIZE(float, gc_alloc)
|
||||
__GC_SPECIALIZE(double, gc_alloc)
|
||||
|
||||
__GC_SPECIALIZE(char, alloc)
|
||||
__GC_SPECIALIZE(int, alloc)
|
||||
__GC_SPECIALIZE(unsigned, alloc)
|
||||
__GC_SPECIALIZE(float, alloc)
|
||||
__GC_SPECIALIZE(double, alloc)
|
||||
|
||||
__GC_SPECIALIZE(char, single_client_gc_alloc)
|
||||
__GC_SPECIALIZE(int, single_client_gc_alloc)
|
||||
__GC_SPECIALIZE(unsigned, single_client_gc_alloc)
|
||||
__GC_SPECIALIZE(float, single_client_gc_alloc)
|
||||
__GC_SPECIALIZE(double, single_client_gc_alloc)
|
||||
|
||||
__GC_SPECIALIZE(char, single_client_alloc)
|
||||
__GC_SPECIALIZE(int, single_client_alloc)
|
||||
__GC_SPECIALIZE(unsigned, single_client_alloc)
|
||||
__GC_SPECIALIZE(float, single_client_alloc)
|
||||
__GC_SPECIALIZE(double, single_client_alloc)
|
||||
|
||||
#ifdef __STL_USE_STD_ALLOCATORS
|
||||
|
||||
???copy stuff from stl_alloc.h or remove it to a different file ???
|
||||
|
||||
#endif /* __STL_USE_STD_ALLOCATORS */
|
||||
|
||||
#endif /* _SGI_SOURCE */
|
||||
|
||||
#endif /* GC_ALLOC_H */
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user