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.

(generate/rgraph): Make only a single edge for the entry of each
rgraph.  This is important because the linearizer looks at the number
of edges to determine when labels are needed.

Fix bug by which attempting to print a bogus object would kill Scheme.
It now prints #[UNDEFINED-TYPE:<n> <datum>] and does NOT hash the object.

Fix missing label bug.  OPEN-PROCEDURE-HEADERS define both the
internal and external entry points always.

- "Self consistent closing": A group of procedures whose only free
variables represent each other will be represented as trivial closures
that reference each other by direct pc offsets.

- Known trivial closure variables are now integrated.

- Similar procedures used in operator position may not be closed.
There is a notion of a virtual closure: A closure whose environment is
known, but whose code pointer is not.

- Procedures now remember why they were closed.

- Once-only assignments to top-level or completely free variables are
done with local-assignment rather than with assignment caches.

- Variuos fixes to the closure analysis.  Lambda expressions in
operand position are closed only if they are escaping their context.
This was broken when the uniform closing strategy (all closures close
to the top) was introduced in the front end.

Initial revision

Add sf/usual-integrations-default-deletions.

Add sf/usual-integrations-default-deletions.

Add stage3 and merge with markf's makefile.

Change `define-structure' macro to handle `named' option better,
allowing it to be a constant which is used as the tag.  This allows
redefinition of several structures in the runtime system, making them
fasdumpable.  Change handling of packages to attach a package to its
environment if that environment is not already attached to another
package.  Change the rep loop to show this package name when the
package is changed; also add command `pe' to return the current
package.

Add expansion rules for predicates like `vector?', `char?', etc. that
expand into code that the compiler can open code pretty well.  Add new
global variables `sf/default-syntax-table' and
`sf/top-level-definitions', the latter being a list of names which
should not be treated specially by `usual-integrations'.

Fixed bug when multiplying a number by itself.

Several changes to make package model objects fasdumpable.

Don't forget to output the return codes with their frames.

More debugging support.

Add several new entries to support debugging of compiled code.

Adjust `RETURN_NAME_TABLE' to contain all current return address
names; some were missing.

Merged 4.9 with 4.8.1.2.

Update for new runtime system.  Much simpler now that stack parser
does most of the work.

(compiled_entry_to_block): `suba.w' instruction sign extends its first
argument, which in this case is exactly the wrong thing.  Rewrite this
to zero extend the 16 bit offset.

Continuation can still be sometimes known even when it is passed out.
This was causing bug where continuation was "never known", but because
the return application knew it, it was assuming "sometimes known".

Change directory reader to default the name/type/version to WILD, and
to be faster for that default case.  Also add optional second argument
to disable sorting of output.  These changes combine to give a fairly
fast interface to the underlying directory reader.

If slashification is turned off, it is still necessary to slashify
non-ASCII characters because the output port probably won't have any
representation for them.

Make sure that TERM_SIGNAL control variables are initialized correctly
even when `dump-world' or job control is used.  Also, force control-g
synchronization under Emacs for all unix operating systems.

Force control-g synchronization always.  Turns out BSD had the same
problem as hp-ux.

Don't use second argument to `interrupt-process' and `quit-process'.
Apparently that causes difficulties under Ultrix.

Two copies of the copyright message at beginning of file; removed one.

Removed extra copyright message; had two copies of it at the beginning of the
file.

Several changes to make unix signals work right.

Change this code to use the new `clear-interrupts!' primitive to
disable interrupt bits when the interrupt handlers are invoked.

(disk-save): Unless IDENTIFY is a string, return a boolean value.

Fix bug in `disk-save': when the IDENTIFY argument is #F, we should
return #F just after the save, and #T after a restore.

Fix some problems with unix signals: (1) Emacs uses SIGHUP to kill a
process when its buffer is killed, so treat SIGHUP differently if
under Emacs -- also don't print messages in this case as the buffer is
dead; (2) don't ask for core dump if signal received.

Also define new primitive `clear-interrupts!'; change
`get-next-interrupt-character' and `setup-timer-interrupt' so they
don't clear the interrupt bit.  It is now the responsibility of the
runtime system to clear the bit when it gets the interrupt.

Another stab at open coded generic arithmetic (stiil no floating point yet).

Transferred version 4.8.1.1 onto the main trunk, essentially undoing
4.9 because we no longer use an expansion phase.

Added rule for OVERFLOW-TEST in support of generic arithmetic.

Changed a bunch of fixnum procedures. Fixnums are now shifted 8 bit to
the left before the operations (except multiply, where only one of the
operands is shifted) so that overflow detection gets done
automatically by the hardware.
Also fixed a bug in the fixnum register*register rule which was
manifested when the two source registers were the same and we could
alias them with the target.

Added generic arithmetic rtl types and overflow-test predicate.
Added fixnum->address and address->fixnum since we have changed the
way fixnum's are handled (i.e. we shift them to the left by 8 bits now).
Removed rtl-constructor stuff since we don't have the expand phase anymore.

In the open coding of generic arithmetic it is possible to create some
cfg node which are in the rtl-graph but turn out not to be reachable
from the entry edge of the rtl-graph (this happens when we are
creating a pcfg for a type test but the object we are testing is a
constant, for example). We need to make sure that rgraph/compress!
removes these unreachable cfg nodes, because there are some algorithms
which depened on all of node's predecessors being on a path from an
entry edge of the rtl-graph.

Added expression methods for generic arithmetic RTL types.

Fixed bugs in generic arithmetic open coding.

Changed a bunch of fixnum procedures. Fixnums are now shifted 8 bit to
the left before the operations (except multiply, where only one of the
operands is shifted) so that overflow detection gets done
automatically by the hardware.

fixed shift intructions with dynamic bit counts.