1b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames/* 26a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * Copyright (C) 2015 The Android Open Source Project 36a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * 46a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * Licensed under the Apache License, Version 2.0 (the "License"); 56a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * you may not use this file except in compliance with the License. 66a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * You may obtain a copy of the License at 76a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * 86a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * http://www.apache.org/licenses/LICENSE-2.0 96a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * 106a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * Unless required by applicable law or agreed to in writing, software 116a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * distributed under the License is distributed on an "AS IS" BASIS, 126a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 136a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * See the License for the specific language governing permissions and 146a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain * limitations under the License. 156a92a033c33e383541d77607fbe8cd982875d13dRoland Levillain */ 16b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 17f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdilimport java.lang.reflect.Method; 18f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil 19b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Ramespublic class Main { 20b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 210d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil public static void assertBooleanEquals(boolean expected, boolean result) { 220d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil if (expected != result) { 230d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil throw new Error("Expected: " + expected + ", found: " + result); 240d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil } 250d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil } 260d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil 27b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static void assertIntEquals(int expected, int result) { 28b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames if (expected != result) { 29b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames throw new Error("Expected: " + expected + ", found: " + result); 30b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 31b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 32b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 33b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static void assertLongEquals(long expected, long result) { 34b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames if (expected != result) { 35b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames throw new Error("Expected: " + expected + ", found: " + result); 36b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 37b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 38b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 390d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray public static void assertFloatEquals(float expected, float result) { 400d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray if (expected != result) { 410d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray throw new Error("Expected: " + expected + ", found: " + result); 420d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray } 430d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray } 440d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 450d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray public static void assertDoubleEquals(double expected, double result) { 460d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray if (expected != result) { 470d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray throw new Error("Expected: " + expected + ", found: " + result); 480d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray } 490d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray } 500d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 51b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static void assertStringEquals(String expected, String result) { 52b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko if (expected == null ? result != null : !expected.equals(result)) { 53b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko throw new Error("Expected: " + expected + ", found: " + result); 54b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 55b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 56b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 57b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames /** 58b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames * Tiny programs exercising optimizations of arithmetic identities. 59b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames */ 60b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 61a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Add0(long) instruction_simplifier (before) 62a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 63a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0 64a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add:j\d+>> Add [<<Const0>>,<<Arg>>] 65a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Add>>] 66b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 67a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Add0(long) instruction_simplifier (after) 68a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 69a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 700d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil 71a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Add0(long) instruction_simplifier (after) 72a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Add 73b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 74b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static long Add0(long arg) { 75b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return 0 + arg; 76b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 77b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 78a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (before) 79a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 80a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1 81a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<And:i\d+>> And [<<Arg>>,<<ConstF>>] 82a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<And>>] 83b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 84a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after) 85a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 86a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 87b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 88a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after) 89a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: And 90744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 91b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static int AndAllOnes(int arg) { 92b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg & -1; 93b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 94b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 95452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: int Main.UShr28And15(int) instruction_simplifier (before) 96452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 97452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const28:i\d+>> IntConstant 28 98452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const15:i\d+>> IntConstant 15 99452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Arg>>,<<Const28>>] 100452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:i\d+>> And [<<UShr>>,<<Const15>>] 101452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 102452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 103452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: int Main.UShr28And15(int) instruction_simplifier (after) 104452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 105452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const28:i\d+>> IntConstant 28 106452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Arg>>,<<Const28>>] 107452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<UShr>>] 108452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 109452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: int Main.UShr28And15(int) instruction_simplifier (after) 110452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-NOT: And 111452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 112452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko public static int UShr28And15(int arg) { 113452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko return (arg >>> 28) & 15; 114452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko } 115452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 116452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: long Main.UShr60And15(long) instruction_simplifier (before) 117452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 118452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const60:i\d+>> IntConstant 60 119452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const15:j\d+>> LongConstant 15 120452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const60>>] 121452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:j\d+>> And [<<UShr>>,<<Const15>>] 122452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 123452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 124452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: long Main.UShr60And15(long) instruction_simplifier (after) 125452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 126452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const60:i\d+>> IntConstant 60 127452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const60>>] 128452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<UShr>>] 129452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 130452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: long Main.UShr60And15(long) instruction_simplifier (after) 131452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-NOT: And 132452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 133452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko public static long UShr60And15(long arg) { 134452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko return (arg >>> 60) & 15; 135452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko } 136452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 137452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: int Main.UShr28And7(int) instruction_simplifier (before) 138452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 139452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const28:i\d+>> IntConstant 28 140452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7 141452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Arg>>,<<Const28>>] 142452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:i\d+>> And [<<UShr>>,<<Const7>>] 143452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 144452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 145452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: int Main.UShr28And7(int) instruction_simplifier (after) 146452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 147452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const28:i\d+>> IntConstant 28 148452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7 149452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Arg>>,<<Const28>>] 150452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:i\d+>> And [<<UShr>>,<<Const7>>] 151452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 152452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 153452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko public static int UShr28And7(int arg) { 154452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko return (arg >>> 28) & 7; 155452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko } 156452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 157452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: long Main.UShr60And7(long) instruction_simplifier (before) 158452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 159452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const60:i\d+>> IntConstant 60 160452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const7:j\d+>> LongConstant 7 161452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const60>>] 162452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:j\d+>> And [<<UShr>>,<<Const7>>] 163452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 164452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 165452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: long Main.UShr60And7(long) instruction_simplifier (after) 166452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 167452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const60:i\d+>> IntConstant 60 168452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const7:j\d+>> LongConstant 7 169452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const60>>] 170452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:j\d+>> And [<<UShr>>,<<Const7>>] 171452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 172452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 173452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko public static long UShr60And7(long arg) { 174452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko return (arg >>> 60) & 7; 175452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko } 176452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 177452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: int Main.Shr24And255(int) instruction_simplifier (before) 178452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 179452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const24:i\d+>> IntConstant 24 180452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const255:i\d+>> IntConstant 255 181452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Shr:i\d+>> Shr [<<Arg>>,<<Const24>>] 182452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:i\d+>> And [<<Shr>>,<<Const255>>] 183452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 184452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 185452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: int Main.Shr24And255(int) instruction_simplifier (after) 186452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 187452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const24:i\d+>> IntConstant 24 188452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<UShr:i\d+>> UShr [<<Arg>>,<<Const24>>] 189452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<UShr>>] 190452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 191452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: int Main.Shr24And255(int) instruction_simplifier (after) 192452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-NOT: Shr 193452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-NOT: And 194452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 195452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko public static int Shr24And255(int arg) { 196452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko return (arg >> 24) & 255; 197452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko } 198452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 199452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: long Main.Shr56And255(long) instruction_simplifier (before) 200452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 201452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const56:i\d+>> IntConstant 56 202452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const255:j\d+>> LongConstant 255 203452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const56>>] 204452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:j\d+>> And [<<Shr>>,<<Const255>>] 205452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 206452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 207452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: long Main.Shr56And255(long) instruction_simplifier (after) 208452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 209452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const56:i\d+>> IntConstant 56 210452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const56>>] 211452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<UShr>>] 212452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 213452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: long Main.Shr56And255(long) instruction_simplifier (after) 214452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-NOT: Shr 215452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-NOT: And 216452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 217452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko public static long Shr56And255(long arg) { 218452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko return (arg >> 56) & 255; 219452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko } 220452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 221452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: int Main.Shr24And127(int) instruction_simplifier (before) 222452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 223452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const24:i\d+>> IntConstant 24 224452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const127:i\d+>> IntConstant 127 225452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Shr:i\d+>> Shr [<<Arg>>,<<Const24>>] 226452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:i\d+>> And [<<Shr>>,<<Const127>>] 227452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 228452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 229452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: int Main.Shr24And127(int) instruction_simplifier (after) 230452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 231452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const24:i\d+>> IntConstant 24 232452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const127:i\d+>> IntConstant 127 233452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Shr:i\d+>> Shr [<<Arg>>,<<Const24>>] 234452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:i\d+>> And [<<Shr>>,<<Const127>>] 235452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 236452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 237452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko public static int Shr24And127(int arg) { 238452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko return (arg >> 24) & 127; 239452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko } 240452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 241452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: long Main.Shr56And127(long) instruction_simplifier (before) 242452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 243452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const56:i\d+>> IntConstant 56 244452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const127:j\d+>> LongConstant 127 245452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const56>>] 246452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:j\d+>> And [<<Shr>>,<<Const127>>] 247452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 248452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 249452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-START: long Main.Shr56And127(long) instruction_simplifier (after) 250452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 251452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const56:i\d+>> IntConstant 56 252452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Const127:j\d+>> LongConstant 127 253452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const56>>] 254452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: <<And:j\d+>> And [<<Shr>>,<<Const127>>] 255452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko /// CHECK-DAG: Return [<<And>>] 256452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 257452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko public static long Shr56And127(long arg) { 258452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko return (arg >> 56) & 127; 259452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko } 260452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko 261a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Div1(long) instruction_simplifier (before) 262a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 263a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1 264a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Div:j\d+>> Div [<<Arg>>,<<Const1>>] 265a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Div>>] 266b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 267a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Div1(long) instruction_simplifier (after) 268a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 269a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 270b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 271a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Div1(long) instruction_simplifier (after) 272a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Div 273744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 274b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static long Div1(long arg) { 275b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg / 1; 276b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 277b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 278a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.DivN1(int) instruction_simplifier (before) 279a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 280a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1 281a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Div:i\d+>> Div [<<Arg>>,<<ConstN1>>] 282a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Div>>] 283b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 284a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after) 285a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 286a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>] 287a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Neg>>] 288b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 289a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after) 290a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Div 291744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 292b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static int DivN1(int arg) { 293b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg / -1; 294b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 295b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 296a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Mul1(long) instruction_simplifier (before) 297a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 298a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const1:j\d+>> LongConstant 1 29957e863c3739c310380e19252ad5746ff08d219c7David Brazdil /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Const1>>,<<Arg>>] 300a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Mul>>] 301b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 302a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after) 303a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 304a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 305b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 306a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after) 307a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Mul 308744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 309b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static long Mul1(long arg) { 310b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg * 1; 311b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 312b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 313a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.MulN1(int) instruction_simplifier (before) 314a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 315a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<ConstN1:i\d+>> IntConstant -1 316a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Mul:i\d+>> Mul [<<Arg>>,<<ConstN1>>] 317a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Mul>>] 318b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 319a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after) 320a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 321a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>] 322a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Neg>>] 323b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 324a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after) 325a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Mul 326744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 327b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static int MulN1(int arg) { 328b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg * -1; 329b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 330b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 331a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (before) 332a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 333a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const128:j\d+>> LongConstant 128 33457e863c3739c310380e19252ad5746ff08d219c7David Brazdil /// CHECK-DAG: <<Mul:j\d+>> Mul [<<Const128>>,<<Arg>>] 335a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Mul>>] 336b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 337a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after) 338a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 339a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const7:i\d+>> IntConstant 7 340a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Shl:j\d+>> Shl [<<Arg>>,<<Const7>>] 341a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Shl>>] 342b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 343a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after) 344a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Mul 345744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 346b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static long MulPowerOfTwo128(long arg) { 347b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg * 128; 348b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 349b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 350a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.Or0(int) instruction_simplifier (before) 351a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 352a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 353a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Or:i\d+>> Or [<<Arg>>,<<Const0>>] 354a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Or>>] 355b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 356a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.Or0(int) instruction_simplifier (after) 357a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 358a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 359b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 360a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.Or0(int) instruction_simplifier (after) 361a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Or 362744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 363b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static int Or0(int arg) { 364b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg | 0; 365b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 366b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 367a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.OrSame(long) instruction_simplifier (before) 368a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 369a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Or:j\d+>> Or [<<Arg>>,<<Arg>>] 370a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Or>>] 371b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 372a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after) 373a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 374a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 375b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 376a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after) 377a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Or 378744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 379b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static long OrSame(long arg) { 380b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg | arg; 381b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 382b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 383a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.Shl0(int) instruction_simplifier (before) 384a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 385a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 386a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Shl:i\d+>> Shl [<<Arg>>,<<Const0>>] 387a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Shl>>] 388b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 389a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after) 390a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 391a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 392b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 393a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after) 394a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Shl 395744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 396b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static int Shl0(int arg) { 397b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg << 0; 398b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 399b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 400a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Shr0(long) instruction_simplifier (before) 401a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 402a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 403a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const0>>] 404a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Shr>>] 405b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 406a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after) 407a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 408a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 409b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 410a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after) 411a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Shr 412744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 413b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static long Shr0(long arg) { 414b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg >> 0; 415b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 416b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 417164306e779de522efba7df637618a8eeed9e37acVladimir Marko /// CHECK-START: long Main.Shr64(long) instruction_simplifier (before) 418164306e779de522efba7df637618a8eeed9e37acVladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 419164306e779de522efba7df637618a8eeed9e37acVladimir Marko /// CHECK-DAG: <<Const64:i\d+>> IntConstant 64 420164306e779de522efba7df637618a8eeed9e37acVladimir Marko /// CHECK-DAG: <<Shr:j\d+>> Shr [<<Arg>>,<<Const64>>] 421164306e779de522efba7df637618a8eeed9e37acVladimir Marko /// CHECK-DAG: Return [<<Shr>>] 422164306e779de522efba7df637618a8eeed9e37acVladimir Marko 423164306e779de522efba7df637618a8eeed9e37acVladimir Marko /// CHECK-START: long Main.Shr64(long) instruction_simplifier (after) 424164306e779de522efba7df637618a8eeed9e37acVladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 425164306e779de522efba7df637618a8eeed9e37acVladimir Marko /// CHECK-DAG: Return [<<Arg>>] 426164306e779de522efba7df637618a8eeed9e37acVladimir Marko 427164306e779de522efba7df637618a8eeed9e37acVladimir Marko /// CHECK-START: long Main.Shr64(long) instruction_simplifier (after) 428164306e779de522efba7df637618a8eeed9e37acVladimir Marko /// CHECK-NOT: Shr 429164306e779de522efba7df637618a8eeed9e37acVladimir Marko 430164306e779de522efba7df637618a8eeed9e37acVladimir Marko public static long Shr64(long arg) { 431164306e779de522efba7df637618a8eeed9e37acVladimir Marko return arg >> 64; 432164306e779de522efba7df637618a8eeed9e37acVladimir Marko } 433164306e779de522efba7df637618a8eeed9e37acVladimir Marko 434a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Sub0(long) instruction_simplifier (before) 435a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 436a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0 437a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg>>,<<Const0>>] 438a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Sub>>] 439b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 440a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after) 441a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 442a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 443b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 444a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after) 445a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Sub 446744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 447b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static long Sub0(long arg) { 448b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg - 0; 449b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 450b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 451a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (before) 452a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 453a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 454a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const0>>,<<Arg>>] 455a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Sub>>] 456b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 457a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after) 458a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 459a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg>>] 460a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Neg>>] 461b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 462a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after) 463a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Sub 464744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 465b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static int SubAliasNeg(int arg) { 466b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return 0 - arg; 467b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 468b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 469a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.UShr0(long) instruction_simplifier (before) 470a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 471a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 472a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<UShr:j\d+>> UShr [<<Arg>>,<<Const0>>] 473a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<UShr>>] 474b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 475a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after) 476a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 477a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 478b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 479a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after) 480a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: UShr 481744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 482b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static long UShr0(long arg) { 483b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg >>> 0; 484b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 485b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 486a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.Xor0(int) instruction_simplifier (before) 487a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 488a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 489a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<Const0>>] 490a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Xor>>] 491b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 492a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after) 493a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 494a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 495b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 496a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after) 497a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Xor 498744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 499b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static int Xor0(int arg) { 500b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg ^ 0; 501b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 502b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 503a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (before) 504a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 505a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1 506a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Xor:i\d+>> Xor [<<Arg>>,<<ConstF>>] 507a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Xor>>] 508b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 509a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after) 510a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 511a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>] 512a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Not>>] 513b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 514a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after) 515a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Xor 516744176959a259f36fe7ca7d101aee1cf39d707d5Alexandre Rames 517b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames public static int XorAllOnes(int arg) { 518b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames return arg ^ -1; 519b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames } 520b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 521188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 522188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * Test that addition or subtraction operation with both inputs negated are 523188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * optimized to use a single negation after the operation. 524188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in 525188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`. 526188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 527188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 528a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (before) 529a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 530a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 531a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>] 532a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>] 533a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>] 534a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Add>>] 535a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil 536a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (after) 537a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 538a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 539a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Neg 540a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>] 541a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>] 542a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Neg>>] 543188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 544188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static int AddNegs1(int arg1, int arg2) { 545188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return -arg1 + -arg2; 546188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 547188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 548188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 549188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * This is similar to the test-case AddNegs1, but the negations have 550188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * multiple uses. 551188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in 552188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`. 553188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The current code won't perform the previous optimization. The 554188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * transformations do not look at other uses of their inputs. As they don't 555188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * know what will happen with other uses, they do not take the risk of 556188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * increasing the register pressure by creating or extending live ranges. 557188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 558188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 559a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (before) 560a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 561a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 562a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>] 563a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>] 564a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>] 565a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>] 566a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>] 567a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Or>>] 568a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil 569a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (after) 570a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 571a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 572a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>] 573a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>] 574a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add1:i\d+>> Add [<<Neg1>>,<<Neg2>>] 575a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add2:i\d+>> Add [<<Neg1>>,<<Neg2>>] 576a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Neg 577a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Or:i\d+>> Or [<<Add1>>,<<Add2>>] 578a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Or>>] 579a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil 580a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.AddNegs2(int, int) GVN (after) 581a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 582a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 583a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg1>>] 584a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Arg2>>] 585a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg1>>,<<Neg2>>] 586a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Or:i\d+>> Or [<<Add>>,<<Add>>] 587a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Or>>] 588b2a58477e14e1b15cb9848d16015a49a854ee32cAlexandre Rames 589188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static int AddNegs2(int arg1, int arg2) { 590188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames int temp1 = -arg1; 591188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames int temp2 = -arg2; 592188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return (temp1 + temp2) | (temp1 + temp2); 593188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 594188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 595188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 596188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * This follows test-cases AddNegs1 and AddNegs2. 597188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in 598188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`. 599188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The optimization should not happen if it moves an additional instruction in 600188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * the loop. 601188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 602188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 603a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (before) 604a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil // -------------- Arguments and initial negation operations. 605a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue 606a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue 607a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>] 608a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>] 609a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: Goto 610a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil // -------------- Loop 611a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: SuspendCheck 612a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>] 613a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: Goto 614a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil 615a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (after) 616a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil // -------------- Arguments and initial negation operations. 617a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue 618a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue 619a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg1>>] 620a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Arg2>>] 621a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: Goto 622a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil // -------------- Loop 623a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: SuspendCheck 624a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: <<Add:j\d+>> Add [<<Neg1>>,<<Neg2>>] 625a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Neg 626a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: Goto 627188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 628188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static long AddNegs3(long arg1, long arg2) { 629188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames long res = 0; 630188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames long n_arg1 = -arg1; 631188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames long n_arg2 = -arg2; 632188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames for (long i = 0; i < 1; i++) { 633188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames res += n_arg1 + n_arg2 + i; 634188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 635188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return res; 636188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 637188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 638188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 639188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * Test the simplification of an addition with a negated argument into a 640188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * subtraction. 641188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitAdd`. 642188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 643188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 644a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (before) 645a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue 646a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue 647a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>] 648a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add:j\d+>> Add [<<Neg>>,<<Arg2>>] 649a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Add>>] 650188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 651a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after) 652a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue 653a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue 654a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Arg2>>,<<Arg1>>] 655a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Sub>>] 656188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 657a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after) 658a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Neg 659a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Add 660188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 661188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static long AddNeg1(long arg1, long arg2) { 662188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return -arg1 + arg2; 663188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 664188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 665188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 666188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * This is similar to the test-case AddNeg1, but the negation has two uses. 667188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitAdd`. 668188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The current code won't perform the previous optimization. The 669188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * transformations do not look at other uses of their inputs. As they don't 670188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * know what will happen with other uses, they do not take the risk of 671188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * increasing the register pressure by creating or extending live ranges. 672188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 673188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 674a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (before) 675a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue 676a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue 677a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>] 678a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>] 679a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>] 680a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>] 681a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Res>>] 682a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil 683a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after) 684a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue 685a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue 686a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg2>>] 687a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add1:j\d+>> Add [<<Arg1>>,<<Neg>>] 688a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add2:j\d+>> Add [<<Arg1>>,<<Neg>>] 689a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Res:j\d+>> Or [<<Add1>>,<<Add2>>] 690a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Res>>] 691a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil 692a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after) 693a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Sub 694188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 695188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static long AddNeg2(long arg1, long arg2) { 696188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames long temp = -arg2; 697188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return (arg1 + temp) | (arg1 + temp); 698188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 699188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 700188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 701188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * Test simplification of the `-(-var)` pattern. 702188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`. 703188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 704188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 705a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (before) 706a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 707a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg1:j\d+>> Neg [<<Arg>>] 708a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg2:j\d+>> Neg [<<Neg1>>] 709a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Neg2>>] 710188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 711a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after) 712a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 713a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 714188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 715a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after) 716a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Neg 717188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 718188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static long NegNeg1(long arg) { 719188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return -(-arg); 720188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 721188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 722188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 723188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * Test 'multi-step' simplification, where a first transformation yields a 724188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * new simplification possibility for the current instruction. 725188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformations tested are implemented in `InstructionSimplifierVisitor::VisitNeg` 726188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * and in `InstructionSimplifierVisitor::VisitAdd`. 727188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 728188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 729a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (before) 730a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 731a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Arg>>] 732a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Neg1>>] 73357e863c3739c310380e19252ad5746ff08d219c7David Brazdil /// CHECK-DAG: <<Add:i\d+>> Add [<<Neg2>>,<<Neg1>>] 734a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Add>>] 735188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 736a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after) 737a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 738a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg>>,<<Arg>>] 739a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Sub>>] 740188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 741a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after) 742a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Neg 743a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Add 744188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 745a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NegNeg2(int) constant_folding_after_inlining (after) 746a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: <<Const0:i\d+>> IntConstant 0 747a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Neg 748a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Add 749a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: Return [<<Const0>>] 750b2a58477e14e1b15cb9848d16015a49a854ee32cAlexandre Rames 751188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static int NegNeg2(int arg) { 752188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames int temp = -arg; 753188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return temp + -temp; 754188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 755188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 756188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 757188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * Test another 'multi-step' simplification, where a first transformation 758188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * yields a new simplification possibility for the current instruction. 759188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformations tested are implemented in `InstructionSimplifierVisitor::VisitNeg` 760188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * and in `InstructionSimplifierVisitor::VisitSub`. 761188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 762188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 763a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (before) 764a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 765a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const0:j\d+>> LongConstant 0 766a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg>>] 767a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub:j\d+>> Sub [<<Const0>>,<<Neg>>] 768a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Sub>>] 769188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 770a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after) 771a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 772a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 773188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 774a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after) 775a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Neg 776a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Sub 777188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 778188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static long NegNeg3(long arg) { 779188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return 0 - -arg; 780188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 781188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 782188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 783188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * Test that a negated subtraction is simplified to a subtraction with its 784188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * arguments reversed. 785188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`. 786188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 787188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 788a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (before) 789a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 790a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 791a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>] 792a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Sub>>] 793a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Neg>>] 794188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 795a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after) 796a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 797a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 798a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg2>>,<<Arg1>>] 799a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Sub>>] 800188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 801a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after) 802a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Neg 803188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 804188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static int NegSub1(int arg1, int arg2) { 805188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return -(arg1 - arg2); 806188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 807188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 808188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 809188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * This is similar to the test-case NegSub1, but the subtraction has 810188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * multiple uses. 811188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`. 812188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The current code won't perform the previous optimization. The 813188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * transformations do not look at other uses of their inputs. As they don't 814188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * know what will happen with other uses, they do not take the risk of 815188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * increasing the register pressure by creating or extending live ranges. 816188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 817188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 818a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (before) 819a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 820a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 821a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>] 822a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>] 823a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>] 824a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>] 825a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Or>>] 826a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil 827a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (after) 828a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 829a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 830a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Arg1>>,<<Arg2>>] 831a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg1:i\d+>> Neg [<<Sub>>] 832a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg2:i\d+>> Neg [<<Sub>>] 833a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Or:i\d+>> Or [<<Neg1>>,<<Neg2>>] 834a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Or>>] 835188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 836188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static int NegSub2(int arg1, int arg2) { 837188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames int temp = arg1 - arg2; 838188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return -temp | -temp; 839188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 840188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 841188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 842188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * Test simplification of the `~~var` pattern. 843188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNot`. 844188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 845188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 846a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (before) 847a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 848f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<Not1:j\d+>> Not [<<Arg>>] 849f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<Not2:j\d+>> Not [<<Not1>>] 850f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: Return [<<Not2>>] 851188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 852a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after) 853a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 854a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 855188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 856a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after) 857f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-NOT: Not 858188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 859188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static long NotNot1(long arg) { 860188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return ~~arg; 861188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 862188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 863a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (before) 864a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 865f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<Not1:i\d+>> Not [<<Arg>>] 866f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<Not2:i\d+>> Not [<<Not1>>] 867f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<Add:i\d+>> Add [<<Not2>>,<<Not1>>] 868a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Add>>] 869188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 870a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after) 871a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 872a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Not:i\d+>> Not [<<Arg>>] 87357e863c3739c310380e19252ad5746ff08d219c7David Brazdil /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg>>,<<Not>>] 874a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Add>>] 875188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 876a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after) 877f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK: Not 878f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-NOT: Not 879188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 880188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static int NotNot2(int arg) { 881188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames int temp = ~arg; 882188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return temp + ~temp; 883188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 884188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 885188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 886188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * Test the simplification of a subtraction with a negated argument. 887188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`. 888188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 889188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 890a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (before) 891a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 892a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 893a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>] 894a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Neg>>,<<Arg2>>] 895a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Sub>>] 896188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 897a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after) 898a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 899a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 900a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Add:i\d+>> Add [<<Arg1>>,<<Arg2>>] 901a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Add>>] 902a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Neg>>] 903188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 904a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after) 905a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Sub 906188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 907188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static int SubNeg1(int arg1, int arg2) { 908188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return -arg1 - arg2; 909188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 910188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 911188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 912188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * This is similar to the test-case SubNeg1, but the negation has 913188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * multiple uses. 914188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`. 915188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The current code won't perform the previous optimization. The 916188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * transformations do not look at other uses of their inputs. As they don't 917188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * know what will happen with other uses, they do not take the risk of 918188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * increasing the register pressure by creating or extending live ranges. 919188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 920188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 921a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (before) 922a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 923a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 924a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>] 925a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>] 926a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>] 927a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>] 928a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Or>>] 929a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil 930a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after) 931a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:i\d+>> ParameterValue 932a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:i\d+>> ParameterValue 933a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:i\d+>> Neg [<<Arg1>>] 934a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub1:i\d+>> Sub [<<Neg>>,<<Arg2>>] 935a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Sub2:i\d+>> Sub [<<Neg>>,<<Arg2>>] 936a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Or:i\d+>> Or [<<Sub1>>,<<Sub2>>] 937a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Or>>] 938a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil 939a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after) 940a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Add 941188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 942188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static int SubNeg2(int arg1, int arg2) { 943188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames int temp = -arg1; 944188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return (temp - arg2) | (temp - arg2); 945188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 946188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 947188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames /** 948188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * This follows test-cases SubNeg1 and SubNeg2. 949188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`. 950188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * The optimization should not happen if it moves an additional instruction in 951188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames * the loop. 952188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames */ 953188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 954a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (before) 955a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil // -------------- Arguments and initial negation operation. 956a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue 957a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue 958a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>] 959a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: Goto 960a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil // -------------- Loop 961a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: SuspendCheck 962a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>] 963a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: Goto 964a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil 965a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (after) 966a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil // -------------- Arguments and initial negation operation. 967a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg1:j\d+>> ParameterValue 968a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg2:j\d+>> ParameterValue 969a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Neg:j\d+>> Neg [<<Arg1>>] 970a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Goto 971a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil // -------------- Loop 972a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: SuspendCheck 973a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: <<Sub:j\d+>> Sub [<<Neg>>,<<Arg2>>] 974a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Neg 975a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK: Goto 976188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 977188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames public static long SubNeg3(long arg1, long arg2) { 978188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames long res = 0; 979188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames long temp = -arg1; 980188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames for (long i = 0; i < 1; i++) { 981188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames res += temp - arg2 - i; 982188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 983188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames return res; 984188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames } 985188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames 9861e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil /// CHECK-START: boolean Main.EqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (before) 9871e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil /// CHECK-DAG: <<Arg:z\d+>> ParameterValue 98874eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 98974eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 9901e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 99174eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<NotArg:i\d+>> Select [<<Const1>>,<<Const0>>,<<Arg>>] 99274eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Cond:z\d+>> Equal [<<NotArg>>,<<Const2>>] 99374eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<NotCond:i\d+>> Select [<<Const1>>,<<Const0>>,<<Cond>>] 99474eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<NotCond>>] 9951e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil 9961e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil /// CHECK-START: boolean Main.EqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (after) 99774eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<True:i\d+>> IntConstant 1 99874eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<True>>] 9991e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil 10001e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil public static boolean EqualBoolVsIntConst(boolean arg) { 100174eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil return (arg ? 0 : 1) != 2; 10021e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil } 10031e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil 10041e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil /// CHECK-START: boolean Main.NotEqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (before) 10051e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil /// CHECK-DAG: <<Arg:z\d+>> ParameterValue 100674eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 100774eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 10081e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2 100974eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<NotArg:i\d+>> Select [<<Const1>>,<<Const0>>,<<Arg>>] 101074eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Cond:z\d+>> NotEqual [<<NotArg>>,<<Const2>>] 101174eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<NotCond:i\d+>> Select [<<Const1>>,<<Const0>>,<<Cond>>] 101274eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<NotCond>>] 10131e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil 10141e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil /// CHECK-START: boolean Main.NotEqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (after) 101574eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<False:i\d+>> IntConstant 0 101674eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<False>>] 10171e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil 10181e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil public static boolean NotEqualBoolVsIntConst(boolean arg) { 101974eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil return (arg ? 0 : 1) == 2; 10201e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil } 10211e9ec053008fca7eb713815716c69375c37b399cDavid Brazdil 10220d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil /* 10230d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil * Test simplification of double Boolean negation. Note that sometimes 10240d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil * both negations can be removed but we only expect the simplifier to 10250d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil * remove the second. 10260d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil */ 10270d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil 1028b2bdfce7f805b00668a2521b1c939a0aafb2be49Nicolas Geoffray /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_bce (before) 1029a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:z\d+>> ParameterValue 103074eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 103174eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 103274eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<NotArg:i\d+>> Select [<<Const1>>,<<Const0>>,<<Arg>>] 103374eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<NotNotArg:i\d+>> Select [<<Const1>>,<<Const0>>,<<NotArg>>] 1034a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<NotNotArg>>] 10350d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil 1036b2bdfce7f805b00668a2521b1c939a0aafb2be49Nicolas Geoffray /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_bce (after) 1037a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:z\d+>> ParameterValue 1038a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Arg>>] 10390d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil 1040769c9e539da8ca80aa914cd12276aa5bd79148eeDavid Brazdil public static boolean NegateValue(boolean arg) { 1041769c9e539da8ca80aa914cd12276aa5bd79148eeDavid Brazdil return !arg; 1042769c9e539da8ca80aa914cd12276aa5bd79148eeDavid Brazdil } 1043769c9e539da8ca80aa914cd12276aa5bd79148eeDavid Brazdil 10440d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil public static boolean NotNotBool(boolean arg) { 1045769c9e539da8ca80aa914cd12276aa5bd79148eeDavid Brazdil return !(NegateValue(arg)); 10460d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil } 10470d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil 1048a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: float Main.Div2(float) instruction_simplifier (before) 1049a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:f\d+>> ParameterValue 1050a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const2:f\d+>> FloatConstant 2 1051a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<Const2>>] 1052a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Div>>] 10530d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 1054a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: float Main.Div2(float) instruction_simplifier (after) 1055a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:f\d+>> ParameterValue 1056a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<ConstP5:f\d+>> FloatConstant 0.5 1057a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstP5>>] 1058a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Mul>>] 10590d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 1060a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: float Main.Div2(float) instruction_simplifier (after) 1061a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Div 10620d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 10630d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray public static float Div2(float arg) { 10640d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray return arg / 2.0f; 10650d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray } 10660d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 1067a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: double Main.Div2(double) instruction_simplifier (before) 1068a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:d\d+>> ParameterValue 1069a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Const2:d\d+>> DoubleConstant 2 1070a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<Const2>>] 1071a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Div>>] 10720d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 1073a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: double Main.Div2(double) instruction_simplifier (after) 1074a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:d\d+>> ParameterValue 1075a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<ConstP5:d\d+>> DoubleConstant 0.5 1076a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstP5>>] 1077a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Mul>>] 10780d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 1079a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: double Main.Div2(double) instruction_simplifier (after) 1080a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Div 10810d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray public static double Div2(double arg) { 10820d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray return arg / 2.0; 10830d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray } 10840d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 1085a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (before) 1086a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:f\d+>> ParameterValue 1087a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<ConstMP25:f\d+>> FloatConstant -0.25 1088a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Div:f\d+>> Div [<<Arg>>,<<ConstMP25>>] 1089a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Div>>] 10900d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 1091a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after) 1092a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:f\d+>> ParameterValue 1093a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<ConstM4:f\d+>> FloatConstant -4 1094a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Mul:f\d+>> Mul [<<Arg>>,<<ConstM4>>] 1095a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Mul>>] 10960d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 1097a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after) 1098a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Div 10990d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 11000d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray public static float DivMP25(float arg) { 11010d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray return arg / -0.25f; 11020d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray } 11030d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 1104a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (before) 1105a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:d\d+>> ParameterValue 1106a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<ConstMP25:d\d+>> DoubleConstant -0.25 1107a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Div:d\d+>> Div [<<Arg>>,<<ConstMP25>>] 1108a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Div>>] 11090d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 1110a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after) 1111a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Arg:d\d+>> ParameterValue 1112a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<ConstM4:d\d+>> DoubleConstant -4 1113a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: <<Mul:d\d+>> Mul [<<Arg>>,<<ConstM4>>] 1114a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-DAG: Return [<<Mul>>] 11150d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 1116a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after) 1117a06d66a4ee60926127b9498b7ff0b3e37a24fccfDavid Brazdil /// CHECK-NOT: Div 11180d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray public static double DivMP25(double arg) { 11190d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray return arg / -0.25f; 11200d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray } 11210d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray 112238db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /** 112338db785600757a832423e076b3cf0af3bee942d8Alexandre Rames * Test strength reduction of factors of the form (2^n + 1). 112438db785600757a832423e076b3cf0af3bee942d8Alexandre Rames */ 112538db785600757a832423e076b3cf0af3bee942d8Alexandre Rames 112638db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-START: int Main.mulPow2Plus1(int) instruction_simplifier (before) 112738db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 112838db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-DAG: <<Const9:i\d+>> IntConstant 9 112938db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK: Mul [<<Arg>>,<<Const9>>] 113038db785600757a832423e076b3cf0af3bee942d8Alexandre Rames 113138db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-START: int Main.mulPow2Plus1(int) instruction_simplifier (after) 113238db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 113338db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-DAG: <<Const3:i\d+>> IntConstant 3 113438db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK: <<Shift:i\d+>> Shl [<<Arg>>,<<Const3>>] 113538db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-NEXT: Add [<<Arg>>,<<Shift>>] 113638db785600757a832423e076b3cf0af3bee942d8Alexandre Rames 113738db785600757a832423e076b3cf0af3bee942d8Alexandre Rames public static int mulPow2Plus1(int arg) { 113838db785600757a832423e076b3cf0af3bee942d8Alexandre Rames return arg * 9; 113938db785600757a832423e076b3cf0af3bee942d8Alexandre Rames } 114038db785600757a832423e076b3cf0af3bee942d8Alexandre Rames 114138db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /** 114238db785600757a832423e076b3cf0af3bee942d8Alexandre Rames * Test strength reduction of factors of the form (2^n - 1). 114338db785600757a832423e076b3cf0af3bee942d8Alexandre Rames */ 114438db785600757a832423e076b3cf0af3bee942d8Alexandre Rames 114538db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-START: long Main.mulPow2Minus1(long) instruction_simplifier (before) 114638db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 114738db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-DAG: <<Const31:j\d+>> LongConstant 31 114857e863c3739c310380e19252ad5746ff08d219c7David Brazdil /// CHECK: Mul [<<Const31>>,<<Arg>>] 114938db785600757a832423e076b3cf0af3bee942d8Alexandre Rames 115038db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-START: long Main.mulPow2Minus1(long) instruction_simplifier (after) 115138db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 115238db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5 115338db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK: <<Shift:j\d+>> Shl [<<Arg>>,<<Const5>>] 115438db785600757a832423e076b3cf0af3bee942d8Alexandre Rames /// CHECK-NEXT: Sub [<<Shift>>,<<Arg>>] 115538db785600757a832423e076b3cf0af3bee942d8Alexandre Rames 115638db785600757a832423e076b3cf0af3bee942d8Alexandre Rames public static long mulPow2Minus1(long arg) { 115738db785600757a832423e076b3cf0af3bee942d8Alexandre Rames return arg * 31; 115838db785600757a832423e076b3cf0af3bee942d8Alexandre Rames } 115938db785600757a832423e076b3cf0af3bee942d8Alexandre Rames 1160f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-START: int Main.booleanFieldNotEqualOne() instruction_simplifier_after_bce (before) 1161f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 1162f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 1163f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 1164f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Field:z\d+>> StaticFieldGet 1165f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<NE:z\d+>> NotEqual [<<Field>>,<<Const1>>] 1166f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<Select:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] 1167f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: Return [<<Select>>] 116874eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil 1169f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-START: int Main.booleanFieldNotEqualOne() instruction_simplifier_after_bce (after) 117074eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Field:z\d+>> StaticFieldGet 117174eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 117274eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 117374eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Select:i\d+>> Select [<<Const54>>,<<Const13>>,<<Field>>] 117474eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<Select>>] 1175f652917de5634b30c974c81d35a72871915b352aMark Mendell 1176f652917de5634b30c974c81d35a72871915b352aMark Mendell public static int booleanFieldNotEqualOne() { 1177f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil return (booleanField == $inline$true()) ? 13 : 54; 1178f652917de5634b30c974c81d35a72871915b352aMark Mendell } 1179f652917de5634b30c974c81d35a72871915b352aMark Mendell 1180f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-START: int Main.booleanFieldEqualZero() instruction_simplifier_after_bce (before) 1181f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 1182f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 1183f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 1184f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Field:z\d+>> StaticFieldGet 1185f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<NE:z\d+>> Equal [<<Field>>,<<Const0>>] 1186f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: <<Select:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] 1187f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-DAG: Return [<<Select>>] 118874eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil 1189f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil /// CHECK-START: int Main.booleanFieldEqualZero() instruction_simplifier_after_bce (after) 119074eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Field:z\d+>> StaticFieldGet 119174eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 119274eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 119374eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Select:i\d+>> Select [<<Const54>>,<<Const13>>,<<Field>>] 119474eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<Select>>] 1195f652917de5634b30c974c81d35a72871915b352aMark Mendell 1196f652917de5634b30c974c81d35a72871915b352aMark Mendell public static int booleanFieldEqualZero() { 1197f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil return (booleanField != $inline$false()) ? 13 : 54; 1198f652917de5634b30c974c81d35a72871915b352aMark Mendell } 1199f652917de5634b30c974c81d35a72871915b352aMark Mendell 1200f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-START: int Main.intConditionNotEqualOne(int) instruction_simplifier_after_bce (before) 1201f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 120274eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 1203f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 120474eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 1205f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 120674eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 120774eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<LE:z\d+>> LessThanOrEqual [<<Arg>>,<<Const42>>] 120874eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<GT:i\d+>> Select [<<Const1>>,<<Const0>>,<<LE>>] 1209f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<NE:z\d+>> NotEqual [<<GT>>,<<Const1>>] 121074eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Result:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] 121174eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<Result>>] 1212f652917de5634b30c974c81d35a72871915b352aMark Mendell 1213f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-START: int Main.intConditionNotEqualOne(int) instruction_simplifier_after_bce (after) 1214f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 121574eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 1216f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 121774eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 121874eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Result:i\d+>> Select [<<Const13>>,<<Const54>>,<<LE:z\d+>>] 1219f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<LE>> LessThanOrEqual [<<Arg>>,<<Const42>>] 122074eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<Result>>] 122174eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil // Note that we match `LE` from Select because there are two identical 122274eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil // LessThanOrEqual instructions. 1223f652917de5634b30c974c81d35a72871915b352aMark Mendell 1224f652917de5634b30c974c81d35a72871915b352aMark Mendell public static int intConditionNotEqualOne(int i) { 1225f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil return ((i > 42) == $inline$true()) ? 13 : 54; 1226f652917de5634b30c974c81d35a72871915b352aMark Mendell } 1227f652917de5634b30c974c81d35a72871915b352aMark Mendell 1228f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-START: int Main.intConditionEqualZero(int) instruction_simplifier_after_bce (before) 1229f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 1230f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Const0:i\d+>> IntConstant 0 123174eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1 123274eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 1233f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 123474eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 123574eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<LE:z\d+>> LessThanOrEqual [<<Arg>>,<<Const42>>] 123674eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<GT:i\d+>> Select [<<Const1>>,<<Const0>>,<<LE>>] 123774eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<NE:z\d+>> Equal [<<GT>>,<<Const0>>] 123874eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Result:i\d+>> Select [<<Const13>>,<<Const54>>,<<NE>>] 123974eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<Result>>] 1240f652917de5634b30c974c81d35a72871915b352aMark Mendell 1241f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-START: int Main.intConditionEqualZero(int) instruction_simplifier_after_bce (after) 1242f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 124374eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 1244f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 124574eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 124674eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Result:i\d+>> Select [<<Const13>>,<<Const54>>,<<LE:z\d+>>] 1247f652917de5634b30c974c81d35a72871915b352aMark Mendell /// CHECK-DAG: <<LE>> LessThanOrEqual [<<Arg>>,<<Const42>>] 124874eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<Result>>] 124974eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil // Note that we match `LE` from Select because there are two identical 125074eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil // LessThanOrEqual instructions. 1251f652917de5634b30c974c81d35a72871915b352aMark Mendell 1252f652917de5634b30c974c81d35a72871915b352aMark Mendell public static int intConditionEqualZero(int i) { 1253f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil return ((i > 42) != $inline$false()) ? 13 : 54; 1254f652917de5634b30c974c81d35a72871915b352aMark Mendell } 1255f652917de5634b30c974c81d35a72871915b352aMark Mendell 1256f652917de5634b30c974c81d35a72871915b352aMark Mendell // Test that conditions on float/double are not flipped. 1257f652917de5634b30c974c81d35a72871915b352aMark Mendell 1258badd826664896d4a9628a5a89b78016894aa414bDavid Brazdil /// CHECK-START: int Main.floatConditionNotEqualOne(float) builder (after) 125974eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK: LessThanOrEqual 126074eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil 12612f10a5fb8c236a6786928f0323bd312c3ee9a4ccMark P Mendell /// CHECK-START: int Main.floatConditionNotEqualOne(float) instruction_simplifier_before_codegen (after) 126274eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Arg:f\d+>> ParameterValue 126374eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 126474eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 126574eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const42:f\d+>> FloatConstant 42 126674eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<LE:z\d+>> LessThanOrEqual [<<Arg>>,<<Const42>>] 126774eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Select:i\d+>> Select [<<Const13>>,<<Const54>>,<<LE>>] 126874eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<Select>>] 1269f652917de5634b30c974c81d35a72871915b352aMark Mendell 1270f652917de5634b30c974c81d35a72871915b352aMark Mendell public static int floatConditionNotEqualOne(float f) { 1271f652917de5634b30c974c81d35a72871915b352aMark Mendell return ((f > 42.0f) == true) ? 13 : 54; 1272f652917de5634b30c974c81d35a72871915b352aMark Mendell } 1273f652917de5634b30c974c81d35a72871915b352aMark Mendell 1274badd826664896d4a9628a5a89b78016894aa414bDavid Brazdil /// CHECK-START: int Main.doubleConditionEqualZero(double) builder (after) 127574eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK: LessThanOrEqual 127674eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil 12772f10a5fb8c236a6786928f0323bd312c3ee9a4ccMark P Mendell /// CHECK-START: int Main.doubleConditionEqualZero(double) instruction_simplifier_before_codegen (after) 127874eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Arg:d\d+>> ParameterValue 127974eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13 128074eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const54:i\d+>> IntConstant 54 128174eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Const42:d\d+>> DoubleConstant 42 128274eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<LE:z\d+>> LessThanOrEqual [<<Arg>>,<<Const42>>] 128374eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: <<Select:i\d+>> Select [<<Const13>>,<<Const54>>,<<LE>>] 128474eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil /// CHECK-DAG: Return [<<Select>>] 1285f652917de5634b30c974c81d35a72871915b352aMark Mendell 1286f652917de5634b30c974c81d35a72871915b352aMark Mendell public static int doubleConditionEqualZero(double d) { 1287f652917de5634b30c974c81d35a72871915b352aMark Mendell return ((d > 42.0) != false) ? 13 : 54; 1288f652917de5634b30c974c81d35a72871915b352aMark Mendell } 128938db785600757a832423e076b3cf0af3bee942d8Alexandre Rames 1290b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.intToDoubleToInt(int) instruction_simplifier (before) 1291b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 1292b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] 1293b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Double>>] 1294b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Int>>] 1295b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1296b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.intToDoubleToInt(int) instruction_simplifier (after) 1297b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 1298b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Arg>>] 1299b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1300b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.intToDoubleToInt(int) instruction_simplifier (after) 1301b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-NOT: TypeConversion 1302b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1303b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static int intToDoubleToInt(int value) { 1304b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Lossless conversion followed by a conversion back. 1305b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (int) (double) value; 1306b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1307b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1308b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: java.lang.String Main.intToDoubleToIntPrint(int) instruction_simplifier (before) 1309b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 1310b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] 1311b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: {{i\d+}} TypeConversion [<<Double>>] 1312b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1313b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: java.lang.String Main.intToDoubleToIntPrint(int) instruction_simplifier (after) 1314b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 1315b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: {{d\d+}} TypeConversion [<<Arg>>] 1316b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1317b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: java.lang.String Main.intToDoubleToIntPrint(int) instruction_simplifier (after) 1318b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: TypeConversion 1319b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-NOT: TypeConversion 1320b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1321b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static String intToDoubleToIntPrint(int value) { 1322b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Lossless conversion followed by a conversion back 1323b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // with another use of the intermediate result. 1324b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko double d = (double) value; 1325b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko int i = (int) d; 1326b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return "d=" + d + ", i=" + i; 1327b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1328b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1329b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.byteToDoubleToInt(byte) instruction_simplifier (before) 1330b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:b\d+>> ParameterValue 1331b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] 1332b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Double>>] 1333b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Int>>] 1334b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1335b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.byteToDoubleToInt(byte) instruction_simplifier (after) 1336b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:b\d+>> ParameterValue 1337b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Arg>>] 1338b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1339b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.byteToDoubleToInt(byte) instruction_simplifier (after) 1340b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-NOT: TypeConversion 1341b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1342b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static int byteToDoubleToInt(byte value) { 1343b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Lossless conversion followed by another conversion, use implicit conversion. 1344b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (int) (double) value; 1345b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1346b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1347b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.floatToDoubleToInt(float) instruction_simplifier (before) 1348b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:f\d+>> ParameterValue 1349b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] 1350b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Double>>] 1351b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Int>>] 1352b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1353b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.floatToDoubleToInt(float) instruction_simplifier (after) 1354b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:f\d+>> ParameterValue 1355b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] 1356b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Int>>] 1357b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1358b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.floatToDoubleToInt(float) instruction_simplifier (after) 1359b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: TypeConversion 1360b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-NOT: TypeConversion 1361b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1362b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static int floatToDoubleToInt(float value) { 1363b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Lossless conversion followed by another conversion. 1364b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (int) (double) value; 1365b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1366b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1367b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: java.lang.String Main.floatToDoubleToIntPrint(float) instruction_simplifier (before) 1368b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:f\d+>> ParameterValue 1369b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] 1370b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: {{i\d+}} TypeConversion [<<Double>>] 1371b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1372b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: java.lang.String Main.floatToDoubleToIntPrint(float) instruction_simplifier (after) 1373b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:f\d+>> ParameterValue 1374b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] 1375b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: {{i\d+}} TypeConversion [<<Double>>] 1376b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1377b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static String floatToDoubleToIntPrint(float value) { 1378b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Lossless conversion followed by another conversion with 1379b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // an extra use of the intermediate result. 1380b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko double d = (double) value; 1381b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko int i = (int) d; 1382b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return "d=" + d + ", i=" + i; 1383b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1384b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1385b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: short Main.byteToDoubleToShort(byte) instruction_simplifier (before) 1386b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:b\d+>> ParameterValue 1387b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] 1388b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Double>>] 1389b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Int>>] 1390b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Short>>] 1391b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1392b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: short Main.byteToDoubleToShort(byte) instruction_simplifier (after) 1393b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:b\d+>> ParameterValue 1394b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Arg>>] 1395b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1396b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: short Main.byteToDoubleToShort(byte) instruction_simplifier (after) 1397b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-NOT: TypeConversion 1398b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1399b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static short byteToDoubleToShort(byte value) { 1400b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Originally, this is byte->double->int->short. The first conversion is lossless, 1401b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // so we merge this with the second one to byte->int which we omit as it's an implicit 1402b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // conversion. Then we eliminate the resulting byte->short as an implicit conversion. 1403b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (short) (double) value; 1404b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1405b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1406b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: short Main.charToDoubleToShort(char) instruction_simplifier (before) 1407b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:c\d+>> ParameterValue 1408b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] 1409b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Double>>] 1410b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Int>>] 1411b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Short>>] 1412b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1413b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: short Main.charToDoubleToShort(char) instruction_simplifier (after) 1414b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:c\d+>> ParameterValue 1415b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Arg>>] 1416b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Short>>] 1417b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1418b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: short Main.charToDoubleToShort(char) instruction_simplifier (after) 1419b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: TypeConversion 1420b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-NOT: TypeConversion 1421b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1422b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static short charToDoubleToShort(char value) { 1423b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Originally, this is char->double->int->short. The first conversion is lossless, 1424b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // so we merge this with the second one to char->int which we omit as it's an implicit 1425b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // conversion. Then we are left with the resulting char->short conversion. 1426b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (short) (double) value; 1427b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1428b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1429b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: short Main.floatToIntToShort(float) instruction_simplifier (before) 1430b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:f\d+>> ParameterValue 1431b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] 1432b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Int>>] 1433b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Short>>] 1434b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1435b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: short Main.floatToIntToShort(float) instruction_simplifier (after) 1436b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:f\d+>> ParameterValue 1437b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] 1438b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Int>>] 1439b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Short>>] 1440b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1441b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static short floatToIntToShort(float value) { 1442b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Lossy FP to integral conversion followed by another conversion: no simplification. 1443b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (short) value; 1444b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1445b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1446b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.intToFloatToInt(int) instruction_simplifier (before) 1447b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 1448b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Float:f\d+>> TypeConversion [<<Arg>>] 1449b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Float>>] 1450b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Int>>] 1451b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1452b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.intToFloatToInt(int) instruction_simplifier (after) 1453b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 1454b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Float:f\d+>> TypeConversion [<<Arg>>] 1455b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Float>>] 1456b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Int>>] 1457b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1458b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static int intToFloatToInt(int value) { 1459b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Lossy integral to FP conversion followed another conversion: no simplification. 1460b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (int) (float) value; 1461b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1462b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1463b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: double Main.longToIntToDouble(long) instruction_simplifier (before) 1464b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 1465b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] 1466b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Int>>] 1467b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Double>>] 1468b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1469b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: double Main.longToIntToDouble(long) instruction_simplifier (after) 1470b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 1471b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] 1472b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Int>>] 1473b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Double>>] 1474b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1475b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static double longToIntToDouble(long value) { 1476b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Lossy long-to-int conversion followed an integral to FP conversion: no simplification. 1477b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (double) (int) value; 1478b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1479b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1480b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: long Main.longToIntToLong(long) instruction_simplifier (before) 1481b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 1482b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] 1483b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Long:j\d+>> TypeConversion [<<Int>>] 1484b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Long>>] 1485b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1486b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: long Main.longToIntToLong(long) instruction_simplifier (after) 1487b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 1488b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Arg>>] 1489b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Long:j\d+>> TypeConversion [<<Int>>] 1490b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Long>>] 1491b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1492b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static long longToIntToLong(long value) { 1493b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Lossy long-to-int conversion followed an int-to-long conversion: no simplification. 1494b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (long) (int) value; 1495b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1496b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1497b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: short Main.shortToCharToShort(short) instruction_simplifier (before) 1498b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:s\d+>> ParameterValue 1499b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<Arg>>] 1500b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<Char>>] 1501b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Short>>] 1502b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1503b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: short Main.shortToCharToShort(short) instruction_simplifier (after) 1504b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:s\d+>> ParameterValue 1505b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Arg>>] 1506b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1507b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static short shortToCharToShort(short value) { 1508b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Integral conversion followed by non-widening integral conversion to original type. 1509b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (short) (char) value; 1510b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1511b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1512b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.shortToLongToInt(short) instruction_simplifier (before) 1513b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:s\d+>> ParameterValue 1514b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Long:j\d+>> TypeConversion [<<Arg>>] 1515b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<Long>>] 1516b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Int>>] 1517b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1518b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: int Main.shortToLongToInt(short) instruction_simplifier (after) 1519b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:s\d+>> ParameterValue 1520b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Arg>>] 1521b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1522b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static int shortToLongToInt(short value) { 1523b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Integral conversion followed by non-widening integral conversion, use implicit conversion. 1524b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (int) (long) value; 1525b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1526b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1527b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: byte Main.shortToCharToByte(short) instruction_simplifier (before) 1528b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:s\d+>> ParameterValue 1529b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<Arg>>] 1530b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Byte:b\d+>> TypeConversion [<<Char>>] 1531b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Byte>>] 1532b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1533b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: byte Main.shortToCharToByte(short) instruction_simplifier (after) 1534b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:s\d+>> ParameterValue 1535b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Byte:b\d+>> TypeConversion [<<Arg>>] 1536b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: Return [<<Byte>>] 1537b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1538b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static byte shortToCharToByte(short value) { 1539b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Integral conversion followed by non-widening integral conversion losing bits 1540b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // from the original type. Simplify to use only one conversion. 1541b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return (byte) (char) value; 1542b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1543b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1544b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: java.lang.String Main.shortToCharToBytePrint(short) instruction_simplifier (before) 1545b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:s\d+>> ParameterValue 1546b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<Arg>>] 1547b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: {{b\d+}} TypeConversion [<<Char>>] 1548b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1549b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-START: java.lang.String Main.shortToCharToBytePrint(short) instruction_simplifier (after) 1550b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Arg:s\d+>> ParameterValue 1551b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<Arg>>] 1552b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko /// CHECK-DAG: {{b\d+}} TypeConversion [<<Char>>] 1553b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1554b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko public static String shortToCharToBytePrint(short value) { 1555b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // Integral conversion followed by non-widening integral conversion losing bits 1556b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko // from the original type with an extra use of the intermediate result. 1557b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko char c = (char) value; 1558b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko byte b = (byte) c; 1559b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko return "c=" + ((int) c) + ", b=" + ((int) b); // implicit conversions. 1560b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko } 1561b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 15628428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-START: byte Main.longAnd0xffToByte(long) instruction_simplifier (before) 15638428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 15648428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Mask:j\d+>> LongConstant 255 15658428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<And:j\d+>> And [<<Mask>>,<<Arg>>] 15668428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Int:i\d+>> TypeConversion [<<And>>] 15678428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Byte:b\d+>> TypeConversion [<<Int>>] 15688428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: Return [<<Byte>>] 15698428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko 15708428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-START: byte Main.longAnd0xffToByte(long) instruction_simplifier (after) 15718428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Arg:j\d+>> ParameterValue 15728428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Byte:b\d+>> TypeConversion [<<Arg>>] 15738428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: Return [<<Byte>>] 15748428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko 15758428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-START: byte Main.longAnd0xffToByte(long) instruction_simplifier (after) 15768428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-NOT: And 15778428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko 15788428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko public static byte longAnd0xffToByte(long value) { 15798428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko return (byte) (value & 0xff); 15808428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko } 15818428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko 15828428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-START: char Main.intAnd0x1ffffToChar(int) instruction_simplifier (before) 15838428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 15848428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Mask:i\d+>> IntConstant 131071 15858428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<And:i\d+>> And [<<Mask>>,<<Arg>>] 15868428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<And>>] 15878428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: Return [<<Char>>] 15888428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko 15898428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-START: char Main.intAnd0x1ffffToChar(int) instruction_simplifier (after) 15908428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 15918428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Char:c\d+>> TypeConversion [<<Arg>>] 15928428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: Return [<<Char>>] 15938428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko 15948428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-START: char Main.intAnd0x1ffffToChar(int) instruction_simplifier (after) 15958428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-NOT: And 15968428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko 15978428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko public static char intAnd0x1ffffToChar(int value) { 15988428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko // Keeping all significant bits and one more. 15998428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko return (char) (value & 0x1ffff); 16008428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko } 16018428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko 16028428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-START: short Main.intAnd0x17fffToShort(int) instruction_simplifier (before) 16038428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 16048428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Mask:i\d+>> IntConstant 98303 16058428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<And:i\d+>> And [<<Mask>>,<<Arg>>] 16068428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<And>>] 16078428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: Return [<<Short>>] 16088428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko 16098428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-START: short Main.intAnd0x17fffToShort(int) instruction_simplifier (after) 16108428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 16118428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Mask:i\d+>> IntConstant 98303 16128428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<And:i\d+>> And [<<Mask>>,<<Arg>>] 16138428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: <<Short:s\d+>> TypeConversion [<<And>>] 16148428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko /// CHECK-DAG: Return [<<Short>>] 16158428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko 16168428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko public static short intAnd0x17fffToShort(int value) { 16178428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko // No simplification: clearing a significant bit. 16188428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko return (short) (value & 0x17fff); 16198428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko } 16208428bd376e660df2ffceee72f797d1cfc6c66433Vladimir Marko 1621625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko /// CHECK-START: double Main.shortAnd0xffffToShortToDouble(short) instruction_simplifier (before) 1622625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko /// CHECK-DAG: <<Arg:s\d+>> ParameterValue 1623625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko /// CHECK-DAG: <<Mask:i\d+>> IntConstant 65535 1624625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko /// CHECK-DAG: <<And:i\d+>> And [<<Mask>>,<<Arg>>] 1625625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko /// CHECK-DAG: <<Same:s\d+>> TypeConversion [<<And>>] 1626625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Same>>] 1627625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko /// CHECK-DAG: Return [<<Double>>] 1628625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko 1629625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko /// CHECK-START: double Main.shortAnd0xffffToShortToDouble(short) instruction_simplifier (after) 1630625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko /// CHECK-DAG: <<Arg:s\d+>> ParameterValue 1631625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko /// CHECK-DAG: <<Double:d\d+>> TypeConversion [<<Arg>>] 1632625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko /// CHECK-DAG: Return [<<Double>>] 1633625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko 1634625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko public static double shortAnd0xffffToShortToDouble(short value) { 1635625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko short same = (short) (value & 0xffff); 1636625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko return (double) same; 1637625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko } 1638625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko 1639bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-START: int Main.intReverseCondition(int) instruction_simplifier (before) 1640bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 1641bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 1642bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<LE:z\d+>> LessThanOrEqual [<<Const42>>,<<Arg>>] 1643bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin 1644bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-START: int Main.intReverseCondition(int) instruction_simplifier (after) 1645bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<Arg:i\d+>> ParameterValue 1646bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<Const42:i\d+>> IntConstant 42 1647bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<GE:z\d+>> GreaterThanOrEqual [<<Arg>>,<<Const42>>] 1648bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin 1649bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin public static int intReverseCondition(int i) { 1650bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin return (42 > i) ? 13 : 54; 1651bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin } 1652bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin 1653bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-START: int Main.intReverseConditionNaN(int) instruction_simplifier (before) 1654bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<Const42:d\d+>> DoubleConstant 42 1655bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<Result:d\d+>> InvokeStaticOrDirect 1656bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<CMP:i\d+>> Compare [<<Const42>>,<<Result>>] 1657bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin 1658bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-START: int Main.intReverseConditionNaN(int) instruction_simplifier (after) 1659bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<Const42:d\d+>> DoubleConstant 42 1660bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<Result:d\d+>> InvokeStaticOrDirect 1661bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin /// CHECK-DAG: <<EQ:z\d+>> Equal [<<Result>>,<<Const42>>] 1662bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin 1663bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin public static int intReverseConditionNaN(int i) { 1664bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin return (42 != Math.sqrt(i)) ? 13 : 54; 1665bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin } 1666bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin 1667f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil public static int runSmaliTest(String name, boolean input) { 1668f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil try { 1669f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil Class<?> c = Class.forName("SmaliTests"); 1670f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil Method m = c.getMethod(name, new Class[] { boolean.class }); 1671f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil return (Integer) m.invoke(null, input); 1672f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil } catch (Exception ex) { 1673f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil throw new Error(ex); 1674f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil } 1675f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil } 1676f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil 1677bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shaminpublic static void main(String[] args) { 1678b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames int arg = 123456; 1679b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames 1680b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertLongEquals(Add0(arg), arg); 1681b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertIntEquals(AndAllOnes(arg), arg); 1682b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertLongEquals(Div1(arg), arg); 1683b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertIntEquals(DivN1(arg), -arg); 1684b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertLongEquals(Mul1(arg), arg); 1685b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertIntEquals(MulN1(arg), -arg); 1686b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertLongEquals(MulPowerOfTwo128(arg), (128 * arg)); 1687b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertIntEquals(Or0(arg), arg); 1688b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertLongEquals(OrSame(arg), arg); 1689b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertIntEquals(Shl0(arg), arg); 1690b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertLongEquals(Shr0(arg), arg); 1691164306e779de522efba7df637618a8eeed9e37acVladimir Marko assertLongEquals(Shr64(arg), arg); 1692b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertLongEquals(Sub0(arg), arg); 1693b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertIntEquals(SubAliasNeg(arg), -arg); 1694b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertLongEquals(UShr0(arg), arg); 1695b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertIntEquals(Xor0(arg), arg); 1696b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames assertIntEquals(XorAllOnes(arg), ~arg); 1697188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertIntEquals(AddNegs1(arg, arg + 1), -(arg + arg + 1)); 1698188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertIntEquals(AddNegs2(arg, arg + 1), -(arg + arg + 1)); 1699188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertLongEquals(AddNegs3(arg, arg + 1), -(2 * arg + 1)); 1700188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertLongEquals(AddNeg1(arg, arg + 1), 1); 1701188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertLongEquals(AddNeg2(arg, arg + 1), -1); 1702188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertLongEquals(NegNeg1(arg), arg); 1703188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertIntEquals(NegNeg2(arg), 0); 1704188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertLongEquals(NegNeg3(arg), arg); 1705188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertIntEquals(NegSub1(arg, arg + 1), 1); 1706188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertIntEquals(NegSub2(arg, arg + 1), 1); 1707188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertLongEquals(NotNot1(arg), arg); 1708188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertIntEquals(NotNot2(arg), -1); 1709188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertIntEquals(SubNeg1(arg, arg + 1), -(arg + arg + 1)); 1710188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertIntEquals(SubNeg2(arg, arg + 1), -(arg + arg + 1)); 1711188d4316a880ae24aed315aa52dc503c4fcb1ec7Alexandre Rames assertLongEquals(SubNeg3(arg, arg + 1), -(2 * arg + 1)); 171274eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil assertBooleanEquals(EqualBoolVsIntConst(true), true); 171374eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil assertBooleanEquals(EqualBoolVsIntConst(true), true); 171474eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil assertBooleanEquals(NotEqualBoolVsIntConst(false), false); 171574eb1b264691c4eb399d0858015a7fc13c476ac6David Brazdil assertBooleanEquals(NotEqualBoolVsIntConst(false), false); 17160d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil assertBooleanEquals(NotNotBool(true), true); 17170d13fee6f4330cc9cb100c43135490a34c11d7a5David Brazdil assertBooleanEquals(NotNotBool(false), false); 17180d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray assertFloatEquals(Div2(100.0f), 50.0f); 17190d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray assertDoubleEquals(Div2(150.0), 75.0); 17200d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray assertFloatEquals(DivMP25(100.0f), -400.0f); 17210d22184ec9e5b1e958c031ac92c7f053de3a13a2Nicolas Geoffray assertDoubleEquals(DivMP25(150.0), -600.0); 1722452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko assertIntEquals(UShr28And15(0xc1234567), 0xc); 1723452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko assertLongEquals(UShr60And15(0xc123456787654321L), 0xcL); 1724452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko assertIntEquals(UShr28And7(0xc1234567), 0x4); 1725452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko assertLongEquals(UShr60And7(0xc123456787654321L), 0x4L); 1726452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko assertIntEquals(Shr24And255(0xc1234567), 0xc1); 1727452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko assertLongEquals(Shr56And255(0xc123456787654321L), 0xc1L); 1728452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko assertIntEquals(Shr24And127(0xc1234567), 0x41); 1729452c1b60120aee0883c3339b363f820b8d69c299Vladimir Marko assertLongEquals(Shr56And127(0xc123456787654321L), 0x41L); 173038db785600757a832423e076b3cf0af3bee942d8Alexandre Rames assertIntEquals(0, mulPow2Plus1(0)); 173138db785600757a832423e076b3cf0af3bee942d8Alexandre Rames assertIntEquals(9, mulPow2Plus1(1)); 173238db785600757a832423e076b3cf0af3bee942d8Alexandre Rames assertIntEquals(18, mulPow2Plus1(2)); 173338db785600757a832423e076b3cf0af3bee942d8Alexandre Rames assertIntEquals(900, mulPow2Plus1(100)); 173438db785600757a832423e076b3cf0af3bee942d8Alexandre Rames assertIntEquals(111105, mulPow2Plus1(12345)); 173538db785600757a832423e076b3cf0af3bee942d8Alexandre Rames assertLongEquals(0, mulPow2Minus1(0)); 173638db785600757a832423e076b3cf0af3bee942d8Alexandre Rames assertLongEquals(31, mulPow2Minus1(1)); 173738db785600757a832423e076b3cf0af3bee942d8Alexandre Rames assertLongEquals(62, mulPow2Minus1(2)); 173838db785600757a832423e076b3cf0af3bee942d8Alexandre Rames assertLongEquals(3100, mulPow2Minus1(100)); 173938db785600757a832423e076b3cf0af3bee942d8Alexandre Rames assertLongEquals(382695, mulPow2Minus1(12345)); 1740f652917de5634b30c974c81d35a72871915b352aMark Mendell 1741f652917de5634b30c974c81d35a72871915b352aMark Mendell booleanField = false; 1742f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(booleanFieldNotEqualOne(), 54); 1743f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(booleanFieldEqualZero(), 54); 1744f652917de5634b30c974c81d35a72871915b352aMark Mendell booleanField = true; 1745f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(booleanFieldNotEqualOne(), 13); 1746f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(booleanFieldEqualZero(), 13); 1747f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(intConditionNotEqualOne(6), 54); 1748f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(intConditionNotEqualOne(43), 13); 1749f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(intConditionEqualZero(6), 54); 1750f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(intConditionEqualZero(43), 13); 1751f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(floatConditionNotEqualOne(6.0f), 54); 1752f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(floatConditionNotEqualOne(43.0f), 13); 1753f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(doubleConditionEqualZero(6.0), 54); 1754f652917de5634b30c974c81d35a72871915b352aMark Mendell assertIntEquals(doubleConditionEqualZero(43.0), 13); 1755b52bbde2870e5ab5d126612961dcb3da8e5236eeVladimir Marko 1756625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(1234567, intToDoubleToInt(1234567)); 1757625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Integer.MIN_VALUE, intToDoubleToInt(Integer.MIN_VALUE)); 1758625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Integer.MAX_VALUE, intToDoubleToInt(Integer.MAX_VALUE)); 1759625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertStringEquals("d=7654321.0, i=7654321", intToDoubleToIntPrint(7654321)); 1760625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(12, byteToDoubleToInt((byte) 12)); 1761625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Byte.MIN_VALUE, byteToDoubleToInt(Byte.MIN_VALUE)); 1762625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Byte.MAX_VALUE, byteToDoubleToInt(Byte.MAX_VALUE)); 1763625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(11, floatToDoubleToInt(11.3f)); 1764625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertStringEquals("d=12.25, i=12", floatToDoubleToIntPrint(12.25f)); 1765625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(123, byteToDoubleToShort((byte) 123)); 1766625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Byte.MIN_VALUE, byteToDoubleToShort(Byte.MIN_VALUE)); 1767625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Byte.MAX_VALUE, byteToDoubleToShort(Byte.MAX_VALUE)); 1768625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(1234, charToDoubleToShort((char) 1234)); 1769625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Character.MIN_VALUE, charToDoubleToShort(Character.MIN_VALUE)); 1770625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(/* sign-extended */ -1, charToDoubleToShort(Character.MAX_VALUE)); 1771625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(12345, floatToIntToShort(12345.75f)); 1772625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Short.MAX_VALUE, floatToIntToShort((float)(Short.MIN_VALUE - 1))); 1773625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Short.MIN_VALUE, floatToIntToShort((float)(Short.MAX_VALUE + 1))); 1774625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(-54321, intToFloatToInt(-54321)); 1775625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertDoubleEquals((double) 0x12345678, longToIntToDouble(0x1234567812345678L)); 1776625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertDoubleEquals(0.0, longToIntToDouble(Long.MIN_VALUE)); 1777625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertDoubleEquals(-1.0, longToIntToDouble(Long.MAX_VALUE)); 1778625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertLongEquals(0x0000000012345678L, longToIntToLong(0x1234567812345678L)); 1779625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertLongEquals(0xffffffff87654321L, longToIntToLong(0x1234567887654321L)); 1780625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertLongEquals(0L, longToIntToLong(Long.MIN_VALUE)); 1781625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertLongEquals(-1L, longToIntToLong(Long.MAX_VALUE)); 1782625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals((short) -5678, shortToCharToShort((short) -5678)); 1783625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Short.MIN_VALUE, shortToCharToShort(Short.MIN_VALUE)); 1784625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Short.MAX_VALUE, shortToCharToShort(Short.MAX_VALUE)); 1785625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(5678, shortToLongToInt((short) 5678)); 1786625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Short.MIN_VALUE, shortToLongToInt(Short.MIN_VALUE)); 1787625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Short.MAX_VALUE, shortToLongToInt(Short.MAX_VALUE)); 1788625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(0x34, shortToCharToByte((short) 0x1234)); 1789625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(-0x10, shortToCharToByte((short) 0x12f0)); 1790625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(0, shortToCharToByte(Short.MIN_VALUE)); 1791625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(-1, shortToCharToByte(Short.MAX_VALUE)); 1792625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertStringEquals("c=1025, b=1", shortToCharToBytePrint((short) 1025)); 1793625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertStringEquals("c=1023, b=-1", shortToCharToBytePrint((short) 1023)); 1794625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertStringEquals("c=65535, b=-1", shortToCharToBytePrint((short) -1)); 1795625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko 1796625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(0x21, longAnd0xffToByte(0x1234432112344321L)); 1797625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(0, longAnd0xffToByte(Long.MIN_VALUE)); 1798625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(-1, longAnd0xffToByte(Long.MAX_VALUE)); 1799625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(0x1234, intAnd0x1ffffToChar(0x43211234)); 1800625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(0, intAnd0x1ffffToChar(Integer.MIN_VALUE)); 1801625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Character.MAX_VALUE, intAnd0x1ffffToChar(Integer.MAX_VALUE)); 1802625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(0x4321, intAnd0x17fffToShort(0x87654321)); 1803625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(0x0888, intAnd0x17fffToShort(0x88888888)); 1804625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(0, intAnd0x17fffToShort(Integer.MIN_VALUE)); 1805625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertIntEquals(Short.MAX_VALUE, intAnd0x17fffToShort(Integer.MAX_VALUE)); 1806625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko 1807625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertDoubleEquals(0.0, shortAnd0xffffToShortToDouble((short) 0)); 1808625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertDoubleEquals(1.0, shortAnd0xffffToShortToDouble((short) 1)); 1809625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertDoubleEquals(-2.0, shortAnd0xffffToShortToDouble((short) -2)); 1810625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertDoubleEquals(12345.0, shortAnd0xffffToShortToDouble((short) 12345)); 1811625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertDoubleEquals((double)Short.MAX_VALUE, shortAnd0xffffToShortToDouble(Short.MAX_VALUE)); 1812625090fe9bf47d8d735c9a66cbf491de3a3e3765Vladimir Marko assertDoubleEquals((double)Short.MIN_VALUE, shortAnd0xffffToShortToDouble(Short.MIN_VALUE)); 1813f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil 1814bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin assertIntEquals(intReverseCondition(41), 13); 1815bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin assertIntEquals(intReverseConditionNaN(-5), 13); 1816bdd7935c2adc3ad190ee87958e714a36f33cedaeAnton Shamin 1817f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil for (String condition : new String[] { "Equal", "NotEqual" }) { 1818f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil for (String constant : new String[] { "True", "False" }) { 1819f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil for (String side : new String[] { "Rhs", "Lhs" }) { 1820f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil String name = condition + constant + side; 1821f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil assertIntEquals(runSmaliTest(name, true), 5); 1822f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil assertIntEquals(runSmaliTest(name, false), 3); 1823f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil } 1824f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil } 1825f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil } 1826f652917de5634b30c974c81d35a72871915b352aMark Mendell } 1827f652917de5634b30c974c81d35a72871915b352aMark Mendell 1828f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil private static boolean $inline$true() { return true; } 1829f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil private static boolean $inline$false() { return false; } 1830f02c3cf66c2c24533f6da43970e7b766b2ca9938David Brazdil 1831f652917de5634b30c974c81d35a72871915b352aMark Mendell public static boolean booleanField; 1832b2fd7bca70b580921eebf7c45769c39d2dfd8a5aAlexandre Rames} 1833