X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Fedu%2Fberkeley%2Ffleet%2Ftwo%2FFleetTwoFleet.java;h=7936ad0dcedf2a24c3c6a94e51f49ca812bcd296;hb=8b1a948e7dd11e188ccbed082791aec6338196f9;hp=da3e2f11265bbc1c9c677588599bdb1a710a1eb3;hpb=42514a734f7539d178763f53d487a79f75428886;p=fleet.git

diff --git a/src/edu/berkeley/fleet/two/FleetTwoFleet.java b/src/edu/berkeley/fleet/two/FleetTwoFleet.java
index da3e2f1..7936ad0 100644
--- a/src/edu/berkeley/fleet/two/FleetTwoFleet.java
+++ b/src/edu/berkeley/fleet/two/FleetTwoFleet.java
@@ -10,78 +10,222 @@ import static edu.berkeley.fleet.api.Predicate.*;
 /** common subclass for the "FleetTwo" generation of processors, all 37-bit wide, with AM33 encoding */
 public abstract class FleetTwoFleet extends Fleet {
 
-    public static final Mask PACKET_TOKEN               = new Mask("v.................................................");
-    public static final Mask PACKET_DATA                = new Mask(".vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv............");
-    public static final Mask PACKET_SIGNAL              = new Mask("......................................v...........");
-    public static final Mask PACKET_DEST                = new Mask(".......................................vvvvvvvvvvv");
-
-    public static final Mask CBD_SIZE                   = new Mask("...............................vvvvvv");
-    public static final Mask CBD_OFFSET                 = new Mask("vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv......");
-
-    public static final int  WIDTH_WORD                 = PACKET_DATA.valmaskwidth;
-    public static final int  WIDTH_PACKET               = PACKET_TOKEN.width;
-
-    public static final Mask WHOLE_WORD                 = new Mask("vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv");
-    public static final Mask DISPATCH_PATH              = new Mask("vvvvvvvvvvv..........................");
-    public static final Mask DISPATCH_INSTR             = new Mask("...........vvvvvvvvvvvvvvvvvvvvvvvvvv");
-    public static final Mask I                          = new Mask("...........1.........................");
-    public static final Mask OS                         = new Mask("............1........................");
-    public static final Mask P                          = new Mask(".............vvv.....................");
-    public static final Mask P_NOT_A                    = new Mask(".............000.....................");
-    public static final Mask P_A                        = new Mask(".............001.....................");
-    public static final Mask P_NOT_B                    = new Mask(".............010.....................");
-    public static final Mask P_B                        = new Mask(".............011.....................");
-    public static final Mask P_UNUSED                   = new Mask(".............100.....................");
-    public static final Mask P_OLC_ZERO                 = new Mask(".............101.....................");
-    public static final Mask P_OLC_NONZERO              = new Mask(".............110.....................");
-    public static final Mask P_ALWAYS                   = new Mask(".............111.....................");
-
-    public static final Mask SHIFT                      = new Mask("................00vvvvvvvvvvvvvvvvvvv");
-
-    public static final Mask TAIL                       = new Mask("................11...................");
-
-    public static final Mask MOVE                       = new Mask("................01...................");
-    public static final Mask TI                         = new Mask("................011..................");
-    public static final Mask DI                         = new Mask("................01.1.................");
-    public static final Mask FLUSH                      = new Mask("................01.01................");
-    public static final Mask DC                         = new Mask("................01.11................");
-    public static final Mask DO                         = new Mask("................01...1...............");
-    public static final Mask TO                         = new Mask("................01....1..............");
-    public static final Mask PATH_IMMEDIATE             = new Mask("................01.....1vvvvvvvvvvvvv");
-    public static final Mask PATH_DATA                  = new Mask("................01.....01............");
-    public static final Mask PATH_NOCHANGE              = new Mask("................01.....00............");
-
-    public static final Mask SET_OLC_FROM_IMMEDIATE     = new Mask("................101000100......vvvvvv");
-    public static final Mask SET_OLC_FROM_DATA_LATCH    = new Mask("................101000010............");
-    public static final Mask SET_OLC_FROM_OLC_MINUS_ONE = new Mask("................101000001............");
-
-    public static final Mask SET_ILC_FROM_IMMEDIATE     = new Mask("................10010010......0vvvvvv");
-    public static final Mask SET_ILC_FROM_INFINITY      = new Mask("................10010010......1......");
-    public static final Mask SET_ILC_FROM_DATA_LATCH    = new Mask("................10010001.............");
-
-    public static final Mask SET_IMMEDIATE              = new Mask("................100010.vvvvvvvvvvvvvv");
-    public static final Mask SET_IMMEDIATE_EXTEND       = new Mask("................100010v..............");
-
-    public static final Mask SET_FLAGS                  = new Mask("................100001...............");
-    public static final Mask SET_FLAGS_A                = new Mask("................100001...vvvvvv......");
-    public static final Mask SET_FLAGS_B                = new Mask("................100001.........vvvvvv");
-    public static final Mask SET_FLAGS_VALUE_A          = new Mask("1.....");
-    public static final Mask SET_FLAGS_VALUE_NOT_A      = new Mask(".1....");
-    public static final Mask SET_FLAGS_VALUE_B          = new Mask("..1...");
-    public static final Mask SET_FLAGS_VALUE_NOT_B      = new Mask("...1..");
-    public static final Mask SET_FLAGS_VALUE_C          = new Mask("....1.");
-    public static final Mask SET_FLAGS_VALUE_NOT_C      = new Mask(".....1");
+    private final boolean hack = "true".equals(System.getProperty("inverted-dc-bit-hack", "false"));
+
+    public final Mask PACKET_TOKEN;
+    public final Mask PACKET_IS_TOKEN;
+    public final Mask PACKET_DATA;
+    public final Mask PACKET_SIGNAL;
+    public final Mask PACKET_DEST;
+
+    public final Mask CBD_SIZE;
+    public final Mask CBD_OFFSET;
+
+    public final Mask WHOLE_WORD;
+    public final Mask DISPATCH_PATH;
+    public final Mask DISPATCH_INSTR;
+    public final Mask NOT_INTERRUPTIBLE;
+    public final Mask IS_INTERRUPTIBLE;
+    public final Mask P;
+    public final Mask P_NOT_A;
+    public final Mask P_A;
+    public final Mask P_NOT_B;
+    public final Mask P_B;
+    public final Mask P_UNUSED;
+    public final Mask P_OLC_ZERO;
+    public final Mask P_OLC_NONZERO;
+    public final Mask P_ALWAYS;
+
+    public final Mask SHIFT;
+
+    public final Mask TAIL;
+    public final Mask HEAD;
+    public final Mask ABORT;
+
+    public final Mask MOVE;
+    public final Mask TI;
+    public final Mask DI;
+    public final Mask FLUSH;
+    public final Mask DC;
+    public final Mask DO;
+    public final Mask TO;
+    public final Mask PATH_IMMEDIATE;
+    public final Mask PATH_DATA;
+    public final Mask PATH_NOCHANGE;
+
+    public final Mask SET_OLC_FROM_IMMEDIATE;
+    public final Mask SET_OLC_FROM_DATA_LATCH;
+    public final Mask SET_OLC_FROM_OLC_MINUS_ONE;
+
+    public final Mask SET_ILC_FROM_IMMEDIATE;
+    public final Mask SET_ILC_FROM_INFINITY;
+    public final Mask SET_ILC_FROM_DATA_LATCH;
+
+    public final Mask SET_IMMEDIATE;
+    public final Mask SET_IMMEDIATE_EXTEND;
+
+    public final Mask SET_FLAGS;
+    public final Mask SET_FLAGS_A;
+    public final Mask SET_FLAGS_B;
+    public final Mask SET_FLAGS_VALUE_A;
+    public final Mask SET_FLAGS_VALUE_NOT_A;
+    public final Mask SET_FLAGS_VALUE_B;
+    public final Mask SET_FLAGS_VALUE_NOT_B;
+    public final Mask SET_FLAGS_VALUE_C;
+    public final Mask SET_FLAGS_VALUE_NOT_C;
+
+    public final int  WIDTH_WORD;
+    public final int  WIDTH_PACKET;
+
+    public final int DataLatch_WIDTH;
+    private final long mask;
+
+    public FleetTwoFleet() { this(false); }
+
+    public FleetTwoFleet(boolean useInternalEncoding) {
+        PACKET_TOKEN               = new Mask("v.................................................");
+        PACKET_IS_TOKEN            = new Mask("1.................................................");
+        PACKET_DATA                = new Mask(".vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv............");
+        PACKET_SIGNAL              = new Mask("......................................v...........");
+        PACKET_DEST                = new Mask(".......................................vvvvvvvvvvv");
+
+        CBD_SIZE                   = new Mask("...............................vvvvvv");
+        CBD_OFFSET                 = new Mask("vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv......");
+
+        WHOLE_WORD                 = new Mask("vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv");
+
+        if (useInternalEncoding) {
+
+            DISPATCH_PATH              = new Mask("v....................................");
+            DISPATCH_INSTR             = new Mask(".vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv");
+            P                          = new Mask(".vvvvvv..............................");
+            P_NOT_A                    = new Mask(".010001..............................");
+            P_A                        = new Mask(".010010..............................");
+            P_NOT_B                    = new Mask(".010100..............................");
+            P_B                        = new Mask(".011000..............................");
+            P_UNUSED                   = new Mask(".111111..............................");
+            P_OLC_ZERO                 = new Mask(".100000..............................");
+            P_OLC_NONZERO              = new Mask(".010000..............................");
+            P_ALWAYS                   = new Mask(".000000..............................");
+
+            HEAD                       = new Mask(".......1.............................");
+            ABORT                      = new Mask("........1......1.........000100000001");
+            TAIL                       = new Mask(".........1...........................");
+
+            // actually "is interruptible"
+            NOT_INTERRUPTIBLE          = new Mask("...........0....0....................");
+            IS_INTERRUPTIBLE           = new Mask("...........1....1....................");
+
+            SHIFT                      = new Mask("..........1......1vvvvvvvvvvvvvvvvvvv");
+            SET_IMMEDIATE              = new Mask("..........1......0.....vvvvvvvvvvvvvv");
+            SET_IMMEDIATE_EXTEND       = new Mask("..........1......0....v..............");
+            MOVE                       = new Mask("............1........................");
+            TI                         = new Mask("............1.....1..................");
+            DI                         = new Mask("............1......1.................");
+            FLUSH                      = new Mask("..........1......0.....011...........");
+            DC                         = new Mask("............1.......1................");
+            DO                         = new Mask("............1........1...............");
+            TO                         = new Mask("............1.........1..............");
+            PATH_IMMEDIATE             = new Mask("............1..........1vvvvvvvvvvvvv");
+            PATH_DATA                  = new Mask("............1..........00............");
+            PATH_NOCHANGE              = new Mask("............1..........01............");
+
+            SET_OLC_FROM_OLC_MINUS_ONE = new Mask(".............1..1....................");
+            SET_OLC_FROM_DATA_LATCH    = new Mask("..............1.11...................");
+            SET_OLC_FROM_IMMEDIATE     = new Mask("..............1.10.............vvvvvv");
+
+            SET_ILC_FROM_DATA_LATCH    = new Mask("..............1.01...................");
+            SET_ILC_FROM_IMMEDIATE     = new Mask("..............1.00...........0.vvvvvv");
+            SET_ILC_FROM_INFINITY      = new Mask("..............1.0............1.......");
+
+            SET_FLAGS                  = new Mask("...............1.....................");
+            SET_FLAGS_A                = new Mask("...............1...............vvvvvv");
+            SET_FLAGS_B                = new Mask("...............1.........vvvvvv......");
+
+            SET_FLAGS_VALUE_A          = new Mask(".....1");
+            SET_FLAGS_VALUE_NOT_A      = new Mask("....1.");
+            SET_FLAGS_VALUE_B          = new Mask("...1..");
+            SET_FLAGS_VALUE_NOT_B      = new Mask("..1...");
+            SET_FLAGS_VALUE_C          = new Mask(".1....");
+            SET_FLAGS_VALUE_NOT_C      = new Mask("1.....");
+
+        } else {
+            DISPATCH_PATH              = new Mask("vvvvvvvvvvv..........................");
+            DISPATCH_INSTR             = new Mask("...........vvvvvvvvvvvvvvvvvvvvvvvvvv");
+            NOT_INTERRUPTIBLE          = new Mask("...........1.........................");
+            IS_INTERRUPTIBLE           = new Mask("...........0.........................");
+            P                          = new Mask(".............vvv.....................");
+            P_NOT_A                    = new Mask(".............000.....................");
+            P_A                        = new Mask(".............001.....................");
+            P_NOT_B                    = new Mask(".............010.....................");
+            P_B                        = new Mask(".............011.....................");
+            P_UNUSED                   = new Mask(".............100.....................");
+            P_OLC_ZERO                 = new Mask(".............101.....................");
+            P_OLC_NONZERO              = new Mask(".............110.....................");
+            P_ALWAYS                   = new Mask(".............111.....................");
+
+            SHIFT                      = new Mask("................00vvvvvvvvvvvvvvvvvvv");
+
+            ABORT                      = new Mask("................1100.................");  // note: has a predicate!
+
+            HEAD                       = new Mask("................1110.................");
+            TAIL                       = new Mask("................1111.................");
+
+            MOVE                       = new Mask("................01...................");
+            TI                         = new Mask("................011..................");
+            DI                         = new Mask("................01.1.................");
+            FLUSH                      = new Mask("................01.01................");
+            DC                         = new Mask("................01.11................");
+            DO                         = new Mask("................01...1...............");
+            TO                         = new Mask("................01....1..............");
+            PATH_IMMEDIATE             = new Mask("................01.....1vvvvvvvvvvvvv");
+            PATH_DATA                  = new Mask("................01.....01............");
+            PATH_NOCHANGE              = new Mask("................01.....00............");
+
+            SET_OLC_FROM_IMMEDIATE     = new Mask("................101000100......vvvvvv");
+            SET_OLC_FROM_DATA_LATCH    = new Mask("................101000010............");
+            SET_OLC_FROM_OLC_MINUS_ONE = new Mask("................101000001............");
+
+            SET_ILC_FROM_IMMEDIATE     = new Mask("................10010010......0vvvvvv");
+            SET_ILC_FROM_INFINITY      = new Mask("................10010010......1......");
+            SET_ILC_FROM_DATA_LATCH    = new Mask("................10010001.............");
+
+            SET_IMMEDIATE              = new Mask("................100010.vvvvvvvvvvvvvv");
+            SET_IMMEDIATE_EXTEND       = new Mask("................100010v..............");
+
+            SET_FLAGS                  = new Mask("................100001...............");
+            SET_FLAGS_A                = new Mask("................100001...vvvvvv......");
+            SET_FLAGS_B                = new Mask("................100001.........vvvvvv");
+
+            SET_FLAGS_VALUE_A          = new Mask("1.....");
+            SET_FLAGS_VALUE_NOT_A      = new Mask(".1....");
+            SET_FLAGS_VALUE_B          = new Mask("..1...");
+            SET_FLAGS_VALUE_NOT_B      = new Mask("...1..");
+            SET_FLAGS_VALUE_C          = new Mask("....1.");
+            SET_FLAGS_VALUE_NOT_C      = new Mask(".....1");
+        }
+
+        WIDTH_WORD                 = PACKET_DATA.valmaskwidth;
+        WIDTH_PACKET               = PACKET_TOKEN.width;
+        DataLatch_WIDTH = SET_IMMEDIATE.valmaskmax-SET_IMMEDIATE.valmaskmin+1;  // FIXME: this is an abstraction breakage
+        mask  = ~(-1L << DataLatch_WIDTH);
+    }
 
     // Misc //////////////////////////////////////////////////////////////////////////////
 
-    public static final long DataLatch_WIDTH = SET_IMMEDIATE.valmaskmax-SET_IMMEDIATE.valmaskmin+1;  // FIXME: this is an abstraction breakage
-    private static final long mask  = ~(-1L << DataLatch_WIDTH);
-    public static boolean isSmallEnoughToFit(long immediate) {
+    public boolean isSmallEnoughToFit(long immediate) {
         if ((immediate & ~mask) == 0)   return true;
         if ((immediate |  mask) == -1L) return true;
         return false;
     }
 
+    public boolean isSmallEnoughToFit(BitVector immediate) {
+        boolean b = immediate.get((int)DataLatch_WIDTH);
+        for(int i=DataLatch_WIDTH+1; i<immediate.length(); i++)
+            if (immediate.get(i) != b) return false;
+        return true;
+    }
+
     public int getWordWidth() { return 37; }
 
     //////////////////////////////////////////////////////////////////////////////
@@ -99,7 +243,7 @@ public abstract class FleetTwoFleet extends Fleet {
                 for(Destination d : new Destination[] { bb.getInstructionDestination(), bb.getDataDestination() }) {
                     for(BitVector signal : new BitVector[] { SIGNAL_ZERO, SIGNAL_ONE }) {
                         Path p = (Path)source.getPath(d, signal);
-                        if (getDestAddr(p).equals(dest)) return p;
+                        if (getDestAddr(p).equalsZeroExtended(dest)) return p;
                     }
                 }
             }
@@ -122,39 +266,41 @@ public abstract class FleetTwoFleet extends Fleet {
         Dock dock = getPathByAddr(dispatchFrom, DISPATCH_PATH.getvalAsBitVector(inst)).getDestination().getDock();
 
         if (TAIL.get(inst))   return new Tail(dock);
+        if (HEAD.get(inst))   return new Head(dock);
 
         Predicate predicate = Default;
-        if (P_ALWAYS.get(inst)) predicate = IgnoreOLC;
+        if (P_ALWAYS.get(inst)) predicate = IgnoreFlagD;
         if (P_OLC_NONZERO.get(inst))    predicate = Default;
-        if (P_OLC_ZERO.get(inst))    predicate = OLCZero;
+        if (P_OLC_ZERO.get(inst))    predicate = FlagD;
         if (P_A.get(inst))      predicate = FlagA;
         if (P_B.get(inst))      predicate = FlagB;
         if (P_NOT_A.get(inst))  predicate = NotFlagA;
         if (P_NOT_B.get(inst))  predicate = NotFlagB;
 
-        boolean looping = !OS.get(inst);
         if (FLUSH.get(inst))
-            return new Flush(dock, looping, predicate);
-        if (SHIFT.get(inst))                return new Shift(dock, looping, predicate, new BitVector(dock.getShip().getFleet().getShiftWidth()).set(SHIFT.getval(inst)));
+            return new Flush(dock, predicate);
+        if (ABORT.get(inst))
+            return new Abort(dock, predicate);
+        if (SHIFT.get(inst))                return new Shift(dock, predicate, new BitVector(dock.getShip().getFleet().getShiftWidth()).set(SHIFT.getval(inst)));
         if (SET_IMMEDIATE.get(inst)) {
             boolean extend = SET_IMMEDIATE_EXTEND.getval(inst) != 0;
             long immediate = SET_IMMEDIATE.getval(inst);
             if (extend) immediate |= (-1L << DataLatch_WIDTH);
-            return new Set(dock, looping, predicate, SetDest.DataLatch, (immediate));
+            return new Set(dock, predicate, SetDest.DataLatch, (immediate));
         }
 
         if (SET_OLC_FROM_OLC_MINUS_ONE.get(inst))
-            return new Set(dock, looping, predicate, SetDest.OuterLoopCounter, SetSource.Decrement);
+            return new Set(dock, predicate, SetDest.OuterLoopCounter, SetSource.Decrement);
         if (SET_OLC_FROM_IMMEDIATE.get(inst))
-            return new Set(dock, looping, predicate, SetDest.OuterLoopCounter, (SET_OLC_FROM_IMMEDIATE.getval(inst)));
+            return new Set(dock, predicate, SetDest.OuterLoopCounter, (SET_OLC_FROM_IMMEDIATE.getval(inst)));
         if (SET_ILC_FROM_IMMEDIATE.get(inst))
-            return new Set(dock, looping, predicate, SetDest.InnerLoopCounter, (SET_ILC_FROM_IMMEDIATE.getval(inst)));
+            return new Set(dock, predicate, SetDest.InnerLoopCounter, (SET_ILC_FROM_IMMEDIATE.getval(inst)));
         if (SET_OLC_FROM_DATA_LATCH.get(inst))
-            return new Set(dock, looping, predicate, SetDest.OuterLoopCounter, SetSource.DataLatch);
+            return new Set(dock, predicate, SetDest.OuterLoopCounter, SetSource.DataLatch);
         if (SET_ILC_FROM_DATA_LATCH.get(inst))
-            return new Set(dock, looping, predicate, SetDest.InnerLoopCounter, SetSource.DataLatch);
+            return new Set(dock, predicate, SetDest.InnerLoopCounter, SetSource.DataLatch);
         if (SET_ILC_FROM_INFINITY.get(inst))
-            return new Set(dock, looping, predicate, SetDest.InnerLoopCounter, SetSource.Infinity);
+            return new Set(dock, predicate, SetDest.InnerLoopCounter, SetSource.Infinity);
         if (SET_FLAGS.get(inst)) {
             long flag_a = SET_FLAGS_A.getval(inst);
             long flag_b = SET_FLAGS_B.getval(inst);
@@ -172,17 +318,16 @@ public abstract class FleetTwoFleet extends Fleet {
             if (SET_FLAGS_VALUE_NOT_B.get(flag_b)) bp = bp.add(NotFlagB );
             if (SET_FLAGS_VALUE_C    .get(flag_b)) bp = bp.add(FlagC    );
             if (SET_FLAGS_VALUE_NOT_C.get(flag_b)) bp = bp.add(NotFlagC );
-            return new Set(dock, looping, predicate, ap, bp);
+            return new Set(dock,  predicate, ap, bp);
         }
         if (MOVE.get(inst))
             return new Move(dock,
-                            looping,
                             predicate,
-                            I.get(inst),
-                            getPathByAddr(dock, PATH_IMMEDIATE.getvalAsBitVector(inst)),
+                            !NOT_INTERRUPTIBLE.get(inst),
+                            PATH_DATA.get(inst)?null:getPathByAddr(dock, PATH_IMMEDIATE.getvalAsBitVector(inst)),
                             TI.get(inst),
                             DI.get(inst),
-                            DC.get(inst),
+                            hack?(!DC.get(inst)):DC.get(inst),
                             PATH_DATA.get(inst),
                             DO.get(inst),
                             TO.get(inst)
@@ -190,23 +335,23 @@ public abstract class FleetTwoFleet extends Fleet {
         throw new RuntimeException("unknown instruction: 0x" + Long.toString(inst, 16));
     }
 
+    // FIXME: should use BitVector here
     public long writeInstruction(Instruction d, Dock dispatchFrom) {
         long instr = 0;
 
         if (d.dock != null) {
             BitVector bv = getDestAddr(dispatchFrom.getPath(d.dock.getInstructionDestination(),null));
             BitVector bv2 = new BitVector(DISPATCH_PATH.valmaskwidth);
-            for(int i=0; i<bv2.length(); i++)
+            for(int i=0; i<Math.min(bv.length(),bv2.length()); i++)
                 bv2.set(i, bv.get(i));
             instr = DISPATCH_PATH.setval(instr, bv2);
         }
 
         boolean dl = false;
         Instruction pi = d;
-        if (!pi.looping) instr = OS.set(instr);
         switch(pi.predicate) {
-            case IgnoreOLC:         instr = P_ALWAYS.set(instr); break;
-            case OLCZero:         instr = P_OLC_ZERO.set(instr); break;
+            case IgnoreFlagD:         instr = P_ALWAYS.set(instr); break;
+            case FlagD:         instr = P_OLC_ZERO.set(instr); break;
             case Default: instr = P_OLC_NONZERO.set(instr); break;
             case FlagA:      instr = P_A.set(instr);      break;
             case FlagB:      instr = P_B.set(instr);      break;
@@ -218,14 +363,20 @@ public abstract class FleetTwoFleet extends Fleet {
         if (d instanceof Tail) {
             instr = TAIL.set(instr);
 
+        } else if (d instanceof Head) {
+            instr = HEAD.set(instr);
+
         } else if (d instanceof Shift) {
             Shift shift = (Shift)d;
             instr = SHIFT.set(instr);
-            instr = SHIFT.setval(instr, shift.immediate);
+            instr = SHIFT.setval(instr, shift.immediate.getBitVector());
 
         } else if (d instanceof Flush) {
             instr = FLUSH.set(instr);
 
+        } else if (d instanceof Abort) {
+            instr = ABORT.set(instr);
+
         } else if (d instanceof Set) {
             Set s = (Set)d;
             switch(s.dest) {
@@ -274,21 +425,27 @@ public abstract class FleetTwoFleet extends Fleet {
             instr  = MOVE.set(instr);
             if (inst.tokenIn)                    instr = TI.set(instr);
             if (inst.dataIn)                     instr = DI.set(instr);
-            if (inst.latchData)                  instr = DC.set(instr);
+            if (hack) {
+                if (!inst.latchData)                 instr = DC.set(instr);
+                System.err.println("WARNING: employing inverted-Dc-bit hack -- DO NOT FORGET TO DISABLE THIS WHEN THE NETLIST GETS UPDATED!");
+            } else {
+                if (inst.latchData)                  instr = DC.set(instr);
+            }
             if (inst.dataOut)                    instr = DO.set(instr);
             if (inst.tokenOut)                   instr = TO.set(instr);
-            if (inst.interruptible)              instr = I.set(instr);
+            if (!inst.interruptible)             instr = NOT_INTERRUPTIBLE.set(instr);
+            else                                 instr = IS_INTERRUPTIBLE.set(instr);
 
             if (inst.latchPath)                  instr = PATH_DATA.set(instr);
-            else {
+            else if (inst.path!=null) {
                 instr  = PATH_IMMEDIATE.set(instr);
-                if (inst.path != null) {
-                    BitVector bv  = getDestAddr(inst.path);
-                    BitVector bv2 = new BitVector(PATH_IMMEDIATE.valmaskwidth);
-                    for(int i=0; i<Math.min(bv.length(),bv2.length()); i++)
-                        bv2.set(i, bv.get(i));
-                    instr  = PATH_IMMEDIATE.setval(instr, bv2);
-                }
+                BitVector bv  = getDestAddr(inst.path);
+                BitVector bv2 = new BitVector(PATH_IMMEDIATE.valmaskwidth);
+                for(int i=0; i<Math.min(bv.length(),bv2.length()); i++)
+                    bv2.set(i, bv.get(i));
+                instr  = PATH_IMMEDIATE.setval(instr, bv2);
+            } else {
+                instr  = PATH_NOCHANGE.set(instr);
             }
 
         } else {