if (snode.instruction().isStore() &&
if (snode.instruction().isImplicitStore() &&
  private void computeForwardDependences(OPT_Instruction start,                                         OPT_Instruction end) {    boolean readsKill= ir.options.READS_KILL;    OPT_DepGraphNode lastStoreNode = null;    OPT_DepGraphNode lastExceptionNode = null;    OPT_DepGraphNode lastLoadNode = null; // only used if reads kill    clearRegisters(start, end);        for (OPT_DepGraphNode pnode = (OPT_DepGraphNode) firstNode();         pnode != null;          pnode = (OPT_DepGraphNode) pnode.getNext())  {      OPT_Instruction p = pnode.instruction();      // (1) Add edges due to registers      int useMask = p.operator().implicitUses;      int defMask = p.operator().implicitDefs;      if (p.isTSPoint()) {        useMask |= OPT_PhysicalDefUse.maskTSPUses;        defMask |= OPT_PhysicalDefUse.maskTSPDefs;      }      for (OPT_OperandEnumeration uses = p.getUses();           uses.hasMoreElements(); ) {        computeForwardDependencesUse(uses.next(), pnode, lastExceptionNode);      }      for (Enumeration uses = OPT_PhysicalDefUse.enumerate(useMask,ir);           uses.hasMoreElements(); ) {        OPT_Register r = (OPT_Register)uses.nextElement();         computeImplicitForwardDependencesUse(r, pnode);      }      for (OPT_OperandEnumeration defs = p.getDefs();           defs.hasMoreElements(); )  {        computeForwardDependencesDef(defs.next(), pnode, lastExceptionNode);      }      for (Enumeration defs = OPT_PhysicalDefUse.enumerate(defMask,ir);           defs.hasMoreElements(); ) {        OPT_Register r = (OPT_Register)defs.nextElement();         computeImplicitForwardDependencesDef(r, pnode);      }      // (2) Add edges due to memory      boolean isStore = p.isStore();      boolean isLoad = p.isLoad();      if (isStore || isLoad) {        // If readsKill then add memory model memory dependence from prior load        // NOTE: In general alias relationships are not transitive and therefore        //       we cannot exit this loop early.        if (readsKill && isLoad) {          for (OPT_DepGraphNode lnode = lastLoadNode;                lnode != null;               lnode = (OPT_DepGraphNode) lnode.getPrev()) {            if (lnode.instruction().isLoad() &&                OPT_LocationOperand.mayBeAliased(getLocation(p),                                                 getLocation(lnode.instruction()))) {              lnode.insertOutEdge(pnode, MEM_READS_KILL);            }          }           lastLoadNode = pnode;        }        // Add output/flow memory dependence from prior potentially aliased stores.        // NOTE: In general alias relationships are not transitive and therefore        //       we cannot exit this loop early.        for (OPT_DepGraphNode snode = lastStoreNode;              snode != null;             snode = (OPT_DepGraphNode) snode.getPrev()) {          if (snode.instruction().isStore() &&               OPT_LocationOperand.mayBeAliased(getLocation(p),                                               getLocation(snode.instruction())))  {            snode.insertOutEdge(pnode, isStore?MEM_OUTPUT:MEM_TRUE);          }        }        if (isStore) {          lastStoreNode = pnode;          if (lastExceptionNode != null) {            lastExceptionNode.insertOutEdge(pnode, EXCEPTION_MS);          }        }      }      // (3) Add edges due to exception state/exceptional control flow.      if (p.isPEI()) {        if (lastExceptionNode != null) {          lastExceptionNode.insertOutEdge(pnode, EXCEPTION_E);        }        lastExceptionNode = pnode;      }    }  }