[mlir] NFC: fix trivial typos

[kiszk]

Summary

fix typo under include and lib directories

[herhut]

Thanks for fixing these. Just some remarks while looking through the changes.

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

772

While at it, this could be a two line string.

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

1464

This elides the .

mlir/lib/Dialect/StandardOps/Transforms/ExpandOps.cpp

1

Also drop the 0 from 0to?

[kiszk]

Thank you for your comments. I addressed the comments.

mlir/include/mlir-c/Support.h

  *
  * This function is called back by the functions that need to return a reference
  * to the portion of the string with the following arguments:
- *   - an MlirStringRef represening the current portion of the string
+ *   - an MlirStringRef representing the current portion of the string
  *   - a pointer to user data forwarded from the printing call.
  */
 typedef void (*MlirStringCallback)(MlirStringRef, void *);

mlir/include/mlir/Conversion/SPIRVToLLVM/SPIRVToLLVMPass.h

 /// the host module code to LLVM.
 ///
 /// This transformation creates a sequence of global variables that are later
-/// linked to the varables in the kernel module, and a series of copies to/from
+/// linked to the variables in the kernel module, and a series of copies to/from
 /// them to emulate the memory transfer from the host or to the device sides. It
 /// also converts the remaining Standard dialect into LLVM dialect, emitting C
 /// wrappers.

