3/11/96:

1.  Misaligned instructions now generate a warning message in the
    listener box rather than a fatal error.
    
2.  Instructions are still restricted to 128 bits (16 bytes) or less.


3/5/96:

1.  bset and bclr fixed.

2.  Alignment of vector and small vector memory accesses is now forced
	by masking the appropriate number of low order bits.


3/4/96:

1.  Removed the segments table_ram and table_rom because they are
    no longer needed.

2.  The mv_spr pc,rz instruction should now move the correct value
    for pc into rz even when combined with a jmp with an implied nop.

3.  Redefined the address ranges of local ram/rom, instruction ram/rom,
    shared ram and external ram to match the current spec.

4.  Removed shared_rom because it is no longer in the memory map.


2/28/96:

1.  The debugger now handles the new two tick multiply instructions.

2.  I've renamed butta to butt since none of the other alu instructions
    have an 'a' appended.  John has agreed to change his document in the
    next release.

3.  I've changed add_reg to addr as suggested by John.

4.  butta and add_reg are available as aliases for butt and addr.

5.  The ac register now contains the full 64 bit result of scalar multiplies
    although it is not accessable programmatically.  I figured that seeing all
    the bits might be useful for debugging.


Ancient history:

New emulator features:

0.  The debugger now handles the packed instruction set.

1.  You can now put labels within instruction packets.

2.  Before methods must appear before the first instruction in a packet.

3.  If a packet has an embedded label, a before method can appear after
    the label and will be executed when control transfers to the label
    but not when control flows through the label.  For example:

    {   before (print "Hello")
        add #1,r1
    foo:
        before (print "Hello again")
        mul r1,r2
        before (print "Never")
        ld_s #1,r3
        after (print "Goodbye")
    }

    If control flows into the packet, the first before method will be
    executed but not the second.  If control is transfered to the label,
    the second before method will be executed but not the first.  The
    third before method will never be executed since there is no way to
    tranfer control directly to the ld_s instruction.  The after method
    will be executed no matter how control is transfered into the packet.

4.  There are two ways of specifying register unit instructions.  The first
    is:

     add_reg #1,r1
     add_reg #1,r1,--rc0
     add_reg #1,r1,--rc1
     add_reg #1,r1,--rc0,--rc1

    The second allows the decrement operations to be specified as if they
    were separate instructions:
    
     {   add_reg #1,r1
         dec rc0
         dec rc1
     }
        
    If this for is used, the decrement instructions must follow the add_reg or
    mv_spr instruction and no labels may appear between the register instructions.
    This is because all of the register instructions are encoded into a single
    16 bit instruction.

    Also, a dec instruction can appear by itself.  In this case, the assembler
    automatically generates an add_reg #0,rx instruction and sets the appropriate
    decrement bits.

5.  16 bit ALU instructions must be the last instruction in a packet.

6.  I've added the dma_stat register.  You must now use this register to determine
    whether a dma operation has completed.

7.  Note that what the document calls dma_rs0 and dma_rs1, I still call dma_1 and
    dma_2.

8.  The assembler now supports two new pseudo-ops:

    .module [name]

    .export name [, name]...

    The .module pseudo-op sets the name of the current module.  If the name is left
    out, all symbols in the file are assumed to be global (exported).  If a name is
    specified, every symbol not mentioned in either an .export or a .import pseudo-op
    is prefixed by the module name followed by the percent character.  For instance:

    .module foo

    .export x

    x=1
    y=2

    This will result in a module containing the symbols "x" and "foo%y".

    It is not necessary to include the module prefix when refering to a symbol within
    the module where it is declared when that reference is in assembly code.  It is
    necessary to include the module prefix when refering to a symbol with XLISP code
    (in a before or after method).

    The .module pseudo-op applies only to the file in which it appears and any files
    included by that file unless the included file also contains a .module pseudo-op.
