diff --git a/runtime/compiler/compile/J9Compilation.cpp b/runtime/compiler/compile/J9Compilation.cpp index 3bfde4cf0fb..939c41b843d 100644 --- a/runtime/compiler/compile/J9Compilation.cpp +++ b/runtime/compiler/compile/J9Compilation.cpp @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2000, 2018 IBM Corp. and others + * Copyright (c) 2000, 2019 IBM Corp. and others * * This program and the accompanying materials are made available under * the terms of the Eclipse Public License 2.0 which accompanies this @@ -185,12 +185,8 @@ J9::Compilation::Compilation(int32_t id, _profileInfo = new (m->trHeapMemory()) TR_AccessedProfileInfo(heapMemoryRegion); - _ObjectClassPointer = fe->getClassFromSignature("Ljava/lang/Object;", 18, compilee); - _RunnableClassPointer = fe->getClassFromSignature("Ljava/lang/Runnable;", 20, compilee); - _StringClassPointer = fe->getClassFromSignature("Ljava/lang/String;", 18, compilee); - _SystemClassPointer = fe->getClassFromSignature("Ljava/lang/System;", 18, compilee); - _ReferenceClassPointer = fe->getClassFromSignature("Ljava/lang/ref/Reference;", 25, compilee); - _JITHelpersClassPointer = fe->getClassFromSignature("Lcom/ibm/jit/JITHelpers;", 24, compilee); + for (int i = 0; i < CACHED_CLASS_POINTER_COUNT; i++) + _cachedClassPointers[i] = NULL; } J9::Compilation::~Compilation() @@ -1188,7 +1184,10 @@ TR_OpaqueClassBlock * J9::Compilation::getClassClassPointer(bool isVettedForAOT) { if (!isVettedForAOT || self()->getOption(TR_UseSymbolValidationManager)) - return _ObjectClassPointer ? self()->fe()->getClassClassPointer(_ObjectClassPointer) : 0; + { + TR_OpaqueClassBlock *jlObject = self()->getObjectClassPointer(); + return jlObject ? self()->fe()->getClassClassPointer(jlObject) : 0; + } if (_aotClassClassPointerInitialized) return _aotClassClassPointer; @@ -1217,6 +1216,77 @@ J9::Compilation::getClassClassPointer(bool isVettedForAOT) return jlClass; } +TR_OpaqueClassBlock * +J9::Compilation::getObjectClassPointer() + { + return self()->getCachedClassPointer(OBJECT_CLASS_POINTER); + } + +TR_OpaqueClassBlock * +J9::Compilation::getRunnableClassPointer() + { + return self()->getCachedClassPointer(RUNNABLE_CLASS_POINTER); + } + +TR_OpaqueClassBlock * +J9::Compilation::getStringClassPointer() + { + return self()->getCachedClassPointer(STRING_CLASS_POINTER); + } + +TR_OpaqueClassBlock * +J9::Compilation::getSystemClassPointer() + { + return self()->getCachedClassPointer(SYSTEM_CLASS_POINTER); + } + +TR_OpaqueClassBlock * +J9::Compilation::getReferenceClassPointer() + { + return self()->getCachedClassPointer(REFERENCE_CLASS_POINTER); + } + +TR_OpaqueClassBlock * +J9::Compilation::getJITHelpersClassPointer() + { + return self()->getCachedClassPointer(JITHELPERS_CLASS_POINTER); + } + +TR_OpaqueClassBlock * +J9::Compilation::getCachedClassPointer(CachedClassPointerId which) + { + TR_OpaqueClassBlock *clazz = _cachedClassPointers[which]; + if (clazz != NULL) + return clazz; + + if (self()->compileRelocatableCode() + && !self()->getOption(TR_UseSymbolValidationManager)) + return NULL; + + static const char * const names[] = + { + "Ljava/lang/Object;", + "Ljava/lang/Runnable;", + "Ljava/lang/String;", + "Ljava/lang/System;", + "Ljava/lang/ref/Reference;", + "Lcom/ibm/jit/JITHelpers;", + }; + + static_assert( + sizeof (names) / sizeof (names[0]) == CACHED_CLASS_POINTER_COUNT, + "wrong number of entries in J9::Compilation cached class names array"); + + const char *name = names[which]; + clazz = self()->fej9()->getClassFromSignature( + name, + strlen(name), + self()->getCurrentMethod()); + + _cachedClassPointers[which] = clazz; + return clazz; + } + /* * Adds the provided TR_OpaqueClassBlock to the set of those to trigger OSR Guard patching * on a redefinition. diff --git a/runtime/compiler/compile/J9Compilation.hpp b/runtime/compiler/compile/J9Compilation.hpp index 09e3d944e71..2a688d70653 100644 --- a/runtime/compiler/compile/J9Compilation.hpp +++ b/runtime/compiler/compile/J9Compilation.hpp @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2000, 2018 IBM Corp. and others + * Copyright (c) 2000, 2019 IBM Corp. and others * * This program and the accompanying materials are made available under * the terms of the Eclipse Public License 2.0 which accompanies this @@ -274,12 +274,12 @@ class OMR_EXTENSIBLE Compilation : public OMR::CompilationConnector bool isGeneratedReflectionMethod(TR_ResolvedMethod *method); // cache J9 VM pointers - TR_OpaqueClassBlock *getObjectClassPointer() { return _ObjectClassPointer; } - TR_OpaqueClassBlock *getRunnableClassPointer() { return _RunnableClassPointer; } - TR_OpaqueClassBlock *getStringClassPointer() { return _StringClassPointer; } - TR_OpaqueClassBlock *getSystemClassPointer() { return _SystemClassPointer; } - TR_OpaqueClassBlock *getReferenceClassPointer() { return _ReferenceClassPointer; } - TR_OpaqueClassBlock *getJITHelpersClassPointer() { return _JITHelpersClassPointer; } + TR_OpaqueClassBlock *getObjectClassPointer(); + TR_OpaqueClassBlock *getRunnableClassPointer(); + TR_OpaqueClassBlock *getStringClassPointer(); + TR_OpaqueClassBlock *getSystemClassPointer(); + TR_OpaqueClassBlock *getReferenceClassPointer(); + TR_OpaqueClassBlock *getJITHelpersClassPointer(); TR_OpaqueClassBlock *getClassClassPointer(bool isVettedForAOT = false); // Monitors @@ -314,6 +314,18 @@ class OMR_EXTENSIBLE Compilation : public OMR::CompilationConnector TR::SymbolValidationManager *getSymbolValidationManager() { return _symbolValidationManager; } private: + enum CachedClassPointerId + { + OBJECT_CLASS_POINTER, + RUNNABLE_CLASS_POINTER, + STRING_CLASS_POINTER, + SYSTEM_CLASS_POINTER, + REFERENCE_CLASS_POINTER, + JITHELPERS_CLASS_POINTER, + CACHED_CLASS_POINTER_COUNT, + }; + + TR_OpaqueClassBlock *getCachedClassPointer(CachedClassPointerId which); J9VMThread *_j9VMThread; @@ -365,12 +377,7 @@ class OMR_EXTENSIBLE Compilation : public OMR::CompilationConnector TR::list _sideEffectGuardPatchSites; // cache VM pointers - TR_OpaqueClassBlock *_ObjectClassPointer; - TR_OpaqueClassBlock *_RunnableClassPointer; - TR_OpaqueClassBlock *_StringClassPointer; - TR_OpaqueClassBlock *_SystemClassPointer; - TR_OpaqueClassBlock *_ReferenceClassPointer; - TR_OpaqueClassBlock *_JITHelpersClassPointer; + TR_OpaqueClassBlock *_cachedClassPointers[CACHED_CLASS_POINTER_COUNT]; TR_OpaqueClassBlock *_aotClassClassPointer; bool _aotClassClassPointerInitialized; diff --git a/runtime/compiler/ras/DebugExt.cpp b/runtime/compiler/ras/DebugExt.cpp index 496deaab059..7784367e724 100644 --- a/runtime/compiler/ras/DebugExt.cpp +++ b/runtime/compiler/ras/DebugExt.cpp @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2000, 2018 IBM Corp. and others + * Copyright (c) 2000, 2019 IBM Corp. and others * * This program and the accompanying materials are made available under * the terms of the Eclipse Public License 2.0 which accompanies this @@ -2540,10 +2540,12 @@ TR_DebugExt::dxPrintCompilation() _dbgPrintf("\tTR_Debug *_debug = 0x%p\n",localCompiler->_debug); _dbgPrintf("\tTR::SymbolReferenceTable *_currentSymRefTab = 0x%p\n",localCompiler->_currentSymRefTab); _dbgPrintf("\tTR::Recompilation *_recompilationInfo = 0x%p\n",localCompiler->_recompilationInfo); - _dbgPrintf("\tTR_OpaqueClassBlock *_ObjectClassPointer = 0x%p\n",localCompiler->_ObjectClassPointer); - _dbgPrintf("\tTR_OpaqueClassBlock *_RunnableClassPointer = 0x%p\n",localCompiler->_RunnableClassPointer); - _dbgPrintf("\tTR_OpaqueClassBlock *_StringClassPointer = 0x%p\n",localCompiler->_StringClassPointer); - _dbgPrintf("\tTR_OpaqueClassBlock *_SystemClassPointer = 0x%p\n",localCompiler->_SystemClassPointer); + _dbgPrintf("\tTR_OpaqueClassBlock *_cachedClassPointers[OBJECT_CLASS_POINTER] = 0x%p\n",localCompiler->_cachedClassPointers[J9::Compilation::OBJECT_CLASS_POINTER]); + _dbgPrintf("\tTR_OpaqueClassBlock *_cachedClassPointers[RUNNABLE_CLASS_POINTER] = 0x%p\n",localCompiler->_cachedClassPointers[J9::Compilation::RUNNABLE_CLASS_POINTER]); + _dbgPrintf("\tTR_OpaqueClassBlock *_cachedClassPointers[STRING_CLASS_POINTER] = 0x%p\n",localCompiler->_cachedClassPointers[J9::Compilation::STRING_CLASS_POINTER]); + _dbgPrintf("\tTR_OpaqueClassBlock *_cachedClassPointers[SYSTEM_CLASS_POINTER] = 0x%p\n",localCompiler->_cachedClassPointers[J9::Compilation::SYSTEM_CLASS_POINTER]); + _dbgPrintf("\tTR_OpaqueClassBlock *_cachedClassPointers[REFERENCE_CLASS_POINTER] = 0x%p\n",localCompiler->_cachedClassPointers[J9::Compilation::REFERENCE_CLASS_POINTER]); + _dbgPrintf("\tTR_OpaqueClassBlock *_cachedClassPointers[JITHELPERS_CLASS_POINTER] = 0x%p\n",localCompiler->_cachedClassPointers[J9::Compilation::JITHELPERS_CLASS_POINTER]); _dbgPrintf("\tTR_OptimizationPlan *_optimizationPlan = !trprint optimizationplan 0x%p\n",localCompiler->_optimizationPlan); _dbgPrintf("\tTR_Array _methodSymbols = 0x%p\n",(char*)_remoteCompiler +((char*)&(localCompiler->_methodSymbols) - (char*)localCompiler) );