Merge pull request #21742 from jdmpapin/linkToVirtual-invokeBasic-0.51

(0.51) Add table of invokeBasic() call sites to J9JITExceptionTable

Author: pshipton

doc/compiler/runtime/J9JITExceptionTable.md

@@ -56,6 +56,8 @@ The following diagram provides the high level overview. The
 (7) | GPU Info                                            | // If GPU
     |-----------------------------------------------------|
 (8) | Bytecode PC to Instruction Address Map              | // If Hardware Profiling
+    |-----------------------------------------------------|
+(9) | invokeBasic() Call Site Info                        | // If Applicable Call Sites Exist
     +-----------------------------------------------------+
 ```
 
@@ -434,4 +436,11 @@ set of data for each mapping
 via the `bodyInfo` field of the `J9JITExceptionTable` struct. This
 structure contains data such as flags used to describe the body,
 as well as data used to implement features such as
-Guarded Counting Recompilation (GCR).
+Guarded Counting Recompilation (GCR).
+
+## (9) `invokeBasic()` Call Info
+The `invokeBasic()` Call Info section can be accessed via the
+`invokeBasicCallInfo` field of the `J9JITExceptionTable` struct. This section
+consists of a single instance of the variable-size `J9JITInvokeBasicCallInfo`
+struct, which contains a table of call sites that are capable of calling the
+interpreter's implementation of `MethodHandle.invokeBasic()`.

runtime/codert_vm/cnathelp.cpp

@@ -3383,12 +3383,26 @@ old_slow_icallVMprJavaSendPatchupVirtual(J9VMThread *currentThread)
 	J9Class *clazz = J9OBJECT_CLAZZ(currentThread, receiver);
 	UDATA interpVTableOffset = sizeof(J9Class) - jitVTableOffset;
 	J9Method *method = *(J9Method**)((UDATA)clazz + interpVTableOffset);
-	J9ROMMethod *romMethod = J9_ROM_METHOD_FROM_RAM_METHOD(method);
-	J9ROMNameAndSignature *nas = &romMethod->nameAndSignature;
-	UDATA const thunk = (UDATA)jitConfig->thunkLookUpNameAndSig(jitConfig, nas);
-	UDATA const patchup = (UDATA)jitConfig->patchupVirtual;
-	UDATA *jitVTableSlot = (UDATA*)((UDATA)clazz + jitVTableOffset);
-	VM_AtomicSupport::lockCompareExchange(jitVTableSlot, patchup, thunk);
+	UDATA thunk = 0;
+#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
+	if (J9_BCLOOP_SEND_TARGET_METHODHANDLE_INVOKEBASIC == J9_BCLOOP_DECODE_SEND_TARGET(method->methodRunAddress)) {
+		/* Because invokeBasic() is signature-polymorphic, the signature from the ROM method is irrelevant.
+		 * We need the J2I thunk that corresponds to the signature that the JIT was using at the call site.
+		 * Since this varies depending on the call site, we can't replace the VFT entry with the J2I thunk.
+		 */
+		J9JITInvokeBasicCallSite *site = jitGetInvokeBasicCallSiteFromPC(currentThread, (UDATA)jitReturnAddress);
+		thunk = (UDATA)site->j2iThunk;
+	}
+	else
+#endif /* defined(J9VM_OPT_OPENJDK_METHODHANDLE) */
+	{
+		J9ROMMethod *romMethod = J9_ROM_METHOD_FROM_RAM_METHOD(method);
+		J9ROMNameAndSignature *nas = &romMethod->nameAndSignature;
+		thunk = (UDATA)jitConfig->thunkLookUpNameAndSig(jitConfig, nas);
+		UDATA const patchup = (UDATA)jitConfig->patchupVirtual;
+		UDATA *jitVTableSlot = (UDATA*)((UDATA)clazz + jitVTableOffset);
+		VM_AtomicSupport::lockCompareExchange(jitVTableSlot, patchup, thunk);
+	}
 	currentThread->tempSlot = thunk;
 }
 

runtime/compiler/aarch64/codegen/ARM64PrivateLinkage.cpp

@@ -1430,6 +1430,14 @@ void J9::ARM64::PrivateLinkage::buildDirectCall(TR::Node *callNode,
          new (trHeapMemory()) TR::SymbolReference(comp()->getSymRefTab(), label),
          snippet);
 
+#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
+      auto rm = callSymbol->getMandatoryRecognizedMethod();
+      if (rm == TR::java_lang_invoke_MethodHandle_invokeBasic)
+         {
+         cg()->addInvokeBasicCallSite(callNode, gcPoint);
+         }
+#endif
+
       // Nop is necessary due to confusion when resolving shared slots at a transition
       if (callSymRef->isOSRInductionHelper())
          cg()->generateNop(callNode);
@@ -2090,6 +2098,15 @@ void J9::ARM64::PrivateLinkage::buildVirtualDispatch(TR::Node *callNode,
       TR::Instruction *gcPoint = generateRegBranchInstruction(cg(), TR::InstOpCode::blr, callNode, vftReg, dependencies);
       gcPoint->ARM64NeedsGCMap(cg(), regMapForGC);
 
+#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
+      // JITHelpers.dispatchVirtual() can target MethodHandle.invokeBasic().
+      auto rm = methodSymbol->getMandatoryRecognizedMethod();
+      if (rm == TR::com_ibm_jit_JITHelpers_dispatchVirtual)
+         {
+         cg()->addInvokeBasicCallSite(callNode, gcPoint);
+         }
+#endif
+
       return;
       }
 

runtime/compiler/codegen/J9CodeGenerator.cpp

@@ -81,6 +81,9 @@ J9::CodeGenerator::CodeGenerator(TR::Compilation *comp) :
    _jniCallSites(getTypedAllocator<TR_Pair<TR_ResolvedMethod,TR::Instruction> *>(comp->allocator())),
    _monitorMapping(std::less<ncount_t>(), MonitorMapAllocator(comp->trMemory()->heapMemoryRegion())),
    _dummyTempStorageRefNode(NULL)
+#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
+   , _invokeBasicCallSites(comp->region())
+#endif
    {
    /**
     * Do not add CodeGenerator initialization logic here.
@@ -797,15 +800,16 @@ J9::CodeGenerator::lowerTreeIfNeeded(
       {
       TR::RecognizedMethod rm = node->getSymbol()->castToMethodSymbol()->getMandatoryRecognizedMethod();
 
-      if(rm == TR::java_lang_invoke_MethodHandle_invokeBasic ||
-        rm == TR::java_lang_invoke_MethodHandle_linkToStatic ||
+      // There's no need to set tempSlot for invokeBasic(). The number of stack
+      // slots for the arguments will be available from the JIT body metadata.
+
+      if(rm == TR::java_lang_invoke_MethodHandle_linkToStatic ||
         rm == TR::java_lang_invoke_MethodHandle_linkToSpecial ||
         rm == TR::java_lang_invoke_MethodHandle_linkToVirtual ||
         rm == TR::java_lang_invoke_MethodHandle_linkToInterface)
          {
-         // invokeBasic and linkTo* are signature-polymorphic, so the VM needs to know the number of argument slots
-         // for the INL call in order to locate the start of the arguments on the stack. The arg slot count is stored
-         // in vmThread.tempSlot.
+         // linkTo* is signature-polymorphic, so the VM needs to know the number of argument slots for the INL call in order to
+         // locate the start of the arguments on the stack. The arg slot count is stored in vmThread.tempSlot.
          //
          // Furthermore, for unresolved invokedynamic and invokehandle bytecodes, we create a dummy TR_ResolvedMethod call to
          // linkToStatic. The appendix object in the invoke cache array entry could be NULL, which we cannot determine at compile
@@ -5289,3 +5293,111 @@ J9::CodeGenerator::stressJitDispatchJ9MethodJ2I()
    static const bool stress = feGetEnv("TR_stressJitDispatchJ9MethodJ2I") != NULL;
    return stress;
    }
+
+#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
+void
+J9::CodeGenerator::addInvokeBasicCallSiteImpl(
+   TR::Node *callNode, TR::Instruction *instr, uint8_t *retAddr)
+   {
+   TR_ASSERT_FATAL_WITH_NODE(
+      callNode,
+      (instr != NULL) != (retAddr != NULL),
+      "expected exactly one of TR::Instruction or return address");
+
+   if (comp()->getOption(TR_TraceCG))
+      {
+      traceMsg(comp(), "Call instruction ");
+      if (instr != NULL)
+         {
+         traceMsg(comp(), "%p", instr);
+         }
+      else
+         {
+         traceMsg(comp(), "with return address %p", retAddr);
+         }
+
+      traceMsg(
+         comp(),
+         " for n%un [%p] may target VM MethodHandle.invokeBasic\n",
+         callNode->getGlobalIndex(),
+         callNode);
+      }
+
+   TR_J9VMBase *fej9 = comp()->fej9();
+   TR::Node *j2iCallNode = callNode;
+   TR::MethodSymbol *methodSymbol = callNode->getSymbol()->castToMethodSymbol();
+   TR::RecognizedMethod rm = methodSymbol->getMandatoryRecognizedMethod();
+   switch (rm)
+      {
+      case TR::java_lang_invoke_MethodHandle_invokeBasic:
+         break; // ok
+
+      case TR::com_ibm_jit_JITHelpers_dispatchVirtual:
+         j2iCallNode =
+            fej9->getEquivalentVirtualCallNodeForDispatchVirtual(callNode, comp());
+         break;
+
+      default:
+         TR_ASSERT_FATAL_WITH_NODE(
+            callNode,
+            false,
+            "expected MethodHandle.invokeBasic or JITHelpers.dispatchVirtual");
+         break;
+      }
+
+   int32_t numChildren = j2iCallNode->getNumChildren();
+   int32_t firstArgIndex = j2iCallNode->getFirstArgumentIndex();
+   uint32_t numArgSlots32 = 0;
+   for (int32_t i = firstArgIndex; i < numChildren; i++)
+      {
+      TR::Node *child = j2iCallNode->getChild(i);
+
+      // PassThrough nodes will appear to have type TR::NoType. The actual type
+      // of the resulting value is the same as the type of the child.
+      while (child->getOpCodeValue() == TR::PassThrough)
+         {
+         child = child->getChild(0);
+         }
+
+      TR::DataTypes dt = child->getDataType().getDataType();
+      numArgSlots32 += 1 + (uint32_t)(dt == TR::Int64 || dt == TR::Double);
+      }
+
+   if (comp()->getOption(TR_TraceCG))
+      {
+      traceMsg(comp(), "  arg slots: %u\n", numArgSlots32);
+      }
+
+   TR_ASSERT_FATAL_WITH_NODE(
+      callNode,
+      numArgSlots32 <= UINT8_MAX,
+      "too many argument slots (%u)",
+      numArgSlots32);
+
+   uint8_t numArgSlots = (uint8_t)numArgSlots32;
+
+   void *j2iThunk = NULL;
+   if (rm == TR::com_ibm_jit_JITHelpers_dispatchVirtual)
+      {
+      TR::Method *m = methodSymbol->getMethod();
+      char *sig = fej9->getJ2IThunkSignatureForDispatchVirtual(
+         m->signatureChars(), m->signatureLength(), comp());
+
+      int32_t sigLen = strlen(sig);
+      j2iThunk = fej9->getJ2IThunk(sig, sigLen, comp());
+      TR_ASSERT_FATAL_WITH_NODE(callNode, j2iThunk != NULL, "missing J2I thunk");
+
+      if (comp()->getOption(TR_TraceCG))
+         {
+         traceMsg(comp(), "  J2I thunk: %p\n", j2iThunk);
+         }
+      }
+
+   InvokeBasicCallSite site = {};
+   site._instr = instr;
+   site._retAddr = retAddr;
+   site._numArgSlots = numArgSlots;
+   site._j2iThunk = j2iThunk;
+   _invokeBasicCallSites.push_back(site);
+   }
+#endif // defined(J9VM_OPT_OPENJDK_METHODHANDLE)

runtime/compiler/codegen/J9CodeGenerator.hpp

@@ -40,6 +40,7 @@ namespace J9 { typedef J9::CodeGenerator CodeGeneratorConnector; }
 #include "env/jittypes.h"
 #include "infra/List.hpp"
 #include "infra/HashTab.hpp"
+#include "infra/TRlist.hpp"
 #include "codegen/RecognizedMethods.hpp"
 #if defined(J9VM_OPT_JITSERVER)
 #include "control/CompilationRuntime.hpp"
@@ -708,8 +709,40 @@ void addMonClass(TR::Node* monNode, TR_OpaqueClassBlock* clazz);
    /// Determine whether to stress the J2I path for \c jitDispatchJ9Method.
    bool stressJitDispatchJ9MethodJ2I();
 
+#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
+   void addInvokeBasicCallSite(TR::Node *callNode, TR::Instruction *instr)
+      {
+      addInvokeBasicCallSiteImpl(callNode, instr, NULL);
+      }
+
+   void addInvokeBasicCallSite(TR::Node *callNode, uint8_t *retAddr)
+      {
+      addInvokeBasicCallSiteImpl(callNode, NULL, retAddr);
+      }
+
+   struct InvokeBasicCallSite
+      {
+      TR::Instruction *_instr; // for call instruction from an evaluator
+      void *_retAddr; // for call instruction from a snippet
+      uint8_t _numArgSlots;
+      void *_j2iThunk; // for JITHelpers.dispatchVirtual()
+      };
+
+   typedef TR::list<InvokeBasicCallSite, TR::Region&> InvokeBasicCallSiteList;
+
+   const InvokeBasicCallSiteList &invokeBasicCallSites()
+      {
+      return _invokeBasicCallSites;
+      }
+#endif
+
 private:
 
+#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
+   void addInvokeBasicCallSiteImpl(
+      TR::Node *callNode, TR::Instruction *instr, uint8_t *retAddr);
+#endif
+
    enum // Flags
       {
       HasFixedFrameC_CallingConvention                    = 0x00000001,
@@ -734,6 +767,10 @@ void addMonClass(TR::Node* monNode, TR_OpaqueClassBlock* clazz);
       };
 
    flags32_t _j9Flags;
+
+#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
+   InvokeBasicCallSiteList _invokeBasicCallSites;
+#endif
    };
 }
 

runtime/compiler/p/codegen/CallSnippet.cpp

@@ -373,6 +373,14 @@ uint8_t *TR::PPCCallSnippet::emitSnippetBody()
 
    cursor += PPC_INSTRUCTION_LENGTH;
 
+#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
+   auto rm = methodSymbol->getMandatoryRecognizedMethod();
+   if (rm == TR::java_lang_invoke_MethodHandle_invokeBasic)
+      {
+      cg()->addInvokeBasicCallSite(callNode, cursor);
+      }
+#endif
+
    if (isNativeStatic)
       {
       // Rather than placing the return address as data after the 'bl', place a 'b' back to main line code

runtime/compiler/p/codegen/PPCPrivateLinkage.cpp

@@ -2320,6 +2320,15 @@ void J9::Power::PrivateLinkage::buildVirtualDispatch(TR::Node
       TR::Instruction *gcPoint = generateInstruction(cg(), TR::InstOpCode::bctrl, callNode);
       generateDepLabelInstruction(cg(), TR::InstOpCode::label, callNode, doneLabel, dependencies);
 
+#if defined(J9VM_OPT_OPENJDK_METHODHANDLE)
+      // JITHelpers.dispatchVirtual() can target MethodHandle.invokeBasic().
+      auto rm = methodSymbol->getMandatoryRecognizedMethod();
+      if (rm == TR::com_ibm_jit_JITHelpers_dispatchVirtual)
+         {
+         cg()->addInvokeBasicCallSite(callNode, gcPoint);
+         }
+#endif
+
       gcPoint->PPCNeedsGCMap(regMapForGC);
       return;
       }