Fix false positives

VitalyAnkh · VitalyAnkh · commit cd4dec1d4802 · 2024-09-12T18:51:44.000+08:00
diff --git a/mlir/docs/Canonicalization.md b/mlir/docs/Canonicalization.md
@@ -12,7 +12,7 @@ Most compilers have canonicalization passes, and sometimes they have many
 different ones (e.g. instcombine, dag combine, etc in LLVM). Because MLIR is a
 multi-level IR, we can provide a single canonicalization infrastructure and
 reuse it across many different IRs that it represents. This document describes
-the general approach, global canonicalization performed, and provides sections
+the general approach, global canonicalizations performed, and provides sections
 to capture IR-specific rules for reference.
 
 [TOC]
@@ -28,7 +28,7 @@ exhausted. This is for efficiency reasons and to ensure that faulty patterns
 cannot cause infinite looping.
 
 Canonicalization patterns are registered with the operations themselves, which
-allows each dialect to define its own set of operations and canonicalization
+allows each dialect to define its own set of operations and canonicalizations
 together.
 
 Some important things to think about w.r.t. canonicalization patterns:
@@ -107,15 +107,15 @@ These transformations are applied to all levels of IR:
 
 ## Defining Canonicalizations
 
-Two mechanisms are available with which to define canonicalization;
+Two mechanisms are available with which to define canonicalizations;
 general `RewritePattern`s and the `fold` method.
 
 ### Canonicalizing with `RewritePattern`s
 
-This mechanism allows for providing canonicalization as a set of
+This mechanism allows for providing canonicalizations as a set of
 `RewritePattern`s, either imperatively defined in C++ or declaratively as
 [Declarative Rewrite Rules](DeclarativeRewrites.md). The pattern rewrite
-infrastructure allows for expressing many different types of canonicalization.
+infrastructure allows for expressing many different types of canonicalizations.
 These transformations may be as simple as replacing a multiplication with a
 shift, or even replacing a conditional branch with an unconditional one.
 
@@ -156,7 +156,7 @@ defining operation rewrites.
 ### Canonicalizing with the `fold` method
 
 The `fold` mechanism is an intentionally limited, but powerful mechanism that
-allows for applying canonicalization in many places throughout the compiler.
+allows for applying canonicalizations in many places throughout the compiler.
 For example, outside of the canonicalizer pass, `fold` is used within the
 [dialect conversion infrastructure](DialectConversion.md) as a legalization
 mechanism, and can be invoked directly anywhere with an `OpBuilder` via
diff --git a/mlir/docs/Rationale/RationaleLinalgDialect.md b/mlir/docs/Rationale/RationaleLinalgDialect.md
@@ -516,7 +516,7 @@ write, easy to verify and easy to maintain.
 declaratively. In turn this allows using local pattern rewrite rules in MLIR
 (i.e. [DRR](../DeclarativeRewrites.md)).
 - Allow creating customizable passes declaratively by simply selecting rewrite
