[DAGCombiner] Modify the comment to fit the current implementation and

apply clang-format

Author: yichi170

llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp

@@ -18862,12 +18862,15 @@ SDValue DAGCombiner::visitFPOW(SDNode *N) {
 
 static SDValue foldFPToIntToFP(SDNode *N, const SDLoc &DL, SelectionDAG &DAG,
                                const TargetLowering &TLI) {
-  // We only do this if the target has legal ftrunc. Otherwise, we'd likely be
-  // replacing casts with a libcall. We also must be allowed to ignore -0.0
-  // because FTRUNC will return -0.0 for (-1.0, -0.0), but using integer
-  // conversions would return +0.0.
+  // We can fold the fpto[us]i -> [us]itofp pattern into a single ftrunc.
+  // If NoSignedZerosFPMath is enabled, this is a direct replacement.
+  // Otherwise, for strict math, we must handle edge cases:
+  // 1. For signed conversions, clamp out-of-range values to the valid
+  //    integer range before the trunc.
+  // 2. For unsigned conversions, use FABS. A negative float becomes integer 0,
+  //    which must convert back to +0.0. FTRUNC on its own could produce -0.0.
+
   // FIXME: We should be able to use node-level FMF here.
-  // TODO: If strict math, should we use FABS (+ range check for signed cast)?
   EVT VT = N->getValueType(0);
   if (!TLI.isOperationLegal(ISD::FTRUNC, VT))
     return SDValue();
@@ -18880,6 +18883,7 @@ static SDValue foldFPToIntToFP(SDNode *N, const SDLoc &DL, SelectionDAG &DAG,
     if (DAG.getTarget().Options.NoSignedZerosFPMath)
       return DAG.getNode(ISD::FTRUNC, DL, VT, N0.getOperand(0));
 
+    // Strict math: clamp to the signed integer range before truncating.
     unsigned IntWidth = N0.getValueSizeInBits();
     APInt APMax = APInt::getSignedMaxValue(IntWidth);
     APInt APMin = APInt::getSignedMinValue(IntWidth);
@@ -18892,9 +18896,9 @@ static SDValue foldFPToIntToFP(SDNode *N, const SDLoc &DL, SelectionDAG &DAG,
     SDValue MaxFP = DAG.getConstantFP(MaxAPF, DL, VT);
     SDValue MinFP = DAG.getConstantFP(MinAPF, DL, VT);
 
-    SDValue Clamped = DAG.getNode(ISD::FMINNUM, DL, VT,
-                                  DAG.getNode(ISD::FMAXNUM, DL, VT, N0->getOperand(0), MinFP),
-                                  MaxFP);
+    SDValue Clamped = DAG.getNode(
+        ISD::FMINNUM, DL, VT,
+        DAG.getNode(ISD::FMAXNUM, DL, VT, N0->getOperand(0), MinFP), MaxFP);
     return DAG.getNode(ISD::FTRUNC, DL, VT, Clamped);
   }
 
@@ -18903,6 +18907,7 @@ static SDValue foldFPToIntToFP(SDNode *N, const SDLoc &DL, SelectionDAG &DAG,
     if (DAG.getTarget().Options.NoSignedZerosFPMath)
       return DAG.getNode(ISD::FTRUNC, DL, VT, N0.getOperand(0));
 
+    // Strict math: use FABS to handle negative inputs correctly.
     if (TLI.isFAbsFree(VT)) {
       SDValue Abs = DAG.getNode(ISD::FABS, DL, VT, N0.getOperand(0));
       return DAG.getNode(ISD::FTRUNC, DL, VT, Abs);