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

@@ -39,7 +39,7 @@
 #include "ras/Logger.hpp"
 #include "runtime/CodeCacheManager.hpp"
 
-uint8_t *flushArgumentsToStack(uint8_t *buffer, TR::Node *callNode, int32_t argSize, TR::CodeGenerator *cg)
+uint8_t *TR::PPCCallSnippet::flushArgumentsToStack(uint8_t *buffer, TR::Node *callNode, int32_t argSize, TR::CodeGenerator *cg)
    {
    int32_t        intArgNum=0, floatArgNum=0, offset;
    TR::Compilation *comp = cg->comp();
@@ -48,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();
@@ -62,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())
                {
@@ -98,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;
          }
@@ -1644,4 +1649,3 @@ TR_Debug::print(OMR::Logger *log, TR::PPCInterfaceCallSnippet * snippet)
    printPrefix(log, NULL, cursor, sizeof(intptr_t));
    log->printf(".long \t" POINTER_PRINTF_FORMAT "\t\t; J2I thunk address for private", *(intptr_t *)cursor);
    }
-

runtime/compiler/p/codegen/CallSnippet.hpp

@@ -57,6 +57,7 @@ class PPCCallSnippet : public TR::Snippet
    TR::SymbolReference * _realMethodSymbolReference;
 
    public:
+   static uint8_t *flushArgumentsToStack(uint8_t *buffer, TR::Node *callNode, int32_t argSize, TR::CodeGenerator *cg);
 
    PPCCallSnippet(TR::CodeGenerator *cg, TR::Node *c, TR::LabelSymbol *lab, int32_t s)
       : TR::Snippet(cg, c, lab, needsGCMap(cg, c->getSymbolReference())), sizeOfArguments(s), callRA(0)

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/J9PPCSnippet.cpp

@@ -42,6 +42,7 @@
 #include "p/codegen/PPCEvaluator.hpp"
 #include "p/codegen/PPCInstruction.hpp"
 #include "p/codegen/GenerateInstructions.hpp"
+#include "p/codegen/CallSnippet.hpp"
 #include "ras/Logger.hpp"
 #include "runtime/CodeCache.hpp"
 #include "runtime/CodeCacheManager.hpp"
@@ -293,6 +294,25 @@ int32_t TR::PPCReadMonitorSnippet::setEstimatedCodeLocation(int32_t estimatedSni
    return(estimatedSnippetStart);
    }
 
+uint8_t *TR::PPCJ9HelperCallSnippet::emitSnippetBody() {
+    uint8_t *buffer = cg()->getBinaryBufferCursor();
+    uint8_t *gtrmpln, *trmpln;
+
+    getSnippetLabel()->setCodeLocation(buffer);
+    buffer = TR::PPCCallSnippet::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);
+}
+
 TR::PPCAllocPrefetchSnippet::PPCAllocPrefetchSnippet(
    TR::CodeGenerator   *codeGen,
    TR::Node            *node,
@@ -1270,4 +1290,3 @@ uint32_t TR::PPCNonZeroAllocPrefetchSnippet::getLength(int32_t estimatedCodeStar
 
    return PPC_INSTRUCTION_LENGTH;
    }
-

runtime/compiler/p/codegen/J9PPCSnippet.hpp

@@ -74,6 +74,20 @@ class PPCReadMonitorSnippet : public TR::PPCHelperCallSnippet
    int32_t getLoadOffset() { return _loadOffset; }
    };
 
+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();
+};
+
 class PPCAllocPrefetchSnippet : public TR::Snippet
    {
 

runtime/compiler/p/codegen/PPCPrivateLinkage.cpp

@@ -49,6 +49,7 @@
 #include "il/TreeTop_inlines.hpp"
 #include "p/codegen/CallSnippet.hpp"
 #include "p/codegen/GenerateInstructions.hpp"
+#include "p/codegen/J9PPCSnippet.hpp"
 #include "p/codegen/PPCEvaluator.hpp"
 #include "p/codegen/PPCHelperCallSnippet.hpp"
 #include "p/codegen/PPCInstruction.hpp"
@@ -373,7 +374,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()
@@ -1470,10 +1471,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)
       {
@@ -1501,7 +1503,7 @@ int32_t J9::Power::PrivateLinkage::buildPrivateLinkageArgs(TR::Node
    switch (callSymbol->getMandatoryRecognizedMethod())
       {
       // Node: special long args are still only passed in one GPR
-      case TR::java_lang_invoke_ComputedCalls_dispatchJ9Method:
+      case TR::java_lang_invoke_ComputedCalls_dispatchJ9Method: // old MH implementation
          specialArgReg = getProperties().getJ9MethodArgumentRegister();
          // Other args go in memory
          numIntArgRegs   = 0;
@@ -1515,6 +1517,11 @@ int32_t J9::Power::PrivateLinkage::buildPrivateLinkageArgs(TR::Node
          break;
       }
 
+   if (isJitDispatchJ9Method)
+      {
+      specialArgReg = getProperties().getJ9MethodArgumentRegister();
+      }
+
    if (specialArgReg != TR::RealRegister::NoReg)
       {
       logprintf(trace, log, "Special arg %s in %s\n",
@@ -1533,6 +1540,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);
@@ -1588,7 +1596,9 @@ int32_t J9::Power::PrivateLinkage::buildPrivateLinkageArgs(TR::Node
       }
 
    if (specialArgReg)
+      {
       from -= step;  // we do want to process special args in the following loop
+      }
 
    numIntegerArgs = 0;
    numFloatArgs = 0;
@@ -2870,20 +2880,94 @@ 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 regMapMask = pp.getPreservedRegisterMapForGC();
+
+      TR::Register *scratchReg = dependencies->searchPostConditionRegister(pp.getVTableIndexArgumentRegister());
+      TR::Register *scratchReg2 = dependencies->searchPreConditionRegister(TR::RealRegister::gr0);
+      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 *postDeps = dependencies->clone(cg());
+      postDeps->setNumPreConditions(0, trMemory());
+      postDeps->setAddCursorForPre(0);
+
+      TR::LabelSymbol *snippetLabel = generateLabelSymbol(cg());
+      TR::SymbolReference *helperRef = cg()->symRefTab()->findOrCreateRuntimeHelper(TR_j2iTransition, true, true, false);
+      TR::Snippet *interpCallSnippet = new (cg()->trHeapMemory()) TR::PPCJ9HelperCallSnippet(cg(), callNode, snippetLabel, helperRef, doneLabel, argSize);
+      interpCallSnippet->gcMap().setGCRegisterMask(regMapMask);
+      cg()->addSnippet(interpCallSnippet);
+      TR::SymbolReference *snippetSymRef = new (trHeapMemory()) TR::SymbolReference(comp()->getSymRefTab(), snippetLabel);
+
+      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(regMapMask);
+      generateLabelInstruction(cg(), TR::InstOpCode::b, callNode, 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);
+      cg()->stopUsingRegister(scratchReg2);
+
+      if (cg()->stressJitDispatchJ9MethodJ2I())
+         {
+         gcPoint =  generateLabelInstruction(cg(), TR::InstOpCode::b, callNode, oolLabel);
+         }
+      else
+         {
+         generateConditionalBranchInstruction(cg(), TR::InstOpCode::bne, callNode, oolLabel, cndReg);
+         }
+      gcPoint->PPCNeedsGCMap(regMapMask);
+
+      // 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(regMapMask);
+
+      generateDepLabelInstruction(cg(), TR::InstOpCode::label, callNode, doneLabel, postDeps);
+      return;
+      }
    else
       {
       TR::LabelSymbol *label   = generateLabelSymbol(cg());