SSAU-lite

Author: Kroppeb

src/org/jetbrains/java/decompiler/modules/decompiler/SimplifyExprentsHelper.java

@@ -1,17 +1,18 @@
 // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package org.jetbrains.java.decompiler.modules.decompiler;
 
-import org.jetbrains.java.decompiler.code.CodeConstants;
 import org.jetbrains.java.decompiler.main.ClassesProcessor.ClassNode;
 import org.jetbrains.java.decompiler.main.DecompilerContext;
 import org.jetbrains.java.decompiler.main.extern.IFernflowerPreferences;
 import org.jetbrains.java.decompiler.main.rels.ClassWrapper;
 import org.jetbrains.java.decompiler.modules.decompiler.exps.*;
 import org.jetbrains.java.decompiler.modules.decompiler.exps.FunctionExprent.FunctionType;
 import org.jetbrains.java.decompiler.modules.decompiler.sforms.SSAConstructorSparseEx;
+import org.jetbrains.java.decompiler.modules.decompiler.sforms.SSAUConstructorSparseEx;
 import org.jetbrains.java.decompiler.modules.decompiler.stats.BasicBlockStatement;
 import org.jetbrains.java.decompiler.modules.decompiler.stats.IfStatement;
 import org.jetbrains.java.decompiler.modules.decompiler.stats.Statement;
+import org.jetbrains.java.decompiler.modules.decompiler.vars.VarVersionNode;
 import org.jetbrains.java.decompiler.modules.decompiler.vars.VarVersionPair;
 import org.jetbrains.java.decompiler.struct.StructClass;
 import org.jetbrains.java.decompiler.struct.gen.CodeType;
@@ -1175,4 +1176,84 @@ private static boolean collapseInlinedClass14(Statement stat) {
 
     return ret;
   }
+
+  public static boolean simplifySimple(Statement stat, SSAUConstructorSparseEx ssu) {
+    if (stat instanceof BasicBlockStatement bbStat) {
+      return simplifySimpleBlock(bbStat, ssu);
+    }
+    boolean simplified = false;
+    for(var subStat : stat.getStats()) {
+      simplified |= simplifySimple(subStat, ssu);
+    }
+    return simplified;
+  }
+
+  private static boolean simplifySimpleBlock(BasicBlockStatement bbStat, SSAUConstructorSparseEx ssu) {
+    var statExprents = bbStat.getExprents();
+    if (statExprents == null) {
+      return false;
+    }
+
+    boolean simplified = false;
+
+    for (int i = statExprents.size() - 1; i > 0; i--) {
+      var prevExprent = statExprents.get(i - 1);
+      if (prevExprent instanceof AssignmentExprent ass &&
+        ass.getCondType() == null &&
+        ass.getLeft() instanceof VarExprent varExprent &&
+        varExprent.isStack()
+      ){
+        VarVersionNode node = ssu.getNode(varExprent);
+        if (node.hasSingleSuccessor()) {
+          VarVersionNode targetNode = node.getSingleSuccessor();
+          if (targetNode.hasSinglePredecessor() && !targetNode.hasAnySuccessors()) {
+            // inlining in next exprent if the use is in the next exprent
+
+            if (inlineExprent(statExprents.get(i), targetNode.asPair(), ass.getRight()) == 1){
+              simplified = true;
+              statExprents.remove(i - 1);
+            }
+          }
+        }
+      }
+    }
+    return simplified;
+  }
+
+  // 0 => fail; 1 => success; 2 => fail, stop looking (impure)
+  private static int inlineExprent(
+    Exprent targetExprent,
+    VarVersionPair replaceablePair,
+    Exprent replaceExprent
+  ) {
+    // step 1: find exprent
+    for (var subExprent : targetExprent.getAllExprents()) {
+      if (subExprent instanceof VarExprent varExprent) {
+        if (varExprent.getIndex() == replaceablePair.var &&
+          varExprent.getVersion() == replaceablePair.version) {
+
+          targetExprent.replaceExprent(varExprent, replaceExprent);
+          return 1;
+        }
+      }
+
+      if ((subExprent.getExprentUse() & Exprent.SIDE_EFFECTS_FREE) != 0) {
+        int sub = inlineExprent(subExprent, replaceablePair, replaceExprent);
+        if(          sub > 0        ) {
+          return sub;
+        }
+      } else if(subExprent instanceof InvocationExprent) {
+        int sub = inlineExprent(subExprent, replaceablePair, replaceExprent);
+        if(          sub > 0        ) {
+          return sub;
+        }
+        return 2;
+      } else {
+        return 2;  // safety
+      }
+    }
+
+    // exprent use is not here
+    return 0;
+  }
 }

src/org/jetbrains/java/decompiler/modules/decompiler/StackVarsProcessor.java

@@ -64,6 +64,15 @@ public static void simplifyStackVars(RootStatement root, StructMethod mt, Struct
       SequenceHelper.condenseSequences(root);
       ValidationHelper.validateStatement(root);
 
+      if (first)  {
+        ssau = new SSAUConstructorSparseEx(false);
+        ssau.splitVariables(root, mt);
+
+        found |= SimplifyExprentsHelper.simplifySimple(root, ssau);
+
+        setVersionsToNull(root);
+      }
+
       ssau = new SSAUConstructorSparseEx();
       ssau.splitVariables(root, mt);
 

src/org/jetbrains/java/decompiler/modules/decompiler/sforms/SSAUConstructorSparseEx.java

@@ -31,18 +31,28 @@ public class SSAUConstructorSparseEx extends SFormsConstructor {
   // field access counter
   private int fieldVarCounter = -1;
 
-  public SSAUConstructorSparseEx() {
+  final private boolean trackLiveVars;
+
+  public SSAUConstructorSparseEx(boolean trackLiveVars) {
     super(
       true,
       true
     );
+
+    this.trackLiveVars = trackLiveVars;
+  }
+
+  public SSAUConstructorSparseEx() {
+    this(true);
   }
 
   @Override
   public void splitVariables(RootStatement root, StructMethod mt) {
     super.splitVariables(root, mt);
 
-    this.ssaStatements(this.dgraph, new HashSet<>(), true, mt, 999_999);
+    if (this.trackLiveVars) {
+      this.ssaStatements(this.dgraph, new HashSet<>(), true, mt, 999_999);
+    }
 
 //    this.ssuVersions.initDominators();
 

src/org/jetbrains/java/decompiler/modules/decompiler/vars/VarVersionNode.java

@@ -49,6 +49,10 @@ public boolean hasSinglePredecessor() {
     return this.predecessors.size() == 1;
   }
 
+  public boolean hasSingleSuccessor() {
+    return this.successors.size() == 1;
+  }
+
   public boolean hasAnySuccessors() {
     return !this.successors.isEmpty();
   }
@@ -58,6 +62,11 @@ public VarVersionNode getSinglePredecessor() {
     return this.predecessors.iterator().next();
   }
 
+  public VarVersionNode getSingleSuccessor() {
+    ValidationHelper.validateTrue(this.hasSingleSuccessor(), "Expected only a single successor");
+    return this.successors.iterator().next();
+  }
+
   @Override
   public String toString() {
     return "(" + this.var + "_" + this.version + ")";