Add support for jitDispatchJ9Method for MH on P

Enables transformation of invokeBasic, linkToStatic, and linkToSpecial calls into jitDispatchJ9Method acall nodes. Codegen recognizes this node in private linakge and produces code to directly call the MethodHandle target at runtime - using a new PPCJ9HelperCall snippet when the target is interpreted - otherwise branch and link to jit start pc of target Signed-off-by: Matthew Hall <matthew.hall3@outlook.com>

Author: matthewhall2

runtime/compiler/p/codegen/CallSnippet.cpp

@@ -36,6 +36,7 @@
 #include "il/Node_inlines.hpp"
 #include "p/codegen/PPCAOTRelocation.hpp"
 #include "p/codegen/PPCTableOfConstants.hpp"
+#include "p/codegen/PPCJ9HelperCallSnippet.hpp"
 #include "runtime/CodeCacheManager.hpp"
 
 uint8_t *flushArgumentsToStack(uint8_t *buffer, TR::Node *callNode, int32_t argSize, TR::CodeGenerator *cg)
@@ -47,8 +48,13 @@ uint8_t *flushArgumentsToStack(uint8_t *buffer, TR::Node *callNode, int32_t argS
  TR::Linkage* linkage = cg->getLinkage(callNode->getSymbol()->castToMethodSymbol()->getLinkageConvention());
  const TR::PPCLinkageProperties &linkageProperties = linkage->getProperties();
  int32_t argStart = callNode->getFirstArgumentIndex();
+ bool isJitDispatchJ9Method = callNode->isJitDispatchJ9MethodCall(comp);
+ if (isJitDispatchJ9Method) {
+ argStart += 1;
+ }
 
- if (linkageProperties.getRightToLeft())
+ bool rightToLeft = linkageProperties.getRightToLeft() && !isJitDispatchJ9Method;
+ if (rightToLeft)
  offset = linkage->getOffsetToFirstParm();
  else
  offset = argSize+linkage->getOffsetToFirstParm();
@@ -61,29 +67,29 @@ uint8_t *flushArgumentsToStack(uint8_t *buffer, TR::Node *callNode, int32_t argS
  case TR::Int8:
  case TR::Int16:
  case TR::Int32:
- if (!linkageProperties.getRightToLeft())
+ if (!rightToLeft)
  offset -= TR::Compiler->om.sizeofReferenceAddress();
  if (intArgNum < linkageProperties.getNumIntArgRegs())
  {
  buffer = storeArgumentItem(TR::InstOpCode::stw, buffer, machine->getRealRegister(linkageProperties.getIntegerArgumentRegister(intArgNum)), offset, cg);
  }
  intArgNum++;
- if (linkageProperties.getRightToLeft())
+ if (rightToLeft)
  offset += TR::Compiler->om.sizeofReferenceAddress();
  break;
  case TR::Address:
- if (!linkageProperties.getRightToLeft())
+ if (!rightToLeft)
  offset -= TR::Compiler->om.sizeofReferenceAddress();
  if (intArgNum < linkageProperties.getNumIntArgRegs())
  {
  buffer = storeArgumentItem(storeGPROp, buffer, machine->getRealRegister(linkageProperties.getIntegerArgumentRegister(intArgNum)), offset, cg);
  }
  intArgNum++;
- if (linkageProperties.getRightToLeft())
+ if (rightToLeft)
  offset += TR::Compiler->om.sizeofReferenceAddress();
  break;
  case TR::Int64:
- if (!linkageProperties.getRightToLeft())
+ if (!rightToLeft)
  offset -= 2*TR::Compiler->om.sizeofReferenceAddress();
  if (intArgNum < linkageProperties.getNumIntArgRegs())
  {
@@ -97,29 +103,29 @@ uint8_t *flushArgumentsToStack(uint8_t *buffer, TR::Node *callNode, int32_t argS
  }
  }
  intArgNum += comp->target().is64Bit() ? 1 : 2;
- if (linkageProperties.getRightToLeft())
+ if (rightToLeft)
  offset += 2*TR::Compiler->om.sizeofReferenceAddress();
  break;
  case TR::Float:
- if (!linkageProperties.getRightToLeft())
+ if (!rightToLeft)
  offset -= TR::Compiler->om.sizeofReferenceAddress();
  if (floatArgNum < linkageProperties.getNumFloatArgRegs())
  {
  buffer = storeArgumentItem(TR::InstOpCode::stfs, buffer, machine->getRealRegister(linkageProperties.getFloatArgumentRegister(floatArgNum)), offset, cg);
  }
  floatArgNum++;
- if (linkageProperties.getRightToLeft())
+ if (rightToLeft)
  offset += TR::Compiler->om.sizeofReferenceAddress();
  break;
  case TR::Double:
- if (!linkageProperties.getRightToLeft())
+ if (!rightToLeft)
  offset -= 2*TR::Compiler->om.sizeofReferenceAddress();
  if (floatArgNum < linkageProperties.getNumFloatArgRegs())
  {
  buffer = storeArgumentItem(TR::InstOpCode::stfd, buffer, machine->getRealRegister(linkageProperties.getFloatArgumentRegister(floatArgNum)), offset, cg);
  }
  floatArgNum++;
- if (linkageProperties.getRightToLeft())
+ if (rightToLeft)
  offset += 2*TR::Compiler->om.sizeofReferenceAddress();
  break;
  }
@@ -328,6 +334,25 @@ TR_RuntimeHelper TR::PPCCallSnippet::getInterpretedDispatchHelper(
  }
  }
 
