Subject: publishing
From: Craig Chambers (chambers@cs.washington.edu)
Date: Fri Sep 21 2001 - 19:29:33 PDT
I'm publishing some major changes to WIL and Whirlwind. This was
precipitated by my efforts to add vtbl arrays to objects.
** Wil language changes:
*) I broke down and changed gf, fun, and class constructor expressions
into regular declarations. Initial var declarations go away, since
these new kinds of declarations (along with rep and method
declarations) are the only declarations that need to have recursion
and forward references supported.
*) I changed how objects work. Instead of just being records used by
convention, they're now tied closely to classes. A class now
specifies the record rep of its instance variables; reps of
superclasses must be compatible (all must be a prefix of some longest
superclass rep), and the subclass extends the rep of its superclasses.
An object rep is a new kind of rep, written "object C" where C is some
class, whose layout is derived from the layout of C. A class field is
implicitly part of an object rep, and made explicit as part of
lowering. Object reps now support @< and @= operations to test their
implicit class, and #< is now the subclass comparison operation over
class values.
*) I changed now dynamic arrays are created, to put the length
expression as an extra argument of the new expression rather than
embedded in the representation. This cleaned up the implementation,
and allows naming such dynamically sized representations and including
them as part of the layout of class declarations.
I've updated the whirlwind/notes/ir.txt file to document these
language changes, the Java front-end to generate the new code, and all
the various .wil generated and hand-written files. I expanded the
test suite to exercise the new features and more on objects, classes,
methods, and gfs. Of course, I modified Whirlwind to handle these
language changes.
** Whirlwind changes:
*) I changed how Whirlwind determines what is saved in a checkpoint.
Now, like options, each object (usually a field of the compiler) that
wants to be stored in the checkpoint registers a checkpoint_entry in
the checkpoint_entries global.
*) To properly evaluate code in a scope, we now have *three* passes:
one to create initial objects (e.g. classes, gfs, and funs); a second
to add references between initial objects (e.g. superclass links and
method decls); and finally a third to actually run the non-initial
code. Accordingly, I've extended the code generation to have two
special initial code functions, not just one. (I couldn't figure out
how to get the old initial var decl scheme to work in the face of
forward & recursive references, so the new scheme solves this open
problem.)
*) I added a ProgramWindIR IR, of which there is one for the whole
program. It works well at keeping track of what slices/invariants
have been performed over the whole program, and simplifies some of the
top-level build-globals logic.
*) I added some code that computes dispatching patterns (e.g. no
dispatching, single dispatching, general dispatching) for each gf in
the program. It's the first piece at implementing gf applications via
vtbl indirection.
*) I reworked the builder code a lot. I removed a lot of unused
generality, and focused on the operations that we actually use in
lowering and in the initial set of 4 optimizations. I rewrote the
optimizations to use the new builder interfaces. I think things now
are much simpler, and easier to use, and with fewer magic incantations
to remember to do. The code to build replacement graphs is now a lot
shorter. [The remaining big irritation, in my opinion, is having to
set the representation of all new nodes. I'd like eventually to
compute these reps automatically, as we do on whole IRs.]
*) I extended the replacement graph verification code to also do
rep_checking of the replacement graph and of the modified graph, at
the appropriate level. (Perhaps verifying an IR containing a
RepsComputed slice should always do this...)
*) I added some code that might support automatically constructing
various pseudoslices, including computing reps, over fragments. Not
tested yet.
*) I added some filename name mangling to allow e.g. $ in source file
names (for inner classes), even though make doesn't like them in
target file names.
*) I put back in the up_to_date operation. Its implementation is much
cleaner with Keunwoo's reorganized file_info hierarchy.
*) I replaced the Strategy object with the app compiler object.
*) I fixed a problem with the Java front-end thinking that methods
could only raise java.lang.Exception objects; in fact, they can raise
java.lang.Throwable objects.
*) I added a couple of constant propagation et al. tests from Sorin to
the test suite.
** Status:
At this point, the whirlwind test program compiles and runs w/ and w/o
optimization. The towers Java program compiles and runs w/ and w/o
optimization, up to the point it tries to invoke a generic function;
it gets successfully through evaluation of all the top-level
declarations and expressions in the program, building run-time class
hierarchies, registering classes, etc. The towers Java program
compiled against the 1.2.1 SDK (all 574 files of it) compiles & runs
w/o optimization (I haven't waited for the optimized version to finish
compiling).
-- Craig
_______________________________________________
Cecil mailing list
Cecil@cs.washington.edu
http://majordomo.cs.washington.edu/mailman/listinfo/cecil
This archive was generated by hypermail 2b25 : Fri Sep 21 2001 - 19:30:04 PDT