Current state of the `ooc' project?

[jnzimmer@informatik.uni-kl.de]

Hello!

As Michael van Acken sent a TODO list, I'm very much interested in
what is already done or will be done in the near future.

From my side, I realized some of the optimization steps described
in the Brandis paper, as described below:

- Constant propagation and unreachable code elimination.
The module looks for constants and propagates them. As a result from
this propagation, some regions may be found to be never executed, so
they are deleted. For regions, which are found to be always executed,
the leading guard is eliminated. 
(code is considered `finished')

- Algebraic transformations
Some instruction patterns in the GSA code generated by the frontend
could be replaced by simpler ones, e.g. "a+0" is the same as "a". 
This module tries to find such code patterns and replaces them by the
equivaltent but cheeper ones.
(code is considered `finished')

- Common subexpression elimination (CSE)
In the intermediate GSA code there are often instructions which yield
the same result. CSE tries to find them and reuse the result of one
execution of such an instruction in as many places as possible. 
(code is considered `beta')

- Topological sort
This could be described as a `prototype' of an instruction
scheduler. The module takes the GSA code and rearranges it. This
rearrangement is done in such a way that an instruction is emited
before it is used by another instruction.
(code is considered `finished')

- Dependency analysis
I'm currently working on this module. The goal is to remove as many
instruction dependencies for accesses/updates on $store and records as
possible. Moreover, I try fold several update/access instructions into
one update/access instruction, when possible.
(code is in the work, not even `alpha')


These are the things I am currently working on. 

But now for you. As the frontend is there and considered `working',
I'm very much interested if someone has got some experience in trying
to write a backend for the GSA code. I myself have no idea how the GSA
code could be translated to object files (machine language) for a
specific processor. 
Also, has anyone tried to work on some optimization stuff?


So long,
  Juergen Zimmermann