wip Stable and unique Lambda and LambdaForm class names

runtime/bcutil/ComparingCursor.cpp

@@ -428,29 +428,10 @@ ComparingCursor::shouldCheckForEquality(DataType dataType, U_32 u32Value)
  }
 
  switch (dataType) {
- case SRP_TO_UTF8_CLASS_NAME:
-#if JAVA_SPEC_VERSION < 21
- if (_context->isLambdaClass() && _romClassIsShared) {
- /*
- * If the class is a lambda class, don't compare the class names because lambda
- * classes might have different index numbers from run to run.
- */
- return false;
- }
-#endif /* JAVA_SPEC_VERSION < 21 */
- break;
+ case SRP_TO_UTF8_CLASS_NAME: /* fall through */
  case BYTECODE: /* fall through */
  case GENERIC: /* fall through */
  case CLASS_FILE_SIZE: /* fall through */
-#if JAVA_SPEC_VERSION < 21
- if ((CLASS_FILE_SIZE == dataType) 
- && _context->isLambdaClass()
- && _romClassIsShared
- ) {
- /* If comparing a lambda class from the shared cache, class file size comparison is already done in ROMClassBuilder::compareROMClassForEquality(). */
- return false;
- }
-#endif /* JAVA_SPEC_VERSION < 21 */
  case SRP_TO_DEBUG_DATA: /* fall through */
  case SRP_TO_GENERIC: /* fall through */
  case SRP_TO_UTF8: /* fall through */

runtime/bcutil/ROMClassBuilder.cpp

@@ -277,16 +277,6 @@ ROMClassBuilder::handleAnonClassName(J9CfrClassFile *classfile, ROMClassCreation
  PORT_ACCESS_FROM_PORT(_portLibrary);
 
 #if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
- /*
- * Prevent generated LambdaForm classes from MethodHandles to be stored to the shared cache.
- * When there are a large number of such classes in the shared cache, they trigger a lot of class comparisons.
- * Performance can be much worse (compared to shared cache turned off).
- */
- if (isLambdaFormClassName(originalStringBytes, originalStringLength, NULL/*deterministicPrefixLength*/)) {
- context->addFindClassFlags(J9_FINDCLASS_FLAG_DO_NOT_SHARE);
- context->addFindClassFlags(J9_FINDCLASS_FLAG_LAMBDAFORM);
- }
-
 #if JAVA_SPEC_VERSION >= 15
  /* InjectedInvoker is a hidden class without the strong attribute set. It
  * is created by MethodHandleImpl.makeInjectedInvoker on the OpenJDK side.
@@ -417,22 +407,6 @@ ROMClassBuilder::handleAnonClassName(J9CfrClassFile *classfile, ROMClassCreation
  j9str_printf(PORTLIB, buf, ROM_ADDRESS_LENGTH + 1, ROM_ADDRESS_FORMAT, 0);
  memcpy(constantPool[newUtfCPEntry].bytes + newHostPackageLength + originalStringLength + 1, buf, ROM_ADDRESS_LENGTH + 1); 
 
- /* Mark if the class is a Lambda class. */
-#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
- if (!context->isLambdaFormClass()
- && isLambdaClassName(reinterpret_cast<const char *>(_anonClassNameBuffer),
- newAnonClassNameLength - 1, NULL/*deterministicPrefixLength*/)
- ) {
- context->addFindClassFlags(J9_FINDCLASS_FLAG_LAMBDA);
- }
-#else /* defined(J9VM_OPT_OPENJDK_METHODHANDLE) */
- if (isLambdaClassName(reinterpret_cast<const char *>(_anonClassNameBuffer),
- newAnonClassNameLength - 1, NULL/*deterministicPrefixLength*/)
- ) {
- context->addFindClassFlags(J9_FINDCLASS_FLAG_LAMBDA);
- }
-#endif /* defined(J9VM_OPT_OPENJDK_METHODHANDLE) */
-
  /* search constantpool for all other identical classRefs. We have not actually
  * tested this scenario as javac will not output more than one classRef or utfRef of the
  * same kind.
@@ -590,18 +564,6 @@ ROMClassBuilder::prepareAndLaydown( BufferManager *bufferManager, ClassFileParse
  getSizeInfo(context, &romClassWriter, &srpOffsetTable, &countDebugDataOutOfLine, &sizeInformation);
 
  U_32 romSize = 0;
-#if JAVA_SPEC_VERSION < 21
- U_32 sizeToCompareForLambda = 0;
- if (context->isLambdaClass()) {
- /* 
- * romSize calculated from getSizeInfo() does not involve StringInternManager. It is only accurate for string intern disabled classes. 
- * Lambda classes in java 15 and up are strong hidden classes (defined with Option.STONG), which has the same lifecycle as its
- * defining class loader. It is string intern enabled. So pass classFileSize instead of romSize to sizeToCompareForLambda.
- */
- sizeToCompareForLambda = classFileOracle.getClassFileSize();
- }
-#endif /* JAVA_SPEC_VERSION < 21 */
-
  if (context->shouldCompareROMClassForEquality()) {
  ROMClassVerbosePhase v(context, CompareHashtableROMClass);
 
@@ -624,9 +586,6 @@ ROMClassBuilder::prepareAndLaydown( BufferManager *bufferManager, ClassFileParse
  modifiers,
  extraModifiers,
  optionalFlags,
-#if JAVA_SPEC_VERSION < 21
- sizeToCompareForLambda,
-#endif /* JAVA_SPEC_VERSION < 21 */
  context)
  ) {
  return OK;
@@ -720,9 +679,6 @@ ROMClassBuilder::prepareAndLaydown( BufferManager *bufferManager, ClassFileParse
  modifiers,
  extraModifiers,
  optionalFlags,
-#if JAVA_SPEC_VERSION < 21
- sizeToCompareForLambda,
-#endif /* JAVA_SPEC_VERSION < 21 */
  context)
 
  ) {
@@ -1479,55 +1435,19 @@ ROMClassBuilder::compareROMClassForEquality(
  U_32 modifiers,
  U_32 extraModifiers,
  U_32 optionalFlags,
-#if JAVA_SPEC_VERSION < 21
- U_32 sizeToCompareForLambda,
-#endif /* JAVA_SPEC_VERSION < 21 */
  ROMClassCreationContext *context)
 {
  bool ret = false;
+ ComparingCursor compareCursor(_javaVM, srpOffsetTable, srpKeyProducer, classFileOracle, romClass, romClassIsShared, context);
+ romClassWriter->writeROMClass(&compareCursor,
+ &compareCursor,
+ &compareCursor,
+ NULL,
+ NULL,
+ 0, modifiers, extraModifiers, optionalFlags,
+ ROMClassWriter::WRITE);
 
-#if JAVA_SPEC_VERSION < 21
- if (context->isLambdaClass()) {
- /*
- * Lambda class names are in the format of HostClassName$$Lambda$<IndexNumber>/<zeroed out ROM_ADDRESS>.
- * When we reach this check, the host class names will be the same for both the classes because
- * of the earlier hash-key check. So, the only difference in the size will be the difference
- * between the number of digits of the index number. The same lambda class might have a
- * different index number from run to run and when the number of digits of the index number
- * increases by 1, classFileSize also increases by 1. The indexNumber is the counter for the number of
- * lambda classes defined so far. It is an int in the JCL side. So the it cannot vary more than max
- * integer vs 0, which is maxVariance (9 bytes). This check is different than the romSize check because
- * when the number of digits of the index number increases by 1, classFileSize also increases by 1 but
- * romSize increases by 2.
- */
- int maxVariance = 9;
- int variance = abs(static_cast<int>((sizeToCompareForLambda - reinterpret_cast<J9ROMClass *>(romClass)->classFileSize)));
- if (variance <= maxVariance) {
- ComparingCursor compareCursor(_javaVM, srpOffsetTable, srpKeyProducer, classFileOracle, romClass, romClassIsShared, context);
- romClassWriter->writeROMClass(&compareCursor,
- &compareCursor,
- &compareCursor,
- NULL,
- NULL,
- 0, modifiers, extraModifiers, optionalFlags,
- ROMClassWriter::WRITE);
-
- ret = compareCursor.isEqual();
- }
- } else
-#endif /* JAVA_SPEC_VERSION < 21 */
- {
- ComparingCursor compareCursor(_javaVM, srpOffsetTable, srpKeyProducer, classFileOracle, romClass, romClassIsShared, context);
- romClassWriter->writeROMClass(&compareCursor,
- &compareCursor,
- &compareCursor,
- NULL,
- NULL,
- 0, modifiers, extraModifiers, optionalFlags,
- ROMClassWriter::WRITE);
-
- ret = compareCursor.isEqual();
- }
+ ret = compareCursor.isEqual();
  J9UTF8* name = J9ROMCLASS_CLASSNAME((J9ROMClass *)romClass);
  Trc_BCU_compareROMClassForEquality_event(ret, J9UTF8_LENGTH(name), J9UTF8_DATA(name));
  return ret;

runtime/bcutil/ROMClassBuilder.hpp

@@ -169,9 +169,6 @@ class ROMClassBuilder
  U_32 modifiers,
  U_32 extraModifiers,
  U_32 optionalFlags,
-#if JAVA_SPEC_VERSION < 21
- U_32 sizeToCompareForLambda,
-#endif /* JAVA_SPEC_VERSION < 21 */
  ROMClassCreationContext *context);
 
  SharedCacheRangeInfo getSharedCacheSRPRangeInfo(void *address);

runtime/bcutil/ROMClassCreationContext.hpp

@@ -240,10 +240,6 @@ class ROMClassCreationContext
  bool isHiddenClassOptNestmateSet() const { return J9_ARE_ALL_BITS_SET(_findClassFlags, J9_FINDCLASS_FLAG_CLASS_OPTION_NESTMATE); }
  bool isHiddenClassOptStrongSet() const { return J9_ARE_ALL_BITS_SET(_findClassFlags, J9_FINDCLASS_FLAG_CLASS_OPTION_STRONG); }
  bool isDoNotShareClassFlagSet() const {return J9_ARE_ALL_BITS_SET(_findClassFlags, J9_FINDCLASS_FLAG_DO_NOT_SHARE);}
- bool isLambdaClass() const { return J9_ARE_ALL_BITS_SET(_findClassFlags, J9_FINDCLASS_FLAG_LAMBDA); }
-#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
- bool isLambdaFormClass() const { return J9_ARE_ALL_BITS_SET(_findClassFlags, J9_FINDCLASS_FLAG_LAMBDAFORM); }
-#endif /* defined(J9VM_OPT_OPENJDK_METHODHANDLE) */
 
  bool isClassUnmodifiable() const {
  bool unmodifiable = false;
@@ -406,33 +402,11 @@ class ROMClassCreationContext
  if (NULL != _className) {
  U_16 classNameLenToCompare0 = static_cast<U_16>(_classNameLength);
  U_16 classNameLenToCompare1 = classNameLength;
- BOOLEAN misMatch = FALSE;
  if (isClassHidden()) {
  /* For hidden classes, className has the ROM address appended, _className does not. */
  classNameLenToCompare1 = static_cast<U_16>(_classNameLength);
-#if JAVA_SPEC_VERSION < 21
- if (isROMClassShareable()) {
- /*
- * Before JDK21, Lambda class names are in the format:
- * HostClassName$$Lambda$<IndexNumber>/<zeroed out ROM_ADDRESS>
- * Do not compare the IndexNumber as it can be different from run to run.
- */
- U_8 *lambdaClass0 = reinterpret_cast<U_8 *>(getLastDollarSignOfLambdaClassName(
- reinterpret_cast<const char *>(_className), _classNameLength));
- U_8 *lambdaClass1 = reinterpret_cast<U_8 *>(getLastDollarSignOfLambdaClassName(
- reinterpret_cast<const char *>(className), classNameLength));
- if ((NULL != lambdaClass0) && (NULL != lambdaClass1)) {
- classNameLenToCompare0 = static_cast<U_16>(lambdaClass0 - _className + 1);
- classNameLenToCompare1 = static_cast<U_16>(lambdaClass1 - className + 1);
- } else if ((NULL == lambdaClass0) != (NULL == lambdaClass1)) {
- misMatch = TRUE;
- }
- }
-#endif /* JAVA_SPEC_VERSION < 21 */
  }
- if (misMatch
- || !J9UTF8_DATA_EQUALS(_className, classNameLenToCompare0, className, classNameLenToCompare1)
- ) {
+ if (!J9UTF8_DATA_EQUALS(_className, classNameLenToCompare0, className, classNameLenToCompare1)) {
 #define J9WRONGNAME " (wrong name: "
  PORT_ACCESS_FROM_PORT(_portLibrary);
  UDATA errorStringSize = _classNameLength + sizeof(J9WRONGNAME) + 1 + classNameLength;

runtime/jcl/CMakeLists.txt

@@ -92,6 +92,9 @@ target_link_libraries(jclse
  j9vm_interface
  j9vm_gc_includes
 
+ j9shrcommon
+ j9shrutil
+ j9zip
  omrsig
  j9hookable
  j9zlib

runtime/jcl/common/java_lang_invoke_MethodHandleNatives.cpp

@@ -32,10 +32,14 @@
 #include "j9vmconstantpool.h"
 #include "ObjectAccessBarrierAPI.hpp"
 #include "objhelp.h"
+#include "SCAbstractAPI.h"
 
 #include <string.h>
 #include <assert.h>
 
+#undef UT_MODULE_LOADED
+#undef UT_MODULE_UNLOADED
+#include "CacheMap.hpp"
 #include "VMHelpers.hpp"
 
 extern "C" {
@@ -945,6 +949,121 @@ Java_java_lang_invoke_MethodHandleNatives_expand(JNIEnv *env, jclass clazz, jobj
  vmFuncs->internalExitVMToJNI(currentThread);
 }
 
+/**
+ * Find a Lambda or customized LambdaForm class in the SCC.
+ * Requires non-null input arguments.
+ * If found, returns a pointer to a RAMClass of the SCC-cached class, otherwise nullptr.
+ *
+ * Throws OutOfMemoryError if lookup key memory allocation fails.
+ */
+jobject
+findLambdaOrLambdaFormInSCC(JNIEnv *env, jclass clazz, jstring classnameObject, jclass lookupClass, UDATA options)
+{
+ jobject result = nullptr;
+
+#if defined(J9VM_OPT_SHARED_CLASSES)
+ J9VMThread *currentThread = reinterpret_cast<J9VMThread*>(env);
+ J9JavaVM *vm = currentThread->javaVM;
+ const J9InternalVMFunctions *vmFuncs = vm->internalVMFunctions;
+ PORT_ACCESS_FROM_JAVAVM(vm);
+ vmFuncs->internalEnterVMFromJNI(currentThread);
+ Trc_JCL_java_lang_invoke_MethodHandleNatives_findLambdaOrLambdaFormInSCC_Entry(env, classnameObject, lookupClass, options);
+
+#if defined(J9VM_ENV_DATA64)
+#define J9_ROM_ADDRESS_SUFFIX "/0x0000000000000000"
+#else /* defined(J9VM_ENV_DATA64) */
+#define J9_ROM_ADDRESS_SUFFIX "/0x00000000"
+#endif /* defined(J9VM_ENV_DATA64) */
+ j9object_t classname = J9_JNI_UNWRAP_REFERENCE(classnameObject);
+ IDATA classnameLength = vmFuncs->getStringUTF8Length(currentThread, classname);
+ UDATA romAddressSuffixLength = LITERAL_STRLEN(J9_ROM_ADDRESS_SUFFIX);
+ UDATA lookupKeyLength = classnameLength + romAddressSuffixLength + 1; /* +1 for null terminator. */
+ char *lookupKey = static_cast<char *>(j9mem_allocate_memory(lookupKeyLength, OMRMEM_CATEGORY_VM));
+
+ if (nullptr == lookupKey) {
+ vmFuncs->setNativeOutOfMemoryError(currentThread, 0, 0);
+ } else {
+ vmFuncs->copyStringToUTF8Helper(currentThread, classname, J9_STR_NONE, 0, classnameLength, reinterpret_cast<U_8 *>(lookupKey), classnameLength);
+ memcpy(lookupKey + classnameLength, J9_ROM_ADDRESS_SUFFIX, romAddressSuffixLength);
+ lookupKey[lookupKeyLength - 1] = '\0';
+
+ if (nullptr != vm->sharedClassConfig && nullptr != vm->sharedClassConfig->sharedAPIObject) {
+ SCAbstractAPI *sharedapi = static_cast<SCAbstractAPI *>(vm->sharedClassConfig->sharedAPIObject);
+ J9ROMClass *romClass = sharedapi->jclFindOrphanROMClassByUniqueID(currentThread, lookupKey, lookupKeyLength - 1);
+ if (nullptr != romClass) {
+ J9Class *hostClass = J9VM_J9CLASS_FROM_HEAPCLASS(currentThread, J9_JNI_UNWRAP_REFERENCE(lookupClass));
+ J9ClassLoader *classloader = hostClass->classLoader;
+ if (nullptr != hostClass) {
+ omrthread_monitor_enter(vm->classTableMutex);
+ /* internalCreateRAMClassFromROMClass will release the classTableMutex. */
+ J9Class *ramClass = vmFuncs->internalCreateRAMClassFromROMClass(
+ currentThread,
+ classloader,
+ romClass,
+ options,
+ nullptr /* elementClass */,
+ nullptr /* protectionDomain */,
+ nullptr /* methodRemapArray */,
+ J9_CP_INDEX_NONE,
+ LOAD_LOCATION_UNKNOWN,
+ nullptr /* classBeingRedefined */,
+ hostClass);
+ if (nullptr != ramClass && nullptr == currentThread->currentException) {
+ Trc_JCL_java_lang_invoke_MethodHandleNatives_findLambdaOrLambdaFormInSCC_Found(env, lookupKeyLength - 1, lookupKey, lookupClass, options);
+ result = vmFuncs->j9jni_createLocalRef(env, J9VM_J9CLASS_TO_HEAPCLASS(ramClass));
+ }
+ }
+ }
+ }
+ }
+
+ if (nullptr != lookupKey) {
+ j9mem_free_memory(lookupKey);
+ }
+ Trc_JCL_java_lang_invoke_MethodHandleNatives_findLambdaOrLambdaFormInSCC_Exit(env);
+ vmFuncs->internalExitVMToJNI(currentThread);
+#undef J9_ROM_ADDRESS_SUFFIX
+#endif /* J9VM_OPT_SHARED_CLASSES */
+ return result;
+}
+
+/**
+ * static native Class<?> findLambdaInSCC(String classname, Class<?> hostClass);
+ *
+ * Find a Lambda class in the SCC.
+ * Requires non-null input arguments.
+ * If found, returns a pointer to a RAMClass of the SCC-cached, otherwise nullptr.
+ */
+jobject JNICALL
+Java_java_lang_invoke_MethodHandleNatives_findLambdaInSCC(JNIEnv *env, jclass clazz, jstring classnameObject, jclass lookupClass)
+{
+ UDATA options = J9_FINDCLASS_FLAG_NO_CHECK_FOR_EXISTING_CLASS
+ | J9_FINDCLASS_FLAG_THROW_ON_FAIL
+ | J9_FINDCLASS_FLAG_UNSAFE
+ | J9_FINDCLASS_FLAG_HIDDEN
+ | J9_FINDCLASS_FLAG_CLASS_OPTION_NESTMATE
+ | J9_FINDCLASS_FLAG_CLASS_OPTION_STRONG;
+ return findLambdaOrLambdaFormInSCC(env, clazz, classnameObject, lookupClass, options);
+}
+
+/**
+ * static native Class<?> findLambdaFormInSCC(String classname, Class<?> hostClass);
+ *
+ * Find a customized LambdaForm class in the SCC.
+ * Requires non-null input arguments.
+ * If found, returns a pointer to a RAMClass of the SCC-cached class, otherwise nullptr.
+ */
+jobject JNICALL
+Java_java_lang_invoke_MethodHandleNatives_findLambdaFormInSCC(JNIEnv *env, jclass clazz, jstring classnameObject, jclass lookupClass)
+{
+ UDATA options = J9_FINDCLASS_FLAG_NO_CHECK_FOR_EXISTING_CLASS
+ | J9_FINDCLASS_FLAG_THROW_ON_FAIL
+ | J9_FINDCLASS_FLAG_UNSAFE
+ | J9_FINDCLASS_FLAG_HIDDEN
+ | J9_FINDCLASS_FLAG_ANON;
+ return findLambdaOrLambdaFormInSCC(env, clazz, classnameObject, lookupClass, options);
+}
+
 /**
  * [JDK8] static native MemberName resolve(MemberName self, Class<?> caller)
  * throws LinkageError, ClassNotFoundException;
@@ -987,7 +1106,7 @@ Java_java_lang_invoke_MethodHandleNatives_resolve(
  char nameBuffer[256];
  nameBuffer[0] = 0;
  J9UTF8 *signature = NULL;
- char signatureBuffer[256];
+ char signatureBuffer[512];
  signatureBuffer[0] = 0;
  PORT_ACCESS_FROM_JAVAVM(vm);
  vmFuncs->internalEnterVMFromJNI(currentThread);
@@ -1419,7 +1538,7 @@ Java_java_lang_invoke_MethodHandleNatives_getMembers(
  char nameBuffer[256];
  nameBuffer[0] = 0;
  J9UTF8 *signature = NULL;
- char signatureBuffer[256];
+ char signatureBuffer[512];
  signatureBuffer[0] = 0;
  j9object_t callerObject = ((NULL == caller) ? NULL : J9_JNI_UNWRAP_REFERENCE(caller));