Compare commits

..
1 Commits
Author SHA1 Message Date
nobody d02373e837 This commit was manufactured by cvs2svn to create tag 'MCS_0_6'.
svn path=/tags/MCS_0_6/mcs/; revision=574
2001-08-22 23:32:44 +00:00
11557 changed files with 58471 additions and 1898189 deletions

No files matched your search

-6
View File
@@ -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
View File
@@ -1,3 +1,2 @@
Miguel de Icaza ([email protected])
Paolo Molaro ([email protected])
Dietmar Maurer ([email protected])
-485
View File
@@ -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!
-1862
View File
File diff suppressed because it is too large. Load diff
+1 -187
View File
@@ -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
-1578
View File
File diff suppressed because it is too large. Load diff
+13 -227
View File
@@ -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
-37
View File
@@ -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
+52 -53
View File
@@ -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
+14
View File
@@ -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
+16 -1236
View File
File diff suppressed because it is too large. Load diff
-5
View File
@@ -1,5 +0,0 @@
Makefile.in
Makefile
config
.cvsignore
browscap.ini
File diff suppressed because it is too large. Load diff
-17
View File
@@ -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 $^ > $@
Binary file not shown.
-9
View File
@@ -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>
-210
View File
@@ -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>
+3
View File
@@ -0,0 +1,3 @@
Makefile.in
Makefile
all-docs
+19
View File
@@ -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
+17
View File
@@ -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
+188
View File
@@ -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
+112
View File
@@ -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.
+183
View File
@@ -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.
+16
View File
@@ -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.
+16
View 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>
+105
View File
@@ -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.
+190
View File
@@ -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.
+50
View File
@@ -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.
+177
View File
@@ -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.
+722
View File
@@ -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.
+9
View File
@@ -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.
+119
View File
@@ -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>
+103
View File
@@ -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>
+276
View File
@@ -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>)
+14
View File
@@ -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.
+173
View File
@@ -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.
+46
View File
@@ -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.
+43
View File
@@ -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.
+121
View File
@@ -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>
+30
View File
@@ -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
+12
View File
@@ -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)
+144
View File
@@ -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.
+38
View File
@@ -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>
+2
View File
@@ -0,0 +1,2 @@
* The MonoNet Team
+21
View File
@@ -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>.
+6
View File
@@ -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.
+1
View File
@@ -0,0 +1 @@
Discuss with write new JIT
+67
View File
@@ -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.
+2
View File
@@ -0,0 +1,2 @@
*.src
*.html
+17
View File
@@ -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
+26
View File
@@ -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";
}
}
File renamed without changes.

Before

Width:  |  Height:  |  Size: 4.8 KiB

After

Width:  |  Height:  |  Size: 4.8 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.5 KiB

After

Width:  |  Height:  |  Size: 4.5 KiB

File renamed without changes.
File renamed without changes.

Before

Width:  |  Height:  |  Size: 3.0 KiB

After

Width:  |  Height:  |  Size: 3.0 KiB

Binary file not shown.

Before

Width:  |  Height:  |  Size: 4.4 KiB

After

Width:  |  Height:  |  Size: 4.4 KiB

File renamed without changes.

Before

Width:  |  Height:  |  Size: 49 B

After

Width:  |  Height:  |  Size: 49 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 156 B

After

Width:  |  Height:  |  Size: 157 B

+39
View File
@@ -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
+73
View File
@@ -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\">&nbsp;&nbsp;&nbsp<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;
}
+78
View File
@@ -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>
-15
View File
@@ -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
-525
View File
@@ -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).
-44
View File
@@ -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
-57
View File
@@ -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.
-271
View File
@@ -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.
-110
View File
@@ -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.
-173
View File
@@ -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
-31
View File
@@ -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).
-84
View File
@@ -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,
-54
View File
@@ -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.
-64
View File
@@ -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.
-125
View File
@@ -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.
-52
View File
@@ -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
-208
View File
@@ -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
-771
View File
@@ -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. <
-424
View File
@@ -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.
-98
View File
@@ -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
-63
View File
@@ -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);
-113
View File
@@ -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...)
-16
View File
@@ -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.
-26
View File
@@ -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().
-33
View File
@@ -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 |
-----------------------------------------------------------
| | | | | | | | |
-----------------------------------------------------------
-156
View File
@@ -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.
-135
View File
@@ -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.
-3
View File
@@ -1,3 +0,0 @@
Makefile.in
Makefile
.deps
-16
View File
@@ -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.
-15
View File
@@ -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
-1263
View File
File diff suppressed because it is too large. Load diff
+16
View File
@@ -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
+440
View File
@@ -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.
+764
View File
@@ -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.
+20
View File
@@ -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.
+72
View File
@@ -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
+513
View File
@@ -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].
+12
View File
@@ -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
+97
View File
@@ -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
])
+247
View File
@@ -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;
}
+278
View File
@@ -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
+183
View File
@@ -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;
}
}
Loaded 100 of 11557 files, more files were not shown because too many files have changed in this diff. Show more