-rules. This allows mixing transformations, canonicalization, constant folding
+rules. This allows mixing transformations, canonicalizations, constant folding
 and other enabling rewrites in a single pass. The result is a system where pass
 fusion is very simple to obtain and gives hope for solving certain
 [phase ordering issues](https://dl.acm.org/doi/10.1145/201059.201061).
diff --git a/mlir/docs/doxygen.cfg.in b/mlir/docs/doxygen.cfg.in
@@ -931,7 +931,7 @@ REFERENCES_RELATION    = YES
 REFERENCES_LINK_SOURCE = YES
 
 # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
-# source code will show a tooldip with additional information such as prototype,
+# source code will show a tooltip with additional information such as prototype,
 # brief description and links to the definition and documentation. Since this
 # will make the HTML file larger and loading of large files a bit slower, you
 # can opt to disable this feature.
diff --git a/mlir/include/mlir/Conversion/TosaToLinalg/TosaToLinalg.h b/mlir/include/mlir/Conversion/TosaToLinalg/TosaToLinalg.h
@@ -32,7 +32,7 @@ std::unique_ptr<Pass> createTosaToLinalgNamed(
 /// Populates passes to convert from TOSA to Linalg on buffers. At the end of
 /// the pass, the function will only contain linalg ops or standard ops if the
 /// pipeline succeeds.  The option to disable decompositions is available for
-/// benchmarking performance improvements from the canonicalization.
+/// benchmarking performance improvements from the canonicalizations.
 void addTosaToLinalgPasses(
     OpPassManager &pm, const TosaToLinalgOptions &options,
     const TosaToLinalgNamedOptions &tosaToLinalgNamedOptions =
diff --git a/mlir/include/mlir/Dialect/Arith/IR/ArithBase.td b/mlir/include/mlir/Dialect/Arith/IR/ArithBase.td
@@ -41,7 +41,7 @@ def Arith_CmpFPredicateAttr : I64EnumAttr<
       I64EnumAttrCase<"OEQ", 1, "oeq">,
       I64EnumAttrCase<"OGT", 2, "ogt">,
       I64EnumAttrCase<"OGE", 3, "oge">,
-      I64EnumAttrCase<"OLT", 4, "old">,
+      I64EnumAttrCase<"OLT", 4, "olt">,
       I64EnumAttrCase<"OLE", 5, "ole">,
       I64EnumAttrCase<"ONE", 6, "one">,
       I64EnumAttrCase<"ORD", 7, "ord">,
diff --git a/mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h b/mlir/include/mlir/Dialect/Bufferization/IR/BufferizableOpInterface.h
@@ -646,7 +646,7 @@ OpTy replaceOpWithNewBufferizedOp(RewriterBase &rewriter, Operation *op,
 ///
 /// Note: Canonicalization patterns could clean up layout maps and infer more
 /// precise layout maps after bufferization. However, many possible
-/// canonicalization are currently not implemented.
+/// canonicalizations are currently not implemented.
 BaseMemRefType getMemRefType(Value value, const BufferizationOptions &options,
                              MemRefLayoutAttrInterface layout = {},
                              Attribute memorySpace = nullptr);
diff --git a/mlir/include/mlir/Dialect/DLTI/DLTIAttrs.td b/mlir/include/mlir/Dialect/DLTI/DLTIAttrs.td
@@ -72,7 +72,7 @@ def DLTI_DataLayoutSpecAttr :
     DataLayoutSpecAttr combineWith(ArrayRef<DataLayoutSpecInterface> specs) const;
 
     /// Returns the endiannes identifier.
-    StringAttr getEndiannesssIdentifier(MLIRContext *context) const;
+    StringAttr getEndiannessIdentifier(MLIRContext *context) const;
 
     /// Returns the alloca memory space identifier.
     StringAttr getAllocaMemorySpaceIdentifier(MLIRContext *context) const;
diff --git a/mlir/include/mlir/Dialect/DLTI/DLTIBase.td b/mlir/include/mlir/Dialect/DLTI/DLTIBase.td
@@ -41,13 +41,13 @@ def DLTI_Dialect : Dialect {
 
     // Constants used in entries.
     constexpr const static ::llvm::StringLiteral
-    kDataLayoutEndiannesssKey = "dlti.endianness";
+    kDataLayoutEndiannessKey = "dlti.endianness";
 
     constexpr const static ::llvm::StringLiteral
-    kDataLayoutEndiannesssBig = "big";
+    kDataLayoutEndiannessBig = "big";
 
     constexpr const static ::llvm::StringLiteral
-    kDataLayoutEndiannesssLittle = "little";
+    kDataLayoutEndiannessLittle = "little";
 
     constexpr const static ::llvm::StringLiteral
     kDataLayoutAllocaMemorySpaceKey = "dlti.alloca_memory_space";
diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMEnums.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMEnums.td
@@ -544,7 +544,7 @@ def FCmpPredicateFALSE : LLVM_EnumAttrCase<"_false", "_false", "FCMP_FALSE", 0>;
 def FCmpPredicateOEQ   : LLVM_EnumAttrCase<"oeq", "oeq", "FCMP_OEQ", 1>;
 def FCmpPredicateOGT   : LLVM_EnumAttrCase<"ogt", "ogt", "FCMP_OGT", 2>;
 def FCmpPredicateOGE   : LLVM_EnumAttrCase<"oge", "oge", "FCMP_OGE", 3>;
-def FCmpPredicateOLT   : LLVM_EnumAttrCase<"old", "old", "FCMP_OLT", 4>;
+def FCmpPredicateOLT   : LLVM_EnumAttrCase<"olt", "olt", "FCMP_OLT", 4>;
 def FCmpPredicateOLE   : LLVM_EnumAttrCase<"ole", "ole", "FCMP_OLE", 5>;
 def FCmpPredicateONE   : LLVM_EnumAttrCase<"one", "one", "FCMP_ONE", 6>;
 def FCmpPredicateORD   : LLVM_EnumAttrCase<"ord", "ord", "FCMP_ORD", 7>;
diff --git a/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h b/mlir/include/mlir/Dialect/Linalg/Transforms/Transforms.h
@@ -1753,7 +1753,7 @@ void populateFuseTensorPadWithProducerLinalgOpPatterns(
     RewritePatternSet &patterns);
 
 /// Patterns to convert from one named op to another. These can be seen as
-/// canonicalization of named ops into another named op.
+/// canonicalizations of named ops into another named op.
 void populateLinalgNamedOpConversionPatterns(RewritePatternSet &patterns);
 
 /// Patterns to fold unit-extent dimensions in operands/results of linalg ops on
diff --git a/mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td b/mlir/include/mlir/Dialect/MemRef/IR/MemRefOps.td
@@ -937,7 +937,7 @@ def MemRef_ExtractStridedMetadataOp : MemRef_Op<"extract_strided_metadata", [
     This makes lowering more progressive and brings the following benefits:
       - not all users of MLIR want to lower to LLVM and the information to e.g.
         lower to library calls---like libxsmm---or to SPIR-V was not available.
-      - foldings and canonicalization can happen at a higher level in MLIR:
+      - foldings and canonicalizations can happen at a higher level in MLIR:
         before this op existed, lowering to LLVM would create large amounts of
         LLVMIR. Even when LLVM does a good job at folding the low-level IR from
         a performance perspective, it is unnecessarily opaque and inefficient to
diff --git a/mlir/include/mlir/Dialect/SCF/Transforms/Transforms.h b/mlir/include/mlir/Dialect/SCF/Transforms/Transforms.h
@@ -56,7 +56,7 @@ void naivelyFuseParallelOps(Region &region,
 /// `partialIteration`). This transformation is called "loop peeling".
 ///
 /// This transformation is beneficial for a wide range of transformations such
-/// as vectorization or loop tiling: It enables additional canonicalization
+/// as vectorization or loop tiling: It enables additional canonicalizations
 /// inside the peeled loop body such as rewriting masked loads into unmaked
 /// loads.
 ///
diff --git a/mlir/include/mlir/Dialect/SCF/Utils/Utils.h b/mlir/include/mlir/Dialect/SCF/Utils/Utils.h
@@ -57,7 +57,7 @@ SmallVector<scf::ForOp> 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.
+/// `outlinedFuncBody` to alloc simple canonicalizations.
 /// Creates a new FuncOp and thus cannot be used in a FuncOp pass.
 /// The client is responsible for providing a unique `funcName` that will not
 /// collide with another FuncOp name.  If `callOp` is provided, it will be set
diff --git a/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td b/mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td
@@ -1288,7 +1288,7 @@ def SparseTensor_SelectOp : SparseTensor_Op<"select", [Pure, SameOperandsAndResu
           %col = linalg.index 1 : index
           %result = sparse_tensor.select %a : f64 {
               ^bb0(%arg0: f64):
-                %keep = arith.cmpf "old", %col, %row : f64
+                %keep = arith.cmpf "olt", %col, %row : f64
                 sparse_tensor.yield %keep : i1
             }
           linalg.yield %result : f64
diff --git a/mlir/include/mlir/Dialect/Tensor/TransformOps/TensorTransformOps.td b/mlir/include/mlir/Dialect/Tensor/TransformOps/TensorTransformOps.td
@@ -92,7 +92,7 @@ def ApplyMergeConsecutiveInsertExtractSlicePatternsOp : Op<Transform_Dialect,
     [DeclareOpInterfaceMethods<PatternDescriptorOpInterface>]> {
   let description = [{
     Indicates that consecutive tensor.extract_slice/tensor.insert_slice ops
-    should be merged into a single op. These patterns are not canonicalization
+    should be merged into a single op. These patterns are not canonicalizations
     because the bufferization is sensitive to IR structure.
   }];
 
diff --git a/mlir/include/mlir/IR/OperationSupport.h b/mlir/include/mlir/IR/OperationSupport.h
@@ -257,7 +257,7 @@ class OperationName {
   ///     success.  The caller will remove the operation and use those results
   ///     instead.
   ///
-  /// This allows expression of some simple in-place canonicalization (e.g.
+  /// This allows expression of some simple in-place canonicalizations (e.g.
   /// "x+0 -> x", "min(x,y,x,z) -> min(x,y,z)", "x+y-x -> y", etc), as well as
   /// generalized constant folding.
   LogicalResult foldHook(Operation *op, ArrayRef<Attribute> operands,
diff --git a/mlir/include/mlir/Interfaces/DataLayoutInterfaces.h b/mlir/include/mlir/Interfaces/DataLayoutInterfaces.h
@@ -74,7 +74,7 @@ getDefaultIndexBitwidth(Type type, const DataLayout &dataLayout,
 
 /// Default handler for endianness request. Dispatches to the
 /// DataLayoutInterface if specified, otherwise returns the default.
-Attribute getDefaultEndiannesss(DataLayoutEntryInterface entry);
+Attribute getDefaultEndianness(DataLayoutEntryInterface entry);
 
 /// Default handler for alloca memory space request. Dispatches to the
 /// DataLayoutInterface if specified, otherwise returns the default.
@@ -227,7 +227,7 @@ class DataLayout {
   std::optional<uint64_t> getTypeIndexBitwidth(Type t) const;
 
   /// Returns the specified endianness.
-  Attribute getEndiannesss() const;
+  Attribute getEndianness() const;
 
   /// Returns the memory space used for AllocaOps.
   Attribute getAllocaMemorySpace() const;
diff --git a/mlir/include/mlir/Interfaces/DataLayoutInterfaces.td b/mlir/include/mlir/Interfaces/DataLayoutInterfaces.td
@@ -132,7 +132,7 @@ def DataLayoutSpecInterface : AttrInterface<"DataLayoutSpecInterface", [DLTIQuer
     InterfaceMethod<
       /*description=*/"Returns the endianness identifier.",
       /*retTy=*/"::mlir::StringAttr",
-      /*methodName=*/"getEndiannesssIdentifier",
+      /*methodName=*/"getEndiannessIdentifier",
       /*args=*/(ins "::mlir::MLIRContext *":$context)
     >,
     InterfaceMethod<
@@ -462,11 +462,11 @@ def DataLayoutOpInterface : OpInterface<"DataLayoutOpInterface"> {
                       "using the relevant entries. The data layout object "
                       "can be used for recursive queries.",
       /*retTy=*/"::mlir::Attribute",
-      /*methodName=*/"getEndiannesss",
+      /*methodName=*/"getEndianness",
       /*args=*/(ins "::mlir::DataLayoutEntryInterface":$entry),
       /*methodBody=*/"",
       /*defaultImplementation=*/[{
-        return ::mlir::detail::getDefaultEndiannesss(entry);
+        return ::mlir::detail::getDefaultEndianness(entry);
       }]
     >,
     StaticInterfaceMethod<
diff --git a/mlir/include/mlir/Transforms/Passes.td b/mlir/include/mlir/Transforms/Passes.td
@@ -19,7 +19,7 @@ include "mlir/Rewrite/PassUtil.td"
 def Canonicalizer : Pass<"canonicalize"> {
   let summary = "Canonicalize operations";
   let description = [{
-    This pass performs various types of canonicalization over a set of
+    This pass performs various types of canonicalizations over a set of
     operations by iteratively applying the canonicalization patterns of all
     loaded dialects until either a fixpoint is reached or the maximum number of
     iterations/rewrites is exhausted. Canonicalization is best-effort and does
@@ -106,7 +106,7 @@ def RemoveDeadValues : Pass<"remove-dead-values"> {
     (A) Removes function arguments that are not live,
     (B) Removes function return values that are not live across all callers of
     the function,
-    (C) Removes unnecessary operands, results, region arguments, and region
+    (C) Removes unneccesary operands, results, region arguments, and region
     terminator operands of region branch ops, and,
     (D) Removes simple and region branch ops that have all non-live results and
     don't affect memory in any way,
@@ -412,7 +412,7 @@ def SROA : Pass<"sroa"> {
   let summary = "Scalar Replacement of Aggregates";
   let description = [{
     Scalar Replacement of Aggregates. Replaces allocations of aggregates into
-    independent allocations of its elements.
+    independant allocations of its elements.
 
     Allocators must implement `DestructurableAllocationOpInterface` to provide
     the list of memory slots for which destructuring should be attempted.
diff --git a/mlir/lib/Conversion/GPUToNVVM/WmmaOpsToNvvm.cpp b/mlir/lib/Conversion/GPUToNVVM/WmmaOpsToNvvm.cpp
@@ -305,7 +305,7 @@ static Value createMinMaxF(OpBuilder &builder, Location loc, Value lhs,
   if (auto vecType = dyn_cast<VectorType>(lhs.getType()))
     i1Type = VectorType::get(vecType.getShape(), i1Type);
   Value cmp = builder.create<LLVM::FCmpOp>(
-      loc, i1Type, isMin ? LLVM::FCmpPredicate::old : LLVM::FCmpPredicate::ogt,
+      loc, i1Type, isMin ? LLVM::FCmpPredicate::olt : LLVM::FCmpPredicate::ogt,
       lhs, rhs);
   Value sel = builder.create<LLVM::SelectOp>(loc, cmp, lhs, rhs);
   Value isNan = builder.create<LLVM::FCmpOp>(
diff --git a/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp b/mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp
@@ -316,7 +316,7 @@ static omp::DeclareReductionOp declareReduction(PatternRewriter &builder,
           reduction, {arith::CmpFPredicate::OLT, arith::CmpFPredicate::OLE},
           {arith::CmpFPredicate::OGT, arith::CmpFPredicate::OGE}, isMin) ||
       matchSelectReduction<LLVM::FCmpOp, LLVM::SelectOp>(
-          reduction, {LLVM::FCmpPredicate::old, LLVM::FCmpPredicate::ole},
+          reduction, {LLVM::FCmpPredicate::olt, LLVM::FCmpPredicate::ole},
           {LLVM::FCmpPredicate::ogt, LLVM::FCmpPredicate::oge}, isMin)) {
     return createDecl(builder, symbolTable, reduce, reductionIndex,
                       minMaxValueForFloat(type, !isMin));
diff --git a/mlir/lib/Dialect/Affine/IR/AffineOps.cpp b/mlir/lib/Dialect/Affine/IR/AffineOps.cpp
@@ -637,7 +637,7 @@ static int64_t getLargestKnownDivisor(AffineExpr e, ArrayRef<Value> operands) {
   // We simply exploit information from loop IVs.
   // We don't need to use mlir::getLargestKnownDivisorOfValue since the other
   // desired simplifications are expected to be part of other
-  // canonicalization. Also, mlir::getLargestKnownDivisorOfValue is part of the
+  // canonicalizations. Also, mlir::getLargestKnownDivisorOfValue is part of the
   // LoopAnalysis library.
   Value operand = operands[dimExpr.getPosition()];
   int64_t operandDivisor = 1;
diff --git a/mlir/lib/Dialect/Affine/Utils/Utils.cpp b/mlir/lib/Dialect/Affine/Utils/Utils.cpp
@@ -531,7 +531,7 @@ void mlir::affine::normalizeAffineParallel(AffineParallelOp op) {
                               /*symbolCount=*/lbMap.getNumSymbols(), expr);
 
     // Use an 'affine.apply' op that will be simplified later in subsequent
-    // canonicalization.
+    // canonicalizations.
     OperandRange lbOperands = op.getLowerBoundsOperands();
     OperandRange dimOperands = lbOperands.take_front(nDims);
     OperandRange symbolOperands = lbOperands.drop_front(nDims);
diff --git a/mlir/lib/Dialect/ArmSME/Transforms/VectorLegalization.cpp b/mlir/lib/Dialect/ArmSME/Transforms/VectorLegalization.cpp
@@ -507,7 +507,7 @@ struct LegalizeMultiTileTransferWriteAsStoreLoop
 };
 
 //===----------------------------------------------------------------------===//
-// ArmSME-specific fixup canonicalization/folds
+// ArmSME-specific fixup canonicalizations/folds
 //===----------------------------------------------------------------------===//
 
 /// Folds an extract from a 3D `vector.create_mask` (which is a vector of
diff --git a/mlir/lib/Dialect/DLTI/DLTI.cpp b/mlir/lib/Dialect/DLTI/DLTI.cpp
@@ -254,8 +254,8 @@ DataLayoutSpecAttr::combineWith(ArrayRef<DataLayoutSpecInterface> specs) const {
 }
 
 StringAttr
-DataLayoutSpecAttr::getEndiannesssIdentifier(MLIRContext *context) const {
-  return Builder(context).getStringAttr(DLTIDialect::kDataLayoutEndiannesssKey);
+DataLayoutSpecAttr::getEndiannessIdentifier(MLIRContext *context) const {
+  return Builder(context).getStringAttr(DLTIDialect::kDataLayoutEndiannessKey);
 }
 
 StringAttr
@@ -490,9 +490,9 @@ dlti::query(Operation *op, ArrayRef<DataLayoutEntryKey> keys, bool emitError) {
 }
 
 constexpr const StringLiteral mlir::DLTIDialect::kDataLayoutAttrName;
-constexpr const StringLiteral mlir::DLTIDialect::kDataLayoutEndiannesssKey;
-constexpr const StringLiteral mlir::DLTIDialect::kDataLayoutEndiannesssBig;
-constexpr const StringLiteral mlir::DLTIDialect::kDataLayoutEndiannesssLittle;
+constexpr const StringLiteral mlir::DLTIDialect::kDataLayoutEndiannessKey;
+constexpr const StringLiteral mlir::DLTIDialect::kDataLayoutEndiannessBig;
+constexpr const StringLiteral mlir::DLTIDialect::kDataLayoutEndiannessLittle;
 
 namespace {
 class TargetDataLayoutInterface : public DataLayoutDialectInterface {
@@ -502,16 +502,16 @@ class TargetDataLayoutInterface : public DataLayoutDialectInterface {
   LogicalResult verifyEntry(DataLayoutEntryInterface entry,
                             Location loc) const final {
     StringRef entryName = entry.getKey().get<StringAttr>().strref();
-    if (entryName == DLTIDialect::kDataLayoutEndiannesssKey) {
+    if (entryName == DLTIDialect::kDataLayoutEndiannessKey) {
       auto value = llvm::dyn_cast<StringAttr>(entry.getValue());
       if (value &&
-          (value.getValue() == DLTIDialect::kDataLayoutEndiannesssBig ||
-           value.getValue() == DLTIDialect::kDataLayoutEndiannesssLittle))
+          (value.getValue() == DLTIDialect::kDataLayoutEndiannessBig ||
+           value.getValue() == DLTIDialect::kDataLayoutEndiannessLittle))
         return success();
       return emitError(loc) << "'" << entryName
                             << "' data layout entry is expected to be either '"
-                            << DLTIDialect::kDataLayoutEndiannesssBig << "' or '"
-                            << DLTIDialect::kDataLayoutEndiannesssLittle << "'";
+                            << DLTIDialect::kDataLayoutEndiannessBig << "' or '"
+                            << DLTIDialect::kDataLayoutEndiannessLittle << "'";
     }
     if (entryName == DLTIDialect::kDataLayoutAllocaMemorySpaceKey ||
         entryName == DLTIDialect::kDataLayoutProgramMemorySpaceKey ||
