# Copyright (C) 2017 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. .class public LSmaliTests; .super Ljava/lang/Object; # # Test transformation of Not/Not/And into Or/Not. # ## CHECK-START: int SmaliTests.$opt$noinline$andToOr(int, int) instruction_simplifier (before) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<Not1:i\d+>> Not [<<P1>>] ## CHECK-DAG: <<Not2:i\d+>> Not [<<P2>>] ## CHECK-DAG: <<And:i\d+>> And [<<Not1>>,<<Not2>>] ## CHECK-DAG: Return [<<And>>] ## CHECK-START: int SmaliTests.$opt$noinline$andToOr(int, int) instruction_simplifier (after) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<Or:i\d+>> Or [<<P1>>,<<P2>>] ## CHECK-DAG: <<Not:i\d+>> Not [<<Or>>] ## CHECK-DAG: Return [<<Not>>] ## CHECK-START: int SmaliTests.$opt$noinline$andToOr(int, int) instruction_simplifier (after) ## CHECK-DAG: Not ## CHECK-NOT: Not ## CHECK-START: int SmaliTests.$opt$noinline$andToOr(int, int) instruction_simplifier (after) ## CHECK-NOT: And .method public static $opt$noinline$andToOr(II)I .registers 4 .param p0, "a" # I .param p1, "b" # I .prologue sget-boolean v0, LSmaliTests;->doThrow:Z if-eqz v0, :cond_a new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 :cond_a # return ~a & ~b; not-int v0, p0 not-int v1, p1 and-int/2addr v0, v1 return v0 .end method # Test transformation of Not/Not/And into Or/Not for boolean negations. # Note that the graph before this instruction simplification pass does not # contain `HBooleanNot` instructions. This is because this transformation # follows the optimization of `HSelect` to `HBooleanNot` occurring in the # same pass. ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier (before) ## CHECK-DAG: <<P1:z\d+>> ParameterValue ## CHECK-DAG: <<P2:z\d+>> ParameterValue ## CHECK-DAG: <<Const1:i\d+>> IntConstant 1 ## CHECK-DAG: <<NotP1:i\d+>> Xor [<<P1>>,<<Const1>>] ## CHECK-DAG: <<NotP2:i\d+>> Xor [<<P2>>,<<Const1>>] ## CHECK-DAG: <<And:i\d+>> And [<<NotP1>>,<<NotP2>>] ## CHECK-DAG: Return [<<And>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier (after) ## CHECK-DAG: <<Cond1:z\d+>> ParameterValue ## CHECK-DAG: <<Cond2:z\d+>> ParameterValue ## CHECK-DAG: <<Or:i\d+>> Or [<<Cond1>>,<<Cond2>>] ## CHECK-DAG: <<BooleanNot:z\d+>> BooleanNot [<<Or>>] ## CHECK-DAG: Return [<<BooleanNot>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_bce (after) ## CHECK-DAG: BooleanNot ## CHECK-NOT: BooleanNot ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOr(boolean, boolean) instruction_simplifier$after_bce (after) ## CHECK-NOT: And .method public static $opt$noinline$booleanAndToOr(ZZ)Z .registers 4 .param p0, "a" # Z .param p1, "b" # Z .prologue sget-boolean v0, LSmaliTests;->doThrow:Z if-eqz v0, :cond_a new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 :cond_a # return !a & !b; xor-int/lit8 v0, p0, 0x1 xor-int/lit8 v1, p1, 0x1 and-int/2addr v0, v1 return v0 .end method # Test transformation of Not/Not/Or into And/Not. ## CHECK-START: long SmaliTests.$opt$noinline$orToAnd(long, long) instruction_simplifier (before) ## CHECK-DAG: <<P1:j\d+>> ParameterValue ## CHECK-DAG: <<P2:j\d+>> ParameterValue ## CHECK-DAG: <<Not1:j\d+>> Not [<<P1>>] ## CHECK-DAG: <<Not2:j\d+>> Not [<<P2>>] ## CHECK-DAG: <<Or:j\d+>> Or [<<Not1>>,<<Not2>>] ## CHECK-DAG: Return [<<Or>>] ## CHECK-START: long SmaliTests.$opt$noinline$orToAnd(long, long) instruction_simplifier (after) ## CHECK-DAG: <<P1:j\d+>> ParameterValue ## CHECK-DAG: <<P2:j\d+>> ParameterValue ## CHECK-DAG: <<And:j\d+>> And [<<P1>>,<<P2>>] ## CHECK-DAG: <<Not:j\d+>> Not [<<And>>] ## CHECK-DAG: Return [<<Not>>] ## CHECK-START: long SmaliTests.$opt$noinline$orToAnd(long, long) instruction_simplifier (after) ## CHECK-DAG: Not ## CHECK-NOT: Not ## CHECK-START: long SmaliTests.$opt$noinline$orToAnd(long, long) instruction_simplifier (after) ## CHECK-NOT: Or .method public static $opt$noinline$orToAnd(JJ)J .registers 8 .param p0, "a" # J .param p2, "b" # J .prologue sget-boolean v0, LSmaliTests;->doThrow:Z if-eqz v0, :cond_a new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 :cond_a # return ~a | ~b; not-long v0, p0 not-long v2, p2 or-long/2addr v0, v2 return-wide v0 .end method # Test transformation of Not/Not/Or into Or/And for boolean negations. # Note that the graph before this instruction simplification pass does not # contain `HBooleanNot` instructions. This is because this transformation # follows the optimization of `HSelect` to `HBooleanNot` occurring in the # same pass. ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier (before) ## CHECK-DAG: <<P1:z\d+>> ParameterValue ## CHECK-DAG: <<P2:z\d+>> ParameterValue ## CHECK-DAG: <<Const1:i\d+>> IntConstant 1 ## CHECK-DAG: <<NotP1:i\d+>> Xor [<<P1>>,<<Const1>>] ## CHECK-DAG: <<NotP2:i\d+>> Xor [<<P2>>,<<Const1>>] ## CHECK-DAG: <<Or:i\d+>> Or [<<NotP1>>,<<NotP2>>] ## CHECK-DAG: Return [<<Or>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier (after) ## CHECK-DAG: <<Cond1:z\d+>> ParameterValue ## CHECK-DAG: <<Cond2:z\d+>> ParameterValue ## CHECK-DAG: <<And:i\d+>> And [<<Cond1>>,<<Cond2>>] ## CHECK-DAG: <<BooleanNot:z\d+>> BooleanNot [<<And>>] ## CHECK-DAG: Return [<<BooleanNot>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_bce (after) ## CHECK-DAG: BooleanNot ## CHECK-NOT: BooleanNot ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAnd(boolean, boolean) instruction_simplifier$after_bce (after) ## CHECK-NOT: Or .method public static $opt$noinline$booleanOrToAnd(ZZ)Z .registers 4 .param p0, "a" # Z .param p1, "b" # Z .prologue sget-boolean v0, LSmaliTests;->doThrow:Z if-eqz v0, :cond_a new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 :cond_a # return !a | !b; xor-int/lit8 v0, p0, 0x1 xor-int/lit8 v1, p1, 0x1 or-int/2addr v0, v1 return v0 .end method # Test that the transformation copes with inputs being separated from the # bitwise operations. # This is a regression test. The initial logic was inserting the new bitwise # operation incorrectly. ## CHECK-START: int SmaliTests.$opt$noinline$regressInputsAway(int, int) instruction_simplifier (before) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1 ## CHECK-DAG: <<AddP1:i\d+>> Add [<<P1>>,<<Cst1>>] ## CHECK-DAG: <<Not1:i\d+>> Not [<<AddP1>>] ## CHECK-DAG: <<AddP2:i\d+>> Add [<<P2>>,<<Cst1>>] ## CHECK-DAG: <<Not2:i\d+>> Not [<<AddP2>>] ## CHECK-DAG: <<Or:i\d+>> Or [<<Not1>>,<<Not2>>] ## CHECK-DAG: Return [<<Or>>] ## CHECK-START: int SmaliTests.$opt$noinline$regressInputsAway(int, int) instruction_simplifier (after) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1 ## CHECK-DAG: <<AddP1:i\d+>> Add [<<P1>>,<<Cst1>>] ## CHECK-DAG: <<AddP2:i\d+>> Add [<<P2>>,<<Cst1>>] ## CHECK-DAG: <<And:i\d+>> And [<<AddP1>>,<<AddP2>>] ## CHECK-DAG: <<Not:i\d+>> Not [<<And>>] ## CHECK-DAG: Return [<<Not>>] ## CHECK-START: int SmaliTests.$opt$noinline$regressInputsAway(int, int) instruction_simplifier (after) ## CHECK-DAG: Not ## CHECK-NOT: Not ## CHECK-START: int SmaliTests.$opt$noinline$regressInputsAway(int, int) instruction_simplifier (after) ## CHECK-NOT: Or .method public static $opt$noinline$regressInputsAway(II)I .registers 7 .param p0, "a" # I .param p1, "b" # I .prologue sget-boolean v4, LSmaliTests;->doThrow:Z if-eqz v4, :cond_a new-instance v4, Ljava/lang/Error; invoke-direct {v4}, Ljava/lang/Error;-><init>()V throw v4 :cond_a # int a1 = a + 1; add-int/lit8 v0, p0, 0x1 # int not_a1 = ~a1; not-int v2, v0 # int b1 = b + 1; add-int/lit8 v1, p1, 0x1 # int not_b1 = ~b1; not-int v3, v1 # return not_a1 | not_b1 or-int v4, v2, v3 return v4 .end method # Test transformation of Not/Not/Xor into Xor. # See first note above. ## CHECK-START: int SmaliTests.$opt$noinline$notXorToXor(int, int) instruction_simplifier (before) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<Not1:i\d+>> Not [<<P1>>] ## CHECK-DAG: <<Not2:i\d+>> Not [<<P2>>] ## CHECK-DAG: <<Xor:i\d+>> Xor [<<Not1>>,<<Not2>>] ## CHECK-DAG: Return [<<Xor>>] ## CHECK-START: int SmaliTests.$opt$noinline$notXorToXor(int, int) instruction_simplifier (after) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<Xor:i\d+>> Xor [<<P1>>,<<P2>>] ## CHECK-DAG: Return [<<Xor>>] ## CHECK-START: int SmaliTests.$opt$noinline$notXorToXor(int, int) instruction_simplifier (after) ## CHECK-NOT: Not .method public static $opt$noinline$notXorToXor(II)I .registers 4 .param p0, "a" # I .param p1, "b" # I .prologue sget-boolean v0, LSmaliTests;->doThrow:Z if-eqz v0, :cond_a new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 :cond_a # return ~a ^ ~b; not-int v0, p0 not-int v1, p1 xor-int/2addr v0, v1 return v0 .end method # Test transformation of Not/Not/Xor into Xor for boolean negations. # Note that the graph before this instruction simplification pass does not # contain `HBooleanNot` instructions. This is because this transformation # follows the optimization of `HSelect` to `HBooleanNot` occurring in the # same pass. ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier (before) ## CHECK-DAG: <<P1:z\d+>> ParameterValue ## CHECK-DAG: <<P2:z\d+>> ParameterValue ## CHECK-DAG: <<Const1:i\d+>> IntConstant 1 ## CHECK-DAG: <<NotP1:i\d+>> Xor [<<P1>>,<<Const1>>] ## CHECK-DAG: <<NotP2:i\d+>> Xor [<<P2>>,<<Const1>>] ## CHECK-DAG: <<Xor:i\d+>> Xor [<<NotP1>>,<<NotP2>>] ## CHECK-DAG: Return [<<Xor>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier (after) ## CHECK-DAG: <<Cond1:z\d+>> ParameterValue ## CHECK-DAG: <<Cond2:z\d+>> ParameterValue ## CHECK-DAG: <<Xor:i\d+>> Xor [<<Cond1>>,<<Cond2>>] ## CHECK-DAG: Return [<<Xor>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanNotXorToXor(boolean, boolean) instruction_simplifier$after_bce (after) ## CHECK-NOT: BooleanNot .method public static $opt$noinline$booleanNotXorToXor(ZZ)Z .registers 4 .param p0, "a" # Z .param p1, "b" # Z .prologue sget-boolean v0, LSmaliTests;->doThrow:Z if-eqz v0, :cond_a new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 :cond_a # return !a ^ !b; xor-int/lit8 v0, p0, 0x1 xor-int/lit8 v1, p1, 0x1 xor-int/2addr v0, v1 return v0 .end method # Check that no transformation is done when one Not has multiple uses. ## CHECK-START: int SmaliTests.$opt$noinline$notMultipleUses(int, int) instruction_simplifier (before) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<One:i\d+>> IntConstant 1 ## CHECK-DAG: <<Not2:i\d+>> Not [<<P2>>] ## CHECK-DAG: <<And2:i\d+>> And [<<Not2>>,<<One>>] ## CHECK-DAG: <<Not1:i\d+>> Not [<<P1>>] ## CHECK-DAG: <<And1:i\d+>> And [<<Not1>>,<<Not2>>] ## CHECK-DAG: <<Add:i\d+>> Add [<<And2>>,<<And1>>] ## CHECK-DAG: Return [<<Add>>] ## CHECK-START: int SmaliTests.$opt$noinline$notMultipleUses(int, int) instruction_simplifier (after) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<One:i\d+>> IntConstant 1 ## CHECK-DAG: <<Not2:i\d+>> Not [<<P2>>] ## CHECK-DAG: <<And2:i\d+>> And [<<Not2>>,<<One>>] ## CHECK-DAG: <<Not1:i\d+>> Not [<<P1>>] ## CHECK-DAG: <<And1:i\d+>> And [<<Not1>>,<<Not2>>] ## CHECK-DAG: <<Add:i\d+>> Add [<<And2>>,<<And1>>] ## CHECK-DAG: Return [<<Add>>] ## CHECK-START: int SmaliTests.$opt$noinline$notMultipleUses(int, int) instruction_simplifier (after) ## CHECK-NOT: Or .method public static $opt$noinline$notMultipleUses(II)I .registers 5 .param p0, "a" # I .param p1, "b" # I .prologue sget-boolean v1, LSmaliTests;->doThrow:Z if-eqz v1, :cond_a new-instance v1, Ljava/lang/Error; invoke-direct {v1}, Ljava/lang/Error;-><init>()V throw v1 :cond_a # int tmp = ~b; not-int v0, p1 # return (tmp & 0x1) + (~a & tmp); and-int/lit8 v1, v0, 0x1 not-int v2, p0 and-int/2addr v2, v0 add-int/2addr v1, v2 return v1 .end method # static fields .field static doThrow:Z # boolean # direct methods .method static constructor <clinit>()V .registers 1 .prologue # doThrow = false const/4 v0, 0x0 sput-boolean v0, LSmaliTests;->doThrow:Z return-void .end method # Test transformation of Not/Not/And into Or/Not. # Note: before the instruction_simplifier pass, Xor's are used instead of # Not's (the simplification happens during the same pass). ## CHECK-START: int SmaliTests.$opt$noinline$andToOrV2(int, int) instruction_simplifier (before) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<CstM1:i\d+>> IntConstant -1 ## CHECK-DAG: <<Not1:i\d+>> Xor [<<P1>>,<<CstM1>>] ## CHECK-DAG: <<Not2:i\d+>> Xor [<<P2>>,<<CstM1>>] ## CHECK-DAG: <<And:i\d+>> And [<<Not1>>,<<Not2>>] ## CHECK-DAG: Return [<<And>>] ## CHECK-START: int SmaliTests.$opt$noinline$andToOrV2(int, int) instruction_simplifier (after) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<Or:i\d+>> Or [<<P1>>,<<P2>>] ## CHECK-DAG: <<Not:i\d+>> Not [<<Or>>] ## CHECK-DAG: Return [<<Not>>] ## CHECK-START: int SmaliTests.$opt$noinline$andToOrV2(int, int) instruction_simplifier (after) ## CHECK-DAG: Not ## CHECK-NOT: Not ## CHECK-START: int SmaliTests.$opt$noinline$andToOrV2(int, int) instruction_simplifier (after) ## CHECK-NOT: And # Original java source: # # public static int $opt$noinline$andToOr(int a, int b) { # if (doThrow) throw new Error(); # return ~a & ~b; # } .method public static $opt$noinline$andToOrV2(II)I .registers 4 .param p0, "a" # I .param p1, "b" # I .prologue .line 85 sget-boolean v0, LMain;->doThrow:Z if-eqz v0, :cond_a new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 .line 86 :cond_a xor-int/lit8 v0, p0, -0x1 xor-int/lit8 v1, p1, -0x1 and-int/2addr v0, v1 return v0 .end method # Test transformation of Not/Not/And into Or/Not for boolean negations. # Note that the graph before this instruction simplification pass does not # contain `HBooleanNot` instructions. This is because this transformation # follows the optimization of `HSelect` to `HBooleanNot` occurring in the # same pass. ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOrV2(boolean, boolean) instruction_simplifier$after_gvn (before) ## CHECK-DAG: <<P1:z\d+>> ParameterValue ## CHECK-DAG: <<P2:z\d+>> ParameterValue ## CHECK-DAG: <<Const0:i\d+>> IntConstant 0 ## CHECK-DAG: <<Const1:i\d+>> IntConstant 1 ## CHECK-DAG: <<Select1:i\d+>> Select [<<Const1>>,<<Const0>>,<<P1>>] ## CHECK-DAG: <<Select2:i\d+>> Select [<<Const1>>,<<Const0>>,<<P2>>] ## CHECK-DAG: <<And:i\d+>> And [<<Select1>>,<<Select2>>] ## CHECK-DAG: Return [<<And>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOrV2(boolean, boolean) instruction_simplifier$after_gvn (after) ## CHECK-DAG: <<Cond1:z\d+>> ParameterValue ## CHECK-DAG: <<Cond2:z\d+>> ParameterValue ## CHECK-DAG: <<Or:i\d+>> Or [<<Cond1>>,<<Cond2>>] ## CHECK-DAG: <<BooleanNot:z\d+>> BooleanNot [<<Or>>] ## CHECK-DAG: Return [<<BooleanNot>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOrV2(boolean, boolean) instruction_simplifier$after_bce (after) ## CHECK-DAG: BooleanNot ## CHECK-NOT: BooleanNot ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanAndToOrV2(boolean, boolean) instruction_simplifier$after_bce (after) ## CHECK-NOT: And # Original java source: # # public static boolean $opt$noinline$booleanAndToOr(boolean a, boolean b) { # if (doThrow) throw new Error(); # return !a & !b; # } .method public static $opt$noinline$booleanAndToOrV2(ZZ)Z .registers 5 .param p0, "a" # Z .param p1, "b" # Z .prologue const/4 v0, 0x1 const/4 v1, 0x0 .line 122 sget-boolean v2, LMain;->doThrow:Z if-eqz v2, :cond_c new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 .line 123 :cond_c if-nez p0, :cond_13 move v2, v0 :goto_f if-nez p1, :cond_15 :goto_11 and-int/2addr v0, v2 return v0 :cond_13 move v2, v1 goto :goto_f :cond_15 move v0, v1 goto :goto_11 .end method # Test transformation of Not/Not/Or into And/Not. # See note above. # The second Xor has its arguments reversed for no obvious reason. ## CHECK-START: long SmaliTests.$opt$noinline$orToAndV2(long, long) instruction_simplifier (before) ## CHECK-DAG: <<P1:j\d+>> ParameterValue ## CHECK-DAG: <<P2:j\d+>> ParameterValue ## CHECK-DAG: <<CstM1:j\d+>> LongConstant -1 ## CHECK-DAG: <<Not1:j\d+>> Xor [<<P1>>,<<CstM1>>] ## CHECK-DAG: <<Not2:j\d+>> Xor [<<CstM1>>,<<P2>>] ## CHECK-DAG: <<Or:j\d+>> Or [<<Not1>>,<<Not2>>] ## CHECK-DAG: Return [<<Or>>] ## CHECK-START: long SmaliTests.$opt$noinline$orToAndV2(long, long) instruction_simplifier (after) ## CHECK-DAG: <<P1:j\d+>> ParameterValue ## CHECK-DAG: <<P2:j\d+>> ParameterValue ## CHECK-DAG: <<And:j\d+>> And [<<P1>>,<<P2>>] ## CHECK-DAG: <<Not:j\d+>> Not [<<And>>] ## CHECK-DAG: Return [<<Not>>] ## CHECK-START: long SmaliTests.$opt$noinline$orToAndV2(long, long) instruction_simplifier (after) ## CHECK-DAG: Not ## CHECK-NOT: Not ## CHECK-START: long SmaliTests.$opt$noinline$orToAndV2(long, long) instruction_simplifier (after) ## CHECK-NOT: Or # Original java source: # # public static long $opt$noinline$orToAnd(long a, long b) { # if (doThrow) throw new Error(); # return ~a | ~b; # } .method public static $opt$noinline$orToAndV2(JJ)J .registers 8 .param p0, "a" # J .param p2, "b" # J .prologue const-wide/16 v2, -0x1 .line 156 sget-boolean v0, LMain;->doThrow:Z if-eqz v0, :cond_c new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 .line 157 :cond_c xor-long v0, p0, v2 xor-long/2addr v2, p2 or-long/2addr v0, v2 return-wide v0 .end method # Test transformation of Not/Not/Or into Or/And for boolean negations. # Note that the graph before this instruction simplification pass does not # contain `HBooleanNot` instructions. This is because this transformation # follows the optimization of `HSelect` to `HBooleanNot` occurring in the # same pass. ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAndV2(boolean, boolean) instruction_simplifier$after_gvn (before) ## CHECK-DAG: <<P1:z\d+>> ParameterValue ## CHECK-DAG: <<P2:z\d+>> ParameterValue ## CHECK-DAG: <<Const0:i\d+>> IntConstant 0 ## CHECK-DAG: <<Const1:i\d+>> IntConstant 1 ## CHECK-DAG: <<Select1:i\d+>> Select [<<Const1>>,<<Const0>>,<<P1>>] ## CHECK-DAG: <<Select2:i\d+>> Select [<<Const1>>,<<Const0>>,<<P2>>] ## CHECK-DAG: <<Or:i\d+>> Or [<<Select1>>,<<Select2>>] ## CHECK-DAG: Return [<<Or>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAndV2(boolean, boolean) instruction_simplifier$after_gvn (after) ## CHECK-DAG: <<Cond1:z\d+>> ParameterValue ## CHECK-DAG: <<Cond2:z\d+>> ParameterValue ## CHECK-DAG: <<And:i\d+>> And [<<Cond1>>,<<Cond2>>] ## CHECK-DAG: <<BooleanNot:z\d+>> BooleanNot [<<And>>] ## CHECK-DAG: Return [<<BooleanNot>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAndV2(boolean, boolean) instruction_simplifier$after_bce (after) ## CHECK-DAG: BooleanNot ## CHECK-NOT: BooleanNot ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanOrToAndV2(boolean, boolean) instruction_simplifier$after_bce (after) ## CHECK-NOT: Or # Original java source: # # public static boolean $opt$noinline$booleanOrToAnd(boolean a, boolean b) { # if (doThrow) throw new Error(); # return !a | !b; # } .method public static $opt$noinline$booleanOrToAndV2(ZZ)Z .registers 5 .param p0, "a" # Z .param p1, "b" # Z .prologue const/4 v0, 0x1 const/4 v1, 0x0 .line 193 sget-boolean v2, LMain;->doThrow:Z if-eqz v2, :cond_c new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 .line 194 :cond_c if-nez p0, :cond_13 move v2, v0 :goto_f if-nez p1, :cond_15 :goto_11 or-int/2addr v0, v2 return v0 :cond_13 move v2, v1 goto :goto_f :cond_15 move v0, v1 goto :goto_11 .end method # Test that the transformation copes with inputs being separated from the # bitwise operations. # This is a regression test. The initial logic was inserting the new bitwise # operation incorrectly. ## CHECK-START: int SmaliTests.$opt$noinline$regressInputsAwayV2(int, int) instruction_simplifier (before) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1 ## CHECK-DAG: <<CstM1:i\d+>> IntConstant -1 ## CHECK-DAG: <<AddP1:i\d+>> Add [<<P1>>,<<Cst1>>] ## CHECK-DAG: <<Not1:i\d+>> Xor [<<AddP1>>,<<CstM1>>] ## CHECK-DAG: <<AddP2:i\d+>> Add [<<P2>>,<<Cst1>>] ## CHECK-DAG: <<Not2:i\d+>> Xor [<<AddP2>>,<<CstM1>>] ## CHECK-DAG: <<Or:i\d+>> Or [<<Not1>>,<<Not2>>] ## CHECK-DAG: Return [<<Or>>] ## CHECK-START: int SmaliTests.$opt$noinline$regressInputsAwayV2(int, int) instruction_simplifier (after) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<Cst1:i\d+>> IntConstant 1 ## CHECK-DAG: <<AddP1:i\d+>> Add [<<P1>>,<<Cst1>>] ## CHECK-DAG: <<AddP2:i\d+>> Add [<<P2>>,<<Cst1>>] ## CHECK-DAG: <<And:i\d+>> And [<<AddP1>>,<<AddP2>>] ## CHECK-DAG: <<Not:i\d+>> Not [<<And>>] ## CHECK-DAG: Return [<<Not>>] ## CHECK-START: int SmaliTests.$opt$noinline$regressInputsAwayV2(int, int) instruction_simplifier (after) ## CHECK-DAG: Not ## CHECK-NOT: Not ## CHECK-START: int SmaliTests.$opt$noinline$regressInputsAwayV2(int, int) instruction_simplifier (after) ## CHECK-NOT: Or # Original java source: # # public static int $opt$noinline$regressInputsAway(int a, int b) { # if (doThrow) throw new Error(); # int a1 = a + 1; # int not_a1 = ~a1; # int b1 = b + 1; # int not_b1 = ~b1; # return not_a1 | not_b1; # } .method public static $opt$noinline$regressInputsAwayV2(II)I .registers 7 .param p0, "a" # I .param p1, "b" # I .prologue .line 234 sget-boolean v4, LMain;->doThrow:Z if-eqz v4, :cond_a new-instance v4, Ljava/lang/Error; invoke-direct {v4}, Ljava/lang/Error;-><init>()V throw v4 .line 235 :cond_a add-int/lit8 v0, p0, 0x1 .line 236 .local v0, "a1":I xor-int/lit8 v2, v0, -0x1 .line 237 .local v2, "not_a1":I add-int/lit8 v1, p1, 0x1 .line 238 .local v1, "b1":I xor-int/lit8 v3, v1, -0x1 .line 239 .local v3, "not_b1":I or-int v4, v2, v3 return v4 .end method # Test transformation of Not/Not/Xor into Xor. # See first note above. ## CHECK-START: int SmaliTests.$opt$noinline$notXorToXorV2(int, int) instruction_simplifier (before) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<CstM1:i\d+>> IntConstant -1 ## CHECK-DAG: <<Not1:i\d+>> Xor [<<P1>>,<<CstM1>>] ## CHECK-DAG: <<Not2:i\d+>> Xor [<<P2>>,<<CstM1>>] ## CHECK-DAG: <<Xor:i\d+>> Xor [<<Not1>>,<<Not2>>] ## CHECK-DAG: Return [<<Xor>>] ## CHECK-START: int SmaliTests.$opt$noinline$notXorToXorV2(int, int) instruction_simplifier (after) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<Xor:i\d+>> Xor [<<P1>>,<<P2>>] ## CHECK-DAG: Return [<<Xor>>] ## CHECK-START: int SmaliTests.$opt$noinline$notXorToXorV2(int, int) instruction_simplifier (after) ## CHECK-NOT: Not # Original java source: # # public static int $opt$noinline$notXorToXor(int a, int b) { # if (doThrow) throw new Error(); # return ~a ^ ~b; # } .method public static $opt$noinline$notXorToXorV2(II)I .registers 4 .param p0, "a" # I .param p1, "b" # I .prologue .line 266 sget-boolean v0, LMain;->doThrow:Z if-eqz v0, :cond_a new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 .line 267 :cond_a xor-int/lit8 v0, p0, -0x1 xor-int/lit8 v1, p1, -0x1 xor-int/2addr v0, v1 return v0 .end method # Test transformation of Not/Not/Xor into Xor for boolean negations. # Note that the graph before this instruction simplification pass does not # contain `HBooleanNot` instructions. This is because this transformation # follows the optimization of `HSelect` to `HBooleanNot` occurring in the # same pass. ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanNotXorToXorV2(boolean, boolean) instruction_simplifier$after_gvn (before) ## CHECK-DAG: <<P1:z\d+>> ParameterValue ## CHECK-DAG: <<P2:z\d+>> ParameterValue ## CHECK-DAG: <<Const0:i\d+>> IntConstant 0 ## CHECK-DAG: <<Const1:i\d+>> IntConstant 1 ## CHECK-DAG: <<Select1:i\d+>> Select [<<Const1>>,<<Const0>>,<<P1>>] ## CHECK-DAG: <<Select2:i\d+>> Select [<<Const1>>,<<Const0>>,<<P2>>] ## CHECK-DAG: <<Xor:i\d+>> Xor [<<Select1>>,<<Select2>>] ## CHECK-DAG: Return [<<Xor>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanNotXorToXorV2(boolean, boolean) instruction_simplifier$after_gvn (after) ## CHECK-DAG: <<Cond1:z\d+>> ParameterValue ## CHECK-DAG: <<Cond2:z\d+>> ParameterValue ## CHECK-DAG: <<Xor:i\d+>> Xor [<<Cond1>>,<<Cond2>>] ## CHECK-DAG: Return [<<Xor>>] ## CHECK-START: boolean SmaliTests.$opt$noinline$booleanNotXorToXorV2(boolean, boolean) instruction_simplifier$after_bce (after) ## CHECK-NOT: BooleanNot # Original java source: # # public static boolean $opt$noinline$booleanNotXorToXor(boolean a, boolean b) { # if (doThrow) throw new Error(); # return !a ^ !b; # } .method public static $opt$noinline$booleanNotXorToXorV2(ZZ)Z .registers 5 .param p0, "a" # Z .param p1, "b" # Z .prologue const/4 v0, 0x1 const/4 v1, 0x0 .line 298 sget-boolean v2, LMain;->doThrow:Z if-eqz v2, :cond_c new-instance v0, Ljava/lang/Error; invoke-direct {v0}, Ljava/lang/Error;-><init>()V throw v0 .line 299 :cond_c if-nez p0, :cond_13 move v2, v0 :goto_f if-nez p1, :cond_15 :goto_11 xor-int/2addr v0, v2 return v0 :cond_13 move v2, v1 goto :goto_f :cond_15 move v0, v1 goto :goto_11 .end method # Check that no transformation is done when one Not has multiple uses. ## CHECK-START: int SmaliTests.$opt$noinline$notMultipleUsesV2(int, int) instruction_simplifier (before) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<CstM1:i\d+>> IntConstant -1 ## CHECK-DAG: <<One:i\d+>> IntConstant 1 ## CHECK-DAG: <<Not2:i\d+>> Xor [<<P2>>,<<CstM1>>] ## CHECK-DAG: <<And2:i\d+>> And [<<Not2>>,<<One>>] ## CHECK-DAG: <<Not1:i\d+>> Xor [<<P1>>,<<CstM1>>] ## CHECK-DAG: <<And1:i\d+>> And [<<Not1>>,<<Not2>>] ## CHECK-DAG: <<Add:i\d+>> Add [<<And2>>,<<And1>>] ## CHECK-DAG: Return [<<Add>>] ## CHECK-START: int SmaliTests.$opt$noinline$notMultipleUsesV2(int, int) instruction_simplifier (after) ## CHECK-DAG: <<P1:i\d+>> ParameterValue ## CHECK-DAG: <<P2:i\d+>> ParameterValue ## CHECK-DAG: <<One:i\d+>> IntConstant 1 ## CHECK-DAG: <<Not2:i\d+>> Not [<<P2>>] ## CHECK-DAG: <<And2:i\d+>> And [<<Not2>>,<<One>>] ## CHECK-DAG: <<Not1:i\d+>> Not [<<P1>>] ## CHECK-DAG: <<And1:i\d+>> And [<<Not1>>,<<Not2>>] ## CHECK-DAG: <<Add:i\d+>> Add [<<And2>>,<<And1>>] ## CHECK-DAG: Return [<<Add>>] ## CHECK-START: int SmaliTests.$opt$noinline$notMultipleUsesV2(int, int) instruction_simplifier (after) ## CHECK-NOT: Or # Original java source: # # public static int $opt$noinline$notMultipleUses(int a, int b) { # if (doThrow) throw new Error(); # int tmp = ~b; # return (tmp & 0x1) + (~a & tmp); # } .method public static $opt$noinline$notMultipleUsesV2(II)I .registers 5 .param p0, "a" # I .param p1, "b" # I .prologue .line 333 sget-boolean v1, LMain;->doThrow:Z if-eqz v1, :cond_a new-instance v1, Ljava/lang/Error; invoke-direct {v1}, Ljava/lang/Error;-><init>()V throw v1 .line 334 :cond_a xor-int/lit8 v0, p1, -0x1 .line 335 .local v0, "tmp":I and-int/lit8 v1, v0, 0x1 xor-int/lit8 v2, p0, -0x1 and-int/2addr v2, v0 add-int/2addr v1, v2 return v1 .end method