+uint8_t *TR::PPCJ9HelperCallSnippet::emitSnippetBody() {
+ uint8_t *buffer = cg()->getBinaryBufferCursor();
+ uint8_t *gtrmpln, *trmpln;
+
+ getSnippetLabel()->setCodeLocation(buffer);
+ buffer = flushArgumentsToStack(buffer, this->getNode(), this->getSizeOfArguments(), cg());
+
+ if (this->getNode()->isJitDispatchJ9MethodCall(cg()->comp()))
+ {
+ // move value in r11 to r3 for the interpreter
+ // or r11 r3 r11 444 0
+ // 011111 01011 00011 01011 0110111100 0
+ *(int32_t *)buffer = 0x7D635B78;
+ buffer += 4;
+ }
+
+ return this->genHelperCall(buffer);
+}
+
 uint8_t *TR::PPCCallSnippet::emitSnippetBody()
  {
 
@@ -1642,4 +1667,3 @@ TR_Debug::print(TR::FILE *pOutFile, TR::PPCInterfaceCallSnippet * snippet)
  printPrefix(pOutFile, NULL, cursor, sizeof(intptr_t));
  trfprintf(pOutFile, ".long \t" POINTER_PRINTF_FORMAT "\t\t; J2I thunk address for private", *(intptr_t *)cursor);
  }
-

runtime/compiler/p/codegen/J9CodeGenerator.cpp

@@ -832,3 +832,13 @@ J9::Power::CodeGenerator::deriveCallingLinkage(TR::Node *node, bool isIndirect)
 
  return self()->getLinkage(callee->getLinkageConvention());
  }
+
+bool
+J9::Power::CodeGenerator::supportsNonHelper(TR::SymbolReferenceTable::CommonNonhelperSymbol symbol)
+ {
+ if (symbol == TR::SymbolReferenceTable::jitDispatchJ9MethodSymbol)
+ {
+ return true;
+ }
+ return J9::CodeGenerator::supportsNonHelper(symbol);
+ }

runtime/compiler/p/codegen/J9CodeGenerator.hpp

@@ -102,6 +102,8 @@ class OMR_EXTENSIBLE CodeGenerator : public J9::CodeGenerator
 
  bool canEmitDataForExternallyRelocatableInstructions();
 
+ bool supportsNonHelper(TR::SymbolReferenceTable::CommonNonhelperSymbol symbol);
+
 #ifdef J9VM_OPT_JAVA_CRYPTO_ACCELERATION
  bool suppressInliningOfCryptoMethod(TR::RecognizedMethod method);
  bool inlineCryptoMethod(TR::Node *node, TR::Register *&resultReg);

runtime/compiler/p/codegen/PPCJ9HelperCallSnippet.hpp

