Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
d02373e837 |
No files matched your search
@@ -15,9 +15,3 @@ Makefile.in
|
||||
mono-*.tar.gz
|
||||
stamp-h
|
||||
stamp-h.in
|
||||
mono.pc
|
||||
mono.spec
|
||||
autom4te.cache
|
||||
mint.pc
|
||||
stamp-h1
|
||||
config.h.in
|
||||
@@ -1,3 +1,2 @@
|
||||
Miguel de Icaza ([email protected])
|
||||
Paolo Molaro ([email protected])
|
||||
Dietmar Maurer ([email protected])
|
||||
@@ -1,485 +0,0 @@
|
||||
|
||||
The Mono runtime is licensed under the terms of the GNU
|
||||
Library General Public License, version 2.
|
||||
|
||||
GNU LIBRARY GENERAL PUBLIC LICENSE
|
||||
Version 2, June 1991
|
||||
|
||||
Copyright (C) 1991 Free Software Foundation, Inc.
|
||||
675 Mass Ave, Cambridge, MA 02139, USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
[This is the first released version of the library GPL. It is
|
||||
numbered 2 because it goes with version 2 of the ordinary GPL.]
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
Licenses are intended to guarantee your freedom to share and change
|
||||
free software--to make sure the software is free for all its users.
|
||||
|
||||
This license, the Library General Public License, applies to some
|
||||
specially designated Free Software Foundation software, and to any
|
||||
other libraries whose authors decide to use it. You can use it for
|
||||
your libraries, too.
|
||||
|
||||
When we speak of free software, we are referring to freedom, not
|
||||
price. Our General Public Licenses are designed to make sure that you
|
||||
have the freedom to distribute copies of free software (and charge for
|
||||
this service if you wish), that you receive source code or can get it
|
||||
if you want it, that you can change the software or use pieces of it
|
||||
in new free programs; and that you know you can do these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
anyone to deny you these rights or to ask you to surrender the rights.
|
||||
These restrictions translate to certain responsibilities for you if
|
||||
you distribute copies of the library, or if you modify it.
|
||||
|
||||
For example, if you distribute copies of the library, whether gratis
|
||||
or for a fee, you must give the recipients all the rights that we gave
|
||||
you. You must make sure that they, too, receive or can get the source
|
||||
code. If you link a program with the library, you must provide
|
||||
complete object files to the recipients so that they can relink them
|
||||
with the library, after making changes to the library and recompiling
|
||||
it. And you must show them these terms so they know their rights.
|
||||
|
||||
Our method of protecting your rights has two steps: (1) copyright
|
||||
the library, and (2) offer you this license which gives you legal
|
||||
permission to copy, distribute and/or modify the library.
|
||||
|
||||
Also, for each distributor's protection, we want to make certain
|
||||
that everyone understands that there is no warranty for this free
|
||||
library. If the library is modified by someone else and passed on, we
|
||||
want its recipients to know that what they have is not the original
|
||||
version, so that any problems introduced by others will not reflect on
|
||||
the original authors' reputations.
|
||||
|
||||
Finally, any free program is threatened constantly by software
|
||||
patents. We wish to avoid the danger that companies distributing free
|
||||
software will individually obtain patent licenses, thus in effect
|
||||
transforming the program into proprietary software. To prevent this,
|
||||
we have made it clear that any patent must be licensed for everyone's
|
||||
free use or not licensed at all.
|
||||
|
||||
Most GNU software, including some libraries, is covered by the ordinary
|
||||
GNU General Public License, which was designed for utility programs. This
|
||||
license, the GNU Library General Public License, applies to certain
|
||||
designated libraries. This license is quite different from the ordinary
|
||||
one; be sure to read it in full, and don't assume that anything in it is
|
||||
the same as in the ordinary license.
|
||||
|
||||
The reason we have a separate public license for some libraries is that
|
||||
they blur the distinction we usually make between modifying or adding to a
|
||||
program and simply using it. Linking a program with a library, without
|
||||
changing the library, is in some sense simply using the library, and is
|
||||
analogous to running a utility program or application program. However, in
|
||||
a textual and legal sense, the linked executable is a combined work, a
|
||||
derivative of the original library, and the ordinary General Public License
|
||||
treats it as such.
|
||||
|
||||
Because of this blurred distinction, using the ordinary General
|
||||
Public License for libraries did not effectively promote software
|
||||
sharing, because most developers did not use the libraries. We
|
||||
concluded that weaker conditions might promote sharing better.
|
||||
|
||||
However, unrestricted linking of non-free programs would deprive the
|
||||
users of those programs of all benefit from the free status of the
|
||||
libraries themselves. This Library General Public License is intended to
|
||||
permit developers of non-free programs to use free libraries, while
|
||||
preserving your freedom as a user of such programs to change the free
|
||||
libraries that are incorporated in them. (We have not seen how to achieve
|
||||
this as regards changes in header files, but we have achieved it as regards
|
||||
changes in the actual functions of the Library.) The hope is that this
|
||||
will lead to faster development of free libraries.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow. Pay close attention to the difference between a
|
||||
"work based on the library" and a "work that uses the library". The
|
||||
former contains code derived from the library, while the latter only
|
||||
works together with the library.
|
||||
|
||||
Note that it is possible for a library to be covered by the ordinary
|
||||
General Public License rather than by this special one.
|
||||
|
||||
GNU LIBRARY GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License Agreement applies to any software library which
|
||||
contains a notice placed by the copyright holder or other authorized
|
||||
party saying it may be distributed under the terms of this Library
|
||||
General Public License (also called "this License"). Each licensee is
|
||||
addressed as "you".
|
||||
|
||||
A "library" means a collection of software functions and/or data
|
||||
prepared so as to be conveniently linked with application programs
|
||||
(which use some of those functions and data) to form executables.
|
||||
|
||||
The "Library", below, refers to any such software library or work
|
||||
which has been distributed under these terms. A "work based on the
|
||||
Library" means either the Library or any derivative work under
|
||||
copyright law: that is to say, a work containing the Library or a
|
||||
portion of it, either verbatim or with modifications and/or translated
|
||||
straightforwardly into another language. (Hereinafter, translation is
|
||||
included without limitation in the term "modification".)
|
||||
|
||||
"Source code" for a work means the preferred form of the work for
|
||||
making modifications to it. For a library, complete source code means
|
||||
all the source code for all modules it contains, plus any associated
|
||||
interface definition files, plus the scripts used to control compilation
|
||||
and installation of the library.
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running a program using the Library is not restricted, and output from
|
||||
such a program is covered only if its contents constitute a work based
|
||||
on the Library (independent of the use of the Library in a tool for
|
||||
writing it). Whether that is true depends on what the Library does
|
||||
and what the program that uses the Library does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Library's
|
||||
complete source code as you receive it, in any medium, provided that
|
||||
you conspicuously and appropriately publish on each copy an
|
||||
appropriate copyright notice and disclaimer of warranty; keep intact
|
||||
all the notices that refer to this License and to the absence of any
|
||||
warranty; and distribute a copy of this License along with the
|
||||
Library.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy,
|
||||
and you may at your option offer warranty protection in exchange for a
|
||||
fee.
|
||||
|
||||
2. You may modify your copy or copies of the Library or any portion
|
||||
of it, thus forming a work based on the Library, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) The modified work must itself be a software library.
|
||||
|
||||
b) You must cause the files modified to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
c) You must cause the whole of the work to be licensed at no
|
||||
charge to all third parties under the terms of this License.
|
||||
|
||||
d) If a facility in the modified Library refers to a function or a
|
||||
table of data to be supplied by an application program that uses
|
||||
the facility, other than as an argument passed when the facility
|
||||
is invoked, then you must make a good faith effort to ensure that,
|
||||
in the event an application does not supply such function or
|
||||
table, the facility still operates, and performs whatever part of
|
||||
its purpose remains meaningful.
|
||||
|
||||
(For example, a function in a library to compute square roots has
|
||||
a purpose that is entirely well-defined independent of the
|
||||
application. Therefore, Subsection 2d requires that any
|
||||
application-supplied function or table used by this function must
|
||||
be optional: if the application does not supply it, the square
|
||||
root function must still compute square roots.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Library,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Library, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote
|
||||
it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Library.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Library
|
||||
with the Library (or with a work based on the Library) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may opt to apply the terms of the ordinary GNU General Public
|
||||
License instead of this License to a given copy of the Library. To do
|
||||
this, you must alter all the notices that refer to this License, so
|
||||
that they refer to the ordinary GNU General Public License, version 2,
|
||||
instead of to this License. (If a newer version than version 2 of the
|
||||
ordinary GNU General Public License has appeared, then you can specify
|
||||
that version instead if you wish.) Do not make any other change in
|
||||
these notices.
|
||||
|
||||
Once this change is made in a given copy, it is irreversible for
|
||||
that copy, so the ordinary GNU General Public License applies to all
|
||||
subsequent copies and derivative works made from that copy.
|
||||
|
||||
This option is useful when you wish to copy part of the code of
|
||||
the Library into a program that is not a library.
|
||||
|
||||
4. You may copy and distribute the Library (or a portion or
|
||||
derivative of it, under Section 2) in object code or executable form
|
||||
under the terms of Sections 1 and 2 above provided that you accompany
|
||||
it with the complete corresponding machine-readable source code, which
|
||||
must be distributed under the terms of Sections 1 and 2 above on a
|
||||
medium customarily used for software interchange.
|
||||
|
||||
If distribution of object code is made by offering access to copy
|
||||
from a designated place, then offering equivalent access to copy the
|
||||
source code from the same place satisfies the requirement to
|
||||
distribute the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
5. A program that contains no derivative of any portion of the
|
||||
Library, but is designed to work with the Library by being compiled or
|
||||
linked with it, is called a "work that uses the Library". Such a
|
||||
work, in isolation, is not a derivative work of the Library, and
|
||||
therefore falls outside the scope of this License.
|
||||
|
||||
However, linking a "work that uses the Library" with the Library
|
||||
creates an executable that is a derivative of the Library (because it
|
||||
contains portions of the Library), rather than a "work that uses the
|
||||
library". The executable is therefore covered by this License.
|
||||
Section 6 states terms for distribution of such executables.
|
||||
|
||||
When a "work that uses the Library" uses material from a header file
|
||||
that is part of the Library, the object code for the work may be a
|
||||
derivative work of the Library even though the source code is not.
|
||||
Whether this is true is especially significant if the work can be
|
||||
linked without the Library, or if the work is itself a library. The
|
||||
threshold for this to be true is not precisely defined by law.
|
||||
|
||||
If such an object file uses only numerical parameters, data
|
||||
structure layouts and accessors, and small macros and small inline
|
||||
functions (ten lines or less in length), then the use of the object
|
||||
file is unrestricted, regardless of whether it is legally a derivative
|
||||
work. (Executables containing this object code plus portions of the
|
||||
Library will still fall under Section 6.)
|
||||
|
||||
Otherwise, if the work is a derivative of the Library, you may
|
||||
distribute the object code for the work under the terms of Section 6.
|
||||
Any executables containing that work also fall under Section 6,
|
||||
whether or not they are linked directly with the Library itself.
|
||||
|
||||
6. As an exception to the Sections above, you may also compile or
|
||||
link a "work that uses the Library" with the Library to produce a
|
||||
work containing portions of the Library, and distribute that work
|
||||
under terms of your choice, provided that the terms permit
|
||||
modification of the work for the customer's own use and reverse
|
||||
engineering for debugging such modifications.
|
||||
|
||||
You must give prominent notice with each copy of the work that the
|
||||
Library is used in it and that the Library and its use are covered by
|
||||
this License. You must supply a copy of this License. If the work
|
||||
during execution displays copyright notices, you must include the
|
||||
copyright notice for the Library among them, as well as a reference
|
||||
directing the user to the copy of this License. Also, you must do one
|
||||
of these things:
|
||||
|
||||
a) Accompany the work with the complete corresponding
|
||||
machine-readable source code for the Library including whatever
|
||||
changes were used in the work (which must be distributed under
|
||||
Sections 1 and 2 above); and, if the work is an executable linked
|
||||
with the Library, with the complete machine-readable "work that
|
||||
uses the Library", as object code and/or source code, so that the
|
||||
user can modify the Library and then relink to produce a modified
|
||||
executable containing the modified Library. (It is understood
|
||||
that the user who changes the contents of definitions files in the
|
||||
Library will not necessarily be able to recompile the application
|
||||
to use the modified definitions.)
|
||||
|
||||
b) Accompany the work with a written offer, valid for at
|
||||
least three years, to give the same user the materials
|
||||
specified in Subsection 6a, above, for a charge no more
|
||||
than the cost of performing this distribution.
|
||||
|
||||
c) If distribution of the work is made by offering access to copy
|
||||
from a designated place, offer equivalent access to copy the above
|
||||
specified materials from the same place.
|
||||
|
||||
d) Verify that the user has already received a copy of these
|
||||
materials or that you have already sent this user a copy.
|
||||
|
||||
For an executable, the required form of the "work that uses the
|
||||
Library" must include any data and utility programs needed for
|
||||
reproducing the executable from it. However, as a special exception,
|
||||
the source code distributed need not include anything that is normally
|
||||
distributed (in either source or binary form) with the major
|
||||
components (compiler, kernel, and so on) of the operating system on
|
||||
which the executable runs, unless that component itself accompanies
|
||||
the executable.
|
||||
|
||||
It may happen that this requirement contradicts the license
|
||||
restrictions of other proprietary libraries that do not normally
|
||||
accompany the operating system. Such a contradiction means you cannot
|
||||
use both them and the Library together in an executable that you
|
||||
distribute.
|
||||
|
||||
7. You may place library facilities that are a work based on the
|
||||
Library side-by-side in a single library together with other library
|
||||
facilities not covered by this License, and distribute such a combined
|
||||
library, provided that the separate distribution of the work based on
|
||||
the Library and of the other library facilities is otherwise
|
||||
permitted, and provided that you do these two things:
|
||||
|
||||
a) Accompany the combined library with a copy of the same work
|
||||
based on the Library, uncombined with any other library
|
||||
facilities. This must be distributed under the terms of the
|
||||
Sections above.
|
||||
|
||||
b) Give prominent notice with the combined library of the fact
|
||||
that part of it is a work based on the Library, and explaining
|
||||
where to find the accompanying uncombined form of the same work.
|
||||
|
||||
8. You may not copy, modify, sublicense, link with, or distribute
|
||||
the Library except as expressly provided under this License. Any
|
||||
attempt otherwise to copy, modify, sublicense, link with, or
|
||||
distribute the Library is void, and will automatically terminate your
|
||||
rights under this License. However, parties who have received copies,
|
||||
or rights, from you under this License will not have their licenses
|
||||
terminated so long as such parties remain in full compliance.
|
||||
|
||||
9. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Library or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Library (or any work based on the
|
||||
Library), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Library or works based on it.
|
||||
|
||||
10. Each time you redistribute the Library (or any work based on the
|
||||
Library), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute, link with or modify the Library
|
||||
subject to these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties to
|
||||
this License.
|
||||
|
||||
11. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Library at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Library by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Library.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under any
|
||||
particular circumstance, the balance of the section is intended to apply,
|
||||
and the section as a whole is intended to apply in other circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
12. If the distribution and/or use of the Library is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Library under this License may add
|
||||
an explicit geographical distribution limitation excluding those countries,
|
||||
so that distribution is permitted only in or among countries not thus
|
||||
excluded. In such case, this License incorporates the limitation as if
|
||||
written in the body of this License.
|
||||
|
||||
13. The Free Software Foundation may publish revised and/or new
|
||||
versions of the Library General Public License from time to time.
|
||||
Such new versions will be similar in spirit to the present version,
|
||||
but may differ in detail to address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Library
|
||||
specifies a version number of this License which applies to it and
|
||||
"any later version", you have the option of following the terms and
|
||||
conditions either of that version or of any later version published by
|
||||
the Free Software Foundation. If the Library does not specify a
|
||||
license version number, you may choose any version ever published by
|
||||
the Free Software Foundation.
|
||||
|
||||
14. If you wish to incorporate parts of the Library into other free
|
||||
programs whose distribution conditions are incompatible with these,
|
||||
write to the author to ask for permission. For software which is
|
||||
copyrighted by the Free Software Foundation, write to the Free
|
||||
Software Foundation; we sometimes make exceptions for this. Our
|
||||
decision will be guided by the two goals of preserving the free status
|
||||
of all derivatives of our free software and of promoting the sharing
|
||||
and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
|
||||
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
|
||||
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
|
||||
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
|
||||
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
|
||||
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
|
||||
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
|
||||
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
|
||||
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
|
||||
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
|
||||
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
|
||||
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
|
||||
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
|
||||
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
|
||||
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
||||
DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
Appendix: How to Apply These Terms to Your New Libraries
|
||||
|
||||
If you develop a new library, and you want it to be of the greatest
|
||||
possible use to the public, we recommend making it free software that
|
||||
everyone can redistribute and change. You can do so by permitting
|
||||
redistribution under these terms (or, alternatively, under the terms of the
|
||||
ordinary General Public License).
|
||||
|
||||
To apply these terms, attach the following notices to the library. It is
|
||||
safest to attach them to the start of each source file to most effectively
|
||||
convey the exclusion of warranty; and each file should have at least the
|
||||
"copyright" line and a pointer to where the full notice is found.
|
||||
|
||||
<one line to give the library's name and a brief idea of what it does.>
|
||||
Copyright (C) <year> <name of author>
|
||||
|
||||
This library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Library General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2 of the License, or (at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Library General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Library General Public
|
||||
License along with this library; if not, write to the Free
|
||||
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
Also add information on how to contact you by electronic and paper mail.
|
||||
|
||||
You should also get your employer (if you work as a programmer) or your
|
||||
school, if any, to sign a "copyright disclaimer" for the library, if
|
||||
necessary. Here is a sample; alter the names:
|
||||
|
||||
Yoyodyne, Inc., hereby disclaims all copyright interest in the
|
||||
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
|
||||
|
||||
<signature of Ty Coon>, 1 April 1990
|
||||
Ty Coon, President of Vice
|
||||
|
||||
That's all there is to it!
|
||||
@@ -1,187 +1 @@
|
||||
AUTOMAKE_OPTIONS = foreign
|
||||
ACLOCAL_AMFLAGS = -I .
|
||||
|
||||
SUBDIRS = @libgc_dir@ mono @ikvm_jni_dir@ docs runtime scripts man data samples support web
|
||||
|
||||
# Keep in sync with SUBDIRS
|
||||
## 'tools' is not normally built
|
||||
DIST_SUBDIRS = libgc mono ikvm-jni docs runtime scripts man data samples support web tools
|
||||
|
||||
EXTRA_DIST= mono.pc.in mono.spec.in mint.pc.in
|
||||
|
||||
pkgconfigdir = $(libdir)/pkgconfig
|
||||
if JIT_SUPPORTED
|
||||
pkgconfig_DATA= mono.pc mint.pc
|
||||
else
|
||||
pkgconfig_DATA= mint.pc
|
||||
endif
|
||||
DISTCLEANFILES= mono.pc mint.pc
|
||||
|
||||
#
|
||||
# The following targets are used to compile and install
|
||||
# mono and mcs without running into the out-of-sync
|
||||
# problems by doing the compilation in the right order.
|
||||
#
|
||||
|
||||
mcs_topdir=$(top_srcdir)/../mcs
|
||||
|
||||
.PHONY: bootstrap faststrap fasterstrap bootstrap-clean bootstrap-check get-monolite-latest monolite-bootstrap
|
||||
.PHONY: tmpinst-dir tmpinst-mcs-basic-build tmpinst-mcs-short-build tmpinst-mcs-full-build tmpinst-monolite
|
||||
.PHONY: mono-do-runtime-only mcs-do-basic-build mcs-do-short-build mcs-do-full-build mcs-do-clean-profiles mcs-do-run-test
|
||||
|
||||
if USE_JIT
|
||||
mono_runtime = mono/mini/mono
|
||||
else
|
||||
mono_runtime = mono/interpreter/mint
|
||||
endif
|
||||
|
||||
# Minimal set of directories to build, and files used to run the 'mcs' compiler
|
||||
MCS_BASIC_DIRS = jay mcs class/corlib class/System
|
||||
MCS_BASIC_FILES = \
|
||||
$(mcs_topdir)/mcs/mcs.exe \
|
||||
$(mcs_topdir)/class/lib/default/mscorlib.dll \
|
||||
$(mcs_topdir)/class/lib/default/System.dll
|
||||
|
||||
# Set of directories and files the 'mcs' compiler can use
|
||||
## We build class/System twice to resolve the cyclic dependency of class/System.XML
|
||||
MCS_DIRS = $(MCS_BASIC_DIRS) class/System.XML class/System class/Mono.CSharp.Debugger
|
||||
MCS_FILES = $(MCS_BASIC_FILES) \
|
||||
$(mcs_topdir)/class/lib/default/System.Xml.dll \
|
||||
$(mcs_topdir)/class/lib/default/Mono.CSharp.Debugger.dll
|
||||
|
||||
tmpinst = _tmpinst
|
||||
|
||||
bootstrap: tmpinst-mcs-basic-build mono-do-runtime-only
|
||||
$(MAKE) tmpinst-mcs-short-build
|
||||
$(MAKE) fasterstrap
|
||||
|
||||
faststrap: tmpinst-mcs-short-build
|
||||
$(MAKE) mono-do-runtime-only
|
||||
$(MAKE) fasterstrap
|
||||
|
||||
.PHONY: populate-runtime-subdir
|
||||
## *** warning ***: tested only with GNU make
|
||||
populate-runtime-subdir:
|
||||
srcdir=`cd $(srcdir) && pwd`; tmpinst=`pwd`/$(tmpinst) ; \
|
||||
PATH=$$tmpinst/bin:$$PATH ; export PATH ; \
|
||||
cd $(mcs_topdir) \
|
||||
&& $(MAKE) PROGRAM_INSTALL_DIR=$$srcdir/runtime LIBRARY_INSTALL_DIR=$$srcdir/runtime/net_1_1 prefix=$$tmpinst/prefix PROFILE=default install \
|
||||
&& $(MAKE) PROGRAM_INSTALL_DIR=$$srcdir/runtime LIBRARY_INSTALL_DIR=$$srcdir/runtime/net_2_0 prefix=$$tmpinst/prefix PROFILE=net_2_0 install
|
||||
test -z "`find $(tmpinst)/prefix -name '*.dll'`"
|
||||
test -z "`find $(tmpinst)/prefix -name '*.exe'`"
|
||||
set fnord `find $(tmpinst)/prefix -type f | wc -l` ; test "$$2" = 9
|
||||
rm -rf $(tmpinst)/prefix
|
||||
|
||||
fasterstrap: tmpinst-mcs-full-build
|
||||
$(MAKE) populate-runtime-subdir
|
||||
$(MAKE)
|
||||
|
||||
bootstrap-clean: clean mcs-do-clean-profiles
|
||||
bootstrap-check: check mcs-do-run-test
|
||||
|
||||
# building with monolite
|
||||
|
||||
get-monolite-latest:
|
||||
wget -O $(srcdir)/../monolite-latest.tar.gz http://www.go-mono.com/daily/monolite-latest.tar.gz
|
||||
|
||||
monolite-bootstrap: tmpinst-monolite mono-do-runtime-only
|
||||
rm -f $(MCS_FILES)
|
||||
$(MAKE) tmpinst-mcs-short-build
|
||||
$(MAKE) fasterstrap
|
||||
|
||||
# internal targets
|
||||
|
||||
tmpinst-mcs-basic-build: mcs-do-basic-build tmpinst-dir
|
||||
mv -f $(MCS_BASIC_FILES) $(tmpinst)/lib
|
||||
|
||||
tmpinst-mcs-short-build: mcs-do-short-build tmpinst-dir
|
||||
mv -f $(MCS_FILES) $(tmpinst)/lib
|
||||
|
||||
tmpinst-mcs-full-build: mcs-do-full-build tmpinst-dir
|
||||
cp -f $(MCS_FILES) $(tmpinst)/lib
|
||||
|
||||
tmpinst-monolite: tmpinst-dir
|
||||
-rm -f $(tmpinst)/lib/mcs.exe $(tmpinst)/lib/*.dll
|
||||
-rm -fr $(tmpinst)/monolite-*
|
||||
srcdir=`cd $(srcdir) && pwd` && cd $(tmpinst) && ( gzip -d -c $$srcdir/../monolite-latest.tar.gz | tar xf - )
|
||||
mv -f $(tmpinst)/monolite-*/mcs.exe $(tmpinst)/monolite-*/*.dll $(tmpinst)/lib
|
||||
rm -fr $(tmpinst)/monolite-*
|
||||
|
||||
# Build enough of 'mono' to run the stage1 mcs.exe
|
||||
mono-do-runtime-only: $(CONFIG_HEADER)
|
||||
for dir in $(libgc_dir) mono data; do \
|
||||
(cd $$dir && $(MAKE)) || exit 1 ; \
|
||||
done
|
||||
|
||||
mcs-do-basic-build:
|
||||
rm -f $(MCS_FILES)
|
||||
for dir in $(MCS_BASIC_DIRS); do \
|
||||
(cd $(mcs_topdir)/$$dir && $(MAKE) PROFILE=default USE_BOOT_COMPILE=yes BOOTSTRAP_MCS="mcs -d:BOOTSTRAP_WITH_OLDLIB") || exit 1 ; \
|
||||
done
|
||||
|
||||
mcs-do-short-build:
|
||||
tmpinst=`cd $(tmpinst) && pwd` ; \
|
||||
PATH=$$tmpinst/bin:$$PATH; export PATH ; \
|
||||
for dir in $(MCS_DIRS); do \
|
||||
(cd $(mcs_topdir)/$$dir && $(MAKE) PROFILE=default) || exit 1 ; \
|
||||
done
|
||||
|
||||
mcs-do-full-build:
|
||||
tmpinst=`cd $(tmpinst) && pwd` ; \
|
||||
PATH=$$tmpinst/bin:$$PATH ; export PATH ; \
|
||||
cd $(mcs_topdir) && $(MAKE) all-profiles
|
||||
|
||||
mcs-do-clean-profiles:
|
||||
cd $(mcs_topdir) && $(MAKE) clean-profiles
|
||||
|
||||
mcs-do-run-test: tmpinst-dir
|
||||
tmpinst=`cd $(tmpinst) && pwd` ; \
|
||||
PATH=$$tmpinst/bin:$$PATH ; export PATH ; \
|
||||
cd $(mcs_topdir) && $(MAKE) PROFILE=default run-test
|
||||
|
||||
tmpinst-dir:
|
||||
mkdir -p $(tmpinst) $(tmpinst)/bin $(tmpinst)/lib $(tmpinst)/etc/mono
|
||||
$(MAKE) $(tmpinst)/bin/mono $(tmpinst)/bin/mcs $(tmpinst)/etc/mono/machine.config
|
||||
|
||||
$(tmpinst)/bin/mono: $(srcdir)/Makefile.am
|
||||
echo '#! /bin/sh' > $@
|
||||
echo 'builddir="'`pwd`'"; tmpinst=$$builddir/$(tmpinst)' >> $@
|
||||
echo 'if test -z "$$MONO_PATH" ; then MONO_PATH=$$tmpinst/lib; else MONO_PATH=$${MONO_PATH}:$$tmpinst/lib ; fi' >> $@
|
||||
echo 'MONO_CFG_DIR=$$tmpinst/etc' >> $@
|
||||
echo 'export MONO_PATH MONO_CFG_DIR' >> $@
|
||||
echo 'exec "$$builddir/libtool" --mode=execute "$$builddir/$(mono_runtime)" --config "$$builddir/data/config" "$$@"' >> $@
|
||||
chmod +x $@
|
||||
|
||||
$(tmpinst)/bin/mcs: $(srcdir)/Makefile.am
|
||||
(t=`cd $(tmpinst) && pwd`; echo '#! /bin/sh'; echo 'exec "'"$$t/bin/mono"'" "'"$$t/lib/mcs.exe"'" "$$@"') > $@
|
||||
chmod +x $@
|
||||
|
||||
$(tmpinst)/etc/mono/machine.config: $(srcdir)/data/machine.config
|
||||
rm -f $@
|
||||
srcdir=`cd $(srcdir) && pwd`; cd $(tmpinst)/etc/mono && $(LN_S) $$srcdir/data/machine.config machine.config
|
||||
|
||||
# Obsolete target -- don't use.
|
||||
.PHONY: fullbuild
|
||||
fullbuild: bootstrap
|
||||
$(MAKE) install
|
||||
echo "*** 'fullbuild' is an obsolete target. Use 'make bootstrap && make install'."
|
||||
exit 1
|
||||
|
||||
win32getdeps:
|
||||
wget http://www.go-mono.com/archive/pkgconfig-0.11-20020310.zip
|
||||
wget http://www.go-mono.com/archive/glib-2.0.4-20020703.zip
|
||||
wget http://www.go-mono.com/archive/glib-dev-2.0.4-20020703.zip
|
||||
wget http://www.go-mono.com/archive/libiconv-1.7.zip
|
||||
wget http://www.go-mono.com/archive/libiconv-dev-1.7.zip
|
||||
wget http://www.go-mono.com/archive/libintl-0.10.40-20020101.zip
|
||||
wget http://www.jroith.de/nsis4cygwin.zip
|
||||
unzip -n -d / pkgconfig-0.11-20020310.zip
|
||||
unzip -n -d / glib-2.0.4-20020703.zip
|
||||
unzip -n -d / glib-dev-2.0.4-20020703.zip
|
||||
unzip -n -d / libiconv-1.7.zip
|
||||
unzip -n -d / libiconv-dev-1.7.zip
|
||||
unzip -n -d / libintl-0.10.40-20020101.zip
|
||||
unzip -n -d / nsis4cygwin.zip
|
||||
|
||||
win32setup:
|
||||
makensis /DMILESTONE=$(VERSION) /DSOURCE_INSTALL_DIR=$(SOURCE_INSTALL_DIR) /DBUILDNUM=$(BUILDNUM) monowiz.win32.nsi
|
||||
SUBDIRS = libffi mono doc runtime
|
||||
@@ -1,224 +1,16 @@
|
||||
|
||||
This is Mono.
|
||||
|
||||
1. Installation
|
||||
2. Using Mono
|
||||
3. Directory Roadmap
|
||||
|
||||
1. Compilation and Installation
|
||||
===============================
|
||||
|
||||
a. Build Requirements
|
||||
---------------------
|
||||
|
||||
To build Mono, you will need the following components:
|
||||
|
||||
* pkg-config
|
||||
|
||||
Available from: http://www.freedesktop.org/Software/pkgconfig
|
||||
|
||||
* glib 2.0
|
||||
|
||||
Available from: http://www.gtk.org/
|
||||
|
||||
Optional dependencies:
|
||||
|
||||
* ICU library
|
||||
|
||||
http://oss.software.ibm.com/icu/index.html
|
||||
|
||||
You will need this one to get complete support for the international
|
||||
features of the .NET Framework.
|
||||
|
||||
* Cairo and libgdiplus
|
||||
|
||||
If you want to get support for System.Drawing, you will need to get
|
||||
both Libgdiplus and Cairo.
|
||||
|
||||
b. Building the Software
|
||||
------------------------
|
||||
|
||||
If you obtained this package as an officially released tarball,
|
||||
this is very simple, use configure and make:
|
||||
|
||||
./configure --prefix=/usr/local
|
||||
make
|
||||
make install
|
||||
|
||||
Mono supports a JIT engine on x86, SPARC and PowerPC systems.
|
||||
The various commands that ship with Mono default to the JIT engine
|
||||
on x86 and SPARC, to turn it on for PPC systems, use the --with-jit=yes
|
||||
command line option to configure.
|
||||
|
||||
MacOS X Users: you will need to download the latest Boehm GC
|
||||
Alpha release for garbage collection to work properly.
|
||||
|
||||
If you obtained this as a snapshot, you will need an existing
|
||||
Mono installation. To upgrade your installation, unpack both
|
||||
mono and mcs:
|
||||
|
||||
tar xzf mcs-XXXX.tar.gz
|
||||
tar xzf mono-XXXX.tar.gz
|
||||
mv mono-XXX mono
|
||||
mv mcs-XXX mcs
|
||||
cd mono
|
||||
./autogen.sh --prefix=/usr/local
|
||||
make bootstrap
|
||||
|
||||
c. Building the software from CVS
|
||||
---------------------------------
|
||||
|
||||
If you are building the software from CVS, make sure that you
|
||||
have up-to-date mcs and mono sources:
|
||||
|
||||
cvs co mono mcs
|
||||
|
||||
Then, go into the mono directory, and configure:
|
||||
|
||||
cd mono
|
||||
./autogen.sh --prefix=/usr/local
|
||||
|
||||
Depending on whether you have an existing Mono installation or
|
||||
not, you can try the following:
|
||||
|
||||
i. If you have an existing Mono installation
|
||||
-----------------------------------------
|
||||
|
||||
First verify that you have a working installation:
|
||||
|
||||
echo 'class X { static void Main () { System.Console.Write("OK");}}' > x.cs
|
||||
|
||||
Compile:
|
||||
|
||||
mcs x.cs
|
||||
|
||||
And run:
|
||||
|
||||
mono x.exe
|
||||
|
||||
If you get the output `OK' and no errors, and you have mono
|
||||
version 0.31 or later, continue. Otherwise, you can try option
|
||||
(ii) below.
|
||||
|
||||
You are ready to start your CVS upgrade. Compile with
|
||||
|
||||
make bootstrap
|
||||
|
||||
This will automatically go into the mcs/ tree and build the
|
||||
binaries there, and copy them into the appropriate
|
||||
sub-directories of mono/runtime/.
|
||||
|
||||
Now, go to step (iii) below.
|
||||
|
||||
ii. If you don't have a working Mono installation
|
||||
---------------------------------------------
|
||||
|
||||
If you don't have a working Mono installation, an obvious choice
|
||||
is to install the latest released packages of 'mono' for your
|
||||
distribution and go back to step (i).
|
||||
|
||||
You can also try a slightly more risky approach that should work
|
||||
almost all the time.
|
||||
|
||||
This works by first getting the latest version of the 'monolite'
|
||||
distribution, which contains just enough to run the 'mcs'
|
||||
compiler. You do this by
|
||||
|
||||
make get-monolite-latest
|
||||
|
||||
This should place a monolite-latest.tar.gz in the parent
|
||||
directory of the 'mono' source tree. You can then run:
|
||||
|
||||
make monolite-bootstrap
|
||||
|
||||
This will automatically gunzip and untar the tarball, place the
|
||||
files appropriately, and then complete the bootstrap.
|
||||
|
||||
iii. Testing and Installation
|
||||
------------------------
|
||||
|
||||
You can run the mono and mcs testsuites with the command:
|
||||
|
||||
make -k bootstrap-check
|
||||
|
||||
Expect to find several testsuite failures, especially in the
|
||||
mcs/ tree. As a sanity check, you can compare the failures you
|
||||
got with
|
||||
|
||||
http://go-mono.com/tests/displayTestResults.php
|
||||
|
||||
You can now install it:
|
||||
|
||||
make install
|
||||
|
||||
Failure to follow these steps will result in a broken installation.
|
||||
|
||||
iv. Other useful "bootstrap"-like facilities
|
||||
----------------------------------------
|
||||
|
||||
If you have a CVS snapshot that you keep updating periodically,
|
||||
and/or do your development in, you may try using a couple of
|
||||
specialty make targets that may be slightly faster than a
|
||||
"make bootstrap".
|
||||
|
||||
You can try a two-stage bootstrap with:
|
||||
|
||||
make faststrap
|
||||
|
||||
This assumes that you have already run a "make bootstrap" on the
|
||||
tree before.
|
||||
|
||||
If you want to avoid waiting even for that, you can try the
|
||||
riskier one-stage build:
|
||||
|
||||
make fasterstrap
|
||||
|
||||
This should be attempted only if you're sure that the sources of
|
||||
the mcs compiler itself and the sources of the libraries used by
|
||||
it have not been changed.
|
||||
|
||||
2. Using Mono
|
||||
=============
|
||||
|
||||
Once you have installed the software, you can run a few programs:
|
||||
|
||||
* runtime engine
|
||||
|
||||
mono program.exe
|
||||
or
|
||||
mint program.exe
|
||||
|
||||
* C# compiler
|
||||
|
||||
mcs program.cs
|
||||
|
||||
* CIL Disassembler
|
||||
|
||||
monodis program.exe
|
||||
|
||||
See the man pages for mono(1), mint(1), monodis(1) and mcs(2)
|
||||
for further details.
|
||||
|
||||
3. Directory Roadmap
|
||||
====================
|
||||
A directory roadmap:
|
||||
|
||||
doc/
|
||||
Contains the web site contents.
|
||||
|
||||
docs/
|
||||
Technical documents about the Mono runtime.
|
||||
|
||||
data/
|
||||
Configuration files installed as part of the Mono runtime.
|
||||
Contains documentation and the web site contents.
|
||||
|
||||
mono/
|
||||
The core of the Mono Runtime.
|
||||
The core of the executable.
|
||||
|
||||
metadata/
|
||||
The object system and metadata reader.
|
||||
|
||||
jit/
|
||||
The Just in Time Compiler.
|
||||
The library to deal with executables and libraries for
|
||||
.NET
|
||||
|
||||
dis/
|
||||
CIL executable Disassembler
|
||||
@@ -226,10 +18,6 @@ This is Mono.
|
||||
cli/
|
||||
Common code for the JIT and the interpreter.
|
||||
|
||||
io-layer/
|
||||
The I/O layer and system abstraction for
|
||||
emulating the .NET IO model.
|
||||
|
||||
cil/
|
||||
Common Intermediate Representation, XML
|
||||
definition of the CIL bytecodes.
|
||||
@@ -237,20 +25,18 @@ This is Mono.
|
||||
interp/
|
||||
Interpreter for CLI executables.
|
||||
|
||||
arch/
|
||||
Architecture specific portions.
|
||||
* Using Mono
|
||||
|
||||
man/
|
||||
Once you have installed the software, you can run a few programs:
|
||||
|
||||
Manual pages for the various Mono commands and programs.
|
||||
monodis program.exe
|
||||
|
||||
scripts/
|
||||
That will dump the bytecodes for program.exe. Monodis support
|
||||
a number of options that dumps various metadata tables
|
||||
(chapter 23 of the Partition III).
|
||||
|
||||
Scripts used to invoke Mono and the corresponding program.
|
||||
You can try the interpreter like this:
|
||||
|
||||
runtime/
|
||||
|
||||
A directory holding a pre-compiled version of the Mono
|
||||
runtime.
|
||||
mono-int program.exe
|
||||
|
||||
|
||||
@@ -1,37 +0,0 @@
|
||||
#undef HAVE_INET_PTON
|
||||
#undef HAVE_INET_ATON
|
||||
#undef HAVE_MSG_NOSIGNAL
|
||||
#undef HAVE_SOL_IP
|
||||
#undef HAVE_SOL_TCP
|
||||
#undef HAVE_SOL_IPV6
|
||||
#undef HAVE_IP_PKTINFO
|
||||
#undef HAVE_STRUCT_IP_MREQN
|
||||
#undef HAVE_STRUCT_IP_MREQ
|
||||
#undef HAVE_PTHREAD_MUTEX_TIMEDLOCK
|
||||
#undef USE_MONO_MUTEX
|
||||
#undef HAVE_LARGE_FILE_SUPPORT
|
||||
#undef HAVE_NEW_ICONV
|
||||
#undef NAME_DEV_RANDOM
|
||||
#undef HAVE_CRYPT_RNG
|
||||
#undef HAVE_BOEHM_GC
|
||||
#undef USE_INCLUDED_LIBGC
|
||||
#undef DISABLE_SHARED_HANDLES
|
||||
#undef HAVE_TIMEZONE
|
||||
#undef HAVE_TM_GMTOFF
|
||||
#undef MONO_SIZEOF_SUNPATH
|
||||
#undef MONO_ZERO_ARRAY_LENGTH
|
||||
#undef PTHREAD_POINTER_ID
|
||||
#undef HAVE_GC_H
|
||||
#undef HAVE_GC_GCJ_MALLOC
|
||||
#undef HAVE_GC_ENABLE
|
||||
#undef WITH_BUNDLE
|
||||
#undef HAVE_GETHOSTBYNAME2_R
|
||||
#undef HAVE_ICU
|
||||
#undef HAVE_KW_THREAD
|
||||
#undef HAVE_SIGNBIT
|
||||
#undef USE_MACH_SEMA
|
||||
#undef HAVE_SOCKLEN_T
|
||||
#undef HAVE_TRUNCL
|
||||
#undef HAVE_AINTL
|
||||
#undef HAVE_SCANDIR
|
||||
#undef HAVE_WORKING_SIGALTSTACK
|
||||
@@ -8,17 +8,8 @@ srcdir=`dirname $0`
|
||||
test -z "$srcdir" && srcdir=.
|
||||
|
||||
if [ -n "$MONO_PATH" ]; then
|
||||
# from -> /mono/lib:/another/mono/lib
|
||||
# to -> /mono /another/mono
|
||||
for i in `echo ${MONO_PATH} | tr ":" " "`; do
|
||||
i=`dirname ${i}`
|
||||
if [ -n "{i}" -a -d "${i}/share/aclocal" ]; then
|
||||
ACLOCAL_FLAGS="-I ${i}/share/aclocal $ACLOCAL_FLAGS"
|
||||
fi
|
||||
if [ -n "{i}" -a -d "${i}/bin" ]; then
|
||||
PATH="${i}/bin:$PATH"
|
||||
fi
|
||||
done
|
||||
ACLOCAL_FLAGS="-I $MONO_PATH/share/aclocal $ACLOCAL_FLAGS"
|
||||
PATH="$MONO_PATH/bin:$PATH"
|
||||
export PATH
|
||||
fi
|
||||
|
||||
@@ -30,15 +21,8 @@ fi
|
||||
DIE=1
|
||||
}
|
||||
|
||||
if [ -z "$LIBTOOL" ]; then
|
||||
LIBTOOL=`which glibtool 2>/dev/null`
|
||||
if [ ! -x "$LIBTOOL" ]; then
|
||||
LIBTOOL=`which libtool`
|
||||
fi
|
||||
fi
|
||||
|
||||
(grep "^AM_PROG_LIBTOOL" $srcdir/configure.in >/dev/null) && {
|
||||
($LIBTOOL --version) < /dev/null > /dev/null 2>&1 || {
|
||||
(libtool --version) < /dev/null > /dev/null 2>&1 || {
|
||||
echo
|
||||
echo "**Error**: You must have \`libtool' installed to compile Mono."
|
||||
echo "Get ftp://ftp.gnu.org/pub/gnu/libtool-1.2d.tar.gz"
|
||||
@@ -94,42 +78,57 @@ xlc )
|
||||
am_opt=--include-deps;;
|
||||
esac
|
||||
|
||||
for coin in `find $srcdir -name configure.in -print`
|
||||
do
|
||||
dr=`dirname $coin`
|
||||
if test -f $dr/NO-AUTO-GEN; then
|
||||
echo skipping $dr -- flagged as no auto-gen
|
||||
else
|
||||
echo processing $dr
|
||||
macrodirs=`sed -n -e 's,AM_ACLOCAL_INCLUDE(\(.*\)),\1,gp' < $coin`
|
||||
( cd $dr
|
||||
macrosdir=`find . -name macros -print`
|
||||
if grep "^AM_GNU_GETTEXT" configure.in >/dev/null; then
|
||||
if grep "sed.*POTFILES" configure.in >/dev/null; then
|
||||
: do nothing -- we still have an old unmodified configure.in
|
||||
else
|
||||
echo "Creating $dr/aclocal.m4 ..."
|
||||
test -r $dr/aclocal.m4 || touch $dr/aclocal.m4
|
||||
echo "Running gettextize... Ignore non-fatal messages."
|
||||
echo "no" | gettextize --force --copy
|
||||
echo "Making $dr/aclocal.m4 writable ..."
|
||||
test -r $dr/aclocal.m4 && chmod u+w $dr/aclocal.m4
|
||||
fi
|
||||
fi
|
||||
if grep "^AM_PROG_LIBTOOL" configure.in >/dev/null; then
|
||||
if test -z "$NO_LIBTOOLIZE" ; then
|
||||
echo "Running libtoolize..."
|
||||
libtoolize --force --copy
|
||||
fi
|
||||
fi
|
||||
echo "Running aclocal $aclocalinclude ..."
|
||||
aclocal $aclocalinclude || {
|
||||
echo
|
||||
echo "**Error**: aclocal failed. This may mean that you have not"
|
||||
echo "installed all of the packages you need, or you may need to"
|
||||
echo "set ACLOCAL_FLAGS to include \"-I \$prefix/share/aclocal\""
|
||||
echo "for the prefix where you installed the packages whose"
|
||||
echo "macros were not found"
|
||||
exit 1
|
||||
}
|
||||
|
||||
if grep "^AM_PROG_LIBTOOL" configure.in >/dev/null; then
|
||||
if test -z "$NO_LIBTOOLIZE" ; then
|
||||
echo "Running libtoolize..."
|
||||
${LIBTOOL}ize --force --copy
|
||||
if grep "^AM_CONFIG_HEADER" configure.in >/dev/null; then
|
||||
echo "Running autoheader..."
|
||||
autoheader || { echo "**Error**: autoheader failed."; exit 1; }
|
||||
fi
|
||||
echo "Running automake --gnu $am_opt ..."
|
||||
automake --add-missing --gnu $am_opt ||
|
||||
{ echo "**Error**: automake failed."; exit 1; }
|
||||
echo "Running autoconf ..."
|
||||
autoconf || { echo "**Error**: autoconf failed."; exit 1; }
|
||||
) || exit 1
|
||||
fi
|
||||
fi
|
||||
|
||||
echo "Running aclocal $ACLOCAL_FLAGS ..."
|
||||
aclocal $ACLOCAL_FLAGS || {
|
||||
echo
|
||||
echo "**Error**: aclocal failed. This may mean that you have not"
|
||||
echo "installed all of the packages you need, or you may need to"
|
||||
echo "set ACLOCAL_FLAGS to include \"-I \$prefix/share/aclocal\""
|
||||
echo "for the prefix where you installed the packages whose"
|
||||
echo "macros were not found"
|
||||
exit 1
|
||||
}
|
||||
|
||||
if grep "^AM_CONFIG_HEADER" configure.in >/dev/null; then
|
||||
echo "Running autoheader..."
|
||||
autoheader || { echo "**Error**: autoheader failed."; exit 1; }
|
||||
fi
|
||||
|
||||
echo "Running automake --gnu $am_opt ..."
|
||||
automake --add-missing --gnu $am_opt ||
|
||||
{ echo "**Error**: automake failed."; exit 1; }
|
||||
echo "Running autoconf ..."
|
||||
autoconf || { echo "**Error**: autoconf failed."; exit 1; }
|
||||
|
||||
if test -d $srcdir/libgc; then
|
||||
echo Running libgc/autogen.sh ...
|
||||
(cd $srcdir/libgc ; NOCONFIGURE=1 ./autogen.sh "$@")
|
||||
echo Done running libgc/autogen.sh ...
|
||||
fi
|
||||
|
||||
done
|
||||
|
||||
conf_flags="--enable-maintainer-mode --enable-compile-warnings" #--enable-iso-c
|
||||
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
/* config.h.in. Generated automatically from configure.in by autoheader 2.13. */
|
||||
|
||||
/* Define if you have the ANSI C header files. */
|
||||
#undef STDC_HEADERS
|
||||
|
||||
/* Define if you have the <dlfcn.h> header file. */
|
||||
#undef HAVE_DLFCN_H
|
||||
|
||||
/* Name of package */
|
||||
#undef PACKAGE
|
||||
|
||||
/* Version number of package */
|
||||
#undef VERSION
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
Makefile.in
|
||||
Makefile
|
||||
config
|
||||
.cvsignore
|
||||
browscap.ini
|
||||
@@ -1,17 +0,0 @@
|
||||
monodir = $(sysconfdir)/mono
|
||||
|
||||
EXTRA_DIST = config.in \
|
||||
machine.config \
|
||||
DefaultWsdlHelpGenerator.aspx \
|
||||
browscap.ini.gz
|
||||
|
||||
mono_DATA = config \
|
||||
machine.config \
|
||||
DefaultWsdlHelpGenerator.aspx \
|
||||
browscap.ini
|
||||
|
||||
CLEANFILES = browscap.ini
|
||||
|
||||
browscap.ini: browscap.ini.gz
|
||||
gunzip -c $^ > $@
|
||||
|
||||
@@ -1,9 +0,0 @@
|
||||
<configuration>
|
||||
<dllmap dll="cygwin1.dll" target="@LIBC@" />
|
||||
<dllmap dll="libc" target="@LIBC@" />
|
||||
<dllmap dll="libxslt.dll" target="libxslt@libsuffix@" />
|
||||
<dllmap dll="libmySQL.dll" target="libmysqlclient@libsuffix@" />
|
||||
<dllmap dll="odbc32.dll" target="libodbc@libsuffix@" />
|
||||
<dllmap dll="oci" target="clntsh" />
|
||||
<dllmap dll="db2cli" target="libdb2_36@libsuffix@"/>
|
||||
</configuration>
|
||||
@@ -1,210 +0,0 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
|
||||
<configuration>
|
||||
|
||||
<configSections>
|
||||
<section name="appSettings" type="System.Configuration.NameValueFileSectionHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<section name="system.diagnostics" type="System.Diagnostics.DiagnosticsConfigurationHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<section name="system.runtime.remoting" type="System.Configuration.IgnoreSectionHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowLocation="false"/>
|
||||
<sectionGroup name="system.web">
|
||||
<section name="httpHandlers"
|
||||
type="System.Web.Configuration.HttpHandlersSectionHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="httpModules"
|
||||
type="System.Web.Configuration.HttpModulesConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="machineKey"
|
||||
type="System.Web.Configuration.MachineKeyConfigHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="authentication"
|
||||
type="System.Web.Configuration.AuthenticationConfigHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="authorization"
|
||||
type="System.Web.Configuration.AuthorizationConfigHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="globalization"
|
||||
type="System.Web.Configuration.GlobalizationConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="sessionState"
|
||||
type="System.Web.SessionState.SessionStateSectionHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="trace"
|
||||
type="System.Web.Configuration.TraceConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="webServices"
|
||||
type="System.Web.Services.Configuration.WebServicesConfigurationSectionHandler, System.Web.Services, Version=1.0.5000.0 Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="webControls"
|
||||
type="System.Web.Configuration.WebControlsSectionHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="compilation"
|
||||
type="System.Web.Configuration.CompilationConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="httpRuntime"
|
||||
type="System.Web.Configuration.HttpRuntimeConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="customErrors"
|
||||
type="System.Web.Configuration.CustomErrorsConfigHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<section name="pages"
|
||||
type="System.Web.Configuration.PagesConfigurationHandler, System.Web, Version=1.0.5000.0, Culture=neutral" />
|
||||
<section name="clientTarget"
|
||||
type="System.Web.Configuration.ClientTargetSectionHandler, System.Web, Version=1.0.5000.0, Culture=neutral" />
|
||||
</sectionGroup>
|
||||
<sectionGroup name="system.net">
|
||||
<section name="settings"
|
||||
type="System.Net.Configuration.NetConfigurationHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<section name="connectionManagement"
|
||||
type="System.Net.Configuration.ConnectionManagementHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<section name="authenticationModules"
|
||||
type="System.Net.Configuration.NetAuthenticationModuleHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<section name="defaultProxy"
|
||||
type="System.Net.Configuration.DefaultProxyHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<section name="webRequestModules"
|
||||
type="System.Net.Configuration.WebRequestModuleHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
</sectionGroup>
|
||||
<section name="system.drawing" type="System.Configuration.NameValueSectionHandler, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
</configSections>
|
||||
<system.net>
|
||||
<connectionManagement>
|
||||
<add address="*" maxconnection="2" />
|
||||
</connectionManagement>
|
||||
<authenticationModules>
|
||||
<add type="System.Net.BasicClient, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<add type="System.Net.DigestClient, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<add type="System.Net.NtlmClient, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
</authenticationModules>
|
||||
<defaultProxy>
|
||||
<proxy />
|
||||
<!-- bypassonlocal and proxyaddress are ok -->
|
||||
<!-- usessystemdefault is not supported -->
|
||||
</defaultProxy>
|
||||
<webRequestModules>
|
||||
<add prefix="http" type="System.Net.HttpRequestCreator, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<add prefix="https" type="System.Net.HttpRequestCreator, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<add prefix="file" type="System.Net.FileWebRequestCreator, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
</webRequestModules>
|
||||
<settings>
|
||||
<ipv6 enabled="false"/>
|
||||
</settings>
|
||||
</system.net>
|
||||
<system.web>
|
||||
<httpHandlers>
|
||||
<add verb="*" path="Trace.axd" type="System.Web.Handlers.TraceHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add verb="*" path="*.aspx" type="System.Web.UI.PageHandlerFactory, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add verb="*" path="*.asmx" validate="false" type="System.Web.Services.Protocols.WebServiceHandlerFactory, System.Web.Services, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add verb="*" path="*.ashx" type="System.Web.UI.SimpleHandlerFactory, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add verb="GET" path="WebResource.axd" type="System.Web.Handlers.AssemblyResourceLoader, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add verb="*" path="*.asax" type="System.Web.HttpForbiddenHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add verb="*" path="*.ascx" type="System.Web.HttpForbiddenHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add verb="*" path="*.config" type="System.Web.HttpForbiddenHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add verb="*" path="*.cs" type="System.Web.HttpForbiddenHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add verb="*" path="*.rem" type="System.Runtime.Remoting.Channels.Http.HttpRemotingHandlerFactory, System.Runtime.Remoting, Culture=neutral, PublicKeyToken=b77a5c561934e089" validate="false" />
|
||||
<add verb="*" path="*.soap" type="System.Runtime.Remoting.Channels.Http.HttpRemotingHandlerFactory, System.Runtime.Remoting, Culture=neutral, PublicKeyToken=b77a5c561934e089" validate="false" />
|
||||
<add verb="GET,HEAD" path="*" type="System.Web.StaticFileHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add verb="*" path="*" type="System.Web.HttpMethodNotAllowedHandler, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
</httpHandlers>
|
||||
<httpModules>
|
||||
<add name="FormsAuthentication" type="System.Web.Security.FormsAuthenticationModule, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add name="UrlAuthorization" type="System.Web.Security.UrlAuthorizationModule, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add name="Session" type="System.Web.SessionState.SessionStateModule, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
<add name="OutputCache" type="System.Web.Caching.OutputCacheModule, System.Web, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
|
||||
</httpModules>
|
||||
<authentication mode="Forms">
|
||||
<forms name=".MONOAUTH" loginUrl="login.aspx" protection="All" timeout="30" path="/">
|
||||
<credentials passwordFormat="Clear">
|
||||
<!--<user name="gonzalo" password="gonz"/>-->
|
||||
</credentials>
|
||||
</forms>
|
||||
</authentication>
|
||||
<machineKey validationKey="AutoGenerate" decryptionKey="AutoGenerate" validation="SHA1" />
|
||||
<globalization requestEncoding="utf-8"
|
||||
responseEncoding="utf-8"
|
||||
fileEncoding="utf-8"/>
|
||||
<!--
|
||||
culture="en-US"
|
||||
uiculture="en-US" />
|
||||
-->
|
||||
<sessionState mode="InProc" />
|
||||
<webServices>
|
||||
<protocols>
|
||||
<add name="HttpSoap"/>
|
||||
<add name="HttpPost"/>
|
||||
<add name="HttpGet"/>
|
||||
<add name="Documentation"/>
|
||||
</protocols>
|
||||
<wsdlHelpGenerator href="DefaultWsdlHelpGenerator.aspx" />
|
||||
</webServices>
|
||||
<webControls clientScriptsLocation="/web_scripts" />
|
||||
<compilation debug="false" defaultLanguage="c#">
|
||||
<compilers>
|
||||
<compiler language="cs;c#;csharp" extension=".cs" warningLevel="1" compilerOptions=""
|
||||
type="Microsoft.CSharp.CSharpCodeProvider, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<compiler language="vb;vbs;visualbasic;vbscript" extension=".vb"
|
||||
warningLevel="1" compilerOptions=""
|
||||
type="Microsoft.VisualBasic.VBCodeProvider, System, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
</compilers>
|
||||
<assemblies>
|
||||
<!--<add assembly="mscorlib" /> -->
|
||||
<add assembly="System" />
|
||||
<add assembly="System.Xml" />
|
||||
<add assembly="System.Data" />
|
||||
<add assembly="System.Web" />
|
||||
<add assembly="System.Web.Services" />
|
||||
<add assembly="System.Drawing" />
|
||||
<add assembly="*" /> <!-- Add assemblies in bin directory -->
|
||||
</assemblies>
|
||||
</compilation>
|
||||
<httpRuntime executionTimeout="90"
|
||||
maxRequestLength="4096"
|
||||
useFullyQualifiedRedirectUrl="false"
|
||||
minFreeThreads="8"
|
||||
minLocalRequestFreeThreads="4"
|
||||
appRequestQueueLimit="100" />
|
||||
<pages buffer="true"
|
||||
enableSessionState="true"
|
||||
autoEventWireup="true"
|
||||
validateRequest="true" />
|
||||
</system.web>
|
||||
|
||||
<system.runtime.remoting>
|
||||
<application>
|
||||
<channels>
|
||||
<channel ref="http client" displayName="http client (delay loaded)" delayLoadAsClientChannel="true" />
|
||||
<channel ref="tcp client" displayName="tcp client (delay loaded)" delayLoadAsClientChannel="true" />
|
||||
</channels>
|
||||
</application>
|
||||
<channels>
|
||||
<channel id="http" type="System.Runtime.Remoting.Channels.Http.HttpChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<channel id="http client" type="System.Runtime.Remoting.Channels.Http.HttpClientChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<channel id="http server" type="System.Runtime.Remoting.Channels.Http.HttpServerChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<channel id="tcp" type="System.Runtime.Remoting.Channels.Tcp.TcpChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<channel id="tcp client" type="System.Runtime.Remoting.Channels.Tcp.TcpClientChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<channel id="tcp server" type="System.Runtime.Remoting.Channels.Tcp.TcpServerChannel, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
</channels>
|
||||
<channelSinkProviders>
|
||||
<clientProviders>
|
||||
<formatter id="soap" type="System.Runtime.Remoting.Channels.SoapClientFormatterSinkProvider, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<formatter id="binary" type="System.Runtime.Remoting.Channels.BinaryClientFormatterSinkProvider, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
</clientProviders>
|
||||
<serverProviders>
|
||||
<formatter id="soap" type="System.Runtime.Remoting.Channels.SoapServerFormatterSinkProvider, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<formatter id="binary" type="System.Runtime.Remoting.Channels.BinaryServerFormatterSinkProvider, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
<provider id="wsdl" type="System.Runtime.Remoting.MetadataServices.SdlChannelSinkProvider, System.Runtime.Remoting, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
|
||||
</serverProviders>
|
||||
</channelSinkProviders>
|
||||
</system.runtime.remoting>
|
||||
|
||||
<appSettings>
|
||||
<!--<add key="yourkey" value="your value" /> -->
|
||||
<!--<remove key="a key defined higher in the hierarchy" /> -->
|
||||
<!--<clear/> Removes all defined settings -->
|
||||
</appSettings>
|
||||
<system.diagnostics>
|
||||
<trace autoflush="false" indentsize="4" />
|
||||
</system.diagnostics>
|
||||
<system.drawing>
|
||||
</system.drawing>
|
||||
|
||||
<strongNames>
|
||||
<pubTokenMapping>
|
||||
<!-- ECMA key -->
|
||||
<map Token="b77a5c561934e089" PublicKey="002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df" />
|
||||
<!-- Microsoft (final) key -->
|
||||
<map Token="b03f5f7f11d50a3a" PublicKey="002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df" />
|
||||
<!-- Microsoft (Web Service Enhancement) key -->
|
||||
<map Token="31bf3856ad364e35" PublicKey="002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df" />
|
||||
<!-- IBM (DB2 Data Provider) key -->
|
||||
<map Token="7c307b91aa13d208" PublicKey="002400000480000094000000060200000024000052534131000400000100010079159977d2d03a8e6bea7a2e74e8d1afcc93e8851974952bb480a12c9134474d04062447c37e0e68c080536fcf3c3fbe2ff9c979ce998475e506e8ce82dd5b0f350dc10e93bf2eeecf874b24770c5081dbea7447fddafa277b22de47d6ffea449674a4f9fccf84d15069089380284dbdd35f46cdff12a1bd78e4ef0065d016df" />
|
||||
</pubTokenMapping>
|
||||
</strongNames>
|
||||
</configuration>
|
||||
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
Makefile.in
|
||||
Makefile
|
||||
all-docs
|
||||
@@ -0,0 +1,19 @@
|
||||
WEB_FILES= \
|
||||
c-sharp class-library contact contributing documentation download \
|
||||
faq gcc-frontend ideas index passport rationale resources \
|
||||
roadmap runtime status team testing thanks tools
|
||||
|
||||
OTHERS= pending resources-pending todo
|
||||
|
||||
EXTRA_DIST = $(WEB_FILES) README $(OTHERS)
|
||||
|
||||
all-docs: $(WEB_FILES)
|
||||
cat rationale roadmap c-sharp tools class-library \
|
||||
runtime documentation download faq contributing \
|
||||
resources status > all-docs
|
||||
|
||||
webit:
|
||||
(cd web; make && make push)
|
||||
|
||||
push-notes:
|
||||
scp release-notes/mono* www@www:/web/cvsmodules/mono/archive
|
||||
@@ -0,0 +1,17 @@
|
||||
To edit the website appearance:
|
||||
|
||||
cd doc/web
|
||||
edit template.html.in
|
||||
make
|
||||
|
||||
To edit website content:
|
||||
|
||||
cd doc (this directory)
|
||||
edit files carefully
|
||||
cd web
|
||||
make
|
||||
|
||||
To publish changes:
|
||||
|
||||
cd web
|
||||
make push
|
||||
@@ -0,0 +1,188 @@
|
||||
* MCS: The Ximian C# compiler
|
||||
|
||||
MCS began as an experiment to learn the features of C# by
|
||||
writing a large C# program. MCS is currently able to parse C#
|
||||
programs and create an internal tree representation of the
|
||||
program. MCS can parse itself.
|
||||
|
||||
MCS now does type checking at the class, interface and struct
|
||||
levels and can resolve the class hierarchy and as of last week
|
||||
can generate interface code.
|
||||
|
||||
Work is progressing quickly on various fronts in the C#
|
||||
compiler. Recently I started using the System.Reflection API
|
||||
to load system type definitions and avoid self-population of
|
||||
types in the compiler and dropped my internal Type
|
||||
representation in favor of using the CLI's System.Type.
|
||||
|
||||
** Phases of the compiler
|
||||
|
||||
The compiler has a number of phases:
|
||||
|
||||
<ul>
|
||||
* Lexical analyzer: hand-coded lexical analyzer that
|
||||
provides tokens to the parser.
|
||||
|
||||
* The Parser: the parser is implemented using Jay (A
|
||||
Berkeley Yacc port to Java, that I ported to C#).
|
||||
The parser does minimal work and syntax checking,
|
||||
and only constructs a parsed tree.
|
||||
|
||||
Each language element gets its own class. The code
|
||||
convention is to use an uppercase name for the
|
||||
language element. So a C# class and its associated
|
||||
information is kept in a "Class" class, a "struct"
|
||||
in a "Struct" class and so on. Statements derive
|
||||
from the "Statement" class, and Expressions from the
|
||||
Expr class.
|
||||
|
||||
* Parent class resolution: before the actual code
|
||||
generation, we need to resolve the parents and
|
||||
interfaces for interface, classe and struct
|
||||
definitions.
|
||||
|
||||
* Semantic analysis: since C# can not resolve in a
|
||||
top-down pass what identifiers actually mean, we
|
||||
have to postpone this decision until the above steps
|
||||
are finished.
|
||||
|
||||
* Code generation: The compiler recently started generating IL
|
||||
executables that contain interfaces. Work is
|
||||
progressing in other areas.
|
||||
|
||||
The code generation is done through the System.Reflection.Emit API.
|
||||
</ul>
|
||||
|
||||
<a name="tasks">
|
||||
** Current pending tasks
|
||||
|
||||
Simple tasks:
|
||||
|
||||
<ul>
|
||||
* Array declarations are currently being ignored,
|
||||
|
||||
* PInvoke declarations are not supported.
|
||||
|
||||
* Pre-processing is not supported.
|
||||
|
||||
* Attribute declarations and passing currently ignored.
|
||||
|
||||
* Compiler does not pass around line/col information from tokenizer for error reporting.
|
||||
|
||||
* Jay does not work correctly with `error'
|
||||
productions, making parser errors hard to point. It
|
||||
would be best to port the Bison-To-Java compiler to
|
||||
become Bison-to-C# compiler ([email protected]
|
||||
might have more information)
|
||||
</ul>
|
||||
|
||||
Interesting and Fun hacks to the compiler:
|
||||
|
||||
<ul>
|
||||
* Finishing the JB port from Java to C#. If you are
|
||||
interested in working on this, please contact Brian
|
||||
Jepson (bjepson at oreilly d-o-t com).
|
||||
|
||||
More on JB at: <a href="http://www.cs.colorado.edu/~dennis/software/jb.html">
|
||||
http://www.cs.colorado.edu/~dennis/software/jb.html</a>
|
||||
|
||||
JB will allow us to move from the Berkeley Yacc
|
||||
based Jay to a Bison-based compiler (better error
|
||||
reporting and recovery).
|
||||
|
||||
* Semantic Analysis: Return path coverage and
|
||||
initialization before use coverage are two great
|
||||
features of C# that help reduce the number of bugs
|
||||
in applications. It is one interesting hack.
|
||||
|
||||
* Enum resolutions: it is another fun hack, as enums can be defined
|
||||
in terms of themselves (<tt>enum X { a = b + 1, b = 5 }</tt>).
|
||||
|
||||
</ul>
|
||||
|
||||
** Questions and Answers
|
||||
|
||||
Q: Why not write a C# front-end for GCC?
|
||||
|
||||
A: I wanted to learn about C#, and this was an exercise in this
|
||||
task. The resulting compiler is highly object-oriented, which has
|
||||
lead to a very nice, easy to follow and simple implementation of
|
||||
the compiler.
|
||||
|
||||
I found that the design of this compiler is very similar to
|
||||
Guavac's implementation.
|
||||
|
||||
Targeting the CIL/MSIL byte codes would require to re-architecting
|
||||
GCC, as GCC is mostly designed to be used for register machines.
|
||||
|
||||
The GCC Java engine that generates Java byte codes cheats: it does
|
||||
not use the GCC backend; it has a special backend just for Java, so
|
||||
you can not really generate Java bytecodes from the other languages
|
||||
supported by GCC.
|
||||
|
||||
Q: If your C# compiler is written in C#, how do you plan on getting
|
||||
this working on a non-Microsoft environment.
|
||||
|
||||
We will do this through an implementation of the CLI Virtual
|
||||
Execution System for Unix (our JIT engine).
|
||||
|
||||
Q: Do you use Bison?
|
||||
|
||||
A: No, currently I am using Jay which is a port of Berkeley Yacc to
|
||||
Java that I later ported to C#. This means that error recovery is
|
||||
not as nice as I would like to, and for some reason error
|
||||
productions are not being caught.
|
||||
|
||||
In the future I want to port one of the Bison/Java ports to C# for
|
||||
the parser.
|
||||
|
||||
Q: Should someone work on a GCC front-end to C#?
|
||||
|
||||
A: I would love if someone does, and we would love to help anyone that
|
||||
takes on that task, but we do not have the time or expertise to
|
||||
build a C# compiler with the GCC engine. I find it a lot more fun
|
||||
personally to work on C# on a C# compiler, which has an intrinsic
|
||||
beauty.
|
||||
|
||||
We can provide help and assistance to anyone who would like to work
|
||||
on this task.
|
||||
|
||||
Q: Should someone make a GCC backend that will generate CIL images?
|
||||
|
||||
A: I would love to see a backend to GCC that generates CIL images. It
|
||||
would provide a ton of free compilers that would generate CIL
|
||||
code. This is something that people would want to look into
|
||||
anyways for Windows interoperation in the future.
|
||||
|
||||
Again, we would love to provide help and assistance to anyone
|
||||
interested in working in such a project.
|
||||
|
||||
Q: What about making a front-end to GCC that takes CIL images and
|
||||
generates native code?
|
||||
|
||||
A: I would love to see this, specially since GCC supports this same
|
||||
feature for Java Byte Codes. You could use the metadata library
|
||||
from Mono to read the byte codes (ie, this would be your
|
||||
"front-end") and generate the trees that get passed to the
|
||||
optimizer.
|
||||
|
||||
Ideally our implementation of the CLI will be available as a shared
|
||||
library that could be linked with your application as its runtime
|
||||
support.
|
||||
|
||||
Again, we would love to provide help and assistance to anyone
|
||||
interested in working in such a project.
|
||||
|
||||
Q: But would this work around the GPL in the GCC compiler and allow
|
||||
people to work on non-free front-ends?
|
||||
|
||||
A: People can already do this by targeting the JVM byte codes (there
|
||||
are about 130 compilers for various languages that target the JVM).
|
||||
|
||||
Q: Why are you writing a JIT engine instead of a front-end to GCC?
|
||||
|
||||
A: The JIT engine and runtime engine will be able to execute CIL
|
||||
executables generated on Windows.
|
||||
|
||||
You might also want to look at the <a href="faq.html#gcc">GCC</a>
|
||||
section on the main FAQ
|
||||
@@ -0,0 +1,112 @@
|
||||
* CVS Access
|
||||
|
||||
If you are an active Mono developer, you can get a CVS account
|
||||
that hosts the Mono source code.
|
||||
|
||||
Send an e-mail to miguel with your public SSH key for this
|
||||
purpose. Please specify if the key was generated with SSH1 or SSH2.
|
||||
|
||||
If you are using SSH2, please generate your key using:
|
||||
|
||||
<pre>
|
||||
ssh-keygen -t rsa
|
||||
</pre>
|
||||
|
||||
And mail me the id_rsa.pub file.
|
||||
|
||||
If you are using SSH1, run:
|
||||
<pre>
|
||||
ssh-keygen
|
||||
</pre>
|
||||
|
||||
And mail me your identity.pub file.
|
||||
|
||||
You will need CVS and SSH. Windows users can get both by
|
||||
installing Cygwin (<a
|
||||
href="http://www.cygwin.com">http://www.cygwin.com</a>)
|
||||
|
||||
Unix users will probably have those tools installed already.
|
||||
|
||||
** Checking out the sources
|
||||
|
||||
To check out the sources for the first time from the
|
||||
repository, use this command:
|
||||
|
||||
<pre>
|
||||
export CVS_RSH=ssh
|
||||
export [email protected]:/cvs/public
|
||||
cvs -z3 co mcs mono
|
||||
</pre>
|
||||
|
||||
** Updating your sources
|
||||
|
||||
Every day people will be making changes, to get your latest
|
||||
updated sources, use:
|
||||
|
||||
<pre>
|
||||
cvs -z3 update -Pd mcs mono
|
||||
</pre>
|
||||
|
||||
Note: The '-z3' enables compression for the whole cvs action.
|
||||
The '-Pd' makes the update operation (P)rune directories that
|
||||
have been deleted and get new (d)irectories added to the
|
||||
repository.
|
||||
|
||||
** Making patches
|
||||
|
||||
Usually you will want to make a patch to contribute, and let
|
||||
other people review it before commiting it. To obtain such a
|
||||
"patch", you type:
|
||||
|
||||
<pre>
|
||||
cd directory-you-want-to-diff
|
||||
cvs -z3 diff -u > file.diff
|
||||
mail [email protected] < file.diff
|
||||
</pre>
|
||||
|
||||
** Commiting your work
|
||||
|
||||
Once you get approval to commit to the CVS, or if you are
|
||||
commiting code that you are the maintainer of, you will want
|
||||
to commit your code to CVS.
|
||||
|
||||
To do this, you have to "add" any new files that you created:
|
||||
|
||||
<pre>
|
||||
cvs add new-file.cs
|
||||
</pre>
|
||||
|
||||
And then commit your changes to the repository:
|
||||
|
||||
<pre>
|
||||
cvs commit file-1.cs file-2.cs
|
||||
</pre>
|
||||
|
||||
** The Mailing List
|
||||
|
||||
To keep track of the various development and changes to the
|
||||
CVS tree, you can subscribe to the [email protected].
|
||||
To subscribe, send an email message to
|
||||
[email protected] and in the body of the
|
||||
message put `subscribe'.
|
||||
|
||||
This will send you an email message every time a change is
|
||||
made to the CVS repository, together with the information that
|
||||
the author of the changes submitted.
|
||||
|
||||
** Recommendations
|
||||
|
||||
Please do not commit code that would break the compile to the
|
||||
CVS, because that normally wastes everybody's time.
|
||||
|
||||
Make sure that you add all the files before you do a commit.
|
||||
|
||||
Use ChangeLog entries so we can keep textual descriptions of
|
||||
your work, and use the contents of your ChangeLog file as the
|
||||
CVS commit message (ie, paste the contents of this into the
|
||||
editor buffer).
|
||||
|
||||
If you are making changes to someone else's code, please make
|
||||
sure you get in touch with the maintainer of that code before
|
||||
applying patches. You want to avoid commiting conflicting
|
||||
work to someone else's code.
|
||||
@@ -0,0 +1,183 @@
|
||||
* The Class Library
|
||||
|
||||
The Class Library should be compatible with Microsoft's .NET
|
||||
implementation.
|
||||
|
||||
Please see the <a href="class-status.html">Class Status</a>
|
||||
page for a status of who is working on which classes.
|
||||
|
||||
We will write as much code as possible in C#. We may need to
|
||||
interface with code written in C to gain access to the
|
||||
functionality of libraries like libart, Gtk+, and libc.
|
||||
|
||||
** Contributing
|
||||
|
||||
We welcome contributions to the the Class Library. To get
|
||||
started, check the status page for information about which
|
||||
APIs are being worked on, and how to get in touch with
|
||||
individual maintainers.
|
||||
|
||||
If you want to work on a class, first check the <a
|
||||
href="download.html">Classes Distribution</a> to see if it is
|
||||
not implemented yet, if not, check the <a
|
||||
href="class-status.html">Class Status</a> to see if someone is
|
||||
already working on it, and maybe contact them.
|
||||
|
||||
If nobody is working on it, mail <a
|
||||
href="mailto:[email protected]">[email protected]</a>
|
||||
with the class you want to implement and CC <a
|
||||
href="mailto:[email protected]">[email protected]</a>.
|
||||
|
||||
You can also track live the activities of the Mono CVS module
|
||||
by subscribing to the <a
|
||||
href="http://mail.ximian.com/mailman/listinfo/mono-cvs-list">mono-cvs-list</a>
|
||||
|
||||
|
||||
|
||||
** Layout
|
||||
|
||||
The Class Library resides in the `mcs' module in the directoy
|
||||
`class'.
|
||||
|
||||
Each directory in the directory represents the assembly where
|
||||
the code belongs to, and inside each directory we divide the
|
||||
code based on the namespace they implement.
|
||||
|
||||
There are two cases when we should consider portability: when
|
||||
we are dealing with a couple of classes only that differ from
|
||||
system to system (Consider System.Net and System.IO for Win32
|
||||
and Unix). In those cases we will just place the files for
|
||||
example on <t>corlib/System/System.IO/Unix-Console.cs</t> and
|
||||
<t>corlib/System/System.IO/Win32-Console.cs</t>.
|
||||
|
||||
For classes that might differ more (for example, the
|
||||
implementation of Windows.Forms), we might have different
|
||||
directories altogether: <t>System.Windows.Forms/Win32</t>,
|
||||
<t>System.Windows.Forms/Gtk+</t> and
|
||||
<t>System.Windows.Forms/Cocoa</t>.
|
||||
|
||||
** Using existing components from GNOME.
|
||||
|
||||
Our current plan is to implement the GUI tools on top of
|
||||
Gtk+. The only obstacle here is that applications from Windows
|
||||
might expect to be able to pull the HWND property from the
|
||||
widgets and use PInvoke to call Windows functions.
|
||||
|
||||
** Class Library and Win32 dependencies.
|
||||
|
||||
There are a few spots where the Win32 foundation is exposed to
|
||||
the class library (for example, the HDC and HWND properties in
|
||||
the GDI+). Casual inspection suggests that these can be
|
||||
safely mapped to Gdk's GC and GdkWindow pointers without
|
||||
breaking anything.
|
||||
|
||||
The only drawback is that support for PInvoke of Win32 code
|
||||
won't be available. An alternate solution would be to use
|
||||
portions of Wine, or even to use Wine as our toolkit.
|
||||
|
||||
*** Initial GDI+ and WinForms implementation
|
||||
|
||||
The initial implementation will use Gtk+ as the underlying
|
||||
toolkit. Since GTK+ has already been ported to many windowing
|
||||
systems other than X (including frame buffer, Win32, and BeOS)
|
||||
its use should cover most applications for most users.
|
||||
|
||||
*** Database access
|
||||
|
||||
We will implement ADO.NET functionality by reusing <a
|
||||
href="http://www.gnome-db.org">GNOME-DB</a>. This is an ideal
|
||||
choice, since GNOME-DB was implemented precisely to provide an
|
||||
ADO-like system for GNOME.
|
||||
|
||||
*** Component Integration
|
||||
|
||||
We will provide a new namespace to use GNOME specific features
|
||||
as well as a namespace to host Bonobo interfaces and classes
|
||||
in Mono.
|
||||
|
||||
** Licensing
|
||||
|
||||
The class library will be licensed under the terms of the GNU
|
||||
LGPL. Some people have pointed out that the plain LGPL is
|
||||
troublesome for embedded use of the Mono class libraries. So
|
||||
we are considering to use the GPL with a special exception
|
||||
(like the <a
|
||||
href="http://www.gnu.org/software/classpath/classpath.html">GNU
|
||||
Classpath</a> project did.
|
||||
|
||||
The exception to the GPL would be:
|
||||
|
||||
<i>The library is distributed under the terms of the GNU General
|
||||
Public License with the following exception:
|
||||
|
||||
If you link this library against your own program, then you do not
|
||||
need to release the source code for that program. However, any
|
||||
changes that you make to the library itself, or to any native
|
||||
methods upon which the library relies, must be re-distributed in
|
||||
accordance with the terms of the GPL.</i>
|
||||
|
||||
If you are going to contribute, please keep in mind that we
|
||||
might require you to agree that Ximian might adjust the
|
||||
license to enable the use of the class libraries on embedded
|
||||
systems or to develop proprietary applications using Mono.
|
||||
|
||||
We suggest that you assign the copyright of your work to the
|
||||
GNOME Foundation or the Free Software Foundation to simplify
|
||||
defending the code in case it is used inappropiately.
|
||||
|
||||
** Class Library testing
|
||||
|
||||
We need to write regression tests that will verify
|
||||
the correctness of the class library, compiler, and JIT
|
||||
engine.
|
||||
|
||||
Please write your regression tests using <a
|
||||
href="http://nunit.sourceforge.net">NUnit</a>
|
||||
|
||||
** Coding conventions
|
||||
|
||||
Please follow the conventions on the ECMA specification (On
|
||||
the Annex Partition) for your coding your libraries.
|
||||
|
||||
Use 8 space tabs for writing your code (hopefully we can keep
|
||||
this consistent). If you are modifying someone else's code, try
|
||||
to keep the coding style similar.
|
||||
|
||||
For a rationale on 8 space tabs, read Linus Torvald's Coding
|
||||
Style guidelines in the Linux kernel source for a rationale.
|
||||
|
||||
*** Missing implementation bits
|
||||
|
||||
If you implement a class and you are missing implementation bits,
|
||||
please put in the code the word "TODO" and a description of what
|
||||
is missing to be implemented.
|
||||
|
||||
*** Tagging buggy code
|
||||
|
||||
If there is a bug in your implementation tag the problem by using
|
||||
the word "FIXME" in the code, together with a description of the
|
||||
problem.
|
||||
|
||||
Do not use XXX or obscure descriptions, because otherwise people
|
||||
will not be able to understand what you mean.
|
||||
|
||||
*** Tagging Lame specs
|
||||
|
||||
Sometimes the specification will be lame (consider Version.ToString (fieldCount)
|
||||
where there is no way of knowing how many fields are available, making the API
|
||||
not only stupid, but leading to unreliable code).
|
||||
|
||||
In those cases, use the keyword "LAMESPEC".
|
||||
|
||||
** FAQ
|
||||
|
||||
Frequently asked questions about the class library:
|
||||
|
||||
Q: I am writing a new class that overrides one of the system classes,
|
||||
and I am getting a 1595 warning from the compiler. Should we use a
|
||||
different namespace?
|
||||
|
||||
A: There is a quick solution to the problem, you can pass the command
|
||||
line argument /nowarn:1595 and this will effectively let you use
|
||||
your implementation of the code, while overriding the ones from the
|
||||
system assemblies.
|
||||
@@ -0,0 +1,16 @@
|
||||
* Status of the various pieces of the class library
|
||||
|
||||
You can browse the status of the class library and see who has
|
||||
registered to work on what parts of the system. These list
|
||||
work-in-progress components currently.
|
||||
|
||||
Browse the current <a href="class-status/index.html">status</a>.
|
||||
|
||||
You can also download the XML <a
|
||||
href="class-status/maintainers.xml">maintainers</a> file that
|
||||
contains the actual maintainers list.
|
||||
|
||||
You can also download the master <a
|
||||
href="class-status/class.xml">Class Status XML</a> file.
|
||||
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
* Contacting the Mono team.
|
||||
|
||||
You can contact the Mono Team by sending e-mail to `<a
|
||||
href="mailto:[email protected]">[email protected]</a>'.
|
||||
|
||||
You can contact the general forum of discussion by sending
|
||||
e-mail to <a href="mailto:[email protected]">[email protected]</a>
|
||||
|
||||
You can contact me (Miguel de Icaza) by sending e-mail to <a
|
||||
href="mailto:[email protected]">[email protected]</a>. My web
|
||||
page is <a
|
||||
href="http://primates.ximian.com/~miguel">http://primates.ximian.com/~miguel"</a>
|
||||
|
||||
You can also <a
|
||||
href="http://www.ximian.com/about/contact.php3">reach Ximian.</a>
|
||||
|
||||
@@ -0,0 +1,105 @@
|
||||
* Contributing to the Mono project
|
||||
|
||||
There are many ways in which you can help in the Mono project:
|
||||
|
||||
<ul>
|
||||
* <b>Programmers:</b> You can work on a free
|
||||
implementation of the <a
|
||||
href="class-library.html">class libraries</a>, the
|
||||
<a href="runtime.html">runtime engine</a>, <a
|
||||
href="tools.html">the tools</a>, the <a
|
||||
href="testing.html">testing framework</a>
|
||||
|
||||
* <b>Writers:</b> You can help us bywriting <a
|
||||
href="documentation.html">documentation</a>.
|
||||
</ul>
|
||||
|
||||
Those are just broad things that need to be worked on, but
|
||||
something that would help tremendously would be to help with
|
||||
small duties in the project that need to be addressed.
|
||||
|
||||
** To start contributing
|
||||
|
||||
To start developing classes or to contribute to the compiler,
|
||||
you only need Windows and the .NET Beta 2 SDK. Please notice
|
||||
that you do not need Visual Studio (although you can use it if
|
||||
you want).
|
||||
|
||||
You can get it <a href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/000/976/msdncompositedoc.xml&frame=true">here</a>
|
||||
|
||||
Alternatively you can use the <a
|
||||
href="#compile-service">compilation service</a> that was setup by
|
||||
Derek.
|
||||
|
||||
** Bug reporting
|
||||
|
||||
If you find bugs in Mono, please make sure you enter a bug
|
||||
report so we can keep track of problems in Mono.
|
||||
|
||||
To enter bug reports go to <a href="http://bugzilla.ximian.com">
|
||||
http://bugzilla.ximian.com</a> and enter bug reports against
|
||||
your favorite component (Mono, Runtime, C# compiler).
|
||||
|
||||
** Small tasks
|
||||
|
||||
A few smaller tasks are here, dropped in no particular order:
|
||||
<ul>
|
||||
* <b>MCS compilation process:</b> Currently MCS does
|
||||
not build with a single `make' command. This should
|
||||
be fixed (this being part of the `Joel Test' that
|
||||
software has to pass).
|
||||
|
||||
* <b>Mono/doc and web site:</b> They need to be
|
||||
packaged up in the official `distribution'
|
||||
</ul>
|
||||
|
||||
<a name="compile-service">
|
||||
* C# Compilation Service
|
||||
|
||||
If you are working on a class for the Mono project, but do not
|
||||
have a C# compiler available or a Windows machine to run the
|
||||
.NET SDK, you can use the compilation service that Derek
|
||||
Holden setup in the following URL: <a
|
||||
href="http://toilet.2y.net:8080/">http://toilet.2y.net:8080/</a>
|
||||
|
||||
The service will let you compile a source file and get back a
|
||||
list of errors in the class file. You will not be able to run
|
||||
the code, but at least you can get some code written that will
|
||||
help us further down the line.
|
||||
|
||||
You can contact (and thank) Derek for this service by sending
|
||||
him nice email at <a
|
||||
href="mailto:[email protected]">[email protected]</a>
|
||||
|
||||
* Books on C# and DotNet.
|
||||
|
||||
<ul>
|
||||
* Dotnet Books (<a href="http://www.dotnetbooks.com">http://www.dotnetbooks.com</a>)
|
||||
|
||||
* Dotnet Resources (<a href="http://www.dotnetexperts.com/resources/">
|
||||
http://www.dotnetexperts.com/resources</a>)
|
||||
|
||||
* O'Really C# Essentials (<a href="http://www.oreilly.com/catalog/csharpess/">
|
||||
http://www.oreally.com/catalog/csharpess</a>)
|
||||
|
||||
* O'Really .NET Essentials (<a href="http://www.oreilly.com/catalog/dotnetfrmess/">
|
||||
http://www.oreally.com/catalog/dotnetfrmess</a>)
|
||||
|
||||
* Special note
|
||||
|
||||
If you have looked at Microsoft's implementation of .NET or
|
||||
their shared source code, you may not be able to contribute
|
||||
to Mono. Details will follow when we know more about this.
|
||||
|
||||
In general be careful when you are implementing free software
|
||||
and you have access to proprietary code. We need to make sure
|
||||
that we are not using someone else's copyrighted code
|
||||
accidentally.
|
||||
|
||||
Please do not use the <b>ildasm</b> program to disassemble
|
||||
proprietary code when you are planning to reimplement a class
|
||||
for Mono. If you have done this, we might not be able to use
|
||||
your code.
|
||||
|
||||
Please stick to published documentation for implementing any
|
||||
classes.
|
||||
@@ -0,0 +1,190 @@
|
||||
* Developer FAQ
|
||||
|
||||
** New classes
|
||||
|
||||
Q: Should we write classes which are not part of the .NET or ECMA specs?
|
||||
|
||||
A: Yes. The ECMA and .NET specifications are far from complete, and
|
||||
to produce a complete platform we will need a number of other
|
||||
classes and components.
|
||||
|
||||
Any new classes that are not part of .NET or ECMA should be
|
||||
designed to be reusable on anyone's CLI implementation. So that
|
||||
Windows developers can also use any new classes that we come up
|
||||
with.
|
||||
|
||||
We have a few existing <a href="ideas.html">Ideas on missing
|
||||
classes</a>
|
||||
|
||||
** Language Compatibility
|
||||
|
||||
Q: What is the magic that allow multiple languages to co-exist?
|
||||
|
||||
A: From Fergus Henderson:
|
||||
|
||||
<i><blockquote>
|
||||
There are different levels of interoperability.
|
||||
The ECMA spec defines different categories of
|
||||
CLS (Common Language Specification) conformance.
|
||||
There are also some useful categories that don't
|
||||
correspond to any of the levels defined in the ECMA spec.
|
||||
In increasing degree of difficulty, your language implementation
|
||||
can
|
||||
|
||||
<ul>
|
||||
* (a) just generate IL
|
||||
|
||||
* (b) be a CLS "consumer", which means that it can read in
|
||||
meta-data describing component interfaces,
|
||||
and that it provides a way to declare variables of
|
||||
CLS-complaint types and to call CLS-complaint methods.
|
||||
|
||||
* (c) be a CLS "extender", which means that it can in addition
|
||||
derive from CLS-compliant classes
|
||||
and implement CLS-compliant interfaces
|
||||
|
||||
* (d) be able to produce components with *any* CLS-compliant
|
||||
component interface.
|
||||
</ul>
|
||||
|
||||
Supporting some of these may require extending your language. However,
|
||||
you can get quite a lot of interoperability by just putting appropriate
|
||||
functionality in your compiler, without extending your language.
|
||||
|
||||
For some things, e.g. ASP.NET, your language implementation also needs to be
|
||||
able to
|
||||
|
||||
<ul>
|
||||
* (e) consume CodeDom trees. CodeDom trees are an abstract
|
||||
representation of programs in a form similar to a C# parse
|
||||
tree, with embedded code snippets (unparsed strings).
|
||||
Given a CodeDom tree, with the snippets in your language,
|
||||
your language implementation needs to generate a (i) .NET
|
||||
assembly and possibly also (ii) a source file in your language.
|
||||
|
||||
* (f) produce CodeDom trees. For some applications,
|
||||
your language implementation also needs to be able to
|
||||
round-trip from CodeDom -> your language -> CodeDom.
|
||||
</ul>
|
||||
|
||||
and for some things it needs to
|
||||
|
||||
<ul>
|
||||
* (g) generate *verifiable* IL
|
||||
</ul>
|
||||
|
||||
So when you hear all the hype about how language XYZ is a
|
||||
".NET language", make sure you ask which of these different
|
||||
things are supported.
|
||||
|
||||
[For the record, Mercury currently supports (a). We're working on
|
||||
(b) and (g), and on parts of (c) and (e). We're never going to do (f), I very
|
||||
strongly doubt we'll ever do (d), and for (c) we might only ever support
|
||||
implementing interfaces, not deriving from classes.]
|
||||
|
||||
</blockquote></i>
|
||||
|
||||
** PInvoke
|
||||
|
||||
Q: What are the two major initiatives to implement PInvoke?
|
||||
|
||||
A: Fergus Henderson answers:
|
||||
|
||||
<i><blockquote>
|
||||
Many of the .NET APIs will need to be implemented using code that calls C/Unix
|
||||
APIs, such as stat(). The standard way of interfacing with native code from
|
||||
.NET code is to use "PInvoke". However, there is a difficulty: many of
|
||||
these APIs are defined in terms of types such as C's `long' or `size_t'
|
||||
or the Posix `struct stat' whose representation varies depending on the
|
||||
platform (architecture/OS/C compiler). There's no *portable* way of
|
||||
accessing those from .NET managed code.
|
||||
|
||||
So, there are a couple of different approaches.
|
||||
One possibility is to access such routines by writing a wrapper, e.g. in C,
|
||||
that provides the same functionality without using types with a system-dependent
|
||||
representation. The wrapper can then be directly accessed from portable
|
||||
.NET code. The .NET code remains both source- and binary-portable;
|
||||
the wrapper code is source-portable, but needs to be compiled
|
||||
seperately for each target platform. The drawback of this approach is
|
||||
that you have to write a lot of cumbersome wrapper code.
|
||||
|
||||
Another possibility is to extend the .NET VM with support for an
|
||||
additional custom attribute, e.g. "[PosixType]". The VM would then
|
||||
represent types tagged with this attribute in the same way that the
|
||||
underlying system represents those types. With this approach, no
|
||||
wrapper code would be needed. A drawback of this approach is that it
|
||||
pushes quite a bit of complexity into the VM; the VM would have to know
|
||||
the native representation of all types annotated with this attribute.
|
||||
Another drawback is that code using this extension might not work on
|
||||
different VMs.
|
||||
|
||||
There have also been some other suggestions, but those are the two that
|
||||
I think are the best.
|
||||
</blockquote></i>
|
||||
|
||||
Q: What is the problem implementing PInvoke?
|
||||
|
||||
A: Again, from Fergus Henderson:
|
||||
|
||||
<i><blockquote>
|
||||
There's no problem implementing PInvoke as specified in the ECMA
|
||||
specs and/or MS documentation. It's just that PInvoke by itself
|
||||
doesn't solve all of the problems; in particular it doesn't solve
|
||||
the problem of C types whose representation is different on different
|
||||
systems.
|
||||
</blockquote></i>
|
||||
|
||||
** CVS use
|
||||
|
||||
Q: Why do we keep ChangeLogs and make the CVS commit messages be the
|
||||
same? One could be generated from the other
|
||||
|
||||
A: There are a number of reasons for keeping ChangeLog files as well as
|
||||
CVS commit files:
|
||||
|
||||
<ul>
|
||||
* Offline programming: when people are traveling, CVS logs are
|
||||
not available.
|
||||
|
||||
* Slow CVS access: Many people work over modem lines (very
|
||||
typical for contributors in Europe, Asia, Latin America)
|
||||
using CVS is slow and might not be available to you (cvs
|
||||
server down, no anoncvs server available).
|
||||
|
||||
* ChangeLogs travel in a released tarball package, so it is
|
||||
possible to study the rationale of changes even after a
|
||||
project is long "released", or you only have the sources for
|
||||
the code.
|
||||
|
||||
* ChangeLog are not metadata for each file, they are live
|
||||
files that you can browse in the package that is being
|
||||
distributed.
|
||||
</ul>
|
||||
|
||||
Making the CVS commit message be the same as the ChangeLog has other
|
||||
benefits:
|
||||
|
||||
<ul>
|
||||
* You can track down with `cvs log' what things were changed,
|
||||
and match those to meaningful reports on the intentions of
|
||||
the commit.
|
||||
|
||||
* When reading the commits-list, you can get a glimpse of the
|
||||
changes without having to diff out or cvs update your tree.
|
||||
|
||||
* You can read off-line the changes that are being made
|
||||
(asyncrouns operation).
|
||||
</ul>
|
||||
|
||||
This mechanism works very well for GNOME and other projects.
|
||||
|
||||
Q: Should I use any of the special RCS keywords like $Id: devel-faq,v 1.1 2001/07/31 21:13:05 miguel Exp $, $Author: miguel $,
|
||||
$Date: 2001/07/31 21:13:05 $, or $Revision: 1.1 $?
|
||||
|
||||
A: Please avoid using those in the source code in the CVS. They
|
||||
are not really useful, and they cause a lot of conflicts when
|
||||
people have separate CVS trees.
|
||||
|
||||
It was a nightmare with the Linux kernel when two people had their
|
||||
private CVS trees and were submitting patches to the core.
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
* Documentation
|
||||
|
||||
Although most of the concepts from Microsoft.NET can
|
||||
be applied to the completed Mono platform, we do need to
|
||||
have a complete set of free documentation written specifically
|
||||
for Mono.
|
||||
|
||||
The documentation license we have chosen is the GNU Free
|
||||
Documentation License (FDL), the standard for most documents
|
||||
in the free software world.
|
||||
|
||||
We need documentation on a number of topics:
|
||||
|
||||
<ul>
|
||||
|
||||
* The development tools (compilers, assembler tools,
|
||||
language reference, design time features).
|
||||
|
||||
* Frequently Asked Question compilations.
|
||||
|
||||
* HOWTO documents.
|
||||
|
||||
* The Class Libraries
|
||||
|
||||
* Tutorials on Mono and the specifics of running it.
|
||||
|
||||
* A guide to Mono as compared to the Microsoft.NET
|
||||
Framework SDK
|
||||
|
||||
</ul>
|
||||
|
||||
** Class Library documentation
|
||||
|
||||
When contributing to the Class Library effort, please use the
|
||||
inline XML documentation tags to document your classes so we
|
||||
can automatically generate the documentation from the class
|
||||
libraries.
|
||||
|
||||
If you provide examples, please do not embed them into the
|
||||
source code, as that will make the source code harder to read
|
||||
and maintain. Instead, put examples for your code into a
|
||||
subdirectory of the class libraries. Make your sample
|
||||
code a full standalone application that people can compile.
|
||||
Ideally the Mono documentation browser will let you edit, modify
|
||||
and run the sample programs.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,177 @@
|
||||
* Software Availability
|
||||
|
||||
The Virtual Execution System is available in package `mono'.
|
||||
Currently this contains a metadata library and the
|
||||
disassembler. Please reffer to our <a
|
||||
href="runtime.html">Runtime</a> description for more details
|
||||
on this part of the project.
|
||||
|
||||
The code for the C# compiler as well as the language error
|
||||
test suite and the class library are in the `mcs' package, we
|
||||
will move this later into `mono' itself.
|
||||
|
||||
In order to make mcs and the class libraries you will need the
|
||||
GNU make tools. These may be obtained for the Windows
|
||||
environment from <a href="http://www.cygwin.com">cygwin.com</a>.
|
||||
|
||||
You will also need to get GLIB, from: <a
|
||||
href="ftp://ftp.gtk.org/pub/gtk/v1.2/glib-1.2.10.tar.gz">ftp://ftp.gtk.org/pub/gtk/v1.2/glib-1.2.10.tar.gz</a>
|
||||
|
||||
<a name="sources">
|
||||
** Sources
|
||||
|
||||
We provide both <a href="packaged">packaged and tested</a>
|
||||
tarballs (those are known to compile and pass `make
|
||||
distcheck') as well as <a href="snapshots">daily snapshots</a> done
|
||||
at 10pm Boston Time
|
||||
|
||||
<a name="snapshots">
|
||||
*** Snapshots
|
||||
|
||||
The daily snapshots are available <a
|
||||
href="http://www.go-mono.com/snapshots">here</a>. These
|
||||
snapshots are done every day at 10pm EST (Boston Time).
|
||||
|
||||
They are not guaranteed to build, but most of the time they
|
||||
should. They should give you a window to see what we are up to.
|
||||
|
||||
You might also want to track our development using the <a
|
||||
href="http://mail.ximian.com/mailman/listinfo/mono-cvs-list">mono-cvs-list</a>
|
||||
mailing list.
|
||||
|
||||
<a name="packaged">
|
||||
*** Released and tested packages
|
||||
|
||||
<ul>
|
||||
<a name="july-29">
|
||||
<b>July 29, 2001</b>
|
||||
<ul>
|
||||
* <a href="archive/mono-0.5.tar.gz">mono-0.5.tar.gz</a>: Mono Runtime 0.5 release
|
||||
* <a href="archive/mono-0.5">Release Notes</a>
|
||||
</ul>
|
||||
|
||||
<a name="july-22">
|
||||
<b>July 22, 2001</b>
|
||||
<ul>
|
||||
* <a href="archive/mcs-22-Jul-2001.tar.gz">mcs-22-Jul-2001.tar.gz</a>: CVS snapshot.
|
||||
* <a href="archive/mcs-Jul-22-Jul-19-2001.tar.gz">Differences since 19</a>: CVS snapshot.
|
||||
* <a href="archive/mcs-22">Release Notes</a>
|
||||
</ul>
|
||||
|
||||
<a name="july-19">
|
||||
<b>July 19th, 2001</b>
|
||||
<ul>
|
||||
* <a href="archive/mcs-19-Jul-2001.tar.gz">mcs-19-Jul-2001.tar.gz</a>: CVS snapshot.
|
||||
* <a href="archive/mcs-Jul-17-Jul-19-2001.tar.gz">Differences since 17</a>: CVS snapshot.
|
||||
* <a href="archive/mcs-19">Release Notes</a>
|
||||
</ul>
|
||||
|
||||
<a name="july-17">
|
||||
<b>July 17th, 2001</b>
|
||||
<ul>
|
||||
* <a href="archive/mcs-17-Jul-2001.tar.gz">mcs-17-Jul-2001.tar.gz</a>: CVS snapshot.
|
||||
* <a href="archive/mcs-Jul-15-Jul-17-2001.tar.gz">Differences since 15</a>: CVS snapshot.
|
||||
* <a href="archive/mcs-17">Release Notes</a>
|
||||
</ul>
|
||||
|
||||
<a name="july-15">
|
||||
<b>July 15th, 2001</b>
|
||||
<ul>
|
||||
* <a href="archive/mcs-15-Jul-2001.tar.gz">mcs-15-Jul-2001.tar.gz</a>: CVS snapshot.
|
||||
* <a href="archive/mono-0.4.tar.gz">mono-0.4.tar.gz</a>: Packaged Source Code.
|
||||
* <a href="archive/mono-0.4">Release Notes</a>
|
||||
</ul>
|
||||
|
||||
<a name="july-14">
|
||||
<b>July 14th, 2001</b>
|
||||
<ul>
|
||||
* <a href="archive/mcs-12-Jul-2001.tar.gz">mcs-12-Jul-2001.tar.gz</a>: CVS snapshot.
|
||||
* <a href="archive/mono-0.3.tar.gz">mono-0.3.tar.gz</a>: Packaged Source Code.
|
||||
</ul>
|
||||
|
||||
<a name="july-8">
|
||||
<b>July 8th, 2001</b>
|
||||
|
||||
<ul>
|
||||
* <a href="archive/mcs-08-Jul-2001.tar.gz">mcs-08-Jul-2001.tar.gz</a>: CVS Snapshot
|
||||
* <a href="archive/mono-08-Jul-2001.tar.gz">mono-08-Jul-2001.tar.gz</a>: CVS Snapshot
|
||||
</ul>
|
||||
</ul>
|
||||
|
||||
<a name="install">
|
||||
** Installing the software
|
||||
|
||||
To install and work on the compiler and the class libraries,
|
||||
follow these instructions:
|
||||
|
||||
<ul>
|
||||
* Install <a href="http://www.cygwin.com">CygWin</a> first.
|
||||
|
||||
* Untar the MCS distribution (see below for information).
|
||||
|
||||
* Go into the MCS directory and type `make windows'
|
||||
</ul>
|
||||
|
||||
To compile the mono runtime on windows:
|
||||
|
||||
<ul>
|
||||
* Install <a href="http://www.cygwin.com">CygWin</a> first.
|
||||
|
||||
* Once installed, in a terminal window or a cygwin
|
||||
window (a shortcut should be on your desktop), untar the glib
|
||||
distribution:
|
||||
|
||||
<pre>
|
||||
tar xzvf glib-1.2.10.tar.gz
|
||||
</pre>
|
||||
|
||||
* Configure, compile and install glib, like this:
|
||||
|
||||
<pre>
|
||||
./configure --prefix=/usr
|
||||
make
|
||||
make install
|
||||
</pre>
|
||||
|
||||
* Unpack the mono distribution:
|
||||
|
||||
<pre>
|
||||
tar xzvf mono-XXX.tar.gz
|
||||
</pre>
|
||||
|
||||
* Configure, compile and install:
|
||||
|
||||
<pre>
|
||||
./configure --prefix=//c/mono
|
||||
make
|
||||
make install
|
||||
</pre>
|
||||
</ul>
|
||||
|
||||
To compile the mono runtime on Unix:
|
||||
|
||||
<ul>
|
||||
|
||||
* Download the mono distribution
|
||||
|
||||
* Unpack the mono distribution:
|
||||
|
||||
<pre>
|
||||
tar xzvf mono-XXX.tar.gz
|
||||
</pre>
|
||||
|
||||
* Configure, compile and install:
|
||||
<pre>
|
||||
./configure
|
||||
make
|
||||
make install
|
||||
</pre>
|
||||
</ul>
|
||||
|
||||
** CVS
|
||||
|
||||
We are trying to figure out where to put our CVS repository.
|
||||
We are debating between the GNOME CVS or SourceForge. Watch
|
||||
this spot.
|
||||
|
||||
|
||||
@@ -0,0 +1,722 @@
|
||||
** Basics
|
||||
|
||||
Q: Is Mono the same as Microsoft's .NET initiative?
|
||||
|
||||
A: It is not.
|
||||
|
||||
.NET is a company-wide initiative at Microsoft that
|
||||
encompasses many different areas. The .NET development framework,
|
||||
Passport, Biztalk, new server products, and anything that is
|
||||
remotely connected to .NET gets the ".NET-stamping" treatment.
|
||||
Some components of Microsoft's .NET initiative have been announced
|
||||
and some others are in the works.
|
||||
|
||||
Mono is a project to implement several technologies developed by
|
||||
Microsoft that have now been submitted to the ECMA Standards Body.
|
||||
|
||||
Q: What technologies are included in Mono?
|
||||
|
||||
A: Mono contains a number of components useful for building new
|
||||
software:
|
||||
|
||||
<ul>
|
||||
* A Common Language Infrastructure (CLI) virtual
|
||||
machine that contains a class loader, Just-in-time
|
||||
compiler, and a garbage collecting runtime.
|
||||
|
||||
* A class library that can work with any language
|
||||
which works on the CLR.
|
||||
|
||||
* A compiler for the C# language. In the future we
|
||||
might work on other compilers that target the Common
|
||||
Language Runtime.
|
||||
|
||||
Windows has compilers that target the
|
||||
virtual machine from
|
||||
<a href="http://msdn.microsoft.com/net/thirdparty/default.asp#lang">a
|
||||
number of languages:</a> Managed C++, Java Script,
|
||||
Eiffel, Component Pascal, APL, Cobol, Oberon, Perl,
|
||||
Python, Scheme, Smalltalk, Standard ML, Haskell,
|
||||
Mercury and Oberon.
|
||||
</ul>
|
||||
|
||||
The CLR and the Common Type System (CTS) enables applications and
|
||||
libraries to be written in a number of languages. Classes and
|
||||
methods created in one language can be used from a different
|
||||
language.
|
||||
|
||||
This means for example that if you define a class to do algebraic
|
||||
manipulation in C#, that class can be reused from any other
|
||||
language that supports the CLI. You could create a class in C#,
|
||||
subclass it in C++ and instantiate it in an Eiffel program.
|
||||
|
||||
A single object system, threading system, class libraries, and
|
||||
garbage collection system can be shared across all these languages.
|
||||
|
||||
Q: Where can I find the specification for these technologies?
|
||||
|
||||
A: You can find the work-in-progress documentation from the T3G ECMA
|
||||
group here:
|
||||
|
||||
<a href="http://www.dotnetexperts.com">http://www.dotnetexperts.com</a>
|
||||
|
||||
Q: Will you implement the .NET Framework SDK class libraries?
|
||||
|
||||
A: Yes, we will be implementing the APIs of the .NET Framework SDK
|
||||
class libraries.
|
||||
|
||||
Q: What does Mono stand for?
|
||||
|
||||
A: Mono is the word for `Monkey' in Spanish. We like monkeys.
|
||||
|
||||
It only means a number of other things: monochromatic (hence the
|
||||
gray theme used in the Web site).
|
||||
|
||||
Q: When will you ship it?
|
||||
|
||||
A: We do not know when the code will be shipped. The more
|
||||
contributions we get to the project, the sooner it will ship.
|
||||
|
||||
A rough estimate is that we might be able to run our C# compiler on
|
||||
Linux by the end of the year. That means running the Windows
|
||||
Executable generated by a Microsoft .NET compiler on the Linux
|
||||
platform.
|
||||
|
||||
We expect that doing GUI applications will require more work on the
|
||||
class libraries. That could take another six months.
|
||||
|
||||
Q: How can I contribute?
|
||||
|
||||
A: Check the <a href="contributing.html">contributing</a> section.
|
||||
|
||||
Q: You guys should innovate instead of copying.
|
||||
|
||||
A: In this particular case, we see a clear advantage in the platform
|
||||
and we are interested in using the features of the CLI on open source systems.
|
||||
|
||||
We have decided that we should spend our limited resources towards
|
||||
implementing an existing specification instead of designing and
|
||||
implementing our own.
|
||||
|
||||
Designing and implementing our own would be possible, but it doesn't make
|
||||
sense to do that just because the specification comes from a
|
||||
proprietary vendor.
|
||||
|
||||
** Ximian
|
||||
|
||||
Q: Why is Ximian working on .NET?
|
||||
|
||||
A: We are interested in providing the best tools for programmers to
|
||||
develop applications for Free Operating Systems.
|
||||
|
||||
For more information, read the project <a
|
||||
href="rationale.html">rationale</a> page.
|
||||
|
||||
Q: Will Ximian be able to take on a project of this size?
|
||||
|
||||
A: Ximian will not be able to taken on the whole project on its own.
|
||||
Mono will be a free software/open source community project, that is
|
||||
the only way we can hope to implement something of this size. You
|
||||
can <a href="contributing.html">contribute</a> to this effort.
|
||||
|
||||
Q: What pieces will Ximian be working on?
|
||||
|
||||
A: We will focus on building a development and execution
|
||||
environment.
|
||||
|
||||
The idea is to get Mono to a state of that would allow
|
||||
third parties to actually be able to use it real-world development.
|
||||
|
||||
Q: Why does Ximian even care?
|
||||
|
||||
A: We like the features that the CLI and its related technologies
|
||||
bring to the table. An exciting addition to the developer toolkit.
|
||||
The goal of Mono is to bring this technology to non-Windows
|
||||
platforms (although we hope Mono will also run on Windows, for
|
||||
debugging and comparative purposes).
|
||||
|
||||
|
||||
** Licensing
|
||||
|
||||
Q: Will I be able to write proprietary applications that run with
|
||||
Mono?
|
||||
|
||||
A: Yes. The licensing scheme is planned to allow proprietary
|
||||
developers to write applications with Mono.
|
||||
|
||||
Q: What license is Mono on?
|
||||
|
||||
A: The C# Compiler is released under the terms of the GPL. The class
|
||||
libraries will be under the LGPL or the GPL with a special
|
||||
exception. The runtime libraries are under the LGPL.
|
||||
|
||||
Since the LGPL is not suitable for embedded systems development, we
|
||||
are also licensing the libraries under the GPL with the following exception:
|
||||
|
||||
If you link this library against your own program, then you do not
|
||||
need to release the source code for that program. However, any
|
||||
changes that you make to the library itself, or to any native
|
||||
methods upon which the library relies, must be re-distributed in
|
||||
accordance with the terms of the GPL.
|
||||
|
||||
This is similar in spirit to <a
|
||||
href="http://www.gnu.org/software/classpath/classpath.html">GNU
|
||||
Classpath.</a>
|
||||
|
||||
Q: But in Object Oriented Programming I need to subclass your library
|
||||
functions, does that mean that I am making modifications to your
|
||||
library and hence I would have to distribute my sources under the
|
||||
LGPL?
|
||||
|
||||
A: No. Object Oriented Programming in the class library is a well
|
||||
understood interface barrier, so you can actually develop
|
||||
proprietary applications with the Mono libraries.
|
||||
|
||||
Q: Will you accept code under the XXX License?
|
||||
|
||||
A: If the XXX License is compatible with the license we use in that
|
||||
specific piece of code, then yes. If you want to use the BSD license, make
|
||||
sure you use the BSD license without the advertisement clause (The
|
||||
`Ousterhout License').
|
||||
|
||||
** Mono and .NET
|
||||
|
||||
Q: If applications use Mono, does that mean that I have to pay a service fee?
|
||||
|
||||
A: No. Mono is not related to Microsoft's initiative of
|
||||
software-as-a-service.
|
||||
|
||||
Q: If you implement .NET, will I depend on Microsoft Passport to run my software?
|
||||
|
||||
A: No. The .NET Framework is a runtime infrastructure and collection
|
||||
of class libraries. Passport may be required to access certain web
|
||||
services written for that framework, but only if the programmer
|
||||
chooses Passport as the authentication mechanism.
|
||||
|
||||
Q: Is .NET just a bunch of marketing slogans?
|
||||
|
||||
A: Although the `.NET initiative' is still quite nebulous, The .NET Framework
|
||||
has been available for some time. Mono is not an implementation of the .NET
|
||||
initiative, just the development framework.
|
||||
|
||||
Q: What is a 100% .NET application?
|
||||
|
||||
A: A `100% .NET application' is one that only uses the APIs defined
|
||||
under the System namespace and does not use PInvoke. These
|
||||
applications would in theory run unmodified on Windows, Linux,
|
||||
HP-UX, Solaris, MacOS X and others.
|
||||
|
||||
Q: But Microsoft will release a port of the real thing under the
|
||||
`Shared Source' license, why bother with anything else?
|
||||
|
||||
A: The Shared Source implementation will not be usable for commercial
|
||||
purposes. We are working towards an implementation that will grant
|
||||
a number of rights to recipients: use for any purpose,
|
||||
redistribution, modification, and redistribution of modifications.
|
||||
|
||||
This is what we call <a
|
||||
href="http://www.gnu.org/philosophy/free-sw.html">Free Software</a>
|
||||
|
||||
** Passport
|
||||
|
||||
Q: Is this a free implementation of Passport?
|
||||
|
||||
A: No. Passport is part of Microsoft's Hailstorm initiative. Mono
|
||||
is just a runtime, a compiler and a set of class libraries.
|
||||
|
||||
Q: Will the System.Web.Security.PassportIdentity class, mean
|
||||
that my software will depend on Passport?
|
||||
|
||||
A: No. That just means that applications might use that API to
|
||||
contact a Passport site.
|
||||
|
||||
As long as your application does not use Passport, you will not
|
||||
need Passport.
|
||||
|
||||
It might even be possible to implement that class with
|
||||
a set of dummy functions, or use an alternate Passport implementation.
|
||||
|
||||
We do not know at this time whether the Passport protocol is
|
||||
documented and whether we will be able to talk to
|
||||
passport.com
|
||||
|
||||
Q: But that must mean that you are tied to Passport!
|
||||
|
||||
A: All the contrary. The implementation could keep the interface (for
|
||||
the sake of simplicity, lets say it implements the method `Login'
|
||||
and `GetUserName').
|
||||
|
||||
We could implement `Login' and `GetUserName' by talking to XNS or
|
||||
any other decentralized systems. Or any other system that the
|
||||
industry standarizes on.
|
||||
|
||||
Q: What is your opinion?
|
||||
|
||||
A: You can read my personal <a href="passport.html">opinion on
|
||||
passport</a>.
|
||||
|
||||
Q: Will Mono running on Linux make Passport available for Linux?
|
||||
|
||||
A: The Passport toolkit for Linux-based web servers is available from
|
||||
Microsoft.
|
||||
|
||||
Again, Mono has nothing to do with Passport.
|
||||
|
||||
** Mono and Windows
|
||||
|
||||
Q: Will Mono allow me to run Microsoft Office on Linux?
|
||||
|
||||
A: No, it will not. Microsoft Office is a Windows application. To
|
||||
run Windows applications on Intel Unix systems refer to <a
|
||||
href="http://www.winehq.com">the Wine Project</a>
|
||||
|
||||
** GNOME
|
||||
|
||||
Q: How is this related to GNOME?
|
||||
|
||||
A: In a number of ways:
|
||||
|
||||
* Mono will use existing
|
||||
components that have been developed for GNOME when it makes
|
||||
sense. For example on X systems, we will use Gtk+ and
|
||||
Libart to implement Winforms and the Drawing2D API.
|
||||
|
||||
For database access, we will use LibGDA (not really
|
||||
depending on GNOME, but related to).
|
||||
|
||||
* This project was born out of the need of providing improved
|
||||
tools for the GNOME community.
|
||||
|
||||
* We would like to add support to our CLR implementation to
|
||||
deal with GObjects (in GNOME 1.x, they are called
|
||||
GtkObjects), and allow Mono developers to provide GObjects
|
||||
or use and extend existing GObjects.
|
||||
|
||||
Q: Has the GNOME Foundation or the GNOME team adopted Mono?
|
||||
|
||||
A: Mono is too new to be adopted by those groups. We hope that the
|
||||
tools that we will provide will be adopted by free software
|
||||
programmers including the GNOME Foundation members and the GNOME
|
||||
project generally.
|
||||
|
||||
Q: Should GNOME programmers switch over to Mono?
|
||||
|
||||
A: Mono will not be ready even within the next six months, and a
|
||||
complete implementation is probably one year away.
|
||||
|
||||
We encourage GNOME developers to continue using the existing tools,
|
||||
libraries and components. Improvements made to GNOME will have an
|
||||
impact on Mono, as they will provide the "backend" for various
|
||||
classes.
|
||||
|
||||
Q: Will Mono include compatibility with Bonobo components?
|
||||
|
||||
A: Yes, we will provide a set of classes for implementing and using
|
||||
Bonobo components from within Mono.
|
||||
|
||||
Q: Does Mono replace Bonobo?
|
||||
|
||||
A: Bonobo is very focused on cross-application component reuse. Mono
|
||||
will provide a Bonobo framework to allow you to develop Bonobo
|
||||
components and use Bonobo components on Unix.
|
||||
|
||||
Mono should allow you to write Bonobo components more easily, just
|
||||
like .NET on Windows allows you to export .NET components to COM.
|
||||
|
||||
** Mono and the Web
|
||||
|
||||
Q: Is Mono a way of running Java applets?
|
||||
|
||||
A: No.
|
||||
|
||||
** Web Services
|
||||
|
||||
Q: Is Mono just a new way of writing Web Services?
|
||||
|
||||
A: No.
|
||||
|
||||
Q: If this implements the SDK classes, will I be able to write and
|
||||
execute .NET Web Services with this?
|
||||
|
||||
A: Yes, you will.
|
||||
|
||||
When the project is finished, you will be able to use the same
|
||||
technologies that are available through the .NET Framework SDK on
|
||||
Windows to write Web Services.
|
||||
|
||||
Q: What about Soup?
|
||||
|
||||
A: Soup is a library for GNOME applications to create SOAP server and
|
||||
SOAP clients. You can browse the source code for soup using <a
|
||||
href="http://cvs.gnome.org/bonsai">GNOME's Bonsai</a>
|
||||
|
||||
Q: Can I use CORBA?
|
||||
|
||||
A: Yes. The CLI contains enough information about a class that
|
||||
exposing it to other RPC systems (like CORBA) is really simple, and
|
||||
does not even require support from an object.
|
||||
|
||||
We will be implementing CORBA interoperation as an extension to the
|
||||
Mono classes so that we can integrate with Bonobo, just like
|
||||
Microsoft provides COM interoperation classes and support
|
||||
mechanisms.
|
||||
|
||||
Q: Can I serialize my objects to other things other than XML?
|
||||
|
||||
A: Yes, although the serializing tools have not yet been planned, and
|
||||
you would probably have to implement them yourself.
|
||||
|
||||
** Development Tools
|
||||
|
||||
Q: Will it be possible to use the CLI features without using bytecodes
|
||||
or the JIT?
|
||||
|
||||
A: Yes. The CLI engine will be made available as a shared library.
|
||||
The garbage collection engine, the threading abstraction, the
|
||||
object system, the dynamic type code system and the JIT will be
|
||||
available for C developers to integreate with their applications if
|
||||
they wish to do so.
|
||||
|
||||
Q: Will you have new development tools?
|
||||
|
||||
A: Hopefully Free Software enthusiasts will contribute tools to
|
||||
improve the developer environment. These tools could be developed
|
||||
initially using Microsoft implementation of the CLI and then
|
||||
executed later with Mono.
|
||||
|
||||
** Mono and Java
|
||||
|
||||
Q: What about using Java? After all there are many languages that
|
||||
target the Java VM.
|
||||
|
||||
A: You can get very good tools for doing Java development on free
|
||||
systems right now. <a href="http://www.redhat.com">Red Hat</a> has
|
||||
contributed a <a href="http://gcc.gnu.org">GCC</a> <a
|
||||
href="http://gcc.gnu.org/java">frontend for Java</a> that can take
|
||||
Java sources or Java byte codes and generate native executables; <a
|
||||
href="http://www.transvirtual.com">Transvirtual</a> has implemented
|
||||
<a href="http://www.kaffe.org">Kaffe</a> a JIT engine for Java;
|
||||
Intel also has a Java VM called <a
|
||||
href="http://www.intel.com/research/mrl/orp">ORP</a>.
|
||||
|
||||
The JVM is not designed to be a general purpose virtual machine.
|
||||
The Common Intermediate Language (CIL), on the other hand, is
|
||||
designed to be a target for a
|
||||
wide variety of programming languages, and has a set of rules
|
||||
designed to be optimal for JITers.
|
||||
|
||||
|
||||
Q: What kind of rules make the Common Intermediate Language useful for
|
||||
JITers?
|
||||
|
||||
A: The main rule is that the stack in the CLI is not a general purpose
|
||||
stack. You are not allowed to use it for other purposes than
|
||||
computing values and passing arguments to functions or return
|
||||
values.
|
||||
|
||||
At any given call or return instruction, the types on the stack
|
||||
have to be the same independently of the flow of execution of your
|
||||
code.
|
||||
|
||||
Q: I heard that the CIL is ideal for JITing and not efficient for
|
||||
interpreters, is this the case?
|
||||
|
||||
A: The CIL is better suited to be JITed than JVM byte codes, but you
|
||||
can interpret them as trivially as you can interpret JVM byte
|
||||
codes.
|
||||
|
||||
Q: Could Java target the CLI?
|
||||
|
||||
A: Yes, Java could target the CLI. We have details on a <a
|
||||
href="ideas.html#guavac">project</a> that someone could take on to
|
||||
make this happen.
|
||||
|
||||
** Extending Mono
|
||||
|
||||
Q: Would you allow other classes other than those in the
|
||||
specification?
|
||||
|
||||
A: Yes. The Microsoft class collection is very big, but it is by no
|
||||
means complete. It would be nice to have a port of `Camel' (the
|
||||
Mail API used by Evolution inspired by Java Mail) for Mono
|
||||
applications.
|
||||
|
||||
You might also want to look into implementing CORBA for Mono. Not
|
||||
only because it would be useful, but because it sounds like a fun
|
||||
thing to do, given the fact that the CLI is such a type rich
|
||||
system.
|
||||
|
||||
For more information on extending Mono, see our <a
|
||||
href="ideas.html">ideas</a> page.
|
||||
|
||||
** Mono and portability
|
||||
|
||||
Q: Will Mono only work on Linux?
|
||||
|
||||
A: Currently, we are doing our work on Linux-based systems and
|
||||
Windows. We do not expect many Linux-isms in the code, so it
|
||||
should be easy to port Mono to other UNIX variants.
|
||||
|
||||
Q: What about Mono on non X-based systems?
|
||||
|
||||
A: Our main intention at Ximian is to be able to develop GNOME
|
||||
applications with Mono, but if you are interested in providing a
|
||||
port of the Winform classes to other platforms (frame buffer or
|
||||
MacOS X for example), we would gladly integrate them, as long
|
||||
they are under a Free Software License.
|
||||
|
||||
** Reusing existing Code
|
||||
|
||||
Q: What projects will you reuse or build upon?
|
||||
|
||||
A: We want to get Mono in the hands of programmers soon. We are
|
||||
interested in reusing existing open source software.
|
||||
|
||||
Q: What about Intel's research JIT framework, ORP?
|
||||
|
||||
A: At this time, we are investigating whether we can use elements of
|
||||
ORP for Mono. ORP is a research JIT engine that has a clear
|
||||
defined API that splits the JIT from the GC system and the actual
|
||||
byte code implementation. It is a research product.
|
||||
|
||||
Q: What about using GNU Lightning?
|
||||
|
||||
A: We are also researching <a
|
||||
href="http://www.gnu.org/software/lightning/lightning.html">GNU
|
||||
Lightning</a>.
|
||||
|
||||
<a name="ximian-and-microsoft">
|
||||
** Ximian and Microsoft
|
||||
|
||||
Q: I read that Microsoft is helping out Ximian, is this true?
|
||||
|
||||
A: Initial contact between David Stutz and Miguel de Icaza happened.
|
||||
It was a friendly conversation. Microsoft is interested in other
|
||||
implementing .NET and are willing to help make the ECMA spec more
|
||||
accurate for this purpose.
|
||||
|
||||
We were initially contacted by Sam Ruby at the ECMA TG3 committee
|
||||
to discuss the same issue. And we are glad to have good contacts
|
||||
to ask questions about the specs.
|
||||
|
||||
Q: Is Microsoft paying Ximian to do this?
|
||||
|
||||
A: No, we are doing this for purely selfish reasons. We are upgrading
|
||||
our development platform to build better applications on Unix and other
|
||||
systems.
|
||||
|
||||
Q: Do you fear that Microsoft will change the spec and render Mono useless?
|
||||
|
||||
A: No. Microsoft proved with the CLI and the C# language that it was
|
||||
possible to create a powerful foundation for many languages to
|
||||
interoperate. We will always have that.
|
||||
|
||||
Even if changes happened in the platform which were undocumented
|
||||
(which is very unlikely), the existing platform has a value on its
|
||||
own.
|
||||
|
||||
Miguel once explained its motivation for working on Mono to Dave
|
||||
Winer, and his mail got posted <a
|
||||
href="http://scriptingnews.userland.com/stories/storyReader$1275">here</a>
|
||||
|
||||
Q: Didn't Miguel de Icaza say that `Unix Sucks'?
|
||||
|
||||
A: Yes, he did, as a catch phrase in his opening remark on the Ottawa
|
||||
Linux Symposium. His talk focused on various ways to improve Unix.
|
||||
|
||||
There is a paper describing some ways to improve Unix at:
|
||||
|
||||
<a href="http://primates.ximian.com/~miguel/bongo-bong.html">
|
||||
http://primates.ximian.com/~miguel/bongo-bong.html</a>
|
||||
|
||||
Q: Didn't Ximian's Miguel work for Microsoft?
|
||||
|
||||
A: Actually, Nat Friedman (Ximian's co-founder) did work as an
|
||||
intern for Microsoft for one summer but Miguel did not.
|
||||
|
||||
Q: Did Nat and Miguel meet at Microsoft?
|
||||
|
||||
A: They met online on the Linux IRC network; They met in person for
|
||||
the first time in 1997.
|
||||
|
||||
** Mono and Microsoft
|
||||
|
||||
Q: How can you expect Mono to compete with Microsoft, wont this
|
||||
require an effort too large?
|
||||
|
||||
A: You are right. Mono will never become a reality without the help
|
||||
of other contributors. Ximian is a small company that can not
|
||||
finish Mono alone. We will be working with members of the
|
||||
community to deliver the product.
|
||||
|
||||
Q: Is Microsoft and Corel involved in the Mono implementation?
|
||||
|
||||
A: No, they are not.
|
||||
|
||||
Q: Are you writing Mono from the ECMA specs?
|
||||
|
||||
A: yes, we are writing them from the ECMA specs and the published
|
||||
materials in print about .NET
|
||||
|
||||
Q: What happens if Microsoft `Embraces and Extends' the CLI standard
|
||||
and keeps Mono out of the play?
|
||||
|
||||
A: There are various explanations to this question. The first one is
|
||||
that the benefits that you can get from the CLI are going to be
|
||||
there with or without `embracing and extending'. We might not be
|
||||
able to run every .NET Windows application on Mono. But remember:
|
||||
it was already easy for someone to just use PInvoke to tie their
|
||||
application to Windows.
|
||||
|
||||
The bottom line is that the advantages of having a CLI runtime will
|
||||
be with us, no matter if Microsoft forks their version to be
|
||||
incompatible.
|
||||
|
||||
Q: What if Microsoft changes the interface, and all of a sudden
|
||||
applications break?
|
||||
|
||||
A: If they change their released API, every application that was
|
||||
developed against it will break.
|
||||
|
||||
That being said, Microsoft have a pretty good record of keeping
|
||||
backwards binary compatibility.
|
||||
|
||||
** Acronyms
|
||||
|
||||
Q: What is the difference between CLR (Common Language Runtime) and
|
||||
CLI (Common Language Infrastructure)?
|
||||
|
||||
A: CLI is the specification of an execution system. The Microsoft
|
||||
implementation of this specification is named CLR.
|
||||
|
||||
Unless we come up with our own acronym, we could just call ours
|
||||
also CLR, just because it would do exactly the same thing the
|
||||
Microsoft implementation does.
|
||||
|
||||
<a name="gcc">
|
||||
** Mono and GCC
|
||||
|
||||
Q: Should someone work on a GCC front-end to C#?
|
||||
|
||||
A: I would love if someone does, and we would love to help anyone that
|
||||
takes on that task, but we do not have the time or expertise to
|
||||
build a C# compiler with the GCC engine. I find it a lot more fun
|
||||
personally to work on C# on a C# compiler, which has an intrinsic
|
||||
beauty.
|
||||
|
||||
We can provide help and assistance to anyone who would like to work
|
||||
on this task.
|
||||
|
||||
Q: Should someone make a GCC backend that will generate CIL images?
|
||||
|
||||
A: I would love to see a backend to GCC that generates CIL images. It
|
||||
would provide a ton of free compilers that would generate CIL
|
||||
code. This is something that people would want to look into
|
||||
anyways for Windows interoperation in the future.
|
||||
|
||||
Again, we would love to provide help and assistance to anyone
|
||||
interested in working in such a project.
|
||||
|
||||
Q: What about making a front-end to GCC that takes CIL images and
|
||||
generates native code?
|
||||
|
||||
A: I would love to see this, specially since GCC supports this same
|
||||
feature for Java Byte Codes. You could use the metadata library
|
||||
from Mono to read the byte codes (ie, this would be your
|
||||
"front-end") and generate the trees that get passed to the
|
||||
optimizer.
|
||||
|
||||
Ideally our implementation of the CLI will be available as a shared
|
||||
library that could be linked with your application as its runtime
|
||||
support.
|
||||
|
||||
Again, we would love to provide help and assistance to anyone
|
||||
interested in working in such a project.
|
||||
|
||||
Q: But would this work around the GPL in the GCC compiler and allow
|
||||
people to work on non-free front-ends?
|
||||
|
||||
A: People can already do this by targeting the JVM byte codes (there
|
||||
are about 130 compilers for various languages that target the JVM).
|
||||
|
||||
Q: Why are you writing a JIT engine instead of a front-end to GCC?
|
||||
|
||||
A: The JIT engine and runtime engine will be able to execute CIL
|
||||
executables generated on Windows.
|
||||
|
||||
** Mono and Portability
|
||||
|
||||
Q: Will Mono work on other variants of Unix?
|
||||
|
||||
A: Yes. We do not expect to add any gratuitous incompatibilities.
|
||||
|
||||
Q: Will Mono run on Windows?
|
||||
|
||||
A: Hopefully yes. Currently some parts of Mono only run on Windows
|
||||
(the C# compiler is a .NET executable) and other parts have only
|
||||
been compiled on Linux, but work on Windows with Cygwin.
|
||||
|
||||
Q: Will Mono depend on GNOME?
|
||||
|
||||
A: It will depend only if you are using a particular assembly (for
|
||||
example, for doing GUI applications). If you are just interested
|
||||
in Mono for implementing a `Hello World Enterprise P2P Web
|
||||
Service', you will not need any GNOME component.
|
||||
|
||||
** Performance
|
||||
|
||||
Q: How fast will be Mono?
|
||||
|
||||
A: We can not predict the future, but a conservative estimate is that
|
||||
it would be at least `as fast as other JIT engines'.
|
||||
|
||||
Now, wishfully thinking I hope that we will ship various JITs with
|
||||
Mono just like Microsoft has done. A fast JITer when maximum
|
||||
performance is not needed, but fast load times are important; And
|
||||
an optimizing JITer that would be slower at generating code but
|
||||
produce more optimal output.
|
||||
|
||||
The CIL has some advantages over the Java byte code: it is really
|
||||
an intermediate representation and there are a number of
|
||||
restrictions on how you can emit CIL code that simplify creating
|
||||
better JIT engines.
|
||||
|
||||
For example, on the CIL the stack is not really an abstraction
|
||||
available for the code generator to use at will: it is just a way
|
||||
of creating a postfix representation of the parsed tree. At any
|
||||
given call point or return point, the contents of the stack are
|
||||
expected to contain the same object types independently of how the
|
||||
instructions was reached.
|
||||
|
||||
|
||||
** Mono and Portable.NET
|
||||
|
||||
Q: What are the differences between Mono and Portable.NET?
|
||||
|
||||
A: Most of Mono is being written using C#, the only pieces written in
|
||||
C are those who have to absolutely be built using C (The JIT
|
||||
engine, the runtime, the interfaces to the garbage collection
|
||||
system).
|
||||
|
||||
The C# compiler and the tools will become reusable C# components.
|
||||
|
||||
Portable.NET is building its components out of C pieces.
|
||||
|
||||
** Assorted questions
|
||||
|
||||
Q: You say that the CLI allows multiple languages to execute on the
|
||||
same environment. Isn't this the purpose of CORBA?
|
||||
|
||||
A: The key difference between CORBA (and COM) and the CLI is that the
|
||||
CLI allows "data-level interoperability" because every
|
||||
language/component uses the same data layout and memory management.
|
||||
|
||||
This means you can operate directly upon the datatypes that someone
|
||||
else provides, without having to go via their interfaces. It also
|
||||
means you don't have to "marshall" (convert) parameters (data
|
||||
layouts are the same, so you can just pass components directly) and
|
||||
you don't have to worry about memory managment, because all
|
||||
languages/components share the same garbage collector and address
|
||||
space. This means much less copying and no need for reference
|
||||
counting.
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
* The GCC front-end
|
||||
|
||||
The GCC front-end will accept input in a binary file with
|
||||
codes in the Common Intermediate Language (CIL), and generate
|
||||
native code.
|
||||
|
||||
This will allow pre-compilation and full optimization to take
|
||||
place before a program is executed.
|
||||
|
||||
@@ -0,0 +1,119 @@
|
||||
* Ideas
|
||||
|
||||
Here are a few ideas of tools, classes and projects that you
|
||||
could start. More are forthcoming.
|
||||
|
||||
<a name="runtime">
|
||||
** Runtime
|
||||
|
||||
We need a verifier that can be run on an executable (assembly)
|
||||
and tells whether the metadata for the executable is correct
|
||||
or not. It should report any anomalies.
|
||||
|
||||
For a list of anomalies in assemblies, check the various assertions
|
||||
that are described on the ECMA documentation.
|
||||
|
||||
This will help test our generated executables and can be also
|
||||
used as an external verifier.
|
||||
|
||||
<a name="classes">
|
||||
** Classes
|
||||
|
||||
<ul>
|
||||
TODO=jxta,The JXTA Peer to Peer foundation
|
||||
* Implement a JXTA protocol implementation:
|
||||
<a href="http://www.jxta.org">http://www.jxta.org</a>
|
||||
|
||||
TODO=camel,Mail API
|
||||
* Implement a Mail API, similar to Camel or JavaMail (Camel has
|
||||
significant architecture features that are required on a real
|
||||
mailer).
|
||||
|
||||
You can check the current C
|
||||
<a href="http://cvs.gnome.org/bonsai/rview.cgi?dir=evolution%2Fcamel">
|
||||
Camel implementation</a>.
|
||||
|
||||
Such an implementation could be used both with
|
||||
Microsoft .NET and Mono.
|
||||
|
||||
TODO=multimedia
|
||||
* Interfacing to Multimedia systems. You might want
|
||||
to look into the Quicktime API. I know <a
|
||||
href="mailto:[email protected]">Vladimir</a> has
|
||||
researched the problem before
|
||||
|
||||
TODO=gtk,Gtk+ wrappers for Mono and .NET
|
||||
* Wrap the Gtk+ API. This is simple and can be done
|
||||
on Windows as Gtk+ 2.0 works on Windows.
|
||||
|
||||
This work can also be used on Windows and will
|
||||
enable developers on Windows to use some of Gtk+'s
|
||||
advanced features.
|
||||
|
||||
The idea is to wrap the Gtk+ API and allow us to
|
||||
build GUI applications using Gtk+ and in the future
|
||||
other Gtk+-based libraries from Mono (Gal, GtkHTML).
|
||||
|
||||
There is extensive knowledge on wrapping Gtk+ in
|
||||
other languages (this has been done this for Perl,
|
||||
Python, Java, Scheme, Haskel and other languages in
|
||||
the past).
|
||||
</ul>
|
||||
|
||||
<a name="projects">
|
||||
** Projects
|
||||
|
||||
<ul>
|
||||
TODO=xmlStorage,
|
||||
* Implement an xmlStorageSystem for the CLI:
|
||||
<a href="http://www.soapware.org/xmlStorageSystem">
|
||||
http://www.soapware.org/xmlStorageSystem</a>
|
||||
|
||||
TODO=guavac,Java compiler for .NET
|
||||
* You could take one of the existing Java compilers
|
||||
(Guavac comes to mind as it is so nice) and modify
|
||||
it to generate .NET code rather than JVM byte
|
||||
codes.
|
||||
|
||||
This should be a pretty straightforward task.
|
||||
Guavac has the advantage of being written in C++ and
|
||||
it could be compiled with the Microsoft Managed C++
|
||||
compiler and produce a .NET executable with it.
|
||||
|
||||
TODO=CORBA,CORBA implementation
|
||||
* Build a CORBA interoperability engine for the CLR.
|
||||
You do not need to do all of the work, just talking
|
||||
the protocol will get us a long way (<a
|
||||
href="http://www.omg.org">The OMG site</a> has the
|
||||
CORBA specs).
|
||||
|
||||
Get in touch with David Taylor (dtaylo11 at bigpond
|
||||
dot net dot au) as he has been working on this
|
||||
project.
|
||||
|
||||
TODO=Bonobo,Bonobo for Mono
|
||||
* Once CORBA is done, implement the Bonobo interfaces
|
||||
to allow people to use Bonobo components in Mono and
|
||||
Mono components with Bonobo. The best of both worlds!
|
||||
|
||||
TODO=moniker,Object Naming System with Monikers
|
||||
* A naming space for Mono. An object naming space is
|
||||
a very powerful tool. Bonobo implements a moniker
|
||||
system that is more powerful than the original
|
||||
moniker concept that was pioneered by COM/OLE in the
|
||||
Microsoft world.
|
||||
|
||||
Our implementation builds on a concept, and we have
|
||||
made it simpler, more powerful, more extensible and
|
||||
a much better mechanism than the equivalent monikers
|
||||
on Windows.
|
||||
|
||||
Implementing Mono monikers would benefit both
|
||||
Windows users using .NET and Mono users on Unix and
|
||||
Windows.
|
||||
|
||||
Here is <a
|
||||
href="http://primates.ximian.com/~miguel/monikers.html">an
|
||||
overview of the moniker system</a> in Bonobo.
|
||||
|
||||
</ul>
|
||||
@@ -0,0 +1,103 @@
|
||||
<a href="http://www.ximian.com">Ximian</a> announced the
|
||||
launch of the Mono project, an effort to create an Open Source
|
||||
implementation of the .NET Development Framework.
|
||||
|
||||
Mono includes: <a href="c-sharp.html">a compiler</a> for the
|
||||
C# language, a <a href="runtime.html">runtime</a> for the
|
||||
Common Language Infrastructure and a set of <a
|
||||
href="class-librayr.html">class libraries</a>
|
||||
|
||||
You can read our <a href="rationale.html">rationale</a> for
|
||||
this project. If you have questions about the project, please
|
||||
read our list of <a href="faq.html">Frequently Asked
|
||||
Questions</a> or <a href="mailto:[email protected]">contact us.</a>
|
||||
|
||||
You might also want to <a href="download.html">Download the
|
||||
source</a> for our work so far. Or you can grab a <a
|
||||
href="snapshots">snapshot</a> of our current work.
|
||||
|
||||
You might want to <a
|
||||
href="resources.html#mailing">subscribe</a> to our mono-list
|
||||
and mono-announce-list
|
||||
|
||||
You can contact the team at: <a
|
||||
href="mailto:[email protected]">[email protected]</a>
|
||||
|
||||
** Aug 20, 2001
|
||||
|
||||
A new <a href="contributing.html#compile-service">Compilation
|
||||
service</a> has been made available by Derek to allow people
|
||||
without access to the <a
|
||||
href="http://msdn.microsoft.com/downloads/default.asp?url=/downloads/sample.asp?url=/msdn-files/027/000/976/msdncompositedoc.xml&frame=true">.NET SDK</a>
|
||||
|
||||
** Aug 3, 2001
|
||||
|
||||
Daily snapshots of mcs and mono are now available, they will
|
||||
run every night at 10pm Boston time.
|
||||
|
||||
** Jul 29, 2001
|
||||
|
||||
Mono Runtime 0.5 has been <a
|
||||
href="download.html#july-29">released.</a> Check the <a
|
||||
href="archive/mono-0.5">release notes</a>
|
||||
|
||||
** Jul 25, 2001
|
||||
|
||||
The slides for <A href="Presentations/O-Reilly">my
|
||||
presentation</a> at <a href="http://www.oreilly.com">O'Reilly
|
||||
Open Source Software Convention</a>
|
||||
|
||||
** Jul 22, 2001
|
||||
|
||||
Another release of the class libraries is out, check the <a
|
||||
href="archive/mcs-22">MCS 22-July Release Notes</a>. You can
|
||||
get the new class libraries from <a
|
||||
href="download.html#july-22">here</a>
|
||||
|
||||
** Jul 19, 2001
|
||||
|
||||
Another release of the class libraries is out, check the <a
|
||||
href="archive/mcs-19">MCS 19-July Release Notes</a>. You can
|
||||
get the new class libraries from <a
|
||||
href="download.html#july-19">here</a>
|
||||
|
||||
** Jul 17, 2001
|
||||
|
||||
Another release of the class libraries is out, check the <a
|
||||
href="archive/mcs-17">MCS 17-July Release Notes</a>. You can
|
||||
get the new class libraries from <a
|
||||
href="download.html#july-17">here</a>
|
||||
|
||||
Do not forget to check out the updated <a href="faq.html">FAQ</a>.
|
||||
|
||||
Got Sean's new <a href="class-status/index.html">Class
|
||||
Status</a> web pages up. These are a lot better than mine, and
|
||||
we are now keeping better track of contributors.
|
||||
|
||||
** Jul 15, 2001
|
||||
|
||||
Another release of Mono is out, check the <a
|
||||
href="archive/mono-0.4">Mono 0.4 Release Notes</a>. Get it <a
|
||||
href="download.html#july-15">here</a>.
|
||||
|
||||
** Jul 14, 2001
|
||||
|
||||
A <a
|
||||
href="http://mail.ximian.com/archives/public/mono-list/2001-July/000399.html">new
|
||||
release</a> of the
|
||||
runtime, compiler and classes has been made. Get it <a href="download.html#july-14">here</a>
|
||||
|
||||
** Jul 12, 2001
|
||||
|
||||
I keep getting questions about my opinion on Passport, even when
|
||||
Mono has <b>nothing</b> to do with it. I finally <a
|
||||
href="passport.html">wrote something.</a>
|
||||
|
||||
** Jul 9, 2001
|
||||
|
||||
Project launched.
|
||||
|
||||
** O'Reilly
|
||||
|
||||
Brian posted a story on <a
|
||||
href="http://www.oreillynet.com/dotnet">O'Reilly Network .NET</a>
|
||||
@@ -0,0 +1,276 @@
|
||||
* Updates
|
||||
|
||||
I have received many comments from people, and I have updated
|
||||
the page accordingly. From removing incorrect statements, to
|
||||
fixing typos, to include mentions to other software pieces.
|
||||
|
||||
I also corrected my statement about IIS and a trojan horse, I
|
||||
should read a more educated press in the future. My apologies
|
||||
to Microsoft and its employees on this particular topic. IIS
|
||||
did not have a trojan horse built in.
|
||||
|
||||
* Microsoft Hailstorm and Passport
|
||||
|
||||
Microsoft Passport is a centralized database hosted by
|
||||
Microsoft that enhances the consumer experience with the Web
|
||||
by providing a single logon system that they can use across a
|
||||
number of participant web sites.
|
||||
|
||||
As you might know by now from our extensive <a
|
||||
href="faq.html">FAQ</a>, the Mono project has nothing to do
|
||||
with Microsoft Hailstorm or <a
|
||||
href="http://www.passport.com">Microsoft Passport.</a>
|
||||
|
||||
Still a lot of people have asked us our opinion on them.
|
||||
|
||||
** Passport
|
||||
|
||||
Passport is important not because of it being a breakthrough
|
||||
technologically speaking, but because the company is in a
|
||||
position to drive most people toward being suscribers of it.
|
||||
|
||||
At the time of this writing passport is required to use the
|
||||
free mail service <a href="http://www.hotmail.com">Hotmail</a>
|
||||
to get customized support for the <a
|
||||
href="http://www.msn.com">MSN portal</a>, <a
|
||||
href="http://msdn.microsoft.com">Microsoft Developers
|
||||
Network</a> and according to the original announcement from
|
||||
Microsoft <a href="http://www.americanexpress.com">American
|
||||
Express</a> and <a href="http://www.ebay.com">EBay</a> will be
|
||||
adopting it.
|
||||
|
||||
There is already a <a
|
||||
href="http://www.passport.com/Directory/Default.asp?PPDir=C&lc=1033">Large
|
||||
list</a> of participating sites.
|
||||
|
||||
There are many current users of it and Microsoft will be
|
||||
driving more users towards Passport as it <a
|
||||
href="http://news.cnet.com/news/0-1003-200-6343275.html">integrates
|
||||
it</a> in their upcoming release of Windows.
|
||||
|
||||
Microsoft has also <a
|
||||
href="http://www.passport.com/Business/JoinPassportNetwork.asp?lc=1033">developed
|
||||
a toolkit</a> to enable current web merchants to integrate
|
||||
their services with passport.
|
||||
|
||||
To the end user, there is a clear benefit: they only have to
|
||||
log into a single network and not remember multiple passwords
|
||||
across sites on the internet. Companies that adopt passport
|
||||
will have a competition advantage over those that dont.
|
||||
Microsoft lists a list of <a
|
||||
href="http://www.passport.com/Business/Default.asp?lc=1033">benefits</a>
|
||||
to companies.
|
||||
|
||||
|
||||
** The problems of Passport
|
||||
|
||||
There are a number of concerns that different groups have over
|
||||
Passport. Sometimes I have some, sometimes I do not. But
|
||||
overall, consumers and businesses can have better solutions.
|
||||
|
||||
<ul>
|
||||
* <b>Single Point of Failure:</b> As more services and
|
||||
components depend on remote servers, functionality can
|
||||
grind to a halt if there is a failure on the
|
||||
centralized Passport system.
|
||||
|
||||
Such a failure was predicted, and we recently <a
|
||||
href="http://news.cnet.com/news/0-1005-200-6473003.html">witnessed</a>
|
||||
got a lot of people worried.
|
||||
|
||||
The outgage lasted for seven days. Think what this
|
||||
could do to your business.
|
||||
|
||||
* <b>Trust:</b> Not everyone trusts Microsoft to keep
|
||||
their information confidential. Concerns are not only
|
||||
at the corporate level policy, but also the fact that
|
||||
the source code for Microsoft products is not
|
||||
available, means that trojans or worms could be built
|
||||
into the products by malicious engineers.
|
||||
|
||||
* <b>Security:</b> With a centralized system like
|
||||
Passport, imagine the repercussions of a malicious
|
||||
hacker gaining access to the Passport database.
|
||||
Personal information and credit card information about
|
||||
almost everyone using a computer could be stored there.
|
||||
|
||||
Hackers have already <a
|
||||
href="http://slashdot.org/articles/00/10/27/1147248.shtml">broken
|
||||
into Microsoft</a> in the past. And the company was
|
||||
unable to figure out for how long their systems had
|
||||
been hacked.
|
||||
|
||||
Security holes have been found in <a
|
||||
href="http://slashdot.org/articles/00/04/14/0619206.shtml">IIS
|
||||
in the past.</a> If all the world's data is stored on
|
||||
a central location, when a single security hole is
|
||||
detected, it would allow an intruder to install a
|
||||
backdoor within seconds into the corporate network
|
||||
without people ever noticing.
|
||||
|
||||
Microsoft itself has been recently hit by worms,
|
||||
imagine if all your business depended on a single
|
||||
provider for providing all or your authentication
|
||||
needs
|
||||
</ul>
|
||||
|
||||
Microsoft might or might not realize this. The idea behind
|
||||
Passport is indeed a good one (I can start to get rid of my
|
||||
file that keeps track of the 30 logins and passwords or so
|
||||
that I use across the various services on the net myself).
|
||||
|
||||
** Alternatives to Microsoft Passport
|
||||
|
||||
An alternative to Microsoft Passport needs to take the above
|
||||
problems into consideration. Any solution of the form `We
|
||||
will just have a competing offering' will not work.
|
||||
|
||||
The system thus has to be:
|
||||
|
||||
<ul>
|
||||
* <b>Distributed:</b> The entire authentication
|
||||
system should not create an internet `blackout' in the
|
||||
case of failure.
|
||||
|
||||
A distributed system using different software
|
||||
platforms and different vendors would be more
|
||||
resistent to an attack, as holes in a particular
|
||||
implementation of the server software would not affect
|
||||
every person at the same time.
|
||||
|
||||
A security hole attack might not even be relevant to
|
||||
other software vendors software.
|
||||
|
||||
* <b>Allow for multiple registrars:</b> Users should
|
||||
be able to choose a registrar (their banks, local
|
||||
phone company, service provider, Swiss bank, or any
|
||||
other entity they trust.
|
||||
|
||||
* <b>Mandate good security measures:</b> As a
|
||||
principle, only Open Source software should be used
|
||||
for servers in the registrar, and they should conform
|
||||
to a standard set of tools and software that can be
|
||||
examined by third parties.
|
||||
</ul>
|
||||
|
||||
An implementation of this protocol could use the DNS or a
|
||||
DNS-like setup to distribute the information of users with the
|
||||
possibility of replicating and caching public information
|
||||
about the user.
|
||||
|
||||
For instant messaging (another piece of the Hailstorm bit),
|
||||
you want to use a non-centralized system like Sun's <a
|
||||
href="http://www.jxta.org">JXTA</a>. Some people mailed me to
|
||||
mention Jabber as a messaging platform and other people
|
||||
pointed out to the <a
|
||||
href="http://java.sun.com/products/jms/">Java Message
|
||||
Service</a>. The JMS does support a number of very
|
||||
interesting features that are worth researching.
|
||||
|
||||
It could also just use the user e-mail address as the `key' to
|
||||
choose the registrar (msn.com, hotmail.com -> passport.com;
|
||||
aol.com -> aol.passport.com; you get the idea).
|
||||
|
||||
The <a
|
||||
href="http://www.soapware.org/xmlStorageSystem">xmlStorage</a>
|
||||
idea from <a href="http://www.scripting.com">Dave Winer</a>
|
||||
could be used to store the information.
|
||||
|
||||
A toolkit for various popular web servers could be provided,
|
||||
authenticated and should be open sourced (for those of you who
|
||||
think that a binary program would give more security and would
|
||||
prevent people from tampering: you are wrong. You can always
|
||||
use a proxy system that "behaves" like the binary, and passes
|
||||
information back and forth from the real program, and snoops
|
||||
in-transit information).
|
||||
|
||||
Good cryptographers need to be involved in this problem to
|
||||
figure out the details and the possible insecure pieces of a
|
||||
proposal like this.
|
||||
|
||||
** Implementation: In short
|
||||
|
||||
To keep it short: <b>DNS, JXTA, xmlStorage.</b>
|
||||
|
||||
|
||||
** Deploying it
|
||||
|
||||
The implementation of such a system should be a pretty
|
||||
straightforward task once security cryptographers have
|
||||
designed such a beast.
|
||||
|
||||
The major problems are:
|
||||
|
||||
<ul>
|
||||
* <b>People might just not care:</b> In a poll to US
|
||||
citizens a couple of decades ago, it was found that
|
||||
most people did not care about the rights they were
|
||||
given by the Bill of Rights, which lead to a number of
|
||||
laws to be passed in the US that eliminated most of
|
||||
the rights people had.
|
||||
|
||||
* <b>The industry will move way too slow:</b>
|
||||
Microsoft's implementation is out in the open now: it
|
||||
is being deployed, and soon it will be insinuated to
|
||||
many, many users. The industry needs to get together
|
||||
soon if they care about this issue.
|
||||
|
||||
By the time the industry reacts, it might be too
|
||||
late.
|
||||
</ul>
|
||||
|
||||
** Passport and Mono
|
||||
|
||||
The .NET class libraries include a Passport class that
|
||||
applications might use to authenticate with Passport. Since
|
||||
we do not have information at this point on the exact protocol
|
||||
of Passport, it is not even feasible to implement it.
|
||||
|
||||
If at some point the information is disclosed, it could be
|
||||
implemented.
|
||||
|
||||
If a competing system to Passport existed, we could probably
|
||||
hide all the authentication information to use a number of
|
||||
different passport-like systems.
|
||||
|
||||
If a user does not want to use Passport at all, he could
|
||||
always turn it off (or completely remove the class from the
|
||||
library). After all, this is free software.
|
||||
|
||||
Currently, we are too far from the point where this is a real
|
||||
issue.
|
||||
|
||||
** Passport and endangering Open Source.
|
||||
|
||||
A few people have said: `Mono will allow Passport to be
|
||||
available for Linux and that is bad'. This is plain
|
||||
missinformation.
|
||||
|
||||
Currently, you can obtain Passport for Linux from Microsoft
|
||||
itself and deploy it today on your Web server. Mono does not
|
||||
even enter the picture here. Go to passport.com and download
|
||||
the toolkit and you will see with your own eyes that passport
|
||||
is <B>already</b> available for Linux.
|
||||
|
||||
** Disclaimer
|
||||
|
||||
This is just a group of personal thoughts of mine that I have
|
||||
placed here because I get asked this question a lot lately.
|
||||
The views of this page are not a statement from my employer
|
||||
(Ximian, Inc).
|
||||
|
||||
This is not part of Mono. We are not trying to deal with this
|
||||
problem.
|
||||
|
||||
Nat Friedman (Ximian's co-founder) has his own ideas on how a
|
||||
competing system to Passport could be designed, but I will let
|
||||
<a href="http://www.nat.org/">him</a> post his own story.
|
||||
|
||||
** Other Alternatives
|
||||
|
||||
Some people have pointed out <a
|
||||
href="http://www.xns.org">XNS</a>
|
||||
|
||||
Send comments to me: Miguel de Icaza (<a
|
||||
href="mailto:[email protected]">[email protected]</a>)
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
** Microsoft and GNU and Linux.
|
||||
|
||||
Q: Does this mean that Microsoft is better than Linux?
|
||||
|
||||
A: Many of us are working on <a
|
||||
href="http://www.gnu.org/philosophy/free-sw.html">free software<a>
|
||||
and want to have an <a href="http://www.opensource.org">open
|
||||
source</a> environment that we can change, modify, improve, learn
|
||||
from, and share with others. Some of us also think that this will
|
||||
lead on the long run to better software: more efficient, faster,
|
||||
more robust and more.
|
||||
|
||||
We are willing to take good ideas from any source they come from.
|
||||
|
||||
@@ -0,0 +1,173 @@
|
||||
|
||||
* The Mono Project
|
||||
|
||||
** Background.
|
||||
|
||||
The GNOME project goal was to bring missing technologies to
|
||||
Unix and make it competitive in the current market place for
|
||||
desktop applications. We also realized early on that language
|
||||
independence was important, and that is why GNOME APIs were
|
||||
coded using a standard that allowed the APIs to be easily
|
||||
wrapped for other languages. Our APIs are available to most
|
||||
programming languages on Unix (Perl, Python, Scheme, C++,
|
||||
Objective-C, Ada).
|
||||
|
||||
Later on we decided to use better methods for encapsulating
|
||||
our APIs, and we started to use CORBA to define interfaces to
|
||||
components. We complemented it with policy and a set of
|
||||
standard GNOME interfaces for easily creating reusable,
|
||||
language independent components, controls and compound
|
||||
documents. This technology is known as <a
|
||||
href="http://www.ximian.com/tech/bonobo.php3">Bonobo</a>.
|
||||
Interfaces to Bonobo exist for C, Perl, Python, and
|
||||
Java.
|
||||
|
||||
CORBA is good when you define coarse interfaces, and most
|
||||
Bonobo interfaces are coarse. The only problem is that
|
||||
Bonobo/CORBA interfaces are not good for small interfaces.
|
||||
For example, an XML parsing Bonobo/CORBA component would be
|
||||
inefficient compared to a C API.
|
||||
|
||||
** Another explanation
|
||||
|
||||
I recently explained our motivations to Dave Winer, and he posted
|
||||
it <a
|
||||
href="http://scriptingnews.userland.com/stories/storyReader$1275">here</a>
|
||||
|
||||
** Microsoft's .NET
|
||||
|
||||
The Microsoft .NET initiative is confusing because it is a
|
||||
company wide effort that ranges from development tools to end
|
||||
user applications. .NET is a branding formative that
|
||||
has been applied to:
|
||||
|
||||
<ul>
|
||||
* The .NET development platform, a new platform for
|
||||
writing software.
|
||||
|
||||
* Web services.
|
||||
|
||||
* Microsoft Server Applications.
|
||||
|
||||
* New tools that use the new development platform.
|
||||
|
||||
* Hailstorm, the Passport centralized single-signon
|
||||
system that is being integrated into Windows XP.
|
||||
|
||||
</ul>
|
||||
|
||||
Mono is an implementation of the .NET development platform.
|
||||
|
||||
** The Common Language Infrastructure platform.
|
||||
|
||||
Microsoft has created a new development platform. The
|
||||
highlights of this new development platform are:
|
||||
|
||||
<ul>
|
||||
* A runtime environment that provides garbage
|
||||
collection, threading and a virtual machine
|
||||
specification (The Virtual Execution System, VES)
|
||||
|
||||
* A comprehensive class library.
|
||||
|
||||
* A new language, C#. Very similar to Java, C#
|
||||
allows programmers to use all the features available
|
||||
on the .NET runtime.
|
||||
|
||||
* A language specification that compilers can
|
||||
follow if they want to generate classes and code
|
||||
that can interoperate with other programming
|
||||
languages (The Common Language Specification: CLS)
|
||||
</ul>
|
||||
|
||||
The Common Language Infrastructure platform is similar to the
|
||||
goals we had in GNOME of giving language independence to
|
||||
programmers. It is more mature, documented, larger in scope,
|
||||
and has a consistent design.
|
||||
|
||||
Any API that is written using a CLS provider language can be
|
||||
used by any language that is a CLS consumer. Compilers
|
||||
generate code in a format called Common Intermediate Language
|
||||
(CIL) which is an intermediate representation of a compiled
|
||||
program and is easy to compile to native code or compiled
|
||||
using Just-in-Time (JIT) engines. The restrictions placed by
|
||||
the runtime on the CIL byte codes ensures that it is possible
|
||||
to do a good job at optimizing the code in a JIT compiler.
|
||||
|
||||
There is not really a lot of innovation in this platform: we
|
||||
have seen all of these concepts before, and we are all
|
||||
familiar with how these things work.
|
||||
|
||||
What makes the Common Language Infrastructure development
|
||||
platform interesting is that it is a good mix of technologies
|
||||
that have been nicely integrated.
|
||||
|
||||
The .NET development platform is essentially a new foundation
|
||||
for program development that gives Microsoft a room to grow
|
||||
for the coming years.
|
||||
|
||||
** ECMA standards.
|
||||
|
||||
Microsoft has submitted the
|
||||
specifications of C#, the runtime, the metadata and the
|
||||
other various bits of the .NET development platform to the
|
||||
<a href="http://www.ecma.ch">ECMA</a> for standarization.
|
||||
|
||||
You can get a copy of the specifications submitted to ECMA
|
||||
from: <a href="http://www.dotnetexperts.com/ecma">http://www.dotnetexperts.com/ecma</a>
|
||||
|
||||
** Mono: an Open Source Common Language Infrastructure implementation.
|
||||
|
||||
Ximian has begun work on Mono, a project that aims to bring
|
||||
the Common Language Infrastructure platform to free systems.
|
||||
|
||||
When the GNU project was launched, they picked the best
|
||||
operating system that was available out there, and they
|
||||
began to clone it: Unix.
|
||||
|
||||
The .NET development platform is a very rich, powerful, and
|
||||
well designed platform that would help improve the free
|
||||
software development platform. Just like the GNU project
|
||||
began to clone Unix sixteen years ago, we will be cloning the
|
||||
.NET development platform because it is a great platform to
|
||||
build on.
|
||||
|
||||
** What makes up Mono?
|
||||
|
||||
There are various pieces that will make up Mono:
|
||||
|
||||
<ul>
|
||||
* A C# compiler.
|
||||
|
||||
* The Virtual Execution System: that will have the
|
||||
Just-in-Time compiler, garbage collector, loader,
|
||||
threading engine.
|
||||
|
||||
A byte code interpreter will be provided for quickly
|
||||
porting Mono to new systems and debugging the JIT
|
||||
purposes, but it is not intended to be the ideal
|
||||
execution environment.
|
||||
|
||||
* An implemenation of the .NET class library.
|
||||
|
||||
* Visual development tools.
|
||||
|
||||
* A CIL GCC frontend.
|
||||
</ul>
|
||||
|
||||
** Why use GNOME components?
|
||||
|
||||
GNOME is an umbrella project that consists of infrastructural
|
||||
components (GUI toolkit, XML libraries, CORBA implementation,
|
||||
printing architecture, imaging system), a desktop environment,
|
||||
and productivity applications.
|
||||
|
||||
The GNOME infrastructural components can be used to quickly
|
||||
implement various pieces of the class libraries without reinventing
|
||||
the wheel, and since all those components are licensed under
|
||||
the terms of the GNU LGPL it is a perfect fit.
|
||||
|
||||
Libart will be used to implement the Drawing.2D API; Gtk+ and
|
||||
the GNOME libraries will be used to implement the WinForms
|
||||
API and of course Glib and libxml will be used in various
|
||||
places.
|
||||
@@ -0,0 +1,46 @@
|
||||
To: [email protected], [email protected]
|
||||
Subject: July 12 snapshots.
|
||||
FCC: ~/Mail/outbox.txt
|
||||
X-Windows: Sometimes you fill a vacuum and it still sucks.
|
||||
--text follows this line--
|
||||
|
||||
Hey!
|
||||
|
||||
July 12 snapshots of class libraries, the compiler and the mono
|
||||
runtime are available.
|
||||
|
||||
New on this release:
|
||||
|
||||
* Runtime (module: mono)
|
||||
|
||||
The beginning of a simple interpreter that Paolo started
|
||||
workign on (can run really simple .NET programs).
|
||||
|
||||
Disassembler copes with more elements of the binary format and
|
||||
more tokens are decoded. Paolo is working now on moving some
|
||||
of these to the metadata library.
|
||||
|
||||
More tables are dumped.
|
||||
|
||||
* Class libraries (module: mcs/class)
|
||||
|
||||
Many new more classes are in from Joe, Vladimir, Jeff, Sean
|
||||
and yours truly.
|
||||
|
||||
Sean fixed the build process, and it is now possible to
|
||||
compile with a single command the assemblies. We will be
|
||||
revisiting this mechanism in the future to compile per-OS
|
||||
assemblies (ie, Unix, Windows, MacOS, etc).
|
||||
|
||||
* Compiler (module mcs/mcs)
|
||||
|
||||
Not much done this week, just a few fixes here and there, and
|
||||
more work to make it easy to compiler.
|
||||
|
||||
* Documentation (module: mono/doc)
|
||||
|
||||
All the changes to the web site are there for your browsing
|
||||
pleasure. We still need to integrate the status system in
|
||||
there.
|
||||
|
||||
Miguel.
|
||||
@@ -0,0 +1,43 @@
|
||||
To: [email protected]
|
||||
Subject: Sunday snapshot available.
|
||||
Gcc: mail.2001-07
|
||||
--text follows this line--
|
||||
|
||||
Hey guys,
|
||||
|
||||
I promise I will not be doing these so often once we have the CVS
|
||||
server up. In the meantime:
|
||||
|
||||
* MCS
|
||||
|
||||
Sean got the classes to compile in a single go. You
|
||||
will need CygWin (www.cygwin.org) to compile though
|
||||
(GNU make and stuff is required).
|
||||
|
||||
System.Xml.XmlReader contribution from Jason
|
||||
(WOOHHOO!!). It also contains a nice test-suite for
|
||||
his functions, and in his new code bit, his
|
||||
implementation is faster than Microsoft's
|
||||
|
||||
We now ship `jay' as part of the distribution to allow
|
||||
you to compile the compiler with the same `make'
|
||||
command. Small fixes to the parser as well were
|
||||
introduced.
|
||||
|
||||
* Mono 0.4
|
||||
|
||||
Paolo's interpreter supports call instructions and has
|
||||
the test suite program that he posted about.
|
||||
|
||||
|
||||
All documentation ships now in the mono-0.4.tar.gz
|
||||
|
||||
Notes:
|
||||
|
||||
As usual, MCS is targeted to be compiled on a Windows machine
|
||||
(you will need Cygwin).
|
||||
|
||||
Mono is targeted to be compiled on a Unix machine or a Windows
|
||||
machine running Cygwin.
|
||||
|
||||
Miguel.
|
||||
@@ -0,0 +1,121 @@
|
||||
|
||||
* Resources
|
||||
|
||||
There are a number of resources available for those of you who
|
||||
want to contribute to the Mono project. Here are a few links.
|
||||
|
||||
If you want to send suggestions for links, address them to <a
|
||||
mailto="[email protected]">[email protected]</a>.
|
||||
|
||||
** ECMA Documentation.
|
||||
|
||||
You can get the documentation for the ECMA specs from a number of sites:
|
||||
<ul>
|
||||
* <a href="http://msdn.microsoft.com/net/ecma">At MSDN</a>
|
||||
* <a href="http://www.dotnetexperts.com">Dot Net Experts</a>
|
||||
* <a href="http://developer.intel.com/software/idap/ecma">Intel</a>
|
||||
* <a href="http://lightning.csse.monash.edu.au/.net/CLI">Monash University</a>
|
||||
</ul>
|
||||
|
||||
These contain specifications for the assembler, the metadata,
|
||||
byte codes supported by the CLI virtual machine, the C#
|
||||
language and the core class libraries.
|
||||
|
||||
For details on the .NET class libraries, you can
|
||||
visit the Microsoft's Developer Network:
|
||||
|
||||
<ul>
|
||||
* <a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/cpref_start.asp">.NET Framework Class Library</a>
|
||||
</ul>
|
||||
|
||||
You can also get this information if you install the Beta2
|
||||
release of the .NET Framework.
|
||||
|
||||
<a name="mailing">
|
||||
** Mailing Lists
|
||||
|
||||
There are a number of mailing lists for Mono
|
||||
|
||||
<ul>
|
||||
|
||||
* <b><a
|
||||
href="http://mail.ximian.com/mailman/listinfo/mono-list">mono-list:</a></b>
|
||||
The general Mono discussion list.
|
||||
* <b><a
|
||||
href="http://mail.ximian.com/mailman/listinfo/mono-announce-list">mono-announce-list:</a></b>
|
||||
Announcements of Mono developments.
|
||||
* <b><a
|
||||
href="http://mail.ximian.com/mailman/listinfo/mono-gc-list">mono-gc-list:</a></b>
|
||||
Discussion on the GC system of Mono.
|
||||
* <b><a
|
||||
href="http://mail.ximian.com/mailman/listinfo/mono-cvs-list">mono-cvs-list:</a></b>
|
||||
Track the CVS activity of Mono on this mailing list. You can get <a href="http://www.go-mono.com/snapshots">daily snapshots</a> as well.
|
||||
* <b><a
|
||||
href="http://mail.ximian.com/mailman/listinfo/mono-docs-list">mono-docs-list:</a></b>
|
||||
Discussion on the documentation of Mono.
|
||||
* <b><a
|
||||
href="http://discuss.develop.com/dotnet.html">Dotnet mailing
|
||||
list at Develop.com:</a></b> The guys at Develop Mentor run
|
||||
this general purpose mailing list.
|
||||
</ul>
|
||||
|
||||
** Discussion Groups.
|
||||
|
||||
<ul>
|
||||
|
||||
* <a href="http://www.oreillynet.com">O'Reilly
|
||||
Network</a> has a <a
|
||||
href="http://www.oreillynet.com/dotnet">section devoted to
|
||||
.NET</a>
|
||||
* <a
|
||||
href="http://msdn.microsoft.com/newsgroups">MSDN</a> also
|
||||
lists various newsgroups related to .NET</ul>
|
||||
</ul>
|
||||
|
||||
** Other .NET related projects
|
||||
|
||||
There are a number of related projects to Mono:
|
||||
|
||||
<ul>
|
||||
* <a
|
||||
href="http://www.icsharpcode.net/OpenSource/SD/default.asp">Sharp
|
||||
Develop:</a> an IDE for the C# language written in C#.
|
||||
|
||||
* <a
|
||||
href="http://janet-js.sourceforge.net/">Janet:</a>
|
||||
an implemention of ECMAScript (the standarized
|
||||
version of JavaScript) in C#
|
||||
|
||||
* <a
|
||||
href="http://www.southern-storm.com.au/portable_net.html">Portable.NET:</a>
|
||||
Another implementation of the CLI and C# compiler.
|
||||
|
||||
* <a href="http://nunit.sourceforge.net">NUnit:</a> A
|
||||
testing framework for .NET classes.
|
||||
|
||||
* <a href="http://www.kaffe.org">Kaffe:</a> A popular
|
||||
Free Software JIT engine for Java.
|
||||
|
||||
* <a href="http://www.intel.com/research/mrl/orp">ORP:</a> A research
|
||||
JIT/VM/GC system from Intel.
|
||||
</ul>
|
||||
|
||||
** GNOME Documentation
|
||||
|
||||
Documnetation on GNOME, and the GNOME APIs is available from
|
||||
the <a href="http://developer.gnome.org">developer</a> site at
|
||||
GNOME:
|
||||
|
||||
<ul>
|
||||
* <a href="http://developer.gnome.org/doc/API/">GNOME
|
||||
API documentation</a>
|
||||
|
||||
* <a href="http://developer.gnome.org/doc/books">GNOME
|
||||
Online books</a>
|
||||
|
||||
* <A
|
||||
href="http://developer.gnome.org/arch/">Architecture Overview</a>
|
||||
</ul>
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
** MacOS Documentation
|
||||
|
||||
** Assembly Language Manuals online
|
||||
Intel
|
||||
MIPS
|
||||
SPARC
|
||||
|
||||
** Microsoft
|
||||
msdn.microsoft.com/net
|
||||
Research.microsoft.com
|
||||
|
||||
** Related Technologies
|
||||
|
||||
<ul>
|
||||
|
||||
* The CLI allows people to create Web Services using the SOAP
|
||||
protocol. SOAP is based on XML, XML schemas an the HTTP
|
||||
protocol.
|
||||
<ul>
|
||||
* XML specification.
|
||||
* XML Namespaces.
|
||||
* XML Schemas.
|
||||
* SOAP Specification.
|
||||
</ul>
|
||||
</ul>
|
||||
|
||||
** Compiler Information
|
||||
GCC
|
||||
GCC Sample front-end tutorial
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
* Roadmap
|
||||
|
||||
We are working on the following three projects at Ximian:
|
||||
|
||||
The C# Compiler (mcs/mcs)
|
||||
|
||||
A .NET compatible Class Library (mcs/class)
|
||||
|
||||
The JIT/interpreter (mono)
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,144 @@
|
||||
* The Mono runtime
|
||||
|
||||
The Mono runtime will implement the JIT engine (and a byte
|
||||
code interpreter for quickly porting to new systems), the
|
||||
class loader, the garbage collector, threading system and
|
||||
metadata access libraries.
|
||||
|
||||
Currently the runtime has an image loader and metadata access
|
||||
entry points. The runtime comes with a simple interpreter
|
||||
that can execute very simple programs.
|
||||
|
||||
** Executing MSIL/CIL images
|
||||
|
||||
The code will load an executable and map the references to
|
||||
external assemblies to our own version of the assemblies on
|
||||
GNU/Linux.
|
||||
|
||||
Our roadmap looks like this, this has been updated as of
|
||||
<b>Jul 15, 2001</b>:
|
||||
|
||||
<ul>
|
||||
|
||||
* Milestone 1: <b> Done</b> Fully read and parse all CIL byte-codes
|
||||
and metadata tokens (ie, a disassembler).
|
||||
|
||||
* Milestone 2: Complete an interpreter for CIL byte
|
||||
codes. This interpreter can be used temporarly to
|
||||
run CIL byte code on a system where no JIT is
|
||||
available.
|
||||
|
||||
* Milestone 3: Define an <i>lburg</i>-like instruction
|
||||
selector for the JITer for Intel. Although slower
|
||||
at JITing than a streaming JITer, it generates
|
||||
better code. The same grammar can later be used for
|
||||
the stream jitter.
|
||||
|
||||
* Milestone 4: Implement JITer.
|
||||
|
||||
* Milestone 5: Port of the JITer to non IA32 systems.
|
||||
</ul>
|
||||
|
||||
A setup similar to the Kaffe JIT engine can be used to
|
||||
layout the code to support non-IA32 architectures. Our work
|
||||
will be focused on getting a IA32 version running first.
|
||||
|
||||
The JIT engine should work on Linux and Win32, although you
|
||||
will need to install the CygWin32 development tools to get a
|
||||
Unix-like compilation environment.
|
||||
|
||||
** JIT Engine (<b>updated, Jul 14th, 2001</b>)
|
||||
|
||||
We will be using a code-generator generator approach for our
|
||||
JITer. Given the properties of CIL byte codes, we can take
|
||||
full advantage of a real instruction selector for our code
|
||||
generator.
|
||||
|
||||
There are a couple of books that deal with this technique: "A
|
||||
Retargetable C Compiler" and "Advanced Compiler Design and
|
||||
Implementation" are good references. You can also get a
|
||||
technical description of <a
|
||||
href="http://research.microsoft.com/copyright/accept.asp?path=http://www.research.microsoft.com/~drh/pubs/iburg.pdf&pub=ACM">lbrug</a>
|
||||
|
||||
Previously we had looked at a number of JIT engines and tools,
|
||||
but they would not take full advantage of the CIL properties:
|
||||
|
||||
<ul>
|
||||
* <a
|
||||
href="http://www.intel.com/research/mrl/orp/">ORP</a>
|
||||
|
||||
* <a
|
||||
href="http://www.gnu.org/software/lightning/">GNU
|
||||
Lightning</a>
|
||||
|
||||
* <a href="http://www.eecs.harvard.edu/~nr/toolkit/">NJ Machine
|
||||
Toolkit</a>.).
|
||||
|
||||
* VCODE.
|
||||
</ul>
|
||||
|
||||
** Garbage Collection
|
||||
|
||||
We have decided to implement a generational tracing garbage
|
||||
collector, which is very similar to the one being used by
|
||||
.NET. For an introduction to the garbage collection system
|
||||
used by Microsoft's CLR implementation, you can read this book
|
||||
on <a
|
||||
href="http://www.amazon.com/exec/obidos/ASIN/0471941484/o/qid=992556433/sr=2-1/ref=aps_sr_b_1_1/103-5866388-0492603">Garbage
|
||||
Collection.</a>
|
||||
|
||||
Another consideration is to use the same interface that ORP
|
||||
uses to its Garbage Collection system and reuse that GC system
|
||||
instead of rolling our own, as the ORP system is pretty advanced
|
||||
and is independent of the rest of ORP.
|
||||
|
||||
Although using a conservative garbage collector like Bohem's
|
||||
would work, all the type information is available at runtime,
|
||||
so we can actually implement a better collector than a
|
||||
conservative collector.
|
||||
|
||||
<ul>
|
||||
* Garbage collection list and FAQ:<br>
|
||||
<a href="http://www.iecc.com/gclist/">http://www.iecc.com/gclist/</a>
|
||||
|
||||
* "GC points in a Threaded Environment":<br>
|
||||
<a href="http://research.sun.com/techrep/1998/abstract-70.html">
|
||||
http://research.sun.com/techrep/1998/abstract-70.html</a>
|
||||
|
||||
* "A Generational Mostly-concurrent Garbage Collector":
|
||||
<a href="http://research.sun.com/techrep/2000/abstract-88.html">
|
||||
http://research.sun.com/techrep/2000/abstract-88.html</a>
|
||||
|
||||
* Details on The Microsoft .NET Garbage Collection Implementation:<br>
|
||||
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp">http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI.asp</a>
|
||||
<a href="http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI2.asp">http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnmag00/html/GCI2.asp</a>
|
||||
</ul>
|
||||
|
||||
** Useful links
|
||||
|
||||
Paolo Molaro found a few interesting links:
|
||||
|
||||
<ul>
|
||||
* On compilation of stack-based languages:<br>
|
||||
<a href="http://www.complang.tuwien.ac.at/projects/rafts.html">
|
||||
http://www.complang.tuwien.ac.at/projects/rafts.html</a>
|
||||
|
||||
* A paper on fast JIT compilation of a stack-based language:<br>
|
||||
<a href="http://www.research.microsoft.com/~cwfraser/pldi99codegen.pdf">
|
||||
http://www.research.microsoft.com/~cwfraser/pldi99codegen.pdf</a>
|
||||
|
||||
* Vmgen generates much of the code for efficient virtual machine (VM)
|
||||
interpreters from simple descriptions of the VM instructions:<br>
|
||||
<a href="http://www.complang.tuwien.ac.at/anton/vmgen/">
|
||||
http://www.complang.tuwien.ac.at/anton/vmgen</a>
|
||||
</ul>
|
||||
|
||||
** PInvoke
|
||||
|
||||
PInvoke is the mechanism we are using to wrap Unix API calls
|
||||
as well as talking to system libraries.
|
||||
|
||||
We hvae implemented PInvoke through libffi, but we are likely
|
||||
going to roll our own system as the runtime matures, specially
|
||||
as the interpreter is approaching completion, and we move into
|
||||
the JITer.
|
||||
@@ -0,0 +1,38 @@
|
||||
* Project Status
|
||||
|
||||
|
||||
Pieces of Mono that have been implemented:
|
||||
|
||||
<ul>
|
||||
* C# compiler: The C# parser can now generate parse
|
||||
trees. Next up: semantic analysis, compiler lever optimizations
|
||||
and code generation.
|
||||
|
||||
* Metadata library: Can currently parse and load
|
||||
information from .NET modules (executables and DLL
|
||||
files).
|
||||
|
||||
Parsing of Exception tables is missing.
|
||||
|
||||
* Disassembler: Can disassemble .NET modules. Still
|
||||
lacking exception handling as well as useful debugging
|
||||
tools (hex dumping, token dumping).
|
||||
|
||||
* Class Libraries: You can check the current status in the
|
||||
<a href="class-status.html">Class Status page</a>
|
||||
</ul>
|
||||
|
||||
Tasks on the critical path:
|
||||
|
||||
<ul>
|
||||
* Bytecode interpreter: (Paolo is working on this).
|
||||
|
||||
* Simple JIT: Not implemented yet (Miguel is
|
||||
researching the code-generator generator)
|
||||
|
||||
* Garbage collection engine (Dick is working on this, his contact is <a
|
||||
href="mailto:[email protected]">[email protected]</a>
|
||||
</ul>
|
||||
|
||||
If you want to work on any task here, please mail <a
|
||||
href="mailto:[email protected]">[email protected]</a>
|
||||
@@ -0,0 +1,21 @@
|
||||
* Testing
|
||||
|
||||
All classes in Mono libraries should have comprehensive unit test
|
||||
suites to go with them. Unit testing is a software engineering
|
||||
methodology that makes it easier to build correct code. Every
|
||||
method in every class should have a set of tests to verify
|
||||
that they work correctly. Mono also needs a testing framework
|
||||
to make it easy to write and run lots of tests.
|
||||
|
||||
Try <a href="http://nunit.sourceforge.net">NUnit</a>
|
||||
|
||||
Why do unit testing? It becomes simple to run automated tests
|
||||
for the whole library. Unit tests are a safety net - you can
|
||||
change part of the code and verify that you haven't broken
|
||||
anything. Ideally, tests are written before the actual library
|
||||
code itself. And every time a bug is discovered, a test should
|
||||
be written to demonstrate the bug and its fix. Then, if
|
||||
you ever reintroduce the bug, you will know immediately. For
|
||||
more info, read <a
|
||||
href="http://nunit.sourceforge.net/doc/testinfected/testing.html">
|
||||
JUnit Test Infected: Programmers Love Writing Tests</a>.
|
||||
@@ -0,0 +1,6 @@
|
||||
* Thanks
|
||||
|
||||
We would like to thank Tim O'Reilly, Brian Jepson and Nathan
|
||||
Torkington for their help.
|
||||
|
||||
Dave Winer for provided interesting comments and a to read.
|
||||
@@ -0,0 +1,67 @@
|
||||
* Tools
|
||||
|
||||
We need a number of tools to make people productive using a
|
||||
Mono-based solution. Some of these tools can be developed on
|
||||
Windows before Mono is fully finished.
|
||||
|
||||
All of these tools should be written using C#.
|
||||
|
||||
For the tools that are typically command line tools: Try to
|
||||
write these as components that could load their input from
|
||||
streams or collections of streams, and implement the command
|
||||
line tools as wrappers around those classes.
|
||||
|
||||
For example, we will be making the C# compiler a component
|
||||
that could be reused by applications that might have a use for
|
||||
the various bits of the compiler (either to embed the
|
||||
compiler, or reuse the code generator part of it).
|
||||
|
||||
This is important so that these components (compiler,
|
||||
assembler, linker, etc) can be integrated later into the
|
||||
visual development environment (hopefully with the help of the
|
||||
SharpDevelop hackers).
|
||||
|
||||
TODO=ilasm,IL Assembler
|
||||
** IL Assembler.
|
||||
|
||||
This assembler should basically take as input a file
|
||||
containing IL bytecodes as specified in the `Partition II' of
|
||||
the ECMA spec, and produce a binary file.
|
||||
|
||||
TODO=al,Assembly Linker
|
||||
** Assembly Linker.
|
||||
|
||||
This tool is used to construct assemblies, which are basically
|
||||
deployment units for CLI executables.
|
||||
|
||||
TODO=debugger,Debugger
|
||||
** Debugger
|
||||
|
||||
We will need a debugging API to debug CLI applications and
|
||||
then a debugger component that can be used in an IDE
|
||||
environment.
|
||||
|
||||
TODO=ide,Integrated Development Environment
|
||||
** Integrated Development Environment
|
||||
|
||||
There is already a project to create a C# development
|
||||
environment: <a
|
||||
href="http://www.icsharpcode.net/OpenSource/SD/default.asp">SharpDevelop</a>.
|
||||
People should work with the SharpDevelop hackers to produce a
|
||||
unified development environment.
|
||||
|
||||
Please work with the SharpDevelop hackers to build a good IDE.
|
||||
We will work on creating an embedable compiler component and
|
||||
an embeddable debugger component that can be used withing
|
||||
SharpDevelop
|
||||
|
||||
TODO=hbrowser,Help Browser
|
||||
** Help Browser
|
||||
|
||||
We need a good help browser that can be used to browse
|
||||
documentation. Ideally this help browser can accept as input
|
||||
XML Docbook input and an assorted set of file formats
|
||||
(Microsoft Help, Unix manual pages, Unix Info pages)
|
||||
|
||||
Look at the GNOME DevHelp for a good set of ideas on how to
|
||||
implement this.
|
||||
@@ -0,0 +1,2 @@
|
||||
*.src
|
||||
*.html
|
||||
@@ -0,0 +1,17 @@
|
||||
0,Home,index.html,index.src
|
||||
1,FAQ,faq.html,faq.src
|
||||
0,Mono,rationale.html,rationale.src
|
||||
1,Runtime,runtime.html,runtime.src
|
||||
1,Classes,class-library.html,class-library.src
|
||||
2,Class Status,class-status.html,class-status.src
|
||||
1,C# Compiler,c-sharp.html,c-sharp.src
|
||||
1,Status,status.html,status.src
|
||||
0,Contributing,contributing.html,contributing.src
|
||||
1,Documentation,documentation.html,documentation.src
|
||||
1,Test Suite,testing.html,testing.src
|
||||
1,Tools,tools.html,tools.src
|
||||
0,Download,download.html,download.src
|
||||
0,Resources,resources.html,resources.src
|
||||
1,Ideas,ideas.html,ideas.src
|
||||
1,Passport,passport.html,passport.src
|
||||
0,Contact,contact.html,contact.src
|
||||
@@ -0,0 +1,26 @@
|
||||
#!/usr/bin/perl
|
||||
$q = 1;
|
||||
|
||||
while (<>){
|
||||
chop;
|
||||
if (/^\* (.*)$/){
|
||||
print "<h1>$1</h1>\n";
|
||||
} elsif (/^\*\* (.*)$/) {
|
||||
print "<h2>$1</h2>\n";
|
||||
} elsif (/^\*\*\* (.*)$/) {
|
||||
print "<h3>$1</h3>\n";
|
||||
} elsif (/^$/) {
|
||||
print "<p>\n";
|
||||
} elsif (/^\t\t\* (.*)$/) {
|
||||
print "<li>$1\n";
|
||||
} elsif (/^Q: (.*)$/){
|
||||
print "<p><a name=\"q$q\"></a><b>Question $q:</b> $1\n";
|
||||
$q++;
|
||||
} elsif (/^A: (.*)$/){
|
||||
print "$1\n";
|
||||
} elsif (/^TODO=(.*),$/){
|
||||
print "<a name=\"$1\">\n";
|
||||
} else {
|
||||
print "$_\n";
|
||||
}
|
||||
}
|
||||
|
Before Width: | Height: | Size: 4.8 KiB After Width: | Height: | Size: 4.8 KiB |
|
Before Width: | Height: | Size: 4.5 KiB After Width: | Height: | Size: 4.5 KiB |
|
Before Width: | Height: | Size: 3.0 KiB After Width: | Height: | Size: 3.0 KiB |
|
Before Width: | Height: | Size: 4.4 KiB After Width: | Height: | Size: 4.4 KiB |
|
Before Width: | Height: | Size: 49 B After Width: | Height: | Size: 49 B |
|
Before Width: | Height: | Size: 156 B After Width: | Height: | Size: 157 B |
@@ -0,0 +1,39 @@
|
||||
SOURCES= \
|
||||
../contributing \
|
||||
../class-library \
|
||||
../class-status \
|
||||
../contact \
|
||||
../c-sharp \
|
||||
../documentation \
|
||||
../download \
|
||||
../faq \
|
||||
../gcc-frontend \
|
||||
../index \
|
||||
../ideas \
|
||||
../passport \
|
||||
../rationale \
|
||||
../resources \
|
||||
../roadmap \
|
||||
../runtime \
|
||||
../status \
|
||||
../testing \
|
||||
../tools
|
||||
|
||||
all:
|
||||
-mkdir site
|
||||
for i in $(SOURCES); do \
|
||||
perl htmlify $$i > `basename $$i`.src; \
|
||||
done;
|
||||
|
||||
perl process.pl commands template.html.in .
|
||||
|
||||
clean:
|
||||
for i in $(SOURCES); do \
|
||||
rm -f `basename $$i`.src `basename $$i`.html; \
|
||||
done;
|
||||
|
||||
push:
|
||||
scp *.html [email protected]:/web/cvsmodules/mono
|
||||
|
||||
push2:
|
||||
scp *.html primates:public_html/xxx
|
||||
@@ -0,0 +1,73 @@
|
||||
#!/usr/bin/perl
|
||||
#
|
||||
# Author:
|
||||
# Sean MacIsaac
|
||||
#
|
||||
|
||||
use strict;
|
||||
|
||||
my $full_expand = 1;
|
||||
my @template;
|
||||
my $n;
|
||||
|
||||
if ($#ARGV != 2) {
|
||||
print "process.pl command_file template_file directory_prefix\n";
|
||||
exit ();
|
||||
}
|
||||
|
||||
my $menu = "";
|
||||
|
||||
open COMMANDS, $ARGV[0] || die "Can not open $ARGV[0]";
|
||||
while (<COMMANDS>) {
|
||||
chop;
|
||||
my @command = split /,/;
|
||||
if ($command[0] != -1) {
|
||||
$menu .= "\t\t";
|
||||
if ($command[0] == 0){
|
||||
$menu .= "<tr><td valign=\"top\" class=\"navi\"><a class=\"navi\"";
|
||||
} else {
|
||||
$menu .= "<tr><td valign=\"top\" class=\"subnavi\">  <a class=\"subnavi\"";
|
||||
}
|
||||
$menu .= "HREF=\"$command[2]\">$command[1]</A></td></tr>\n\n";
|
||||
}
|
||||
}
|
||||
close COMMANDS;
|
||||
|
||||
open TEMPLATE, $ARGV[1] || die "Can not open $ARGV[1]";
|
||||
while (<TEMPLATE>) {
|
||||
push @template, $_;
|
||||
}
|
||||
close TEMPLATE;
|
||||
|
||||
open COMMANDS, $ARGV[0] || die "Can not open $ARGV[0]";
|
||||
while (<COMMANDS>) {
|
||||
chop;
|
||||
my @command = split /,/;
|
||||
|
||||
$n = $ARGV[2] . "/" . $command[2];
|
||||
open OUTPUT, ">" . $n || die "Can not create $n";
|
||||
|
||||
my $content = "";
|
||||
open INPUT, $command[3] || die "Can not open $command[3]";
|
||||
while (<INPUT>) {
|
||||
$content .= $_;
|
||||
}
|
||||
close INPUT;
|
||||
|
||||
my $line;
|
||||
my $temp;
|
||||
my $tit;
|
||||
my $title;
|
||||
|
||||
$tit = $command[1];
|
||||
foreach $line (@template) {
|
||||
$temp = $line;
|
||||
$title = "$tit / Mono";
|
||||
$temp =~ s/#TITLE#/$title/;
|
||||
$temp =~ s/#CONTENT#/$content/;
|
||||
$temp =~ s/#MENU#/$menu/;
|
||||
print OUTPUT $temp;
|
||||
}
|
||||
|
||||
close OUTPUT;
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
<html>
|
||||
<head>
|
||||
<title>#TITLE#</title>
|
||||
<style type="text/css">
|
||||
<!--
|
||||
body { font-family: "trebuchet ms", lucida, verdana, helvetica;
|
||||
background-image: url("images/bgsquares.gif");
|
||||
background-attachment: fixed; }
|
||||
body, td, table { font-family: "trebuchet ms", lucida, verdana, helvetica;
|
||||
font-size: 12px; }
|
||||
|
||||
.navi { font-size: 14px; background: #444444; }
|
||||
.subnavi { font-size: 12px; }
|
||||
.footnote { font-size: 10px; color: #aaaaaa; }
|
||||
|
||||
a.navi { color: #ffffff; text-decoration: none; font-weight: bold; }
|
||||
a.navi:visited { color: #cccccc; }
|
||||
a.navi:hover { color: #ee9900; text-decoration: underline; }
|
||||
|
||||
a.subnavi { color: #ffffff; text-decoration: none; font-weight: bold; }
|
||||
a.subnavi:visited { color: #cccccc; }
|
||||
a.subnavi:hover { color: #ee9900; text-decoration: underline; }
|
||||
|
||||
// -->
|
||||
</style>
|
||||
</head>
|
||||
<body bgcolor="#555555" text="#000000">
|
||||
|
||||
<table cellpadding="0" cellspacing="0" border="0" width="100%">
|
||||
<tr>
|
||||
<td><img src="images/pixel.gif"></td><!-- left border -->
|
||||
<td colspan="4">
|
||||
<a href="/"><img src="images/mono.gif" border="0"></a></td>
|
||||
<td><img src="images/pixel.gif"></td><!-- right border -->
|
||||
</tr>
|
||||
<tr>
|
||||
<td><img src="images/pixel.gif" width="1" height="1"></td>
|
||||
<td colspan="3" bgcolor="black"><img src="images/pixel.gif" height="2"></td>
|
||||
<td bgcolor="black"><img src="images/pixel.gif" width="1"></td>
|
||||
<td><img src="images/pixel.gif"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td width="100"><img src="images/pixel.gif"></td>
|
||||
<td valign="top">
|
||||
<table cellpadding="2" valign="top" cellspacing="0" border="0">
|
||||
#MENU#
|
||||
</table>
|
||||
</td>
|
||||
<td bgcolor="black" width="1"><img src="images/pixel.gif" width="1"></td>
|
||||
<td bgcolor="white" align="left" width="80%" valign="top">
|
||||
<table cellpadding="16">
|
||||
<tr><td>
|
||||
#CONTENT#
|
||||
</td></tr>
|
||||
</table>
|
||||
</td>
|
||||
<td bgcolor="black"><img src="images/pixel.gif" width="1"></td>
|
||||
<td width="100"><img src="images/pixel.gif"></td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td colspan="2">
|
||||
<img src="images/pixel.gif"></td>
|
||||
<td colspan="2" bgcolor="black"><img src="images/pixel.gif" height="1"></td>
|
||||
<td bgcolor="black"><img src="images/pixel.gif" width="1"></td>
|
||||
<td><img src="images/pixel.gif"></td>
|
||||
</tr>
|
||||
|
||||
<td colspan="2"></td>
|
||||
<td colspan="2" align="center">
|
||||
<a class="footnote" href="mailto: [email protected]">[email protected]</a>
|
||||
</td>
|
||||
<td colspan="2"></td>
|
||||
</tr>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
@@ -1,15 +0,0 @@
|
||||
EXTRA_DIST = \
|
||||
aot-compiler.txt \
|
||||
assembly-bundle \
|
||||
embedded-api \
|
||||
exceptions \
|
||||
gc-issues \
|
||||
jit-thoughts \
|
||||
jit-trampolines \
|
||||
local-regalloc.txt \
|
||||
mini-doc.txt \
|
||||
mini-porting.txt \
|
||||
opcode-decomp.txt \
|
||||
object-layout \
|
||||
unmanaged-calls \
|
||||
stack-alignment
|
||||
@@ -1,525 +0,0 @@
|
||||
|
||||
Here "abc" stays for "array bounds check", or "array bound checks", or
|
||||
some combination of the two...
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
USAGE
|
||||
|
||||
Simply use the "abcrem" optimization invoking mono.
|
||||
|
||||
To see if bound checks are actually removed, use "mono -v" and grep for
|
||||
"ARRAY-ACCESS" in the output, there should be a message for each check
|
||||
that has been removed.
|
||||
|
||||
To trace the algorithm execution, use "-v -v -v", and be prepared to be
|
||||
totally submersed by debugging messages...
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
EFFECTIVENESS
|
||||
|
||||
The abc removal code can now always remove bound checks from "clean"
|
||||
array scans in loops, and generally anyway there are clear conditions that
|
||||
already state that the index is "safe".
|
||||
|
||||
To be clearer, and give an idea of what the algorithm can and cannot do
|
||||
without describing it in detail... keep in mind that only "redunant" checks
|
||||
cannot be removed. By "redundant", I mean "already explicitly checked" in
|
||||
the method code.
|
||||
|
||||
Unfortunately, analyzing complex expressions is not so easy (see below for
|
||||
details), so the capabilities of this "abc remover" are limited.
|
||||
|
||||
These are simple guidelines:
|
||||
- Only simple comparisons between variables are understood.
|
||||
- Only increment-decrement operations are handled.
|
||||
- "switch" statements are not yet handled.
|
||||
|
||||
This means that code like this will be handled well:
|
||||
|
||||
for (int i = 0; i < a.Length; i++) {
|
||||
a [i] = .....
|
||||
}
|
||||
|
||||
The "i" variable could be declared out of the "for", the "for" could be a
|
||||
"while", and maybe even implemented with "goto", the array could be scanned
|
||||
in reverse order, and everything would still work.
|
||||
I could have a temporary variable storing the array length, and check on
|
||||
it inside the loop, and the abc removal would still occurr, like this:
|
||||
|
||||
int i = 0;
|
||||
int l = a.Length;
|
||||
while ( i < l ) {
|
||||
a [i] ......
|
||||
}
|
||||
|
||||
or this:
|
||||
|
||||
int l = a.Length;
|
||||
for (int i = l; i > 0; i--) {
|
||||
a [i] = .....
|
||||
}
|
||||
|
||||
|
||||
But just something like this
|
||||
|
||||
for (int i = 0; i < (a.Length -1); i++) .....
|
||||
|
||||
or like this
|
||||
|
||||
for (int i = 0; i < a.Length; i += 2) .....
|
||||
|
||||
would not work, the check would stay there, sorry :-(
|
||||
|
||||
Just to make you understand how things are tricky... this would work!
|
||||
|
||||
int limit = a.Length - 1;
|
||||
for (int i = 0; i < limit; i++) {
|
||||
a [i] = .....
|
||||
}
|
||||
|
||||
|
||||
A detailed explanation of the reason why things are done like this is given
|
||||
below...
|
||||
|
||||
All in all, the compiling phase is generally non so fast, and the abc removed
|
||||
are so few, that there is hardly a performance gain in using the "abcrem"
|
||||
flag in the compiling options for short programs like the ones I tried.
|
||||
|
||||
Anyway, various bound checks *are* removed, and this is good :-)
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
THE ALGORITHM
|
||||
|
||||
Unfortunately, this time google has not been my friend, and I did not
|
||||
find an algorithm I could reasonably implement in the time frame I had,
|
||||
so I had to invent one. The two cleasses of algorithms I found were either
|
||||
simply an analisys of variable ranges (which is not very different from
|
||||
what I'm doing), or they were based on type systems richer than the .NET
|
||||
one (particularly, they required integer types to have an explicit range,
|
||||
which could be related to array ranges). By the way, it seems that the
|
||||
gcj people do not have an array bound check removal optimization (they
|
||||
just have a compiler flag that unconditionally removes all the checks,
|
||||
but this is not what we want).
|
||||
|
||||
This array bound check removal (abc removal) algorithm is based on
|
||||
symbolic execution concepts. I handle the removal like an "unreachable
|
||||
code elimination" (and in fact the optimization could be extended to remove
|
||||
also other unreachable sections of code, due to branches that "always go the
|
||||
same way").
|
||||
|
||||
In symbolic execution, variables do not have actual (numeric) values, but
|
||||
instead symbolic expressions (like "a", or "x+y").
|
||||
Also, branch conditions are handled like symbolic conditions (like "i<k"),
|
||||
which state relations between variable values.
|
||||
|
||||
The SSA representation inside mini is somewhat close to a symbolic
|
||||
representation of the execution of the compiled method.
|
||||
Particularly, the representation of variable values is exactly a symbolic
|
||||
one. It is enough to find all CEE_STIND_* instructions which store to a
|
||||
local variable, and their second argument is exactly the variable value.
|
||||
Actually, "cfg->vars [<variable-index>]->def" should contain exactly
|
||||
those store instructions, and the "get_variable_value_from_ssa_store"
|
||||
function extracts the variable value from there.
|
||||
|
||||
On the other hand, the conditions under which each basic block is
|
||||
executed are not made fully explicit.
|
||||
|
||||
However, it is not difficult to make them so.
|
||||
Each BB that has more than one exit BB, in practice must end either with
|
||||
a conditional branch instruction or with a switch instruction.
|
||||
In the first case, the BB has exactly two exit BBs, and their execution
|
||||
conditions are easy to get from the condition of the branch (see the
|
||||
"get_relation_from_branch_instruction" function, and expecially the end of
|
||||
"analyze_block" in abcremoval.c.
|
||||
If there is a switch, the jump condition of every exit BB is the equality
|
||||
of the switch argument with the particular index associated with its case
|
||||
(but the current implementation does not handle switch statements yet).
|
||||
|
||||
These individual conditions are in practice associated to each arc that
|
||||
connects BBs in the CFG (with the simple case that unconditional branches
|
||||
have a "TRUE" condition, because they always happen).
|
||||
|
||||
So, for each BB, its *proper* entry condition is the union of all the
|
||||
conditions associated to arcs that enter the BB. The "union" is like a
|
||||
logical "or", in the sense that either of the condition could be true,
|
||||
they are not necessarily all true. This means that if I can enter a BB
|
||||
in two ways, and in one case I know that "x>0", and in the other that
|
||||
"x==0", actually in the BB I know that "x>=0", which is a weaker
|
||||
condition (the union of the two).
|
||||
|
||||
Also, the *complete* entry condition for a BB is the "intersection" of all
|
||||
the entry conditions of its dominators. This is true because each dominator
|
||||
is the only way to reach the BB, so the entry condition of each dominator
|
||||
must be true if the control flow reached the BB. This translates to the
|
||||
logical "and" of all the "proper" conditions of the BBs met walking up in the
|
||||
dominator tree. So, if one says "x>0", and another "x==1", then I know
|
||||
that "x==1", which is a stronger condition (the intersection of the two).
|
||||
Note that, if the two conditions were "x>0" and "x==0", then the block would
|
||||
be unreachable (the intersection is empty), because some branch is impossible.
|
||||
|
||||
Another observation is that, inside each BB, every variable is subject to the
|
||||
complete entry condition of that very same BB, and not the one in which it is
|
||||
defined (with the "complete entry condition" being the thing I defined before,
|
||||
sorry if these terms "proper" and "complete" are strange, I found nothing
|
||||
better).
|
||||
This happens because the branch conditions are related to the control flow.
|
||||
I can define "i=a", and if I am in a BB where "a>0", then "i>0", but not
|
||||
otherwise.
|
||||
|
||||
So, intuitively, if the available conditions say "i>=0", and i is used as an
|
||||
index in an array access, then the lower bound check can be omitted.
|
||||
If the condition also says "(i>=0)&&(i<array.length)", the abc removal can
|
||||
occur.
|
||||
|
||||
So, a complete solution to the problem of abc removal would be the following:
|
||||
for each array access, build a system of equations containing:
|
||||
[1] all the symbolic variable definitions
|
||||
[2] the complete entry condition of the BB in which the array access occurs
|
||||
[3] the two "goal functions" ("index >=0" and "index < array.length")
|
||||
If the system is valid for *each possible* variable value, then the goal
|
||||
functions are always true, and the abc can be removed.
|
||||
|
||||
All this discussion is useful to give a precise specification to the problem
|
||||
we are trying to solve.
|
||||
The trouble is that, in the general case, the resulting system of equations
|
||||
is like a predicate in first order logic, which is semi-decidable, and its
|
||||
general solution is anyway too complex to be attempted in a JIT compiler
|
||||
(which should not contain a full fledged theorem prover).
|
||||
|
||||
Therefore, we must cut some corner.
|
||||
|
||||
|
||||
By the way, there is also another big problem, which is caused by "recursive"
|
||||
symbolic definitions. These definition can (and generally do) happen every
|
||||
time there is a loop. For instance, in the following piece of code
|
||||
|
||||
for ( int i = 0; i < array.length; i++ ) {
|
||||
Console.WriteLine( "array [i] = " + array [i] );
|
||||
}
|
||||
|
||||
one of the definitions of i is a PHI that can be either 0 or "i + 1".
|
||||
|
||||
Now, we know that mathematically "i = i + 1" does not make sense, and in
|
||||
fact symbolic values are not "equations", they are "symbolic definitions".
|
||||
|
||||
The symbolic value of i is a generic "n", where "n" is the number of
|
||||
iterations of the loop, but this is terrible to handle (and in more complex
|
||||
examples the symbolic definition of i simply cannot be written, because i is
|
||||
calculated in an iterative way).
|
||||
|
||||
However, the definition "i = i + 1" tells us something about i: it tells us
|
||||
that i "grows". So (from the PHI definition) we know that i is either 0, or
|
||||
"grows". This is enough to tell that "i>=0", which is what we want!
|
||||
It is important to note that recursive definitions can only occurr inside
|
||||
PHI definitions, because actually a variable cannot be defined *only* in terms
|
||||
of itself!
|
||||
|
||||
|
||||
At this point, I can explain which corners I want to cut to make the
|
||||
problem solvable. It will not remove all the abc that could theoretically
|
||||
be removed, but at least it will work.
|
||||
|
||||
The easiest way to cut corners is to only handle expressions which are
|
||||
"reasonably simple", and ignore the rest.
|
||||
Keep in mind that ignoring an expression is not harmful in itself.
|
||||
The algorithm will be simply "less powerful", because it will ignore
|
||||
conditions that could have caused to the removal of an abc, but will
|
||||
not remove checks "by mistake" (so the resulting code will be in any case
|
||||
correct).
|
||||
|
||||
In a first attempt, we can consider only conditions that have the simple
|
||||
possible form, which is "(compare simpleExpression simpleExpression)",
|
||||
where "simpleExpression" is either "(ldind.* local[*])" or
|
||||
"(ldlen (ldind.ref local[*]))" (or a constant, of course).
|
||||
|
||||
We can also "summarize" variable definitions, keeping only what is relevant
|
||||
to know: if they are greater or smaller than zero or other variables.
|
||||
|
||||
One particular note on PHI functions: they work (obviously) like the logical
|
||||
"or" of their definitions, and therefore are equivalent to the "logical or"
|
||||
of the summarization of their definitions.
|
||||
|
||||
About recursive definitions (which, believe me, are the worst thing in all
|
||||
this mess), we handle only "monotonic" ones. That is, we try to understand
|
||||
if the recursive definition (which, as we said above, must happen because
|
||||
of a loop) always "grows" or "gets smaller". In all other cases, we decide
|
||||
we cannot handle it.
|
||||
|
||||
So, the algorithm to optimize one method could be something like:
|
||||
|
||||
[1] Build the SSA representation.
|
||||
[2] Analyze each BB. Particularly, do the following:
|
||||
[2a] summarize its exit conditions
|
||||
[2b] summarize all the variable definitions occurring in the BB
|
||||
[2c] check if it contains array accesses (only as optimization, so that
|
||||
step 3 will be performed only when necessary)
|
||||
[3] Perform the removal. For each BB that contains array accesses, do:
|
||||
[3a] build an evaluation area where for each variable we keep track
|
||||
of its relations with zero and with each other variable.
|
||||
[3b] populate the evaluation area with the initial data (the variable
|
||||
definitions and the complete entry condition of the BB)
|
||||
[3c] propagate the relations between variables (so that from "a<b" and
|
||||
"b<c" we know that "a<c") in the evaluation area
|
||||
[3d] for each array access in the BB, use the evaluation area to "match
|
||||
conditions", to see if the goal functions are satisfied
|
||||
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
LOW LEVEL DESIGN DECISIONS
|
||||
|
||||
One of the problems I had to solve was the representation of the relations
|
||||
between symbolic values.
|
||||
The "canonical" solution would be to have a complex, potentially recursive
|
||||
data structure, somewhat similar to MonoInst, and use it all the time (maybe
|
||||
MonoInst could be used "as is").
|
||||
The problem is that, at this point, the software would have to "play" with
|
||||
these structures, for instance to deduce "b < a-1" from "a > b+1", because we
|
||||
are interested in what value b has, and not a. And maybe the software should
|
||||
be able to do this without modifying the original condition, because it was
|
||||
used elsewhere (or could be reused).
|
||||
Then, the software should also be able to apply logical relations to
|
||||
conditions (like "(a>0)||(c<1)"), and manipulate them, too.
|
||||
|
||||
In my opinion, an optimizer written in this way risks to be too complex, and
|
||||
its performance not acceptable in a JIT compiler.
|
||||
Therefore, I decided to represent values in a "summarized" way.
|
||||
For instance, "x = a + 1" becomes "x > a" (and, by the way, "x = x + 1"
|
||||
would look like "x > x", which means that "x grows").
|
||||
So, each variable value is simply a "relation" of the variable with other
|
||||
variables or constants. Anything more complex is ignored.
|
||||
Relations are represented with flags (EQ, LT and GT), so that it is easy
|
||||
to combine them logically (it is enough to perform the bitwise operations
|
||||
on the flags). The condition (EQ|LT|GT) means we know nothing special, any
|
||||
value is possible. The empty condition would mean an unreachable statement
|
||||
(because no value is acceptable).
|
||||
|
||||
There is still the problem of identifying variables, and where to store all
|
||||
these relations. After some thinking, I decided that a "brute force" approach
|
||||
is the easier, and probably also the fastest. In practice, I keep in memory
|
||||
an array of "variable relations", where for each variable I record its
|
||||
relation with the constants 0 and 1 and an array of its relations with all
|
||||
other variables. The evaluation area, therefore, looks like a square matrix
|
||||
as large as the number of variables. I *know* that the matrix is rather sparse
|
||||
(in the sense that only few of its cells are significant), but I decided that
|
||||
this data structure was the simplest and more efficient anyway. After all,
|
||||
each cell takes just one byte, and any other data structure must be some
|
||||
kind of associative array (like a g_hash_table). Such a data structue is
|
||||
difficult to use with a MonoMemPool, and in the end is slower than a plain
|
||||
array, and has the storage overhead of all the pointers... in the end, maybe
|
||||
the full matrix is not a waste at all.
|
||||
<note>
|
||||
After a few benchmarks, I clearly see that the matrix works well if the
|
||||
variables are not too much, otherwise it gets "too sparse", and much time
|
||||
is wasted in the propagation phase. Maybe the data structure could be changed
|
||||
after a more careful evaluation of the problem...
|
||||
</note>
|
||||
|
||||
With these assumptions, all the memory used to represent values, conditions
|
||||
and the evaluation area can be allocated in advance (from a MonoMemPool), and
|
||||
used for all the analysis of one method. Moreover, the performance of logical
|
||||
operations is high (they are simple bitwise operations on bytes).
|
||||
<note>
|
||||
For the propagation phase, there was a function I could not easily code
|
||||
with bitwise operations. As that phase is a real pain for the performance
|
||||
(the complexity is quadratic, and it must be executed iteratively until
|
||||
nothing changes), I decided to code it in perl, and generate a precomputed
|
||||
table then used by the C code (just 64 bytes). I think this is faster than
|
||||
all those branches... Really, I could think again to phases 3c and 3d (see
|
||||
above), maybe there is a better way to do them.
|
||||
</note>
|
||||
|
||||
Of course not all expressions can be handled by the summarization, so the
|
||||
optimizer is not as effective as a full blown theorem prover...
|
||||
|
||||
Another thing related to design... the implementation is as less intrusive
|
||||
as possible.
|
||||
I "patched" the main files to add an option for abc removal, and handle it
|
||||
just like any other option, and then wrote all the relevant code in two
|
||||
separated files (one header for data structures, and a C file for the code).
|
||||
If the patch turns out to be useful also for other pourposes (like a more
|
||||
generic "unreachable code elimination", that detects branches that will never
|
||||
be taken using the analysis of variable values), it will not be difficult
|
||||
to integrate the branch summarizations into the BasicBlock data structures,
|
||||
and so on.
|
||||
|
||||
One last thing... in some places, I knowingly coded in an inefficient way.
|
||||
For instance, "remove_abc_from_block" does something only if the flag
|
||||
"has_array_access_instructions" is true, but I call it anyway, letting it
|
||||
do nothing (calling it conditionally would be better). There are several
|
||||
things like this in the code, but I was in a hurry, and preferred to make
|
||||
the code more readable (it is already difficult to understand as it is).
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
WHEN IS ABC REMOVAL POSSIBLE? WHEN IS IT USEFUL?
|
||||
|
||||
Warning! Random ideas ahead!
|
||||
|
||||
In general, managed code should be safe, so abc removal is possible only if
|
||||
there already is some branch in the method that does the check.
|
||||
So, one check on the index is "mandatory", the abc removal can only avoid a
|
||||
second one (which is useless *because* of the first one).
|
||||
If in the code there is not a conditional branch that "avoids" to access
|
||||
an array out of its bounds, in general the abc removal cannot occur.
|
||||
|
||||
It could happen, however, that one method is called from another one, and
|
||||
the check on the index is performed in the caller.
|
||||
|
||||
For instance:
|
||||
|
||||
void
|
||||
caller( int[] a, int n ) {
|
||||
if ( n <= a.Length ) {
|
||||
for ( int i = 0; i < n; i++ ) {
|
||||
callee( a, i );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void callee( int[] a, int i ) {
|
||||
Console.WriteLine( "a [i] = " + a [i] );
|
||||
}
|
||||
|
||||
|
||||
In this case, it should be possible to have two versions of the callee, one
|
||||
without checks, to be called from methods that do the check themselves, and
|
||||
another to be called otherwise.
|
||||
This kind of optimization could be profile driven: if one method is executed
|
||||
several times, wastes CPU time for bound checks, and is mostly called from
|
||||
another one, it could make sense to analyze the situation in detail.
|
||||
|
||||
However, one simple way to perform this optimization would be to inline
|
||||
the callee (so that the abc removal algorithm can see both methods at once).
|
||||
|
||||
The biggest benefits of abc removal can be seen for array accesses that
|
||||
occur "often", like the ones inside inner loops. This is why I tried to
|
||||
handle "recursive" variable definitions, because without them you cannot
|
||||
optimize inside loops, which is also where you need it most.
|
||||
|
||||
Another possible optimization (alwais related to loops) is the following:
|
||||
|
||||
void method( int[] a, int n ) {
|
||||
for ( int i = 0; i < n; i++ ) {
|
||||
Console.WriteLine( "a [i] = " + a [i] );
|
||||
}
|
||||
}
|
||||
|
||||
In this case, the check on n is missing, so the abc could not be removed.
|
||||
However, this would mean that i will be checked twice at each loop iteration,
|
||||
one against n, and the other against a.Length. The code could be transformed
|
||||
like this:
|
||||
|
||||
void method( int[] a, int n ) {
|
||||
if ( n < a.Length ) {
|
||||
for ( int i = 0; i < n; i++ ) {
|
||||
Console.WriteLine( "a [i] = " + a [i] ); // Remove abc
|
||||
}
|
||||
} else {
|
||||
for ( int i = 0; i < n; i++ ) {
|
||||
Console.WriteLine( "a [i] = " + a [i] ); // Leave abc
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
This could result in performance improvements (again, probably this
|
||||
optimization should be profile driven).
|
||||
|
||||
------------------------------------------------------------------------------
|
||||
OPEN ISSUES
|
||||
|
||||
There are several issues that should still be addressed...
|
||||
|
||||
One is related to aliasing. For now, I decided to operate only on local
|
||||
variables, and ignore aliasing problems (and alias analisys has not yet
|
||||
been implemented anyway).
|
||||
Actually, I identified the local arrays with their length, because I
|
||||
totally ignore the contents of arrays (and objects in general).
|
||||
|
||||
Also, in several places in the code I only handle some cases, and ignore
|
||||
other more complex ones, which could anyway work (there are comments where
|
||||
this happens). Anyway, this is not harmful (the code is not as effective
|
||||
as it could be).
|
||||
|
||||
Another possible improvement is the explicit handling of all constants.
|
||||
For now, code like
|
||||
|
||||
void
|
||||
method () {
|
||||
int[] a = new int [16];
|
||||
for ( int i = 0; i < 16; i++ ) {
|
||||
a [i] = i;
|
||||
}
|
||||
}
|
||||
|
||||
is not handled, because the two constants "16" are lost when variable
|
||||
relations are summarized (actually they are not lost, they are stored in the
|
||||
summarized values, but they are not yet used correctly).
|
||||
|
||||
The worst thing, anyway, is that for now I fail completely in distinguishing
|
||||
between signed and unsigned variables/operations/conditions, and between
|
||||
different integer sizes (in bytes). I did this on pourpose, just for lack of
|
||||
time, but this can turn out to be terribly wrong.
|
||||
The problem is caused by the fact that I handle arithmetical operations and
|
||||
conditions as "ideal" operations, but actually they can overflow and/or
|
||||
underflow, giving "surprising" results.
|
||||
|
||||
For instance, look at the following two methods:
|
||||
|
||||
public static void testSignedOverflow()
|
||||
{
|
||||
Console.WriteLine( "Testing signed overflow..." );
|
||||
int[] ia = new int[70000];
|
||||
int i = 1;
|
||||
while ( i <ia.Length )
|
||||
{
|
||||
try
|
||||
{
|
||||
Console.WriteLine( " i = " + i );
|
||||
ia[i] = i;
|
||||
}
|
||||
catch ( IndexOutOfRangeException e )
|
||||
{
|
||||
Console.WriteLine( "Yes, we had an overflow (i = " + i + ")" );
|
||||
}
|
||||
i *= 60000;
|
||||
}
|
||||
Console.WriteLine( "Testing signed overflow done." );
|
||||
}
|
||||
|
||||
public static void testUnsignedOverflow()
|
||||
{
|
||||
Console.WriteLine( "Testing unsigned overflow..." );
|
||||
int[] ia = new int[70000];
|
||||
uint i = 1;
|
||||
while ( i <ia.Length )
|
||||
{
|
||||
try
|
||||
{
|
||||
Console.WriteLine( " i = " + i );
|
||||
ia[i] = (int) i;
|
||||
}
|
||||
catch ( IndexOutOfRangeException e )
|
||||
{
|
||||
Console.WriteLine( "Yes, we had an overflow (i = " + i + ")" );
|
||||
}
|
||||
i *= 60000;
|
||||
}
|
||||
Console.WriteLine( "Testing unsigned overflow done." );
|
||||
}
|
||||
|
||||
In the "testSignedOverflow" method, the exception will be thrown, while
|
||||
in the "testUnsignedOverflow" everything will go on smoothly.
|
||||
The problem is that the test "i <ia.Length" is a signed comparison in the
|
||||
first case, and will not exit from the loop if the index is negative.
|
||||
Therefore, in the first method, the abc should not be removed.
|
||||
|
||||
In practice, the abc removal code should try to predict if any given
|
||||
expression could over/under-flow, and act accordingly.
|
||||
For now, I made so that the only accepted expressions are plain increments
|
||||
and decrements of variables (which cannot over/under-flow without being
|
||||
trapped by the existing conditions). Anyway, this issue should be analyzed
|
||||
better.
|
||||
By the way, in summarizations there is a field that keeps track of the
|
||||
relation with "1", which I planned to use exactly to summarize products and
|
||||
quotients, but it is never used (as I said, only increment and decrement
|
||||
operations are properly summarized).
|
||||
|
||||
@@ -1,44 +0,0 @@
|
||||
Mono Ahead Of Time Compiler
|
||||
===========================
|
||||
|
||||
The new mono JIT has sophisticated optimization features. It uses SSA and has a
|
||||
pluggable architecture for further optimizations. This makes it possible and
|
||||
efficient to use the JIT also for AOT compilation.
|
||||
|
||||
|
||||
* file format: We use the native object format of the platform. That way it is
|
||||
possible to reuse existing tools like objdump and the dynamic loader. All we
|
||||
need is a working assembler, i.e. we write out a text file which is then
|
||||
passed to gas (the gnu assembler) to generate the object file.
|
||||
|
||||
* file names: we simply add ".so" to the generated file. For example:
|
||||
basic.exe -> basic.exe.so
|
||||
corlib.dll -> corlib.dll.so
|
||||
|
||||
* staring the AOT compiler: mini --aot assembly_name
|
||||
|
||||
The following things are saved in the object file:
|
||||
|
||||
* version infos:
|
||||
|
||||
* native code: this is labeled with method_XXXXXXXX: where XXXXXXXX is the
|
||||
hexadecimal token number of the method.
|
||||
|
||||
* additional informations needed by the runtime: For example we need to store
|
||||
the code length and the exception tables. We also need a way to patch
|
||||
constants only available at runtime (for example vtable and class
|
||||
addresses). This is stored i a binary blob labeled method_info_XXXXXXXX:
|
||||
|
||||
PROBLEMS:
|
||||
|
||||
- all precompiled methods must be domain independent, or we add patch infos to
|
||||
patch the target doamin.
|
||||
|
||||
- the main problem is how to patch runtime related addresses, for example:
|
||||
|
||||
- current application domain
|
||||
- string objects loaded with LDSTR
|
||||
- address of MonoClass data
|
||||
- static field offsets
|
||||
- method addreses
|
||||
- virtual function and interface slots
|
||||
@@ -1,57 +0,0 @@
|
||||
|
||||
HOWTO bundle assemblies inside the mono runtime.
|
||||
Paolo Molaro ([email protected])
|
||||
|
||||
* Intent
|
||||
|
||||
Bundling assemblies inside the mono runtime may be useful for a number
|
||||
of reasons:
|
||||
|
||||
* creating a standalone complete runtime that can be more easily
|
||||
distributed
|
||||
|
||||
* having an application run against a known set of assemblies
|
||||
that has been tested
|
||||
|
||||
Of course, there are drawbacks, too: if there has been fixes
|
||||
to the assemblies, replacing them means recompiling the
|
||||
runtime as well and if there are other mono apps, unless they
|
||||
use the same mono binary, there will be less opportunities for
|
||||
the operating system to optimize memory usage. So use this
|
||||
feature only when really needed.
|
||||
|
||||
* Creating the Bundle
|
||||
|
||||
To bundle a set of assemblies, you need to create a file that
|
||||
lists the assembly names and the relative files. Empty lines
|
||||
and lines starting with # are ignored:
|
||||
|
||||
== cut cut ==
|
||||
# Sample bundle template
|
||||
mscorlib: /path/to/mscorlib/assembly.dll
|
||||
myapp: /path/to/myapp.exe
|
||||
== cut cut ==
|
||||
|
||||
Next you need to build the mono runtime using a special configure option:
|
||||
|
||||
./configure --with-bundle=/path/to/bundle/template
|
||||
|
||||
The path to the template should be an absolute path.
|
||||
|
||||
The script metadata/make-bundle.pl will take the specifie
|
||||
assemblies and embed them inside the runtime where the loading
|
||||
routines can find them before searching for them on disk.
|
||||
|
||||
* Open Issues
|
||||
|
||||
There are still two issues to solve:
|
||||
|
||||
* config files: sometimes they are needed but they are
|
||||
not yet bundled inside the library ()
|
||||
|
||||
* building with the included libgc makes it not
|
||||
possible to build a mono binary statically linked to
|
||||
libmono: this needs to be fixed to make bundles
|
||||
really useful.
|
||||
|
||||
|
||||
@@ -1,271 +0,0 @@
|
||||
|
||||
Embedding the Mono runtime, preliminary version
|
||||
Miguel de Icaza ([email protected]),
|
||||
Paolo Molaro ([email protected])
|
||||
|
||||
This document describes how to embed the Mono runtime in your
|
||||
application, and how to invoke CIL methods from C, and how to
|
||||
invoke C code from CIL. Both the JIT and interpreter can be
|
||||
embedded in very similar ways so most of what is described
|
||||
here can be used in either case.
|
||||
|
||||
* Embedding the runtime.
|
||||
|
||||
Embedding the runtime consists of various steps:
|
||||
|
||||
* Compiling and linking the Mono runtime
|
||||
|
||||
* Initializing the Mono runtime
|
||||
|
||||
* Optionally expose C code to the C#/CIL universe.
|
||||
|
||||
These are discussed in detail next.
|
||||
|
||||
** Compiling and Linking
|
||||
|
||||
To embed the runtime, you have to link your code against the
|
||||
Mono runtime libraries. To do this, you want to pass the
|
||||
flags returned by pkg-config to your compiler:
|
||||
|
||||
pkg-config --cflags --libs mono
|
||||
|
||||
is used to get the flags for the JIT runtime and
|
||||
|
||||
pkg-config --cflags --libs mint
|
||||
|
||||
for the interpreted runtime.
|
||||
|
||||
Like this:
|
||||
|
||||
gcc sample.c `pkg-config --cflags --libs mono`
|
||||
|
||||
You can separate the compilation flags from the linking flags, for
|
||||
instance, you can use the following macros in your makefile:
|
||||
|
||||
CFLAGS=`pkg-config --cflags mono`
|
||||
LDFLAGS=`pkg-config --libs mono`
|
||||
|
||||
** Initializing the Mono runtime
|
||||
|
||||
To initialize the JIT runtime, call mono_jit_init, like this:
|
||||
|
||||
#include <mono/mini/jit.h>
|
||||
|
||||
MonoDomain *domain;
|
||||
|
||||
domain = mono_jit_init ("domain-name");
|
||||
|
||||
For the interpreted runtime use mono_interp_init instead:
|
||||
|
||||
#include <mono/interpreter/embed.h>
|
||||
|
||||
MonoDomain *domain;
|
||||
|
||||
domain = mono_interp_init ("domain-name");
|
||||
|
||||
That will return a MonoDomain where your code will be
|
||||
executed. You can create multiple domains. Each domain is
|
||||
isolated from the other domains and code in one domain will
|
||||
not interfere with code in other domains. This is useful if
|
||||
you want to host different applications in your program.
|
||||
|
||||
Then you can load an assembly containing code into the domain:
|
||||
|
||||
MonoAssembly *assembly;
|
||||
|
||||
assembly = mono_domain_assembly_open (domain, "file.dll");
|
||||
if (!assembly)
|
||||
error ();
|
||||
|
||||
In the above example, the contents of `file.dll' will be
|
||||
loaded into the domain. This only loads the code, but it will
|
||||
not execute anything yet. You can replace `file.dll' with
|
||||
another transport file, like `file.exe'
|
||||
|
||||
To start executing code, you must invoke a method in the
|
||||
assembly, or if you have provided a static Main method (an
|
||||
entry point), you can use the convenience function:
|
||||
|
||||
retval = mono_jit_exec (domain, assembly, argc - 1, argv + 1);
|
||||
|
||||
or when using the interpreter use:
|
||||
|
||||
retval = mono_interp_exec (domain, assembly, argc - 1, argv + 1);
|
||||
|
||||
If you want to invoke a different method, look at the
|
||||
`Invoking Methods in the CIL universe' section later on.
|
||||
|
||||
** Shutting down the runtime
|
||||
|
||||
To shutdown the Mono runtime, you have to clean up all the
|
||||
domains that were created, use this function:
|
||||
|
||||
mono_jit_cleanup (domain);
|
||||
|
||||
Or in the case of the interpreted runtime use:
|
||||
|
||||
mono_interp_cleanup (domain);
|
||||
|
||||
** Applications that use threads.
|
||||
|
||||
The Boehm GC system needs to catch your calls to the pthreads
|
||||
layer, so in each file where you use pthread.h you should
|
||||
include the <gc/gc.h> file.
|
||||
|
||||
* Exposing C code to the CIL universe
|
||||
|
||||
The Mono runtime provides two mechanisms to expose C code to
|
||||
the CIL universe: internal calls and native C code. Internal
|
||||
calls are tightly integrated with the runtime, and have the
|
||||
least overhead, as they use the same data types that the
|
||||
runtime uses.
|
||||
|
||||
The other option is to use the Platform Invoke (P/Invoke) to
|
||||
call C code from the CIL universe, using the standard P/Invoke
|
||||
mechanisms.
|
||||
|
||||
To register an internal call, use this call in the C code:
|
||||
|
||||
mono_add_internal_call ("Hello::Sample", sample);
|
||||
|
||||
Now, you need to declare this on the C# side:
|
||||
|
||||
using System;
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
class Hello {
|
||||
[MethodImplAttribute(MethodImplOptions.InternalCall)]
|
||||
extern static string Sample ();
|
||||
}
|
||||
|
||||
Since this routine returns a string, here is the C definition:
|
||||
|
||||
static MonoString*
|
||||
Sample ()
|
||||
{
|
||||
return mono_string_new (mono_domain_get (), "Hello!");
|
||||
}
|
||||
|
||||
Notice that we have to return a `MonoString', and we use the
|
||||
`mono_string_new' API call to obtain this from a string.
|
||||
|
||||
* Invoking Methods in the CIL universe
|
||||
|
||||
Calling a method in the CIL universe from C requires a number of steps:
|
||||
|
||||
* Obtaining the MonoMethod handle to the method.
|
||||
|
||||
* The method invocation.
|
||||
|
||||
** Obtaining a MonoMethod
|
||||
|
||||
To get a MonoMethod there are several ways.
|
||||
|
||||
You can get a MonoClass (the structure representing a type)
|
||||
using:
|
||||
|
||||
MonoClass *
|
||||
mono_class_from_name (MonoImage *image, const char* name_space, const char *name);
|
||||
|
||||
and then loop in the returned class method array until you get
|
||||
the one you're looking for. There are examples of such
|
||||
searches as static functions in several C files in
|
||||
metadata/*.c: we need to expose one through the API and remove
|
||||
the duplicates.
|
||||
|
||||
The other, simpler, way is to use the functions in
|
||||
debug-helpers.h: there are examples of their use in monograph,
|
||||
mint and the jit as well. You basically use a string
|
||||
description of the method, like:
|
||||
|
||||
"System.Object:GetHashCode()"
|
||||
|
||||
and create a MonoMethodDesc out of it with:
|
||||
|
||||
MonoMethodDesc* mono_method_desc_new (const char *name, gboolean include_namespace);
|
||||
|
||||
You can then use:
|
||||
|
||||
MonoMethod* mono_method_desc_search_in_class (MonoMethodDesc *desc, MonoClass *klass);
|
||||
MonoMethod* mono_method_desc_search_in_image (MonoMethodDesc *desc, MonoImage *image);
|
||||
|
||||
to search for the method in a class or in an image. You would
|
||||
tipically do this just once at the start of the program and
|
||||
store the result for reuse somewhere.
|
||||
|
||||
** Invoking a Method
|
||||
|
||||
There are two functions to call a managed method:
|
||||
|
||||
MonoObject*
|
||||
mono_runtime_invoke (MonoMethod *method, void *obj, void **params,
|
||||
MonoObject **exc);
|
||||
and
|
||||
MonoObject*
|
||||
mono_runtime_invoke_array (MonoMethod *method, void *obj, MonoArray *params,
|
||||
MonoObject **exc);
|
||||
|
||||
obj is the 'this' pointer, it should be NULL for static
|
||||
methods, a MonoObject* for object instances and a pointer to
|
||||
the value type for value types.
|
||||
|
||||
These functions can be used in both the JIT and the interpreted
|
||||
environments.
|
||||
|
||||
The params array contains the arguments to the method with the
|
||||
same convention: MonoObject* pointers for object instances and
|
||||
pointers to the value type otherwise. The _invoke_array
|
||||
variant takes a C# object[] as the params argument (MonoArray
|
||||
*params): in this case the value types are boxed inside the
|
||||
respective reference representation.
|
||||
|
||||
From unmanaged code you'll usually use the
|
||||
mono_runtime_invoke() variant.
|
||||
|
||||
Note that this function doesn't handle virtual methods for
|
||||
you, it will exec the exact method you pass: we still need to
|
||||
expose a function to lookup the derived class implementation
|
||||
of a virtual method (there are examples of this in the code,
|
||||
though).
|
||||
|
||||
You can pass NULL as the exc argument if you don't want to
|
||||
catch exceptions, otherwise, *exc will be set to the exception
|
||||
thrown, if any. if an exception is thrown, you can't use the
|
||||
MonoObject* result from the function.
|
||||
|
||||
If the method returns a value type, it is boxed in an object
|
||||
reference.
|
||||
|
||||
We have plans for providing an additional method that returns
|
||||
an unmanaged->managed thunk like this:
|
||||
|
||||
void* mono_method_get_unmanaged_thunk (MonoMethod *method);
|
||||
|
||||
You'll be able to store the returned pointer in a function
|
||||
pointer with the proper signature and call that directly from
|
||||
C:
|
||||
|
||||
typedef gint32 (*GetHashCode) (MonoObject *obj);
|
||||
|
||||
GetHashCode func = mono_method_get_unmanaged_thunk (System_Object_GetHashCode_method);
|
||||
|
||||
gint32 hashvalue = func (myobject);
|
||||
|
||||
It may not be possible to manage exceptions in that case,
|
||||
though. I need to think more about it.
|
||||
|
||||
** Threading issues
|
||||
|
||||
If your application creates threads on its own, and you want them to
|
||||
be able to call code into the CIL universe with Mono, you have to
|
||||
register the thread with Mono before issuing the call.
|
||||
|
||||
To do so, call the mono_thread_attach() function before you execute
|
||||
any managed code from the thread
|
||||
|
||||
* Samples
|
||||
|
||||
See the sample programs in mono/sample/embed for examples of
|
||||
embedding the Mono runtime in your application.
|
||||
|
||||
|
||||
@@ -1,110 +0,0 @@
|
||||
Exception Implementation in the Mono Runtime
|
||||
Dietmar Maurer ([email protected])
|
||||
(C) 2001 Ximian, Inc.
|
||||
|
||||
Exception implementation (jit):
|
||||
===============================
|
||||
|
||||
Stack unwinding:
|
||||
================
|
||||
|
||||
We record the code address (start_address, size) of all methods. That way it is
|
||||
possible to map an instruction pointer (IP) to the method information needed
|
||||
for unwinding the stack:
|
||||
|
||||
We also save a Last Managed Frame (LMF) structure at each call from managed to
|
||||
unmanaged code. That way we can recover from exceptions inside unmanaged code.
|
||||
|
||||
void handle_exception ((struct sigcontext *ctx, gpointer obj)
|
||||
{
|
||||
if (ctx->bp < mono_end_of_stack) {
|
||||
/* unhandled exception */
|
||||
abort ();
|
||||
}
|
||||
|
||||
info = mono_jit_info_table_find (mono_jit_info_table, ctx->ip);
|
||||
|
||||
if (info) { // we are inside managed code
|
||||
|
||||
if (ch = find_catch_handler ())
|
||||
execute_catch_handler (ch, ctx, obj);
|
||||
|
||||
execute_all_finally_handler ();
|
||||
|
||||
// restore register, including IP and Frame pointer
|
||||
ctx = restore_caller_saved_registers_from_ctx (ji, ctx);
|
||||
|
||||
// continue unwinding
|
||||
handle_exception (ctx, obj);
|
||||
|
||||
} else {
|
||||
|
||||
lmf = get_last_managed_frame ();
|
||||
|
||||
// restore register, including IP and Frame pointer
|
||||
ctx = restore_caller_saved_registers_from_lmf (ji, lmf);
|
||||
|
||||
// continue unwinding
|
||||
handle_exception (ctx, obj);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Code generation:
|
||||
================
|
||||
|
||||
leave: is simply translated into a branch to the target. If the leave
|
||||
instruction is inside a finally block (but not inside another handler)
|
||||
we call the finally handler before we branch to the target.
|
||||
|
||||
finally/endfinally, filter/endfilter: is translated into subroutine ending with
|
||||
a "return" statement. The subroutine does not save EBP, because we need access
|
||||
to the local variables of the enclosing method. Its is possible that
|
||||
instructions inside those handlers modify the stack pointer, thus we save the
|
||||
stack pointer at the start of the handler, and restore it at the end. We have
|
||||
to use a "call" instruction to execute such finally handlers. This makes it
|
||||
also possible to execute them inside the stack unwinding code. The exception
|
||||
object for filters is passed in a local variable (cfg->exvar).
|
||||
|
||||
throw: we first save all regs into a sigcontext struct and then call the stack
|
||||
unwinding code.
|
||||
|
||||
catch handler: catch hanlders are always called from the stack unwinding
|
||||
code. The exception object is passed in a local variable (cfg->exvar).
|
||||
|
||||
gcc support for Exceptions
|
||||
==========================
|
||||
|
||||
gcc supports exceptions in files compiled with the -fexception option. gcc
|
||||
generates DWARF exceptions tables in that case, so it is possible to unwind the
|
||||
stack. The method to read those exception tables is contained in libgcc.a, and
|
||||
in newer versions of glibc (glibc 2.2.5 for example), and it is called
|
||||
__frame_state_for(). Another usable glibc function is backtrace_symbols() which
|
||||
returns the function name corresponding to a code address.
|
||||
|
||||
We dynamically check if those features are available using g_module_symbol(),
|
||||
and we use them only when available. If not available we use the LMF as
|
||||
fallback.
|
||||
|
||||
Using gcc exception information prevents us from saving the LMF at each native
|
||||
call, so this is a way to speed up native calls. This is especially valuable
|
||||
for internal calls, because we can make sure that all internal calls are
|
||||
compiled with -fexceptions (we compile the whole mono runtime with that
|
||||
option).
|
||||
|
||||
All native function are able to call function without exception tables, and so
|
||||
we are unable to restore all caller saved registers if an exception is raised
|
||||
in such function. Well, its possible if the previous function already saves all
|
||||
registers. So we only omit the the LMF if a function has an exception table
|
||||
able to restore all caller saved registers.
|
||||
|
||||
One problem is that gcc almost never saves all caller saved registers, because
|
||||
it is just unnecessary in normal situations. But there is a trick forcing gcc
|
||||
to save all register, we just need to call __builtin_unwind_init() at the
|
||||
beginning of a function. That way gcc generates code to save all caller saved
|
||||
register on the stack.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,173 +0,0 @@
|
||||
Rules for opening shared files
|
||||
==============================
|
||||
|
||||
File is already open, with share set to none:
|
||||
|
||||
Can not open again
|
||||
|
||||
|
||||
File is already open for reading, with read share:
|
||||
|
||||
Can open for reading only, share must include read (can have write too)
|
||||
|
||||
|
||||
File is already open for reading, with write share:
|
||||
|
||||
Can open for writing only, share must include read (can have write too)
|
||||
|
||||
|
||||
File is already open for reading, with read + write share:
|
||||
|
||||
Can open for read, writing or both, share must include read (can have write too)
|
||||
|
||||
|
||||
File is already open for writing, with read share:
|
||||
|
||||
Can open for reading only, share must include write (can have read too)
|
||||
|
||||
|
||||
File is already open for writing, with write share:
|
||||
|
||||
Can open for writing only, share must include write (can have read too)
|
||||
|
||||
|
||||
File is already open for writing, with read + write share:
|
||||
|
||||
Can open for reading, writing or both, share must include write (can have read too)
|
||||
|
||||
|
||||
File is already open for reading + writing, with read share:
|
||||
|
||||
Can open for reading only, share must be read + write
|
||||
|
||||
|
||||
File is already open for reading + writing, with write share:
|
||||
|
||||
Can open for for writing only, share must be read + write
|
||||
|
||||
|
||||
File is already open for reading + writing, with read + write share:
|
||||
|
||||
Can open for read, writing or both, share must be read + write
|
||||
|
||||
|
||||
|
||||
Executive Summary
|
||||
-----------------
|
||||
|
||||
Second open must have access within first share, must set second share to at least first access
|
||||
|
||||
|
||||
|
||||
|
||||
Documenting code
|
||||
----------------
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <windows.h>
|
||||
|
||||
int access[] = {
|
||||
GENERIC_READ,
|
||||
GENERIC_WRITE,
|
||||
GENERIC_READ | GENERIC_WRITE
|
||||
};
|
||||
|
||||
char *access_names[] = {
|
||||
"G_READ",
|
||||
"G_WRITE",
|
||||
"G_READ|G_WRITE"
|
||||
};
|
||||
|
||||
int share[] = {
|
||||
FILE_SHARE_READ,
|
||||
FILE_SHARE_WRITE,
|
||||
FILE_SHARE_READ | FILE_SHARE_WRITE
|
||||
};
|
||||
|
||||
char *share_names[] = {
|
||||
"SHARE_READ",
|
||||
"SHARE_WRITE",
|
||||
"SHARE_READ|SHARE_WRITE"
|
||||
};
|
||||
|
||||
void lockfiles(int access1, int share1, int access2, int share2)
|
||||
{
|
||||
HANDLE h1, h2;
|
||||
BOOL ret;
|
||||
|
||||
if (access2 == 0 && share2 == 0) {
|
||||
printf("\n");
|
||||
printf("%22.22s\n%22.22s", access_names[access1], share_names[share1]);
|
||||
}
|
||||
|
||||
h1 = CreateFile("lockedfile",
|
||||
access[access1],
|
||||
share[share1],
|
||||
NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
||||
if (h1 == INVALID_HANDLE_VALUE) {
|
||||
printf("Open1 failed: %d\n", GetLastError());
|
||||
return;
|
||||
}
|
||||
|
||||
h2 = CreateFile("lockedfile",
|
||||
access[access2],
|
||||
share[share2],
|
||||
NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
||||
if (h2 == INVALID_HANDLE_VALUE) {
|
||||
printf(" %4.4s", "");
|
||||
} else {
|
||||
printf(" %4.4s", "OK");
|
||||
CloseHandle(h2);
|
||||
}
|
||||
|
||||
CloseHandle(h1);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int i, j, k, l;
|
||||
|
||||
printf("\t\t\t\t\t\t\tSecond Open\n");
|
||||
printf("%22.22s G_RE G_RE G_RE G_WR G_WR G_WR G_RW G_RW G_RW\n", "");
|
||||
printf("%22.22s S_RE S_WR S_RW S_RE S_WR S_RW S_RE S_WR S_RW", "First open --v ");
|
||||
for (i = 0; i < 3; i++) {
|
||||
for (j = 0; j < 3; j++) {
|
||||
for (k = 0; k < 3; k++) {
|
||||
for (l = 0; l < 3; l++) {
|
||||
lockfiles(i, j, k, l);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return(0);
|
||||
}
|
||||
|
||||
|
||||
|
||||
Code output
|
||||
-----------
|
||||
|
||||
Second Open
|
||||
G_RE G_RE G_RE G_WR G_WR G_WR G_RW G_RW G_RW
|
||||
First open --v S_RE S_WR S_RW S_RE S_WR S_RW S_RE S_WR S_RW
|
||||
G_READ
|
||||
SHARE_READ OK OK
|
||||
G_READ
|
||||
SHARE_WRITE OK OK
|
||||
G_READ
|
||||
SHARE_READ|SHARE_WRITE OK OK OK OK OK OK
|
||||
G_WRITE
|
||||
SHARE_READ OK OK
|
||||
G_WRITE
|
||||
SHARE_WRITE OK OK
|
||||
G_WRITE
|
||||
SHARE_READ|SHARE_WRITE OK OK OK OK OK OK
|
||||
G_READ|G_WRITE
|
||||
SHARE_READ OK
|
||||
G_READ|G_WRITE
|
||||
SHARE_WRITE OK
|
||||
G_READ|G_WRITE
|
||||
SHARE_READ|SHARE_WRITE OK OK OK
|
||||
|
||||
@@ -1,31 +0,0 @@
|
||||
* GC issues you need to be careful about when hacking on the mono runtime.
|
||||
|
||||
mono currently uses the Boehm garbage collection library. This is a conservative
|
||||
GC package: this means that the memory is searched for possible memory references
|
||||
to chunks allocated with the GC. Not all the memory is searched, but only the memory
|
||||
allocated with the GC itself (unless you use the 'atomic' variant of the allocation
|
||||
routines), the stack and global variables. Also, if the last reference to an object
|
||||
is stored in an area of themory that is not searched, the object may be freed resulting
|
||||
in memory corruption ind segfaults.
|
||||
|
||||
In particular, memory allocated with system's malloc() is not searched, so you need to be
|
||||
careful NOT to store object references in memory allocated with malloc() (unless you are sure
|
||||
that the object reference will be live at the same time in some other area under the control
|
||||
of the GC (on the stack or in a global variable, for example). Since g_malloc()
|
||||
ultimately calls system malloc() the data structures in GLib are not safe to
|
||||
use to store object references.
|
||||
|
||||
Occasionally, you'll need to store some object reference from C code: in this case,
|
||||
you must make sure that the store location is searched by the GC. You can safely
|
||||
use thread local storage areas, global variables, stack variables. If you need a more
|
||||
complicated data structure, you can use a hash table: MonoGHashTable.
|
||||
This hash table has the same interface as GHashTable from GLib, just stick the "mono_"
|
||||
prefix in function calls and the "Mono" prefix in the hash table type name.
|
||||
This hash table ensures that object references stored in it are tracked by the GC, as long
|
||||
as the pointer to the hash is tracked itself.
|
||||
|
||||
Other data structures that are allocated with the GC and are safe to use to store pointers
|
||||
to GC-allocated memory, are MonoDomain (keeps track of many domain specfic objects)
|
||||
and MonoVTable (referenced by MonoDomain: keeps track of the static data of a type
|
||||
since that can hold references to objects).
|
||||
|
||||
@@ -1,84 +0,0 @@
|
||||
Internal Call Topics
|
||||
|
||||
* Introduction
|
||||
|
||||
The Common Language Infrastructure allows for methods to be
|
||||
implemented in unmanaged code. Unlike the Platform Invocation
|
||||
services which provide marshalling and unmarshalling of data
|
||||
from managed to unmanaged and viceversa the Internal calls do
|
||||
not perform any kind of marshalling.
|
||||
|
||||
* Basic Type mapping
|
||||
|
||||
The following lists how the C# types are exposed to the C API.
|
||||
|
||||
C# type C type
|
||||
-----------------------------
|
||||
char gunichar2
|
||||
bool MonoBoolean
|
||||
sbyte signed char
|
||||
byte guchar
|
||||
short gint16
|
||||
ushort guint16
|
||||
int gint32
|
||||
uint guint32
|
||||
long gint64
|
||||
ulong guint64
|
||||
IntPtr/UIntPtr gpointer
|
||||
object MonoObject*
|
||||
string MonoString*
|
||||
|
||||
* Pointers
|
||||
|
||||
For ref and out paramaters you'll use the corresponding
|
||||
pointer type.
|
||||
|
||||
So if you have a C# type listed as "ref int", you should use
|
||||
"int *" in your implementation.
|
||||
|
||||
* Arrays
|
||||
|
||||
Arrays of any type must be described with a MonoArray* and the
|
||||
elements must be accessed with the mono_array_* macros.
|
||||
|
||||
* Other Structures
|
||||
|
||||
Any other type that has a matching C structure representation,
|
||||
should use a pointer to the struct instead of a generic
|
||||
MonoObject pointer.
|
||||
|
||||
* Instance Methods.
|
||||
|
||||
Instance methods that are internal calls will receive as first argument
|
||||
the instance object, so you must account for it in the C method signature:
|
||||
|
||||
[MethodImplAttribute(MethodImplOptions.InternalCall)]
|
||||
public extern override int GetHashCode ();
|
||||
|
||||
becomes:
|
||||
|
||||
gint32 ves_icall_System_String_GetHashCode (MonoString *this);
|
||||
|
||||
* How to hook internal calls with the runtime
|
||||
|
||||
Once you require an internal call in corlib, you need to
|
||||
create a C implementation for it and register it in a static
|
||||
table in metadata/icall.c. Add an entry in the table like:
|
||||
|
||||
"System.String::GetHashCode", ves_icall_System_String_GetHashCode,
|
||||
|
||||
Note that you need to include the full namespace.name of the
|
||||
class. If there are overloaded methods, you need also to
|
||||
specify the signature of _all_ of them:
|
||||
|
||||
[MethodImplAttribute(MethodImplOptions.InternalCall)]
|
||||
public extern override void DoSomething ();
|
||||
[MethodImplAttribute(MethodImplOptions.InternalCall)]
|
||||
public extern override void DoSomething (bool useful);
|
||||
|
||||
should be mapped with:
|
||||
|
||||
"Namespace.ClassName::DoSomething()", ves_icall_Namespace_ClassName_DoSomething,
|
||||
"Namespace.ClassName::DoSomething(bool)", ves_icall_Namespace_ClassName_DoSomething_bool,
|
||||
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
Mono Intermediate Representation Documentation
|
||||
|
||||
Operation: OP_LOCALLOC
|
||||
inst_left:
|
||||
The value
|
||||
ins->inst_left = *sp;
|
||||
ins->cil_code = ip;
|
||||
|
||||
This is the equivalent of alloca() in a C implementation: it
|
||||
allocates a bunch of bytes on the stack dynamically. Local
|
||||
variables are allocated statically in the stack instead.
|
||||
|
||||
It is implemented by moving the stack pointer according to the
|
||||
platform ABI: you may need to keep a specific frame register
|
||||
to address local variables when LOCALLOC is used (the PPC code
|
||||
does this, for example: ifyou're doing the s390 port I suggest
|
||||
starting from that)
|
||||
|
||||
Operation: OP_CALL_HANDLER.
|
||||
|
||||
cil_code:
|
||||
Points to the CIL where the LEAVE or LEAVE_S
|
||||
instruction was found.
|
||||
|
||||
inst_target_bb:
|
||||
The target basic block for this invocation.
|
||||
|
||||
This instruction must call the target basic block.
|
||||
|
||||
Operation: OP_CISINST
|
||||
|
||||
Implements the CEE_MONO_CISINST opcode that is decoded from
|
||||
the CIL stream.
|
||||
|
||||
This opcode takes as input an object reference and a class,
|
||||
and leaves on the assigned register:
|
||||
|
||||
0. if the object is an instance of the class,
|
||||
1. if the object is not instance of the class,
|
||||
2. if the object is a proxy whose type cannot be determined.
|
||||
|
||||
Operation: OP_CCASTCLASS
|
||||
|
||||
Implements the CEE_MONO_CCASTCLASS opcode that is decoded from
|
||||
the CIL stream.
|
||||
|
||||
This opcode takes as input an object reference and a class,
|
||||
and leaves on the assigned register:
|
||||
|
||||
0. if the object is an instance of the class,
|
||||
1. if the object is a proxy whose type cannot be determined
|
||||
|
||||
throws an InvalidCastException exception otherwise.
|
||||
|
||||
@@ -1,64 +0,0 @@
|
||||
Register Allocation
|
||||
===================
|
||||
|
||||
The current JIT implementation uses a tree matcher to generate code. We use a
|
||||
simple algorithm to allocate registers in trees, and limit the number of used
|
||||
temporary register to 4 when evaluating trees. So we can use 2 registers for
|
||||
global register allocation.
|
||||
|
||||
Register Allocation for Trees
|
||||
=============================
|
||||
|
||||
We always evaluate trees from left to right. When there are no more registers
|
||||
available we need to spill values to memory. Here is the simplified algorithm.
|
||||
|
||||
gboolean
|
||||
tree_allocate_regs (tree, exclude_reg)
|
||||
{
|
||||
if (!tree_allocate_regs (tree->left, -1))
|
||||
return FALSE;
|
||||
|
||||
if (!tree_allocate_regs (tree->right, -1)) {
|
||||
|
||||
tree->left->spilled == TRUE;
|
||||
|
||||
free_used_regs (tree->left);
|
||||
|
||||
if (!tree_allocate_regs (tree->right, tree->left->reg))
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
free_used_regs (tree->left);
|
||||
free_used_regs (tree->right);
|
||||
|
||||
/* try to allocate a register (reg != exclude_reg) */
|
||||
if ((tree->reg = next_free_reg (exclude_reg)) != -1)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
The emit routing actually spills the registers:
|
||||
|
||||
tree_emit (tree)
|
||||
{
|
||||
|
||||
tree_emit (tree->left);
|
||||
|
||||
if (tree->left->spilled)
|
||||
save_reg (tree->left->reg);
|
||||
|
||||
tree_emit (tree->right);
|
||||
|
||||
if (tree->left->spilled)
|
||||
restore_reg (tree->left->reg);
|
||||
|
||||
|
||||
emit_code (tree);
|
||||
}
|
||||
|
||||
|
||||
Global Register Allocation
|
||||
==========================
|
||||
|
||||
TODO.
|
||||
@@ -1,125 +0,0 @@
|
||||
Just some thoughts for the JITer:
|
||||
|
||||
General issues:
|
||||
===============
|
||||
|
||||
We are designing a JIT compiler, so we have to consider two things:
|
||||
|
||||
- the quality of the generated code
|
||||
- the time needed to generate that code
|
||||
|
||||
The current approach is to keep the JITer as simple as possible, and thus as
|
||||
fast as possible. The generated code quality will suffer from that.
|
||||
|
||||
Register Allocation:
|
||||
====================
|
||||
|
||||
With lcc you can assign a fixed register to a tree before register
|
||||
allocation. For example this is needed by call, which return the value always
|
||||
in EAX on x86. The current implementation works without such system, due to
|
||||
special forest generation.
|
||||
|
||||
Different Register Sets:
|
||||
========================
|
||||
|
||||
Most processors have more that one register set, at least one for floating
|
||||
point values, and one for integers. Should we support architectures with more
|
||||
that two sets? Does someone knows such an architecture?
|
||||
|
||||
64bit Integer Values:
|
||||
=====================
|
||||
|
||||
I can imagine two different implementation. On possibility would be to treat
|
||||
long (64bit) values simply like any other value type. This implies that we
|
||||
call class methods for ALU operations like add or sub. Sure, this method will
|
||||
be be a bit inefficient.
|
||||
|
||||
The more performant solution is to allocate two 32bit registers for each 64bit
|
||||
value. We add a new non terminal to the monoburg grammar called "lreg". The
|
||||
register allocation routines takes care of this non terminal and allocates two
|
||||
32 bit registers for them.
|
||||
|
||||
Forest generation:
|
||||
==================
|
||||
|
||||
Consider the following code:
|
||||
|
||||
OPCODE: STACK LOCALS
|
||||
LDLOC.0 (5) [5,0]
|
||||
LDC.1 (5,1) [5,0]
|
||||
STLOC.0 (5) [1,0]
|
||||
STLOC.1 () [1,5]
|
||||
|
||||
A simple forest generation generates:
|
||||
|
||||
STLOC.0(LDC.1)
|
||||
STLOC.1(LDLOC.0)
|
||||
|
||||
Which is wrong, since it stores the wrong value (1 instead of 5). Instead we
|
||||
must generate something like:
|
||||
|
||||
STLOC.TMP(LDLOC.0)
|
||||
STLOC.0(LDC.1)
|
||||
STLOC.1(LDLOC.TMP)
|
||||
|
||||
Where STLOC.TMP saves the value into a new temporary variable.
|
||||
|
||||
We also need a similar solution for basic block boundaries when the stack depth
|
||||
is not zero. We can simply save those values to new temporary values. Consider
|
||||
the following basic block with one instruction:
|
||||
|
||||
LDLOC.1
|
||||
This should generate a tree like:
|
||||
|
||||
STLOC.TMP(LDLOC.1) Please notice that an intelligent register allocator can
|
||||
still allocate registers for those new variables.
|
||||
|
||||
DAG handling:
|
||||
=============
|
||||
|
||||
Monoburg can't handle DAGs, instead we need real trees as input for
|
||||
the code generator. So we have two problems:
|
||||
|
||||
1.) DUP instruction: This one is obvious - we need to store the value
|
||||
into a temporary variable to solve the problem.
|
||||
|
||||
2.) function calls: Chapter 12.8, page 343 of "A retargetable C compiler"
|
||||
explains that: "because listing a call node will give it a hidden reference
|
||||
from the code list". I don't understand that (can someone explain that?), but
|
||||
there is another reason to save return values to temporaries: Consider the
|
||||
following code:
|
||||
|
||||
x = f(y) + g(z); // all functions return integers
|
||||
|
||||
We could generate such a tree for this expression: STLOC(ADD(CALL,CALL))
|
||||
|
||||
The problem is that both calls returns the value in the same register,
|
||||
so it is non trivial to generate code for that tree. We must copy one
|
||||
register into another one, which make register allocation more complex.
|
||||
The easier solution is store the result of function calls to
|
||||
temporaries. This leads to the following forest:
|
||||
|
||||
STLOC(CALL)
|
||||
STLOC(CALL)
|
||||
STLOC(ADD (LDLOC, LDLOC))
|
||||
|
||||
This is what lcc is doing, if I understood 12.8, page 342, 343?
|
||||
|
||||
Possible Optimisations:
|
||||
=======================
|
||||
|
||||
Miguel said ORP does some optimisation on IL level, for example moving array
|
||||
bounds checking out of loops:
|
||||
|
||||
for (i = 0; i < N; i++) { check_range (a, i); a [i] = X; }
|
||||
|
||||
id transformed to:
|
||||
|
||||
if (in_range (a, 0, N)) { for (i = 0; i < N; i++) a[i] = X; }
|
||||
else for (i = 0; i < N; i++) { check_range (a, i); a [i] = X; }
|
||||
|
||||
The "else" is only to keep original semantics (exception handling).
|
||||
|
||||
We need loop detection logic in order to implement this (dominator tree).
|
||||
|
||||
AFAIK CACAO also implements this.
|
||||
@@ -1,52 +0,0 @@
|
||||
Author: Dietmar Maurer ([email protected])
|
||||
(C) 2001 Ximian, Inc.
|
||||
|
||||
Howto trigger JIT compilation
|
||||
=============================
|
||||
|
||||
The JIT translates CIL code to native code on a per method basis. For example
|
||||
if you have this simple program:
|
||||
|
||||
public class Test {
|
||||
public static void Main () {
|
||||
System.Console.WriteLine ("Hello");
|
||||
}
|
||||
}
|
||||
|
||||
the JIT first compiles the Main function. Unfortunately Main() contains another
|
||||
reference to System.Console.WriteLine(), so the JIT also needs the address for
|
||||
WriteLine() to generate a call instruction.
|
||||
|
||||
The simplest solution would be to JIT compile System.Console.WriteLine()
|
||||
to generate that address. But that would mean that we JIT compile half of our
|
||||
class library at once, since WriteLine() uses many other classes and function,
|
||||
and we have to call the JIT for each of them. Even worse there is the
|
||||
possibility of cyclic references, and we would end up in an endless loop.
|
||||
|
||||
Thus we need some kind of trampoline function for JIT compilation. Such a
|
||||
trampoline first calls the JIT compiler to create native code, and then jumps
|
||||
directly into that code. Whenever the JIT needs the address of a function (to
|
||||
emit a call instruction) it uses the address of those trampoline functions.
|
||||
|
||||
One drawback of this approach is that it requires an additional indirection. We
|
||||
always call the trampoline. Inside the trampoline we need to check if the
|
||||
method is already compiled or not, and when not compiled we start JIT
|
||||
compilation. After that we call the code. This process is quite time consuming
|
||||
and shows very bad performance.
|
||||
|
||||
The solution is to add some logic to the trampoline function to detect from
|
||||
where it is called. It is then possible for the JIT to patch the call
|
||||
instruction in the caller, so that it directly calls the JIT compiled code
|
||||
next time.
|
||||
|
||||
Implementation for x86
|
||||
======================
|
||||
|
||||
emit-x86.c (arch_create_jit_trampoline): return the JIT trampoline function
|
||||
|
||||
emit-x86.c (x86_magic_trampoline): contains the code to detect the caller and
|
||||
patch the call instruction.
|
||||
|
||||
emit-x86.c (arch_compile_method): JIT compile a method
|
||||
|
||||
|
||||
@@ -1,208 +0,0 @@
|
||||
|
||||
* Proposal for the local register allocator
|
||||
|
||||
The local register allocator deals with allocating registers
|
||||
for temporaries inside a single basic block, while the global
|
||||
register allocator is concerned with method-wide allocation of
|
||||
variables.
|
||||
The global register allocator uses callee-saved register for it's
|
||||
purpouse so that there is no need to save and restore these registers
|
||||
at call sites.
|
||||
|
||||
There are a number of issues the local allocator needs to deal with:
|
||||
*) some instructions expect operands in specific registers (for example
|
||||
the shl instruction on x86, or the call instruction with thiscall
|
||||
convention, or the equivalent call instructions on other architectures,
|
||||
such as the need to put output registers in %oX on sparc)
|
||||
*) some instructions deliver results only in specific registers (for example
|
||||
the div instruction on x86, or the call instructionson on almost all
|
||||
the architectures).
|
||||
*) it needs to know what registers may be clobbered by an instruction
|
||||
(such as in a method call)
|
||||
*) it should avoid excessive reloads or stores to improve performance
|
||||
|
||||
While which specific instructions have limitations is architecture-dependent,
|
||||
the problem shold be solved in an arch-independent way to reduce code duplication.
|
||||
The register allocator will be 'driven' by the arch-dependent code, but it's
|
||||
implementation should be arch-independent.
|
||||
|
||||
To improve the current local register allocator, we need to
|
||||
keep more state in it than the current setup that only keeps busy/free info.
|
||||
|
||||
Possible state information is:
|
||||
|
||||
free: the resgister is free to use and it doesn't contain useful info
|
||||
freeable: the register contains data loaded from a local (there is
|
||||
also info about _which_ local it contains) as a result from previous
|
||||
instructions (like, there was a store from the register to the local)
|
||||
moveable: it contains live data that is needed in a following instruction, but
|
||||
the contents may be moved to a different register
|
||||
busy: the register contains live data and it is placed there because
|
||||
the following instructions need it exactly in that register
|
||||
allocated: the register is used by the global allocator
|
||||
|
||||
The local register allocator will have the following interfaces:
|
||||
|
||||
int get_register ();
|
||||
Searches for a register in the free state. If it doesn't find it,
|
||||
searches for a freeable register. Sets the status to moveable.
|
||||
Looking for a 'free' register before a freeable one should allow for
|
||||
removing a few redundant loads (though I'm still unsure if such
|
||||
things should be delegated entirely to the peephole pass).
|
||||
|
||||
int get_register_force (int reg);
|
||||
Returns 'reg' if it is free or freeable. If it is moveable, it moves it
|
||||
to another free or freeable register.
|
||||
Sets the status of 'reg' to busy.
|
||||
|
||||
void set_register_freeable (int reg);
|
||||
Sets the status of 'reg' to freeable.
|
||||
|
||||
void set_register_free (int reg);
|
||||
Sets the status of 'reg' to free.
|
||||
|
||||
void will_clobber (int reg);
|
||||
Spills the register to the stack. Sets the status to freeable.
|
||||
After the clobbering has occurred, set the status to free.
|
||||
|
||||
void register_unspill (int reg);
|
||||
Un-spills register reg and sets the status to moveable.
|
||||
|
||||
FIXME: how is the 'local' information represented? Maybe a MonoInst* pointer.
|
||||
|
||||
Note: the register allocator will insert instructions in the basic block
|
||||
during it's operation.
|
||||
|
||||
* Examples
|
||||
|
||||
Given the tree (on x86 the right argument to shl needs to be in ecx):
|
||||
|
||||
store (local1, shl (local1, call (some_arg)))
|
||||
|
||||
At the start of the basic block, the registers are set to the free state.
|
||||
The sequence of instructions may be:
|
||||
instruction register status -> [%eax %ecx %edx]
|
||||
start free free free
|
||||
eax = load local1 mov free free
|
||||
/* call clobbers eax, ecx, edx */
|
||||
spill eax free free free
|
||||
call mov free free
|
||||
/* now eax contains the right operand of the shl */
|
||||
mov %eax -> %ecx free busy free
|
||||
un-spill mov busy free
|
||||
shl %cl, %eax mov free free
|
||||
|
||||
The resulting x86 code is:
|
||||
mov $fffc(%ebp), %eax
|
||||
mov %eax, $fff0(%ebp)
|
||||
push some_arg
|
||||
call func
|
||||
mov %eax, %ecx
|
||||
mov $fff0(%ebp), %eax
|
||||
shl %cl, %eax
|
||||
|
||||
Note that since shl could operate directly on memory, we could have:
|
||||
|
||||
push some_arg
|
||||
call func
|
||||
mov %eax, %ecx
|
||||
shl %cl, $fffc(%ebp)
|
||||
|
||||
The above example with loading the operand in a register is just to complicate
|
||||
the example and show that the algorithm should be able to handle it.
|
||||
|
||||
Let's take another example with the this-call call convention (the first argument
|
||||
is passed in %ecx).
|
||||
In this case, will_clobber() will be called only on %eax and %edx, while %ecx
|
||||
will be allocated with get_register_force ().
|
||||
Note: when a register is allocated with get_register_force(), it should be set
|
||||
to a different state as soon as possible.
|
||||
|
||||
store (local1, shl (local1, this-call (local1)))
|
||||
|
||||
instruction register status -> [%eax %ecx %edx]
|
||||
start free free free
|
||||
eax = load local1 mov free free
|
||||
/* force load in %ecx */
|
||||
ecx = load local1 mov busy free
|
||||
spill eax free busy free
|
||||
call mov free free
|
||||
/* now eax contains the right operand of the shl */
|
||||
mov %eax -> %ecx free busy free
|
||||
un-spill mov busy free
|
||||
shl %cl, %eax mov free free
|
||||
|
||||
What happens when a register that we need to allocate with get_register_force ()
|
||||
contains an operand for the next instruction?
|
||||
|
||||
instruction register status -> [%eax %ecx %edx]
|
||||
eax = load local0 mov free free
|
||||
ecx = load local1 mov mov free
|
||||
get_register_force (ecx) here.
|
||||
We have two options:
|
||||
mov %ecx, %edx
|
||||
or:
|
||||
spill %ecx
|
||||
The first option is way better (and allows the peephole pass to
|
||||
just load the value in %edx directly, instead of loading first to %ecx).
|
||||
This doesn't work, though, if the instruction clobbers the %edx register
|
||||
(like in a this-call). So, we first need to clobber the registers
|
||||
(so the state of %ecx changes to freebale and there is no issue
|
||||
with get_register_force ()).
|
||||
What if an instruction both clobbers a register and requires it as
|
||||
an operand? Lets' take the x86 idiv instruction as an example: it
|
||||
requires the dividend in edx:eax and returns the result in eax,
|
||||
with the modulus in edx.
|
||||
|
||||
store (local1, div (local1, local2))
|
||||
|
||||
instruction register status -> [%eax %ecx %edx]
|
||||
eax = load local0 mov free free
|
||||
will_clobber eax, edx free mov free
|
||||
force mov %ecx, %eax busy free free
|
||||
set %edx busy free busy
|
||||
idiv mov free free
|
||||
|
||||
Note: edx is set to free after idiv, because the modulus is not needed
|
||||
(if it was a rem, eax would have been freed).
|
||||
If we load the divisor before will_clobber(), we'll have to spill
|
||||
eax and reload it later. If we load it just after the idiv, there is no issue.
|
||||
In any case, the algorithm should give the correct results and allow the operation.
|
||||
|
||||
Working recursively on the isntructions there shouldn't be huge issues
|
||||
with this algorithm (though, of course, it's not optimal and it may
|
||||
introduce excessive spills or register moves). The advantage over the current
|
||||
local reg allocator is that:
|
||||
1) the number of spills/moves would be smaller anyway
|
||||
2) a separate peephole pass could be able to eliminate reg moves
|
||||
3) we'll be able to remove the 'forced' spills we currently do with
|
||||
the return value of method calls
|
||||
|
||||
* Issues
|
||||
|
||||
How to best integrate such a reg allocator with the burg stuff.
|
||||
|
||||
Think about a call os sparc with two arguments: they got into %o0 and %o1
|
||||
and each of them sets the register as busy. But what if the values to put there
|
||||
are themselves the result of a call? %o0 is no problem, but for all the
|
||||
next argument n the above algorithm would spill all the 0...n-1 registers...
|
||||
|
||||
* Papers
|
||||
|
||||
More complex solutions to the local register allocator problem:
|
||||
http://dimacs.rutgers.edu/TechnicalReports/abstracts/1997/97-33.html
|
||||
|
||||
Combining register allocation and instruction scheduling:
|
||||
http://citeseer.nj.nec.com/motwani95combining.html
|
||||
|
||||
More on LRA euristics:
|
||||
http://citeseer.nj.nec.com/liberatore97hardness.html
|
||||
|
||||
Linear-time optimal code scheduling for delayedload architectures
|
||||
http://www.cs.wisc.edu/~fischer/cs701.f01/inst.sched.ps.gz
|
||||
|
||||
Precise Register Allocation for Irregular Architectures
|
||||
http://citeseer.nj.nec.com/kong98precise.html
|
||||
|
||||
Allocate registers first to subtrees that need more of them.
|
||||
http://www.upb.de/cs/ag-kastens/compii/folien/comment401-409.2.pdf
|
||||
@@ -1,771 +0,0 @@
|
||||
|
||||
A new JIT compiler for the Mono Project
|
||||
|
||||
Miguel de Icaza (miguel@{ximian.com,gnome.org}),
|
||||
Paolo Molaro (lupus@{ximian.com,debian.org})
|
||||
|
||||
|
||||
* Abstract
|
||||
|
||||
Mini is a new compilation engine for the Mono runtime. The
|
||||
new engine is designed to bring new code generation
|
||||
optimizations, portability and pre-compilation.
|
||||
|
||||
In this document we describe the design decisions and the
|
||||
architecture of the new compilation engine.
|
||||
|
||||
* Introduction
|
||||
|
||||
Mono is a Open Source implementation of the .NET Framework: it
|
||||
is made up of a runtime engine that implements the ECMA Common
|
||||
Language Infrastructure (CLI), a set of compilers that target
|
||||
the CLI and a large collection of class libraries.
|
||||
|
||||
This article discusses the new code generation facilities that
|
||||
have been added to the Mono runtime.
|
||||
|
||||
First we discuss the overall architecture of the Mono runtime,
|
||||
and how code generation fits into it; Then we discuss the
|
||||
development and basic architecture of our first JIT compiler
|
||||
for the ECMA CIL framework. The next section covers the
|
||||
objectives for the work on the new JIT compiler, then we
|
||||
discuss the new features available in the new JIT compiler,
|
||||
and finally a technical description of the new code generation
|
||||
engine.
|
||||
|
||||
* Architecture of the Mono Runtime
|
||||
|
||||
The Mono runtime is an implementation of the ECMA Common
|
||||
Language Infrastructure (CLI), whose aim is to be a common
|
||||
platform for executing code in multiple languages.
|
||||
|
||||
Languages that target the CLI generate images that contain
|
||||
code in high-level intermediate representation called the
|
||||
"Common Intermediate Language". This intermediate language is
|
||||
rich enough to allow for programs and pre-compiled libraries
|
||||
to be reflected. The execution environment allows for an
|
||||
object oriented execution environment with single inheritance
|
||||
and multiple interface implementations.
|
||||
|
||||
This runtime provides a number of services for programs that
|
||||
are targeted to it: Just-in-Time compilation of CIL code into
|
||||
native code, garbage collection, thread management, I/O
|
||||
routines, single, double and decimal floating point,
|
||||
asynchronous method invocation, application domains, and a
|
||||
framework for building arbitrary RPC systems (remoting) and
|
||||
integration with system libraries through the Platform Invoke
|
||||
functionality.
|
||||
|
||||
The focus of this document is on the services provided by the
|
||||
Mono runtime to transform CIL bytecodes into code that is
|
||||
native to the underlying architecture.
|
||||
|
||||
The code generation interface is a set of macros that allow a
|
||||
C programmer to generate code on the fly, this is done
|
||||
through a set of macros found in the mono/jit/arch/ directory.
|
||||
These macros are used by the JIT compiler to generate native
|
||||
code.
|
||||
|
||||
The platform invocation code is interesting, as it generates
|
||||
CIL code on the fly to marshal parameters, and then this
|
||||
code is in turned processed by the JIT engine.
|
||||
|
||||
* Previous Experiences
|
||||
|
||||
Mono has built a JIT engine, which has been used to bootstrap
|
||||
Mono since January, 2002. This JIT engine has reasonable
|
||||
performance, and uses an tree pattern matching instruction
|
||||
selector based on the BURS technology. This JIT compiler was
|
||||
designed by Dietmar Maurer, Paolo Molaro and Miguel de Icaza.
|
||||
|
||||
The existing JIT compiler has three phases:
|
||||
|
||||
* Re-creation of the semantic tree from CIL
|
||||
byte-codes.
|
||||
|
||||
* Instruction selection, with a cost-driven
|
||||
engine.
|
||||
|
||||
* Code generation and register allocation.
|
||||
|
||||
It is also hooked into the rest of the runtime to provide
|
||||
services like marshaling, just-in-time compilation and
|
||||
invocation of "internal calls".
|
||||
|
||||
This engine constructed a collection of trees, which we
|
||||
referred to as the "forest of trees", this forest is created by
|
||||
"hydrating" the CIL instruction stream.
|
||||
|
||||
The first step was to identify the basic blocks on the method,
|
||||
and computing the control flow graph (cfg) for it. Once this
|
||||
information was computed, a stack analysis on each basic block
|
||||
was performed to create a forest of trees for each one of
|
||||
them.
|
||||
|
||||
So for example, the following statement:
|
||||
|
||||
int a, b;
|
||||
...
|
||||
b = a + 1;
|
||||
|
||||
Which would be represented in CIL as:
|
||||
|
||||
ldloc.0
|
||||
ldc.i4.1
|
||||
add
|
||||
stloc.1
|
||||
|
||||
After the stack analysis would create the following tree:
|
||||
|
||||
(STIND_I4 ADDR_L[EBX|2] (
|
||||
ADD (LDIND_I4 ADDR_L[ESI|1])
|
||||
CONST_I4[1]))
|
||||
|
||||
This tree contains information from the stack analysis: for
|
||||
instance, notice that the operations explicitly encode the
|
||||
data types they are operating on, there is no longer an
|
||||
ambiguity on the types, because this information has been
|
||||
inferred.
|
||||
|
||||
At this point the JIT would pass the constructed forest of
|
||||
trees to the architecture-dependent JIT compiler.
|
||||
|
||||
The architecture dependent code then performed register
|
||||
allocation (optionally using linear scan allocation for
|
||||
variables, based on life analysis).
|
||||
|
||||
Once variables had been assigned, a tree pattern matching with
|
||||
dynamic programming is used (the tree pattern matcher is
|
||||
custom build for each architecture, using a code
|
||||
generator: monoburg). The instruction selector used cost
|
||||
functions to select the best instruction patterns.
|
||||
|
||||
The instruction selector is able to produce instructions that
|
||||
take advantage of the x86 instruction indexing instructions
|
||||
for example.
|
||||
|
||||
One problem though is that the code emitter and the register
|
||||
allocator did not have any visibility outside the current
|
||||
tree, which meant that some redundant instructions were
|
||||
generated. A peephole optimizer with this architecture was
|
||||
hard to write, given the tree-based representation that is
|
||||
used.
|
||||
|
||||
This JIT was functional, but it did not provide a good
|
||||
architecture to base future optimizations on. Also the
|
||||
line between architecture neutral and architecture
|
||||
specific code and optimizations was hard to draw.
|
||||
|
||||
The JIT engine supported two code generation modes to support
|
||||
the two optimization modes for applications that host multiple
|
||||
application domains: generate code that will be shared across
|
||||
application domains, or generate code that will not be shared
|
||||
across application domains.
|
||||
|
||||
* Objectives of the new JIT engine.
|
||||
|
||||
We wanted to support a number of features that were missing:
|
||||
|
||||
* Ahead-of-time compilation.
|
||||
|
||||
The idea is to allow developers to pre-compile their code
|
||||
to native code to reduce startup time, and the working
|
||||
set that is used at runtime in the just-in-time compiler.
|
||||
|
||||
Although in Mono this has not been a visible problem, we
|
||||
wanted to pro-actively address this problem.
|
||||
|
||||
When an assembly (a Mono/.NET executable) is installed in
|
||||
the system, it would then be possible to pre-compile the
|
||||
code, and have the JIT compiler tune the generated code
|
||||
to the particular CPU on which the software is
|
||||
installed.
|
||||
|
||||
This is done in the Microsoft.NET world with a tool
|
||||
called ngen.exe
|
||||
|
||||
* Have a good platform for doing code optimizations.
|
||||
|
||||
The design called for a good architecture that would
|
||||
enable various levels of optimizations: some
|
||||
optimizations are better performed on high-level
|
||||
intermediate representations, some on medium-level and
|
||||
some at low-level representations.
|
||||
|
||||
Also it should be possible to conditionally turn these on
|
||||
or off. Some optimizations are too expensive to be used
|
||||
in just-in-time compilation scenarios, but these
|
||||
expensive optimizations can be turned on for
|
||||
ahead-of-time compilations or when using profile-guided
|
||||
optimizations on a subset of the executed methods.
|
||||
|
||||
* Reduce the effort required to port the Mono code
|
||||
generator to new architectures.
|
||||
|
||||
For Mono to gain wide adoption in the Unix world, it is
|
||||
necessary that the JIT engine works in most of today's
|
||||
commercial hardware platforms.
|
||||
|
||||
* Features of the new JIT engine.
|
||||
|
||||
The new JIT engine was architected by Dietmar Maurer and Paolo
|
||||
Molaro, based on the new objectives.
|
||||
|
||||
Mono provides a number of services to applications running
|
||||
with the new JIT compiler:
|
||||
|
||||
* Just-in-Time compilation of CLI code into native code.
|
||||
|
||||
* Ahead-of-Time compilation of CLI code, to reduce
|
||||
startup time of applications.
|
||||
|
||||
A number of software development features are also available:
|
||||
|
||||
* Execution time profiling (--profile)
|
||||
|
||||
Generates a report of the times consumed by routines,
|
||||
as well as the invocation times, as well as the
|
||||
callers.
|
||||
|
||||
* Memory usage profiling (--profile)
|
||||
|
||||
Generates a report of the memory usage by a program
|
||||
that is ran under the Mono JIT.
|
||||
|
||||
* Code coverage (--coverage)
|
||||
|
||||
* Execution tracing.
|
||||
|
||||
People who are interested in developing and improving the Mini
|
||||
JIT compiler will also find a few useful routines:
|
||||
|
||||
* Compilation times
|
||||
|
||||
This is used to time the execution time for the JIT
|
||||
when compiling a routine.
|
||||
|
||||
* Control Flow Graph and Dominator Tree drawing.
|
||||
|
||||
These are visual aids for the JIT developer: they
|
||||
render representations of the Control Flow graph, and
|
||||
for the more advanced optimizations, they draw the
|
||||
dominator tree graph.
|
||||
|
||||
This requires Dot (from the graphwiz package) and Ghostview.
|
||||
|
||||
* Code generator regression tests.
|
||||
|
||||
The engine contains support for running regression
|
||||
tests on the virtual machine, which is very helpful to
|
||||
developers interested in improving the engine.
|
||||
|
||||
* Optimization benchmark framework.
|
||||
|
||||
The JIT engine will generate graphs that compare
|
||||
various benchmarks embedded in an assembly, and run the
|
||||
various tests with different optimization flags.
|
||||
|
||||
This requires Perl, GD::Graph.
|
||||
|
||||
* Flexibility
|
||||
|
||||
This is probably the most important component of the new code
|
||||
generation engine. The internals are relatively easy to
|
||||
replace and update, even large passes can be replaced and
|
||||
implemented differently.
|
||||
|
||||
* New code generator
|
||||
|
||||
Compiling a method begins with the `mini_method_to_ir' routine
|
||||
that converts the CIL representation into a medium
|
||||
intermediate representation.
|
||||
|
||||
The mini_method_to_ir routine performs a number of operations:
|
||||
|
||||
* Flow analysis and control flow graph computation.
|
||||
|
||||
Unlike the previous version, stack analysis and control
|
||||
flow graphs are computed in a single pass in the
|
||||
mini_method_to_ir function, this is done for performance
|
||||
reasons: although the complexity increases, the benefit
|
||||
for a JIT compiler is that there is more time available
|
||||
for performing other optimizations.
|
||||
|
||||
* Basic block computation.
|
||||
|
||||
mini_method_to_ir populates the MonoCompile structure
|
||||
with an array of basic blocks each of which contains
|
||||
forest of trees made up of MonoInst structures.
|
||||
|
||||
* Inlining
|
||||
|
||||
Inlining is no longer restricted to methods containing
|
||||
one single basic block, instead it is possible to inline
|
||||
arbitrary complex methods.
|
||||
|
||||
The heuristics to choose what to inline are likely going
|
||||
to be tuned in the future.
|
||||
|
||||
* Method to opcode conversion.
|
||||
|
||||
Some method call invocations like `call Math.Sin' are
|
||||
transformed into an opcode: this transforms the call
|
||||
into a semantically rich node, which is later inline
|
||||
into an FPU instruction.
|
||||
|
||||
Various Array methods invocations are turned into
|
||||
opcodes as well (The Get, Set and Address methods)
|
||||
|
||||
* Tail recursion elimination
|
||||
|
||||
Basic blocks ****
|
||||
|
||||
The MonoInst structure holds the actual decoded instruction,
|
||||
with the semantic information from the stack analysis.
|
||||
MonoInst is interesting because initially it is part of a tree
|
||||
structure, here is a sample of the same tree with the new JIT
|
||||
engine:
|
||||
|
||||
(stind.i4 regoffset[0xffffffd4(%ebp)]
|
||||
(add (ldind.i4 regoffset[0xffffffd8(%ebp)])
|
||||
iconst[1]))
|
||||
|
||||
This is a medium-level intermediate representation (MIR).
|
||||
|
||||
Some complex opcodes are decomposed at this stage into a
|
||||
collection of simpler opcodes. Not every complex opcode is
|
||||
decomposed at this stage, as we need to preserve the semantic
|
||||
information during various optimization phases.
|
||||
|
||||
For example a NEWARR opcode carries the length and the type of
|
||||
the array that could be used later to avoid type checking or
|
||||
array bounds check.
|
||||
|
||||
There are a number of operations supported on this
|
||||
representation:
|
||||
|
||||
* Branch optimizations.
|
||||
|
||||
* Variable liveness.
|
||||
|
||||
* Loop optimizations: the dominator trees are
|
||||
computed, loops are detected, and their nesting
|
||||
level computed.
|
||||
|
||||
* Conversion of the method into static single assignment
|
||||
form (SSA form).
|
||||
|
||||
* Dead code elimination.
|
||||
|
||||
* Constant propagation.
|
||||
|
||||
* Copy propagation.
|
||||
|
||||
* Constant folding.
|
||||
|
||||
Once the above optimizations are optionally performed, a
|
||||
decomposition phase is used to turn some complex opcodes into
|
||||
internal method calls. In the initial version of the JIT
|
||||
engine, various operations on longs are emulated instead of
|
||||
being inlined. Also the newarr invocation is turned into a
|
||||
call to the runtime.
|
||||
|
||||
At this point, after computing variable liveness, it is
|
||||
possible to use the linear scan algorithm for allocating
|
||||
variables to registers. The linear scan pass uses the
|
||||
information that was previously gathered by the loop nesting
|
||||
and loop structure computation to favor variables in inner
|
||||
loops. This process updates the basic block `nesting' field
|
||||
which is later used during liveness analysis.
|
||||
|
||||
Stack space is then reserved for the local variables and any
|
||||
temporary variables generated during the various
|
||||
optimizations.
|
||||
|
||||
** Instruction selection
|
||||
|
||||
At this point, the BURS instruction selector is invoked to
|
||||
transform the tree-based representation into a list of
|
||||
instructions. This is done using a tree pattern matcher that
|
||||
is generated for the architecture using the `monoburg' tool.
|
||||
|
||||
Monoburg takes as input a file that describes tree patterns,
|
||||
which are matched against the trees that were produced by the
|
||||
engine in the previous stages.
|
||||
|
||||
The pattern matching might have more than one match for a
|
||||
particular tree. In this case, the match selected is the one
|
||||
whose cost is the smallest. A cost can be attached to each
|
||||
rule, and if no cost is provided, the implicit cost is one.
|
||||
Smaller costs are selected over higher costs.
|
||||
|
||||
The cost function can be used to select particular blocks of
|
||||
code for a given architecture, or by using a prohibitive high
|
||||
number to avoid having the rule match.
|
||||
|
||||
The various rules that our JIT engine uses transform a tree of
|
||||
MonoInsts into a list of monoinsts:
|
||||
|
||||
+-----------------------------------------------------------+
|
||||
| Tree List |
|
||||
| of ===> Instruction selection ===> of |
|
||||
| MonoInst MonoInst. |
|
||||
+-----------------------------------------------------------+
|
||||
|
||||
During this process various "types" of MonoInst kinds
|
||||
disappear and turned into lower-level representations. The
|
||||
JIT compiler just happens to reuse the same structure (this is
|
||||
done to reduce memory usage and improve memory locality).
|
||||
|
||||
The instruction selection rules are split in a number of
|
||||
files, each one with a particular purpose:
|
||||
|
||||
inssel.brg
|
||||
Contains the generic instruction selection
|
||||
patterns.
|
||||
|
||||
inssel-x86.brg
|
||||
Contains x86 specific rules.
|
||||
|
||||
inssel-ppc.brg
|
||||
Contains PowerPC specific rules.
|
||||
|
||||
inssel-long32.brg
|
||||
burg file for 64bit instructions on 32bit architectures.
|
||||
|
||||
inssel-long.brg
|
||||
burg file for 64bit architectures.
|
||||
|
||||
inssel-float.brg
|
||||
burg file for floating point instructions
|
||||
|
||||
For a given build, a set of those files would be included.
|
||||
For example, for the build of Mono on the x86, the following
|
||||
set is used:
|
||||
|
||||
inssel.brg inssel-x86.brg inssel-long32.brg inssel-float.brg
|
||||
|
||||
** Native method generation
|
||||
|
||||
The native method generation has a number of steps:
|
||||
|
||||
* Architecture specific register allocation.
|
||||
|
||||
The information about loop nesting that was
|
||||
previously gathered is used here to hint the
|
||||
register allocator.
|
||||
|
||||
* Generating the method prolog/epilog.
|
||||
|
||||
* Optionally generate code to introduce tracing facilities.
|
||||
|
||||
* Hooking into the debugger.
|
||||
|
||||
* Performing any pending fixups.
|
||||
|
||||
* Code generation.
|
||||
|
||||
*** Code Generation
|
||||
|
||||
The actual code generation is contained in the architecture
|
||||
specific portion of the compiler. The input to the code
|
||||
generator is each one of the basic blocks with its list of
|
||||
instructions that were produced in the instruction selection
|
||||
phase.
|
||||
|
||||
During the instruction selection phase, virtual registers are
|
||||
assigned. Just before the peephole optimization is performed,
|
||||
physical registers are assigned.
|
||||
|
||||
A simple peephole and algebraic optimizer is ran at this
|
||||
stage.
|
||||
|
||||
The peephole optimizer removes some redundant operations at
|
||||
this point. This is possible because the code generation at
|
||||
this point has visibility into the basic block that spans the
|
||||
original trees.
|
||||
|
||||
The algebraic optimizer performs some simple algebraic
|
||||
optimizations that replace expensive operations with cheaper
|
||||
operations if possible.
|
||||
|
||||
The rest of the code generation is fairly simple: a switch
|
||||
statement is used to generate code for each of the MonoInsts,
|
||||
in the mono/mini/mini-ARCH.c files, the method is called
|
||||
"mono_arch_output_basic_block".
|
||||
|
||||
We always try to allocate code in sequence, instead of just using
|
||||
malloc. This way we increase spatial locality which gives a massive
|
||||
speedup on most architectures.
|
||||
|
||||
*** Ahead of Time compilation
|
||||
|
||||
Ahead-of-Time compilation is a new feature of our new
|
||||
compilation engine. The compilation engine is shared by the
|
||||
Just-in-Time (JIT) compiler and the Ahead-of-Time compiler
|
||||
(AOT).
|
||||
|
||||
The difference is on the set of optimizations that are turned
|
||||
on for each mode: Just-in-Time compilation should be as fast
|
||||
as possible, while Ahead-of-Time compilation can take as long
|
||||
as required, because this is not done at a time critical
|
||||
time.
|
||||
|
||||
With AOT compilation, we can afford to turn all of the
|
||||
computationally expensive optimizations on.
|
||||
|
||||
After the code generation phase is done, the code and any
|
||||
required fixup information is saved into a file that is
|
||||
readable by "as" (the native assembler available on all
|
||||
systems). This assembly file is then passed to the native
|
||||
assembler, which generates a loadable module.
|
||||
|
||||
At execution time, when an assembly is loaded from the disk,
|
||||
the runtime engine will probe for the existence of a
|
||||
pre-compiled image. If the pre-compiled image exists, then it
|
||||
is loaded, and the method invocations are resolved to the code
|
||||
contained in the loaded module.
|
||||
|
||||
The code generated under the AOT scenario is slightly
|
||||
different than the JIT scenario. It generates code that is
|
||||
application-domain relative and that can be shared among
|
||||
multiple thread.
|
||||
|
||||
This is the same code generation that is used when the runtime
|
||||
is instructed to maximize code sharing on a multi-application
|
||||
domain scenario.
|
||||
|
||||
* SSA-based optimizations
|
||||
|
||||
SSA form simplifies many optimization because each variable
|
||||
has exactly one definition site. This means that each
|
||||
variable is only initialized once.
|
||||
|
||||
For example, code like this:
|
||||
|
||||
a = 1
|
||||
..
|
||||
a = 2
|
||||
call (a)
|
||||
|
||||
Is internally turned into:
|
||||
|
||||
a1 = 1
|
||||
..
|
||||
a2 = 2
|
||||
call (a2)
|
||||
|
||||
In the presence of branches, like:
|
||||
|
||||
if (x)
|
||||
a = 1
|
||||
else
|
||||
a = 2
|
||||
|
||||
call (a)
|
||||
|
||||
The code is turned into:
|
||||
|
||||
if (x)
|
||||
a1 = 1;
|
||||
else
|
||||
a2 = 2;
|
||||
a3 = phi (a1, a2)
|
||||
call (a3)
|
||||
|
||||
All uses of a variable are "dominated" by its definition
|
||||
|
||||
This representation is useful as it simplifies the
|
||||
implementation of a number of optimizations like conditional
|
||||
constant propagation, array bounds check removal and dead code
|
||||
elimination.
|
||||
|
||||
* Register allocation.
|
||||
|
||||
Global register allocation is performed on the medium
|
||||
intermediate representation just before instruction selection
|
||||
is performed on the method. Local register allocation is
|
||||
later performed at the basic-block level on the
|
||||
|
||||
Global register allocation uses the following input:
|
||||
|
||||
1) set of register-sized variables that can be allocated to a
|
||||
register (this is an architecture specific setting, for x86
|
||||
these registers are the callee saved register ESI, EDI and
|
||||
EBX).
|
||||
|
||||
2) liveness information for the variables
|
||||
|
||||
3) (optionally) loop info to favor variables that are used in
|
||||
inner loops.
|
||||
|
||||
During instruction selection phase, symbolic registers are
|
||||
assigned to temporary values in expressions.
|
||||
|
||||
Local register allocation assigns hard registers to the
|
||||
symbolic registers, and it is performed just before the code
|
||||
is actually emitted and is performed at the basic block level.
|
||||
A CPU description file describes the input registers, output
|
||||
registers, fixed registers and clobbered registers by each
|
||||
operation.
|
||||
|
||||
* BURG Code Generator Generator
|
||||
|
||||
monoburg was written by Dietmar Maurer. It is based on the
|
||||
papers from Christopher W. Fraser, Robert R. Henry and Todd
|
||||
A. Proebsting: "BURG - Fast Optimal Instruction Selection and
|
||||
Tree Parsing" and "Engineering a Simple, Efficient Code
|
||||
Generator Generator".
|
||||
|
||||
The original BURG implementation is unable to work on DAGs, instead only
|
||||
trees are allowed. Our monoburg implementations is able to generate tree
|
||||
matcher which works on DAGs, and we use this feature in the new
|
||||
JIT. This simplifies the code because we can directly pass DAGs and
|
||||
don't need to convert them to trees.
|
||||
|
||||
* Adding IL opcodes: an excercise (from a post by Paolo Molaro)
|
||||
|
||||
mini.c is the file that read the IL code stream and decides
|
||||
how any single IL instruction is implemented
|
||||
(mono_method_to_ir () func), so you always have to add an
|
||||
entry to the big switch inside the function: there are plenty
|
||||
of examples in that file.
|
||||
|
||||
An IL opcode can be implemented in a number of ways, depending
|
||||
on what it does and how it needs to do it.
|
||||
|
||||
Some opcodes are implemented using a helper function: one of
|
||||
the simpler examples is the CEE_STELEM_REF implementation.
|
||||
|
||||
In this case the opcode implementation is written in a C
|
||||
function. You will need to register the function with the jit
|
||||
before you can use it (mono_register_jit_call) and you need to
|
||||
emit the call to the helper using the mono_emit_jit_icall()
|
||||
function.
|
||||
|
||||
This is the simpler way to add a new opcode and it doesn't
|
||||
require any arch-specific change (though it's limited to what
|
||||
you can do in C code and the performance may be limited by the
|
||||
function call).
|
||||
|
||||
Other opcodes can be implemented with one or more of the already
|
||||
implemented low-level instructions.
|
||||
|
||||
An example is the OP_STRLEN opcode which implements
|
||||
String.Length using a simple load from memory. In this case
|
||||
you need to add a rule to the appropriate burg file,
|
||||
describing what are the arguments of the opcode and what is,
|
||||
if any, it's 'return' value.
|
||||
|
||||
The OP_STRLEN case is:
|
||||
|
||||
reg: OP_STRLEN (reg) {
|
||||
MONO_EMIT_LOAD_MEMBASE_OP (s, tree, OP_LOADI4_MEMBASE, state->reg1,
|
||||
state->left->reg1, G_STRUCT_OFFSET (MonoString, length));
|
||||
}
|
||||
|
||||
The above means: the OP_STRLEN takes a register as an argument
|
||||
and returns its value in a register. And the implementation
|
||||
of this is included in the braces.
|
||||
|
||||
The opcode returns a value in an integer register
|
||||
(state->reg1) by performing a int32 load of the length field
|
||||
of the MonoString represented by the input register
|
||||
(state->left->reg1): before the burg rules are applied, the
|
||||
internal representation is based on trees, so you get the
|
||||
left/right pointers (state->left and state->right
|
||||
respectively, the result is stored in state->reg1).
|
||||
|
||||
This instruction implementation doesn't require arch-specific
|
||||
changes (it is using the MONO_EMIT_LOAD_MEMBASE_OP which is
|
||||
available on all platforms), and usually the produced code is
|
||||
fast.
|
||||
|
||||
Next we have opcodes that must be implemented with new low-level
|
||||
architecture specific instructions (either because of performance
|
||||
considerations or because the functionality can't get implemented in
|
||||
other ways).
|
||||
|
||||
You also need a burg rule in this case, too. For example,
|
||||
consider the OP_CHECK_THIS opcode (used to raise an exception
|
||||
if the this pointer is null). The burg rule simply reads:
|
||||
|
||||
stmt: OP_CHECK_THIS (reg) {
|
||||
mono_bblock_add_inst (s->cbb, tree);
|
||||
}
|
||||
|
||||
Note that this opcode does not return a value (hence the
|
||||
"stmt") and it takes a register as input.
|
||||
|
||||
mono_bblock_add_inst (s->cbb, tree) just adds the instruction
|
||||
(the tree variable) to the current basic block (s->cbb). In
|
||||
mini this is the place where the internal representation
|
||||
switches from the tree format to the low-level format (the
|
||||
list of simple instructions).
|
||||
|
||||
In this case the actual opcode implementation is delegated to
|
||||
the arch-specific code. A low-level opcode needs an entry in
|
||||
the machine description (the *.md files in mini/). This entry
|
||||
describes what kind of registers are used if any by the
|
||||
instruction, as well as other details such as constraints or
|
||||
other hints to the low-level engine which are architecture
|
||||
specific.
|
||||
|
||||
cpu-pentium.md, for example has the following entry:
|
||||
|
||||
checkthis: src1:b len:3
|
||||
|
||||
This means the instruction uses an integer register as a base
|
||||
pointer (basically a load or store is done on it) and it takes
|
||||
3 bytes of native code to implement it.
|
||||
|
||||
Now you just need to provide the low-level implementation for
|
||||
the opcode in one of the mini-$arch.c files, in the
|
||||
mono_arch_output_basic_block() function. There is a big switch
|
||||
here too. The x86 implementation is:
|
||||
|
||||
case OP_CHECK_THIS:
|
||||
/* ensure ins->sreg1 is not NULL */
|
||||
x86_alu_membase_imm (code, X86_CMP, ins->sreg1, 0, 0);
|
||||
break;
|
||||
|
||||
If the $arch-codegen.h header file doesn't have the code to
|
||||
emit the low-level native code, you'll need to write that as
|
||||
well.
|
||||
|
||||
Complex opcodes with register constraints may require other
|
||||
changes to the local register allocator, but usually they are
|
||||
not needed.
|
||||
|
||||
* Future
|
||||
|
||||
Profile-based optimization is something that we are very
|
||||
interested in supporting. There are two possible usage
|
||||
scenarios:
|
||||
|
||||
* Based on the profile information gathered during
|
||||
the execution of a program, hot methods can be compiled
|
||||
with the highest level of optimizations, while bootstrap
|
||||
code and cold methods can be compiled with the least set
|
||||
of optimizations and placed in a discardable list.
|
||||
|
||||
* Code reordering: this profile-based optimization would
|
||||
only make sense for pre-compiled code. The profile
|
||||
information is used to re-order the assembly code on disk
|
||||
so that the code is placed on the disk in a way that
|
||||
increments locality.
|
||||
|
||||
This is the same principle under which SGI's cord program
|
||||
works.
|
||||
|
||||
The nature of the CIL allows the above optimizations to be
|
||||
easy to implement and deploy. Since we live and define our
|
||||
universe for these things, there are no interactions with
|
||||
system tools required, nor upgrades on the underlying
|
||||
infrastructure required.
|
||||
|
||||
Instruction scheduling is important for certain kinds of
|
||||
processors, and some of the framework exists today in our
|
||||
register allocator and the instruction selector to cope with
|
||||
this, but has not been finished. The instruction selection
|
||||
would happen at the same time as local register allocation. <
|
||||
@@ -1,424 +0,0 @@
|
||||
Mono JIT porting guide.
|
||||
Paolo Molaro ([email protected])
|
||||
|
||||
* Introduction
|
||||
|
||||
This documents describes the process of porting the mono JIT
|
||||
to a new CPU architecture. The new mono JIT has been designed
|
||||
to make porting easier though at the same time enable the port
|
||||
to take full advantage from the new architecture features and
|
||||
instructions. Knowledge of the mini architecture (described in
|
||||
the mini-doc.txt file) is a requirement for understanding this
|
||||
guide, as well as an earlier document about porting the mono
|
||||
interpreter (available on the web site).
|
||||
|
||||
There are six main areas that a port needs to implement to
|
||||
have a fully-functional JIT for a given architecture:
|
||||
|
||||
1) instruction selection
|
||||
2) native code emission
|
||||
3) call conventions and register allocation
|
||||
4) method trampolines
|
||||
5) exception handling
|
||||
6) minor helper methods
|
||||
|
||||
To take advantage of some not-so-common processor features
|
||||
(for example conditional execution of instructions as may be
|
||||
found on ARM or ia64), it may be needed to develop an
|
||||
high-level optimization, but doing so is not a requirement for
|
||||
getting the JIT to work.
|
||||
|
||||
We'll see in more details each of the steps required, note,
|
||||
though, that a new port may just as well start from a
|
||||
cut&paste of an existing port to a similar architecture (for
|
||||
example from x86 to amd64, or from powerpc to sparc).
|
||||
|
||||
The architecture specific code is split from the rest of the
|
||||
JIT, for example the x86 specific code and data is all
|
||||
included in the following files in the distribution:
|
||||
|
||||
mini-x86.h mini-x86.c
|
||||
inssel-x86.brg
|
||||
cpu-pentium.md
|
||||
tramp-x86.c
|
||||
exceptions-x86.c
|
||||
|
||||
I suggest a similar split for other architectures as well.
|
||||
|
||||
Note that this document is still incomplete: some sections are
|
||||
only sketched and some are missing, but the important info to
|
||||
get a port going is already described.
|
||||
|
||||
|
||||
* Architecture-specific instructions and instruction selection.
|
||||
|
||||
The JIT already provides a set of instructions that can be
|
||||
easily mapped to a great variety of different processor
|
||||
instructions. Sometimes it may be necessary or advisable to
|
||||
add a new instruction that represent more closely an
|
||||
instruction in the architecture. Note that a mini instruction
|
||||
can be used to represent also a short sequence of CPU
|
||||
low-level instructions, but note that each instruction
|
||||
represents the minimum amount of code the instruction
|
||||
scheduler will handle (i.e., the scheduler won't schedule the
|
||||
instructions that compose the low-level sequence as individual
|
||||
instructions, but just the whole sequence, as an indivisible
|
||||
block).
|
||||
|
||||
New instructions are created by adding a line in the
|
||||
mini-ops.h file, assigning an opcode and a name. To specify
|
||||
the input and output for the instruction, there are two
|
||||
different places, depending on the context in which the
|
||||
instruction gets used.
|
||||
|
||||
If the instruction is used in the tree representation, the
|
||||
input and output types are defined by the BURG rules in the
|
||||
*.brg files (the usual non-terminals are 'reg' to represent a
|
||||
normal register, 'lreg' to represent a register or two that
|
||||
hold a 64 bit value, freg for a floating point register).
|
||||
|
||||
If an instruction is used as a low-level CPU instruction, the
|
||||
info is specified in a machine description file. The
|
||||
description file is processed by the genmdesc program to
|
||||
provide a data structure that can be easily used from C code
|
||||
to query the needed info about the instruction.
|
||||
|
||||
As an example, let's consider the add instruction for both x86
|
||||
and ppc:
|
||||
|
||||
x86 version:
|
||||
add: dest:i src1:i src2:i len:2 clob:1
|
||||
ppc version:
|
||||
add: dest:i src1:i src2:i len:4
|
||||
|
||||
Note that the instruction takes two input integer registers on
|
||||
both CPU, but on x86 the first source register is clobbered
|
||||
(clob:1) and the length in bytes of the instruction differs.
|
||||
|
||||
Note that integer adds and floating point adds use different
|
||||
opcodes, unlike the IL language (64 bit add is done with two
|
||||
instructions on 32 bit architectures, using a add that sets
|
||||
the carry and an add with carry).
|
||||
|
||||
A specific CPU port may assign any meaning to the clob field
|
||||
for an instruction since the value will be processed in an
|
||||
arch-specific file anyway.
|
||||
|
||||
See the top of the existing cpu-pentium.md file for more info
|
||||
on other fields: the info may or may not be applicable to a
|
||||
different CPU, in this latter case the info can be ignored.
|
||||
|
||||
The code in mini.c together with the BURG rules in inssel.brg,
|
||||
inssel-float.brg and inssel-long32.brg provides general
|
||||
purpose mappings from the tree representation to a set of
|
||||
instructions that should be easily implemented in any
|
||||
architecture. To allow for additional arch-specific
|
||||
functionality, an arch-specific BURG file can be used: in this
|
||||
file arch-specific instructions can be selected that provide
|
||||
better performance than the general instructions or that
|
||||
provide functionality that is needed by the JIT but that
|
||||
cannot be expressed in a general enough way.
|
||||
|
||||
As an example, x86 has the special instruction "push" to make
|
||||
it easier to implement the default call convention (passing
|
||||
arguments on the stack): almost all the other architectures
|
||||
don't have such an instruction (and don't need it anyway), so
|
||||
we added a special rule in the inssel-x86.brg file for it.
|
||||
|
||||
So, one of the first things needed in a port is to write a
|
||||
cpu-$(arch).md machine description file and fill it with the
|
||||
needed info. As a start, only a few instructions can be
|
||||
specified, like the ones required to do simple integer
|
||||
operations. The default rules of the instruction selector will
|
||||
emit the common instructions and so we're ready to go for the
|
||||
next step in porting the JIT.
|
||||
|
||||
|
||||
*) Native code emission
|
||||
|
||||
Since the first step in porting mono to a new CPU is to port
|
||||
the interpreter, there should be already a file that allows
|
||||
the emission of binary native code in a buffer for the
|
||||
architecture. This file should be placed in the
|
||||
|
||||
mono/arch/$(arch)/
|
||||
|
||||
directory.
|
||||
|
||||
The bulk of the code emission happens in the mini-$(arch).c
|
||||
file, in a function called mono_arch_output_basic_block
|
||||
(). This function takes a basic block, walks the list of
|
||||
instructions in the block and emits the binary code for each.
|
||||
Optionally a peephole optimization pass is done on the basic
|
||||
block, but this can be left for later, when the port actually
|
||||
works.
|
||||
|
||||
This function is very simple, there is just a big switch on
|
||||
the instruction opcode and in the corresponding case the
|
||||
functions or macros to emit the binary native code are
|
||||
used. Note that in this function the lengths of the
|
||||
instructions are used to determine if the buffer for the code
|
||||
needs enlarging.
|
||||
|
||||
To complete the code emission for a method, a few other
|
||||
functions need implementing as well:
|
||||
|
||||
mono_arch_emit_prolog ()
|
||||
mono_arch_emit_epilog ()
|
||||
mono_arch_patch_code ()
|
||||
|
||||
mono_arch_emit_prolog () will emit the code to setup the stack
|
||||
frame for a method, optionally call the callbacks used in
|
||||
profiling and tracing, and move the arguments to their home
|
||||
location (in a caller-save register if the variable was
|
||||
allocated to one, or in a stack location if the argument was
|
||||
passed in a volatile register and wasn't allocated a
|
||||
non-volatile one). caller-save registers used by the function
|
||||
are saved in the prolog as well.
|
||||
|
||||
mono_arch_emit_epilog () will emit the code needed to return
|
||||
from the function, optionally calling the profiling or tracing
|
||||
callbacks. At this point the basic blocks or the code that was
|
||||
moved out of the normal flow for the function can be emitted
|
||||
as well (this is usually done to provide better info for the
|
||||
static branch predictor). In the epilog, caller-save
|
||||
registers are restored if they were used.
|
||||
|
||||
Note that, to help exception handling and stack unwinding,
|
||||
when there is a transition from managed to unmanaged code,
|
||||
some special processing needs to be done (basically, saving
|
||||
all the registers and setting up the links in the Last Managed
|
||||
Frame structure).
|
||||
|
||||
When the epilog has been emitted, the upper level code
|
||||
arranges for the buffer of memory that contains the native
|
||||
code to be copied in an area of executable memory and at this
|
||||
point, instructions that use relative addressing need to be
|
||||
patched to have the right offsets: this work is done by
|
||||
mono_arch_patch_code ().
|
||||
|
||||
|
||||
* Call conventions and register allocation
|
||||
|
||||
To account for the differences in the call conventions, a few functions need to
|
||||
be implemented.
|
||||
|
||||
mono_arch_allocate_vars () assigns to both arguments and local
|
||||
variables the offset relative to the frame register where they
|
||||
are stored, dead variables are simply discarded. The total
|
||||
amount of stack needed is calculated.
|
||||
|
||||
mono_arch_call_opcode () is the function that more closely
|
||||
deals with the call convention on a given system. For each
|
||||
argument to a function call, an instruction is created that
|
||||
actually puts the argument where needed, be it the stack or a
|
||||
specific register. This function can also re-arrange th order
|
||||
of evaluation when multiple arguments are involved if needed
|
||||
(like, on x86 arguments are pushed on the stack in reverse
|
||||
order). The function needs to carefully take into accounts
|
||||
platform specific issues, like how structures are returned as
|
||||
well as the differences in size and/or alignment of managed
|
||||
and corresponding unmanaged structures.
|
||||
|
||||
The other chunk of code that needs to deal with the call
|
||||
convention and other specifics of a CPU, is the local register
|
||||
allocator, implemented in a function named
|
||||
mono_arch_local_regalloc (). The local allocator deals with a
|
||||
basic block at a time and basically just allocates registers
|
||||
for temporary values during expression evaluation, spilling
|
||||
and unspilling as necessary.
|
||||
|
||||
The local allocator needs to take into account clobbering
|
||||
information, both during simple instructions and during
|
||||
function calls and it needs to deal with other
|
||||
architecture-specific weirdnesses, like instructions that take
|
||||
inputs only in specific registers or output only is some.
|
||||
|
||||
Some effort will be put later in moving most of the local
|
||||
register allocator to a common file so that the code can be
|
||||
shared more for similar, risc-like CPUs. The register
|
||||
allocator does a first pass on the instructions in a block,
|
||||
collecting liveness information and in a backward pass on the
|
||||
same list performs the actual register allocation, inserting
|
||||
the instructions needed to spill values, if necessary.
|
||||
|
||||
When this part of code is implemented, some testing can be
|
||||
done with the generated code for the new architecture. Most
|
||||
helpful is the use of the --regression command line switch to
|
||||
run the regression tests (basic.cs, for example).
|
||||
|
||||
Note that the JIT will try to initialize the runtime, but it
|
||||
may not be able yet to compile and execute complex code:
|
||||
commenting most of the code in the mini_init() function in
|
||||
mini.c is needed to let the JIT just compile the regression
|
||||
tests. Also, using multiple -v switches on the command line
|
||||
makes the JIT dump an increasing amount of information during
|
||||
compilation.
|
||||
|
||||
|
||||
* Method trampolines
|
||||
|
||||
To get better startup performance, the JIT actually compiles a
|
||||
method only when needed. To achieve this, when a call to a
|
||||
method is compiled, we actually emit a call to a magic
|
||||
trampoline. The magic trampoline is a function written in
|
||||
assembly that invokes the compiler to compile the given method
|
||||
and jumps to the newly compiled code, ensuring the arguments
|
||||
it received are passed correctly to the actual method.
|
||||
|
||||
Before jumping to the new code, though, the magic trampoline
|
||||
takes care of patching the call site so that next time the
|
||||
call will go directly to the method instead of the
|
||||
trampoline. How does this all work?
|
||||
|
||||
mono_arch_create_jit_trampoline () creates a small function
|
||||
that just preserves the arguments passed to it and adds an
|
||||
additional argument (the method to compile) before calling the
|
||||
generic trampoline. This small function is called the specific
|
||||
trampoline, because it is method-specific (the method to
|
||||
compile is hard-code in the instruction stream).
|
||||
|
||||
The generic trampoline saves all the arguments that could get
|
||||
clobbered and calls a C function that will do two things:
|
||||
|
||||
*) actually call the JIT to compile the method
|
||||
*) identify the calling code so that it can be patched to call directly
|
||||
the actual method
|
||||
|
||||
If the 'this' argument to a method is a boxed valuetype that
|
||||
is passed to a method that expects just a pointer to the data,
|
||||
an additional unboxing trampoline will need to be inserted as
|
||||
well.
|
||||
|
||||
|
||||
* Exception handling
|
||||
|
||||
Exception handling is likely the most difficult part of the
|
||||
port, as it needs to deal with unwinding (both managed and
|
||||
unmanaged code) and calling catch and filter blocks. It also
|
||||
needs to deal with signals, because mono takes advantage of
|
||||
the MMU in the CPU and of the operation system to handle
|
||||
dereferences of the NULL pointer. Some of the function needed
|
||||
to implement the mechanisms are:
|
||||
|
||||
mono_arch_get_throw_exception () returns a function that takes
|
||||
an exception object and invokes an arch-specific function that
|
||||
will enter the exception processing. To do so, all the
|
||||
relevant registers need to be saved and passed on.
|
||||
|
||||
mono_arch_handle_exception () this function takes the
|
||||
exception thrown and a context that describes the state of the
|
||||
CPU at the time the exception was thrown. The function needs
|
||||
to implement the exception handling mechanism, so it makes a
|
||||
search for an handler for the exception and if none is found,
|
||||
it follows the unhandled exception path (that can print a
|
||||
trace and exit or just abort the current thread). The
|
||||
difficulty here is to unwind the stack correctly, by restoring
|
||||
the register state at each call site in the call chain,
|
||||
calling finally, filters and handler blocks while doing so.
|
||||
|
||||
As part of exception handling a couple of internal calls need
|
||||
to be implemented as well.
|
||||
|
||||
ves_icall_get_frame_info () returns info about a specific
|
||||
frame.
|
||||
|
||||
mono_jit_walk_stack () walks the stack and calls a callback with info for
|
||||
each frame found.
|
||||
|
||||
ves_icall_get_trace () return an array of StackFrame objects.
|
||||
|
||||
** Code generation for filter/finally handlers
|
||||
|
||||
Filter and finally handlers are called from 2 different locations:
|
||||
|
||||
1.) from within the method containing the exception clauses
|
||||
2.) from the stack unwinding code
|
||||
|
||||
To make this possible we implement them like subroutines,
|
||||
ending with a "return" statement. The subroutine does not save
|
||||
the base pointer, because we need access to the local
|
||||
variables of the enclosing method. Its is possible that
|
||||
instructions inside those handlers modify the stack pointer,
|
||||
thus we save the stack pointer at the start of the handler,
|
||||
and restore it at the end. We have to use a "call" instruction
|
||||
to execute such finally handlers.
|
||||
|
||||
The MIR code for filter and finally handlers looks like:
|
||||
|
||||
OP_START_HANDLER
|
||||
...
|
||||
OP_END_FINALLY | OP_ENDFILTER(reg)
|
||||
|
||||
OP_START_HANDLER: should save the stack pointer somewhere
|
||||
OP_END_FINALLY: restores the stack pointers and returns.
|
||||
OP_ENDFILTER (reg): restores the stack pointers and returns the value in "reg".
|
||||
|
||||
** Calling finally/filter handlers
|
||||
|
||||
There is a special opcode to call those handler, its called
|
||||
OP_CALL_HANDLER. It simple emits a call instruction.
|
||||
|
||||
Its a bit more complex to call handler from outside (in the
|
||||
stack unwinding code), because we have to restore the whole
|
||||
context of the method first. After that we simply emit a call
|
||||
instruction to invoke the handler. Its usually possible to use
|
||||
the same code to call filter and finally handlers (see
|
||||
arch_get_call_filter).
|
||||
|
||||
** Calling catch handlers
|
||||
|
||||
Catch handlers are always called from the stack unwinding
|
||||
code. Unlike finally clauses or filters, catch handler never
|
||||
return. Instead we simply restore the whole context, and
|
||||
restart execution at the catch handler.
|
||||
|
||||
** Passing Exception objects to catch handlers and filters.
|
||||
|
||||
We use a local variable to store exception objects. The stack
|
||||
unwinding code must store the exception object into this
|
||||
variable before calling catch handler or filter.
|
||||
|
||||
* Minor helper methods
|
||||
|
||||
A few minor helper methods are referenced from the arch-independent code.
|
||||
Some of them are:
|
||||
|
||||
*) mono_arch_cpu_optimizations ()
|
||||
This function returns a mask of optimizations that
|
||||
should be enabled for the current CPU and a mask of
|
||||
optimizations that should be excluded, instead.
|
||||
|
||||
*) mono_arch_regname ()
|
||||
Returns the name for a numeric register.
|
||||
|
||||
*) mono_arch_get_allocatable_int_vars ()
|
||||
Returns a list of variables that can be allocated to
|
||||
the integer registers in the current architecture.
|
||||
|
||||
*) mono_arch_get_global_int_regs ()
|
||||
Returns a list of caller-save registers that can be
|
||||
used to allocate variables in the current method.
|
||||
|
||||
*) mono_arch_instrument_mem_needs ()
|
||||
*) mono_arch_instrument_prolog ()
|
||||
*) mono_arch_instrument_epilog ()
|
||||
Functions needed to implement the profiling interface.
|
||||
|
||||
|
||||
* Writing regression tests
|
||||
|
||||
Regression tests for the JIT should be written for any bug
|
||||
found in the JIT in one of the *.cs files in the mini
|
||||
directory. Eventually all the operations of the JIT should be
|
||||
tested (including the ones that get selected only when some
|
||||
specific optimization is enabled).
|
||||
|
||||
|
||||
* Platform specific optimizations
|
||||
|
||||
An example of a platform-specific optimization is the peephole
|
||||
optimization: we look at a small window of code at a time and
|
||||
we replace one or more instructions with others that perform
|
||||
better for the given architecture or CPU.
|
||||
|
||||
@@ -1,98 +0,0 @@
|
||||
=pod
|
||||
|
||||
=head1 Internal design document for the mono_handle_d
|
||||
|
||||
This document is designed to hold the design of the mono_handle_d and
|
||||
not as an api reference.
|
||||
|
||||
=head2 Primary goal and purpose
|
||||
|
||||
The mono_handle_d is a process which takes care of the (de)allocation
|
||||
of scratch shared memory and handles (of files, threads, mutexes,
|
||||
sockets etc. see L<WapiHandleType>) and refcounts of the
|
||||
filehandles. It is designed to be run by a user and to be fast, thus
|
||||
minimal error checking on input is done and will most likely crash if
|
||||
given a faulty package. No effort has been, or should be, made to have
|
||||
the daemon talking to machine of different endianness/size of int.
|
||||
|
||||
=head2 How to start the daemon
|
||||
|
||||
To start the daemon you either run the mono_handle_d executable or try
|
||||
to attach to the shared memory segment via L<_wapi_shm_attach> which
|
||||
will start a daemon if one does not exist.
|
||||
|
||||
=head1 Internal details
|
||||
|
||||
The daemon works by opening a socket and listening to clients. These
|
||||
clients send packages over the socket complying to L<struct
|
||||
WapiHandleRequest>.
|
||||
|
||||
=head2 Possible requests
|
||||
|
||||
=over
|
||||
|
||||
=item WapiHandleRequest_New
|
||||
|
||||
Find a handle in the shared memory segment that is free and allocate
|
||||
it to the specified type. To destroy use
|
||||
L</WapiHandleRequest_Close>. A L<WapiHandleResponse> with
|
||||
.type=WapiHandleResponseType_New will be sent back with .u.new.handle
|
||||
set to the handle that was allocated. .u.new.type is the type that was
|
||||
requested.
|
||||
|
||||
=item WapiHandleRequestType_Open
|
||||
|
||||
Increase the ref count of an already created handle. A
|
||||
L<WapiHandleResponse> with .type=WapiHandleResponseType_Open will be sent
|
||||
back with .u.new.handle set to the handle, .u.new.type is set to the
|
||||
type of handle this is.
|
||||
|
||||
=item WapiHandleRequestType_Close
|
||||
|
||||
Decrease the ref count of an already created handle. A
|
||||
L<WapiHandleResponse> with .type=WapiHandleResponseType_Close will be
|
||||
sent back with .u.close.destroy set to TRUE if ref count for this
|
||||
client reached 0.
|
||||
|
||||
=item WapiHandleRequestType_Scratch
|
||||
|
||||
Allocate a shared memory area of size .u.scratch.length in bytes. A
|
||||
L<WapiHandleResponse> with .type=WapiHandleResponseType_Scratch will be
|
||||
sent back with .u.scratch.idx set to the index into the shared
|
||||
memory's scratch area where to memory begins. (works just like
|
||||
malloc(3))
|
||||
|
||||
=item WapiHandleRequestType_Scratch
|
||||
|
||||
Deallocate a shared memory area, this must have been allocated before
|
||||
deallocating. A L<WapiHandleResponse> with
|
||||
.type=WapiHandleResponseType_ScratchFree will be sent back (works just
|
||||
like free(3))
|
||||
|
||||
=back
|
||||
|
||||
=head1 Why a daemon
|
||||
|
||||
From an email:
|
||||
|
||||
Dennis: I just have one question about the daemon... Why does it
|
||||
exist? Isn't it better performancewise to just protect the shared area
|
||||
with a mutex when allocation a new handle/shared mem segment or
|
||||
changing refcnt? It will however be a less resilient to clients that
|
||||
crash (the deamon cleans up ref'd handles if socket closes)
|
||||
|
||||
Dick: It's precisely because with a mutex the shared memory segment
|
||||
can be left in a locked state. Also, it's not so easy to clean up
|
||||
shared memory without it (you can't just mark it deleted when creating
|
||||
it, because you can't attach any more readers to the same segment
|
||||
after that). I did some minimal performance testing, and I don't
|
||||
think the daemon is particularly slow.
|
||||
|
||||
|
||||
=head1 Authors
|
||||
|
||||
Documentaion: Dennis Haney
|
||||
|
||||
Implementation: Dick Porter
|
||||
|
||||
=cut
|
||||
@@ -1,63 +0,0 @@
|
||||
Author: Dietmar Maurer ([email protected])
|
||||
(C) 2001 Ximian, Inc.
|
||||
|
||||
Object and VTable layout
|
||||
========================
|
||||
|
||||
The first pointer inside an Object points to a MonoVtable structure. Objects
|
||||
also contains a MonoThreadsSync structure which is used by the mono Thread
|
||||
implementation.
|
||||
|
||||
typedef struct {
|
||||
MonoVTable *vtable;
|
||||
MonoThreadsSync synchronisation;
|
||||
|
||||
/* object specific data goes here */
|
||||
} MonoObject;
|
||||
|
||||
The MonoVtable contains the vtable, interface offsets and a pointer to static
|
||||
class data. Each object/vtable belongs to exactly one AppDomain.
|
||||
|
||||
typedef struct {
|
||||
MonoClass *klass;
|
||||
MonoDomain *domain;
|
||||
gpointer *interface_offsets;
|
||||
/* a pointer to static data */
|
||||
gpointer data;
|
||||
/* the variable sized vtable is included at the end */
|
||||
gpointer vtable [0];
|
||||
} MonoVTable;
|
||||
|
||||
The MonoClass contains domain independent Class infos.
|
||||
|
||||
typedef struct {
|
||||
/* various class infos */
|
||||
MonoClass *parent;
|
||||
const char *name;
|
||||
const char *name_space;
|
||||
...
|
||||
} MonoClass;
|
||||
|
||||
|
||||
Calling virtual functions:
|
||||
==========================
|
||||
|
||||
Each MonoMethod (if virtual) has an associated slot, which is an index into the
|
||||
VTable. So we can use the following code to compute the address of a virtual
|
||||
function:
|
||||
|
||||
method_addr = object->vtable->vtable [method->slot];
|
||||
|
||||
|
||||
Calling interface methods:
|
||||
==========================
|
||||
|
||||
Each interface class is associated with an unique ID. The following code
|
||||
computes the address of an interface function:
|
||||
|
||||
method_addr = *(object->vtable->interface_offsets [interface_id] + method->slot*4);
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,113 +0,0 @@
|
||||
|
||||
* How to handle complex IL opcodes in an arch-independent way
|
||||
|
||||
Many IL opcodes are very simple: add, ldind etc.
|
||||
Such opcodes can be implemented with a single cpu instruction
|
||||
in most architectures (on some, a group of IL instructions
|
||||
can be converted to a single cpu op).
|
||||
There are many IL opcodes, though, that are more complex, but
|
||||
can be expressed as a series of trees or a single tree of
|
||||
simple operations. Such simple operations are architecture-independent.
|
||||
It makes sense to decompose such complex IL instructions in their
|
||||
simpler equivalent so that we gain in several ways:
|
||||
*) porting effort is easier, because only the simple instructions
|
||||
need to be implemented in arch-specific code
|
||||
*) we could apply BURG rules to the trees and do pattern matching
|
||||
on them to optimize the expressions according to the host cpu
|
||||
|
||||
The issue is: where do we do such conversion from coarse opcodes to
|
||||
simple expressions?
|
||||
|
||||
* Doing the conversion in method_to_ir ()
|
||||
|
||||
Some of these conversions can certainly be done in method_to_ir (),
|
||||
but it's not always easy to decide which are better done there and
|
||||
which in a different pass.
|
||||
For example, let's take ldlen: in the mono implementation, ldlen
|
||||
can be simply implemented with a load from a fixed position in the
|
||||
array object:
|
||||
|
||||
len = [reg + maxlen_offset]
|
||||
|
||||
However, ldlen carries also semantics information: the result is the
|
||||
length of the array, and since in the CLR arrays are of fixed size,
|
||||
this information can be useful to later do bounds check removal.
|
||||
If we convert this opcode in method_to_ir () we lost some useful
|
||||
information for further optimizations.
|
||||
|
||||
In some other ways, decomposing an opcode in method_to_ir() may
|
||||
allow for better optimizations later on (need to come up with an
|
||||
example here ...).
|
||||
|
||||
* Doing the conversion in inssel.brg
|
||||
|
||||
Some conversion may be done inside the burg rules: this has the
|
||||
disadvantage that the instruction selector is not run again on
|
||||
the resulting expression tree and we could miss some optimization
|
||||
(this is what effectively happens with the coarse opcodes in the old
|
||||
jit). This may also interfere with an efficient local register allocator.
|
||||
It may be possible to add an extension in monoburg that allows a rule
|
||||
such as:
|
||||
|
||||
recheck: LDLEN (reg) {
|
||||
create an expression tree representing LDLEN
|
||||
and return it
|
||||
}
|
||||
|
||||
When the monoburg label process gets back a recheck, it will run
|
||||
the labeling again on the resulting expression tree.
|
||||
If this is possible at all (and in an efficient way) is a
|
||||
question for dietmar:-)
|
||||
It should be noted, though, that this may not always work, since
|
||||
some complex IL opcodes may require a series of expression trees
|
||||
and handling such cases in monoburg could become quite hairy.
|
||||
For example, think of opcode that need to do multiple actions on the
|
||||
same object: this basically means a DUP...
|
||||
On the other end, if a complex opcode needs a DUP, monoburg doesn't
|
||||
actually need to create trees if it emits the instructions in
|
||||
the correct sequence and maintains the right values in the registers
|
||||
(usually the values that need a DUP are not changed...). How
|
||||
this integrates with the current register allocator is not clear, since
|
||||
that assigns registers based on the rule, but the instructions emitted
|
||||
by the rules may be different (this already happens with the current JIT
|
||||
where a MULT is replaced with lea etc...).
|
||||
|
||||
* Doing it in a separate pass.
|
||||
|
||||
Doing the conversion in a separate pass over the instructions
|
||||
is another alternative. This can be done right after method_to_ir ()
|
||||
or after the SSA pass (since the IR after the SSA pass should look
|
||||
almost like the IR we get back from method_to_ir ()).
|
||||
|
||||
This has the following advantages:
|
||||
*) monoburg will handle only the simple opcodes (makes porting easier)
|
||||
*) the instruction selection will be run on all the additional trees
|
||||
*) it's easier to support coarse opcodes that produce multiple expression
|
||||
trees (and apply the monoburg selector on all of them)
|
||||
*) the SSA optimizer will see the original opcodes and will be able to use
|
||||
the semantic info associated with them
|
||||
|
||||
The disadvantage is that this is a separate pass on the code and
|
||||
it takes time (how much has not been measured yet, though).
|
||||
|
||||
With this approach, we may also be able to have C implementations
|
||||
of some of the opcodes: this pass would insert a function call to
|
||||
the C implementation (for example in the cases when first porting
|
||||
to a new arch and implemenating some stuff may be too hard in asm).
|
||||
|
||||
* Extended basic blocks
|
||||
|
||||
IL code needs a lot of checks, bounds checks, overflow checks,
|
||||
type checks and so on. This potentially increases by a lot
|
||||
the number of basic blocks in a control flow graph. However,
|
||||
all such blocks end up with a throw opcode that gives control to the
|
||||
exception handling mechanism.
|
||||
After method_to_ir () a MonoBasicBlock can be considered a sort
|
||||
of extended basic block where the additional exits don't point
|
||||
to basic blocks in the same procedure (at least when the method
|
||||
doesn't have exception tables).
|
||||
We need to make sure the passes following method_to_ir () can cope
|
||||
with such kinds of extended basic blocks (especially the passes
|
||||
that we need to apply to all the methods: as a start, we could
|
||||
skip SSA optimizations for methods with exception clauses...)
|
||||
|
||||
@@ -1,16 +0,0 @@
|
||||
<h1>Mono 1.0 Release Notes</h1>
|
||||
|
||||
<h2>What does Mono Include</h2>
|
||||
|
||||
<h2>Missing functionality</h2>
|
||||
|
||||
<p>COM support.
|
||||
|
||||
<p>EnterpriseServices are non-existant.
|
||||
|
||||
<p>Windows.Forms is only available as a preview, it is not
|
||||
completed nor stable.
|
||||
|
||||
<h3>Assembly: System.Drawing</h3>
|
||||
|
||||
<p>System.Drawing.Printing is not supported.
|
||||
@@ -1,26 +0,0 @@
|
||||
Runtime support for Remoting
|
||||
============================
|
||||
|
||||
The runtime supports a special objects called "TransparentProxy". You can
|
||||
create objects of this type by calling GetTransparentProxy() on a "RealProxy"
|
||||
object.
|
||||
|
||||
LDFLD/STFLD for transparent proxies
|
||||
===================================
|
||||
|
||||
Access to fields must be redirected to the remote object. System.Object has
|
||||
some special methods for that:
|
||||
|
||||
void FieldGetter (string typeName, string fieldName, ref object val);
|
||||
|
||||
void FieldSetter (string typeName, string fieldName, object val);
|
||||
|
||||
This methods are never called on actual object. The are only used to pack
|
||||
LDFLD/STFLD operations into method call messages, which are then passed to the
|
||||
RealProxy::Invoke() method.
|
||||
|
||||
There are two helper methods which can be used by the JIT and the interpreter
|
||||
to convert LDFLD/STFLD operations into messages and then call
|
||||
RealProxy::Invoke(): mono_store_remote_field() and mono_load_remote_field().
|
||||
|
||||
|
||||
@@ -1,33 +0,0 @@
|
||||
Size and alignment requirements of stack values
|
||||
===============================================
|
||||
|
||||
P ... System.IntPtr
|
||||
I1 ... System.Int8
|
||||
I2 ... System.Int16
|
||||
I4 ... System.Int32
|
||||
I8 ... System.Int64
|
||||
F ... System.Single
|
||||
D ... System.Double
|
||||
LD ... native long double
|
||||
|
||||
-----------------------------------------------------------
|
||||
ARCH | P | I1 | I2 | I4 | I8 | F | D | LD |
|
||||
-----------------------------------------------------------
|
||||
X86 | 4/4 | 4/4 | 4/4 | 4/4 | 8/4 | 4/4 | 8/4 |12/4 |
|
||||
-----------------------------------------------------------
|
||||
X86/W32 | 4/4 | 4/4 | 4/4 | 4/4 | 8/4 | 4/4 | 8/4 |12/4 |
|
||||
-----------------------------------------------------------
|
||||
ARM | 4/4 | 4/4 | 4/4 | 4/4 | 8/4 | 4/4 | 8/4 | 8/4 |
|
||||
-----------------------------------------------------------
|
||||
M68K | 4/4 | 4/4 | 4/4 | 4/4 | 8/4 | 4/4 | 8/4 |12/4 |
|
||||
-----------------------------------------------------------
|
||||
ALPHA | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 |
|
||||
-----------------------------------------------------------
|
||||
SPARC | 4/4 | 4/4 | 4/4 | 4/4 | 8/8 | 4/4 | 8/8 |16/8 |
|
||||
-----------------------------------------------------------
|
||||
SPARC64 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 | 8/8 |16/16|
|
||||
-----------------------------------------------------------
|
||||
MIPS | 4/4 | 4/4 | 4/4 | 4/4 | ?/? | 4/4 | 8/8 | 8/8 |
|
||||
-----------------------------------------------------------
|
||||
| | | | | | | | |
|
||||
-----------------------------------------------------------
|
||||
@@ -1,156 +0,0 @@
|
||||
|
||||
Threading in Mono
|
||||
=================
|
||||
|
||||
0. Terminology
|
||||
--------------
|
||||
|
||||
"Main thread" - The initial OS-native thread that the
|
||||
application started with.
|
||||
|
||||
"Helper thread" - A native thread created internally
|
||||
by the runtime, such as the finalizer thread, or an
|
||||
asynchronous delegate invocation thread. These
|
||||
threads can run managed code.
|
||||
|
||||
"Primary CLR thread" - The native thread that called
|
||||
the Main() method when executing an assembly.
|
||||
|
||||
"Secondary CLR thread" - A native thread created by a
|
||||
program that instantiates a System.Threading.Thread object
|
||||
and calls its Start() method.
|
||||
|
||||
1. Thread exit behaviour in the standalone mono runtime
|
||||
-------------------------------------------------------
|
||||
|
||||
The correct behaviour of the runtime should be:
|
||||
|
||||
a) If Main() returns, the runtime should wait for all
|
||||
foreground secondary CLR threads to finish. The
|
||||
wording in the class documentation states: "Once all
|
||||
foreground threads belonging to a process have
|
||||
terminated, the common language runtime ends the
|
||||
process by invoking Abort on any background threads
|
||||
that are still alive." Testing seems to indicate that
|
||||
the background thread can't cancel the Abort by
|
||||
catching the ThreadAbortException and calling
|
||||
ResetAbort here. Indeed, not even the finally block
|
||||
seems to be executed.
|
||||
|
||||
b) if any of the primary CLR thread, a secondary CLR
|
||||
thread or a helper thread calls
|
||||
System.Environment.Exit(), the application should
|
||||
terminate immediately without waiting for foreground
|
||||
primary or secondary CLR threads to finish.
|
||||
|
||||
c) if the primary CLR thread throws an uncaught
|
||||
exception, the application should terminate
|
||||
immediately without waiting for secondary CLR threads
|
||||
to finish. This might be implemented internally by
|
||||
pretending that all the running secondary CLR threads
|
||||
are background threads.
|
||||
|
||||
d) if a secondary CLR thread throws an uncaught
|
||||
exception that thread should terminate and all other
|
||||
threads should continue to execute.
|
||||
|
||||
e) if a helper thread throws an uncaught exception and
|
||||
that thread happens to be the GC finalizer thread,
|
||||
testing seems to indicate that the exception stack
|
||||
trace is displayed as normal, and the exception is
|
||||
then ignored (as though there is a try {} catch{}
|
||||
around all finalizers that just prints the stack
|
||||
trace.) Calling Abort() on the GC finalizer thread
|
||||
also does not cause it to exit: it behaves as though
|
||||
the ThreadAbortException is caught and ResetAbort is
|
||||
called. Asynchronous delegate helper threads should
|
||||
behave as secondary CLR threads, but uncaught
|
||||
exceptions should be rethrown on the thread that calls
|
||||
EndInvoke().
|
||||
|
||||
|
||||
The difficulties happen with cases b) and c):
|
||||
|
||||
The current implementation of
|
||||
System.Environment.Exit() calls exit(2) directly,
|
||||
which is rather unfriendly: it prevents any runtime
|
||||
cleanup, statistics gathering, etc. and is pretty
|
||||
obnoxious to embedded code.
|
||||
|
||||
The current exception handling code calls ExitThread()
|
||||
(emulated with pthread_exit() in the io-layer) if an
|
||||
exception is not caught.
|
||||
|
||||
When called from the main thread, both POSIX
|
||||
pthread_exit() and w32 ExitThread() block if there are
|
||||
other threads still running (in the w32 case, if there
|
||||
are other foreground threads still running; threads
|
||||
can set as background.) If the main thread is also
|
||||
the primary CLR thread, then the application will
|
||||
block until all other threads (including helper
|
||||
threads) terminate. Some helper threads will not
|
||||
terminate until specifically told to by the runtime:
|
||||
for example, the GC finalizer thread needs to run
|
||||
until all of the primary and secondary CLR threads
|
||||
have finished.
|
||||
|
||||
Also, if the main thread is also the primary CLR
|
||||
thread, the runtime loses the opportunity to do any
|
||||
cleaning up. Adding a special case to call exit(2)
|
||||
instead of ExitThread() in the primary CLR thread
|
||||
suffers from the same problems as
|
||||
System.Environment.Exit() calling exit(2).
|
||||
|
||||
|
||||
The simple solution is to run the primary CLR thread
|
||||
in a new native thread, leaving the main thread free
|
||||
for housekeeping duties. There still needs to be some
|
||||
special handling for the case where the primary CLR
|
||||
thread fails to catch an exception: the secondary CLR
|
||||
threads then need to be terminated.
|
||||
|
||||
When the primary and secondary CLR threads have all
|
||||
terminated, the helper threads can be killed off and
|
||||
the runtime can clean itself up and exit.
|
||||
|
||||
|
||||
|
||||
2. Thread initialisation
|
||||
------------------------
|
||||
|
||||
Threads have to undergo some initialisation before
|
||||
managed code can be executed. A
|
||||
System.Threading.Thread object must be created, and
|
||||
the thread details need to be stored so that the
|
||||
threads can be managed later. The JIT needs to record
|
||||
the last managed frame stack pointer in a TLS slot,
|
||||
and the current Thread object is also recorded.
|
||||
|
||||
New threads created by managed calls to
|
||||
System.Threading.Thread methods will have all needed
|
||||
initialisation performed. Threads created by the
|
||||
runtime with calls to mono_thread_create() will too.
|
||||
Existing threads can be passed to the runtime; these
|
||||
must call mono_thread_attach() before any CLR code can
|
||||
be executed on that thread.
|
||||
|
||||
|
||||
3. Constraints on embedding the Mono runtime
|
||||
--------------------------------------------
|
||||
|
||||
The discussion above concerning application behaviour
|
||||
in the event of threads terminating, whether by
|
||||
returning from the start function, throwing uncaught
|
||||
exceptions or by calling System.Environment.Exit(),
|
||||
only really applies to the standalone Mono runtime.
|
||||
|
||||
An embedding application should specify what behaviour
|
||||
is required when, for example,
|
||||
System.Environment.Exit() is called. The application
|
||||
is also responsible for its own thread management, and
|
||||
it should be prepared for any of the primary CLR
|
||||
thread or secondary CLR threads to terminate at any
|
||||
time. The application should also take into account
|
||||
that the runtime will create helper threads as needed,
|
||||
as this may cause pthread_exit() or ExitThread() to
|
||||
block indefinitely, as noted above.
|
||||
@@ -1,135 +0,0 @@
|
||||
Author: Dietmar Maurer ([email protected])
|
||||
(C) 2001 Ximian, Inc.
|
||||
|
||||
More about PInvoke and Internal calls
|
||||
=====================================
|
||||
|
||||
1.) What is PInvoke
|
||||
|
||||
PInvoke stands for Platform Invoke. It is possible to call functions contained
|
||||
in native shared libraries, for example you can declare:
|
||||
|
||||
[DllImport("cygwin1.dll", EntryPoint="puts"]
|
||||
public static extern int puts (string name);
|
||||
|
||||
If you then call "puts(...)" it invokes the native "puts" functions in
|
||||
"cygwin1.dll". It is also possible to specify several marshalling attributes
|
||||
for the arguments, for example you can specify that they puts() function expect
|
||||
ts the string in Ansi encoding by setting the CharSet attribute field:
|
||||
|
||||
[DllImport("cygwin1.dll", EntryPoint="puts", CharSet=CharSet.Ansi)]
|
||||
public static extern int puts (string name);
|
||||
|
||||
2.) What are internal calls
|
||||
|
||||
Some class library functions are implemented in C, because it is either not
|
||||
possible to implement them in C# or because of performance gains. Internal
|
||||
functions are contained in the mono executable itself. Here is an example form
|
||||
our array implementation:
|
||||
|
||||
[MethodImplAttribute(MethodImplOptions.InternalCall)]
|
||||
public extern int GetRank ();
|
||||
|
||||
If you call this GetRank() function it invokes
|
||||
ves_icall_System_Array_GetRank() inside the mono runtime.
|
||||
|
||||
If you write your own runtime environment you can add internal calls with
|
||||
mono_add_internal_call().
|
||||
|
||||
|
||||
2.) Runtime considerations
|
||||
|
||||
Invoking native (unmanaged) code has several implications:
|
||||
|
||||
- We need to handle exceptions inside unmanaged code. The JIT simply saves some
|
||||
informations at each transition from managed to unmanaged code (in a linked
|
||||
list), called Last Managed Frame (LMF). If an exception occurs the runtime
|
||||
first looks if the exception was inside managed code. If not there must be a
|
||||
LMF entry which contains all necessary information to unwind the stack.
|
||||
|
||||
Creation of those LMF structure clearly involves some overhead, so calling
|
||||
into unmanaged code is not as cheap as it looks like at first glance. Maybe
|
||||
we can introduce a special attribute to avoid the creation of LMF on internal
|
||||
call methods that cant raise exceptions.
|
||||
|
||||
- PInvoke has the possibility to convert argument types. For example Strings
|
||||
are marshalled as Char*. So each String argument is translated into a
|
||||
char*. The encoding is specified in the CharSet of the DllImport attribute.
|
||||
|
||||
|
||||
3.) When/how does the runtime call unmanaged PInvoke code
|
||||
|
||||
- LDFTN, CALLI, Delegate::Invoke, Delegate::BeginInvoke: We must generate
|
||||
wrapper code when we load the function with LDFTN, so that all arguments are
|
||||
marshalled in the right format. We also need to save/restore the LMF.
|
||||
|
||||
- MethodBase::Invoke (runtime invoke): We need to marshal all arguments in
|
||||
they right format and save/restore the LMF
|
||||
|
||||
- CALL: We need to marshal all arguments in they right format and save/restore
|
||||
the LMF
|
||||
|
||||
The easiest way to implement this is to always create a wrapper function for
|
||||
PInvoke calls, which takes care of argument marshalling and LMF save/restore.
|
||||
|
||||
4.) When/how does the runtime call unmanaged internal calls
|
||||
|
||||
We don't need to convert any arguments, so we need only take care of the LMF
|
||||
structure.
|
||||
|
||||
- LDFTN, CALLI, Delegate::Invoke, Delegate::BeginInvoke: We must generate
|
||||
wrapper code when we load the function with LDFTN which saves/restores the
|
||||
LMF.
|
||||
|
||||
- MethodBase::Invoke (runtime invoke): We need to save/restore the LMF.
|
||||
|
||||
- CALL: We need to save/restore the LMF.
|
||||
|
||||
- CALLVIRT (through the vtable): We must generate wrapper code to save/restore
|
||||
the LMF.
|
||||
|
||||
Please notice that we can call internal function with CALLVIRT, i.e. we can
|
||||
call those function through a VTable. But we cant know in advance if a vtable
|
||||
slot contains an internal call or managed code. So again it is best to generate
|
||||
a wrapper functions for internal calls in order to save/restore the LMF.
|
||||
|
||||
Unfortunately we need to push all arguments 2 times, because we have to save
|
||||
the LMF, and the LMF is currently allocated on the stack. So the stack looks
|
||||
like:
|
||||
|
||||
--------------------
|
||||
| method arguments |
|
||||
--------------------
|
||||
| LMF |
|
||||
--------------------
|
||||
| copied arguments |
|
||||
--------------------
|
||||
|
||||
AFAIK this is the way ORP works. Another way is to allocate the LMF not on the
|
||||
stack, but then we have additional overhead to allocate/free LMF structures
|
||||
(and another call to arch_get_lmf_addr).
|
||||
|
||||
Maybe it is possible to avoid this addiotional copy for internal calls by
|
||||
including the LMF in the C function signature. Lets say we hav a puts()
|
||||
function which is a internal call:
|
||||
|
||||
ves_icall_puts (MonoString *string);
|
||||
|
||||
If we simply modify that to include the LMF we can avoid to copy all arguments:
|
||||
|
||||
ves_icall_puts (MonoLMF lmf, MonoString *string);
|
||||
|
||||
But this depends somehow on the calling conventions, and I don't know if that
|
||||
works on all plattforms?
|
||||
|
||||
|
||||
5.) What is stored in the LMF
|
||||
|
||||
- all caller saved registers (since we can trust unmanaged code)
|
||||
- the instruction pointer of the last managed instruction
|
||||
- a MonoMethod pointer for the unmanaged function
|
||||
- the address of the thread local lfm_addr pointer (to avoid another call to
|
||||
arch_get_lmf_addr when restoring LMF)
|
||||
|
||||
The LMF is allocated on the stack, so we also know the stack position for
|
||||
stack unwinding.
|
||||
@@ -1,3 +0,0 @@
|
||||
Makefile.in
|
||||
Makefile
|
||||
.deps
|
||||
@@ -1,16 +0,0 @@
|
||||
2004-05-05 Zoltan Varga <[email protected]>
|
||||
|
||||
* mono-jni.c: Implement some missing JNI functions.
|
||||
|
||||
2004-04-13 Zoltan Varga <[email protected]>
|
||||
|
||||
* mono-jni.c: Use <stdarg.h> instead of <varargs.h>.
|
||||
|
||||
2004-04-12 Zoltan Varga <[email protected]>
|
||||
|
||||
* mono-jni.c: Fix compilation under gcc 2.95 + fix warnings.
|
||||
|
||||
2004-04-07 Zoltan Varga <[email protected]>
|
||||
|
||||
* mono-jni.c Makefile.am: New files.
|
||||
|
||||
@@ -1,15 +0,0 @@
|
||||
|
||||
INCLUDES = \
|
||||
-I$(top_srcdir) \
|
||||
$(IKVM_JNI_CFLAGS) \
|
||||
$(GMODULE_CFLAGS) \
|
||||
$(GLIB_CFLAGS)
|
||||
|
||||
if JIT_SUPPORTED
|
||||
|
||||
lib_LTLIBRARIES = libmono-ikvm-jni.la
|
||||
endif
|
||||
|
||||
libmono_ikvm_jni_la_SOURCES = mono-jni.c
|
||||
libmono_ikvm_jni_la_LIBADD = $(top_builddir)/mono/mini/libmono.la
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
.deps
|
||||
aclocal.m4
|
||||
config.cache
|
||||
config.guess
|
||||
config.h
|
||||
config.h.in
|
||||
config.log
|
||||
config.status
|
||||
config.sub
|
||||
configure
|
||||
fficonfig.h
|
||||
fficonfig.h.in
|
||||
Makefile
|
||||
Makefile.in
|
||||
stamp-h
|
||||
stamp-h.in
|
||||
@@ -0,0 +1,440 @@
|
||||
2001-08-16 Alex Graveley <[email protected]>
|
||||
|
||||
* libffi/include/fficonfig.h: Remove as this is auto generated.
|
||||
|
||||
* Makefile.am: Only generate libffi.a.
|
||||
|
||||
* configure.in: replace A[CM]_PROG_LIBTOOL with AC_PROG_RANLIB.
|
||||
|
||||
Sun Apr 22 15:50:08 2001 Anthony Green <[email protected]>
|
||||
|
||||
* include/ffi_common.h: Delete, after moving contents to...
|
||||
* include/ffi_private.h: Subsume contents of ffi_common.h.
|
||||
* include/Makefile.am (noinst_HEADERS): Remove ffi_common.h.
|
||||
* include/Makefile.in: Rebuilt.
|
||||
* arm/ffi.c, m68k/ffi.c, mips/ffi.c, powerpc/ffi.c, s390/ffi.c,
|
||||
ia64/ffi.c: Include ffi_private.h, not ffi_common.h.
|
||||
* alpha/ffi.c, sparc/ffi.c, x86/ffi.c: Don't include ffi_common.h.
|
||||
* types.c, raw_api.c, java_raw_api.c, prep_cif.c: Don't include
|
||||
ffi_common.h.
|
||||
* debug.c: Include ffi_private.h instead of ffi_common.h.
|
||||
|
||||
* mips/ffi.c (calc_n32_struct_flags): Make static.
|
||||
(FIX_ARGP): Remove call to debugging routine ffi_stop_here.
|
||||
|
||||
* mips/n32.S: Include ffi_private.h.
|
||||
* mips/o32.S: Include ffi_private.h.
|
||||
|
||||
Sun Apr 22 12:37:44 2001 Anthony Green <[email protected]>
|
||||
|
||||
* README: Update some comments.
|
||||
|
||||
* Makefile.am (SUBDIRS): Add include so ffi.h gets installed.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
* include/ffi.h: Change ALPHA to __alpha__ and SPARC to __sparc__.
|
||||
* types.c: Ditto.
|
||||
* prep_cif.c (ffi_prep_cif): Ditto.
|
||||
|
||||
* alpha/ffi.c, alpha/osf.S, sparc/ffi.c, sparc/v8.S, sparc/v9.S:
|
||||
Include ffi_private.h.
|
||||
|
||||
* include/ffi_private.h (FFI_TYPE_LAST): Define.
|
||||
|
||||
Sun Apr 22 11:41:55 2001 Anthony Green <[email protected]>
|
||||
|
||||
* Revolutionary changes. Target independent ffi.h. dejagnu
|
||||
testing infrastructure. Moved source files around. Configure no
|
||||
longer depends on run tests.
|
||||
|
||||
Sat Apr 14 20:49:46 2001 Anthony Green <[email protected]>
|
||||
|
||||
* mips/ffi.c: Include mips/mips.h.
|
||||
* mips/o32.S: Ditto.
|
||||
* mips/n32.S: Ditto.
|
||||
* mips/o32.s: Deleted.
|
||||
* mips/n32.s: Deleted.
|
||||
|
||||
Sat Apr 14 20:47:13 2001 Anthony Green <[email protected]>
|
||||
|
||||
* mips/mips.h: Moved from include/ffi_mips.h.
|
||||
|
||||
Sat Apr 14 20:09:05 2001 Anthony Green <[email protected]>
|
||||
|
||||
* powerpc/asm.h: Remove rcs id.
|
||||
|
||||
Sat Apr 14 15:04:08 2001 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in: Use AC_COMPILE_CHECK_SIZEOF and
|
||||
AC_C_BIGENDIAN_CROSS.
|
||||
|
||||
Sat Apr 14 15:02:53 2001 Anthony Green <[email protected]>
|
||||
|
||||
* aclocal.m4: Rebuilt.
|
||||
* acinclude.m4: New file. Add AC_COMPILE_CHECK_SIZEOF and
|
||||
AC_C_BIGENDIAN_CROSS.
|
||||
|
||||
2001-04-8 Neale Ferguson <[email protected]>
|
||||
|
||||
* src/s390/ffi.c: New file.
|
||||
* src/s390/sysv.S: New file.
|
||||
* include/ffi.h: Add s390 bits.
|
||||
* configure.in: Ditto.
|
||||
* configure: Rebuild.
|
||||
|
||||
2001-03-29 Bryce McKinlay <[email protected]>
|
||||
|
||||
* configure.in: Use different syntax for subdirectory creation.
|
||||
* configure: Rebuilt.
|
||||
|
||||
2001-03-27 Jon Beniston <[email protected]>
|
||||
|
||||
* configure.in: Added X86_WIN32 target (Win32, CygWin, MingW).
|
||||
* configure: Rebuilt.
|
||||
* Makefile.am: Added X86_WIN32 target support.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
* include/ffi.h.in: Added X86_WIN32 target support.
|
||||
|
||||
* src/ffitest.c: Doesn't run structure tests for X86_WIN32 targets.
|
||||
* src/types.c: Added X86_WIN32 target support.
|
||||
|
||||
* src/x86/win32.S: New file. Based on sysv.S, but with EH
|
||||
stuff removed and made to work with CygWin's gas.
|
||||
|
||||
2001-03-26 Bryce McKinlay <[email protected]>
|
||||
|
||||
* configure.in: Make target subdirectory in build dir.
|
||||
* Makefile.am: Override suffix based rules to specify correct output
|
||||
subdirectory.
|
||||
* Makefile.in: Rebuilt.
|
||||
* configure: Rebuilt.
|
||||
|
||||
2001-03-23 Kevin B Hendricks <[email protected]>
|
||||
|
||||
* src/powerpc/ppc_closure.S: New file.
|
||||
* src/powerpc/ffi.c (ffi_prep_args): Fixed ABI compatibility bug
|
||||
involving long long and register pairs.
|
||||
(ffi_prep_closure): New function.
|
||||
(flush_icache): Likewise.
|
||||
(ffi_closure_helper_SYSV): Likewise.
|
||||
* include/ffi.h.in (FFI_CLOSURES): Define on PPC.
|
||||
(FFI_TRAMPOLINE_SIZE): Likewise.
|
||||
(FFI_NATIVE_RAW_API): Likewise.
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (EXTRA_DIST): Added src/powerpc/ppc_closure.S.
|
||||
(TARGET_SRC_POWERPC): Likewise.
|
||||
|
||||
2001-03-19 Tom Tromey <[email protected]>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (ffitest_LDFLAGS): New macro.
|
||||
|
||||
2001-03-02 Nick Clifton <[email protected]>
|
||||
|
||||
* include/ffi.h.in: Remove RCS ident string.
|
||||
* include/ffi_mips.h: Remove RCS ident string.
|
||||
* src/debug.c: Remove RCS ident string.
|
||||
* src/ffitest.c: Remove RCS ident string.
|
||||
* src/prep_cif.c: Remove RCS ident string.
|
||||
* src/types.c: Remove RCS ident string.
|
||||
* src/alpha/ffi.c: Remove RCS ident string.
|
||||
* src/alpha/osf.S: Remove RCS ident string.
|
||||
* src/arm/ffi.c: Remove RCS ident string.
|
||||
* src/arm/sysv.S: Remove RCS ident string.
|
||||
* src/mips/ffi.c: Remove RCS ident string.
|
||||
* src/mips/n32.S: Remove RCS ident string.
|
||||
* src/mips/o32.S: Remove RCS ident string.
|
||||
* src/sparc/ffi.c: Remove RCS ident string.
|
||||
* src/sparc/v8.S: Remove RCS ident string.
|
||||
* src/sparc/v9.S: Remove RCS ident string.
|
||||
* src/x86/ffi.c: Remove RCS ident string.
|
||||
* src/x86/sysv.S: Remove RCS ident string.
|
||||
|
||||
2001-02-08 Joseph S. Myers <[email protected]>
|
||||
|
||||
* include/ffi.h.in: Change sourceware.cygnus.com references to
|
||||
gcc.gnu.org.
|
||||
|
||||
2000-12-09 Richard Henderson <[email protected]>
|
||||
|
||||
* src/alpha/ffi.c (ffi_call): Simplify struct return test.
|
||||
(ffi_closure_osf_inner): Index rather than increment avalue
|
||||
and arg_types. Give ffi_closure_osf the raw return value type.
|
||||
* src/alpha/osf.S (ffi_closure_osf): Handle return value type
|
||||
promotion.
|
||||
|
||||
2000-12-07 Richard Henderson <[email protected]>
|
||||
|
||||
* src/raw_api.c (ffi_translate_args): Fix typo.
|
||||
(ffi_prep_closure): Likewise.
|
||||
|
||||
* include/ffi.h.in [ALPHA]: Define FFI_CLOSURES and
|
||||
FFI_TRAMPOLINE_SIZE.
|
||||
* src/alpha/ffi.c (ffi_prep_cif_machdep): Adjust minimal
|
||||
cif->bytes for new ffi_call_osf implementation.
|
||||
(ffi_prep_args): Absorb into ...
|
||||
(ffi_call): ... here. Do all stack allocation here and
|
||||
avoid a callback function.
|
||||
(ffi_prep_closure, ffi_closure_osf_inner): New.
|
||||
* src/alpha/osf.S (ffi_call_osf): Reimplement with no callback.
|
||||
(ffi_closure_osf): New.
|
||||
|
||||
2000-09-10 Alexandre Oliva <[email protected]>
|
||||
|
||||
* config.guess, config.sub, install-sh: Removed.
|
||||
* ltconfig, ltmain.sh, missing, mkinstalldirs: Likewise.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
* acinclude.m4: Include libtool macros from the top level.
|
||||
* aclocal.m4, configure: Rebuilt.
|
||||
|
||||
2000-08-22 Alexandre Oliva <[email protected]>
|
||||
|
||||
* configure.in [i*86-*-freebsd*] (TARGET, TARGETDIR): Set.
|
||||
* configure: Rebuilt.
|
||||
|
||||
2000-05-11 Scott Bambrough <[email protected]>
|
||||
|
||||
* libffi/src/arm/sysv.S (ffi_call_SYSV): Doubles are not saved to
|
||||
memory correctly. Use conditional instructions, not branches where
|
||||
possible.
|
||||
|
||||
2000-05-04 Tom Tromey <[email protected]>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Match `arm*-*-linux-*'.
|
||||
From Chris Dornan <[email protected]>.
|
||||
|
||||
2000-04-28 Jakub Jelinek <[email protected]>
|
||||
|
||||
* Makefile.am (SUBDIRS): Define.
|
||||
(AM_MAKEFLAGS): Likewise.
|
||||
(Multilib support.): Add section.
|
||||
* Makefile.in: Rebuilt.
|
||||
* ltconfig (extra_compiler_flags, extra_compiler_flags_value):
|
||||
New variables. Set for gcc using -print-multi-lib. Export them
|
||||
to libtool.
|
||||
(sparc64-*-linux-gnu*): Use libsuff 64 for search paths.
|
||||
* ltmain.sh (B|b|V): Don't throw away gcc's -B, -b and -V options
|
||||
for -shared links.
|
||||
(extra_compiler_flags_value, extra_compiler_flags): Check these
|
||||
for extra compiler options which need to be passed down in
|
||||
compiler_flags.
|
||||
|
||||
2000-04-16 Anthony Green <[email protected]>
|
||||
|
||||
* README: Credit updates. Update supported platorms.
|
||||
|
||||
* include/ffi.h.in: Important size fixes from William Knottenblet
|
||||
([email protected]).
|
||||
|
||||
2000-04-16 Anthony Green <[email protected]>
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Change i*86-pc-linux* to i*86-*-linux*.
|
||||
|
||||
2000-04-14 Jakub Jelinek <[email protected]>
|
||||
|
||||
* include/ffi.h.in (SPARC64): Define for 64bit SPARC builds.
|
||||
Set SPARC FFI_DEFAULT_ABI based on SPARC64 define.
|
||||
* src/sparc/ffi.c (ffi_prep_args_v8): Renamed from ffi_prep_args.
|
||||
Replace all void * sizeofs with sizeof(int).
|
||||
Only compare type with FFI_TYPE_LONGDOUBLE if LONGDOUBLE is
|
||||
different than DOUBLE.
|
||||
Remove FFI_TYPE_SINT32 and FFI_TYPE_UINT32 cases (handled elsewhere).
|
||||
(ffi_prep_args_v9): New function.
|
||||
(ffi_prep_cif_machdep): Handle V9 ABI and long long on V8.
|
||||
(ffi_V9_return_struct): New function.
|
||||
(ffi_call): Handle FFI_V9 ABI from 64bit code and FFI_V8 ABI from
|
||||
32bit code (not yet cross-arch calls).
|
||||
* src/sparc/v8.S: Add struct return delay nop.
|
||||
Handle long long.
|
||||
* src/sparc/v9.S: New file.
|
||||
* src/prep_cif.c (ffi_prep_cif): Return structure pointer
|
||||
is used on sparc64 only for structures larger than 32 bytes.
|
||||
Pass by reference for structures is done for structure arguments
|
||||
larger than 16 bytes.
|
||||
* src/ffitest.c (main): Use 64bit rint on sparc64.
|
||||
Run long long tests on sparc.
|
||||
* src/types.c (FFI_TYPE_POINTER): Pointer is 64bit on alpha and
|
||||
sparc64.
|
||||
(FFI_TYPE_LONGDOUBLE): long double is 128 bit aligned to 128 bits
|
||||
on sparc64.
|
||||
* configure.in (sparc-*-linux*): New supported target.
|
||||
(sparc64-*-linux*): Likewise.
|
||||
* configure: Rebuilt.
|
||||
* Makefile.am: Add v9.S to SPARC files.
|
||||
* Makefile.in: Likewise.
|
||||
(LINK): Surround $(CCLD) into double quotes, so that multilib
|
||||
compiles work correctly.
|
||||
|
||||
2000-04-04 Alexandre Petit-Bianco <[email protected]>
|
||||
|
||||
* configure: Rebuilt.
|
||||
|
||||
* configure.in: (i*86-*-solaris*): New libffi target. Patch
|
||||
proposed by Bryce McKinlay.
|
||||
|
||||
2000-03-20 Tom Tromey <[email protected]>
|
||||
|
||||
* Makefile.in: Hand edit for java_raw_api.lo.
|
||||
|
||||
2000-03-08 Bryce McKinlay <[email protected]>
|
||||
|
||||
* config.guess, config.sub: Update from the gcc tree.
|
||||
Fix for PR libgcj/168.
|
||||
|
||||
2000-03-03 Tom Tromey <[email protected]>
|
||||
|
||||
* Makefile.in: Fixed ia64 by hand.
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in (--enable-multilib): New option.
|
||||
(libffi_basedir): New subst.
|
||||
(AC_OUTPUT): Added multilib code.
|
||||
|
||||
2000-03-02 Tom Tromey <[email protected]>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (TARGET_SRC_IA64): Use `ia64', not `alpha', as
|
||||
directory name.
|
||||
|
||||
2000-02-25 Hans Boehm <[email protected]>
|
||||
|
||||
* src/ia64/ffi.c, src/ia64/ia64_flags.h, src/ia64/unix.S: New
|
||||
files.
|
||||
* src/raw_api.c (ffi_translate_args): Fixed typo in argument
|
||||
list.
|
||||
(ffi_prep_raw_closure): Use ffi_translate_args, not
|
||||
ffi_closure_translate.
|
||||
* src/java_raw_api.c: New file.
|
||||
* src/ffitest.c (closure_test_fn): New function.
|
||||
(main): Define `rint' as long long on IA64. Added new test when
|
||||
FFI_CLOSURES is defined.
|
||||
* include/ffi.h.in (ALIGN): Use size_t, not unsigned.
|
||||
(ffi_abi): Recognize IA64.
|
||||
(ffi_raw): Added `flt' field.
|
||||
Added "Java raw API" code.
|
||||
* configure.in: Recognize ia64.
|
||||
* Makefile.am (TARGET_SRC_IA64): New macro.
|
||||
(libffi_la_common_SOURCES): Added java_raw_api.c.
|
||||
(libffi_la_SOURCES): Define in IA64 case.
|
||||
|
||||
2000-01-04 Tom Tromey <[email protected]>
|
||||
|
||||
* Makefile.in: Rebuilt with newer automake.
|
||||
|
||||
1999-12-31 Tom Tromey <[email protected]>
|
||||
|
||||
* Makefile.am (INCLUDES): Added -I$(top_srcdir)/src.
|
||||
|
||||
1999-09-01 Tom Tromey <[email protected]>
|
||||
|
||||
* include/ffi.h.in: Removed PACKAGE and VERSION defines and
|
||||
undefs.
|
||||
* fficonfig.h.in: Rebuilt.
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Pass 3rd argument to AM_INIT_AUTOMAKE.
|
||||
Use AM_PROG_LIBTOOL (automake 1.4 compatibility).
|
||||
* acconfig.h: Don't #undef PACKAGE or VERSION.
|
||||
|
||||
1999-08-09 Anthony Green <[email protected]>
|
||||
|
||||
* include/ffi.h.in: Try to work around messy header problem
|
||||
with PACKAGE and VERSION.
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in: Change version to 2.00-beta.
|
||||
|
||||
* fficonfig.h.in: Rebuilt.
|
||||
* acconfig.h (FFI_NO_STRUCTS, FFI_NO_RAW_API): Define.
|
||||
|
||||
* src/x86/ffi.c (ffi_raw_call): Rename.
|
||||
|
||||
Mon Aug 9 18:33:38 1999 Rainer Orth <[email protected]>
|
||||
|
||||
* include/Makefile.in: Rebuilt.
|
||||
* Makefile.in: Rebuilt
|
||||
* Makefile.am (toolexeclibdir): Add $(MULTISUBDIR) even for native
|
||||
builds.
|
||||
Use USE_LIBDIR.
|
||||
|
||||
* configure: Rebuilt.
|
||||
* configure.in (USE_LIBDIR): Define for native builds.
|
||||
Use lowercase in configure --help explanations.
|
||||
|
||||
1999-08-08 Anthony Green <[email protected]>
|
||||
|
||||
* include/ffi.h.in (FFI_FN): Remove `...'.
|
||||
|
||||
1999-08-08 Anthony Green <[email protected]>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (AM_CFLAGS): Compile with -fexceptions.
|
||||
|
||||
* src/x86/sysv.S: Add exception handling metadata.
|
||||
|
||||
1999-08-02 Kresten Krab Thorup <[email protected]>
|
||||
|
||||
* src/x86/ffi.c (ffi_closure_SYSV): New function.
|
||||
(ffi_prep_incoming_args_SYSV): Ditto.
|
||||
(ffi_prep_closure): Ditto.
|
||||
(ffi_closure_raw_SYSV): Ditto.
|
||||
(ffi_prep_raw_closure): More ditto.
|
||||
(ffi_call_raw): Final ditto.
|
||||
|
||||
* include/ffi.h.in: Add definitions for closure and raw API.
|
||||
|
||||
* src/x86/ffi.c (ffi_prep_cif_machdep): Added case for
|
||||
FFI_TYPE_UINT64.
|
||||
|
||||
* Makefile.am (libffi_la_common_SOURCES): Added raw_api.c
|
||||
|
||||
* src/raw_api.c: New file.
|
||||
|
||||
* include/ffi.h.in (ffi_raw): New type.
|
||||
(UINT_ARG, SINT_ARG): New defines.
|
||||
(ffi_closure, ffi_raw_closure): New types.
|
||||
(ffi_prep_closure, ffi_prep_raw_closure): New declarations.
|
||||
|
||||
* configure.in: Add check for endianness and sizeof void*.
|
||||
|
||||
* src/x86/sysv.S (ffi_call_SYSV): Call fixup routine via argument,
|
||||
instead of directly.
|
||||
|
||||
* configure: Rebuilt.
|
||||
|
||||
Thu Jul 8 14:28:42 1999 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in: Add x86 and powerpc BeOS configurations.
|
||||
From Makoto Kato <[email protected]>.
|
||||
|
||||
1999-05-09 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in: Add warning about this being beta code.
|
||||
Remove src/Makefile.am from the picture.
|
||||
* configure: Rebuilt.
|
||||
|
||||
* Makefile.am: Move logic from src/Makefile.am. Add changes
|
||||
to support libffi as a target library.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
* aclocal.m4, config.guess, config.sub, ltconfig, ltmain.sh:
|
||||
Upgraded to new autoconf, automake, libtool.
|
||||
|
||||
* README: Tweaks.
|
||||
|
||||
* LICENSE: Update copyright date.
|
||||
|
||||
* src/Makefile.am, src/Makefile.in: Removed.
|
||||
|
||||
1998-11-29 Anthony Green <[email protected]>
|
||||
|
||||
* include/ChangeLog: Removed.
|
||||
* src/ChangeLog: Removed.
|
||||
* src/mips/ChangeLog: Removed.
|
||||
* src/sparc/ChangeLog: Remboved.
|
||||
* src/x86/ChangeLog: Removed.
|
||||
|
||||
* ChangeLog.v1: Created.
|
||||
@@ -0,0 +1,764 @@
|
||||
The libffi version 1 ChangeLog archive.
|
||||
|
||||
Version 1 of libffi had per-directory ChangeLogs. Current and future
|
||||
versions have a single ChangeLog file in the root directory. The
|
||||
version 1 ChangeLogs have all been concatonated into this file for
|
||||
future reference only.
|
||||
|
||||
--- libffi ----------------------------------------------------------------
|
||||
|
||||
Mon Oct 5 02:17:50 1998 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in: Boosted rev.
|
||||
* configure, Makefile.in, aclocal.m4: Rebuilt.
|
||||
* README: Boosted rev and updated release notes.
|
||||
|
||||
Mon Oct 5 01:03:03 1998 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in: Boosted rev.
|
||||
* configure, Makefile.in, aclocal.m4: Rebuilt.
|
||||
* README: Boosted rev and updated release notes.
|
||||
|
||||
1998-07-25 Andreas Schwab <[email protected]>
|
||||
|
||||
* m68k/ffi.c (ffi_prep_cif_machdep): Use bitmask for cif->flags.
|
||||
Correctly handle small structures.
|
||||
(ffi_prep_args): Also handle small structures.
|
||||
(ffi_call): Pass size of return type to ffi_call_SYSV.
|
||||
* m68k/sysv.S: Adjust for above changes. Correctly align small
|
||||
structures in the return value.
|
||||
|
||||
* types.c (uint64, sint64) [M68K]: Change alignment to 4.
|
||||
|
||||
Fri Apr 17 17:26:58 1998 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in: Boosted rev.
|
||||
* configure,Makefile.in,aclocal.m4: Rebuilt.
|
||||
* README: Boosted rev and added release notes.
|
||||
|
||||
Sun Feb 22 00:50:41 1998 Geoff Keating <[email protected]>
|
||||
|
||||
* configure.in: Add PowerPC config bits.
|
||||
|
||||
1998-02-14 Andreas Schwab <[email protected]>
|
||||
|
||||
* configure.in: Add m68k config bits. Change AC_CANONICAL_SYSTEM
|
||||
to AC_CANONICAL_HOST, this is not a compiler. Use $host instead
|
||||
of $target. Remove AC_CHECK_SIZEOF(char), we already know the
|
||||
result. Fix argument of AC_ARG_ENABLE.
|
||||
* configure, fficonfig.h.in: Rebuilt.
|
||||
|
||||
Tue Feb 10 20:53:40 1998 Richard Henderson <[email protected]>
|
||||
|
||||
* configure.in: Add Alpha config bits.
|
||||
|
||||
Tue May 13 13:39:20 1997 Anthony Green <[email protected]>
|
||||
|
||||
* README: Updated dates and reworded Irix comments.
|
||||
|
||||
* configure.in: Removed AC_PROG_RANLIB.
|
||||
|
||||
* Makefile.in, aclocal.m4, config.guess, config.sub, configure,
|
||||
ltmain.sh, */Makefile.in: libtoolized again and rebuilt with
|
||||
automake and autoconf.
|
||||
|
||||
Sat May 10 18:44:50 1997 Tom Tromey <[email protected]>
|
||||
|
||||
* configure, aclocal.m4: Rebuilt.
|
||||
* configure.in: Don't compute EXTRADIST; now handled in
|
||||
src/Makefile.in. Removed macros implied by AM_INIT_AUTOMAKE.
|
||||
Don't run AM_MAINTAINER_MODE.
|
||||
|
||||
Thu May 8 14:34:05 1997 Anthony Green <[email protected]>
|
||||
|
||||
* missing, ltmain.sh, ltconfig.sh: Created. These are new files
|
||||
required by automake and libtool.
|
||||
|
||||
* README: Boosted rev to 1.14. Added notes.
|
||||
|
||||
* acconfig.h: Moved PACKAGE and VERSION for new automake.
|
||||
|
||||
* configure.in: Changes for libtool.
|
||||
|
||||
* Makefile.am (check): make test now make check. Uses libtool now.
|
||||
|
||||
* Makefile.in, configure.in, aclocal.h, fficonfig.h.in: Rebuilt.
|
||||
|
||||
Thu May 1 16:27:07 1997 Anthony Green <[email protected]>
|
||||
|
||||
* missing: Added file required by new automake.
|
||||
|
||||
Tue Nov 26 14:10:42 1996 Anthony Green <[email protected]>
|
||||
|
||||
* acconfig.h: Added USING_PURIFY flag. This is defined when
|
||||
--enable-purify-safety was used at configure time.
|
||||
|
||||
* configure.in (allsources): Added --enable-purify-safety switch.
|
||||
(VERSION): Boosted rev to 1.13.
|
||||
* configure: Rebuilt.
|
||||
|
||||
Fri Nov 22 06:46:12 1996 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in (VERSION): Boosted rev to 1.12.
|
||||
Removed special CFLAGS hack for gcc.
|
||||
* configure: Rebuilt.
|
||||
|
||||
* README: Boosted rev to 1.12. Added notes.
|
||||
|
||||
* Many files: Cygnus Support changed to Cygnus Solutions.
|
||||
|
||||
Wed Oct 30 11:15:25 1996 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in (VERSION): Boosted rev to 1.11.
|
||||
* configure: Rebuilt.
|
||||
|
||||
* README: Boosted rev to 1.11. Added notes about GNU make.
|
||||
|
||||
Tue Oct 29 12:25:12 1996 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in: Fixed -Wall trick.
|
||||
(VERSION): Boosted rev.
|
||||
* configure: Rebuilt
|
||||
|
||||
* acconfig.h: Needed for --enable-debug configure switch.
|
||||
|
||||
* README: Boosted rev to 1.09. Added more notes on building
|
||||
libffi, and LCLint.
|
||||
|
||||
* configure.in: Added --enable-debug switch. Boosted rev to
|
||||
1.09.
|
||||
* configure: Rebuilt
|
||||
|
||||
Tue Oct 15 13:11:28 1996 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in (VERSION): Boosted rev to 1.08
|
||||
* configure: Rebuilt.
|
||||
|
||||
* README: Added n32 bug fix notes.
|
||||
|
||||
* Makefile.am: Added "make lint" production.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
Mon Oct 14 10:54:46 1996 Anthony Green <[email protected]>
|
||||
|
||||
* README: Added web page reference.
|
||||
|
||||
* configure.in, README: Boosted rev to 1.05
|
||||
* configure: Rebuilt.
|
||||
|
||||
* README: Fixed n32 sample code.
|
||||
|
||||
Fri Oct 11 17:09:28 1996 Anthony Green <[email protected]>
|
||||
|
||||
* README: Added sparc notes.
|
||||
|
||||
* configure.in, README: Boosted rev to 1.04.
|
||||
* configure: Rebuilt.
|
||||
|
||||
Thu Oct 10 10:31:03 1996 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in, README: Boosted rev to 1.03.
|
||||
* configure: Rebuilt.
|
||||
|
||||
* README: Added struct notes.
|
||||
|
||||
* Makefile.am (EXTRA_DIST): Added LICENSE to distribution.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
* README: Removed Linux section. No special notes now
|
||||
because aggregates arg/return types work.
|
||||
|
||||
Wed Oct 9 16:16:42 1996 Anthony Green <[email protected]>
|
||||
|
||||
* README, configure.in (VERSION): Boosted rev to 1.02
|
||||
* configure: Rebuilt.
|
||||
|
||||
Tue Oct 8 11:56:33 1996 Anthony Green <[email protected]>
|
||||
|
||||
* README (NOTE): Added n32 notes.
|
||||
|
||||
* Makefile.am: Added test production.
|
||||
* Makefile: Rebuilt
|
||||
|
||||
* README: spell checked!
|
||||
|
||||
* configure.in (VERSION): Boosted rev to 1.01
|
||||
* configure: Rebuilt.
|
||||
|
||||
Mon Oct 7 15:50:22 1996 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in: Added nasty bit to support SGI tools.
|
||||
* configure: Rebuilt.
|
||||
|
||||
* README: Added SGI notes. Added note about automake bug.
|
||||
|
||||
Mon Oct 7 11:00:28 1996 Anthony Green <[email protected]>
|
||||
|
||||
* README: Rewrote intro, and fixed examples.
|
||||
|
||||
Fri Oct 4 10:19:55 1996 Anthony Green <[email protected]>
|
||||
|
||||
* configure.in: -D$TARGET is no longer used as a compiler switch.
|
||||
It is now inserted into ffi.h at configure time.
|
||||
* configure: Rebuilt.
|
||||
|
||||
* FFI_ABI and FFI_STATUS are now ffi_abi and ffi_status.
|
||||
|
||||
Thu Oct 3 13:47:34 1996 Anthony Green <[email protected]>
|
||||
|
||||
* README, LICENSE: Created. Wrote some docs.
|
||||
|
||||
* configure.in: Don't barf on i586-unknown-linuxaout.
|
||||
Added EXTRADIST code for "make dist".
|
||||
* configure: Rebuilt.
|
||||
|
||||
* */Makefile.in: Rebuilt with patched automake.
|
||||
|
||||
Tue Oct 1 17:12:25 1996 Anthony Green <[email protected]>
|
||||
|
||||
* Makefile.am, aclocal.m4, config.guess, config.sub,
|
||||
configure.in, fficonfig.h.in, install-sh, mkinstalldirs,
|
||||
stamp-h.in: Created
|
||||
* Makefile.in, configure: Generated
|
||||
|
||||
--- libffi/include --------------------------------------------------------
|
||||
|
||||
Tue Feb 24 13:09:36 1998 Anthony Green <[email protected]>
|
||||
|
||||
* ffi_mips.h: Updated FFI_TYPE_STRUCT_* values based on
|
||||
ffi.h.in changes. This is a work-around for SGI's "simple"
|
||||
assembler.
|
||||
|
||||
Sun Feb 22 00:51:55 1998 Geoff Keating <[email protected]>
|
||||
|
||||
* ffi.h.in: PowerPC support.
|
||||
|
||||
1998-02-14 Andreas Schwab <[email protected]>
|
||||
|
||||
* ffi.h.in: Add m68k support.
|
||||
(FFI_TYPE_LONGDOUBLE): Make it a separate value.
|
||||
|
||||
Tue Feb 10 20:55:16 1998 Richard Henderson <[email protected]>
|
||||
|
||||
* ffi.h.in (SIZEOF_ARG): Use a pointer type by default.
|
||||
|
||||
* ffi.h.in: Alpha support.
|
||||
|
||||
Fri Nov 22 06:48:45 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.h.in, ffi_common.h: Cygnus Support -> Cygnus Solutions.
|
||||
|
||||
Wed Nov 20 22:31:01 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.h.in: Added ffi_type_void definition.
|
||||
|
||||
Tue Oct 29 12:22:40 1996 Anthony Green <[email protected]>
|
||||
|
||||
* Makefile.am (hack_DATA): Always install ffi_mips.h.
|
||||
|
||||
* ffi.h.in: Removed FFI_DEBUG. It's now in the correct
|
||||
place (acconfig.h).
|
||||
Added #include <stddef.h> for size_t definition.
|
||||
|
||||
Tue Oct 15 17:23:35 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.h.in, ffi_common.h, ffi_mips.h: More clean up.
|
||||
Commented out #define of FFI_DEBUG.
|
||||
|
||||
Tue Oct 15 13:01:06 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi_common.h: Added bool definition.
|
||||
|
||||
* ffi.h.in, ffi_common.h: Clean up based on LCLint output.
|
||||
Added funny /*@...@*/ comments to annotate source.
|
||||
|
||||
Mon Oct 14 12:29:23 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.h.in: Interface changes based on feedback from Jim
|
||||
Blandy.
|
||||
|
||||
Fri Oct 11 16:49:35 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.h.in: Small change for sparc support.
|
||||
|
||||
Thu Oct 10 14:53:37 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi_mips.h: Added FFI_TYPE_STRUCT_* definitions for
|
||||
special structure return types.
|
||||
|
||||
Wed Oct 9 13:55:57 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.h.in: Added SIZEOF_ARG definition for X86
|
||||
|
||||
Tue Oct 8 11:40:36 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.h.in (FFI_FN): Added macro for eliminating compiler warnings.
|
||||
Use it to case your function pointers to the proper type.
|
||||
|
||||
* ffi_mips.h (SIZEOF_ARG): Added magic to fix type promotion bug.
|
||||
|
||||
* Makefile.am (EXTRA_DIST): Added ffi_mips.h to EXTRA_DIST.
|
||||
* Makefile: Rebuilt.
|
||||
|
||||
* ffi_mips.h: Created. Moved all common mips definitions here.
|
||||
|
||||
Mon Oct 7 10:58:12 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.h.in: The SGI assember is very picky about parens. Redefined
|
||||
some macros to avoid problems.
|
||||
|
||||
* ffi.h.in: Added FFI_DEFAULT_ABI definitions. Also added
|
||||
externs for pointer, and 64bit integral ffi_types.
|
||||
|
||||
Fri Oct 4 09:51:37 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.h.in: Added FFI_ABI member to ffi_cif and changed
|
||||
function prototypes accordingly.
|
||||
Added #define @TARGET@. Now programs including ffi.h don't
|
||||
have to specify this themselves.
|
||||
|
||||
Thu Oct 3 15:36:44 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.h.in: Changed ffi_prep_cif's values from void* to void**
|
||||
|
||||
* Makefile.am (EXTRA_DIST): Added EXTRA_DIST for "make dist"
|
||||
to work.
|
||||
* Makefile.in: Regenerated.
|
||||
|
||||
Wed Oct 2 10:16:59 1996 Anthony Green <[email protected]>
|
||||
|
||||
* Makefile.am: Created
|
||||
* Makefile.in: Generated
|
||||
|
||||
* ffi_common.h: Added rcsid comment
|
||||
|
||||
Tue Oct 1 17:13:51 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.h.in, ffi_common.h: Created
|
||||
|
||||
--- libffi/src ------------------------------------------------------------
|
||||
|
||||
Mon Oct 5 02:17:50 1998 Anthony Green <[email protected]>
|
||||
|
||||
* arm/ffi.c, arm/sysv.S: Created.
|
||||
|
||||
* Makefile.am: Added arm files.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
Mon Oct 5 01:41:38 1998 Anthony Green <[email protected]>
|
||||
|
||||
* Makefile.am (libffi_la_LDFLAGS): Incremented revision.
|
||||
|
||||
Sun Oct 4 16:27:17 1998 Anthony Green <[email protected]>
|
||||
|
||||
* alpha/osf.S (ffi_call_osf): Patch for DU assembler.
|
||||
|
||||
* ffitest.c (main): long long and long double return values work
|
||||
for x86.
|
||||
|
||||
Fri Apr 17 11:50:58 1998 Anthony Green <[email protected]>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
* ffitest.c (main): Floating point tests not executed for systems
|
||||
with broken lond double (SunOS 4 w/ GCC).
|
||||
|
||||
* types.c: Fixed x86 alignment info for long long types.
|
||||
|
||||
Thu Apr 16 07:15:28 1998 Anthony Green <[email protected]>
|
||||
|
||||
* ffitest.c: Added more notes about GCC bugs under Irix 6.
|
||||
|
||||
Wed Apr 15 08:42:22 1998 Anthony Green <[email protected]>
|
||||
|
||||
* ffitest.c (struct5): New test function.
|
||||
(main): New test with struct5.
|
||||
|
||||
Thu Mar 5 10:48:11 1998 Anthony Green <[email protected]>
|
||||
|
||||
* prep_cif.c (initialize_aggregate): Fix assertion for
|
||||
nested structures.
|
||||
|
||||
Tue Feb 24 16:33:41 1998 Anthony Green <[email protected]>
|
||||
|
||||
* prep_cif.c (ffi_prep_cif): Added long double support for sparc.
|
||||
|
||||
Sun Feb 22 00:52:18 1998 Geoff Keating <[email protected]>
|
||||
|
||||
* powerpc/asm.h: New file.
|
||||
* powerpc/ffi.c: New file.
|
||||
* powerpc/sysv.S: New file.
|
||||
* Makefile.am: PowerPC port.
|
||||
* ffitest.c (main): Allow all tests to run even in presence of gcc
|
||||
bug on PowerPC.
|
||||
|
||||
1998-02-17 Anthony Green <[email protected]>
|
||||
|
||||
* mips/ffi.c: Fixed comment typo.
|
||||
|
||||
* x86/ffi.c (ffi_prep_cif_machdep), x86/sysv.S (retfloat):
|
||||
Fixed x86 long double return handling.
|
||||
|
||||
* types.c: Fixed x86 long double alignment info.
|
||||
|
||||
1998-02-14 Andreas Schwab <[email protected]>
|
||||
|
||||
* types.c: Add m68k support.
|
||||
|
||||
* ffitest.c (floating): Add long double parameter.
|
||||
(return_ll, ldblit): New functions to test long long and long
|
||||
double return value.
|
||||
(main): Fix type error in assignment of ts[1-4]_type.elements.
|
||||
Add tests for long long and long double arguments and return
|
||||
values.
|
||||
|
||||
* prep_cif.c (ffi_prep_cif) [M68K]: Don't allocate argument for
|
||||
struct value pointer.
|
||||
|
||||
* m68k/ffi.c, m68k/sysv.S: New files.
|
||||
* Makefile.am: Add bits for m68k port. Add kludge to work around
|
||||
automake deficiency.
|
||||
(test): Don't require "." in $PATH.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
Wed Feb 11 07:36:50 1998 Anthony Green <[email protected]>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
Tue Feb 10 20:56:00 1998 Richard Henderson <[email protected]>
|
||||
|
||||
* alpha/ffi.c, alpha/osf.S: New files.
|
||||
* Makefile.am: Alpha port.
|
||||
|
||||
Tue Nov 18 14:12:07 1997 Anthony Green <[email protected]>
|
||||
|
||||
* mips/ffi.c (ffi_prep_cif_machdep): Initialize rstruct_flag
|
||||
for n32.
|
||||
|
||||
Tue Jun 3 17:18:20 1997 Anthony Green <[email protected]>
|
||||
|
||||
* ffitest.c (main): Added hack to get structure tests working
|
||||
correctly.
|
||||
|
||||
Sat May 10 19:06:42 1997 Tom Tromey <[email protected]>
|
||||
|
||||
* Makefile.in: Rebuilt.
|
||||
* Makefile.am (EXTRA_DIST): Explicitly list all distributable
|
||||
files in subdirs.
|
||||
(VERSION, CC): Removed.
|
||||
|
||||
Thu May 8 17:19:01 1997 Anthony Green <[email protected]>
|
||||
|
||||
* Makefile.am: Many changes for new automake and libtool.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
Fri Nov 22 06:57:56 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffitest.c (main): Fixed test case for non mips machines.
|
||||
|
||||
Wed Nov 20 22:31:59 1996 Anthony Green <[email protected]>
|
||||
|
||||
* types.c: Added ffi_type_void declaration.
|
||||
|
||||
Tue Oct 29 13:07:19 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffitest.c (main): Fixed character constants.
|
||||
(main): Emit warning for structure test 3 failure on Sun.
|
||||
|
||||
* Makefile.am (VPATH): Fixed VPATH def'n so automake won't
|
||||
strip it out.
|
||||
Moved distdir hack from libffi to automake.
|
||||
(ffitest): Added missing -c for $(COMPILE) (change in automake).
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
Tue Oct 15 13:08:20 1996 Anthony Green <[email protected]>
|
||||
|
||||
* Makefile.am: Added "make lint" production.
|
||||
* Makefile.in: Rebuilt.
|
||||
|
||||
* prep_cif.c (STACK_ARG_SIZE): Improved STACK_ARG_SIZE macro.
|
||||
Clean up based on LCLint output. Added funny /*@...@*/ comments to
|
||||
annotate source.
|
||||
|
||||
* ffitest.c, debug.c: Cleaned up code.
|
||||
|
||||
Mon Oct 14 12:26:56 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffitest.c: Changes based on interface changes.
|
||||
|
||||
* prep_cif.c (ffi_prep_cif): Cleaned up interface based on
|
||||
feedback from Jim Blandy.
|
||||
|
||||
Fri Oct 11 15:53:18 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffitest.c: Reordered tests while porting to sparc.
|
||||
Made changes to handle lame structure passing for sparc.
|
||||
Removed calls to fflush().
|
||||
|
||||
* prep_cif.c (ffi_prep_cif): Added special case for sparc
|
||||
aggregate type arguments.
|
||||
|
||||
Thu Oct 10 09:56:51 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffitest.c (main): Added structure passing/returning tests.
|
||||
|
||||
* prep_cif.c (ffi_prep_cif): Perform proper initialization
|
||||
of structure return types if needed.
|
||||
(initialize_aggregate): Bug fix
|
||||
|
||||
Wed Oct 9 16:04:20 1996 Anthony Green <[email protected]>
|
||||
|
||||
* types.c: Added special definitions for x86 (double doesn't
|
||||
need double word alignment).
|
||||
|
||||
* ffitest.c: Added many tests
|
||||
|
||||
Tue Oct 8 09:19:22 1996 Anthony Green <[email protected]>
|
||||
|
||||
* prep_cif.c (ffi_prep_cif): Fixed assertion.
|
||||
|
||||
* debug.c (ffi_assert): Must return a non void now.
|
||||
|
||||
* Makefile.am: Added test production.
|
||||
* Makefile: Rebuilt.
|
||||
|
||||
* ffitest.c (main): Created.
|
||||
|
||||
* types.c: Created. Stripped common code out of */ffi.c.
|
||||
|
||||
* prep_cif.c: Added missing stdlib.h include.
|
||||
|
||||
* debug.c (ffi_type_test): Used "a" to eliminate compiler
|
||||
warnings in non-debug builds. Included ffi_common.h.
|
||||
|
||||
Mon Oct 7 15:36:42 1996 Anthony Green <[email protected]>
|
||||
|
||||
* Makefile.am: Added a rule for .s -> .o
|
||||
This is required by the SGI compiler.
|
||||
* Makefile: Rebuilt.
|
||||
|
||||
Fri Oct 4 09:51:08 1996 Anthony Green <[email protected]>
|
||||
|
||||
* prep_cif.c (initialize_aggregate): Moved abi specification
|
||||
to ffi_prep_cif().
|
||||
|
||||
Thu Oct 3 15:37:37 1996 Anthony Green <[email protected]>
|
||||
|
||||
* prep_cif.c (ffi_prep_cif): Changed values from void* to void**.
|
||||
(initialize_aggregate): Fixed aggregate type initialization.
|
||||
|
||||
* Makefile.am (EXTRA_DIST): Added support code for "make dist".
|
||||
* Makefile.in: Regenerated.
|
||||
|
||||
Wed Oct 2 11:41:57 1996 Anthony Green <[email protected]>
|
||||
|
||||
* debug.c, prep_cif: Created.
|
||||
|
||||
* Makefile.am: Added debug.o and prep_cif.o to OBJ.
|
||||
* Makefile.in: Regenerated.
|
||||
|
||||
* Makefile.am (INCLUDES): Added missing -I../include
|
||||
* Makefile.in: Regenerated.
|
||||
|
||||
Tue Oct 1 17:11:51 1996 Anthony Green <[email protected]>
|
||||
|
||||
* error.c, Makefile.am: Created.
|
||||
* Makefile.in: Generated.
|
||||
|
||||
--- libffi/src/x86 --------------------------------------------------------
|
||||
|
||||
Sun Oct 4 16:27:17 1998 Anthony Green <[email protected]>
|
||||
|
||||
* sysv.S (retlongdouble): Fixed long long return value support.
|
||||
* ffi.c (ffi_prep_cif_machdep): Ditto.
|
||||
|
||||
Wed May 13 04:30:33 1998 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c (ffi_prep_cif_machdep): Fixed long double return value
|
||||
support.
|
||||
|
||||
Wed Apr 15 08:43:20 1998 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c (ffi_prep_args): small struct support was missing.
|
||||
|
||||
Thu May 8 16:53:58 1997 Anthony Green <[email protected]>
|
||||
|
||||
* objects.mak: Removed.
|
||||
|
||||
Mon Dec 2 15:12:58 1996 Tom Tromey <[email protected]>
|
||||
|
||||
* sysv.S: Use .balign, for a.out Linux boxes.
|
||||
|
||||
Tue Oct 15 13:06:50 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c: Clean up based on LCLint output.
|
||||
Added funny /*@...@*/ comments to annotate source.
|
||||
|
||||
Fri Oct 11 16:43:38 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c (ffi_call): Added assertion for bad ABIs.
|
||||
|
||||
Wed Oct 9 13:57:27 1996 Anthony Green <[email protected]>
|
||||
|
||||
* sysv.S (retdouble): Fixed double return problems.
|
||||
|
||||
* ffi.c (ffi_call): Corrected fn arg definition.
|
||||
(ffi_prep_cif_machdep): Fixed double return problems
|
||||
|
||||
Tue Oct 8 12:12:49 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c: Moved ffi_type definitions to types.c.
|
||||
(ffi_prep_args): Fixed type promotion bug.
|
||||
|
||||
Mon Oct 7 15:53:06 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c (FFI_*_TYPEDEF): Removed redundant ';'
|
||||
|
||||
Fri Oct 4 09:54:53 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c (ffi_call): Removed FFI_ABI arg, and swapped
|
||||
remaining args.
|
||||
|
||||
Wed Oct 2 10:07:05 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c, sysv.S, objects.mak: Created.
|
||||
(ffi_prep_cif): cif->rvalue no longer initialized to NULL.
|
||||
(ffi_prep_cif_machdep): Moved machine independent cif processing
|
||||
to src/prep_cif.c. Introduced ffi_prep_cif_machdep().
|
||||
|
||||
--- libffi/src/mips -------------------------------------------------------
|
||||
|
||||
Tue Feb 17 17:18:07 1998 Anthony Green <[email protected]>
|
||||
|
||||
* o32.S: Fixed typo in comment.
|
||||
|
||||
* ffi.c (ffi_prep_cif_machdep): Fixed argument processing.
|
||||
|
||||
Thu May 8 16:53:58 1997 Anthony Green <[email protected]>
|
||||
|
||||
* o32.s, n32.s: Wrappers for SGI tool support.
|
||||
|
||||
* objects.mak: Removed.
|
||||
|
||||
Tue Oct 29 14:37:45 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c (ffi_prep_args): Changed int z to size_t z.
|
||||
|
||||
Tue Oct 15 13:17:25 1996 Anthony Green <[email protected]>
|
||||
|
||||
* n32.S: Fixed bad stack munging.
|
||||
|
||||
* ffi.c: Moved prototypes for ffi_call_?32() to here from
|
||||
ffi_mips.h because extended_cif is not defined in ffi_mips.h.
|
||||
|
||||
Mon Oct 14 12:42:02 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c: Interface changes based on feedback from Jim Blandy.
|
||||
|
||||
Thu Oct 10 11:22:16 1996 Anthony Green <[email protected]>
|
||||
|
||||
* n32.S, ffi.c: Lots of changes to support passing and
|
||||
returning structures with the n32 calling convention.
|
||||
|
||||
* n32.S: Fixed fn pointer bug.
|
||||
|
||||
* ffi.c (ffi_prep_cif_machdep): Fix for o32 structure
|
||||
return values.
|
||||
(ffi_prep_args): Fixed n32 structure passing when structures
|
||||
partially fit in registers.
|
||||
|
||||
Wed Oct 9 13:49:25 1996 Anthony Green <[email protected]>
|
||||
|
||||
* objects.mak: Added n32.o.
|
||||
|
||||
* n32.S: Created.
|
||||
|
||||
* ffi.c (ffi_prep_args): Added magic to support proper
|
||||
n32 processing.
|
||||
|
||||
Tue Oct 8 10:37:35 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c: Moved ffi_type definitions to types.c.
|
||||
(ffi_prep_args): Fixed type promotion bug.
|
||||
|
||||
* o32.S: This code is only built for o32 compiles.
|
||||
A lot of the #define cruft has moved to ffi_mips.h.
|
||||
|
||||
* ffi.c (ffi_prep_cif_machdep): Fixed arg flags. Second arg
|
||||
is only processed if the first is either a float or double.
|
||||
|
||||
Mon Oct 7 15:33:59 1996 Anthony Green <[email protected]>
|
||||
|
||||
* o32.S: Modified to compile under each of o32, n32 and n64.
|
||||
|
||||
* ffi.c (FFI_*_TYPEDEF): Removed redundant ';'
|
||||
|
||||
Fri Oct 4 09:53:25 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c (ffi_call): Removed FFI_ABI arg, and swapped
|
||||
remaining args.
|
||||
|
||||
Wed Oct 2 17:41:22 1996 Anthony Green <[email protected]>
|
||||
|
||||
* o32.S: Removed crufty definitions.
|
||||
|
||||
Wed Oct 2 12:53:42 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c (ffi_prep_cif): cif->rvalue no longer initialized to NULL.
|
||||
(ffi_prep_cif_machdep): Moved all machine independent cif processing
|
||||
to src/prep_cif.c. Introduced ffi_prep_cif_machdep. Return types
|
||||
of FFI_TYPE_STRUCT are no different than FFI_TYPE_INT.
|
||||
|
||||
Tue Oct 1 17:11:02 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c, o32.S, object.mak: Created
|
||||
|
||||
--- libffi/src/sparc ------------------------------------------------------
|
||||
|
||||
Tue Feb 24 16:33:18 1998 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c (ffi_prep_args): Added long double support.
|
||||
|
||||
Thu May 8 16:53:58 1997 Anthony Green <[email protected]>
|
||||
|
||||
* objects.mak: Removed.
|
||||
|
||||
Thu May 1 16:07:56 1997 Anthony Green <[email protected]>
|
||||
|
||||
* v8.S: Fixed minor portability problem reported by
|
||||
Russ McManus <[email protected]>.
|
||||
|
||||
Tue Nov 26 14:12:43 1996 Anthony Green <[email protected]>
|
||||
|
||||
* v8.S: Used STACKFRAME define elsewhere.
|
||||
|
||||
* ffi.c (ffi_prep_args): Zero out space when USING_PURIFY
|
||||
is set.
|
||||
(ffi_prep_cif_machdep): Allocate the correct stack frame
|
||||
space for functions with < 6 args.
|
||||
|
||||
Tue Oct 29 15:08:55 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c (ffi_prep_args): int z is now size_t z.
|
||||
|
||||
Mon Oct 14 13:31:24 1996 Anthony Green <[email protected]>
|
||||
|
||||
* v8.S (ffi_call_V8): Gordon rewrites this again. It looks
|
||||
great now.
|
||||
|
||||
* ffi.c (ffi_call): The comment about hijacked registers
|
||||
is no longer valid after gordoni hacked v8.S.
|
||||
|
||||
* v8.S (ffi_call_V8): Rewrote with gordoni. Much simpler.
|
||||
|
||||
* v8.S, ffi.c: ffi_call() had changed to accept more than
|
||||
two args, so v8.S had to change (because it hijacks incoming
|
||||
arg registers).
|
||||
|
||||
* ffi.c: Interface changes based on feedback from Jim Blandy.
|
||||
|
||||
Thu Oct 10 17:48:16 1996 Anthony Green <[email protected]>
|
||||
|
||||
* ffi.c, v8.S, objects.mak: Created.
|
||||
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
libffi - Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 Red Hat, Inc.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
``Software''), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included
|
||||
in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
OTHER DEALINGS IN THE SOFTWARE.
|
||||
@@ -0,0 +1,72 @@
|
||||
## Process this with automake to create Makefile.in
|
||||
|
||||
AUTOMAKE_OPTIONS = foreign no-installinfo
|
||||
|
||||
if TESTSUBDIR
|
||||
SUBDIRS = include testsuite
|
||||
else
|
||||
SUBDIRS = include
|
||||
endif
|
||||
|
||||
EXTRA_DIST = \
|
||||
LICENSE \
|
||||
README \
|
||||
ChangeLog.v1 \
|
||||
alpha/ffi.c \
|
||||
arm/ffi.c \
|
||||
ia64/ffi.c \
|
||||
m68k/ffi.c \
|
||||
mips/ffi.c \
|
||||
powerpc/ffi.c \
|
||||
s390/ffi.c \
|
||||
sparc/ffi.c \
|
||||
x86/ffi.c \
|
||||
alpha/osf.S \
|
||||
arm/sysv.S \
|
||||
ia64/unix.S \
|
||||
m68k/sysv.S \
|
||||
mips/n32.S \
|
||||
mips/o32.S \
|
||||
powerpc/sysv.S \
|
||||
s390/sysv.S \
|
||||
sparc/v8.S \
|
||||
sparc/v9.S \
|
||||
x86/win32.S \
|
||||
x86/sysv.S
|
||||
|
||||
# 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_LIBRARIES = libffi.a
|
||||
|
||||
## Work around automake deficiency
|
||||
nodist_libffi_a_SOURCES = t-ffi.c t-asm.S
|
||||
|
||||
libffi_a_SOURCES = \
|
||||
debug.c \
|
||||
prep_cif.c \
|
||||
types.c \
|
||||
raw_api.c \
|
||||
java_raw_api.c \
|
||||
$(nodist_libffi_a_SOURCES)
|
||||
|
||||
AM_CFLAGS = -fexceptions
|
||||
|
||||
INCLUDES = \
|
||||
-I$(top_srcdir)/include \
|
||||
-Iinclude \
|
||||
-I$(top_srcdir)/src
|
||||
@@ -0,0 +1,513 @@
|
||||
README for libffi-2.00
|
||||
|
||||
libffi-2.00 has not been released yet! This is a development snapshot!
|
||||
|
||||
libffi-1.20 was released on [SOME FUTURE DAY]. Check the libffi web
|
||||
page for updates: <URL:http://sourceware.cygnus.com/libffi/>.
|
||||
|
||||
|
||||
What is libffi?
|
||||
===============
|
||||
|
||||
Compilers for high level languages generate code that follow certain
|
||||
conventions. These conventions are necessary, in part, for separate
|
||||
compilation to work. One such convention is the "calling
|
||||
convention". The "calling convention" is essentially a set of
|
||||
assumptions made by the compiler about where function arguments will
|
||||
be found on entry to a function. A "calling convention" also specifies
|
||||
where the return value for a function is found.
|
||||
|
||||
Some programs may not know at the time of compilation what arguments
|
||||
are to be passed to a function. For instance, an interpreter may be
|
||||
told at run-time about the number and types of arguments used to call
|
||||
a given function. Libffi can be used in such programs to provide a
|
||||
bridge from the interpreter program to compiled code.
|
||||
|
||||
The libffi library provides a portable, high level programming
|
||||
interface to various calling conventions. This allows a programmer to
|
||||
call any function specified by a call interface description at run
|
||||
time.
|
||||
|
||||
Ffi stands for Foreign Function Interface. A foreign function
|
||||
interface is the popular name for the interface that allows code
|
||||
written in one language to call code written in another language. The
|
||||
libffi library really only provides the lowest, machine dependent
|
||||
layer of a fully featured foreign function interface. A layer must
|
||||
exist above libffi that handles type conversions for values passed
|
||||
between the two languages.
|
||||
|
||||
|
||||
Supported Platforms and Prerequisites
|
||||
=====================================
|
||||
|
||||
Libffi has been ported to:
|
||||
|
||||
Alpha - Linux and OSF/1
|
||||
|
||||
ARM - Linux (System V ABI)
|
||||
|
||||
IA-32 - Linux, Solaris, and BeOS (System V ABI)
|
||||
|
||||
IA-64 - Linux (System V ABI)
|
||||
|
||||
m68k - Linux (System V ABI)
|
||||
|
||||
MIPS, 32- and 64-bit - Irix (System V/o32 and n32)
|
||||
|
||||
PowerPC - Linux (System V ABI)
|
||||
|
||||
S390 - Linux (System V ABI)
|
||||
|
||||
Sparc, 32-bit - SunOS 4.1.3, Solaris 2.x, and Linux (Sparc v8)
|
||||
|
||||
Sparc, 64-bit - Linux (Sparc v9)
|
||||
|
||||
|
||||
Libffi has been tested with GCC 3.00 and newer compilers.
|
||||
|
||||
You must use GNU make to build libffi.
|
||||
|
||||
If you port libffi to another platform, please let me know! I assume
|
||||
that some will be easy (x86 NetBSD), and others will be more difficult
|
||||
(HP, AIX).
|
||||
|
||||
|
||||
Installing libffi
|
||||
=================
|
||||
|
||||
[Note: before actually performing any of these installation steps,
|
||||
you may wish to read the "Platform Specific Notes" below.]
|
||||
|
||||
First you must configure the distribution for your particular
|
||||
system. Go to the directory you wish to build libffi in and run the
|
||||
"configure" program found in the root directory of the libffi source
|
||||
distribution.
|
||||
|
||||
You may want to tell configure where to install the libffi library and
|
||||
header files. To do that, use the --prefix configure switch. Libffi
|
||||
will install under /usr/local by default.
|
||||
|
||||
If you want to enable extra run-time debugging checks use the the
|
||||
--enable-debug configure switch. This is useful when your program dies
|
||||
mysteriously while using libffi.
|
||||
|
||||
Another useful configure switch is --enable-purify-safety. Using this
|
||||
will add some extra code which will suppress certain warnings when you
|
||||
are using Purify with libffi. Only use this switch when using
|
||||
Purify, as it will slow down the library.
|
||||
|
||||
Configure has many other options. Use "configure --help" to see them all.
|
||||
|
||||
Once configure has finished, type "make". Note that you must be using
|
||||
GNU make. SGI's make will not work. Sun's probably won't either.
|
||||
You can ftp GNU make from prep.ai.mit.edu:/pub/gnu.
|
||||
|
||||
To ensure that libffi is working as advertised, type "make test".
|
||||
|
||||
To install the library and header files, type "make install".
|
||||
|
||||
|
||||
Using libffi
|
||||
============
|
||||
|
||||
The Basics
|
||||
----------
|
||||
|
||||
Libffi assumes that you have a pointer to the function you wish to
|
||||
call and that you know the number and types of arguments to pass it,
|
||||
as well as the return type of the function.
|
||||
|
||||
The first thing you must do is create an ffi_cif object that matches
|
||||
the signature of the function you wish to call. The cif in ffi_cif
|
||||
stands for Call InterFace. To prepare a call interface object, use the
|
||||
following function:
|
||||
|
||||
ffi_status ffi_prep_cif(ffi_cif *cif, ffi_abi abi,
|
||||
unsigned int nargs,
|
||||
ffi_type *rtype, ffi_type **atypes);
|
||||
|
||||
CIF is a pointer to the call interface object you wish
|
||||
to initialize.
|
||||
|
||||
ABI is an enum that specifies the calling convention
|
||||
to use for the call. FFI_DEFAULT_ABI defaults
|
||||
to the system's native calling convention. Other
|
||||
ABI's may be used with care. They are system
|
||||
specific.
|
||||
|
||||
NARGS is the number of arguments this function accepts.
|
||||
libffi does not yet support vararg functions.
|
||||
|
||||
RTYPE is a pointer to an ffi_type structure that represents
|
||||
the return type of the function. Ffi_type objects
|
||||
describe the types of values. libffi provides
|
||||
ffi_type objects for many of the native C types:
|
||||
signed int, unsigned int, signed char, unsigned char,
|
||||
etc. There is also a pointer ffi_type object and
|
||||
a void ffi_type. Use &ffi_type_void for functions that
|
||||
don't return values.
|
||||
|
||||
ATYPES is a vector of ffi_type pointers. ARGS must be NARGS long.
|
||||
If NARGS is 0, this is ignored.
|
||||
|
||||
|
||||
ffi_prep_cif will return a status code that you are responsible
|
||||
for checking. It will be one of the following:
|
||||
|
||||
FFI_OK - All is good.
|
||||
|
||||
FFI_BAD_TYPEDEF - One of the ffi_type objects that ffi_prep_cif
|
||||
came across is bad.
|
||||
|
||||
|
||||
Before making the call, the VALUES vector should be initialized
|
||||
with pointers to the appropriate argument values.
|
||||
|
||||
To call the the function using the initialized ffi_cif, use the
|
||||
ffi_call function:
|
||||
|
||||
void ffi_call(ffi_cif *cif, void *fn, void *rvalue, void **avalues);
|
||||
|
||||
CIF is a pointer to the ffi_cif initialized specifically
|
||||
for this function.
|
||||
|
||||
FN is a pointer to the function you want to call.
|
||||
|
||||
RVALUE is a pointer to a chunk of memory that is to hold the
|
||||
result of the function call. Currently, it must be
|
||||
at least one word in size (except for the n32 version
|
||||
under Irix 6.x, which must be a pointer to an 8 byte
|
||||
aligned value (a long long). It must also be at least
|
||||
word aligned (depending on the return type, and the
|
||||
system's alignment requirements). If RTYPE is
|
||||
&ffi_type_void, this is ignored. If RVALUE is NULL,
|
||||
the return value is discarded.
|
||||
|
||||
AVALUES is a vector of void* that point to the memory locations
|
||||
holding the argument values for a call.
|
||||
If NARGS is 0, this is ignored.
|
||||
|
||||
|
||||
If you are expecting a return value from FN it will have been stored
|
||||
at RVALUE.
|
||||
|
||||
|
||||
|
||||
An Example
|
||||
----------
|
||||
|
||||
Here is a trivial example that calls puts() a few times.
|
||||
|
||||
#include <stdio.h>
|
||||
#include <ffi.h>
|
||||
|
||||
int main()
|
||||
{
|
||||
ffi_cif cif;
|
||||
ffi_type *args[1];
|
||||
void *values[1];
|
||||
char *s;
|
||||
int rc;
|
||||
|
||||
/* Initialize the argument info vectors */
|
||||
args[0] = &ffi_type_uint;
|
||||
values[0] = &s;
|
||||
|
||||
/* Initialize the cif */
|
||||
if (ffi_prep_cif(&cif, FFI_DEFAULT_ABI, 1,
|
||||
&ffi_type_uint, args) == FFI_OK)
|
||||
{
|
||||
s = "Hello World!";
|
||||
ffi_call(&cif, puts, &rc, values);
|
||||
/* rc now holds the result of the call to puts */
|
||||
|
||||
/* values holds a pointer to the function's arg, so to
|
||||
call puts() again all we need to do is change the
|
||||
value of s */
|
||||
s = "This is cool!";
|
||||
ffi_call(&cif, puts, &rc, values);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Aggregate Types
|
||||
---------------
|
||||
|
||||
Although libffi has no special support for unions or bit-fields, it is
|
||||
perfectly happy passing structures back and forth. You must first
|
||||
describe the structure to libffi by creating a new ffi_type object
|
||||
for it. Here is the definition of ffi_type:
|
||||
|
||||
typedef struct _ffi_type
|
||||
{
|
||||
unsigned size;
|
||||
short alignment;
|
||||
short type;
|
||||
struct _ffi_type **elements;
|
||||
} ffi_type;
|
||||
|
||||
All structures must have type set to FFI_TYPE_STRUCT. You may set
|
||||
size and alignment to 0. These will be calculated and reset to the
|
||||
appropriate values by ffi_prep_cif().
|
||||
|
||||
elements is a NULL terminated array of pointers to ffi_type objects
|
||||
that describe the type of the structure elements. These may, in turn,
|
||||
be structure elements.
|
||||
|
||||
The following example initializes a ffi_type object representing the
|
||||
tm struct from Linux's time.h:
|
||||
|
||||
struct tm {
|
||||
int tm_sec;
|
||||
int tm_min;
|
||||
int tm_hour;
|
||||
int tm_mday;
|
||||
int tm_mon;
|
||||
int tm_year;
|
||||
int tm_wday;
|
||||
int tm_yday;
|
||||
int tm_isdst;
|
||||
/* Those are for future use. */
|
||||
long int __tm_gmtoff__;
|
||||
__const char *__tm_zone__;
|
||||
};
|
||||
|
||||
{
|
||||
ffi_type tm_type;
|
||||
ffi_type *tm_type_elements[12];
|
||||
int i;
|
||||
|
||||
tm_type.size = tm_type.alignment = 0;
|
||||
tm_type.elements = &tm_type_elements;
|
||||
|
||||
for (i = 0; i < 9; i++)
|
||||
tm_type_elements[i] = &ffi_type_sint;
|
||||
|
||||
tm_type_elements[9] = &ffi_type_slong;
|
||||
tm_type_elements[10] = &ffi_type_pointer;
|
||||
tm_type_elements[11] = NULL;
|
||||
|
||||
/* tm_type can now be used to represent tm argument types and
|
||||
return types for ffi_prep_cif() */
|
||||
}
|
||||
|
||||
|
||||
|
||||
Platform Specific Notes
|
||||
=======================
|
||||
|
||||
Intel x86
|
||||
---------
|
||||
|
||||
There are no known problems with the x86 port.
|
||||
|
||||
Sun Sparc - SunOS 4.1.3 & Solaris 2.x
|
||||
-------------------------------------
|
||||
|
||||
There's a bug in the structure passing code for sparc processors.
|
||||
Struct arguments that are passed in value actually end up being passed
|
||||
by reference. This will be fixed Real Soon Now.
|
||||
|
||||
"long long" values are not supported yet.
|
||||
|
||||
You must use GNU Make to build libffi on Sun platforms.
|
||||
|
||||
MIPS - Irix 5.3 & 6.x
|
||||
---------------------
|
||||
|
||||
Irix 6.2 and better supports three different calling conventions: o32,
|
||||
n32 and n64. Currently, libffi only supports both o32 and n32 under
|
||||
Irix 6.x, but only o32 under Irix 5.3. Libffi will automatically be
|
||||
configured for whichever calling convention it was built for.
|
||||
|
||||
By default, the configure script will try to build libffi with the GNU
|
||||
development tools. To build libffi with the SGI development tools, set
|
||||
the environment variable CC to either "cc -32" or "cc -n32" before
|
||||
running configure under Irix 6.x (depending on whether you want an o32
|
||||
or n32 library), or just "cc" for Irix 5.3.
|
||||
|
||||
With the n32 calling convention, when returning structures smaller
|
||||
than 16 bytes, be sure to provide an RVALUE that is 8 byte aligned.
|
||||
Here's one way of forcing this:
|
||||
|
||||
double struct_storage[2];
|
||||
my_small_struct *s = (my_small_struct *) struct_storage;
|
||||
/* Use s for RVALUE */
|
||||
|
||||
If you don't do this you are liable to get spurious bus errors.
|
||||
|
||||
"long long" values are not supported yet.
|
||||
|
||||
You must use GNU Make to build libffi on SGI platforms.
|
||||
|
||||
ARM - System V ABI
|
||||
------------------
|
||||
|
||||
The ARM port was performed on a NetWinder running ARM Linux ELF
|
||||
(2.0.31) and gcc 2.8.1. config.sub still does not recognize the
|
||||
machine name sa110-unknown-linux-gnu (currently returned by
|
||||
NetWinder). In the mean time the package can be configured by running
|
||||
'configure arm-linux'.
|
||||
|
||||
|
||||
|
||||
PowerPC System V ABI
|
||||
--------------------
|
||||
|
||||
There are two `System V ABI's which libffi implements for PowerPC.
|
||||
They differ only in how small structures are returned from functions.
|
||||
|
||||
In the FFI_SYSV version, structures that are 8 bytes or smaller are
|
||||
returned in registers. This is what GCC does when it is configured
|
||||
for solaris, and is what the System V ABI I have (dated September
|
||||
1995) says.
|
||||
|
||||
In the FFI_GCC_SYSV version, all structures are returned the same way:
|
||||
by passing a pointer as the first argument to the function. This is
|
||||
what GCC does when it is configured for linux or a generic sysv
|
||||
target.
|
||||
|
||||
EGCS 1.0.1 (and probably other versions of EGCS/GCC) also has a
|
||||
inconsistency with the SysV ABI: When a procedure is called with many
|
||||
floating-point arguments, some of them get put on the stack. They are
|
||||
all supposed to be stored in double-precision format, even if they are
|
||||
only single-precision, but EGCS stores single-precision arguments as
|
||||
single-precision anyway. This causes one test to fail (the `many
|
||||
arguments' test).
|
||||
|
||||
|
||||
History
|
||||
=======
|
||||
|
||||
2.00 ???-??-01
|
||||
|
||||
Many configure improvements. No more run tests required at
|
||||
configure time so cross compiling should work well. ffi.h is
|
||||
target independent now and may be installed safely anywhere.
|
||||
ffitest replaced with dejagnu testing infrastructure. s390
|
||||
port from ????. ia64 port from Hans Boehm. General
|
||||
performance improvements. Closures designed and implemented
|
||||
by Kresten Krab Thorup and ported to ia64 and powerpc by Hans
|
||||
Boehm and ???? respectively.
|
||||
|
||||
1.20 Oct-5-98
|
||||
Raffaele Sena produces ARM port.
|
||||
|
||||
1.19 Oct-5-98
|
||||
Fixed x86 long double and long long return support.
|
||||
m68k bug fixes from Andreas Schwab.
|
||||
Patch for DU assembler compatibility for the Alpha from Richard
|
||||
Henderson.
|
||||
|
||||
1.18 Apr-17-98
|
||||
Bug fixes and MIPS configuration changes.
|
||||
|
||||
1.17 Feb-24-98
|
||||
Bug fixes and m68k port from Andreas Schwab. PowerPC port from
|
||||
Geoffrey Keating. Various bug x86, Sparc and MIPS bug fixes.
|
||||
|
||||
1.16 Feb-11-98
|
||||
Richard Henderson produces Alpha port.
|
||||
|
||||
1.15 Dec-4-97
|
||||
Fixed an n32 ABI bug. New libtool, auto* support.
|
||||
|
||||
1.14 May-13-97
|
||||
libtool is now used to generate shared and static libraries.
|
||||
Fixed a minor portability problem reported by Russ McManus
|
||||
<[email protected]>.
|
||||
|
||||
1.13 Dec-2-96
|
||||
Added --enable-purify-safety to keep Purify from complaining
|
||||
about certain low level code.
|
||||
Sparc fix for calling functions with < 6 args.
|
||||
Linux x86 a.out fix.
|
||||
|
||||
1.12 Nov-22-96
|
||||
Added missing ffi_type_void, needed for supporting void return
|
||||
types. Fixed test case for non MIPS machines. Cygnus Support
|
||||
is now Cygnus Solutions.
|
||||
|
||||
1.11 Oct-30-96
|
||||
Added notes about GNU make.
|
||||
|
||||
1.10 Oct-29-96
|
||||
Added configuration fix for non GNU compilers.
|
||||
|
||||
1.09 Oct-29-96
|
||||
Added --enable-debug configure switch. Clean-ups based on LCLint
|
||||
feedback. ffi_mips.h is always installed. Many configuration
|
||||
fixes. Fixed ffitest.c for sparc builds.
|
||||
|
||||
1.08 Oct-15-96
|
||||
Fixed n32 problem. Many clean-ups.
|
||||
|
||||
1.07 Oct-14-96
|
||||
Gordon Irlam rewrites v8.S again. Bug fixes.
|
||||
|
||||
1.06 Oct-14-96
|
||||
Gordon Irlam improved the sparc port.
|
||||
|
||||
1.05 Oct-14-96
|
||||
Interface changes based on feedback.
|
||||
|
||||
1.04 Oct-11-96
|
||||
Sparc port complete (modulo struct passing bug).
|
||||
|
||||
1.03 Oct-10-96
|
||||
Passing struct args, and returning struct values works for
|
||||
all architectures/calling conventions. Expanded tests.
|
||||
|
||||
1.02 Oct-9-96
|
||||
Added SGI n32 support. Fixed bugs in both o32 and Linux support.
|
||||
Added "make test".
|
||||
|
||||
1.01 Oct-8-96
|
||||
Fixed float passing bug in mips version. Restructured some
|
||||
of the code. Builds cleanly with SGI tools.
|
||||
|
||||
1.00 Oct-7-96
|
||||
First release. No public announcement.
|
||||
|
||||
|
||||
Authors & Credits
|
||||
=================
|
||||
|
||||
libffi was written by Anthony Green <[email protected]>.
|
||||
|
||||
Portions of libffi were derived from Gianni Mariani's free gencall
|
||||
library for Silicon Graphics machines.
|
||||
|
||||
The closure mechanism was designed and implemented on IA-32 by Kresten
|
||||
Krab Thorup.
|
||||
|
||||
The initial Sparc port was derived from code contributed by the fine
|
||||
folks at Visible Decisions Inc. Further enhancements were made by
|
||||
Gordon Irlam while at Cygnus Solutions.
|
||||
|
||||
The Alpha port was written by Richard Henderson at Cygnus Solutions/Red Hat.
|
||||
|
||||
Andreas Schwab ported libffi to m68k Linux and provided a number of
|
||||
bug fixes.
|
||||
|
||||
Geoffrey Keating ported libffi to the PowerPC.
|
||||
|
||||
Raffaele Sena ported libffi to the ARM.
|
||||
|
||||
Hans Boehm ported libffi to IA-64.
|
||||
|
||||
Jakub Jelinek ported libffi to 32- and 64-bit Sparc Linux.
|
||||
|
||||
Jesper Skov and Andrew Haley both did more than their fair share of
|
||||
stepping through the code and tracking down bugs.
|
||||
|
||||
Thanks also to Tom Tromey for bug fixes and configuration help.
|
||||
|
||||
Thanks to Jim Blandy, who provided some useful feedback on the libffi
|
||||
interface.
|
||||
|
||||
If you have a problem, or have found a bug, please send a note to
|
||||
[email protected].
|
||||
@@ -0,0 +1,12 @@
|
||||
/* Define this if you want extra debugging */
|
||||
#undef FFI_DEBUG
|
||||
|
||||
/* Define this if you are using Purify and want to suppress
|
||||
spurious messages. */
|
||||
#undef USING_PURIFY
|
||||
|
||||
/* Define this is you do not want support for aggregate types. */
|
||||
#undef FFI_NO_STRUCTS
|
||||
|
||||
/* Define this is you do not want support for the raw API. */
|
||||
#undef FFI_NO_RAW_API
|
||||
@@ -0,0 +1,97 @@
|
||||
AC_DEFUN([AC_COMPILE_CHECK_SIZEOF],
|
||||
[changequote(<<, >>)dnl
|
||||
dnl The name to #define.
|
||||
define(<<AC_TYPE_NAME>>, translit(sizeof_$1, [a-z *], [A-Z_P]))dnl
|
||||
dnl The cache variable name.
|
||||
define(<<AC_CV_NAME>>, translit(ac_cv_sizeof_$1, [ *], [_p]))dnl
|
||||
changequote([, ])dnl
|
||||
AC_MSG_CHECKING(size of $1)
|
||||
AC_CACHE_VAL(AC_CV_NAME,
|
||||
[for ac_size in 4 8 1 2 16 12 $2 ; do # List sizes in rough order of prevalence.
|
||||
AC_TRY_COMPILE([#include "confdefs.h"
|
||||
#include <sys/types.h>
|
||||
$2
|
||||
], [switch (0) case 0: case (sizeof ($1) == $ac_size):;], AC_CV_NAME=$ac_size)
|
||||
if test x$AC_CV_NAME != x ; then break; fi
|
||||
done
|
||||
])
|
||||
if test x$AC_CV_NAME = x ; then
|
||||
AC_MSG_ERROR([cannot determine a size for $1])
|
||||
fi
|
||||
AC_MSG_RESULT($AC_CV_NAME)
|
||||
AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [The number of bytes in type $1])
|
||||
undefine([AC_TYPE_NAME])dnl
|
||||
undefine([AC_CV_NAME])dnl
|
||||
])
|
||||
|
||||
|
||||
AC_DEFUN([AC_C_BIGENDIAN_CROSS],
|
||||
[AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian,
|
||||
[ac_cv_c_bigendian=unknown
|
||||
# See if sys/param.h defines the BYTE_ORDER macro.
|
||||
AC_TRY_COMPILE([#include <sys/types.h>
|
||||
#include <sys/param.h>], [
|
||||
#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
|
||||
bogus endian macros
|
||||
#endif], [# It does; now see whether it defined to BIG_ENDIAN or not.
|
||||
AC_TRY_COMPILE([#include <sys/types.h>
|
||||
#include <sys/param.h>], [
|
||||
#if BYTE_ORDER != BIG_ENDIAN
|
||||
not big endian
|
||||
#endif], ac_cv_c_bigendian=yes, ac_cv_c_bigendian=no)])
|
||||
if test $ac_cv_c_bigendian = unknown; then
|
||||
AC_TRY_RUN([main () {
|
||||
/* Are we little or big endian? From Harbison&Steele. */
|
||||
union
|
||||
{
|
||||
long l;
|
||||
char c[sizeof (long)];
|
||||
} u;
|
||||
u.l = 1;
|
||||
exit (u.c[sizeof (long) - 1] == 1);
|
||||
}], ac_cv_c_bigendian=no, ac_cv_c_bigendian=yes,
|
||||
[ echo $ac_n "cross-compiling... " 2>&AC_FD_MSG ])
|
||||
fi])
|
||||
if test $ac_cv_c_bigendian = unknown; then
|
||||
AC_MSG_CHECKING(to probe for byte ordering)
|
||||
[
|
||||
cat >conftest.c <<EOF
|
||||
short ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
|
||||
short ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
|
||||
void _ascii() { char* s = (char*) ascii_mm; s = (char*) ascii_ii; }
|
||||
short ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
|
||||
short ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
|
||||
void _ebcdic() { char* s = (char*) ebcdic_mm; s = (char*) ebcdic_ii; }
|
||||
int main() { _ascii (); _ebcdic (); return 0; }
|
||||
EOF
|
||||
] if test -f conftest.c ; then
|
||||
if ${CC-cc} ${CFLAGS} conftest.c -o conftest.o && test -f conftest.o ; then
|
||||
if test `grep -l BIGenDianSyS conftest.o` ; then
|
||||
echo $ac_n ' big endian probe OK, ' 1>&AC_FD_MSG
|
||||
ac_cv_c_bigendian=yes
|
||||
fi
|
||||
if test `grep -l LiTTleEnDian conftest.o` ; then
|
||||
echo $ac_n ' little endian probe OK, ' 1>&AC_FD_MSG
|
||||
if test $ac_cv_c_bigendian = yes ; then
|
||||
ac_cv_c_bigendian=unknown;
|
||||
else
|
||||
ac_cv_c_bigendian=no
|
||||
fi
|
||||
fi
|
||||
echo $ac_n 'guessing bigendian ... ' >&AC_FD_MSG
|
||||
fi
|
||||
fi
|
||||
AC_MSG_RESULT($ac_cv_c_bigendian)
|
||||
fi
|
||||
if test $ac_cv_c_bigendian = yes; then
|
||||
AC_DEFINE(WORDS_BIGENDIAN, 1, [whether byteorder is bigendian])
|
||||
BYTEORDER=4321
|
||||
else
|
||||
BYTEORDER=1234
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED(BYTEORDER, $BYTEORDER, [1234 = LIL_ENDIAN, 4321 = BIGENDIAN])
|
||||
if test $ac_cv_c_bigendian = unknown; then
|
||||
AC_MSG_ERROR(unknown endianess - sorry, please pre-set ac_cv_c_bigendian)
|
||||
fi
|
||||
])
|
||||
|
||||
@@ -0,0 +1,247 @@
|
||||
/* -----------------------------------------------------------------------
|
||||
ffi.c - Copyright (c) 1998 Cygnus Solutions
|
||||
|
||||
Alpha Foreign Function Interface
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
``Software''), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included
|
||||
in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
OTHER DEALINGS IN THE SOFTWARE.
|
||||
----------------------------------------------------------------------- */
|
||||
|
||||
#include <ffi.h>
|
||||
#include <ffi_private.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
extern void ffi_call_osf(void *, unsigned long, unsigned, void *, void (*)());
|
||||
extern void ffi_closure_osf(void);
|
||||
|
||||
|
||||
ffi_status
|
||||
ffi_prep_cif_machdep(ffi_cif *cif)
|
||||
{
|
||||
/* Adjust cif->bytes to represent a minimum 6 words for the temporary
|
||||
register argument loading area. */
|
||||
if (cif->bytes < 6*SIZEOF_ARG)
|
||||
cif->bytes = 6*SIZEOF_ARG;
|
||||
|
||||
/* Set the return type flag */
|
||||
switch (cif->rtype->type)
|
||||
{
|
||||
case FFI_TYPE_STRUCT:
|
||||
case FFI_TYPE_FLOAT:
|
||||
case FFI_TYPE_DOUBLE:
|
||||
cif->flags = cif->rtype->type;
|
||||
break;
|
||||
|
||||
default:
|
||||
cif->flags = FFI_TYPE_INT;
|
||||
break;
|
||||
}
|
||||
|
||||
return FFI_OK;
|
||||
}
|
||||
|
||||
void
|
||||
ffi_call(ffi_cif *cif, void (*fn)(), void *rvalue, void **avalue)
|
||||
{
|
||||
unsigned long *stack, *argp;
|
||||
long i, avn;
|
||||
ffi_type **arg_types;
|
||||
|
||||
FFI_ASSERT (cif->abi == FFI_OSF);
|
||||
|
||||
/* If the return value is a struct and we don't have a return
|
||||
value address then we need to make one. */
|
||||
if (rvalue == NULL && cif->flags == FFI_TYPE_STRUCT)
|
||||
rvalue = alloca(cif->rtype->size);
|
||||
|
||||
/* Allocate the space for the arguments, plus 4 words of temp
|
||||
space for ffi_call_osf. */
|
||||
argp = stack = alloca(cif->bytes + 4*SIZEOF_ARG);
|
||||
|
||||
if (cif->flags == FFI_TYPE_STRUCT)
|
||||
*(void **) argp++ = rvalue;
|
||||
|
||||
i = 0;
|
||||
avn = cif->nargs;
|
||||
arg_types = cif->arg_types;
|
||||
|
||||
while (i < avn)
|
||||
{
|
||||
switch ((*arg_types)->type)
|
||||
{
|
||||
case FFI_TYPE_SINT8:
|
||||
*(SINT64 *) argp = *(SINT8 *)(* avalue);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_UINT8:
|
||||
*(SINT64 *) argp = *(UINT8 *)(* avalue);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_SINT16:
|
||||
*(SINT64 *) argp = *(SINT16 *)(* avalue);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_UINT16:
|
||||
*(SINT64 *) argp = *(UINT16 *)(* avalue);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_SINT32:
|
||||
case FFI_TYPE_UINT32:
|
||||
/* Note that unsigned 32-bit quantities are sign extended. */
|
||||
*(SINT64 *) argp = *(SINT32 *)(* avalue);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_SINT64:
|
||||
case FFI_TYPE_UINT64:
|
||||
case FFI_TYPE_POINTER:
|
||||
*(UINT64 *) argp = *(UINT64 *)(* avalue);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_FLOAT:
|
||||
if (argp - stack < 6)
|
||||
{
|
||||
/* Note the conversion -- all the fp regs are loaded as
|
||||
doubles. The in-register format is the same. */
|
||||
*(double *) argp = *(float *)(* avalue);
|
||||
}
|
||||
else
|
||||
*(float *) argp = *(float *)(* avalue);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_DOUBLE:
|
||||
*(double *) argp = *(double *)(* avalue);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_STRUCT:
|
||||
memcpy(argp, *avalue, (*arg_types)->size);
|
||||
break;
|
||||
|
||||
default:
|
||||
FFI_ASSERT(0);
|
||||
}
|
||||
|
||||
argp += ALIGN((*arg_types)->size, SIZEOF_ARG) / SIZEOF_ARG;
|
||||
i++, arg_types++, avalue++;
|
||||
}
|
||||
|
||||
ffi_call_osf(stack, cif->bytes, cif->flags, rvalue, fn);
|
||||
}
|
||||
|
||||
|
||||
ffi_status
|
||||
ffi_prep_closure (ffi_closure* closure,
|
||||
ffi_cif* cif,
|
||||
void (*fun)(ffi_cif*, void*, void**, void*),
|
||||
void *user_data)
|
||||
{
|
||||
unsigned int *tramp;
|
||||
|
||||
FFI_ASSERT (cif->abi == FFI_OSF);
|
||||
|
||||
tramp = (unsigned int *) &closure->tramp[0];
|
||||
tramp[0] = 0x47fb0401; /* mov $27,$1 */
|
||||
tramp[1] = 0xa77b0010; /* ldq $27,16($27) */
|
||||
tramp[2] = 0x6bfb0000; /* jmp $31,($27),0 */
|
||||
tramp[3] = 0x47ff041f; /* nop */
|
||||
*(void **) &tramp[4] = ffi_closure_osf;
|
||||
|
||||
closure->cif = cif;
|
||||
closure->fun = fun;
|
||||
closure->user_data = user_data;
|
||||
|
||||
/* Flush the Icache. */
|
||||
asm volatile ("imb" : : : "memory");
|
||||
|
||||
return FFI_OK;
|
||||
}
|
||||
|
||||
int
|
||||
ffi_closure_osf_inner(ffi_closure *closure, void *rvalue, unsigned long *argp)
|
||||
{
|
||||
ffi_cif *cif;
|
||||
void **avalue;
|
||||
ffi_type **arg_types;
|
||||
long i, avn, argn;
|
||||
|
||||
cif = closure->cif;
|
||||
avalue = alloca(cif->nargs * sizeof(void *));
|
||||
|
||||
argn = 0;
|
||||
|
||||
/* Copy the caller's structure return address to that the closure
|
||||
returns the data directly to the caller. */
|
||||
if (cif->flags == FFI_TYPE_STRUCT)
|
||||
{
|
||||
rvalue = (void *) argp[0];
|
||||
argn = 1;
|
||||
}
|
||||
|
||||
i = 0;
|
||||
avn = cif->nargs;
|
||||
arg_types = cif->arg_types;
|
||||
|
||||
/* Grab the addresses of the arguments from the stack frame. */
|
||||
while (i < avn)
|
||||
{
|
||||
switch (arg_types[i]->type)
|
||||
{
|
||||
case FFI_TYPE_SINT8:
|
||||
case FFI_TYPE_UINT8:
|
||||
case FFI_TYPE_SINT16:
|
||||
case FFI_TYPE_UINT16:
|
||||
case FFI_TYPE_SINT32:
|
||||
case FFI_TYPE_UINT32:
|
||||
case FFI_TYPE_SINT64:
|
||||
case FFI_TYPE_UINT64:
|
||||
case FFI_TYPE_POINTER:
|
||||
case FFI_TYPE_STRUCT:
|
||||
avalue[i] = &argp[argn];
|
||||
break;
|
||||
|
||||
case FFI_TYPE_FLOAT:
|
||||
if (argn < 6)
|
||||
{
|
||||
/* Floats coming from registers need conversion from double
|
||||
back to float format. */
|
||||
*(float *)&argp[argn - 6] = *(double *)&argp[argn - 6];
|
||||
avalue[i] = &argp[argn - 6];
|
||||
}
|
||||
else
|
||||
avalue[i] = &argp[argn];
|
||||
break;
|
||||
|
||||
case FFI_TYPE_DOUBLE:
|
||||
avalue[i] = &argp[argn - (argn < 6 ? 6 : 0)];
|
||||
break;
|
||||
|
||||
default:
|
||||
FFI_ASSERT(0);
|
||||
}
|
||||
|
||||
argn += ALIGN(arg_types[i]->size, SIZEOF_ARG) / SIZEOF_ARG;
|
||||
i++;
|
||||
}
|
||||
|
||||
/* Invoke the closure. */
|
||||
(closure->fun) (cif, rvalue, avalue, closure->user_data);
|
||||
|
||||
/* Tell ffi_closure_osf how to perform return type promotions. */
|
||||
return cif->rtype->type;
|
||||
}
|
||||
@@ -0,0 +1,278 @@
|
||||
/* -----------------------------------------------------------------------
|
||||
osf.S - Copyright (c) 1998 Cygnus Solutions
|
||||
|
||||
Alpha/OSF Foreign Function Interface
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
``Software''), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included
|
||||
in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
OTHER DEALINGS IN THE SOFTWARE.
|
||||
----------------------------------------------------------------------- */
|
||||
|
||||
#define LIBFFI_ASM
|
||||
#include <ffi.h>
|
||||
#include <ffi_private.h>
|
||||
|
||||
.arch ev6
|
||||
.text
|
||||
|
||||
/* ffi_call_osf (void *args, unsigned long bytes, unsigned flags,
|
||||
void *raddr, void (*fnaddr)());
|
||||
|
||||
Bit o trickiness here -- ARGS+BYTES is the base of the stack frame
|
||||
for this function. This has been allocated by ffi_call. We also
|
||||
deallocate some of the stack that has been alloca'd. */
|
||||
|
||||
.align 3
|
||||
.globl ffi_call_osf
|
||||
.ent ffi_call_osf
|
||||
ffi_call_osf:
|
||||
.frame $15, 32, $26, 0
|
||||
.mask 0x4008000, -32
|
||||
addq $16,$17,$1
|
||||
mov $16, $30
|
||||
stq $26, 0($1)
|
||||
stq $15, 8($1)
|
||||
stq $18, 16($1)
|
||||
mov $1, $15
|
||||
.prologue 0
|
||||
|
||||
stq $19, 24($1)
|
||||
mov $20, $27
|
||||
|
||||
# Load up all of the (potential) argument registers.
|
||||
ldq $16, 0($30)
|
||||
ldt $f16, 0($30)
|
||||
ldt $f17, 8($30)
|
||||
ldq $17, 8($30)
|
||||
ldt $f18, 16($30)
|
||||
ldq $18, 16($30)
|
||||
ldt $f19, 24($30)
|
||||
ldq $19, 24($30)
|
||||
ldt $f20, 32($30)
|
||||
ldq $20, 32($30)
|
||||
ldt $f21, 40($30)
|
||||
ldq $21, 40($30)
|
||||
|
||||
# Deallocate the register argument area.
|
||||
lda $30, 48($30)
|
||||
|
||||
jsr $26, ($27), 0
|
||||
ldgp $29, 0($26)
|
||||
|
||||
# If the return value pointer is NULL, assume no return value.
|
||||
ldq $19, 24($15)
|
||||
ldq $18, 16($15)
|
||||
ldq $26, 0($15)
|
||||
beq $19, $noretval
|
||||
|
||||
# Store the return value out in the proper type.
|
||||
cmpeq $18, FFI_TYPE_INT, $1
|
||||
bne $1, $retint
|
||||
cmpeq $18, FFI_TYPE_FLOAT, $2
|
||||
bne $2, $retfloat
|
||||
cmpeq $18, FFI_TYPE_DOUBLE, $3
|
||||
bne $3, $retdouble
|
||||
|
||||
$noretval:
|
||||
ldq $15, 8($15)
|
||||
ret
|
||||
|
||||
$retint:
|
||||
stq $0, 0($19)
|
||||
nop
|
||||
ldq $15, 8($15)
|
||||
ret
|
||||
|
||||
$retfloat:
|
||||
sts $f0, 0($19)
|
||||
nop
|
||||
ldq $15, 8($15)
|
||||
ret
|
||||
|
||||
$retdouble:
|
||||
stt $f0, 0($19)
|
||||
nop
|
||||
ldq $15, 8($15)
|
||||
ret
|
||||
|
||||
.end ffi_call_osf
|
||||
|
||||
/* ffi_closure_osf(...)
|
||||
|
||||
Receives the closure argument in $1. */
|
||||
|
||||
.align 3
|
||||
.globl ffi_closure_osf
|
||||
.ent ffi_closure_osf
|
||||
ffi_closure_osf:
|
||||
.frame $30, 16*8, $26, 0
|
||||
.mask 0x4000000, -16*8
|
||||
ldgp $29, 0($27)
|
||||
subq $30, 16*8, $30
|
||||
stq $26, 0($30)
|
||||
.prologue 1
|
||||
|
||||
# Store all of the potential argument registers in va_list format.
|
||||
stt $f16, 4*8($30)
|
||||
stt $f17, 5*8($30)
|
||||
stt $f18, 6*8($30)
|
||||
stt $f19, 7*8($30)
|
||||
stt $f20, 8*8($30)
|
||||
stt $f21, 9*8($30)
|
||||
stq $16, 10*8($30)
|
||||
stq $17, 11*8($30)
|
||||
stq $18, 12*8($30)
|
||||
stq $19, 13*8($30)
|
||||
stq $20, 14*8($30)
|
||||
stq $21, 15*8($30)
|
||||
|
||||
# Call ffi_closure_osf_inner to do the bulk of the work.
|
||||
mov $1, $16
|
||||
lda $17, 2*8($30)
|
||||
lda $18, 10*8($30)
|
||||
jsr $26, ffi_closure_osf_inner
|
||||
ldgp $29, 0($26)
|
||||
ldq $26, 0($30)
|
||||
|
||||
# Load up the return value in the proper type.
|
||||
lda $1, $load_table
|
||||
s4addq $0, $1, $1
|
||||
ldl $1, 0($1)
|
||||
addq $1, $29, $1
|
||||
jmp $31, ($1), $load_32
|
||||
|
||||
.align 4
|
||||
$load_none:
|
||||
addq $30, 16*8, $30
|
||||
ret
|
||||
|
||||
.align 4
|
||||
$load_float:
|
||||
lds $f0, 16($30)
|
||||
nop
|
||||
addq $30, 16*8, $30
|
||||
ret
|
||||
|
||||
.align 4
|
||||
$load_double:
|
||||
ldt $f0, 16($30)
|
||||
nop
|
||||
addq $30, 16*8, $30
|
||||
ret
|
||||
|
||||
.align 4
|
||||
$load_u8:
|
||||
#ifdef __alpha_bwx__
|
||||
ldbu $0, 16($30)
|
||||
nop
|
||||
#else
|
||||
ldq $0, 16($30)
|
||||
and $0, 255, $0
|
||||
#endif
|
||||
addq $30, 16*8, $30
|
||||
ret
|
||||
|
||||
.align 4
|
||||
$load_s8:
|
||||
#ifdef __alpha_bwx__
|
||||
ldbu $0, 16($30)
|
||||
sextb $0, $0
|
||||
#else
|
||||
ldq $0, 16($30)
|
||||
sll $0, 56, $0
|
||||
sra $0, 56, $0
|
||||
#endif
|
||||
addq $30, 16*8, $30
|
||||
ret
|
||||
|
||||
.align 4
|
||||
$load_u16:
|
||||
#ifdef __alpha_bwx__
|
||||
ldwu $0, 16($30)
|
||||
nop
|
||||
#else
|
||||
ldq $0, 16($30)
|
||||
zapnot $0, 3, $0
|
||||
#endif
|
||||
addq $30, 16*8, $30
|
||||
ret
|
||||
|
||||
.align 4
|
||||
$load_s16:
|
||||
#ifdef __alpha_bwx__
|
||||
ldwu $0, 16($30)
|
||||
sextw $0, $0
|
||||
#else
|
||||
ldq $0, 16($30)
|
||||
sll $0, 48, $0
|
||||
sra $0, 48, $0
|
||||
#endif
|
||||
addq $30, 16*8, $30
|
||||
ret
|
||||
|
||||
.align 4
|
||||
$load_32:
|
||||
ldl $0, 16($30)
|
||||
nop
|
||||
addq $30, 16*8, $30
|
||||
ret
|
||||
|
||||
.align 4
|
||||
$load_64:
|
||||
ldq $0, 16($30)
|
||||
nop
|
||||
addq $30, 16*8, $30
|
||||
ret
|
||||
|
||||
.end ffi_closure_osf
|
||||
|
||||
.section .rodata
|
||||
$load_table:
|
||||
.gprel32 $load_none # FFI_TYPE_VOID
|
||||
.gprel32 $load_32 # FFI_TYPE_INT
|
||||
.gprel32 $load_float # FFI_TYPE_FLOAT
|
||||
.gprel32 $load_double # FFI_TYPE_DOUBLE
|
||||
.gprel32 $load_double # FFI_TYPE_LONGDOUBLE
|
||||
.gprel32 $load_u8 # FFI_TYPE_UINT8
|
||||
.gprel32 $load_s8 # FFI_TYPE_SINT8
|
||||
.gprel32 $load_u16 # FFI_TYPE_UINT16
|
||||
.gprel32 $load_s16 # FFI_TYPE_SINT16
|
||||
.gprel32 $load_32 # FFI_TYPE_UINT32
|
||||
.gprel32 $load_32 # FFI_TYPE_SINT32
|
||||
.gprel32 $load_64 # FFI_TYPE_UINT64
|
||||
.gprel32 $load_64 # FFI_TYPE_SINT64
|
||||
.gprel32 $load_none # FFI_TYPE_STRUCT
|
||||
.gprel32 $load_64 # FFI_TYPE_POINTER
|
||||
|
||||
/* Assert that the table above is in sync with ffi.h. */
|
||||
|
||||
#if FFI_TYPE_FLOAT != 2 \
|
||||
|| FFI_TYPE_DOUBLE != 3 \
|
||||
|| FFI_TYPE_UINT8 != 5 \
|
||||
|| FFI_TYPE_SINT8 != 6 \
|
||||
|| FFI_TYPE_UINT16 != 7 \
|
||||
|| FFI_TYPE_SINT16 != 8 \
|
||||
|| FFI_TYPE_UINT32 != 9 \
|
||||
|| FFI_TYPE_SINT32 != 10 \
|
||||
|| FFI_TYPE_UINT64 != 11 \
|
||||
|| FFI_TYPE_SINT64 != 12 \
|
||||
|| FFI_TYPE_STRUCT != 13 \
|
||||
|| FFI_TYPE_POINTER != 14 \
|
||||
|| FFI_TYPE_LAST != 14
|
||||
#error "osf.S out of sync with ffi.h"
|
||||
#endif
|
||||
@@ -0,0 +1,183 @@
|
||||
/* -----------------------------------------------------------------------
|
||||
ffi.c - Copyright (c) 1998 Cygnus Solutions
|
||||
|
||||
ARM Foreign Function Interface
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
``Software''), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included
|
||||
in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL CYGNUS SOLUTIONS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
OTHER DEALINGS IN THE SOFTWARE.
|
||||
----------------------------------------------------------------------- */
|
||||
|
||||
#include <ffi.h>
|
||||
#include <ffi_private.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
/* ffi_prep_args is called by the assembly routine once stack space
|
||||
has been allocated for the function's arguments */
|
||||
|
||||
/*@-exportheader@*/
|
||||
void ffi_prep_args(char *stack, extended_cif *ecif)
|
||||
/*@=exportheader@*/
|
||||
{
|
||||
register unsigned int i;
|
||||
register int tmp;
|
||||
register unsigned int avn;
|
||||
register void **p_argv;
|
||||
register char *argp;
|
||||
register ffi_type **p_arg;
|
||||
|
||||
tmp = 0;
|
||||
argp = stack;
|
||||
|
||||
if ( ecif->cif->rtype->type == FFI_TYPE_STRUCT ) {
|
||||
*(void **) argp = ecif->rvalue;
|
||||
argp += 4;
|
||||
}
|
||||
|
||||
avn = ecif->cif->nargs;
|
||||
p_argv = ecif->avalue;
|
||||
|
||||
for (i = ecif->cif->nargs, p_arg = ecif->cif->arg_types;
|
||||
(i != 0) && (avn != 0);
|
||||
i--, p_arg++)
|
||||
{
|
||||
size_t z;
|
||||
|
||||
/* Align if necessary */
|
||||
if (((*p_arg)->alignment - 1) & (unsigned) argp) {
|
||||
argp = (char *) ALIGN(argp, (*p_arg)->alignment);
|
||||
}
|
||||
|
||||
if (avn != 0)
|
||||
{
|
||||
avn--;
|
||||
z = (*p_arg)->size;
|
||||
if (z < sizeof(int))
|
||||
{
|
||||
z = sizeof(int);
|
||||
switch ((*p_arg)->type)
|
||||
{
|
||||
case FFI_TYPE_SINT8:
|
||||
*(signed int *) argp = (signed int)*(SINT8 *)(* p_argv);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_UINT8:
|
||||
*(unsigned int *) argp = (unsigned int)*(UINT8 *)(* p_argv);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_SINT16:
|
||||
*(signed int *) argp = (signed int)*(SINT16 *)(* p_argv);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_UINT16:
|
||||
*(unsigned int *) argp = (unsigned int)*(UINT16 *)(* p_argv);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_STRUCT:
|
||||
*(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
|
||||
break;
|
||||
|
||||
default:
|
||||
FFI_ASSERT(0);
|
||||
}
|
||||
}
|
||||
else if (z == sizeof(int))
|
||||
{
|
||||
*(unsigned int *) argp = (unsigned int)*(UINT32 *)(* p_argv);
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy(argp, *p_argv, z);
|
||||
}
|
||||
p_argv++;
|
||||
argp += z;
|
||||
}
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* Perform machine dependent cif processing */
|
||||
ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
|
||||
{
|
||||
/* Set the return type flag */
|
||||
switch (cif->rtype->type)
|
||||
{
|
||||
case FFI_TYPE_VOID:
|
||||
case FFI_TYPE_STRUCT:
|
||||
case FFI_TYPE_FLOAT:
|
||||
case FFI_TYPE_DOUBLE:
|
||||
cif->flags = (unsigned) cif->rtype->type;
|
||||
break;
|
||||
|
||||
default:
|
||||
cif->flags = FFI_TYPE_INT;
|
||||
break;
|
||||
}
|
||||
|
||||
return FFI_OK;
|
||||
}
|
||||
|
||||
/*@-declundef@*/
|
||||
/*@-exportheader@*/
|
||||
extern void ffi_call_SYSV(void (*)(char *, extended_cif *),
|
||||
/*@out@*/ extended_cif *,
|
||||
unsigned, unsigned,
|
||||
/*@out@*/ unsigned *,
|
||||
void (*fn)());
|
||||
/*@=declundef@*/
|
||||
/*@=exportheader@*/
|
||||
|
||||
void ffi_call(/*@dependent@*/ ffi_cif *cif,
|
||||
void (*fn)(),
|
||||
/*@out@*/ void *rvalue,
|
||||
/*@dependent@*/ void **avalue)
|
||||
{
|
||||
extended_cif ecif;
|
||||
|
||||
ecif.cif = cif;
|
||||
ecif.avalue = avalue;
|
||||
|
||||
/* If the return value is a struct and we don't have a return */
|
||||
/* value address then we need to make one */
|
||||
|
||||
if ((rvalue == NULL) &&
|
||||
(cif->rtype->type == FFI_TYPE_STRUCT))
|
||||
{
|
||||
/*@-sysunrecog@*/
|
||||
ecif.rvalue = alloca(cif->rtype->size);
|
||||
/*@=sysunrecog@*/
|
||||
}
|
||||
else
|
||||
ecif.rvalue = rvalue;
|
||||
|
||||
|
||||
switch (cif->abi)
|
||||
{
|
||||
case FFI_SYSV:
|
||||
/*@-usedef@*/
|
||||
ffi_call_SYSV(ffi_prep_args, &ecif, cif->bytes,
|
||||
cif->flags, ecif.rvalue, fn);
|
||||
/*@=usedef@*/
|
||||
break;
|
||||
default:
|
||||
FFI_ASSERT(0);
|
||||
break;
|
||||
}
|
||||
}
|
||||