[CodeGen] Don't create combine loops for PTRADD with opaque constants

We were implicitly assuming here that, if one of Y or Z is a constant,
either the other is not or we will have already (in the nested PTRADD
case) constant-folded both of them into one, and thus don't need to
consider the possibility. However, opaque constants exist and do not get
constant-folded, so we can end up cycling between PTRADD+ADD and
PTRADD+PTRADD. Catch this case by checking the other is not a constant
and skipping all but one combine if so.

No test is provided since I've yet to be able to trigger it in CHERI
LLVM, only downstream in Codasip LLVM and Morello LLVM (and only when
targeting CHERI-RISC-V even in Morello LLVM), both of which enable SCEV
and thus do interesting loop transformations.

Fixes: 05fd67a ("[CodeGen][CHERI-Generic] Support commuting capability offsets when safe")

Author: jrtc27

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

@@ -2789,8 +2789,9 @@ SDValue DAGCombiner::visitPTRADD(SDNode *N) {
   //   * x is a null pointer; or
   //   * the add can be constant-folded; or
   //   * the add can be combined and z is not a constant; or
-  //   * y is a constant and z has one use; or
-  //   * y is a constant and (ptradd x, y) has one use; or
+  //   * y is a constant and z has one use and z is not a constant; or
+  //   * y is a constant and (ptradd x, y) has one use and z is not a
+  //     constant; or
   //   * (ptradd x, y) and z have one use and z is not a constant.
   //
   // Some of these overly-restrictive conditions are to not obfuscate CAndAddr
@@ -2799,12 +2800,15 @@ SDValue DAGCombiner::visitPTRADD(SDNode *N) {
   // and canonicalise it to a PTRMASK.
   //
   // Commute: (ptradd (ptradd x, y), z) -> (ptradd (ptradd x, z), y) if:
-  //   * y and z have the same sign and y is a constant.
+  //   * y and z have the same sign and only y is a constant.
   //
   // This allows immediate addressing modes to be used. Note that we need to be
   // careful to ensure we don't transiently become unrepresentable if the
   // original DAG does not already do so, and this is the case if both PTRADDs
   // have the same sign.
+  //
+  // Note we must be careful to handle the case that both are
+  // constants, as opaque constants will not be constant-folded.
   if (N0.getOpcode() == ISD::PTRADD &&
       !reassociationCanBreakAddressingModePattern(ISD::PTRADD, DL, N, N0, N1)) {
     SDValue X = N0.getOperand(0);
@@ -2827,34 +2831,38 @@ SDValue DAGCombiner::visitPTRADD(SDNode *N) {
     }
     LLVM_DEBUG(dbgs() << "visitPTRADD() add operand:"; Add.dump(&DAG));
     assert(Add->getOpcode() != ISD::DELETED_NODE && "Deleted Node used");
-    if (isNullConstant(X) ||
-        DAG.isConstantIntBuildVectorOrConstantInt(Add) ||
-        (VisitedAdd && !DAG.isConstantIntBuildVectorOrConstantInt(Z)) ||
-        (DAG.isConstantIntBuildVectorOrConstantInt(Y) && Z.hasOneUse()) ||
-        (DAG.isConstantIntBuildVectorOrConstantInt(Y) && N0.hasOneUse()) ||
-        (N0.hasOneUse() && Z.hasOneUse() &&
-         !DAG.isConstantIntBuildVectorOrConstantInt(Z)))
+    bool IsZConst = DAG.isConstantIntBuildVectorOrConstantInt(Z);
+    if (isNullConstant(X) || DAG.isConstantIntBuildVectorOrConstantInt(Add) ||
+        (VisitedAdd && !IsZConst) ||
+        (DAG.isConstantIntBuildVectorOrConstantInt(Y) && Z.hasOneUse() &&
+         !IsZConst) ||
+        (DAG.isConstantIntBuildVectorOrConstantInt(Y) && N0.hasOneUse() &&
+         !IsZConst) ||
+        (N0.hasOneUse() && Z.hasOneUse() && !IsZConst))
       return DAG.getMemBasePlusOffset(X, Add, DL);
-    if (DAG.SignBitIsSame(Y, Z) && DAG.isConstantIntBuildVectorOrConstantInt(Y))
+    if (DAG.SignBitIsSame(Y, Z) &&
+        DAG.isConstantIntBuildVectorOrConstantInt(Y) &&
+        !DAG.isConstantIntBuildVectorOrConstantInt(Z))
       return GetPTRADD2(X, Z, Y);
   }
 
   // Transform: (ptradd x, (add y, z)) -> (ptradd (ptradd x, y), z) if:
   //   * both y and z have the same sign and z is a constant.
   //
   // Transform: (ptradd x, (add y, z)) -> (ptradd (ptradd x, z), y) if:
-  //   * both y and z have the same sign and y is a constant.
+  //   * both y and z have the same sign and y is a constant (and
+  //     implicitly not z due to the previous transform).
   //
   // As above, this allows for immediate addressing modes.
   if (N1.getOpcode() == ISD::ADD) {
     SDValue X = N0;
     SDValue Y = N1.getOperand(0);
     SDValue Z = N1.getOperand(1);
     if (DAG.SignBitIsSame(Y, Z)) {
-      if (DAG.isConstantIntBuildVectorOrConstantInt(Y))
-        return GetPTRADD2(X, Z, Y);
       if (DAG.isConstantIntBuildVectorOrConstantInt(Z))
         return GetPTRADD2(X, Y, Z);
+      if (DAG.isConstantIntBuildVectorOrConstantInt(Y))
+        return GetPTRADD2(X, Z, Y);
     }
   }