[DAGCombine] Slightly improve perf of SimplifySelectOps

[loladiro]

Summary

In [1], I noted an issue with SimplifySelectOps' performance.
This revision contains a few misc changes that improve
performance slightly by avoiding unnecessary walks, but
because the overall problem reported in this issue is algorithmic,
the end-to-end perf impact is minimal (at most 3x faster or so).

In particular, this change:

• Removes redundant ->isPredecessorOf check that is covered more performantly by the subsequent call to hasPredecessorHelper.

• Changes the backwards search barrier from TheSelect (which, contrary to the comment above, should always be a *successor* of the nodes in question). Instead, we use the chain operand of the loads. One of the legality conditions is that both loads have the same chain operand, so this is guaranteed to be a predecessor of at least the loads, and cuts off search through it.

• Corrects the argument checked in hasAnyUseOfValue. According to the comment, this was supposed to check the chain operand of the load. However, it instead checks the value operand is thus trivially true, because we know that the value is used by TheSelect. I think the comment is correct here. We already know that TheSelect is the only user of the loads' values. As a result, the only path to the condition would have to go through the chain operand, so if that is unused, we can avoid performing the search.

[1] https://github.com/llvm/llvm-project/issues/60132

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

if (LHS.getOperand(0) != RHS.getOperand(0) ||
         // We can't produce a CMOV of a TargetFrameIndex since we won't
         // generate the address generation required.
         LLD->getBasePtr().getOpcode() == ISD::TargetFrameIndex ||
         RLD->getBasePtr().getOpcode() == ISD::TargetFrameIndex ||
         !TLI.isOperationLegalOrCustom(TheSelect->getOpcode(),
                                       LLD->getBasePtr().getValueType()))
       return false;
 
-    // The loads must not depend on one another.
-    if (LLD->isPredecessorOf(RLD) || RLD->isPredecessorOf(LLD))
-      return false;
-
     // Check that the select condition doesn't reach either load.  If so,
     // folding this will induce a cycle into the DAG.  If not, this is safe to
     // xform, so create a select of the addresses.
-
     SmallPtrSet<const SDNode *, 32> Visited;
     SmallVector<const SDNode *, 16> Worklist;
 
-    // Always fail if LLD and RLD are not independent. TheSelect is a
-    // predecessor to all Nodes in question so we need not search past it.
+    // The token chain was verified to be identical between RHS and LHD above
+    // and transitively is a predecessor of all nodes in question.
+    Visited.insert(LHS.getOperand(0).getNode());
 
-    Visited.insert(TheSelect);
     Worklist.push_back(LLD);
     Worklist.push_back(RLD);
 
     if (SDNode::hasPredecessorHelper(LLD, Visited, Worklist) ||
         SDNode::hasPredecessorHelper(RLD, Visited, Worklist))
       return false;
 
     SDValue Addr;
     if (TheSelect->getOpcode() == ISD::SELECT) {
       // We cannot do this optimization if any pair of {RLD, LLD} is a
       // predecessor to {RLD, LLD, CondNode}. As we've already compared the
       // Loads, we only need to check if CondNode is a successor to one of the
       // loads. We can further avoid this if there's no use of their chain
-      // value.
+      // value, because we check about that the only use of the value result
+      // is the select itself.
       SDNode *CondNode = TheSelect->getOperand(0).getNode();
       Worklist.push_back(CondNode);
 
-      if ((LLD->hasAnyUseOfValue(1) &&
+      if ((LLD->hasAnyUseOfValue(0) &&
            SDNode::hasPredecessorHelper(LLD, Visited, Worklist)) ||
-          (RLD->hasAnyUseOfValue(1) &&
+          (RLD->hasAnyUseOfValue(0) &&
            SDNode::hasPredecessorHelper(RLD, Visited, Worklist)))
         return false;
 
       Addr = DAG.getSelect(SDLoc(TheSelect),
                            LLD->getBasePtr().getValueType(),
                            TheSelect->getOperand(0), LLD->getBasePtr(),
                            RLD->getBasePtr());
     } else {  // Otherwise SELECT_CC
       // We cannot do this optimization if any pair of {RLD, LLD} is a
       // predecessor to {RLD, LLD, CondLHS, CondRHS}. As we've already compared
       // the Loads, we only need to check if CondLHS/CondRHS is a successor to
       // one of the loads. We can further avoid this if there's no use of their
       // chain value.
 
       SDNode *CondLHS = TheSelect->getOperand(0).getNode();
       SDNode *CondRHS = TheSelect->getOperand(1).getNode();
       Worklist.push_back(CondLHS);
       Worklist.push_back(CondRHS);
 
-      if ((LLD->hasAnyUseOfValue(1) &&
+      if ((LLD->hasAnyUseOfValue(0) &&
            SDNode::hasPredecessorHelper(LLD, Visited, Worklist)) ||
-          (RLD->hasAnyUseOfValue(1) &&
+          (RLD->hasAnyUseOfValue(0) &&
            SDNode::hasPredecessorHelper(RLD, Visited, Worklist)))
         return false;
 
       Addr = DAG.getNode(ISD::SELECT_CC, SDLoc(TheSelect),
                          LLD->getBasePtr().getValueType(),
                          TheSelect->getOperand(0),
                          TheSelect->getOperand(1),
                          LLD->getBasePtr(), RLD->getBasePtr(),