Merge pull request #19699 from jdmpapin/aggressive-sfff

Make static final field folding more aggressive

Author: vijaysun-omr

runtime/compiler/control/J9Options.cpp

@@ -3552,6 +3552,7 @@ J9::Options::packOptions(const TR::Options *origOptions)
    addRegexStringSize(origOptions->_memUsage, totalSize);
    addRegexStringSize(origOptions->_classesWithFolableFinalFields, totalSize);
    addRegexStringSize(origOptions->_disabledIdiomPatterns, totalSize);
+   addRegexStringSize(origOptions->_dontFoldStaticFinalFields, totalSize);
 
    std::string optionsStr(totalSize, '\0');
    TR::Options * options = (TR::Options *)optionsStr.data();
@@ -3593,6 +3594,7 @@ J9::Options::packOptions(const TR::Options *origOptions)
    appendRegex(options->_memUsage, curPos);
    appendRegex(options->_classesWithFolableFinalFields, curPos);
    appendRegex(options->_disabledIdiomPatterns, curPos);
+   appendRegex(options->_dontFoldStaticFinalFields, curPos);
    options->_osVersionString = NULL;
    options->_logListForOtherCompThreads = NULL;
    options->_objectFileName = NULL;
@@ -3661,6 +3663,7 @@ J9::Options::unpackOptions(char *clientOptions, size_t clientOptionsSize, TR::Co
    unpackRegex(options->_memUsage);
    unpackRegex(options->_classesWithFolableFinalFields);
    unpackRegex(options->_disabledIdiomPatterns);
+   unpackRegex(options->_dontFoldStaticFinalFields);
 
    return options;
    }

runtime/compiler/control/JITClientCompilationThread.cpp

@@ -2124,6 +2124,14 @@ handleServerMessage(JITServer::ClientStream *client, TR_J9VM *fe, JITServer::Mes
          client->write(response, TR::Compiler->cls.getDefaultValueSlotAddress(comp, clazz));
          }
          break;
