In the merged register map, if there are multiple aliases of the same
type for a given register, eliminate all but one of the aliases.

Repackage lifetime-analysis and register-allocation code.

Eliminate fluid let to patch SF since the latter has now been fixed.
Introduce use of `->environment'.

(block-partial-ancestry): allow ancestor to be same as starting block.

Fix another case which was generating dangling code.

When generating new code, must use contexts instead of blocks.

Rule for (OVERFLOW-TEST) must return some code.  Before, it was
winning entirely by accident.

Change `block' to `context'.

Delete `variable-auxiliary!'.

*** empty log message ***

Lots of changes to implement frame reuse stuff.  See the individual
log entries.

Delete all of the system predicate expansions: variable?, etc.

Change modifiers to return `unassigned'.  This will result in superior
compiled code as the compiler will not attempt to produce the original
value of the location being modified.

Frame reuse changes.  Also add change to prevent noop from pop-frames.

* Change `block' to `context' where needed.

* New abstractions support owning and disowning of block children.

* Guarantee that `combination/model!' is always defined.

* Change `block' to `context' where needed.

* Make changes to convert `block' to `context'.

* Update multiple value stuff.

* Move `original-block-parent' to "base/blocks.scm".

* Add pass which runs afterwards to find closures and install the
correct reference context for each.

* Fix bug in `syntax-files!': was not causing circularly dependent
files to recompile one another when needed.

* Add declarations for new files.

* Change `discriminate-items' to guarantee that the order of the
results is the same as the order of the argument.

* Update multiple value stuff.

* Add new passes to setup frame adjustments of combinations, compute
subproblem free variables, and recompute closure contexts.

* Change `block' to `context' where needed.

* Define `procedure-arity-encoding'.

* Delete `set-procedure-closing-block!'.

* Redefine `procedure/type' to discriminate closure and
trivial-closure types.

`tagged-vector/subclass-predicate' should use `vector-tag?' predicate
rather than `pair?'.

* Add new lvalue slots: `initial-{for,back}ward-links'.  These
correspond to `initial-values' in that they are the first order links
of the DFG.

* Delete `popping-limits' slot from variables.

* Change `variable-in-known-location?' to accept a context rather than
a block.

* Change `block' fields to `context' where appropriate.

* Add two new items to combinations: `frame-adjustment' and
`reuse-existing-frame?'.

* Add `context' field to `true-test' node.

* Add new node type: `stack-overwrite'.

* Delete `node/offset'.  Offsets are now stored in reference contexts.

Significant repackaging.

Redefine `block-original-parent' to be `original-block-parent' in
keeping with changes to closure analysis.

Change analysis in two ways: (1) static link computation now uses
`initial-backward-links' to get much more precise notion of when
parent is the stack link.  (2) dynamic link computation stores all of
the popping limits in the caller block for use by the combination code
generator.

UUO links to entities and some procedures with optional arguments have
been improved.

New type: stack-overwrite.  Remove changes to delete unreachable
nodes, as this code was buggy.  No longer needed because of changes to
code generator, but we'll replace it soon anyway.

Block->context changes.  Improve handling of static links.  New type:
stack-overwrite.

Multiple value changes.  Block->context changes.

Many changes for frame reuse stuff.

Significant changes for frame reuse stuff.

* Change `block' to `context' where needed.

* Change open coding stuff to avoid generating code that will be
dangling in the output.

* Move everything except the core block search stuff to another file.

* Update to use reference contexts.

Many changes: see the diff.

Major changes to accomodate frame reuse.

Significant changes: see the diff.

Add new node type: `stack-overwrite'

* Make necessary changes to convert `block' to `context'.

* Initialize the contexts at the end of FG generation.

* Add `free-variables' slot to subproblem objects.

* Define `continuation*/type' and `set-continuation*/type!'.

* Define `continuation*/context'.

* Change `block' to `context' in virtual continuations.

Change `block' to `context' where needed.

UUO links to entities and some procedures with optional arguments have
been improved.

* Add new node type: `stack-overwrite'.

Delete popping-limit stuff from continuations.  Also delete
`reduction-continuation/block' which was never used.

* Add `popping-limits' components to block.

* Change `ic-block?' to be non-integrable.

* Change `block-ancestry' to eliminate random extra argument.

* Define new procedure `block-partial-ancestry' which is like
`block-ancestry' except that it stops at a given ancestor.

* Make `stack-block/static-link?' be more sophisticated: static link
is not needed unless the block has some free variables.  Also, for IC
parent, check to see if lookup is being used on the parent.

* Define new procedures `block-original-parent', and
`{dis,}own-block-child!'.

Initial revision

Fix some bugs: (1) was allowing volatile expressions to be moved
around; (2) was moving stack references over assignments to the same
stack location.

New definitions:
rtl:invocation-prefix?
rtl:volatile-expression?
rtl:stack-reference-expression?
rtl:expression-contains?

Change to store the initial links as well as the transitive closure.

* Add two new slots to lvalue type.

* Change vector modification definitions to return `unspecific' rather
than the original value.

Delete all of the system predicate expansions: variable?, etc.

Change modifiers to return `unassigned'.  This will result in superior
compiled code as the compiler will not attempt to produce the original
value of the location being modified.

