Merge pull request #8477 from fjeremic/document-private-linkage-doubl…

…e-slot

Common getOffsetToFirstParm and mapIncomingParms in the linkage class across codegens

runtime/compiler/aarch64/codegen/ARM64PrivateLinkage.cpp

@@ -209,7 +209,7 @@ J9::ARM64::PrivateLinkage::PrivateLinkage(TR::CodeGenerator *cg)
 
    // Volatile GPR (0-15, 18) + FPR (0-31) + VFT Reg
    _properties._numberOfDependencyGPRegisters = 17 + 32 + 1;
-   _properties._offsetToFirstParm             = 0;
+   setOffsetToFirstParm(0);
    _properties._offsetToFirstLocal            = -8;
    }
 
@@ -331,7 +331,7 @@ void J9::ARM64::PrivateLinkage::mapStack(TR::ResolvedMethodSymbol *method)
    ListIterator<TR::ParameterSymbol> parameterIterator(&method->getParameterList());
    TR::ParameterSymbol *parmCursor = parameterIterator.getFirst();
 
-   int32_t offsetToFirstParm = linkageProperties.getOffsetToFirstParm();
+   int32_t offsetToFirstParm = getOffsetToFirstParm();
    uint32_t sizeOfParameterArea = method->getNumParameterSlots() * TR::Compiler->om.sizeofReferenceAddress();
 
    while (parmCursor != NULL)
@@ -532,7 +532,7 @@ void J9::ARM64::PrivateLinkage::createPrologue(TR::Instruction *cursor)
    // The offset to the first parm is the offset between the entry JavaSP and the first
    // mapped parameter.  It is a positive (or zero) offset.
    //
-   int32_t outgoingArgsSize = cg()->getLargestOutgoingArgSize() + properties.getOffsetToFirstParm();
+   int32_t outgoingArgsSize = cg()->getLargestOutgoingArgSize() + getOffsetToFirstParm();
 
    int32_t frameSizeIncludingReturnAddress = preservedRegisterSaveSize + localsSize + outgoingArgsSize;
 
@@ -772,7 +772,7 @@ void J9::ARM64::PrivateLinkage::createEpilogue(TR::Instruction *cursor)
    TR::RealRegister *javaSP = machine->getRealRegister(properties.getStackPointerRegister()); // x20
 
    // restore preserved GPRs
-   int32_t preservedRegisterOffsetFromJavaSP = cg()->getLargestOutgoingArgSize() + properties.getOffsetToFirstParm(); // outgoingArgsSize
+   int32_t preservedRegisterOffsetFromJavaSP = cg()->getLargestOutgoingArgSize() + getOffsetToFirstParm(); // outgoingArgsSize
    TR::RealRegister::RegNum firstPreservedGPR = TR::RealRegister::x21;
    TR::RealRegister::RegNum lastPreservedGPR = TR::RealRegister::x28;
    for (TR::RealRegister::RegNum r = firstPreservedGPR; r <= lastPreservedGPR; r = (TR::RealRegister::RegNum)((uint32_t)r+1))

runtime/compiler/aarch64/codegen/CallSnippet.cpp

