Merge pull request #20855 from matthewhall2/assignableFrom_genSuperclassTest

Generate inline superclass test for Class.isAssignableFrom on Z

Author: r30shah

runtime/compiler/z/codegen/J9TreeEvaluator.cpp

@@ -3378,7 +3378,7 @@ static void genTestModifierFlags(TR::CodeGenerator *cg, TR::Node *node, TR::Regi
    TR::Instruction *cursor = NULL;
    TR_Debug * debugObj = cg->getDebug();
 
-   if (!j9classModifierFlagsReg)
+   if (NULL == j9classModifierFlagsReg)
       {
       generateRXInstruction(cg, TR::InstOpCode::getLoadOpCode(), node, scratchReg,
                               generateS390MemoryReference(classReg, offsetof(J9Class, romClass), cg));
@@ -3394,7 +3394,7 @@ static void genTestModifierFlags(TR::CodeGenerator *cg, TR::Node *node, TR::Regi
 
    // when user passes in modiferFlags register, it is going to be reused later
    // so we use an RRF instruction to avoid the flags being overwritten by the AND
-   if (j9classModifierFlagsReg)
+   if (NULL != j9classModifierFlagsReg)
       {
       TR::Register *flagsReg = srm->findOrCreateScratchRegister();
       generateRILInstruction(cg, TR::InstOpCode::IILF, node, flagsReg, flags);
@@ -3407,7 +3407,7 @@ static void genTestModifierFlags(TR::CodeGenerator *cg, TR::Node *node, TR::Regi
       }
 
    cursor = generateS390BranchInstruction(cg, TR::InstOpCode::BRC, TR::InstOpCode::COND_BNE, node, handleFlagsLabel);
-   if (!j9classModifierFlagsReg)
+   if (NULL == j9classModifierFlagsReg)
       srm->reclaimScratchRegister(scratchReg);
    }
 
@@ -3484,23 +3484,28 @@ static void genSuperclassTest(TR::CodeGenerator *cg, TR::Node *node, TR::Registe
       {
       if (comp->target().is64Bit())
          {
-         generateRSInstruction(cg, TR::InstOpCode::SLLG, node, toClassDepthReg, toClassDepthReg, 3);
+         cursor = generateRSInstruction(cg, TR::InstOpCode::SLLG, node, toClassDepthReg, toClassDepthReg, 3);
          }
       else
          {
-         generateRSInstruction(cg, TR::InstOpCode::SLL, node, toClassDepthReg, 2);
+         cursor = generateRSInstruction(cg, TR::InstOpCode::SLL, node, toClassDepthReg, 2);
          }
 
-      generateRXInstruction(cg, TR::InstOpCode::getCmpOpCode(), node, toClassReg,
+      if (debugObj)
+         debugObj->addInstructionComment(cursor, "convert toClasDepth to superclass array offset");
+
+      cursor = generateRXInstruction(cg, TR::InstOpCode::getCmpOpCode(), node, toClassReg,
                               generateS390MemoryReference(superclassArrayReg, toClassDepthReg, 0, cg));
       srm->reclaimScratchRegister(toClassDepthReg);
       }
    else
       {
       int32_t superClassOffset = toClassDepth * TR::Compiler->om.sizeofReferenceAddress();
-      generateRXInstruction(cg, TR::InstOpCode::getCmpOpCode(), node, toClassReg,
+      cursor = generateRXInstruction(cg, TR::InstOpCode::getCmpOpCode(), node, toClassReg,
                               generateS390MemoryReference(superclassArrayReg, superClassOffset, cg));
       }
+   if (debugObj)
+      debugObj->addInstructionComment(cursor, "check superclass array");
    srm->reclaimScratchRegister(superclassArrayReg);
    }
 
@@ -11667,8 +11672,6 @@ J9::Z::TreeEvaluator::VMarrayCheckEvaluator(TR::Node *node, TR::CodeGenerator *c
    return 0;
    }
 
-/////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////
 static bool inlineIsAssignableFrom(TR::Node *node, TR::CodeGenerator *cg)
    {
    static char *disable = feGetEnv("TR_disableInlineIsAssignableFrom");
@@ -11809,53 +11812,172 @@ static bool inlineIsAssignableFrom(TR::Node *node, TR::CodeGenerator *cg)
    return true;
    }
 
+static TR::SymbolReference *getClassSymRefAndDepth(TR::Node *classNode, TR::Compilation *comp, int32_t &classDepth)
+   {
+   classDepth = -1;
+   TR::SymbolReference *classSymRef = NULL;
+   const TR::ILOpCodes opcode = classNode->getOpCodeValue();
+   bool isClassNodeLoadAddr = opcode == TR::loadaddr;
+
+   // getting the symbol ref
+   if (isClassNodeLoadAddr)
+      {
+      classSymRef = classNode->getSymbolReference();
+      }
+   else if (opcode == TR::aloadi)
+      {
+      // recognizedCallTransformer adds another layer of aloadi
+      while (classNode->getOpCodeValue() == TR::aloadi && classNode->getFirstChild()->getOpCodeValue() == TR::aloadi)
+         {
+         classNode = classNode->getFirstChild();
+         }
+
+      if (classNode->getOpCodeValue() == TR::aloadi && classNode->getFirstChild()->getOpCodeValue() == TR::loadaddr)
+         {
+         classSymRef = classNode->getFirstChild()->getSymbolReference();
+         }
+      }
+
+   // the class node being <loadaddr> is an edge case - likely will not happen since we shouldn't see
+   // Class.isAssignableFrom on classes known at compile (javac) time, but still possible.
+   if (!isClassNodeLoadAddr && (classNode->getOpCodeValue() != TR::aloadi ||
+        classNode->getSymbolReference() != comp->getSymRefTab()->findJavaLangClassFromClassSymbolRef() ||
+        classNode->getFirstChild()->getOpCodeValue() != TR::loadaddr))
+      {
+      return classSymRef; // cannot find class depth
+      }
+
+   TR::Node *classRef = isClassNodeLoadAddr ? classNode : classNode->getFirstChild();
+   TR::SymbolReference *symRef = classRef->getOpCode().hasSymbolReference() ? classRef->getSymbolReference() : NULL;
+
+   if (symRef != NULL && !symRef->isUnresolved())
+      {
+      TR::StaticSymbol *classSym = symRef->getSymbol()->getStaticSymbol();
+      TR_OpaqueClassBlock *clazz = (classSym != NULL) ? (TR_OpaqueClassBlock *) classSym->getStaticAddress() : NULL;
+      if (clazz != NULL)
+         classDepth = static_cast<int32_t>(TR::Compiler->cls.classDepthOf(clazz));
+      }
+
+   return classSymRef;
+   }
+
 TR::Register *J9::Z::TreeEvaluator::inlineCheckAssignableFromEvaluator(TR::Node *node, TR::CodeGenerator *cg)
    {
-   TR::Register *fromClassReg = cg->evaluate(node->getFirstChild());
-   TR::Register *toClassReg = cg->evaluate(node->getSecondChild());
+   TR::Compilation *comp = cg->comp();
+   // recognizedCallTransformer swaps the args - caller class obj is the second argument after the transformation
+   TR::Node *fromClass = node->getFirstChild();
+   TR::Node *toClass = node->getSecondChild();
+   TR::Register *fromClassReg = cg->evaluate(fromClass);
+   TR::Register *toClassReg = cg->evaluate(toClass);
 
-   TR::Register *resultReg = cg->allocateRegister();
    TR::LabelSymbol *helperCallLabel = generateLabelSymbol(cg);
    TR::LabelSymbol *doneLabel = generateLabelSymbol(cg);
-   TR::LabelSymbol *successLabel = generateLabelSymbol(cg);
-
+   TR::LabelSymbol *failLabel = generateLabelSymbol(cg);
+   TR::LabelSymbol *successLabel = doneLabel;
    TR::LabelSymbol* cFlowRegionStart = generateLabelSymbol(cg);
-   generateS390LabelInstruction(cg, TR::InstOpCode::label, node, cFlowRegionStart);
-   cFlowRegionStart->setStartInternalControlFlow();
 
-   /*
-    * check for class equality
-    * if equal, we are done. If not, fall through to helper call
-    */
-   generateS390CompareAndBranchInstruction(cg, TR::InstOpCode::getCmpRegOpCode(), node, toClassReg, fromClassReg, TR::InstOpCode::COND_BE, successLabel, false, false);
-
-   /*
-    * TODO: add inlined tests (SuperclassTest, cast class cache, etc)
-    * Inlined tests will be used when possible, or will jump to the OOL section
-    * and perform the tests using the CHelper when not possible
-    */
+   TR_S390ScratchRegisterManager *srm = cg->generateScratchRegisterManager(2);
 
-   generateS390BranchInstruction(cg, TR::InstOpCode::BRC, TR::InstOpCode::COND_BRC, node, helperCallLabel);
+   // create OOL section here to have access to the result register to load initial result
    TR_S390OutOfLineCodeSection *outlinedSlowPath = new (cg->trHeapMemory()) TR_S390OutOfLineCodeSection(helperCallLabel, doneLabel, cg);
    cg->getS390OutOfLineCodeSectionList().push_front(outlinedSlowPath);
    outlinedSlowPath->swapInstructionListsWithCompilation();
-
    generateS390LabelInstruction(cg, TR::InstOpCode::label, node, helperCallLabel);
-   resultReg = TR::TreeEvaluator::performCall(node, false, cg);
-
+   TR::Register *resultReg = TR::TreeEvaluator::performCall(node, false, cg);
    generateS390BranchInstruction(cg, TR::InstOpCode::BRC, TR::InstOpCode::COND_BRC, node, doneLabel); // exit OOL section
    outlinedSlowPath->swapInstructionListsWithCompilation();
 
-   generateS390LabelInstruction(cg, TR::InstOpCode::label, node, successLabel);
-   generateRIInstruction(cg, TR::InstOpCode::getLoadHalfWordImmOpCode(), node, resultReg, 1);
+   // load with initial result of true
+   generateRIInstruction(cg, TR::InstOpCode::LHI, node, resultReg, 1);
+   generateS390LabelInstruction(cg, TR::InstOpCode::label, node, cFlowRegionStart);
+   cFlowRegionStart->setStartInternalControlFlow();
+   TR_Debug * debugObj = cg->getDebug();
+   TR::Instruction *cursor = NULL;
+
+   if (comp->getOption(TR_TraceCG))
+      traceMsg(comp,"%s: Emitting Class Equality Test\n",node->getOpCode().getName());
+   // for isAssignableFrom we can always generate the class equality test since both arguments are classes
+   cg->generateDebugCounter(TR::DebugCounter::debugCounterName(comp, "isAssignableFromStats/(%s)/ClassEqualityTest", comp->signature()), 1, TR::DebugCounter::Undetermined);
+   cursor = generateS390CompareAndBranchInstruction(cg, TR::InstOpCode::getCmpRegOpCode(), node, toClassReg, fromClassReg, TR::InstOpCode::COND_BE, successLabel, false, false);
+   if (debugObj)
+      debugObj->addInstructionComment(cursor, "class equality test");
+   cg->generateDebugCounter(TR::DebugCounter::debugCounterName(comp, "isAssignableFromStats/(%s)/ClassEqualityTest/Fail", comp->signature()), 1, TR::DebugCounter::Undetermined);
+
+   int32_t toClassDepth = -1;
+   TR::SymbolReference *toClassSymRef = getClassSymRefAndDepth(toClass, comp, toClassDepth);
+   bool fastFail = false;
+   if (comp->getOption(TR_TraceCG))
+      traceMsg(comp,"%s: toClassSymRef is %s\n",node->getOpCode().getName(), NULL == toClassSymRef ? "null" : "non-null");
+   if (NULL != toClassSymRef && comp->getOption(TR_TraceCG))
+      traceMsg(comp,"%s: toClass is %s\n",node->getOpCode().getName(), toClassSymRef->isClassInterface(comp) ? "an interface" : "not an interface");
+   if ((NULL != toClassSymRef) && !toClassSymRef->isClassInterface(comp))
+      {
+      int32_t fromClassDepth = -1;
+      TR::SymbolReference *fromClassSymRef = getClassSymRefAndDepth(fromClass, comp, fromClassDepth);
+      if (comp->getOption(TR_TraceCG))
+         traceMsg(comp,"%s: fromClassSymRef is %s\n",node->getOpCode().getName(), NULL == toClassSymRef ? "null" : "non-null");
+      if ((NULL != fromClassSymRef) && !fromClassSymRef->isClassInterface(comp))
+         {
+         if (toClassDepth > -1 && fromClassDepth > -1 && toClassDepth > fromClassDepth)
+            {
+            cursor = generateS390BranchInstruction(cg, TR::InstOpCode::BRC, TR::InstOpCode::COND_BRC, node, failLabel);
+            if (debugObj)
+               {
+               debugObj->addInstructionComment(cursor, "toclass depth > fromClass depth at compile time - fast fail");
+               }
+            }
+            fastFail = true;
+         }
+      }
+
+   if (!fastFail)
+      {
+      // castClassCache test
+      if ((NULL != toClassSymRef) && comp->getOption(TR_TraceCG))
+         traceMsg(comp,"%s: toclass is %s\n",node->getOpCode().getName(), toClassSymRef->isClassAbstract(comp) ? "abstract" : "non-abstract");
+      if ((NULL == toClassSymRef) || !toClassSymRef->isClassAbstract(comp))
+         {
+         if (comp->getOption(TR_TraceCG))
+            traceMsg(comp,"%s: Emitting CastClassCacheTest\n",node->getOpCode().getName());
+         TR::Register *castClassCacheReg = srm->findOrCreateScratchRegister();
+         cg->generateDebugCounter(TR::DebugCounter::debugCounterName(comp, "isAssignableFromStats/(%s)/Cache", comp->signature()), 1, TR::DebugCounter::Undetermined);
+         generateRXInstruction(cg, TR::InstOpCode::getLoadOpCode(), node, castClassCacheReg,
+            generateS390MemoryReference(fromClassReg, offsetof(J9Class, castClassCache), cg));
+         cursor = generateS390CompareAndBranchInstruction(cg, TR::InstOpCode::getCmpRegOpCode(), node, castClassCacheReg, toClassReg, TR::InstOpCode::COND_BE, successLabel, false, false);
+         if (debugObj)
+            debugObj->addInstructionComment(cursor, "castclass cache test");
+         cg->generateDebugCounter(TR::DebugCounter::debugCounterName(comp, "isAssignableFromStats/(%s)/Cache/Fail", comp->signature()), 1, TR::DebugCounter::Undetermined);
+         srm->reclaimScratchRegister(castClassCacheReg);
+         }
 
-   TR::RegisterDependencyConditions* deps = new (cg->trHeapMemory()) TR::RegisterDependencyConditions(0, 3, cg);
+      // superclass test
+      if((NULL == toClassSymRef) || !toClassSymRef->isClassInterface(comp))
+         {
+         const int32_t flags = (J9AccInterface | J9AccClassArray);
+         cg->generateDebugCounter(TR::DebugCounter::debugCounterName(comp, "isAssignableFromStats/(%s)/SuperclassTest", comp->signature()), 1, TR::DebugCounter::Undetermined);
+         if (toClassDepth == -1)
+            {
+            genTestModifierFlags(cg, node, toClassReg, toClassDepth, helperCallLabel, srm, flags);
+            }
+         genSuperclassTest(cg, node, toClassReg, toClassDepth, fromClassReg, failLabel, srm);
+         generateS390BranchInstruction(cg, TR::InstOpCode::BRC, TR::InstOpCode::COND_BE, node, successLabel);
+         cg->generateDebugCounter(TR::DebugCounter::debugCounterName(comp, "isAssignableFromStats/(%s)/SuperclassTest/Fail", comp->signature()), 1, TR::DebugCounter::Undetermined);
+         }
+      generateS390BranchInstruction(cg, TR::InstOpCode::BRC, TR::InstOpCode::COND_BRC, node, helperCallLabel);
+      }
+
+   srm->stopUsingRegisters();
+   generateS390LabelInstruction(cg, TR::InstOpCode::label, node, failLabel);
+   generateRIInstruction(cg, TR::InstOpCode::LHI, node, resultReg, 0);
+
+   TR::RegisterDependencyConditions* deps = new (cg->trHeapMemory()) TR::RegisterDependencyConditions(0, 3 + srm->numAvailableRegisters(), cg);
+   srm->addScratchRegistersToDependencyList(deps);
+   deps->addPostCondition(resultReg, TR::RealRegister::AssignAny);
    deps->addPostCondition(fromClassReg, TR::RealRegister::AssignAny);
    deps->addPostConditionIfNotAlreadyInserted(toClassReg, TR::RealRegister::AssignAny);
-   deps->addPostCondition(resultReg, TR::RealRegister::AssignAny);
-
    generateS390LabelInstruction(cg, TR::InstOpCode::label, node, doneLabel, deps);
    doneLabel->setEndInternalControlFlow();
+
    node->setRegister(resultReg);
    return resultReg;
    }