Interesting paper on Supporting Binary Compatibility with StaticCompilation

[Mark Wielaard <mark at klomp dot org>]

Hi,

The following paper seems to be a must read for gcj hackers:

http://flint.cs.yale.edu/flint/publications/bincomp.html
Supporting Binary Compatibility with Static Compilation
Dachuan Yu, Zhong Shao, Valery Trifonov
Department of Computer Science, Yale University

Below is the Abstract, Conclusion and Acknowledgments.
I believe this describes what Bryce calls "the grand binary
compatibility plan".

Cheers,

Mark

    Abstract
    
    There is an ongoing debate in the Java community on
    whether statically compiled implementations can meet
    the Java specification on dynamic features such as binary
    compatibility. Static compilation is sometimes desirable
    because it provides better code optimization, smaller
    memory footprint, more robustness, and better intellec-
    tual property protection. Unfortunately, none of the ex-
    isting static Java compilers support binary compatibility,
    because it incurs unacceptable performance overhead.
    In this paper, we propose a simple yet effective solu-
    tion which handles all of the binary-compatibility cases
    specified by the Java Language Specification. Our ex-
    perimental results using an implementation in the GNU
    Java compiler shows that the performance penalty is on
    average less than 2%. Besides solving the problem for
    static compilers, it is also possible to use this technique
    in JIT compilers to achieve an optimal balance point be-
    tween static and dynamic compilation.

    Conclusion
    
    We have presented a scheme which uses static compi-
    lation to support Java binary compatibility. All of the
    binary compatibility requirements in the Java Language
    Specification are supported with the same set of sim-
    ple techniques. Binaries changed in a compatible man-
    ner can link successfully with pre-existing binaries that
    previously linked without error. Incompatible changes
    raise various run-time exceptions accordingly. Our im-
    plementation shows that this approach is fairly efficient
    and has the potential of being applied to real systems.
    
    Acknowledgments
    
    We want to specially thank Bryce McKinlay for imple-
    menting the indirect dispatching scheme for GCJ and his
    inspiring discussion on related issues, and Manish Gupta
    for keeping us informed about the state-of-the-art in dy-
    namic Java compilers. We also thank many posters on
    the GCJ mailing list (java@gcc.gnu.org) for answering
    our questions about the GCJ internals, Greg Collins and
    Andrew McCreight for valuable comments on an early
    version of our paper, and the anonymous reviewers.