1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17import java.lang.reflect.Method;
18
19public class Main {
20
21  public static void assertBooleanEquals(boolean expected, boolean result) {
22    if (expected != result) {
23      throw new Error("Expected: " + expected + ", found: " + result);
24    }
25  }
26
27  public static void assertIntEquals(int expected, int result) {
28    if (expected != result) {
29      throw new Error("Expected: " + expected + ", found: " + result);
30    }
31  }
32
33  public static void assertLongEquals(long expected, long result) {
34    if (expected != result) {
35      throw new Error("Expected: " + expected + ", found: " + result);
36    }
37  }
38
39  public static void assertFloatEquals(float expected, float result) {
40    if (expected != result) {
41      throw new Error("Expected: " + expected + ", found: " + result);
42    }
43  }
44
45  public static void assertDoubleEquals(double expected, double result) {
46    if (expected != result) {
47      throw new Error("Expected: " + expected + ", found: " + result);
48    }
49  }
50
51  public static void assertStringEquals(String expected, String result) {
52    if (expected == null ? result != null : !expected.equals(result)) {
53      throw new Error("Expected: " + expected + ", found: " + result);
54    }
55  }
56
57  /**
58   * Tiny programs exercising optimizations of arithmetic identities.
59   */
60
61  /// CHECK-START: long Main.Add0(long) instruction_simplifier (before)
62  /// CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
63  /// CHECK-DAG:     <<Const0:j\d+>>  LongConstant 0
64  /// CHECK-DAG:     <<Add:j\d+>>     Add [<<Const0>>,<<Arg>>]
65  /// CHECK-DAG:                      Return [<<Add>>]
66
67  /// CHECK-START: long Main.Add0(long) instruction_simplifier (after)
68  /// CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
69  /// CHECK-DAG:                      Return [<<Arg>>]
70
71  /// CHECK-START: long Main.Add0(long) instruction_simplifier (after)
72  /// CHECK-NOT:                        Add
73
74  public static long Add0(long arg) {
75    return 0 + arg;
76  }
77
78  /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (before)
79  /// CHECK-DAG:     <<Arg:i\d+>>     ParameterValue
80  /// CHECK-DAG:     <<ConstF:i\d+>>  IntConstant -1
81  /// CHECK-DAG:     <<And:i\d+>>     And [<<Arg>>,<<ConstF>>]
82  /// CHECK-DAG:                      Return [<<And>>]
83
84  /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
85  /// CHECK-DAG:     <<Arg:i\d+>>     ParameterValue
86  /// CHECK-DAG:                      Return [<<Arg>>]
87
88  /// CHECK-START: int Main.AndAllOnes(int) instruction_simplifier (after)
89  /// CHECK-NOT:                      And
90
91  public static int AndAllOnes(int arg) {
92    return arg & -1;
93  }
94
95  /// CHECK-START: int Main.UShr28And15(int) instruction_simplifier (before)
96  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
97  /// CHECK-DAG:     <<Const28:i\d+>>  IntConstant 28
98  /// CHECK-DAG:     <<Const15:i\d+>>  IntConstant 15
99  /// CHECK-DAG:     <<UShr:i\d+>>     UShr [<<Arg>>,<<Const28>>]
100  /// CHECK-DAG:     <<And:i\d+>>      And [<<UShr>>,<<Const15>>]
101  /// CHECK-DAG:                       Return [<<And>>]
102
103  /// CHECK-START: int Main.UShr28And15(int) instruction_simplifier (after)
104  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
105  /// CHECK-DAG:     <<Const28:i\d+>>  IntConstant 28
106  /// CHECK-DAG:     <<UShr:i\d+>>     UShr [<<Arg>>,<<Const28>>]
107  /// CHECK-DAG:                       Return [<<UShr>>]
108
109  /// CHECK-START: int Main.UShr28And15(int) instruction_simplifier (after)
110  /// CHECK-NOT:                       And
111
112  public static int UShr28And15(int arg) {
113    return (arg >>> 28) & 15;
114  }
115
116  /// CHECK-START: long Main.UShr60And15(long) instruction_simplifier (before)
117  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
118  /// CHECK-DAG:     <<Const60:i\d+>>  IntConstant 60
119  /// CHECK-DAG:     <<Const15:j\d+>>  LongConstant 15
120  /// CHECK-DAG:     <<UShr:j\d+>>     UShr [<<Arg>>,<<Const60>>]
121  /// CHECK-DAG:     <<And:j\d+>>      And [<<UShr>>,<<Const15>>]
122  /// CHECK-DAG:                       Return [<<And>>]
123
124  /// CHECK-START: long Main.UShr60And15(long) instruction_simplifier (after)
125  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
126  /// CHECK-DAG:     <<Const60:i\d+>>  IntConstant 60
127  /// CHECK-DAG:     <<UShr:j\d+>>     UShr [<<Arg>>,<<Const60>>]
128  /// CHECK-DAG:                       Return [<<UShr>>]
129
130  /// CHECK-START: long Main.UShr60And15(long) instruction_simplifier (after)
131  /// CHECK-NOT:                       And
132
133  public static long UShr60And15(long arg) {
134    return (arg >>> 60) & 15;
135  }
136
137  /// CHECK-START: int Main.UShr28And7(int) instruction_simplifier (before)
138  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
139  /// CHECK-DAG:     <<Const28:i\d+>>  IntConstant 28
140  /// CHECK-DAG:     <<Const7:i\d+>>   IntConstant 7
141  /// CHECK-DAG:     <<UShr:i\d+>>     UShr [<<Arg>>,<<Const28>>]
142  /// CHECK-DAG:     <<And:i\d+>>      And [<<UShr>>,<<Const7>>]
143  /// CHECK-DAG:                       Return [<<And>>]
144
145  /// CHECK-START: int Main.UShr28And7(int) instruction_simplifier (after)
146  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
147  /// CHECK-DAG:     <<Const28:i\d+>>  IntConstant 28
148  /// CHECK-DAG:     <<Const7:i\d+>>   IntConstant 7
149  /// CHECK-DAG:     <<UShr:i\d+>>     UShr [<<Arg>>,<<Const28>>]
150  /// CHECK-DAG:     <<And:i\d+>>      And [<<UShr>>,<<Const7>>]
151  /// CHECK-DAG:                       Return [<<And>>]
152
153  public static int UShr28And7(int arg) {
154    return (arg >>> 28) & 7;
155  }
156
157  /// CHECK-START: long Main.UShr60And7(long) instruction_simplifier (before)
158  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
159  /// CHECK-DAG:     <<Const60:i\d+>>  IntConstant 60
160  /// CHECK-DAG:     <<Const7:j\d+>>   LongConstant 7
161  /// CHECK-DAG:     <<UShr:j\d+>>     UShr [<<Arg>>,<<Const60>>]
162  /// CHECK-DAG:     <<And:j\d+>>      And [<<UShr>>,<<Const7>>]
163  /// CHECK-DAG:                       Return [<<And>>]
164
165  /// CHECK-START: long Main.UShr60And7(long) instruction_simplifier (after)
166  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
167  /// CHECK-DAG:     <<Const60:i\d+>>  IntConstant 60
168  /// CHECK-DAG:     <<Const7:j\d+>>   LongConstant 7
169  /// CHECK-DAG:     <<UShr:j\d+>>     UShr [<<Arg>>,<<Const60>>]
170  /// CHECK-DAG:     <<And:j\d+>>      And [<<UShr>>,<<Const7>>]
171  /// CHECK-DAG:                       Return [<<And>>]
172
173  public static long UShr60And7(long arg) {
174    return (arg >>> 60) & 7;
175  }
176
177  /// CHECK-START: int Main.Shr24And255(int) instruction_simplifier (before)
178  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
179  /// CHECK-DAG:     <<Const24:i\d+>>  IntConstant 24
180  /// CHECK-DAG:     <<Const255:i\d+>> IntConstant 255
181  /// CHECK-DAG:     <<Shr:i\d+>>      Shr [<<Arg>>,<<Const24>>]
182  /// CHECK-DAG:     <<And:i\d+>>      And [<<Shr>>,<<Const255>>]
183  /// CHECK-DAG:                       Return [<<And>>]
184
185  /// CHECK-START: int Main.Shr24And255(int) instruction_simplifier (after)
186  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
187  /// CHECK-DAG:     <<Const24:i\d+>>  IntConstant 24
188  /// CHECK-DAG:     <<UShr:i\d+>>     UShr [<<Arg>>,<<Const24>>]
189  /// CHECK-DAG:                       Return [<<UShr>>]
190
191  /// CHECK-START: int Main.Shr24And255(int) instruction_simplifier (after)
192  /// CHECK-NOT:                       Shr
193  /// CHECK-NOT:                       And
194
195  public static int Shr24And255(int arg) {
196    return (arg >> 24) & 255;
197  }
198
199  /// CHECK-START: long Main.Shr56And255(long) instruction_simplifier (before)
200  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
201  /// CHECK-DAG:     <<Const56:i\d+>>  IntConstant 56
202  /// CHECK-DAG:     <<Const255:j\d+>> LongConstant 255
203  /// CHECK-DAG:     <<Shr:j\d+>>      Shr [<<Arg>>,<<Const56>>]
204  /// CHECK-DAG:     <<And:j\d+>>      And [<<Shr>>,<<Const255>>]
205  /// CHECK-DAG:                       Return [<<And>>]
206
207  /// CHECK-START: long Main.Shr56And255(long) instruction_simplifier (after)
208  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
209  /// CHECK-DAG:     <<Const56:i\d+>>  IntConstant 56
210  /// CHECK-DAG:     <<UShr:j\d+>>     UShr [<<Arg>>,<<Const56>>]
211  /// CHECK-DAG:                       Return [<<UShr>>]
212
213  /// CHECK-START: long Main.Shr56And255(long) instruction_simplifier (after)
214  /// CHECK-NOT:                       Shr
215  /// CHECK-NOT:                       And
216
217  public static long Shr56And255(long arg) {
218    return (arg >> 56) & 255;
219  }
220
221  /// CHECK-START: int Main.Shr24And127(int) instruction_simplifier (before)
222  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
223  /// CHECK-DAG:     <<Const24:i\d+>>  IntConstant 24
224  /// CHECK-DAG:     <<Const127:i\d+>> IntConstant 127
225  /// CHECK-DAG:     <<Shr:i\d+>>      Shr [<<Arg>>,<<Const24>>]
226  /// CHECK-DAG:     <<And:i\d+>>      And [<<Shr>>,<<Const127>>]
227  /// CHECK-DAG:                       Return [<<And>>]
228
229  /// CHECK-START: int Main.Shr24And127(int) instruction_simplifier (after)
230  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
231  /// CHECK-DAG:     <<Const24:i\d+>>  IntConstant 24
232  /// CHECK-DAG:     <<Const127:i\d+>> IntConstant 127
233  /// CHECK-DAG:     <<Shr:i\d+>>      Shr [<<Arg>>,<<Const24>>]
234  /// CHECK-DAG:     <<And:i\d+>>      And [<<Shr>>,<<Const127>>]
235  /// CHECK-DAG:                       Return [<<And>>]
236
237  public static int Shr24And127(int arg) {
238    return (arg >> 24) & 127;
239  }
240
241  /// CHECK-START: long Main.Shr56And127(long) instruction_simplifier (before)
242  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
243  /// CHECK-DAG:     <<Const56:i\d+>>  IntConstant 56
244  /// CHECK-DAG:     <<Const127:j\d+>> LongConstant 127
245  /// CHECK-DAG:     <<Shr:j\d+>>      Shr [<<Arg>>,<<Const56>>]
246  /// CHECK-DAG:     <<And:j\d+>>      And [<<Shr>>,<<Const127>>]
247  /// CHECK-DAG:                       Return [<<And>>]
248
249  /// CHECK-START: long Main.Shr56And127(long) instruction_simplifier (after)
250  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
251  /// CHECK-DAG:     <<Const56:i\d+>>  IntConstant 56
252  /// CHECK-DAG:     <<Const127:j\d+>> LongConstant 127
253  /// CHECK-DAG:     <<Shr:j\d+>>      Shr [<<Arg>>,<<Const56>>]
254  /// CHECK-DAG:     <<And:j\d+>>      And [<<Shr>>,<<Const127>>]
255  /// CHECK-DAG:                       Return [<<And>>]
256
257  public static long Shr56And127(long arg) {
258    return (arg >> 56) & 127;
259  }
260
261  /// CHECK-START: long Main.Div1(long) instruction_simplifier (before)
262  /// CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
263  /// CHECK-DAG:     <<Const1:j\d+>>  LongConstant 1
264  /// CHECK-DAG:     <<Div:j\d+>>     Div [<<Arg>>,<<Const1>>]
265  /// CHECK-DAG:                      Return [<<Div>>]
266
267  /// CHECK-START: long Main.Div1(long) instruction_simplifier (after)
268  /// CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
269  /// CHECK-DAG:                      Return [<<Arg>>]
270
271  /// CHECK-START: long Main.Div1(long) instruction_simplifier (after)
272  /// CHECK-NOT:                      Div
273
274  public static long Div1(long arg) {
275    return arg / 1;
276  }
277
278  /// CHECK-START: int Main.DivN1(int) instruction_simplifier (before)
279  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
280  /// CHECK-DAG:     <<ConstN1:i\d+>>  IntConstant -1
281  /// CHECK-DAG:     <<Div:i\d+>>      Div [<<Arg>>,<<ConstN1>>]
282  /// CHECK-DAG:                       Return [<<Div>>]
283
284  /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
285  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
286  /// CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg>>]
287  /// CHECK-DAG:                       Return [<<Neg>>]
288
289  /// CHECK-START: int Main.DivN1(int) instruction_simplifier (after)
290  /// CHECK-NOT:                       Div
291
292  public static int DivN1(int arg) {
293    return arg / -1;
294  }
295
296  /// CHECK-START: long Main.Mul1(long) instruction_simplifier (before)
297  /// CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
298  /// CHECK-DAG:     <<Const1:j\d+>>  LongConstant 1
299  /// CHECK-DAG:     <<Mul:j\d+>>     Mul [<<Const1>>,<<Arg>>]
300  /// CHECK-DAG:                      Return [<<Mul>>]
301
302  /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
303  /// CHECK-DAG:     <<Arg:j\d+>>     ParameterValue
304  /// CHECK-DAG:                      Return [<<Arg>>]
305
306  /// CHECK-START: long Main.Mul1(long) instruction_simplifier (after)
307  /// CHECK-NOT:                       Mul
308
309  public static long Mul1(long arg) {
310    return arg * 1;
311  }
312
313  /// CHECK-START: int Main.MulN1(int) instruction_simplifier (before)
314  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
315  /// CHECK-DAG:     <<ConstN1:i\d+>>  IntConstant -1
316  /// CHECK-DAG:     <<Mul:i\d+>>      Mul [<<Arg>>,<<ConstN1>>]
317  /// CHECK-DAG:                       Return [<<Mul>>]
318
319  /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
320  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
321  /// CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg>>]
322  /// CHECK-DAG:                       Return [<<Neg>>]
323
324  /// CHECK-START: int Main.MulN1(int) instruction_simplifier (after)
325  /// CHECK-NOT:                       Mul
326
327  public static int MulN1(int arg) {
328    return arg * -1;
329  }
330
331  /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (before)
332  /// CHECK-DAG:     <<Arg:j\d+>>       ParameterValue
333  /// CHECK-DAG:     <<Const128:j\d+>>  LongConstant 128
334  /// CHECK-DAG:     <<Mul:j\d+>>       Mul [<<Const128>>,<<Arg>>]
335  /// CHECK-DAG:                        Return [<<Mul>>]
336
337  /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
338  /// CHECK-DAG:     <<Arg:j\d+>>       ParameterValue
339  /// CHECK-DAG:     <<Const7:i\d+>>    IntConstant 7
340  /// CHECK-DAG:     <<Shl:j\d+>>       Shl [<<Arg>>,<<Const7>>]
341  /// CHECK-DAG:                        Return [<<Shl>>]
342
343  /// CHECK-START: long Main.MulPowerOfTwo128(long) instruction_simplifier (after)
344  /// CHECK-NOT:                        Mul
345
346  public static long MulPowerOfTwo128(long arg) {
347    return arg * 128;
348  }
349
350  /// CHECK-START: int Main.Or0(int) instruction_simplifier (before)
351  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
352  /// CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
353  /// CHECK-DAG:     <<Or:i\d+>>       Or [<<Arg>>,<<Const0>>]
354  /// CHECK-DAG:                       Return [<<Or>>]
355
356  /// CHECK-START: int Main.Or0(int) instruction_simplifier (after)
357  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
358  /// CHECK-DAG:                       Return [<<Arg>>]
359
360  /// CHECK-START: int Main.Or0(int) instruction_simplifier (after)
361  /// CHECK-NOT:                       Or
362
363  public static int Or0(int arg) {
364    return arg | 0;
365  }
366
367  /// CHECK-START: long Main.OrSame(long) instruction_simplifier (before)
368  /// CHECK-DAG:     <<Arg:j\d+>>       ParameterValue
369  /// CHECK-DAG:     <<Or:j\d+>>        Or [<<Arg>>,<<Arg>>]
370  /// CHECK-DAG:                        Return [<<Or>>]
371
372  /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
373  /// CHECK-DAG:     <<Arg:j\d+>>       ParameterValue
374  /// CHECK-DAG:                        Return [<<Arg>>]
375
376  /// CHECK-START: long Main.OrSame(long) instruction_simplifier (after)
377  /// CHECK-NOT:                        Or
378
379  public static long OrSame(long arg) {
380    return arg | arg;
381  }
382
383  /// CHECK-START: int Main.Shl0(int) instruction_simplifier (before)
384  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
385  /// CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
386  /// CHECK-DAG:     <<Shl:i\d+>>      Shl [<<Arg>>,<<Const0>>]
387  /// CHECK-DAG:                       Return [<<Shl>>]
388
389  /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
390  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
391  /// CHECK-DAG:                       Return [<<Arg>>]
392
393  /// CHECK-START: int Main.Shl0(int) instruction_simplifier (after)
394  /// CHECK-NOT:                       Shl
395
396  public static int Shl0(int arg) {
397    return arg << 0;
398  }
399
400  /// CHECK-START: long Main.Shr0(long) instruction_simplifier (before)
401  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
402  /// CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
403  /// CHECK-DAG:     <<Shr:j\d+>>      Shr [<<Arg>>,<<Const0>>]
404  /// CHECK-DAG:                       Return [<<Shr>>]
405
406  /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
407  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
408  /// CHECK-DAG:                       Return [<<Arg>>]
409
410  /// CHECK-START: long Main.Shr0(long) instruction_simplifier (after)
411  /// CHECK-NOT:                       Shr
412
413  public static long Shr0(long arg) {
414    return arg >> 0;
415  }
416
417  /// CHECK-START: long Main.Shr64(long) instruction_simplifier (before)
418  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
419  /// CHECK-DAG:     <<Const64:i\d+>>  IntConstant 64
420  /// CHECK-DAG:     <<Shr:j\d+>>      Shr [<<Arg>>,<<Const64>>]
421  /// CHECK-DAG:                       Return [<<Shr>>]
422
423  /// CHECK-START: long Main.Shr64(long) instruction_simplifier (after)
424  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
425  /// CHECK-DAG:                       Return [<<Arg>>]
426
427  /// CHECK-START: long Main.Shr64(long) instruction_simplifier (after)
428  /// CHECK-NOT:                       Shr
429
430  public static long Shr64(long arg) {
431    return arg >> 64;
432  }
433
434  /// CHECK-START: long Main.Sub0(long) instruction_simplifier (before)
435  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
436  /// CHECK-DAG:     <<Const0:j\d+>>   LongConstant 0
437  /// CHECK-DAG:     <<Sub:j\d+>>      Sub [<<Arg>>,<<Const0>>]
438  /// CHECK-DAG:                       Return [<<Sub>>]
439
440  /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
441  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
442  /// CHECK-DAG:                       Return [<<Arg>>]
443
444  /// CHECK-START: long Main.Sub0(long) instruction_simplifier (after)
445  /// CHECK-NOT:                       Sub
446
447  public static long Sub0(long arg) {
448    return arg - 0;
449  }
450
451  /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (before)
452  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
453  /// CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
454  /// CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Const0>>,<<Arg>>]
455  /// CHECK-DAG:                       Return [<<Sub>>]
456
457  /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
458  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
459  /// CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg>>]
460  /// CHECK-DAG:                       Return [<<Neg>>]
461
462  /// CHECK-START: int Main.SubAliasNeg(int) instruction_simplifier (after)
463  /// CHECK-NOT:                       Sub
464
465  public static int SubAliasNeg(int arg) {
466    return 0 - arg;
467  }
468
469  /// CHECK-START: long Main.UShr0(long) instruction_simplifier (before)
470  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
471  /// CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
472  /// CHECK-DAG:     <<UShr:j\d+>>     UShr [<<Arg>>,<<Const0>>]
473  /// CHECK-DAG:                       Return [<<UShr>>]
474
475  /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
476  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
477  /// CHECK-DAG:                       Return [<<Arg>>]
478
479  /// CHECK-START: long Main.UShr0(long) instruction_simplifier (after)
480  /// CHECK-NOT:                       UShr
481
482  public static long UShr0(long arg) {
483    return arg >>> 0;
484  }
485
486  /// CHECK-START: int Main.Xor0(int) instruction_simplifier (before)
487  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
488  /// CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
489  /// CHECK-DAG:     <<Xor:i\d+>>      Xor [<<Arg>>,<<Const0>>]
490  /// CHECK-DAG:                       Return [<<Xor>>]
491
492  /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
493  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
494  /// CHECK-DAG:                       Return [<<Arg>>]
495
496  /// CHECK-START: int Main.Xor0(int) instruction_simplifier (after)
497  /// CHECK-NOT:                       Xor
498
499  public static int Xor0(int arg) {
500    return arg ^ 0;
501  }
502
503  /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (before)
504  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
505  /// CHECK-DAG:     <<ConstF:i\d+>>   IntConstant -1
506  /// CHECK-DAG:     <<Xor:i\d+>>      Xor [<<Arg>>,<<ConstF>>]
507  /// CHECK-DAG:                       Return [<<Xor>>]
508
509  /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
510  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
511  /// CHECK-DAG:     <<Not:i\d+>>      Not [<<Arg>>]
512  /// CHECK-DAG:                       Return [<<Not>>]
513
514  /// CHECK-START: int Main.XorAllOnes(int) instruction_simplifier (after)
515  /// CHECK-NOT:                       Xor
516
517  public static int XorAllOnes(int arg) {
518    return arg ^ -1;
519  }
520
521  /**
522   * Test that addition or subtraction operation with both inputs negated are
523   * optimized to use a single negation after the operation.
524   * The transformation tested is implemented in
525   * `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`.
526   */
527
528  /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (before)
529  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
530  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
531  /// CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Arg1>>]
532  /// CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Arg2>>]
533  /// CHECK-DAG:     <<Add:i\d+>>      Add [<<Neg1>>,<<Neg2>>]
534  /// CHECK-DAG:                       Return [<<Add>>]
535
536  /// CHECK-START: int Main.AddNegs1(int, int) instruction_simplifier (after)
537  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
538  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
539  /// CHECK-NOT:                       Neg
540  /// CHECK-DAG:     <<Add:i\d+>>      Add [<<Arg1>>,<<Arg2>>]
541  /// CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Add>>]
542  /// CHECK-DAG:                       Return [<<Neg>>]
543
544  public static int AddNegs1(int arg1, int arg2) {
545    return -arg1 + -arg2;
546  }
547
548  /**
549   * This is similar to the test-case AddNegs1, but the negations have
550   * multiple uses.
551   * The transformation tested is implemented in
552   * `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`.
553   * The current code won't perform the previous optimization. The
554   * transformations do not look at other uses of their inputs. As they don't
555   * know what will happen with other uses, they do not take the risk of
556   * increasing the register pressure by creating or extending live ranges.
557   */
558
559  /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (before)
560  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
561  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
562  /// CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Arg1>>]
563  /// CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Arg2>>]
564  /// CHECK-DAG:     <<Add1:i\d+>>     Add [<<Neg1>>,<<Neg2>>]
565  /// CHECK-DAG:     <<Add2:i\d+>>     Add [<<Neg1>>,<<Neg2>>]
566  /// CHECK-DAG:     <<Or:i\d+>>       Or [<<Add1>>,<<Add2>>]
567  /// CHECK-DAG:                       Return [<<Or>>]
568
569  /// CHECK-START: int Main.AddNegs2(int, int) instruction_simplifier (after)
570  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
571  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
572  /// CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Arg1>>]
573  /// CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Arg2>>]
574  /// CHECK-DAG:     <<Add1:i\d+>>     Add [<<Neg1>>,<<Neg2>>]
575  /// CHECK-DAG:     <<Add2:i\d+>>     Add [<<Neg1>>,<<Neg2>>]
576  /// CHECK-NOT:                       Neg
577  /// CHECK-DAG:     <<Or:i\d+>>       Or [<<Add1>>,<<Add2>>]
578  /// CHECK-DAG:                       Return [<<Or>>]
579
580  /// CHECK-START: int Main.AddNegs2(int, int) GVN (after)
581  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
582  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
583  /// CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Arg1>>]
584  /// CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Arg2>>]
585  /// CHECK-DAG:     <<Add:i\d+>>      Add [<<Neg1>>,<<Neg2>>]
586  /// CHECK-DAG:     <<Or:i\d+>>       Or [<<Add>>,<<Add>>]
587  /// CHECK-DAG:                       Return [<<Or>>]
588
589  public static int AddNegs2(int arg1, int arg2) {
590    int temp1 = -arg1;
591    int temp2 = -arg2;
592    return (temp1 + temp2) | (temp1 + temp2);
593  }
594
595  /**
596   * This follows test-cases AddNegs1 and AddNegs2.
597   * The transformation tested is implemented in
598   * `InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop`.
599   * The optimization should not happen if it moves an additional instruction in
600   * the loop.
601   */
602
603  /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (before)
604  //  -------------- Arguments and initial negation operations.
605  /// CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
606  /// CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
607  /// CHECK-DAG:     <<Neg1:j\d+>>     Neg [<<Arg1>>]
608  /// CHECK-DAG:     <<Neg2:j\d+>>     Neg [<<Arg2>>]
609  /// CHECK:                           Goto
610  //  -------------- Loop
611  /// CHECK:                           SuspendCheck
612  /// CHECK:         <<Add:j\d+>>      Add [<<Neg1>>,<<Neg2>>]
613  /// CHECK:                           Goto
614
615  /// CHECK-START: long Main.AddNegs3(long, long) instruction_simplifier (after)
616  //  -------------- Arguments and initial negation operations.
617  /// CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
618  /// CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
619  /// CHECK-DAG:     <<Neg1:j\d+>>     Neg [<<Arg1>>]
620  /// CHECK-DAG:     <<Neg2:j\d+>>     Neg [<<Arg2>>]
621  /// CHECK:                           Goto
622  //  -------------- Loop
623  /// CHECK:                           SuspendCheck
624  /// CHECK:         <<Add:j\d+>>      Add [<<Neg1>>,<<Neg2>>]
625  /// CHECK-NOT:                       Neg
626  /// CHECK:                           Goto
627
628  public static long AddNegs3(long arg1, long arg2) {
629    long res = 0;
630    long n_arg1 = -arg1;
631    long n_arg2 = -arg2;
632    for (long i = 0; i < 1; i++) {
633      res += n_arg1 + n_arg2 + i;
634    }
635    return res;
636  }
637
638  /**
639   * Test the simplification of an addition with a negated argument into a
640   * subtraction.
641   * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitAdd`.
642   */
643
644  /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (before)
645  /// CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
646  /// CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
647  /// CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg1>>]
648  /// CHECK-DAG:     <<Add:j\d+>>      Add [<<Neg>>,<<Arg2>>]
649  /// CHECK-DAG:                       Return [<<Add>>]
650
651  /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
652  /// CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
653  /// CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
654  /// CHECK-DAG:     <<Sub:j\d+>>      Sub [<<Arg2>>,<<Arg1>>]
655  /// CHECK-DAG:                       Return [<<Sub>>]
656
657  /// CHECK-START: long Main.AddNeg1(long, long) instruction_simplifier (after)
658  /// CHECK-NOT:                       Neg
659  /// CHECK-NOT:                       Add
660
661  public static long AddNeg1(long arg1, long arg2) {
662    return -arg1 + arg2;
663  }
664
665  /**
666   * This is similar to the test-case AddNeg1, but the negation has two uses.
667   * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitAdd`.
668   * The current code won't perform the previous optimization. The
669   * transformations do not look at other uses of their inputs. As they don't
670   * know what will happen with other uses, they do not take the risk of
671   * increasing the register pressure by creating or extending live ranges.
672   */
673
674  /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (before)
675  /// CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
676  /// CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
677  /// CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg2>>]
678  /// CHECK-DAG:     <<Add1:j\d+>>     Add [<<Arg1>>,<<Neg>>]
679  /// CHECK-DAG:     <<Add2:j\d+>>     Add [<<Arg1>>,<<Neg>>]
680  /// CHECK-DAG:     <<Res:j\d+>>      Or [<<Add1>>,<<Add2>>]
681  /// CHECK-DAG:                       Return [<<Res>>]
682
683  /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
684  /// CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
685  /// CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
686  /// CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg2>>]
687  /// CHECK-DAG:     <<Add1:j\d+>>     Add [<<Arg1>>,<<Neg>>]
688  /// CHECK-DAG:     <<Add2:j\d+>>     Add [<<Arg1>>,<<Neg>>]
689  /// CHECK-DAG:     <<Res:j\d+>>      Or [<<Add1>>,<<Add2>>]
690  /// CHECK-DAG:                       Return [<<Res>>]
691
692  /// CHECK-START: long Main.AddNeg2(long, long) instruction_simplifier (after)
693  /// CHECK-NOT:                       Sub
694
695  public static long AddNeg2(long arg1, long arg2) {
696    long temp = -arg2;
697    return (arg1 + temp) | (arg1 + temp);
698  }
699
700  /**
701   * Test simplification of the `-(-var)` pattern.
702   * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`.
703   */
704
705  /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (before)
706  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
707  /// CHECK-DAG:     <<Neg1:j\d+>>     Neg [<<Arg>>]
708  /// CHECK-DAG:     <<Neg2:j\d+>>     Neg [<<Neg1>>]
709  /// CHECK-DAG:                       Return [<<Neg2>>]
710
711  /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
712  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
713  /// CHECK-DAG:                       Return [<<Arg>>]
714
715  /// CHECK-START: long Main.NegNeg1(long) instruction_simplifier (after)
716  /// CHECK-NOT:                       Neg
717
718  public static long NegNeg1(long arg) {
719    return -(-arg);
720  }
721
722  /**
723   * Test 'multi-step' simplification, where a first transformation yields a
724   * new simplification possibility for the current instruction.
725   * The transformations tested are implemented in `InstructionSimplifierVisitor::VisitNeg`
726   * and in `InstructionSimplifierVisitor::VisitAdd`.
727   */
728
729  /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (before)
730  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
731  /// CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Arg>>]
732  /// CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Neg1>>]
733  /// CHECK-DAG:     <<Add:i\d+>>      Add [<<Neg2>>,<<Neg1>>]
734  /// CHECK-DAG:                       Return [<<Add>>]
735
736  /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
737  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
738  /// CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Arg>>,<<Arg>>]
739  /// CHECK-DAG:                       Return [<<Sub>>]
740
741  /// CHECK-START: int Main.NegNeg2(int) instruction_simplifier (after)
742  /// CHECK-NOT:                       Neg
743  /// CHECK-NOT:                       Add
744
745  /// CHECK-START: int Main.NegNeg2(int) constant_folding_after_inlining (after)
746  /// CHECK:         <<Const0:i\d+>>   IntConstant 0
747  /// CHECK-NOT:                       Neg
748  /// CHECK-NOT:                       Add
749  /// CHECK:                           Return [<<Const0>>]
750
751  public static int NegNeg2(int arg) {
752    int temp = -arg;
753    return temp + -temp;
754  }
755
756  /**
757   * Test another 'multi-step' simplification, where a first transformation
758   * yields a new simplification possibility for the current instruction.
759   * The transformations tested are implemented in `InstructionSimplifierVisitor::VisitNeg`
760   * and in `InstructionSimplifierVisitor::VisitSub`.
761   */
762
763  /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (before)
764  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
765  /// CHECK-DAG:     <<Const0:j\d+>>   LongConstant 0
766  /// CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg>>]
767  /// CHECK-DAG:     <<Sub:j\d+>>      Sub [<<Const0>>,<<Neg>>]
768  /// CHECK-DAG:                       Return [<<Sub>>]
769
770  /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
771  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
772  /// CHECK-DAG:                       Return [<<Arg>>]
773
774  /// CHECK-START: long Main.NegNeg3(long) instruction_simplifier (after)
775  /// CHECK-NOT:                       Neg
776  /// CHECK-NOT:                       Sub
777
778  public static long NegNeg3(long arg) {
779    return 0 - -arg;
780  }
781
782  /**
783   * Test that a negated subtraction is simplified to a subtraction with its
784   * arguments reversed.
785   * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`.
786   */
787
788  /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (before)
789  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
790  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
791  /// CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Arg1>>,<<Arg2>>]
792  /// CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Sub>>]
793  /// CHECK-DAG:                       Return [<<Neg>>]
794
795  /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
796  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
797  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
798  /// CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Arg2>>,<<Arg1>>]
799  /// CHECK-DAG:                       Return [<<Sub>>]
800
801  /// CHECK-START: int Main.NegSub1(int, int) instruction_simplifier (after)
802  /// CHECK-NOT:                       Neg
803
804  public static int NegSub1(int arg1, int arg2) {
805    return -(arg1 - arg2);
806  }
807
808  /**
809   * This is similar to the test-case NegSub1, but the subtraction has
810   * multiple uses.
811   * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNeg`.
812   * The current code won't perform the previous optimization. The
813   * transformations do not look at other uses of their inputs. As they don't
814   * know what will happen with other uses, they do not take the risk of
815   * increasing the register pressure by creating or extending live ranges.
816   */
817
818  /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (before)
819  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
820  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
821  /// CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Arg1>>,<<Arg2>>]
822  /// CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Sub>>]
823  /// CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Sub>>]
824  /// CHECK-DAG:     <<Or:i\d+>>       Or [<<Neg1>>,<<Neg2>>]
825  /// CHECK-DAG:                       Return [<<Or>>]
826
827  /// CHECK-START: int Main.NegSub2(int, int) instruction_simplifier (after)
828  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
829  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
830  /// CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Arg1>>,<<Arg2>>]
831  /// CHECK-DAG:     <<Neg1:i\d+>>     Neg [<<Sub>>]
832  /// CHECK-DAG:     <<Neg2:i\d+>>     Neg [<<Sub>>]
833  /// CHECK-DAG:     <<Or:i\d+>>       Or [<<Neg1>>,<<Neg2>>]
834  /// CHECK-DAG:                       Return [<<Or>>]
835
836  public static int NegSub2(int arg1, int arg2) {
837    int temp = arg1 - arg2;
838    return -temp | -temp;
839  }
840
841  /**
842   * Test simplification of the `~~var` pattern.
843   * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitNot`.
844   */
845
846  /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (before)
847  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
848  /// CHECK-DAG:     <<Not1:j\d+>>     Not [<<Arg>>]
849  /// CHECK-DAG:     <<Not2:j\d+>>     Not [<<Not1>>]
850  /// CHECK-DAG:                       Return [<<Not2>>]
851
852  /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
853  /// CHECK-DAG:     <<Arg:j\d+>>      ParameterValue
854  /// CHECK-DAG:                       Return [<<Arg>>]
855
856  /// CHECK-START: long Main.NotNot1(long) instruction_simplifier (after)
857  /// CHECK-NOT:                       Not
858
859  public static long NotNot1(long arg) {
860    return ~~arg;
861  }
862
863  /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (before)
864  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
865  /// CHECK-DAG:     <<Not1:i\d+>>     Not [<<Arg>>]
866  /// CHECK-DAG:     <<Not2:i\d+>>     Not [<<Not1>>]
867  /// CHECK-DAG:     <<Add:i\d+>>      Add [<<Not2>>,<<Not1>>]
868  /// CHECK-DAG:                       Return [<<Add>>]
869
870  /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
871  /// CHECK-DAG:     <<Arg:i\d+>>      ParameterValue
872  /// CHECK-DAG:     <<Not:i\d+>>      Not [<<Arg>>]
873  /// CHECK-DAG:     <<Add:i\d+>>      Add [<<Arg>>,<<Not>>]
874  /// CHECK-DAG:                       Return [<<Add>>]
875
876  /// CHECK-START: int Main.NotNot2(int) instruction_simplifier (after)
877  /// CHECK:                           Not
878  /// CHECK-NOT:                       Not
879
880  public static int NotNot2(int arg) {
881    int temp = ~arg;
882    return temp + ~temp;
883  }
884
885  /**
886   * Test the simplification of a subtraction with a negated argument.
887   * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`.
888   */
889
890  /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (before)
891  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
892  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
893  /// CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg1>>]
894  /// CHECK-DAG:     <<Sub:i\d+>>      Sub [<<Neg>>,<<Arg2>>]
895  /// CHECK-DAG:                       Return [<<Sub>>]
896
897  /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
898  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
899  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
900  /// CHECK-DAG:     <<Add:i\d+>>      Add [<<Arg1>>,<<Arg2>>]
901  /// CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Add>>]
902  /// CHECK-DAG:                       Return [<<Neg>>]
903
904  /// CHECK-START: int Main.SubNeg1(int, int) instruction_simplifier (after)
905  /// CHECK-NOT:                       Sub
906
907  public static int SubNeg1(int arg1, int arg2) {
908    return -arg1 - arg2;
909  }
910
911  /**
912   * This is similar to the test-case SubNeg1, but the negation has
913   * multiple uses.
914   * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`.
915   * The current code won't perform the previous optimization. The
916   * transformations do not look at other uses of their inputs. As they don't
917   * know what will happen with other uses, they do not take the risk of
918   * increasing the register pressure by creating or extending live ranges.
919   */
920
921  /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (before)
922  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
923  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
924  /// CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg1>>]
925  /// CHECK-DAG:     <<Sub1:i\d+>>     Sub [<<Neg>>,<<Arg2>>]
926  /// CHECK-DAG:     <<Sub2:i\d+>>     Sub [<<Neg>>,<<Arg2>>]
927  /// CHECK-DAG:     <<Or:i\d+>>       Or [<<Sub1>>,<<Sub2>>]
928  /// CHECK-DAG:                       Return [<<Or>>]
929
930  /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
931  /// CHECK-DAG:     <<Arg1:i\d+>>     ParameterValue
932  /// CHECK-DAG:     <<Arg2:i\d+>>     ParameterValue
933  /// CHECK-DAG:     <<Neg:i\d+>>      Neg [<<Arg1>>]
934  /// CHECK-DAG:     <<Sub1:i\d+>>     Sub [<<Neg>>,<<Arg2>>]
935  /// CHECK-DAG:     <<Sub2:i\d+>>     Sub [<<Neg>>,<<Arg2>>]
936  /// CHECK-DAG:     <<Or:i\d+>>       Or [<<Sub1>>,<<Sub2>>]
937  /// CHECK-DAG:                       Return [<<Or>>]
938
939  /// CHECK-START: int Main.SubNeg2(int, int) instruction_simplifier (after)
940  /// CHECK-NOT:                       Add
941
942  public static int SubNeg2(int arg1, int arg2) {
943    int temp = -arg1;
944    return (temp - arg2) | (temp - arg2);
945  }
946
947  /**
948   * This follows test-cases SubNeg1 and SubNeg2.
949   * The transformation tested is implemented in `InstructionSimplifierVisitor::VisitSub`.
950   * The optimization should not happen if it moves an additional instruction in
951   * the loop.
952   */
953
954  /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (before)
955  //  -------------- Arguments and initial negation operation.
956  /// CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
957  /// CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
958  /// CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg1>>]
959  /// CHECK:                           Goto
960  //  -------------- Loop
961  /// CHECK:                           SuspendCheck
962  /// CHECK:         <<Sub:j\d+>>      Sub [<<Neg>>,<<Arg2>>]
963  /// CHECK:                           Goto
964
965  /// CHECK-START: long Main.SubNeg3(long, long) instruction_simplifier (after)
966  //  -------------- Arguments and initial negation operation.
967  /// CHECK-DAG:     <<Arg1:j\d+>>     ParameterValue
968  /// CHECK-DAG:     <<Arg2:j\d+>>     ParameterValue
969  /// CHECK-DAG:     <<Neg:j\d+>>      Neg [<<Arg1>>]
970  /// CHECK-DAG:                       Goto
971  //  -------------- Loop
972  /// CHECK:                           SuspendCheck
973  /// CHECK:         <<Sub:j\d+>>      Sub [<<Neg>>,<<Arg2>>]
974  /// CHECK-NOT:                       Neg
975  /// CHECK:                           Goto
976
977  public static long SubNeg3(long arg1, long arg2) {
978    long res = 0;
979    long temp = -arg1;
980    for (long i = 0; i < 1; i++) {
981      res += temp - arg2 - i;
982    }
983    return res;
984  }
985
986  /// CHECK-START: boolean Main.EqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (before)
987  /// CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
988  /// CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
989  /// CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
990  /// CHECK-DAG:     <<Const2:i\d+>>   IntConstant 2
991  /// CHECK-DAG:     <<NotArg:i\d+>>   Select [<<Const1>>,<<Const0>>,<<Arg>>]
992  /// CHECK-DAG:     <<Cond:z\d+>>     Equal [<<NotArg>>,<<Const2>>]
993  /// CHECK-DAG:     <<NotCond:i\d+>>  Select [<<Const1>>,<<Const0>>,<<Cond>>]
994  /// CHECK-DAG:                       Return [<<NotCond>>]
995
996  /// CHECK-START: boolean Main.EqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (after)
997  /// CHECK-DAG:     <<True:i\d+>>     IntConstant 1
998  /// CHECK-DAG:                       Return [<<True>>]
999
1000  public static boolean EqualBoolVsIntConst(boolean arg) {
1001    return (arg ? 0 : 1) != 2;
1002  }
1003
1004  /// CHECK-START: boolean Main.NotEqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (before)
1005  /// CHECK-DAG:     <<Arg:z\d+>>      ParameterValue
1006  /// CHECK-DAG:     <<Const0:i\d+>>   IntConstant 0
1007  /// CHECK-DAG:     <<Const1:i\d+>>   IntConstant 1
1008  /// CHECK-DAG:     <<Const2:i\d+>>   IntConstant 2
1009  /// CHECK-DAG:     <<NotArg:i\d+>>   Select [<<Const1>>,<<Const0>>,<<Arg>>]
1010  /// CHECK-DAG:     <<Cond:z\d+>>     NotEqual [<<NotArg>>,<<Const2>>]
1011  /// CHECK-DAG:     <<NotCond:i\d+>>  Select [<<Const1>>,<<Const0>>,<<Cond>>]
1012  /// CHECK-DAG:                       Return [<<NotCond>>]
1013
1014  /// CHECK-START: boolean Main.NotEqualBoolVsIntConst(boolean) instruction_simplifier_after_bce (after)
1015  /// CHECK-DAG:     <<False:i\d+>>    IntConstant 0
1016  /// CHECK-DAG:                       Return [<<False>>]
1017
1018  public static boolean NotEqualBoolVsIntConst(boolean arg) {
1019    return (arg ? 0 : 1) == 2;
1020  }
1021
1022  /*
1023   * Test simplification of double Boolean negation. Note that sometimes
1024   * both negations can be removed but we only expect the simplifier to
1025   * remove the second.
1026   */
1027
1028  /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_bce (before)
1029  /// CHECK-DAG:     <<Arg:z\d+>>       ParameterValue
1030  /// CHECK-DAG:     <<Const0:i\d+>>    IntConstant 0
1031  /// CHECK-DAG:     <<Const1:i\d+>>    IntConstant 1
1032  /// CHECK-DAG:     <<NotArg:i\d+>>    Select [<<Const1>>,<<Const0>>,<<Arg>>]
1033  /// CHECK-DAG:     <<NotNotArg:i\d+>> Select [<<Const1>>,<<Const0>>,<<NotArg>>]
1034  /// CHECK-DAG:                        Return [<<NotNotArg>>]
1035
1036  /// CHECK-START: boolean Main.NotNotBool(boolean) instruction_simplifier_after_bce (after)
1037  /// CHECK-DAG:     <<Arg:z\d+>>       ParameterValue
1038  /// CHECK-DAG:                        Return [<<Arg>>]
1039
1040  public static boolean NegateValue(boolean arg) {
1041    return !arg;
1042  }
1043
1044  public static boolean NotNotBool(boolean arg) {
1045    return !(NegateValue(arg));
1046  }
1047
1048  /// CHECK-START: float Main.Div2(float) instruction_simplifier (before)
1049  /// CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
1050  /// CHECK-DAG:      <<Const2:f\d+>>   FloatConstant 2
1051  /// CHECK-DAG:      <<Div:f\d+>>      Div [<<Arg>>,<<Const2>>]
1052  /// CHECK-DAG:                        Return [<<Div>>]
1053
1054  /// CHECK-START: float Main.Div2(float) instruction_simplifier (after)
1055  /// CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
1056  /// CHECK-DAG:      <<ConstP5:f\d+>>  FloatConstant 0.5
1057  /// CHECK-DAG:      <<Mul:f\d+>>      Mul [<<Arg>>,<<ConstP5>>]
1058  /// CHECK-DAG:                        Return [<<Mul>>]
1059
1060  /// CHECK-START: float Main.Div2(float) instruction_simplifier (after)
1061  /// CHECK-NOT:                        Div
1062
1063  public static float Div2(float arg) {
1064    return arg / 2.0f;
1065  }
1066
1067  /// CHECK-START: double Main.Div2(double) instruction_simplifier (before)
1068  /// CHECK-DAG:      <<Arg:d\d+>>      ParameterValue
1069  /// CHECK-DAG:      <<Const2:d\d+>>   DoubleConstant 2
1070  /// CHECK-DAG:      <<Div:d\d+>>      Div [<<Arg>>,<<Const2>>]
1071  /// CHECK-DAG:                        Return [<<Div>>]
1072
1073  /// CHECK-START: double Main.Div2(double) instruction_simplifier (after)
1074  /// CHECK-DAG:      <<Arg:d\d+>>      ParameterValue
1075  /// CHECK-DAG:      <<ConstP5:d\d+>>  DoubleConstant 0.5
1076  /// CHECK-DAG:      <<Mul:d\d+>>      Mul [<<Arg>>,<<ConstP5>>]
1077  /// CHECK-DAG:                        Return [<<Mul>>]
1078
1079  /// CHECK-START: double Main.Div2(double) instruction_simplifier (after)
1080  /// CHECK-NOT:                        Div
1081  public static double Div2(double arg) {
1082    return arg / 2.0;
1083  }
1084
1085  /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (before)
1086  /// CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
1087  /// CHECK-DAG:      <<ConstMP25:f\d+>>   FloatConstant -0.25
1088  /// CHECK-DAG:      <<Div:f\d+>>      Div [<<Arg>>,<<ConstMP25>>]
1089  /// CHECK-DAG:                        Return [<<Div>>]
1090
1091  /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
1092  /// CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
1093  /// CHECK-DAG:      <<ConstM4:f\d+>>  FloatConstant -4
1094  /// CHECK-DAG:      <<Mul:f\d+>>      Mul [<<Arg>>,<<ConstM4>>]
1095  /// CHECK-DAG:                        Return [<<Mul>>]
1096
1097  /// CHECK-START: float Main.DivMP25(float) instruction_simplifier (after)
1098  /// CHECK-NOT:                        Div
1099
1100  public static float DivMP25(float arg) {
1101    return arg / -0.25f;
1102  }
1103
1104  /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (before)
1105  /// CHECK-DAG:      <<Arg:d\d+>>      ParameterValue
1106  /// CHECK-DAG:      <<ConstMP25:d\d+>>   DoubleConstant -0.25
1107  /// CHECK-DAG:      <<Div:d\d+>>      Div [<<Arg>>,<<ConstMP25>>]
1108  /// CHECK-DAG:                        Return [<<Div>>]
1109
1110  /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
1111  /// CHECK-DAG:      <<Arg:d\d+>>      ParameterValue
1112  /// CHECK-DAG:      <<ConstM4:d\d+>>  DoubleConstant -4
1113  /// CHECK-DAG:      <<Mul:d\d+>>      Mul [<<Arg>>,<<ConstM4>>]
1114  /// CHECK-DAG:                        Return [<<Mul>>]
1115
1116  /// CHECK-START: double Main.DivMP25(double) instruction_simplifier (after)
1117  /// CHECK-NOT:                        Div
1118  public static double DivMP25(double arg) {
1119    return arg / -0.25f;
1120  }
1121
1122  /**
1123   * Test strength reduction of factors of the form (2^n + 1).
1124   */
1125
1126  /// CHECK-START: int Main.mulPow2Plus1(int) instruction_simplifier (before)
1127  /// CHECK-DAG:   <<Arg:i\d+>>         ParameterValue
1128  /// CHECK-DAG:   <<Const9:i\d+>>      IntConstant 9
1129  /// CHECK:                            Mul [<<Arg>>,<<Const9>>]
1130
1131  /// CHECK-START: int Main.mulPow2Plus1(int) instruction_simplifier (after)
1132  /// CHECK-DAG:   <<Arg:i\d+>>         ParameterValue
1133  /// CHECK-DAG:   <<Const3:i\d+>>      IntConstant 3
1134  /// CHECK:       <<Shift:i\d+>>       Shl [<<Arg>>,<<Const3>>]
1135  /// CHECK-NEXT:                       Add [<<Arg>>,<<Shift>>]
1136
1137  public static int mulPow2Plus1(int arg) {
1138    return arg * 9;
1139  }
1140
1141  /**
1142   * Test strength reduction of factors of the form (2^n - 1).
1143   */
1144
1145  /// CHECK-START: long Main.mulPow2Minus1(long) instruction_simplifier (before)
1146  /// CHECK-DAG:   <<Arg:j\d+>>         ParameterValue
1147  /// CHECK-DAG:   <<Const31:j\d+>>     LongConstant 31
1148  /// CHECK:                            Mul [<<Const31>>,<<Arg>>]
1149
1150  /// CHECK-START: long Main.mulPow2Minus1(long) instruction_simplifier (after)
1151  /// CHECK-DAG:   <<Arg:j\d+>>         ParameterValue
1152  /// CHECK-DAG:   <<Const5:i\d+>>      IntConstant 5
1153  /// CHECK:       <<Shift:j\d+>>       Shl [<<Arg>>,<<Const5>>]
1154  /// CHECK-NEXT:                       Sub [<<Shift>>,<<Arg>>]
1155
1156  public static long mulPow2Minus1(long arg) {
1157    return arg * 31;
1158  }
1159
1160  /// CHECK-START: int Main.booleanFieldNotEqualOne() instruction_simplifier_after_bce (before)
1161  /// CHECK-DAG:      <<Const1:i\d+>>   IntConstant 1
1162  /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
1163  /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
1164  /// CHECK-DAG:      <<Field:z\d+>>    StaticFieldGet
1165  /// CHECK-DAG:      <<NE:z\d+>>       NotEqual [<<Field>>,<<Const1>>]
1166  /// CHECK-DAG:      <<Select:i\d+>>   Select [<<Const13>>,<<Const54>>,<<NE>>]
1167  /// CHECK-DAG:                        Return [<<Select>>]
1168
1169  /// CHECK-START: int Main.booleanFieldNotEqualOne() instruction_simplifier_after_bce (after)
1170  /// CHECK-DAG:      <<Field:z\d+>>    StaticFieldGet
1171  /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
1172  /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
1173  /// CHECK-DAG:      <<Select:i\d+>>   Select [<<Const54>>,<<Const13>>,<<Field>>]
1174  /// CHECK-DAG:                        Return [<<Select>>]
1175
1176  public static int booleanFieldNotEqualOne() {
1177    return (booleanField == $inline$true()) ? 13 : 54;
1178  }
1179
1180  /// CHECK-START: int Main.booleanFieldEqualZero() instruction_simplifier_after_bce (before)
1181  /// CHECK-DAG:      <<Const0:i\d+>>   IntConstant 0
1182  /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
1183  /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
1184  /// CHECK-DAG:      <<Field:z\d+>>    StaticFieldGet
1185  /// CHECK-DAG:      <<NE:z\d+>>       Equal [<<Field>>,<<Const0>>]
1186  /// CHECK-DAG:      <<Select:i\d+>>   Select [<<Const13>>,<<Const54>>,<<NE>>]
1187  /// CHECK-DAG:                        Return [<<Select>>]
1188
1189  /// CHECK-START: int Main.booleanFieldEqualZero() instruction_simplifier_after_bce (after)
1190  /// CHECK-DAG:      <<Field:z\d+>>    StaticFieldGet
1191  /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
1192  /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
1193  /// CHECK-DAG:      <<Select:i\d+>>   Select [<<Const54>>,<<Const13>>,<<Field>>]
1194  /// CHECK-DAG:                        Return [<<Select>>]
1195
1196  public static int booleanFieldEqualZero() {
1197    return (booleanField != $inline$false()) ? 13 : 54;
1198  }
1199
1200  /// CHECK-START: int Main.intConditionNotEqualOne(int) instruction_simplifier_after_bce (before)
1201  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1202  /// CHECK-DAG:      <<Const0:i\d+>>   IntConstant 0
1203  /// CHECK-DAG:      <<Const1:i\d+>>   IntConstant 1
1204  /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
1205  /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
1206  /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
1207  /// CHECK-DAG:      <<LE:z\d+>>       LessThanOrEqual [<<Arg>>,<<Const42>>]
1208  /// CHECK-DAG:      <<GT:i\d+>>       Select [<<Const1>>,<<Const0>>,<<LE>>]
1209  /// CHECK-DAG:      <<NE:z\d+>>       NotEqual [<<GT>>,<<Const1>>]
1210  /// CHECK-DAG:      <<Result:i\d+>>   Select [<<Const13>>,<<Const54>>,<<NE>>]
1211  /// CHECK-DAG:                        Return [<<Result>>]
1212
1213  /// CHECK-START: int Main.intConditionNotEqualOne(int) instruction_simplifier_after_bce (after)
1214  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1215  /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
1216  /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
1217  /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
1218  /// CHECK-DAG:      <<Result:i\d+>>   Select [<<Const13>>,<<Const54>>,<<LE:z\d+>>]
1219  /// CHECK-DAG:      <<LE>>            LessThanOrEqual [<<Arg>>,<<Const42>>]
1220  /// CHECK-DAG:                        Return [<<Result>>]
1221  // Note that we match `LE` from Select because there are two identical
1222  // LessThanOrEqual instructions.
1223
1224  public static int intConditionNotEqualOne(int i) {
1225    return ((i > 42) == $inline$true()) ? 13 : 54;
1226  }
1227
1228  /// CHECK-START: int Main.intConditionEqualZero(int) instruction_simplifier_after_bce (before)
1229  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1230  /// CHECK-DAG:      <<Const0:i\d+>>   IntConstant 0
1231  /// CHECK-DAG:      <<Const1:i\d+>>   IntConstant 1
1232  /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
1233  /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
1234  /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
1235  /// CHECK-DAG:      <<LE:z\d+>>       LessThanOrEqual [<<Arg>>,<<Const42>>]
1236  /// CHECK-DAG:      <<GT:i\d+>>       Select [<<Const1>>,<<Const0>>,<<LE>>]
1237  /// CHECK-DAG:      <<NE:z\d+>>       Equal [<<GT>>,<<Const0>>]
1238  /// CHECK-DAG:      <<Result:i\d+>>   Select [<<Const13>>,<<Const54>>,<<NE>>]
1239  /// CHECK-DAG:                        Return [<<Result>>]
1240
1241  /// CHECK-START: int Main.intConditionEqualZero(int) instruction_simplifier_after_bce (after)
1242  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1243  /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
1244  /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
1245  /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
1246  /// CHECK-DAG:      <<Result:i\d+>>   Select [<<Const13>>,<<Const54>>,<<LE:z\d+>>]
1247  /// CHECK-DAG:      <<LE>>            LessThanOrEqual [<<Arg>>,<<Const42>>]
1248  /// CHECK-DAG:                        Return [<<Result>>]
1249  // Note that we match `LE` from Select because there are two identical
1250  // LessThanOrEqual instructions.
1251
1252  public static int intConditionEqualZero(int i) {
1253    return ((i > 42) != $inline$false()) ? 13 : 54;
1254  }
1255
1256  // Test that conditions on float/double are not flipped.
1257
1258  /// CHECK-START: int Main.floatConditionNotEqualOne(float) builder (after)
1259  /// CHECK:                            LessThanOrEqual
1260
1261  /// CHECK-START: int Main.floatConditionNotEqualOne(float) instruction_simplifier_before_codegen (after)
1262  /// CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
1263  /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
1264  /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
1265  /// CHECK-DAG:      <<Const42:f\d+>>  FloatConstant 42
1266  /// CHECK-DAG:      <<LE:z\d+>>       LessThanOrEqual [<<Arg>>,<<Const42>>]
1267  /// CHECK-DAG:      <<Select:i\d+>>   Select [<<Const13>>,<<Const54>>,<<LE>>]
1268  /// CHECK-DAG:                        Return [<<Select>>]
1269
1270  public static int floatConditionNotEqualOne(float f) {
1271    return ((f > 42.0f) == true) ? 13 : 54;
1272  }
1273
1274  /// CHECK-START: int Main.doubleConditionEqualZero(double) builder (after)
1275  /// CHECK:                            LessThanOrEqual
1276
1277  /// CHECK-START: int Main.doubleConditionEqualZero(double) instruction_simplifier_before_codegen (after)
1278  /// CHECK-DAG:      <<Arg:d\d+>>      ParameterValue
1279  /// CHECK-DAG:      <<Const13:i\d+>>  IntConstant 13
1280  /// CHECK-DAG:      <<Const54:i\d+>>  IntConstant 54
1281  /// CHECK-DAG:      <<Const42:d\d+>>  DoubleConstant 42
1282  /// CHECK-DAG:      <<LE:z\d+>>       LessThanOrEqual [<<Arg>>,<<Const42>>]
1283  /// CHECK-DAG:      <<Select:i\d+>>   Select [<<Const13>>,<<Const54>>,<<LE>>]
1284  /// CHECK-DAG:                        Return [<<Select>>]
1285
1286  public static int doubleConditionEqualZero(double d) {
1287    return ((d > 42.0) != false) ? 13 : 54;
1288  }
1289
1290  /// CHECK-START: int Main.intToDoubleToInt(int) instruction_simplifier (before)
1291  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1292  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Arg>>]
1293  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Double>>]
1294  /// CHECK-DAG:                        Return [<<Int>>]
1295
1296  /// CHECK-START: int Main.intToDoubleToInt(int) instruction_simplifier (after)
1297  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1298  /// CHECK-DAG:                        Return [<<Arg>>]
1299
1300  /// CHECK-START: int Main.intToDoubleToInt(int) instruction_simplifier (after)
1301  /// CHECK-NOT:                        TypeConversion
1302
1303  public static int intToDoubleToInt(int value) {
1304    // Lossless conversion followed by a conversion back.
1305    return (int) (double) value;
1306  }
1307
1308  /// CHECK-START: java.lang.String Main.intToDoubleToIntPrint(int) instruction_simplifier (before)
1309  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1310  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Arg>>]
1311  /// CHECK-DAG:      {{i\d+}}          TypeConversion [<<Double>>]
1312
1313  /// CHECK-START: java.lang.String Main.intToDoubleToIntPrint(int) instruction_simplifier (after)
1314  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1315  /// CHECK-DAG:      {{d\d+}}          TypeConversion [<<Arg>>]
1316
1317  /// CHECK-START: java.lang.String Main.intToDoubleToIntPrint(int) instruction_simplifier (after)
1318  /// CHECK-DAG:                        TypeConversion
1319  /// CHECK-NOT:                        TypeConversion
1320
1321  public static String intToDoubleToIntPrint(int value) {
1322    // Lossless conversion followed by a conversion back
1323    // with another use of the intermediate result.
1324    double d = (double) value;
1325    int i = (int) d;
1326    return "d=" + d + ", i=" + i;
1327  }
1328
1329  /// CHECK-START: int Main.byteToDoubleToInt(byte) instruction_simplifier (before)
1330  /// CHECK-DAG:      <<Arg:b\d+>>      ParameterValue
1331  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Arg>>]
1332  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Double>>]
1333  /// CHECK-DAG:                        Return [<<Int>>]
1334
1335  /// CHECK-START: int Main.byteToDoubleToInt(byte) instruction_simplifier (after)
1336  /// CHECK-DAG:      <<Arg:b\d+>>      ParameterValue
1337  /// CHECK-DAG:                        Return [<<Arg>>]
1338
1339  /// CHECK-START: int Main.byteToDoubleToInt(byte) instruction_simplifier (after)
1340  /// CHECK-NOT:                        TypeConversion
1341
1342  public static int byteToDoubleToInt(byte value) {
1343    // Lossless conversion followed by another conversion, use implicit conversion.
1344    return (int) (double) value;
1345  }
1346
1347  /// CHECK-START: int Main.floatToDoubleToInt(float) instruction_simplifier (before)
1348  /// CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
1349  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Arg>>]
1350  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Double>>]
1351  /// CHECK-DAG:                        Return [<<Int>>]
1352
1353  /// CHECK-START: int Main.floatToDoubleToInt(float) instruction_simplifier (after)
1354  /// CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
1355  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Arg>>]
1356  /// CHECK-DAG:                        Return [<<Int>>]
1357
1358  /// CHECK-START: int Main.floatToDoubleToInt(float) instruction_simplifier (after)
1359  /// CHECK-DAG:                        TypeConversion
1360  /// CHECK-NOT:                        TypeConversion
1361
1362  public static int floatToDoubleToInt(float value) {
1363    // Lossless conversion followed by another conversion.
1364    return (int) (double) value;
1365  }
1366
1367  /// CHECK-START: java.lang.String Main.floatToDoubleToIntPrint(float) instruction_simplifier (before)
1368  /// CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
1369  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Arg>>]
1370  /// CHECK-DAG:      {{i\d+}}          TypeConversion [<<Double>>]
1371
1372  /// CHECK-START: java.lang.String Main.floatToDoubleToIntPrint(float) instruction_simplifier (after)
1373  /// CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
1374  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Arg>>]
1375  /// CHECK-DAG:      {{i\d+}}          TypeConversion [<<Double>>]
1376
1377  public static String floatToDoubleToIntPrint(float value) {
1378    // Lossless conversion followed by another conversion with
1379    // an extra use of the intermediate result.
1380    double d = (double) value;
1381    int i = (int) d;
1382    return "d=" + d + ", i=" + i;
1383  }
1384
1385  /// CHECK-START: short Main.byteToDoubleToShort(byte) instruction_simplifier (before)
1386  /// CHECK-DAG:      <<Arg:b\d+>>      ParameterValue
1387  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Arg>>]
1388  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Double>>]
1389  /// CHECK-DAG:      <<Short:s\d+>>    TypeConversion [<<Int>>]
1390  /// CHECK-DAG:                        Return [<<Short>>]
1391
1392  /// CHECK-START: short Main.byteToDoubleToShort(byte) instruction_simplifier (after)
1393  /// CHECK-DAG:      <<Arg:b\d+>>      ParameterValue
1394  /// CHECK-DAG:                        Return [<<Arg>>]
1395
1396  /// CHECK-START: short Main.byteToDoubleToShort(byte) instruction_simplifier (after)
1397  /// CHECK-NOT:                        TypeConversion
1398
1399  public static short byteToDoubleToShort(byte value) {
1400    // Originally, this is byte->double->int->short. The first conversion is lossless,
1401    // so we merge this with the second one to byte->int which we omit as it's an implicit
1402    // conversion. Then we eliminate the resulting byte->short as an implicit conversion.
1403    return (short) (double) value;
1404  }
1405
1406  /// CHECK-START: short Main.charToDoubleToShort(char) instruction_simplifier (before)
1407  /// CHECK-DAG:      <<Arg:c\d+>>      ParameterValue
1408  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Arg>>]
1409  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Double>>]
1410  /// CHECK-DAG:      <<Short:s\d+>>    TypeConversion [<<Int>>]
1411  /// CHECK-DAG:                        Return [<<Short>>]
1412
1413  /// CHECK-START: short Main.charToDoubleToShort(char) instruction_simplifier (after)
1414  /// CHECK-DAG:      <<Arg:c\d+>>      ParameterValue
1415  /// CHECK-DAG:      <<Short:s\d+>>    TypeConversion [<<Arg>>]
1416  /// CHECK-DAG:                        Return [<<Short>>]
1417
1418  /// CHECK-START: short Main.charToDoubleToShort(char) instruction_simplifier (after)
1419  /// CHECK-DAG:                        TypeConversion
1420  /// CHECK-NOT:                        TypeConversion
1421
1422  public static short charToDoubleToShort(char value) {
1423    // Originally, this is char->double->int->short. The first conversion is lossless,
1424    // so we merge this with the second one to char->int which we omit as it's an implicit
1425    // conversion. Then we are left with the resulting char->short conversion.
1426    return (short) (double) value;
1427  }
1428
1429  /// CHECK-START: short Main.floatToIntToShort(float) instruction_simplifier (before)
1430  /// CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
1431  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Arg>>]
1432  /// CHECK-DAG:      <<Short:s\d+>>    TypeConversion [<<Int>>]
1433  /// CHECK-DAG:                        Return [<<Short>>]
1434
1435  /// CHECK-START: short Main.floatToIntToShort(float) instruction_simplifier (after)
1436  /// CHECK-DAG:      <<Arg:f\d+>>      ParameterValue
1437  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Arg>>]
1438  /// CHECK-DAG:      <<Short:s\d+>>    TypeConversion [<<Int>>]
1439  /// CHECK-DAG:                        Return [<<Short>>]
1440
1441  public static short floatToIntToShort(float value) {
1442    // Lossy FP to integral conversion followed by another conversion: no simplification.
1443    return (short) value;
1444  }
1445
1446  /// CHECK-START: int Main.intToFloatToInt(int) instruction_simplifier (before)
1447  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1448  /// CHECK-DAG:      <<Float:f\d+>>    TypeConversion [<<Arg>>]
1449  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Float>>]
1450  /// CHECK-DAG:                        Return [<<Int>>]
1451
1452  /// CHECK-START: int Main.intToFloatToInt(int) instruction_simplifier (after)
1453  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1454  /// CHECK-DAG:      <<Float:f\d+>>    TypeConversion [<<Arg>>]
1455  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Float>>]
1456  /// CHECK-DAG:                        Return [<<Int>>]
1457
1458  public static int intToFloatToInt(int value) {
1459    // Lossy integral to FP conversion followed another conversion: no simplification.
1460    return (int) (float) value;
1461  }
1462
1463  /// CHECK-START: double Main.longToIntToDouble(long) instruction_simplifier (before)
1464  /// CHECK-DAG:      <<Arg:j\d+>>      ParameterValue
1465  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Arg>>]
1466  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Int>>]
1467  /// CHECK-DAG:                        Return [<<Double>>]
1468
1469  /// CHECK-START: double Main.longToIntToDouble(long) instruction_simplifier (after)
1470  /// CHECK-DAG:      <<Arg:j\d+>>      ParameterValue
1471  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Arg>>]
1472  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Int>>]
1473  /// CHECK-DAG:                        Return [<<Double>>]
1474
1475  public static double longToIntToDouble(long value) {
1476    // Lossy long-to-int conversion followed an integral to FP conversion: no simplification.
1477    return (double) (int) value;
1478  }
1479
1480  /// CHECK-START: long Main.longToIntToLong(long) instruction_simplifier (before)
1481  /// CHECK-DAG:      <<Arg:j\d+>>      ParameterValue
1482  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Arg>>]
1483  /// CHECK-DAG:      <<Long:j\d+>>     TypeConversion [<<Int>>]
1484  /// CHECK-DAG:                        Return [<<Long>>]
1485
1486  /// CHECK-START: long Main.longToIntToLong(long) instruction_simplifier (after)
1487  /// CHECK-DAG:      <<Arg:j\d+>>      ParameterValue
1488  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Arg>>]
1489  /// CHECK-DAG:      <<Long:j\d+>>     TypeConversion [<<Int>>]
1490  /// CHECK-DAG:                        Return [<<Long>>]
1491
1492  public static long longToIntToLong(long value) {
1493    // Lossy long-to-int conversion followed an int-to-long conversion: no simplification.
1494    return (long) (int) value;
1495  }
1496
1497  /// CHECK-START: short Main.shortToCharToShort(short) instruction_simplifier (before)
1498  /// CHECK-DAG:      <<Arg:s\d+>>      ParameterValue
1499  /// CHECK-DAG:      <<Char:c\d+>>     TypeConversion [<<Arg>>]
1500  /// CHECK-DAG:      <<Short:s\d+>>    TypeConversion [<<Char>>]
1501  /// CHECK-DAG:                        Return [<<Short>>]
1502
1503  /// CHECK-START: short Main.shortToCharToShort(short) instruction_simplifier (after)
1504  /// CHECK-DAG:      <<Arg:s\d+>>      ParameterValue
1505  /// CHECK-DAG:                        Return [<<Arg>>]
1506
1507  public static short shortToCharToShort(short value) {
1508    // Integral conversion followed by non-widening integral conversion to original type.
1509    return (short) (char) value;
1510  }
1511
1512  /// CHECK-START: int Main.shortToLongToInt(short) instruction_simplifier (before)
1513  /// CHECK-DAG:      <<Arg:s\d+>>      ParameterValue
1514  /// CHECK-DAG:      <<Long:j\d+>>     TypeConversion [<<Arg>>]
1515  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<Long>>]
1516  /// CHECK-DAG:                        Return [<<Int>>]
1517
1518  /// CHECK-START: int Main.shortToLongToInt(short) instruction_simplifier (after)
1519  /// CHECK-DAG:      <<Arg:s\d+>>      ParameterValue
1520  /// CHECK-DAG:                        Return [<<Arg>>]
1521
1522  public static int shortToLongToInt(short value) {
1523    // Integral conversion followed by non-widening integral conversion, use implicit conversion.
1524    return (int) (long) value;
1525  }
1526
1527  /// CHECK-START: byte Main.shortToCharToByte(short) instruction_simplifier (before)
1528  /// CHECK-DAG:      <<Arg:s\d+>>      ParameterValue
1529  /// CHECK-DAG:      <<Char:c\d+>>     TypeConversion [<<Arg>>]
1530  /// CHECK-DAG:      <<Byte:b\d+>>     TypeConversion [<<Char>>]
1531  /// CHECK-DAG:                        Return [<<Byte>>]
1532
1533  /// CHECK-START: byte Main.shortToCharToByte(short) instruction_simplifier (after)
1534  /// CHECK-DAG:      <<Arg:s\d+>>      ParameterValue
1535  /// CHECK-DAG:      <<Byte:b\d+>>     TypeConversion [<<Arg>>]
1536  /// CHECK-DAG:                        Return [<<Byte>>]
1537
1538  public static byte shortToCharToByte(short value) {
1539    // Integral conversion followed by non-widening integral conversion losing bits
1540    // from the original type. Simplify to use only one conversion.
1541    return (byte) (char) value;
1542  }
1543
1544  /// CHECK-START: java.lang.String Main.shortToCharToBytePrint(short) instruction_simplifier (before)
1545  /// CHECK-DAG:      <<Arg:s\d+>>      ParameterValue
1546  /// CHECK-DAG:      <<Char:c\d+>>     TypeConversion [<<Arg>>]
1547  /// CHECK-DAG:      {{b\d+}}          TypeConversion [<<Char>>]
1548
1549  /// CHECK-START: java.lang.String Main.shortToCharToBytePrint(short) instruction_simplifier (after)
1550  /// CHECK-DAG:      <<Arg:s\d+>>      ParameterValue
1551  /// CHECK-DAG:      <<Char:c\d+>>     TypeConversion [<<Arg>>]
1552  /// CHECK-DAG:      {{b\d+}}          TypeConversion [<<Char>>]
1553
1554  public static String shortToCharToBytePrint(short value) {
1555    // Integral conversion followed by non-widening integral conversion losing bits
1556    // from the original type with an extra use of the intermediate result.
1557    char c = (char) value;
1558    byte b = (byte) c;
1559    return "c=" + ((int) c) + ", b=" + ((int) b);  // implicit conversions.
1560  }
1561
1562  /// CHECK-START: byte Main.longAnd0xffToByte(long) instruction_simplifier (before)
1563  /// CHECK-DAG:      <<Arg:j\d+>>      ParameterValue
1564  /// CHECK-DAG:      <<Mask:j\d+>>     LongConstant 255
1565  /// CHECK-DAG:      <<And:j\d+>>      And [<<Mask>>,<<Arg>>]
1566  /// CHECK-DAG:      <<Int:i\d+>>      TypeConversion [<<And>>]
1567  /// CHECK-DAG:      <<Byte:b\d+>>     TypeConversion [<<Int>>]
1568  /// CHECK-DAG:                        Return [<<Byte>>]
1569
1570  /// CHECK-START: byte Main.longAnd0xffToByte(long) instruction_simplifier (after)
1571  /// CHECK-DAG:      <<Arg:j\d+>>      ParameterValue
1572  /// CHECK-DAG:      <<Byte:b\d+>>     TypeConversion [<<Arg>>]
1573  /// CHECK-DAG:                        Return [<<Byte>>]
1574
1575  /// CHECK-START: byte Main.longAnd0xffToByte(long) instruction_simplifier (after)
1576  /// CHECK-NOT:                        And
1577
1578  public static byte longAnd0xffToByte(long value) {
1579    return (byte) (value & 0xff);
1580  }
1581
1582  /// CHECK-START: char Main.intAnd0x1ffffToChar(int) instruction_simplifier (before)
1583  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1584  /// CHECK-DAG:      <<Mask:i\d+>>     IntConstant 131071
1585  /// CHECK-DAG:      <<And:i\d+>>      And [<<Mask>>,<<Arg>>]
1586  /// CHECK-DAG:      <<Char:c\d+>>     TypeConversion [<<And>>]
1587  /// CHECK-DAG:                        Return [<<Char>>]
1588
1589  /// CHECK-START: char Main.intAnd0x1ffffToChar(int) instruction_simplifier (after)
1590  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1591  /// CHECK-DAG:      <<Char:c\d+>>     TypeConversion [<<Arg>>]
1592  /// CHECK-DAG:                        Return [<<Char>>]
1593
1594  /// CHECK-START: char Main.intAnd0x1ffffToChar(int) instruction_simplifier (after)
1595  /// CHECK-NOT:                        And
1596
1597  public static char intAnd0x1ffffToChar(int value) {
1598    // Keeping all significant bits and one more.
1599    return (char) (value & 0x1ffff);
1600  }
1601
1602  /// CHECK-START: short Main.intAnd0x17fffToShort(int) instruction_simplifier (before)
1603  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1604  /// CHECK-DAG:      <<Mask:i\d+>>     IntConstant 98303
1605  /// CHECK-DAG:      <<And:i\d+>>      And [<<Mask>>,<<Arg>>]
1606  /// CHECK-DAG:      <<Short:s\d+>>    TypeConversion [<<And>>]
1607  /// CHECK-DAG:                        Return [<<Short>>]
1608
1609  /// CHECK-START: short Main.intAnd0x17fffToShort(int) instruction_simplifier (after)
1610  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1611  /// CHECK-DAG:      <<Mask:i\d+>>     IntConstant 98303
1612  /// CHECK-DAG:      <<And:i\d+>>      And [<<Mask>>,<<Arg>>]
1613  /// CHECK-DAG:      <<Short:s\d+>>    TypeConversion [<<And>>]
1614  /// CHECK-DAG:                        Return [<<Short>>]
1615
1616  public static short intAnd0x17fffToShort(int value) {
1617    // No simplification: clearing a significant bit.
1618    return (short) (value & 0x17fff);
1619  }
1620
1621  /// CHECK-START: double Main.shortAnd0xffffToShortToDouble(short) instruction_simplifier (before)
1622  /// CHECK-DAG:      <<Arg:s\d+>>      ParameterValue
1623  /// CHECK-DAG:      <<Mask:i\d+>>     IntConstant 65535
1624  /// CHECK-DAG:      <<And:i\d+>>      And [<<Mask>>,<<Arg>>]
1625  /// CHECK-DAG:      <<Same:s\d+>>     TypeConversion [<<And>>]
1626  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Same>>]
1627  /// CHECK-DAG:                        Return [<<Double>>]
1628
1629  /// CHECK-START: double Main.shortAnd0xffffToShortToDouble(short) instruction_simplifier (after)
1630  /// CHECK-DAG:      <<Arg:s\d+>>      ParameterValue
1631  /// CHECK-DAG:      <<Double:d\d+>>   TypeConversion [<<Arg>>]
1632  /// CHECK-DAG:                        Return [<<Double>>]
1633
1634  public static double shortAnd0xffffToShortToDouble(short value) {
1635    short same = (short) (value & 0xffff);
1636    return (double) same;
1637  }
1638
1639  /// CHECK-START: int Main.intReverseCondition(int) instruction_simplifier (before)
1640  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1641  /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
1642  /// CHECK-DAG:      <<LE:z\d+>>       LessThanOrEqual [<<Const42>>,<<Arg>>]
1643
1644  /// CHECK-START: int Main.intReverseCondition(int) instruction_simplifier (after)
1645  /// CHECK-DAG:      <<Arg:i\d+>>      ParameterValue
1646  /// CHECK-DAG:      <<Const42:i\d+>>  IntConstant 42
1647  /// CHECK-DAG:      <<GE:z\d+>>       GreaterThanOrEqual [<<Arg>>,<<Const42>>]
1648
1649  public static int intReverseCondition(int i) {
1650    return (42 > i) ? 13 : 54;
1651  }
1652
1653  /// CHECK-START: int Main.intReverseConditionNaN(int) instruction_simplifier (before)
1654  /// CHECK-DAG:      <<Const42:d\d+>>  DoubleConstant 42
1655  /// CHECK-DAG:      <<Result:d\d+>>   InvokeStaticOrDirect
1656  /// CHECK-DAG:      <<CMP:i\d+>>      Compare [<<Const42>>,<<Result>>]
1657
1658  /// CHECK-START: int Main.intReverseConditionNaN(int) instruction_simplifier (after)
1659  /// CHECK-DAG:      <<Const42:d\d+>>  DoubleConstant 42
1660  /// CHECK-DAG:      <<Result:d\d+>>   InvokeStaticOrDirect
1661  /// CHECK-DAG:      <<EQ:z\d+>>       Equal [<<Result>>,<<Const42>>]
1662
1663  public static int intReverseConditionNaN(int i) {
1664    return (42 != Math.sqrt(i)) ? 13 : 54;
1665  }
1666
1667  public static int runSmaliTest(String name, boolean input) {
1668    try {
1669      Class<?> c = Class.forName("SmaliTests");
1670      Method m = c.getMethod(name, new Class[] { boolean.class });
1671      return (Integer) m.invoke(null, input);
1672    } catch (Exception ex) {
1673      throw new Error(ex);
1674    }
1675  }
1676
1677public static void main(String[] args) {
1678    int arg = 123456;
1679
1680    assertLongEquals(Add0(arg), arg);
1681    assertIntEquals(AndAllOnes(arg), arg);
1682    assertLongEquals(Div1(arg), arg);
1683    assertIntEquals(DivN1(arg), -arg);
1684    assertLongEquals(Mul1(arg), arg);
1685    assertIntEquals(MulN1(arg), -arg);
1686    assertLongEquals(MulPowerOfTwo128(arg), (128 * arg));
1687    assertIntEquals(Or0(arg), arg);
1688    assertLongEquals(OrSame(arg), arg);
1689    assertIntEquals(Shl0(arg), arg);
1690    assertLongEquals(Shr0(arg), arg);
1691    assertLongEquals(Shr64(arg), arg);
1692    assertLongEquals(Sub0(arg), arg);
1693    assertIntEquals(SubAliasNeg(arg), -arg);
1694    assertLongEquals(UShr0(arg), arg);
1695    assertIntEquals(Xor0(arg), arg);
1696    assertIntEquals(XorAllOnes(arg), ~arg);
1697    assertIntEquals(AddNegs1(arg, arg + 1), -(arg + arg + 1));
1698    assertIntEquals(AddNegs2(arg, arg + 1), -(arg + arg + 1));
1699    assertLongEquals(AddNegs3(arg, arg + 1), -(2 * arg + 1));
1700    assertLongEquals(AddNeg1(arg, arg + 1), 1);
1701    assertLongEquals(AddNeg2(arg, arg + 1), -1);
1702    assertLongEquals(NegNeg1(arg), arg);
1703    assertIntEquals(NegNeg2(arg), 0);
1704    assertLongEquals(NegNeg3(arg), arg);
1705    assertIntEquals(NegSub1(arg, arg + 1), 1);
1706    assertIntEquals(NegSub2(arg, arg + 1), 1);
1707    assertLongEquals(NotNot1(arg), arg);
1708    assertIntEquals(NotNot2(arg), -1);
1709    assertIntEquals(SubNeg1(arg, arg + 1), -(arg + arg + 1));
1710    assertIntEquals(SubNeg2(arg, arg + 1), -(arg + arg + 1));
1711    assertLongEquals(SubNeg3(arg, arg + 1), -(2 * arg + 1));
1712    assertBooleanEquals(EqualBoolVsIntConst(true), true);
1713    assertBooleanEquals(EqualBoolVsIntConst(true), true);
1714    assertBooleanEquals(NotEqualBoolVsIntConst(false), false);
1715    assertBooleanEquals(NotEqualBoolVsIntConst(false), false);
1716    assertBooleanEquals(NotNotBool(true), true);
1717    assertBooleanEquals(NotNotBool(false), false);
1718    assertFloatEquals(Div2(100.0f), 50.0f);
1719    assertDoubleEquals(Div2(150.0), 75.0);
1720    assertFloatEquals(DivMP25(100.0f), -400.0f);
1721    assertDoubleEquals(DivMP25(150.0), -600.0);
1722    assertIntEquals(UShr28And15(0xc1234567), 0xc);
1723    assertLongEquals(UShr60And15(0xc123456787654321L), 0xcL);
1724    assertIntEquals(UShr28And7(0xc1234567), 0x4);
1725    assertLongEquals(UShr60And7(0xc123456787654321L), 0x4L);
1726    assertIntEquals(Shr24And255(0xc1234567), 0xc1);
1727    assertLongEquals(Shr56And255(0xc123456787654321L), 0xc1L);
1728    assertIntEquals(Shr24And127(0xc1234567), 0x41);
1729    assertLongEquals(Shr56And127(0xc123456787654321L), 0x41L);
1730    assertIntEquals(0, mulPow2Plus1(0));
1731    assertIntEquals(9, mulPow2Plus1(1));
1732    assertIntEquals(18, mulPow2Plus1(2));
1733    assertIntEquals(900, mulPow2Plus1(100));
1734    assertIntEquals(111105, mulPow2Plus1(12345));
1735    assertLongEquals(0, mulPow2Minus1(0));
1736    assertLongEquals(31, mulPow2Minus1(1));
1737    assertLongEquals(62, mulPow2Minus1(2));
1738    assertLongEquals(3100, mulPow2Minus1(100));
1739    assertLongEquals(382695, mulPow2Minus1(12345));
1740
1741    booleanField = false;
1742    assertIntEquals(booleanFieldNotEqualOne(), 54);
1743    assertIntEquals(booleanFieldEqualZero(), 54);
1744    booleanField = true;
1745    assertIntEquals(booleanFieldNotEqualOne(), 13);
1746    assertIntEquals(booleanFieldEqualZero(), 13);
1747    assertIntEquals(intConditionNotEqualOne(6), 54);
1748    assertIntEquals(intConditionNotEqualOne(43), 13);
1749    assertIntEquals(intConditionEqualZero(6), 54);
1750    assertIntEquals(intConditionEqualZero(43), 13);
1751    assertIntEquals(floatConditionNotEqualOne(6.0f), 54);
1752    assertIntEquals(floatConditionNotEqualOne(43.0f), 13);
1753    assertIntEquals(doubleConditionEqualZero(6.0), 54);
1754    assertIntEquals(doubleConditionEqualZero(43.0), 13);
1755
1756    assertIntEquals(1234567, intToDoubleToInt(1234567));
1757    assertIntEquals(Integer.MIN_VALUE, intToDoubleToInt(Integer.MIN_VALUE));
1758    assertIntEquals(Integer.MAX_VALUE, intToDoubleToInt(Integer.MAX_VALUE));
1759    assertStringEquals("d=7654321.0, i=7654321", intToDoubleToIntPrint(7654321));
1760    assertIntEquals(12, byteToDoubleToInt((byte) 12));
1761    assertIntEquals(Byte.MIN_VALUE, byteToDoubleToInt(Byte.MIN_VALUE));
1762    assertIntEquals(Byte.MAX_VALUE, byteToDoubleToInt(Byte.MAX_VALUE));
1763    assertIntEquals(11, floatToDoubleToInt(11.3f));
1764    assertStringEquals("d=12.25, i=12", floatToDoubleToIntPrint(12.25f));
1765    assertIntEquals(123, byteToDoubleToShort((byte) 123));
1766    assertIntEquals(Byte.MIN_VALUE, byteToDoubleToShort(Byte.MIN_VALUE));
1767    assertIntEquals(Byte.MAX_VALUE, byteToDoubleToShort(Byte.MAX_VALUE));
1768    assertIntEquals(1234, charToDoubleToShort((char) 1234));
1769    assertIntEquals(Character.MIN_VALUE, charToDoubleToShort(Character.MIN_VALUE));
1770    assertIntEquals(/* sign-extended */ -1, charToDoubleToShort(Character.MAX_VALUE));
1771    assertIntEquals(12345, floatToIntToShort(12345.75f));
1772    assertIntEquals(Short.MAX_VALUE, floatToIntToShort((float)(Short.MIN_VALUE - 1)));
1773    assertIntEquals(Short.MIN_VALUE, floatToIntToShort((float)(Short.MAX_VALUE + 1)));
1774    assertIntEquals(-54321, intToFloatToInt(-54321));
1775    assertDoubleEquals((double) 0x12345678, longToIntToDouble(0x1234567812345678L));
1776    assertDoubleEquals(0.0, longToIntToDouble(Long.MIN_VALUE));
1777    assertDoubleEquals(-1.0, longToIntToDouble(Long.MAX_VALUE));
1778    assertLongEquals(0x0000000012345678L, longToIntToLong(0x1234567812345678L));
1779    assertLongEquals(0xffffffff87654321L, longToIntToLong(0x1234567887654321L));
1780    assertLongEquals(0L, longToIntToLong(Long.MIN_VALUE));
1781    assertLongEquals(-1L, longToIntToLong(Long.MAX_VALUE));
1782    assertIntEquals((short) -5678, shortToCharToShort((short) -5678));
1783    assertIntEquals(Short.MIN_VALUE, shortToCharToShort(Short.MIN_VALUE));
1784    assertIntEquals(Short.MAX_VALUE, shortToCharToShort(Short.MAX_VALUE));
1785    assertIntEquals(5678, shortToLongToInt((short) 5678));
1786    assertIntEquals(Short.MIN_VALUE, shortToLongToInt(Short.MIN_VALUE));
1787    assertIntEquals(Short.MAX_VALUE, shortToLongToInt(Short.MAX_VALUE));
1788    assertIntEquals(0x34, shortToCharToByte((short) 0x1234));
1789    assertIntEquals(-0x10, shortToCharToByte((short) 0x12f0));
1790    assertIntEquals(0, shortToCharToByte(Short.MIN_VALUE));
1791    assertIntEquals(-1, shortToCharToByte(Short.MAX_VALUE));
1792    assertStringEquals("c=1025, b=1", shortToCharToBytePrint((short) 1025));
1793    assertStringEquals("c=1023, b=-1", shortToCharToBytePrint((short) 1023));
1794    assertStringEquals("c=65535, b=-1", shortToCharToBytePrint((short) -1));
1795
1796    assertIntEquals(0x21, longAnd0xffToByte(0x1234432112344321L));
1797    assertIntEquals(0, longAnd0xffToByte(Long.MIN_VALUE));
1798    assertIntEquals(-1, longAnd0xffToByte(Long.MAX_VALUE));
1799    assertIntEquals(0x1234, intAnd0x1ffffToChar(0x43211234));
1800    assertIntEquals(0, intAnd0x1ffffToChar(Integer.MIN_VALUE));
1801    assertIntEquals(Character.MAX_VALUE, intAnd0x1ffffToChar(Integer.MAX_VALUE));
1802    assertIntEquals(0x4321, intAnd0x17fffToShort(0x87654321));
1803    assertIntEquals(0x0888, intAnd0x17fffToShort(0x88888888));
1804    assertIntEquals(0, intAnd0x17fffToShort(Integer.MIN_VALUE));
1805    assertIntEquals(Short.MAX_VALUE, intAnd0x17fffToShort(Integer.MAX_VALUE));
1806
1807    assertDoubleEquals(0.0, shortAnd0xffffToShortToDouble((short) 0));
1808    assertDoubleEquals(1.0, shortAnd0xffffToShortToDouble((short) 1));
1809    assertDoubleEquals(-2.0, shortAnd0xffffToShortToDouble((short) -2));
1810    assertDoubleEquals(12345.0, shortAnd0xffffToShortToDouble((short) 12345));
1811    assertDoubleEquals((double)Short.MAX_VALUE, shortAnd0xffffToShortToDouble(Short.MAX_VALUE));
1812    assertDoubleEquals((double)Short.MIN_VALUE, shortAnd0xffffToShortToDouble(Short.MIN_VALUE));
1813
1814    assertIntEquals(intReverseCondition(41), 13);
1815    assertIntEquals(intReverseConditionNaN(-5), 13);
1816
1817    for (String condition : new String[] { "Equal", "NotEqual" }) {
1818      for (String constant : new String[] { "True", "False" }) {
1819        for (String side : new String[] { "Rhs", "Lhs" }) {
1820          String name = condition + constant + side;
1821          assertIntEquals(runSmaliTest(name, true), 5);
1822          assertIntEquals(runSmaliTest(name, false), 3);
1823        }
1824      }
1825    }
1826  }
1827
1828  private static boolean $inline$true() { return true; }
1829  private static boolean $inline$false() { return false; }
1830
1831  public static boolean booleanField;
1832}
1833