JT Harness : Tests that passed

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/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/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/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/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/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#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/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#adaptive:
• gc/shenandoah/TestDynamicSoftMaxHeapSize.java#aggressive:
• gc/shenandoah/TestDynamicSoftMaxHeapSize.java#compact:
• gc/shenandoah/TestDynamicSoftMaxHeapSize.java#generational:
• gc/shenandoah/TestDynamicSoftMaxHeapSize.java#passive:
• gc/shenandoah/TestDynamicSoftMaxHeapSize.java#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/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/JavaAgent.java: -javaagent should be allowed in AOT workflow.
• 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/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/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.