Update hashCodeHelper for off-heap

The acceleration was initially disabled because it added array header
size to the array object, which was required to reach the elements.
However, this is unnecessary for off-heap mode. As a result, the
evaluator has been updated to add the array header size exclusively
for non-off-heap mode, while in off-heap mode, it now retrieves the
data element address directly from the array header, enabling
acceleration in off-heap mode.

Signed-off-by: Shubham Verma <[email protected]>

Author: VermaSh

runtime/compiler/z/codegen/J9CodeGenerator.cpp

@@ -93,8 +93,7 @@ J9::Z::CodeGenerator::initialize()
       cg->setSupportsInlineStringIndexOf();
       }
 
-   if (cg->getSupportsVectorRegisters() && !comp->getOption(TR_DisableSIMDStringHashCode) &&
-       !TR::Compiler->om.canGenerateArraylets() && !TR::Compiler->om.isOffHeapAllocationEnabled())
+   if (cg->getSupportsVectorRegisters() && !comp->getOption(TR_DisableSIMDStringHashCode) && !TR::Compiler->om.canGenerateArraylets())
       {
       cg->setSupportsInlineStringHashCode();
       cg->setSupportsInlineVectorizedHashCode();

runtime/compiler/z/codegen/J9TreeEvaluator.cpp

@@ -2825,10 +2825,34 @@ hashCodeHelper(TR::Node* node, TR::CodeGenerator* cg, TR::DataType elementType,
    TR::LabelSymbol * cFlowRegionEnd    = generateLabelSymbol(cg);
 
    // Create the necessary registers
-   TR::Register* registerValue = cg->evaluate(nodeValue);
+   TR::Register* registerValue = NULL;
    TR::Register* registerIndex = cg->gprClobberEvaluate(nodeIndex);
    TR::Register* registerCount = cg->gprClobberEvaluate(nodeCount);
 
+   // Offset to be added to array object pointer to get to the data elements
+   int32_t offsetToDataElements = static_cast<int32_t>(TR::Compiler->om.contiguousArrayHeaderSizeInBytes());
+#ifdef J9VM_GC_SPARSE_HEAP_ALLOCATION
+   if (TR::Compiler->om.isOffHeapAllocationEnabled())
+      {
+      // Clobber evaluate value node as we'll overwrite it with first data element address
+      registerValue = cg->gprClobberEvaluate(nodeValue);
+
+      // Load first data element address
+      generateRXInstruction(cg,
+         TR::InstOpCode::getLoadOpCode(),
+         nodeValue,
+         registerValue,
+         generateS390MemoryReference(registerValue, cg->comp()->fej9()->getOffsetOfContiguousDataAddrField(), cg));
+
+      // Since the first data element address is retrieved from the array header, the offset is set to 0
+      offsetToDataElements = 0;
+      }
+   else
+#endif /* J9VM_GC_SPARSE_HEAP_ALLOCATION */
+      {
+      registerValue = cg->evaluate(nodeValue);
+      }
+
    if (cg->comp()->target().is64Bit())
       {
       generateRRInstruction(cg, TR::InstOpCode::getLoadRegWidenOpCode(), node, registerIndex, registerIndex);
@@ -2911,20 +2935,20 @@ hashCodeHelper(TR::Node* node, TR::CodeGenerator* cg, TR::DataType elementType,
       {
       case TR::Int8:
          // registerVC = 4 consecutive (8 bit) bytes at the current index
-         generateVRXInstruction(cg, TR::InstOpCode::VLLEZ, node, registerVC, generateS390MemoryReference(registerValue, registerIndex, TR::Compiler->om.contiguousArrayHeaderSizeInBytes(), cg), 2);
+         generateVRXInstruction(cg, TR::InstOpCode::VLLEZ, node, registerVC, generateS390MemoryReference(registerValue, registerIndex, offsetToDataElements, cg), 2);
          // registerVC = unpack 4 (8 bit) byte elements into 4 (32 bit) int elements
          generateVRRaInstruction(cg, isSigned ? TR::InstOpCode::VUPH : TR::InstOpCode::VUPLH, node, registerVC, registerVC, 0, 0, 0);
          generateVRRaInstruction(cg, isSigned ? TR::InstOpCode::VUPL : TR::InstOpCode::VUPLL, node, registerVC, registerVC, 0, 0, 1);
          break;
       case TR::Int16:
          // registerVC = 4 consecutive (16 bit) shorts at the current index
-         generateVRXInstruction(cg, TR::InstOpCode::VLLEZ, node, registerVC, generateS390MemoryReference(registerValue, registerIndex, TR::Compiler->om.contiguousArrayHeaderSizeInBytes(), cg), 3);
+         generateVRXInstruction(cg, TR::InstOpCode::VLLEZ, node, registerVC, generateS390MemoryReference(registerValue, registerIndex, offsetToDataElements, cg), 3);
          // registerVC = unpack 4 (16 bit) short elements into 4 (32 bit) int elements
          generateVRRaInstruction(cg, isSigned ? TR::InstOpCode::VUPH : TR::InstOpCode::VUPLH, node, registerVC, registerVC, 0, 0, 1);
          break;
       case TR::Int32:
          // registerVC = 4 consecutive (32 bit) ints at the current index
-         generateVRXInstruction(cg, TR::InstOpCode::VL, node, registerVC, generateS390MemoryReference(registerValue, registerIndex, TR::Compiler->om.contiguousArrayHeaderSizeInBytes(), cg));
+         generateVRXInstruction(cg, TR::InstOpCode::VL, node, registerVC, generateS390MemoryReference(registerValue, registerIndex, offsetToDataElements, cg));
          break;
       default:
          TR_ASSERT_FATAL(false, "Unsupported vectorizedHashCode element type");
@@ -2990,15 +3014,15 @@ hashCodeHelper(TR::Node* node, TR::CodeGenerator* cg, TR::DataType elementType,
       {
       case TR::Int8:
          // registerHash = byte at registerIndex
-         generateRXInstruction(cg, isSigned ? TR::InstOpCode::LB : TR::InstOpCode::LLC, node, registerHash, generateS390MemoryReference(registerValue, registerIndex, TR::Compiler->om.contiguousArrayHeaderSizeInBytes(), cg));
+         generateRXInstruction(cg, isSigned ? TR::InstOpCode::LB : TR::InstOpCode::LLC, node, registerHash, generateS390MemoryReference(registerValue, registerIndex, offsetToDataElements, cg));
          break;
       case TR::Int16:
          // registerHash = short at registerIndex
-         generateRXInstruction(cg, isSigned ? TR::InstOpCode::LH : TR::InstOpCode::LLH, node, registerHash, generateS390MemoryReference(registerValue, registerIndex, TR::Compiler->om.contiguousArrayHeaderSizeInBytes(), cg));
+         generateRXInstruction(cg, isSigned ? TR::InstOpCode::LH : TR::InstOpCode::LLH, node, registerHash, generateS390MemoryReference(registerValue, registerIndex, offsetToDataElements, cg));
          break;
       case TR::Int32:
          // registerHash = int at registerIndex
-         generateRXInstruction(cg, TR::InstOpCode::L, node, registerHash, generateS390MemoryReference(registerValue, registerIndex, TR::Compiler->om.contiguousArrayHeaderSizeInBytes(), cg));
+         generateRXInstruction(cg, TR::InstOpCode::L, node, registerHash, generateS390MemoryReference(registerValue, registerIndex, offsetToDataElements, cg));
          break;
       default:
          TR_ASSERT_FATAL(false, "Unsupported vectorizedHashCode element type");