changes.

diff --git a/Robust/src/Analysis/SSJava/BuildLattice.java b/Robust/src/Analysis/SSJava/BuildLattice.java
index b306a4fc00cf9abbd8d1cd1ccf8970fd5d41a302..931e865d3153b3a339585b253ffe4c76276ee7bd 100644 (file)
--- a/Robust/src/Analysis/SSJava/BuildLattice.java
+++ b/Robust/src/Analysis/SSJava/BuildLattice.java
@@ -8,16 +8,19 @@ import java.util.Set;
 
 import IR.Descriptor;
 import IR.MethodDescriptor;
+import IR.NameDescriptor;
 import Util.Pair;
 
 public class BuildLattice {
 
   private LocationInference infer;
   private Map<HNode, TripleItem> mapSharedNodeToTripleItem;
+  private Map<HNode, Integer> mapHNodeToHighestIndex;
 
   public BuildLattice(LocationInference infer) {
     this.infer = infer;
     this.mapSharedNodeToTripleItem = new HashMap<HNode, TripleItem>();
+    this.mapHNodeToHighestIndex = new HashMap<HNode, Integer>();
   }
 
   public SSJavaLattice<String> buildLattice(Descriptor desc) {
@@ -54,13 +57,16 @@ public class BuildLattice {
     Family family = generateFamily(basisSet);
     Map<Set<Integer>, Set<Set<Integer>>> mapImSucc = coveringGraph(basisSet, family);
 
-    SSJavaLattice<String> lattice = buildLattice(basisSet, inputGraph, locSummary, mapImSucc);
+    SSJavaLattice<String> lattice = buildLattice(desc, basisSet, inputGraph, locSummary, mapImSucc);
     return lattice;
 
   }
 
-  private SSJavaLattice<String> buildLattice(BasisSet basisSet, HierarchyGraph inputGraph,
-      LocationSummary locSummary, Map<Set<Integer>, Set<Set<Integer>>> mapImSucc) {
+  private SSJavaLattice<String> buildLattice(Descriptor desc, BasisSet basisSet,
+      HierarchyGraph inputGraph, LocationSummary locSummary,
+      Map<Set<Integer>, Set<Set<Integer>>> mapImSucc) {
+
+    HierarchyGraph simpleHierarchyGraph = infer.getSimpleHierarchyGraph(desc);
 
     SSJavaLattice<String> lattice =
         new SSJavaLattice<String>(SSJavaAnalysis.TOP, SSJavaAnalysis.BOTTOM);
@@ -74,6 +80,7 @@ public class BuildLattice {
       String higherName = generateElementName(basisSet, inputGraph, mapFToLocName, higher);
 
       HNode higherNode = inputGraph.getHNode(higherName);
+
       if (higherNode != null && higherNode.isSharedNode()) {
         lattice.addSharedLoc(higherName);
       }
@@ -92,6 +99,7 @@ public class BuildLattice {
 
         String lowerName = generateElementName(basisSet, inputGraph, mapFToLocName, lower);
         HNode lowerNode = inputGraph.getHNode(lowerName);
+
         if (lowerNode != null && lowerNode.isSharedNode()) {
           lattice.addSharedLoc(lowerName);
         }
@@ -164,7 +172,7 @@ public class BuildLattice {
     // System.out.println("***nodeSet=" + nodeSet);
     for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
       HNode node = (HNode) iterator.next();
-      // System.out.println("node=" + node);
+      System.out.println("node=" + node);
 
       if (node.isSkeleton() && (!visited.contains(node))) {
         visited.add(node);
@@ -175,7 +183,12 @@ public class BuildLattice {
 
           if (!outNode.isSkeleton()) {
             if (outNode.isCombinationNode()) {
-              expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary, outNode);
+              if (visited.containsAll(simpleGraph.getIncomingNodeSet(outNode))) {
+                // if (needToExpandCombinationNode(desc, outNode)) {
+                expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary,
+                    outNode);
+                // }
+              }
             } else {
               // we have a node that is neither combination or skeleton node
               // System.out.println("%%%skeleton node=" + node + "  outNode=" + outNode);
@@ -311,15 +324,44 @@ public class BuildLattice {
     return aboveSet;
   }
 
+  private boolean needToExpandCombinationNode(Descriptor desc, HNode cnode) {
+
+    System.out.println("needToExpandCombinationNode?=" + cnode);
+
+    HierarchyGraph simpleGraph = infer.getSimpleHierarchyGraph(desc);
+    // HNode combinationNodeInSCGraph = getCombinationNodeInSCGraph(desc, cnode);
+    Set<HNode> combineSkeletonNodeSet = simpleGraph.getCombineSetByCombinationNode(cnode);
+    Set<HNode> combinationNodeSetInSimpleGraph =
+        simpleGraph.getCombinationNodeSetByCombineNodeSet(combineSkeletonNodeSet);
+    System.out.println("---combinationNodeSetInSimpleGraph=" + combinationNodeSetInSimpleGraph);
+    Set<HNode> inNodeSetToCNode = simpleGraph.getIncomingNodeSet(cnode);
+    System.out.println("------inNodeSetToCNode=" + inNodeSetToCNode);
+    for (Iterator iterator = combinationNodeSetInSimpleGraph.iterator(); iterator.hasNext();) {
+      HNode nodeBelongToTheSameCombinationNode = (HNode) iterator.next();
+      if (inNodeSetToCNode.contains(nodeBelongToTheSameCombinationNode)) {
+        // the combination node 'cnode' is not the highest location among the same combination node
+        return false;
+      }
+    }
+
+    return true;
+  }
+
   private void expandCombinationNode(Descriptor desc, SSJavaLattice<String> lattice,
       Set<HNode> visited, Map<TripleItem, String> mapIntermediateLoc, LocationSummary locSummary,
       HNode cnode) {
 
-    // System.out.println("expandCombinationNode=" + cnode);
     // expand the combination node 'outNode'
     // here we need to expand the corresponding combination location in the lattice
     HNode combinationNodeInSCGraph = getCombinationNodeInSCGraph(desc, cnode);
 
+    System.out.println("expandCombinationNode=" + cnode + "  cnode in scgraph="
+        + combinationNodeInSCGraph);
+
+    if (combinationNodeInSCGraph == null) {
+      return;
+    }
+
     HierarchyGraph simpleGraph = infer.getSimpleHierarchyGraph(desc);
 
     Set<HNode> combineSkeletonNodeSet = simpleGraph.getCombineSetByCombinationNode(cnode);
@@ -501,13 +543,13 @@ public class BuildLattice {
     }
 
     String locName = mapIntermediateLoc.get(item);
-    HierarchyGraph graph = infer.getSimpleHierarchyGraph(desc);
+    HierarchyGraph simpleHierarchyGraph = infer.getSimpleHierarchyGraph(desc);
 
     if (curNode.isSharedNode()) {
       // if the current node is shared location, add a shared location to the lattice later
       mapSharedNodeToTripleItem.put(curNode, item);
     } else {
-      Set<Descriptor> descSet = graph.getDescSetOfNode(curNode);
+      Set<Descriptor> descSet = simpleHierarchyGraph.getDescSetOfNode(curNode);
       for (Iterator iterator = descSet.iterator(); iterator.hasNext();) {
         Descriptor d = (Descriptor) iterator.next();
         locSummary.addMapHNodeNameToLocationName(d.getSymbol(), locName);
@@ -515,24 +557,36 @@ public class BuildLattice {
       locSummary.addMapHNodeNameToLocationName(curNode.getName(), locName);
     }
 
-    // System.out.println("-TripleItem=" + item);
-    // System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode()
-    // + " locName=" + locName);
+    System.out.println("-TripleItem normal=" + item);
+    System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode()
+        + " locName=" + locName + "  isC=" + curNode.isCombinationNode());
 
-    Set<HNode> outSet = graph.getOutgoingNodeSet(curNode);
+    Set<HNode> outSet = simpleHierarchyGraph.getOutgoingNodeSet(curNode);
     for (Iterator iterator2 = outSet.iterator(); iterator2.hasNext();) {
       HNode outNode = (HNode) iterator2.next();
 
-      Set<HNode> inNodeSetToOutNode = graph.getIncomingNodeSet(outNode);
+      Set<HNode> incomingHNodeSetToOutNode = simpleHierarchyGraph.getIncomingNodeSet(outNode);
+      System.out.println("outNode=" + outNode);
+      System.out.println("---incomingHNodeSetToOutNode=" + incomingHNodeSetToOutNode);
 
-      if (visited.containsAll(inNodeSetToOutNode)) {
-        if (!outNode.isSkeleton() && !outNode.isCombinationNode() && !visited.contains(outNode)) {
+      if (!outNode.isSkeleton() && !outNode.isCombinationNode() && !visited.contains(outNode)) {
+        if (visited.containsAll(simpleHierarchyGraph.getIncomingNodeSet(outNode))) {
           visited.add(outNode);
+          int newidx = getCurrentHighestIndex(outNode, idx + 1);
           recurDFSNormalNode(desc, lattice, startNode, endNodeSet, visited, mapIntermediateLoc,
-              idx + 1, locSummary, outNode);
-        } else if (!outNode.isSkeleton() && outNode.isCombinationNode()
-            && !visited.contains(outNode)) {
+              newidx, locSummary, outNode);
+          // recurDFSNormalNode(desc, lattice, startNode, endNodeSet, visited, mapIntermediateLoc,
+          // idx + 1, locSummary, outNode);
+        } else {
+          updateHighestIndex(outNode, idx + 1);
+          System.out.println("NOT RECUR");
+        }
+      } else if (!outNode.isSkeleton() && outNode.isCombinationNode() && !visited.contains(outNode)) {
+        if (needToExpandCombinationNode(desc, outNode)) {
+          System.out.println("NEED TO");
           expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary, outNode);
+        } else {
+          System.out.println("NOT NEED TO");
         }
       }
 
@@ -578,13 +632,13 @@ public class BuildLattice {
     // return;
     // }
 
-    HierarchyGraph graph = infer.getSimpleHierarchyGraph(desc);
+    HierarchyGraph simpleHierarchyGraph = infer.getSimpleHierarchyGraph(desc);
     String locName = mapIntermediateLoc.get(item);
     if (curNode.isSharedNode()) {
       // if the current node is shared location, add a shared location to the lattice later
       mapSharedNodeToTripleItem.put(curNode, item);
     } else {
-      Set<Descriptor> descSet = graph.getDescSetOfNode(curNode);
+      Set<Descriptor> descSet = simpleHierarchyGraph.getDescSetOfNode(curNode);
       for (Iterator iterator = descSet.iterator(); iterator.hasNext();) {
         Descriptor d = (Descriptor) iterator.next();
         locSummary.addMapHNodeNameToLocationName(d.getSymbol(), locName);
@@ -592,40 +646,88 @@ public class BuildLattice {
       locSummary.addMapHNodeNameToLocationName(curNode.getName(), locName);
     }
 
-    // System.out.println("-TripleItem=" + item);
-    // System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode()
-    // + " locName=" + locName);
+    System.out.println("-TripleItem=" + item);
+    System.out.println("-curNode=" + curNode.getName() + " S=" + curNode.isSharedNode()
+        + " locName=" + locName);
 
-    Set<HNode> outSet = graph.getOutgoingNodeSet(curNode);
+    Set<HNode> outSet = simpleHierarchyGraph.getOutgoingNodeSet(curNode);
     for (Iterator iterator2 = outSet.iterator(); iterator2.hasNext();) {
       HNode outNode = (HNode) iterator2.next();
-      // System.out.println("recurDFS outNode=" + outNode);
-      // System.out.println("---cur combinationNodeInSCGraph=" + combinationNodeInSCGraph);
-      // System.out.println("---outNode combinationNodeInSCGraph="
-      // + getCombinationNodeInSCGraph(desc, outNode));
-
-      Set<HNode> inNodeSetToOutNode = graph.getIncomingNodeSet(outNode);
-
-      if (visited.containsAll(inNodeSetToOutNode)) {
-        if (!outNode.isSkeleton() && !visited.contains(outNode)) {
-          if (outNode.isCombinationNode()) {
-            // check whether the next combination node is different from the current node
-            if (combinationNodeInSCGraph.equals(getCombinationNodeInSCGraph(desc, outNode))) {
+      System.out.println("---recurDFS outNode=" + outNode);
+      System.out.println("---cur combinationNodeInSCGraph=" + combinationNodeInSCGraph);
+      System.out.println("---outNode combinationNodeInSCGraph="
+          + getCombinationNodeInSCGraph(desc, outNode));
+
+      if (!outNode.isSkeleton() && !visited.contains(outNode)) {
+        if (outNode.isCombinationNode()) {
+
+          Set<HNode> combineSkeletonNodeSet =
+              simpleHierarchyGraph.getCombineSetByCombinationNode(outNode);
+          Set<HNode> incomingHNodeSetToOutNode = simpleHierarchyGraph.getIncomingNodeSet(outNode);
+          // extract nodes belong to the same combine node
+          Set<HNode> incomingCombinedHNodeSet = new HashSet<HNode>();
+          for (Iterator iterator = incomingHNodeSetToOutNode.iterator(); iterator.hasNext();) {
+            HNode inNode = (HNode) iterator.next();
+            if (combineSkeletonNodeSet.contains(inNode)) {
+              incomingCombinedHNodeSet.add(inNode);
+            }
+          }
+          System.out.println("-----incomingCombinedHNodeSet=" + incomingCombinedHNodeSet);
+
+          // check whether the next combination node is different from the current node
+          if (combinationNodeInSCGraph.equals(getCombinationNodeInSCGraph(desc, outNode))) {
+            if (visited.containsAll(incomingCombinedHNodeSet)) {
               visited.add(outNode);
+              System.out.println("-------curIdx=" + (idx + 1));
+              int newIdx = getCurrentHighestIndex(outNode, idx + 1);
+              System.out.println("-------newIdx=" + newIdx);
               recurDFS(desc, lattice, combinationNodeInSCGraph, endNodeSet, visited,
-                  mapIntermediateLoc, idx + 1, locSummary, outNode);
+                  mapIntermediateLoc, newIdx, locSummary, outNode);
+              // recurDFS(desc, lattice, combinationNodeInSCGraph, endNodeSet, visited,
+              // mapIntermediateLoc, idx + 1, locSummary, outNode);
             } else {
+              updateHighestIndex(outNode, idx + 1);
+              System.out.println("-----NOT RECUR!");
+            }
+          } else {
+            if (needToExpandCombinationNode(desc, outNode)) {
+              System.out.println("NEED TO");
               expandCombinationNode(desc, lattice, visited, mapIntermediateLoc, locSummary, outNode);
+            } else {
+              System.out.println("NOT NEED TO");
             }
-          }
 
+          }
         }
       }
+      // }
 
     }
 
   }
 
+  private int getCurrentHighestIndex(HNode node, int curIdx) {
+    int recordedIdx = getCurrentHighestIndex(node);
+    if (recordedIdx > curIdx) {
+      return recordedIdx;
+    } else {
+      return curIdx;
+    }
+  }
+
+  private int getCurrentHighestIndex(HNode node) {
+    if (!mapHNodeToHighestIndex.containsKey(node)) {
+      mapHNodeToHighestIndex.put(node, new Integer(-1));
+    }
+    return mapHNodeToHighestIndex.get(node).intValue();
+  }
+
+  private void updateHighestIndex(HNode node, int idx) {
+    if (idx > getCurrentHighestIndex(node)) {
+      mapHNodeToHighestIndex.put(node, new Integer(idx));
+    }
+  }
+
   private String generateElementName(BasisSet basisSet, HierarchyGraph inputGraph,
       Map<Set<Integer>, String> mapF2LocName, Set<Integer> F) {
 

diff --git a/Robust/src/Analysis/SSJava/FlowDownCheck.java b/Robust/src/Analysis/SSJava/FlowDownCheck.java
index b5f22d32a51be8184e6582aa5dbac292b615ce85..6d22825dcaa312f6bc8e87711300cf25fedfe4c6 100644 (file)
--- a/Robust/src/Analysis/SSJava/FlowDownCheck.java
+++ b/Robust/src/Analysis/SSJava/FlowDownCheck.java
@@ -2207,7 +2207,10 @@ public class FlowDownCheck {
       }
 
       SSJavaLattice<String> locOrder = getLatticeByDescriptor(priorityDescriptor);
+      System.out.println("priorityDescriptor=" + priorityDescriptor);
+      System.out.println("GLB INPUT=" + priorityLocIdentifierSet);
       String glbOfPriorityLoc = locOrder.getGLB(priorityLocIdentifierSet);
+      System.out.println("GLB OUTPUT="+glbOfPriorityLoc);
       glbCompLoc.addLocation(new Location(priorityDescriptor, glbOfPriorityLoc));
       Set<CompositeLocation> compSet = locId2CompLocSet.get(glbOfPriorityLoc);
 

diff --git a/Robust/src/Analysis/SSJava/HierarchyGraph.java b/Robust/src/Analysis/SSJava/HierarchyGraph.java
index 8b364b1cc483c867dcc2d9f6d1bcebb3b65184e2..d51e6107d41705113b6d3f0bc682f153e30c8e12 100644 (file)
--- a/Robust/src/Analysis/SSJava/HierarchyGraph.java
+++ b/Robust/src/Analysis/SSJava/HierarchyGraph.java
@@ -401,7 +401,7 @@ public class HierarchyGraph {
   private void addEdgeWithNoCycleCheck(HNode srcHNode, HNode dstHNode) {
     getIncomingNodeSet(dstHNode).add(srcHNode);
     getOutgoingNodeSet(srcHNode).add(dstHNode);
-//    System.out.println("addEdgeWithNoCycleCheck src=" + srcHNode + " -> " + dstHNode);
+    // System.out.println("addEdgeWithNoCycleCheck src=" + srcHNode + " -> " + dstHNode);
   }
 
   private HNode mergeNodes(Set<HNode> set, boolean onlyCombinationNodes) {
@@ -777,9 +777,9 @@ public class HierarchyGraph {
     Set<Set<HNode>> keySet = simpleHierarchyGraph.getCombineNodeSet();
     for (Iterator iterator = keySet.iterator(); iterator.hasNext();) {
       Set<HNode> combineSet = (Set<HNode>) iterator.next();
-      System.out.println("--combineSet=" + combineSet);
+      // System.out.println("--combineSet=" + combineSet);
       HNode combinationNode = getCombinationNode(combineSet);
-      System.out.println("--combinationNode=" + combinationNode);
+      // System.out.println("--combinationNode=" + combinationNode);
       // add an edge from a skeleton node to a combination node
       for (Iterator iterator2 = combineSet.iterator(); iterator2.hasNext();) {
         HNode inSkeletonNode = (HNode) iterator2.next();
@@ -850,10 +850,10 @@ public class HierarchyGraph {
     Set<HNode> visited = new HashSet<HNode>();
     recurSkeletonReachTo(node, reachToSet, visited);
 
+    // obsolete!
     // if a node reaches to one of elements in the reachToSet, we do not need to keep it
     // because the node is not directly connected to the combination node
-
-    removeRedundantReachToNodes(reachToSet);
+    // removeRedundantReachToNodes(reachToSet);
 
     return reachToSet;
   }
@@ -967,6 +967,7 @@ public class HierarchyGraph {
       HNode node = (HNode) iterator.next();
       if (!node.isSkeleton()) {
         Set<HNode> reachToSet = getSkeleteNodeSetReachTo(node);
+        System.out.println("$node=" + node + "   reachToNodeSet=" + reachToSet);
         if (reachToSet.size() > 1) {
           // if (countSkeletonNodes(reachToSet) > 1) {
           System.out.println("-node=" + node + "  reachToSet=" + reachToSet);
@@ -1074,7 +1075,7 @@ public class HierarchyGraph {
 
   public void assignUniqueIndexToNode() {
     int idx = 1;
-    System.out.println("nodeSet=" + nodeSet);
+    // System.out.println("nodeSet=" + nodeSet);
     for (Iterator iterator = nodeSet.iterator(); iterator.hasNext();) {
       HNode node = (HNode) iterator.next();
       mapHNodeToUniqueIndex.put(node, idx);
@@ -1104,17 +1105,17 @@ public class HierarchyGraph {
       basis.addAll(BASISTOPELEMENT);
 
       Set<HNode> reachableNodeSet = getReachableNodeSetFrom(node);
-      System.out.println("node=" + node + "    reachableNodeSet=" + reachableNodeSet);
-      System.out.println("mapHNodeToUniqueIndex.get(node)=" + mapHNodeToUniqueIndex.get(node));
+      // System.out.println("node=" + node + "    reachableNodeSet=" + reachableNodeSet);
+      // System.out.println("mapHNodeToUniqueIndex.get(node)=" + mapHNodeToUniqueIndex.get(node));
       // if a node is reachable from the current node
       // need to remove the index of the reachable node from the basis
 
       basis.remove(getHNodeIndex(node));
       for (Iterator iterator2 = reachableNodeSet.iterator(); iterator2.hasNext();) {
         HNode reachableNode = (HNode) iterator2.next();
-        System.out.println("reachableNode=" + reachableNode);
-        System.out.println("getHNodeIndex(reachableNode))="
-            + mapHNodeToUniqueIndex.get(reachableNode));
+        // System.out.println("reachableNode=" + reachableNode);
+        // System.out.println("getHNodeIndex(reachableNode))="
+        // + mapHNodeToUniqueIndex.get(reachableNode));
         int idx = getHNodeIndex(reachableNode);
         basis.remove(idx);
       }

diff --git a/Robust/src/Analysis/SSJava/LocationInference.java b/Robust/src/Analysis/SSJava/LocationInference.java
index 99a7315f62b8b0f19960ff5f44fe7f3998b25467..c3440672619a9a869369314d5551ee0622ab58d9 100644 (file)
--- a/Robust/src/Analysis/SSJava/LocationInference.java
+++ b/Robust/src/Analysis/SSJava/LocationInference.java
@@ -1759,9 +1759,21 @@ public class LocationInference {
   public static boolean isReference(Descriptor desc) {
 
     if (desc instanceof FieldDescriptor) {
-      return ((FieldDescriptor) desc).getType().isPtr();
+
+      TypeDescriptor type = ((FieldDescriptor) desc).getType();
+      if (type.isArray()) {
+        return false;
+      } else {
+        return type.isPtr();
+      }
+
     } else if (desc instanceof VarDescriptor) {
-      return ((VarDescriptor) desc).getType().isPtr();
+      TypeDescriptor type = ((VarDescriptor) desc).getType();
+      if (type.isArray()) {
+        return false;
+      } else {
+        return type.isPtr();
+      }
     }
 
     return false;
@@ -3879,8 +3891,10 @@ public class LocationInference {
           + "   idx=" + idx);
       if (!srcFieldDesc.equals(dstFieldDesc)) {
         // add a new edge
+        System.out.println("-ADD EDGE");
         getHierarchyGraph(cd).addEdge(srcFieldDesc, dstFieldDesc);
       } else if (!isReference(srcFieldDesc) && !isReference(dstFieldDesc)) {
+        System.out.println("-ADD EDGE");
         getHierarchyGraph(cd).addEdge(srcFieldDesc, dstFieldDesc);
       }
 
@@ -5329,10 +5343,10 @@ public class LocationInference {
       analyzeFlowExpressionNode(md, nametable, an.getSrc(), nodeSetRHS, null, implicitFlowTupleSet,
           false);
 
-      // System.out.println("-analyzeFlowAssignmentNode=" + an.printNode(0));
-      // System.out.println("-nodeSetLHS=" + nodeSetLHS);
-      // System.out.println("-nodeSetRHS=" + nodeSetRHS);
-      // System.out.println("-implicitFlowTupleSet=" + implicitFlowTupleSet);
+      System.out.println("-analyzeFlowAssignmentNode=" + an.printNode(0));
+      System.out.println("-nodeSetLHS=" + nodeSetLHS);
+      System.out.println("-nodeSetRHS=" + nodeSetRHS);
+      System.out.println("-implicitFlowTupleSet=" + implicitFlowTupleSet);
       // System.out.println("-");
 
       if (an.getOperation().getOp() >= 2 && an.getOperation().getOp() <= 12) {

diff --git a/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/LayerIIIDecoder.java b/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/LayerIIIDecoder.java
index c022ba06dc86338fdd4db4064ad7fae21567b476..bd57283d15780f7c98f84901a5c5038f403c3127 100644 (file)
--- a/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/LayerIIIDecoder.java
+++ b/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/LayerIIIDecoder.java
@@ -1950,7 +1950,24 @@ final class LayerIIIDecoder implements FrameDecoder {
     float tmpf_16;
     float tmpf_17;
 
-    tmpf_0 = tmpf_1 = tmpf_2 = tmpf_3 = tmpf_4 = tmpf_5 = tmpf_6 = tmpf_7 = tmpf_8 = tmpf_9 = tmpf_10 = tmpf_11 = tmpf_12 = tmpf_13 = tmpf_14 = tmpf_15 = tmpf_16 = tmpf_17 = 0.0f;
+    tmpf_0 = 0.0f;
+    tmpf_1 = 0.0f;
+    tmpf_2 = 0.0f;
+    tmpf_3 = 0.0f;
+    tmpf_4 = 0.0f;
+    tmpf_5 = 0.0f;
+    tmpf_6 = 0.0f;
+    tmpf_7 = 0.0f;
+    tmpf_8 = 0.0f;
+    tmpf_9 = 0.0f;
+    tmpf_10 = 0.0f;
+    tmpf_11 = 0.0f;
+    tmpf_12 = 0.0f;
+    tmpf_13 = 0.0f;
+    tmpf_14 = 0.0f;
+    tmpf_15 = 0.0f;
+    tmpf_16 = 0.0f;
+    tmpf_17 = 0.0f;
 
     if (block_type == 2) {
 
@@ -2382,7 +2399,7 @@ final class LayerIIIDecoder implements FrameDecoder {
    * 12, 13, 14, 15, 16, 17 };
    */
 
-  private static/* final */int reorder_table[][]/* = loadReorderTable() */; // SZD:
+  private static final int reorder_table[][]/* = loadReorderTable() */; // SZD:
 
   // will
   // be

diff --git a/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/Player.java b/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/Player.java
index c7ef1c0f4310310a6df6c158b0cf1b68891da0ba..236fd3e66ad97d406b76583bb42ebe3439645dc5 100644 (file)
--- a/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/Player.java
+++ b/Robust/src/Benchmarks/SSJava/MP3DecoderInfer/Player.java
@@ -120,26 +120,41 @@ public class Player {
     sampleNumber = 1;\r
     System.out.println("Gobble sentinel: +++");\r
 \r
+    ret=play2(h);\r
     // int count = 0;\r
+//    SSJAVA: while (true) {\r
+//      if (h == null) {\r
+//        break;\r
+//      }\r
+//      ret = decodeFrame(init, h);\r
+//      if (!ret) {\r
+//        break;\r
+//      }\r
+//      h = BitstreamWrapper.readFrame();\r
+//    }\r
+\r
+    /*\r
+     * if (!ret) { // last frame, ensure all data flushed to the audio device.\r
+     * AudioDevice out = audio; if (out!=null) { out.flush(); synchronized\r
+     * (this) { complete = (!closed); close(); } } }\r
+     */\r
+    return ret;\r
+  }\r
+\r
+  public boolean play2( Header h){\r
+    boolean ret;\r
     SSJAVA: while (true) {\r
       if (h == null) {\r
         break;\r
       }\r
-      ret = decodeFrame(init, h);\r
+      ret = decodeFrame(true, h);\r
       if (!ret) {\r
         break;\r
       }\r
       h = BitstreamWrapper.readFrame();\r
     }\r
-\r
-    /*\r
-     * if (!ret) { // last frame, ensure all data flushed to the audio device.\r
-     * AudioDevice out = audio; if (out!=null) { out.flush(); synchronized\r
-     * (this) { complete = (!closed); close(); } } }\r
-     */\r
     return ret;\r
   }\r
-\r
   /**\r
    * Cloases this player. Any audio currently playing is stopped immediately.\r
    */\r