+      case MessageType::ClassEnv_setClassHasIllegalStaticFinalFieldModification:
+         {
+         auto recv = client->getRecvData<TR_OpaqueClassBlock *>();
+         auto clazz = std::get<0>(recv);
+         TR::Compiler->cls.setClassHasIllegalStaticFinalFieldModification(clazz, comp);
+         client->write(response, JITServer::Void());
+         }
+         break;
       case MessageType::ClassEnv_enumerateFields:
          {
          auto recv = client->getRecvData<TR_OpaqueClassBlock *>();

runtime/compiler/env/J9ClassEnv.cpp

@@ -21,6 +21,7 @@
  *******************************************************************************/
 
 #include "compile/Compilation.hpp"
+#include "AtomicSupport.hpp"
 #if defined(J9VM_OPT_JITSERVER)
 #include "control/CompilationRuntime.hpp"
 #include "control/CompilationThread.hpp"
@@ -394,6 +395,38 @@ J9::ClassEnv::classHasIllegalStaticFinalFieldModification(TR_OpaqueClassBlock *
    return J9_ARE_ANY_BITS_SET(j9clazz->classFlags, J9ClassHasIllegalFinalFieldModifications);
    }
 
+void
+J9::ClassEnv::setClassHasIllegalStaticFinalFieldModification(
+   TR_OpaqueClassBlock *clazz, TR::Compilation *comp)
+   {
+   J9Class *j9c = TR::Compiler->cls.convertClassOffsetToClassPtr(clazz);
+
+#if defined(J9VM_OPT_JITSERVER)
+   if (comp->isOutOfProcessCompilation())
+      {
+      // Set the flag on the actual class in the client.
+      auto stream = comp->getStream();
+      stream->write(
+         JITServer::MessageType::ClassEnv_setClassHasIllegalStaticFinalFieldModification,
+         clazz);
+
+      stream->read<JITServer::Void>();
+
+      // Update the cache
+      ClientSessionData *clientSessionData = TR::compInfoPT->getClientData();
+      OMR::CriticalSection romMapCS(clientSessionData->getROMMapMonitor());
+      auto it = clientSessionData->getROMClassMap().find(j9c);
+      if (it != clientSessionData->getROMClassMap().end())
+         it->second._classFlags |= J9ClassHasIllegalFinalFieldModifications;
+
+      return;
+      }
+#endif
+
+   VM_AtomicSupport::bitOrU32(
+      &j9c->classFlags, J9ClassHasIllegalFinalFieldModifications);
+   }
+
 bool
 J9::ClassEnv::hasFinalFieldsInClass(TR::Compilation *comp, TR_OpaqueClassBlock *clazz)
    {

runtime/compiler/env/J9ClassEnv.hpp

@@ -87,6 +87,8 @@ class OMR_EXTENSIBLE ClassEnv : public OMR::ClassEnvConnector
    bool isStringClass(TR_OpaqueClassBlock *clazz);
 
    bool classHasIllegalStaticFinalFieldModification(TR_OpaqueClassBlock * clazzPointer);
+   void setClassHasIllegalStaticFinalFieldModification(
+      TR_OpaqueClassBlock *clazz, TR::Compilation *comp);
    bool isAbstractClass(TR::Compilation *comp, TR_OpaqueClassBlock *clazzPointer);
    bool isInterfaceClass(TR::Compilation *comp, TR_OpaqueClassBlock *clazzPointer);
    bool isConcreteClass(TR::Compilation *comp, TR_OpaqueClassBlock * clazzPointer);

runtime/compiler/env/JITServerPersistentCHTable.cpp

@@ -620,6 +620,12 @@ void TR_JITClientPersistentClassInfo::clearShouldNotBeNewlyExtended()
    TR_PersistentClassInfo::clearShouldNotBeNewlyExtended();
    }
 
+void TR_JITClientPersistentClassInfo::setAlreadyScannedForFinalPutstatic()
+   {
+   TR_JITClientPersistentClassInfo::_chTable->markDirty(getClassId());
+   TR_PersistentClassInfo::setAlreadyScannedForFinalPutstatic();
+   }
+
 void TR_JITClientPersistentClassInfo::setHasRecognizedAnnotations(bool v)
    {
    TR_JITClientPersistentClassInfo::_chTable->markDirty(getClassId());

runtime/compiler/env/JITServerPersistentCHTable.hpp

@@ -212,6 +212,7 @@ class TR_JITClientPersistentClassInfo : public TR_PersistentClassInfo
    virtual void setShouldNotBeNewlyExtended(int32_t ID) override;
    virtual void resetShouldNotBeNewlyExtended(int32_t ID) override;
    virtual void clearShouldNotBeNewlyExtended() override;
+   virtual void setAlreadyScannedForFinalPutstatic() override;
    virtual void setHasRecognizedAnnotations(bool v = true) override;
    virtual void setAlreadyCheckedForAnnotations(bool v = true) override;
    virtual void setCannotTrustStaticFinal(bool v = true) override;

runtime/compiler/ilgen/Walker.cpp

@@ -5441,7 +5441,7 @@ TR_J9ByteCodeIlGenerator::loadStatic(int32_t cpIndex)
 
    TR::SymbolReference * symRef = symRefTab()->findOrCreateStaticSymbol(_methodSymbol, cpIndex, false);
    if (comp()->getOption(TR_TraceILGen))
-      traceMsg(comp(), "load static symref %d created with knownObjectIndex %d", symRef->getReferenceNumber(), symRef->getKnownObjectIndex());
+      traceMsg(comp(), "load static symref %d created with knownObjectIndex %d\n", symRef->getReferenceNumber(), symRef->getKnownObjectIndex());
    TR::StaticSymbol *      symbol = symRef->getSymbol()->castToStaticSymbol();
    TR_ASSERT(symbol, "Didn't geta static symbol.");
 

runtime/compiler/net/CommunicationStream.hpp

@@ -128,7 +128,7 @@ class CommunicationStream
    // likely to lose an increment when merging/rebasing/etc.
    //
    static const uint8_t MAJOR_NUMBER = 1;
-   static const uint16_t MINOR_NUMBER = 62; // ID: TNff0n0QdLOhsH6CmQlT/
+   static const uint16_t MINOR_NUMBER = 64; // ID: EbRgDu72oycJkc90HtnO
    static const uint8_t PATCH_NUMBER = 0;
    static uint32_t CONFIGURATION_FLAGS;
 

runtime/compiler/net/MessageTypes.cpp

@@ -212,6 +212,7 @@ const char *messageNames[] =
    "ClassEnv_enumerateFields",
    "ClassEnv_flattenedArrayElementSize",
    "ClassEnv_getDefaultValueSlotAddress",
+   "ClassEnv_setClassHasIllegalStaticFinalFieldModification",
    "SharedCache_getClassChainOffsetIdentifyingLoader",
    "SharedCache_rememberClass",
    "SharedCache_addHint",

runtime/compiler/net/MessageTypes.hpp

@@ -225,6 +225,7 @@ enum MessageType : uint16_t
    ClassEnv_enumerateFields,
    ClassEnv_flattenedArrayElementSize,
    ClassEnv_getDefaultValueSlotAddress,
+   ClassEnv_setClassHasIllegalStaticFinalFieldModification,
 
    // For TR_J9SharedCache
    SharedCache_getClassChainOffsetIdentifyingLoader,