Fix more

Author: VitalyAnkh

mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp

@@ -1573,7 +1573,7 @@ void mlir::populateSPIRVToLLVMConversionPatterns(
       FComparePattern<spirv::FOrdGreaterThanOp, LLVM::FCmpPredicate::ogt>,
       FComparePattern<spirv::FOrdGreaterThanEqualOp, LLVM::FCmpPredicate::oge>,
       FComparePattern<spirv::FOrdLessThanEqualOp, LLVM::FCmpPredicate::ole>,
-      FComparePattern<spirv::FOrdLessThanOp, LLVM::FCmpPredicate::old>,
+      FComparePattern<spirv::FOrdLessThanOp, LLVM::FCmpPredicate::olt>,
       FComparePattern<spirv::FOrdNotEqualOp, LLVM::FCmpPredicate::one>,
       FComparePattern<spirv::FUnordEqualOp, LLVM::FCmpPredicate::ueq>,
       FComparePattern<spirv::FUnordGreaterThanOp, LLVM::FCmpPredicate::ugt>,

mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp

@@ -1076,7 +1076,7 @@ struct EraseAlwaysFalseDealloc : public OpRewritePattern<DeallocOp> {
 /// memref if the operand is not already guaranteed to be the result of a memref
 /// allocation operation. This canonicalization pattern removes this extraction
 /// operation if the operand is now produced by an allocation operation (e.g.,
-/// due to other canonicalization simplifying the IR).
+/// due to other canonicalizations simplifying the IR).
 ///
 /// Example:
 /// ```mlir

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

@@ -374,7 +374,7 @@ struct RemoveUnusedCycleInGenericOp : public OpRewritePattern<GenericOp> {
 /// Assuming that all %a and %b have the same index map:
 /// * All uses of %in0 and %in2 are replaced with %out1
 /// * All uses of %in1 are replaced with %in3
-/// This pattern can enable additional canonicalization: In the above example,
+/// This pattern can enable additional canonicalizations: In the above example,
 /// %in0, %in1 and %in3 have no uses anymore and their corresponding operands
 /// can be folded away. This pattern does not modify uses of output block args.
 struct FoldDuplicateInputBbArgs : public OpRewritePattern<GenericOp> {

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

@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 //
 // This file implements conversions between named ops that can be seens as
-// canonicalization of named ops.
+// canonicalizations of named ops.
 //
 //===----------------------------------------------------------------------===//
 

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

@@ -1283,8 +1283,8 @@ vectorizeOneOp(RewriterBase &rewriter, VectorizationState &state,
 /// permutation_map of the vector.transfer_read operations. The eager
 /// broadcasting makes it trivial to detrmine where broadcast, transposes and
 /// reductions should occur, without any bookkeeping. The tradeoff is that, in
-/// the absence of good canonicalization, the amount of work increases.
-/// This is not deemed a problem as we expect canonicalization and foldings to
+/// the absence of good canonicalizations, the amount of work increases.
+/// This is not deemed a problem as we expect canonicalizations and foldings to
 /// aggressively clean up the useless work.
 static LogicalResult
 vectorizeAsLinalgGeneric(RewriterBase &rewriter, VectorizationState &state,

mlir/lib/Dialect/MemRef/Transforms/EmulateWideInt.cpp

@@ -121,7 +121,7 @@ struct EmulateWideIntPass final
         [&typeConverter](Operation *op) { return typeConverter.isLegal(op); });
 
     RewritePatternSet patterns(ctx);
-    // Add common pattenrs to support contains, functions, etc.
+    // Add common patterns to support contants, functions, etc.
     arith::populateArithWideIntEmulationPatterns(typeConverter, patterns);
 
     memref::populateMemRefWideIntEmulationPatterns(typeConverter, patterns);

mlir/lib/Dialect/SCF/Utils/Utils.cpp

@@ -110,7 +110,7 @@ SmallVector<scf::ForOp> mlir::replaceLoopNestWithNewYields(
 /// Assumes the FuncOp result types is the type of the yielded operands of the
 /// single block. This constraint makes it easy to determine the result.
 /// This method also clones the `arith::ConstantIndexOp` at the start of
-/// `outlinedFuncBody` to alloc simple canonicalization. If `callOp` is
+/// `outlinedFuncBody` to alloc simple canonicalizations. If `callOp` is
 /// provided, it will be set to point to the operation that calls the outlined
 /// function.
 // TODO: support more than single-block regions.