Update comments

Author: adelejjeh

llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp

@@ -2805,10 +2805,9 @@ SDValue AMDGPUTargetLowering::LowerFLOGCommon(SDValue Op,
 
     SDValue C = DAG.getConstantFP(IsLog10 ? c_log10 : c_log, DL, VT);
     SDValue CC = DAG.getConstantFP(IsLog10 ? cc_log10 : cc_log, DL, VT);
-    // Our implementation of LOG is not contract safe because we generate
-    // error-correcting summations for which contraction may lead to an increase
-    // in the error of the approximation. Disable contraction for the expanded
-    // instructions.
+    // Our implementation of LOG is not contract safe because we add correction
+    // terms for which contraction may lead to an increase in the error of the
+    // approximation. Disable contraction for the expanded instructions.
     Flags.setAllowContract(false);
     R = DAG.getNode(ISD::FMUL, DL, VT, Y, C, Flags);
     SDValue NegR = DAG.getNode(ISD::FNEG, DL, VT, R, Flags);
@@ -2832,10 +2831,9 @@ SDValue AMDGPUTargetLowering::LowerFLOGCommon(SDValue Op,
     SDValue YHInt = DAG.getNode(ISD::AND, DL, MVT::i32, YAsInt, MaskConst);
     SDValue YH = DAG.getNode(ISD::BITCAST, DL, MVT::f32, YHInt);
     SDValue YT = DAG.getNode(ISD::FSUB, DL, VT, Y, YH, Flags);
-    // Our implementation of LOG is not contract safe because we generate
-    // error-correcting summations for which contraction may lead to an increase
-    // in the error of the approximation. Disable contraction for the expanded
-    // instructions.
+    // Our implementation of LOG is not contract safe because we add correction
+    // terms for which contraction may lead to an increase in the error of the
+    // approximation. Disable contraction for the expanded instructions.
     Flags.setAllowContract(false);
     SDValue YTCT = DAG.getNode(ISD::FMUL, DL, VT, YT, CT, Flags);
     SDValue Mad0 = getMad(DAG, DL, VT, YH, CT, YTCT, Flags);

llvm/lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp

@@ -3551,10 +3551,9 @@ bool AMDGPULegalizerInfo::legalizeFlogCommon(MachineInstr &MI,
 
     auto C = B.buildFConstant(Ty, IsLog10 ? c_log10 : c_log);
     auto CC = B.buildFConstant(Ty, IsLog10 ? cc_log10 : cc_log);
-    // Our implementation of LOG is not contract safe because we generate
-    // error-correcting summations  for which contraction may lead to an
-    // increase in the error of the approximation. Disable contraction for the
-    // expanded instructions.
+    // Our implementation of LOG is not contract safe because we add correction
+    // terms for which contraction may lead to an increase in the error of the
+    // approximation. Disable contraction for the expanded instructions.
     auto NewFlags = Flags & ~(MachineInstr::FmContract);
     R = B.buildFMul(Ty, Y, C, NewFlags).getReg(0);
     auto NegR = B.buildFNeg(Ty, R, NewFlags);
@@ -3576,10 +3575,9 @@ bool AMDGPULegalizerInfo::legalizeFlogCommon(MachineInstr &MI,
     auto MaskConst = B.buildConstant(Ty, 0xfffff000);
     auto YH = B.buildAnd(Ty, Y, MaskConst);
     auto YT = B.buildFSub(Ty, Y, YH, Flags);
-    // Our implementation of LOG is not contract safe because we generate
-    // error-correcting summations  for which contraction may lead to an
-    // increase in the error of the approximation. Disable contraction for the
-    // expanded instructions.
+    // Our implementation of LOG is not contract safe because we add correction
+    // terms for which contraction may lead to an increase in the error of the
+    // approximation. Disable contraction for the expanded instructions.
     auto NewFlags = Flags & ~(MachineInstr::FmContract);
     auto YTCT = B.buildFMul(Ty, YT, CT, NewFlags);