Subject: publishing
chambers@cs.washington.edu
Date: Tue Jan 04 2000 - 13:29:49 PST
I'm publishing my current system, primarily changes to get Whirlwind
to successfully typecheck and compile, with some dataflow analysis,
the Java towers and javac programs.
Vortex-visible changes:
*) I reorganized the code for opening and initializing the output
files, so that individual compiler applications (e.g. vortex
vs. whirlwind) can customize what code gets emitted.
*) I fixed what seemed to be a bug in testing whether compiled files
are out of date, to check whether the generated files exist.
*) I reorganized the code for sequential file streams.
*) I tweaked the code for making checkpoints to enable it to be
customized by the compiler application (vortex vs. whirlwind).
*) I included a bug fix to the dataflow analysis framework found by
Jonathan Aldrich.
*) I included a bug fix to big-int division found by one of our
external users. (!)
*) I did some renamings of various methods, e.g. code_gen -> compile,
to make things more sensible.
Other visible changes:
*) I changed all the /usr/local/bin/perl references in various scripts
to /usr/bin/perl. The latter is on the new june, while the former is
not. /usr/bin/perl appears to be on all our different kinds of
machines, although it is sometimes perl 4 and sometimes perl 5.
Whirlwind-specific changes:
*) In part based on my work on the representations grant proposal and
in part based on my previous implementation work, I made some changes
and improvements to the IR and representation structure. E.g.: gotos
now do not pass arguments. I fixed some problems with character
subrange representations to make the appropriate character set
explicit. I dropped the distinction between abstract and concrete
records, unions, and pointers. I made member names required in
records and unions. I dropped the unknown (...) representation, and
replaced it by allowing records to have a final ... open-ended
indication. I changed how the set of operations allowed on pointers
of particular representations are specified.
*) I dropped some of the reuse of syntactic categories that had
different semantics (e.g. the old Target and TargetSpec), to make the
IRNode structure cleaner.
*) To reduce the size of checkpoints, I simplified the representations
of some IR nodes. E.g. I dropped the IDName wrapper around strings.
*) I made representations separate from IR nodes, and pure values w/o
state. (In the future, they can be canonicalized to further save lots
of space.) I also shrunk the size of CharSet representations.
*) I fixed some problems in generating C code to declare recursive
types.
*) I fixed global declarations to be generated as global declarations
rather than local declarations in the top-level init function.
*) I fixed C code generation to work off the DFG representation as
well as the CFG representation.
*) I changed the global "graphs" phase to construct just the top-level
scope. The name-resolution and rep-checking passes were reorganized
to support incremental per-scope operation, and to record whether
they've been run as trivial slices in the IR data structure for each
procedure. This also allows the program rep to be compressed as part
of saving a checkpoint without losing the global state and requiring
all code to be recompiled. There are two new options,
print_name_resolve_progress and print_rep_check_progress, that allow
monitoring these phases.
*) I implemented the "typecheck" operation to perform name resolution
and rep checking over the whole program. Otherwise, it's performed
incrementally as needed by code generation.
*) To save internal memory space, I added code to incrementally
compress the program representations (i.e., throw out IR data
structures other than the most primitive forms (ASTs or text strings))
as various passes (typechecking or code generation) proceeded. This
was required to be able to handle programs of the size of javac.
There's a new option, print_compress_progress, to watch when
compression happens.
*) I added a topologically numbered DFG representation, and a
view of this supporting forward dataflow analysis. Some renamings of
the fields and data structures of the numbered CFG representation were
needed to allow both numbered representations simultaneously.
*) I started the framework for a lowering pass, which in the future
will be fleshed out to lower abstract representations & operations
into concrete ones.
*) I created a vortex/runtime/wil/src directory to hold the Wil
runtime system, whenever it's written.
Jil changes:
*) I reworked the translation process to following reachable control
flow paths through the bytecodes, based on a worklist of PCs to
translate, rather than the old linear pass through the bytecodes. The
new way now never encounters a PC without knowing its stack/dataflow
information; the old way had to make guesses, which on rare occasion
were wrong and prevented translation of a .class file. Things are
much better now. (But still not ideal: for example, I still don't do
an iterative dataflow analysis to compute the appropriate types for
each local & stack variable at each bytecode PC, but make conservative
guesses as appropriate. I think the current way works, but it
requires generating a bunch of type-casts in the WIL code to make the
Whirlwind representation checking phase happy. It would be nicer to
not generate any such casts (except perhaps as part of an explicit
Java cast bytecode) and to allow the Whirlwind rep checking to catch
more errors and have more precise representations to work with.)
*) I stopped using nested WIL procedures for JSR subroutines,
since I was having trouble getting the scoping right for exceptions
raised within JSR subroutines and handled either within or outside the
subroutines. I went back to the old Vortex IL way of using explicit
return codes and switch statements. This is yucky, as it breaks the
decl-before-use-on-all-paths property of the old code, but at least
the scopes work out. I still have the old code, ifdef'd out, so if I
get aggressive and figure out how to generate exception handlers
properly in the face of nested subroutines, we can go back to the old
way.
*) I fixed a bug in the exception stack Top function.
*) I removed the assumption that a final static field was not assigned
after its declaration, since the class initializer function assigns to
it. Too bad; it's hard to express these stylized "delayed"
initializations to the Whirlwind back-end. Similarly, it's hard to
express that the "initialized" flag associated with each class is
changed from false to true at most once during program execution, and
never changed back from true to false.
*) I moved some functions around to make the organization more
sensible.
*) I changed the Jil Java front-end (and the JV/Jil-em wrapper script)
to match the slightly-changed WIL syntax.
*) I regenerated all the standard .wil files.
-- Craig
This archive was generated by hypermail 2b25 : Tue Oct 03 2000 - 15:21:19 PDT