Merge pull request #19752 from theresa-m/remove_q_5

hangshao0 · web-flow · commit 293f2b781279 · 2024-06-27T10:56:11.000-04:00
Remove internal qtype methods
diff --git a/runtime/compiler/env/J9ClassEnv.cpp b/runtime/compiler/env/J9ClassEnv.cpp
@@ -513,22 +513,8 @@ static void addEntryForFieldImpl(TR_VMField *field, TR::TypeLayoutBuilder &tlb,
    bool trace = comp->getOption(TR_TraceILGen);
    uint32_t mergedLength = 0;
    J9UTF8 *signature = J9ROMFIELDSHAPE_SIGNATURE(field->shape);
-
-   bool isFieldPrimitiveValueType = false;
-
-   if (TR::Compiler->om.areFlattenableValueTypesEnabled())
-      {
-      if (TR::Compiler->om.isQDescriptorForValueTypesSupported())
-         {
-         isFieldPrimitiveValueType = vm->internalVMFunctions->isNameOrSignatureQtype(signature);
-         }
-      else
-         {
-         isFieldPrimitiveValueType = vm->internalVMFunctions->isFieldNullRestricted(field->shape);
-         }
-      }
-
-   if (isFieldPrimitiveValueType &&
+   if (TR::Compiler->om.areFlattenableValueTypesEnabled() &&
+       vm->internalVMFunctions->isFieldNullRestricted(field->shape) &&
        vm->internalVMFunctions->isFlattenableFieldFlattened(definingClass, field->shape))
       {
       char *prefixForChild = buildTransitiveFieldNames(prefix, prefixLength, field->shape, comp->trMemory()->currentStackRegion(), mergedLength);
@@ -1033,14 +1019,7 @@ J9::ClassEnv::classNameToSignature(const char *name, int32_t &len, TR::Compilati
       {
       len += 2;
       sig = (char *)comp->trMemory()->allocateMemory(len+1, allocKind);
-      if (clazz &&
-         TR::Compiler->om.areFlattenableValueTypesEnabled() &&
-         TR::Compiler->om.isQDescriptorForValueTypesSupported() &&
-         self()->isPrimitiveValueTypeClass(clazz)
-         )
-         sig[0] = 'Q';
-      else
-         sig[0] = 'L';
+      sig[0] = 'L';
       memcpy(sig+1,name,len-2);
       sig[len-1]=';';
       }
diff --git a/runtime/compiler/env/J9ObjectModel.cpp b/runtime/compiler/env/J9ObjectModel.cpp
@@ -141,28 +141,6 @@ J9::ObjectModel::areFlattenableValueTypesEnabled()
    return javaVM->internalVMFunctions->areFlattenableValueTypesEnabled(javaVM);
    }
 
-bool
-J9::ObjectModel::isQDescriptorForValueTypesSupported()
-   {
-   // TODO: Implementation is required to determine under which case 'Q' descriptor is removed
-#if defined(J9VM_OPT_JITSERVER)
-   if (auto stream = TR::CompilationInfo::getStream())
-      {
-#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
-      return true;
-#else /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
-      return false;
-#endif /* defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES) */
-      }
-#endif /* defined(J9VM_OPT_JITSERVER) */
-
-   J9JavaVM * javaVM = TR::Compiler->javaVM;
-   if (javaVM->internalVMFunctions->areFlattenableValueTypesEnabled(javaVM))
-     return true;
-
-   return false;
-   }
-
 bool
 J9::ObjectModel::areValueBasedMonitorChecksEnabled()
    {
diff --git a/runtime/compiler/env/J9ObjectModel.hpp b/runtime/compiler/env/J9ObjectModel.hpp
@@ -70,11 +70,6 @@ class ObjectModel : public OMR::ObjectModelConnector
    * @brief Whether or not flattenable value object (aka null restricted) type is enabled
    */
    bool areFlattenableValueTypesEnabled();
-   /**
-   * @brief Whether or not `Q` signature is supported
-   */
-   bool isQDescriptorForValueTypesSupported();
-
    /**
    * @brief Whether the check is enabled on monitor object being value based class type
    */
diff --git a/runtime/compiler/env/VMJ9.cpp b/runtime/compiler/env/VMJ9.cpp
@@ -2562,14 +2562,7 @@ TR_J9VMBase::getClassSignature_DEPRECATED(TR_OpaqueClassBlock * clazz, int32_t &
    for (i = 0; i < numDims; i++)
       sig[i] = '[';
    if (* name != '[')
-      {
-      if (TR::Compiler->om.areFlattenableValueTypesEnabled() &&
-          TR::Compiler->om.isQDescriptorForValueTypesSupported() &&
-          TR::Compiler->cls.isPrimitiveValueTypeClass(myClass))
-         sig[i++] = 'Q';
-      else
-         sig[i++] = 'L';
-      }
+      sig[i++] = 'L';
    memcpy(sig+i, name, len);
    i += len;
    if (* name != '[')
@@ -2597,14 +2590,7 @@ TR_J9VMBase::getClassSignature(TR_OpaqueClassBlock * clazz, TR_Memory * trMemory
    for (i = 0; i < numDims; i++)
       sig[i] = '[';
    if (* name != '[')
-      {
-      if (TR::Compiler->om.areFlattenableValueTypesEnabled() &&
-          TR::Compiler->om.isQDescriptorForValueTypesSupported() &&
-          TR::Compiler->cls.isPrimitiveValueTypeClass(myClass))
-         sig[i++] = 'Q';
-      else
-         sig[i++] = 'L';
-      }
+      sig[i++] = 'L';
    memcpy(sig+i, name, len);
    i += len;
    if (* name != '[')
diff --git a/runtime/compiler/env/j9method.cpp b/runtime/compiler/env/j9method.cpp
@@ -9643,30 +9643,13 @@ TR_J9ByteCodeIlGenerator::packReferenceChainOffsets(TR::Node *node, std::vector<
    }
 #endif
 
-bool
-TR_ResolvedJ9Method::isFieldQType(int32_t cpIndex)
-   {
-   J9ROMFieldRef *ref = (J9ROMFieldRef *) (&romCPBase()[cpIndex]);
-   J9ROMNameAndSignature *nameAndSignature = J9ROMFIELDREF_NAMEANDSIGNATURE(ref);
-   J9UTF8 *signature = J9ROMNAMEANDSIGNATURE_SIGNATURE(nameAndSignature);
-
-   J9VMThread *vmThread = fej9()->vmThread();
-   return vmThread->javaVM->internalVMFunctions->isNameOrSignatureQtype(signature);
-   }
-
 bool
 TR_ResolvedJ9Method::isFieldNullRestricted(TR::Compilation *comp, int32_t cpIndex, bool isStatic, bool isStore)
    {
    if (!TR::Compiler->om.areFlattenableValueTypesEnabled() ||
       (-1 == cpIndex))
       return false;
 
-   if (TR::Compiler->om.isQDescriptorForValueTypesSupported())
-      {
-      if (isFieldQType(cpIndex)) // Temporary until javac supports NullRestricted attribute
-         return true;
-      }
-
    J9VMThread *vmThread = fej9()->vmThread();
    J9ROMFieldShape *fieldShape = NULL;
 
diff --git a/runtime/compiler/env/j9method.h b/runtime/compiler/env/j9method.h
@@ -470,13 +470,6 @@ class TR_ResolvedJ9Method : public TR_J9Method, public TR_ResolvedJ9MethodBase
    TR_ResolvedMethod *             aotMaskResolvedPossiblyPrivateVirtualMethod(TR::Compilation *comp, TR_ResolvedMethod *method);
    TR_ResolvedMethod *             aotMaskResolvedImproperInterfaceMethod(TR::Compilation *comp, TR_ResolvedMethod *method);
 
-   /**
-    * @brief Check if a field is a QType or not.
-    *
-    * @param[in] cpIndex : the constant pool index of the field
-    */
-   virtual bool isFieldQType(int32_t cpIndex);
-
 public:
    virtual bool                    virtualMethodIsOverridden();
    virtual void                    setVirtualMethodIsOverridden();
diff --git a/runtime/compiler/env/j9methodServer.cpp b/runtime/compiler/env/j9methodServer.cpp
@@ -1844,30 +1844,13 @@ TR_ResolvedJ9JITServerMethod::archetypeArgPlaceholderSlot()
    return paramSlots;
    }
 
-bool
-TR_ResolvedJ9JITServerMethod::isFieldQType(int32_t cpIndex)
-   {
-   auto comp = _fe->_compInfoPT->getCompilation();
-   int32_t sigLen;
-   char *sig = fieldOrStaticSignatureChars(cpIndex, sigLen);
-   J9UTF8 *utfWrapper = str2utf8(sig, sigLen, comp->trMemory(), heapAlloc);
-
-   J9VMThread *vmThread = comp->j9VMThread();
-   return vmThread->javaVM->internalVMFunctions->isNameOrSignatureQtype(utfWrapper);
-   }
-
 bool
 TR_ResolvedJ9JITServerMethod::isFieldNullRestricted(TR::Compilation *comp, int32_t cpIndex, bool isStatic, bool isStore)
    {
    if (!TR::Compiler->om.areFlattenableValueTypesEnabled() ||
       (-1 == cpIndex))
       return false;
 
-   if (TR::Compiler->om.isQDescriptorForValueTypesSupported())
-      {
-      return isFieldQType(cpIndex);
-      }
-
    _stream->write(JITServer::MessageType::ResolvedMethod_isFieldNullRestricted, _remoteMirror, cpIndex, isStatic, isStore);
    return std::get<0>(_stream->read<bool>());
    }
diff --git a/runtime/compiler/env/j9methodServer.hpp b/runtime/compiler/env/j9methodServer.hpp
@@ -244,8 +244,6 @@ class TR_ResolvedJ9JITServerMethod : public TR_ResolvedJ9Method
    virtual bool validateMethodFieldAttributes(const TR_J9MethodFieldAttributes &attributes, bool isStatic, int32_t cpIndex, bool isStore, bool needAOTValidation);
    virtual bool canCacheFieldAttributes(int32_t cpIndex, const TR_J9MethodFieldAttributes &attributes, bool isStatic);
 
-   virtual bool isFieldQType(int32_t cpIndex) override;
-
 private:
 
    J9ROMClass *_romClass; // cached copy of ROM class from client
diff --git a/runtime/compiler/ilgen/Walker.cpp b/runtime/compiler/ilgen/Walker.cpp
@@ -6749,24 +6749,9 @@ TR_J9ByteCodeIlGenerator::genAconst_init(TR_OpaqueClassBlock *valueTypeClass, in
             case TR::Address:
                {
                const char *fieldSignature = entry._typeSignature;
-
-               // If the field's signature begins with a Q, it is a value type and should be initialized with a default value
-               // for that value type.  That's handled with a recursive call to genAconst_init.
-               // If the signature does not begin with a Q, the field is an identity type whose default value is a Java null
-               /// reference.
-               bool isNullRestricted = false;
                if (TR::Compiler->om.areFlattenableValueTypesEnabled())
                   {
-                  if (!TR::Compiler->om.isQDescriptorForValueTypesSupported())
-                     {
-                     isNullRestricted = entry._isNullRestricted;
-                     }
-                  else if (fieldSignature[0] == 'Q')
-                     {
-                     isNullRestricted = true;
-                     }
-
-                  if (isNullRestricted)
+                  if (entry._isNullRestricted)
                      {
                      // In non-SVM AOT compilation, cpIndex is required for AOT relocation.
                      // In this case, cpindex is unknown for the field.
@@ -6787,7 +6772,7 @@ TR_J9ByteCodeIlGenerator::genAconst_init(TR_OpaqueClassBlock *valueTypeClass, in
                      }
                   }
 
-               if (!isNullRestricted)
+               if (!entry._isNullRestricted)
                   {
                   if (comp()->target().is64Bit())
                      {
diff --git a/runtime/compiler/runtime/JITClientSession.cpp b/runtime/compiler/runtime/JITClientSession.cpp
@@ -201,12 +201,7 @@ ClientSessionData::processUnloadedClasses(const std::vector<TR_OpaqueClassBlock*
             }
          else
             {
-            if (TR::Compiler->om.areFlattenableValueTypesEnabled() &&
-                TR::Compiler->om.isQDescriptorForValueTypesSupported() &&
-                TR::Compiler->cls.isPrimitiveValueTypeClass(clazz))
-               sigStr[0] = 'Q';
-            else
-               sigStr[0] = 'L';
+            sigStr[0] = 'L';
             memcpy(&sigStr[1], className, sigLen - 2);
             sigStr[sigLen-1]=';';
             }
diff --git a/runtime/jcl/common/java_lang_invoke_MethodHandleNatives.cpp b/runtime/jcl/common/java_lang_invoke_MethodHandleNatives.cpp
@@ -209,9 +209,7 @@ initImpl(J9VMThread *currentThread, j9object_t membernameObject, j9object_t refO
 			flags |= MN_TRUSTED_FINAL;
 		}
 #if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
-		if (vmFuncs->isNameOrSignatureQtype(J9ROMFIELDSHAPE_SIGNATURE(romField))
-			|| J9ROMFIELD_IS_NULL_RESTRICTED(romField)
-		) {
+		if (J9ROMFIELD_IS_NULL_RESTRICTED(romField)) {
 			if (vmFuncs->isFlattenableFieldFlattened(fieldID->declaringClass, fieldID->field)) {
 				flags |= MN_FLAT_FIELD;
 			}
diff --git a/runtime/oti/j9nonbuilder.h b/runtime/oti/j9nonbuilder.h
@@ -5110,8 +5110,6 @@ typedef struct J9InternalVMFunctions {
 #endif /* J9VM_OPT_JITSERVER */
 	IDATA ( *createJoinableThreadWithCategory)(omrthread_t* handle, UDATA stacksize, UDATA priority, UDATA suspend, omrthread_entrypoint_t entrypoint, void* entryarg, U_32 category) ;
 	BOOLEAN ( *valueTypeCapableAcmp)(struct J9VMThread *currentThread, j9object_t lhs, j9object_t rhs) ;
-	BOOLEAN ( *isNameOrSignatureQtype)(J9UTF8 *utfWrapper) ;
-	BOOLEAN ( *isClassRefQtype)(struct J9Class *cpContextClass, U_16 cpIndex) ;
 	BOOLEAN ( *isFieldNullRestricted)(J9ROMFieldShape *field);
 	UDATA ( *getFlattenableFieldOffset)(struct J9Class *fieldOwner, J9ROMFieldShape *field);
 	BOOLEAN ( *isFlattenableFieldFlattened)(J9Class *fieldOwner, J9ROMFieldShape *field);
diff --git a/runtime/oti/vm_api.h b/runtime/oti/vm_api.h
@@ -2685,29 +2685,6 @@ classPrepareWithWithUnflattenedFlattenables(J9VMThread *currentThread, J9Class *
 BOOLEAN
 valueTypeCapableAcmp(J9VMThread *currentThread, j9object_t lhs, j9object_t rhs);
 
-/**
- * Determines if a name or a signature pointed by a J9UTF8 pointer is a Qtype.
- *
- * @param[in] utfWrapper J9UTF8 pointer that points to the name or the signature
- *
- * @return TRUE if the name or the signature pointed by the J9UTF8 pointer is a Qtype, FALSE otherwise
- */
-BOOLEAN
-isNameOrSignatureQtype(J9UTF8 *utfWrapper);
-
-
-/**
- * Determines if the classref c=signature is a Qtype. There is no validation performed
- * to ensure that the cpIndex points at a classref.
- *
- * @param[in] cpContextClass ramClass that owns the constantpool being queried
- * @param[in] cpIndex the CP index
- *
- * @return TRUE if classref is a Qtype, FALSE otherwise
- */
-BOOLEAN
-isClassRefQtype(J9Class *cpContextClass, U_16 cpIndex);
-
 /**
  * Determines if null restricted attribute is set on a field or not.
  *
diff --git a/runtime/vm/BytecodeInterpreter.hpp b/runtime/vm/BytecodeInterpreter.hpp
@@ -4379,7 +4379,7 @@ class INTERPRETER_CLASS
 				rc = GOTO_THROW_CURRENT_EXCEPTION;
 			} else {
 				I_32 result = false;
-				if (VM_ValueTypeHelpers::isNameOrSignatureQtype(J9ROMFIELDSHAPE_SIGNATURE(fieldID->field)) || J9ROMFIELD_IS_NULL_RESTRICTED(fieldID->field)) {
+				if (J9ROMFIELD_IS_NULL_RESTRICTED(fieldID->field)) {
 					result = (I_32)isFlattenableFieldFlattened(fieldID->declaringClass, fieldID->field);
 				}
 				restoreInternalNativeStackFrame(REGISTER_ARGS);
@@ -8551,9 +8551,6 @@ class INTERPRETER_CLASS
 					goto done;
 				}
 			} else {
-#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
-resolve:
-#endif /* J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES */
 				/* Unresolved */
 				buildGenericSpecialStackFrame(REGISTER_ARGS, 0);
 				updateVMStruct(REGISTER_ARGS);
@@ -8570,23 +8567,12 @@ class INTERPRETER_CLASS
 				goto retry;
 			}
 		}
-#if defined(J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES)
-		else if (VM_ValueTypeHelpers::isClassRefQtype(ramConstantPool, index)) {
-			/* Even though an NPE is going to be thrown the classref must still be resolved because
-			 * its a qtype.
-			 *
-			 * TODO in the future a different type of exception may thrown, spec for this behaviour
-			 * not currently known.
-			 */
-			if (NULL == castClass) {
-				/* Resolve the class and then check again whether it is a value type */
-				goto resolve;
-			}
 
-			rc = THROW_NPE;
-			goto done;
-		}
-#endif /* J9VM_OPT_VALHALLA_FLATTENABLE_VALUE_TYPES */
+		/* In the future Valhalla checkcast needs to throw exception on
+		 * null restricted checkedType if obj is null,
+		 * see issue https://github.com/eclipse-openj9/openj9/issues/19764
+		 */
+
 		_pc += 3;
 done:
 		return rc;
diff --git a/runtime/vm/ValueTypeHelpers.cpp b/runtime/vm/ValueTypeHelpers.cpp
@@ -109,18 +109,6 @@ valueTypeCapableAcmp(J9VMThread *currentThread, j9object_t lhs, j9object_t rhs)
 	return VM_ValueTypeHelpers::acmp(currentThread, objectAccessBarrier, lhs, rhs);
 }
 
-BOOLEAN
-isNameOrSignatureQtype(J9UTF8 *utfWrapper)
-{
-	return VM_ValueTypeHelpers::isNameOrSignatureQtype(utfWrapper);
-}
-
-BOOLEAN
-isClassRefQtype(J9Class *cpContextClass, U_16 cpIndex)
-{
-	return VM_ValueTypeHelpers::isClassRefQtype(cpContextClass->ramConstantPool, cpIndex);
-}
-
 BOOLEAN
 isFieldNullRestricted(J9ROMFieldShape *field)
 {
diff --git a/runtime/vm/ValueTypeHelpers.hpp b/runtime/vm/ValueTypeHelpers.hpp
diff --git a/runtime/vm/intfunc.c b/runtime/vm/intfunc.c
diff --git a/test/functional/Valhalla/src_qtypes/org/openj9/test/lworld/ValueTypeGenerator.java b/test/functional/Valhalla/src_qtypes/org/openj9/test/lworld/ValueTypeGenerator.java
diff --git a/test/functional/Valhalla/src_qtypes/org/openj9/test/lworld/ValueTypeTests.java b/test/functional/Valhalla/src_qtypes/org/openj9/test/lworld/ValueTypeTests.java

Original file line number	Diff line number	Diff line change
`@@ -6749,24 +6749,9 @@ TR_J9ByteCodeIlGenerator::genAconst_init(TR_OpaqueClassBlock *valueTypeClass, in`
`6749`	`6749`	`case TR::Address:`
`6750`	`6750`	`{`
`6751`	`6751`	`const char *fieldSignature = entry._typeSignature;`
`6752`		`-`
`6753`		`- // If the field's signature begins with a Q, it is a value type and should be initialized with a default value`
`6754`		`- // for that value type. That's handled with a recursive call to genAconst_init.`
`6755`		`- // If the signature does not begin with a Q, the field is an identity type whose default value is a Java null`
`6756`		`- /// reference.`
`6757`		`- bool isNullRestricted = false;`
`6758`	`6752`	`if (TR::Compiler->om.areFlattenableValueTypesEnabled())`
`6759`	`6753`	`{`
`6760`		`- if (!TR::Compiler->om.isQDescriptorForValueTypesSupported())`
`6761`		`- {`
`6762`		`- isNullRestricted = entry._isNullRestricted;`
`6763`		`- }`
`6764`		`- else if (fieldSignature[0] == 'Q')`
`6765`		`- {`
`6766`		`- isNullRestricted = true;`
`6767`		`- }`
`6768`		`-`
`6769`		`- if (isNullRestricted)`
	`6754`	`+ if (entry._isNullRestricted)`
`6770`	`6755`	`{`
`6771`	`6756`	`// In non-SVM AOT compilation, cpIndex is required for AOT relocation.`
`6772`	`6757`	`// In this case, cpindex is unknown for the field.`
`@@ -6787,7 +6772,7 @@ TR_J9ByteCodeIlGenerator::genAconst_init(TR_OpaqueClassBlock *valueTypeClass, in`
`6787`	`6772`	`}`
`6788`	`6773`	`}`
`6789`	`6774`
`6790`		`- if (!isNullRestricted)`
	`6775`	`+ if (!entry._isNullRestricted)`
`6791`	`6776`	`{`
`6792`	`6777`	`if (comp()->target().is64Bit())`
`6793`	`6778`	`{`
Original file line number	Diff line number	Diff line change
`@@ -201,12 +201,7 @@ ClientSessionData::processUnloadedClasses(const std::vector<TR_OpaqueClassBlock*`
`201`	`201`	`}`
`202`	`202`	`else`
`203`	`203`	`{`
`204`		`- if (TR::Compiler->om.areFlattenableValueTypesEnabled() &&`
`205`		`- TR::Compiler->om.isQDescriptorForValueTypesSupported() &&`
`206`		`- TR::Compiler->cls.isPrimitiveValueTypeClass(clazz))`
`207`		`- sigStr[0] = 'Q';`
`208`		`- else`
`209`		`- sigStr[0] = 'L';`
	`204`	`+ sigStr[0] = 'L';`
`210`	`205`	`memcpy(&sigStr[1], className, sigLen - 2);`
`211`	`206`	`sigStr[sigLen-1]=';';`
`212`	`207`	`}`