Missing \n\ in documentation string.

Rewrite constant folding and closure analysis phases.
Write two new phases: compute-call-graph and side-effect-analysis.

Initial revision

Add a couple of fg optimizer phases:
- compute call graph
- side effect analysis

Add a list? check to syntax-expression and some paranoia to syntax-sequence.

Fix a bug in blktyp, and allow envopt to keep data structures when desired.

1) Integrated parameters are filtered before we design the closure
block.  This fixes a bug by which closures with no free variables were
created.

2) Add paranoia checks to make sure that a trivial closure remains
trivial after its closure block is computed.  This is important
because if it was previously considered trivial, it may already have
been integrated into some other closure.  This check would have caught
the bug fixed in 1.

free callers and callees lists are preserved if
compiler:preserve-data-structures? is true.

Improve constant folding:
- Mutable objects can now be known values of variables, although
operations will not be open coded over them.
- The outer analysis has been changed to have passed-out and passed-in
counters rather than flags.  In this way it is easy to recompute their
values value after an operation has been constant folded, and decide
whether further propagation can occur or not.
- Non-primitive operations can now be constant folded.  There is a new
declaration: USUAL-DEFINITION which allows the variables to which it
applies to be constant folded to their usual (global) definition.
Examples of this are ATAN, GCD, etc.
- Fix bug in base/utils.scm by which temporary label names were being
interned.  This would cause the compiler to run out of storage after
many compilations.

Add `flush-output' operation to file output ports.  This change
requires microcode 10.63 or later.

Rewrite unix file opening code to be really careful about what kinds
of files can be opened, and how.  As of now, only regular files and
character special files are allowed; symbolic links are detected when
opening output files and deleted, thus overwriting the link rather
than writing through it.

Implement new primitive `file-flush-output' which is needed since we
changed file I/O to use buffered stdio some time ago.

Fix self evaluation of compiled entries which are not compiled
expressions.

Change to use `for' loop on subdirectories.

Initial revision

Add fix:<mumble> to the list of constant-foldable-primitives.

Generalize rule for `cons-closure' so that it handles more types of
target expressions.

Change `cons-closure' from a statement to an expression.  This allows
us more freedom in choosing the target register.

Change `cons-closure' from a statement to an expression.  This allows
us more freedom in choosing the target register.

Add new primitive, `compiled-closure->entry'.

(rcd): Fix case where there is no error continuation.  Allow
specification of continuation without filename.

Add new primitive `compiled-closure->entry', and new predicate
`compiled-closure?'.  Change the unparser to print compiled code
entries differently, showing their offset and absolute address for
better debugging.  Closures show this information for their entry
point, and additionally show the address of the closure itself.

Kill dead registers when not doing control merge.

Fix incorrect reference.

Fix unbound variable bug.  Delete unused variable.

Substantial rewrite of code that computes register map of a basic
block with multiple "previous" edges.  The algorithm is roughly as
follows:

* Wait until all of the "previous" nodes have been generated.  This
depends on the absence of explicit loops in the graph, and will
require some rethinking when we introduce these loops.

* Compute a "weighted average" register map (the target map) from the
maps of the "previous" nodes.  This is a heuristic computation, but it
seems to have about the right effect for simple cases.

* Separate the "previous" maps into equivalence classes, where all the
maps in an equivalence class can be converted to the target map with
an identical sequence of instructions.  This could be made
substantially more sophisticated, but for now it will do.

* For each edge, insert code to coerce the "previous" map into the
target map.  Heed the equivalence classes that were just computed, and
causes all maps in a given equivalence class to share a single code
sequence.

Initial revision

Add new file: "back/mermap".

(delete-dead-registers!): Rewrite to accomodate change to
`delete-pseudo-registers'.

(bblock-compress!): when counting previous edges to determine if this
is the beginning of a basic block, we must include edges which have no
left node.

Fix bugs in previously unused `coerce-map-instructions'.  Add new
procedures `register-map:keep-live-registers' and `map-equal?'.

Add dependency for new file: "back/mermap".

Improve generic arithmetic by adding branch preferences to type,
range, and overflow tests.  These preferences cause the linearizer to
attempt to optimize for the preferred branch.

Export switches to global environment.

Heed branch preferences when deciding which branch to generate in line.

Specify branch preferences for things like type, range, and overflow
checks; the linearizer will heed these when making decisions about
which branch falls through.  Recode string operations to do type and
range checks if these are enabled.

Add operations to allow specification of branch preference in pblocks.

An lvalue whose only backward link is itself may be known.
This is a patch. General loops should work as well.

"machines/bobcat/dassm1" now uses the compiler syntax table.

Initial revision

Fix unbound variable error.

Efficiency improvement to last change.

*** empty log message ***

Last change was a little too ambitious.  Back off a bit.

Must adjust stack pointer for special primitive invocations.

Change code generation for `&=' to significantly improve output code.
Many minor editing changes also.

Fix typo introduced in last changes.

Patch up several rules to capture common abstractions.  Add a couple
of new rules which are conglomerates of existing rules, and which can
be more efficiently generated as a unit.