| // Copyright (c) 2016, the R8 project authors. Please see the AUTHORS file | |
| // for details. All rights reserved. Use of this source code is governed by a | |
| // BSD-style license that can be found in the LICENSE file. | |
| package com.android.tools.r8.smali; | |
| import static org.junit.Assert.assertEquals; | |
| import static org.junit.Assert.assertTrue; | |
| import com.android.tools.r8.TestParameters; | |
| import com.android.tools.r8.TestParametersCollection; | |
| import com.android.tools.r8.dex.code.DexConst4; | |
| import com.android.tools.r8.dex.code.DexIfEqz; | |
| import com.android.tools.r8.dex.code.DexIfGez; | |
| import com.android.tools.r8.dex.code.DexIfGtz; | |
| import com.android.tools.r8.dex.code.DexIfLez; | |
| import com.android.tools.r8.dex.code.DexIfLtz; | |
| import com.android.tools.r8.dex.code.DexIfNez; | |
| import com.android.tools.r8.dex.code.DexInvokeVirtual; | |
| import com.android.tools.r8.dex.code.DexReturn; | |
| import com.android.tools.r8.dex.code.DexReturnObject; | |
| import com.android.tools.r8.graph.DexCode; | |
| import com.android.tools.r8.graph.DexEncodedMethod; | |
| import com.android.tools.r8.ir.code.IfType; | |
| import com.google.common.collect.ImmutableList; | |
| import com.google.common.collect.Lists; | |
| import java.util.ArrayList; | |
| import java.util.Collections; | |
| import java.util.List; | |
| import org.junit.Test; | |
| import org.junit.runner.RunWith; | |
| import org.junit.runners.Parameterized; | |
| import org.junit.runners.Parameterized.Parameter; | |
| import org.junit.runners.Parameterized.Parameters; | |
| @RunWith(Parameterized.class) | |
| public class IfSimplificationTest extends SmaliTestBase { | |
| static String[] ifOpcode; | |
| static { | |
| ifOpcode = new String[6]; | |
| ifOpcode[IfType.EQ.ordinal()] = "if-eq"; | |
| ifOpcode[IfType.NE.ordinal()] = "if-ne"; | |
| ifOpcode[IfType.LE.ordinal()] = "if-le"; | |
| ifOpcode[IfType.GE.ordinal()] = "if-ge"; | |
| ifOpcode[IfType.LT.ordinal()] = "if-lt"; | |
| ifOpcode[IfType.GT.ordinal()] = "if-gt"; | |
| } | |
| @Parameter(0) | |
| public TestParameters parameters; | |
| @Parameters(name = "{0}") | |
| public static TestParametersCollection data() { | |
| return getTestParameters().withNoneRuntime().build(); | |
| } | |
| @Test | |
| public void ifZeroNeqZero() { | |
| DexEncodedMethod method = | |
| oneMethodApplication( | |
| "int", | |
| Collections.emptyList(), | |
| 1, | |
| " const v0, 0", | |
| " if-nez v0, :label_2", | |
| ":label_1", | |
| " return v0", | |
| ":label_2", | |
| " const v0, 1", | |
| " goto :label_1"); | |
| DexCode code = method.getCode().asDexCode(); | |
| assertEquals(2, code.instructions.length); | |
| assertTrue(code.instructions[0] instanceof DexConst4); | |
| assertEquals(0, ((DexConst4) code.instructions[0]).B); | |
| assertTrue(code.instructions[1] instanceof DexReturn); | |
| } | |
| @Test | |
| public void ifTwoEqZero() { | |
| DexEncodedMethod method = | |
| oneMethodApplication( | |
| "int", | |
| Collections.emptyList(), | |
| 1, | |
| " const v0, 2", | |
| " if-eqz v0, :label_2", | |
| ":label_1", | |
| " return v0", | |
| ":label_2", | |
| " const v0, 1", | |
| " goto :label_1"); | |
| DexCode code = method.getCode().asDexCode(); | |
| assertEquals(2, code.instructions.length); | |
| assertTrue(code.instructions[0] instanceof DexConst4); | |
| assertEquals(2, ((DexConst4) code.instructions[0]).B); | |
| assertTrue(code.instructions[1] instanceof DexReturn); | |
| } | |
| @Test | |
| public void b() { | |
| DexEncodedMethod method = | |
| oneMethodApplication( | |
| "int", | |
| Collections.singletonList("int"), | |
| 1, | |
| " const v0, 0", | |
| " if-nez v0, :label_2", | |
| ":label_1", | |
| " return v0", | |
| ":label_2", | |
| " if-nez p0, :label_3", | |
| " const v0, 1", | |
| " goto :label_1", | |
| ":label_3", | |
| " const v0, 2", | |
| " goto :label_1"); | |
| DexCode code = method.getCode().asDexCode(); | |
| assertEquals(2, code.instructions.length); | |
| assertTrue(code.instructions[0] instanceof DexConst4); | |
| assertEquals(0, ((DexConst4) code.instructions[0]).B); | |
| assertTrue(code.instructions[1] instanceof DexReturn); | |
| } | |
| @Test | |
| public void c() { | |
| DexEncodedMethod method = | |
| oneMethodApplication( | |
| "int", | |
| Collections.singletonList("int"), | |
| 1, | |
| " const v0, 0", | |
| " if-nez v0, :label_2", | |
| ":label_1", | |
| " return v0", | |
| ":label_2", | |
| " if-nez p0, :label_3", | |
| " const v0, 1", | |
| " goto :label_1", | |
| ":label_3", | |
| " const p0, 0", | |
| " goto :label_2"); | |
| DexCode code = method.getCode().asDexCode(); | |
| assertEquals(2, code.instructions.length); | |
| assertTrue(code.instructions[0] instanceof DexConst4); | |
| assertEquals(0, ((DexConst4) code.instructions[0]).B); | |
| assertTrue(code.instructions[1] instanceof DexReturn); | |
| } | |
| @Test | |
| public void d() { | |
| DexEncodedMethod method = | |
| oneMethodApplication( | |
| "int", | |
| Collections.singletonList("int"), | |
| 1, | |
| " const v0, 0", | |
| " if-nez v0, :label_2", | |
| ":label_1", | |
| " return v0", | |
| ":label_2", | |
| " if-nez p0, :label_3", | |
| " const v0, 1", | |
| " goto :label_4", | |
| ":label_3", | |
| " const p0, 0", | |
| " goto :label_2", | |
| ":label_4", | |
| " if-nez p0, :label_5", | |
| " const v0, 1", | |
| " goto :label_4", | |
| ":label_5", | |
| " const p0, 0", | |
| " goto :label_2"); | |
| DexCode code = method.getCode().asDexCode(); | |
| assertEquals(2, code.instructions.length); | |
| assertTrue(code.instructions[0] instanceof DexConst4); | |
| assertEquals(0, ((DexConst4) code.instructions[0]).B); | |
| assertTrue(code.instructions[1] instanceof DexReturn); | |
| } | |
| @Test | |
| public void e() { | |
| DexEncodedMethod method = | |
| oneMethodApplication( | |
| "int", | |
| ImmutableList.of("int", "int", "int"), | |
| 1, | |
| " const v0, 0", | |
| " if-nez v0, :x", | |
| " const v0, 1", | |
| " if-nez p0, :x", | |
| " const v0, 2", | |
| " if-nez p1, :x", | |
| " const v0, 3", | |
| " if-nez p2, :return", | |
| " const v0, 4", | |
| " goto :return", | |
| ":x", | |
| " add-int v0, v0, p0", | |
| ":return", | |
| " return v0"); | |
| DexCode code = method.getCode().asDexCode(); | |
| assertEquals(12, code.instructions.length); | |
| assertTrue(code.instructions[11] instanceof DexReturn); | |
| } | |
| @Test | |
| public void f() { | |
| DexEncodedMethod method = | |
| oneMethodApplication( | |
| "int", | |
| Collections.singletonList("int"), | |
| 1, | |
| " const v0, 0", | |
| " if-nez v0, :label_2", | |
| ":label_1", | |
| " return v0", | |
| ":label_2", | |
| " const v0, 1", | |
| " goto :label_2"); | |
| DexCode code = method.getCode().asDexCode(); | |
| assertEquals(2, code.instructions.length); | |
| assertTrue(code.instructions[0] instanceof DexConst4); | |
| assertEquals(0, ((DexConst4) code.instructions[0]).B); | |
| assertTrue(code.instructions[1] instanceof DexReturn); | |
| } | |
| @Test | |
| public void simplifyNonZeroTests() { | |
| class TestData { | |
| final int a; | |
| final int b; | |
| final boolean results[]; | |
| TestData(int a, int b) { | |
| this.a = a; | |
| this.b = b; | |
| results = new boolean[6]; | |
| results[IfType.EQ.ordinal()] = a == b; | |
| results[IfType.NE.ordinal()] = a != b; | |
| results[IfType.LE.ordinal()] = a <= b; | |
| results[IfType.GE.ordinal()] = a >= b; | |
| results[IfType.LT.ordinal()] = a < b; | |
| results[IfType.GT.ordinal()] = a > b; | |
| } | |
| } | |
| int[] testValues = new int[] {100, 1, 0, -1, 100}; | |
| List<TestData> tests = new ArrayList<>(); | |
| for (int i = 0; i < testValues.length; i++) { | |
| for (int j = 0; j < testValues.length; j++) { | |
| tests.add(new TestData(testValues[i], testValues[j])); | |
| } | |
| } | |
| for (TestData test : tests) { | |
| for (IfType type : IfType.values()) { | |
| DexEncodedMethod method = | |
| oneMethodApplication( | |
| "int", | |
| Collections.singletonList("int"), | |
| 2, | |
| " const v0, 0x" + Integer.toHexString(test.a), | |
| " const v1, 0x" + Integer.toHexString(test.b), | |
| " " + ifOpcode[type.ordinal()] + " v0, v1, :label_2", | |
| " const v0, 0", | |
| ":label_1", | |
| " return v0", | |
| ":label_2", | |
| " const v0, 1", | |
| " goto :label_1"); | |
| DexCode code = method.getCode().asDexCode(); | |
| assertEquals(2, code.instructions.length); | |
| assertTrue(code.instructions[0] instanceof DexConst4); | |
| int expected = test.results[type.ordinal()] ? 1 : 0; | |
| assertEquals(expected, ((DexConst4) code.instructions[0]).B); | |
| assertTrue(code.instructions[1] instanceof DexReturn); | |
| } | |
| } | |
| } | |
| public void runRewriteIfWithConstZeroTest(IfType type, boolean zeroLeft, Class expected) { | |
| String ifInstruction; | |
| if (zeroLeft) { | |
| ifInstruction = " " + ifOpcode[type.ordinal()] + " v0, v1, :label_2"; | |
| } else { | |
| ifInstruction = " " + ifOpcode[type.ordinal()] + " v1, v0, :label_2"; | |
| } | |
| DexEncodedMethod method = | |
| oneMethodApplication( | |
| "int", | |
| Collections.singletonList("int"), | |
| 1, | |
| " const v0, 0x00", | |
| ifInstruction, | |
| " const v0, 0", | |
| ":label_1", | |
| " return v0", | |
| ":label_2", | |
| " const v0, 2", | |
| " goto :label_1"); | |
| DexCode code = method.getCode().asDexCode(); | |
| assertEquals(5, code.instructions.length); | |
| assertTrue(expected.isInstance(code.instructions[0])); | |
| assertTrue(code.instructions[4] instanceof DexReturn); | |
| } | |
| @Test | |
| public void testRewriteIfWithConstZero() { | |
| runRewriteIfWithConstZeroTest(IfType.EQ, true, DexIfEqz.class); | |
| runRewriteIfWithConstZeroTest(IfType.NE, true, DexIfNez.class); | |
| runRewriteIfWithConstZeroTest(IfType.LE, true, DexIfGez.class); | |
| runRewriteIfWithConstZeroTest(IfType.GE, true, DexIfLez.class); | |
| runRewriteIfWithConstZeroTest(IfType.LT, true, DexIfGtz.class); | |
| runRewriteIfWithConstZeroTest(IfType.GT, true, DexIfLtz.class); | |
| runRewriteIfWithConstZeroTest(IfType.EQ, false, DexIfEqz.class); | |
| runRewriteIfWithConstZeroTest(IfType.NE, false, DexIfNez.class); | |
| runRewriteIfWithConstZeroTest(IfType.LE, false, DexIfLez.class); | |
| runRewriteIfWithConstZeroTest(IfType.GE, false, DexIfGez.class); | |
| runRewriteIfWithConstZeroTest(IfType.LT, false, DexIfLtz.class); | |
| runRewriteIfWithConstZeroTest(IfType.GT, false, DexIfGtz.class); | |
| } | |
| @Test | |
| public void x() { | |
| DexEncodedMethod method = | |
| oneMethodApplication( | |
| "Test", | |
| Lists.newArrayList( | |
| "Test", | |
| "java.lang.String[]", | |
| "java.lang.String", | |
| "java.lang.String[]", | |
| "java.lang.String"), | |
| 10, | |
| " const/4 v4, 0x00 # 0", | |
| " invoke-virtual { v10 }, LTest;->a()LTest;", | |
| " if-nez v4, :label_8", | |
| " move-object v0, v4", | |
| " :label_7", | |
| " return-object v0", | |
| " :label_8", | |
| " invoke-static { v14 }, LTest;->a([Ljava/lang/String;)LTest;", | |
| " move-result-object v2", | |
| " invoke-virtual { v2 }, LTest;->a()Z", | |
| " move-result v0", | |
| " if-nez v0, :label_20", | |
| " move-object v0, v4", | |
| " goto :label_7", | |
| " :label_20", | |
| " iget-wide v0, v2, LTest;->a:J", | |
| " iget-wide v6, v2, LTest;->b:J", | |
| " invoke-virtual { v2 }, LTest;->c()Z", | |
| " move-result v2", | |
| " if-eqz v2, :label_33", | |
| " invoke-virtual { v4 }, LTest;->a()V", | |
| " :label_33", | |
| " new-instance v5, LTest;", | |
| " sget-object v2, LTest;->a:[Ljava/lang/String;", | |
| " invoke-direct { v5, v2 }, LTest;-><init>([Ljava/lang/String;)V", | |
| " invoke-virtual { v10 }, LTest;->a()LTest;", | |
| " invoke-virtual { v4, v0, v1, v6, v7 }, LTest;->a(JJ)Ljava/util/List;", | |
| " move-result-object v2", | |
| " invoke-interface { v2 }," | |
| + " Ljava/util/List;->iterator()Ljava/util/Iterator;", | |
| " move-result-object v6", | |
| " move-wide v2, v0", | |
| " :label_52", | |
| " invoke-interface { v6 }, Ljava/util/Iterator;->hasNext()Z", | |
| " move-result v0", | |
| " if-eqz v0, :label_107", | |
| " invoke-interface { v6 }, Ljava/util/Iterator;->next()Ljava/lang/Object;", | |
| " move-result-object v0", | |
| " check-cast v0, LTest;", | |
| " const-wide/16 v8, 0x0000000000000001 # 1", | |
| " add-long/2addr v2, v8", | |
| " invoke-virtual { v5 }, LTest;->newRow()LTest;", | |
| " move-result-object v1", | |
| " invoke-static { v2, v3 }," | |
| + " Ljava/lang/Long;->valueOf(J)Ljava/lang/Long;", | |
| " move-result-object v7", | |
| " invoke-virtual { v1, v7 }, LTest;->a(Ljava/lang/Object;)LTest;", | |
| " move-result-object v1", | |
| " const-string v7, \"add\"", | |
| " invoke-virtual { v1, v7 }, LTest;->a(Ljava/lang/Object;)LTest;", | |
| " move-result-object v1", | |
| " iget-object v7, v0, LTest;->a:Ljava/lang/String;", | |
| " invoke-virtual { v1, v7 }, LTest;->a(Ljava/lang/Object;)LTest;", | |
| " move-result-object v1", | |
| " iget v7, v0, LTest;->b:I", | |
| " invoke-static { v7 }," | |
| + " Ljava/lang/Integer;->valueOf(I)Ljava/lang/Integer;", | |
| " move-result-object v7", | |
| " invoke-virtual { v1, v7 }, LTest;->add(Ljava/lang/Object;)LTest;", | |
| " move-result-object v1", | |
| " iget-object v0, v0, LTest;->a:Ljava/lang/String;", | |
| " invoke-virtual { v1, v0 }, LTest;->add(Ljava/lang/Object;)LTest;", | |
| " goto :label_52", | |
| " :label_107", | |
| " iget-object v0, v4, LTest;->a:LTest;", | |
| " const-string v1, \"text 1\"", | |
| " const/4 v2, 0x00 # 0", | |
| " invoke-virtual { v0, v1, v2 }, LTest;->a(Ljava/lang/String;I)LTest;", | |
| " move-result-object v0", | |
| " const-string v1, \"text 2\"", | |
| " const-string v2, \"\"", | |
| " invoke-interface { v0, v1, v2 }," | |
| + " LTest;->getString(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;", | |
| " move-result-object v0", | |
| " invoke-static { v5, v0 }, LTest;->a(LTest;Ljava/lang/String;)LTest;", | |
| " move-result-object v0", | |
| " goto :label_7"); | |
| DexCode code = method.getCode().asDexCode(); | |
| assertEquals(3, code.instructions.length); | |
| assertTrue(code.instructions[0] instanceof DexInvokeVirtual); | |
| assertTrue(code.instructions[1] instanceof DexConst4); | |
| assertEquals(0, ((DexConst4) code.instructions[1]).B); | |
| assertTrue(code.instructions[2] instanceof DexReturnObject); | |
| } | |
| @Test | |
| public void y() { | |
| DexEncodedMethod method = | |
| oneMethodApplication( | |
| "boolean", | |
| Lists.newArrayList("Test", "java.lang.Object"), | |
| 6, | |
| " const-wide/16 v4, 0x0000000000000000L # 0", | |
| " const/4 v0, 0x01 # 1", | |
| " const/4 v3, 0x00 # 0", | |
| " const/4 v1, 0x00 # 0", | |
| " if-ne v6, v7, :label_8", | |
| " :label_7", | |
| " return v0", | |
| " :label_8", | |
| " if-nez v7, :label_12", | |
| " move v0, v1", | |
| " goto :label_7", | |
| " :label_12", | |
| " instance-of v2, v7, LTest;", | |
| " if-nez v2, :label_18", | |
| " move v0, v1", | |
| " goto :label_7", | |
| " :label_18", | |
| " check-cast v7, LTest;", | |
| " cmp-long v2, v4, v4", | |
| " if-nez v2, :label_50", | |
| " invoke-static { v3, v3 }," | |
| + " LTest;->a(Ljava/lang/Object;Ljava/lang/Object;)Z", | |
| " move-result v2", | |
| " if-eqz v2, :label_50", | |
| " invoke-static { v3, v3 }," | |
| + " LTest;->a(Ljava/lang/Object;Ljava/lang/Object;)Z", | |
| " move-result v2", | |
| " if-eqz v2, :label_50", | |
| " invoke-static { v1 }, Ljava/lang/Integer;->valueOf(I)Ljava/lang/Integer;", | |
| " move-result-object v2", | |
| " invoke-static { v1 }, Ljava/lang/Integer;->valueOf(I)Ljava/lang/Integer;", | |
| " move-result-object v3", | |
| " invoke-static { v2, v3 }," | |
| + " LTest;->a(Ljava/lang/Object;Ljava/lang/Object;)Z", | |
| " move-result v2", | |
| " if-nez v2, :label_7", | |
| " :label_50", | |
| " move v0, v1", | |
| " goto :label_7"); | |
| assertEquals(20, method.getCode().asDexCode().getInstructions().length); | |
| } | |
| } |