• file
• revisions
• annotate
• diff
• comparison
• raw

test/compiler/6921969/TestMultiplyLongHiZero.java@dbb05f6d93c4 (annotated)

test/compiler/6921969/TestMultiplyLongHiZero.java

Mon, 28 Jul 2014 15:06:38 -0700

author

fzhinkin

date

Mon, 28 Jul 2014 15:06:38 -0700

changeset 6997

dbb05f6d93c4

parent 1907

c18cbe5936b8

child 6876

710a3c8b516e

permissions

-rw-r--r--

8051344: JVM crashed in Compile::start() during method parsing w/ UseRTMDeopt turned on
Summary: call rtm_deopt() only if there were no compilation bailouts before.
Reviewed-by: kvn

never@1644	1	/*
never@1644	2	* Copyright 2010 Google, Inc. All Rights Reserved.
never@1644	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
never@1644	4	*
never@1644	5	* This code is free software; you can redistribute it and/or modify it
never@1644	6	* under the terms of the GNU General Public License version 2 only, as
never@1644	7	* published by the Free Software Foundation.
never@1644	8	*
never@1644	9	* This code is distributed in the hope that it will be useful, but WITHOUT
never@1644	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
never@1644	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
never@1644	12	* version 2 for more details (a copy is included in the LICENSE file that
never@1644	13	* accompanied this code).
never@1644	14	*
never@1644	15	* You should have received a copy of the GNU General Public License version
never@1644	16	* 2 along with this work; if not, write to the Free Software Foundation,
never@1644	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
never@1644	18	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
never@1644	22	*
never@1644	23	*/
never@1644	24
never@1644	25	/*
never@1644	26	* @test
never@1644	27	* @bug 6921969
never@1644	28	* @summary Tests shorter long multiply sequences when the high 32 bits of long operands are known to be zero on x86_32
never@1644	29	* @run main/othervm -Xbatch -XX:-Inline -XX:CompileOnly=.testNormal,.testLeftOptimized,.testRightOptimized,.testOptimized,.testLeftOptimized_LoadUI2L,.testRightOptimized_LoadUI2L,.testOptimized_LoadUI2L TestMultiplyLongHiZero
never@1644	30	*/
never@1644	31
never@1644	32	// This test must run without any command line arguments.
never@1644	33
never@1644	34	public class TestMultiplyLongHiZero {
never@1644	35
never@1644	36	private static void check(long leftFactor, long rightFactor, long optimizedProduct, long constantProduct) {
never@1644	37	long normalProduct = leftFactor * rightFactor; // unaffected by the new optimization
never@1644	38	if (optimizedProduct != constantProduct || normalProduct != constantProduct) {
never@1644	39	throw new RuntimeException("Not all three products are equal: " +
never@1644	40	Long.toHexString(normalProduct) + ", " +
never@1644	41	Long.toHexString(optimizedProduct) + ", " +
never@1644	42	Long.toHexString(constantProduct));
never@1644	43	}
never@1644	44	}
never@1644	45
never@1644	46	private static int initInt(String[] args, int v) {
never@1644	47	if (args.length > 0) {
never@1644	48	try {
never@1644	49	return Integer.valueOf(args[0]);
never@1644	50	} catch (NumberFormatException e) { }
never@1644	51	}
never@1644	52	return v;
never@1644	53	}
never@1644	54
never@1644	55	private static final long mask32 = 0x00000000FFFFFFFFL;
never@1644	56
never@1644	57	private static void testNormal(int leftFactor, int rightFactor, long constantProduct) {
never@1644	58	check((long) leftFactor,
never@1644	59	(long) rightFactor,
never@1644	60	(long) leftFactor * (long) rightFactor, // unaffected by the new optimization
never@1644	61	constantProduct);
never@1644	62	}
never@1644	63
never@1644	64	private static void testLeftOptimized(int leftFactor, int rightFactor, long constantProduct) {
never@1644	65	check((leftFactor & mask32),
never@1644	66	(long) rightFactor,
never@1644	67	(leftFactor & mask32) * (long) rightFactor, // left factor optimized
never@1644	68	constantProduct);
never@1644	69	}
never@1644	70
never@1644	71	private static void testRightOptimized(int leftFactor, int rightFactor, long constantProduct) {
never@1644	72	check((long) leftFactor,
never@1644	73	(rightFactor & mask32),
never@1644	74	(long) leftFactor * (rightFactor & mask32), // right factor optimized
never@1644	75	constantProduct);
never@1644	76	}
never@1644	77
never@1644	78	private static void testOptimized(int leftFactor, int rightFactor, long constantProduct) {
never@1644	79	check((leftFactor & mask32),
never@1644	80	(rightFactor & mask32),
never@1644	81	(leftFactor & mask32) * (rightFactor & mask32), // both factors optimized
never@1644	82	constantProduct);
never@1644	83	}
never@1644	84
never@1644	85	private static void testLeftOptimized_LoadUI2L(int leftFactor, int rightFactor, long constantProduct, int[] factors) {
never@1644	86	check((leftFactor & mask32),
never@1644	87	(long) rightFactor,
never@1644	88	(factors[0] & mask32) * (long) rightFactor, // left factor optimized
never@1644	89	constantProduct);
never@1644	90	}
never@1644	91
never@1644	92	private static void testRightOptimized_LoadUI2L(int leftFactor, int rightFactor, long constantProduct, int[] factors) {
never@1644	93	check((long) leftFactor,
never@1644	94	(rightFactor & mask32),
never@1644	95	(long) leftFactor * (factors[1] & mask32), // right factor optimized
never@1644	96	constantProduct);
never@1644	97	}
never@1644	98
never@1644	99	private static void testOptimized_LoadUI2L(int leftFactor, int rightFactor, long constantProduct, int[] factors) {
never@1644	100	check((leftFactor & mask32),
never@1644	101	(rightFactor & mask32),
never@1644	102	(factors[0] & mask32) * (factors[1] & mask32), // both factors optimized
never@1644	103	constantProduct);
never@1644	104	}
never@1644	105
never@1644	106	private static void test(int leftFactor, int rightFactor,
never@1644	107	long normalConstantProduct,
never@1644	108	long leftOptimizedConstantProduct,
never@1644	109	long rightOptimizedConstantProduct,
never@1644	110	long optimizedConstantProduct) {
never@1644	111	int[] factors = new int[2];
never@1644	112	factors[0] = leftFactor;
never@1644	113	factors[1] = rightFactor;
never@1644	114	testNormal(leftFactor, rightFactor, normalConstantProduct);
never@1644	115	testLeftOptimized(leftFactor, rightFactor, leftOptimizedConstantProduct);
never@1644	116	testRightOptimized(leftFactor, rightFactor, rightOptimizedConstantProduct);
never@1644	117	testOptimized(leftFactor, rightFactor, optimizedConstantProduct);
never@1644	118	testLeftOptimized_LoadUI2L(leftFactor, rightFactor, leftOptimizedConstantProduct, factors);
never@1644	119	testRightOptimized_LoadUI2L(leftFactor, rightFactor, rightOptimizedConstantProduct, factors);
never@1644	120	testOptimized_LoadUI2L(leftFactor, rightFactor, optimizedConstantProduct, factors);
never@1644	121	}
never@1644	122
never@1644	123	public static void main(String[] args) {
never@1644	124	for (int i = 0; i < 100000; ++i) { // Trigger compilation
never@1644	125	int i0 = initInt(args, 1);
never@1644	126	int i1 = initInt(args, 3);
never@1644	127	int i2 = initInt(args, -1);
never@1644	128	int i3 = initInt(args, 0x7FFFFFFF);
never@1644	129	test(i0, i1, 3L, 3L, 3L, 3L);
never@1644	130	test(i0, i2, -1L, -1L, 0xFFFFFFFFL, 0xFFFFFFFFL);
never@1644	131	test(i0, i3, 0x7FFFFFFFL, 0x7FFFFFFFL, 0x7FFFFFFFL, 0x7FFFFFFFL);
never@1644	132	test(i1, i2, -3L, -3L, 0x2FFFFFFFDL, 0x2FFFFFFFDL);
never@1644	133	test(i1, i3, 0x17FFFFFFDL, 0x17FFFFFFDL, 0x17FFFFFFDL, 0x17FFFFFFDL);
never@1644	134	test(i2, i3, 0xFFFFFFFF80000001L, 0x7FFFFFFE80000001L,
never@1644	135	0xFFFFFFFF80000001L, 0x7FFFFFFE80000001L);
never@1644	136	}
never@1644	137	}
never@1644	138	}