add pump-local literals and convert Alu1 test case

[fleet.git] / src / edu / berkeley / fleet / ies44 / InstructionEncoder.java

diff --git a/src/edu/berkeley/fleet/ies44/InstructionEncoder.java b/src/edu/berkeley/fleet/ies44/InstructionEncoder.java
index 8ec338f..767ada7 100644 (file)
--- a/src/edu/berkeley/fleet/ies44/InstructionEncoder.java
+++ b/src/edu/berkeley/fleet/ies44/InstructionEncoder.java
@@ -12,8 +12,7 @@ public abstract class InstructionEncoder {
     public static final int WIDTH_DEST_ADDR     = 11;
     public static final int WIDTH_COUNT         = 7;
 
-    public static final int OFFSET_PUMP_ADDR    = 0;
-    public static final int OFFSET_COUNT        = OFFSET_PUMP_ADDR+WIDTH_PUMP_ADDR;
+    public static final int OFFSET_COUNT        = 0;
     public static final int OFFSET_DEST         = OFFSET_COUNT+WIDTH_COUNT;
     public static final int OFFSET_CONTROL      = OFFSET_DEST+WIDTH_DEST_ADDR;
     public static final int OFFSET_RQ           = OFFSET_CONTROL+0;
@@ -22,17 +21,21 @@ public abstract class InstructionEncoder {
     public static final int OFFSET_DL           = OFFSET_CONTROL+3;
     public static final int OFFSET_DI           = OFFSET_CONTROL+4;
     public static final int OFFSET_TI           = OFFSET_CONTROL+5;
+    public static final int OFFSET_PUMP_ADDR    = OFFSET_TI+1;
+
+    public static final int OFFSET_LITERAL      = OFFSET_COUNT;
+    public static final int WIDTH_LITERAL       = WIDTH_COUNT+WIDTH_DEST_ADDR;
 
     /** get the bits describing this box's location on the DESTINATION HORN */
     protected abstract long getDestAddr(Destination box);
 
     /** get the bits describing this box's location on the INSTRUCTION HORN */
-    protected abstract long getBoxInstAddr(BenkoBox box);
+    protected abstract long getBoxInstAddr(Pump box);
 
-    /** given an INSTRUCTION HORN address, retrieve the corresponding BenkoBox object */
-    protected abstract BenkoBox getBoxByInstAddr(long dest);
+    /** given an INSTRUCTION HORN address, retrieve the corresponding Pump object */
+    protected abstract Pump getBoxByInstAddr(long dest);
     
-    /** given a DESTINATION HORN address, retrieve the corresponding BenkoBox object */
+    /** given a DESTINATION HORN address, retrieve the corresponding Pump object */
     protected abstract Destination getDestByAddr(long dest);
 
     /** read a machine-formatted instruction from a file (into a Java object) */
@@ -55,9 +58,9 @@ public abstract class InstructionEncoder {
         long inst = instr;
         switch((int)getField(WIDTH_WORD-1, WIDTH_WORD-2, inst)) {
             case 0: {
-                BenkoBox name    = getBoxByInstAddr(getIntField(OFFSET_PUMP_ADDR+WIDTH_PUMP_ADDR-1, OFFSET_PUMP_ADDR, inst));
-                Destination dest = getDestByAddr   (getIntField(OFFSET_DEST+WIDTH_DEST_ADDR-1,      OFFSET_DEST,      inst));
-                int count        = getIntField(                 OFFSET_COUNT+WIDTH_COUNT-1,         OFFSET_COUNT,     inst);
+                Pump name           = getBoxByInstAddr(getIntField(OFFSET_PUMP_ADDR+WIDTH_PUMP_ADDR-1, OFFSET_PUMP_ADDR, inst));
+                Destination dest    = getDestByAddr   (getIntField(OFFSET_DEST+WIDTH_DEST_ADDR-1,      OFFSET_DEST,      inst));
+                int count           = getIntField(                 OFFSET_COUNT+WIDTH_COUNT-1,         OFFSET_COUNT,     inst);
                 boolean tokenIn     = getBit(OFFSET_TI, instr);
                 boolean dataIn      = getBit(OFFSET_DI, instr);
                 boolean latch       = getBit(OFFSET_DL, instr);
@@ -65,6 +68,9 @@ public abstract class InstructionEncoder {
                 boolean tokenOut    = getBit(OFFSET_TO, instr);
                 boolean requeue     = getBit(OFFSET_RQ, instr);
                 boolean dataOutDest = dataOut && tokenOut;
+                boolean isLiteral   = tokenIn && tokenOut && !dataOutDest;
+                if (isLiteral)
+                    return new Instruction.LocalLiteral(name, getIntField(OFFSET_LITERAL+WIDTH_LITERAL-1, OFFSET_LITERAL, inst));
                 if (latch & !dataIn) return new Instruction.Kill(name, count, tokenIn);
                 return new Instruction.Executable(name, dest, count, tokenIn, dataIn, latch, dataOutDest,
                                                   dataOut, tokenOut, requeue);
@@ -72,8 +78,8 @@ public abstract class InstructionEncoder {
 
             case 1: {
                 Destination name = getDestByAddr(getField(WIDTH_WORD-3, WIDTH_WORD-3-WIDTH_DEST_ADDR+1, inst));
-                long offset = getSignedField(WIDTH_WORD-3-WIDTH_DEST_ADDR, WIDTH_CODEBAG_SIZE, instr);
-                long size   = getSignedField(WIDTH_CODEBAG_SIZE-1,        0,                 instr);
+                long offset      = getSignedField(WIDTH_WORD-3-WIDTH_DEST_ADDR, WIDTH_CODEBAG_SIZE, instr);
+                long size        = getSignedField(WIDTH_CODEBAG_SIZE-1,        0,                 instr);
                 return new Instruction.Literal.CodeBagDescriptor(name, offset, size);
             }
 
@@ -98,13 +104,19 @@ public abstract class InstructionEncoder {
         // Kill is encoded as Execute with the illegal combination (Latch & ~DataIn)
         if (d instanceof Instruction.Kill) {
             Instruction.Kill k = (Instruction.Kill)d;
-            d = new Instruction.Executable(k.benkoBox, null, k.count, k.killOnlyStandingInstructions,
+            d = new Instruction.Executable(k.pump, null, k.count, k.killOnlyStandingInstructions,
                                            false, true, false, false, false, false);
         }
-
-        if (d instanceof Instruction.Executable) {
+        if (d instanceof Instruction.LocalLiteral) {
+            Instruction.LocalLiteral inst = (Instruction.LocalLiteral)d;
+            instr |= putField(OFFSET_PUMP_ADDR+WIDTH_PUMP_ADDR-1, OFFSET_PUMP_ADDR,   getBoxInstAddr(inst.pump));
+            instr |= putField(OFFSET_TI,                          OFFSET_TI,          1);
+            instr |= putField(OFFSET_TO,                          OFFSET_TO,          1);
+            instr |= putField(OFFSET_LITERAL+WIDTH_LITERAL-1, OFFSET_LITERAL,         inst.literal);
+
+        } else if (d instanceof Instruction.Executable) {
             Instruction.Executable inst = (Instruction.Executable)d;
-            instr |= putField(OFFSET_PUMP_ADDR+WIDTH_PUMP_ADDR-1, OFFSET_PUMP_ADDR,   getBoxInstAddr(inst.benkoBox));
+            instr |= putField(OFFSET_PUMP_ADDR+WIDTH_PUMP_ADDR-1, OFFSET_PUMP_ADDR,   getBoxInstAddr(inst.pump));
             instr |= putField(OFFSET_DEST+WIDTH_DEST_ADDR-1,      OFFSET_DEST,        inst.dest==null?0:getDestAddr(inst.dest));
             instr |= putField(OFFSET_COUNT+WIDTH_COUNT-1,         OFFSET_COUNT,       inst.count);
             instr |= putField(OFFSET_TI,                          OFFSET_TI,          inst.tokenIn?1:0);