anchor.diff:  
       method ActionValue#(LSQHitInfo) getHit(LdStQTag t);
           wrongSpec_hit_conflict.wset(?); // TODO remove, seems useless
  -        return LSQHitInfo {
  -            waitWPResp: ld_waitWPResp[t],
  -            dst: ld_dst[t]
  -        };
  +        return (case(t) matches
  +            tagged Ld .tag: (LSQHitInfo {
  +                waitWPResp: ld_waitWPResp[tag],
  +                dst: ld_dst[tag]
  +            });
  +            tagged St .tag: (LSQHitInfo {
  +                waitWPResp: False,
  +                dst: st_dst[tag]
  +            });
  +            default: ?;
  +        endcase);
       endmethod
   
       method Maybe#(LdStQTag) enqTag(MemFunc f);
           return (case(f)
  -            Ld, Lr:  (ld_can_enq_wire ? Valid (ld_enqP) : Invalid);
  -            default: (st_can_enq_wire ? Valid (st_enqP) : Invalid);
  +            Ld, Lr:  (ld_can_enq_wire ? Valid (Ld (ld_enqP)) : Invalid);
  +            default: (st_can_enq_wire ? Valid (St (st_enqP)) : Invalid);
           endcase);
       endmethod
   
  
positive.code:     // enqIssueQ, i.e. update and issue will not affect the entry found in
      // findIssue We use a wire to pass phase 1 result to phase 2.  It is fine
      // that phase 2 dose not fire when phase 1 has fired, next cycle phase 1
      // will redo the work
      RWire#(LSQIssueLdInfo) issueLdInfo <- mkRWire;
  
      // FIFO of LSQ tags that should be killed. Replicated tags may exist, but
      // replications will all be killed when the first is processed due to spec
      // bits.
      LSQKillLdQ killByLdStQ <- mkLSQKillLdQ;
      LSQKillLdQ killByCacheQ <- mkLSQKillLdQ;
  
      // make wrongSpec conflict with all others (but not correctSpec method and
      // findIssue)
  
negative.code:     // olderSt fields of loads.
      method StQDeqEntry firstSt;
      method Action deqSt;
  `ifdef TSO_MM
      // Kill loads when a cache line is evicted (TSO only)
      method Action cacheEvict(LineAddr a);
      // Get the load killed by cache eviction (TSO only)
      method ActionValue#(LSQKillLdInfo) getLdKilledByCache;
  `else
      // Wake up younger loads when SB deq (only WEAK model has SB)
      method Action wakeupLdStalledBySB(SBIndex sbIdx);
  `endif
      // Speculation
      interface SpeculationUpdate specUpdate;
  endinterface
  