optimizing removal of useless load/pop pairs

Author: osamie

bin/JasminOptimizer.class

@@ -1,68 +0,0 @@
-  ;;;;;;;;; Begin Block 0 ;;;;;;;;;
-.class public simple 
-.super java/lang/Object 
-  ;;;;;;;;; End Block 0 ;;;;;;;;;
-  ;;;;;;;;; Begin Block 1 ;;;;;;;;;
-.method public <init>()V 
-  aload_0 
-  invokenonvirtual java/lang/Object/<init>()V 
-  return 
-  ;;;;;;;;; End Block 1 ;;;;;;;;;
-  ;;;;;;;;; Begin Block 2 ;;;;;;;;;
-.end method 
-  ;;;;;;;;; End Block 2 ;;;;;;;;;
-  ;;;;;;;;; Begin Block 3 ;;;;;;;;;
-.method public static println(I)I 
-.limit stack 5 
-.limit locals 2 
-  getstatic java/lang/System/out Ljava/io/PrintStream; 
-  iload 0 
-  ifeq false_label 
-  ; Block 3 exits to blocks 4 5
-  ;;;;;;;;; End Block 3 ;;;;;;;;;
-  ;;;;;;;;; Begin Block 4 ;;;;;;;;;
-  ldc "true" 
-  ifne dummy_label 
-  ; Block 4 exits to blocks 5 7
-  ;;;;;;;;; End Block 4 ;;;;;;;;;
-  ;;;;;;;;; Begin Block 5 ;;;;;;;;;
-false_label: ;label (target of jump) 
-  ldc "false" 
-  ldc 0 
-  ifne dummy_label 
-  ; Block 5 exits to blocks 6 7
-  ;;;;;;;;; End Block 5 ;;;;;;;;;
-  ;;;;;;;;; Begin Block 6 ;;;;;;;;;
-  ldc 6 
-  dup 
-  fadd 
-  ldc 2 
-  ldc 2 
-  ldc 2 
-  fmul 
-  ldc "table" 
-  astore 
-  ;;;;;;;;; End Block 6 ;;;;;;;;;
-  ;;;;;;;;; Begin Block 7 ;;;;;;;;;
-dummy_label: ;label (target of jump) 
-  pop 
-  ldc 0 
-  fload 2.0 
-  ldc 3 
-  fmul 
-.end method 
-  ;;;;;;;;; End Block 7 ;;;;;;;;;
-  ;;;;;;;;; Begin Block 8 ;;;;;;;;;
-.method public static main()F 
-.limit stack 50 
-.limit locals 50 
-  ldc 0.0 
-  fstore 0 
-  ldc "test" 
-  pop 
-  fload 0 
-  freturn 
-  ;;;;;;;;; End Block 8 ;;;;;;;;;
-  ;;;;;;;;; Begin Block 9 ;;;;;;;;;
-.end method 
-  ;;;;;;;;; End Block 9 ;;;;;;;;;

bin/output.txt

