JT Harness : Tests that passed

Tests are grouped by their final status message.

Clean successful

compiler/jvmci/compilerToVM/GetLocalVariableTableTest.java:

Execution successful

applications/ctw/modules/java_compiler.java: run CTW for all classes from java.compiler module
applications/ctw/modules/java_datatransfer.java: run CTW for all classes from java.datatransfer module
applications/ctw/modules/java_instrument.java: run CTW for all classes from java.instrument module
applications/ctw/modules/java_logging.java: run CTW for all classes from java.logging module
applications/ctw/modules/java_management.java: run CTW for all classes from java.management module
applications/ctw/modules/java_management_rmi.java: run CTW for all classes from java.management.rmi module
applications/ctw/modules/java_naming.java: run CTW for all classes from java.naming module
applications/ctw/modules/java_net_http.java: run CTW for all classes from java.net.http module
applications/ctw/modules/java_prefs.java: run CTW for all classes from java.prefs module
applications/ctw/modules/java_rmi.java: run CTW for all classes from java.rmi module
applications/ctw/modules/java_scripting.java: run CTW for all classes from java.scripting module
applications/ctw/modules/java_security_jgss.java: run CTW for all classes from java.security.jgss module
applications/ctw/modules/java_security_sasl.java: run CTW for all classes from java.security.sasl module
applications/ctw/modules/java_smartcardio.java: run CTW for all classes from java.smartcardio module
applications/ctw/modules/java_sql.java: run CTW for all classes from java.sql module
applications/ctw/modules/java_sql_rowset.java: run CTW for all classes from java.sql.rowset module
applications/ctw/modules/java_transaction_xa.java: run CTW for all classes from java.transaction.xa module
applications/ctw/modules/java_xml_crypto.java: run CTW for all classes from java.xml.crypto module
applications/ctw/modules/jdk_accessibility.java: run CTW for all classes from jdk.accessibility module
applications/ctw/modules/jdk_attach.java: run CTW for all classes from jdk.attach module
applications/ctw/modules/jdk_charsets.java: run CTW for all classes from jdk.charsets module
applications/ctw/modules/jdk_crypto_cryptoki.java: run CTW for all classes from jdk.crypto.cryptoki module
applications/ctw/modules/jdk_dynalink.java: run CTW for all classes from jdk.dynalink module
applications/ctw/modules/jdk_editpad.java: run CTW for all classes from jdk.editpad module
applications/ctw/modules/jdk_hotspot_agent.java: run CTW for all classes from jdk.hotspot.agent module
applications/ctw/modules/jdk_httpserver.java: run CTW for all classes from jdk.httpserver module
applications/ctw/modules/jdk_incubator_vector.java: run CTW for all classes from jdk.incubator.vector module
applications/ctw/modules/jdk_internal_ed.java: run CTW for all classes from jdk.internal.ed module
applications/ctw/modules/jdk_internal_jvmstat.java: run CTW for all classes from jdk.internal.jvmstat module
applications/ctw/modules/jdk_internal_le.java: run CTW for all classes from jdk.internal.le module
applications/ctw/modules/jdk_internal_md.java: run CTW for all classes from jdk.internal.md module
applications/ctw/modules/jdk_internal_opt.java: run CTW for all classes from jdk.internal.opt module
applications/ctw/modules/jdk_internal_vm_ci.java: run CTW for all classes from jdk.internal.vm.ci module
applications/ctw/modules/jdk_jartool.java: run CTW for all classes from jdk.jartool module
applications/ctw/modules/jdk_javadoc.java: run CTW for all classes from jdk.javadoc module
applications/ctw/modules/jdk_jcmd.java: run CTW for all classes from jdk.jcmd module
applications/ctw/modules/jdk_jconsole.java: run CTW for all classes from jdk.jconsole module
applications/ctw/modules/jdk_jdeps.java: run CTW for all classes from jdk.jdeps module
applications/ctw/modules/jdk_jdi.java: run CTW for all classes from jdk.jdi module
applications/ctw/modules/jdk_jfr.java: run CTW for all classes from jdk.jfr module
applications/ctw/modules/jdk_jlink.java: run CTW for all classes from jdk.jlink module
applications/ctw/modules/jdk_jpackage.java: run CTW for all classes from jdk.jpackage module
applications/ctw/modules/jdk_jshell.java: run CTW for all classes from jdk.jshell module
applications/ctw/modules/jdk_jsobject.java: run CTW for all classes from jdk.jsobject module
applications/ctw/modules/jdk_jstatd.java: run CTW for all classes from jdk.jstatd module
applications/ctw/modules/jdk_management.java: run CTW for all classes from jdk.management module
applications/ctw/modules/jdk_management_agent.java: run CTW for all classes from jdk.management.agent module
applications/ctw/modules/jdk_management_jfr.java: run CTW for all classes from jdk.management.jfr module
applications/ctw/modules/jdk_naming_dns.java: run CTW for all classes from jdk.naming.dns module
applications/ctw/modules/jdk_naming_rmi.java: run CTW for all classes from jdk.naming.rmi module
applications/ctw/modules/jdk_net.java: run CTW for all classes from jdk.net module
applications/ctw/modules/jdk_nio_mapmode.java: run CTW for all classes from jdk.nio.mapmode module
applications/ctw/modules/jdk_sctp.java: run CTW for all classes from jdk.sctp module
applications/ctw/modules/jdk_security_auth.java: run CTW for all classes from jdk.security.auth module
applications/ctw/modules/jdk_security_jgss.java: run CTW for all classes from jdk.security.jgss module
applications/ctw/modules/jdk_unsupported.java: run CTW for all classes from jdk.unsupported module
applications/ctw/modules/jdk_unsupported_desktop.java: run CTW for all classes from jdk.unsupported.desktop module
applications/ctw/modules/jdk_xml_dom.java: run CTW for all classes from jdk.xml.dom module
applications/ctw/modules/jdk_zipfs.java: run CTW for all classes from jdk.zipfs module
compiler/allocation/TestAllocArrayAfterAllocNoUse.java: fatal error: no reachable node should have no use
compiler/allocation/TestAllocation.java: Testing allocation expansion when there is no use of the allocation
compiler/allocation/TestCCPAllocateArray.java: C2: assert(t->meet(t0) == t) failed: Not monotonic after JDK-8278413
compiler/allocation/TestFailedAllocationBadGraph.java: C2 crash when allocating array of size too large
compiler/allocation/TestNewArrayBadSize.java: C2 compilation asserts with "Bad graph detected in compute_lca_of_uses"
compiler/allocation/TestNewArrayOutsideLoopValidLengthTestInLoop.java: C2: assert compiling SSLEngineInputRecord::decodeInputRecord
compiler/allocation/TestNewMaxLengthArray.java: C2: large byte array clone triggers "failed: malformed control flow" assertion failure on linux-x86
compiler/arguments/CheckCICompilerCount.java: Check that correct range of values for CICompilerCount are allowed depending on whether tiered is enabled or not
compiler/arguments/CheckCompileThresholdScaling.java: Add CompileThresholdScaling flag to control when methods are first compiled (with +/-TieredCompilation)
compiler/arguments/TestCodeEntryAlignment.java: Test large CodeEntryAlignments are accepted
compiler/arguments/TestCompileThresholdScaling.java: With a very large value of CompileThresholdScaling all scaled thresholds should be outside the allowed range
compiler/arguments/TestCompilerCounts.java:
compiler/arguments/TestLogJIT.java: Test running with log:jit*=debug enabled.
compiler/arguments/TestManyParameters.java: Check that C2's restriction on number of method arguments is not too restrictive on x64.
compiler/arguments/TestOptoLoopAlignment.java: Test large OptoLoopAlignments are accepted
compiler/arguments/TestScavengeRootsInCode.java: Test compilation with non-default value for ScavengeRootsInCode.
compiler/arguments/TestStressReflectiveCode.java: Test running with StressReflectiveCode enabled.
compiler/arguments/TestTraceICs.java: Test running with log:inlinecache=trace enabled.
compiler/arguments/TestTraceTypeProfile.java: Test running TraceTypeProfile enabled.
compiler/arguments/TestUseBMI1InstructionsOnSupportedCPU.java: Verify processing of UseBMI1Instructions option on CPU with BMI1 feature support.
compiler/arguments/TestUseBMI1InstructionsOnUnsupportedCPU.java: Verify processing of UseBMI1Instructions option on CPU without BMI1 feature support.
compiler/arguments/TestUseCompiler.java: Tests execution with inconsistent UseCompiler flag combination.
compiler/arguments/TestUseCountLeadingZerosInstructionOnSupportedCPU.java: Verify processing of UseCountLeadingZerosInstruction option on CPU with LZCNT support.
compiler/arguments/TestUseCountLeadingZerosInstructionOnUnsupportedCPU.java: Verify processing of UseCountLeadingZerosInstruction option on CPU without LZCNT support.
compiler/arguments/TestUseCountTrailingZerosInstructionOnSupportedCPU.java: Verify processing of UseCountTrailingZerosInstruction option on CPU with TZCNT (BMI1 feature) support.
compiler/arguments/TestUseCountTrailingZerosInstructionOnUnsupportedCPU.java: Verify processing of UseCountTrailingZerosInstruction option on CPU without TZCNT instruction (BMI1 feature) support.
compiler/arraycopy/ACasLoadsStoresBadMem.java: arraycopy converted as a series of loads/stores uses wrong slice for loads
compiler/arraycopy/TestACSameSrcDst.java: ArrayCopy with same src and dst can cause incorrect execution or compiler crash
compiler/arraycopy/TestArrayCloneBadAssert.java: assert broken when array size becomes known during igvn
compiler/arraycopy/TestArrayCopyAsLoadsStores.java#id0: small array copy as loads/stores
compiler/arraycopy/TestArrayCopyAsLoadsStores.java#id1:
compiler/arraycopy/TestArrayCopyBadReexec.java: Fix for 8064703 may also cause stores between the allocation and arraycopy to be rexecuted after a deoptimization
compiler/arraycopy/TestArrayCopyConjoint.java: Optimize arrayCopy using AVX-512 masked instructions.
compiler/arraycopy/TestArrayCopyDisjoint.java: Optimize arrayCopy using AVX-512 masked instructions.
compiler/arraycopy/TestArrayCopyDisjointLarge.java: Test large arrayCopy.
compiler/arraycopy/TestArrayCopyIntrinsicWithUCT.java: Test taking UCT between array allocation and array copy to report correct exception.
compiler/arraycopy/TestArrayCopyMacro.java: arraycopy as macro node
compiler/arraycopy/TestArrayCopyMaskedWithSub.java:
compiler/arraycopy/TestArrayCopyMaskedWithZeroSrc.java: Test that LoadVectorMaskedNodes works when the source array is known to only contain zeros
compiler/arraycopy/TestArrayCopyMemoryChain.java: Test correct wiring of load/store memory for arraycopy ideal transformation.
compiler/arraycopy/TestArrayCopyNoInit.java: Deoptimization between array allocation and arraycopy may result in non initialized array
compiler/arraycopy/TestArrayCopyNoInitDeopt.java: Infinite deoptimization/recompilation cycles in case of arraycopy with tightly coupled allocation
compiler/arraycopy/TestArrayCopyOfRangeGuards.java: Test that the appropriate guards are generated for the copyOfRange intrinsic, even if the result of the array copy is not used.
compiler/arraycopy/TestArrayCopyOfStopped.java: after guards in Arrays.copyOf() intrinsic, control may become top
compiler/arraycopy/TestArrayCopyOverflowArguments.java: Test that overflowed integers passed to arraycopy don't do any harm.
compiler/arraycopy/TestArrayCopyOverflowInBoundChecks.java: test that checks whether an array load falls into the range of an arraycopy is incorrect on 32bits
compiler/arraycopy/TestArrayCopyPartialInliningLoadSplit.java: misc tests failed "assert(false) failed: graph should be schedulable"
compiler/arraycopy/TestArrayCopyStoppedAfterGuards.java: control becomes top after arraycopy guards and confuses tighly coupled allocation logic
compiler/arraycopy/TestArrayCopyUNCBadMem.java: Loads generated at uncommon trap from eliminated arraycopy have incorrect memory state
compiler/arraycopy/TestArrayCopyWithBadOffset.java: Test arraycopy optimizations with bad src/dst array offsets.
compiler/arraycopy/TestArraysCopyOfNoTypeCheck.java: Arrays.copyOf doesn't perform subtype check
compiler/arraycopy/TestCloneAccess.java: Test cloning with more than 8 (=ArrayCopyLoadStoreMaxElem) where loads are wrongly replaced by zero.
compiler/arraycopy/TestCloneArrayWithDifferentLengthConstness.java: Test that idealization of clone-derived ArrayCopy nodes does not trigger assertion failures for different combinations of constant/variable array length (in number of elements) and array copy length (in words).
compiler/arraycopy/TestDeadArrayCopyOnMemChain.java: eliminated arraycopy node still reachable through exception edges
compiler/arraycopy/TestDefaultMethodArrayCloneDeoptC2.java: C2: Access to [].clone from interfaces fails.
compiler/arraycopy/TestEliminateArrayCopy.java: arraycopy to non escaping destination may be eliminated
compiler/arraycopy/TestEliminatedArrayCopyDeopt.java: Eliminated instance/array written to by an array copy variant must be correctly initialized when reallocated at a deopt
compiler/arraycopy/TestEliminatedArrayCopyPhi.java: Code that capture field values of eliminated allocation at a safepoint when there's an arraycopy behind a Phi is broken
compiler/arraycopy/TestEliminatedArrayLoopPredicateCopyDeopt.java: Cannot pin eliminated arraycopy loads for deopt state in uncommon trap path if it is a loop predicate unc
compiler/arraycopy/TestEliminatedCloneBadMemEdge.java: Elimination of clone's ArrayCopyNode may make compilation fail silently
compiler/arraycopy/TestIllegalArrayCopyBeforeInfiniteLoop.java: ArrayCopy with negative index before infinite loop
compiler/arraycopy/TestInstanceCloneAsLoadsStores.java: small instance clone as loads/stores
compiler/arraycopy/TestLoadBypassArrayCopy.java: load bypasses arraycopy that sets the value after the ArrayCopyNode is expanded
compiler/arraycopy/TestMissingControl.java: missing control on LoadRange and LoadKlass when array copy macro node is expanded
compiler/arraycopy/TestNegativeArrayCopyAfterLoop.java: C2 inline array_copy move CastIINode(Array Length) before allocation cause crash.
compiler/arraycopy/TestObjectArrayClone.java: Test Object.clone() intrinsic.
compiler/arraycopy/TestObjectArrayCopy.java: Wrong assertion 'should be an array copy/clone' in arraycopynode.cpp
compiler/arraycopy/TestOutOfBoundsArrayLoad.java: Out of bounds array load on clone source crashes GC which interpretes the loaded value as oop.
compiler/arraycopy/TestReduceBulkZeroingDisabled.java: Test arraycopy elimination with ReduceBulkZeroing disabled.
compiler/arraycopy/TestSunkLoadAntiDependency.java: C2: use_mem_state != load->find_exact_control(load->in(0)) assert failure
compiler/arraycopy/TestTightlyCoupledAllocationAssert.java: Test that triggers the too strong assertion "just_allocated_object(alloc_ctl) == ptr" in LibraryCallKit::tightly_coupled_allocation()
compiler/blackhole/BlackholeExistingIntrinsicWarningTest.java:
compiler/blackhole/BlackholeExperimentalUnlockTest.java:
compiler/blackhole/BlackholeIntrinsicTest.java:
compiler/blackhole/BlackholeNonEmptyWarningTest.java:
compiler/blackhole/BlackholeNonStaticWarningTest.java:
compiler/blackhole/BlackholeNonVoidWarningTest.java:
compiler/blackhole/DeadBhElimination.java: Test that blackhole without control input are removed
compiler/c1/ArithmeticRemRCE.java: apply RCE for % operations
compiler/c1/CCEMessageTest.java: C1 dumps incorrect class name in CCE message
compiler/c1/CanonicalizeArrayLength.java: C1 crashes in Canonicalizer::do_ArrayLength() after fix for JDK-8150102
compiler/c1/CanonicalizeGetModifiers.java#id0: Canonicalizes Foo.class.getModifiers() with interpreter mode
compiler/c1/CanonicalizeGetModifiers.java#id1: Canonicalizes Foo.class.getModifiers() with C1 mode
compiler/c1/CanonicalizeGetModifiers.java#id2: Canonicalizes Foo.class.getModifiers() with C2 mode
compiler/c1/KlassAccessCheckTest.java:
compiler/c1/MultiplyByMaxInt.java:
compiler/c1/NullCheckTest.java: C1 NullCheckEliminator yields incorrect exceptions
compiler/c1/RangeCheckVerificationOfIR.java: Checks the C1 RangeCheckEliminator::Verification code for nested exceptions in loops that are always executed once on the non-exceptional path.
compiler/c1/StrengthReduceCheck.java:
compiler/c1/Test6579789.java: Internal error "c1_LinearScan.cpp:1429 Error: assert(false,"")" in debuggee with fastdebug VM
compiler/c1/Test6756768.java: C1 generates invalid code
compiler/c1/Test6756768_2.java: C1 generates invalid code
compiler/c1/Test6757316.java: load_constant() produces a wrong long constant, with high a low words swapped
compiler/c1/Test6758234.java: if (k cond (a ? : b: c)) returns reversed answer if k is constant and b and c are longs
compiler/c1/Test6795465.java: Crash in assembler_sparc.cpp with client compiler on solaris-sparc
compiler/c1/Test6849574.java: VM crash using NonBlockingHashMap (high_scale_lib)
compiler/c1/Test6855215.java: Calculation error (NaN) after about 1500 calculations
compiler/c1/Test6932496.java: incorrect deopt of jsr subroutine on 64 bit c1
compiler/c1/Test7042153.java: Bad folding of IfOps with unloaded constant arguments in C1
compiler/c1/Test7090976.java: Eclipse/CDT causes a JVM crash while indexing C++ code
compiler/c1/Test7103261.java: crash with jittester on sparc
compiler/c1/Test7123108.java: C1 crashes with assert(if_state != NULL) failed: states do not match up
compiler/c1/Test8004051.java: assert(_oprs_len[mode] < maxNumberOfOperands) failed: array overflow
compiler/c1/Test8011706.java: loop invariant code motion may move load before store to the same field
compiler/c1/Test8011771.java: Array bound check elimination's in block motion doesn't always reset its data structures from one step to the other.
compiler/c1/Test8172751.java: OSR compilation at unreachable bci causes C1 crash
compiler/c1/Test8211100.java: hotspot C1 issue with comparing long numbers on x86 32-bit
compiler/c1/Test8267042.java: missing displaced_header initialization causes hangup
compiler/c1/Test8275337.java:
compiler/c1/Test8301489.java: ShortLoopOptimizer might lift instructions before their inputs
compiler/c1/TestArrayCopy.java: arraycopy may crash the VM with c1 on 64 bit
compiler/c1/TestArrayCopyToFromObject.java: C1-generated code for System.arraycopy() does not throw an ArrayStoreException if 'dst' is no a "proper" array (i.e., it is java.lang.Object)
compiler/c1/TestBadStateAtLongCmp.java: Incorrect result when switching to C2 OSR compilation from C1
compiler/c1/TestC1PhiPlacementPathologyMain.java: Test a pathological case for phi placement with an irreducible loop of a particular shape.
compiler/c1/TestCheckIndexC1Intrinsic.java: C1 intrinsic support for jdk.internal.util.Preconditions.checkIndex
compiler/c1/TestClassConstantPatching.java:
compiler/c1/TestConcurrentPatching.java: Test that concurrent patching of oop immediates is thread-safe in C1.
compiler/c1/TestDeoptInt.java: int value might not be correctly decoded on deopt with c1 on 64 bit
compiler/c1/TestGotoIfMain.java:
compiler/c1/TestInvokeinterfaceWithBadReceiver.java: Test monomorphic interface call to with invalid receiver.
compiler/c1/TestLargeMonitorOffset.java: Verify that monitors with large offset in the OSR buffer are handled properly.
compiler/c1/TestLinearScanHasFPURegisters.java:
compiler/c1/TestLinearScanOrderMain.java:
compiler/c1/TestLoadIndexedMismatch.java: C1: Incorrect LoadIndexed value numbering
compiler/c1/TestManyMethodParameters.java: Test if a call with 8 integer + 13 float = 21 parameters can can be compiled.
compiler/c1/TestNullArrayClone.java: Tests that an array clone call that has been compiled with C1 handles null values correctly.
compiler/c1/TestOSRLotsOfLocals.java: Test that OSR correctly handles method with large number of locals
compiler/c1/TestPinnedConstantExceptionEdge.java: Add check in LinearScan::resolve_exception_edge for pinned constant that is not virtual which cannot be used to find an interval which resulted in an assertion error.
compiler/c1/TestPinnedIntrinsics.java: Test correct scheduling of System.nanoTime C1 intrinsic.
compiler/c1/TestStaticInitializerSideEffect.java: Test that C1 respects that static initializers can have memory side effects.
compiler/c1/TestStaticInterfaceMethodCall.java: Test invocation of static interface method with and without method handle with C1.
compiler/c1/TestTooManyVirtualRegistersMain.java: Tests custom bytecode which requires too many virtual registers in the linear scan of C1.
compiler/c1/TestUnalignedLoad.java: unaligned load may fail with c1 on 64 bit
compiler/c1/TestUnresolvedFieldMain.java:
compiler/c1/TestValueNumberingNullObject.java: CTW: C1 compilation fails with assert(x->type()->tag() == f->type()->tag()) failed: should have same type
compiler/c1/UnsafeVolatileGuardTest.java: C1 value numbering handling of Unsafe.get*Volatile is incorrect
compiler/c1/VolatileGuardTest.java: C1 doesn't respect the JMM with volatile field loads
compiler/c2/ClearArray.java: ClearArray instruction overflows scratch buffer
compiler/c2/CompareKlassPointersTest.java: This test uses a class pointer comparison optimization which was not applied anymore since JDK-6964458 resulting in a better IR.
compiler/c2/FloatingPointFoldingTest.java: Test that causes C2 to fold two NaNs with different values into a single NaN.
compiler/c2/IVTest.java: JVM crashes while trying to execute api/java_security/Signature/SignatureTests.html#initSign tests.
compiler/c2/InterruptedTest.java: Thread.isInterrupted() fails to return true on multiprocessor PC
compiler/c2/IsInstanceTest.java: No ClassCastException for HashAttributeSet constructors if run with -Xcomp
compiler/c2/LongCountedLoopAsUnswitchIff.java: C2: assert(iff->Opcode() == Op_If || iff->Opcode() == Op_CountedLoopEnd || iff->Opcode() == Op_RangeCheck) failed: Check this code when new subtype is added
compiler/c2/MinValueStrideCountedLoop.java#id0: Loop increment should not be transformed into unsigned comparison
compiler/c2/MinValueStrideCountedLoop.java#id1: Loop increment should not be transformed into unsigned comparison
compiler/c2/PolynomialRoot.java: C2: assert(!def_outside->member(r)) failed: Use of external LRG overlaps the same LRG defined in this block
compiler/c2/StackOverflowInSetNextCall.java: Triggered a stack overflow in PhaseCFG::set_next_call due to a legitimately big (mostly deep and not wide) graph.
compiler/c2/SubsumingLoadsCauseFlagSpill.java: assert failure in coalesce.cpp: attempted to spill a non-spillable item
compiler/c2/Test5057225.java: Remove useless I2L conversions
compiler/c2/Test5091921.java: Sign flip issues in loop optimizer
compiler/c2/Test6186134.java: Server virtual machine produces/exeutes incorrect code.
compiler/c2/Test6196102.java: Integer seems to be greater than Integer.MAX_VALUE
compiler/c2/Test6357214.java: Hotspot server compiler gets integer comparison wrong
compiler/c2/Test6443505.java: Some cases for CmpLTMask missed; also wrong code.
compiler/c2/Test6559156.java: Server compiler generates bad code for "<= Integer.MAX_VALUE" expression
compiler/c2/Test6636138_1.java: SuperWord::co_locate_pack(Node_List* p) generates memory graph that leads to memory order violation.
compiler/c2/Test6636138_2.java: SuperWord::co_locate_pack(Node_List* p) generates memory graph that leads to memory order violation.
compiler/c2/Test6646019.java: array subscript expressions become top() with -d64
compiler/c2/Test6661247.java: Internal bug in 32-bit HotSpot optimizer while bit manipulations
compiler/c2/Test6695810.java: null oop passed to encode_heap_oop_not_null
compiler/c2/Test6700047.java: C2 failed in idom_no_update
compiler/c2/Test6711100.java: 64bit fastdebug server vm crashes with assert(_base == Int,"Not an Int")
compiler/c2/Test6724218.java: Fix raise_LCA_above_marks() early termination
compiler/c2/Test6732154.java: REG: Printing an Image using image/gif doc flavor crashes the VM, Solsparc
compiler/c2/Test6741738.java: TypePtr::add_offset() set incorrect offset when the add overflows
compiler/c2/Test6753639.java: Strange optimisation in for loop with cyclic integer condition
compiler/c2/Test6795362.java: 32bit server compiler leads to wrong results on solaris-x86
compiler/c2/Test6796786.java: invalid FP identity transform - (a - b) -> b - a
compiler/c2/Test6799693.java: Server compiler leads to data corruption when expression throws an Exception
compiler/c2/Test6800154.java: Add comments to long_by_long_mulhi() for better understandability
compiler/c2/Test6805724.java: ModLNode::Ideal() generates functionally incorrect graph when divisor is any (2^k-1) constant.
compiler/c2/Test6823453.java: DeoptimizeALot causes fastdebug server jvm to fail with assert(false,"unscheduable graph")
compiler/c2/Test6832293.java: JIT compiler got wrong result in type checking with -server
compiler/c2/Test6837011.java: SIGSEGV in PhaseIdealLoop in 32bit jvm
compiler/c2/Test6837094.java: False positive for "meet not symmetric" failure
compiler/c2/Test6843752.java: missing code for an anti-dependent Phi in GCM
compiler/c2/Test6851282.java: JIT miscompilation results in null entry in array when using CompressedOops
compiler/c2/Test6857159.java: local schedule failed with checkcast of Thread.currentThread()
compiler/c2/Test6863155.java: Server compiler generates incorrect code (x86, long, bitshift, bitmask)
compiler/c2/Test6866651.java: delay dead node elimination in set_req_X to prevent killing the current node when it is in use
compiler/c2/Test6877254.java: Implement StoreCMNode::Ideal to promote its OopStore above the MergeMem
compiler/c2/Test6880034.java: SIGBUS during deoptimisation at a safepoint on 64bit-SPARC
compiler/c2/Test6885584.java: A particular class structure causes large allocation spike for jit
compiler/c2/Test6897150.java: Hotspot optimises away a valid loop
compiler/c2/Test6901572.java: JVM 1.6.16 crash on loops: assert(has_node(i),"")
compiler/c2/Test6910484.java: incorrect integer optimization (loosing and op-r in a given example)
compiler/c2/Test6910605_1.java: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used original test: nsk/coverage/runtime/runtime007
compiler/c2/Test6910605_2.java: C2: NullPointerException/ClassCaseException is thrown when C2 with DeoptimizeALot is used
compiler/c2/Test6916644.java: C2 compiler crash on x86
compiler/c2/Test6930043.java: C2: SIGSEGV in javasoft.sqe.tests.lang.arr017.arr01702.arr01702.loop_forw(II)I
compiler/c2/Test6931567.java: JIT Error (on class file compiled with eclipse) on JVM x64 (but not on x32!).
compiler/c2/Test6935022.java: Server VM incorrectly breaks out of while loop
compiler/c2/Test6956668.java: misbehavior of XOR operator (^) with int
compiler/c2/Test6958485.java: fix for 6879921 was insufficient
compiler/c2/Test6959129.java: COMPARISON WITH INTEGER.MAX_INT DOES NOT WORK CORRECTLY IN THE CLIENT VM.
compiler/c2/Test6968348.java: Byteswapped memory access can point to wrong location after JIT
compiler/c2/Test6973329.java: C2 with Zero based COOP produces code with broken anti-dependency on x86
compiler/c2/Test6985295.java: JVM fails to evaluate condition randomly
compiler/c2/Test6992759.java: Bad code generated for integer <= comparison, fails for Integer.MAX_VALUE
compiler/c2/Test7002666.java: eclipse CDT projects crash with compressed oops
compiler/c2/Test7005594.java: Array overflow not handled correctly with loop optimzations
compiler/c2/Test7009359.java: HS optimizes new StringBuffer(null) so it does not throw NPE as expected
compiler/c2/Test7017746.java: Regression : C2 compiler crash due to SIGSEGV in PhaseCFG::schedule_early()
compiler/c2/Test7020614.java: "-server" mode optimizer makes code hang
compiler/c2/Test7024475.java: loop doesn't terminate when compiled
compiler/c2/Test7029152.java: Ideal nodes for String intrinsics miss memory edge optimization
compiler/c2/Test7041100.java: The load in String.equals intrinsic executed before null check
compiler/c2/Test7046096.java#id0: SEGV IN C2 WITH 6U25
compiler/c2/Test7046096.java#stringConcatInline: The same test with an updated compile directive that produces StringBuilder-backed string concatenations.
compiler/c2/Test7047069.java: Array can dynamically change size when assigned to an object field
compiler/c2/Test7048332.java: Cadd_cmpLTMask doesn't handle 64-bit tmp register properly
compiler/c2/Test7068051.java: SIGSEGV in PhaseIdealLoop::build_loop_late_post on T5440
compiler/c2/Test7110586.java: C2 generates icorrect results
compiler/c2/Test7125879.java: assert(proj != NULL) failed: must be found
compiler/c2/Test7160610.java: Unknown Native Code compilation issue.
compiler/c2/Test7169782.java: C2: SIGSEGV in LShiftLNode::Ideal(PhaseGVN*, bool)
compiler/c2/Test7174363.java: crash with Arrays.copyOfRange(original, from, to) when from > original.length
compiler/c2/Test7177917.java: Micro-benchmark for Math.pow() and Math.exp()
compiler/c2/Test7179138_2.java#id0: Incorrect result with String concatenation optimization
compiler/c2/Test7179138_2.java#stringConcatInline: The same test with an updated compile directive that produces StringBuilder-backed string concatenations.
compiler/c2/Test7190310.java: Inlining WeakReference.get(), and hoisting $referent may lead to non-terminating loops
compiler/c2/Test7190310_unsafe.java: Inlining WeakReference.get(), and hoisting $referent may lead to non-terminating loops
compiler/c2/Test7199742.java: A lot of C2 OSR compilations of the same method's bci
compiler/c2/Test8000805.java: JMM issue: short loads are non-atomic
compiler/c2/Test8002069.java: Assert failed in C2: assert(field->edge_count() > 0) failed: sanity
compiler/c2/Test8007294.java: ReduceFieldZeroing doesn't check for dependent load and can lead to incorrect execution
compiler/c2/Test8007722.java: GetAndSetP's MachNode should capture bottom type
compiler/c2/Test8202414.java: Unsafe write after primitive array creation may result in array length change
compiler/c2/Test8217359.java: C2 compiler triggers SIGSEGV after transformation in ConvI2LNode::Ideal
compiler/c2/Test8bitLogicalOperators.java: Missing x86_64.ad patterns for 8-bit logical operators with destination in memory
compiler/c2/TestAddXorIdeal.java: C2: Improve Add and Xor ideal optimizations
compiler/c2/TestAndShiftZeroCCP.java: Test that And nodes are added to the CCP worklist if they have an LShift as input.
compiler/c2/TestBitSetAndReset.java: Missing x86_64.ad patterns for clearing and setting long vector bits
compiler/c2/TestCMoveHasTopInput.java: C2: assert(false) failed: bad AD file after JDK-8267687
compiler/c2/TestCMoveIConAsBool.java: Test BoolNode::Ideal() transformation with CMoveINode that has a Con node as condition.
compiler/c2/TestCallDevirtualizationWithInfiniteLoop.java: Test that post-parse call devirtualization works when call does not have an IO projection.
compiler/c2/TestCastX2NotProcessedIGVN.java: C2: CastX2P Ideal transformation not always applied
compiler/c2/TestCastX2P.java: AArch64: remove extra register copy when converting from long to pointer.
compiler/c2/TestCharShortByteSwap.java: Tests Character/Short.reverseBytes and their intrinsics implementation in the server compiler
compiler/c2/TestCondAddDeadBranch.java: C2: assert(false) failed: unscheduable graph Error mixing types with -XX:+UseCMoveUnconditionally -XX:+UseVectorCmov
compiler/c2/TestDeadDataLoop.java: An unreachable loop is not removed, leading to a broken graph.
compiler/c2/TestDeadDataLoopIGVN.java: A dead data loop in dying code is not correctly removed resulting in unremovable data nodes.
compiler/c2/TestDeadPhiMergeMemLoop.java: A dead memory loop is detected when replacing an actually dead memory phi node in PhiNode::Ideal() by a dead MergeMemNode which builds a cycle with one of its slices.
compiler/c2/TestDivModNodes.java: Test that DIV and MOD nodes are converted into DIVMOD where possible
compiler/c2/TestDominatingDeadCheckCast.java: node replaced by dominating dead cast during parsing
compiler/c2/TestDuplicateSimpleLoopBackedge.java: Crash in PhaseIdealLoop::verify_strip_mined_scheduling
compiler/c2/TestExHandlerTrap.java#default_config: Test whether trap in place of pruned exception handler block works
compiler/c2/TestExHandlerTrap.java#no_profiling: basic smoke test for disabled ex.
compiler/c2/TestFoldCompares.java: C2 crash in IfNode::fold_compares
compiler/c2/TestFoldCompares2.java: Test Fold-compares are safe when C2 optimizes unstable_if traps (-XX:+OptimizeUnstableIf)
compiler/c2/TestFoldIfRemovesTopNode.java: C2 compilation hits 'node must be dead' assert
compiler/c2/TestGuardOfCastIIDoesntFold.java: C2: when a Type node becomes dead, make CFG path that uses it unreachable
compiler/c2/TestIfWithDeadRegion.java: Test IfNode::up_one_dom() with dead regions.
compiler/c2/TestImplicitNullCheckDominance.java: Check correct re-wiring of control edge when hoisting a memory operation for an implicit null check.
compiler/c2/TestInfiniteLoopCompilationFailure.java: C2: "assert(false) failed: infinite loop" failure
compiler/c2/TestLWLockingCodeGen.java: Tests correct code generation of lightweight locking when using -XX:+ShowMessageBoxOnError; times-out on failure
compiler/c2/TestLargeTreeOfSubNodes.java: Endless loop in C2 compilation triggered by AddNode::IdealIL
compiler/c2/TestLiveNodeLimit.java: Test which exceeds the live node limit in Compile::Code_Gen().
compiler/c2/TestLoadSplitThruPhiNull.java: C2: assert(has_node(i)) failed during split thru phi
compiler/c2/TestMatcherLargeOffset.java: C2: Unexpected dead nodes after matching
compiler/c2/TestMatcherTwoImmOffsets.java: Test that the matcher does not create dead nodes when matching address expressions with two immediate offsets.
compiler/c2/TestMergeStores.java#id0: Test merging of consecutive stores
compiler/c2/TestMergeStores.java#id1: Test merging of consecutive stores
compiler/c2/TestMergeStores.java#id2: Test merging of consecutive stores
compiler/c2/TestMergeStoresAndAllocationElimination.java: Test case where we had escape analysis tell us that we can possibly eliminate the array allocation, then MergeStores introduces a mismatched store, which the actual elimination does not verify for.
compiler/c2/TestMergeStoresMemorySegment.java#byte-array: Test MergeStores optimization for MemorySegment
compiler/c2/TestMergeStoresMemorySegment.java#byte-buffer: Test MergeStores optimization for MemorySegment
compiler/c2/TestMergeStoresMemorySegment.java#byte-buffer-direct: Test MergeStores optimization for MemorySegment
compiler/c2/TestMergeStoresMemorySegment.java#char-array: Test MergeStores optimization for MemorySegment
compiler/c2/TestMergeStoresMemorySegment.java#double-array: Test MergeStores optimization for MemorySegment
compiler/c2/TestMergeStoresMemorySegment.java#float-array: Test MergeStores optimization for MemorySegment
compiler/c2/TestMergeStoresMemorySegment.java#int-array: Test MergeStores optimization for MemorySegment
compiler/c2/TestMergeStoresMemorySegment.java#long-array: Test MergeStores optimization for MemorySegment
compiler/c2/TestMergeStoresMemorySegment.java#native: Test MergeStores optimization for MemorySegment
compiler/c2/TestMergeStoresMemorySegment.java#short-array: Test MergeStores optimization for MemorySegment
compiler/c2/TestMergeStoresNullAdrType.java: Test merge stores, when "adr_type() == nullptr" because of TOP somewhere in the address.
compiler/c2/TestMergeStoresUnsafeArrayPointer.java: Test merge stores for some Unsafe store address patterns.
compiler/c2/TestMinMaxSubword.java: Test Math.min/max vectorization miscompilation for integer subwords
compiler/c2/TestMinValueStrideLongCountedLoop.java: Long counted loop exit check should not be transformed into an unsigned check
compiler/c2/TestModDivTopInput.java: C2: assert(_base == Long) failed: Not a Long
compiler/c2/TestMultiplyLongHiZero.java: Tests shorter long multiply sequences when the high 32 bits of long operands are known to be zero on x86_32
compiler/c2/TestNPEHeapBased.java: Invalid ImplicitNullChecks when heap base not protected
compiler/c2/TestNotifyCastToXor.java: Test that xor nodes are properly notified when constraint casts change.
compiler/c2/TestNullRegionInputAtPhiMakePathDead.java: Crash in fuzzer tests: assert(n != nullptr) failed: must not be null
compiler/c2/TestReduceAllocationAndHeapDump.java: Check that the JVM is able to dump the heap even when there are ReduceAllocationMerge in the scope.
compiler/c2/TestReduceAllocationAndLoadKlass.java: Check that Reduce Allocation Merges doesn't crash when CompressedClassPointers is disabled and there is an access to Klass "field" through the phi.
compiler/c2/TestReduceAllocationAndMemoryLoop.java: Check that the RAM optimization works when there is a memory loop.
compiler/c2/TestReduceAllocationAndNullableLoads.java: Check that Reduce Allocation Merges does not crash when legacy string concatenation optimization is applied.
compiler/c2/TestReduceAllocationAndPointerComparisons.java: Check that Reduce Allocation Merges correctly handle "NE" pointer comparisons.
compiler/c2/TestRemoveMemBarPrecEdge.java: Test removal of precedence edge of MemBarAcquire together with other now dead input nodes which visits a top node.
compiler/c2/TestRemoveSingleIterationLoop.java: Test that OuterStripMinedLoop and its CountedLoop are both removed after the removal of Opaque1 and 2 nodes which allows the loop backedge to be optimized out.
compiler/c2/TestRenumberLiveNodesInfiniteLoop.java: Crash in PhaseIdealLoop::verify_strip_mined_scheduling
compiler/c2/TestReplaceEquivPhis.java: Unexpected test result caused by C2 MergeMemNode::Ideal
compiler/c2/TestReplacedNodesOSR.java: SafePointNode::_replaced_nodes breaks with irreducible loops
compiler/c2/TestRotateNegativeEvenValues.java: Test RotateLeftNode and RotateRightNode with negative even numbers which produces a wrong result due to applying an arithemtic instead of a logical shift.
compiler/c2/TestShiftRightAndAccumulate.java#id0: AArch64: Wrong code generated for shifting right and accumulating four unsigned short integers.
compiler/c2/TestShiftRightAndAccumulate.java#id1: AArch64: Wrong code generated for shifting right and accumulating four unsigned short integers.
compiler/c2/TestSignExtract.java: Better implementation for sign extract.
compiler/c2/TestSkipLongToIntCast.java: Functional test to enshure CmpL(int value, long constant) is not broken
compiler/c2/TestSubIdealC0Minus_YPlusC1_.java: New subnode ideal optimization: converting "c0 - (x + c1)" into "(c0 - c1) - x"
compiler/c2/TestTopCastIIOnUndetectedDeadPath.java: CastII because of condition guarding it becomes top
compiler/c2/TestTopCastIIOnUndetectedDeadPath2.java: CastII because of condition guarding it becomes top
compiler/c2/TestTopCastIIOnUndetectedDeadPath3.java: CastII because of condition guarding it becomes top
compiler/c2/TestTopCastIIOnUndetectedDeadPath4.java#JDK-8293941: Tests that CastII are not dying anymore and breaking the graph due to control that is not removed
compiler/c2/TestTopCastIIOnUndetectedDeadPath4.java#JDK-8314111: Tests that CastII are not dying anymore and breaking the graph due to control that is not removed
compiler/c2/TestTopCastIIOnUndetectedDeadPath4.java#NoFlags: Tests that CastII are not dying anymore and breaking the graph due to control that is not removed
compiler/c2/TestUnalignedAccess.java: AArch64: C2 compilation hits offset_ok_for_immed: assert "c2 compiler bug".
compiler/c2/TestUnexpectedParallelIV.java: Unexpected parallel induction variable pattern was recongized
compiler/c2/TestUninitializedKlassField.java: Test that the TypeAryPtr::_klass field is properly initialized on use.
compiler/c2/TestUnreachableRegionDuringCCP.java: Test removal of unreachable regions during CCP.
compiler/c2/TestUnresolvedConstantDynamic.java: Test compilation of unresolved constant dynamics.
compiler/c2/TestUnsignedByteCompare.java: Bitwise AND on byte value sometimes produces wrong result
compiler/c2/TestUnsignedByteCompare1.java:
compiler/c2/TestUnsignedCompareIntoEqualityNotCanonical.java: C2: assert(BoolTest(btest).is_canonical()) failure
compiler/c2/UpcastTest.java:
compiler/c2/aarch64/ConvI2LWideningAssertTooStrong.java: C2 OSR compilation fails with "shouldn't process one node several times" in final graph reshaping
compiler/c2/aarch64/TestIntrinsicsRegStress.java: Verify vector register clobbering in some aarch64 intrinsics
compiler/c2/cr6646020/Tester.java: assert(in_bb(n),"must be in block") in -Xcomp mode
compiler/c2/cr6663848/Tester.java: assert(i < Max(),"oob")
compiler/c2/cr6663854/Test6663854.java: assert(n != __null,"Bad immediate dominator info.") in C2 with -Xcomp
compiler/c2/cr6711117/Test.java: Assertion in 64bit server vm (flat != TypePtr::BOTTOM,"cannot alias-analyze an untyped ptr")
compiler/c2/cr6712835/Test6712835.java: Server compiler fails with assertion (loop_count < K,"infinite loop in PhaseIterGVN::transform")
compiler/c2/cr6714694/Tester.java: assertion in 64bit server vm (store->find_edge(load) != -1,"missing precedence edge") with COOPs
compiler/c2/cr6865031/Test.java: Application gives bad result (throws bad exception) with compressed oops
compiler/c2/cr7192963/TestByteVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/cr7192963/TestDoubleVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/cr7192963/TestFloatVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/cr7192963/TestIntVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/cr7192963/TestLongVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/cr7192963/TestShortVect.java: assert(_in[req-1] == this) failed: Must pass arg count to 'new'
compiler/c2/cr7200264/TestIntVect.java: 7192963 changes disabled shift vectors
compiler/c2/gvn/DoubleLShiftCrashDuringIGVN.java: During the transformation (X << con1) << con2 ==> X << (con1 + con2) in IGVN, we modified the inner shift, during the transformation of the outer shift without removing it from the hashtable
compiler/c2/gvn/MissedOptCastII.java#id0: Missed optimization in IGVN because `CastIINode::Value` used to look for deep structures.
compiler/c2/gvn/MissedOptCastII.java#id1:
compiler/c2/gvn/MissedOptWithShiftConvAnd.java#id0: AndNode has a special handling when one of the operands is a LShiftNode: (LHS << s) & RHS if RHS fits in less than s bits, the value of this expression is 0.
compiler/c2/gvn/MissedOptWithShiftConvAnd.java#id1:
compiler/c2/gvn/MissedOptWithShiftConvCastAnd.java#id0: Similar to MissedOptWithShiftConvAnd, but with CastII on the way.
compiler/c2/gvn/MissedOptWithShiftConvCastAnd.java#id1:
compiler/c2/gvn/ReverseBytesConstantsTests.java: Test that ReverseBytes operations constant-fold.
compiler/c2/gvn/TestBoolNodeGVN.java: Refactor boolean node tautology transformations
compiler/c2/irTests/AddINodeIdealizationTests.java: Test that Ideal transformations of AddINode* are being performed as expected.
compiler/c2/irTests/AddLNodeIdealizationTests.java: Test that Ideal transformations of AddLNode* are being performed as expected.
compiler/c2/irTests/AndINodeIdealizationTests.java: Test that Ideal transformations of AndINode* are being performed as expected.
compiler/c2/irTests/AndLNodeIdealizationTests.java: Test that Ideal transformations of AndLNode* are being performed as expected.
compiler/c2/irTests/CMoveLConstants.java: Verify codegen for CMoveL with constants 0 and 1
compiler/c2/irTests/CmpUWithZero.java: verify that x <u 1 is transformed to x == 0
compiler/c2/irTests/ConstructorBarriers.java: Test barriers emitted in constructors
compiler/c2/irTests/ConvF2HFIdealizationTests.java: Test that Ideal transformations of ConvF2HF are being performed as expected.
compiler/c2/irTests/DeMorganLawIntTests.java: Test that Ideal transformations on the De Morgan's Law perform as expected for int.
compiler/c2/irTests/DeMorganLawLongTests.java: Test that Ideal transformations on the De Morgan's Law perform as expected for long.
compiler/c2/irTests/DivINodeIdealizationTests.java: Test that Ideal transformations of DivINode* are being performed as expected.
compiler/c2/irTests/DivLNodeIdealizationTests.java: Test that Ideal transformations of DivLNode* are being performed as expected.
compiler/c2/irTests/FPModWithoutControlProj.java: Test that Ideal transformations of Mod[DF]Node are not crashing when control proj is absent, and the node is still removed.
compiler/c2/irTests/LShiftINodeIdealizationTests.java: Test that Ideal transformations of LShiftINode* are being performed as expected.
compiler/c2/irTests/LShiftLNodeIdealizationTests.java: Test that Ideal transformations of LShiftLNode* are being performed as expected.
compiler/c2/irTests/MaxMinINodeIdealizationTests.java: Test that Ideal transformations of MaxINode and MinINode are being performed as expected.
compiler/c2/irTests/ModDNodeTests.java: Test that Ideal transformations of ModDNode are being performed as expected.
compiler/c2/irTests/ModFNodeTests.java: Test that Ideal transformations of ModFNode are being performed as expected.
compiler/c2/irTests/ModINodeIdealizationTests.java: Test that Ideal transformations of ModINode* are being performed as expected.
compiler/c2/irTests/ModLNodeIdealizationTests.java: Test that Ideal transformations of ModLNode* are being performed as expected.
compiler/c2/irTests/MulHFNodeIdealizationTests.java: Test that Ideal transformations of MulHFNode are being performed as expected.
compiler/c2/irTests/MulINodeIdealizationTests.java: Test that Ideal transformations of MulINode* are being performed as expected.
compiler/c2/irTests/MulLNodeIdealizationTests.java: Test that Ideal transformations of MulLNode* are being performed as expected.
compiler/c2/irTests/OrINodeIdealizationTests.java: Test that Ideal transformations of OrINode* are being performed as expected.
compiler/c2/irTests/OrLNodeIdealizationTests.java: Test that Ideal transformations of OrLNode* are being performed as expected.
compiler/c2/irTests/ProfileAtTypeCheck.java: C2: use profile data in subtype checks when profile has more than one class
compiler/c2/irTests/RShiftINodeIdealizationTests.java: Test that RShiftINode optimizations are being performed as expected.
compiler/c2/irTests/RShiftLNodeIdealizationTests.java: Test that RShiftLNode optimizations are being performed as expected.
compiler/c2/irTests/RotateLeftNodeIntIdealizationTests.java: Test that Ideal transformations of RotateLeftNode* are being performed as expected.
compiler/c2/irTests/RotateLeftNodeLongIdealizationTests.java: Test that Ideal transformations of RotateLeftNode* are being performed as expected.
compiler/c2/irTests/SubINodeIdealizationTests.java: Test that Ideal transformations of SubINode* are being performed as expected.
compiler/c2/irTests/SubLNodeIdealizationTests.java: Test that Ideal transformations of SubLNode* are being performed as expected.
compiler/c2/irTests/TestArrayElementTypeLoad.java:
compiler/c2/irTests/TestAutoVecCountingDownLoop.java: Auto-vectorization enhancement for special counting down loops
compiler/c2/irTests/TestAutoVectorization2DArray.java: Auto-vectorization enhancement for two-dimensional array operations
compiler/c2/irTests/TestBackToBackIfs.java: C2: Improve identical back-to-back if elimination
compiler/c2/irTests/TestBackToBackMustBeNotNull.java: C2: missing record_for_ign() call in GraphKit::must_be_not_null()
compiler/c2/irTests/TestCMoveCCP.java: C2: improve CMoveNode::Value() when condition is always true or false
compiler/c2/irTests/TestContinuationPinningAndEA.java: Test that Continuation.pin() and unpin() intrinsics work with EA.
compiler/c2/irTests/TestConv2BExpansion.java: Test that patterns leading to Conv2B are correctly expanded.
compiler/c2/irTests/TestConvI2LCastLongLoop.java: C2: Optimize MemorySegment shape in int loop
compiler/c2/irTests/TestCountedLoopPhiValue.java: PhiNode::Value() is too conservative for tripcount of CountedLoop
compiler/c2/irTests/TestCountedLoopSafepoint.java: check counted loop is properly constructed with/without safepoint
compiler/c2/irTests/TestDebugInfo.java: Verify that debug information in C2 compiled code is correct.
compiler/c2/irTests/TestEnumFinalFold.java: Verify constant folding for Enum fields
compiler/c2/irTests/TestFPComparison.java: Test that code generation for fp comparison works as intended
compiler/c2/irTests/TestFPConversion.java: Test that code generation for FP conversion works as intended
compiler/c2/irTests/TestFewIterationsCountedLoop.java: Add Tests to verify single iteration loops are properly optimized
compiler/c2/irTests/TestFloat16ScalarOperations.java: Validate compiler IR for various Float16 scalar operations.
compiler/c2/irTests/TestGetAndAdd.java: verify that the correct node is matched for atomic getAndAdd
compiler/c2/irTests/TestIRAbs.java: Test abs nodes optimization in C2.
compiler/c2/irTests/TestIRFma.java: Test fma match rule after C2 optimizer.
compiler/c2/irTests/TestIRLShiftIdeal_XPlusX_LShiftC.java: Test that transformation from (x + x) >> c to x >> (c + 1) works as intended.
compiler/c2/irTests/TestIfMinMax.java: Test that if expressions are properly folded into min/max nodes
compiler/c2/irTests/TestIterativeEA.java: Test C2 iterative Escape Analysis to remove all allocations in test
compiler/c2/irTests/TestLSMMissedEmptyLoop.java:
compiler/c2/irTests/TestLongRangeChecks.java: C2: optimize long range checks in long counted loops
compiler/c2/irTests/TestMinMaxIdentities.java: Test identities of MinNodes and MaxNodes.
compiler/c2/irTests/TestMulNodeIdealization.java: Test that transformation of multiply-by-2 is appropriately turned into additions.
compiler/c2/irTests/TestOptimizeUnstableIf.java: Test that C2 uses aggressive liveness to get rid of the boxing object which is only consumed by uncommon_trap.
compiler/c2/irTests/TestPadding.java: [x64] Fix useless padding
compiler/c2/irTests/TestPhiDuplicatedConversion.java: Test that patterns involving duplicated conversion nodes behind phi are properly optimized.
compiler/c2/irTests/TestPostParseCallDevirtualization.java: Test that post-parse call devirtualization works as intended.
compiler/c2/irTests/TestPrunedExHandler.java: check that uncommon trap is generated for unhandled catch block
compiler/c2/irTests/TestPushAddThruCast.java: c2: Transform (CastLL (AddL into (AddL (CastLL when possible
compiler/c2/irTests/TestRemixAddressExpressions.java: C2: Refactor PhaseIdealLoop::remix_address_expressions() so it operates on longs
compiler/c2/irTests/TestScalarReplacement.java: Test various scalarization scenarios
compiler/c2/irTests/TestScheduleSmallMethod.java: Test that small method with runtime calls can be scheduled.
compiler/c2/irTests/TestShiftAndMask.java: C2: optimize mask checks in counted loops
compiler/c2/irTests/TestSkeletonPredicates.java: C2: assert(false) failed: graph should be schedulable
compiler/c2/irTests/TestSpecialCasesOf_AMinusB_Plus_CMinusD_InAddIdeal.java: Remove unreached rules in AddNode::IdealIL
compiler/c2/irTests/TestStripMiningDropsSafepoint.java: When loop strip mining fails, safepoints are removed from loop anyway
compiler/c2/irTests/TestSuperwordFailsUnrolling.java: C2: loop candidate for superword not always unrolled fully if superword fails
compiler/c2/irTests/TestTestRemovalPeephole.java: Test that unnessercary test instructions are not present in the final code
compiler/c2/irTests/TestTypeSpeculation.java: C2: optimize long range checks in long counted loops
compiler/c2/irTests/TestUnsignedComparison.java: Test that unsigned comparison transformation works as intended.
compiler/c2/irTests/TestVectorConditionalMove.java: Auto-vectorization enhancement to support vector conditional move.
compiler/c2/irTests/TestVectorizationMismatchedAccess.java: C2: vectorization fails on simple ByteBuffer loop
compiler/c2/irTests/TestVectorizationMultiInvar.java: C2: vectorization fails on some simple Memory Segment loops
compiler/c2/irTests/TestVectorizationNotRun.java:
compiler/c2/irTests/TestVectorizeTypeConversion.java: Auto-vectorization enhancement for type conversion between different data sizes.
compiler/c2/irTests/TestVectorizeURShiftSubword.java: Auto-vectorization enhancement for unsigned shift right on signed subword types
compiler/c2/irTests/UDivINodeIdealizationTests.java: Test that Ideal transformations of UDivINode* are being performed as expected.
compiler/c2/irTests/UDivLNodeIdealizationTests.java: Test that Ideal transformations of UDivLNode* are being performed as expected.
compiler/c2/irTests/UModINodeIdealizationTests.java: Test that Ideal transformations of UModINode* are being performed as expected.
compiler/c2/irTests/UModLNodeIdealizationTests.java: Test that Ideal transformations of UModLNode* are being performed as expected.
compiler/c2/irTests/URShiftINodeIdealizationTests.java: Test that Ideal transformations of URShiftINode* are being performed as expected.
compiler/c2/irTests/URShiftLNodeIdealizationTests.java: Test that Ideal transformations of URShiftLNode* are being performed as expected.
compiler/c2/irTests/XorINodeIdealizationTests.java: Test correctness of optimizations of xor
compiler/c2/irTests/XorLNodeIdealizationTests.java: Test correctness of optimizations of xor
compiler/c2/irTests/blackhole/BlackholeHotInlineTest.java: Blackholes should work when hot inlined
compiler/c2/irTests/blackhole/BlackholeLoadOptoTest.java: Blackholes should allow load optimizations
compiler/c2/irTests/blackhole/BlackholeStoreStoreEATest.java: Blackhole arguments are globally escaping, thus preventing advanced EA optimizations
compiler/c2/irTests/blackhole/BlackholeSyncEATest.java: Blackhole arguments are globally escaping, thus preventing advanced EA optimizations
compiler/c2/irTests/gc/ReferenceClearTests.java: Test that Reference.clear intrinsics are properly handled
compiler/c2/irTests/gc/ReferenceRefersToTests.java: Test that Reference.refersTo intrinsics are properly handled
compiler/c2/irTests/igvn/TestCombineAddPWithConstantOffsets.java: Test that chains of AddP nodes with constant offsets are idealized when their offset input changes.
compiler/c2/irTests/igvn/TestIntegerMulRing.java: Test that IntegerMulRing works correctly and returns correct (and optimized) types.
compiler/c2/irTests/igvn/TestLoadNIdeal.java: Test that IGVN optimizes away one of two identical LoadNs.
compiler/c2/irTests/loopOpts/LoopIdealizationTests.java: Test that Ideal transformations of CountedLoopNode* are being performed as expected.
compiler/c2/irTests/scalarReplacement/ScalarReplacementTests.java: Tests that Escape Analysis and Scalar Replacement is able to handle some simple cases.
compiler/c2/irTests/scalarReplacement/ScalarReplacementWithGCBarrierTests.java: Tests that dead barrier control flows do not affect the scalar replacement.
compiler/c2/irTests/stable/StablePrimArrayTest.java: Check stable field folding and barriers
compiler/c2/irTests/stable/StablePrimFinalTest.java: Check stable field folding and barriers
compiler/c2/irTests/stable/StablePrimPlainTest.java: Check stable field folding and barriers
compiler/c2/irTests/stable/StablePrimVolatileTest.java: Check stable field folding and barriers
compiler/c2/irTests/stable/StableRefArrayTest.java: Check stable field folding and barriers
compiler/c2/irTests/stable/StableRefFinalTest.java: Check stable field folding and barriers
compiler/c2/irTests/stable/StableRefPlainTest.java: Check stable field folding and barriers
compiler/c2/irTests/stable/StableRefVolatileTest.java: Check stable field folding and barriers
compiler/c2/irTests/stringopts/TestNegativeArraySize.java: C2 applies string opts to StringBuilder object created with a negative size and misses the NegativeArraySizeException.
compiler/c2/unloaded/TestInlineUnloaded.java:
compiler/calls/NativeCalls.java: check that native methods get compiled and printed
compiler/calls/TestDirtyInt.java:
compiler/calls/fromCompiled/CompiledInvokeDynamic2CompiledTest.java: check calls from compiled to compiled using InvokeDynamic
compiler/calls/fromCompiled/CompiledInvokeDynamic2InterpretedTest.java: check calls from compiled to interpreted using InvokeDynamic
compiler/calls/fromCompiled/CompiledInvokeDynamic2NativeTest.java: check calls from compiled to native using InvokeDynamic
compiler/calls/fromCompiled/CompiledInvokeInterface2CompiledTest.java: check calls from compiled to compiled using InvokeInterface
compiler/calls/fromCompiled/CompiledInvokeInterface2InterpretedTest.java: check calls from compiled to interpreted using InvokeInterface
compiler/calls/fromCompiled/CompiledInvokeInterface2NativeTest.java: check calls from compiled to native using InvokeInterface
compiler/calls/fromCompiled/CompiledInvokeSpecial2CompiledTest.java: check calls from compiled to compiled using InvokeSpecial
compiler/calls/fromCompiled/CompiledInvokeSpecial2InterpretedTest.java: check calls from compiled to interpreted using InvokeSpecial
compiler/calls/fromCompiled/CompiledInvokeSpecial2NativeTest.java: check calls from compiled to native using InvokeSpecial
compiler/calls/fromCompiled/CompiledInvokeStatic2CompiledTest.java: check calls from compiled to compiled using InvokeStatic
compiler/calls/fromCompiled/CompiledInvokeStatic2InterpretedTest.java: check calls from compiled to interpreted using InvokeStatic
compiler/calls/fromCompiled/CompiledInvokeStatic2NativeTest.java: check calls from compiled to native using InvokeStatic
compiler/calls/fromCompiled/CompiledInvokeVirtual2CompiledTest.java: check calls from compiled to compiled using InvokeVirtual
compiler/calls/fromCompiled/CompiledInvokeVirtual2InterpretedTest.java: check calls from compiled to interpreted using InvokeVirtual
compiler/calls/fromCompiled/CompiledInvokeVirtual2NativeTest.java: check calls from compiled to native using InvokeVirtual
compiler/calls/fromInterpreted/InterpretedInvokeDynamic2CompiledTest.java: check calls from interpreted to compiled using InvokeDynamic
compiler/calls/fromInterpreted/InterpretedInvokeDynamic2InterpretedTest.java: check calls from interpreted to interpreted using InvokeDynamic
compiler/calls/fromInterpreted/InterpretedInvokeDynamic2NativeTest.java: check calls from interpreted to native using InvokeDynamic
compiler/calls/fromInterpreted/InterpretedInvokeInterface2CompiledTest.java: check calls from interpreted to compiled using InvokeInterface
compiler/calls/fromInterpreted/InterpretedInvokeInterface2InterpretedTest.java: check calls from interpreted to interpreted using InvokeInterface
compiler/calls/fromInterpreted/InterpretedInvokeInterface2NativeTest.java: check calls from interpreted to native using InvokeInterface
compiler/calls/fromInterpreted/InterpretedInvokeSpecial2CompiledTest.java: check calls from interpreted to compiled using InvokeSpecial
compiler/calls/fromInterpreted/InterpretedInvokeSpecial2InterpretedTest.java: check calls from interpreted to interpreted using InvokeSpecial
compiler/calls/fromInterpreted/InterpretedInvokeSpecial2NativeTest.java: check calls from interpreted to native using InvokeSpecial
compiler/calls/fromInterpreted/InterpretedInvokeStatic2CompiledTest.java: check calls from interpreted to compiled using InvokeStatic
compiler/calls/fromInterpreted/InterpretedInvokeStatic2InterpretedTest.java: check calls from interpreted to interpreted using InvokeStatic
compiler/calls/fromInterpreted/InterpretedInvokeStatic2NativeTest.java: check calls from interpreted to native using InvokeStatic
compiler/calls/fromInterpreted/InterpretedInvokeVirtual2CompiledTest.java: check calls from interpreted to compiled using InvokeVirtual
compiler/calls/fromInterpreted/InterpretedInvokeVirtual2InterpretedTest.java: check calls from interpreted to interpreted using InvokeVirtual
compiler/calls/fromInterpreted/InterpretedInvokeVirtual2NativeTest.java: check calls from interpreted to native using InvokeVirtual
compiler/calls/fromNative/NativeInvokeSpecial2CompiledTest.java: check calls from native to compiled using InvokeSpecial
compiler/calls/fromNative/NativeInvokeSpecial2InterpretedTest.java: check calls from native to interpreted using InvokeSpecial
compiler/calls/fromNative/NativeInvokeSpecial2NativeTest.java: check calls from native to native using InvokeSpecial
compiler/calls/fromNative/NativeInvokeStatic2CompiledTest.java: check calls from native to compiled using InvokeStatic
compiler/calls/fromNative/NativeInvokeStatic2InterpretedTest.java: check calls from native to interpreted using InvokeStatic
compiler/calls/fromNative/NativeInvokeStatic2NativeTest.java: check calls from native to native using InvokeStatic
compiler/calls/fromNative/NativeInvokeVirtual2CompiledTest.java: check calls from native to compiled using InvokeVirtual
compiler/calls/fromNative/NativeInvokeVirtual2InterpretedTest.java: check calls from native to interpreted using InvokeVirtual
compiler/calls/fromNative/NativeInvokeVirtual2NativeTest.java: check calls from native to native using InvokeVirtual
compiler/ccp/TestAndConZeroCCP.java: Test that And nodes are monotonic and added to the CCP worklist if they have a constant as input.
compiler/ccp/TestCastIIWrongTypeCCP.java: Test that CastII nodes are added to the CCP worklist if they could have been optimized due to a CmpI/If pattern.
compiler/ccp/TestInfiniteIGVNAfterCCP.java: assert(false) failed: infinite loop in PhaseIterGVN::optimize
compiler/ccp/TestMissingMulLOptimization.java: Tests that MulL::Value() does not return bottom type and then an optimized type again in CCP.
compiler/ccp/TestPushCmpU3Node.java: Test that CmpU3Nodes are pushed back to the CCP worklist such that the type can be re-evaluated.
compiler/ccp/TestRemoveUnreachableCCP.java: CCP must remove nodes that are not traversed, else their type can be inconsistent
compiler/ccp/TestShiftCastAndNotification.java: CCP missed optimization opportunity.
compiler/ccp/TestShiftConvertAndNotification.java#id0: Test CCP notification for value update of AndL through LShiftI and ConvI2L.
compiler/ccp/TestShiftConvertAndNotification.java#id1: Test CCP notification for value update of AndL through LShiftI and ConvI2L (no flags).
compiler/ccp/TestWrongMinLWiden.java: Test that _widen is set correctly in MinL::add_ring() to prevent an endless widening in CCP.
compiler/cha/AbstractRootMethod.java:
compiler/cha/DefaultRootMethod.java:
compiler/cha/StrengthReduceInterfaceCall.java:
compiler/cha/TypeProfileFinalMethod.java: test c1 to record type profile with CHA optimization
compiler/ciTypeFlow/TestSharedLoopHead.java: C2: assert(nb == 1) failed: only when the head is not shared
compiler/classUnloading/methodUnloading/TestMethodUnloading.java: Tests the unloading of methods to to class unloading
compiler/codecache/CheckLargePages.java: Code cache reservation should gracefully downgrade to using smaller pages if the code cache size is too small to host the requested page size.
compiler/codecache/CheckReservedInitialCodeCacheSizeArgOrder.java: Test checks that the order in which ReversedCodeCacheSize and InitialCodeCacheSize are passed to the VM is irrelevant.
compiler/codecache/CheckSegmentedCodeCache.java: Checks VM options related to the segmented code cache
compiler/codecache/CheckUpperLimit.java: Test ensures that the ReservedCodeCacheSize is at most MAXINT
compiler/codecache/MHIntrinsicAllocFailureTest.java: test allocation failure of method handle intrinsic in profiled/non-profiled space
compiler/codecache/OverflowCodeCacheTest.java: testing of code cache segments overflow
compiler/codecache/cli/TestSegmentedCodeCacheOption.java: Verify SegmentedCodeCache option's processing
compiler/codecache/cli/codeheapsize/TestCodeHeapSizeOptions.java: Verify processing of options related to code heaps sizing.
compiler/codecache/cli/printcodecache/TestPrintCodeCacheOption.java: Verify that PrintCodeCache option print correct information.
compiler/codecache/jmx/BeanTypeTest.java: verify types of code cache memory pool bean
compiler/codecache/jmx/CodeHeapBeanPresenceTest.java: verify CodeHeap bean presence
compiler/codecache/jmx/GetUsageTest.java: testing of getUsage() for segmented code cache
compiler/codecache/jmx/InitialAndMaxUsageTest.java: testing of initial and max usage
compiler/codecache/jmx/ManagerNamesTest.java: verify getMemoryManageNames calls in case of segmented code cache
compiler/codecache/jmx/MemoryPoolsPresenceTest.java: verify that MemoryManagerMXBean exists for every code cache segment
compiler/codecache/jmx/PeakUsageTest.java: testing of getPeakUsage() and resetPeakUsage for segmented code cache
compiler/codecache/jmx/PoolsIndependenceTest.java: testing of getUsageThreshold()
compiler/codecache/jmx/ThresholdNotificationsTest.java: testing of getUsageThreshold()
compiler/codecache/jmx/UsageThresholdExceededSeveralTimesTest.java: verifying that getUsageThresholdCount() returns correct value after threshold has been hit several times
compiler/codecache/jmx/UsageThresholdExceededTest.java: verifying that getUsageThresholdCount() returns correct value after threshold has been hit
compiler/codecache/jmx/UsageThresholdIncreasedTest.java: verifying that threshold hasn't been hit after allocation smaller than threshold value and that threshold value can be changed
compiler/codecache/jmx/UsageThresholdNotExceededTest.java: verifying that usage threshold not exceeded while allocating less than usage threshold
compiler/codegen/BMI1.java: Support BMI1 instructions on x86/x64
compiler/codegen/BMI2.java: Support BMI2 instructions on x86/x64
compiler/codegen/BadLogicCode.java: Solaris JIT generates bad code for logic expression
compiler/codegen/BitTests.java: Use AArch64 bit-test instructions in C2
compiler/codegen/C1NullCheckOfNullStore.java: Null check is placed in a wrong place when storing a null to an object field on x64 with compressed oops off
compiler/codegen/CRCTest.java: Use x86 Hardware CRC32 Instruction with java.util.zip.CRC32 and java.util.zip.Adler32
compiler/codegen/ClearArrayTest.java: Test for correct code generation by the JIT
compiler/codegen/IntRotateWithImmediate.java: Test that the rotate distance used in the rotate instruction is properly masked with 0x1f
compiler/codegen/LoadWithMask.java: Invalid node sizing for loadUS2L_immI16 and loadI2L_immI
compiler/codegen/LoadWithMask2.java: loadI2L_immI broken for negative memory values
compiler/codegen/ShiftByZero.java: Test shift by 0
compiler/codegen/ShiftTest.java: Test for correct code generation by the JIT
compiler/codegen/Test6378821.java: where available, bitCount() should use POPC on SPARC processors and AMD+10h
compiler/codegen/Test6431242.java:
compiler/codegen/Test6797305.java: Add LoadUB and LoadUI opcode class
compiler/codegen/Test6814842.java: Load shortening optimizations
compiler/codegen/Test6823354.java: These methods can be instrinsified by using bit scan, bit test, and population count instructions.
compiler/codegen/Test6875866.java: Intrinsic for String.indexOf() is broken on x86 with SSE4.2
compiler/codegen/Test6879902.java: CTW failure jdk6_18/hotspot/src/cpu/sparc/vm/assembler_sparc.hpp:845
compiler/codegen/Test6909839.java: missing unsigned compare cases for some cmoves in sparc.ad
compiler/codegen/Test6935535.java#id0: String.indexOf() returns incorrect result on x86 with SSE4.2
compiler/codegen/Test6942326.java: x86 code in string_indexof() could read beyond reserved heap space
compiler/codegen/Test7009231.java: C1: Incorrect CAS code for longs on SPARC 32bit
compiler/codegen/Test7100757.java: The BitSet.nextSetBit() produces incorrect result in 32bit VM on Sparc
compiler/codegen/Test8005033.java: On sparcv9, C2's intrinsic for Integer.bitCount(OV) returns wrong result if OV is the result of an operation with int overflow.
compiler/codegen/Test8011901.java: instruct xaddL_no_res shouldn't allow 64 bit constants.
compiler/codegen/TestAntiDependenciesHighMemUsage.java: C2: high memory usage in PhaseCFG::raise_above_anti_dependences()
compiler/codegen/TestAntiDependenciesHighMemUsage2.java: C2: high memory usage in PhaseCFG::raise_above_anti_dependences()
compiler/codegen/TestBooleanVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteFloatVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteIntVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteLongVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteShortVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestByteVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestCharShortVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestCharVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestCharVect2.java#id0: incorrect results of char vectors right shift operation
compiler/codegen/TestCharVect2.java#id1: incorrect results of char vectors right shift operation
compiler/codegen/TestConvertImplicitNullCheck.java: Exercise float to double conversion with implicit null check
compiler/codegen/TestDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestFloatDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestFloatVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestGCMLoadPlacement.java: Test that loads are not scheduled too late.
compiler/codegen/TestGCMStorePlacement.java: Tests GCM's store placement in different scenarios (regular and OSR compilations, reducible and irreducible CFGs).
compiler/codegen/TestIntDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestIntFloatVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestIntLongVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestIntVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestLongDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestLongFloatVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestLongVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestMultiMemInstructionMatching.java: Test matching of instructions that have multiple memory inputs.
compiler/codegen/TestOopCmp.java: On ppc64, C1 erroneously emits a 32-bit compare instruction for oop compares.
compiler/codegen/TestShortDoubleVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestShortFloatVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestShortIntVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestShortLongVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestShortVect.java: Increase superword's vector size up to 256 bits
compiler/codegen/TestSignedMultiplyLong.java: Test some cases of combined signed multiply long operation
compiler/codegen/TestTrichotomyExpressions.java: Test that C2 correctly optimizes trichotomy expressions.
compiler/controldependency/TestAddPChainMismatchedBase.java: C2: cast nodes from PhiNode::Ideal() cause "Base pointers must match" assert failure
compiler/controldependency/TestAddPChainMismatchedBase2.java: C2: cast nodes from PhiNode::Ideal() cause "Base pointers must match" assert failure
compiler/controldependency/TestAntiDependencyAfterStringInflation.java: Test correct insertion of anti-dependencies after String inflation.
compiler/controldependency/TestAntiDependencyForPinnedLoads.java: Test that MergeMem is skipped when looking for stores
compiler/controldependency/TestAntiDependentMembar.java: Test correct insertion of anti-dependencies if load is already control dependent on membar.
compiler/controldependency/TestDivDependentOnMainLoopGuard.java: C2: Div looses dependency on condition that guarantees divisor not null in counted loop
compiler/controldependency/TestLoadBypassesClassCast.java: C2: Load can bypass subtype check that enforces it's from the right object type
compiler/controldependency/TestMainLoopNoBackedgeFloatingDiv.java: C2: Div looses dependency on condition that guarantees divisor not null in counted loop
compiler/controldependency/TestPeeledLoopNoBackedgeFloatingDiv.java: C2: Div looses dependency on condition that guarantees divisor not zero in counted loop after peeling
compiler/conversions/TestChainOfIntAddsToLongConversion.java: Tests that the optimization of a chain of integer additions followed by a long conversion does not lead to an explosion of live nodes.
compiler/conversions/TestMoveConvI2LOrCastIIThruAddIs.java: Exercises the optimization that moves integer-to-long conversions upwards through different shapes of integer addition subgraphs.
compiler/conversions/TestPrimitiveConversions.java: Test implicit narrowing conversion of primivite values at putfield.
compiler/cpuflags/RestoreMXCSR.java: Crash when using -XX:+RestoreMXCSROnJNICalls
compiler/cpuflags/TestSSE4Disabled.java: Test correct execution without SSE 4.
compiler/dependencies/MonomorphicObjectCall/TestMonomorphicObjectCall.java: Compiles a monomorphic call to finalizeObject() on a modified java.lang.Object to test C1 CHA.
compiler/eliminateAutobox/TestByteBoxing.java:
compiler/eliminateAutobox/TestDoubleBoxing.java: enable parts of EliminateAutoBox by default
compiler/eliminateAutobox/TestFloatBoxing.java: enable parts of EliminateAutoBox by default
compiler/eliminateAutobox/TestIdentityWithEliminateBoxInDebugInfo.java: Verify that box object identity matches after deoptimization when it is eliminated.
compiler/eliminateAutobox/TestIntBoxing.java: enable parts of EliminateAutoBox by default
compiler/eliminateAutobox/TestLongBoxing.java: enable parts of EliminateAutoBox by default
compiler/eliminateAutobox/TestSafepointDebugInfo.java: Verify consistency of safepoint debug info when boxes are scalar replaced during incremental inlining.
compiler/eliminateAutobox/TestShortBoxing.java: enable parts of EliminateAutoBox by default
compiler/eliminateAutobox/TestSplitThroughPhi.java: Test splitting a boxed field load through a loop Phi.
compiler/eliminateAutobox/UnsignedLoads.java:
compiler/escapeAnalysis/Test6689060.java: Escape Analysis does not work with Compressed Oops
compiler/escapeAnalysis/Test6726999.java: nsk/stress/jck12a/jck12a010 assert(n != NULL,"Bad immediate dominator info.");
compiler/escapeAnalysis/Test6775880.java: EA +DeoptimizeALot: assert(mon_info->owner()->is_locked(),"object must be locked now")
compiler/escapeAnalysis/Test6895383.java: JCK test throws NPE for method compiled with Escape Analysis
compiler/escapeAnalysis/Test6896727.java: nsk/logging/LoggingPermission/LoggingPermission/logperm002 fails with G1, EscapeAnalisys w/o COOPs
compiler/escapeAnalysis/Test8020215.java: Different execution plan when using JIT vs interpreter
compiler/escapeAnalysis/Test8329757.java: Deoptimization with nested eliminated and not eliminated locks caused reordered lock stacks.
compiler/escapeAnalysis/Test8331033.java: EA fails with "EA unexpected CallLeaf unsafe_setmemory" after JDK-8329331
compiler/escapeAnalysis/TestAllocatedEscapesPtrComparison.java: bcEscapeAnalyzer allocated_escapes not conservative enough
compiler/escapeAnalysis/TestArrayCopy.java: The elimination of System.arraycopy by EscapeAnalysis prevents an IndexOutOfBoundsException from being thrown if the arraycopy is called with a negative length argument.
compiler/escapeAnalysis/TestArrayCopySameSrcDstInitializesNonEscapingArray.java: Unexpected null in C2 compiled code
compiler/escapeAnalysis/TestBrokenEA.java: EA does not propagate NSR (not scalar replaceable) state.
compiler/escapeAnalysis/TestCanReduceCheckUsersDifferentIfs.java: Test that can_reduce_check_users() can handle different If nodes and that we bail out properly if it's not an actual IfNode.
compiler/escapeAnalysis/TestCopyOfBrokenAntiDependency.java: CTW: C2 compilation fails with "assert(store != load->find_exact_control(load->in(0))) failed: dependence cycle found"
compiler/escapeAnalysis/TestEABadMergeMem.java: Bad rewiring of memory edges when we split unique types during EA
compiler/escapeAnalysis/TestEAVectorizedHashCode.java: Crash encountered while converting the types of non-escaped object to instance types.
compiler/escapeAnalysis/TestEliminateAllocation.java: The enhancement eliminates all allocations in the loop body of test() due to an improved field zeroing elimination dominance check.
compiler/escapeAnalysis/TestEliminateLocksOffCrash.java: C2 compilation fails with "graph should be schedulable" when running with -XX:-EliminateLocks
compiler/escapeAnalysis/TestEscapeThroughInvoke.java: Tests C2 EA with allocated object escaping through a call.
compiler/escapeAnalysis/TestFindInstMemRecursion.java: Ensure that ConnectionGraph::find_inst_mem does not cause a stack overflow.
compiler/escapeAnalysis/TestGetClass.java: BCEscapeAnalyzer assigns wrong escape state to getClass return value.
compiler/escapeAnalysis/TestIdealAllocShape.java: full loop unroll before EA creates phis between allocs projs and init
compiler/escapeAnalysis/TestInvalidLocation.java: C2 Segfaults during code generation because of unhandled SafePointScalarMerge monitor debug info.
compiler/escapeAnalysis/TestMissingAntiDependency.java: 8240795 may cause anti-dependency to be missed
compiler/escapeAnalysis/TestNestedRelockAtDeopt.java: During deoptimization locking and unlocking for nested locks are executed in incorrect order.
compiler/escapeAnalysis/TestReduceAllocationAndJVMStates.java: Check that Reduce Allocation Merges doesn't crash when there is an uncommon_trap with a chain of JVMS and, the reduced phi input(s) are local(s) in an old JVMS but not in a younger JVMS.
compiler/escapeAnalysis/TestReduceAllocationAndNestedScalarized.java: Check that Reduce Allocation Merges doesn't crash when an input of the Phi is not the _current_ output of the Phi but said input needs to be rematerialized because it's used regardless of the Phi output.
compiler/escapeAnalysis/TestReduceAllocationAndNonReduciblePhi.java: Check that Reduce Allocation Merges doesn't crash when a reducible Phi becomes irreducible after the last of its SR inputs is flagged as NSR.
compiler/escapeAnalysis/TestReduceAllocationAndSetTypeTwice.java: Check that RAM does not crash when split load through phi tries to register an old node twice with IGVN.
compiler/escapeAnalysis/TestRematerializeObjects.java#nEA:
compiler/escapeAnalysis/TestRematerializeObjects.java#yEA: Test elimination of array allocation, and the rematerialization.
compiler/escapeAnalysis/TestSelfArrayCopy.java: Test correct elimination of array allocation with arraycopy to itself.
compiler/escapeAnalysis/TestUnsafePutAddressNullObjMustNotEscape.java: assert(null_obj->escape_state() == PointsToNode::NoEscape,etc)
compiler/escapeAnalysis/TestValAtSafepointOverflowsInt.java: C2 compilation fails with assert(!had_error) failed: bad dominance
compiler/escapeAnalysis/cr6716441/Tester.java: error in meet with +DoEscapeAnalysis
compiler/escapeAnalysis/cr6795161/Test.java: Escape analysis leads to data corruption
compiler/exceptions/CatchInlineExceptions.java: assert(adr_type != NULL) failed: expecting TypeKlassPtr
compiler/exceptions/OptimizeImplicitExceptions.java: Record null_check traps for calls and array_check traps in the interpreter
compiler/exceptions/SumTest.java: FP registers are not properly restored by C1 when handling exceptions
compiler/exceptions/TestC1ExceptionHandlersSameBCI.java: assert failure with 2 handlers at same bci
compiler/exceptions/TestDeoptExceptionState.java: Test exception state used for deoptimization.
compiler/exceptions/TestLateMHInlineExceptions.java: GraphKit::combine_exception_states fails with "matching stack sizes" assert
compiler/exceptions/TestRecursiveReplacedException.java: Recursive method compiled by C1 is unable to catch StackOverflowError
compiler/floatingpoint/DmodTest.java: Add intrinsic for float/double modulo for x86 AVX2 and AVX512
compiler/floatingpoint/FmodTest.java: Add intrinsic for float/double modulo for x86 AVX2 and AVX512
compiler/floatingpoint/ModNaN.java: double a%b returns NaN for some (a,b) (|a| < inf, |b|>0) (on Core i7 980X)
compiler/floatingpoint/NaNTest.java: Verify if signaling NaNs are preserved.
compiler/floatingpoint/TestFMA.java: intrinsify fused mac operations
compiler/floatingpoint/TestFMABrokenC1RegAlloc.java: C1's Math.fma() intrinsic doesn't correctly marks its inputs
compiler/floatingpoint/TestFloatJNIArgs.java#id0: Regression test for passing float args to a jni function.
compiler/floatingpoint/TestFloatJNIArgs.java#id1: Regression test for passing float args to a jni function.
compiler/floatingpoint/TestFloatSyncJNIArgs.java: Regression test for passing float args to a synchronized jni function.
compiler/floatingpoint/TestLibmIntrinsics.java: Test libm intrinsics
compiler/floatingpoint/TestPow2.java: X^2 special case for C2 yields different result than interpreter
compiler/floatingpoint/TestRound.java: calling Math.round(NaN) can break subsequent calls to Math.round()
compiler/floatingpoint/TestSubNodeFloatDoubleNegation.java: The compiler must not fold `0-(0-x)` for x: float | double
compiler/floatingpoint/TestSubnormalDouble.java: DSO created with -ffast-math breaks Java floating-point arithmetic
compiler/floatingpoint/TestSubnormalFloat.java: DSO created with -ffast-math breaks Java floating-point arithmetic
compiler/gcbarriers/EqvUncastStepOverBarrier.java: Node::eqv_uncast() shouldn't step over load barriers unconditionally
compiler/gcbarriers/G1CrashTest.java: C2 optimization breaks with G1
compiler/gcbarriers/TestAlwaysAtomicAccesses.java: Test memory accesses from compiled code with AlwaysAtomicAccesses.
compiler/gcbarriers/TestArrayCopyWithLargeObjectAlignment.java: Test that, when using a larger object alignment, ZGC arraycopy barriers are only applied to actual OOPs, and not to object alignment padding words.
compiler/gcbarriers/TestG1BarrierGeneration.java: Test that G1 barriers are generated and optimized as expected.
compiler/gcbarriers/TestMembarDependencies.java: Tests correct scheduling of memory loads around MembarVolatile emitted by GC barriers.
compiler/gcbarriers/TestShenandoahBarrierExpansion.java: Test that Shenandoah barriers are expanded correctly
compiler/gcbarriers/TestZGCBarrierElision.java#id0: Test that the ZGC barrier elision optimization does not elide necessary barriers.
compiler/gcbarriers/TestZGCBarrierElision.java#id1: Test that the ZGC barrier elision optimization elides unnecessary barriers following simple allocation and domination rules.
compiler/gcbarriers/TestZGCUnrolling.java: Test that the expanded size of ZGC barriers is taken into account in C2's loop unrolling heuristics so that over-unrolling is avoided.
compiler/gcbarriers/UnsafeIntrinsicsTest.java#Shenandoah: Validate barriers after Unsafe getReference, CAS and swap (GetAndSet)
compiler/gcbarriers/UnsafeIntrinsicsTest.java#Z: Validate barriers after Unsafe getReference, CAS and swap (GetAndSet)
compiler/igvn/TestSplitPhiThroughMergeMem.java: Splitting Phi memory nodes through MergeMem nodes in PhiNode::Ideal could sometimes result in a too large number of added nodes within a single iteration of the main loop in PhaseIterGVN::optimize.
compiler/inlining/DefaultAndConcreteMethodsCHA.java: CHA ignores default methods during analysis leading to incorrect code generation
compiler/inlining/DefaultMethodsDependencies.java: Deoptimization between array allocation and arraycopy may result in non initialized array
compiler/inlining/InlineAccessors.java: Method::is_accessor should cover getters and setters for all types
compiler/inlining/InlineBimorphicVirtualCallAfterMorphismChanged.java: C2 doesn't perform bimorphic inlining on a call site that was monomorphic during tier 3 compilation.
compiler/inlining/InlineDefaultMethod.java: CHA in C1 should make correct decisions about default methods
compiler/inlining/InlineDefaultMethod1.java: Default method returns true for a while, and then returns false
compiler/inlining/LateInlineVirtualNullReceiverCheck.java:
compiler/inlining/PrintInlining.java: PrintInlining as compiler directive doesn't print virtual calls
compiler/inlining/ResolvedClassTest.java:
compiler/inlining/StringConcatInfiniteLoop.java: Multiple passes of PhaseRemoveUseless causes infinite loop to be optimized out
compiler/inlining/TestDuplicatedLateInliningOutput.java: late inlining output shouldn't produce both failure and success messages
compiler/inlining/TestLateInlineReplacedNodesExceptionPath.java: C2 compilation asserts during incremental inlining because Phi input is out of bounds
compiler/inlining/TestNullAtCallAfterLateInline.java: C2: "Bad graph detected in build_loop_late" with incremental inlining
compiler/inlining/TestReplacedNodesAfterLateInline.java: C2: "malformed control flow" created during incremental inlining
compiler/inlining/TestReplacedNodesAfterLateInlineManyPaths.java: C2: "malformed control flow" created during incremental inlining
compiler/integerArithmetic/MultiplyByConstantLongMax.java: test/hotspot/jtreg/compiler/intrinsics/mathexact/MulExactLConstantTest.java fails on Windows x64 when run with -XX:-TieredCompilation
compiler/integerArithmetic/MultiplyByIntegerMinHang.java: C2 may hang in MulLNode::Ideal()/MulINode::Ideal() with gcc 8.2.1
compiler/integerArithmetic/TestAssociative.java: Test corner cases of integer associative rules
compiler/integerArithmetic/TestIntegerComparison.java: Tests optimizations of signed and unsigned integer comparison.
compiler/integerArithmetic/TestNegAnd.java: Test broken transformation (-a) & (-b) = a & b does not happen
compiler/integerArithmetic/TestNegMultiply.java: Test transformation (-a)*(-b) = a*b
compiler/integerArithmetic/TestOrSaturate.java: Test that an or with all bits set is folded to all bits (x | -1 == -1).
compiler/integerArithmetic/TestUnsignedModByZero.java: Test that modulo by zero throws an exception at runtime in case of unsigned values.
compiler/interpreter/DisableOSRTest.java: testing that -XX:-UseOnStackReplacement works with both -XX:(+/-)TieredCompilation
compiler/interpreter/Test6539464.java: Math.log() produces inconsistent results between successive runs.
compiler/interpreter/Test6833129.java: Object.clone() and Arrays.copyOf ignore coping with -XX:+DeoptimizeALot
compiler/interpreter/TestVerifyStackAfterDeopt.java: Checks VerifyStack after deoptimization of array allocation slow call
compiler/interpreter/TestVerifyStackWithUnreachableBytecode.java#areturn: Ensure VerifyStack does not crash on bytecodes in unreachable basic blocks after areturn.
compiler/interpreter/TestVerifyStackWithUnreachableBytecode.java#goto: Ensure VerifyStack does not crash on bytecodes in unreachable basic blocks after goto.
compiler/interpreter/TestVerifyStackWithUnreachableBytecode.java#gotow: Ensure VerifyStack does not crash on bytecodes in unreachable basic blocks after gotow.
compiler/interpreter/TestVerifyStackWithUnreachableBytecode.java#return: Ensure VerifyStack does not crash on bytecodes in unreachable basic blocks after return.
compiler/interpreter/VerifyStackWithUnreachableBlock.java: Using VerifyStack for method that contains unreachable basic blocks
compiler/interpreter/cr7116216/StackOverflow.java: The vm crashes when GC happens during throwing a StackOverflow exception
compiler/intrinsics/BitCountIAarch64PreservesArgument.java#id0: Integer.bitCount modifies input register
compiler/intrinsics/BitCountIAarch64PreservesArgument.java#id1:
compiler/intrinsics/IntrinsicAvailableTest.java:
compiler/intrinsics/IntrinsicDisabledTest.java:
compiler/intrinsics/SortingDeoptimizationTest.java: Exercise Arrays.parallelSort when -XX:+DeoptimizeALot is enabled
compiler/intrinsics/Test6982370.java: SIGBUS in jbyte_fill
compiler/intrinsics/Test8005419.java: Improve intrinsics code performance on x86 by using AVX2
compiler/intrinsics/Test8215792.java: Fix a bug in AArch64 string intrinsics
compiler/intrinsics/Test8237524.java: String.compareTo() may return incorrect result in this case
compiler/intrinsics/TestArrayGuardWithInterfaces.java: Test folding of array guards used by intrinsics.
compiler/intrinsics/TestArraysHashCode.java: Verify failure to intrinsify does not pollute control flow
compiler/intrinsics/TestBitShuffleOpers.java: To test various transforms added for bit COMPRESS_BITS and EXPAND_BITS operations
compiler/intrinsics/TestCheckIndex.java: Add utility methods to check long indexes and ranges
compiler/intrinsics/TestCompareUnsigned.java: Test the intrinsics implementation of Integer/Long::compareUnsigned
compiler/intrinsics/TestContinuationPinningAndEA.java: Test that Continuation.pin() and unpin() intrinsics work with EA.
compiler/intrinsics/TestIntegerUnsignedDivMod.java: Test intrinsic for divideUnsigned() and remainderUnsigned() methods for Integer
compiler/intrinsics/TestLongUnsignedDivMod.java: Test intrinsic for divideUnsigned() and remainderUnsigned() methods for Long
compiler/intrinsics/TestReferenceGetWithNull.java: Test that the Reference::get intrinsic works with a null argument.
compiler/intrinsics/TestReferenceRefersTo.java: Based on test/jdk/java/lang/ref/ReferenceRefersTo.java.
compiler/intrinsics/TestRotate.java: Support for scalar rotates ([Integer/Long].rotate[Left/Right]).
compiler/intrinsics/VectorizedMismatchTest.java:
compiler/intrinsics/base64/TestBase64.java: tests java.util.Base64
compiler/intrinsics/bigInteger/MontgomeryMultiplyTest.java: Verify that the Montgomery multiply and square intrinsic works and correctly checks their arguments.
compiler/intrinsics/bigInteger/TestMulAdd.java: Add C2 x86 intrinsic for BigInteger::mulAdd() method
compiler/intrinsics/bigInteger/TestMultiplyToLen.java: Add C2 x86 intrinsic for BigInteger::multiplyToLen() method
compiler/intrinsics/bigInteger/TestMultiplyToLenReturnProfile.java: MultiplyToLen sets its return type to have a bottom offset which confuses code generation
compiler/intrinsics/bigInteger/TestShift.java: Add C2 x86 intrinsic for BigInteger::shiftLeft() and BigInteger::shiftRight() method
compiler/intrinsics/bigInteger/TestSquareToLen.java: Add C2 x86 intrinsic for BigInteger::squareToLen() method
compiler/intrinsics/bmi/TestAndnI.java: Verify that results of computations are the same w/ and w/o usage of ANDN instruction
compiler/intrinsics/bmi/TestAndnL.java: Verify that results of computations are the same w/ and w/o usage of ANDN instruction
compiler/intrinsics/bmi/TestBlsiI.java: Verify that results of computations are the same w/ and w/o usage of BLSI instruction
compiler/intrinsics/bmi/TestBlsiL.java: Verify that results of computations are the same w/ and w/o usage of BLSI instruction
compiler/intrinsics/bmi/TestBlsmskI.java: Verify that results of computations are the same w/ and w/o usage of BLSMSK instruction
compiler/intrinsics/bmi/TestBlsmskL.java: Verify that results of computations are the same w/ and w/o usage of BLSMSK instruction
compiler/intrinsics/bmi/TestBlsrI.java: Verify that results of computations are the same w/ and w/o usage of BLSR instruction
compiler/intrinsics/bmi/TestBlsrL.java: Verify that results of computations are the same w/ and w/o usage of BLSR instruction
compiler/intrinsics/bmi/TestBzhiI2L.java: Verify that results of computations are the same w/ and w/o usage of BZHI instruction
compiler/intrinsics/bmi/TestLzcntI.java: Verify that results of computations are the same w/ and w/o usage of intrinsic
compiler/intrinsics/bmi/TestLzcntL.java: Verify that results of computations are the same w/ and w/o usage of intrinsic
compiler/intrinsics/bmi/TestTzcntI.java: Verify that results of computations are the same w/ and w/o usage of intrinsic
compiler/intrinsics/bmi/TestTzcntL.java: Verify that results of computations are the same w/ and w/o usage of intrinsic
compiler/intrinsics/bmi/verifycode/AndnTestI.java:
compiler/intrinsics/bmi/verifycode/AndnTestL.java:
compiler/intrinsics/bmi/verifycode/BlsiTestI.java:
compiler/intrinsics/bmi/verifycode/BlsiTestL.java:
compiler/intrinsics/bmi/verifycode/BlsmskTestI.java:
compiler/intrinsics/bmi/verifycode/BlsmskTestL.java:
compiler/intrinsics/bmi/verifycode/BlsrTestI.java:
compiler/intrinsics/bmi/verifycode/BlsrTestL.java:
compiler/intrinsics/bmi/verifycode/BzhiTestI2L.java:
compiler/intrinsics/bmi/verifycode/LZcntTestI.java:
compiler/intrinsics/bmi/verifycode/LZcntTestL.java:
compiler/intrinsics/bmi/verifycode/TZcntTestI.java:
compiler/intrinsics/bmi/verifycode/TZcntTestL.java:
compiler/intrinsics/chacha/TestChaCha20.java: ChaCha20 Intrinsics
compiler/intrinsics/float16/Binary16Conversion.java: Verify conversion between float and the binary16 format
compiler/intrinsics/float16/Binary16ConversionNaN.java: Verify NaN sign and significand bits are preserved across conversions
compiler/intrinsics/float16/TestAllFloat16ToFloat.java: Verify conversion between float and the binary16 format
compiler/intrinsics/float16/TestConstFloat16ToFloat.java: Verify conversion cons between float and the binary16 format
compiler/intrinsics/float16/TestFloat16MaxMinSpecialValues.java: Add special case handling for Float16.max/min x86 backend
compiler/intrinsics/klass/CastNullCheckDroppingsTest.java: Casting can result in redundant null checks in generated code
compiler/intrinsics/klass/TestGetModifiers.java#id0:
compiler/intrinsics/klass/TestGetModifiers.java#id1:
compiler/intrinsics/klass/TestGetModifiers.java#id2:
compiler/intrinsics/klass/TestIsPrimitive.java: C1 intrinsic for Class.isPrimitive
compiler/intrinsics/math/MaxMinOptimizeTest.java: Test the result of 8263006's optimization
compiler/intrinsics/math/Test8210461.java: Math cos instrinsic returns incorrect result for large value
compiler/intrinsics/math/TestFpMinMaxIntrinsics.java: Test compiler intrinsics of floating-point Math.min/max
compiler/intrinsics/math/TestFpMinMaxReductions.java: Test that floating-point min/max x64 operations are implemented differently depending on whether they are part of a reduction.
compiler/intrinsics/math/TestMinMaxInlining.java: Test min and max IR inlining decisions
compiler/intrinsics/math/TestMinMaxIntrinsics.java: Test integer min and max intrinsics
compiler/intrinsics/math/TestMinMaxOpt.java: Test min and max optimizations
compiler/intrinsics/math/TestPow0Dot5Opt.java: test the optimization of pow(x, 0.5)
compiler/intrinsics/math/TestPow2Opt.java: test the optimization of pow(x, 2.0)
compiler/intrinsics/math/TestSignumIntrinsic.java: Test compiler intrinsics for signum
compiler/intrinsics/mathexact/AddExactICondTest.java: Test non constant addExact
compiler/intrinsics/mathexact/AddExactIConstantTest.java: Test constant addExact
compiler/intrinsics/mathexact/AddExactILoadTest.java: Test non constant addExact
compiler/intrinsics/mathexact/AddExactILoopDependentTest.java: Test non constant addExact
compiler/intrinsics/mathexact/AddExactINonConstantTest.java: Test non constant addExact
compiler/intrinsics/mathexact/AddExactIRepeatTest.java: Test repeating addExact
compiler/intrinsics/mathexact/AddExactLConstantTest.java: Test constant addExact
compiler/intrinsics/mathexact/AddExactLNonConstantTest.java: Test non constant addExact
compiler/intrinsics/mathexact/CompareTest.java: Verify that the compare after addExact is a signed compare
compiler/intrinsics/mathexact/DecExactITest.java: Test decrementExact
compiler/intrinsics/mathexact/DecExactLTest.java: Test decrementExact
compiler/intrinsics/mathexact/GVNTest.java: Verify that GVN doesn't mess up the two addExacts
compiler/intrinsics/mathexact/IncExactITest.java: Test incrementExact
compiler/intrinsics/mathexact/IncExactLTest.java: Test incrementExact
compiler/intrinsics/mathexact/LongMulOverflowTest.java: Regression test for multiplyExact intrinsic
compiler/intrinsics/mathexact/MulExactICondTest.java: Test multiplyExact as condition
compiler/intrinsics/mathexact/MulExactIConstantTest.java: Test constant multiplyExact
compiler/intrinsics/mathexact/MulExactILoadTest.java: Test multiplyExact
compiler/intrinsics/mathexact/MulExactILoopDependentTest.java: Test loop dependent multiplyExact
compiler/intrinsics/mathexact/MulExactINonConstantTest.java: Test non constant multiplyExact
compiler/intrinsics/mathexact/MulExactIRepeatTest.java: Test repeating multiplyExact
compiler/intrinsics/mathexact/MulExactLConstantTest.java: Test constant mulExact
compiler/intrinsics/mathexact/MulExactLNonConstantTest.java: Test non constant mulExact
compiler/intrinsics/mathexact/NegExactIConstantTest.java: Test constant negExact
compiler/intrinsics/mathexact/NegExactILoadTest.java: Test negExact
compiler/intrinsics/mathexact/NegExactILoopDependentTest.java: Test negExact loop dependent
compiler/intrinsics/mathexact/NegExactINonConstantTest.java: Test non constant negExact
compiler/intrinsics/mathexact/NegExactLConstantTest.java: Test constant negExact
compiler/intrinsics/mathexact/NegExactLNonConstantTest.java: Test constant negExact
compiler/intrinsics/mathexact/NestedMathExactTest.java: Test nested loops
compiler/intrinsics/mathexact/OverflowTest.java#id0: Math.*Exact intrinsics, especially in case of overflow The base case
compiler/intrinsics/mathexact/OverflowTest.java#id1: Math.*Exact intrinsics, especially in case of overflow With ProfileTraps enabled to allow builtin_throw to work
compiler/intrinsics/mathexact/OverflowTest.java#id2: Math.*Exact intrinsics, especially in case of overflow ProfileTraps off => throw will never be hot for builtin_throw
compiler/intrinsics/mathexact/OverflowTest.java#id3: Math.*Exact intrinsics, especially in case of overflow OmitStackTraceInFastThrow off => can_omit_stack_trace is false => no builtin_throw
compiler/intrinsics/mathexact/OverflowTest.java#id4: Math.*Exact intrinsics, especially in case of overflow StackTraceInThrowable off => can_omit_stack_trace is true => yes builtin_throw
compiler/intrinsics/mathexact/OverflowTest.java#id5: Math.*Exact intrinsics, especially in case of overflow StackTraceInThrowable off && OmitStackTraceInFastThrow off => can_omit_stack_trace is true => yes builtin_throw
compiler/intrinsics/mathexact/OverflowTest.java#id6: Math.*Exact intrinsics, especially in case of overflow Without intrinsics
compiler/intrinsics/mathexact/SplitThruPhiTest.java: Verify that split through phi does the right thing
compiler/intrinsics/mathexact/SubExactICondTest.java: Test subtractExact as condition
compiler/intrinsics/mathexact/SubExactIConstantTest.java: Test constant subtractExact
compiler/intrinsics/mathexact/SubExactILoadTest.java: Test non constant subtractExact
compiler/intrinsics/mathexact/SubExactILoopDependentTest.java: Test non constant subtractExact
compiler/intrinsics/mathexact/SubExactINonConstantTest.java: Test non constant subtractExact
compiler/intrinsics/mathexact/SubExactIRepeatTest.java: Test repeating subtractExact
compiler/intrinsics/mathexact/SubExactLConstantTest.java: Test constant subtractExact
compiler/intrinsics/mathexact/SubExactLNonConstantTest.java: Test non constant subtractExact
compiler/intrinsics/mathexact/sanity/AddExactIntTest.java:
compiler/intrinsics/mathexact/sanity/AddExactLongTest.java:
compiler/intrinsics/mathexact/sanity/DecrementExactIntTest.java:
compiler/intrinsics/mathexact/sanity/DecrementExactLongTest.java:
compiler/intrinsics/mathexact/sanity/IncrementExactIntTest.java:
compiler/intrinsics/mathexact/sanity/IncrementExactLongTest.java:
compiler/intrinsics/mathexact/sanity/MultiplyExactIntTest.java:
compiler/intrinsics/mathexact/sanity/MultiplyExactLongTest.java:
compiler/intrinsics/mathexact/sanity/NegateExactIntTest.java:
compiler/intrinsics/mathexact/sanity/NegateExactLongTest.java:
compiler/intrinsics/mathexact/sanity/SubtractExactIntTest.java:
compiler/intrinsics/mathexact/sanity/SubtractExactLongTest.java:
compiler/intrinsics/object/TestClone.java: assert(ex_map->jvms()->same_calls_as(_exceptions->jvms())) failed: all collected exceptions must come from the same place
compiler/intrinsics/object/TestHashCode.java: SEGV in compiled code with loop predication
compiler/intrinsics/sha/TestDigest.java: C2 support for MD5/SHA-1/SHA-224/SHA-256/SHA-384/SHA-512/SHA3
compiler/intrinsics/sha/cli/TestUseMD5IntrinsicsOptionOnSupportedCPU.java: Verify UseMD5Intrinsics option processing on supported CPU.
compiler/intrinsics/sha/cli/TestUseMD5IntrinsicsOptionOnUnsupportedCPU.java: Verify UseMD5Intrinsics option processing on unsupported CPU.
compiler/intrinsics/sha/cli/TestUseSHA1IntrinsicsOptionOnSupportedCPU.java: Verify UseSHA1Intrinsics option processing on supported CPU.
compiler/intrinsics/sha/cli/TestUseSHA1IntrinsicsOptionOnUnsupportedCPU.java: Verify UseSHA1Intrinsics option processing on unsupported CPU.
compiler/intrinsics/sha/cli/TestUseSHA256IntrinsicsOptionOnSupportedCPU.java: Verify UseSHA256Intrinsics option processing on supported CPU.
compiler/intrinsics/sha/cli/TestUseSHA256IntrinsicsOptionOnUnsupportedCPU.java: Verify UseSHA256Intrinsics option processing on unsupported CPU.
compiler/intrinsics/sha/cli/TestUseSHA3IntrinsicsOptionOnUnsupportedCPU.java: Verify UseSHA3Intrinsics option processing on unsupported CPU.
compiler/intrinsics/sha/cli/TestUseSHA512IntrinsicsOptionOnSupportedCPU.java: Verify UseSHA512Intrinsics option processing on supported CPU.
compiler/intrinsics/sha/cli/TestUseSHA512IntrinsicsOptionOnUnsupportedCPU.java: Verify UseSHA512Intrinsics option processing on unsupported CPU.
compiler/intrinsics/sha/cli/TestUseSHAOptionOnSupportedCPU.java: Verify UseSHA option processing on supported CPU.
compiler/intrinsics/sha/cli/TestUseSHAOptionOnUnsupportedCPU.java: Verify UseSHA option processing on unsupported CPU.
compiler/intrinsics/sha/sanity/TestMD5Intrinsics.java: Verify that MD5 intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestMD5MultiBlockIntrinsics.java: Verify that MD5 multi block intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA1Intrinsics.java: Verify that SHA-1 intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA1MultiBlockIntrinsics.java: Verify that SHA-1 multi block intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA256Intrinsics.java: Verify that SHA-256 intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA256MultiBlockIntrinsics.java: Verify that SHA-256 multi block intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA3Intrinsics.java#id0: Verify that SHA3-224, SHA3-256, SHA3-384, SHA3-512 intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA3MultiBlockIntrinsics.java#id0: Verify that SHA3-224, SHA3-256, SHA3-384, SHA3-512 multi block intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA512Intrinsics.java: Verify that SHA-512 intrinsic is actually used.
compiler/intrinsics/sha/sanity/TestSHA512MultiBlockIntrinsics.java: Verify that SHA-512 multi block intrinsic is actually used.
compiler/intrinsics/string/TestCopyValueOf.java: Verify that String.copyValueOf properly handles null input with intrinsified helper methods.
compiler/intrinsics/string/TestCountPositives.java#id0: Validates StringCoding.countPositives intrinsic with a small range of tests.
compiler/intrinsics/string/TestEncodeIntrinsics.java: Verify potentially intrinsified encoders behave well before and after compilation
compiler/intrinsics/string/TestHasNegatives.java#id0: Validates StringCoding.hasNegatives intrinsic with a small range of tests.
compiler/intrinsics/string/TestStringConstruction.java: Tests handling of invalid array indices in C2 intrinsic if explicit range check in Java code is not inlined.
compiler/intrinsics/string/TestStringConstructionIntrinsics.java#id0: Validates String constructor intrinsics using varied input data.
compiler/intrinsics/string/TestStringEqualsBadLength.java: String.equals() may be called with a length whose upper bits are not cleared
compiler/intrinsics/string/TestStringIndexOfCharIntrinsics.java: Check for correct return value when calling indexOfChar intrinsics with negative value.
compiler/intrinsics/string/TestStringIntrinsicMemoryFlow.java: Check for correct memory flow with the String compress/inflate intrinsics.
compiler/intrinsics/string/TestStringIntrinsicRangeChecks.java: Verifies that string intrinsics throw array out of bounds exceptions.
compiler/intrinsics/string/TestStringIntrinsics.java: Tests correctness of string related intrinsics and C2 optimizations.
compiler/intrinsics/string/TestStringIntrinsics2.java: PPC64: fix string intrinsics after CompactStrings change
compiler/intrinsics/string/TestStringLatin1IndexOfChar.java: Test intrinsification of StringLatin1.indexOf(char).
compiler/intrinsics/string/TestStringUTF16IntrinsicRangeChecks.java: Verifies that callers of StringUTF16 intrinsics throw array out of bounds exceptions.
compiler/intrinsics/unsafe/AllocateUninitializedArray.java: Unsafe methods to produce uninitialized arrays
compiler/intrinsics/unsafe/DirectByteBufferTest.java: Verify that direct byte buffers are correctly accessed.
compiler/intrinsics/unsafe/HeapByteBufferTest.java#id0: Verify that byte buffers are correctly accessed.
compiler/intrinsics/unsafe/HeapByteBufferTest.java#id1: intermittent, check that spilling MoveF2I etc produce memory edge
compiler/intrinsics/unsafe/TestCAEAntiDep.java: Unsafe.compareAndExchangeReference should keep track of returned type after matching
compiler/intrinsics/unsafe/TestUnsafeMismatchedArrayFieldAccess.java: Unsafe access to an array is wrongly marked as mismatched
compiler/intrinsics/unsafe/TestUnsafeUnalignedMismatchedAccesses.java: Mismatched stores on same slice possible with Unsafe.Put*Unaligned methods
compiler/intrinsics/unsafe/UnsafeGetAddressTest.java: C2 intrinsic for Unsafe.getAddress performs pointer sign extension on 32-bit systems
compiler/intrinsics/unsafe/UnsafeTwoCASLong.java: C1 LinearScan asserts when compiling two back-to-back CompareAndSwapLongs
compiler/intrinsics/zip/TestAdler32.java: C2 support for Adler32 on SPARC
compiler/intrinsics/zip/TestCRC32.java: CRC32 Intrinsics support on SPARC
compiler/intrinsics/zip/TestCRC32C.java: C2 support for CRC32C on SPARC
compiler/intrinsics/zip/TestFpRegsABI.java: ABI for the Arm 64-bit Architecture requires to preserve registers v8-v15 by a callee across subroutine calls
compiler/jsr292/CallSiteDepContextTest.java:
compiler/jsr292/ConcurrentClassLoadingTest.java: JSR292: deadlock during class loading of MethodHandles, MethodHandleImpl & MethodHandleNatives
compiler/jsr292/ContinuousCallSiteTargetChange.java:
compiler/jsr292/CreatesInterfaceDotEqualsCallInfo.java: MethodHandle lookup for an interface method causes assertion failure in linkResolver.cpp
compiler/jsr292/InvokerGC.java:
compiler/jsr292/InvokerSignatureMismatch.java:
compiler/jsr292/LongReferenceCastingTest.java: Test correct casting of MH arguments during inlining.
compiler/jsr292/MHDeoptTest.java:
compiler/jsr292/MHInlineTest.java: C2: inlining failure due to access checks being too strict
compiler/jsr292/NonInlinedCall/InvokeTest.java:
compiler/jsr292/NonInlinedCall/RedefineTest.java:
compiler/jsr292/NullConstantMHReceiver.java:
compiler/jsr292/NullConstantReceiver.java:
compiler/jsr292/PollutedTrapCounts.java:
compiler/jsr292/RedefineMethodUsedByMultipleMethodHandles.java: redefining method used by multiple MethodHandles crashes VM
compiler/jsr292/Test7082949.java: JSR 292: missing ResourceMark in methodOopDesc::make_invoke_method
compiler/jsr292/TestArrayReturnType.java:
compiler/jsr292/cr6990212/Test6990212.java: JSR 292 JVMTI MethodEnter hook is not called for JSR 292 bootstrap and target methods
compiler/jsr292/cr8026328/Test8026328.java:
compiler/jsr292/methodHandleExceptions/TestAMEnotNPE.java: Ensure that correct exceptions are thrown, not NullPointerException
compiler/jvmci/JVM_GetJVMCIRuntimeTest.java:
compiler/jvmci/TestEnableJVMCIProduct.java: Tests effect of -XX:+EnableJVMCIProduct on EnableJVMCI and UseJVMCICompiler
compiler/jvmci/TestInvalidJVMCIOption.java: Ensures invalid JVMCI options do not crash the VM with a hs-err log.
compiler/jvmci/TestJVMCIPrintProperties.java: Ensure -XX:+JVMCIPrintProperties successfully prints expected output to stdout.
compiler/jvmci/TestJVMCISavedProperties.java: Ensures Services.getSavedProperties() includes properties set on the command line as well some specified properties but not properties set programmatically.
compiler/jvmci/TestValidateModules.java: Ensure java --validate-modules works with --XX:+EnableJVMCI
compiler/jvmci/compilerToVM/AllocateCompileIdTest.java:
compiler/jvmci/compilerToVM/AsResolvedJavaMethodTest.java:
compiler/jvmci/compilerToVM/CollectCountersTest.java:
compiler/jvmci/compilerToVM/DisassembleCodeBlobTest.java:
compiler/jvmci/compilerToVM/DoNotInlineOrCompileTest.java:
compiler/jvmci/compilerToVM/FindUniqueConcreteMethodTest.java:
compiler/jvmci/compilerToVM/GetBytecodeTest.java:
compiler/jvmci/compilerToVM/GetClassInitializerTest.java:
compiler/jvmci/compilerToVM/GetExceptionTableTest.java:
compiler/jvmci/compilerToVM/GetFlagValueTest.java:
compiler/jvmci/compilerToVM/GetImplementorTest.java:
compiler/jvmci/compilerToVM/GetLineNumberTableTest.java:
compiler/jvmci/compilerToVM/GetMaxCallTargetOffsetTest.java:
compiler/jvmci/compilerToVM/GetStackTraceElementTest.java:
compiler/jvmci/compilerToVM/GetSymbolTest.java:
compiler/jvmci/compilerToVM/GetVtableIndexForInterfaceTest.java:
compiler/jvmci/compilerToVM/HasCompiledCodeForOSRTest.java:
compiler/jvmci/compilerToVM/HasFinalizableSubclassTest.java:
compiler/jvmci/compilerToVM/HasNeverInlineDirectiveTest.java:
compiler/jvmci/compilerToVM/IsCompilableTest.java#id1:
compiler/jvmci/compilerToVM/IsMatureTest.java:
compiler/jvmci/compilerToVM/IsMatureVsReprofileTest.java:
compiler/jvmci/compilerToVM/IterateFramesNative.java:
compiler/jvmci/compilerToVM/LookupConstantInPoolTest.java:
compiler/jvmci/compilerToVM/LookupKlassInPoolTest.java: Testing compiler.jvmci.CompilerToVM.lookupKlassInPool method
compiler/jvmci/compilerToVM/LookupKlassRefIndexInPoolTest.java:
compiler/jvmci/compilerToVM/LookupMethodInPoolTest.java:
compiler/jvmci/compilerToVM/LookupNameAndTypeRefIndexInPoolTest.java:
compiler/jvmci/compilerToVM/LookupNameInPoolTest.java:
compiler/jvmci/compilerToVM/LookupSignatureInPoolTest.java:
compiler/jvmci/compilerToVM/LookupTypeTest.java:
compiler/jvmci/compilerToVM/MaterializeVirtualObjectTest.java:
compiler/jvmci/compilerToVM/MethodIsIgnoredBySecurityStackWalkTest.java:
compiler/jvmci/compilerToVM/ReadConfigurationTest.java:
compiler/jvmci/compilerToVM/ReprofileTest.java:
compiler/jvmci/compilerToVM/ResolveFieldInPoolTest.java:
compiler/jvmci/compilerToVM/ResolveMethodTest.java:
compiler/jvmci/compilerToVM/ResolveTypeInPoolTest.java: Testing compiler.jvmci.CompilerToVM.resolveTypeInPool method
compiler/jvmci/compilerToVM/ShouldDebugNonSafepointsTest.java:
compiler/jvmci/compilerToVM/ShouldInlineMethodTest.java:
compiler/jvmci/errors/TestInvalidCompilationResult.java:
compiler/jvmci/errors/TestInvalidDebugInfo.java:
compiler/jvmci/errors/TestInvalidOopMap.java:
compiler/jvmci/errors/TestInvalidTieredStopAtLevel.java:
compiler/jvmci/events/JvmciNotifyBootstrapFinishedEventTest.java:
compiler/jvmci/events/JvmciShutdownEventTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/CodeInvalidationReasonTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/DataPatchTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/InstalledCodeTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/InterpreterFrameSizeTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/MaxOopMapStackOffsetTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/NativeCallTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/RuntimeStubAllocFailTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/SimpleCodeInstallationTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/SimpleDebugInfoTest.java:
compiler/jvmci/jdk.vm.ci.code.test/src/jdk/vm/ci/code/test/VirtualObjectDebugInfoTest.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/HotSpotConstantReflectionProviderTest.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/HotSpotResolvedJavaFieldTest.java: Tests HotSpotResolvedJavaField functionality
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/MemoryAccessProviderTest.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/MethodHandleAccessProviderTest.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/TestDynamicConstant.java: Test CONSTANT_Dynamic resolution by HotSpotConstantPool.
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/TestHotSpotJVMCIRuntime.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/TestHotSpotResolvedJavaField.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/TestHotSpotSpeculationLog.java:
compiler/jvmci/jdk.vm.ci.hotspot.test/src/jdk/vm/ci/hotspot/test/VirtualObjectLayoutTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/ConstantPoolTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/ConstantTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/RedefineClassTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/ResolvedJavaTypeResolveConcreteMethodTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/ResolvedJavaTypeResolveMethodTest.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestBytecodeFrame.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestConstantReflectionProvider.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestJavaField.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestJavaMethod.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestJavaType.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestMetaAccessProvider.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaField.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaMethod.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestResolvedJavaType.java:
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestSingleImplementor.java: Verify single interface implementor recording supports diamond-shaped class hierarchies
compiler/jvmci/jdk.vm.ci.runtime.test/src/jdk/vm/ci/runtime/test/TestSpeculationLog.java:
compiler/jvmci/meta/ProfilingInfoTest.java:
compiler/jvmci/meta/StableFieldTest.java:
compiler/linkage/LinkageErrors.java:
compiler/linkage/TestLinkageErrorInGenerateOopMap.java: Test OSR compilation with bad operand stack.
compiler/locks/TestCoarsenedAndNestedLocksElimination.java: C2 incorrectly marks unbalanced (after coarsened locks were eliminated) nested locks for elimination.
compiler/locks/TestCoarsenedAndNotEscapedLocksElimination.java: C2 incorrectly marks not-escaped locks for elimination after coarsened locks were eliminated and created unbalanced regions.
compiler/locks/TestLocksInOSR.java: EA incorrectly marks locks for elimination for escaped object which comes from Interpreter in OSR compilation.
compiler/locks/TestNestedLocksElimination.java: Nested locks optimization may create unbalanced monitor enter/exit code
compiler/locks/TestNestedSynchronize.java: Ensure no assert error in C2 with deeply nested synchronize statements.
compiler/locks/TestSynchronizeWithEmptyBlock.java: Test that C2 does not remove blocks with BoxLock nodes that are otherwise empty.
compiler/locks/TestUnlockOSR.java: During OSR, locks get transferred from interpreter frame.
compiler/longcountedloops/TestAssertWhenOuterStripMinedLoopRemoved.java: C2: assert(!loop->_body.contains(in)) failed
compiler/longcountedloops/TestDeadLongPhi.java: C2: assert(!had_error) failed: bad dominance
compiler/longcountedloops/TestIVPhiTypeIncorrectAfterCCP.java: Incorrect type for IV phi of long counted loops after CCP
compiler/longcountedloops/TestInaccurateInnerLoopLimit.java: C2 compilation fails with assert(!x->as_Loop()->is_loop_nest_inner_loop()) failed: loop was transformed
compiler/longcountedloops/TestLongCountedLoopSplitIf.java: cmp != __null && cmp->Opcode() == Op_CmpL failure with -XX:StressLongCountedLoop=200000000 in lucene
compiler/longcountedloops/TestSafePointWithEAState.java: C2 compilation fails with "all memory state should have been processed" assert
compiler/longcountedloops/TestTooManyLoopOpts.java: C2: assert(!n->as_Loop()->is_transformed_long_loop()) failure with -XX:StressLongCountedLoop=1
compiler/loopopts/BadPredicateAfterPartialPeel.java: Predicate moved after partial peel may lead to broken graph
compiler/loopopts/ConstFPVectorization.java: C2 code generator can replace -0.0f with +0.0f on Linux
compiler/loopopts/CountedLoopPeelingProfilePredicates.java: CountedLoopEndNode from peeled loop body is not candidate for profile loop predication
compiler/loopopts/CountedLoopProblem.java: Inner loop induction variable increment occurs before compare which causes integer overflow
compiler/loopopts/FillArrayWithUnsafe.java: Fill a byte array with Java Unsafe API
compiler/loopopts/InfiniteLoopBadControlNeverBranch.java: C2: assert(!loop->is_member(get_loop(useblock))) failed: must be outside loop
compiler/loopopts/InvariantCodeMotionReassociateAddSub.java: Test loop invariant code motion of add/sub through reassociation
compiler/loopopts/InvariantCodeMotionReassociateCmp.java: Test loop invariant code motion for cmp nodes through reassociation
compiler/loopopts/IterationSplitPredicateInconsistency.java: Bad graph when unrolled loop bounds conflicts with range checks
compiler/loopopts/LoadVectorFromStableArray.java: LoadVector from a known element of a stable array shouldn't attempt to constant fold
compiler/loopopts/LoopReductionHasControlOrBadInput.java: Optimization bails out and hits an assert: assert(false) failed: reduction has ctrl or bad vector_input
compiler/loopopts/LoopRotateBadNodeBudget.java: Node estimate for loop rotate is not correct/sufficient: assert(delta <= 2 * required) failed: Bad node estimate ...
compiler/loopopts/LoopUnrollBadNodeBudget.java: Node estimate for loop unrolling is not correct/sufficient: assert(delta <= 2 * required) failed: Bad node estimate ...
compiler/loopopts/LoopUnswitchingBadNodeBudget.java: Node estimate for loop unswitching is not correct: assert(delta <= 2 * required) failed: Bad node estimate
compiler/loopopts/PartialPeelingUnswitch.java: Tests if partially peeled statements are not executed before the loop predicates by bailing out of loop unswitching.
compiler/loopopts/PeelingAndLoopStripMining.java: Tests dominance in PhaseIdealLoop::get_early_ctrl_for_expensive() if an expensive SqrtD node is peeled.
compiler/loopopts/PeelingZeroTripCount.java: C2 crash in loopTransform.cpp with assert(cl->trip_count() > 0) failed: peeling a fully unrolled loop
compiler/loopopts/SplitIfSharedFastLockBehindCastPP.java: assert(bol->is_Bool()) crash during split if due to FastLockNode
compiler/loopopts/StoreMovedBeforeInfiniteLoop.java: assert(is_Loop()) crash in PhaseIdealLoop::try_move_store_before_loop()
compiler/loopopts/Test6659207.java: access violation in CompilerThread0
compiler/loopopts/Test6855164.java: SIGSEGV during compilation of method involving loop over CharSequence
compiler/loopopts/Test6860469.java: remix_address_expressions reshapes address expression with bad control
compiler/loopopts/Test7044738.java: Loop unroll optimization causes incorrect result
compiler/loopopts/Test7052494.java: Eclipse test fails on JDK 7 b142
compiler/loopopts/Test8210392.java: C2 Assert failure: Live node limit exceeded
compiler/loopopts/Test8211698.java: Crash in C2 compiled code during execution of double array heavy processing code
compiler/loopopts/TestAddPChainWithDifferentBase.java: C2: assert(!addp->is_AddP() || addp->in(AddPNode::Base)->is_top() || addp->in(AddPNode::Base) == n->in(AddPNode::Base)) failed: Base pointers must match (addp 1301)
compiler/loopopts/TestArrayFillAntiDependence.java: Test that loads anti-dependent on array fill intrinsics are scheduled correctly, for different load and array fill types.
compiler/loopopts/TestArrayFillIntrinsic.java: Test replacement of array-filling loops with intrinsic calls in the face of matching and mismatching stores.
compiler/loopopts/TestArraysFillDeadControl.java: Array.fill intrinsification code doesn't mark replaced control as dead
compiler/loopopts/TestAssertPredicatePeeling.java: C2: assert(false) failed: Bad graph detected in build_loop_late after JDK-8305189
compiler/loopopts/TestBackedgeLoadArrayFillMain.java: ArrayFill: if store is on backedge, last iteration is not to be executed.
compiler/loopopts/TestBadControlAfterPreMainPost.java: C2: "control input must dominate current control" assert failure
compiler/loopopts/TestBadControlLoopLimitCheck.java: "Bad graph detected in build_loop_late" when loads are pinned on loop limit check uncommon branch
compiler/loopopts/TestBadCountedLoopLimit.java: C2 fails with assert(opaq->outcnt() == 1 && opaq->in(1) == limit) failed
compiler/loopopts/TestBadlyFormedCountedLoop.java: CountedLoopEndNode::stride_con crash in debug build with -XX:+TraceLoopOpts
compiler/loopopts/TestBaseCountedEndLoopUnswitchCandidate.java: Test Loop Unswitching with BaseCountedLoopEnd nodes as unswitch candidate.
compiler/loopopts/TestBeautifyLoops.java: JVM crashes after transformation in C2 IdealLoopTree::merge_many_backedges
compiler/loopopts/TestBeautifyLoops_2.java: JVM crashes after transformation in C2 IdealLoopTree::split_fall_in
compiler/loopopts/TestBrokenAntiDependenceWithPhi.java: C2: assert(early->dominates(LCA)) failed: early is high enough
compiler/loopopts/TestCMovSplitThruPhi.java: C2 conditonal move optimization might create broken graph
compiler/loopopts/TestCMovWithOpaque.java: Test conditional move optimization encountering an Opaque4Node.
compiler/loopopts/TestCMoveWithDeadPhi.java: Test conditional move optimization with a TOP PhiNode.
compiler/loopopts/TestCanonicalLoopEntryOpaqueOrder.java: C2 PhaseIdealLoop::do_unroll get wrong opaque node
compiler/loopopts/TestCastFFAtPhi.java: C2: assert(phi_type->isa_int() || phi_type->isa_ptr() || phi_type->isa_long()) failed: bad phi type Error mixing types with -XX:+UseCMoveUnconditionally -XX:+UseVectorCmov
compiler/loopopts/TestCastIIMakesMainLoopPhiDead.java: C2: assert(!had_error) failed: bad dominance
compiler/loopopts/TestCastIIMakesMainLoopPhiDead2.java: C2: assert(!had_error) failed: bad dominance
compiler/loopopts/TestCastIINoLoopLimitCheck.java: CastII that guards counted loops confuses range check elimination with LoopLimitCheck off
compiler/loopopts/TestCountedLoopBadIVRange.java: Bad range for IV phi when exit condition is a not equal test
compiler/loopopts/TestCountedLoopInsideInfiniteLoopMain.java: Counted Loops inside infinite loops are only detected later, and may still be a Region and not a LoopNode as expected.
compiler/loopopts/TestCountedLoopPhiValue.java: PhiNode::Value() is too conservative for tripcount of CountedLoop
compiler/loopopts/TestCountedLoopSafepointBackedge.java: Safepoint on backedge breaks UseCountedLoopSafepoints
compiler/loopopts/TestCountedLoopZeroIter.java: C2: assert(inner->is_valid_counted_loop(T_INT) && inner->is_strip_mined()) failed: OuterStripMinedLoop should have been removed
compiler/loopopts/TestCreateNewIfForPredicateCloning.java: Test cloning of pinned phi input nodes in create_new_if_for_predicate().
compiler/loopopts/TestDeadBackbranchArrayAccess.java: dead backbranch in main loop results in erroneous array access
compiler/loopopts/TestDeadCountedLoop.java: C2: java/text/Normalizer/ConformanceTest.java test failed with assertion
compiler/loopopts/TestDeadIrreducibleLoopsMain.java#id0: Irreducible loops have many entries, only when the last entry loses control from the outside does the loop die, and have to disappear.
compiler/loopopts/TestDeadIrreducibleLoopsMain.java#id1: Irreducible loops have many entries, only when the last entry loses control from the outside does the loop die, and have to disappear.
compiler/loopopts/TestDeadIrreducibleLoopsMain.java#id2: Irreducible loops have many entries, only when the last entry loses control from the outside does the loop die, and have to disappear.
compiler/loopopts/TestDeadIrreducibleLoopsMain.java#id3: Irreducible loops have many entries, only when the last entry loses control from the outside does the loop die, and have to disappear.
compiler/loopopts/TestDeadPostLoopBecausePredicate.java: C2: assert(n->is_Root() || n->is_Region() || n->is_Phi() || n->is_MachMerge() || def_block->dominates(block)) failed: uses must be dominated by definitions
compiler/loopopts/TestDepBetweenLoopAndPredicate.java: RangeCheck should not be moved out of a loop if a node on the data input chain for the bool is dependent on the projection into the loop (after the predicates).
compiler/loopopts/TestDivWithTopDivisor.java: Fix "assert(_base == Int) failed: Not an Int" due to a top divisor not handled correctly in no_dependent_zero_check().
compiler/loopopts/TestDivZeroCheckControl.java#id0: Verify that zero check is executed before division/modulo operation.
compiler/loopopts/TestEmptyLoopMultiplePhis.java: Test that the JVM doesn't fail due to split-if causing empty loop to temporarily have more than one phi
compiler/loopopts/TestEmptyPreLoopForDifferentMainLoop.java: Test empty loop removal of pre-loop, with different main-loop after it.
compiler/loopopts/TestIdomAfterLoopUnswitching.java: Test idom data after unswitching loop following by full unroll.
compiler/loopopts/TestIfReplacedByMainLoopExit.java: C2: Incorrect computation after JDK-8269752
compiler/loopopts/TestImpossibleIV.java: C2 IV elimination throws FPE
compiler/loopopts/TestInfLoopNearUsePlacement.java: Test node placement when its use is inside infinite loop.
compiler/loopopts/TestInfiniteLoopCCP.java: Crash PhaseIdealLoop::clone_outer_loop
compiler/loopopts/TestInfiniteLoopNest.java: Assertion failure: parsing found no loops but there are some
compiler/loopopts/TestInfiniteLoopNotInnerMost.java: C2: "failed: parsing found no loops but there are some" assert failure
compiler/loopopts/TestInfiniteLoopWithUnmergedBackedgesMain.java: Infinite loops may not have the backedges merged, before we call IdealLoopTree::check_safepts
compiler/loopopts/TestInlinedSplitFallInIrreducibleLoopStatusMain.java: Regions that are inlined are by default tagged as NeverIrreducibleEntry.
compiler/loopopts/TestIrreducibleLoopWithVNNI.java: assert(is_Loop()) failed: invalid node class, during OSR compilation for VNNI pattern match.
compiler/loopopts/TestIterationSplitWithRegionHead.java: Tests infinite loop with region head in iteration split.
compiler/loopopts/TestLimitLoadBelowLoopLimitCheck.java: C2 Crash in Node::in(unsigned int) const+0x14
compiler/loopopts/TestLoadPinnedAfterAllocate.java: C2: assert(false) failed: unscheduable graph
compiler/loopopts/TestLogSum.java: Segmentation fault in JVM (easily reproducible)
compiler/loopopts/TestLongCountedLoopInInfiniteLoop.java: C2: assert(!n->as_Loop()->is_loop_nest_inner_loop() || _loop_opts_cnt == 0) failed: should have been turned into a counted loop
compiler/loopopts/TestLoopEndNodeEliminate.java: Crashes in PhaseIdealLoop::transform_long_counted_loop
compiler/loopopts/TestLoopLimitNodeElimination.java: C2: LoopLimit node is not eliminated
compiler/loopopts/TestLoopLimitOverflowDuringCCP.java: Integer overflow in LoopLimit::Value during PhaseCCP::analyze, triggered by the Phi Node from "flag ? Integer.MAX_VALUE : 1000"
compiler/loopopts/TestLoopLimitOverflowDuringSplitThruPhi.java: Integer overflow in LoopLimit::Value during PhaseIdealLoop::split_thru_phi
compiler/loopopts/TestLoopLimitSubtractionsCollapse.java: Verify that AddL->MaxL->AddL->MaxL chains of unroll limit adjustments collapse.
compiler/loopopts/TestLoopPeeling.java: Tests correct dominator information after loop peeling.
compiler/loopopts/TestLoopPredicateDep.java: Crashes in PhaseIdealLoop::build_loop_late_post_work
compiler/loopopts/TestLoopPredicationDivZeroCheck.java: C2: Crash with SIGFPE
compiler/loopopts/TestMainBodyExecutedOnce.java: C2: assert(false) failed: Bad graph detected in build_loop_late
compiler/loopopts/TestMainNeverExecuted.java: C2: assert(!had_error) failed: bad dominance
compiler/loopopts/TestMalformedControlIrreducibleLoop.java: C2: "malformed control flow" with irreducible loop
compiler/loopopts/TestMaxLoopOptsCountReached.java: triggers the loop optimization phase `LoopOptsCount` many times
compiler/loopopts/TestMissedOpaqueInPredicate.java: Apache Lucene triggers: DEBUG MESSAGE: duplicated predicate failed which is impossible
compiler/loopopts/TestMoveStoreAfterInfiniteLoop.java: C2: assert(!n_loop->is_member(get_loop(lca))) failed: control must not be back in the loop
compiler/loopopts/TestMoveStoresOutOfLoops.java: Move stores out of loops if possible
compiler/loopopts/TestMoveStoresOutOfLoopsStoreNoCtrl.java: Store nodes may not have a control if used to update profiling
compiler/loopopts/TestMultipleInfiniteLoops.java: Test that blocks made unreachable after processing multiple infinite loops in the block ordering phase are removed correctly.
compiler/loopopts/TestNestedIrreducibleLoopsMain.java: Tests custom bytecode with deep nested irreducible loops.
compiler/loopopts/TestNodeSunkFromPreLoop.java: Node used in check in main loop sunk from pre loop before RC elimination
compiler/loopopts/TestNotifyOpaqueZeroTripGuardToCmpI.java: Test that if input to OpaqueZeroTripGuard changes, we notify down to CmpI.
compiler/loopopts/TestOneIterationStripMined.java: Test removal of strip mined loop with only one iteration.
compiler/loopopts/TestOnlyInfiniteLoopsMain.java: Nested irreducible loops, where the inner loop floats out of the outer
compiler/loopopts/TestOpaqueZeroTripGuardPostLoopRemoval.java: Must remove OpaqueZeroTripGuardPostLoop after main loop disappears else the zero-trip-guard of the post loop cannot die and leaves an inconsistent graph behind.
compiler/loopopts/TestOptimizeFillWithStripMinedLoop.java: assert(use == polladr) failed: the use should be a safepoint polling
compiler/loopopts/TestOverunrolling.java: Tests correct dominator information after over-unrolling a loop.
compiler/loopopts/TestPartialPeelAtUnsignedTests.java: Tests partial peeling at unsigned tests.
compiler/loopopts/TestPartialPeelAtUnsignedTestsNegativeLimit.java#Xbatch: Tests partial peeling at unsigned tests with limit being negative in exit tests "i >u limit".
compiler/loopopts/TestPartialPeelAtUnsignedTestsNegativeLimit.java#Xcomp-compile-test: Tests partial peeling at unsigned tests with limit being negative in exit tests "i >u limit".
compiler/loopopts/TestPartialPeelAtUnsignedTestsNegativeLimit.java#Xcomp-run-inline: Tests partial peeling at unsigned tests with limit being negative in exit tests "i >u limit".
compiler/loopopts/TestPartialPeelAtUnsignedTestsNegativeLimit.java#vanilla: Tests partial peeling at unsigned tests with limit being negative in exit tests "i >u limit".
compiler/loopopts/TestPartialPeelingAtSingleInputRegion.java: C2: Partial peeling fails with assert "last_peel <- first_not_peeled"
compiler/loopopts/TestPartialPeelingSinkNodes.java: Sinking of nodes in partial peeling creates too many clones resulting in a live node limit exceeded assertion failure.
compiler/loopopts/TestPeelingNeverEnteredLoop.java: C2: assert(cl->trip_count() > 0) failed: peeling a fully unrolled loop
compiler/loopopts/TestPeelingSkeletonPredicateInitialization.java: When skeleton predicates are not copied into peeled loop and initialized, this can happen: 1.
compiler/loopopts/TestPhaseCFGNeverBranchToGotoMain.java#id0: Peeling of Irreducible loop can lead to NeverBranch being visited from either side
compiler/loopopts/TestPhaseCFGNeverBranchToGotoMain.java#id1: Peeling of Irreducible loop can lead to NeverBranch being visited from either side
compiler/loopopts/TestPhiInSkeletonPredicateExpression.java: Assertion in PhaseIdealLoop::skeleton_predicate_has_opaque after JDK-8289127
compiler/loopopts/TestPreMainPostFallInEdges.java: Tests the rewiring and cloning of fall-in values from the main loop (and pre loop) to the post (and main loop) which resulted in a DUIterator_Fast assertion failure due to an insertion in the outputs of the loop header node.
compiler/loopopts/TestPredicateInputBelowLoopPredicate.java: C2: assert(false) failed: cyclic dependency prevents range check elimination
compiler/loopopts/TestRCEAfterUnrolling.java: SIGILL in C2 generated OSR compilation.
compiler/loopopts/TestRemixAddressExpressionsWithIrreducibleLoop.java: Test handling of irreducible loops in PhaseIdealLoop::remix_address_expressions.
compiler/loopopts/TestRemoveEmptyLoop.java: Unexpected test result caused by C2 IdealLoopTree::do_remove_empty_loop
compiler/loopopts/TestRemoveMainPostLoops.java: Verify that correct loops are selected when trying to remove main/post.
compiler/loopopts/TestSinkingMoreThan2AddPNodes.java: C2: assert(u->find_out_with(Op_AddP) == nullptr) failed: more than 2 chained AddP nodes?
compiler/loopopts/TestSinkingNodesCausesLongCompilation.java: Massive (up to ~30x) increase in C2 compilation time since JDK 17
compiler/loopopts/TestSkeletonPredicateNegation.java: Skeleton predicates sometimes need to be negated
compiler/loopopts/TestSplitIfBlocksDisabled.java: Verifies that loop optimizations work if SplitIfBlocks is disabled.
compiler/loopopts/TestSplitIfNewIrreducibleLoop.java: Tests where new irreducible loop is introduced by split_if.
compiler/loopopts/TestSplitIfOpaque1.java: The split-if optimization fails because an unexpected Opaque1 is encountered.
compiler/loopopts/TestSplitIfPinnedCMove.java: too strong assert from 8186125
compiler/loopopts/TestSplitIfPinnedLoadInStripMinedLoop.java: A LoadNode is pinned in split_if_with_blocks_post() on a loop exit node x that is part of a strip mined loop.
compiler/loopopts/TestSplitIfUnswitchedLoopsEliminated.java: split if finds predicates on several incoming paths when unswitched's loops are optimized out
compiler/loopopts/TestSplitThruPhiDivMod.java: A Division/modulo node whose zero check was removed is split through an induction variable phi and executed before the loop limit check resulting in a SIGFPE because the divisor is zero.
compiler/loopopts/TestSplitThruPhiInfinitely.java: The phi of cnt is split from the inner to the outer loop, and then from outer loop to the inner loop again.
compiler/loopopts/TestStoreSunkInInnerLoop.java: C2 fails with assert(!n->is_Store() && !n->is_LoadStore()) failed: no node with a side effect
compiler/loopopts/TestStrangeControl.java: Test PhaseIdealLoop::has_local_phi_input() with phi input with non-dominating control.
compiler/loopopts/TestStripMinedBackToBackIfs.java: Bad graph when unrolled loop bounds conflicts with range checks
compiler/loopopts/TestSunkCastOnUnreachablePath.java: C2: assert(false) failed: Bad graph detected in build_loop_late
compiler/loopopts/TestSunkNodeDueToBrokenAntiDependency.java: C2: assert(false) failed: graph should be schedulable after JDK-8252372
compiler/loopopts/TestSunkNodeInInfiniteLoop.java: C2: assert(get_loop(lca)->_nest < n_loop->_nest || lca->in(0)->is_NeverBranch()) failed: must not be moved into inner loop
compiler/loopopts/TestSunkNodeMissingCastAssert.java: assert(cast != nullptr) failed: must have added a cast to pin the node
compiler/loopopts/TestUndetectedLoopInInfiniteLoop.java: Loops inside infinite loops may not be detected, thus a region may still be the loop head, even if it is not a LoopNode.
compiler/loopopts/TestUnreachableInnerLoop.java: C2: Assert failed in PhaseCFG::verify() after JDK-8183390
compiler/loopopts/TestUnrollLimitPreciseType.java#test1: CMoveI for underflow protection of the limit did not compute a type that was precise enough.
compiler/loopopts/TestUnrollLimitPreciseType.java#test2: CMoveI for underflow protection of the limit did not compute a type that was precise enough.
compiler/loopopts/TestUnsupportedConditionalMove.java: Superword should remove unsupported cmove packs from candidate packset
compiler/loopopts/TestUnswitchCloneSkeletonPredicates.java: Test the complete cloning of skeleton predicates to unswitched loops as done when cloning them to the main loop.
compiler/loopopts/TestUnswitchOverunrolling.java: Test different cases of overunrolling the main loop of unswitched loops (pre/main/post) which are then not entered.
compiler/loopopts/TestUnswitchPredicateCloning.java: Test that all parse predicates are cloned after loop unswitching.
compiler/loopopts/TestUnswitchWithSunkNodes.java: A pinned Cast node on the UCT projection of a predicate is as input for the UCT phi node for the original loop, the fast and slow loop resulting in a dominance failure.
compiler/loopopts/TestValidTypeInOverflowProtection.java: Test for the check of a valid type (long) for the input variable of overflow protection
compiler/loopopts/TestWrongCMovSplitIf.java: C2: "Bad graph detected in build_loop_late" after a CMove is wrongly split thru phi
compiler/loopopts/TestWrongOffsetConstantArrayConstant.java: Phi of AddP transformation can cause offset in constant array to be dropped
compiler/loopopts/TestZeroTripGuardShared.java: C2 failed "assert(_outcnt==1) failed: not unique"
compiler/loopopts/UnrollWideLoopHitsTooStrictAssert.java: C2's unrolling code has a too strict assert when a counted loop's range is as wide as int's.
compiler/loopopts/VerifyGraphEdgesWithDeadCodeCheckFromSafepoints.java: Crash Compile::verify_graph_edges with dead code check when safepoints are reachable but not connected back to Root's inputs
compiler/loopopts/parallel_iv/TestParallelIvInIntCountedLoop.java: test the long typed parallel iv replacing transformation for int counted loop
compiler/loopopts/superword/AlignmentOnePack.java: Tests the case where there is only 1 pack and no operations left when calling SuperWord::find_align_to_ref() to find the best alignment again.
compiler/loopopts/superword/CoLocatePack.java: Tests SuperWord::co_locate_pack() involving a load pack that relies on a sandwiched and moved StoreF node.
compiler/loopopts/superword/CoLocatePackMemoryState.java: Tests to select the memory state of the last load in a load pack in SuperWord::co_locate_pack.
compiler/loopopts/superword/MinMaxRed_Int.java: [SuperWord] MaxReduction and MinReduction should vectorize for int
compiler/loopopts/superword/MinMaxRed_Long.java: [SuperWord] MaxReduction and MinReduction should vectorize for long
compiler/loopopts/superword/ProdRed_Double.java: Add C2 x86 Superword support for scalar product reduction optimizations : float test
compiler/loopopts/superword/ProdRed_Float.java: Add C2 x86 Superword support for scalar product reduction optimizations : float test
compiler/loopopts/superword/ProdRed_Int.java: Add C2 x86 Superword support for scalar product reduction optimizations : int test
compiler/loopopts/superword/RedTest_int.java: Add C2 x86 Superword support for scalar logical reduction optimizations : int test
compiler/loopopts/superword/RedTest_long.java: Add C2 x86 Superword support for scalar logical reduction optimizations : long test
compiler/loopopts/superword/ReductionPerf.java: Test SuperWord Reduction Perf.
compiler/loopopts/superword/SumRedAbsNeg_Double.java: Add C2 AArch64 Superword support for scalar sum reduction optimizations : double abs & neg test
compiler/loopopts/superword/SumRedAbsNeg_Float.java: Add C2 AArch64 Superword support for scalar sum reduction optimizations : float abs & neg test
compiler/loopopts/superword/SumRedSqrt_Double.java: Add C2 x86 Superword support for scalar sum reduction optimizations : double sqrt test
compiler/loopopts/superword/SumRed_Double.java: Add C2 x86 Superword support for scalar sum reduction optimizations : double test
compiler/loopopts/superword/SumRed_Float.java: Add C2 x86 Superword support for scalar sum reduction optimizations : float test
compiler/loopopts/superword/SumRed_Int.java: Add C2 x86 Superword support for scalar sum reduction optimizations : int test
compiler/loopopts/superword/SumRed_Long.java: Add C2 x86 Superword support for scalar sum reduction optimizations : long test
compiler/loopopts/superword/SuperWordIntermediateUse.java: The IR of this test contains a reduction chain which corresponds to a pack in which the 2nd last element has a usage outside of the optimized loop.
compiler/loopopts/superword/TestAlignVector.java#AlignVector: Test AlignVector with various loop init, stride, scale, invar, etc.
compiler/loopopts/superword/TestAlignVector.java#NoAlignVector: Test AlignVector with various loop init, stride, scale, invar, etc.
compiler/loopopts/superword/TestAlignVector.java#NoAlignVector-COH: Test AlignVector with various loop init, stride, scale, invar, etc.
compiler/loopopts/superword/TestAlignVector.java#VerifyAlignVector: Test AlignVector with various loop init, stride, scale, invar, etc.
compiler/loopopts/superword/TestAlignVector.java#VerifyAlignVector-COH: Test AlignVector with various loop init, stride, scale, invar, etc.
compiler/loopopts/superword/TestAlignVectorFuzzer.java#CompileOnly: Fuzzing loops with different (random) init, limit, stride, scale etc.
compiler/loopopts/superword/TestAlignVectorFuzzer.java#Vanilla: Fuzzing loops with different (random) init, limit, stride, scale etc.
compiler/loopopts/superword/TestAlignVectorFuzzer.java#VerifyAlignVector: Fuzzing loops with different (random) init, limit, stride, scale etc.
compiler/loopopts/superword/TestAlignVectorFuzzer.java#VerifyAlignVector-Align16: Fuzzing loops with different (random) init, limit, stride, scale etc.
compiler/loopopts/superword/TestAlignVectorFuzzer.java#VerifyAlignVector-NoTieredCompilation-Xbatch: Fuzzing loops with different (random) init, limit, stride, scale etc.
compiler/loopopts/superword/TestAutoVectorizationOverrideProfitability.java: Test the effect of AutoVectorizationOverrideProfitability.
compiler/loopopts/superword/TestBestAlign.java: Limit calculation of pre loop during super word optimization is wrong
compiler/loopopts/superword/TestCmpInvar.java: Test loop invariant input to Cmp.
compiler/loopopts/superword/TestCompatibleUseDefTypeSize.java: Test some cases that vectorize after the removal of the alignment boundaries code.
compiler/loopopts/superword/TestCyclicDependency.java: Writing forward on array creates cyclic dependency which leads to wrong result, when ignored.
compiler/loopopts/superword/TestDependencyOffsets.java#avx1-v016-A: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#avx1-v016-U: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#avx1-v032-A: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#avx1-v032-U: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#avx2-v016-A: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#avx2-v016-U: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#avx2-v032-A: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#avx2-v032-U: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#sse4-v004-A: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#sse4-v004-U: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#sse4-v008-A: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#sse4-v008-U: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#sse4-v016-A: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#sse4-v016-U: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#vanilla-A: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestDependencyOffsets.java#vanilla-U: Test SuperWord: vector size, offsets, dependencies, alignment.
compiler/loopopts/superword/TestEliminateAllocationWithCastP2XUse.java: Test SuperWord, when it aligns to field-store, and the corresponding allocation is eliminated.
compiler/loopopts/superword/TestEquivalentInvariants.java: Test vectorization with various invariants that are equivalent, but not trivially so, i.e.
compiler/loopopts/superword/TestFuzzPreLoop.java: SEGV in SuperWord::get_pre_loop_end
compiler/loopopts/superword/TestGeneralizedReductions.java: Test reduction vectorizations that are enabled by performing SLP reduction analysis on unrolled loops.
compiler/loopopts/superword/TestHoistedReductionNode.java: Test that inconsistent reduction node-loop state does not trigger assertion failures when the inconsistency does not lead to a miscompilation.
compiler/loopopts/superword/TestIndependentPacksWithCyclicDependency.java: Test some examples with independent packs with cyclic dependency between the packs.
compiler/loopopts/superword/TestIndependentPacksWithCyclicDependency2.java: Test some examples with independent packs with cyclic dependency between the packs.
compiler/loopopts/superword/TestLargeCompilation.java: Test compile time for large compilation, where SuperWord takes especially much time.
compiler/loopopts/superword/TestLargeScaleAndStride.java#AlignVector:
compiler/loopopts/superword/TestLargeScaleAndStride.java#StoreToLoadForwardingFailureDetection:
compiler/loopopts/superword/TestLargeScaleAndStride.java#vanilla: Test autovectorization with large scale and stride
compiler/loopopts/superword/TestMemorySegment.java#byte-array: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#byte-array-AlignVector: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#byte-buffer: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#byte-buffer-direct: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#char-array: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#double-array: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#float-array: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#int-array: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#int-array-AlignVector: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#long-array: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#long-array-AlignVector: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#native: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#native-AlignVector: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegment.java#short-array: Test vectorization of loops over MemorySegment
compiler/loopopts/superword/TestMemorySegmentMainLoopAlignment.java: Case where VPointer finds an "adr" CastX2P, which contains a CastLL, that has a ctrl after the pre-loop.
compiler/loopopts/superword/TestMemorySegmentUnalignedAddress.java#byte-buffer-direct: Test vectorization of loops over MemorySegment, with native memory where the address is not always aligned.
compiler/loopopts/superword/TestMemorySegmentUnalignedAddress.java#byte-buffer-direct-AlignVector: Test vectorization of loops over MemorySegment, with native memory where the address is not always aligned.
compiler/loopopts/superword/TestMemorySegmentUnalignedAddress.java#byte-buffer-direct-VerifyAlignVector: Test vectorization of loops over MemorySegment, with native memory where the address is not always aligned.
compiler/loopopts/superword/TestMemorySegmentUnalignedAddress.java#native: Test vectorization of loops over MemorySegment, with native memory where the address is not always aligned.
compiler/loopopts/superword/TestMemorySegmentUnalignedAddress.java#native-AlignVector: Test vectorization of loops over MemorySegment, with native memory where the address is not always aligned.
compiler/loopopts/superword/TestMemorySegmentUnalignedAddress.java#native-VerifyAlignVector: Test vectorization of loops over MemorySegment, with native memory where the address is not always aligned.
compiler/loopopts/superword/TestMovingLoadBeforeStore.java: In SuperWord::output, LoadVector can be moved before StoreVector, but only if it is proven to be safe.
compiler/loopopts/superword/TestMulAddS2I.java: Test MulAddS2I vectorization.
compiler/loopopts/superword/TestMultiversionRemoveUselessSlowLoop.java: Test case where the multiversion fast_loop disappears, and we should constant fold the multiversion_if, to remove the slow_loop.
compiler/loopopts/superword/TestMultiversionWithPeelMainPost.java: Test case where we used to Multiversion a PeelMainPost loop, which is useless and triggered an assert later on.
compiler/loopopts/superword/TestNegBaseOffset.java: Test skipping vector packs with negative base offset.
compiler/loopopts/superword/TestNoInputInLoop.java#Vanilla: Test bad loop ctrl: a node is in the loop, but has no input in the loop
compiler/loopopts/superword/TestNoInputInLoop.java#WithFlags: Test bad loop ctrl: a node is in the loop, but has no input in the loop
compiler/loopopts/superword/TestNoInputInLoop.java#WithMoreFlags: Test bad loop ctrl: a node is in the loop, but has no input in the loop
compiler/loopopts/superword/TestParallelReduction.java: Test parallel reductions.
compiler/loopopts/superword/TestPeelMainPostNoMultiversioning.java: IR test to ensure that PeelMainPost cases does not get Multiversioned.
compiler/loopopts/superword/TestPeeledReductionNode.java: Test that reduction nodes peeled out of an inner loop are not vectorized as reductions within the outer loop.
compiler/loopopts/superword/TestPickFirstMemoryState.java: Test which needs to select the memory state of the first load in a load pack in SuperWord::co_locate_pack.
compiler/loopopts/superword/TestPickLastMemoryState.java: Test which needs to select the memory state of the last load in a load pack in SuperWord::co_locate_pack.
compiler/loopopts/superword/TestReductionWithLoopVariantUse.java: Loop variant use in reduction should prevent vectorization
compiler/loopopts/superword/TestScheduleReordersScalarMemops.java: Test some examples where non-vectorized memops also need to be reordered during SuperWord::schedule.
compiler/loopopts/superword/TestSearchAlignment.java: JVM crash in SWPointer during C2 compilation
compiler/loopopts/superword/TestSplitPacks.java: Test splitting packs in SuperWord
compiler/loopopts/superword/TestUnorderedReduction.java#MaxVectorSize16-Unaligned: Special test cases for PhaseIdealLoop::move_unordered_reduction_out_of_loop
compiler/loopopts/superword/TestUnorderedReduction.java#MaxVectorSize32-Aligned: Special test cases for PhaseIdealLoop::move_unordered_reduction_out_of_loop
compiler/loopopts/superword/TestUnorderedReduction.java#Vanilla-Aligned: Special test cases for PhaseIdealLoop::move_unordered_reduction_out_of_loop
compiler/loopopts/superword/TestUnorderedReduction.java#Vanilla-Unaligned: Special test cases for PhaseIdealLoop::move_unordered_reduction_out_of_loop
compiler/loopopts/superword/TestUnorderedReductionPartialVectorization.java: Special test cases for PhaseIdealLoop::move_unordered_reduction_out_of_loop Here a case with partial vectorization of the reduction.
compiler/loopopts/superword/TestVectorFPReduction.java: Ensure strictly ordered AddReductionVF/VD and MulReductionVF/VD nodes are generated when these operations are auto-vectorized
compiler/loopopts/superword/TestVectorizationWithInvariant.java: Tests correct alignment of vectors with loop invariant offset.
compiler/loopopts/superword/TestVectorizeTypeConversionWithUnsafe.java: Tests auto-vectorization of type conversion with unsafe.
compiler/loopopts/superword/TestWronglyMarkedReduction.java: Cloned node in AddNode::Ideal is no longer a reduction but is still marked as such leading to wrong vectorization.
compiler/loopopts/superword/Vec_MulAddS2I.java: Test operations in C2 MulAddS2I and MulAddVS2VI nodes.
compiler/loopstripmining/AntiDependentLoadInOuterStripMinedLoop.java: Sinking load out of loop may trigger: assert(found_sfpt) failed: no node in loop that's not input to safepoint
compiler/loopstripmining/BackedgeNodeWithOutOfLoopControl.java: "node not on backedge" assert in OuterStripMinedLoopNode::adjust_strip_mined_loop
compiler/loopstripmining/CheckLoopStripMining.java: C2: LoopStripMining doesn't strip as expected
compiler/loopstripmining/CheckLoopStripMiningIterShortLoop.java: when loop strip is enabled, LoopStripMiningIterShortLoop should be not null
compiler/loopstripmining/DeadNodesInOuterLoopAtLoopCloning.java: loop unrolling breaks when outer strip mined loop contains dead node
compiler/loopstripmining/DeadNodesInOuterLoopAtLoopCloning2.java: loop unrolling breaks when outer strip mined loop contains dead node
compiler/loopstripmining/LimitSharedwithOutOfLoopTest.java: limit test is shared with out of loop if
compiler/loopstripmining/LoadDependsOnIfIdenticalToLoopExit.java: shared an identical bool node with a strip-mined loop
compiler/loopstripmining/LoadSplitThruPhi.java: ShouldNotReachHere in PhaseIdealLoop::verify_strip_mined_scheduling
compiler/loopstripmining/OuterStripMinedLoopLoadWronglyHoisted.java: C2 compilation fails with assert "n is later than its clone"
compiler/loopstripmining/StripMinedLoopReorgOffsets.java: C2 still crashes with "assert(mode == ControlAroundStripMined && use == sfpt) failed: missed a node"
compiler/loopstripmining/TestAddPAtOuterLoopHead.java: C2: assert(get_ctrl(n) == cle_out) during unrolling
compiler/loopstripmining/TestBrokenEmptyLoopLogic.java: C2: assert(wq.size() - before == EMPTY_LOOP_SIZE) failed: expect the EMPTY_LOOP_SIZE nodes of this body if empty
compiler/loopstripmining/TestCastIIAfterUnrollingInOuterLoop.java: C2: assert(found_sfpt) failed: no node in loop that's not input to safepoint
compiler/loopstripmining/TestConservativeAntiDep.java: C2: ShouldNotReachHere() in verify_strip_mined_scheduling
compiler/loopstripmining/TestDeadOuterStripMinedLoop.java: Test loop strip mining verification with dying outer loop.
compiler/loopstripmining/TestEliminatedLoadPinnedOnBackedge.java: C2: "failed: only phis" assert failure in loop strip mining verfication
compiler/loopstripmining/TestIdenticalDominatingCLE.java: C2: assert(is_OuterStripMinedLoop()) failed: invalid node class: IfTrue
compiler/loopstripmining/TestLSMBadControlOverride.java: Segfault at PhaseIdealLoop::clone_loop_handle_data_uses
compiler/loopstripmining/TestLoadOnBackedgeWithPrec.java: Loop strip mining verification fails with "should be on the backedge"
compiler/loopstripmining/TestNoWarningLoopStripMiningIterSet.java#Epsilon: G1/Z give warning when using LoopStripMiningIter and turn off LoopStripMiningIter (0)
compiler/loopstripmining/TestNoWarningLoopStripMiningIterSet.java#G1: G1/Z give warning when using LoopStripMiningIter and turn off LoopStripMiningIter (0)
compiler/loopstripmining/TestNoWarningLoopStripMiningIterSet.java#Shenandoah: G1/Z give warning when using LoopStripMiningIter and turn off LoopStripMiningIter (0)
compiler/loopstripmining/TestNoWarningLoopStripMiningIterSet.java#Z: G1/Z give warning when using LoopStripMiningIter and turn off LoopStripMiningIter (0)
compiler/loopstripmining/TestNondeleteableSafePoint.java: C2: assert(false) failed: malformed control flow
compiler/loopstripmining/TestOuterStripMinedDeadAfterExpansion.java: dead outer strip mined not optimized out after expansion
compiler/loopstripmining/TestPinnedNodeInInnerLoop.java: C2: assert(!loop->is_member(u_loop)) failed: can be in outer loop or out of both loops only
compiler/loopstripmining/TestPinnedUseInOuterLSMUnusedBySfpt.java: C2 compilation fails with assert(found_sfpt) failed: no node in loop that's not input to safepoint
compiler/loopstripmining/TestStoreSunkToOuterLoop.java: assert(outer->outcnt() == 2) failed: 'only phis' failure in LoopNode::verify_strip_mined()
compiler/loopstripmining/TestStoresSunkInOuterStripMinedLoop.java: C2: loop strip mining expansion doesn't take sunk stores into account
compiler/loopstripmining/TestStripMinedLimitBelowInit.java: Following 8241492, strip mined loop may run extra iterations
compiler/loopstripmining/TestUseFromInnerInOuterUnusedBySfpt.java: C2 compilation hits "assert((mode == ControlAroundStripMined && use == sfpt) || !use->is_reachable_from_root()) failed: missed a node"
compiler/loopstripmining/UnexpectedNodeInOuterLoopWhenCloning.java: C2: assert(mode == ControlAroundStripMined && use == sfpt) failed: missed a node
compiler/loopstripmining/UnexpectedPinnedNodeInOuterLoop.java: C2: assert(found_sfpt) failed: no node in loop that's not input to safepoint
compiler/macronodes/TestCompleteVolatileStore.java: Tests proper rehashing of a captured volatile field StoreL node when completing it.
compiler/macronodes/TestEliminateAllocationPhi.java: PhiNode inserted between AllocateNode and Initialization node confuses allocation elimination
compiler/macronodes/TestLoopStripMiningInMacroElimination.java: Regression test for an assert triggered during elimination of OuterStripMinedLoop node.
compiler/macronodes/TestTopInMacroElimination.java: Regression test for an assert triggered during allocation elimination because top is found during constructing new phis.
compiler/membars/TestMemBarAcquire.java: Tests optimization of MemBarAcquireNodes
compiler/onSpinWait/TestOnSpinWait.java: (x86 only) checks that java.lang.Thread.onSpinWait is intrinsified
compiler/onSpinWait/TestOnSpinWaitC1.java: (x86 only) checks that java.lang.Thread.onSpinWait is intrinsified
compiler/onSpinWait/TestOnSpinWaitEnableDisable.java: Test to ensure basic functioning of java.lang.Thread.onSpinWait
compiler/osr/TestOSRWithNonEmptyStack.java: Force OSR compilation with non-empty stack at the OSR entry point.
compiler/osr/TestRangeCheck.java: Tests that range check is not skipped
compiler/parsing/TestExceptionBlockWithPredecessorsMain.java: Tests custom bytecode with an explicit entry (fall through or jump) to an exception block which was unexpected for C2 parsing.
compiler/parsing/TestMissingSafepointOnSwitch.java: C2: "malformed control flow" assert due to missing safepoint on backedge with a switch
compiler/parsing/TestMissingSafepointOnTryCatch.java: assert(false) failed: malformed control flow to missing safepoint on backedge of a try-catch
compiler/parsing/TestUnsafeArrayAccessWithNullBase.java: Unsafe::getShortUnaligned with base null hidden behind CheckCastPP nodes
compiler/parsing/UnreachableBlockFallsThroughEndOfCode.java: Compiling method that falls off the end of the code array
compiler/predicates/TestBackToBackParsePredicates.java: Test that back to back Parse Predicates with same deopt reason are not grouped together
compiler/predicates/TestCloningWithManyDiamondsInExpression.java#id0: Test that DFS algorithm for cloning Template Assertion Predicate Expression does not endlessly process paths.
compiler/predicates/TestCloningWithManyDiamondsInExpression.java#id1: Test that DFS algorithm for cloning Template Assertion Predicate Expression does not endlessly process paths.
compiler/predicates/TestCountedLoopMinJintStride.java: C2: "negative trip count?" assert failure in profile predicate code
compiler/predicates/TestDisabledLoopPredicates.java: Test that profiled loop predicates are turned off if loop predicates are turned off
compiler/predicates/TestHoistedPredicateForNonRangeCheck.java#id0: Tests that IfNode is not wrongly chosen as range check by Loop Predication leading to crashes and wrong executions.
compiler/predicates/TestHoistedPredicateForNonRangeCheck.java#id1: Tests that IfNode is not wrongly chosen as range check by Loop Predication leading to crashes and wrong executions.
compiler/predicates/TestLoopUnswitchingWithoutParsePredicates.java: Test that we do not try to copy a Parse Predicate to an unswitched loop if they do not exist anymore.
compiler/predicates/TestParsePredicateUCTWithPhi.java: Test that UCT for a Parse Predicate with a Phi does not incorrectly have a top input after Loop Unswitching.
compiler/predicates/TestPeelingFindsUnrelatedOpaque4Node.java: Test that loop peeling does not treat unrelated Opaque4 node as Template Assertion Predicate.
compiler/predicates/TestPredicatesBasic.java: Test basic loop predicates
compiler/predicates/TestWrongPredicateOrder.java: Test that Parse Predicates immediately following other Parse Predicates are cleaned up properly.
compiler/predicates/TestWrongRuntimePredicateDetection.java: Test that CountedLoopEndNodes and zero trip guard check If nodes are not treated as Runtime Predicates.
compiler/predicates/assertion/TestAssertionPredicateDoesntConstantFold.java: C2: Broken graph after not skipping CastII node anymore for Assertion Predicates after JDK-8309902
compiler/predicates/assertion/TestAssertionPredicates.java#CloneDown:
compiler/predicates/assertion/TestAssertionPredicates.java#DataUpdate:
compiler/predicates/assertion/TestAssertionPredicates.java#LoopMaxUnroll0:
compiler/predicates/assertion/TestAssertionPredicates.java#LoopMaxUnroll2:
compiler/predicates/assertion/TestAssertionPredicates.java#LoopUnrollLimit150:
compiler/predicates/assertion/TestAssertionPredicates.java#LoopUnrollLimit40:
compiler/predicates/assertion/TestAssertionPredicates.java#NoFlags:
compiler/predicates/assertion/TestAssertionPredicates.java#NoLoopPredicationXbatch:
compiler/predicates/assertion/TestAssertionPredicates.java#NoLoopPredicationXcomp:
compiler/predicates/assertion/TestAssertionPredicates.java#NoTieredCompilation:
compiler/predicates/assertion/TestAssertionPredicates.java#StressXbatch:
compiler/predicates/assertion/TestAssertionPredicates.java#StressXcomp:
compiler/predicates/assertion/TestAssertionPredicates.java#StressXcompMaxUnroll0:
compiler/predicates/assertion/TestAssertionPredicates.java#UseProfiledLoopPredicateFalse:
compiler/predicates/assertion/TestAssertionPredicates.java#Xbatch: Test all possible cases in which Assertion Predicates are required such that the graph is not left in a broken state to trigger assertions.
compiler/predicates/assertion/TestAssertionPredicates.java#Xcomp:
compiler/predicates/assertion/TestAssertionPredicates.java#XcompNoTiered:
compiler/predicates/assertion/TestIfWithPhiInput.java: Test bailout of range check policy with an If with a Phi as condition.
compiler/predicates/assertion/TestLoadPinnedAboveAssertionPredicatesAndUsingStore.java: Test that stores cloned with clone_up_backedge_goo() are not pinned above Assertion Predicates on which a load node is pinned at which will later fail in scheduling.
compiler/predicates/assertion/TestOpaqueInitializedAssertionPredicateNode.java#clone_loop_handle_data_uses: Test that using OpaqueInitializedAssertionPredicate for Initialized Assertion Predicates instead of Opaque4 nodes also works with clone_loop_handle_data_uses() which missed a case before.
compiler/predicates/assertion/TestOpaqueInitializedAssertionPredicateNode.java#id0: Test that replacing Opaque4 nodes with OpaqueInitializedAssertionPredicate for Initialized Assertion Predicates works.
compiler/predicates/assertion/TestOpaqueInitializedAssertionPredicateNode.java#noflags:
compiler/predicates/assertion/TestPhiAboveOpaqueInitializedAssertionPredicate.java: Check that we do not introduce a Phi above a OpaqueInitializedAssertionPredicateNode during Partial Peeling.
compiler/predicates/assertion/TestSplitIfCloningDown.java#id0: Sanity test to exercise code to clone a Template Assertion Predicate down in Split If.
compiler/predicates/assertion/TestSplitIfCloningDown.java#no-flags: Sanity test to exercise code to clone a Template Assertion Predicate down in Split If.
compiler/predicates/assertion/TestTemplateAssertionPredicateNotRemoved.java: We fail to remove a Template Assertion Predicate of a dying loop causing an assert.
compiler/predicates/assertion/TestTemplateAssertionPredicateWithTwoUCTs.java: Test that a fail path projection of a Template Assertion Predicate is not treated as success path projection.
compiler/predicates/assertion/TestTemplateWithoutOpaqueLoopNodes.java#Xbatch: Test that no Template Assertion Predicate is created in Loop Prediction for one iteration loop.
compiler/predicates/assertion/TestTemplateWithoutOpaqueLoopNodes.java#Xcomp: Test that no Template Assertion Predicate is created in Loop Prediction for one iteration loop.
compiler/profiling/TestMethodHandleInvokesIntrinsic.java: profiling of arguments in C1 at MethodHandle invoke of intrinsic tries to profile popped argument.
compiler/profiling/TestMultiBranchDataOverflow.java: Test int range overflow of MultiBranchData counter.
compiler/profiling/TestProfileCounterOverflow.java: Profile counter for a call site may overflow.
compiler/profiling/TestSharedHeadExceptionBackedges.java: Access violation in ciTypeFlow::profiled_count
compiler/profiling/TestSpecTrapClassUnloading.java: speculative traps need to be cleaned up at GC
compiler/profiling/TestTypeProfileArgsLimit.java: Tests execution with TypeProfileArgsLimit=0 TypeProfileLevel=222.
compiler/profiling/TestTypeProfiling.java: Parameters type profiling is not performed from aarch64 interpreter
compiler/profiling/TestUnexpectedProfilingMismatch.java: profiling of arguments at calls cannot rely on signature of callee for types
compiler/profiling/UnsafeAccess.java:
compiler/profiling/spectrapredefineclass/Launcher.java:
compiler/profiling/spectrapredefineclass_classloaders/Launcher.java:
compiler/profiling/unloadingconflict/TestProfileConflictClassUnloading.java: class unloading resets profile, method compiled after the profile is first set and before class loading sets unknown bit with not recorded class
compiler/rangechecks/PowerOf2SizedArraysChecks.java: strength reduce or eliminate range checks for power-of-two sized arrays
compiler/rangechecks/RangeCheckEliminationScaleNotOne.java: C2: range check elimination may allow illegal out of bound access
compiler/rangechecks/TestArrayAccessAboveRCAfterPartialPeeling.java: partial peeling loop can cause an array load to become dependent on a test other than its range check
compiler/rangechecks/TestArrayAccessAboveRCAfterRCCastIIEliminated.java: [REDO] C2: crash in compiled code because of dependency on removed range check CastIIs
compiler/rangechecks/TestArrayAccessAboveRCAfterSinking.java: sinking an array load out of loop can cause it to become dependent on a test other than its range check
compiler/rangechecks/TestArrayAccessAboveRCAfterSmearingOrPredication.java: Replacing a test with a dominating test can cause an array load to float above a range check that guards it
compiler/rangechecks/TestArrayAccessAboveRCAfterSplitIf.java: split if can cause an array load to become dependent on a test other than its range check
compiler/rangechecks/TestArrayAccessAboveRCAfterUnswitching.java: loop unswitching can cause an array load to become dependent on a test other than its range check
compiler/rangechecks/TestArrayAccessAboveRCForArrayCopyLoad.java: converting an array copy to a series of loads/stores add loads that can float
compiler/rangechecks/TestArrayAccessCastIIAboveRC.java: Replacing a test with a dominating test can cause an array access CastII to float above a range check that guards it
compiler/rangechecks/TestBadFoldCompare.java: x <= 0 || x > 0 wrongly folded as (x-1) >u -1 and x < 0 || x > -1 wrongly folded as x >u -1
compiler/rangechecks/TestEmptyLoopDeadCast.java: C2: assert(!had_error) failed: bad dominance
compiler/rangechecks/TestExplicitRangeChecks.java: explicit range checks should be recognized by C2
compiler/rangechecks/TestLargeScaleInLongRCOverflow.java: SIGFPE in PhaseIdealLoop::extract_long_range_checks
compiler/rangechecks/TestLimitControlWhenNoRCEliminated.java: C2: assert(main_limit == cl->limit() || get_ctrl(main_limit) == new_limit_ctrl) failed: wrong control for added limit
compiler/rangechecks/TestLongRCWithLoopIncr.java: PhaseIdealLoop::transform_long_range_checks fails with assert "was tested before"
compiler/rangechecks/TestLongRangeCheck.java: C2: optimize long range checks in long counted loops
compiler/rangechecks/TestRCMinInt.java: range checks with min int scale value
compiler/rangechecks/TestRangeCheckCastIISplitThruPhi.java: [REDO] C2: crash in compiled code because of dependency on removed range check CastIIs
compiler/rangechecks/TestRangeCheckCmpUOverflowVsSub.java: In CmpU::Value, the sub computation may be narrower than the overflow computation.
compiler/rangechecks/TestRangeCheckCmpUUnderflow.java: Dominator failure because ConvL2I node becomes TOP, kills data-flow, but range-check does not collapse due to insufficient overflow/underflow handling in CmpUNode::Value.
compiler/rangechecks/TestRangeCheckExceptionHandlerLoopMain.java: C1's range check elimination breaks with a non-natural loop that an exception handler as one entry
compiler/rangechecks/TestRangeCheckLimits.java: Dominator failure because ConvL2I node becomes TOP due to missing overflow/underflow handling in range check elimination in PhaseIdealLoop::add_constraint().
compiler/rangechecks/TestRangeCheckSmearing.java: C2's range check smearing allows out of bound array accesses
compiler/rangechecks/TestRangeCheckSmearingLoopOpts.java: Following range check smearing, range check cannot be replaced by dominating identical test.
compiler/rangechecks/TestSunkRangeFromPreLoopRCE.java: C2: "node pinned on loop exit test?" assert failure
compiler/rangechecks/TestUncommonTrapMerging.java: Verify proper re-execution of checks after merging of uncommon traps
compiler/reflection/ArrayNewInstanceOfVoid.java: ShouldNotReachHere error when creating an array with component type of void
compiler/regalloc/C1ObjectSpillInLogicOp.java: C1 crashes generating G1 post-barrier in Unsafe.getAndSetReference() intrinsic because of the new value spill
compiler/regalloc/TestC1OverlappingRegisterHint.java: The C1 register allocator uses a register hint interval i as spill location for an interval j which overlaps with one of i's split children which has the same spill location which lets verification fail.
compiler/regalloc/TestC2IntPressure.java: C2 compilation often fails on aarch64 with "failed spill-split-recycle sanity check"
compiler/regalloc/TestGCMRecalcPressureNodes.java: crash in PhaseCFG::global_code_motion
compiler/regalloc/TestNodeRegArrayOverflow.java: Test that C2's PhaseRegAlloc::_node_regs (a post-register-allocation mapping from machine nodes to assigned registers) does not overflow in the face of a program with a high-density of CISC spilling candidate nodes.
compiler/regalloc/TestVectorRegAlloc.java: assert in register allocation code when vector Phi for a loop is processed because code assumes all inputs already processed
compiler/regalloc/VolatileLoadMemBarsOnlyUses.java: C2: assert(n->outcnt() != 0 || C->top() == n || n->is_Proj()) failed: No dead instructions after post-alloc
compiler/runtime/JITClassInit.java: self-parser test causes JDK 1.2 Beta4K segmentation fault
compiler/runtime/SpreadNullArg.java: verifies that the MethodHandle spread adapter can gracefully handle null arguments.
compiler/runtime/StackOverflowBug.java: JVM crashes with "missing exception handler" error
compiler/runtime/Test6778657.java: Casts in SharedRuntime::f2i, f2l, d2i and d2l rely on undefined C++ behaviour
compiler/runtime/Test6826736.java: CMS: core dump with -XX:+UseCompressedOops
compiler/runtime/Test6859338.java: Assertion failure in sharedRuntime.cpp
compiler/runtime/Test6863420.java: os::javaTimeNanos() go backward on Solaris x86
compiler/runtime/Test6892265.java: System.arraycopy unable to reference elements beyond Integer.MAX_VALUE bytes
compiler/runtime/Test7088020.java: SEGV in JNIHandleBlock::release_block
compiler/runtime/Test7196199.java: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
compiler/runtime/Test8010927.java: Kitchensink crashed with SIGSEGV, Problematic frame: v ~StubRoutines::checkcast_arraycopy
compiler/runtime/TestConstantDynamic.java:
compiler/runtime/TestConstantsInError.java:
compiler/runtime/TestFloatsOnStackDeopt.java: testing deoptimization on safepoint with floating point values on stack
compiler/runtime/cr6891750/Test6891750.java: deopt blob kills values in O5
compiler/runtime/cr8015436/Test8015436.java: the IK _initial_method_idnum value must be adjusted if overpass methods are added
compiler/runtime/safepoints/TestMachTempsAcrossSafepoints.java: Test that undefined values generated by MachTemp nodes (in this case, derived from G1 barriers) are not included in OopMaps.
compiler/runtime/safepoints/TestRegisterRestoring.java: Test correct saving and restoring of vector registers at safepoints.
compiler/runtime/unloaded/TestMHUnloaded.java:
compiler/runtime/unloaded/TestUnloadedSignatureClass.java:
compiler/splitif/TestCrashAtIGVNSplitIfSubType.java: C2: crash in SubTypeCheckNode::sub() at IGVN split if
compiler/splitif/TestLongCountedLoopConvL2I.java: C2: crash when ConvL2I is split thru phi at LongCountedLoop
compiler/splitif/TestLongCountedLoopConvL2I2.java: C2: crash when ConvL2I is split thru phi at LongCountedLoop
compiler/splitif/TestSplitDivThroughPhiWithControl.java#fuzzer: Test split_thru_phi with pinned divisions/modulo that have phi as inputs.
compiler/splitif/TestSplitDivThroughPhiWithControl.java#normal: Test split_thru_phi with pinned divisions/modulo that have phi as inputs.
compiler/stable/TestStableBoolean.java: tests on stable fields and arrays
compiler/stable/TestStableByte.java: tests on stable fields and arrays
compiler/stable/TestStableChar.java: tests on stable fields and arrays
compiler/stable/TestStableDouble.java: tests on stable fields and arrays
compiler/stable/TestStableFloat.java: tests on stable fields and arrays
compiler/stable/TestStableInt.java: tests on stable fields and arrays
compiler/stable/TestStableLong.java: tests on stable fields and arrays
compiler/stable/TestStableMemoryBarrier.java: tests memory barrier correctly inserted for stable fields
compiler/stable/TestStableMismatched.java: Tests if mismatched char load from stable byte[] returns correct result
compiler/stable/TestStableObject.java: tests on stable fields and arrays
compiler/stable/TestStableShort.java: tests on stable fields and arrays
compiler/stable/TestStableUByte.java: tests on stable fields and arrays
compiler/stable/TestStableUShort.java: tests on stable fields and arrays
compiler/stable/TestUnstableStable.java: Verify that constant folding of field loads observes consistent values during compilation.
compiler/startup/NumCompilerThreadsCheck.java: Ensures correct minimal number of compiler threads (provided by -XX:CICompilerCount=)
compiler/startup/SmallCodeCacheStartup.java: Test ensures that there is no crash if there is not enough ReservedCodeCacheSize to initialize all compiler threads.
compiler/startup/StartupOutput.java: Test ensures correct VM output during startup
compiler/startup/TieredStopAtLevel0SanityTest.java: Sanity test flag combo that force compiles on level 0
compiler/stringopts/TestLongStringConcat.java: Test very long chain of StringBuilder append calls.
compiler/stringopts/TestOptimizeStringConcat.java: test that string optimizations produce code, that doesn't lead to a crash.
compiler/stringopts/TestSideEffectBeforeConstructor.java: Test correctness of the string concatenation optimization with a store between StringBuffer allocation and constructor invocation.
compiler/stringopts/TestStackedConcatsAppendUncommonTrap.java: Test stacked string concatenations where the toString result of the first StringBuilder chain is wired into an uncommon trap located in the second one.
compiler/stringopts/TestStackedConcatsSharedTest.java: Test stacked string concatenations where the toString of the first StringBuilder is used as a shared test by two diamond Ifs in the second StringBuilder.
compiler/stringopts/TestStringObjectInitialization.java: Verifies that no partially initialized String object escapes from C2's String concat optimization in a highly concurrent setting.
compiler/types/TestArrayManyDimensions.java: C2: very slow compilation due to type system verification code
compiler/types/TestArrayMeetNotSymmetrical.java: Meet not symmetric failure when running lucene on jdk8
compiler/types/TestBadMemSliceWithInterfaces.java: C2 compilation asserts with "no node with a side effect" in PhaseIdealLoop::try_sink_out_of_loop
compiler/types/TestBottomArrayTypeCheck.java: SIGSEGV in GraphKit::gen_checkcast
compiler/types/TestCheckCastPPBecomesTOP.java: C2: SIGSEGV in PhaseIdealLoop::push_pinned_nodes_thru_region
compiler/types/TestEACheckCastPP.java: C2 Crash running eclipse benchmark from Dacapo
compiler/types/TestExactArrayOfBasicType.java: Parse::check_interpreter_type fails with assert "must constrain OSR typestate"
compiler/types/TestFoldNECompares.java: Test folding of != integer comparisons.
compiler/types/TestIntArraySubTypeOfCloneableDoesnotFold.java: C2: assert((Value(phase) == t) || (t != TypeInt::CC_GT && t != TypeInt::CC_EQ)) failed: missing Value() optimization
compiler/types/TestInterfaceArraySubtypeCheck.java: C2 incorrectly folds subtype checks involving an interface array.
compiler/types/TestMeetExactConstantArrays.java: meet of 2 constant arrays result in bottom
compiler/types/TestMeetIncompatibleInterfaceArrays.java: C2 can not handle returns with inccompatible interface arrays
compiler/types/TestMeetTopArrayExactConstantArray.java: meet of TopPTR exact array with constant array is not symmetric
compiler/types/TestMeetXor.java: Test meet on xor
compiler/types/TestMethodHandleSpeculation.java: Crash/miscompile in CallGenerator::for_method_handle_inline after JDK-8191998
compiler/types/TestPhiElimination.java: Tests elimination of Phi nodes without losing type information.
compiler/types/TestSpeculationBrokenWithIntArrays.java: C2: 8297933 broke type speculation in some cases
compiler/types/TestSpeculationFailedHigherEqual.java: type methods shouldn't always operate on speculative part
compiler/types/TestSubTypeCheckMacroNodeWrongMem.java: Wiring of memory in SubTypeCheck macro node causes graph should be schedulable
compiler/types/TestSubTypeCheckMacroTrichotomy.java: clazz.isAssignableFrom will return false for interface implementors
compiler/types/TestSubTypeCheckNewObjectNotConstant.java: C2: "assert((Value(phase) == t) || (t != TypeInt::CC_GT && t != TypeInt::CC_EQ)) failed: missing Value() optimization" still happens after fix for 8239335
compiler/types/TestSubTypeCheckUniqueSubclass.java: Test that SubTypeCheckNode takes improved unique concrete klass constant in order to fold consecutive sub type checks.
compiler/types/TestSubTypeCheckWithBottomArray.java#Xbatch: Check that SubTypeCheckNode is properly folded when having an array with bottom type elements checked against an interface.
compiler/types/TestSubTypeCheckWithBottomArray.java#Xcomp: Check that SubTypeCheckNode is properly folded when having an array with bottom type elements checked against an interface.
compiler/types/TestSubTypeCheckWithBottomArray.java#stress: Check that PartialSubtypeCheckNode is properly folded when having an array with bottom type elements checked either against an interface or an unrelated non-sub-class.
compiler/types/TestSubTypeOfAsbtractClassWrongResult.java: subtype check with abstract class that has no children classes can sometimes be constant folded
compiler/types/TestTypePropagationToCmpU.java: Test correctness of type propagation to CmpUNodes.
compiler/types/TypeSpeculation.java: Test that type speculation doesn't cause incorrect execution
compiler/types/correctness/CorrectnessTest.java: Tests correctness of type usage with type profiling and speculations
compiler/types/correctness/OffTest.java:
compiler/uncommontrap/Decompile.java: Quick test for the new WhiteBox methods of JDK-8275908
compiler/uncommontrap/DeoptReallocFailure.java:
compiler/uncommontrap/FoldedIfNonDomMidIf.java: IfNode::fold_compares() may lead to incorrect execution
compiler/uncommontrap/StackOverflowGuardPagesOff.java: stack overflow if callee is marked for deoptimization causes crash
compiler/uncommontrap/Test8009761.java: Deoptimization on sparc doesn't set Llast_SP correctly in the interpreter frames it creates
compiler/uncommontrap/TestDeoptOOM.java#Z: Test that ttyLock is ranked above StackWatermark_lock
compiler/uncommontrap/TestDeoptOOM.java#id0: failed reallocations of scalar replaced objects during deoptimization causes crash
compiler/uncommontrap/TestNullAssertAtCheckCast.java: Test that failing checkcast does not trigger repeated recompilation until cutoff is hit.
compiler/uncommontrap/TestNullCheckAntiDependence.java: Test that no anti-dependence violation is reported between a store used as an implicit null check and a load placed in the null block.
compiler/uncommontrap/TestStackBangMonitorOwned.java: Stack overflow at deoptimization doesn't release owned monitors
compiler/uncommontrap/TestStackBangRbp.java: rbp not restored when stack overflow is thrown from deopt/uncommon trap blobs
compiler/uncommontrap/TestUnstableIfTrap.java:
compiler/uncommontrap/TraceDeoptimizationNoRealloc.java: -XX:+TraceDeoptimization tries to print realloc'ed objects even when there are none
compiler/uncommontrap/UncommonTrapLeak.java: Handle leak might cause object not collected as expected
compiler/uncommontrap/UncommonTrapStackBang.java: Uncommon trap blob did not bang all the stack shadow pages
compiler/unsafe/AlignmentGapAccess.java:
compiler/unsafe/CASandCAEwithNegExpected.java: Aarch64: unsafe.compareAndSetByte() and unsafe.compareAndSetShort() c2 intrinsics broken with negative expected value
compiler/unsafe/GetUnsafeObjectG1PreBarrier.java: The bug only happens with C1 and G1 using a different ObjectAlignmentInBytes than KlassAlignmentInBytes (which is 8)
compiler/unsafe/JdkInternalMiscUnsafeAccessTestBoolean.java: Test unsafe access for boolean
compiler/unsafe/JdkInternalMiscUnsafeAccessTestByte.java: Test unsafe access for byte
compiler/unsafe/JdkInternalMiscUnsafeAccessTestChar.java: Test unsafe access for char
compiler/unsafe/JdkInternalMiscUnsafeAccessTestDouble.java: Test unsafe access for double
compiler/unsafe/JdkInternalMiscUnsafeAccessTestFloat.java: Test unsafe access for float
compiler/unsafe/JdkInternalMiscUnsafeAccessTestInt.java: Test unsafe access for int
compiler/unsafe/JdkInternalMiscUnsafeAccessTestLong.java: Test unsafe access for long
compiler/unsafe/JdkInternalMiscUnsafeAccessTestObject.java: Test unsafe access for Object
compiler/unsafe/JdkInternalMiscUnsafeAccessTestShort.java: Test unsafe access for short
compiler/unsafe/JdkInternalMiscUnsafeUnalignedAccess.java: Test unaligned Unsafe accesses
compiler/unsafe/MaybeOffHeapUnsafeAccessToNewObject.java: "failed: unexpected type" assert failure in ConnectionGraph::split_unique_types() with unsafe accesses
compiler/unsafe/MisalignedAccesses.java: Crash on aarch64 JDK due to long offset
compiler/unsafe/MismatchedUnsafeAccessTest.java:
compiler/unsafe/MismatchedUnsafeLoadFromNewObject.java: Mismatched unsafe access to non escaping object fails
compiler/unsafe/MixedUnsafeStoreObject.java:
compiler/unsafe/OpaqueAccesses.java:
compiler/unsafe/SunMiscUnsafeAccessTestBoolean.java: Test unsafe access for boolean
compiler/unsafe/SunMiscUnsafeAccessTestByte.java: Test unsafe access for byte
compiler/unsafe/SunMiscUnsafeAccessTestChar.java: Test unsafe access for char
compiler/unsafe/SunMiscUnsafeAccessTestDouble.java: Test unsafe access for double
compiler/unsafe/SunMiscUnsafeAccessTestFloat.java: Test unsafe access for float
compiler/unsafe/SunMiscUnsafeAccessTestInt.java: Test unsafe access for int
compiler/unsafe/SunMiscUnsafeAccessTestLong.java: Test unsafe access for long
compiler/unsafe/SunMiscUnsafeAccessTestObject.java: Test unsafe access for Object
compiler/unsafe/SunMiscUnsafeAccessTestShort.java: Test unsafe access for short
compiler/unsafe/TestBadBaseAddress.java: Tests compilation of an unreachable unsafe access with a bad base address.
compiler/unsafe/TestLoopUnswitching.java: loop cloning misses support for Opaque4 node
compiler/unsafe/TestMaybeNullUnsafeAccess.java: cast before unsafe access moved in dominating null check null path causes crash
compiler/unsafe/TestMisalignedUnsafeAccess.java: "assert(field != __null) failed: missing field" in TypeOopPtr::TypeOopPt(...) with misaligned unsafe accesses
compiler/unsafe/TestRawAliasing.java:
compiler/unsafe/TestSplitIf.java: cast before unsafe access moved in dominating null check null path causes crash
compiler/unsafe/TestUnsafeLoadControl.java: Unsafe load can loose control dependency and cause crash
compiler/unsafe/TestUnsafeLoadWithZeroAddress.java: Test compilation of unsafe access with zero address.
compiler/unsafe/TestUnsafeStaticFieldAccess.java: unsafe access to static field causes crash
compiler/unsafe/UnsafeArrayCopy.java: Test UNSAFE.copyMemory in combination with Escape Analysis
compiler/unsafe/UnsafeGetConstantField.java: tests on constant folding of unsafe get operations
compiler/unsafe/UnsafeGetStableArrayElement.java: tests on constant folding of unsafe get operations from stable arrays
compiler/unsafe/UnsafeOffHeapBooleanTest.java:
compiler/unsafe/UnsafeOnHeapBooleanTest.java:
compiler/unsafe/UnsafeRaw.java: Invalid pattern-matching of address computations in raw unsafe
compiler/unsafe/UnsafeSmallOffsetBooleanAccessTest.java:
compiler/vectorization/TestAbsCharVector.java: Test vectorization of Math.abs() with unsigned type
compiler/vectorization/TestAutoVecIntMinMax.java: Auto-vectorization enhancement for integer Math.max/Math.min operations
compiler/vectorization/TestBufferVectorization.java: Test vectorization for Buffer operations.
compiler/vectorization/TestCMoveWithoutBoolPack.java: Test SuperWord with a CMove that does not have a matching bool pack.
compiler/vectorization/TestComplexAddrExpr.java: Test vectorization for complex address expressions
compiler/vectorization/TestFloat16ToFloatConv.java: Test bug fix for JDK-8350835 discovered through Template Framework
compiler/vectorization/TestFloat16VectorConvChain.java: Test Float16 vector conversion chain.
compiler/vectorization/TestFloat16VectorOperations.java: Auto-vectorization support for various Float16 operations
compiler/vectorization/TestFloatConversionsVector.java: Auto-vectorize Float.floatToFloat16, Float.float16ToFloat APIs
compiler/vectorization/TestForEachRem.java: Test vectorization of Streams$RangeIntSpliterator::forEachRemaining
compiler/vectorization/TestMacroLogicVector.java:
compiler/vectorization/TestMaskedVectors.java: Test masked vectors and unsafe access to memory modified by arraycopy
compiler/vectorization/TestMemoryVectorMismatched.java:
compiler/vectorization/TestNaNVector.java: Test vectorization with a signalling NaN.
compiler/vectorization/TestNarrowedIntegerReverseBytes.java: C2: Wrong execution of vectorizing Interger.reverseBytes
compiler/vectorization/TestNumberOfContinuousZeros.java: Test vectorization of numberOfTrailingZeros/numberOfLeadingZeros for Long
compiler/vectorization/TestOffsetSorting.java: Test sorting of VPointer by offset, when subtraction of two offsets can overflow.
compiler/vectorization/TestOptionVectorize.java: Test forced vectorization
compiler/vectorization/TestOptionVectorizeIR.java: Test forced vectorization, and check IR for vector instructions
compiler/vectorization/TestOverlappingMismatchedAccesses.java:
compiler/vectorization/TestPopCountVector.java: Test vectorization of popcount
compiler/vectorization/TestPopulateIndex.java: Test vectorization of loop induction variable usage in the loop
compiler/vectorization/TestReplicateAtConv.java: Replicate node at a VectorCast (ConvL2I) causes superword to fail
compiler/vectorization/TestReplicateLoopIV.java: C2: "bad AD file" with PopulateIndex on x86_64
compiler/vectorization/TestReverseBitsVector.java: Auto-vectorization of Reverse bit operation.
compiler/vectorization/TestReverseBytes.java: Auto-vectorization of ReverseBytes operations.
compiler/vectorization/TestRotateByteAndShortVector.java: Test vectorization of rotate byte and short
compiler/vectorization/TestRoundVectFloat.java: Auto-vectorize Math.round API
compiler/vectorization/TestSignumVector.java: Accelerate Math.signum function for AVX, AVX512, aarch64 (Neon and SVE) and riscv64 (vector)
compiler/vectorization/TestSmallVectorPopIndex.java: Test bug fix for JDK-8287517 related to fuzzer test failure in x86_64
compiler/vectorization/TestSubwordReverseBytes.java: Test miscompilation of reverseBytes call from subword types
compiler/vectorization/TestSubwordTruncation.java: Ensure that truncation of subword vectors produces correct results
compiler/vectorization/TestUnexpectedLoadOrdering.java: RPO walk of counted loop block doesn't properly order loads
compiler/vectorization/TestVectorUnalignedOffset.java: Aarch64: vector nodes need to support misaligned offset
compiler/vectorization/TestVectorZeroCount.java: Ensure that vectorization of numberOfLeadingZeros and numberOfTrailingZeros outputs correct values
compiler/vectorization/TestVectorizationNegativeScale.java: [REDO] C2: crash in compiled code because of dependency on removed range check CastIIs
compiler/vectorization/TestVectorsNotSavedAtSafepoint.java: C2: Vector registers are sometimes corrupted at safepoint
compiler/vectorization/runner/ArrayCopyTest.java: Vectorization test on array copy
compiler/vectorization/runner/ArrayIndexFillTest.java: Vectorization test on array index fill
compiler/vectorization/runner/ArrayInvariantFillTest.java: Vectorization test on array invariant fill
compiler/vectorization/runner/ArrayShiftOpTest.java: Vectorization test on bug-prone shift operation
compiler/vectorization/runner/ArrayTypeConvertTest.java: Vectorization test on array type conversions
compiler/vectorization/runner/ArrayUnsafeOpTest.java: Vectorization test on array unsafe operations
compiler/vectorization/runner/BasicBooleanOpTest.java: Vectorization test on basic boolean operations
compiler/vectorization/runner/BasicByteOpTest.java: Vectorization test on basic byte operations
compiler/vectorization/runner/BasicCharOpTest.java: Vectorization test on basic char operations
compiler/vectorization/runner/BasicDoubleOpTest.java: Vectorization test on basic double operations
compiler/vectorization/runner/BasicFloatOpTest.java: Vectorization test on basic float operations
compiler/vectorization/runner/BasicIntOpTest.java: Vectorization test on basic int operations
compiler/vectorization/runner/BasicLongOpTest.java: Vectorization test on basic long operations
compiler/vectorization/runner/BasicShortOpTest.java: Vectorization test on basic short operations
compiler/vectorization/runner/LoopArrayIndexComputeTest.java: Vectorization test on loop array index computation
compiler/vectorization/runner/LoopCombinedOpTest.java: Vectorization test on combined operations
compiler/vectorization/runner/LoopControlFlowTest.java: Vectorization test on simple control flow in loop
compiler/vectorization/runner/LoopLiveOutNodesTest.java: Vectorization test on loops with live out nodes
compiler/vectorization/runner/LoopRangeStrideTest.java: Vectorization test on different loop ranges and strides
compiler/vectorization/runner/LoopReductionOpTest.java: Vectorization test on reduction operations
compiler/vectorization/runner/MultipleLoopsTest.java: Vectorization test on multiple loops in a method
compiler/vectorization/runner/StripMinedLoopTest.java: Vectorization test with small strip mining iterations
gc/ArraySize.java: Allocating a ridiculously large array should not crash the VM
gc/CondCardMark/Basic.java: Verify UseCondCardMark works
gc/InfiniteList.java: Check if the VM properly throws OutOfMemoryError
gc/TestAgeOutput.java#id0:
gc/TestAgeOutput.java#id1: Check that collectors using age table based aging print an age table even for the first garbage collection
gc/TestAllocHumongousFragment.java#compact: Make sure Shenandoah can recover from humongous allocation fragmentation
gc/TestAllocHumongousFragment.java#generational: Make sure Shenandoah can recover from humongous allocation fragmentation
gc/TestAllocHumongousFragment.java#passive: Make sure Shenandoah can recover from humongous allocation fragmentation
gc/TestAllocateHeapAt.java: Test to check allocation of Java Heap with AllocateHeapAt option
gc/TestAllocateHeapAtError.java: Test to check correct handling of non-existent directory passed to AllocateHeapAt option
gc/TestAllocateHeapAtMultiple.java: Test to check allocation of Java Heap with AllocateHeapAt option.
gc/TestAlwaysPreTouchBehavior.java#Epsilon: tests AlwaysPreTouch
gc/TestAlwaysPreTouchBehavior.java#G1: tests AlwaysPreTouch
gc/TestAlwaysPreTouchBehavior.java#ParallelCollector: tests AlwaysPreTouch
gc/TestAlwaysPreTouchBehavior.java#SerialCollector: tests AlwaysPreTouch
gc/TestAlwaysPreTouchBehavior.java#Shenandoah: tests AlwaysPreTouch
gc/TestAlwaysPreTouchBehavior.java#Z: tests AlwaysPreTouch
gc/TestBigObj.java: ensure gc updates references > 64K bytes from the start of the obj
gc/TestCardTablePageCommits.java: Tests that the card table does not commit the same page twice
gc/TestConcurrentGCBreakpoints.java: Test of WhiteBox concurrent GC control.
gc/TestDisableExplicitGC.java: Verify GC behavior with DisableExplicitGC flag.
gc/TestFillerObjectInstantiation.java: Test that GC filler objects can not be instantiated by Java programs.
gc/TestFullGCCount.java: JMM GC counters overcount in some cases
gc/TestGenerationPerfCounter.java#id0: Tests that the sun.gc.policy.generations returns 2 for all GCs.
gc/TestGenerationPerfCounter.java#id1: Tests that the sun.gc.policy.generations returns 2 for all GCs.
gc/TestGenerationPerfCounter.java#id2: Tests that the sun.gc.policy.generations returns 2 for all GCs.
gc/TestHumongousReferenceObject.java#id0: Test that verifies that iteration over large, plain Java objects, that potentially cross region boundaries, with references in them works.
gc/TestHumongousReferenceObject.java#id1: Test that verifies that iteration over large, plain Java objects, that potentially cross region boundaries on G1, with references in them works.
gc/TestHumongousReferenceObject.java#id2: Test that verifies that iteration over large, plain Java objects, that potentially cross region boundaries, with references in them works.
gc/TestJNICriticalStressTest.java#id0: Check that Full GC calls are not ignored if concurrent with an active GCLocker.
gc/TestJNICriticalStressTest.java#id1:
gc/TestJNICriticalStressTest.java#id2:
gc/TestJNIWeak/TestJNIWeak.java: Test return of JNI weak global refs during concurrent marking, verifying the use of the load barrier to keep the referent alive.
gc/TestMemoryMXBeansAndPoolsPresence.java#id0: Tests that GarbageCollectorMXBeans and GC MemoryPools are created.
gc/TestMemoryMXBeansAndPoolsPresence.java#id1: Tests that GarbageCollectorMXBeans and GC MemoryPools are created.
gc/TestMemoryMXBeansAndPoolsPresence.java#id2: Tests that GarbageCollectorMXBeans and GC MemoryPools are created.
gc/TestNUMAPageSize.java: Make sure that start up with NUMA support does not cause problems.
gc/TestNoPerfCounter.java: Tests that disabling perf counters does not crash the VM
gc/TestNumWorkerOutput.java: Check that when PrintGCDetails is enabled, gc,task output is printed only once per collection.
gc/TestObjectAlignment.java: G1: Concurrent marking crashes with -XX:ObjectAlignmentInBytes>=32 in 64bit VMs
gc/TestObjectAlignmentCardSize.java: Test to check correct handling of ObjectAlignmentInBytes and GCCardSizeInBytes combinations
gc/TestPLABAdaptToMinTLABSize.java#id0: Make sure that Young/OldPLABSize adapt to MinTLABSize setting.
gc/TestPLABAdaptToMinTLABSize.java#id1: Make sure that Young/OldPLABSize adapt to MinTLABSize setting.
gc/TestPolicyNamePerfCounter.java#id0: Tests that sun.gc.policy.name returns expected values for different GCs.
gc/TestPolicyNamePerfCounter.java#id1: Tests that sun.gc.policy.name returns expected values for different GCs.
gc/TestPolicyNamePerfCounter.java#id2: Tests that sun.gc.policy.name returns expected values for different GCs.
gc/TestReferenceClearDuringMarking.java:
gc/TestReferenceClearDuringReferenceProcessing.java#Z:
gc/TestReferenceRefersTo.java:
gc/TestReferenceRefersToDuringConcMark.java:
gc/TestSmallHeap.java: Verify that starting the VM with a small heap works
gc/TestSoftReferencesBehaviorOnOOME.java: Tests that all SoftReferences has been cleared at time of OOM.
gc/TestSpaceCounters.java#Parallel: Verify the expected space counters exist.
gc/TestSpaceCounters.java#Serial: Verify the expected space counters exist.
gc/TestStackOverflow.java: Test verifies only that VM doesn't crash but throw expected Error.
gc/TestSystemGC.java#G1: Runs System.gc() with different flags.
gc/TestSystemGC.java#Parallel: Runs System.gc() with different flags.
gc/TestSystemGC.java#Serial: Runs System.gc() with different flags.
gc/TestSystemGC.java#Shenandoah: Runs System.gc() with different flags.
gc/TestSystemGC.java#Z: Runs System.gc() with different flags.
gc/TestTransparentHugePagesHeap.java#G1: Run tests with G1
gc/TestTransparentHugePagesHeap.java#Parallel: Run tests with Parallel
gc/TestTransparentHugePagesHeap.java#Serial: Run tests with Serial
gc/TestUseGCOverheadLimit.java#G1: Verifies that the UseGCOverheadLimit functionality works in G1 GC.
gc/TestVerifyDuringStartup.java: Simple test run with -XX:+VerifyDuringStartup -XX:-UseTLAB to verify 8010463
gc/TestVerifySilently.java: Test silent verification.
gc/TestVerifySubSet.java: Test VerifySubSet option
gc/arguments/TestAggressiveHeap.java: Test argument processing for -XX:+AggressiveHeap.
gc/arguments/TestAlignmentToUseLargePages.java#id0:
gc/arguments/TestAlignmentToUseLargePages.java#id1: All parallel GC variants may use large pages without the requirement that the heap alignment is large page aligned.
gc/arguments/TestAlignmentToUseLargePages.java#id2:
gc/arguments/TestAlignmentToUseLargePages.java#id3:
gc/arguments/TestCompressedClassFlags.java: Tests that VM prints a warning when -XX:CompressedClassSpaceSize is used together with -XX:-UseCompressedClassPointers
gc/arguments/TestDisableDefaultGC.java: Test that the VM complains when the default GC is disabled and no other GC is specified
gc/arguments/TestDynMaxHeapFreeRatio.java: Verify that MaxHeapFreeRatio flag is manageable
gc/arguments/TestDynMinHeapFreeRatio.java: Verify that MinHeapFreeRatio flag is manageable
gc/arguments/TestG1CompressedOops.java: Verify that the flag UseCompressedOops is updated properly
gc/arguments/TestG1ConcMarkStepDurationMillis.java: Tests argument processing for double type flag, G1ConcMarkStepDurationMillis
gc/arguments/TestG1ConcRefinementThreads.java: Tests argument processing for G1ConcRefinementThreads
gc/arguments/TestG1HeapRegionSize.java: Verify that the flag G1HeapRegionSize is updated properly
gc/arguments/TestG1HeapSizeFlags.java: Tests argument processing for initial and maximum heap size for the G1 collector
gc/arguments/TestG1PercentageOptions.java: Test argument processing of various percentage options
gc/arguments/TestG1RemSetFlags.java: Verify that the remembered set flags are updated as expected
gc/arguments/TestHeapFreeRatio.java: Test parsing of -Xminf and -Xmaxf
gc/arguments/TestInitialTenuringThreshold.java: Tests argument processing for initial tenuring threshold
gc/arguments/TestMaxMinHeapFreeRatioFlags.java: Verify that heap size changes according to max and min heap free ratios.
gc/arguments/TestMaxNewSize.java#id0: Make sure that MaxNewSize always has a useful value after argument processing.
gc/arguments/TestMaxNewSize.java#id1: Make sure that MaxNewSize always has a useful value after argument processing.
gc/arguments/TestMaxNewSize.java#id2: Make sure that MaxNewSize always has a useful value after argument processing.
gc/arguments/TestMaxRAMFlags.java: Verify correct MaxHeapSize and UseCompressedOops when MaxRAM and MaxRAMPercentage are specified.
gc/arguments/TestMinAndInitialSurvivorRatioFlags.java: Verify that MinSurvivorRatio and InitialSurvivorRatio flags work
gc/arguments/TestMinInitialErgonomics.java: Test Parallel GC ergonomics decisions related to minimum and initial heap size.
gc/arguments/TestNewRatioFlag.java: Verify that heap devided among generations according to NewRatio
gc/arguments/TestNewSizeFlags.java: Verify that young gen size conforms values specified by NewSize, MaxNewSize and Xmn options
gc/arguments/TestNewSizeThreadIncrease.java: Tests argument processing for NewSizeThreadIncrease
gc/arguments/TestObjectTenuringFlags.java: Tests argument processing for NeverTenure, AlwaysTenure, and MaxTenuringThreshold
gc/arguments/TestParallelGCErgo.java: Verify ParallelGC minimum young and old ergonomics are setup correctly
gc/arguments/TestParallelGCThreads.java: Tests argument processing for ParallelGCThreads
gc/arguments/TestParallelHeapSizeFlags.java: Tests argument processing for initial and maximum heap size for the parallel collectors.
gc/arguments/TestParallelRefProc.java: Test defaults processing for -XX:+ParallelRefProcEnabled.
gc/arguments/TestSelectDefaultGC.java: Test selection of GC when no GC option is specified
gc/arguments/TestSerialHeapSizeFlags.java: Tests argument processing for initial and maximum heap size for the Serial collector
gc/arguments/TestShrinkHeapInSteps.java: Verify that -XX:-ShrinkHeapInSteps works properly.
gc/arguments/TestSoftMaxHeapSizeFlag.java:
gc/arguments/TestSurvivorRatioFlag.java: Verify that actual survivor ratio is equal to specified SurvivorRatio value
gc/arguments/TestTargetSurvivorRatioFlag.java: Verify that option TargetSurvivorRatio affects survivor space occupancy after minor GC.
gc/arguments/TestUnrecognizedVMOptionsHandling.java: Tests handling unrecognized VM options
gc/arguments/TestUseCompressedOopsErgo.java#id0: Tests ergonomics for UseCompressedOops.
gc/arguments/TestUseCompressedOopsErgo.java#id1: Tests ergonomics for UseCompressedOops.
gc/arguments/TestUseCompressedOopsErgo.java#id2: Tests ergonomics for UseCompressedOops.
gc/arguments/TestUseCompressedOopsErgo.java#id3:
gc/arguments/TestUseCompressedOopsFlagsWithUlimit.java: Verify correct UseCompressedOops when MaxRAM and MaxRAMPercentage are specified with ulimit -v.
gc/arguments/TestUseNUMAInterleaving.java: Tests that UseNUMAInterleaving enabled for all collectors by ergonomics, on all platforms when UseNUMA feature is enabled.
gc/arguments/TestVerifyBeforeAndAfterGCFlags.java: Runs an simple application (GarbageProducer) with various combinations of -XX:{+|-}Verify{After|Before}GC flags and checks that output contain or doesn't contain expected patterns
gc/class_unloading/TestClassUnloadingDisabled.java#id0:
gc/class_unloading/TestClassUnloadingDisabled.java#id1:
gc/class_unloading/TestClassUnloadingDisabled.java#id2:
gc/class_unloading/TestClassUnloadingDisabled.java#id3:
gc/class_unloading/TestG1ClassUnloadingHWM.java: Test that -XX:-ClassUnloadingWithConcurrentMark will trigger a Full GC when more than MetaspaceSize metadata is allocated.
gc/cslocker/TestCSLocker.java: provoking GC.
gc/epsilon/TestAlignment.java#id0: Check Epsilon runs fine with (un)usual alignments
gc/epsilon/TestAlignment.java#id1: Check Epsilon TLAB options with unusual object alignment
gc/epsilon/TestAlwaysPretouch.java: Test that pre-touch works
gc/epsilon/TestArraycopyCheckcast.java: Epsilon is able to handle checkcasted array copies
gc/epsilon/TestByteArrays.java: Epsilon is able to allocate arrays, and does not corrupt their state
gc/epsilon/TestClasses.java: Epsilon is able to allocate a lot of classes, resizing Metaspace
gc/epsilon/TestDieDefault.java: Epsilon GC should die on heap exhaustion
gc/epsilon/TestDieWithHeapDump.java: Epsilon GC should die on heap exhaustion with error handler attached
gc/epsilon/TestDieWithOnError.java: Epsilon GC should die on heap exhaustion with error handler attached
gc/epsilon/TestElasticTLAB.java: Epsilon is able to work with/without elastic TLABs
gc/epsilon/TestElasticTLABDecay.java: Epsilon is able to work with/without elastic TLABs decay
gc/epsilon/TestEnoughUnusedSpace.java: Epsilon should allocates object successfully if it has enough space.
gc/epsilon/TestEpsilonEnabled.java: Basic sanity test for Epsilon
gc/epsilon/TestHelloWorld.java: Basic sanity test for Epsilon
gc/epsilon/TestLogTrace.java: Test that tracing does not crash Epsilon
gc/epsilon/TestManyThreads.java: Test allocations from many threads
gc/epsilon/TestMaxTLAB.java#id0: Check EpsilonMaxTLAB options
gc/epsilon/TestMaxTLAB.java#id1: Check EpsilonMaxTLAB options
gc/epsilon/TestMemoryPools.java: Test JMX memory pools
gc/epsilon/TestObjects.java: Epsilon is able to allocate objects, and does not corrupt their state
gc/epsilon/TestPrintHeapSteps.java: Tests -XX:EpsilonPrintHeapSteps works
gc/epsilon/TestRefArrays.java: Epsilon is able to allocate arrays, and does not corrupt their state
gc/epsilon/TestUpdateCountersSteps.java: Test EpsilonUpdateCountersStep works
gc/ergonomics/TestDynamicNumberOfGCThreads.java: Ensure that UseDynamicNumberOfGCThreads runs
gc/ergonomics/TestInitialGCThreadLogging.java: Check trace logging of initial GC threads.
gc/g1/Test2GbHeap.java: Regression test to ensure we can start G1 with 2gb heap.
gc/g1/TestCodeCacheUnloadDuringConcCycle.java: Test to make sure that code cache unloading does not hang when receiving a request to unload code cache during concurrent mark.
gc/g1/TestConcurrentSystemGC.java: Test that a System.gc() with -XX:+ExplicitGCInvokesConcurrent is *not* upgraded to STW full GC
gc/g1/TestEagerReclaimHumongousRegions.java: Test to make sure that eager reclaim of humongous objects work.
gc/g1/TestEagerReclaimHumongousRegionsLog.java: Check that G1 reports humongous eager reclaim statistics correctly.
gc/g1/TestEagerReclaimHumongousRegionsWithRefs.java: Test to make sure that eager reclaim of humongous objects that have previously been referenced by other old gen regions work.
gc/g1/TestEdenSurvivorLessThanMax.java: Check that G1 eden plus survivor max capacity after GC does not exceed maximum number of regions.
gc/g1/TestG1SkipCompaction.java: Test for JDK-8262068 Improve G1 Full GC by skipping compaction for regions with high survival ratio.
gc/g1/TestG1TraceEagerReclaimHumongousObjects.java: Ensure that the output for a G1TraceEagerReclaimHumongousObjects includes the expected necessary messages.
gc/g1/TestGCLogMessages.java: Ensure the output for a minor GC with G1 includes the expected necessary messages.
gc/g1/TestGreyReclaimedHumongousObjects.java: Test handling of marked but unscanned reclaimed humongous objects.
gc/g1/TestHumongousAllocConcurrentStart.java: G1: humongous object allocations should initiate marking cycles when necessary
gc/g1/TestHumongousAllocNearlyFullRegion.java: G1: humongous object allocations should work even when there is not enough space in the G1HeapRegion to fit a filler object.
gc/g1/TestHumongousCodeCacheRoots.java: Humongous objects may have references from the code cache
gc/g1/TestHumongousConcurrentStartUndo.java: Tests an alternating sequence of Concurrent Mark and Concurrent Undo cycles.
gc/g1/TestHumongousRemsetsMatch.java: Test to make sure that humongous object remset states are in sync
gc/g1/TestHumongousShrinkHeap.java: Verify that heap shrinks after GC in the presence of fragmentation due to humongous objects
gc/g1/TestMarkStackOverflow.java: Finalizing objects may create new concurrent marking work during reference processing.
gc/g1/TestMarkStackSizes.java: Consistency checks for marking flag related options.
gc/g1/TestMixedGCLiveThreshold.java#0percent: Test G1MixedGCLiveThresholdPercent=0.
gc/g1/TestMixedGCLiveThreshold.java#100percent: Test G1MixedGCLiveThresholdPercent=100.
gc/g1/TestMixedGCLiveThreshold.java#25percent: Test G1MixedGCLiveThresholdPercent=25.
gc/g1/TestNoEagerReclaimOfHumongousRegions.java: Test to check that a live humongous object is not eagerly reclaimed.
gc/g1/TestOneEdenRegionAfterGC.java: Test that on a very small heap g1 with very little data (smaller than region size) will use at least one eden region after gc to avoid full gcs.
gc/g1/TestPLABOutput.java: Check that G1 does not report empty PLAB statistics in the first evacuation.
gc/g1/TestPLABSizeBounds.java: Regression test to ensure that G1 supports PLAB sizes of half a region size.
gc/g1/TestParallelAlwaysPreTouch.java: Regression test to ensure AlwaysPreTouch with multiple threads works at mutator time.
gc/g1/TestPeriodicCollection.java: Verify that heap shrinks when the application is idle.
gc/g1/TestPeriodicCollectionJNI.java: Test that issuing a periodic collection while the GC locker is held does not crash the VM.
gc/g1/TestPeriodicLogMessages.java: Verify that log messages are printed as expected
gc/g1/TestPrintRegionRememberedSetInfo.java: Test output of G1PrintRegionRememberedSetInfo
gc/g1/TestRegionAlignment.java: Make sure that G1 ergonomics pick a heap size that is aligned with the region size
gc/g1/TestRegionLivenessPrint.java: Make sure that G1 does not assert when printing region liveness data on a humongous continues region.
gc/g1/TestRemarkCleanupMXBean.java: Test that Remark and Cleanup are correctly reported by a GarbageCollectorMXBean
gc/g1/TestRemsetLogging.java: Verify output of -Xlog:gc+remset*=trace
gc/g1/TestRemsetLoggingPerRegion.java: Verify output of -Xlog:gc+remset*=trace in regards to per-region type output
gc/g1/TestRemsetLoggingThreads.java: Ensure that various values of worker threads/concurrent refinement threads do not crash the VM.
gc/g1/TestSharedArchiveWithPreTouch.java: Verifies that dumping and loading a CDS archive succeeds with AlwaysPreTouch
gc/g1/TestShrinkAuxiliaryDataRunner.java: Checks that decommitment occurs for JVM with different ObjectAlignmentInBytes values
gc/g1/TestShrinkDefragmentedHeap.java: Verify that heap shrinks after GC in the presence of fragmentation due to humongous objects 1.
gc/g1/TestShrinkToOneRegion.java: Shrinking the heap down to one region used to hit an assert
gc/g1/TestSkipRebuildRemsetPhase.java: Skip Rebuild Remset Phase if the Remark pause does not identify any rebuild candidates.
gc/g1/TestVerificationInConcurrentCycle.java#id1: Basic testing of various GC pause verification during the G1 concurrent cycle.
gc/g1/TestVerifyGCType.java: Test the VerifyGCType flag to ensure basic functionality.
gc/g1/humongousObjects/TestHumongousClassLoader.java: Checks that unreachable classes and unreachable humongous class loader are unloaded after GC
gc/g1/humongousObjects/TestHumongousMovement.java: Checks that Humongous objects are not moved during GC
gc/g1/humongousObjects/TestHumongousNonArrayAllocation.java: Checks that huge class' instances (ie with huge amount of fields) are allocated successfully
gc/g1/humongousObjects/TestHumongousThreshold.java: Checks that objects larger than half a region are allocated as humongous
gc/g1/humongousObjects/TestNoAllocationsInHRegions.java: Checks that no additional allocations are made in humongous regions
gc/g1/humongousObjects/TestObjectCollected.java: checks that after different type of GCs weak/soft references to humongous object behave correspondingly to actual object behavior
gc/g1/ihop/TestIHOPStatic.java: Test checks concurrent cycle initiation which depends on IHOP value.
gc/g1/mixedgc/TestLogging.java: Check that a mixed GC is reflected in the gc logs
gc/g1/mixedgc/TestOldGenCollectionUsage.java: G1 Old Gen's CollectionUsage.used is zero after mixed GC which is incorrect
gc/g1/numa/TestG1NUMATouchRegions.java: Ensure the bottom of the given heap regions are properly touched with requested NUMA id.
gc/g1/pinnedobjs/TestDroppedRetainedTAMS.java: Check that TAMSes are correctly updated for regions dropped from the retained collection set candidates during a Concurrent Start pause.
gc/g1/pinnedobjs/TestPinnedHumongousFragmentation.java: Make sure G1 can handle humongous allocation fragmentation with region pinning in the mix, i.e.
gc/g1/pinnedobjs/TestPinnedObjectsEvacuation.java: Test pinned objects lifecycle from young gen to eventual reclamation.
gc/g1/pinnedobjs/TestPinnedOldObjectsEvacuation.java: Test pinned objects lifecycle from old gen to eventual reclamation.
gc/g1/plab/TestPLABEvacuationFailure.java: Checks PLAB statistics on evacuation/allocation failure
gc/g1/plab/TestPLABPromotion.java: Test PLAB promotion
gc/g1/plab/TestPLABResize.java: Test for PLAB resizing
gc/logging/TestDeprecatedPrintFlags.java: Verify PrintGC, PrintGCDetails and -Xloggc
gc/logging/TestGCId.java: Ensure that the GCId is logged
gc/logging/TestMetaSpaceLog.java: Ensure that the Metaspace is updated in the log
gc/logging/TestPrintReferences.java: Validate the reference processing logging
gc/metaspace/TestMetaspaceInitialization.java: Tests to initialize metaspace with a very low MetaspaceSize
gc/metaspace/TestMetaspaceMemoryPool.java: Tests that a MemoryPoolMXBeans is created for metaspace and that a MemoryManagerMXBean is created.
gc/metaspace/TestMetaspacePerfCounters.java#Epsilon-64: Tests that performance counters for metaspace and compressed class space exists and works.
gc/metaspace/TestMetaspacePerfCounters.java#G1-64: Tests that performance counters for metaspace and compressed class space exists and works.
gc/metaspace/TestMetaspacePerfCounters.java#Parallel-64: Tests that performance counters for metaspace and compressed class space exists and works.
gc/metaspace/TestMetaspacePerfCounters.java#Serial-64: Tests that performance counters for metaspace and compressed class space exists and works.
gc/metaspace/TestMetaspacePerfCounters.java#Shenandoah-64: Tests that performance counters for metaspace and compressed class space exists and works.
gc/metaspace/TestMetaspaceSizeFlags.java: Test that metaspace size flags can be set correctly
gc/metaspace/TestPerfCountersAndMemoryPools.java#id0: Tests that a MemoryPoolMXBeans and PerfCounters for metaspace report the same data.
gc/metaspace/TestSizeTransitions.java#id0: Tests that the metaspace size transition logging is done correctly.
gc/metaspace/TestSizeTransitions.java#id1: Tests that the metaspace size transition logging is done correctly.
gc/metaspace/TestSizeTransitions.java#id2: Tests that the metaspace size transition logging is done correctly.
gc/parallel/TestDynShrinkHeap.java: Verify that the heap shrinks after full GC according to the current values of the Min/MaxHeapFreeRatio flags
gc/parallel/TestPrintGCDetailsVerbose.java: Tests that jvm with maximally verbose GC logging does not crash when ParOldGC has no memory
gc/serial/HeapChangeLogging.java: Allocate to get a promotion failure and verify that that heap change logging is present.
gc/shenandoah/TestAllocIntArrays.java#adaptive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocIntArrays.java#aggressive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocIntArrays.java#compact: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocIntArrays.java#generational: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocIntArrays.java#no-tlab: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocIntArrays.java#passive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocIntArrays.java#static: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#adaptive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#aggressive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#compact: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#generational: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#no-tlab: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#passive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjectArrays.java#static: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#adaptive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#aggressive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#compact: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#generational: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#passive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestAllocObjects.java#static: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestArrayCopyCheckCast.java#default:
gc/shenandoah/TestArrayCopyCheckCast.java#generational:
gc/shenandoah/TestArrayCopyStress.java#default:
gc/shenandoah/TestArrayCopyStress.java#generational:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#generational:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#generational-softMaxHeapSizeValidation:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#passive:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#satb-adaptive:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#satb-aggressive:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#satb-compact:
gc/shenandoah/TestDynamicSoftMaxHeapSize.java#satb-static:
gc/shenandoah/TestEvilSyncBug.java#default: Tests for crash/assert when attaching init thread during shutdown
gc/shenandoah/TestGCThreadGroups.java#default: Test Shenandoah GC uses concurrent/parallel threads correctly
gc/shenandoah/TestGCThreadGroups.java#generational: Test Shenandoah GC uses concurrent/parallel threads correctly
gc/shenandoah/TestGCThreadGroups.java#passive: Test Shenandoah GC uses concurrent/parallel threads correctly
gc/shenandoah/TestHeapUncommit.java#adaptive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestHeapUncommit.java#default-lp:
gc/shenandoah/TestHeapUncommit.java#generational: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestHeapUncommit.java#passive: Acceptance tests: collector can withstand allocation
gc/shenandoah/TestJcmdHeapDump.java#adaptive:
gc/shenandoah/TestJcmdHeapDump.java#aggressive:
gc/shenandoah/TestJcmdHeapDump.java#compact:
gc/shenandoah/TestJcmdHeapDump.java#generational:
gc/shenandoah/TestJcmdHeapDump.java#passive:
gc/shenandoah/TestJcmdHeapDump.java#static:
gc/shenandoah/TestLargeObjectAlignment.java#default: Shenandoah crashes with -XX:ObjectAlignmentInBytes=16
gc/shenandoah/TestLargeObjectAlignment.java#generational: Shenandoah crashes with -XX:ObjectAlignmentInBytes=16
gc/shenandoah/TestLotsOfCycles.java#adaptive:
gc/shenandoah/TestLotsOfCycles.java#aggressive:
gc/shenandoah/TestLotsOfCycles.java#compact:
gc/shenandoah/TestLotsOfCycles.java#generational:
gc/shenandoah/TestLotsOfCycles.java#passive:
gc/shenandoah/TestLotsOfCycles.java#static:
gc/shenandoah/TestObjItrWithHeapDump.java: Test heap dump triggered heap object iteration
gc/shenandoah/TestPeriodicGC.java: Test that periodic GC is working
gc/shenandoah/TestReferenceRefersToShenandoah.java#generational:
gc/shenandoah/TestReferenceRefersToShenandoah.java#generational-100:
gc/shenandoah/TestReferenceRefersToShenandoah.java#satb:
gc/shenandoah/TestReferenceRefersToShenandoah.java#satb-100:
gc/shenandoah/TestReferenceShortcutCycle.java#generational-100:
gc/shenandoah/TestReferenceShortcutCycle.java#satb-100:
gc/shenandoah/TestRefprocSanity.java#default: Test that null references/referents work fine
gc/shenandoah/TestRefprocSanity.java#generational: Test that null references/referents work fine
gc/shenandoah/TestRegionSampling.java#adaptive:
gc/shenandoah/TestRegionSampling.java#aggressive:
gc/shenandoah/TestRegionSampling.java#compact:
gc/shenandoah/TestRegionSampling.java#generational:
gc/shenandoah/TestRegionSampling.java#passive:
gc/shenandoah/TestRegionSampling.java#static:
gc/shenandoah/TestRegionSamplingLogging.java#default-rotation:
gc/shenandoah/TestRegionSamplingLogging.java#generational-rotation:
gc/shenandoah/TestResizeTLAB.java#adaptive: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestResizeTLAB.java#aggressive: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestResizeTLAB.java#compact: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestResizeTLAB.java#generational: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestResizeTLAB.java#passive: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestResizeTLAB.java#static: Test that Shenandoah is able to work with(out) resizeable TLABs
gc/shenandoah/TestRetainObjects.java#adaptive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#aggressive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#compact: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#generational: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#no-tlab: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#passive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestRetainObjects.java#static: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestShenandoahRegionLogging.java:
gc/shenandoah/TestSieveObjects.java#adaptive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#aggressive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#compact: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#generational: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#no-tlab: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#passive: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSieveObjects.java#static: Acceptance tests: collector can deal with retained objects
gc/shenandoah/TestSmallHeap.java#default:
gc/shenandoah/TestSmallHeap.java#generational:
gc/shenandoah/TestStringDedup.java#default: Test Shenandoah string deduplication implementation
gc/shenandoah/TestStringDedup.java#generational: Test Shenandoah string deduplication implementation
gc/shenandoah/TestStringDedup.java#passive: Test Shenandoah string deduplication implementation
gc/shenandoah/TestStringInternCleanup.java#default: Check that Shenandoah cleans up interned strings
gc/shenandoah/TestStringInternCleanup.java#generational: Check that Shenandoah cleans up interned strings
gc/shenandoah/TestStringInternCleanup.java#passive: Check that Shenandoah cleans up interned strings
gc/shenandoah/TestVerifyJCStress.java#default: Tests that we pass at least one jcstress-like test with all verification turned on
gc/shenandoah/TestVerifyJCStress.java#passive: Tests that we pass at least one jcstress-like test with all verification turned on
gc/shenandoah/TestVerifyLevels.java#default:
gc/shenandoah/TestVerifyLevels.java#generational:
gc/shenandoah/TestWithLogLevel.java#default: Test Shenandoah with different log levels
gc/shenandoah/TestWithLogLevel.java#generational: Test Shenandoah with different log levels
gc/shenandoah/TestWrongArrayMember.java:
gc/shenandoah/compiler/BarrierInInfiniteLoop.java: Shenandoah: assert(mem == __null) failed: only one safepoint
gc/shenandoah/compiler/CallMultipleCatchProjs.java: barrier expansion breaks if barrier is right after call to rethrow stub
gc/shenandoah/compiler/FoldIfAfterExpansion.java: CTW: C2 (Shenandoah) compilation fails with "Range check dependent CastII node was not removed"
gc/shenandoah/compiler/LRBRightAfterMemBar.java: Shenandoah: assert(_base == Tuple) failure during C2 compilation
gc/shenandoah/compiler/TestBadRawMemoryAfterCall.java: Shenandoah: "graph should be schedulable" assert failure
gc/shenandoah/compiler/TestBarrierAboveProj.java: assert(_base == Tuple) failed: Not a Tuple after JDK-8280799
gc/shenandoah/compiler/TestBarrierExpandCallProjection.java: Shenandoah: crash in CallNode::extract_projections
gc/shenandoah/compiler/TestBarrierExpansionDeadMemPhi.java: C2 failures after JDK-8255000
gc/shenandoah/compiler/TestBarrierOnLoopBackedge.java: Barrier expanded on backedge break loop verification code
gc/shenandoah/compiler/TestC1ArrayCopyNPE.java: test C1 arraycopy intrinsic
gc/shenandoah/compiler/TestC1VectorizedMismatch.java: test C1 vectorized mismatch intrinsic
gc/shenandoah/compiler/TestClone.java#aggressive: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#default: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#default-verify: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#generational: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#generational-no-coops: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#generational-no-coops-verify: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#generational-small-card-size: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#generational-verify: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#no-coops: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#no-coops-aggressive: Test clone barriers work correctly
gc/shenandoah/compiler/TestClone.java#no-coops-verify: Test clone barriers work correctly
gc/shenandoah/compiler/TestLinkToNativeRBP.java: guarantee(loc != NULL) failed: missing saved register with native invoke
gc/shenandoah/compiler/TestLoadBypassesNullCheck.java: C2/Shenandoah: SEGV in compiled code when running jcstress
gc/shenandoah/compiler/TestLoadPinnedAfterCall.java: CTW: C2 (Shenandoah) compilation fails with SEGV due to unhandled catchproj == NUL
gc/shenandoah/compiler/TestLostAntiDependencyAtExpansion.java: C2/Shenandoah: incorrect execution with Unsafe
gc/shenandoah/compiler/TestMaybeNullUnsafeAccess.java: cast before unsafe access moved in dominating null check null path causes crash
gc/shenandoah/compiler/TestNullCheck.java: implicit null check on brooks pointer must not cause crash
gc/shenandoah/compiler/TestReferenceCAS.java#default: Shenandoah reference CAS test
gc/shenandoah/compiler/TestReferenceCAS.java#generational: Shenandoah reference CAS test
gc/shenandoah/compiler/TestReferenceCAS.java#generational-no-coops: Shenandoah reference CAS test
gc/shenandoah/compiler/TestReferenceCAS.java#no-coops: Shenandoah reference CAS test
gc/shenandoah/compiler/TestShenandoahCmpPAfterCall.java: Shenandoah: C2 assertion fails in Matcher::collect_null_checks
gc/shenandoah/compiler/TestShenandoahLRBInOuterStripMinedLoop.java: CTW: C2 (Shenandoah) compilation fails with SEGV in SBC2Support::pin_and_expand
gc/shenandoah/compiler/TestSinkingNodeDropsNotNullCast.java: Sinking node may cause required cast to be dropped
gc/shenandoah/compiler/TestUnsafeLoadStoreMergedHeapStableTests.java: fusion of heap stable test causes GetAndSet node to be removed
gc/shenandoah/compiler/TestUnsafeOffheapSwap.java: Miscompilation in Unsafe off-heap swap routines
gc/shenandoah/generational/TestConcurrentEvac.java: Confirm that card marking and remembered set scanning do not crash.
gc/shenandoah/generational/TestOldGrowthTriggers.java: Test that growth of old-gen triggers old-gen marking
gc/shenandoah/generational/TestSimpleGenerational.java: Confirm that card marking and remembered set scanning do not crash.
gc/shenandoah/jni/TestJNICritical.java#default: test JNI critical arrays support in Shenandoah
gc/shenandoah/jni/TestJNICritical.java#generational: test JNI critical arrays support in Shenandoah
gc/shenandoah/jni/TestJNIGlobalRefs.java#aggressive: Test JNI Global Refs with Shenandoah
gc/shenandoah/jni/TestJNIGlobalRefs.java#aggressive-verify: Test JNI Global Refs with Shenandoah
gc/shenandoah/jni/TestJNIGlobalRefs.java#generational: Test JNI Global Refs with Shenandoah
gc/shenandoah/jni/TestJNIGlobalRefs.java#generational-verify: Test JNI Global Refs with Shenandoah
gc/shenandoah/jni/TestPinnedGarbage.java#aggressive: Test that garbage in the pinned region does not crash VM
gc/shenandoah/jni/TestPinnedGarbage.java#generational: Test that garbage in the pinned region does not crash VM
gc/shenandoah/jni/TestPinnedGarbage.java#passive: Test that garbage in the pinned region does not crash VM
gc/shenandoah/jni/TestPinnedGarbage.java#verify: Test that garbage in the pinned region does not crash VM
gc/shenandoah/jvmti/TestHeapDump.java#aggressive: Tests JVMTI heap dumps
gc/shenandoah/jvmti/TestHeapDump.java#aggressive-strdedup: Tests JVMTI heap dumps
gc/shenandoah/jvmti/TestHeapDump.java#generational: Tests JVMTI heap dumps
gc/shenandoah/jvmti/TestHeapDump.java#generational-strdedup: Tests JVMTI heap dumps
gc/shenandoah/jvmti/TestHeapDump.java#no-coops-aggressive: Tests JVMTI heap dumps
gc/shenandoah/jvmti/TestHeapDump.java#no-coops-generational: Tests JVMTI heap dumps
gc/shenandoah/mxbeans/TestChurnNotifications.java#adaptive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestChurnNotifications.java#aggressive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestChurnNotifications.java#compact: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestChurnNotifications.java#generational: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestChurnNotifications.java#passive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestChurnNotifications.java#static: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestMemoryMXBeans.java#default: Test JMX memory beans
gc/shenandoah/mxbeans/TestMemoryMXBeans.java#generational: Test JMX memory beans
gc/shenandoah/mxbeans/TestMemoryPools.java#default: Test JMX memory pools
gc/shenandoah/mxbeans/TestMemoryPools.java#generational: Test JMX memory pools
gc/shenandoah/mxbeans/TestPauseNotifications.java#adaptive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestPauseNotifications.java#aggressive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestPauseNotifications.java#compact: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestPauseNotifications.java#generational: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestPauseNotifications.java#passive: Check that MX notifications are reported for all cycles
gc/shenandoah/mxbeans/TestPauseNotifications.java#static: Check that MX notifications are reported for all cycles
gc/shenandoah/oom/TestAllocOutOfMemory.java#heap: Test allocation of a heap-sized object results in OOM, but will not crash the JVM
gc/shenandoah/oom/TestAllocOutOfMemory.java#large: Test allocation of large objects results in OOM, but will not crash the JVM
gc/shenandoah/oom/TestAllocOutOfMemory.java#small: Test allocation of small objects results in OOM, but will not crash the JVM
gc/shenandoah/oom/TestClassLoaderLeak.java: Test OOME in due to classloader leak
gc/shenandoah/oom/TestThreadFailure.java: Test OOME in separate thread is recoverable
gc/shenandoah/options/TestAlwaysPreTouch.java: Check that Shenandoah's AlwaysPreTouch does not fire asserts
gc/shenandoah/options/TestArgumentRanges.java: Test that Shenandoah arguments are checked for ranges where applicable
gc/shenandoah/options/TestClassUnloadingArguments.java: Test that loop mining arguments are sane
gc/shenandoah/options/TestEnabled.java#default:
gc/shenandoah/options/TestExplicitGC.java: Test that Shenandoah reacts to explicit GC flags appropriately
gc/shenandoah/options/TestExplicitGCNoConcurrent.java: Test that Shenandoah reacts to explicit GC flags appropriately
gc/shenandoah/options/TestHeuristicsUnlock.java: Test that Shenandoah heuristics are unlocked properly
gc/shenandoah/options/TestHumongousMoves.java: Check Shenandoah reacts on setting humongous moves correctly
gc/shenandoah/options/TestLargePages.java#default:
gc/shenandoah/options/TestLargePages.java#lp:
gc/shenandoah/options/TestLargePages.java#thp:
gc/shenandoah/options/TestLargePagesWithSmallHeap.java#default: when heap is too small for regions to align to large page size, should fallback to regular page size
gc/shenandoah/options/TestLargePagesWithSmallHeap.java#lp:
gc/shenandoah/options/TestLargePagesWithSmallHeap.java#thp:
gc/shenandoah/options/TestLoopMiningArguments.java: Test that loop mining arguments are sane
gc/shenandoah/options/TestModeUnlock.java: Test that Shenandoah modes are unlocked properly
gc/shenandoah/options/TestObjectAlignment.java#16b:
gc/shenandoah/options/TestObjectAlignment.java#default:
gc/shenandoah/options/TestPacing.java:
gc/shenandoah/options/TestParallelRegionStride.java:
gc/shenandoah/options/TestRegionSizeArgs.java: Test that Shenandoah region size args are checked
gc/shenandoah/options/TestSelectiveBarrierFlags.java#id0: Test selective barrier enabling works, by aggressively compiling HelloWorld with combinations of barrier flags
gc/shenandoah/options/TestSelectiveBarrierFlags.java#id1: Test selective barrier enabling works, by aggressively compiling HelloWorld with combinations of barrier flags
gc/shenandoah/options/TestSingleThreaded.java: test single worker threaded Shenandoah
gc/shenandoah/options/TestSoftMaxHeapSize.java: Test that Shenandoah checks SoftMaxHeapSize
gc/shenandoah/options/TestThreadCounts.java: Test that Shenandoah GC thread counts are handled well
gc/shenandoah/options/TestThreadCountsOverride.java: Test that Shenandoah GC thread counts are overridable
gc/shenandoah/options/TestWrongBarrierDisable.java: Test that disabling wrong barriers fails early
gc/shenandoah/options/TestWrongBarrierEnable.java: Test that SATB barrier may be enabled for all modes
gc/stringdedup/TestStringDeduplicationAgeThreshold.java#G1: Test string deduplication age threshold
gc/stringdedup/TestStringDeduplicationAgeThreshold.java#Parallel: Test string deduplication age threshold
gc/stringdedup/TestStringDeduplicationAgeThreshold.java#Serial: Test string deduplication age threshold
gc/stringdedup/TestStringDeduplicationAgeThreshold.java#Shenandoah: Test string deduplication age threshold
gc/stringdedup/TestStringDeduplicationAgeThreshold.java#Z: Test string deduplication age threshold
gc/stringdedup/TestStringDeduplicationFullGC.java#G1: Test string deduplication during full GC
gc/stringdedup/TestStringDeduplicationFullGC.java#Parallel: Test string deduplication during full GC
gc/stringdedup/TestStringDeduplicationFullGC.java#Serial: Test string deduplication during full GC
gc/stringdedup/TestStringDeduplicationFullGC.java#Shenandoah: Test string deduplication during full GC
gc/stringdedup/TestStringDeduplicationFullGC.java#Z: Test string deduplication during full GC
gc/stringdedup/TestStringDeduplicationInterned.java#G1: Test string deduplication of interned strings
gc/stringdedup/TestStringDeduplicationInterned.java#Parallel: Test string deduplication of interned strings
gc/stringdedup/TestStringDeduplicationInterned.java#Serial: Test string deduplication of interned strings
gc/stringdedup/TestStringDeduplicationInterned.java#Shenandoah: Test string deduplication of interned strings
gc/stringdedup/TestStringDeduplicationInterned.java#Z: Test string deduplication of interned strings
gc/stringdedup/TestStringDeduplicationPrintOptions.java#G1: Test string deduplication print options
gc/stringdedup/TestStringDeduplicationPrintOptions.java#Parallel: Test string deduplication print options
gc/stringdedup/TestStringDeduplicationPrintOptions.java#Serial: Test string deduplication print options
gc/stringdedup/TestStringDeduplicationPrintOptions.java#Shenandoah: Test string deduplication print options
gc/stringdedup/TestStringDeduplicationPrintOptions.java#Z: Test string deduplication print options
gc/stringdedup/TestStringDeduplicationTableResize.java#G1: Test string deduplication table resize
gc/stringdedup/TestStringDeduplicationTableResize.java#Parallel: Test string deduplication table resize
gc/stringdedup/TestStringDeduplicationTableResize.java#Serial: Test string deduplication table resize
gc/stringdedup/TestStringDeduplicationTableResize.java#Shenandoah: Test string deduplication table resize
gc/stringdedup/TestStringDeduplicationTableResize.java#Z: Test string deduplication table resize
gc/stringdedup/TestStringDeduplicationYoungGC.java#G1: Test string deduplication during young GC
gc/stringdedup/TestStringDeduplicationYoungGC.java#Parallel: Test string deduplication during young GC
gc/stringdedup/TestStringDeduplicationYoungGC.java#Serial: Test string deduplication during young GC
gc/stringdedup/TestStringDeduplicationYoungGC.java#Shenandoah: Test string deduplication during young GC
gc/stringdedup/TestStringDeduplicationYoungGC.java#Z: Test string deduplication during young GC
gc/whitebox/TestWBGC.java: Test to verify that WB methods isObjectInOldGen and youngGC work correctly.
gc/z/TestAllocateHeapAt.java: Test ZGC with -XX:AllocateHeapAt
gc/z/TestAllocateHeapAtWithHugeTLBFS.java: Test ZGC with -XX:AllocateHeapAt and -XX:+UseLargePages
gc/z/TestAlwaysPreTouch.java: Test ZGC parallel pre-touch
gc/z/TestGarbageCollectorMXBean.java: Test ZGC garbage collector MXBean
gc/z/TestMappedCacheHarvest.java: Test ZGC mapped cache harvesting
gc/z/TestMemoryMXBean.java: Test ZGC heap memory MXBean
gc/z/TestMemoryManagerMXBean.java: Test ZGC memory manager MXBean
gc/z/TestNoUncommit.java: Test ZGC uncommit unused memory disabled
gc/z/TestRelocateInPlace.java: Test ZGC in-place relocateion
gc/z/TestSmallHeap.java: Test ZGC with small heaps
gc/z/TestUncommit.java: Test ZGC uncommit unused memory
gc/z/TestZMediumPageSizes.java: Test TestZMediumPageSizes heap reservation / commits interactions.
gtest/GTestWrapper.java: a jtreg wrapper for gtest tests
gtest/LargePageGtests.java#use-large-pages: Run metaspace-related gtests for reclaim policy none (with verifications)
gtest/LargePageGtests.java#use-large-pages-1G: Run metaspace-related gtests for reclaim policy none (with verifications)
gtest/LockStackGtests.java: Run LockStack gtests with LockingMode=2
gtest/MetaspaceGtests.java#no-ccs: Run metaspace-related gtests with compressed class pointers off
gtest/NMTGtests.java#nmt-detail: Run NMT-related gtests with detailed statistics
gtest/NMTGtests.java#nmt-off: Run NMT-related gtests with NMT switched off
gtest/NMTGtests.java#nmt-summary: Run NMT-related gtests with summary statistics
runtime/6294277/SourceDebugExtension.java: verify that the JVM doesn't crash when SourceDebugExtension attribute is larger than 64K
runtime/6626217/bug_21227.java: Loader-constraint table allows arrays instead of only the base-classes
runtime/6981737/Test6981737.java: check for correct vm properties
runtime/7100935/TestConjointAtomicArraycopy.java: verify that oops are copied element-wise atomic
runtime/7100935/TestShortArraycopy.java: verify that shorts are copied element-wise atomic.
runtime/7158988/FieldMonitor.java: verify jvm does not crash while debugging
runtime/7160757/Test7160757.java: Tests that superclass initialization is not skipped
runtime/7162488/TestUnrecognizedVmOption.java: VM should print unrecognized -XX option
runtime/7167069/PrintAsFlag.java: verify that Flag::print_as_flag() works correctly.
runtime/8007320/ConstMethodTest.java: Test all optional fields in ConstMethod
runtime/8010389/VMThreadDlopen.java:
runtime/8024804/RegisterNatives.java: interface method resolution should skip finding j.l.Object's registerNatives() and succeed in selecting class B's registerNatives()
runtime/AccModule/ACCModule52.java: Test that the JVM ignores ACC_MODULE if it is set for a version 52 class file.
runtime/AccModule/ConstModule.java: Test scenarios for constant pool CONSTANT_Module and CONSTANT_Package types, for class file versions 53 and 52, when ACC_MODULE is set and not set in the access_flags.
runtime/Annotations/TestAnnotatedStringEncoding.java: Tests the correct encoding of latin1/UTF16 Strings used in annotations.
runtime/Annotations/TestBadAnnotations.java: Check that malformed annotations don't cause crashes
runtime/BadObjectClass/BootstrapRedefine.java: Give error if java.lang.Object has been incompatibly overridden on the bootpath
runtime/BadObjectClass/TestUnloadClassError.java: Make sure the VM doesn't crash and throws a SecurityException if defineClass() is called on a byte buffer that parses into a invalid java.lang.Object class.
runtime/BoolReturn/JNIBooleanTest.java: [s390x] Interpreter doesn't call result handler after native calls
runtime/BoolReturn/NativeSmallIntCallsTest.java: Test native functions return booleans as 0/1 but differently than java functions
runtime/BootClassAppendProp/BootClassPathAppend.java: Uninitialized system property jdk.boot.class.path.append causes SIGSEGV
runtime/BootClassAppendProp/BootClassPathAppendProp.java:
runtime/BootClassAppendProp/GetBootClassPathAppendProp.java: Check that JVMTI GetSystemProperty API returns the right values for property jdk.boot.class.path.append.
runtime/BootClassAppendProp/SunBootClassPath.java: Make sure property sun.boot.class.path is null starting with JDK-9.
runtime/BootstrapMethod/BSMCalledTwice.java#id0:
runtime/BootstrapMethod/TestLambdaExceptionInInitializer.java:
runtime/CDSCompressedKPtrs/CDSCompressedKPtrs.java: Testing UseCompressedClassPointers with CDS
runtime/CDSCompressedKPtrs/XShareAuto.java: -Xshare:auto is the default
runtime/CheckUnhandledOops/TestOutOfMemory.java:
runtime/ClassFile/ClassAccessFlagsRawTest.java: Test getting a class's raw access flags using java.lang.Class API
runtime/ClassFile/ClassFileVersionTest.java: Test getting the class file version for java.lang.Class API
runtime/ClassFile/FormatCheckingTest.java: Ensure class name loaded by app class loader is format checked by default
runtime/ClassFile/JsrRewriting.java: JSR (jump local subroutine) rewriting can overflow memory address size variables
runtime/ClassFile/OomWhileParsingRepeatedJsr.java: Testing class file parser; specifically parsing a file with repeated JSR (jump local subroutine) bytecode command.
runtime/ClassFile/PreviewVersion.java: Check that preview minor version and --enable-preview are handled correctly.
runtime/ClassFile/TestCheckedExceptions.java: Check that having a method with an interface type in its throws clause does not cause the JVM to assert nor throw an exception.
runtime/ClassFile/UnsupportedClassFileVersion.java:
runtime/ClassInitErrors/InitExceptionUnloadTest.java: Test that the NCDFE saves the stack trace for the original exception during class initialization with ExceptionInInitializationError, and doesn't prevent the classes in the stacktrace to be unloaded.
runtime/ClassInitErrors/TestOutOfMemoryDuringInit.java: Test that when saving a class initialization failure caused by an OutOfMemoryError, that we record the OOME as the underlying cause, even if we can't create the ExceptionInInitializerError
runtime/ClassInitErrors/TestStackOverflowDuringInit.java: Test that when saving a class initialization failure caused by a StackOverflowError, that we record the SOE as the underlying cause, even if we can't create the ExceptionInInitializerError
runtime/ClassResolutionFail/ErrorsDemoTest.java: Test that tests the ResolutionErrorTable
runtime/ClassResolutionFail/TestClassResolutionFail.java: This tests that failed class resolution doesn't report different class name in detail message for the first and subsequent times
runtime/ClassUnload/ConstantPoolDependsTest.java: Create ClassLoader dependency from initiating loader to class loader through constant pool reference
runtime/ClassUnload/DictionaryDependsTest.java: Create ClassLoader dependency from initiating loader to class loader through reflection
runtime/ClassUnload/KeepAliveClass.java: This test case uses a java.lang.Class instance to keep a class alive.
runtime/ClassUnload/KeepAliveClassLoader.java: This test case uses a java.lang.ClassLoader instance to keep a class alive.
runtime/ClassUnload/KeepAliveObject.java: This test case uses a class instance to keep the class alive.
runtime/ClassUnload/KeepAliveSoftReference.java: This test case uses a java.lang.ref.SoftReference referencing a class instance to keep a class alive.
runtime/ClassUnload/SuperDependsTest.java: Create ClassLoader dependency from initiating loader to class loader through subclassing
runtime/ClassUnload/UnloadInterfaceTest.java:
runtime/ClassUnload/UnloadTest.java:
runtime/ClassUnload/UnloadTestDuringClassLoaderStatsVMOperation.java:
runtime/ClassUnload/UnloadTestWithVerifyDuringGC.java: Make sure that verification during gc does not prevent class unloading
runtime/CommandLine/BooleanFlagWithInvalidValue.java: Setting an invalid value for a bool argument should result in a useful error message
runtime/CommandLine/CompilerConfigFileWarning.java: Warn if unused .hotspot_compiler file is present
runtime/CommandLine/ConfigFileParsing.java: Improve config file parsing
runtime/CommandLine/ConfigFileWarning.java: Warn if unused .hotspot_rc file is present
runtime/CommandLine/DoubleFlagWithIntegerValue.java: Command-line flags of type double should accept integer values
runtime/CommandLine/FlagWithInvalidValue.java: Setting a flag to an invalid value should print a useful error message
runtime/CommandLine/IgnoreUnrecognizedVMOptions.java: -XX:+IgnoreUnrecognizedVMOptions should work according to the spec from JDK-8129855
runtime/CommandLine/NonBooleanFlagWithInvalidBooleanPrefix.java: Using a bool (+/-) prefix on non-bool flag should result in a useful error message
runtime/CommandLine/OptionsValidation/TestJcmdOutput.java: Verify jcmd error message for out-of-range value and for value which is not allowed by constraint.
runtime/CommandLine/OptionsValidation/TestOptionsWithRangesDynamic.java: Test writeable VM Options with ranges.
runtime/CommandLine/PrintClasses.java#id0: Test jcmd VM.classes
runtime/CommandLine/PrintClasses.java#id1: Test jcmd VM.classes with JFR
runtime/CommandLine/PrintGCApplicationConcurrentTime.java:
runtime/CommandLine/TestHexArguments.java: Make sure there is no error using hexadecimal format in vm options
runtime/CommandLine/TestLongUnrecognizedVMOption.java: Verify that JVM correctly processes very long unrecognized VM option
runtime/CommandLine/TestNullTerminatedFlags.java: Test that the VM don't allow random junk characters at the end of valid command line flags.
runtime/CommandLine/TestVMOptions.java: Test various command line options
runtime/CommandLine/TraceExceptionsTest.java: -Xlog:exceptions=info output should have the exception message - useful for ClassNotFoundExceptions especially
runtime/CommandLine/UnrecognizedProperty.java: VM should not crash with property "-D-D"
runtime/CommandLine/UnrecognizedVMOption.java: Using an unrecognized VM option should print the name of the option
runtime/CommandLine/VMAliasOptions.java: Test that various alias options correctly set the target options.
runtime/CommandLine/VMDeprecatedOptions.java: Test that various options are deprecated.
runtime/CommandLine/VMOptionWarning.java#id0: Warn if experimental vm option is used and -XX:+UnlockExperimentalVMOptions isn't specified.
runtime/CommandLine/VMOptionWarning.java#id1: Warn if diagnostic vm option is used and -XX:+UnlockDiagnosticVMOptions isn't specified.
runtime/CommandLine/VMOptionWarning.java#id2: Warn if compile command that is an alias for a diagnostic vm option is used and -XX:+UnlockDiagnosticVMOptions isn't specified.
runtime/CommandLine/VMOptionWarning.java#id3: Warn if develop vm option is used with product version of VM.
runtime/CommandLine/VMOptionsFile/TestVMOptionsFile.java: Test "-XX:VMOptionsFile" VM option
runtime/CompactStrings/TestMethodNames.java: Test method names containing Latin-1 supplement characters.
runtime/CompressedOops/CompressedClassPointers.java: Testing address of compressed class pointer space as best as possible.
runtime/CompressedOops/CompressedClassSpaceSize.java#invalid: Tests for the -XX:CompressedClassSpaceSize command line option
runtime/CompressedOops/CompressedClassSpaceSize.java#valid_large_cds: Tests for the -XX:CompressedClassSpaceSize command line option
runtime/CompressedOops/CompressedClassSpaceSize.java#valid_large_nocds: Tests for the -XX:CompressedClassSpaceSize command line option
runtime/CompressedOops/CompressedClassSpaceSize.java#valid_small: Tests for the -XX:CompressedClassSpaceSize command line option
runtime/CompressedOops/CompressedKlassPointerAndOops.java: NPG: UseCompressedClassPointers asserts with ObjectAlignmentInBytes=32
runtime/CompressedOops/ObjectAlignment.java: Tests for the -XX:ObjectAlignmentInBytes command line option
runtime/CompressedOops/UseCompressedOops.java: Tests for different combination of UseCompressedOops options
runtime/ConstantPool/BadMethodHandles.java: Adding constantTag to keep method call consistent with it.
runtime/ConstantPool/ByteFieldInitTest.java: Negative fields shorter than an int may not be sign extended in cpool but should in static field initializers.
runtime/ConstantPool/IntfMethod.java: Adding constantTag to keep method call consistent with it.
runtime/ConstantPool/TestMethodHandleConstant.java: Test that MethodHandle constants are checked
runtime/CreateMirror/ArraysNewInstanceBug.java: race in setting array_klass field for component mirror with mirror update for klass
runtime/DefineClass/NullClassBytesTest.java: Verifies DefineClass with null or truncate bytes gets appropriate exception
runtime/ElfDecoder/TestElfDirectRead.java#id0: Test reading ELF info direct from underlaying file
runtime/EnclosingMethodAttr/EnclMethodAttr.java: Check attribute_length of EnclosingMethod attribute
runtime/ErrorHandling/CreateCoredumpOnCrash.java:
runtime/ErrorHandling/GenOutOfMemoryError.java: Test if OOME has proper stacktrace
runtime/ErrorHandling/MachCodeFramesInErrorFile.java: Test that abstract machine code is dumped for the top frames in a hs-err log
runtime/ErrorHandling/PrintVMInfoAtExitTest.java: Test PrintVMInfoAtExit
runtime/ErrorHandling/ProblematicFrameTest.java: Test that error is not occurred during printing problematic frame
runtime/ErrorHandling/StackWalkNativeToJava.java: Check that walking the stack works fine when going from C++ frame to Java frame.
runtime/ErrorHandling/TestAbortVmOnException.java: Test -XX:AbortVMOnException=MyAbortException with C1 compilation
runtime/ErrorHandling/TestCrashOnOutOfMemoryError.java: Test using -XX:+CrashOnOutOfMemoryError
runtime/ErrorHandling/TestExitOnOutOfMemoryError.java: Test using -XX:ExitOnOutOfMemoryError
runtime/ErrorHandling/TestGZippedHeapDumpOnOutOfMemoryError.java#id0: Test verifies that -XX:HeapDumpGzipLevel=0 works
runtime/ErrorHandling/TestGZippedHeapDumpOnOutOfMemoryError.java#id1: Test verifies that -XX:HeapDumpGzipLevel=1 works
runtime/ErrorHandling/TestHeapDumpOnOutOfMemoryError.java#id0: Test verifies that -XX:HeapDumpOnOutOfMemoryError dumps heap when OutOfMemory is thrown in heap
runtime/ErrorHandling/TestHeapDumpOnOutOfMemoryError.java#id1: Test verifies that -XX:HeapDumpOnOutOfMemoryError dumps heap when OutOfMemory is thrown in metaspace.
runtime/ErrorHandling/TestHeapDumpPath.java: Test verifies that -XX:HeapDumpPath= supports directory as a parameter.
runtime/ErrorHandling/TestOnOutOfMemoryError.java: Test using single and multiple -XX:OnOutOfMemoryError=<cmd>
runtime/FieldLayout/BaseOffsets.java#no-coops-no-ccp:
runtime/FieldLayout/BaseOffsets.java#no-coops-with-ccp:
runtime/FieldLayout/BaseOffsets.java#no-coops-with-coh:
runtime/FieldLayout/BaseOffsets.java#with-coop--with-coh:
runtime/FieldLayout/BaseOffsets.java#with-coops-no-ccp:
runtime/FieldLayout/BaseOffsets.java#with-coops-with-ccp:
runtime/FieldLayout/FieldDensityTest.java#id0: Verify behaviour of field layout algorithm
runtime/FieldLayout/FieldDensityTest.java#id1:
runtime/FieldLayout/TestFieldLayout.java: Reversed field layout caused by unstable sorting
runtime/FieldLayout/TestOopMapSizeMinimal.java#coops_ccptr_no_coh:
runtime/FieldLayout/TestOopMapSizeMinimal.java#coops_no_ccptr_no_coh:
runtime/FieldLayout/TestOopMapSizeMinimal.java#no_coops_ccptr_coh:
runtime/FieldLayout/TestOopMapSizeMinimal.java#no_coops_ccptr_no_coh:
runtime/FieldLayout/TestOopMapSizeMinimal.java#no_coops_no_ccptr_no_coh:
runtime/FieldStream/LocalFieldLookupTest.java#defaults:
runtime/Final/PutfieldError.java: Throw ICCE rather than crashing for nonstatic final field in static initializer
runtime/Final/TestPutMain.java: The VM does not always perform checks added by 8157181 when updating final instance fields
runtime/GenerateOopMap/TestGenerateOopMapCrash.java: Test that GenerateOopMap does not crash if last bytecode is a conditional branch
runtime/HiddenClasses/CastToParentTest.java: Test that a hidden class can be cast to its parent.
runtime/HiddenClasses/DefineHiddenClass.java:
runtime/HiddenClasses/FieldInSuper.java: Test that verifer assignability checks involving the 'this' pointer work ok for hidden classes.
runtime/HiddenClasses/GCHiddenClass.java: Test that hidden classes get garbage collected.
runtime/HiddenClasses/HiddenClassStack.java: Test that stack tracing isn't broken if an exception is thrown in a hidden class.
runtime/HiddenClasses/HiddenDefMeths.java: Tests a hidden class that implements interfaces with default methods.
runtime/HiddenClasses/HiddenGetModule.java: Test that a hidden class has the same module as its lookup class.
runtime/HiddenClasses/InstantiateHiddenClass.java: Test issues with instantiating hidden classes.
runtime/HiddenClasses/NestedHidden.java: Creates a hidden class inside of a hidden class.
runtime/HiddenClasses/TestHiddenClassUnloading.java: Test unloading of hidden classes.
runtime/InnerClassesAttr/InnerClassesTest.jasm:
runtime/InternalApi/ThreadCpuTimesDeadlock.java#id0: Possible JVM deadlock in ThreadTimesClosure when using HotspotInternal non-public API.
runtime/JVMDoPrivileged/DoPrivRunAbstract.jasm: Test that AccessController.doPrivileged throws java.lang.AbstractMethodError for an abstract run() method.
runtime/JVMDoPrivileged/DoPrivileged.java: Test that AccessController.doPrivileged() searches default methods when looking for the run() method.
runtime/LoadClass/LoadClassNegative.java: make sure there is no fatal error if a class is loaded from an invalid jar file which is in the bootclasspath
runtime/LoadClass/ShowClassLoader.java: Make sure array class has the right class loader
runtime/LoadClass/TestSymlinkLoad.java: JVM should be able to handle loading class via symlink on windows
runtime/LoadLibrary/TestSunBootLibraryPath.java: Confirm using too-long paths in sun.boot.library.path causes failure and useful error message.
runtime/LoaderConstraints/differentLE/Test.java: Test exception messages of LinkageError.
runtime/LoaderConstraints/duplicateLE/Test.java: Test exception messages of LinkageError.
runtime/LoaderConstraints/duplicateParentLE/Test.java: Test exception messages of LinkageError with a parent class loader that is not known to the VM.
runtime/LoaderConstraints/itableICCE/Test.java:
runtime/LoaderConstraints/itableLdrConstraint/Test.java:
runtime/LoaderConstraints/ldrCnstrFldMsg/LdrCnstrFldMsgTest.java:
runtime/LoaderConstraints/vtableAME/Test.java:
runtime/LoaderConstraints/vtableLdrConstraint/Test.java:
runtime/LocalLong/LocalLongTest.java:
runtime/LocalVariableTable/TestLVT.java: Test ClassFileParser::copy_localvariable_table cases
runtime/Locals/TestLargeLocalVarsStackRegion.java:
runtime/MemberName/MemberNameLeak.java: MemberNameTable should reuse entries
runtime/MemberName/ResolvedMethodTableHash.java: ResolvedMethodTable hash function should take method class into account
runtime/Metaspace/DefineClass.java: Failures during class definition can lead to memory leaks in metaspace
runtime/Metaspace/FragmentMetaspace.java#id0:
runtime/Metaspace/FragmentMetaspaceSimple.java:
runtime/Metaspace/MaxMetaspaceSizeEnvVarTest.java: test that setting via the env-var and options file shows up as expected
runtime/Metaspace/MaxMetaspaceSizeTest.java:
runtime/Metaspace/PrintMetaspaceDcmd.java#test-64bit-ccs: Test the VM.metaspace command
runtime/Metaspace/PrintMetaspaceDcmd.java#test-64bit-noccs: Test the VM.metaspace command
runtime/Metaspace/PrintMetaspaceDcmd.java#test-nospecified: Test the VM.metaspace command
runtime/Metaspace/elastic/TestMetaspaceAllocation.java#ndebug:
runtime/Metaspace/elastic/TestMetaspaceAllocationMT1.java#ndebug-default:
runtime/Metaspace/elastic/TestMetaspaceAllocationMT2.java#ndebug-default:
runtime/MirrorFrame/Test8003720.java: Method in interpreter stack frame can be deallocated
runtime/Monitor/CompleteExit.java: This does a sanity test of the poll in the native wrapper.
runtime/Monitor/ConcurrentDeflation.java: Test concurrent monitor deflation by MonitorDeflationThread and thread dumping
runtime/Monitor/DeflationIntervalsTest.java#allIntervalsZero:
runtime/Monitor/DeflationIntervalsTest.java#allThresholdsZero:
runtime/Monitor/DeflationIntervalsTest.java#defaults: Test the deflation intervals options
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_noThresholdADI_noSafepoint:
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_noThresholdADI_safepoint:
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_noThresholdMUDT_noSafepoint:
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_noThresholdMUDT_safepoint:
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_threshold_noSafepoint:
runtime/Monitor/DeflationIntervalsTest.java#guaranteed_threshold_safepoint:
runtime/Monitor/DeflationIntervalsTest.java#noGuaranteedGADT_threshold_noSafepoint:
runtime/Monitor/DeflationIntervalsTest.java#noGuaranteedGADT_threshold_safepoint:
runtime/Monitor/MonitorUnlinkBatchTest.java#aggressive:
runtime/Monitor/MonitorUnlinkBatchTest.java#defaults: Test the MonitorUnlinkBatch options
runtime/Monitor/MonitorUnlinkBatchTest.java#illegal:
runtime/Monitor/MonitorUnlinkBatchTest.java#lazy:
runtime/Monitor/MonitorUnlinkBatchTest.java#legal:
runtime/Monitor/MonitorUsedDeflationThresholdTest.java: Test the MonitorUsedDeflationThreshold and NoAsyncDeflationProgressMax options.
runtime/Monitor/NonOwnerOps.java: Verify that monitor operations by a non-owner thread throw IllegalMonitorStateException.
runtime/Monitor/SyncOnValueBasedClassTest.java: Exercise DiagnoseSyncOnValueBasedClasses diagnostic flag
runtime/Monitor/TestRecursiveLocking.java#C1_alternate_AB: Tests recursive locking in C1 in alternate A and B mode.
runtime/Monitor/TestRecursiveLocking.java#C1_outer_inner: Tests recursive locking in C1 in outer then inner mode.
runtime/Monitor/TestRecursiveLocking.java#C2_alternate_AB: Tests recursive locking in C2 in alternate A and B mode.
runtime/Monitor/TestRecursiveLocking.java#C2_outer_inner: Tests recursive locking in C2 in outer then inner mode.
runtime/Monitor/TestRecursiveLocking.java#Xint_alternate_AB: Tests recursive locking in -Xint in alternate A and B mode.
runtime/Monitor/TestRecursiveLocking.java#Xint_outer_inner: Tests recursive locking in -Xint in outer then inner mode.
runtime/Monitor/UseObjectMonitorTableTest.java#ExtremeDeflation: Run the same tests but with deflation running constantly.
runtime/Monitor/UseObjectMonitorTableTest.java#NormalDeflation: A collection of small tests using synchronized, wait, notify to try and achieve good cheap coverage of UseObjectMonitorTable.
runtime/NMT/BaselineWithParameter.java: Regression test for invoking a jcmd with baseline=false, result was that the target VM crashed
runtime/NMT/CommandLineDetail.java: Running with NMT detail should not result in an error
runtime/NMT/CommandLineEmptyArgument.java: Empty argument to NMT should result in an informative error message
runtime/NMT/CommandLineInvalidArgument.java: Invalid argument to NMT should result in an informative error message
runtime/NMT/CommandLineSummary.java: Running with NMT summary should not result in an error
runtime/NMT/CommandLineTurnOffNMT.java: Turning off NMT should not result in an error
runtime/NMT/CommitOverlappingRegions.java: Test commits of overlapping regions of memory.
runtime/NMT/HugeArenaTracking.java:
runtime/NMT/JcmdBaselineDetail.java: Verify that jcmd correctly reports that baseline succeeds with NMT enabled with detailed tracking.
runtime/NMT/JcmdDetailDiff.java: run NMT baseline, allocate memory and verify output from detail.diff
runtime/NMT/JcmdScale.java: Test the NMT scale parameter
runtime/NMT/JcmdScaleDetail.java: Test the NMT scale parameter with detail tracking level
runtime/NMT/JcmdSummaryClass.java: Check class counters in summary report
runtime/NMT/JcmdSummaryDiff.java: run NMT baseline, allocate memory and verify output from summary.diff
runtime/NMT/JcmdSummaryStatistics.java: Test the NMT scale parameter
runtime/NMT/JcmdWithNMTDisabled.java: Verify that jcmd correctly reports that NMT is not enabled
runtime/NMT/MallocLimitTest.java#compiler-limit-fatal: Verify -XX:MallocLimit with a compiler-specific limit (for "mtCompiler" category)
runtime/NMT/MallocLimitTest.java#compiler-limit-oom: Verify -XX:MallocLimit with a compiler-specific limit (for "mtCompiler" category)
runtime/NMT/MallocLimitTest.java#global-limit-fatal: Verify -XX:MallocLimit with a global limit
runtime/NMT/MallocLimitTest.java#global-limit-oom: Verify -XX:MallocLimit with a global limit
runtime/NMT/MallocLimitTest.java#limit-without-nmt: Verify that the VM warns if -XX:MallocLimit is given but NMT is disabled
runtime/NMT/MallocLimitTest.java#multi-limit: Verify -XX:MallocLimit with multiple limits
runtime/NMT/MallocRoundingReportTest.java: Test consistency of NMT by creating allocations of the Test type with various sizes and verifying visibility with jcmd
runtime/NMT/MallocSiteTypeChange.java:
runtime/NMT/MallocTestType.java: Test consistency of NMT by leaking a few select allocations of the Test type and then verify visibility with jcmd
runtime/NMT/MallocTrackingVerify.java: Test to verify correctness of malloc tracking
runtime/NMT/NMTForOtherLaunchersTest.java#jar:
runtime/NMT/NMTForOtherLaunchersTest.java#javac:
runtime/NMT/NMTInitializationTest.java#default_long-detail:
runtime/NMT/NMTInitializationTest.java#default_long-off:
runtime/NMT/NMTInitializationTest.java#normal-detail:
runtime/NMT/NMTInitializationTest.java#normal-off:
runtime/NMT/NMTJavaHeapTest.java: Sanity check Java Heap size values
runtime/NMT/NMTWithCDS.java:
runtime/NMT/PeakMallocTest.java: Test to verify correctness of peak malloc tracking
runtime/NMT/PrintMemoryMapAtExitTest.java: Verify PrintMemoryMapAtExit on normal JVM exit for summary tracking level
runtime/NMT/PrintNMTStatistics.java: Verify PrintNMTStatistics on normal JVM exit for detail and summary tracking level
runtime/NMT/PrintNMTStatisticsWithNMTDisabled.java: Trying to enable PrintNMTStatistics should result in a warning
runtime/NMT/ReleaseCommittedMemory.java: Release committed memory and make sure NMT handles it correctly
runtime/NMT/ReleaseNoCommit.java: Release uncommitted memory and make sure NMT handles it correctly
runtime/NMT/SafepointPollingPages.java: NMT should report safepoint polling page(s)
runtime/NMT/SummaryDiffThreadCount.java: run NMT baseline, create threads and verify output from summary.diff
runtime/NMT/SummarySanityCheck.java: Sanity check the output of NMT
runtime/NMT/ThreadedMallocTestType.java:
runtime/NMT/ThreadedVirtualAllocTestType.java:
runtime/NMT/TotalMallocMmapDiffTest.java: Test to verify correctness of total malloc and mmap diffs
runtime/NMT/UnsafeAllocMemory.java: Unsafe.allocateMemory should be tagged as Other
runtime/NMT/VirtualAllocAttemptReserveMemoryAt.java: Test that os::attempt_reserve_memory_at doesn't register the memory as committed
runtime/NMT/VirtualAllocCommitMerge.java: Test merging of committed virtual memory and that we track it correctly
runtime/NMT/VirtualAllocCommitUncommitRecommit.java: Test reserve/commit/uncommit/release of virtual memory and that we track it correctly
runtime/NMT/VirtualAllocTestType.java: Test Reserve/Commit/Uncommit/Release of virtual memory and that we track it correctly
runtime/Nestmates/classFileParsing/TestFinalMethodOverride.java: Test nestmate checks are no longer used when check_final_method_override is executed during parsing
runtime/Nestmates/classFileParsing/TestNestmateAttributes.java: Test incorrect use of Nestmate related attributes
runtime/Nestmates/legacy/TestPrivateLookup.java: Test that private Lookup works for both nestmate-enabled classes and legacy classes
runtime/Nestmates/membership/TestDynamicNestmateMembership.java: Test the rules for dynamic nest membership using the Lookup.defineHiddenClass API
runtime/Nestmates/membership/TestNestHostErrorWithClassUnload.java: Test the ability to safely unload a class that has an error with its designated nest host.
runtime/Nestmates/membership/TestNestHostErrorWithMultiThread.java: JVM crashes when two threads encounter the same resolution error
runtime/Nestmates/membership/TestNestmateMembership.java: Test the various rules for nest members and nest-hosts by triggering nestmate access checks on all possible paths
runtime/Nestmates/methodSelection/TestInterfaceMethodSelection.java: Test interface method selection process for private/public nestmate invocation
runtime/Nestmates/methodSelection/TestMethodSelection.java: Test method selection process for private/public nestmate invocation
runtime/Nestmates/privateConstructors/TestConstructorHierarchy.java: Test access to private constructors in the hierarchy that are outside the nest
runtime/Nestmates/privateConstructors/TestInvokeSpecial.java: Test access to private constructors between nestmates and nest-host using different flavours of named nested types that will generate invokespecial for the calls.
runtime/Nestmates/privateConstructors/TestJNI.java: Test JNI access to private constructors between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/Nestmates/privateConstructors/TestMethodHandles.java: Test access to private constructors between nestmates and nest-host using different flavours of named nested types using MethodHandles
runtime/Nestmates/privateConstructors/TestReflection.java: Test access to private constructors between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/Nestmates/privateFields/TestJNI.java: Test JNI access to private fields between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateFields/TestMethodHandles.java: Test access to private fields between nestmates and nest-host using different flavours of named nested types using MethodHandles
runtime/Nestmates/privateFields/TestPrivateField.java: Test access to private fields between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateFields/TestReflection.java: Test access to private fields between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/Nestmates/privateMethods/TestInvoke.java: Test access to private methods between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateMethods/TestInvokeErrors.java: Setup nestmate calls to private methods then use modified jcod classes to introduce errors.
runtime/Nestmates/privateMethods/TestInvokeHierarchy.java: Test access to private methods between nestmates where there is an inheritance hierarchy and we invoke private methods that exist in specific classes in the hierarchy.
runtime/Nestmates/privateMethods/TestJNI.java: Test JNI access to private methods between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateMethods/TestJNIHierarchy.java: Test access to private methods between nestmates where there is an inheritance hierarchy and we invoke private methods that exist in specific classes in the hierarchy.
runtime/Nestmates/privateMethods/TestMethodHandles.java: Test access to private methods between nestmates and nest-host using different flavours of named nested types using MethodHandles
runtime/Nestmates/privateMethods/TestMethodHandlesHierarchy.java: Test access to private methods between nestmates where there is an inheritance hierarchy and we invoke private methods that exist in specific classes in the hierarchy.
runtime/Nestmates/privateMethods/TestReflection.java: Test access to private methods between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/Nestmates/privateMethods/TestReflectionHierarchy.java: Test access to private methods between nestmates where there is an inheritance hierarchy and we invoke private methods that exist in specific classes in the hierarchy.
runtime/Nestmates/privateStaticFields/TestJNI.java: Test JNI access to private static fields between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateStaticFields/TestMethodHandles.java: Test access to private static fields between nestmates and nest-host using different flavours of named nested types using MethodHandles
runtime/Nestmates/privateStaticFields/TestPrivateStaticField.java: Test access to private static fields between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateStaticFields/TestReflection.java: Test access to private static fields between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/Nestmates/privateStaticMethods/TestInvokeStatic.java: Test access to private static methods between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateStaticMethods/TestJNI.java: Test JNI access to private methods between nestmates and nest-host using different flavours of named nested types
runtime/Nestmates/privateStaticMethods/TestMethodHandles.java: Test access to private static methods between nestmates and nest-host using different flavours of named nested types using MethodHandles
runtime/Nestmates/privateStaticMethods/TestReflection.java: Test access to private static methods between nestmates and nest-host using different flavours of named nested types using core reflection
runtime/NonWriteableProperty.java: Ensure non-writeable system properties are not writeable
runtime/ParallelLoad/CallLoadClass/CallLoadClassTest.java: Call unlocked version loadClass directly, with another thread calling forName One class goes through the ClassLoader path and the other goes through JVM path
runtime/ParallelLoad/ParallelCircularity/ParallelCircularityTest.java: This is a testcase for JDK-4699981.
runtime/ParallelLoad/ParallelSuper/ParallelSuperTest.java: Call handle_parallel_super_load, loading parallel threads that throw CCE
runtime/ParallelLoad/SaveResolutionError/SaveResolutionErrorTest.java: JVMS 5.4.3 If an attempt by the Java Virtual Machine to resolve a symbolic reference fails because an error is thrown that is an instance of LinkageError (or a subclass), then subsequent attempts to resolve the reference always fail with the same error that was thrown as a result of the initial resolution attempt.
runtime/ParallelLoad/SuperWait/SuperWaitTest.java: Duplicate class loader deadlock referenced in https://openjdk.org/groups/core-libs/ClassLoaderProposal.html One thread loads (A, CL1) extends (B, CL2), while the second loads (C, CL2) extends (D, CL1)
runtime/PerfMemDestroy/PerfMemDestroy.java: Allow multiple calls to PerfMemory::destroy() without asserting.
runtime/PrintingTests/ClassfilePrintingTests.java: Test various printing functions in classfile directory
runtime/PrintingTests/StringPrinting.java: Test abridged VM String printing
runtime/ReservedStack/ReservedStackTest.java:
runtime/ReservedStack/ReservedStackTestCompiler.java: Run ReservedStackTest with dedicated compilers C1 and C2.
runtime/Safepoint/TestAbortOnVMOperationTimeout.java: Check abort on VM timeout is working
runtime/Safepoint/TestAbortVMOnSafepointTimeout.java: Check if VM can kill thread which doesn't reach safepoint, test grace period before AbortVMOnSafepointTimeout kicks in
runtime/SameObject/SameObject.java: -Xcheck:jni overly strict in JNI method IsSameObject Fixed in JDK1.3.1_10 Fixed in JDK1.4.1_07
runtime/SelectionResolution/AbstractMethodErrorTest.java: Test of method selection and resolution cases that generate AbstractMethodErrorTest
runtime/SelectionResolution/IllegalAccessErrorTest.java: Test of method selection and resolution cases that generate IllegalAccessErrorTest
runtime/SelectionResolution/InvokeInterfaceICCE.java: Test of method selection and resolution cases that generate IncompatibleClassChangeError
runtime/SelectionResolution/InvokeInterfaceSuccessTest.java: Test of method selection and resolution cases that generate InvokeInterfaceSuccessTest
runtime/SelectionResolution/InvokeSpecialICCE.java: Test of method selection and resolution cases that generate IncompatibleClassChangeError
runtime/SelectionResolution/InvokeSpecialSuccessTest.java: Test of method selection and resolution cases that generate InvokeSpecialSuccessTest
runtime/SelectionResolution/InvokeStaticICCE.java: Test of invokestatic method selection and resolution cases that generate IncompatibleClassChangeError
runtime/SelectionResolution/InvokeStaticSuccessTest.java: Test of method selection and resolution cases that generate InvokeStaticSuccessTest
runtime/SelectionResolution/InvokeVirtualICCE.java: Test of method selection and resolution cases that generate IncompatibleClassChangeError
runtime/SelectionResolution/InvokeVirtualSuccessTest.java: Test of method selection and resolution cases that generate InvokeVirtualSuccessTest
runtime/SelectionResolution/NoSuchMethodErrorTest.java: Test of method selection and resolution cases that generate NoSuchMethodError
runtime/Shutdown/ShutdownTest.java: Make MutexLocker smarter about non-Java threads
runtime/StackGap/TestStackGap.java: Linux kernel stack guard should not cause segfaults on x86-32
runtime/StackGuardPages/TestStackGuardPages.java: Stack guard pages should be installed correctly and removed when thread is detached
runtime/StackTrace/HiddenFrameTest.java: Test null source file and negative line number from hidden frame produces correct output.
runtime/StackTrace/LargeClassTest.java: JVM crashes on stack trace for large number of methods.
runtime/StackTrace/StackTraceClassCache.java: Check that stack trace contains proper strings even with class caching
runtime/StringIntrinsic/StringIndexOfChar.java: String.indexOf(char) for empty string must give -1
runtime/TLS/TestTLS.java: Test with extra TLS size.
runtime/Thread/AsyncExceptionOnMonitorEnter.java: Stress delivery of asynchronous exceptions while target is at monitorenter
runtime/Thread/AsyncExceptionTest.java: Stress delivery of asynchronous exceptions.
runtime/Thread/CancellableThreadTest.java:
runtime/Thread/Fibonacci.java: Calculates Fibonacci numbers "recursively" via threads and compares the result with the classical calculation.
runtime/Thread/InterruptAtExit.java: Stress test java.lang.Thread.interrupt() at thread exit.
runtime/Thread/IsInterruptedAtExit.java: Stress test java.lang.Thread.isInterrupted() at thread exit.
runtime/Thread/TestAlwaysPreTouchStacks.java: Test AlwaysPreTouchThreadStacks
runtime/Thread/TestBreakSignalThreadDump.java#default: Check that Ctrl-\ or Ctrl-Break (on Windows) causes HotSpot VM to print a full thread dump.
runtime/Thread/TestBreakSignalThreadDump.java#with_jsig: Check that Ctrl-\ causes HotSpot VM to print a full thread dump when signal chaining is used.
runtime/Thread/TestThreadDumpClassInitMonitor.java: Check that the thread dump shows when a thread is blocked on a class initialization monitor
runtime/Thread/TestThreadDumpSMRInfo.java: Checks whether jstack reports a "Threads class SMR info" section.
runtime/Thread/TestThreadStackSizes.java: Test user threads with various stack sizes.
runtime/Thread/ThreadObjAccessAtExit.java: Use the WhiteBox API to ensure that we can safely access the threadObj oop of a JavaThread during termination, after it has removed itself from the main ThreadsList.
runtime/Thread/ThreadPriorities.java: Creates several threads with different java priorities and checks whether jstack reports correct priorities for them.
runtime/Thread/TooSmallStackSize.java: Setting small CompilerThreadStackSize, ThreadStackSize, and VMThreadStackSize values should result in an error message that shows the minimum stack size value for each thread type.
runtime/Throwable/StackTraceLogging.java: check stacktrace logging
runtime/Throwable/TestCatchThrowableOOM.java: Test catching Throwable doesn't trigger OOME
runtime/Throwable/TestMaxJavaStackTraceDepth.java: MaxJavaStackTraceDepth of zero is not handled correctly/consistently in the VM
runtime/Throwable/TestThrowable.java: Test exception depths, and code to get stack traces
runtime/Throwable/ThrowableIntrospectionSegfault.java: check backtrace field introspection
runtime/TransitiveOverrideCFV50/TransitiveOverrideCFV50.java:
runtime/Unsafe/AllocateInstance.java: Verifies the behaviour of Unsafe.allocateInstance
runtime/Unsafe/AllocateMemory.java: Verifies behaviour of Unsafe.allocateMemory
runtime/Unsafe/CopyMemory.java: Verifies behaviour of Unsafe.copyMemory
runtime/Unsafe/DefineClass.java: Verifies the behaviour of Unsafe.defineClass
runtime/Unsafe/FieldOffset.java: Verifies the behaviour of Unsafe.fieldOffset
runtime/Unsafe/GetField.java: Verifies behaviour of Unsafe.getField
runtime/Unsafe/GetPutAddress.java:
runtime/Unsafe/GetPutBoolean.java: Verify behaviour of Unsafe.get/putBoolean
runtime/Unsafe/GetPutByte.java: Verify behaviour of Unsafe.get/putByte
runtime/Unsafe/GetPutChar.java: Verify behaviour of Unsafe.get/putChar
runtime/Unsafe/GetPutDouble.java: Verify behaviour of Unsafe.get/putDouble
runtime/Unsafe/GetPutFloat.java: Verify behaviour of Unsafe.get/putFloat
runtime/Unsafe/GetPutInt.java:
runtime/Unsafe/GetPutLong.java: Verify behaviour of Unsafe.get/putLong
runtime/Unsafe/GetPutObject.java: Verify behaviour of Unsafe.get/putObject
runtime/Unsafe/GetPutShort.java: Verify behaviour of Unsafe.get/putShort
runtime/Unsafe/GetUncompressedObject.java:
runtime/Unsafe/InternalErrorTest.java: Check that SIGBUS errors caused by memory accesses in Unsafe_CopyMemory() and UnsafeCopySwapMemory() get converted to java.lang.InternalError exceptions.
runtime/Unsafe/PageSize.java: Make sure pageSize() returns a value that is a power of two
runtime/Unsafe/Reallocate.java:
runtime/Unsafe/SetMemory.java: Verifies that setMemory works correctly
runtime/Unsafe/ThrowException.java: Verify that throwException() can throw an exception
runtime/VerifierMessages/Test7116786.java: verify that VerifyError messages are as expected
runtime/VtableTests/VTableTest.java: Check that the vTable for class C gets set up without causing an assertion failure.
runtime/XCheckJniJsig/XCheckJSig.java: Need to suppress info message if -Xcheck:jni is used with libjsig.so
runtime/cds/ArchiveDoesNotExist.java: Test how VM handles "file does not exist" situation while attempting to use CDS archive.
runtime/cds/BootAppendTests.java: Testing -Xbootclasspath/a support for CDS
runtime/cds/CDSMapTest.java: Test the contents of -Xlog:aot+map
runtime/cds/CdsDifferentCompactStrings.java: CDS (class data sharing) requires the same -XX:[+-]CompactStrings setting between archive creation time and load time.
runtime/cds/CdsDifferentObjectAlignment.java: Testing CDS (class data sharing) using varying object alignment.
runtime/cds/CdsSameObjectAlignment.java: Testing CDS (class data sharing) using varying object alignment.
runtime/cds/CheckSharingWithDefaultArchive.java: Sharing should be enabled by default on supported platform/binaries.
runtime/cds/DeterministicDump.java: The same JDK build should always generate the same archive file (no randomness).
runtime/cds/DumpSharedDictionary.java: Check that Shared Dictionary is printed out with jcmd
runtime/cds/DumpSymbolAndStringTable.java: Test jcmd VM.symboltable, VM.stringtable and VM.systemdictionary options
runtime/cds/MaxMetaspaceSize.java: Testing CDS dumping with the -XX:MaxMetaspaceSize=<size> option
runtime/cds/NonBootLoaderClasses.java: Test to ensure platform and app classes are archived when specified in classlist
runtime/cds/NonJVMVariantLocation.java: Test that CDS archive can be loaded if the archive is in a non-JVM variant directory.
runtime/cds/PrimitiveClassMirrors.java: Make sure the archived mirrors of the primitive classes have the proper module (java.base)
runtime/cds/PrintSharedArchiveAndExit.java: Testing -XX:+PrintSharedArchiveAndExit option
runtime/cds/ServiceLoaderTest.java: Make sure that the ServicesCatalogs for boot/platform/app loaders are properly archived.
runtime/cds/SharedArchiveFile.java: Testing new -XX:SharedArchiveFile=<file-name> option
runtime/cds/SharedBaseAddress.java#id0: Test variety of values for SharedBaseAddress, making sure VM handles normal values as well as edge values w/o a crash.
runtime/cds/SharedBaseAddress.java#id1: Test variety of values for SharedBaseAddress, making sure VM handles normal values as well as edge values w/o a crash.
runtime/cds/SharedBaseAddress.java#id2: Test variety of values for SharedBaseAddress, making sure VM handles normal values as well as edge values w/o a crash.
runtime/cds/SharedBaseAddress.java#id3: Test variety of values for SharedBaseAddress, making sure VM handles normal values as well as edge values w/o a crash.
runtime/cds/SharedStrings.java: Check to make sure that shared strings in the bootstrap CDS archive are actually shared
runtime/cds/SharedStringsDedup.java: Test -Xshare:auto with shared strings and -XX:+UseStringDeduplication
runtime/cds/SharedStringsRunAuto.java: Test -Xshare:auto with shared strings.
runtime/cds/SharedSymbolTableBucketSize.java: Test SharedSymbolTableBucketSize option
runtime/cds/SpaceUtilizationCheck.java: Check if the space utilization for shared spaces is adequate
runtime/cds/StaticWritingError.java: Test the writing error when archive file cannot be created
runtime/cds/TestCDSVMCrash.java: Verify that an exception is thrown when the VM crashes during executeAndLog
runtime/cds/TestDefaultArchiveLoading.java#coops_coh: Test Loading of default archives in all configurations (requires --enable-cds-archive-coh)
runtime/cds/TestDefaultArchiveLoading.java#coops_nocoh: Test Loading of default archives in all configurations
runtime/cds/TestDefaultArchiveLoading.java#nocoops_coh: Test Loading of default archives in all configurations (requires --enable-cds-archive-coh)
runtime/cds/TestDefaultArchiveLoading.java#nocoops_nocoh: Test Loading of default archives in all configurations
runtime/cds/TestInterpreterMethodEntries.java#id0: Test interpreter method entries for intrinsics with CDS (class data sharing) and the intrinsic flag enabled during dump and disabled during use of the archive.
runtime/cds/TestInterpreterMethodEntries.java#id1: Test interpreter method entries for intrinsics with CDS (class data sharing) and the intrinsic flag disabled during dump and enabled during use of the archive.
runtime/cds/appcds/AppendClasspath.java: At run time, it is OK to append new elements to the classpath that was used at dump time.
runtime/cds/appcds/ArchiveRelocationTest.java: Testing relocation of CDS archive (during both dump time and run time)
runtime/cds/appcds/BadBSM.java: CDS dump should abort if a class file contains a bad BSM.
runtime/cds/appcds/BootClassPathMismatch.java: bootclasspath mismatch test.
runtime/cds/appcds/CDSandJFR.java: Make sure CDS and JFR work together.
runtime/cds/appcds/CaseSensitiveClassPath.java: Test case sensitive aspect of comparing class paths between dump time and archive use time
runtime/cds/appcds/ClassLoaderTest.java: Initiating and defining classloader test.
runtime/cds/appcds/ClassPathAttr.java: Class-Path: attribute in MANIFEST file
runtime/cds/appcds/CommandLineFlagCombo.java: Test command line flag combinations that could likely affect the behaviour of AppCDS
runtime/cds/appcds/CommandLineFlagComboNegative.java: Test command line flag combinations that differ between the dump and execute steps, in such way that they cause errors E.g.
runtime/cds/appcds/CommonAppClasspath.java: Test app class paths checking with the longest common path taken into account.
runtime/cds/appcds/CreateAOTCacheVerifyError.java: VM should not crash during AOT cache creation when encountering a class with VerifyError.
runtime/cds/appcds/DirClasspathTest.java: Handling of directories in -cp is based on the classlist
runtime/cds/appcds/DumpClassList.java: DumpLoadedClassList should exclude generated classes, classes in bootclasspath/a and --patch-module.
runtime/cds/appcds/DumpClassListWithLF.java: Tests the format checking of LF_RESOLVE in classlist.
runtime/cds/appcds/DumpRuntimeClassesTest.java: Classes used by CDS at runtime should be in the archived
runtime/cds/appcds/DumpingWithNoCoops.java: Test CDS with UseCompressedOops disable with various heap sizes.
runtime/cds/appcds/DuplicateClassPaths.java: duplicate class paths test
runtime/cds/appcds/ExtraSymbols.java: Adding extra symbols into CDS archive using -XX:SharedArchiveConfigFile
runtime/cds/appcds/FieldAnnotationsTest.java: Test for field annotations.
runtime/cds/appcds/FieldLayoutFlags.java: VM should work even if different field layout options are chosen between dump time and run time.
runtime/cds/appcds/FillerObjectLoadTest.java: VM crash caused by unloaded FillerObject_klass
runtime/cds/appcds/FreeUnusedMetadata.java: Unused metadata created during dump time should be freed from the CDS archive.
runtime/cds/appcds/HelloExtTest.java: a simple test for loading a class using the platform class loader (which used to be called the "extension loader) in AppCDS
runtime/cds/appcds/HelloTest.java: Hello World test for AppCDS
runtime/cds/appcds/IgnoreEmptyClassPaths.java: Test the -XX:+IgnoreEmptyClassPaths flag
runtime/cds/appcds/JvmtiAddPath.java: JvmtiEnv::AddToBootstrapClassLoaderSearch and JvmtiEnv::AddToSystemClassLoaderSearch should disable AppCDS
runtime/cds/appcds/LambdaContainsOldInf.java: VM should not crash during CDS dump when a lambda proxy class contains an old version of interface.
runtime/cds/appcds/LambdaEagerInit.java: Run the LambdaEagerInitTest.java test in static CDS archive mode.
runtime/cds/appcds/LambdaInvokeVirtual.java: CDS dump crashes when member_method of a lambda proxy is null
runtime/cds/appcds/LambdaProxyClasslist.java: Test some error handling on the "@lambda-proxy" entries in a classlist.
runtime/cds/appcds/LambdaVerificationFailedDuringDump.java: Dumping of lambda proxy classes should not crash VM in case the caller class has failed verification.
runtime/cds/appcds/LambdaWithJavaAgent.java: Test static dumping with java agent transforming a class loaded by the boot class loader.
runtime/cds/appcds/LambdaWithOldClass.java: VM should not crash during CDS dump and run time when a lambda expression references an old version of class.
runtime/cds/appcds/LambdaWithUseImplMethodHandle.java: CDS cannot archive lambda proxy with useImplMethodHandle
runtime/cds/appcds/LongClassListPath.java: Test the handling of long path to the classlist file.
runtime/cds/appcds/LotsOfJRTClasses.java: Try to archive lots of classes by searching for classes from the jrt:/ file system.
runtime/cds/appcds/LotsOfSyntheticClasses.java: Try to archive lots and lots of classes.
runtime/cds/appcds/MismatchedPathTriggerMemoryRelease.java: Mismatched path at runtime will cause reserved memory released
runtime/cds/appcds/MissingSuperTest.java: When super class is missing during dumping, no crash should happen.
runtime/cds/appcds/MoveJDKTest.java: Test that CDS still works when the JDK is moved to a new directory
runtime/cds/appcds/MultiProcessSharing.java: Run multiple processes with the same archive, ensure they share
runtime/cds/appcds/MultiReleaseJars.java: Test multi-release jar with AppCDS.
runtime/cds/appcds/NestHostOldInf.java: A lambda proxy class should not be archived if its nest host implements an old (with major version < JDK_6 (50)) interface which cannot be verified during dump time.
runtime/cds/appcds/NonExistClasspath.java: Handling of non-existent classpath elements during dump time and run time
runtime/cds/appcds/NonJarInClasspath.java: Non jar file in the classpath will be skipped during dump time and runtime.
runtime/cds/appcds/OldClassTest.java: CDS support of old classes with major version < JDK_6 (50) for static archive.
runtime/cds/appcds/OldClassWithjsr.java: CDS support of old classes with major version < JDK_6 (50) for static archive.
runtime/cds/appcds/OldInfExtendsInfDefMeth.java: CDS support of old classes with major version < JDK_6 (50) for static archive.
runtime/cds/appcds/OldSuperClass.java: CDS support of old classes with major version < JDK_6 (50) for static archive.
runtime/cds/appcds/OldSuperInf.java: CDS support of old classes with major version < JDK_6 (50) for static archive.
runtime/cds/appcds/OldSuperInfIndirect.java: CDS support of old classes with major version < JDK_6 (50) for static archive.
runtime/cds/appcds/PackageSealing.java: AppCDS handling of package.
runtime/cds/appcds/ParallelLoad2.java: Load app classes from CDS archive in parallel threads.
runtime/cds/appcds/ParallelLoadTest.java: Load app classes from CDS archive in parallel threads
runtime/cds/appcds/PrintSharedArchiveAndExit.java: test the -XX:+PrintSharedArchiveAndExit flag
runtime/cds/appcds/ProhibitedPackage.java: AppCDS handling of prohibited package.
runtime/cds/appcds/ProtectionDomain.java: AppCDS handling of protection domain.
runtime/cds/appcds/RelativePath.java: Test relative paths specified in the -cp.
runtime/cds/appcds/RewriteBytecodesTest.java: Use Lookup.defineClass() to load a class with rewritten bytecode.
runtime/cds/appcds/SealingViolation.java: A jar file containing classes in the same package.
runtime/cds/appcds/SharedArchiveConsistency.java: SharedArchiveConsistency
runtime/cds/appcds/SharedBaseAddress.java: Test variety of values for SharedBaseAddress, in AppCDS mode, making sure VM handles normal values as well as edge values w/o a crash.
runtime/cds/appcds/SharedPackages.java: AppCDS handling of package.
runtime/cds/appcds/SharedRegionAlignmentTest.java: Testing handling of CDS region alignment
runtime/cds/appcds/SignedJar.java: AppCDS handling of signed JAR.
runtime/cds/appcds/SpecifySysLoaderProp.java: If -Djava.system.class.loader=xxx is specified in command-line, disable archived non-system classes
runtime/cds/appcds/StaticArchiveWithLambda.java: Sanity test lambda proxy classes in static CDS archive.
runtime/cds/appcds/TestCombinedCompressedFlags.java: Testing different combination of CompressedOops and CompressedClassPointers
runtime/cds/appcds/TestDumpClassListSource.java: test dynamic dump meanwhile output loaded class list
runtime/cds/appcds/TestEpsilonGCWithCDS.java#id0:
runtime/cds/appcds/TestEpsilonGCWithCDS.java#id1:
runtime/cds/appcds/TestParallelGCWithCDS.java#id0:
runtime/cds/appcds/TestParallelGCWithCDS.java#id1:
runtime/cds/appcds/TestSerialGCWithCDS.java#id0:
runtime/cds/appcds/TestSerialGCWithCDS.java#id1:
runtime/cds/appcds/TestShenandoahWithCDS.java#id0:
runtime/cds/appcds/TestShenandoahWithCDS.java#id1:
runtime/cds/appcds/TestWithProfiler.java: After creating an AppCDS archive, run the test with the JFR profiler enabled, and keep calling a method in the archive in a tight loop.
runtime/cds/appcds/TestZGCWithCDS.java:
runtime/cds/appcds/TraceLongClasspath.java: ensure -Xlog:class+path showing entire expecting app classpath
runtime/cds/appcds/TransformInterfaceOfLambda.java: Transforming an interface of an archived lambda proxy class should not crash the VM.
runtime/cds/appcds/UnusedCPDuringDump.java: non-empty dir in -cp should be fine during dump time if only classes from the system modules are being loaded even though some are defined to the PlatformClassLoader and AppClassLoader.
runtime/cds/appcds/VerifierTest_0.java: Unverfiable app classes should not be archived.
runtime/cds/appcds/VerifierTest_1A.java: Unverfiable app classes should not be archived.
runtime/cds/appcds/VerifierTest_1B.java: Unverfiable app classes should not be archived.
runtime/cds/appcds/VerifierTest_2.java: Unverfiable app classes should not be archived.
runtime/cds/appcds/VerifyObjArrayCloneTest.java:
runtime/cds/appcds/VerifyWithDefaultArchive.java: test default cds archive when turning on VerifySharedSpaces
runtime/cds/appcds/WideIloadTest.java: Test 'iload_w' bytecode in shared class
runtime/cds/appcds/WrongClasspath.java: classpath mismatch between dump time and execution time
runtime/cds/appcds/XShareAutoWithChangedJar.java: Test -Xshare:auto for AppCDS
runtime/cds/appcds/aotCache/AOTCacheSupportForCustomLoaders.java: Test AOT cache support for array classes in custom class loaders.
runtime/cds/appcds/aotCache/AOTCompileEagerly.java: Sanity-check that eager compilation flags are accepted
runtime/cds/appcds/aotCache/AOTLoggingTag.java: when AOT cache options are used, old "cds" logs should be aliased to "aot".
runtime/cds/appcds/aotCache/ClassPathLogging.java: verify the output of -Xlog:class+path when using AOT cache
runtime/cds/appcds/aotCache/CloseSystemOut.java: AOT configuration should not be corrupted even if the app closes System.out in the training run
runtime/cds/appcds/aotCache/DiagnosticCommandMBeanTest.java: Sanity test for DiagnosticCommand MBean ability to invoke AOT.end_recording
runtime/cds/appcds/aotCache/ExcludedClasses.java: Test how various AOT optimizations handle classes that are excluded from the AOT cache.
runtime/cds/appcds/aotCache/HelloAOTCache.java: Sanity test for AOTCache
runtime/cds/appcds/aotCache/JNIDefineClass.java: classes defined with JNI DefineClass should be excluded from the AOT config file and AOT cache.
runtime/cds/appcds/aotCache/JavaAgent.java: -javaagent should be allowed in AOT workflow.
runtime/cds/appcds/aotCache/JcmdAOTEndRecordingTest.java: Sanity test for Jcmd AOT.end_recording command
runtime/cds/appcds/aotCache/ManagementAgent.java: ManagementAgent will not be started during AOT cache creation.
runtime/cds/appcds/aotCache/PackageInfoClass.java: AOT cache handling for package-info class loaded by jdk/internal/loader/ClassLoaders$BootClassLoader
runtime/cds/appcds/aotCache/SpecialCacheNames.java: Use special characters in the name of the cache file specified by -XX:AOTCacheOutput Make sure these characters are passed to the child JVM process that assembles the cache.
runtime/cds/appcds/aotCache/VerifierFailOver.java: Sanity test for AOTCache
runtime/cds/appcds/aotClassLinking/AOTCacheWithZGC.java: -XX:AOTMode=create should be compatible with ZGC
runtime/cds/appcds/aotClassLinking/AOTClassLinkingVMOptions.java: Disable CDS when incompatible options related to AOTClassLinking are used
runtime/cds/appcds/aotClassLinking/AOTLoaderConstraintsTest.java:
runtime/cds/appcds/aotClassLinking/AddExports.java: Identical --add-exports switches can be used across training/assembly/production
runtime/cds/appcds/aotClassLinking/AddOpens.java: sanity test the --add-opens option
runtime/cds/appcds/aotClassLinking/AddReads.java: sanity test the --add-reads option
runtime/cds/appcds/aotClassLinking/BulkLoaderTest.java#aot:
runtime/cds/appcds/aotClassLinking/BulkLoaderTest.java#dynamic:
runtime/cds/appcds/aotClassLinking/BulkLoaderTest.java#static:
runtime/cds/appcds/aotClassLinking/FakeCodeLocation.java:
runtime/cds/appcds/aotClassLinking/LambdaInExcludedClass.java:
runtime/cds/appcds/aotClassLinking/NonFinalStaticWithInitVal.java: Handling of non-final static string that has an initial value
runtime/cds/appcds/aotClassLinking/StringConcatStress.java#aot:
runtime/cds/appcds/aotClassLinking/StringConcatStress.java#static:
runtime/cds/appcds/aotClassLinking/TestSetupAOTTest.java: This is a test case for creating an AOT cache using the setup_aot/TestSetupAOT.java program, which is used for running HotSpot tests in the "AOT mode" (E.g., make test JTREG=AOT_JDK=true TEST=open/test/hotspot/jtreg/runtime/invokedynamic)
runtime/cds/appcds/aotClassLinking/TrainingRun.java: -XX:AOTMode=record should not interfere with app execution: (1) thread creation; (2) exit code
runtime/cds/appcds/aotCode/AOTCodeCompressedOopsTest.java: Sanity test of AOT Code Cache with compressed oops configurations
runtime/cds/appcds/aotCode/AOTCodeFlags.java: Sanity test of combinations of the AOT Code Caching diagnostic flags
runtime/cds/appcds/aotFlags/AOTFlags.java: "AOT" aliases for traditional CDS command-line options
runtime/cds/appcds/aotFlags/FileNameSubstitution.java: substitution of %p/%t in AOTCache/AOTCacheOutput/AOTConfiguration
runtime/cds/appcds/aotFlags/JDK_AOT_VM_OPTIONS.java: JDK_AOT_VM_OPTIONS environment variable
runtime/cds/appcds/aotProfile/AOTProfileFlags.java: Sanity test of combinations of the diagnostic flags [+-]AOTRecordTraining and [+-]AOTReplayTraining
runtime/cds/appcds/applications/JavacBench.java#aot: Run JavacBenchApp with AOT cache (JEP 483)
runtime/cds/appcds/applications/JavacBench.java#dynamic: Run JavacBenchApp with the classic dynamic archive workflow
runtime/cds/appcds/applications/JavacBench.java#static: Run JavacBenchApp with the classic static archive workflow
runtime/cds/appcds/cacheObject/ArchivedIntegerCacheTest.java: Test primitive box caches integrity in various scenarios (IntegerCache etc)
runtime/cds/appcds/cacheObject/ArchivedModuleCompareTest.java: Compare archived system modules with non-archived.
runtime/cds/appcds/cacheObject/ArchivedModuleWithCustomImageTest.java: Test archived module graph with custom runtime image
runtime/cds/appcds/cacheObject/DifferentHeapSizes.java: Test automatic relocation of archive heap regions dur to heap size changes.
runtime/cds/appcds/cacheObject/DumpTimeVerifyFailure.java: Dump time should not crash if any class with shared strings fails verification due to missing dependencies.
runtime/cds/appcds/cacheObject/HeapFragmentationTest.java: Relocate CDS archived regions to the top of the G1 heap
runtime/cds/appcds/cacheObject/MirrorWithReferenceFieldsTest.java: Test archived mirror with reference fields
runtime/cds/appcds/cacheObject/OpenArchiveRegion.java: Test open archive heap regions
runtime/cds/appcds/cacheObject/RedefineClassTest.java: Redefine shared class.
runtime/cds/appcds/cacheObject/VerifyArchivedFields.java: run with -XX:VerifyArchivedFields=2 for more expensive verification of the archived heap objects.
runtime/cds/appcds/complexURI/ComplexURITest.java: Verifies that CDS works with jar located in directories with names that need escaping
runtime/cds/appcds/condy/CondyHelloTest.java: Make sure CDS works with a minimal test case that uses a CONSTANT_Dynamic constant-pool entry
runtime/cds/appcds/customLoader/ClassFromSystemModule.java: Test dumping of class from a system module loaded by a custom loader.
runtime/cds/appcds/customLoader/ClassListFormatA.java: Tests the format checking of class list format.
runtime/cds/appcds/customLoader/ClassListFormatB.java: Tests the format checking of hotspot/src/closed/share/vm/classfile/classListParser.cpp.
runtime/cds/appcds/customLoader/ClassListFormatC.java: Tests the format checking of hotspot/src/closed/share/vm/classfile/classListParser.cpp.
runtime/cds/appcds/customLoader/ClassListFormatD.java: Tests the format checking of hotspot/src/closed/share/vm/classfile/classListParser.cpp.
runtime/cds/appcds/customLoader/ClassListFormatE.java: Tests the format checking of hotspot/src/closed/share/vm/classfile/classListParser.cpp.
runtime/cds/appcds/customLoader/CustomClassListDump.java: -XX:DumpLoadedClassList should support custom loaders
runtime/cds/appcds/customLoader/DifferentSourcesTest.java: Tests archiving a hierarchy of package-private classes loaded from different sources.
runtime/cds/appcds/customLoader/HelloCustom.java: Hello World test for AppCDS custom loader support
runtime/cds/appcds/customLoader/HelloCustom_JFR.java: Same as HelloCustom, but add -XX:StartFlightRecording:dumponexit=true to the runtime options.
runtime/cds/appcds/customLoader/LoaderSegregationTest.java: Check that during dumping, the classes for BOOT/EXT/APP loaders are segregated from the custom loader classes.
runtime/cds/appcds/customLoader/OldClassAndInf.java: Test archiving of old class and interface with custom loader.
runtime/cds/appcds/customLoader/ParallelTestMultiFP.java: Load classes from CDS archive into multiple custom loader using parallel threads
runtime/cds/appcds/customLoader/ParallelTestSingleFP.java: Load classes from CDS archive into a single custom loader using parallel threads (finger print)
runtime/cds/appcds/customLoader/PrintSharedArchiveAndExit.java: test -XX:+PrintSharedArchiveAndExit output for shared class.
runtime/cds/appcds/customLoader/ProhibitedPackageNamesTest.java: Make sure prohibited packages cannot be stored into archive for custom loaders.
runtime/cds/appcds/customLoader/ProtectionDomain.java: AppCDS handling of protection domain in custom loaders.
runtime/cds/appcds/customLoader/RegUnregSuperTest.java#reg: If an unregistered class U is specified to have a registered supertype S1 named SN but an unregistered class S2 also named SN has already been loaded S2 will be incorrectly used as the supertype of U instead of S1 due to limitations in the loading mechanism of unregistered classes.
runtime/cds/appcds/customLoader/RegUnregSuperTest.java#unreg: Tests that if a super class is listed as unregistered it is archived as such even if a class with the same name has also been loaded from the classpath.
runtime/cds/appcds/customLoader/SameNameInTwoLoadersTest.java: Testing the loading of a class with the same name in two different class loaders.
runtime/cds/appcds/customLoader/UnintendedLoadersTest.java: Make sure classes intended for custom loaders cannot be loaded by BOOT/EXT/APP loaders
runtime/cds/appcds/customLoader/UnloadUnregisteredLoaderTest.java: Test the behavior when shared classes loaded by custom loaders are unloaded.
runtime/cds/appcds/customLoader/UnsupportedPlatforms.java: Ensure that support for AppCDS custom class loaders are not enabled on unsupported platforms.
runtime/cds/appcds/dynamicArchive/AppendClasspath.java: At run time, it is OK to append new elements to the classpath that was used at dump time.
runtime/cds/appcds/dynamicArchive/ArchiveConsistency.java: Corrupt the header CRC fields of the top archive.
runtime/cds/appcds/dynamicArchive/ArchivedSuperIf.java: An archived super interface should be accessible by the class which implements the interface during runtime although the class itself is not in the CDS archive.
runtime/cds/appcds/dynamicArchive/ArrayKlasses.java: handling of the existence of InstanceKlass::array_klasses()
runtime/cds/appcds/dynamicArchive/BasicLambdaTest.java: Basic operations of Lambda class archiving.
runtime/cds/appcds/dynamicArchive/CDSStreamTestDriver.java: Run the CustomFJPoolTest in dynamic CDSarchive mode.
runtime/cds/appcds/dynamicArchive/ClassResolutionFailure.java: Test with a jar file which contains only the main class but not the dependent class.
runtime/cds/appcds/dynamicArchive/CommonAppClasspath.java: Test app class paths checking with the longest common path taken into account.
runtime/cds/appcds/dynamicArchive/DoubleSumAverageTest.java:
runtime/cds/appcds/dynamicArchive/DumpToDefaultArchive.java: VM should exit with an error message if the specified dynamic archive is the same as the default CDS archive.
runtime/cds/appcds/dynamicArchive/DuplicatedCustomTest.java: Handling of duplicated classes in dynamic archive with custom loader
runtime/cds/appcds/dynamicArchive/DynamicArchiveRelocationTest.java: Testing relocation of dynamic CDS archive (during both dump time and run time)
runtime/cds/appcds/dynamicArchive/DynamicLambdaWithUseImplMethodHandle.java: CDS cannot archive lambda proxy with useImplMethodHandle
runtime/cds/appcds/dynamicArchive/DynamicLotsOfClasses.java: Try to archive lots of classes by searching for classes from the jrt:/ file system.
runtime/cds/appcds/dynamicArchive/DynamicSharedSymbols.java: Test dumping of dynamic shared symbols using jcmd
runtime/cds/appcds/dynamicArchive/ExcludedClasses.java: Unreferenced app classes during dump time should not be included in the archive.
runtime/cds/appcds/dynamicArchive/ExitRaceTest.java: Test the exit race for dynamic dumping at exit
runtime/cds/appcds/dynamicArchive/HelloDynamic.java: Hello World test for dynamic archive
runtime/cds/appcds/dynamicArchive/HelloDynamicCustom.java: Hello World test for dynamic archive with custom loader
runtime/cds/appcds/dynamicArchive/HelloDynamicCustomUnload.java: Hello World test for dynamic archive with custom loader.
runtime/cds/appcds/dynamicArchive/JFRDynamicCDS.java: Test dynamic CDS with JFR recording.
runtime/cds/appcds/dynamicArchive/JITInteraction.java: Test interaction with JIT threads during vm exit.
runtime/cds/appcds/dynamicArchive/LambdaContainsOldInf.java: VM should not crash during CDS dump when a lambda proxy class contains an old version of interface.
runtime/cds/appcds/dynamicArchive/LambdaCustomLoader.java: Lambda proxy class loaded by a custom class loader will not be archived.
runtime/cds/appcds/dynamicArchive/LambdaForClassInBaseArchive.java: Archive an base app class in a base archive and its lambda proxy class in a dynamic archive.
runtime/cds/appcds/dynamicArchive/LambdaForOldInfInBaseArchive.java: Archive an old interface in the base archive and an app class which uses the old interface via a lambda expression in the dynamic archive.
runtime/cds/appcds/dynamicArchive/LambdaInBaseArchive.java: Archive lambda proxy class is in the base archive.
runtime/cds/appcds/dynamicArchive/LambdaProxyCallerIsHidden.java: If the caller class of a lambda proxy class is a hidden class, the lambda proxy class will not be archived.
runtime/cds/appcds/dynamicArchive/LambdaProxyDuringShutdown.java: VM should not crash if a lambda proxy class is created during shutdown and its nest host is not linked.
runtime/cds/appcds/dynamicArchive/LambdasInTwoArchives.java: Test archiving of lambda proxy classes with the same LambdaProxyClassKey (see cds/lambdaProxyClassDictionary.hpp).
runtime/cds/appcds/dynamicArchive/LinkClassTest.java: Classes loaded by the builtin class loaders should be linked during dynamic CDS dump time.
runtime/cds/appcds/dynamicArchive/LotsUnloadTest.java: Lots of classes being unloaded while we try to dump a dynamic archive
runtime/cds/appcds/dynamicArchive/MainModuleOnly.java: Test some scenarios with a main modular jar specified in the --module-path and -cp options in the command line.
runtime/cds/appcds/dynamicArchive/MethodSorting.java: When HelloA and HelloB are copied into the dynamic archive, the Symbols for their method's names will have a different sorting order.
runtime/cds/appcds/dynamicArchive/MismatchedBaseArchive.java: The base archive used for dynamic dump is not the same as the one used during run time.
runtime/cds/appcds/dynamicArchive/MissingArchive.java: error handling when either (or both) of the base/top archives are missing.
runtime/cds/appcds/dynamicArchive/ModularJarWithNonExistentJar.java: This test defines an application module using the DefineModuleApp.
runtime/cds/appcds/dynamicArchive/ModulePath.java: Dyanmic archive with module path
runtime/cds/appcds/dynamicArchive/NestHostOldInf.java: A lambda proxy class should not be archived if its nest host implements an old (with major version < JDK_6 (50)) interface which cannot be verified during dump time.
runtime/cds/appcds/dynamicArchive/NestTest.java: Archive a lambda proxy class created from a nested class.
runtime/cds/appcds/dynamicArchive/NoClassToArchive.java: A few edge cases where there's no class to be included in the dynamic archive.
runtime/cds/appcds/dynamicArchive/OldClassAndInf.java: Test archiving of old class and interface with custom loader with dynamic CDS.
runtime/cds/appcds/dynamicArchive/OldClassInBaseArchive.java: Archive an old class in the base archive and an app class which uses the old class in the dynamic archive.
runtime/cds/appcds/dynamicArchive/OldClassVerifierTrouble.java: Archive an old class, which fails verification and is a supertype of another class, in the base archive.
runtime/cds/appcds/dynamicArchive/ParallelLambdaLoadTest.java: Test parallel loading of lambda proxy classes.
runtime/cds/appcds/dynamicArchive/PredicateTest.java:
runtime/cds/appcds/dynamicArchive/PrintSharedArchiveAndExit.java: Hello World test for dynamic archive with custom loader
runtime/cds/appcds/dynamicArchive/RedefineCallerClassTest.java: If the caller class is redefined during dump time, the caller class and its lambda proxy class should not be archived.
runtime/cds/appcds/dynamicArchive/RegularHiddenClass.java: Hidden class not of type lambda proxy class will not be archived.
runtime/cds/appcds/dynamicArchive/RelativePath.java: Test relative paths specified in the -cp.
runtime/cds/appcds/dynamicArchive/SharedArchiveFileOption.java: Some negative tests for the SharedArchiveFile option
runtime/cds/appcds/dynamicArchive/SharedBaseAddressOption.java: Test how the dynamic archive handles -XX:SharedBaseAddress
runtime/cds/appcds/dynamicArchive/StaticInnerTest.java: Outer class is directly referenced during dump time but not during runtime.
runtime/cds/appcds/dynamicArchive/TestAutoCreateSharedArchive.java: test -XX:+AutoCreateSharedArchive feature
runtime/cds/appcds/dynamicArchive/TestAutoCreateSharedArchiveNoDefaultArchive.java: Test -XX:+AutoCreateSharedArchive on a copied JDK without default shared archive
runtime/cds/appcds/dynamicArchive/TestAutoCreateSharedArchiveUpgrade.java: Check that -XX:+AutoCreateSharedArchive automatically recreates an archive when you change the JDK version.
runtime/cds/appcds/dynamicArchive/TestDynamicDumpAtOom.java: test dynamic dump with OOM
runtime/cds/appcds/dynamicArchive/TestDynamicRegenerateHolderClasses.java: LambHello World test for regenerate lambda holder classes in dynamic archive
runtime/cds/appcds/dynamicArchive/TestLambdaInvokers.java: test archive lambda invoker species type in dynamic dump
runtime/cds/appcds/dynamicArchive/UnsupportedBaseArchive.java: unsupported base archive tests
runtime/cds/appcds/dynamicArchive/UnusedCPDuringDump.java: non-empty dir in -cp should be fine during dump time if only classes from the system modules are being loaded even though some are defined to the PlatformClassLoader and AppClassLoader.
runtime/cds/appcds/dynamicArchive/UsedAllArchivedLambdas.java: Test exhaustive use of archived lambda proxy classes.
runtime/cds/appcds/dynamicArchive/VerifyObjArrayCloneTest.java:
runtime/cds/appcds/dynamicArchive/VerifyWithDynamicArchive.java: test dynamic cds archive when turning on VerifySharedSpaces
runtime/cds/appcds/dynamicArchive/WrongTopClasspath.java: correct classpath for bottom archive, but bad classpath for top archive
runtime/cds/appcds/javaldr/ArrayTest.java: test the ability to archive array classes and load them from the archive
runtime/cds/appcds/javaldr/ExceptionDuringDumpAtObjectsInitPhase.java: Out of memory When dumping the CDS archive
runtime/cds/appcds/javaldr/GCDuringDump.java: When dumping the CDS archive, try to cause garbage collection while classes are being loaded.
runtime/cds/appcds/javaldr/GCSharedStringsDuringDump.java: Similar to GCDuringDumping.java, this test adds the -XX:SharedArchiveConfigFile option for testing the interaction with GC and shared strings.
runtime/cds/appcds/javaldr/LockDuringDump.java: When dumping the CDS archive, try to lock some objects.
runtime/cds/appcds/jcmd/JCmdTestDynamicDump.java: Test jcmd to dump dynamic shared archive.
runtime/cds/appcds/jcmd/JCmdTestFileSafety.java: Test jcmd to dump static shared archive.
runtime/cds/appcds/jcmd/JCmdTestStaticDump.java: Test jcmd to dump static shared archive.
runtime/cds/appcds/jigsaw/CheckUnsupportedDumpingOptions.java: Abort dumping if any of the new jigsaw vm options is specified.
runtime/cds/appcds/jigsaw/ExactOptionMatch.java: FMG are supported if the exact values are used for training/assembly/run for --add-exports, --add-modules, and -enable-native-access.
runtime/cds/appcds/jigsaw/JigsawOptionsCombo.java: Test combinations of jigsaw options that affect the use of AppCDS
runtime/cds/appcds/jigsaw/NewModuleFinderTest.java: Make sure the archived module graph can co-exist with modules that are dynamically defined at runtime using the ModuleFinder API.
runtime/cds/appcds/jigsaw/PatchModule/AppClassInCP.java: a test to demonstrate that an application class in the -cp will be archived although --patch-module is specified.
runtime/cds/appcds/jigsaw/PatchModule/CustomPackage.java: if a class is defined to a package which is not defined to any module in the jimage, the class will not be found during dump time but it will be used during run time.
runtime/cds/appcds/jigsaw/PatchModule/MismatchedPatchModule.java: different settings of --patch-module at dump time and runtime are acceptable.
runtime/cds/appcds/jigsaw/PatchModule/PatchDir.java: a simple test to ensure that a directory in the --patch-module option does not affect dump process
runtime/cds/appcds/jigsaw/PatchModule/PatchJavaBase.java: sharing is disabled if java.base is patch at runtime
runtime/cds/appcds/jigsaw/PatchModule/Simple.java: a simple test to ensure that class is loaded from jar file in --patch-module at runtime
runtime/cds/appcds/jigsaw/PatchModule/SubClassOfPatchedClass.java: the class in the -cp is a subclass of the class in --patch-module.
runtime/cds/appcds/jigsaw/PatchModule/TwoJars.java: a patched class found in --patch-module should be used at runtime
runtime/cds/appcds/jigsaw/RedefineClassesInModuleGraph.java: Make sure that archived module graph is not loaded if critical classes have been redefined.
runtime/cds/appcds/jigsaw/addmods/AddmodsOption.java: Test handling of the --add-modules option.
runtime/cds/appcds/jigsaw/addopens/AddopensOption.java: Test handling of the --add-opens option.
runtime/cds/appcds/jigsaw/classpathtests/BootAppendTests.java: AppCDS tests for testing -Xbootclasspath/a
runtime/cds/appcds/jigsaw/classpathtests/ClassPathTests.java: AppCDS tests for testing classpath/package conflicts
runtime/cds/appcds/jigsaw/classpathtests/DummyClassesInBootClassPath.java: Ensure that classes found in jimage takes precedence over classes found in -Xbootclasspath/a.
runtime/cds/appcds/jigsaw/classpathtests/EmptyClassInBootClassPath.java: Test a few scenarios if an empty class, which has the same name as the one in the jimage, is specified in the -Xbootclasspath/a 1) boot loader will always load the class from the bootclasspath 2) app loader will load the class from the jimage by default; app loader will load the class from the bootclasspath if the "--limit-modules java.base" option is specified
runtime/cds/appcds/jigsaw/module/EnableNativeAccessCDS.java: Test consistency of --enable-native-access option for CDS dump time and runtime
runtime/cds/appcds/jigsaw/module/ModuleOption.java: Test handling of module option (-m).
runtime/cds/appcds/jigsaw/modulepath/AddModules.java: sanity test the --add-modules option
runtime/cds/appcds/jigsaw/modulepath/ExportModule.java: Tests involve exporting a module from the module path to a jar in the -cp.
runtime/cds/appcds/jigsaw/modulepath/JvmtiAddPath.java: JvmtiEnv::AddToBootstrapClassLoaderSearch and JvmtiEnv::AddToSystemClassLoaderSearch should disable AppCDS
runtime/cds/appcds/jigsaw/modulepath/MainModuleOnly.java: Test some scenarios with a main modular jar specified in the --module-path and -cp options in the command line.
runtime/cds/appcds/jigsaw/modulepath/ModulePathAndCP.java: 2 sets of tests: one with only --module-path in the command line; another with both -cp and --module-path in the command line.
runtime/cds/appcds/jigsaw/modulepath/ModulePathAndCP_JFR.java: Same as ModulePathAndCP, but add -XX:StartFlightRecording:dumponexit=true to the runtime options.
runtime/cds/appcds/jigsaw/modulepath/ModulePathAndFMG.java: test module path changes for full module graph handling.
runtime/cds/appcds/jigsaw/modulepath/OptimizeModuleHandlingTest.java: test module path changes for optimization of module handling.
runtime/cds/appcds/jigsaw/overridetests/OverrideTests.java: AppCDS tests for overriding archived classes with -p and --upgrade-module-path
runtime/cds/appcds/jvmti/CFLH/ClassFileLoadHookTest.java: Test jvmti class file loader hook interaction with AppCDS
runtime/cds/appcds/jvmti/CFLH/MultiReleaseJars.java: Test multi-release jar with CFLH
runtime/cds/appcds/jvmti/InstrumentationTest.java: Exercise the java.lang.instrument.Instrumentation APIs on classes archived using CDS/AppCDSv1/AppCDSv2.
runtime/cds/appcds/jvmti/dumpingWithAgent/DumpingWithJavaAgent.java: CDS dumping with java agent.
runtime/cds/appcds/jvmti/dumpingWithAgent/DumpingWithJvmtiAgent.java: CDS dumping with JVMTI agent.
runtime/cds/appcds/jvmti/dumpingWithAgent/OldClassWithJavaAgent.java: Dump old class with java agent.
runtime/cds/appcds/jvmti/parallelLoad/ParallelLoadAndTransformTest.java: Load app classes from CDS archive in parallel threads, use initial transformation (CFLH)
runtime/cds/appcds/jvmti/redefineClasses/OldClassAndRedefineClass.java: Test loading of shared old class when another class has been redefined.
runtime/cds/appcds/jvmti/redefineClasses/RedefineBootClassTest.java: Redefine a shared super class loaded by the boot loader.
runtime/cds/appcds/jvmti/redefineClasses/RedefineOldSuperTest.java: Redefine a shared old super class loaded by the app loader.
runtime/cds/appcds/jvmti/transformRelatedClasses/TransformInterfaceImplementorAppCDS.java: Exercise initial transformation (class file loader hook) with CDS/AppCDS with Interface/Implementor pair
runtime/cds/appcds/jvmti/transformRelatedClasses/TransformSuperSubAppCDS.java: Exercise initial transformation (class file loader hook) with CDS/AppCDS with SubClass and SuperClass
runtime/cds/appcds/lambdaForm/DefaultClassListLFInvokers.java: Always load the lambda-form-invoker lines from default classlist
runtime/cds/appcds/loaderConstraints/DynamicLoaderConstraintsTest.java#custom-cl: Test class loader constraint checks for archived classes (dynamic archive) with custom class loader
runtime/cds/appcds/loaderConstraints/DynamicLoaderConstraintsTest.java#custom-cl-zgc: Test dumptime_table entries are removed with zgc eager class unloading
runtime/cds/appcds/loaderConstraints/DynamicLoaderConstraintsTest.java#default-cl: Test class loader constraint checks for archived classes (dynamic archive)
runtime/cds/appcds/loaderConstraints/LoaderConstraintsTest.java#custom-cl: Test class loader constraint checks for archived classes with custom class loader
runtime/cds/appcds/loaderConstraints/LoaderConstraintsTest.java#default-cl: Test class loader constraint checks for archived classes
runtime/cds/appcds/methodHandles/MethodHandlesAsCollectorTest.java#aot: Run the MethodHandlesAsCollectorTest.java test in CDSAppTester::AOT workflow.
runtime/cds/appcds/methodHandles/MethodHandlesAsCollectorTest.java#dynamic: Run the MethodHandlesAsCollectorTest.java test in CDSAppTester::DYNAMIC workflow.
runtime/cds/appcds/methodHandles/MethodHandlesAsCollectorTest.java#static: Run the MethodHandlesAsCollectorTest.java test in CDSAppTester::STATIC workflow.
runtime/cds/appcds/methodHandles/MethodHandlesCastFailureTest.java#aot: Run the MethodHandlesCastFailureTest.java test in CDSAppTester::AOT workflow.
runtime/cds/appcds/methodHandles/MethodHandlesCastFailureTest.java#dynamic: Run the MethodHandlesCastFailureTest.java test in CDSAppTester::DYNAMIC workflow.
runtime/cds/appcds/methodHandles/MethodHandlesCastFailureTest.java#static: Run the MethodHandlesCastFailureTest.java test in CDSAppTester::STATIC workflow.
runtime/cds/appcds/methodHandles/MethodHandlesGeneralTest.java#aot: Run the MethodHandlesGeneralTest.java test in CDSAppTester::AOT workflow.
runtime/cds/appcds/methodHandles/MethodHandlesGeneralTest.java#dynamic: Run the MethodHandlesGeneralTest.java test in CDSAppTester::DYNAMIC workflow.
runtime/cds/appcds/methodHandles/MethodHandlesGeneralTest.java#static: Run the MethodHandlesGeneralTest.java test in CDSAppTester::STATIC workflow.
runtime/cds/appcds/methodHandles/MethodHandlesInvokersTest.java#aot: Run the MethodHandlesInvokersTest.java test in CDSAppTester::AOT workflow.
runtime/cds/appcds/methodHandles/MethodHandlesInvokersTest.java#dynamic: Run the MethodHandlesInvokersTest.java test in CDSAppTester::DYNAMIC workflow.
runtime/cds/appcds/methodHandles/MethodHandlesInvokersTest.java#static: Run the MethodHandlesInvokersTest.java test in CDSAppTester::STATIC workflow.
runtime/cds/appcds/methodHandles/MethodHandlesPermuteArgumentsTest.java#aot: Run the MethodHandlesPermuteArgumentsTest.java test in CDSAppTester::AOT workflow.
runtime/cds/appcds/methodHandles/MethodHandlesPermuteArgumentsTest.java#dynamic: Run the MethodHandlesPermuteArgumentsTest.java test in CDSAppTester::DYNAMIC workflow.
runtime/cds/appcds/methodHandles/MethodHandlesPermuteArgumentsTest.java#static: Run the MethodHandlesPermuteArgumentsTest.java test in CDSAppTester::STATIC workflow.
runtime/cds/appcds/methodHandles/MethodHandlesSpreadArgumentsTest.java#aot: Run the MethodHandlesSpreadArgumentsTest.java test in CDSAppTester::AOT workflow.
runtime/cds/appcds/methodHandles/MethodHandlesSpreadArgumentsTest.java#dynamic: Run the MethodHandlesSpreadArgumentsTest.java test in CDSAppTester::DYNAMIC workflow.
runtime/cds/appcds/methodHandles/MethodHandlesSpreadArgumentsTest.java#static: Run the MethodHandlesSpreadArgumentsTest.java test in CDSAppTester::STATIC workflow.
runtime/cds/appcds/redefineClass/RedefineBasicTest.java: Run /serviceability/jvmti/RedefineClasses/RedefineRunningMethods in AppCDS mode to make sure class redefinition works with CDS.
runtime/cds/appcds/redefineClass/RedefineRunningMethods_Shared.java: Run /serviceability/jvmti/RedefineClasses/RedefineRunningMethods in AppCDS mode to make sure class redefinition works with CDS.
runtime/cds/appcds/resolvedConstants/AOTLinkedLambdas.java: AOT resolution of lambda expressions
runtime/cds/appcds/resolvedConstants/AOTLinkedVarHandles.java: AOT resolution of VarHandle invocation
runtime/cds/appcds/resolvedConstants/ResolvedConstants.java#dynamic: Dump time resolution of constant pool entries (Dynamic CDS archive)
runtime/cds/appcds/resolvedConstants/ResolvedConstants.java#static: Dump time resolution of constant pool entries (Static CDS archive).
runtime/cds/appcds/resolvedConstants/ResolvedPutField.java: Fieldref entry for putfield bytecodes for a final field cannot be preresolved if it's used by a method outside of <clinit>
runtime/cds/appcds/sharedStrings/ExerciseGC.java: Exercise GC with shared strings
runtime/cds/appcds/sharedStrings/FlagCombo.java#id0: Test relevant combinations of command line flags with shared strings
runtime/cds/appcds/sharedStrings/IncompatibleOptions.java#id0: Test options that are incompatible with use of shared strings Also test mismatch in oops encoding between dump time and run time
runtime/cds/appcds/sharedStrings/IncompatibleOptions.java#id1:
runtime/cds/appcds/sharedStrings/IncompatibleOptions.java#id2:
runtime/cds/appcds/sharedStrings/InternSharedString.java: Test shared strings together with string intern operation
runtime/cds/appcds/sharedStrings/InvalidFileFormat.java: Check most common errors in file format
runtime/cds/appcds/sharedStrings/LargePages.java: Basic shared string test with large pages
runtime/cds/appcds/sharedStrings/ResolvedReferencesNotNullTest.java: Testing resolved references array to ensure elements are non-null
runtime/cds/appcds/sharedStrings/SharedStringsBasic.java: Basic test for shared strings
runtime/cds/appcds/sharedStrings/SharedStringsBasicPlus.java: Basic plus test for shared strings
runtime/cds/appcds/sharedStrings/SharedStringsHumongous.java: Use a shared string allocated in a humongous G1 region.
runtime/cds/appcds/sharedStrings/SharedStringsStress.java: Write a lots of shared strings.
runtime/cds/appcds/sharedStrings/SharedStringsWbTest.java: White box test for shared strings
runtime/cds/appcds/sharedStrings/StaticStringInOldClass.java: make sure all interned strings in old classes are archived.
runtime/cds/appcds/sharedStrings/SysDictCrash.java: Regression test for JDK-8098821
runtime/cds/serviceability/ReplaceCriticalClasses.java: Tests how CDS works when critical library classes are replaced with JVMTI ClassFileLoadHook
runtime/cds/serviceability/ReplaceCriticalClassesForSubgraphs.java: Tests how CDS works when critical library classes are replaced with JVMTI ClassFileLoadHook
runtime/cds/serviceability/transformRelatedClasses/TransformInterfaceAndImplementor.java: Exercise initial transformation (ClassFileLoadHook) with CDS with Interface/Implementor pair
runtime/cds/serviceability/transformRelatedClasses/TransformSuperAndSubClasses.java: Exercise initial transformation (ClassFileLoadHook) with CDS with SubClass and SuperClass
runtime/cds/serviceability/transformRelatedClasses/TransformSuperSubTwoPckgs.java: Exercise initial transformation (ClassFileLoadHook) with CDS with SubClass and SuperClass, each lives in own separate package
runtime/classFileParserBug/AccModuleTest.java: Throw NoClassDefFoundError if class access_flags have ACC_MODULE set
runtime/classFileParserBug/AnnotationTag.java: Fuzzy-ed RuntimeVisibleAnnotations causes assertion
runtime/classFileParserBug/BadInitMethod.java: VM prohibits <clinit> methods with return values
runtime/classFileParserBug/BadNameAndType.java: Constant pool NameAndType entries must point to non-zero length Utf8 strings
runtime/classFileParserBug/Bad_NCDFE_Msg.java: Check that the right message is displayed for NoClassDefFoundError exception.
runtime/classFileParserBug/Class53.jasm: Check that the JVM accepts class files with version 53
runtime/classFileParserBug/Class54.jasm: Check that the JVM accepts class files with version 54
runtime/classFileParserBug/Class55.jasm: Check that the JVM accepts class files with version 55
runtime/classFileParserBug/Class56.jasm: Check that the JVM accepts class files with version 56
runtime/classFileParserBug/ClassFileParserBug.java: Check for exception instead of assert.
runtime/classFileParserBug/EnclosingMethod.java: For InnerClasses attribute, VM permits inner_class_info_index value of zero
runtime/classFileParserBug/FakeMethodAcc.java: Skipping access check for classes generated by core reflection
runtime/classFileParserBug/InitInInterface.java: Check that any method named <init> in an interface causes ClassFormatError
runtime/classFileParserBug/NameAndTypeSig.java: Constant pool NameAndType entries with valid but incompatible method name and signature shouldn't cause an exception until referenced by a method_ref.
runtime/classFileParserBug/TestBadClassName.java: Constant pool utf8 entry for class name cannot have empty qualified name '//'
runtime/classFileParserBug/TestBadPackageWithInterface.java: Check that if the VM rejects classes from packages starting with "java/", it will exit cleanly after InstanceKlass::verify_on(), and not leave freed memory in _local_interfaces.
runtime/classFileParserBug/TestEmptyBootstrapMethodsAttr.java: Test empty bootstrap_methods table within BootstrapMethods attribute
runtime/classFileParserBug/TestEmptyUnqName.java: Test that an unqualified name of "L;" causes a ClassFormatError exception.
runtime/classFileParserBug/TrailingSlashTest.java: Throw ClassFormatError exception for an old class file whose name ends in a '/'.
runtime/classFileParserBug/UnknownAttrTest.java: Unknown attribute erroneously causes ClassFormatError exception.
runtime/clinit/ClassInitBarrier.java:
runtime/clone/AbstractClone.java: Check that invokeinterface of clone() works properly where clone() is an abstract method in a superinterface and also overridden locally.
runtime/clone/AbstractNoClones.jasm: Check that invokeinterface of clone() works properly where clone() is an abstract method in a superinterface and not overridden locally.
runtime/clone/DefaultClone.jasm: Check that a default method named clone() does not get masked by java.lang.Object.clone() during resolution.
runtime/clone/DefaultFinalize.jasm: Check that a default method named finalize() does not get masked by java.lang.Object.finalize() during resolution.
runtime/clone/DefaultHashCode.jasm: Check that invokeinterface calls the right hashCode() method when there is both a local method named hashCode() and a default method named hashCode().
runtime/clone/DefaultNoCloneInC.jasm: Check that calling clone() with an invokeinterface opcode throws an IAE even if there is a default method named clone() in a super interface.
runtime/clone/LocalClone.jasm: Check that method resolution for invokeinterface of clone() fails if it cannot find a public method named clone().
runtime/clone/NoClones.jasm: Check that a NoSuchMethodError exception gets thrown if invokeinterface calls clone() and there is no public implementation of clone().
runtime/clone/invokevirtual/HasLocalClone.jasm: Check that invokevirtual of clone() finds the clone() method that is local to the calling class.
runtime/clone/invokevirtual/NoLocalClone.jasm: Check that invokevirtual of clone() calls java.lang.Object.clone() even if a superinterface has a default method named clone().
runtime/clone/invokevirtual/NoLocalCloneAbstr.jasm: Check that invokevirtual of clone() calls java.lang.Object.clone() even if a superinterface has an abstract method named clone().
runtime/condy/BadBSMUseTest.java: CONSTANT_Dynamic_info structure's tries to use a BSM index whose signature is for an invokedynamic and vice versa.
runtime/condy/CondyBadBSMArrayTest.java: CONSTANT_Dynamic_info structure present with various bad BSM index, BSM array attribute checks.
runtime/condy/CondyBadNameTypeTest.java: CONSTANT_Dynamic_info structure's name_and_type_index item does not point at CONSANT_NameAndType_info
runtime/condy/CondyCFVCheckTest.java: CONSTANT_Dynamic_info structure present within an unsupported class file version.
runtime/condy/CondyExtendedNullPointerTest.java: Test extended NullPointerException message in method with CONSTANT_Dynamic.
runtime/condy/CondyLDCTest.java: Tests various ldc, ldc_w, ldc2_w instructions of CONSTANT_Dynamic.
runtime/condy/CondyNewInvokeSpecialTest.java: Test CONSTANT_Dynamic where the BSM is invoked via a REF_newInvokeSpecial.
runtime/condy/escapeAnalysis/TestEscapeCondy.java: Ensure escape analysis can handle an ldc of a dynamic constant whose return type is an array of boolean.
runtime/condy/staticInit/TestInitException.java: Correctly handle initialization error for Condy BSM.
runtime/contended/Basic.java: Support Contended Annotation - JEP 142
runtime/contended/DefaultValue.java: \@Contended: explicit default value behaves differently from the implicit value
runtime/contended/HasNonStatic.java: \@Contended: fix multiple issues in the layout code
runtime/contended/Inheritance1.java: \@Contended doesn't work correctly with inheritance
runtime/contended/OopMaps.java: \@Contended: fix multiple issues in the layout code
runtime/contended/OopMapsSameGroup.java: \@Contended within the same group to use the same oop map
runtime/contended/Options.java: ContendedPaddingWidth should be range-checked
runtime/duplAttributes/DuplAttributesTest.java: Throw exceptions when duplicate attributes are detected.
runtime/duplAttributes/TestDupSignatureAttr.java: Throw ClassFormatError exception for multiple Signature attributes
runtime/exceptionMsgs/AbstractMethodError/AbstractMethodErrorTest.java: Check that the verbose message of the AME is printed correctly.
runtime/exceptionMsgs/ArrayIndexOutOfBoundsException/ArrayIndexOutOfBoundsExceptionTest.java#id0: Test extended ArrayIndexOutOfBoundsException message.
runtime/exceptionMsgs/ArrayIndexOutOfBoundsException/ArrayIndexOutOfBoundsExceptionTest.java#id1:
runtime/exceptionMsgs/ArrayStoreException/ArrayStoreExceptionTest.java: Test ArrayStoreException message.
runtime/exceptionMsgs/IllegalAccessError/IllegalAccessErrorTest.java: Test messages of IllegalAccessError.
runtime/exceptionMsgs/IncompatibleClassChangeError/IncompatibleClassChangeErrorTest.java: Check that the verbose message of ICCE is printed correctly.
runtime/exceptionMsgs/LongExceptionMessageTest.java: Test to verify throwing an exception with extra long message does not cause hang.
runtime/exceptionMsgs/NegativeArraySizeException/NegativeArraySizeExceptionTest.java: Test that NegativeArraySizeException reports the wrong size.
runtime/exceptionMsgs/NoClassDefFoundError/NoClassDefFoundErrorTest.java: Verifies message returned with NoClassDefFoundError exception.
runtime/exceptionMsgs/NullPointerException/NPEInHiddenTopFrameTest.java: Test NullPointerException messages thrown in frames that are hidden in the backtrace/stackTrace.
runtime/exceptionMsgs/NullPointerException/NullPointerExceptionTest.java#id0: Test extended NullPointerException message for classfiles generated with debug information.
runtime/exceptionMsgs/NullPointerException/NullPointerExceptionTest.java#id1: Test extended NullPointerException message for class files generated without debugging information.
runtime/exceptionMsgs/NullPointerException/SuppressMessagesTest.java#id0: Test that the default of flag ShowCodeDetailsInExceptionMessages is 'true', i.e., make sure the VM does print the message by default.
runtime/exceptionMsgs/NullPointerException/SuppressMessagesTest.java#id1: Test that the messages are suppressed if flag ShowCodeDetailsInExceptionMessages is 'false'.
runtime/exceptionMsgs/NullPointerException/SuppressMessagesTest.java#id2: Test that the messages are printed if flag ShowCodeDetailsInExceptionMessages is 'true'.
runtime/exceptionMsgs/methodPrinting/TestPrintingMethods.java: Check that methods are printed properly.
runtime/execstack/TestCheckJDK.java: Searches for all libraries in test VM and checks that they have the noexecstack bit set.
runtime/execstack/Testexecstack.java: Stack guard pages lost after loading library with executable stack.
runtime/finalStatic/FinalStatic.java: Test that VerifyError is not thrown when 'overriding' a static method.
runtime/getSysPackage/GetPackageXbootclasspath.java: Test that getPackage() works with a class loaded via -Xbootclasspath/a.
runtime/getSysPackage/GetSysPkgTest.java:
runtime/handlerInTry/LoadHandlerInTry.java: JVM stuck in infinite loop during verification
runtime/handshake/AsyncHandshakeWalkStackTest.java:
runtime/handshake/HandshakeDirectTest.java: This test tries to stress direct handshakes between threads while suspending them.
runtime/handshake/HandshakeSuspendExitTest.java: This test tries to stress the handshakes with new and exiting threads while suspending them.
runtime/handshake/HandshakeTransitionTest.java: This does a sanity test of the poll in the native wrapper.
runtime/handshake/HandshakeWalkExitTest.java: This test tries to stress the handshakes with new and exiting threads
runtime/handshake/HandshakeWalkOneExitTest.java: This test tries to stress the handshakes with new and exiting threads
runtime/handshake/HandshakeWalkStackTest.java:
runtime/handshake/MixedHandshakeWalkStackTest.java:
runtime/handshake/SuspendBlocked.java:
runtime/handshake/SystemMembarHandshakeTransitionTest.java: This does a sanity test of the poll in the native wrapper.
runtime/interned/SanityTest.java: Sanity check of String.intern() & GC
runtime/interpreter/BytecodeTracerTest.java: Test the output of the HotSpot BytecodeTracer and ClassPrinter classes.
runtime/interpreter/LastJsrTest.java: Ensure a program that ends with a JSR does not crash
runtime/invokedynamic/BootstrapMethodErrorTest.java: Test exceptions from invokedynamic and the bootstrap method
runtime/invokedynamic/MethodHandleConstantTest.java:
runtime/invokedynamic/TestDynamicConstant.java:
runtime/jcmd/JcmdCmdLine.java: In case of a class path is longer than O_BUFLEN, the class path should not be truncated in the output from jcmd VM.command_line.
runtime/jni/8025979/UninitializedStrings.java: regression tests for 8025922, verify uninitialized strings reference.
runtime/jni/8033445/DefaultMethods.java: regression tests for 8033445, verify default methods call from JNI
runtime/jni/CallWithJNIWeak/CallWithJNIWeak.java: Test call of native function with JNI weak global ref.
runtime/jni/CalleeSavedRegisters/FPRegs.java:
runtime/jni/FastGetField/FastGetField.java: Tests that all FieldAccess notifications for Get*Field with primitive type are generated.
runtime/jni/FindClass/FindClassFromBoot.java: verify if the native library loaded by the boot loader can only find classes visible to the boot loader
runtime/jni/FindClassUtf8/FindClassUtf8.java: verify that -Xcheck:jni finds a bad utf8 name for class name.
runtime/jni/IsVirtualThread/IsVirtualThread.java#default: Test JNI IsVirtualThread
runtime/jni/IsVirtualThread/IsVirtualThread.java#no-vmcontinuations:
runtime/jni/PrivateInterfaceMethods/PrivateInterfaceMethods.java: Add JNI invocation tests for private interface methods
runtime/jni/ReturnJNIWeak/ReturnJNIWeak.java: Test return of JNI weak global refs from native calls.
runtime/jni/ToStringInInterfaceTest/ToStringTest.java:
runtime/jni/abstractMethod/TestJNIAbstractMethod.java: Test that invocation of an abstract method from JNI works correctly
runtime/jni/activeDestroy/TestActiveDestroy.java: Tests that DestroyJavaVM from an active thread fails.
runtime/jni/atExit/TestAtExit.java: Check that attempting to use the JNI invocation API from an atexit handler fails as expected without crashing.
runtime/jni/checked/TestCharArrayReleasing.java:
runtime/jni/checked/TestCheckedJniExceptionCheck.java: regression tests for 8164086, verify correct warning from checked JNI
runtime/jni/checked/TestCheckedReleaseArrayElements.java: verify multiple release calls on a copied array work when checked
runtime/jni/checked/TestLargeUTF8Length.java: Test warning for GetStringUTFLength and functionality of GetStringUTFLengthAsLong
runtime/jni/checked/TestPrimitiveArrayCriticalWithBadParam.java: -Xcheck:jni should catch wrong parameter passed to GetPrimitiveArrayCritical
runtime/jni/daemonDestroy/TestDaemonDestroy.java:
runtime/jni/getCreatedJavaVMs/TestGetCreatedJavaVMs.java:
runtime/jni/nativeStack/TestNativeStack.java: Generate a JNI Fatal error, or a warning, in a launched VM and check the native stack is present as expected.
runtime/jni/registerNativesWarning/TestRegisterNativesWarning.java: Check that re-registering a native method of a boot class generates a warning when not done from a boot class
runtime/jni/terminatedThread/TestTerminatedThread.java: Basic test of Thread and ThreadMXBean queries on a natively attached thread that has failed to detach before terminating.
runtime/jsig/Testjsig.java: sigaction(sig) results in process hang/timed-out if sig is much greater than SIGRTMAX
runtime/lambda-features/CyclicInterfaceInit.java: Interface initialization was crashing on this because the wrong class was getting initialization error.
runtime/lambda-features/InterfaceInitializationStates.java: Test interface initialization states and when certain interfaces are initialized in the presence of initialization errors.
runtime/lambda-features/InvokespecialInterface.java: [JDK 8] Test invokespecial and invokeinterface with the same JVM_CONSTANT_InterfaceMethodref
runtime/lambda-features/PublicStaticInterfaceMethodHandling.java: [JDK 8] Test correct handling of static public interface methods
runtime/lambda-features/TestConcreteClassWithAbstractMethod.java: method lookup on an abstract method in a concrete class should be successful
runtime/lambda-features/TestInterfaceInit.java: [JDK 8u40] Test interface init: only for interfaces declaring default methods, when subclass inits
runtime/lambda-features/TestInterfaceOrder.java: [JDK 8u40] Test interface initialization order
runtime/lambda-features/TestStaticandInstance.java: Test linkresolver search static, instance and overpass duplicates
runtime/linkResolver/InterfaceObjectTest.java: test interface resolution when clone is declared abstract within an interface and when they are not
runtime/linkResolver/NoSuchFieldOutputTest.java: Test output of NoSuchFieldError when field signature does not match
runtime/linkResolver/TestDeletedMethod.java: Test that deleting a subclass method implementation results in execution of a superclass implementation - if it is accessible.
runtime/lockStack/TestLockStackCapacity.java: Tests the interaction between recursive lightweight locking and when the lock stack capacity is exceeded.
runtime/lockStack/TestStackWalk.java:
runtime/locking/TestOutOfOrderUnlocking.jasm#comp: Check that monitorenter A; monitorenter B; monitorexit A; monitorexit B; works, with -Xcomp
runtime/locking/TestOutOfOrderUnlocking.jasm#int: Check that monitorenter A; monitorenter B; monitorexit A; monitorexit B; works
runtime/logging/ClassInitializationTest.java:
runtime/logging/ClassLoadUnloadTest.java:
runtime/logging/ClassResolutionTest.java:
runtime/logging/CompressedOopsTest.java: -Xlog:gc+heap+coops=info should have output from the code
runtime/logging/CondyIndyTest.java: Test -Xlog:methodhandles with a test that contains both a condy and indy.
runtime/logging/DefaultLogDecoratorsTest.java: Running -Xlog with tags which have disabled default decorators should not yield decorated logs
runtime/logging/DefaultMethodsTest.java: defaultmethods=debug should have logging from each of the statements in the code
runtime/logging/DeoptStats.java: Verify that the Deoptimization statistics are printed to the VM/Compiler log file
runtime/logging/ExceptionsTest.java: exceptions=info output should have an exception message for interpreter methods
runtime/logging/FoldMultilinesTest.java:
runtime/logging/LoaderConstraintsTest.java:
runtime/logging/ModulesTest.java: -Xlog:module should emit logging output
runtime/logging/MonitorInflationTest.java: monitorinflation=trace should have logging from each of the statements in the code
runtime/logging/MonitorMismatchTest.java:
runtime/logging/MutexRankTest.java: Verify mutex rank logging works
runtime/logging/OsCpuLoggingTest.java: os+cpu output should contain some os,cpu information
runtime/logging/RedefineClasses.java: Redefine classes with enabling logging to verify Klass:external_name() during GC.
runtime/logging/SafepointTest.java: safepoint=trace should have output from each log statement in the code
runtime/logging/StackWalkTest.java: -Xlog:stackwalk should produce logging from the source code
runtime/logging/StartupTimeTest.java: -Xlog:startuptime should produce logging from the source code
runtime/logging/TestMethodHandlesVerbose.java: Run simple test with -XX:+Verbose and -Xlog:methodhandles.
runtime/logging/ThreadLoggingTest.java: os+thread output should contain logging calls for thread start stop attaches detaches
runtime/logging/VMOperationTest.java: vmoperation=debug should have logging output
runtime/logging/VerificationTest.java: test enabling and disabling verification logging and verification log levels
runtime/logging/loadLibraryTest/LoadLibraryTest.java: Tests logging of shared library loads and unloads.
runtime/memory/LargePages/TestLargePagesFlags.java: Tests how large pages are chosen depending on the given large pages flag combinations.
runtime/memory/MultiAllocateNullCheck.java: multi_allocate() call does not CHECK_NULL and causes crash in fastdebug bits
runtime/memory/ReadFromNoaccessArea.java: Test that touching noaccess area in class ReservedHeapSpace results in SIGSEGV/ACCESS_VIOLATION
runtime/memory/ReadVMPageSize.java: Using WhiteBox to get VM page size
runtime/memory/ReserveMemory.java: Make sure reserved (but uncommitted) memory is not accessible
runtime/memory/StressVirtualSpaceResize.java: Stress test that expands/shrinks VirtualSpace
runtime/modules/AccModuleTest.java:
runtime/modules/AccessCheck/AccessExportTwice.java: Class p1.c1 in an unnamed module cannot read p2.c2 in module second_mod, even after p2 is exported to all unnamed.
runtime/modules/AccessCheck/AccessReadTwice.java: Class p1.c1 in module first_mod cannot read p2.c2 in module second_mod, even after a read edge is added between first_mod and second_mod.
runtime/modules/AccessCheck/CheckRead.java: Test that if module m1x can not read module m2x, then class p1.c1 in module m1x can not access p2.c2 in module m2x.
runtime/modules/AccessCheck/DiffCL_CheckRead.java: Test that if module m1x can not read module m2x, then class p1.c1 in module m1x can not access p2.c2 in module m2x.
runtime/modules/AccessCheck/DiffCL_ExpQualOther.java: Test that if module m1x can read module m2x, but package p2 in m2x is exported specifically to module m3x, then class p1.c1 in m1x can not access p2.c2 in m2x.
runtime/modules/AccessCheck/DiffCL_ExpQualToM1.java: class p1.c1 defined in m1x tries to access p2.c2 defined in m2x.
runtime/modules/AccessCheck/DiffCL_ExpUnqual.java: Test that if module m1x can read module m2x, and package p2 in m2x is exported unqualifiedly, then class p1.c1 in m1x can read p2.c2 in m2x.
runtime/modules/AccessCheck/DiffCL_PkgNotExp.java: Test that if module m1x can read module m2x, but package p2 in m2x is not exported, then class p1.c1 in m1x can not read p2.c2 in m2x.
runtime/modules/AccessCheck/DiffCL_Umod.java: class p1.c1 defined in m1x tries to access p2.c2 defined in unnamed module.
runtime/modules/AccessCheck/DiffCL_UmodUpkg.java: class p3.c3 defined in module m1x tries to access c4 defined in an unnamed package and an unnamed module.
runtime/modules/AccessCheck/ExpQualOther.java: Test that if module m1x can read module m2x, but package p2 in m2x is exported specifically to module m3x, then class p1.c1 in m1x can not access p2.c2 in m2x.
runtime/modules/AccessCheck/ExpQualToM1.java: Test that if module m1x can read module m2x, AND package p2 in m2x is exported qualifiedly to m1x, then class p1.c1 in m1x can read p2.c2 in m2x.
runtime/modules/AccessCheck/ExpQualToM1PrivateMethodIAE.java: Test that if module m1x can read module m2x, AND package p2 in m2x is exported qualifiedly to m1x, then class p1.c1 in m1x can read p2.c2 in m2x.
runtime/modules/AccessCheck/ExpUnqual.java: Test that if module m1x can read module m2x, AND package p2 in module_two is exported unqualifiedly, then class p1.c1 in m1x can read p2.c2 in m2x.
runtime/modules/AccessCheck/ExportAllUnnamed.java: Test if package p2 in module m2x is exported to all unnamed, then class p1.c1 in an unnamed module can read p2.c2 in module m2x.
runtime/modules/AccessCheck/MethodAccessReadTwice.java: Test that invokedynamic instructions, that initially throw IAE exceptions because of a missing module read edge, behave correctly when executed after the module read edge is added.
runtime/modules/AccessCheck/PkgNotExp.java: Test that if module m1x can read module m2x, but package p2 in m2x is not exported, then class p1.c1 in m1x can not read p2.c2 in m2x.
runtime/modules/AccessCheck/Umod.java: class p1.c1 defined in m1x tries to access p2.c2 defined in unnamed module.
runtime/modules/AccessCheck/UmodDiffCL_ExpQualOther.java: class p1.c1 defined in an unnamed module tries to access p2.c2 defined in m2x.
runtime/modules/AccessCheck/UmodDiffCL_ExpUnqual.java: class p1.c1 defined in an unnamed module tries to access p2.c2 defined in m2x.
runtime/modules/AccessCheck/UmodDiffCL_PkgNotExp.java: class p1.c1 defined in unnamed module tries to access p2.c2 defined in m2x.
runtime/modules/AccessCheck/UmodDiffCL_Umod.java: class p1.c1 defined in an unnamed module tries to access p2.c2 defined in an unnamed module.
runtime/modules/AccessCheck/UmodDiffCL_UmodUpkg.java: class p3.c3 defined in a named package in an unnamed module tries to access c4 defined in an unnamed package in an unnamed module.
runtime/modules/AccessCheck/UmodUPkg.java: class p3.c3 defined in module m1x tries to access c4 defined in unnamed module.
runtime/modules/AccessCheck/UmodUpkgDiffCL_ExpQualOther.java: class c5 defined in an unnamed module tries to access p6.c6 defined in m2x.
runtime/modules/AccessCheck/UmodUpkgDiffCL_NotExp.java: class c5 in an unnamed module can read module m2x, but package p6 in module m2x is not exported.
runtime/modules/AccessCheck/UmodUpkgDiffCL_Umod.java: Test public type c5 defined in an unnamed package and unnamed module can access public type p6.c6 defined in an unnamed module.
runtime/modules/AccessCheck/UmodUpkg_ExpQualOther.java: Test that if class c5 in an unnamed module can read package p6 in module m2x, but package p6 in module m2x is exported qualifiedly to module m3x, then class c5 in an unnamed module can not read p6.c6 in module m2x.
runtime/modules/AccessCheck/UmodUpkg_NotExp.java: Test if package p6 in module m2x is not exported, then class c5 in an unnamed module can not access p6.c2 in module m2x.
runtime/modules/AccessCheck/UmodUpkg_Umod.java: Test public type c5 defined in an unnamed package and unnamed module can access public type p6.c6 defined in an unnamed module.
runtime/modules/AccessCheck/Umod_ExpQualOther.java: Test that if package p2 in module m2x is exported to module m3x, then class p1.c1 in an unnamed module can not read p2.c2 in module m2x.
runtime/modules/AccessCheck/Umod_ExpUnqual.java: Test if package p2 in module m2x is exported unqualifiedly, then class p1.c1 in an unnamed module can read p2.c2 in module m2x.
runtime/modules/AccessCheck/Umod_PkgNotExp.java: Test if package p2 in module m2x is not exported, then class p1.c1 in an unnamed module can not access p2.c2 in module m2x.
runtime/modules/AccessCheck/Umod_UmodUpkg.java: class p3.c3 defined in an unnamed module tries to access c4 defined in an unnamed package and an unnamed module.
runtime/modules/AccessCheckAllUnnamed.java:
runtime/modules/AccessCheckExp.java:
runtime/modules/AccessCheckJavaBase.java:
runtime/modules/AccessCheckOpen.java:
runtime/modules/AccessCheckRead.java:
runtime/modules/AccessCheckSuper.java:
runtime/modules/AccessCheckUnnamed.java:
runtime/modules/AccessCheckWorks.java:
runtime/modules/CCE_module_msg.java:
runtime/modules/ClassLoaderNoUnnamedModuleTest.java: Ensure that if the JVM encounters a ClassLoader whose unnamedModule field is not set an InternalError results.
runtime/modules/ExportTwice.java:
runtime/modules/IgnoreModulePropertiesTest.java: Test that the VM ignores explicitly specified module internal properties.
runtime/modules/JVMAddModuleExportToAllUnnamed.java:
runtime/modules/JVMAddModuleExports.java:
runtime/modules/JVMAddModuleExportsToAll.java:
runtime/modules/JVMAddReadsModule.java:
runtime/modules/JVMDefineModule.java:
runtime/modules/LoadUnloadModuleStress.java: Ensure module information is cleaned when owning class loader unloads
runtime/modules/ModuleOptionsTest.java: Test that the VM only recognizes the last specified --list-modules options but accumulates --add-module values.
runtime/modules/ModuleOptionsWarn.java: Test warnings for ignored properties.
runtime/modules/ModuleStress/ExportModuleStressTest.java: package in the boot layer is repeatedly exported to unique module created in layers on top of the boot layer
runtime/modules/ModuleStress/ModuleStress.java: Test differing scenarios where a module's readability list and a package's exportability list should be walked
runtime/modules/ModuleStress/ModuleStressGC.java: layers over the boot layer are repeatedly created, during this iteration, GCs are forced to verify correct walk of module and package lists.
runtime/modules/ModulesSymLink.java: Test with symbolic linked lib/modules
runtime/modules/PatchModule/PatchModule2Dirs.java: Make sure --patch-module works with multiple directories.
runtime/modules/PatchModule/PatchModuleCDS.java: test that --patch-module works with CDS
runtime/modules/PatchModule/PatchModuleClassList.java: classes which are not useable during run time should not be included in the classlist
runtime/modules/PatchModule/PatchModuleDupJavaBase.java: VM exit initialization results if java.base is specificed more than once to --patch-module.
runtime/modules/PatchModule/PatchModuleDupModule.java: Module system initialization exception results if a module is specificed twice to --patch-module.
runtime/modules/PatchModule/PatchModuleJavaBase.java: Make sure --patch-module works for java.base.
runtime/modules/PatchModule/PatchModuleJavaBaseVerify.java: Show that --patch-module for java.base does not verify the classfile.
runtime/modules/PatchModule/PatchModuleTest.java: Make sure --patch-module works for modules besides java.base.
runtime/modules/PatchModule/PatchModuleTestJar.java: Make sure --patch-module works when a jar file is specified for a module
runtime/modules/PatchModule/PatchModuleTestJarDir.java: Make sure --patch-module works when a jar file and a directory is specified for a module
runtime/modules/PatchModule/PatchModuleTraceCL.java: Make sure -Xlog:class+load=info works properly with "modules" jimage, --patch-module, and with -Xbootclasspath/a
runtime/modules/SealedInterfaceModuleTest.java:
runtime/modules/SealedModuleTest.java:
runtime/modules/Visibility/PatchModuleVisibility.java: Ensure that a newly introduced java.base package placed within the --patch-module directory is considered part of the boot loader's visibility boundary
runtime/modules/Visibility/XbootcpNoVisibility.java: Ensure that a class defined within a java.base package can not be located via -Xbootclasspath/a
runtime/modules/Visibility/XbootcpVisibility.java: Ensure that a package whose module has not been defined to the boot loader is correctly located with -Xbootclasspath/a
runtime/modules/getModuleJNI/GetModule.java: test JNI_GetModule() API
runtime/os/AvailableProcessors.java: Check that availableProcessors reports the correct value when running in a cpuset on linux
runtime/os/TestHugePageDecisionsAtVMStartup.java#Default: Test JVM large page setup (default options)
runtime/os/TestHugePageDecisionsAtVMStartup.java#LP_enabled: Test JVM large page setup (+LP)
runtime/os/TestHugePageDecisionsAtVMStartup.java#THP_enabled: Test JVM large page setup (+THP)
runtime/os/TestHugePageDetection.java: Test that the JVM detects the OS hugepage/THP settings correctly.
runtime/os/TestMemoryAllocationLogging.java#testAttemptedReserveFailed: Test that memory allocation logging warns when attempted reservation fails
runtime/os/TestMemoryAllocationLogging.java#testCommitFailed: Test that memory allocation logging warns when commit attempts fail
runtime/os/TestMemoryAllocationLogging.java#testReleaseFailed: Test that memory allocation logging warns when memory release fails
runtime/os/TestMemoryAllocationLogging.java#testSuccessfulFlow: Test that memory allocation logging works when allocation operations run without error
runtime/os/TestMemoryAllocationLogging.java#testUncommitFailed: Test that memory allocation logging warns when memory uncommitment fails
runtime/os/TestTimerSlack.java: Check that timer slack options work
runtime/os/TestTracePageSizes.java#G1: Run tests with G1
runtime/os/TestTracePageSizes.java#Parallel: Run tests with Parallel
runtime/os/TestTracePageSizes.java#Serial: Run tests with Serial
runtime/os/TestTracePageSizes.java#compiler-options: Run test without segmented code cache.
runtime/os/TestTracePageSizes.java#explicit-large-page-size: Run test explicitly with both 2m and 1g pages on x64.
runtime/os/TestTracePageSizes.java#no-options: Run test with no arguments apart from the ones required by the test.
runtime/os/TestTrimNative.java#testOffByDefault: Test that trimming is disabled by default
runtime/os/TestTrimNative.java#testOffExplicit: Test that trimming can be disabled explicitly
runtime/os/TestTrimNative.java#trimNative:
runtime/os/TestTrimNative.java#trimNativeHighInterval: High interval trimming should not even kick in for short program runtimes
runtime/os/TestTrimNative.java#trimNativeLowInterval: Very low (sub-second) interval, nothing should explode
runtime/os/TestUseCpuAllocPath.java: If #processors > 1024 os_linux.cpp uses special coding.
runtime/posixSig/TestPosixSig.java: test that -XX:+CheckJNICalss displays changed signal handlers.
runtime/records/RedefineRecord.java: Test that a class that is a record can be redefined.
runtime/records/recordAttributeTest.java:
runtime/records/recordReflectionTest.java: testing reflection APIs for record classes
runtime/reflect/ArrayGetIntException.java: (reflect) Misleading detail string in IllegalArgumentException thrown by Array.get<Type>
runtime/reflect/ComponentTypeFieldTest.java: (reflect) java.lang.Class componentType field not found.
runtime/reflect/ReflectOutOfMemoryError.java: Test that throwing OOM from reflected method gets InvocationTargetException
runtime/reflect/ReflectStackOverflow.java: This program crashes in 1.1, but runs okay in 1.2.
runtime/sealedClasses/GetPermittedSubclassesTest.java:
runtime/sealedClasses/OverrideSealedTest.java:
runtime/sealedClasses/RedefinePermittedSubclass.java: Test that a permitted subclass, that is resolved by its super class, can be redefined.
runtime/sealedClasses/RedefineSealedClass.java: Test that a class that is a sealed class can be redefined.
runtime/sealedClasses/SealedDifferentUnnamedModuleTest.java:
runtime/sealedClasses/SealedUnnamedModuleIntfTest.java:
runtime/sealedClasses/SealedUnnamedModuleTest.java:
runtime/stackMapCheck/StackMapCheck.java: Class verifier accepts an invalid class file
runtime/strictfp/StrictfpModifierChecksTest.java:
runtime/stringtable/StringTableCleaningTest.java: Stress the string table and cleaning.
runtime/stringtable/StringTableCorruptionTest.java: Verify new error message for corrupting string table contents.
runtime/stringtable/StringTableVerifyTest.java: VerifyStringTableAtExit should not crash
runtime/verifier/CFLH/TestVerify.java: Verifier should verify ClassFileLoadHook bytes even if on bootclasspath
runtime/verifier/InvokeClone.java:
runtime/verifier/OverriderMsg.java:
runtime/verifier/PrimIntArray.java: Throw VerifyError when checking assignability of primitive arrays that are not identical.
runtime/verifier/PutfieldProtectedTest.java: Make sure error message for protected putfield error is correct.
runtime/verifier/ReturnMsgs.java: Test that VerifyError messages are correct when return bytecodes andd method signatures do not match.
runtime/verifier/TestANewArray.java: Test that anewarray bytecode is valid only if it specifies 254 or fewer dimensions.
runtime/verifier/TestMultiANewArray.java:
runtime/verifier/TestSigParse.java: Test that signatures are properly parsed when verification of local classes is requested but verification of remote classes is not.
runtime/verifier/TestStaticIF.java: Test static interface method.
runtime/verifier/TestTableSwitch.java:
runtime/verifier/TraceClassRes.java: split verifier needs to add class resolution tracing
runtime/verifier/VerifyProtectedConstructor.java: Verify that protected constructor calls are not allowed for any classfile versions in either verifier.
runtime/verifier/VerifyStackForExceptionHandlers.java: Verify that methods with max_stack==0 don't have exception handlers
runtime/verifier/defaultMethods/DefaultMethodRegressionTests.java: defaultMethod resolution and verification
runtime/verifier/defaultMethods/DefaultMethodRegressionTestsRun.java: defaultMethod resolution and verification using an URLClassLoader
runtime/verifier/invokespecial/TestInvokeSpecialInterface.java#unverified:
runtime/verifier/invokespecial/TestInvokeSpecialInterface.java#verified:
runtime/verifier/popTopTests/PopDupTop.java: Throw VerifyError when popping a stack element of TOP
runtime/verifier/stackMapTableTests/StackMapTableTest.java: Test that the JVM does not assert when printing a stack map table containing a stack map with a bad verification type.
runtime/vthread/JNIMonitor/JNIMonitor.java#missingUnlock: Don't do the unlock and exit normally
runtime/vthread/JNIMonitor/JNIMonitor.java#missingUnlockWithThrow: Don't do the unlock and exit by throwing
runtime/vthread/JNIMonitor/JNIMonitor.java#multiMissingUnlock: Don't do the unlock and exit normally, by multiple threads
runtime/vthread/JNIMonitor/JNIMonitor.java#multiMissingUnlockWithThrow: Don't do the unlock and exit by throwing, by multiple threads
runtime/vthread/JNIMonitor/JNIMonitor.java#multiNormal: Normal lock then unlock by multiple threads
runtime/vthread/JNIMonitor/JNIMonitor.java#normal: Normal lock then unlock
runtime/vthread/RedefineClass.java: Regression test based on runtime/Metaspace/DefineClass.java
runtime/vthread/StackChunkClassLoaderTest.java: Test that a different jdk.internal.vm.StackChunk can be loaded by non-null class loader
runtime/vthread/TestObjectAllocationSampleEvent.java: Tests ObjectAllocationSampleEvent
runtime/whitebox/TestHiddenClassIsAlive.java: Test that Whitebox.isClassAlive() works with hidden classes.
runtime/whitebox/TestWBDeflateIdleMonitors.java: Test to verify that WB method deflateIdleMonitors works correctly.
runtime/whitebox/WBStackSize.java: verify that whitebox functions getThreadFullStackSize() and getThreadRemainingStackSize are working
sanity/BasicVMTest.java: make sure various basic java options work
serviceability/7170638/SDTProbesGNULinuxTest.java: Test SDT probes available on GNU/Linux when DTRACE_ENABLED
serviceability/AsyncGetCallTrace/MyPackage/ASGCTBaseTest.java: Verifies that AsyncGetCallTrace is call-able and provides sane information.
serviceability/HeapDump/DuplicateArrayClassesTest.java: Verifies heap dump does not contain duplicate array classes
serviceability/HeapDump/FieldsInInstanceTest.java: Verifies heap dump contains all fields of an instance
serviceability/HeapDump/FullGCHeapDumpLimitTest.java: Test of option -XX:FullGCHeapDumpLimit
serviceability/HeapDump/UnmountedVThreadNativeMethodAtTop.java: Test dumping the heap while a virtual thread is unmounted with a native method frame at top.
serviceability/ParserTest.java: Test that the diagnostic command arguemnt parser works
serviceability/attach/AttachAPIv2/CompatTest.java: Basic compatibility test for Attach API v2
serviceability/attach/AttachAPIv2/StreamingOutputTest.java: Sanity test for streaming output support
serviceability/attach/AttachNegativePidTest.java:
serviceability/attach/AttachSetGetFlag.java: Tests the setFlag and printFlag attach command
serviceability/attach/AttachWithStalePidFile.java: Regression test for attach issue where stale pid files in /tmp lead to connection issues
serviceability/attach/ConcAttachTest.java:
serviceability/attach/EarlyDynamicLoad/EarlyDynamicLoad.java: Test that dynamic attach fails gracefully when the JVM is not in live phase.
serviceability/attach/FailedDequeueTest.java: verifies that failure in AttachListener::dequeue does not crash the VM
serviceability/attach/LongArgTest.java: Tests that long arguments of attach operation are not truncated
serviceability/attach/RemovingUnixDomainSocketTest.java:
serviceability/dcmd/compiler/CodeCacheTest.java: Test of diagnostic command Compiler.codecache
serviceability/dcmd/compiler/CodeHeapAnalyticsMethodNames.java: Test Compiler.CodeHeap_Analytics output has qualified method names in the 'METHOD NAMES' section.
serviceability/dcmd/compiler/CodeHeapAnalyticsParams.java: Test the Compiler.CodeHeap_Analytics command
serviceability/dcmd/compiler/CodelistTest.java: Test of diagnostic command Compiler.codelist Flag comment: -XX:-UseCodeCacheFlushing - to prevent methods from being removed from the code cache before we have checked the results This test should never run in the same VM as other tests - the code cache may get huge which will create an enormous amount of output to parse.
serviceability/dcmd/compiler/CompilerDirectivesDCMDTest.java: Test of diagnostic command
serviceability/dcmd/compiler/CompilerMemoryStatisticTest.java: Test Compiler.memory
serviceability/dcmd/compiler/CompilerQueueTest.java: Test of diagnostic command Compiler.queue
serviceability/dcmd/compiler/PerfMapTest.java: Test of diagnostic command Compiler.perfmap
serviceability/dcmd/framework/HelpTest.java: Test of diagnostic command help (tests all DCMD executors)
serviceability/dcmd/framework/InvalidCommandTest.java: Test of invalid diagnostic command (tests all DCMD executors)
serviceability/dcmd/framework/VMVersionTest.java: Test of diagnostic command VM.version (tests all DCMD executors)
serviceability/dcmd/gc/ClassHistogramTest.java: Test of diagnostic command GC.class_histogram
serviceability/dcmd/gc/FinalizerInfoTest.java:
serviceability/dcmd/gc/HeapDumpAllTest.java: Test of diagnostic command GC.heap_dump -all=true
serviceability/dcmd/gc/HeapDumpCompressedTest.java#Epsilon: Test of diagnostic command GC.heap_dump with gzipped output (Epsilon GC)
serviceability/dcmd/gc/HeapDumpCompressedTest.java#G1: Test of diagnostic command GC.heap_dump with gzipped output (G1 GC)
serviceability/dcmd/gc/HeapDumpCompressedTest.java#Parallel: Test of diagnostic command GC.heap_dump with gzipped output (Parallel GC)
serviceability/dcmd/gc/HeapDumpCompressedTest.java#Serial: Test of diagnostic command GC.heap_dump with gzipped output (Serial GC)
serviceability/dcmd/gc/HeapDumpCompressedTest.java#Shenandoah: Test of diagnostic command GC.heap_dump with gzipped output (Shenandoah GC)
serviceability/dcmd/gc/HeapDumpCompressedTest.java#Z: Test of diagnostic command GC.heap_dump with gzipped output (Z GC)
serviceability/dcmd/gc/HeapDumpParallelTest.java: Verify the integrity of generated heap dump and capability of parallel dump
serviceability/dcmd/gc/HeapDumpTest.java: Test of diagnostic command GC.heap_dump
serviceability/dcmd/gc/HeapInfoTest.java: Test of diagnostic command GC.heap_info
serviceability/dcmd/gc/RunGCTest.java: Test of diagnostic command GC.run
serviceability/dcmd/jvmti/AttachFailed/AttachIncorrectLibrary.java:
serviceability/dcmd/jvmti/AttachFailed/AttachNoEntry.java:
serviceability/dcmd/jvmti/AttachFailed/AttachReturnError.java:
serviceability/dcmd/jvmti/DataDumpDcmdTest.java: Test of JVMTI.data_dump diagnostic command
serviceability/dcmd/jvmti/LoadAgentDcmdTest.java:
serviceability/dcmd/thread/ClassInitMonitorVThread.java: Test jcmd Thread.print command for "waiting on the Class initialization monitor" case
serviceability/dcmd/thread/PrintConcurrentLocksTest.java: Test of diagnostic command Thread.print -l=true
serviceability/dcmd/thread/PrintMountedVirtualThread.java: Test of diagnostic command Thread.print with virtual threads
serviceability/dcmd/thread/PrintTest.java: Test of diagnostic command Thread.print
serviceability/dcmd/thread/ThreadDumpToFileTest.java: Basic test for jcmd Thread.dump_to_file
serviceability/dcmd/thread/VThreadCommandsTest.java: Basic test for jcmd Thread.vthread_scheduler and Thread.vthread_pollers
serviceability/dcmd/vm/ClassHierarchyTest.java: Test of diagnostic command VM.class_hierarchy
serviceability/dcmd/vm/ClassLoaderHierarchyTest.java: Test of diagnostic command VM.classloaders
serviceability/dcmd/vm/ClassLoaderStatsTest.java#id0: Test of diagnostic command VM.classloader_stats
serviceability/dcmd/vm/ClassLoaderStatsTest.java#id1: Test of diagnostic command VM.classloader_stats (-UseCCP)
serviceability/dcmd/vm/CommandLineTest.java: Test of diagnostic command VM.command_line
serviceability/dcmd/vm/DictionaryStatsTest.java: Test of diagnostic command VM.systemdictionary which prints dictionary stats
serviceability/dcmd/vm/DynLibsTest.java: Test of VM.dynlib diagnostic command via MBean
serviceability/dcmd/vm/EventsTest.java: Test of diagnostic command VM.events
serviceability/dcmd/vm/FlagsTest.java: Test of diagnostic command VM.flags
serviceability/dcmd/vm/MallocInfoTest.java: Test of diagnostic command System.native_heap_info
serviceability/dcmd/vm/SetVMFlagTest.java: Test of VM.set_flag diagnostic command
serviceability/dcmd/vm/SystemDumpMapTest.java: Test of diagnostic command System.map
serviceability/dcmd/vm/SystemMapTest.java#normal: Test of diagnostic command System.map
serviceability/dcmd/vm/SystemMapTest.java#zgc: Test of diagnostic command System.map using ZGC
serviceability/dcmd/vm/SystemPropertiesTest.java: Test of diagnostic command VM.system_properties
serviceability/dcmd/vm/TrimLibcHeapTest.java: Test of diagnostic command VM.trim_libc_heap
serviceability/dcmd/vm/UptimeTest.java: Test of diagnostic command VM.uptime
serviceability/dtrace/DTraceOptionsTest.java#enabled: Test DTrace options are accepted on suitable builds
serviceability/jdwp/AllModulesCommandTest.java: Tests the modules-related JDWP commands
serviceability/jvmti/8036666/GetObjectLockCount.java: verify jvm returns correct lock recursion count
serviceability/jvmti/AddModuleExportsAndOpens/MyPackage/AddModuleExportsAndOpensTest.java: Verifies the JVMTI AddModuleExports and AddModuleOpens API
serviceability/jvmti/AddModuleReads/MyPackage/AddModuleReadsTest.java: Verifies the JVMTI AddModuleReads API
serviceability/jvmti/AddModuleUsesAndProvides/MyPackage/AddModuleUsesAndProvidesTest.java: Basic test for JVMTI AddModuleUses and AddModuleProvides
serviceability/jvmti/CanGenerateAllClassHook/CanGenerateAllClassHook.java: Tests that jvmtiEnv::GetPotentialCapabilities reports can_generate_all_class_hook_events capability with CDS (-Xshare:on) at ONLOAD and LIVE phases
serviceability/jvmti/CompiledMethodLoad/Zombie.java: Generate compiled method load events without crashing
serviceability/jvmti/DynamicCodeGenerated/DynamicCodeGeneratedTest.java: Test concurrent enabling and posting of DynamicCodeGenerated events.
serviceability/jvmti/FieldAccessWatch/FieldAccessWatch.java: Tests that all FieldAccess and FieldModification notifications are generated.
serviceability/jvmti/FollowReferences/FieldIndices/FieldIndicesTest.java: The test verifies heap walking API (FollowReferences) reports field indeces in correct order (as described by jvmtiHeapReferenceInfoField spec).
serviceability/jvmti/GenerateEvents/MyPackage/GenerateEventsTest.java: Send CompiledMethodLoad events only to the environment requested it with GenerateEvents
serviceability/jvmti/GetClassFields/FilteredFields/FilteredFieldsTest.java: Verifies JVMTI GetClassFields function filters out fields the same way Class.getDeclaredFields() does.
serviceability/jvmti/GetClassMethods/OverpassMethods.java: GetClassMethods is confused by the presence of default methods in super interfaces
serviceability/jvmti/GetLocalVariable/GetLocalVars.java: VM_GetOrSetLocal doesn't check local slot type against requested type
serviceability/jvmti/GetLocalVariable/GetSetLocalUnsuspended.java: Verifies JVMTI GetLocalXXX/SetLocalXXX return errors for unsuspended vthreads
serviceability/jvmti/GetMethodDeclaringClass/TestUnloadedClass.java: Stress test GetMethodDeclaringClass
serviceability/jvmti/GetModulesInfo/JvmtiGetAllModulesTest.java: Verifies the JVMTI GetAllModules API
serviceability/jvmti/GetNamedModule/MyPackage/GetNamedModuleTest.java: Verifies the JVMTI GetNamedModule API
serviceability/jvmti/GetObjectSizeClass.java: JvmtiEnv::GetObjectSize reports incorrect java.lang.Class instance size
serviceability/jvmti/GetOwnedMonitorInfo/GetOwnedMonitorInfoTest.java: Checks that a contended monitor does not show up in the list of owned monitors.
serviceability/jvmti/GetOwnedMonitorInfo/GetOwnedMonitorInfoWithEATest.java: Test JVMTI's GetOwnedMonitorInfo with scalar replaced objects and eliminated locks on stack (optimizations based on escape analysis).
serviceability/jvmti/GetOwnedMonitorStackDepthInfo/GetOwnedMonitorStackDepthInfoTest.java: Need to cover JVMTI's GetOwnedMonitorStackDepthInfo function
serviceability/jvmti/GetOwnedMonitorStackDepthInfo/GetOwnedMonitorStackDepthInfoWithEATest.java: Test JVMTI's GetOwnedMonitorStackDepthInfo with scalar replaced objects and eliminated locks on stack (optimizations based on escape analysis).
serviceability/jvmti/GetSystemProperty/JvmtiGetSystemPropertyTest.java: Verifies the JVMTI GetSystemProperty API returns the updated java.vm.info value
serviceability/jvmti/GetThreadListStackTraces/OneGetThreadListStackTraces.java: Verifies JVMTI GetThreadListStackTraces API with thread_count = 1
serviceability/jvmti/Heap/IterateHeapWithEscapeAnalysisEnabled.java: JVMTI agents can obtain references to not escaping objects using JVMTI Heap functions.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorArrayAllSampledTest.java: Verifies the JVMTI Heap Monitor interval when allocating arrays.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorEventOnOffTest.java: Verifies if turning off the event notification stops events.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorGCParallelTest.java: Verifies the JVMTI Heap Monitor Statistics using ParallelGc
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorGCSerialTest.java: Verifies the JVMTI Heap Monitor Statistics using SerialGC
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorGCTest.java: Verifies the default GC with the Heap Monitor event system.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorIllegalArgumentTest.java: Verifies the JVMTI SetHeapSamplingInterval returns an illegal argument for negative ints.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorInitialAllocationTest.java: Verifies the JVMTI Heap Monitor does not always sample the first object.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorInterpreterArrayTest.java: Verifies the JVMTI Heap Monitor using the interpreter.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorInterpreterObjectTest.java: Verifies the JVMTI Heap Monitor using the interpreter.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorMultiArrayTest.java: Verifies the JVMTI Heap Monitor API when allocating a multi-array.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorNoCapabilityTest.java: Verifies the JVMTI Heap Monitor does not work without the required capability.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorRecursiveTest.java: Verifies the JVMTI Heap Monitor API does not do infinite recursion.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorStatArrayCorrectnessTest.java: Verifies the JVMTI Heap Monitor interval when allocating arrays.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorStatIntervalTest.java: Verifies the JVMTI Heap Monitor sampling interval average.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorStatObjectCorrectnessTest.java: Verifies the JVMTI Heap Monitor sampling via object allocation.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorStatSimpleTest.java: Verifies the JVMTI Heap Monitor events are only sent after enabling.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorTest.java: Verifies the JVMTI Heap Monitor API
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorThreadDisabledTest.java: Verifies the JVMTI Heap Monitor Thread can disable events for a given thread.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorThreadOnOffTest.java: Verifies the JVMTI Heap Monitor Thread sanity.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorThreadTest.java: Verifies the JVMTI Heap Monitor Thread information sanity.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorTwoAgentsTest.java: Verifies the JVMTI Heap Monitor does not work with two agents.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorVMEventsTest.java#id0: Verifies that when the VM event is sent, sampled events are also collected.
serviceability/jvmti/HeapMonitor/MyPackage/HeapMonitorVMEventsTest.java#id1: Verifies that when the VM event is sent, sampled events are also collected.
serviceability/jvmti/HiddenClass/P/Q/HiddenClassSigTest.java:
serviceability/jvmti/IsModifiableModule/MyPackage/IsModifiableModuleTest.java: Verifies the JVMTI IsModifiableModule API
serviceability/jvmti/ModuleAwareAgents/ClassFileLoadHook/MAAClassFileLoadHook.java:
serviceability/jvmti/ModuleAwareAgents/ClassLoadPrepare/MAAClassLoadPrepare.java: Verify ClassLoad and ClassPrepare JVMTI event with and without can_generate_early_vmstart capability
serviceability/jvmti/ModuleAwareAgents/ThreadStart/MAAThreadStart.java: Verify ThreadStart JVMTI event with can_generate_early_vmstart capability
serviceability/jvmti/NotifyFramePop/NotifyFramePopTest.java: Verifies NotifyFramePop request is cleared if JVMTI_EVENT_FRAME_POP is disabled
serviceability/jvmti/ObjectMonitorUsage/ObjectMonitorUsage.java: converted from VM Testbase nsk/jvmti/GetObjectMonitorUsage/objmonusage003 DESCRIPTION The test checks if the JVMTI function GetObjectMonitorUsage returns the expected values for the owner, entry_count, waiter_count fields of JVMTI_monitor_info.
serviceability/jvmti/RedefineClasses/MissedStackMapFrames/MissedStackMapFrames.java:
serviceability/jvmti/RedefineClasses/ModifyAnonymous.java: Test that retransforming and redefining anonymous classes gets UnmodifiableClassException
serviceability/jvmti/RedefineClasses/RedefineAddLambdaExpression.java: Redefine a class' public static method that contains a lambda expression
serviceability/jvmti/RedefineClasses/RedefineAnnotations.java: Test that type annotations are retained after a retransform
serviceability/jvmti/RedefineClasses/RedefineDoubleDelete.java: Redefine class with CFLH twice to test deleting the cached_class_file
serviceability/jvmti/RedefineClasses/RedefineFinalizer.java: Don't assert if we redefine finalize method
serviceability/jvmti/RedefineClasses/RedefineGenericSignatureTest.java: Verifies class redefinition correctly updates generic_signature and source_file_name attributes
serviceability/jvmti/RedefineClasses/RedefineInterfaceCall.java: Redefine class with interface method call
serviceability/jvmti/RedefineClasses/RedefineInterfaceMethods.java: Redefine private and default interface methods
serviceability/jvmti/RedefineClasses/RedefineLeak.java: Test that redefinition reuses metaspace blocks that are freed
serviceability/jvmti/RedefineClasses/RedefineLeakThrowable.java: Test that redefinition of class containing Throwable refs does not leak constant pool
serviceability/jvmti/RedefineClasses/RedefineObject.java: Ensure Object natives stay registered after redefinition
serviceability/jvmti/RedefineClasses/RedefinePreviousVersions.java: Test clean_previous_versions flag and processing during class unloading.
serviceability/jvmti/RedefineClasses/RedefineRetransform/RedefineRetransform.java:
serviceability/jvmti/RedefineClasses/RedefineRunningMethods.java: Redefine EMCP and non-EMCP methods that are running in an infinite loop
serviceability/jvmti/RedefineClasses/RedefineRunningMethodsWithBacktrace.java: Get old method's stack trace elements after GC
serviceability/jvmti/RedefineClasses/RedefineRunningMethodsWithResolutionErrors.java: Redefine running methods that have cached resolution errors
serviceability/jvmti/RedefineClasses/RedefineSharedClass.java: Verify should_clean_previous_versions when run with retransformation and CDS
serviceability/jvmti/RedefineClasses/RedefineSubtractLambdaExpression.java: Redefine a class' public static method that contains a lambda expression
serviceability/jvmti/RedefineClasses/RedefineVerifyError.java: Redefine VerifyError to get a VerifyError should not throw SOE
serviceability/jvmti/RedefineClasses/RetransformClassesZeroLength.java: Instrumentation.retransformClasses(new Class[0]) should be NOP
serviceability/jvmti/RedefineClasses/TestAddDeleteMethods.java: RI does not follow the JVMTI RedefineClasses spec; need to disallow adding and deleting methods
serviceability/jvmti/RedefineClasses/TestLambdaFormRetransformation.java: JSR 292: constant pool reconstitution must support pseudo strings
serviceability/jvmti/RedefineClasses/TestMultipleClasses.java: Scalability problem with redefinition - multiple code cache walks
serviceability/jvmti/RedefineClasses/TestRedefineCondy.java: Test redefining a class with a condy in its constant pool
serviceability/jvmti/RedefineClasses/TestRedefineObject.java:
serviceability/jvmti/RedefineClasses/TestRedefineWithUnresolvedClass.java: Redefine a class with an UnresolvedClass reference in the constant pool.
serviceability/jvmti/RedefineClasses/TransformerDeadlockTest.java: Test recursively retransforms the same class.
serviceability/jvmti/SetBreakpoint/TestManyBreakpoints.java:
serviceability/jvmti/SetTag/TagMapTest.java: Test that 10M tags doesn't time out.
serviceability/jvmti/StartPhase/AllowedFunctions/AllowedFunctions.java: Verify the functions that are allowed to operate in the start phase with and without can_generate_early_vmstart capability.
serviceability/jvmti/SuspendWithCurrentThread/SuspendWithCurrentThread.java: [TEST] develop a test case for SuspendThreadList including current thread
serviceability/jvmti/SuspendWithObjectMonitorEnter/SuspendWithObjectMonitorEnter.java: Test SuspendThread with ObjectMonitor enter.
serviceability/jvmti/SuspendWithObjectMonitorWait/SuspendWithObjectMonitorWait.java: Test SuspendThread with ObjectMonitor wait.
serviceability/jvmti/SuspendWithRawMonitorEnter/SuspendWithRawMonitorEnter.java: Test SuspendThread with RawMonitor enter.
serviceability/jvmti/VMEvent/MyPackage/VMEventRecursionTest.java: Verifies that a VM event callback does not recurse if a VM object is allocated during callback.
serviceability/jvmti/VMObjectAlloc/VMObjectAllocTest.java: Verifies that a VMObjectAlloc event is generated for object created using MethodHandle
serviceability/jvmti/events/Breakpoint/breakpoint01/breakpoint01.java: converted from VM Testbase nsk/jvmti/Breakpoint/breakpoint001.
serviceability/jvmti/events/ClassLoad/classload01/classload01.java: converted from VM Testbase nsk/jvmti/ClassLoad/classload001.
serviceability/jvmti/events/ClassPrepare/classprep01/classprep01.java: converted from VM Testbase nsk/jvmti/ClassPrepare/classprep001.
serviceability/jvmti/events/Exception/exception01/exception01.java: converted from VM Testbase nsk/jvmti/Exception/exception001.
serviceability/jvmti/events/ExceptionCatch/excatch01/excatch01.java: converted from VM Testbase nsk/jvmti/ExceptionCatch/excatch001.
serviceability/jvmti/events/FieldAccess/fieldacc01/fieldacc01.java: converted from VM Testbase nsk/jvmti/FieldAccess/fieldacc001.
serviceability/jvmti/events/FieldAccess/fieldacc02/fieldacc02.java: converted from VM Testbase nsk/jvmti/FieldAccess/fieldacc002.
serviceability/jvmti/events/FieldAccess/fieldacc03/fieldacc03.java: converted from VM Testbase nsk/jvmti/FieldAccess/fieldacc003.
serviceability/jvmti/events/FieldAccess/fieldacc04/fieldacc04.java: converted from VM Testbase nsk/jvmti/FieldAccess/fieldacc004.
serviceability/jvmti/events/FieldModification/fieldmod01/fieldmod01.java: converted from VM Testbase nsk/jvmti/FieldModification/fieldmod001.
serviceability/jvmti/events/FieldModification/fieldmod02/fieldmod02.java: converted from VM Testbase nsk/jvmti/FieldModification/fieldmod002.
serviceability/jvmti/events/FramePop/ClearAllFramePops/ClearAllFramePops.java#platform: Verifies JVMTI ClearAllFramePops clears all FramePop requests
serviceability/jvmti/events/FramePop/ClearAllFramePops/ClearAllFramePops.java#virtual: Verifies JVMTI ClearAllFramePops clears all FramePop requests
serviceability/jvmti/events/FramePop/framepop01/framepop01.java: converted from VM Testbase nsk/jvmti/FramePop/framepop001.
serviceability/jvmti/events/FramePop/framepop02/framepop02.java#id0: converted from VM Testbase nsk/jvmti/FramePop/framepop002.
serviceability/jvmti/events/FramePop/framepop02/framepop02.java#id1:
serviceability/jvmti/events/MethodEntry/mentry01/mentry01.java: converted from VM Testbase nsk/jvmti/MethodEntry/mentry001.
serviceability/jvmti/events/MethodEntry/mentry02/mentry02.java: converted from VM Testbase nsk/jvmti/MethodEntry/mentry002.
serviceability/jvmti/events/MethodExit/mexit01/mexit01.java: converted from VM Testbase nsk/jvmti/MethodExit/mexit001.
serviceability/jvmti/events/MethodExit/mexit02/mexit02.java: converted from VM Testbase nsk/jvmti/MethodExit/mexit002.
serviceability/jvmti/events/MonitorContendedEnter/mcontenter01/mcontenter01.java: converted from VM Testbase nsk/jvmti/MonitorContendedEnter/mcontenter001.
serviceability/jvmti/events/MonitorContendedEntered/mcontentered01/mcontentered01.java: converted from VM Testbase nsk/jvmti/MonitorContendedEntered/mcontentered001.
serviceability/jvmti/events/MonitorWait/monitorwait01/monitorwait01.java: converted from VM Testbase nsk/jvmti/MonitorWait/monitorwait001.
serviceability/jvmti/events/MonitorWaited/monitorwaited01/monitorwaited01.java: converted from VM Testbase nsk/jvmti/MonitorWaited/monitorwaited001.
serviceability/jvmti/events/NativeMethodBind/nativemethbind01/nativemethbind01.java: converted from VM Testbase nsk/jvmti/NativeMethodBind/nativemethbind001.
serviceability/jvmti/events/NativeMethodBind/nativemethbind02/nativemethbind02.java: converted from VM Testbase nsk/jvmti/NativeMethodBind/nativemethbind002.
serviceability/jvmti/events/NativeMethodBind/nativemethbind03/nativemethbind03.java: converted from VM Testbase nsk/jvmti/NativeMethodBind/nativemethbind003.
serviceability/jvmti/events/NativeMethodBind/nativemethbind04/nativemethbind04.java: converted from VM Testbase nsk/jvmti/NativeMethodBind/nativemethbind004.
serviceability/jvmti/events/NotifyFramePopStressTest/NotifyFramePopStressTest.java: JVMTI FRAME_POP event is sometimes missed if NotifyFramePop is called as a method is returning
serviceability/jvmti/events/SingleStep/singlestep01/singlestep01.java: converted from VM Testbase nsk/jvmti/SingleStep/singlestep001.
serviceability/jvmti/events/SingleStep/singlestep02/singlestep02.java: converted from VM Testbase nsk/jvmti/SingleStep/singlestep002.
serviceability/jvmti/events/SingleStep/singlestep03/singlestep03.java: converted from VM Testbase nsk/jvmti/SingleStep/singlestep003.
serviceability/jvmti/events/ThreadEnd/threadend01/threadend01.java: converted from VM Testbase nsk/jvmti/ThreadEnd/threadend001.
serviceability/jvmti/events/ThreadEnd/threadend02/threadend02.java: converted from VM Testbase nsk/jvmti/ThreadEnd/threadend002.
serviceability/jvmti/events/ThreadStart/threadstart01/threadstart01.java: converted from VM Testbase nsk/jvmti/ThreadStart/threadstart001.
serviceability/jvmti/events/ThreadStart/threadstart02/threadstart02.java: converted from VM Testbase nsk/jvmti/ThreadStart/threadstart002.
serviceability/jvmti/events/ThreadStart/threadstart03/threadstart03.java: converted from VM Testbase nsk/jvmti/ThreadStart/threadstart003.
serviceability/jvmti/events/VMObjectAlloc/vmobjalloc01/vmobjalloc01.java: converted from VM Testbase nsk/jvmti/VMObjectAlloc/vmobjalloc001.
serviceability/jvmti/negative/GetAllThreadsNullTest/GetAllThreadsNullTest.java: converted from VM Testbase nsk/jvmti/GetAllThreads/allthr002.
serviceability/jvmti/negative/contmon03/contmon03.java: converted from VM Testbase nsk/jvmti/GetCurrentContendedMonitor/contmon003.
serviceability/jvmti/negative/framecnt02/framecnt02.java: converted from VM Testbase nsk/jvmti/GetFrameCount/framecnt002.
serviceability/jvmti/negative/framecnt03/framecnt03.java: converted from VM Testbase nsk/jvmti/GetFrameCount/framecnt003.
serviceability/jvmti/negative/frameloc03/frameloc03.java: converted from VM Testbase nsk/jvmti/GetFrameLocation/frameloc003.
serviceability/jvmti/negative/getstacktr02/getstacktr02.java: converted from VM Testbase nsk/jvmti/GetStackTrace/getstacktr002.
serviceability/jvmti/negative/getstacktr09/getstacktr09.java: converted from VM Testbase nsk/jvmti/GetStackTrace/getstacktr009.
serviceability/jvmti/negative/thrinfo02/thrinfo02.java: converted from VM Testbase nsk/jvmti/GetThreadInfo/thrinfo002.
serviceability/jvmti/negative/thrstat04/thrstat04.java: converted from VM Testbase nsk/jvmti/GetThreadState/thrstat004.
serviceability/jvmti/stress/StackTrace/Suspended/GetStackTraceSuspendedStressTest.java: Verifies JVMTI GetStackTrace functions called after vthread is suspended.
serviceability/jvmti/stress/ThreadLocalStorage/SetGetThreadLocalStorageStressTest/SetGetThreadLocalStorageStressTest.java: Test verifies set/get TLS data and verifies it's consistency.
serviceability/jvmti/thread/GetAllThreads/allthr01/allthr01.java: converted from VM Testbase nsk/jvmti/GetAllThreads/allthr001.
serviceability/jvmti/thread/GetCurrentContendedMonitor/contmon01/contmon01.java: converted from VM Testbase nsk/jvmti/GetCurrentContendedMonitor/contmon01.
serviceability/jvmti/thread/GetCurrentContendedMonitor/contmon02/contmon02.java: converted from VM Testbase nsk/jvmti/GetCurrentContendedMonitor/contmon002.
serviceability/jvmti/thread/GetFrameCount/framecnt01/framecnt01.java: converted from VM Testbase nsk/jvmti/GetFrameCount/framecnt001.
serviceability/jvmti/thread/GetFrameLocation/frameloc01/frameloc01.java: converted from VM Testbase nsk/jvmti/GetFrameLocation/frameloc001.
serviceability/jvmti/thread/GetFrameLocation/frameloc02/frameloc02.java: converted from VM Testbase nsk/jvmti/GetFrameLocation/frameloc002.
serviceability/jvmti/thread/GetStackTrace/GetStackTraceAndRetransformTest/GetStackTraceAndRetransformTest.java: Test that a sequence of method retransformation and stacktrace capture while the old method version is still on stack does not lead to a crash when that method's jmethodID is used as an argument for JVMTI functions.
serviceability/jvmti/thread/GetStackTrace/GetStackTraceCurrentThreadTest/GetStackTraceCurrentThreadTest.java: converted from VM Testbase nsk/jvmti/GetStackTrace/getstacktr001.
serviceability/jvmti/thread/GetStackTrace/getstacktr03/getstacktr03.java: converted from VM Testbase nsk/jvmti/GetStackTrace/getstacktr003.
serviceability/jvmti/thread/GetStackTrace/getstacktr04/getstacktr04.java: converted from VM Testbase nsk/jvmti/GetStackTrace/getstacktr004.
serviceability/jvmti/thread/GetStackTrace/getstacktr05/getstacktr05.java: converted from VM Testbase nsk/jvmti/GetStackTrace/getstacktr005.
serviceability/jvmti/thread/GetStackTrace/getstacktr06/getstacktr06.java: converted from VM Testbase nsk/jvmti/GetStackTrace/getstacktr006.
serviceability/jvmti/thread/GetStackTrace/getstacktr07/getstacktr07.java: converted from VM Testbase nsk/jvmti/GetStackTrace/getstacktr007.
serviceability/jvmti/thread/GetStackTrace/getstacktr08/getstacktr08.java: converted from VM Testbase nsk/jvmti/GetStackTrace/getstacktr008.
serviceability/jvmti/thread/GetThreadInfo/thrinfo01/thrinfo01.java: converted from VM Testbase nsk/jvmti/GetThreadInfo/thrinfo001.
serviceability/jvmti/thread/GetThreadState/thrstat01/thrstat01.java: converted from VM Testbase nsk/jvmti/GetThreadState/thrstat001.
serviceability/jvmti/thread/GetThreadState/thrstat02/thrstat02.java: converted from VM Testbase nsk/jvmti/GetThreadState/thrstat002.
serviceability/jvmti/thread/GetThreadState/thrstat03/thrstat03.java: converted from VM Testbase nsk/jvmti/GetThreadState/thrstat003.
serviceability/jvmti/thread/GetThreadState/thrstat05/thrstat05.java: converted from VM Testbase nsk/jvmti/GetThreadState/thrstat005.
serviceability/jvmti/thread/ResumeThread/resumethrd01/resumethrd01.java: converted from VM Testbase nsk/jvmti/ResumeThread/resumethrd001.
serviceability/jvmti/thread/ResumeThread/resumethrd02/resumethrd02.java: converted from VM Testbase nsk/jvmti/ResumeThread/resumethrd02.
serviceability/jvmti/thread/ResumeThreadList/resumethrdlst01/resumethrdlst01.java: converted from VM Testbase nsk/jvmti/ResumeThreadList/resumethrdlst001.
serviceability/jvmti/thread/ResumeThreadList/resumethrdlst02/resumethrdlst02.java: converted from VM Testbase nsk/jvmti/ResumeThreadList/resumethrdlst002.
serviceability/jvmti/thread/SuspendThread/suspendthrd01/suspendthrd01.java: converted from VM Testbase nsk/jvmti/SuspendThread/suspendthrd001.
serviceability/jvmti/thread/SuspendThread/suspendthrd02/suspendthrd02.java: converted from VM Testbase nsk/jvmti/SuspendThread/suspendthrd002.
serviceability/jvmti/thread/SuspendThreadList/suspendthrdlst01/suspendthrdlst01.java: converted from VM Testbase nsk/jvmti/SuspendThreadList/suspendthrdlst001.
serviceability/jvmti/thread/SuspendThreadList/suspendthrdlst02/suspendthrdlst02.java: converted from VM Testbase nsk/jvmti/SuspendThreadList/suspendthrdlst002.
serviceability/jvmti/vthread/BoundVThreadTest/BoundVThreadTest.java: Verifies correct JVMTI behavior for BoundVirtualThreads.
serviceability/jvmti/vthread/BreakpointInYieldTest/BreakpointInYieldTest.java: Verifies that JVMTI function return correct info in Breakpoint events in Continuation.yield0().
serviceability/jvmti/vthread/CheckHiddenFrames/CheckHiddenFrames.java: Verifies JVMTI properly hides frames which are in VTMS transition
serviceability/jvmti/vthread/ContFramePopTest/ContFramePopTest.java: Verifies JVMTI support for Continuations
serviceability/jvmti/vthread/ContStackDepthTest/ContStackDepthTest.java: Verifies JVMTI support for Continuations
serviceability/jvmti/vthread/ContYieldBreakPointTest/ContYieldBreakPointTest.java: Verifies setting a breakpoint in Continuation.yield() followed by single stepping
serviceability/jvmti/vthread/ContinuationTest/ContinuationTest.java: Verifies JVMTI support for Continuations
serviceability/jvmti/vthread/FollowReferences/VThreadStackRefTest.java#default:
serviceability/jvmti/vthread/FollowReferences/VThreadStackRefTest.java#no-vmcontinuations:
serviceability/jvmti/vthread/ForceEarlyReturnTest/ForceEarlyReturnTest.java#default: Verifies JVMTI ForceEarlyReturn support for virtual threads.
serviceability/jvmti/vthread/ForceEarlyReturnTest/ForceEarlyReturnTest.java#no-vmcontinuations: Verifies JVMTI ForceEarlyReturn support for bound virtual threads.
serviceability/jvmti/vthread/ForceEarlyReturnTest/ForceEarlyReturnTest.java#platform: Verifies JVMTI ForceEarlyReturn support for platform threads.
serviceability/jvmti/vthread/GetThreadState/GetThreadStateTest.java#default: Basic test for JVMTI GetThreadState with virtual threads
serviceability/jvmti/vthread/GetThreadState/GetThreadStateTest.java#no-vmcontinuations:
serviceability/jvmti/vthread/HeapDump/VThreadInHeapDump.java#default:
serviceability/jvmti/vthread/HeapDump/VThreadInHeapDump.java#no-vmcontinuations:
serviceability/jvmti/vthread/InterruptRawMonitor/InterruptRawMonitor.java: Verifies JVMTI InterruptThread works for virtual threads.
serviceability/jvmti/vthread/InterruptThreadTest/InterruptThreadTest.java#default: Verifies JVMTI InterruptThread works for virtual threads.
serviceability/jvmti/vthread/InterruptThreadTest/InterruptThreadTest.java#no-vmcontinuations:
serviceability/jvmti/vthread/MethodExitTest/MethodExitTest.java: Verifies that MethodExit events are delivered on both carrier and virtual threads.
serviceability/jvmti/vthread/NullAsCurrentThreadTest/NullAsCurrentThreadTest.java#default: Verifies specific JVMTI functions work with current virtual thread passed as NULL.
serviceability/jvmti/vthread/NullAsCurrentThreadTest/NullAsCurrentThreadTest.java#no-vmcontinuations:
serviceability/jvmti/vthread/PinnedTaskTest/PinnedTaskTest.java#default: Verifies JVMTI hadles pinned virtual threads correctly.
serviceability/jvmti/vthread/PinnedTaskTest/PinnedTaskTest.java#no-vmcontinuations:
serviceability/jvmti/vthread/PopFrameTest/PopFrameTest.java#default: Verifies JVMTI PopFrame support for virtual threads.
serviceability/jvmti/vthread/PopFrameTest/PopFrameTest.java#no-vmcontinuations: Verifies JVMTI PopFrame support for bound virtual threads.
serviceability/jvmti/vthread/PopFrameTest/PopFrameTest.java#platform: Verifies JVMTI PopFrame support for platform threads.
serviceability/jvmti/vthread/RawMonitorTest/RawMonitorTest.java: Verifies JVMTI RawMoitor functions works correctly on virtual threads
serviceability/jvmti/vthread/RedefineClasses/RedefineRunningMethods.java: Redefine EMCP and non-EMCP methods that are running in an infinite loop
serviceability/jvmti/vthread/SelfSuspendDisablerTest/SelfSuspendDisablerTest.java#default: Test verifies that selfsuspend doesn' block unmount by VTMTDisabler
serviceability/jvmti/vthread/SelfSuspendDisablerTest/SelfSuspendDisablerTest.java#no-vmcontinuations:
serviceability/jvmti/vthread/StopThreadTest/StopThreadTest.java#default: Verifies JVMTI StopThread support for virtual threads.
serviceability/jvmti/vthread/StopThreadTest/StopThreadTest.java#no-vmcontinuations: Verifies JVMTI StopThread support for bound virtual threads.
serviceability/jvmti/vthread/StopThreadTest/StopThreadTest.java#platform: Verifies JVMTI StopThread support for platform threads.
serviceability/jvmti/vthread/SuspendResume1/SuspendResume1.java#default: Test SuspendThread/ResumeThread, SuspendThreadList/ResumeThreadList for virtual threads.
serviceability/jvmti/vthread/SuspendResume1/SuspendResume1.java#no-vmcontinuations:
serviceability/jvmti/vthread/SuspendResume2/SuspendResume2.java#default: Test SuspendAllVirtualThreads/ResumeAllVirtualThreads
serviceability/jvmti/vthread/SuspendResume2/SuspendResume2.java#no-vmcontinuations:
serviceability/jvmti/vthread/SuspendResumeAll/SuspendResumeAll.java#default: Test SuspendAllVirtualThreads/ResumeAllVirtualThreads
serviceability/jvmti/vthread/SuspendResumeAll/SuspendResumeAll.java#no-vmcontinuations:
serviceability/jvmti/vthread/SuspendWithInterruptLock/SuspendWithInterruptLock.java#default: Do not suspend virtual threads in a critical section.
serviceability/jvmti/vthread/SuspendWithInterruptLock/SuspendWithInterruptLock.java#xint:
serviceability/jvmti/vthread/ThreadListStackTracesTest/ThreadListStackTracesTest.java: GetThreadListStackTraces returns wrong state for blocked VirtualThread
serviceability/jvmti/vthread/ThreadStateTest/ThreadStateTest.java: Exercise JvmtiThreadState creation concurrently with terminating vthreads
serviceability/jvmti/vthread/ToggleNotifyJvmtiTest/ToggleNotifyJvmtiTest.java: Verifies JVMTI works for agents loaded into running VM
serviceability/jvmti/vthread/VThreadEventTest/VThreadEventTest.java: missing JVMTI events from vthreads parked during JVMTI attach
serviceability/jvmti/vthread/VThreadMonitorTest/VThreadMonitorTest.java: Test JVMTI Monitor functions for virtual threads
serviceability/jvmti/vthread/VThreadNotifyFramePopTest/VThreadNotifyFramePopTest.java#default: Verifies that FRAME_POP event is delivered when called from URL.openStream().
serviceability/jvmti/vthread/VThreadNotifyFramePopTest/VThreadNotifyFramePopTest.java#no-vmcontinuations:
serviceability/jvmti/vthread/VThreadTLSTest/VThreadTLSTest.java#id0: Verifies JVMTI GetLocalStorage/SetLocalStorage
serviceability/jvmti/vthread/VThreadTLSTest/VThreadTLSTest.java#id1: Verifies JVMTI GetLocalStorage/SetLocalStorage
serviceability/jvmti/vthread/VThreadTest/VThreadTest.java: Verifies JVMTI support for VThreads.
serviceability/jvmti/vthread/VThreadUnsupportedTest/VThreadUnsupportedTest.java: Verifies that specific JVMTI functions return UNSUPPORTED_OPERATION or OPAQUE_FRAME if called with virtual threads.
serviceability/jvmti/vthread/VirtualStackTraceTest/VirtualStackTraceTest.java#default: Verifies JVMTI GetStackTrace does not truncate virtual thread stack trace with agent attach
serviceability/jvmti/vthread/VirtualStackTraceTest/VirtualStackTraceTest.java#no-vmcontinuations:
serviceability/jvmti/vthread/VirtualThreadStartTest/VirtualThreadStartTest.java: Verifies JVMTI can_support_virtual_threads works for agents loaded at startup and into running VM
serviceability/jvmti/vthread/WaitNotifySuspendedVThreadTest/WaitNotifySuspendedVThreadTest.java: Test verifies that JVMTI raw monitor wait/notify works for suspended virtual thread.
serviceability/jvmti/vthread/premain/AgentWithVThreadTest.java: Test verifies that virtual threads can be executed in premain()
serviceability/logging/TestBasicLogOutput.java: Ensure logging can be enabled and successfully prints to stdout.
serviceability/logging/TestDefaultLogOutput.java: Ensure logging is default on stdout.
serviceability/logging/TestFullNames.java: Ensure proper parsing of unquoted full output names for -Xlog arguments.
serviceability/logging/TestLogRotation.java: test flags for log rotation
serviceability/logging/TestMultipleXlogArgs.java: Ensure multiple -Xlog arguments aggregate the logging options.
serviceability/logging/TestQuotedLogOutputs.java: Ensure proper parsing of quoted output names for -Xlog arguments.
serviceability/monitoring/ThreadInfo/GetLockOwnerName/GetLockOwnerName.java: The test checks that ThreadInfo.getLockOwnerName() returns a non-null string for a blocked thread and then makes repeated calls to getThreadInfo() and ThreadInfo.getLockOwnerName() until the thread has exited.
serviceability/threads/TestFalseDeadLock.java: Make sure no deadlock is reported for this program which has no deadlocks.
serviceability/tmtools/jstack/DaemonThreadTest.java: Create daemon and non-deamon threads.
serviceability/tmtools/jstack/JstackThreadTest.java: jstack doesn't close quotation marks properly with threads' name greater than 1996 characters
serviceability/tmtools/jstack/SpreadLockTest.java: Create a thread which stops in methods a(), a()->b(), a()->b()->c(), synchronizing on one monitor inside of each method.
serviceability/tmtools/jstack/ThreadNamesTest.java: Checks that jstack correctly prints the thread names
serviceability/tmtools/jstack/TraveledLockTest.java: Create a thread which stops in methods a(), a()->b(), a()->b()->c(), synchronizing on one monitor inside of each method.
serviceability/tmtools/jstack/WaitNotifyThreadTest.java: Call Object.wait() method.
serviceability/tmtools/jstat/GcCapacityTest.java: Test checks the consistency of the output displayed with jstat -gccapacity.
serviceability/tmtools/jstat/GcCauseTest01.java: Test checks output displayed with jstat -gccause.
serviceability/tmtools/jstat/GcCauseTest02.java: Test checks output displayed with jstat -gccause.
serviceability/tmtools/jstat/GcCauseTest03.java: Test checks output displayed with jstat -gccause.
serviceability/tmtools/jstat/GcNewTest.java: Test checks output displayed with jstat -gcnew.
serviceability/tmtools/jstat/GcTest01.java: Test checks output displayed with jstat -gc.
serviceability/tmtools/jstat/GcTest02.java: Test checks output displayed with jstat -gc.
sources/TestIncludesAreSorted.java: Tests that HotSpot C++ files have sorted includes
sources/TestNoNULL.java: Test prevent NULL backsliding in hotspot code and tests

Skipped: jtreg.SkippedException: Intermittent inflation detected. Invalid test.

runtime/locking/TestRecursiveMonitorChurn.java: Tests that recursive locking doesn't cause excessive native memory usage

Skipped: jtreg.SkippedException: Large page support does not seem to be available on this platform.

gc/g1/TestLargePageUseForAuxMemory.java: Test that auxiliary data structures are allocated using large pages if available.
gc/g1/TestLargePageUseForHeap.java: Test that Java heap is allocated using large pages of the appropriate size if available.

Skipped: jtreg.SkippedException: SA Attach not expected to work. Ptrace attach not supported.

serviceability/sa/CDSJMapClstats.java: Test the jhsdb jmap -clstats command with CDS enabled
serviceability/sa/ClhsdbAttach.java: Test clhsdb attach, detach, reattach commands
serviceability/sa/ClhsdbAttachDifferentJVMs.java: Test clhsdb attach, detach, and then attach to different JVM
serviceability/sa/ClhsdbCDSJstackPrintAll.java: Test the clhsdb commands 'jstack', 'printall', 'where' with CDS enabled
serviceability/sa/ClhsdbClasses.java: Test clhsdb class and classes commands
serviceability/sa/ClhsdbDumpclass.java: Test clhsdb dumpclass command
serviceability/sa/ClhsdbDumpheap.java: Test clhsdb dumpheap command
serviceability/sa/ClhsdbField.java: Test clhsdb 'field' command
serviceability/sa/ClhsdbFindPC.java#no-xcomp-process: Test the clhsdb 'findpc' command w/o Xcomp on live process
serviceability/sa/ClhsdbFindPC.java#xcomp-process: Test the clhsdb 'findpc' command with Xcomp on live process
serviceability/sa/ClhsdbFlags.java: Test clhsdb flags command
serviceability/sa/ClhsdbHistory.java: Test clhsdb command line history support
serviceability/sa/ClhsdbInspect.java: Test the clhsdb 'inspect' command
serviceability/sa/ClhsdbJdis.java: Test the clhsdb 'jdis' command
serviceability/sa/ClhsdbJhisto.java: Test clhsdb jhisto command
serviceability/sa/ClhsdbJstack.java#id0: Test clhsdb Jstack command
serviceability/sa/ClhsdbJstack.java#id1: Test clhsdb Jstack command
serviceability/sa/ClhsdbJstackWithConcurrentLock.java: Test the clhsdb 'jstack -l' command for printing concurrent lock information
serviceability/sa/ClhsdbJstackXcompStress.java:
serviceability/sa/ClhsdbLongConstant.java: Test clhsdb longConstant command
serviceability/sa/ClhsdbPmap.java#process: Test clhsdb pmap command on a live process
serviceability/sa/ClhsdbPrintAll.java: Test clhsdb 'printall' command
serviceability/sa/ClhsdbPrintAs.java: Test the clhsdb 'printas' command
serviceability/sa/ClhsdbPrintStatics.java: Test clhsdb printstatics command
serviceability/sa/ClhsdbPstack.java#process: Test clhsdb pstack command on a live process
serviceability/sa/ClhsdbScanOops.java#id0: Test the clhsdb 'scanoops' command
serviceability/sa/ClhsdbScanOops.java#id1: Test the clhsdb 'scanoops' command
serviceability/sa/ClhsdbSource.java: Test clhsdb source command
serviceability/sa/ClhsdbSymbol.java: Test the clhsdb 'symbol' command on live process
serviceability/sa/ClhsdbTestAllocationMerge.java: Test clhsdb that decoding of AllocationMerge objects in debug info works correctly
serviceability/sa/ClhsdbThread.java: Test clhsdb 'thread' and 'threads' commands
serviceability/sa/ClhsdbThreadContext.java: Test clhsdb where command
serviceability/sa/ClhsdbVmStructsDump.java: Test clhsdb 'vmstructsdump' command
serviceability/sa/ClhsdbWhere.java: Test clhsdb where command
serviceability/sa/DeadlockDetectionTest.java: Test deadlock detection
serviceability/sa/JhsdbThreadInfoTest.java:
serviceability/sa/TestClassDump.java: Test ClassDump tool
serviceability/sa/TestClhsdbJstackLock.java:
serviceability/sa/TestCpoolForInvokeDynamic.java:
serviceability/sa/TestDebugInfoDecode.java: Test decoding debug info for all nmethods in the code cache
serviceability/sa/TestDefaultMethods.java:
serviceability/sa/TestG1HeapRegion.java:
serviceability/sa/TestHeapDumpForInvokeDynamic.java:
serviceability/sa/TestInstanceKlassSize.java:
serviceability/sa/TestInstanceKlassSizeForInterface.java:
serviceability/sa/TestIntConstant.java: Test the 'intConstant' command of jhsdb clhsdb.
serviceability/sa/TestJhsdbJstackLineNumbers.java:
serviceability/sa/TestJhsdbJstackLock.java:
serviceability/sa/TestJhsdbJstackMixed.java:
serviceability/sa/TestJhsdbJstackPrintVMLocks.java: Test verifies that jstack --mixed prints information about VM locks
serviceability/sa/TestJhsdbJstackUpcall.java:
serviceability/sa/TestJhsdbJstackWithVirtualThread.java:
serviceability/sa/TestObjectAlignment.java:
serviceability/sa/TestObjectMonitorIterate.java:
serviceability/sa/TestPrintMdo.java:
serviceability/sa/TestSysProps.java: Test "jhsdb jinfo --sysprops", "jinfo -sysprops", and clhsdb "sysprops" commands
serviceability/sa/TestType.java: Test the 'type' command of jhsdb clhsdb.
serviceability/sa/TestUniverse.java: Test the 'universe' command of jhsdb clhsdb.
serviceability/sa/UniqueVtableTest.java:
serviceability/sa/jmap-hprof/JMapHProfLargeHeapTest.java: Regression test for hprof export issue due to large heaps (>2G)
serviceability/sa/sadebugd/ClhsdbAttachToDebugServer.java: Test clhsdb connect, detach, reattach commands
serviceability/sa/sadebugd/ClhsdbTestConnectArgument.java:
serviceability/sa/sadebugd/DebugdConnectTest.java: Checks ability for connecting to debug server (jstack, jmap, jinfo, jsnap)
serviceability/sa/sadebugd/DisableRegistryTest.java: Test to use already started RMI registry
serviceability/sa/sadebugd/PmapOnDebugdTest.java:
serviceability/sa/sadebugd/RunCommandOnServerTest.java: Test clhsdb command which should be run on debugd server
serviceability/sa/sadebugd/SADebugDTest.java: Checks that the jshdb debugd utility successfully starts and tries to attach to a running process

Skipped: jtreg.SkippedException: This system uses a crash report tool

serviceability/sa/ClhsdbCDSCore.java: Test the clhsdb commands 'printmdo', 'printall', 'jstack' on a CDS enabled corefile.
serviceability/sa/ClhsdbFindPC.java#no-xcomp-core: Test the clhsdb 'findpc' command w/o Xcomp on core file
serviceability/sa/ClhsdbFindPC.java#xcomp-core: Test the clhsdb 'findpc' command with Xcomp on core file
serviceability/sa/ClhsdbPmap.java#core: Test clhsdb pmap command on a core file
serviceability/sa/ClhsdbPstack.java#core: Test clhsdb pstack command on a core file
serviceability/sa/TestJmapCore.java: Test verifies that jhsdb jmap could generate heap dump from core when heap is full
serviceability/sa/TestJmapCoreMetaspace.java: Test verifies that jhsdb jmap could generate heap dump from core when metaspace is full

Skipped: jtreg.SkippedException: either NUMA or HugeTLB is not supported

gc/arguments/TestSmallInitialHeapWithLargePageAndNUMA.java: Check large pages and NUMA are working together via the output message.

Report generated on Apr 26, 2026 5:51:20 PM
Using JT Harness 6.0 b24; built on January 25, 1970, 12:00:00 AM UTC with openjdk version "17.0.4" 2022-07-19