Add test cases for current sils issues

src/systemTest/java/soot/toolkits/scalar/SharedInitLocalSplitterTest.java

@@ -0,0 +1,68 @@
+package soot.toolkits.scalar;
+
+/*-
+ * #%L
+ * Soot - a J*va Optimization Framework
+ * %%
+ * Copyright (C) 2021 Timothy Hoffman
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 2.1 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Lesser Public License for more details.
+ *
+ * You should have received a copy of the GNU General Lesser Public
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ * #L%
+ */
+
+import org.junit.Assert;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.powermock.core.classloader.annotations.PowerMockIgnore;
+
+import soot.Body;
+import soot.SootMethod;
+import soot.jimple.JimpleBody;
+import soot.options.Options;
+import soot.testing.framework.AbstractTestingFramework;
+
+/**
+ * @author Timothy Hoffman
+ */
+@PowerMockIgnore({ "com.sun.org.apache.xerces.*", "javax.xml.*", "org.xml.*", "org.w3c.*" })
+public class SharedInitLocalSplitterTest extends AbstractTestingFramework {
+
+  private static final String TEST_TARGET_CLASS = "soot.toolkits.scalar.SharedInitLocalSplitterTestInput";
+
+  @Override
+  protected void setupSoot() {
+    Options.v().setPhaseOption("jb.sils", "enabled:true");
+  }
+
+  @Ignore
+  @Test
+  public void testCaseA() {
+    SootMethod target =
+        prepareTarget(methodSigFromComponents(TEST_TARGET_CLASS, "int", "test", "java.lang.Object"), TEST_TARGET_CLASS);
+
+    Body body = target.retrieveActiveBody();
+    Assert.assertTrue(body instanceof JimpleBody);
+
+    // Ensure unused locals are removed before asserting expected count.
+    UnusedLocalEliminator.v().transform(body);
+
+    // System.out.println("[SharedInitLocalSplitterTest#testCaseA] body = " + body);
+
+    // SharedInitializationLocalSplitter should not have introduced any
+    // additional locals in this example because all of the integer constant
+    // values are used only as integers.
+    Assert.assertEquals(3, body.getLocalCount());
+  }
+}

src/systemTest/targets/soot/toolkits/scalar/SharedInitLocalSplitterTestInput.java

@@ -0,0 +1,41 @@
+package soot.toolkits.scalar;
+
+/*-
+ * #%L
+ * Soot - a J*va Optimization Framework
+ * %%
+ * Copyright (C) 2021 Timothy Hoffman
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 2.1 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Lesser Public License for more details.
+ *
+ * You should have received a copy of the GNU General Lesser Public
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ * #L%
+ */
+
+public class SharedInitLocalSplitterTestInput {
+
+  /*
+   * SOURCE: https://github.com/soot-oss/soot/issues/1699
+   */
+  public int test(Object b) {
+    int x = 100;
+    while (b != null) {
+      if (x < 200) {
+        x = 100;
+      } else {
+        x = 200;
+      }
+    }
+    return x;
+  }
+}

src/test/java/soot/toolkits/scalar/SharedInitializationLocalSplitterTest.java

@@ -0,0 +1,124 @@
+package soot.toolkits.scalar;
+
+/*-
+ * #%L
+ * Soot - a J*va Optimization Framework
+ * %%
+ * Copyright (C) 2021 Timothy Hoffman
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 2.1 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Lesser Public License for more details.
+ *
+ * You should have received a copy of the GNU General Lesser Public
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ * #L%
+ */
+
+import java.util.Collections;
+
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import soot.BooleanType;
+import soot.G;
+import soot.Local;
+import soot.Modifier;
+import soot.Scene;
+import soot.SootClass;
+import soot.SootMethod;
+import soot.Unit;
+import soot.UnitPatchingChain;
+import soot.UnknownType;
+import soot.VoidType;
+import soot.jimple.IntConstant;
+import soot.jimple.Jimple;
+import soot.jimple.JimpleBody;
+import soot.options.Options;
+import soot.util.Chain;
+
+/**
+ * Tests for the {@link SharedInitializationLocalSplitter}.
+ * 
+ * @author Timothy Hoffman
+ */
+public class SharedInitializationLocalSplitterTest {
+
+  @Before
+  public void initialize() {
+    // load necessary classes
+    G.reset();
+    final Options opts = Options.v();
+    opts.set_whole_program(true);
+    final Scene sc = Scene.v();
+    sc.loadNecessaryClasses();
+  }
+
+  @Ignore
+  @Test
+  public void testSingleInitUsedAsBoolAndInt() {
+    // create test method and body
+    final BooleanType tyBool = BooleanType.v();
+    final SootMethod method = new SootMethod("testMethod", Collections.singletonList(tyBool), VoidType.v(), Modifier.PUBLIC);
+    SootClass cl = new SootClass("TestClass", Modifier.PUBLIC);
+    cl.addMethod(method);
+
+    final Jimple jimp = Jimple.v();
+    final JimpleBody body = jimp.newBody(method);
+    method.setActiveBody(body);
+
+    final Scene sc = Scene.v();
+    final SootClass clPrtStrm = sc.loadClassAndSupport("java.io.PrintStream");
+    final SootClass clSystem = sc.loadClassAndSupport("java.lang.System");
+
+    // create locals
+    final Chain<Local> locals = body.getLocals();
+    final Local b = jimp.newLocal("b", UnknownType.v());
+    locals.add(b);
+    final Local s = jimp.newLocal("s", UnknownType.v());
+    locals.add(s);
+    final Local u = jimp.newLocal("u", UnknownType.v());
+    locals.add(u);
+
+    // create code
+    final UnitPatchingChain units = body.getUnits();
+    final Unit tgtRet = jimp.newReturnVoidStmt();
+    final Unit tgtBranch = jimp.newNopStmt();
+    // boolean b = @param0;
+    units.add(jimp.newIdentityStmt(b, jimp.newParameterRef(tyBool, 0)));
+    // java.io.PrintStream s = System.out;
+    units.add(jimp.newAssignStmt(s, jimp.newStaticFieldRef(clSystem.getFieldByName("out").makeRef())));
+    // int u = 0;
+    units.add(jimp.newAssignStmt(u, IntConstant.v(0)));
+    // if(b==0) goto <tgtBranch>
+    units.add(jimp.newIfStmt(jimp.newEqExpr(b, IntConstant.v(0)), tgtBranch));
+    // s.println<boolean>(u);
+    units.add(jimp.newInvokeStmt(jimp.newVirtualInvokeExpr(s, clPrtStrm.getMethod("void println(boolean)").makeRef(), u)));
+    // goto <tgtRet>
+    units.add(jimp.newGotoStmt(tgtRet));
+    // <tgtBranch>: nop
+    units.add(tgtBranch);
+    // s.println<int>(u);
+    units.add(jimp.newInvokeStmt(jimp.newVirtualInvokeExpr(s, clPrtStrm.getMethod("void println(int)").makeRef(), u)));
+    // <tgtRet>: return;
+    units.add(tgtRet);
+
+    // System.out.println("[testSingleInitUsedAsBoolAndInt] before = " + body);
+
+    // execute transform
+    SharedInitializationLocalSplitter.v().transform(body);
+    UnusedLocalEliminator.v().transform(body);
+
+    // System.out.println("[testSingleInitUsedAsBoolAndInt] after = " + body);
+
+    // TODO: how to verify that SharedInitializationLocalSplitter did its job?
+  }
+}