@@ -0,0 +1,44 @@
+; Begin standard header
+.class public simple
+.super java/lang/Object
+.method public <init>()V
+  aload_0
+
+  invokenonvirtual java/lang/Object/<init>()V
+  return
+.end method
+.method public static main([Ljava/lang/String;)V
+  invokestatic simple/main()F
+  return
+.end method
+; End standard header
+
+.method public static main()F
+.limit stack 50
+.limit locals 50
+  ldc 0.0
+  fstore 0   ; i
+  ldc 5.0
+  fstore 0   ; i
+  fload 0   ;i
+  ldc 2.0
+  fmul
+  ldc 2.0
+  fmul
+  ldc 2.0
+  fmul
+  pop
+  ldc 0.0
+  fstore 1   ; x
+  ldc 8.0
+  fstore 1   ; x
+  ldc 2.0
+  ldc 2.0
+  ;fmul
+  fload 1   ;x
+  fmul
+  pop
+  ldc 0.0
+  freturn
+.end method
+; Begin standard trailer

bin/simple.j

@@ -39,11 +39,21 @@ false_label:
    ;ldc 2
    fdiv
 
+   fload 7
+  ldc 8.0
+  fmul
+  fload 2
+  ldc 5.0
+  fadd
+  fmul
+	pop
+   
 cipher_label:
 	ldc "table"
 	astore  
 dummy_label:
-	pop
+    
+	;pop
 	ldc 0	
 	fload 2.0
 	ldc 3

bin/simple22.j

@@ -171,11 +171,14 @@ else if (isReturn(first)) {
      */
     public void optimize() {
         for (int i = 0; i < codeBlocks.size(); i++) {
-            CodeBlock b = codeBlocks.elementAt(i);
+        	
+        	CodeBlock b = codeBlocks.elementAt(i);
+        	optimizeBlock(b);
+        	optimizeBLOCK_LoadPopPairs(b);
 
-            optimizeBlock(b);
             optimize_PrecalculateArithmeticConstants(b);
 
+            
         }
 
         optimizeJumpsToUnconditionalJumps();
@@ -186,15 +189,29 @@ public void optimize() {
 
     }
 
+    
+    protected void optimizeBLOCK_LoadPopPairs(CodeBlock b) {
+		LinkedList<Vector<String>> lines = b.getLines();
+		ListIterator<Vector<String>> i = lines.listIterator();
+		while (i.hasNext()) {
+			Vector line = (Vector) i.next();
+			String ins = (String) line.elementAt(0);
+			
+				if (isPopInstruction(ins)) {
+					
+					deletePrevious2(i); // the pop and the popped = 2
+					Vector<String> v = new Vector<String>(1);
+					
+					v.add("; useless load/pop pair removed (including useless instructions in between)" + line);
+					i.add(v);
+				}
+			}
+		}
+    
     protected void optimize_PrecalculateArithmeticConstants(CodeBlock b) {
         LinkedList<Vector<String>> lines = b.getLines();
         ListIterator<Vector<String>> i = lines.listIterator(); 
-
-        // since each mul or add or any other operation
-        // of the sort takes two paramters, we go two up
-        // which is the closest to 0 that we can stumble 
-        // upon an arithmetic operation
-        
+    
         if(i.hasNext()) i.next();
         if(i.hasNext()) i.next();
 
@@ -779,5 +796,50 @@ protected static boolean isMultiplication(String s) {
         return false;        
     }
 
+    protected boolean isRemovableONEaboveString(String s){
+		
+		String instructions[] = { "fload", "ldc" , "pop"};
+		for (int i = 0; i < instructions.length; i++) {
+			if (s.compareTo(instructions[i]) == 0) {
+				return true;
+			}
+		}
+		return false;
+	}
+protected boolean isRemovableTWOaboveString(String s){
+	
+	String instructions[] = { "fmul", "dmul", "imul", "lmul", "fadd", "dadd", "iadd", "ladd", "fdiv", "ddiv", "idiv", "ldiv", "fsub", "dsub", "isub", "lsub" };
+	for (int i = 0; i < instructions.length; i++) {
+		if (s.compareTo(instructions[i]) == 0) {
+			return true;
+		}
+	}
+	return false;
+}
+
+
+protected void deletePrevious2(ListIterator<Vector<String>> i) {
+	delete_previous(i);
+	delete_previous(i);
+}
+protected void delete_previous(ListIterator<Vector<String>> i) {
+	
+	i.remove();
+	if(!i.hasPrevious()) return;
+	i.previous();
+	Vector line = (Vector) i.next();
+	String ins = (String) line.elementAt(0);
+	
+	if(isRemovableONEaboveString(ins)){
+		delete_previous(i);
+	}else if(isRemovableTWOaboveString(ins)){
+		deletePrevious2(i);
+	}else{
+		return;
+	}
+}
+
+
+    
 
 }