@@ -58,13 +58,14 @@ static uint8_t *flushArgumentsToStack(uint8_t *buffer, TR::Node *callNode, int32
    {
    uint32_t intArgNum=0, floatArgNum=0, offset;
    TR::Machine *machine = cg->machine();
-   const TR::ARM64LinkageProperties &linkage = cg->getLinkage(callNode->getSymbol()->castToMethodSymbol()->getLinkageConvention())->getProperties();
+   TR::Linkage* linkage = cg->getLinkage(callNode->getSymbol()->castToMethodSymbol()->getLinkageConvention());
+   const TR::ARM64LinkageProperties &linkageProperties = linkage->getProperties();
    int32_t argStart = callNode->getFirstArgumentIndex();
 
-   if (linkage.getRightToLeft())
-      offset = linkage.getOffsetToFirstParm();
+   if (linkageProperties.getRightToLeft())
+      offset = linkage->getOffsetToFirstParm();
    else
-      offset = argSize+linkage.getOffsetToFirstParm();
+      offset = argSize+linkage->getOffsetToFirstParm();
 
    for (int32_t i=argStart; i<callNode->getNumChildren();i++)
       {
@@ -74,58 +75,58 @@ static uint8_t *flushArgumentsToStack(uint8_t *buffer, TR::Node *callNode, int32
          case TR::Int8:
          case TR::Int16:
          case TR::Int32:
-            if (!linkage.getRightToLeft())
+            if (!linkageProperties.getRightToLeft())
                offset -= TR::Compiler->om.sizeofReferenceAddress();
-            if (intArgNum < linkage.getNumIntArgRegs())
+            if (intArgNum < linkageProperties.getNumIntArgRegs())
                {
-               buffer = storeArgumentItem(TR::InstOpCode::strimmw, buffer, machine->getRealRegister(linkage.getIntegerArgumentRegister(intArgNum)), offset, cg);
+               buffer = storeArgumentItem(TR::InstOpCode::strimmw, buffer, machine->getRealRegister(linkageProperties.getIntegerArgumentRegister(intArgNum)), offset, cg);
                }
             intArgNum++;
-            if (linkage.getRightToLeft())
+            if (linkageProperties.getRightToLeft())
                offset += TR::Compiler->om.sizeofReferenceAddress();
             break;
          case TR::Address:
-            if (!linkage.getRightToLeft())
+            if (!linkageProperties.getRightToLeft())
                offset -= TR::Compiler->om.sizeofReferenceAddress();
-            if (intArgNum < linkage.getNumIntArgRegs())
+            if (intArgNum < linkageProperties.getNumIntArgRegs())
                {
-               buffer = storeArgumentItem(TR::InstOpCode::strimmx, buffer, machine->getRealRegister(linkage.getIntegerArgumentRegister(intArgNum)), offset, cg);
+               buffer = storeArgumentItem(TR::InstOpCode::strimmx, buffer, machine->getRealRegister(linkageProperties.getIntegerArgumentRegister(intArgNum)), offset, cg);
                }
             intArgNum++;
-            if (linkage.getRightToLeft())
+            if (linkageProperties.getRightToLeft())
                offset += TR::Compiler->om.sizeofReferenceAddress();
             break;
          case TR::Int64:
-            if (!linkage.getRightToLeft())
+            if (!linkageProperties.getRightToLeft())
                offset -= 2*TR::Compiler->om.sizeofReferenceAddress();
-            if (intArgNum < linkage.getNumIntArgRegs())
+            if (intArgNum < linkageProperties.getNumIntArgRegs())
                {
-               buffer = storeArgumentItem(TR::InstOpCode::strimmx, buffer, machine->getRealRegister(linkage.getIntegerArgumentRegister(intArgNum)), offset, cg);
+               buffer = storeArgumentItem(TR::InstOpCode::strimmx, buffer, machine->getRealRegister(linkageProperties.getIntegerArgumentRegister(intArgNum)), offset, cg);
                }
             intArgNum++;
-            if (linkage.getRightToLeft())
+            if (linkageProperties.getRightToLeft())
                offset += 2*TR::Compiler->om.sizeofReferenceAddress();
             break;
          case TR::Float:
-            if (!linkage.getRightToLeft())
+            if (!linkageProperties.getRightToLeft())
                offset -= TR::Compiler->om.sizeofReferenceAddress();
-            if (floatArgNum < linkage.getNumFloatArgRegs())
+            if (floatArgNum < linkageProperties.getNumFloatArgRegs())
                {
-               buffer = storeArgumentItem(TR::InstOpCode::vstrimms, buffer, machine->getRealRegister(linkage.getFloatArgumentRegister(floatArgNum)), offset, cg);
+               buffer = storeArgumentItem(TR::InstOpCode::vstrimms, buffer, machine->getRealRegister(linkageProperties.getFloatArgumentRegister(floatArgNum)), offset, cg);
                }
             floatArgNum++;
-            if (linkage.getRightToLeft())
+            if (linkageProperties.getRightToLeft())
                offset += TR::Compiler->om.sizeofReferenceAddress();
             break;
          case TR::Double:
-            if (!linkage.getRightToLeft())
+            if (!linkageProperties.getRightToLeft())
                offset -= 2*TR::Compiler->om.sizeofReferenceAddress();
-            if (floatArgNum < linkage.getNumFloatArgRegs())
+            if (floatArgNum < linkageProperties.getNumFloatArgRegs())
                {
-               buffer = storeArgumentItem(TR::InstOpCode::vstrimmd, buffer, machine->getRealRegister(linkage.getFloatArgumentRegister(floatArgNum)), offset, cg);
+               buffer = storeArgumentItem(TR::InstOpCode::vstrimmd, buffer, machine->getRealRegister(linkageProperties.getFloatArgumentRegister(floatArgNum)), offset, cg);
                }
             floatArgNum++;
-            if (linkage.getRightToLeft())
+            if (linkageProperties.getRightToLeft())
                offset += 2*TR::Compiler->om.sizeofReferenceAddress();
             break;
          }

runtime/compiler/arm/codegen/ARMJNILinkage.cpp

@@ -166,7 +166,7 @@ TR::MemoryReference *J9::ARM::JNILinkage::getOutgoingArgumentMemRef(int32_t
 printf("JNI: offset %d\n", offset); fflush(stdout);
 #endif
    const TR::ARMLinkageProperties &jniLinkageProperties = getProperties();
-   int32_t                spOffset = offset + jniLinkageProperties.getOffsetToFirstParm();
+   int32_t                spOffset = offset + getOffsetToFirstParm();
    TR::RealRegister    *sp       = cg()->machine()->getRealRegister(jniLinkageProperties.getStackPointerRegister());
    TR::MemoryReference *result   = new (trHeapMemory()) TR::MemoryReference(sp, spOffset, cg());
    memArg.argRegister = argReg;

runtime/compiler/arm/codegen/ARMPrivateLinkage.cpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2019 IBM Corp. and others
+ * Copyright (c) 2000, 2020 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
@@ -147,7 +147,6 @@ TR::ARMLinkageProperties J9::ARM::PrivateLinkage::properties =
        TR::RealRegister::gr11, // vtable index register
        TR::RealRegister::gr0,  // j9method argument register
        15,                       // numberOfDependencyRegisters
-       0,                        // offsetToFirstStackParm
        -4,                       // offsetToFirstLocal
        4,                        // numIntegerArgumentRegisters
        0,                        // firstIntegerArgumentRegister
@@ -161,6 +160,12 @@ TR::ARMLinkageProperties J9::ARM::PrivateLinkage::properties =
        0                         // firstFloatReturnRegister
    };
 
+J9::ARM::PrivateLinkage::PrivateLinkage(TR::CodeGenerator *cg)
+   : J9::PrivateLinkage(cg)
+   {
+   setOffsetToFirstParm(0);
+   }
+
 TR::ARMLinkageProperties& J9::ARM::PrivateLinkage::getProperties()
    {
    return properties;
@@ -284,7 +289,7 @@ void J9::ARM::PrivateLinkage::mapStack(TR::ResolvedMethodSymbol *method)
 
    ListIterator<TR::ParameterSymbol> parameterIterator(&method->getParameterList());
    TR::ParameterSymbol              *parmCursor = parameterIterator.getFirst();
-   int32_t                          offsetToFirstParm = linkage.getOffsetToFirstParm();
+   int32_t                          offsetToFirstParm = getOffsetToFirstParm();
    if (linkage.getRightToLeft())
       {
       while (parmCursor != NULL)
@@ -444,7 +449,7 @@ void J9::ARM::PrivateLinkage::createPrologue(TR::Instruction *cursor)
 
    int32_t registerSaveSize = intRegistersSaved * 4 + fpRegistersSaved * 8;
 
-   int32_t outgoingArgSize  = properties.getOffsetToFirstParm() + codeGen->getLargestOutgoingArgSize();
+   int32_t outgoingArgSize  = getOffsetToFirstParm() + codeGen->getLargestOutgoingArgSize();
    int32_t totalFrameSize   = localSize + registerSaveSize + outgoingArgSize;
 
    // Align frame to 8-byte boundaries.
@@ -740,7 +745,7 @@ void J9::ARM::PrivateLinkage::createEpilogue(TR::Instruction *cursor)
 
    int32_t registerSaveSize  = intRegistersSaved * 4 + fpRegistersSaved * 8;
 
-   int32_t outgoingArgSize   = properties.getOffsetToFirstParm() + codeGen->getLargestOutgoingArgSize();
+   int32_t outgoingArgSize   = getOffsetToFirstParm() + codeGen->getLargestOutgoingArgSize();
    int32_t totalFrameSize    = localSize + registerSaveSize + outgoingArgSize;
 
    if (debug("alignStackFrame"))

runtime/compiler/arm/codegen/ARMPrivateLinkage.hpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2019 IBM Corp. and others
+ * Copyright (c) 2000, 2020 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
@@ -42,7 +42,7 @@ class PrivateLinkage : public J9::PrivateLinkage
 
    public:
 
-   PrivateLinkage(TR::CodeGenerator *cg) : J9::PrivateLinkage(cg) {}
+   PrivateLinkage(TR::CodeGenerator *cg);
 
    virtual uint32_t getRightToLeft();
    virtual void mapStack(TR::ResolvedMethodSymbol *method);

runtime/compiler/arm/codegen/CallSnippet.cpp

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2000, 2019 IBM Corp. and others
+ * Copyright (c) 2000, 2020 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
@@ -39,13 +39,14 @@ static uint8_t *flushArgumentsToStack(uint8_t *buffer, TR::Node *callNode, int32
    {
    uint32_t        intArgNum=0, floatArgNum=0, offset;
    TR::Machine *machine = cg->machine();
-   const TR::ARMLinkageProperties &linkage = cg->getLinkage(callNode->getSymbol()->castToMethodSymbol()->getLinkageConvention())->getProperties();
+   TR::Linkage* linkage = cg->getLinkage(callNode->getSymbol()->castToMethodSymbol()->getLinkageConvention());
+   const TR::ARMLinkageProperties &linkageProperties = linkage->getProperties();
    int32_t argStart = callNode->getFirstArgumentIndex();
 
-   if (linkage.getRightToLeft())
-      offset = linkage.getOffsetToFirstParm();
+   if (linkageProperties.getRightToLeft())
+      offset = linkage->getOffsetToFirstParm();
    else
-      offset = argSize+linkage.getOffsetToFirstParm();
+      offset = argSize+linkage->getOffsetToFirstParm();
 
    for (int i=argStart; i<callNode->getNumChildren();i++)
       {
@@ -59,58 +60,58 @@ static uint8_t *flushArgumentsToStack(uint8_t *buffer, TR::Node *callNode, int32
 #if (defined(__VFP_FP__) && !defined(__SOFTFP__))
          case TR::Float:
 #endif
-            if (!linkage.getRightToLeft())
+            if (!linkageProperties.getRightToLeft())
                offset -= 4;
-            if (intArgNum < linkage.getNumIntArgRegs())
+            if (intArgNum < linkageProperties.getNumIntArgRegs())
                {
-               buffer = storeArgumentItem(ARMOp_str, buffer, machine->getRealRegister(linkage.getIntegerArgumentRegister(intArgNum)), offset, cg);
+               buffer = storeArgumentItem(ARMOp_str, buffer, machine->getRealRegister(linkageProperties.getIntegerArgumentRegister(intArgNum)), offset, cg);
                }
             intArgNum++;
-            if (linkage.getRightToLeft())
+            if (linkageProperties.getRightToLeft())
                offset += 4;
             break;
          case TR::Int64:
 #if (defined(__VFP_FP__) && !defined(__SOFTFP__))
          case TR::Double:
 #endif
-            if (!linkage.getRightToLeft())
+            if (!linkageProperties.getRightToLeft())
                offset -= 8;
-            if (intArgNum < linkage.getNumIntArgRegs())
+            if (intArgNum < linkageProperties.getNumIntArgRegs())
                {
-               buffer = storeArgumentItem(ARMOp_str, buffer, machine->getRealRegister(linkage.getIntegerArgumentRegister(intArgNum)), offset, cg);
-               if (intArgNum < linkage.getNumIntArgRegs()-1)
+               buffer = storeArgumentItem(ARMOp_str, buffer, machine->getRealRegister(linkageProperties.getIntegerArgumentRegister(intArgNum)), offset, cg);
+               if (intArgNum < linkageProperties.getNumIntArgRegs()-1)
            	  {
-           	  buffer = storeArgumentItem(ARMOp_str, buffer, machine->getRealRegister(linkage.getIntegerArgumentRegister(intArgNum+1)), offset+4, cg);
+           	  buffer = storeArgumentItem(ARMOp_str, buffer, machine->getRealRegister(linkageProperties.getIntegerArgumentRegister(intArgNum+1)), offset+4, cg);
            	  }
                }
             intArgNum += 2;
-            if (linkage.getRightToLeft())
+            if (linkageProperties.getRightToLeft())
                offset += 8;
             break;
 #if !defined(__VFP_FP__) || defined(__SOFTFP__)
          case TR::Float:
             /* TODO
-               if (!linkage.getRightToLeft())
+               if (!linkageProperties.getRightToLeft())
                offset -= 4;
-               if (floatArgNum < linkage.getNumFloatArgRegs())
+               if (floatArgNum < linkageProperties.getNumFloatArgRegs())
                {
-               buffer = storeArgumentItem(ARMOp_stfs, buffer, machine->getRealRegister(linkage.getFloatArgumentRegister(floatArgNum)), offset, cg);
+               buffer = storeArgumentItem(ARMOp_stfs, buffer, machine->getRealRegister(linkageProperties.getFloatArgumentRegister(floatArgNum)), offset, cg);
                }
                floatArgNum++;
-               if (linkage.getRightToLeft())
+               if (linkageProperties.getRightToLeft())
                offset += 4;
             */
             break;
          case TR::Double:
             /* TODO
-               if (!linkage.getRightToLeft())
+               if (!linkageProperties.getRightToLeft())
                offset -= 8;
-               if (floatArgNum < linkage.getNumFloatArgRegs())
+               if (floatArgNum < linkageProperties.getNumFloatArgRegs())
                {
-               buffer = storeArgumentItem(ARMOp_stfd, buffer, machine->getRealRegister(linkage.getFloatArgumentRegister(floatArgNum)), offset, cg);
+               buffer = storeArgumentItem(ARMOp_stfd, buffer, machine->getRealRegister(linkageProperties.getFloatArgumentRegister(floatArgNum)), offset, cg);
                }
                floatArgNum++;
-               if (linkage.getRightToLeft())
+               if (linkageProperties.getRightToLeft())
                offset += 8;
             */
             break;

runtime/compiler/codegen/CMakeLists.txt

@@ -35,4 +35,6 @@ j9jit_files(
 	codegen/J9TreeEvaluator.cpp
 	codegen/J9WatchedInstanceFieldSnippet.cpp
 	codegen/J9WatchedStaticFieldSnippet.cpp
+	codegen/MonitorState.cpp
+	codegen/PrivateLinkage.cpp
 )

runtime/compiler/codegen/PrivateLinkage.cpp

@@ -20,10 +20,14 @@
  * SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
  *******************************************************************************/
 
+#include "codegen/PrivateLinkage.hpp"
+
 #include "codegen/CodeGenerator.hpp"
 #include "codegen/Linkage_inlines.hpp"
-#include "codegen/PrivateLinkage.hpp"
+#include "compile/ResolvedMethod.hpp"
+#include "env/CompilerEnv.hpp"
 #include "env/jittypes.h"
+#include "il/ParameterSymbol.hpp"
 
 intptr_t
 J9::PrivateLinkage::entryPointFromCompiledMethod()
@@ -38,3 +42,24 @@ J9::PrivateLinkage::entryPointFromInterpretedMethod()
    {
    return reinterpret_cast<intptr_t>(cg()->getCodeStart());
    }
+
+void
+J9::PrivateLinkage::mapIncomingParms(TR::ResolvedMethodSymbol *method)
+   {
+   int32_t offsetToFirstArg = method->getNumParameterSlots() * TR::Compiler->om.sizeofReferenceAddress() + getOffsetToFirstParm();
+
+   const bool is64Bit = cg()->comp()->target().is64Bit();
+   ListIterator<TR::ParameterSymbol> paramIterator(&method->getParameterList());
+   for (TR::ParameterSymbol* paramCursor = paramIterator.getFirst(); paramCursor != NULL; paramCursor = paramIterator.getNext())
+      {
+      // This is a slightly convoluted way of enforcing the JVM specification which states that long and double 
+      // variables take up two stack slots. A stack slot in OpenJ9 is a `uintptr_t`, so on 64-bit int variables
+      // are still placed in 64-bit stack slots, hence the need to check for 64-bit in the query below. For more
+      // details please see eclipse/openj9#8360.
+      int32_t slotMultiplier = is64Bit && paramCursor->getDataType() != TR::Address ? 2 : 1;
+
+      paramCursor->setParameterOffset(offsetToFirstArg -
+         paramCursor->getParameterOffset() -
+         paramCursor->getSize() * slotMultiplier);
+      }
+   }

runtime/compiler/codegen/PrivateLinkage.hpp

@@ -130,6 +130,7 @@ class PrivateLinkage : public TR::Linkage
     */
    virtual intptr_t entryPointFromInterpretedMethod();
 
+   virtual void mapIncomingParms(TR::ResolvedMethodSymbol *method);
    };
 
 }