From c73b3cb5996723c5a15c833a9da059b79c99cf9c Mon Sep 17 00:00:00 2001 From: Aleksey Shipilev Date: Wed, 31 Jul 2024 12:56:43 +0000 Subject: [PATCH] 8336635: Add IR test for Reference.refersTo intrinsic Reviewed-by: thartmann, kvn --- .../c2/irTests/gc/ReferenceRefersToTests.java | 156 ++++++++++++++++++ 1 file changed, 156 insertions(+) create mode 100644 test/hotspot/jtreg/compiler/c2/irTests/gc/ReferenceRefersToTests.java diff --git a/test/hotspot/jtreg/compiler/c2/irTests/gc/ReferenceRefersToTests.java b/test/hotspot/jtreg/compiler/c2/irTests/gc/ReferenceRefersToTests.java new file mode 100644 index 00000000000..7cf7c72c8fd --- /dev/null +++ b/test/hotspot/jtreg/compiler/c2/irTests/gc/ReferenceRefersToTests.java @@ -0,0 +1,156 @@ +/* + * Copyright Amazon.com Inc. or its affiliates. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package compiler.c2.irTests.gc; + +import jdk.test.lib.Asserts; +import compiler.lib.ir_framework.*; +import jdk.test.whitebox.gc.GC; + +import java.lang.ref.*; +import java.util.*; + +/* + * @test + * @bug 8256999 + * @summary Test that Reference.refersTo intrinsics are properly handled + * @library /test/lib / + * @build jdk.test.whitebox.WhiteBox + * @requires vm.compiler2.enabled + * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox + * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI compiler.c2.irTests.gc.ReferenceRefersToTests + */ +public class ReferenceRefersToTests { + + private static String[] args(String... add) { + List args = new ArrayList<>(); + + // Use PerMethodTrapLimit=0 to compile all branches in the intrinsics. + args.add("-XX:PerMethodTrapLimit=0"); + + // Forcefully inline all methods to reach the intrinsic code. + args.add("-XX:CompileCommand=inline,compiler.c2.irTests.gc.ReferenceRefersToTests::*"); + args.add("-XX:CompileCommand=inline,java.lang.ref.Reference::*"); + args.add("-XX:CompileCommand=inline,java.lang.ref.PhantomReference::*"); + + // Mix in test config code. + args.addAll(Arrays.asList(add)); + + return args.toArray(new String[0]); + } + + public static void main(String[] args) { + TestFramework framework = new TestFramework(); + + int idx = 0; + if (GC.isSelectedErgonomically() && GC.Serial.isSupported()) { + // Serial does not have any barriers in refersTo. + framework.addScenarios(new Scenario(idx++, args( + "-XX:+UseSerialGC" + ))); + } + if (GC.isSelectedErgonomically() && GC.Parallel.isSupported()) { + // Parallel does not have any barriers in refersTo. + framework.addScenarios(new Scenario(idx++, args( + "-XX:+UseParallelGC" + ))); + } + if (GC.isSelectedErgonomically() && GC.G1.isSupported()) { + // G1 nominally needs keep-alive barriers for Reference loads, + // but should not have them for refersTo. + framework.addScenarios(new Scenario(idx++, args( + "-XX:+UseG1GC" + ))); + } + if (GC.isSelectedErgonomically() && GC.Shenandoah.isSupported()) { + // Shenandoah nominally needs keep-alive barriers for Reference loads, + // but should not have them for refersTo. We only care to check that + // SATB barrier is not emitted. Shenandoah would also emit LRB barrier, + // which would false-negative the test. + framework.addScenarios(new Scenario(idx++, args( + "-XX:+UnlockDiagnosticVMOptions", + "-XX:ShenandoahGCMode=passive", + "-XX:+ShenandoahSATBBarrier", + "-XX:+UseShenandoahGC" + ))); + } + if (GC.isSelectedErgonomically() && GC.Z.isSupported()) { + // ZGC does not emit barriers in IR. + framework.addScenarios(new Scenario(idx++, args( + "-XX:+UseZGC" + ))); + } + framework.start(); + } + + static final Object REF = new Object(); + + static final SoftReference SR = new SoftReference<>(REF); + static final WeakReference WR = new WeakReference<>(REF); + static final PhantomReference PR = new PhantomReference<>(REF, null); + + // Verify that we are left with a single load of Reference.referent and no stores. + // This serves as a signal that no GC barriers are emitted in IR. + + @Test + @IR(counts = { IRNode.LOAD, "1" }) + @IR(failOn = { IRNode.STORE }) + public boolean soft_null() { + return SR.refersTo(null); + } + + @Test + @IR(counts = { IRNode.LOAD, "1" }) + @IR(failOn = { IRNode.STORE }) + public boolean soft_ref() { + return SR.refersTo(REF); + } + + @Test + @IR(counts = { IRNode.LOAD, "1" }) + @IR(failOn = { IRNode.STORE }) + public boolean weak_null() { + return WR.refersTo(null); + } + + @Test + @IR(counts = { IRNode.LOAD, "1" }) + @IR(failOn = { IRNode.STORE }) + public boolean weak_ref() { + return WR.refersTo(REF); + } + + @Test + @IR(counts = { IRNode.LOAD, "1" }) + @IR(failOn = { IRNode.STORE }) + public boolean phantom_null() { + return PR.refersTo(null); + } + + @Test + @IR(counts = { IRNode.LOAD, "1" }) + @IR(failOn = { IRNode.STORE }) + public boolean phantom_ref() { + return PR.refersTo(REF); + } + +}