Replace reg dep RealRegister property checks with meaningful queries …

…on x86

Register dependencies rely on "special" RealRegister values to convey
other properties about the register dependency, such as whether a byte
register must be assigned, or whether any assignable register is
suitable for this dependency.  The long-term goal is to not rely on
such special values in the RealRegister enum to convey these properties.
To get there, this commit replaces direct tests of the real register for
queries on the register dependency itself for the property in question.

Signed-off-by: Daryl Maier <maier@ca.ibm.com>

compiler/x/codegen/OMRLinkage.cpp

@@ -548,9 +548,10 @@ void OMR::X86::Linkage::stopUsingKilledRegisters(TR::RegisterDependencyCondition
    TR::Register *vmThreadReg = self()->cg()->getVMThreadRegister();
    for (int32_t i = deps->getNumPostConditions()-1; i >= 0; --i)
       {
-      if (deps->getPostConditions()->getRegisterDependency(i)->getRealRegister() != TR::RealRegister::NoReg)
+      TR::RegisterDependency *regDep = deps->getPostConditions()->getRegisterDependency(i);
+      if (!regDep->isNoReg())
          {
-         TR::Register *reg = deps->getPostConditions()->getRegisterDependency(i)->getRegister();
+         TR::Register *reg = regDep->getRegister();
          if (reg                         &&
              reg != firstReturnRegister  &&
              reg != secondReturnRegister &&

compiler/x/codegen/OMRRegisterDependency.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
@@ -657,7 +657,7 @@ void TR_X86RegisterDependencyGroup::blockRealDependencyRegisters(TR_X86RegisterD
    TR::Machine *machine = cg->machine();
    for (TR_X86RegisterDependencyIndex i = 0; i < numberOfRegisters; i++)
       {
-      if (_dependencies[i].getRealRegister() != TR::RealRegister::NoReg)
+      if (!_dependencies[i].isNoReg())
          {
          machine->getRealRegister(_dependencies[i].getRealRegister())->block();
          }
@@ -670,7 +670,7 @@ void TR_X86RegisterDependencyGroup::unblockRealDependencyRegisters(TR_X86Registe
    TR::Machine *machine = cg->machine();
    for (TR_X86RegisterDependencyIndex i = 0; i < numberOfRegisters; i++)
       {
-      if (_dependencies[i].getRealRegister() != TR::RealRegister::NoReg)
+      if (!_dependencies[i].isNoReg())
          {
          machine->getRealRegister(_dependencies[i].getRealRegister())->unblock();
          }
@@ -715,27 +715,27 @@ void TR_X86RegisterDependencyGroup::assignRegisters(TR::Instruction   *currentIn
 
    for (i=0; i<numberOfRegisters; i++)
       {
-      virtReg = _dependencies[i].getRegister();
-      dependentRegNum = _dependencies[i].getRealRegister();
+      TR::RegisterDependency &regDep = _dependencies[i];
+      virtReg = regDep.getRegister();
 
       if (virtReg && (kindsToBeAssigned & virtReg->getKindAsMask())
-          && dependentRegNum != TR::RealRegister::NoReg
-          && dependentRegNum != TR::RealRegister::ByteReg
-          && dependentRegNum != TR::RealRegister::SpilledReg
-          && dependentRegNum != TR::RealRegister::BestFreeReg)
+          && !regDep.isNoReg()
+          && !regDep.isByteReg()
+          && !regDep.isSpilledReg()
+          && !regDep.isBestFreeReg())
          {
          dependencies[numDependencyRegisters++] = getRegisterDependency(i);
          }
-      else if (dependentRegNum == TR::RealRegister::NoReg)
+      else if (regDep.isNoReg())
          hasNoRegDeps = true;
-      else if (dependentRegNum == TR::RealRegister::ByteReg)
+      else if (regDep.isByteReg())
          hasByteDeps = true;
-      else if (dependentRegNum == TR::RealRegister::BestFreeReg)
+      else if (regDep.isBestFreeReg())
          hasBestFreeRegDeps = true;
 
       // Handle spill registers first.
       //
-      if (dependentRegNum == TR::RealRegister::SpilledReg)
+      if (regDep.isSpilledReg())
          {
          if (cg->getUseNonLinearRegisterAssigner())
             {
@@ -790,9 +790,8 @@ void TR_X86RegisterDependencyGroup::assignRegisters(TR::Instruction   *currentIn
       for (i=0; i<numberOfRegisters; i++)
          {
          virtReg = _dependencies[i].getRegister();
-         dependentRegNum = _dependencies[i].getRealRegister();
          if (virtReg && (kindsToBeAssigned & virtReg->getKindAsMask()) &&
-             dependentRegNum == TR::RealRegister::ByteReg)
+             _dependencies[i].isByteReg())
             {
             dependencies[numDependencyRegisters++] = getRegisterDependency(i);
             }
@@ -807,9 +806,8 @@ void TR_X86RegisterDependencyGroup::assignRegisters(TR::Instruction   *currentIn
       for (i=0; i<numberOfRegisters; i++)
          {
          virtReg = _dependencies[i].getRegister();
-         dependentRegNum = _dependencies[i].getRealRegister();
          if (virtReg && (kindsToBeAssigned & virtReg->getKindAsMask()) &&
-             dependentRegNum == TR::RealRegister::NoReg)
+             _dependencies[i].isNoReg())
             {
             dependencies[numDependencyRegisters++] = getRegisterDependency(i);
             }
@@ -824,9 +822,8 @@ void TR_X86RegisterDependencyGroup::assignRegisters(TR::Instruction   *currentIn
       for (i=0; i<numberOfRegisters; i++)
          {
          virtReg = _dependencies[i].getRegister();
-         dependentRegNum = _dependencies[i].getRealRegister();
          if (virtReg && (kindsToBeAssigned & virtReg->getKindAsMask()) &&
-             dependentRegNum == TR::RealRegister::BestFreeReg)
+             _dependencies[i].isBestFreeReg())
             {
             dependencies[numDependencyRegisters++] = getRegisterDependency(i);
             }
@@ -1017,10 +1014,10 @@ void TR_X86RegisterDependencyGroup::assignRegisters(TR::Instruction   *currentIn
       // by snippets that need to look back and figure out which virtual
       // registers ended up assigned to which real registers.
       //
-      if (dependencies[i]->getRealRegister() == TR::RealRegister::NoReg)
+      if (dependencies[i]->isNoReg())
          dependencies[i]->setRealRegister(assignedReg->getRegisterNumber());
 
-      if (dependencies[i]->getRealRegister() == TR::RealRegister::BestFreeReg)
+      if (dependencies[i]->isBestFreeReg())
          {
          dependencies[i]->setRealRegister(bestFreeRealRegIndex);
          virtRegister->decFutureUseCount();
@@ -1041,11 +1038,10 @@ void TR_X86RegisterDependencyGroup::assignRegisters(TR::Instruction   *currentIn
       for (i=0; i<numberOfRegisters; i++)
          {
          virtReg = _dependencies[i].getRegister();
-         dependentRegNum = _dependencies[i].getRealRegister();
 
          if (virtReg
              && (kindsToBeAssigned & virtReg->getKindAsMask())
-             && dependentRegNum == TR::RealRegister::SpilledReg)
+             && _dependencies[i].isSpilledReg())
             {
             virtReg->decFutureUseCount();
             }
@@ -1269,7 +1265,7 @@ void TR_X86RegisterDependencyGroup::assignFPRegisters(TR::Instruction   *prevIns
                   }
                }
             }
-         else if (_dependencies[i].getRealRegister() == TR::RealRegister::AllFPRegisters)
+         else if (_dependencies[i].isAllFPRegisters())
             {
             // Spill the entire FP stack to memory.
             //
@@ -1311,7 +1307,7 @@ void TR_X86RegisterDependencyGroup::assignFPRegisters(TR::Instruction   *prevIns
             }
          else
             {
-            if (_dependencies[i].getRealRegister() == TR::RealRegister::AllFPRegisters)
+            if (_dependencies[i].isAllFPRegisters())
                {
                // Spill the entire FP stack to memory.
                //
@@ -1493,7 +1489,7 @@ uint32_t OMR::X86::RegisterDependencyConditions::numReferencedFPRegisters(TR::Co
       {
       reg = _preConditions->getRegisterDependency(i)->getRegister();
       if ((reg && reg->getKind() == TR_X87) ||
-          (!reg && _preConditions->getRegisterDependency(i)->getRealRegister() == TR::RealRegister::AllFPRegisters))
+          (!reg && _preConditions->getRegisterDependency(i)->isAllFPRegisters()))
          {
          total++;
          }
@@ -1503,7 +1499,7 @@ uint32_t OMR::X86::RegisterDependencyConditions::numReferencedFPRegisters(TR::Co
       {
       reg = _postConditions->getRegisterDependency(i)->getRegister();
       if ((reg && reg->getKind() == TR_X87) ||
-          (!reg && _postConditions->getRegisterDependency(i)->getRealRegister() == TR::RealRegister::AllFPRegisters))
+          (!reg && _postConditions->getRegisterDependency(i)->isAllFPRegisters()))
          {
          total++;
          }

compiler/x/codegen/OMRRegisterDependencyStruct.hpp

@@ -64,6 +64,26 @@ struct RegisterDependency : OMR::RegisterDependency
    {
    uint32_t getGlobalFPRegister()   {return _flags & GlobalRegisterFPDependency;}
    uint32_t setGlobalFPRegister()   {return (_flags |= GlobalRegisterFPDependency);}
+
+   /**
+    * @return Answers \c true if this register dependency refers to all x87 floating
+    *         point registers collectively; \c false otherwise.
+    */
+   bool isAllFPRegisters() { return _realRegister == TR::RealRegister::AllFPRegisters; }
+
+   /**
+    * @return Answers \c true if this register dependency is a request for the
+    *         best free register from the perspective of the register assigner;
+    *         \c false otherwise.
+    */
+   bool isBestFreeReg() { return _realRegister == TR::RealRegister::BestFreeReg; }
+
+   /**
+    * @return Answers \c true if this register dependency is a request for a
+    *         register that can be used as the byte operand in certain machine
+    *         instructions; \c false otherwise.
+    */
+   bool isByteReg() { return _realRegister == TR::RealRegister::ByteReg; }
    };
 }
 }

compiler/x/codegen/OMRX86Instruction.cpp

@@ -255,7 +255,7 @@ void TR::X86LabelInstruction::addPostDepsToOutlinedInstructionsBranch()
 #ifdef DEBUG
       // Ensure all register dependencies have been assigned.
       //
-      TR_ASSERT(dependency->getRealRegister() != TR::RealRegister::NoReg, "unassigned merge dep register");
+      TR_ASSERT(!dependency->isNoReg(), "unassigned merge dep register");
 #endif
       }
    }

compiler/x/codegen/X86Debug.cpp

@@ -239,31 +239,32 @@ TR_Debug::printDependencyConditions(
       cursor += 12;
 
       *(cursor++) = '(';
-      TR::RealRegister::RegNum r = (conditions->getRegisterDependency(i))->getRealRegister();
-      if  (r == TR::RealRegister::AllFPRegisters)
+      TR::RegisterDependency *regDep = conditions->getRegisterDependency(i);
+      if (regDep->isAllFPRegisters())
          {
          len = sprintf(cursor, "AllFP");
          }
-      else if (r == TR::RealRegister::NoReg)
+      else if (regDep->isNoReg())
          {
          len = sprintf(cursor, "NoReg");
          }
-      else if (r == TR::RealRegister::ByteReg)
+      else if (regDep->isByteReg())
          {
          len = sprintf(cursor, "ByteReg");
          }
-      else if (r == TR::RealRegister::BestFreeReg)
+      else if (regDep->isBestFreeReg())
          {
          len = sprintf(cursor, "BestFreeReg");
          }
-      else if (r == TR::RealRegister::SpilledReg)
+      else if (regDep->isSpilledReg())
          {
          len = sprintf(cursor, "SpilledReg");
          }
       else
          {
+         TR::RealRegister::RegNum r = regDep->getRealRegister();
          len = sprintf(cursor, "%s", getName(_cg->machine()->getRealRegister(r)));
-        }
+         }
 
       *(cursor+len)=')';
       *(cursor+9) = 0x00;
@@ -313,31 +314,34 @@ TR_Debug::dumpDependencyGroup(TR::FILE *                         pOutFile,
    trfprintf(pOutFile, "\n\t%s:", prefix);
    for (i = 0; i < numConditions; ++i)
       {
-      virtReg = group->getRegisterDependency(i)->getRegister();
-      r = (group->getRegisterDependency(i))->getRealRegister();
+      TR::RegisterDependency *regDep = group->getRegisterDependency(i);
+      virtReg = regDep->getRegister();
 
       if (omitNullDependencies)
-        if (!virtReg && r != TR::RealRegister::AllFPRegisters)
-           continue;
+         {
+         if (!virtReg && !regDep->isAllFPRegisters())
+            continue;
+         }
 
-      if  (r == TR::RealRegister::AllFPRegisters)
-        {
-        trfprintf(pOutFile, " [All FPRs]");
-        }
+      if (regDep->isAllFPRegisters())
+         {
+         trfprintf(pOutFile, " [All FPRs]");
+         }
       else
-        {
-        trfprintf(pOutFile, " [%s : ", getName(virtReg));
-        if (r == TR::RealRegister::NoReg)
-           trfprintf(pOutFile, "NoReg]");
-        else if (r == TR::RealRegister::ByteReg)
-           trfprintf(pOutFile, "ByteReg]");
-        else if (r == TR::RealRegister::BestFreeReg)
-           trfprintf(pOutFile, "BestFreeReg]");
-        else if (r == TR::RealRegister::SpilledReg)
-           trfprintf(pOutFile, "SpilledReg]");
-        else
-           trfprintf(pOutFile, "%s]", getName(_cg->machine()->getRealRegister(r)));
-        }
+         {
+         r = regDep->getRealRegister();
+         trfprintf(pOutFile, " [%s : ", getName(virtReg));
+         if (regDep->isNoReg())
+            trfprintf(pOutFile, "NoReg]");
+         else if (regDep->isByteReg())
+            trfprintf(pOutFile, "ByteReg]");
+         else if (regDep->isBestFreeReg())
+            trfprintf(pOutFile, "BestFreeReg]");
+         else if (regDep->isSpilledReg())
+            trfprintf(pOutFile, "SpilledReg]");
+         else
+            trfprintf(pOutFile, "%s]", getName(_cg->machine()->getRealRegister(r)));
+         }
 
       foundDep = true;
       }