Flesh out debugging information.  This goes along with changes
introduced in runtime system version 14.31.

Initial revision

Extensive changes to utilize compiled code debugging information:

* The stack parser now knows how to parse individual compiled code
subproblem frames.

* The compiler-info package has been updated to match the new compiled
code info format.

* The environment abstraction has been generalized to handle compiled
code stack and closure frames, when debugging info is available to
describe them.

* The `debug' and `where' presentation formats have been adjusted
somewhat to allow compiled code information to be presented
reasonably.

* `debug' has been extended to provide the common `A' command from
`where'; there should be little need to invoke `where' from `debug'.

Change definition of `compiled-entry-kind' for return addresses.  Now,
the second element is a subtype: 0 means that the offset to the next
return address is fixed and known; 1 means that the next element on
the stack is a dynamic link, which points at the next return address;
and 2 means that this is the "return-to-interpreter" return address.
The third element is either a non-negative offset (for subtypes 0 and
2) or -1 (for subtype 1).

Adjust floating point formats for pyramid.

Don't bother putting out cref information for global and primitive
references.  For a program like the compiler, these comprise about
half the total cref, and are of little use.

Add `next-continuation-offset' slot, which is either the stack offset
to the next continuation, or false indicating that a dynamic link is
in use.

Fix definition of `stack-top-address' to make it consistent with
definition of `object-datum' (which will be used to extract the
address value of a stack address).  Implement new primitive
`stack-address-offset' which computes the offset (in objects) between
the stack-address argument and the top of stack.

Fix definition of `stack-top-address' to make it consistent with
definition of `object-datum' (which will be used to extract the
address value of a stack address).  Implement new primitive
`stack-address-offset' which computes the offset (in objects) between
the stack-address argument and the top of stack.

If combination has a `continuation-push', prevent that continuation
from being pushed when the combination is constant folded in any way.

*** empty log message ***

Rewrite the handling of SCode quotation expressions to allow `car' to
be constant folded by the compiler.

Rewrite the handling of SCode quotation expressions to allow `car' to
be constant folded by the compiler.

Tweak popping-limits computation once again: the external block is not
necessarily one of the limits, and assuming that it is forces the use
of dynamic links in many common situations.

Repackage constant folding code.

Do not require `object-immutable?' of arguments to constant folding
operations.  Because of the rule which says that constants appearing
in program text must be immutable, we can freely constant fold
anything that we can get our hands on, provided that we never constant
fold anything to does a cons-like operation.

Add references such as `car' and `vector-length' to set of constant
foldable "functions".

Delete reference to `block-frame', which has been made obsolete.

Add hooks for debugging info.

No longer need to use `set-type-object-description!'.

No longer need to use `set-type-object-description!'.

*** empty log message ***

Fix bug in `instruction-dead?': an assignment whose RHS contains side
effects cannot be considered dead.

Introduce new algorithm to delete unreachable nodes from the RTL
graph.

Change (commented-out) code that used to use lvalue marking mechanism
to now use new mechanism.

Improve popping limits computation -- new algorithm should eliminate
dynamic links in many situations.

Add generation and alist slots to lvalue objects, similar in form and
purpose to those used in CFG nodes.  Remove the now-obsolete marks
slot.

Change procedure unparser to show the label in a more palatable way.

Change block unparser to show the type, and to show the associated
procedure's label in a more palatable way.

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.