Re: Binary Compatibility: debug info for compiled Java programs

[Andrew Haley <aph@redhat.com>]

Ian Lance Taylor writes:
 > Andrew Haley <aph@redhat.com> writes:
 > 
 > >  > By the way, Tom and Andrew, I meant to ask, but I forgot: would it
 > >  > make sense to build the numeric otables and atables for the common
 > >  > case, and then recompute only when required?
 > > 
 > > That's possibly true, but you'd somehow have to discover that
 > > something had changed, and I'm not sure how you'd do that without
 > > doing the lookups.
 > 
 > It seems to me that you could hash the relevant information for each
 > relevant class and store it in the defining class and in the loaded
 > class.  When you load the binary, check the hashes, and recompute if
 > they differ.

That's worth thinking about.

Say you have a reference to foo.bar and a hash for foo.  You compute
the hash for foo and see that it hasn't changed, so you don't have to
recompute the offset of foo.bar.  That's cool, but hashing is no
easier than recomputing the offset.  So, it's only a win if you have a
lot of references to members of foo.  This might be a big win if you
can show that none of your ancestors have changed, so you don't need
to recompute the offsets of any of your own members.

What you could perhaps do is have two versions of a method, and only
use the BC version if the classes it depends on have changed.  That
would be quicker, but maybe more effort than is really warranted.  It
might be useful for escape analysis, though: you might be able to
prove that an object doesn't escape as long as the lasses it depends
on haven't changed.

 > >  > I have to think that the common case is pretty darn common--I'm
 > >  > sure people don't spend all their time loading classes into
 > >  > different hierarchies.
 > > 
 > > What is very common is for people to distribute Java binaries without
 > > specifying the exact versions of the classes they depend on.  So, it's
 > > normal for the run-time library environment of a Java program to be
 > > different from the compile-time environment.  The whole idea of binary
 > > compatibility is to make this possible.
 > 
 > On the other hand, at during compile/edit/debug, the compile-time and
 > run-time environment should be similar.

Yes, that's true.

Andrew.