/** 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 DISPATCH_PATH = new Mask("vvvvvvvvvvv..........................");
- 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_NOT_C = new Mask(".............100.....................");
- public static final Mask P_C = new Mask(".............101.....................");
- public static final Mask P_OLC = 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("..................1..................");
- public static final Mask DI = new Mask("...................1.................");
- public static final Mask DC = new Mask("....................1................");
- public static final Mask DO = new Mask(".....................1...............");
- public static final Mask TO = new Mask("......................1..............");
- public static final Mask PATH_IMMEDIATE = new Mask(".......................1vvvvvvvvvvvvv");
- public static final Mask PATH_DATA = new Mask(".......................01............");
- public static final Mask PATH_NOCHANGE = new Mask(".......................00............");
-
- public static final Mask SET = new Mask("................10...................");
-
- public static final Mask SET_OLC_FROM_IMMEDIATE = new Mask("................1010000100.....vvvvvv");
- public static final Mask SET_OLC_FROM_DATA_LATCH = new Mask("................1010000010...........");
- public static final Mask SET_OLC_FROM_OLC_MINUS_ONE = new Mask("................1010000001...........");
-
- public static final Mask SET_ILC_FROM_IMMEDIATE = new Mask("................1001000100.....vvvvvv");
- public static final Mask SET_ILC_FROM_INFINITY = new Mask("................1001000010...........");
- public static final Mask SET_ILC_FROM_DATA_LATCH = new Mask("................1001000001...........");
-
- public static final Mask SET_IMMEDIATE = new Mask("................1000100.vvvvvvvvvvvvv");
- public static final Mask SET_IMMEDIATE_EXTEND = new Mask("................1000100v.............");
-
- public static final Mask SET_FLAGS = new Mask("................1000010..............");
- public static final Mask SET_FLAGS_A = new Mask("................1000010..vvvvvv......");
- public static final Mask SET_FLAGS_B = new Mask("................1000010........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");
-
- public static final Mask SET_TAPL_FROM_IMMEDIATE = new Mask("................1000001.vvvvvvvvvvvvv");
+ 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("............................vvvvvvvvv");
+ CBD_OFFSET = new Mask("vvvvvvvvvvvvvvvvvvvvvvvvvvvv.........");
+
+ 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; }
//////////////////////////////////////////////////////////////////////////////
/** get the bits describing this box's location on the DESTINATION HORN */
- // FIXME this should use a BitVector not a long!
- protected abstract long getDestAddr(Path box);
+ protected abstract BitVector getDestAddr(Path box);
private static final BitVector SIGNAL_ZERO = new BitVector(1);
- private static final BitVector SIGNAL_ONE = new BitVector(1);
- static {
- SIGNAL_ONE.set(0,true);
- }
+ private static final BitVector SIGNAL_ONE = new BitVector(1).set(0,true);
/** decode a path, given the starting point and the bits that comprise it */
- // FIXME this should use a BitVector not a long!
- //protected abstract Path getPathByAddr(Dock source, long dest);
- public Path getPathByAddr(Dock source, long dest) {
+ public Path getPathByAddr(Dock source, BitVector dest) {
for(Ship ship : this)
for(Dock bb : ship) {
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) == dest) return p;
+ if (getDestAddr(p).equalsZeroExtended(dest)) return p;
}
}
}
return null;
}
- /** read a machine-formatted instruction from a file (into a Java object) */
- public Instruction readInstruction(DataInputStream is, Dock dispatchFrom) throws IOException {
- long inst = 0;
- try {
- inst = (inst << 8) | (is.readByte() & 0xff);
- inst = (inst << 8) | (is.readByte() & 0xff);
- inst = (inst << 8) | (is.readByte() & 0xff);
- inst = (inst << 8) | (is.readByte() & 0xff);
- inst = (inst << 8) | (is.readByte() & 0xff);
- inst = (inst << 8) | (is.readByte() & 0xff);
- return readInstruction(inst, dispatchFrom);
- } catch (EOFException eof) {
- return null;
- }
+ public Instruction decodeInstruction(BitVector instruction, Dock dispatchFrom) {
+ return readInstruction(instruction.toLong(), dispatchFrom);
+ }
+
+ public BitVector encodeInstruction(Instruction instr, Dock dispatchFrom) {
+ return new BitVector(getWordWidth()).set(writeInstruction(instr, dispatchFrom));
}
+ public int getShiftWidth() { return SHIFT.valmaskwidth; }
+ public int getSetWidth() { return SET_IMMEDIATE.valmaskwidth+1; }
+
+
+ public int getMaxCodeBagSize() {
+ return (1<<CBD_SIZE.valmaskwidth)-1;
+ }
+ public BitVector makeCodeBagDescriptor(long offset, long length) {
+ BitVector descriptor = new BitVector(getWordWidth());
+ CBD_OFFSET.setval(descriptor, offset);
+ CBD_SIZE.setval(descriptor, length);
+ return descriptor;
+ }
+
+
+
+ // FIXME: should use BitVector here
public Instruction readInstruction(long inst, Dock dispatchFrom) {
- Dock dock = getPathByAddr(dispatchFrom, DISPATCH_PATH.getval(inst)).getDestination().getDock();
+ 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_OLC.get(inst)) predicate = Default;
+ if (P_ALWAYS.get(inst)) predicate = IgnoreFlagD;
+ if (P_OLC_NONZERO.get(inst)) predicate = Default;
+ if (P_OLC_ZERO.get(inst)) predicate = FlagD;
if (P_A.get(inst)) predicate = FlagA;
if (P_B.get(inst)) predicate = FlagB;
- if (P_C.get(inst)) predicate = FlagC;
if (P_NOT_A.get(inst)) predicate = NotFlagA;
if (P_NOT_B.get(inst)) predicate = NotFlagB;
- if (P_NOT_C.get(inst)) predicate = NotFlagC;
- boolean looping = !OS.get(inst);
- if (SHIFT.get(inst)) return new Shift(dock, looping, predicate, new BitVector(dock.getShip().getFleet().getWordWidth()).set(SHIFT.getval(inst)));
+ if (FLUSH.get(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);
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 (SET_TAPL_FROM_IMMEDIATE.get(inst))
- return new Set(dock, looping, predicate, SetDest.TAPL, getPathByAddr(dock, SET_TAPL_FROM_IMMEDIATE.getval(inst)));
if (MOVE.get(inst))
return new Move(dock,
- looping,
predicate,
- I.get(inst),
- getPathByAddr(dock, PATH_IMMEDIATE.getval(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)
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)
- instr = DISPATCH_PATH.setval(instr, getDestAddr(dispatchFrom.getPath(d.dock.getInstructionDestination(),null)));
+ 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<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 Default: instr = P_OLC.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;
- case FlagC: instr = P_C.set(instr); break;
case NotFlagA: instr = P_NOT_A.set(instr); break;
case NotFlagB: instr = P_NOT_B.set(instr); break;
- case NotFlagC: instr = P_NOT_C.set(instr); break;
+ default: throw new RuntimeException("error!");
}
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;
break;
}
break;
- case TAPL: {
- instr = SET_TAPL_FROM_IMMEDIATE.set(instr);
- instr = SET_TAPL_FROM_IMMEDIATE.setval(instr, getDestAddr(s.path));
- break;
- }
case Flags: {
instr = SET_FLAGS.set(instr);
instr = SET_FLAGS_A.setval(instr, flagFunctionToLong(s.newFlagA));
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);
- instr = PATH_IMMEDIATE.setval(instr, inst.path==null?0:getDestAddr(inst.path));
+ 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 {
return instr;
}
- public void writeInstruction(DataOutputStream os, Dock dispatchFrom, Instruction d) throws IOException {
- long instr = writeInstruction(d, dispatchFrom);
- for(int i=5; i>=0; i--)
- os.write(BitManipulations.getIntField(i*8+7, i*8, instr));
- }
-
- private static long flagFunctionToLong(FlagFunction ff) {
+ private long flagFunctionToLong(FlagFunction ff) {
long ret = 0;
for(Predicate p : ff)
switch(p) {