@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright IBM Corp. and others 2000
+ *
+ * This program and the accompanying materials are made available under
+ * the terms of the Eclipse Public License 2.0 which accompanies this
+ * distribution and is available at https://www.eclipse.org/legal/epl-2.0/
+ * or the Apache License, Version 2.0 which accompanies this distribution and
+ * is available at https://www.apache.org/licenses/LICENSE-2.0.
+ *
+ * This Source Code may also be made available under the following
+ * Secondary Licenses when the conditions for such availability set
+ * forth in the Eclipse Public License, v. 2.0 are satisfied: GNU
+ * General Public License, version 2 with the GNU Classpath
+ * Exception [1] and GNU General Public License, version 2 with the
+ * OpenJDK Assembly Exception [2].
+ *
+ * [1] https://www.gnu.org/software/classpath/license.html
+ * [2] https://openjdk.org/legal/assembly-exception.html
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0 OR GPL-2.0-only WITH OpenJDK-assembly-exception-1.0
+ *******************************************************************************/
+
+#ifndef PPCJ9HELPERCALLSNIPPET_INCL
+#define PPCJ9HELPERCALLSNIPPET_INCL
+
+#include "codegen/Snippet.hpp"
+#include "codegen/PPCHelperCallSnippet.hpp"
+#include "env/VMJ9.h"
+#include "infra/Annotations.hpp"
+#include "p/codegen/PPCInstruction.hpp"
+
+namespace TR { class CodeGenerator; }
+
+namespace TR {
+
+class PPCJ9HelperCallSnippet : public TR::PPCHelperCallSnippet {
+ int32_t _argSize;
+
+public:
+ PPCJ9HelperCallSnippet(TR::CodeGenerator *cg, TR::Node *node, TR::LabelSymbol *snippetlab,
+ TR::SymbolReference *helper, TR::LabelSymbol *restartLabel = NULL, int32_t argSize = -1)
+ : TR::PPCHelperCallSnippet(cg, node, snippetlab, helper, restartLabel)
+ , _argSize(argSize)
+ {}
+
+ int32_t getSizeOfArguments() { return _argSize; }
+ virtual uint8_t *emitSnippetBody();
+};
+}
+
+#endif

runtime/compiler/p/codegen/PPCPrivateLinkage.cpp

@@ -48,6 +48,7 @@
 #include "il/TreeTop.hpp"
 #include "il/TreeTop_inlines.hpp"
 #include "p/codegen/CallSnippet.hpp"
+#include "p/codegen/PPCJ9HelperCallSnippet.hpp"
 #include "p/codegen/GenerateInstructions.hpp"
 #include "p/codegen/PPCEvaluator.hpp"
 #include "p/codegen/PPCHelperCallSnippet.hpp"
@@ -372,7 +373,7 @@ J9::Power::PrivateLinkage::PrivateLinkage(TR::CodeGenerator *cg)
  }
  _properties._computedCallTargetRegister = TR::RealRegister::gr0; // gr11 = interface, gr12 = virtual, so we need something else for computed
  _properties._vtableIndexArgumentRegister = TR::RealRegister::gr12;
- _properties._j9methodArgumentRegister = TR::RealRegister::gr3; // TODO:JSR292: Confirm
+ _properties._j9methodArgumentRegister = TR::RealRegister::gr11; // TODO:JSR292: Confirm
  }
 
 const TR::PPCLinkageProperties& J9::Power::PrivateLinkage::getProperties()