mlir/include/mlir/Dialect/ArmSVE/ArmSVE.td

                 AllTypesMatch<["src1", "src2"]>,
                 AllTypesMatch<["acc", "dst"]>,
               ]> {
-  let summary = "Matrix-matrix mutiply and accumulate op";
+  let summary = "Matrix-matrix multiply and accumulate op";
   let description = [{
     SMMLA: Signed integer matrix multiply-accumulate.
 

                 AllTypesMatch<["src1", "src2"]>,
                 AllTypesMatch<["acc", "dst"]>,
               ]> {
-  let summary = "Matrix-matrix mutiply and accumulate op";
+  let summary = "Matrix-matrix multiply and accumulate op";
   let description = [{
     UMMLA: Unsigned integer matrix multiply-accumulate.
 

mlir/include/mlir/Dialect/Async/IR/AsyncOps.td

 //   1. Operation returns async result (e.g. the result of an `async.execute`).
 //   2. Async value passed in as a block argument.
 //
-// It is the responsiblity of the async value user to extend the lifetime by
+// It is the responsibility of the async value user to extend the lifetime by
 // adding a +1 reference, if the reference counted value captured by the
 // asynchronously executed region (`async.execute` operation), and drop it after
 // the last nested use.

mlir/include/mlir/Dialect/SCF/SCFOps.td

        * In a "do-while" loop, this region contains the loop body. */
       %next = call @payload(%arg1) : (f32) -> f32
 
-      /* And also evalutes the condition. */
+      /* And also evaluates the condition. */
       %condition = call @evaluate_condition(%arg1) : (f32) -> i1
 
       /* Loop through the "after" region. */

        * "after" region. */
       %shared = call @shared_compute(%arg1) : (f32) -> i64
 
-      /* Evalute the condition. */
+      /* Evaluate the condition. */
       %condition = call @evaluate_condition(%arg1, %shared) : (f32, i64) -> i1
 
       /* Forward the result of the shared computation to the "after" region.

mlir/include/mlir/Dialect/SPIRV/IR/SPIRVGLSLOps.td

     <!-- End of AutoGen section -->
     ```
     uclamp-op ::= ssa-id `=` `spv.GLSL.UClamp` ssa-use, ssa-use, ssa-use `:`
-               unsgined-signless-scalar-vector-type
+               unsigned-signless-scalar-vector-type
     ```
     #### Example:
 

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

     // Uninitialized externally visible variable.
     global_memref @z : memref<3xf16> = uninitialized
 
-    // Externally visibile constant variable.
+    // Externally visible constant variable.
     global_memref constant @c : memref<2xi32> = dense<1, 4>
     ```
   }];

mlir/include/mlir/Dialect/StandardOps/Transforms/Passes.td

     As this pass rewrites function operations, it also rewrites the
     corresponding return operations. Other return-like operations that
     implement the `ReturnLike` trait are not rewritten in general, as they
-    require that the correspondign parent operation is also rewritten.
+    require that the corresponding parent operation is also rewritten.
     Finally, this pass fails for unknown terminators, as we cannot decide
     whether they need rewriting. 
   }];

mlir/include/mlir/Dialect/Tosa/Utils/QuantUtils.h

 namespace tosa {
 
 //===----------------------------------------------------------------------===//
-// Utililty functions to support quantization handling in Tosa.
+// Utility functions to support quantization handling in Tosa.
 //===----------------------------------------------------------------------===//
 
 /// From a scale value, computes multiplier and shift values

mlir/include/mlir/Dialect/Vector/VectorOps.td

     along each dimension.
 
     The dimension associated to each element of `ids` used to extract are
-    implicitly deduced from the the destination type. For each dimension the
+    implicitly deduced from the destination type. For each dimension the
     multiplicity is the destination dimension size divided by the source
     dimension size, each dimension with a multiplicity greater than 1 is
     associated to the next id, following ids order.

mlir/include/mlir/IR/ImplicitLocOpBuilder.h

 
 namespace mlir {
 
-/// ImplictLocOpBuilder maintains a 'current location', allowing use of the
+/// ImplicitLocOpBuilder maintains a 'current location', allowing use of the
 /// create<> method without specifying the location.  It is otherwise the same
 /// as OpBuilder.
 class ImplicitLocOpBuilder : public mlir::OpBuilder {

 
 } // namespace mlir
 
-#endif // MLIR_IR_IMPLICITLOCOPBUILDER_H
+#endif // MLIR_IR_IMPLICITLOCOPBUILDER_H
 

mlir/include/mlir/IR/OpDefinition.h

 
     /// Ensure that the given region has the terminator required by this trait.
     /// If OpBuilder is provided, use it to build the terminator and notify the
-    /// OpBuilder litsteners accordingly. If only a Builder is provided, locally
+    /// OpBuilder listeners accordingly. If only a Builder is provided, locally
     /// construct an OpBuilder with no listeners; this should only be used if no
     /// OpBuilder is available at the call site, e.g., in the parser.
     static void ensureTerminator(Region &region, Builder &builder,

mlir/include/mlir/Pass/PassRegistry.h

   std::unique_ptr<detail::PassPipelineCLParserImpl> impl;
 };
 
-/// This class implements a command-line parser spefically for MLIR pass names.
-/// It registers a cl option with a given argument and description that accepts
-/// a comma delimited list of pass names.
+/// This class implements a command-line parser specifically for MLIR pass
+/// names. It registers a cl option with a given argument and description that
+/// accepts a comma delimited list of pass names.
 class PassNameCLParser {
 public:
   /// Construct a parser with the given command line description.

mlir/include/mlir/Support/IndentedOstream.h

     return *this;
   }
 
-  /// Emits whitespace and sets the indendation for the stream.
+  /// Emits whitespace and sets the indentation for the stream.
   raw_indented_ostream &indent(int with) {
     os.indent(with);
     atStartOfLine = false;

mlir/include/mlir/Target/LLVMIR/ModuleTranslation.h

   DenseMap<Block *, llvm::BasicBlock *> blockMapping;
 
   /// A mapping between MLIR LLVM dialect terminators and LLVM IR terminators
-  /// they are converted to. This allows for conneting PHI nodes to the source
+  /// they are converted to. This allows for connecting PHI nodes to the source
   /// values after all operations are converted.
   DenseMap<Operation *, llvm::Instruction *> branchMapping;
 };

mlir/include/mlir/Target/LLVMIR/TypeTranslation.h

   TypeToLLVMIRTranslator(llvm::LLVMContext &context);
   ~TypeToLLVMIRTranslator();
 
-  /// Returns the perferred alignment for the type given the data layout. Note
+  /// Returns the preferred alignment for the type given the data layout. Note
   /// that this will perform type conversion and store its results for future
   /// uses.
   // TODO: this should be removed when MLIR has proper data layout.

mlir/include/mlir/Transforms/Bufferize.h

 /// "legal" in the given ConversionTarget.
 ///
 /// This function should be called by all bufferization passes using
-/// BufferizeTypeConverter so that materializations work proprely. One exception
+/// BufferizeTypeConverter so that materializations work properly. One exception
 /// is bufferization passes doing "full" conversions, where it can be desirable
 /// for even the materializations to remain illegal so that they are eliminated,
 /// such as via the patterns in

mlir/lib/Analysis/AffineStructures.cpp

 /// constant term.
 static int64_t valueAt(ArrayRef<int64_t> expr, ArrayRef<int64_t> point) {
   assert(expr.size() == 1 + point.size() &&
-         "Dimensionalities of point and expresion don't match!");
+         "Dimensionalities of point and expression don't match!");
   int64_t value = expr.back();
   for (unsigned i = 0; i < point.size(); ++i)
     value += expr[i] * point[i];

mlir/lib/Bindings/Python/IRModules.cpp

   }
 
   static void bind(py::module &m) {
-    py::class_<PyRegionList>(m, "ReqionSequence")
+    py::class_<PyRegionList>(m, "RegionSequence")
         .def("__len__", &PyRegionList::dunderLen)
         .def("__getitem__", &PyRegionList::dunderGetItem);
   }

mlir/lib/CAPI/Transforms/Passes.cpp

-//===- CAPIPasses.cpp - C API for Tranformations Passes -------------------===//
+//===- CAPIPasses.cpp - C API for Transformations Passes ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.

mlir/lib/Conversion/GPUCommon/ConvertKernelFuncToBlob.cpp

     targetMachine.reset(target->createTargetMachine(triple.str(), targetChip,
                                                     features, {}, {}));
     if (targetMachine == nullptr) {
-      emitError(loc, "connot initialize target machine");
+      emitError(loc, "cannot initialize target machine");
       return {};
     }
   }

mlir/lib/Conversion/PDLToPDLInterp/Predicate.h

 // PredicateBuilder
 //===----------------------------------------------------------------------===//
 
-/// This class provides utilties for constructing predicates.
+/// This class provides utilities for constructing predicates.
 class PredicateBuilder {
 public:
   PredicateBuilder(PredicateUniquer &uniquer, MLIRContext *ctx)

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

     auto numKernelOperands = launchOp.getNumKernelOperands();
     auto kernelOperands = operands.take_back(numKernelOperands);
     for (auto operand : llvm::enumerate(kernelOperands)) {
-      // Check if the kernel's opernad is a ranked memref.
+      // Check if the kernel's operand is a ranked memref.
       auto memRefType = launchOp.getKernelOperand(operand.index())
                             .getType()
                             .dyn_cast<MemRefType>();

mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp

     return [&, loopIdx](OpBuilder &b, Location loc, Value iv, ValueRange args) {
       blockInductionVars[loopIdx] = iv;
 
-      // Continute building async loop nest.
+      // Continue building async loop nest.
       if (loopIdx < op.getNumLoops() - 1) {
         b.create<scf::ForOp>(
             loc, blockLowerBounds[loopIdx + 1], blockUpperBounds[loopIdx + 1],

mlir/lib/Dialect/LLVMIR/IR/TypeDetail.h

     /// Returns the identifier of a key for identified structs.
     StringRef getIdentifier() const {
       assert(isIdentified() &&
-             "non-identified struct key canont have an identifier");
+             "non-identified struct key cannot have an identifier");
       return name;
     }
 

                                            key.isOpaque());
   }
 
-  /// Hook into the type unquing infrastructure.
+  /// Hook into the type uniquing infrastructure.
   bool operator==(const KeyTy &other) const { return getKey() == other; };
   static llvm::hash_code hashKey(const KeyTy &key) { return key.hashValue(); }
   static LLVMStructTypeStorage *construct(TypeStorageAllocator &allocator,

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

       // the operation, if the accesses in the producer/consumer are transposes
       // of each other, the loop bounds for the tiled producer can be
       // manipulated accordingly. This requires some additional bookkeeping in
-      // the implementation of tile+fuse that is defered to later.
+      // the implementation of tile+fuse that is deferred to later.
       if (doesTransposeAccess(*consumerLoopToProducerLoop, fusableLoops)) {
         op.emitRemark("unhandled fusion when fusion requires permutation");
         return {};

       if (!consumerMap.isProjectedPermutation()) {
         op.emitRemark(
             "unhandled case where indexing map for fused view in the consumer "
-            "is "
-            "not a projected permuration while fusing at index ")
+            "is not a projected permutation while fusing at index ")
             << operandIndex;
         return FusableOpDependencesTy{};
       }

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

   }
 
   /// Computes a single conjunction of two lattice points by taking the "union"
-  /// of loop indices (effectively constucting a larger "intersection" of those
+  /// of loop indices (effectively constructing a larger "intersection" of those
   /// indices) with a newly constructed tensor (sub)expression of given kind.
   /// Returns the index of the new lattice point.
   unsigned conjLatPoint(Kind kind, unsigned p0, unsigned p1) {

mlir/lib/Dialect/PDL/IR/PDL.cpp

                             << resultTypes.size() << " constraints";
   }
 
-  // If the operation is within a rewrite body and doesn't have type inferrence,
+  // If the operation is within a rewrite body and doesn't have type inference,
   // ensure that the result types can be resolved.
   if (isWithinRewrite && !op.hasTypeInference()) {
     if (failed(verifyResultTypesAreInferrable(op, opResults, resultTypes)))

mlir/lib/Dialect/SPIRV/IR/SPIRVTypes.cpp

   /// An identified struct type is uniqued only by the first part (field 0)
   /// of the key.
   ///
-  /// A literal struct type is unqiued only by the second part (fields 1, 2, and
+  /// A literal struct type is uniqued only by the second part (fields 1, 2, and
   /// 3) of the key. The identifier field (field 0) must be empty.
   using KeyTy =
       std::tuple<StringRef, ArrayRef<Type>, ArrayRef<StructType::OffsetInfo>,

mlir/lib/Dialect/SPIRV/Linking/ModuleCombiner/ModuleCombiner.cpp

 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements the the SPIR-V module combiner library.
+// This file implements the SPIR-V module combiner library.
 //
 //===----------------------------------------------------------------------===//
 

 /// Note: We use the operation's name (not the symbol name) as part of the hash
 /// computation. This prevents, for example, mistakenly considering a global
 /// variable and a spec constant as duplicates because their descriptor set +
-/// binding and spec_id, repectively, happen to hash to the same value.
+/// binding and spec_id, respectively, happen to hash to the same value.
 static llvm::hash_code computeHash(SymbolOpInterface symbolOp) {
   llvm::hash_code hashCode(0);
   hashCode = llvm::hash_combine(symbolOp->getName());

   // renamed in order to maintain the conflicting symbol in the input module
   // being merged. For example, if the conflict is between a global variable in
   // the current combined module and a function in the input module, the global
-  // varaible is renamed. In order to notify listeners of the symbol updates in
+  // variable is renamed. In order to notify listeners of the symbol updates in
   // such cases, we need to keep track of the module from which the renamed
   // symbol in the combined module originated. This map keeps such information.
   DenseMap<StringRef, spirv::ModuleOp> symNameToModuleMap;

     spirv::ModuleOp moduleClone = module.clone();
 
     // In the combined module, rename all symbols that conflict with symbols
-    // from the current input module. This renmaing applies to all ops except
+    // from the current input module. This renaming applies to all ops except
     // for spv.funcs. This way, if the conflicting op in the input module is
     // non-spv.func, we rename that symbol instead and maintain the spv.func in
     // the combined module name as it is.

           symRenameListener(originalModule, oldSymName, newSymName);
 
           // Since the symbol name is updated, there is no need to maintain the
-          // entry that assocaites the old symbol name with the original module.
+          // entry that associates the old symbol name with the original module.
           symNameToModuleMap.erase(oldSymName);
           // Instead, add a new entry to map the new symbol name to the original
           // module in case it gets renamed again later.

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

   }
 };
 
-/// Fold dim of a dim of a cast into the the dim of the source of the tensor
-/// cast.
+/// Fold dim of a dim of a cast into the dim of the source of the tensor cast.
 template <typename CastOpTy>
 struct DimOfCastOp : public OpRewritePattern<DimOp> {
   using OpRewritePattern<DimOp>::OpRewritePattern;

mlir/lib/Dialect/StandardOps/Transforms/ExpandOps.cpp

-//===- StdExpandDivs.cpp - Code to prepare Std for lowring Divs 0to LLVM  -===//
+//===- StdExpandDivs.cpp - Code to prepare Std for lowering Divs to LLVM  -===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.

 //===----------------------------------------------------------------------===//
 //
 // This file Std transformations to expand Divs operation to help for the
-// lowering to LLVM. Currently implemented tranformations are Ceil and Floor
+// lowering to LLVM. Currently implemented transformations are Ceil and Floor
 // for Signed Integers.
 //
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Tosa/Transforms/TosaMakeBroadcastable.cpp

 static void computeReshapeOutput(ArrayRef<int64_t> higherRankShape,
                                  ArrayRef<int64_t> lowerRankShape,
                                  SmallVectorImpl<int64_t> &reshapeOutputShape) {
-  // Intialize new shapes with [1] * higherRank.
+  // Initialize new shapes with [1] * higherRank.
   int64_t higherRank = higherRankShape.size();
   int64_t lowerRank = lowerRankShape.size();
 

mlir/lib/Dialect/Vector/VectorOps.cpp

     auto dstVecType = op.getType().cast<VectorType>();
     unsigned dstRank = dstVecType.getRank();
     unsigned rankDiff = dstRank - srcRrank;
-    // Check if the most inner dimensions of the source of the broacast are the
+    // Check if the most inner dimensions of the source of the broadcast are the
     // same as the destination of the extract. If this is the case we can just
     // use a broadcast as the original dimensions are untouched.
     bool lowerDimMatch = true;

mlir/lib/IR/AsmPrinter.cpp

 private:
   /// Print the given operation in the generic form.
   void printGenericOp(Operation *op) override {
-    // Consider nested opertions for aliases.
+    // Consider nested operations for aliases.
     if (op->getNumRegions() != 0) {
       for (Region &region : op->getRegions())
         printRegion(region, /*printEntryBlockArgs=*/true,

   if (succeeded(generateAlias(type, aliasToType)))
     return;
 
-  // Visit several subtypes that contain types or atttributes.
+  // Visit several subtypes that contain types or attributes.
   if (auto funcType = type.dyn_cast<FunctionType>()) {
     // Visit input and result types for functions.
     for (auto input : funcType.getInputs())

mlir/lib/Rewrite/ByteCode.h

                        PDLByteCodeMutableState &state,
                        SmallVectorImpl<MatchResult> *matches) const;
 
-  /// A vector containing pointers to unqiued data. The storage is intentionally
+  /// A vector containing pointers to uniqued data. The storage is intentionally
   /// opaque such that we can store a wide range of data types. The types of
   /// data stored here include:
   ///  * Attribute, Identifier, OperationName, Type

mlir/lib/Target/SPIRV/Serialization.cpp

 LogicalResult Serializer::processType(Location loc, Type type,
                                       uint32_t &typeID) {
   // Maintains a set of names for nested identified struct types. This is used
-  // to properly serialize resursive references.
+  // to properly serialize recursive references.
   llvm::SetVector<StringRef> serializationCtx;
   return processTypeImpl(loc, type, typeID, serializationCtx);
 }

mlir/lib/Transforms/BufferUtils.cpp

 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements utilties for buffer optimization passes.
+// This file implements utilities for buffer optimization passes.
 //
 //===----------------------------------------------------------------------===//
 

mlir/lib/Transforms/Utils/FoldUtils.cpp

     return constOp;
   }
 
-  // TODO: To faciliate splitting the std dialect (PR48490), have a special case
-  // for falling back to std.constant. Eventually, we will have separate ops
-  // tensor.constant, int.constant, float.constant, etc. that live in their
+  // TODO: To facilitate splitting the std dialect (PR48490), have a special
+  // case for falling back to std.constant. Eventually, we will have separate
+  // ops tensor.constant, int.constant, float.constant, etc. that live in their
   // respective dialects, which will allow each dialect to implement the
   // materializeConstant hook above.
   //

mlir/lib/Transforms/Utils/LoopUtils.cpp

   return success(checkTilingLegalityImpl(origLoops));
 }
 
-/// Check if the input data is valid and wheter tiled code will be legal or not.
+/// Check if the input data is valid and whether tiled code will be legal or
+/// not.
 template <typename t>
 void performPreTilingChecks(MutableArrayRef<AffineForOp> input,
                             ArrayRef<t> tileSizes) {

mlir/lib/Transforms/Utils/RegionUtils.cpp

 
     // If the lhs or rhs has external uses, the blocks cannot be merged as the
     // merged version of this operation will not be either the lhs or rhs
-    // alone (thus semantically incorrect), but some mix dependening on which
+    // alone (thus semantically incorrect), but some mix dependending on which
     // block preceeded this.
     // TODO allow merging of operations when one block does not dominate the
     // other