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.

Add declarations to eliminate "unreferenced bound variable" warnings.

Add declarations to eliminate "unreferenced bound variable" warnings.

Define procedures to capture the object->{type,datum,address}
conversions.

Define new procedure `load-temporary-register' which abstracts the
idea of loading a temporary with the value of some expression, and
then using the temporary for something.  This is important because of
the timing problems associated with `rtl:make-assignment'.  Most
usages of the latter are now translated into usages of the new
procedure.

Delete random definition of `rtl:make-address->fixnum'.  This was a
duplicate definition, but what is worse, it caused incorrect code to
be generated.  This happened because `object->fixnum' gets elided in
certain places, in particular the places where `address->fixnum' is
used.

Conversion of a fixnum to an address must be a logical right shift,
not an arithmetic right shift.  This is because an address is an
unsigned quantity; thus a fixnum representing an address must also be
treated as unsigned.

Rename disassembler/write-compiled-entry to compiler:disassemble,
export it to the global package, and add some cleverness about
printing linkage sections.

Don't run second pass unless there are some circularly dependent files
being resyntaxed.

Don't use the `utime()' or `utimes()' system calls to touch files,
because they are subject to clock skew problems when used on remote
NFS files.  Also, add check for file type to file touching code.

*** empty log message ***

Echo file deletions, and show passes.

Echo message informing user when files are being touched.  Fix big:
was touching file with no type!  Must touch files that SF outputs.
Always touch .bin file, conditionally touch .ext and .unf files.

Redefine `invert-cc-noncommutative'.  This was originally designed to
be like `invert-cc'.  However, it is used to adjust the condition code
for the situation of reversing the arguments to a conditional, while
`invert-cc' is used to adjust for reversing the branches.  These are
quite different.

Because special primitive invocations may now have `next' nodes, it is
necessary to invalidate at least the value register and free pointer.
Perhaps we need to invalidate other things as well?

Define these procedures:
    interpreter-value-register
    interpreter-environment-register
    interpreter-environment-register?

Reset the set of source nodes whenever the compiler band is reloaded.
This should help prevent problems with non-existent files.  Also,
during second pass to resyntax files that have circular dependencies,
touch the dependents that have been syntaxed in the first pass, so
that they have the proper time relationships to the resyntaxed files.

Eliminate random unreferenced labels from RTL and LAP output.
Eliminate dead branches to continuations.  Implement declarations to
disable detection of traps in cached variable references and
assignments.

(reference->register-transfer): When source was an address register
this compared it to target, succeeding when target was a data
register.

Use definition of `compiler:default-top-level-declarations'.  Add new
class of variables: `assigned'.  Add two new declarations:
`ignore-assignment-traps' and  `ignore-reference-traps'.

Add definition of `compiler:default-top-level-declarations', used by
declaration processor.  This is used to force defaults, and may also
be fluid bound to provide special defaults.

Redefine `add-rgraph-entry-node!' to be `add-rgraph-entry-edge!',
because the caller needs an edge to that node, and we wish to avoid
creation of duplicate edges.

Be more careful when `sblock-continuation' is known.  If the
continuation has already been generated, we were previously generating
a jump to the continuation at this point.  This jump was dead code
because nobody referenced it.

Implement `ignore-reference-traps' declaration on free variables.

Implement `ignore-assignment-traps' declaration on free variables.