@@ -1466,10 +1467,11 @@ int32_t J9::Power::PrivateLinkage::buildPrivateLinkageArgs(TR::Node
  TR_Array<TR::Register *>& tempLongRegisters = cg()->getTransientLongRegisters();
  TR::MethodSymbol *callSymbol = callNode->getSymbol()->castToMethodSymbol();
 
+ bool isJitDispatchJ9Method = callNode->isJitDispatchJ9MethodCall(comp());
  bool isHelperCall = linkage == TR_Helper || linkage == TR_CHelper;
  bool rightToLeft = isHelperCall &&
  //we want the arguments for induceOSR to be passed from left to right as in any other non-helper call
- !callNode->getSymbolReference()->isOSRInductionHelper();
+ !callNode->getSymbolReference()->isOSRInductionHelper() && !isJitDispatchJ9Method;
 
  if (rightToLeft)
  {
@@ -1511,6 +1513,11 @@ int32_t J9::Power::PrivateLinkage::buildPrivateLinkageArgs(TR::Node
  break;
  }
 
+ if (isJitDispatchJ9Method)
+ {
+ specialArgReg = getProperties().getJ9MethodArgumentRegister();
+ }
+
  if (specialArgReg != TR::RealRegister::NoReg)
  {
  if (comp()->getOption(TR_TraceCG))
@@ -1531,6 +1538,7 @@ int32_t J9::Power::PrivateLinkage::buildPrivateLinkageArgs(TR::Node
  totalSize += TR::Compiler->om.sizeofReferenceAddress();
  }
 
+ // will not process special args
  for (int32_t i = from; (rightToLeft && i >= to) || (!rightToLeft && i <= to); i += step)
  {
  child = callNode->getChild(i);
@@ -1585,8 +1593,20 @@ int32_t J9::Power::PrivateLinkage::buildPrivateLinkageArgs(TR::Node
  pushToMemory = new (trStackMemory()) TR::PPCMemoryArgument[memArgs];
  }
 
- if (specialArgReg)
+ if (specialArgReg && !isJitDispatchJ9Method)
+ {
  from -= step; // we do want to process special args in the following loop
+ }
+ else if (specialArgReg && isJitDispatchJ9Method)
+ {
+ TR::Register *targetReg = cg()->evaluate(callNode->getChild(0));
+ dependencies->addPreCondition(targetReg, specialArgReg);
+ }
+
+ if (isJitDispatchJ9Method)
+ {
+ TR_ASSERT_FATAL(from == step, "should skip first child for jitDispatchJ9Method\n");
+ }
 
  numIntegerArgs = 0;
  numFloatArgs = 0;
@@ -1611,7 +1631,7 @@ int32_t J9::Power::PrivateLinkage::buildPrivateLinkageArgs(TR::Node
  TR::MemoryReference *mref = NULL;
  TR::Register *argRegister;
  child = callNode->getChild(i);
- bool isSpecialArg = (i == from && specialArgReg != TR::RealRegister::NoReg);
+ bool isSpecialArg = (i == from && specialArgReg != TR::RealRegister::NoReg) && !isJitDispatchJ9Method;
  switch (child->getDataType())
  {
  case TR::Int8:
@@ -2868,20 +2888,95 @@ void J9::Power::PrivateLinkage::buildDirectCall(TR::Node *callNode,
  TR::ResolvedMethodSymbol *sym = callSymbol->getResolvedMethodSymbol();
  TR_ResolvedMethod *vmm = (sym==NULL)?NULL:sym->getResolvedMethod();
  bool myself = comp()->isRecursiveMethodTarget(vmm);
+ bool isJitDispatchJ9Method = callNode->isJitDispatchJ9MethodCall(comp());
 
  TR_J9VMBase *fej9 = (TR_J9VMBase *)(comp()->fe());
 
- if (callSymRef->getReferenceNumber() >= TR_PPCnumRuntimeHelpers)
+ if ((callSymRef->getReferenceNumber() >= TR_PPCnumRuntimeHelpers) && !isJitDispatchJ9Method)
  fej9->reserveTrampolineIfNecessary(comp(), callSymRef, false);
 
  bool forceUnresolvedDispatch = !fej9->isResolvedDirectDispatchGuaranteed(comp());
- if ((callSymbol->isJITInternalNative() ||
+ if (!isJitDispatchJ9Method && (callSymbol->isJITInternalNative() ||
  (!callSymRef->isUnresolved() && !callSymbol->isInterpreted() && ((forceUnresolvedDispatch && callSymbol->isHelper()) || !forceUnresolvedDispatch))))
  {
  gcPoint = generateDepImmSymInstruction(cg(), TR::InstOpCode::bl, callNode,
  myself?0:(uintptr_t)callSymbol->getMethodAddress(),
  dependencies, callSymRef?callSymRef:callNode->getSymbolReference());
  }
+ else if (isJitDispatchJ9Method)
+ {
+ auto flags = pp.getPreservedRegisterMapForGC();
+ // we do not want gr11 in the gc map since this will not contain any object reference
+ flags ^= 1 << pp.getJ9MethodArgumentRegister();
+
+ TR::Register *scratchReg = dependencies->searchPostConditionRegister(pp.getVTableIndexArgumentRegister());
+ TR::Register *scratchReg2 = cg()->allocateRegister();
+ TR::Register *cndReg = dependencies->searchPreConditionRegister(TR::RealRegister::cr0);
+ TR::Register *j9MethodReg = callNode->getChild(0)->getRegister();
+
+ TR::LabelSymbol *startICFLabel = generateLabelSymbol(cg());
+ TR::LabelSymbol *doneLabel = generateLabelSymbol(cg());
+ TR::LabelSymbol *oolLabel = generateLabelSymbol(cg());
+ startICFLabel->setStartInternalControlFlow();
+ doneLabel->setEndInternalControlFlow();
+
+ TR::RegisterDependencyConditions *preDeps = dependencies->clone(cg());
+ preDeps->setNumPostConditions(0, trMemory());
+ preDeps->setAddCursorForPost(0);
+
+ TR::RegisterDependencyConditions *newPostDeps = new (trHeapMemory()) TR::RegisterDependencyConditions(0, 2, trMemory());
+ newPostDeps->addPostCondition(j9MethodReg, TR::RealRegister::NoReg);
+ newPostDeps->addPostCondition(scratchReg2,TR::RealRegister::NoReg);
+
+ TR::RegisterDependencyConditions *postDeps = dependencies->clone(cg(), newPostDeps);
+ postDeps->setNumPreConditions(0, trMemory());
+ postDeps->setAddCursorForPre(0);
+
+ TR::LabelSymbol *snippetLabel = generateLabelSymbol(cg());
+ TR::SymbolReference *helperRef = cg()->symRefTab()->findOrCreateRuntimeHelper(TR_j2iTransition);
+ TR::Snippet *interpCallSnippet = new (cg()->trHeapMemory()) TR::PPCJ9HelperCallSnippet(cg(), callNode, snippetLabel, helperRef, doneLabel, argSize);
+ interpCallSnippet->gcMap().setGCRegisterMask(flags);
+ cg()->addSnippet(interpCallSnippet);
+
+ TR_PPCOutOfLineCodeSection *snippetCall = new (cg()->trHeapMemory()) TR_PPCOutOfLineCodeSection(oolLabel, doneLabel, cg());
+ cg()->getPPCOutOfLineCodeSectionList().push_front(snippetCall);
+ snippetCall->swapInstructionListsWithCompilation();
+ TR::Instruction *OOLLabelInstr = generateLabelInstruction(cg(), TR::InstOpCode::label, callNode, oolLabel);
+ gcPoint = generateDepLabelInstruction(cg(), TR::InstOpCode::bl, callNode, snippetLabel, dependencies);
+ gcPoint->PPCNeedsGCMap(flags);
+ generateLabelInstruction(cg(), TR::InstOpCode::b, callNode, doneLabel);
+ // helper snippet sets up jump back to doneLabel
+ snippetCall->swapInstructionListsWithCompilation();
+
+ generateDepLabelInstruction(cg(), TR::InstOpCode::label, callNode, startICFLabel, preDeps);
+
+ // test if compiled
+ generateTrg1MemInstruction(cg(), TR::InstOpCode::Op_load, callNode, scratchReg,
+ TR::MemoryReference::createWithDisplacement(cg(), j9MethodReg, offsetof(J9Method, extra), TR::Compiler->om.sizeofReferenceAddress()));
+ generateTrg1Src1ImmInstruction(cg(), TR::InstOpCode::andi_r, callNode, scratchReg2, scratchReg, 1);
+ // branch to ool if J9_STARTPC_NOT_TRANSLATED is set
+ gcPoint = generateConditionalBranchInstruction(cg(), TR::InstOpCode::bne, callNode, oolLabel, cndReg);
+ gcPoint->PPCNeedsGCMap(flags);
+
+ // compiled - jump to jit entry point
+ generateTrg1MemInstruction(cg(), TR::InstOpCode::Op_load, callNode, j9MethodReg,
+ TR::MemoryReference::createWithDisplacement(cg(), scratchReg, -4, TR::Compiler->om.sizeofReferenceAddress()));
+ generateTrg1Src1ImmInstruction(cg(), TR::InstOpCode::srawi, callNode, j9MethodReg, j9MethodReg, 16);
+ if (comp()->target().is64Bit())
+ {
+ generateTrg1Src1Instruction(cg(), TR::InstOpCode::extsw, callNode, j9MethodReg, j9MethodReg);
+ }
+ generateTrg1Src2Instruction(cg(), TR::InstOpCode::add, callNode, scratchReg, j9MethodReg, scratchReg);
+ generateSrc1Instruction(cg(), TR::InstOpCode::mtctr, callNode, scratchReg);
+ gcPoint = generateInstruction(cg(), TR::InstOpCode::bctrl, callNode);
+ gcPoint->PPCNeedsGCMap(flags);
+
+ cg()->stopUsingRegister(scratchReg);
+ cg()->stopUsingRegister(scratchReg2);
+ cg()->stopUsingRegister(cndReg);
+ generateDepLabelInstruction(cg(), TR::InstOpCode::label, callNode, doneLabel, postDeps);
+ return;
+ }
  else
  {
  TR::LabelSymbol *label = generateLabelSymbol(cg());