| /* |
| * Copyright (C) 2015 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. |
| */ |
| |
| import java.lang.reflect.Method; |
| |
| public class Main { |
| |
| public static void assertBooleanEquals(boolean expected, boolean result) { |
| if (expected != result) { |
| throw new Error("Expected: " + expected + ", found: " + result); |
| } |
| } |
| |
| public static void assertIntEquals(int expected, int result) { |
| if (expected != result) { |
| throw new Error("Expected: " + expected + ", found: " + result); |
| } |
| } |
| |
| public static void assertLongEquals(long expected, long result) { |
| if (expected != result) { |
| throw new Error("Expected: " + expected + ", found: " + result); |
| } |
| } |
| |
| public static void assertFloatEquals(float expected, float result) { |
| if (expected != result) { |
| throw new Error("Expected: " + expected + ", found: " + result); |
| } |
| } |
| |
| public static void assertDoubleEquals(double expected, double result) { |
| if (expected != result) { |
| throw new Error("Expected: " + expected + ", found: " + result); |
| } |
| } |
| |
| public static void assertStringEquals(String expected, String result) { |
| if (expected == null ? result != null : !expected.equals(result)) { |
| throw new Error("Expected: " + expected + ", found: " + result); |
| } |
| } |
| |
| /** |
| * Tiny programs exercising optimizations of arithmetic identities. |
| */ |
| |
| /// CHECK-START: long Main.Add0(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0 |
| /// CHECK-DAG: <<Add:j\d+>> Add [<<Const0>>,<<Arg>>] |
| /// CHECK-DAG: Return [<<Add>>] |
| |
| /// CHECK-START: long Main.Add0(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: long Main.Add0(long) instruction_simplifier (after) |
| /// CHECK-NOT: Add |
| |
| public static long Add0(long arg) { |
| return 0 + arg; |
| } |
| |
| /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1 |
| /// CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<ConstF>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after) |
| /// CHECK-NOT: And |
| |
| public static int AndAllOnes(int arg) { |
| return arg & -1; |
| } |
| |
| /// CHECK-START: int Main.UShr28And15(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const28:i\d+>> IntConstant 28 |
| /// CHECK-DAG: <<Const15:i\d+>> IntConstant 15 |
| /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Arg>>,<<Const28>>] |
| /// CHECK-DAG: <<And:i\d+>> And [<<UShr>>,<<Const15>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| /// CHECK-START: int Main.UShr28And15(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const28:i\d+>> IntConstant 28 |
| /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Arg>>,<<Const28>>] |
| /// CHECK-DAG: Return [<<UShr>>] |
| |
| /// CHECK-START: int Main.UShr28And15(int) instruction_simplifier (after) |
| /// CHECK-NOT: And |
| |
| public static int UShr28And15(int arg) { |
| return (arg >>> 28) & 15; |
| } |
| |
| /// CHECK-START: long Main.UShr60And15(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const60:i\d+>> IntConstant 60 |
| /// CHECK-DAG: <<Const15:j\d+>> LongConstant 15 |
| /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const60>>] |
| /// CHECK-DAG: <<And:j\d+>> And [<<UShr>>,<<Const15>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| /// CHECK-START: long Main.UShr60And15(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const60:i\d+>> IntConstant 60 |
| /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const60>>] |
| /// CHECK-DAG: Return [<<UShr>>] |
| |
| /// CHECK-START: long Main.UShr60And15(long) instruction_simplifier (after) |
| /// CHECK-NOT: And |
| |
| public static long UShr60And15(long arg) { |
| return (arg >>> 60) & 15; |
| } |
| |
| /// CHECK-START: int Main.UShr28And7(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const28:i\d+>> IntConstant 28 |
| /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7 |
| /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Arg>>,<<Const28>>] |
| /// CHECK-DAG: <<And:i\d+>> And [<<UShr>>,<<Const7>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| /// CHECK-START: int Main.UShr28And7(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const28:i\d+>> IntConstant 28 |
| /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7 |
| /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Arg>>,<<Const28>>] |
| /// CHECK-DAG: <<And:i\d+>> And [<<UShr>>,<<Const7>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| public static int UShr28And7(int arg) { |
| return (arg >>> 28) & 7; |
| } |
| |
| /// CHECK-START: long Main.UShr60And7(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const60:i\d+>> IntConstant 60 |
| /// CHECK-DAG: <<Const7:j\d+>> LongConstant 7 |
| /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const60>>] |
| /// CHECK-DAG: <<And:j\d+>> And [<<UShr>>,<<Const7>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| /// CHECK-START: long Main.UShr60And7(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const60:i\d+>> IntConstant 60 |
| /// CHECK-DAG: <<Const7:j\d+>> LongConstant 7 |
| /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const60>>] |
| /// CHECK-DAG: <<And:j\d+>> And [<<UShr>>,<<Const7>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| public static long UShr60And7(long arg) { |
| return (arg >>> 60) & 7; |
| } |
| |
| /// CHECK-START: int Main.Shr24And255(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const24:i\d+>> IntConstant 24 |
| /// CHECK-DAG: <<Const255:i\d+>> IntConstant 255 |
| /// CHECK-DAG: <<Shr:i\d+>> Shr [<<Arg>>,<<Const24>>] |
| /// CHECK-DAG: <<And:i\d+>> And [<<Shr>>,<<Const255>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| /// CHECK-START: int Main.Shr24And255(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const24:i\d+>> IntConstant 24 |
| /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Arg>>,<<Const24>>] |
| /// CHECK-DAG: Return [<<UShr>>] |
| |
| /// CHECK-START: int Main.Shr24And255(int) instruction_simplifier (after) |
| /// CHECK-NOT: Shr |
| /// CHECK-NOT: And |
| |
| public static int Shr24And255(int arg) { |
| return (arg >> 24) & 255; |
| } |
| |
| /// CHECK-START: long Main.Shr56And255(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const56:i\d+>> IntConstant 56 |
| /// CHECK-DAG: <<Const255:j\d+>> LongConstant 255 |
| /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const56>>] |
| /// CHECK-DAG: <<And:j\d+>> And [<<Shr>>,<<Const255>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| /// CHECK-START: long Main.Shr56And255(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const56:i\d+>> IntConstant 56 |
| /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const56>>] |
| /// CHECK-DAG: Return [<<UShr>>] |
| |
| /// CHECK-START: long Main.Shr56And255(long) instruction_simplifier (after) |
| /// CHECK-NOT: Shr |
| /// CHECK-NOT: And |
| |
| public static long Shr56And255(long arg) { |
| return (arg >> 56) & 255; |
| } |
| |
| /// CHECK-START: int Main.Shr24And127(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const24:i\d+>> IntConstant 24 |
| /// CHECK-DAG: <<Const127:i\d+>> IntConstant 127 |
| /// CHECK-DAG: <<Shr:i\d+>> Shr [<<Arg>>,<<Const24>>] |
| /// CHECK-DAG: <<And:i\d+>> And [<<Shr>>,<<Const127>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| /// CHECK-START: int Main.Shr24And127(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const24:i\d+>> IntConstant 24 |
| /// CHECK-DAG: <<Const127:i\d+>> IntConstant 127 |
| /// CHECK-DAG: <<Shr:i\d+>> Shr [<<Arg>>,<<Const24>>] |
| /// CHECK-DAG: <<And:i\d+>> And [<<Shr>>,<<Const127>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| public static int Shr24And127(int arg) { |
| return (arg >> 24) & 127; |
| } |
| |
| /// CHECK-START: long Main.Shr56And127(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const56:i\d+>> IntConstant 56 |
| /// CHECK-DAG: <<Const127:j\d+>> LongConstant 127 |
| /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const56>>] |
| /// CHECK-DAG: <<And:j\d+>> And [<<Shr>>,<<Const127>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| /// CHECK-START: long Main.Shr56And127(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const56:i\d+>> IntConstant 56 |
| /// CHECK-DAG: <<Const127:j\d+>> LongConstant 127 |
| /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const56>>] |
| /// CHECK-DAG: <<And:j\d+>> And [<<Shr>>,<<Const127>>] |
| /// CHECK-DAG: Return [<<And>>] |
| |
| public static long Shr56And127(long arg) { |
| return (arg >> 56) & 127; |
| } |
| |
| /// CHECK-START: long Main.Div1(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1 |
| /// CHECK-DAG: <<Div:j\d+>> Div [<<Arg>>,<<Const1>>] |
| /// CHECK-DAG: Return [<<Div>>] |
| |
| /// CHECK-START: long Main.Div1(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: long Main.Div1(long) instruction_simplifier (after) |
| /// CHECK-NOT: Div |
| |
| public static long Div1(long arg) { |
| return arg / 1; |
| } |
| |
| /// CHECK-START: int Main.DivN1(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1 |
| /// CHECK-DAG: <<Div:i\d+>> Div [<<Arg>>,<<ConstN1>>] |
| /// CHECK-DAG: Return [<<Div>>] |
| |
| /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>] |
| /// CHECK-DAG: Return [<<Neg>>] |
| |
| /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after) |
| /// CHECK-NOT: Div |
| |
| public static int DivN1(int arg) { |
| return arg / -1; |
| } |
| |
| /// CHECK-START: long Main.Mul1(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1 |
| /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Const1>>,<<Arg>>] |
| /// CHECK-DAG: Return [<<Mul>>] |
| |
| /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after) |
| /// CHECK-NOT: Mul |
| |
| public static long Mul1(long arg) { |
| return arg * 1; |
| } |
| |
| /// CHECK-START: int Main.MulN1(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1 |
| /// CHECK-DAG: <<Mul:i\d+>> Mul [<<Arg>>,<<ConstN1>>] |
| /// CHECK-DAG: Return [<<Mul>>] |
| |
| /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>] |
| /// CHECK-DAG: Return [<<Neg>>] |
| |
| /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after) |
| /// CHECK-NOT: Mul |
| |
| public static int MulN1(int arg) { |
| return arg * -1; |
| } |
| |
| /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const128:j\d+>> LongConstant 128 |
| /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Const128>>,<<Arg>>] |
| /// CHECK-DAG: Return [<<Mul>>] |
| |
| /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7 |
| /// CHECK-DAG: <<Shl:j\d+>> Shl [<<Arg>>,<<Const7>>] |
| /// CHECK-DAG: Return [<<Shl>>] |
| |
| /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after) |
| /// CHECK-NOT: Mul |
| |
| public static long MulPowerOfTwo128(long arg) { |
| return arg * 128; |
| } |
| |
| /// CHECK-START: int Main.Or0(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<Const0>>] |
| /// CHECK-DAG: Return [<<Or>>] |
| |
| /// CHECK-START: int Main.Or0(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: int Main.Or0(int) instruction_simplifier (after) |
| /// CHECK-NOT: Or |
| |
| public static int Or0(int arg) { |
| return arg | 0; |
| } |
| |
| /// CHECK-START: long Main.OrSame(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Or:j\d+>> Or [<<Arg>>,<<Arg>>] |
| /// CHECK-DAG: Return [<<Or>>] |
| |
| /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after) |
| /// CHECK-NOT: Or |
| |
| public static long OrSame(long arg) { |
| return arg | arg; |
| } |
| |
| /// CHECK-START: int Main.Shl0(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const0>>] |
| /// CHECK-DAG: Return [<<Shl>>] |
| |
| /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after) |
| /// CHECK-NOT: Shl |
| |
| public static int Shl0(int arg) { |
| return arg << 0; |
| } |
| |
| /// CHECK-START: long Main.Shr0(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const0>>] |
| /// CHECK-DAG: Return [<<Shr>>] |
| |
| /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after) |
| /// CHECK-NOT: Shr |
| |
| public static long Shr0(long arg) { |
| return arg >> 0; |
| } |
| |
| /// CHECK-START: long Main.Shr64(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const64:i\d+>> IntConstant 64 |
| /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const64>>] |
| /// CHECK-DAG: Return [<<Shr>>] |
| |
| /// CHECK-START: long Main.Shr64(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: long Main.Shr64(long) instruction_simplifier (after) |
| /// CHECK-NOT: Shr |
| |
| public static long Shr64(long arg) { |
| return arg >> 64; |
| } |
| |
| /// CHECK-START: long Main.Sub0(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0 |
| /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Const0>>] |
| /// CHECK-DAG: Return [<<Sub>>] |
| |
| /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after) |
| /// CHECK-NOT: Sub |
| |
| public static long Sub0(long arg) { |
| return arg - 0; |
| } |
| |
| /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const0>>,<<Arg>>] |
| /// CHECK-DAG: Return [<<Sub>>] |
| |
| /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>] |
| /// CHECK-DAG: Return [<<Neg>>] |
| |
| /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after) |
| /// CHECK-NOT: Sub |
| |
| public static int SubAliasNeg(int arg) { |
| return 0 - arg; |
| } |
| |
| /// CHECK-START: long Main.UShr0(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const0>>] |
| /// CHECK-DAG: Return [<<UShr>>] |
| |
| /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after) |
| /// CHECK-NOT: UShr |
| |
| public static long UShr0(long arg) { |
| return arg >>> 0; |
| } |
| |
| /// CHECK-START: int Main.Xor0(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Const0>>] |
| /// CHECK-DAG: Return [<<Xor>>] |
| |
| /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after) |
| /// CHECK-NOT: Xor |
| |
| public static int Xor0(int arg) { |
| return arg ^ 0; |
| } |
| |
| /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1 |
| /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<ConstF>>] |
| /// CHECK-DAG: Return [<<Xor>>] |
| |
| /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>] |
| /// CHECK-DAG: Return [<<Not>>] |
| |
| /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after) |
| /// CHECK-NOT: Xor |
| |
| public static int XorAllOnes(int arg) { |
| return arg ^ -1; |
| } |
| |
| /** |
| * Test that addition or subtraction operation with both inputs negated are |
| * optimized to use a single negation after the operation. |
| * The transformation tested is implemented in |
| * `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`. |
| */ |
| |
| /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>] |
| /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>] |
| /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>] |
| /// CHECK-DAG: Return [<<Add>>] |
| |
| /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-NOT: Neg |
| /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>] |
| /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>] |
| /// CHECK-DAG: Return [<<Neg>>] |
| |
| public static int AddNegs1(int arg1, int arg2) { |
| return -arg1 + -arg2; |
| } |
| |
| /** |
| * This is similar to the test-case AddNegs1, but the negations have |
| * multiple uses. |
| * The transformation tested is implemented in |
| * `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`. |
| * The current code won't perform the previous optimization. The |
| * transformations do not look at other uses of their inputs. As they don't |
| * know what will happen with other uses, they do not take the risk of |
| * increasing the register pressure by creating or extending live ranges. |
| */ |
| |
| /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>] |
| /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>] |
| /// CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>] |
| /// CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>] |
| /// CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>] |
| /// CHECK-DAG: Return [<<Or>>] |
| |
| /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>] |
| /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>] |
| /// CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>] |
| /// CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>] |
| /// CHECK-NOT: Neg |
| /// CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>] |
| /// CHECK-DAG: Return [<<Or>>] |
| |
| /// CHECK-START: int Main.AddNegs2(int, int) GVN (after) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>] |
| /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>] |
| /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>] |
| /// CHECK-DAG: <<Or:i\d+>> Or [<<Add>>,<<Add>>] |
| /// CHECK-DAG: Return [<<Or>>] |
| |
| public static int AddNegs2(int arg1, int arg2) { |
| int temp1 = -arg1; |
| int temp2 = -arg2; |
| return (temp1 + temp2) | (temp1 + temp2); |
| } |
| |
| /** |
| * This follows test-cases AddNegs1 and AddNegs2. |
| * The transformation tested is implemented in |
| * `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`. |
| * The optimization should not happen if it moves an additional instruction in |
| * the loop. |
| */ |
| |
| /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (before) |
| // -------------- Arguments and initial negation operations. |
| /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>] |
| /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>] |
| /// CHECK: Goto |
| // -------------- Loop |
| /// CHECK: SuspendCheck |
| /// CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>] |
| /// CHECK: Goto |
| |
| /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (after) |
| // -------------- Arguments and initial negation operations. |
| /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>] |
| /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>] |
| /// CHECK: Goto |
| // -------------- Loop |
| /// CHECK: SuspendCheck |
| /// CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>] |
| /// CHECK-NOT: Neg |
| /// CHECK: Goto |
| |
| public static long AddNegs3(long arg1, long arg2) { |
| long res = 0; |
| long n_arg1 = -arg1; |
| long n_arg2 = -arg2; |
| for (long i = 0; i < 1; i++) { |
| res += n_arg1 + n_arg2 + i; |
| } |
| return res; |
| } |
| |
| /** |
| * Test the simplification of an addition with a negated argument into a |
| * subtraction. |
| * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitAdd`. |
| */ |
| |
| /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>] |
| /// CHECK-DAG: <<Add:j\d+>> Add [<<Neg>>,<<Arg2>>] |
| /// CHECK-DAG: Return [<<Add>>] |
| |
| /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg2>>,<<Arg1>>] |
| /// CHECK-DAG: Return [<<Sub>>] |
| |
| /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after) |
| /// CHECK-NOT: Neg |
| /// CHECK-NOT: Add |
| |
| public static long AddNeg1(long arg1, long arg2) { |
| return -arg1 + arg2; |
| } |
| |
| /** |
| * This is similar to the test-case AddNeg1, but the negation has two uses. |
| * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitAdd`. |
| * The current code won't perform the previous optimization. The |
| * transformations do not look at other uses of their inputs. As they don't |
| * know what will happen with other uses, they do not take the risk of |
| * increasing the register pressure by creating or extending live ranges. |
| */ |
| |
| /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>] |
| /// CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>] |
| /// CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>] |
| /// CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>] |
| /// CHECK-DAG: Return [<<Res>>] |
| |
| /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>] |
| /// CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>] |
| /// CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>] |
| /// CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>] |
| /// CHECK-DAG: Return [<<Res>>] |
| |
| /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after) |
| /// CHECK-NOT: Sub |
| |
| public static long AddNeg2(long arg1, long arg2) { |
| long temp = -arg2; |
| return (arg1 + temp) | (arg1 + temp); |
| } |
| |
| /** |
| * Test simplification of the `-(-var)` pattern. |
| * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`. |
| */ |
| |
| /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg>>] |
| /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Neg1>>] |
| /// CHECK-DAG: Return [<<Neg2>>] |
| |
| /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after) |
| /// CHECK-NOT: Neg |
| |
| public static long NegNeg1(long arg) { |
| return -(-arg); |
| } |
| |
| /** |
| * Test 'multi-step' simplification, where a first transformation yields a |
| * new simplification possibility for the current instruction. |
| * The transformations tested are implemented in `InstructionSimplifierVisitor::VisitNeg` |
| * and in `InstructionSimplifierVisitor::VisitAdd`. |
| */ |
| |
| /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg>>] |
| /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Neg1>>] |
| /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg2>>,<<Neg1>>] |
| /// CHECK-DAG: Return [<<Add>>] |
| |
| /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg>>,<<Arg>>] |
| /// CHECK-DAG: Return [<<Sub>>] |
| |
| /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after) |
| /// CHECK-NOT: Neg |
| /// CHECK-NOT: Add |
| |
| /// CHECK-START: int Main.NegNeg2(int) constant_folding_after_inlining (after) |
| /// CHECK: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-NOT: Neg |
| /// CHECK-NOT: Add |
| /// CHECK: Return [<<Const0>>] |
| |
| public static int NegNeg2(int arg) { |
| int temp = -arg; |
| return temp + -temp; |
| } |
| |
| /** |
| * Test another 'multi-step' simplification, where a first transformation |
| * yields a new simplification possibility for the current instruction. |
| * The transformations tested are implemented in `InstructionSimplifierVisitor::VisitNeg` |
| * and in `InstructionSimplifierVisitor::VisitSub`. |
| */ |
| |
| /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0 |
| /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg>>] |
| /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Const0>>,<<Neg>>] |
| /// CHECK-DAG: Return [<<Sub>>] |
| |
| /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after) |
| /// CHECK-NOT: Neg |
| /// CHECK-NOT: Sub |
| |
| public static long NegNeg3(long arg) { |
| return 0 - -arg; |
| } |
| |
| /** |
| * Test that a negated subtraction is simplified to a subtraction with its |
| * arguments reversed. |
| * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`. |
| */ |
| |
| /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>] |
| /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Sub>>] |
| /// CHECK-DAG: Return [<<Neg>>] |
| |
| /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg2>>,<<Arg1>>] |
| /// CHECK-DAG: Return [<<Sub>>] |
| |
| /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after) |
| /// CHECK-NOT: Neg |
| |
| public static int NegSub1(int arg1, int arg2) { |
| return -(arg1 - arg2); |
| } |
| |
| /** |
| * This is similar to the test-case NegSub1, but the subtraction has |
| * multiple uses. |
| * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`. |
| * The current code won't perform the previous optimization. The |
| * transformations do not look at other uses of their inputs. As they don't |
| * know what will happen with other uses, they do not take the risk of |
| * increasing the register pressure by creating or extending live ranges. |
| */ |
| |
| /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>] |
| /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>] |
| /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>] |
| /// CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>] |
| /// CHECK-DAG: Return [<<Or>>] |
| |
| /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>] |
| /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>] |
| /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>] |
| /// CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>] |
| /// CHECK-DAG: Return [<<Or>>] |
| |
| public static int NegSub2(int arg1, int arg2) { |
| int temp = arg1 - arg2; |
| return -temp | -temp; |
| } |
| |
| /** |
| * Test simplification of the `~~var` pattern. |
| * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNot`. |
| */ |
| |
| /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Not1:j\d+>> Not [<<Arg>>] |
| /// CHECK-DAG: <<Not2:j\d+>> Not [<<Not1>>] |
| /// CHECK-DAG: Return [<<Not2>>] |
| |
| /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after) |
| /// CHECK-NOT: Not |
| |
| public static long NotNot1(long arg) { |
| return ~~arg; |
| } |
| |
| /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Not1:i\d+>> Not [<<Arg>>] |
| /// CHECK-DAG: <<Not2:i\d+>> Not [<<Not1>>] |
| /// CHECK-DAG: <<Add:i\d+>> Add [<<Not2>>,<<Not1>>] |
| /// CHECK-DAG: Return [<<Add>>] |
| |
| /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>] |
| /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg>>,<<Not>>] |
| /// CHECK-DAG: Return [<<Add>>] |
| |
| /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after) |
| /// CHECK: Not |
| /// CHECK-NOT: Not |
| |
| public static int NotNot2(int arg) { |
| int temp = ~arg; |
| return temp + ~temp; |
| } |
| |
| /** |
| * Test the simplification of a subtraction with a negated argument. |
| * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`. |
| */ |
| |
| /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>] |
| /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Neg>>,<<Arg2>>] |
| /// CHECK-DAG: Return [<<Sub>>] |
| |
| /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>] |
| /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>] |
| /// CHECK-DAG: Return [<<Neg>>] |
| |
| /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after) |
| /// CHECK-NOT: Sub |
| |
| public static int SubNeg1(int arg1, int arg2) { |
| return -arg1 - arg2; |
| } |
| |
| /** |
| * This is similar to the test-case SubNeg1, but the negation has |
| * multiple uses. |
| * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`. |
| * The current code won't perform the previous optimization. The |
| * transformations do not look at other uses of their inputs. As they don't |
| * know what will happen with other uses, they do not take the risk of |
| * increasing the register pressure by creating or extending live ranges. |
| */ |
| |
| /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>] |
| /// CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>] |
| /// CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>] |
| /// CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>] |
| /// CHECK-DAG: Return [<<Or>>] |
| |
| /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>] |
| /// CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>] |
| /// CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>] |
| /// CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>] |
| /// CHECK-DAG: Return [<<Or>>] |
| |
| /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after) |
| /// CHECK-NOT: Add |
| |
| public static int SubNeg2(int arg1, int arg2) { |
| int temp = -arg1; |
| return (temp - arg2) | (temp - arg2); |
| } |
| |
| /** |
| * This follows test-cases SubNeg1 and SubNeg2. |
| * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`. |
| * The optimization should not happen if it moves an additional instruction in |
| * the loop. |
| */ |
| |
| /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (before) |
| // -------------- Arguments and initial negation operation. |
| /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>] |
| /// CHECK: Goto |
| // -------------- Loop |
| /// CHECK: SuspendCheck |
| /// CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>] |
| /// CHECK: Goto |
| |
| /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (after) |
| // -------------- Arguments and initial negation operation. |
| /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>] |
| /// CHECK-DAG: Goto |
| // -------------- Loop |
| /// CHECK: SuspendCheck |
| /// CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>] |
| /// CHECK-NOT: Neg |
| /// CHECK: Goto |
| |
| public static long SubNeg3(long arg1, long arg2) { |
| long res = 0; |
| long temp = -arg1; |
| for (long i = 0; i < 1; i++) { |
| res += temp - arg2 - i; |
| } |
| return res; |
| } |
| |
| /// CHECK-START: boolean Main.EqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (before) |
| /// CHECK-DAG: <<Arg:z\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 |
| /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 |
| /// CHECK-DAG: <<NotArg:i\d+>> Select [<<Const1>>,<<Const0>>,<<Arg>>] |
| /// CHECK-DAG: <<Cond:z\d+>> Equal [<<NotArg>>,<<Const2>>] |
| /// CHECK-DAG: <<NotCond:i\d+>> Select [<<Const1>>,<<Const0>>,<<Cond>>] |
| /// CHECK-DAG: Return [<<NotCond>>] |
| |
| /// CHECK-START: boolean Main.EqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (after) |
| /// CHECK-DAG: <<True:i\d+>> IntConstant 1 |
| /// CHECK-DAG: Return [<<True>>] |
| |
| public static boolean EqualBoolVsIntConst(boolean arg) { |
| return (arg ? 0 : 1) != 2; |
| } |
| |
| /// CHECK-START: boolean Main.NotEqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (before) |
| /// CHECK-DAG: <<Arg:z\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 |
| /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 |
| /// CHECK-DAG: <<NotArg:i\d+>> Select [<<Const1>>,<<Const0>>,<<Arg>>] |
| /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<NotArg>>,<<Const2>>] |
| /// CHECK-DAG: <<NotCond:i\d+>> Select [<<Const1>>,<<Const0>>,<<Cond>>] |
| /// CHECK-DAG: Return [<<NotCond>>] |
| |
| /// CHECK-START: boolean Main.NotEqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (after) |
| /// CHECK-DAG: <<False:i\d+>> IntConstant 0 |
| /// CHECK-DAG: Return [<<False>>] |
| |
| public static boolean NotEqualBoolVsIntConst(boolean arg) { |
| return (arg ? 0 : 1) == 2; |
| } |
| |
| /* |
| * Test simplification of double Boolean negation. Note that sometimes |
| * both negations can be removed but we only expect the simplifier to |
| * remove the second. |
| */ |
| |
| /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_bce (before) |
| /// CHECK-DAG: <<Arg:z\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 |
| /// CHECK-DAG: <<NotArg:i\d+>> Select [<<Const1>>,<<Const0>>,<<Arg>>] |
| /// CHECK-DAG: <<NotNotArg:i\d+>> Select [<<Const1>>,<<Const0>>,<<NotArg>>] |
| /// CHECK-DAG: Return [<<NotNotArg>>] |
| |
| /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_bce (after) |
| /// CHECK-DAG: <<Arg:z\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| public static boolean NegateValue(boolean arg) { |
| return !arg; |
| } |
| |
| public static boolean NotNotBool(boolean arg) { |
| return !(NegateValue(arg)); |
| } |
| |
| /// CHECK-START: float Main.Div2(float) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:f\d+>> ParameterValue |
| /// CHECK-DAG: <<Const2:f\d+>> FloatConstant 2 |
| /// CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<Const2>>] |
| /// CHECK-DAG: Return [<<Div>>] |
| |
| /// CHECK-START: float Main.Div2(float) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:f\d+>> ParameterValue |
| /// CHECK-DAG: <<ConstP5:f\d+>> FloatConstant 0.5 |
| /// CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstP5>>] |
| /// CHECK-DAG: Return [<<Mul>>] |
| |
| /// CHECK-START: float Main.Div2(float) instruction_simplifier (after) |
| /// CHECK-NOT: Div |
| |
| public static float Div2(float arg) { |
| return arg / 2.0f; |
| } |
| |
| /// CHECK-START: double Main.Div2(double) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:d\d+>> ParameterValue |
| /// CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2 |
| /// CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<Const2>>] |
| /// CHECK-DAG: Return [<<Div>>] |
| |
| /// CHECK-START: double Main.Div2(double) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:d\d+>> ParameterValue |
| /// CHECK-DAG: <<ConstP5:d\d+>> DoubleConstant 0.5 |
| /// CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstP5>>] |
| /// CHECK-DAG: Return [<<Mul>>] |
| |
| /// CHECK-START: double Main.Div2(double) instruction_simplifier (after) |
| /// CHECK-NOT: Div |
| public static double Div2(double arg) { |
| return arg / 2.0; |
| } |
| |
| /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:f\d+>> ParameterValue |
| /// CHECK-DAG: <<ConstMP25:f\d+>> FloatConstant -0.25 |
| /// CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<ConstMP25>>] |
| /// CHECK-DAG: Return [<<Div>>] |
| |
| /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:f\d+>> ParameterValue |
| /// CHECK-DAG: <<ConstM4:f\d+>> FloatConstant -4 |
| /// CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstM4>>] |
| /// CHECK-DAG: Return [<<Mul>>] |
| |
| /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after) |
| /// CHECK-NOT: Div |
| |
| public static float DivMP25(float arg) { |
| return arg / -0.25f; |
| } |
| |
| /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:d\d+>> ParameterValue |
| /// CHECK-DAG: <<ConstMP25:d\d+>> DoubleConstant -0.25 |
| /// CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<ConstMP25>>] |
| /// CHECK-DAG: Return [<<Div>>] |
| |
| /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:d\d+>> ParameterValue |
| /// CHECK-DAG: <<ConstM4:d\d+>> DoubleConstant -4 |
| /// CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstM4>>] |
| /// CHECK-DAG: Return [<<Mul>>] |
| |
| /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after) |
| /// CHECK-NOT: Div |
| public static double DivMP25(double arg) { |
| return arg / -0.25f; |
| } |
| |
| /** |
| * Test strength reduction of factors of the form (2^n + 1). |
| */ |
| |
| /// CHECK-START: int Main.mulPow2Plus1(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const9:i\d+>> IntConstant 9 |
| /// CHECK: Mul [<<Arg>>,<<Const9>>] |
| |
| /// CHECK-START: int Main.mulPow2Plus1(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3 |
| /// CHECK: <<Shift:i\d+>> Shl [<<Arg>>,<<Const3>>] |
| /// CHECK-NEXT: Add [<<Arg>>,<<Shift>>] |
| |
| public static int mulPow2Plus1(int arg) { |
| return arg * 9; |
| } |
| |
| /** |
| * Test strength reduction of factors of the form (2^n - 1). |
| */ |
| |
| /// CHECK-START: long Main.mulPow2Minus1(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const31:j\d+>> LongConstant 31 |
| /// CHECK: Mul [<<Const31>>,<<Arg>>] |
| |
| /// CHECK-START: long Main.mulPow2Minus1(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5 |
| /// CHECK: <<Shift:j\d+>> Shl [<<Arg>>,<<Const5>>] |
| /// CHECK-NEXT: Sub [<<Shift>>,<<Arg>>] |
| |
| public static long mulPow2Minus1(long arg) { |
| return arg * 31; |
| } |
| |
| /// CHECK-START: int Main.booleanFieldNotEqualOne() instruction_simplifier_after_bce (before) |
| /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 |
| /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 |
| /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 |
| /// CHECK-DAG: <<Field:z\d+>> StaticFieldGet |
| /// CHECK-DAG: <<NE:z\d+>> NotEqual [<<Field>>,<<Const1>>] |
| /// CHECK-DAG: <<Select:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] |
| /// CHECK-DAG: Return [<<Select>>] |
| |
| /// CHECK-START: int Main.booleanFieldNotEqualOne() instruction_simplifier_after_bce (after) |
| /// CHECK-DAG: <<Field:z\d+>> StaticFieldGet |
| /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 |
| /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 |
| /// CHECK-DAG: <<Select:i\d+>> Select [<<Const54>>,<<Const13>>,<<Field>>] |
| /// CHECK-DAG: Return [<<Select>>] |
| |
| public static int booleanFieldNotEqualOne() { |
| return (booleanField == $inline$true()) ? 13 : 54; |
| } |
| |
| /// CHECK-START: int Main.booleanFieldEqualZero() instruction_simplifier_after_bce (before) |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 |
| /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 |
| /// CHECK-DAG: <<Field:z\d+>> StaticFieldGet |
| /// CHECK-DAG: <<NE:z\d+>> Equal [<<Field>>,<<Const0>>] |
| /// CHECK-DAG: <<Select:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] |
| /// CHECK-DAG: Return [<<Select>>] |
| |
| /// CHECK-START: int Main.booleanFieldEqualZero() instruction_simplifier_after_bce (after) |
| /// CHECK-DAG: <<Field:z\d+>> StaticFieldGet |
| /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 |
| /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 |
| /// CHECK-DAG: <<Select:i\d+>> Select [<<Const54>>,<<Const13>>,<<Field>>] |
| /// CHECK-DAG: Return [<<Select>>] |
| |
| public static int booleanFieldEqualZero() { |
| return (booleanField != $inline$false()) ? 13 : 54; |
| } |
| |
| /// CHECK-START: int Main.intConditionNotEqualOne(int) instruction_simplifier_after_bce (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 |
| /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 |
| /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 |
| /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 |
| /// CHECK-DAG: <<LE:z\d+>> LessThanOrEqual [<<Arg>>,<<Const42>>] |
| /// CHECK-DAG: <<GT:i\d+>> Select [<<Const1>>,<<Const0>>,<<LE>>] |
| /// CHECK-DAG: <<NE:z\d+>> NotEqual [<<GT>>,<<Const1>>] |
| /// CHECK-DAG: <<Result:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] |
| /// CHECK-DAG: Return [<<Result>>] |
| |
| /// CHECK-START: int Main.intConditionNotEqualOne(int) instruction_simplifier_after_bce (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 |
| /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 |
| /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 |
| /// CHECK-DAG: <<Result:i\d+>> Select [<<Const13>>,<<Const54>>,<<LE:z\d+>>] |
| /// CHECK-DAG: <<LE>> LessThanOrEqual [<<Arg>>,<<Const42>>] |
| /// CHECK-DAG: Return [<<Result>>] |
| // Note that we match `LE` from Select because there are two identical |
| // LessThanOrEqual instructions. |
| |
| public static int intConditionNotEqualOne(int i) { |
| return ((i > 42) == $inline$true()) ? 13 : 54; |
| } |
| |
| /// CHECK-START: int Main.intConditionEqualZero(int) instruction_simplifier_after_bce (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 |
| /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 |
| /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 |
| /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 |
| /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 |
| /// CHECK-DAG: <<LE:z\d+>> LessThanOrEqual [<<Arg>>,<<Const42>>] |
| /// CHECK-DAG: <<GT:i\d+>> Select [<<Const1>>,<<Const0>>,<<LE>>] |
| /// CHECK-DAG: <<NE:z\d+>> Equal [<<GT>>,<<Const0>>] |
| /// CHECK-DAG: <<Result:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] |
| /// CHECK-DAG: Return [<<Result>>] |
| |
| /// CHECK-START: int Main.intConditionEqualZero(int) instruction_simplifier_after_bce (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 |
| /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 |
| /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 |
| /// CHECK-DAG: <<Result:i\d+>> Select [<<Const13>>,<<Const54>>,<<LE:z\d+>>] |
| /// CHECK-DAG: <<LE>> LessThanOrEqual [<<Arg>>,<<Const42>>] |
| /// CHECK-DAG: Return [<<Result>>] |
| // Note that we match `LE` from Select because there are two identical |
| // LessThanOrEqual instructions. |
| |
| public static int intConditionEqualZero(int i) { |
| return ((i > 42) != $inline$false()) ? 13 : 54; |
| } |
| |
| // Test that conditions on float/double are not flipped. |
| |
| /// CHECK-START: int Main.floatConditionNotEqualOne(float) builder (after) |
| /// CHECK: LessThanOrEqual |
| |
| /// CHECK-START: int Main.floatConditionNotEqualOne(float) instruction_simplifier_before_codegen (after) |
| /// CHECK-DAG: <<Arg:f\d+>> ParameterValue |
| /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 |
| /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 |
| /// CHECK-DAG: <<Const42:f\d+>> FloatConstant 42 |
| /// CHECK-DAG: <<LE:z\d+>> LessThanOrEqual [<<Arg>>,<<Const42>>] |
| /// CHECK-DAG: <<Select:i\d+>> Select [<<Const13>>,<<Const54>>,<<LE>>] |
| /// CHECK-DAG: Return [<<Select>>] |
| |
| public static int floatConditionNotEqualOne(float f) { |
| return ((f > 42.0f) == true) ? 13 : 54; |
| } |
| |
| /// CHECK-START: int Main.doubleConditionEqualZero(double) builder (after) |
| /// CHECK: LessThanOrEqual |
| |
| /// CHECK-START: int Main.doubleConditionEqualZero(double) instruction_simplifier_before_codegen (after) |
| /// CHECK-DAG: <<Arg:d\d+>> ParameterValue |
| /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 |
| /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 |
| /// CHECK-DAG: <<Const42:d\d+>> DoubleConstant 42 |
| /// CHECK-DAG: <<LE:z\d+>> LessThanOrEqual [<<Arg>>,<<Const42>>] |
| /// CHECK-DAG: <<Select:i\d+>> Select [<<Const13>>,<<Const54>>,<<LE>>] |
| /// CHECK-DAG: Return [<<Select>>] |
| |
| public static int doubleConditionEqualZero(double d) { |
| return ((d > 42.0) != false) ? 13 : 54; |
| } |
| |
| /// CHECK-START: int Main.intToDoubleToInt(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Double>>] |
| /// CHECK-DAG: Return [<<Int>>] |
| |
| /// CHECK-START: int Main.intToDoubleToInt(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: int Main.intToDoubleToInt(int) instruction_simplifier (after) |
| /// CHECK-NOT: TypeConversion |
| |
| public static int intToDoubleToInt(int value) { |
| // Lossless conversion followed by a conversion back. |
| return (int) (double) value; |
| } |
| |
| /// CHECK-START: java.lang.String Main.intToDoubleToIntPrint(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: {{i\d+}} TypeConversion [<<Double>>] |
| |
| /// CHECK-START: java.lang.String Main.intToDoubleToIntPrint(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: {{d\d+}} TypeConversion [<<Arg>>] |
| |
| /// CHECK-START: java.lang.String Main.intToDoubleToIntPrint(int) instruction_simplifier (after) |
| /// CHECK-DAG: TypeConversion |
| /// CHECK-NOT: TypeConversion |
| |
| public static String intToDoubleToIntPrint(int value) { |
| // Lossless conversion followed by a conversion back |
| // with another use of the intermediate result. |
| double d = (double) value; |
| int i = (int) d; |
| return "d=" + d + ", i=" + i; |
| } |
| |
| /// CHECK-START: int Main.byteToDoubleToInt(byte) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:b\d+>> ParameterValue |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Double>>] |
| /// CHECK-DAG: Return [<<Int>>] |
| |
| /// CHECK-START: int Main.byteToDoubleToInt(byte) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:b\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: int Main.byteToDoubleToInt(byte) instruction_simplifier (after) |
| /// CHECK-NOT: TypeConversion |
| |
| public static int byteToDoubleToInt(byte value) { |
| // Lossless conversion followed by another conversion, use implicit conversion. |
| return (int) (double) value; |
| } |
| |
| /// CHECK-START: int Main.floatToDoubleToInt(float) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:f\d+>> ParameterValue |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Double>>] |
| /// CHECK-DAG: Return [<<Int>>] |
| |
| /// CHECK-START: int Main.floatToDoubleToInt(float) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:f\d+>> ParameterValue |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: Return [<<Int>>] |
| |
| /// CHECK-START: int Main.floatToDoubleToInt(float) instruction_simplifier (after) |
| /// CHECK-DAG: TypeConversion |
| /// CHECK-NOT: TypeConversion |
| |
| public static int floatToDoubleToInt(float value) { |
| // Lossless conversion followed by another conversion. |
| return (int) (double) value; |
| } |
| |
| /// CHECK-START: java.lang.String Main.floatToDoubleToIntPrint(float) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:f\d+>> ParameterValue |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: {{i\d+}} TypeConversion [<<Double>>] |
| |
| /// CHECK-START: java.lang.String Main.floatToDoubleToIntPrint(float) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:f\d+>> ParameterValue |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: {{i\d+}} TypeConversion [<<Double>>] |
| |
| public static String floatToDoubleToIntPrint(float value) { |
| // Lossless conversion followed by another conversion with |
| // an extra use of the intermediate result. |
| double d = (double) value; |
| int i = (int) d; |
| return "d=" + d + ", i=" + i; |
| } |
| |
| /// CHECK-START: short Main.byteToDoubleToShort(byte) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:b\d+>> ParameterValue |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Double>>] |
| /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Int>>] |
| /// CHECK-DAG: Return [<<Short>>] |
| |
| /// CHECK-START: short Main.byteToDoubleToShort(byte) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:b\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| /// CHECK-START: short Main.byteToDoubleToShort(byte) instruction_simplifier (after) |
| /// CHECK-NOT: TypeConversion |
| |
| public static short byteToDoubleToShort(byte value) { |
| // Originally, this is byte->double->int->short. The first conversion is lossless, |
| // so we merge this with the second one to byte->int which we omit as it's an implicit |
| // conversion. Then we eliminate the resulting byte->short as an implicit conversion. |
| return (short) (double) value; |
| } |
| |
| /// CHECK-START: short Main.charToDoubleToShort(char) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:c\d+>> ParameterValue |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Double>>] |
| /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Int>>] |
| /// CHECK-DAG: Return [<<Short>>] |
| |
| /// CHECK-START: short Main.charToDoubleToShort(char) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:c\d+>> ParameterValue |
| /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: Return [<<Short>>] |
| |
| /// CHECK-START: short Main.charToDoubleToShort(char) instruction_simplifier (after) |
| /// CHECK-DAG: TypeConversion |
| /// CHECK-NOT: TypeConversion |
| |
| public static short charToDoubleToShort(char value) { |
| // Originally, this is char->double->int->short. The first conversion is lossless, |
| // so we merge this with the second one to char->int which we omit as it's an implicit |
| // conversion. Then we are left with the resulting char->short conversion. |
| return (short) (double) value; |
| } |
| |
| /// CHECK-START: short Main.floatToIntToShort(float) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:f\d+>> ParameterValue |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Int>>] |
| /// CHECK-DAG: Return [<<Short>>] |
| |
| /// CHECK-START: short Main.floatToIntToShort(float) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:f\d+>> ParameterValue |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Int>>] |
| /// CHECK-DAG: Return [<<Short>>] |
| |
| public static short floatToIntToShort(float value) { |
| // Lossy FP to integral conversion followed by another conversion: no simplification. |
| return (short) value; |
| } |
| |
| /// CHECK-START: int Main.intToFloatToInt(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Float:f\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Float>>] |
| /// CHECK-DAG: Return [<<Int>>] |
| |
| /// CHECK-START: int Main.intToFloatToInt(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Float:f\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Float>>] |
| /// CHECK-DAG: Return [<<Int>>] |
| |
| public static int intToFloatToInt(int value) { |
| // Lossy integral to FP conversion followed another conversion: no simplification. |
| return (int) (float) value; |
| } |
| |
| /// CHECK-START: double Main.longToIntToDouble(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Int>>] |
| /// CHECK-DAG: Return [<<Double>>] |
| |
| /// CHECK-START: double Main.longToIntToDouble(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Int>>] |
| /// CHECK-DAG: Return [<<Double>>] |
| |
| public static double longToIntToDouble(long value) { |
| // Lossy long-to-int conversion followed an integral to FP conversion: no simplification. |
| return (double) (int) value; |
| } |
| |
| /// CHECK-START: long Main.longToIntToLong(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Long:j\d+>> TypeConversion [<<Int>>] |
| /// CHECK-DAG: Return [<<Long>>] |
| |
| /// CHECK-START: long Main.longToIntToLong(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Long:j\d+>> TypeConversion [<<Int>>] |
| /// CHECK-DAG: Return [<<Long>>] |
| |
| public static long longToIntToLong(long value) { |
| // Lossy long-to-int conversion followed an int-to-long conversion: no simplification. |
| return (long) (int) value; |
| } |
| |
| /// CHECK-START: short Main.shortToCharToShort(short) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:s\d+>> ParameterValue |
| /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Char>>] |
| /// CHECK-DAG: Return [<<Short>>] |
| |
| /// CHECK-START: short Main.shortToCharToShort(short) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:s\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| public static short shortToCharToShort(short value) { |
| // Integral conversion followed by non-widening integral conversion to original type. |
| return (short) (char) value; |
| } |
| |
| /// CHECK-START: int Main.shortToLongToInt(short) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:s\d+>> ParameterValue |
| /// CHECK-DAG: <<Long:j\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Long>>] |
| /// CHECK-DAG: Return [<<Int>>] |
| |
| /// CHECK-START: int Main.shortToLongToInt(short) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:s\d+>> ParameterValue |
| /// CHECK-DAG: Return [<<Arg>>] |
| |
| public static int shortToLongToInt(short value) { |
| // Integral conversion followed by non-widening integral conversion, use implicit conversion. |
| return (int) (long) value; |
| } |
| |
| /// CHECK-START: byte Main.shortToCharToByte(short) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:s\d+>> ParameterValue |
| /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: <<Byte:b\d+>> TypeConversion [<<Char>>] |
| /// CHECK-DAG: Return [<<Byte>>] |
| |
| /// CHECK-START: byte Main.shortToCharToByte(short) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:s\d+>> ParameterValue |
| /// CHECK-DAG: <<Byte:b\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: Return [<<Byte>>] |
| |
| public static byte shortToCharToByte(short value) { |
| // Integral conversion followed by non-widening integral conversion losing bits |
| // from the original type. Simplify to use only one conversion. |
| return (byte) (char) value; |
| } |
| |
| /// CHECK-START: java.lang.String Main.shortToCharToBytePrint(short) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:s\d+>> ParameterValue |
| /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: {{b\d+}} TypeConversion [<<Char>>] |
| |
| /// CHECK-START: java.lang.String Main.shortToCharToBytePrint(short) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:s\d+>> ParameterValue |
| /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: {{b\d+}} TypeConversion [<<Char>>] |
| |
| public static String shortToCharToBytePrint(short value) { |
| // Integral conversion followed by non-widening integral conversion losing bits |
| // from the original type with an extra use of the intermediate result. |
| char c = (char) value; |
| byte b = (byte) c; |
| return "c=" + ((int) c) + ", b=" + ((int) b); // implicit conversions. |
| } |
| |
| /// CHECK-START: byte Main.longAnd0xffToByte(long) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Mask:j\d+>> LongConstant 255 |
| /// CHECK-DAG: <<And:j\d+>> And [<<Mask>>,<<Arg>>] |
| /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<And>>] |
| /// CHECK-DAG: <<Byte:b\d+>> TypeConversion [<<Int>>] |
| /// CHECK-DAG: Return [<<Byte>>] |
| |
| /// CHECK-START: byte Main.longAnd0xffToByte(long) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:j\d+>> ParameterValue |
| /// CHECK-DAG: <<Byte:b\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: Return [<<Byte>>] |
| |
| /// CHECK-START: byte Main.longAnd0xffToByte(long) instruction_simplifier (after) |
| /// CHECK-NOT: And |
| |
| public static byte longAnd0xffToByte(long value) { |
| return (byte) (value & 0xff); |
| } |
| |
| /// CHECK-START: char Main.intAnd0x1ffffToChar(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Mask:i\d+>> IntConstant 131071 |
| /// CHECK-DAG: <<And:i\d+>> And [<<Mask>>,<<Arg>>] |
| /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<And>>] |
| /// CHECK-DAG: Return [<<Char>>] |
| |
| /// CHECK-START: char Main.intAnd0x1ffffToChar(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: Return [<<Char>>] |
| |
| /// CHECK-START: char Main.intAnd0x1ffffToChar(int) instruction_simplifier (after) |
| /// CHECK-NOT: And |
| |
| public static char intAnd0x1ffffToChar(int value) { |
| // Keeping all significant bits and one more. |
| return (char) (value & 0x1ffff); |
| } |
| |
| /// CHECK-START: short Main.intAnd0x17fffToShort(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Mask:i\d+>> IntConstant 98303 |
| /// CHECK-DAG: <<And:i\d+>> And [<<Mask>>,<<Arg>>] |
| /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<And>>] |
| /// CHECK-DAG: Return [<<Short>>] |
| |
| /// CHECK-START: short Main.intAnd0x17fffToShort(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Mask:i\d+>> IntConstant 98303 |
| /// CHECK-DAG: <<And:i\d+>> And [<<Mask>>,<<Arg>>] |
| /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<And>>] |
| /// CHECK-DAG: Return [<<Short>>] |
| |
| public static short intAnd0x17fffToShort(int value) { |
| // No simplification: clearing a significant bit. |
| return (short) (value & 0x17fff); |
| } |
| |
| /// CHECK-START: double Main.shortAnd0xffffToShortToDouble(short) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:s\d+>> ParameterValue |
| /// CHECK-DAG: <<Mask:i\d+>> IntConstant 65535 |
| /// CHECK-DAG: <<And:i\d+>> And [<<Mask>>,<<Arg>>] |
| /// CHECK-DAG: <<Same:s\d+>> TypeConversion [<<And>>] |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Same>>] |
| /// CHECK-DAG: Return [<<Double>>] |
| |
| /// CHECK-START: double Main.shortAnd0xffffToShortToDouble(short) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:s\d+>> ParameterValue |
| /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] |
| /// CHECK-DAG: Return [<<Double>>] |
| |
| public static double shortAnd0xffffToShortToDouble(short value) { |
| short same = (short) (value & 0xffff); |
| return (double) same; |
| } |
| |
| /// CHECK-START: int Main.intReverseCondition(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 |
| /// CHECK-DAG: <<LE:z\d+>> LessThanOrEqual [<<Const42>>,<<Arg>>] |
| |
| /// CHECK-START: int Main.intReverseCondition(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Arg:i\d+>> ParameterValue |
| /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 |
| /// CHECK-DAG: <<GE:z\d+>> GreaterThanOrEqual [<<Arg>>,<<Const42>>] |
| |
| public static int intReverseCondition(int i) { |
| return (42 > i) ? 13 : 54; |
| } |
| |
| /// CHECK-START: int Main.intReverseConditionNaN(int) instruction_simplifier (before) |
| /// CHECK-DAG: <<Const42:d\d+>> DoubleConstant 42 |
| /// CHECK-DAG: <<Result:d\d+>> InvokeStaticOrDirect |
| /// CHECK-DAG: <<CMP:i\d+>> Compare [<<Const42>>,<<Result>>] |
| |
| /// CHECK-START: int Main.intReverseConditionNaN(int) instruction_simplifier (after) |
| /// CHECK-DAG: <<Const42:d\d+>> DoubleConstant 42 |
| /// CHECK-DAG: <<Result:d\d+>> InvokeStaticOrDirect |
| /// CHECK-DAG: <<EQ:z\d+>> Equal [<<Result>>,<<Const42>>] |
| |
| public static int intReverseConditionNaN(int i) { |
| return (42 != Math.sqrt(i)) ? 13 : 54; |
| } |
| |
| public static int runSmaliTest(String name, boolean input) { |
| try { |
| Class<?> c = Class.forName("SmaliTests"); |
| Method m = c.getMethod(name, new Class[] { boolean.class }); |
| return (Integer) m.invoke(null, input); |
| } catch (Exception ex) { |
| throw new Error(ex); |
| } |
| } |
| |
| public static void main(String[] args) { |
| int arg = 123456; |
| |
| assertLongEquals(Add0(arg), arg); |
| assertIntEquals(AndAllOnes(arg), arg); |
| assertLongEquals(Div1(arg), arg); |
| assertIntEquals(DivN1(arg), -arg); |
| assertLongEquals(Mul1(arg), arg); |
| assertIntEquals(MulN1(arg), -arg); |
| assertLongEquals(MulPowerOfTwo128(arg), (128 * arg)); |
| assertIntEquals(Or0(arg), arg); |
| assertLongEquals(OrSame(arg), arg); |
| assertIntEquals(Shl0(arg), arg); |
| assertLongEquals(Shr0(arg), arg); |
| assertLongEquals(Shr64(arg), arg); |
| assertLongEquals(Sub0(arg), arg); |
| assertIntEquals(SubAliasNeg(arg), -arg); |
| assertLongEquals(UShr0(arg), arg); |
| assertIntEquals(Xor0(arg), arg); |
| assertIntEquals(XorAllOnes(arg), ~arg); |
| assertIntEquals(AddNegs1(arg, arg + 1), -(arg + arg + 1)); |
| assertIntEquals(AddNegs2(arg, arg + 1), -(arg + arg + 1)); |
| assertLongEquals(AddNegs3(arg, arg + 1), -(2 * arg + 1)); |
| assertLongEquals(AddNeg1(arg, arg + 1), 1); |
| assertLongEquals(AddNeg2(arg, arg + 1), -1); |
| assertLongEquals(NegNeg1(arg), arg); |
| assertIntEquals(NegNeg2(arg), 0); |
| assertLongEquals(NegNeg3(arg), arg); |
| assertIntEquals(NegSub1(arg, arg + 1), 1); |
| assertIntEquals(NegSub2(arg, arg + 1), 1); |
| assertLongEquals(NotNot1(arg), arg); |
| assertIntEquals(NotNot2(arg), -1); |
| assertIntEquals(SubNeg1(arg, arg + 1), -(arg + arg + 1)); |
| assertIntEquals(SubNeg2(arg, arg + 1), -(arg + arg + 1)); |
| assertLongEquals(SubNeg3(arg, arg + 1), -(2 * arg + 1)); |
| assertBooleanEquals(EqualBoolVsIntConst(true), true); |
| assertBooleanEquals(EqualBoolVsIntConst(true), true); |
| assertBooleanEquals(NotEqualBoolVsIntConst(false), false); |
| assertBooleanEquals(NotEqualBoolVsIntConst(false), false); |
| assertBooleanEquals(NotNotBool(true), true); |
| assertBooleanEquals(NotNotBool(false), false); |
| assertFloatEquals(Div2(100.0f), 50.0f); |
| assertDoubleEquals(Div2(150.0), 75.0); |
| assertFloatEquals(DivMP25(100.0f), -400.0f); |
| assertDoubleEquals(DivMP25(150.0), -600.0); |
| assertIntEquals(UShr28And15(0xc1234567), 0xc); |
| assertLongEquals(UShr60And15(0xc123456787654321L), 0xcL); |
| assertIntEquals(UShr28And7(0xc1234567), 0x4); |
| assertLongEquals(UShr60And7(0xc123456787654321L), 0x4L); |
| assertIntEquals(Shr24And255(0xc1234567), 0xc1); |
| assertLongEquals(Shr56And255(0xc123456787654321L), 0xc1L); |
| assertIntEquals(Shr24And127(0xc1234567), 0x41); |
| assertLongEquals(Shr56And127(0xc123456787654321L), 0x41L); |
| assertIntEquals(0, mulPow2Plus1(0)); |
| assertIntEquals(9, mulPow2Plus1(1)); |
| assertIntEquals(18, mulPow2Plus1(2)); |
| assertIntEquals(900, mulPow2Plus1(100)); |
| assertIntEquals(111105, mulPow2Plus1(12345)); |
| assertLongEquals(0, mulPow2Minus1(0)); |
| assertLongEquals(31, mulPow2Minus1(1)); |
| assertLongEquals(62, mulPow2Minus1(2)); |
| assertLongEquals(3100, mulPow2Minus1(100)); |
| assertLongEquals(382695, mulPow2Minus1(12345)); |
| |
| booleanField = false; |
| assertIntEquals(booleanFieldNotEqualOne(), 54); |
| assertIntEquals(booleanFieldEqualZero(), 54); |
| booleanField = true; |
| assertIntEquals(booleanFieldNotEqualOne(), 13); |
| assertIntEquals(booleanFieldEqualZero(), 13); |
| assertIntEquals(intConditionNotEqualOne(6), 54); |
| assertIntEquals(intConditionNotEqualOne(43), 13); |
| assertIntEquals(intConditionEqualZero(6), 54); |
| assertIntEquals(intConditionEqualZero(43), 13); |
| assertIntEquals(floatConditionNotEqualOne(6.0f), 54); |
| assertIntEquals(floatConditionNotEqualOne(43.0f), 13); |
| assertIntEquals(doubleConditionEqualZero(6.0), 54); |
| assertIntEquals(doubleConditionEqualZero(43.0), 13); |
| |
| assertIntEquals(1234567, intToDoubleToInt(1234567)); |
| assertIntEquals(Integer.MIN_VALUE, intToDoubleToInt(Integer.MIN_VALUE)); |
| assertIntEquals(Integer.MAX_VALUE, intToDoubleToInt(Integer.MAX_VALUE)); |
| assertStringEquals("d=7654321.0, i=7654321", intToDoubleToIntPrint(7654321)); |
| assertIntEquals(12, byteToDoubleToInt((byte) 12)); |
| assertIntEquals(Byte.MIN_VALUE, byteToDoubleToInt(Byte.MIN_VALUE)); |
| assertIntEquals(Byte.MAX_VALUE, byteToDoubleToInt(Byte.MAX_VALUE)); |
| assertIntEquals(11, floatToDoubleToInt(11.3f)); |
| assertStringEquals("d=12.25, i=12", floatToDoubleToIntPrint(12.25f)); |
| assertIntEquals(123, byteToDoubleToShort((byte) 123)); |
| assertIntEquals(Byte.MIN_VALUE, byteToDoubleToShort(Byte.MIN_VALUE)); |
| assertIntEquals(Byte.MAX_VALUE, byteToDoubleToShort(Byte.MAX_VALUE)); |
| assertIntEquals(1234, charToDoubleToShort((char) 1234)); |
| assertIntEquals(Character.MIN_VALUE, charToDoubleToShort(Character.MIN_VALUE)); |
| assertIntEquals(/* sign-extended */ -1, charToDoubleToShort(Character.MAX_VALUE)); |
| assertIntEquals(12345, floatToIntToShort(12345.75f)); |
| assertIntEquals(Short.MAX_VALUE, floatToIntToShort((float)(Short.MIN_VALUE - 1))); |
| assertIntEquals(Short.MIN_VALUE, floatToIntToShort((float)(Short.MAX_VALUE + 1))); |
| assertIntEquals(-54321, intToFloatToInt(-54321)); |
| assertDoubleEquals((double) 0x12345678, longToIntToDouble(0x1234567812345678L)); |
| assertDoubleEquals(0.0, longToIntToDouble(Long.MIN_VALUE)); |
| assertDoubleEquals(-1.0, longToIntToDouble(Long.MAX_VALUE)); |
| assertLongEquals(0x0000000012345678L, longToIntToLong(0x1234567812345678L)); |
| assertLongEquals(0xffffffff87654321L, longToIntToLong(0x1234567887654321L)); |
| assertLongEquals(0L, longToIntToLong(Long.MIN_VALUE)); |
| assertLongEquals(-1L, longToIntToLong(Long.MAX_VALUE)); |
| assertIntEquals((short) -5678, shortToCharToShort((short) -5678)); |
| assertIntEquals(Short.MIN_VALUE, shortToCharToShort(Short.MIN_VALUE)); |
| assertIntEquals(Short.MAX_VALUE, shortToCharToShort(Short.MAX_VALUE)); |
| assertIntEquals(5678, shortToLongToInt((short) 5678)); |
| assertIntEquals(Short.MIN_VALUE, shortToLongToInt(Short.MIN_VALUE)); |
| assertIntEquals(Short.MAX_VALUE, shortToLongToInt(Short.MAX_VALUE)); |
| assertIntEquals(0x34, shortToCharToByte((short) 0x1234)); |
| assertIntEquals(-0x10, shortToCharToByte((short) 0x12f0)); |
| assertIntEquals(0, shortToCharToByte(Short.MIN_VALUE)); |
| assertIntEquals(-1, shortToCharToByte(Short.MAX_VALUE)); |
| assertStringEquals("c=1025, b=1", shortToCharToBytePrint((short) 1025)); |
| assertStringEquals("c=1023, b=-1", shortToCharToBytePrint((short) 1023)); |
| assertStringEquals("c=65535, b=-1", shortToCharToBytePrint((short) -1)); |
| |
| assertIntEquals(0x21, longAnd0xffToByte(0x1234432112344321L)); |
| assertIntEquals(0, longAnd0xffToByte(Long.MIN_VALUE)); |
| assertIntEquals(-1, longAnd0xffToByte(Long.MAX_VALUE)); |
| assertIntEquals(0x1234, intAnd0x1ffffToChar(0x43211234)); |
| assertIntEquals(0, intAnd0x1ffffToChar(Integer.MIN_VALUE)); |
| assertIntEquals(Character.MAX_VALUE, intAnd0x1ffffToChar(Integer.MAX_VALUE)); |
| assertIntEquals(0x4321, intAnd0x17fffToShort(0x87654321)); |
| assertIntEquals(0x0888, intAnd0x17fffToShort(0x88888888)); |
| assertIntEquals(0, intAnd0x17fffToShort(Integer.MIN_VALUE)); |
| assertIntEquals(Short.MAX_VALUE, intAnd0x17fffToShort(Integer.MAX_VALUE)); |
| |
| assertDoubleEquals(0.0, shortAnd0xffffToShortToDouble((short) 0)); |
| assertDoubleEquals(1.0, shortAnd0xffffToShortToDouble((short) 1)); |
| assertDoubleEquals(-2.0, shortAnd0xffffToShortToDouble((short) -2)); |
| assertDoubleEquals(12345.0, shortAnd0xffffToShortToDouble((short) 12345)); |
| assertDoubleEquals((double)Short.MAX_VALUE, shortAnd0xffffToShortToDouble(Short.MAX_VALUE)); |
| assertDoubleEquals((double)Short.MIN_VALUE, shortAnd0xffffToShortToDouble(Short.MIN_VALUE)); |
| |
| assertIntEquals(intReverseCondition(41), 13); |
| assertIntEquals(intReverseConditionNaN(-5), 13); |
| |
| for (String condition : new String[] { "Equal", "NotEqual" }) { |
| for (String constant : new String[] { "True", "False" }) { |
| for (String side : new String[] { "Rhs", "Lhs" }) { |
| String name = condition + constant + side; |
| assertIntEquals(runSmaliTest(name, true), 5); |
| assertIntEquals(runSmaliTest(name, false), 3); |
| } |
| } |
| } |
| } |
| |
| private static boolean $inline$true() { return true; } |
| private static boolean $inline$false() { return false; } |
| |
| public static boolean booleanField; |
| } |