diff --git a/runtime/compiler/env/VMJ9.cpp b/runtime/compiler/env/VMJ9.cpp index 9575d28c064..e9504e5b395 100644 --- a/runtime/compiler/env/VMJ9.cpp +++ b/runtime/compiler/env/VMJ9.cpp @@ -2733,7 +2733,7 @@ TR_J9VMBase::maybeHighlyPolymorphic(TR::Compilation *comp, TR_ResolvedMethod *ca else { int32_t len = callee->classNameLength(); - char *s = classNameToSignature(callee->classNameChars(), len, comp); + char *s = TR::Compiler->cls.classNameToSignature(callee->classNameChars(), len, comp); classOfMethod = getClassFromSignature(s, len, caller, true); } if (classOfMethod) @@ -5359,7 +5359,7 @@ TR_J9VMBase::getFieldOffset(TR::Compilation * comp, TR::SymbolReference* classRe fprintf(stderr," (len is %d)\n",len);fflush(stderr); **/ - char* classSignature = classNameToSignature((char*)u8ClassString, len, comp); + char* classSignature = TR::Compiler->cls.classNameToSignature((char*)u8ClassString, len, comp); /** fprintf(stderr,"classSignature is \n"); @@ -7820,7 +7820,7 @@ TR_J9VM::inlineNativeCall(TR::Compilation * comp, TR::TreeTop * callNodeTreeTop, TR::SymbolReference * callerSymRef = callNode->getSymbolReference(); TR_ResolvedMethod * owningMethod = callerSymRef->getOwningMethod(comp); int32_t len = owningMethod->classNameLength(); - char * s = classNameToSignature(owningMethod->classNameChars(), len, comp); + char * s = TR::Compiler->cls.classNameToSignature(owningMethod->classNameChars(), len, comp); TR_OpaqueClassBlock * ReferenceClass = getClassFromSignature(s, len, owningMethod); // defect 143867, ReferenceClass == 0 and crashed later in findFieldInClass() if (!ReferenceClass) diff --git a/runtime/compiler/env/j9method.cpp b/runtime/compiler/env/j9method.cpp index c7c24942501..bf91ea651a4 100644 --- a/runtime/compiler/env/j9method.cpp +++ b/runtime/compiler/env/j9method.cpp @@ -7064,7 +7064,7 @@ TR_ResolvedJ9Method::makeParameterList(TR::ResolvedMethodSymbol *methodSym) parmSymbol->setOrdinal(ordinal++); int32_t len = classNameLen; // len is passed by reference and changes during the call - char * s = classNameToSignature(className, len, methodSym->comp(), heapAlloc); + char * s = TR::Compiler->cls.classNameToSignature(className, len, methodSym->comp(), heapAlloc); la.add(parmSymbol); parmSymbol->setTypeSignature(s, len); diff --git a/runtime/compiler/il/J9SymbolReference.cpp b/runtime/compiler/il/J9SymbolReference.cpp index dcac3ecde59..a87b97e7e7b 100644 --- a/runtime/compiler/il/J9SymbolReference.cpp +++ b/runtime/compiler/il/J9SymbolReference.cpp @@ -267,7 +267,7 @@ SymbolReference::getTypeSignature(int32_t & len, TR_AllocationKind allocKind, bo const char * s = TR::Compiler->cls.classNameChars(comp, classOfObject, len); if (s && (s[0] != '[')) { - s = classNameToSignature(s, len, comp); + s = TR::Compiler->cls.classNameToSignature(s, len, comp); } else { @@ -278,7 +278,7 @@ SymbolReference::getTypeSignature(int32_t & len, TR_AllocationKind allocKind, bo classOfObject = comp->fe()->getComponentClassFromArrayClass(classOfObject); s = TR::Compiler->cls.classNameChars(comp, classOfObject, len); } - s = classNameToSignature(s, len, comp); + s = TR::Compiler->cls.classNameToSignature(s, len, comp); s = prependNumParensToSig(s, len, numParens); } @@ -298,7 +298,7 @@ SymbolReference::getTypeSignature(int32_t & len, TR_AllocationKind allocKind, bo len = 18; return "Ljava/lang/Object;"; } - return classNameToSignature(sig, len, comp, allocKind); + return TR::Compiler->cls.classNameToSignature(sig, len, comp, allocKind); } if (_symbol->isConstString()) diff --git a/runtime/compiler/ilgen/Walker.cpp b/runtime/compiler/ilgen/Walker.cpp index 144626b8423..e73813afdb7 100644 --- a/runtime/compiler/ilgen/Walker.cpp +++ b/runtime/compiler/ilgen/Walker.cpp @@ -1825,7 +1825,7 @@ TR_J9ByteCodeIlGenerator::loadConstantValueIfPossible(TR::Node *topNode, uintptr classNameOfFieldOrStatic = symRef->getOwningMethod(comp())->classNameOfFieldOrStatic(symRef->getCPIndex(), len); if (classNameOfFieldOrStatic) { - classNameOfFieldOrStatic=classNameToSignature(classNameOfFieldOrStatic, len, comp()); + classNameOfFieldOrStatic = TR::Compiler->cls.classNameToSignature(classNameOfFieldOrStatic, len, comp()); TR_OpaqueClassBlock * curClass = fej9->getClassFromSignature(classNameOfFieldOrStatic, len, symRef->getOwningMethod(comp())); TR_OpaqueClassBlock * owningClass = comp()->getJittedMethodSymbol()->getResolvedMethod()->containingClass(); if (owningClass == curClass) @@ -4170,7 +4170,7 @@ break // Can't use recognized methods since it's not enabled on AOT //if (symbol->getRecognizedMethod() == TR::com_ibm_rmi_io_FastPathForCollocated_isVMDeepCopySupported) int32_t len = calledMethod->classNameLength(); - char * s = classNameToSignature(calledMethod->classNameChars(), len, comp()); + char * s = TR::Compiler->cls.classNameToSignature(calledMethod->classNameChars(), len, comp()); if (strstr(s, "com/ibm/rmi/io/FastPathForCollocated") && !strncmp(calledMethod->nameChars(), "isVMDeepCopySupported", calledMethod->nameLength())) @@ -4228,7 +4228,7 @@ break performClassLookahead(_classInfo); int32_t len = calledMethod->classNameLength(); - char * s = classNameToSignature(calledMethod->classNameChars(), len, comp()); + char * s = TR::Compiler->cls.classNameToSignature(calledMethod->classNameChars(), len, comp()); TR::Node * thisObject = invokedynamicReceiver ? invokedynamicReceiver : _stack->element(_stack->topIndex() - (numArgs-1)); TR_PersistentFieldInfo * fieldInfo = _classInfo->getFieldInfo() ? _classInfo->getFieldInfo()->findFieldInfo(comp(), thisObject, false) : NULL; @@ -5524,7 +5524,7 @@ TR_J9ByteCodeIlGenerator::loadStatic(int32_t cpIndex) classNameOfFieldOrStatic = symRef->getOwningMethod(comp())->classNameOfFieldOrStatic(symRef->getCPIndex(), len); if (classNameOfFieldOrStatic) { - classNameOfFieldOrStatic=classNameToSignature(classNameOfFieldOrStatic, len, comp()); + classNameOfFieldOrStatic = TR::Compiler->cls.classNameToSignature(classNameOfFieldOrStatic, len, comp()); TR_OpaqueClassBlock * curClass = fej9->getClassFromSignature(classNameOfFieldOrStatic, len, symRef->getOwningMethod(comp())); TR_OpaqueClassBlock * owningClass = comp()->getJittedMethodSymbol()->getResolvedMethod()->containingClass(); if (owningClass == curClass) diff --git a/runtime/compiler/optimizer/EscapeAnalysis.cpp b/runtime/compiler/optimizer/EscapeAnalysis.cpp index d99278a46f2..a080957dfb5 100644 --- a/runtime/compiler/optimizer/EscapeAnalysis.cpp +++ b/runtime/compiler/optimizer/EscapeAnalysis.cpp @@ -4898,7 +4898,7 @@ void TR_EscapeAnalysis::checkEscapeViaCall(TR::Node *node, TR::NodeChecklist& vi TR::MethodSymbol *sym = symRef->getSymbol()->castToMethodSymbol(); TR::Method * originalMethod = sym->getMethod(); int32_t len = originalMethod->classNameLength(); - char *s = classNameToSignature(originalMethod->classNameChars(), len, comp()); + char *s = TR::Compiler->cls.classNameToSignature(originalMethod->classNameChars(), len, comp()); TR_OpaqueClassBlock *originalMethodClass = comp()->fej9()->getClassFromSignature(s, len, owningMethod); TR_OpaqueClassBlock *thisType = (TR_OpaqueClassBlock *) candidate->_node->getFirstChild()->getSymbol()->castToStaticSymbol()->getStaticAddress(); int32_t offset = -1; diff --git a/runtime/compiler/optimizer/InlinerTempForJ9.cpp b/runtime/compiler/optimizer/InlinerTempForJ9.cpp index 7db53368347..1daff82adbc 100644 --- a/runtime/compiler/optimizer/InlinerTempForJ9.cpp +++ b/runtime/compiler/optimizer/InlinerTempForJ9.cpp @@ -5699,7 +5699,7 @@ TR_PrexArgInfo* TR_PrexArgInfo::buildPrexArgInfoForMethodSymbol(TR::ResolvedMeth static void populateClassNameSignature(TR::Method *m, TR_ResolvedMethod* caller, TR_OpaqueClassBlock* &c, char* &nc, int32_t &nl, char* &sc, int32_t &sl) { int32_t len = m->classNameLength(); - char* cs = classNameToSignature(m->classNameChars(), len, TR::comp()); + char* cs = TR::Compiler->cls.classNameToSignature(m->classNameChars(), len, TR::comp()); c = caller->fe()->getClassFromSignature(cs, len, caller); nc = m->nameChars(); nl = m->nameLength(); @@ -5710,7 +5710,7 @@ static void populateClassNameSignature(TR::Method *m, TR_ResolvedMethod* caller, static char* classSignature (TR::Method * m, TR::Compilation* comp) //tracer helper { int32_t len = m->classNameLength(); - return classNameToSignature(m->classNameChars(), len /*don't care, cos this gives us a null terminated string*/, comp); + return TR::Compiler->cls.classNameToSignature(m->classNameChars(), len /*don't care, cos this gives us a null terminated string*/, comp); } static bool treeMatchesCallSite(TR::TreeTop* tt, TR::ResolvedMethodSymbol* callerSymbol, TR_CallSite* callsite, TR_LogTracer* tracer) diff --git a/runtime/compiler/optimizer/InterProceduralAnalyzer.cpp b/runtime/compiler/optimizer/InterProceduralAnalyzer.cpp index f7ae35da0f9..ebe1ba6007c 100644 --- a/runtime/compiler/optimizer/InterProceduralAnalyzer.cpp +++ b/runtime/compiler/optimizer/InterProceduralAnalyzer.cpp @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2000, 2020 IBM Corp. and others + * Copyright (c) 2000, 2021 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 @@ -216,7 +216,7 @@ List *TR::InterProceduralAnalyzer::analyzeCallGraph(TR:: int32_t cpIndex = symRef->getCPIndex(); TR::Method * originalMethod = methodSymbol->getMethod(); int32_t len = originalMethod->classNameLength(); - char *s = classNameToSignature(originalMethod->classNameChars(), len, comp()); + char *s = TR::Compiler->cls.classNameToSignature(originalMethod->classNameChars(), len, comp()); clazz = fe()->getClassFromSignature(s, len, owningMethod); if (!clazz) { diff --git a/runtime/compiler/optimizer/J9Inliner.cpp b/runtime/compiler/optimizer/J9Inliner.cpp index 1e358353b7f..7553ee2b8ec 100644 --- a/runtime/compiler/optimizer/J9Inliner.cpp +++ b/runtime/compiler/optimizer/J9Inliner.cpp @@ -659,7 +659,7 @@ bool TR_J9InterfaceCallSite::findCallSiteTarget (TR_CallStack *callStack, TR_Inl if (!_receiverClass) { int32_t len = _interfaceMethod->classNameLength(); - char * s = classNameToSignature(_interfaceMethod->classNameChars(), len, comp()); + char * s = TR::Compiler->cls.classNameToSignature(_interfaceMethod->classNameChars(), len, comp()); _receiverClass = comp()->fej9()->getClassFromSignature(s, len, _callerResolvedMethod, true); } @@ -690,7 +690,7 @@ bool TR_J9InterfaceCallSite::findCallSiteTarget (TR_CallStack *callStack, TR_Inl TR_OpaqueClassBlock* TR_J9InterfaceCallSite::getClassFromMethod () { int32_t len = _interfaceMethod->classNameLength(); - char * s = classNameToSignature(_interfaceMethod->classNameChars(), len, comp()); + char * s = TR::Compiler->cls.classNameToSignature(_interfaceMethod->classNameChars(), len, comp()); return comp()->fej9()->getClassFromSignature(s, len, _callerResolvedMethod, true); } diff --git a/runtime/compiler/optimizer/MonitorElimination.cpp b/runtime/compiler/optimizer/MonitorElimination.cpp index 47ef67a5c60..4fc978efbc4 100644 --- a/runtime/compiler/optimizer/MonitorElimination.cpp +++ b/runtime/compiler/optimizer/MonitorElimination.cpp @@ -5309,7 +5309,7 @@ bool TR::CoarseningInterProceduralAnalyzer::analyzeNode(TR::Node *node, vcount_t if (originalMethod) { classnameLength = originalMethod->classNameLength(); - className = classNameToSignature(originalMethod->classNameChars(), classnameLength, comp()); + className = TR::Compiler->cls.classNameToSignature(originalMethod->classNameChars(), classnameLength, comp()); } } diff --git a/runtime/compiler/runtime/J9Profiler.cpp b/runtime/compiler/runtime/J9Profiler.cpp index 574a041b4dd..cf6d6ef1da1 100644 --- a/runtime/compiler/runtime/J9Profiler.cpp +++ b/runtime/compiler/runtime/J9Profiler.cpp @@ -449,7 +449,7 @@ void TR_ValueProfiler::modifyTrees() TR::Method *interfaceMethod = methodSymbol->getMethod(); int32_t cpIndex = methodSymRef->getCPIndex(); int32_t len = interfaceMethod->classNameLength(); - char * s = classNameToSignature(interfaceMethod->classNameChars(), len, comp()); + char * s = TR::Compiler->cls.classNameToSignature(interfaceMethod->classNameChars(), len, comp()); TR_OpaqueClassBlock *thisClass = comp()->fe()->getClassFromSignature(s, len, methodSymRef->getOwningMethod(comp())); if (thisClass) { diff --git a/runtime/compiler/x/codegen/X86PrivateLinkage.cpp b/runtime/compiler/x/codegen/X86PrivateLinkage.cpp index 3b9f1830de9..f16239afeb0 100644 --- a/runtime/compiler/x/codegen/X86PrivateLinkage.cpp +++ b/runtime/compiler/x/codegen/X86PrivateLinkage.cpp @@ -1182,7 +1182,7 @@ TR::X86CallSite::X86CallSite(TR::Node *callNode, TR::Linkage *calleeLinkage) // TR::Method *interfaceMethod = getMethodSymbol()->getMethod(); int32_t len = interfaceMethod->classNameLength(); - char * s = classNameToSignature(interfaceMethod->classNameChars(), len, comp()); + char * s = TR::Compiler->cls.classNameToSignature(interfaceMethod->classNameChars(), len, comp()); _interfaceClassOfMethod = fej9->getClassFromSignature(s, len, getSymbolReference()->getOwningMethod(comp())); }