Address comments. Thank you!

mlir/lib/Dialect/Linalg/Transforms/Loops.cpp

Value getPaddedInput(Value input, ArrayRef<Value> indices,
 
   Value readInput = indexedInput(clampedImIdx);
   return conds.empty() ? readInput
                        : (Value)std_select(conds.back(), padValue, readInput);
 }
 
 namespace {
 
-// The padding value for a given Op depends on the semantics of the Op.
-// The identity value for ConvOp and PoolingSumOp is 0, for PoolingMaxOp is -inf
-// or minInt and for PoolingMinOp is inf or maxInt.
-
+/// The padding value for a given Op depends on the semantics of the Op.
+/// The identity value for ConvOp and PoolingSumOp is 0, for PoolingMaxOp is
+/// -inf or minInt and for PoolingMinOp is inf or maxInt.
 template <typename OpType>
 Attribute getPadValueAttr(Type type) {
   llvm_unreachable("Unexpected op type for getPadValueAttr");
   return {};
 }
 
 template <>
 Attribute getPadValueAttr<PoolingMaxOp>(Type type) {
   auto &b = ScopedContext::getBuilderRef();
   if (auto floatType = type.dyn_cast<FloatType>()) {
-    return b.getFloatAttr(floatType,
-                          APFloat::getInf(floatType.getFloatSemantics(), true));
+    return b.getFloatAttr(
+        floatType,
+        APFloat::getInf(floatType.getFloatSemantics(), /*Negative*/ true));
   }
   if (auto intType = type.dyn_cast<IntegerType>()) {
     unsigned width = intType.getWidth();
     // The select instruction used to lower the PoolingMin uses a signed
     // comparison, use a signed constant irrespective of the signedness of the
     // integer type.
     return b.getIntegerAttr(intType, APInt::getSignedMinValue(width));
   }
static void emitScalarImplementation(ArrayRef<Value> allIvs, ConvOp convOp) {
 
   IndexedValueType F(convOp.filter()), O(convOp.output());
 
   // Emit scalar form. Padded conv involves an affine.max in the memory access
   // which is not allowed by affine.load. Override to use an StdIndexedValue
   // when there is non-zero padding.
   if (hasPadding(convOp)) {
     Type type = convOp.input().getType().cast<MemRefType>().getElementType();
-    Value zero = std_constant(type, getPadValueAttr<ConvOp>(type));
+    Value padValue = std_constant(type, getPadValueAttr<ConvOp>(type));
     Value paddedInput = getPaddedInput<StdIndexedValue>(
         convOp.input(), imIdx,
         /* Only need to pad the window dimensions */
-        {0, static_cast<int>(imIdx.size()) - 1}, zero);
+        {0, static_cast<int>(imIdx.size()) - 1}, padValue);
     O(oIdx) += F(fIdx) * paddedInput;
   } else {
     IndexedValueType I(convOp.input());
     O(oIdx) += F(fIdx) * I(imIdx);
   }
 }
 
 template <typename PoolingOp>