[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

771–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

  */
 MLIR_CAPI_EXPORTED MlirStringRef
 mlirStringRefCreateFromCString(const char *str);
 
 /** A callback for returning string references.
  *
  * 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 *);
 
 //===----------------------------------------------------------------------===//
 // MlirLogicalResult.
 //===----------------------------------------------------------------------===//
 

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

 class ModuleOp;
 template <typename T>
 class OperationPass;
 
 /// Creates a pass to emulate `gpu.launch_func` call in LLVM dialect and lower
 /// 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.
 std::unique_ptr<OperationPass<ModuleOp>> createLowerHostCodeToLLVMPass();
 
 /// Creates a pass to convert SPIR-V operations to the LLVMIR dialect.
 std::unique_ptr<OperationPass<ModuleOp>> createConvertSPIRVToLLVMPass();
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_SPIRVTOLLVM_SPIRVTOLLVMPASS_H

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

let assemblyFormat =
     "$acc `,` $src1 `,` $src2 attr-dict `:` type($src1) `to` type($dst)";
 }
 
 def SmmlaOp : ArmSVE_Op<"smmla",
                 [NoSideEffect,
                 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.
 
     This function maps to the SMMLA instruction, and it takes signless integer
     operands that the operation interprets as signed. It partitions the inputs
     into 128-bit quadwords, with the first input containing a row-by-row 2×2
     matrix of 32-bit integers, the second input containing a row-by-row 2×8
     matrix of 8-bit integers, and the third input containing a column-by-column
let assemblyFormat =
     "$acc `,` $src1 `,` $src2 attr-dict `:` type($src1) `to` type($dst)";
 }
 
 def UmmlaOp : ArmSVE_Op<"ummla",
                 [NoSideEffect,
                 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.
 
     This function maps to the UMMLA instruction, and it takes signless integer
     operands that the operation interprets as unsigned. It partitions the inputs
     into 128-bit quadwords, with the first input containing a row-by-row 2×2
     matrix of 32-bit integers, the second input containing a row-by-row 2×8
     matrix of 8-bit integers, and the third input containing a column-by-column

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

 //
 // All values are semantically created with a reference count of +1 and it is
 // the responsibility of the last async value user to drop reference count.
 //
 // Async values created when:
 //   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.
 //
 // Reference counting operations can be added to the IR using automatic
 // reference count pass, that relies on liveness analysis to find the last uses
 // of all reference counted values and automatically inserts
 // `drop_ref` operations.

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

let description = [{
     to a simple forwarder.
 
     ```mlir
     %res = scf.while (%arg1 = %init1) : (f32) -> f32 {
       /* "Before" region.
        * 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. */
       scf.condition(%condition) %next : f32
 
     } do {
     ^bb0(%arg2: f32):
       /* "After" region.
let description = [{
 
     ```mlir
     %res = scf.while (%arg1 = %init1) : (f32) -> i64 {
       /* One can perform some computations, e.g., necessary to evaluate the
        * condition, in the "before" region and forward their results to the
        * "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.
        * The types must match the arguments of the "after" region as well as
        * those of the `scf.while` results. */
       scf.condition(%condition) %shared : i64
 
     } do {

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

let description = [{
     Result Type and the type of the operands must both be integer scalar or
     integer vector types. Result Type and operand types must have the same number
     of components with the same component width. Results are computed per
     component.
 
     <!-- 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
     %2 = spv.GLSL.UClamp %x, %min, %max : i32
     %3 = spv.GLSL.UClamp %x, %min, %max : vector<3xui16>
     ```
   }];

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

let description = [{
     global_memref "private" @x : memref<2xf32> = dense<0.0,2.0>
 
     // Declaration of an external variable.
     global_memref "private" @y : memref<4xi32>
 
     // 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>
     ```
   }];
 
   let arguments = (ins
       SymbolNameAttr:$sym_name,
       OptionalAttr<StrAttr>:$sym_visibility,
       TypeAttr:$type,

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

let description = [{
 
     This pass also changes the type of block arguments, which requires that all
     successor arguments of predecessors be converted. This is achieved by
     rewriting terminators based on the information provided by the
     `BranchOpInterface`.
     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. 
   }];
   let constructor = "mlir::createFuncBufferizePass()";
 }
 
 def TensorConstantBufferize : Pass<"tensor-constant-bufferize", "ModuleOp"> {
   let summary = "Bufferize tensor constants.";

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

 
 #include "mlir/Dialect/Quant/FakeQuantSupport.h"
 #include "mlir/Dialect/Quant/UniformSupport.h"
 
 namespace mlir {
 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
 /// for 16 or 32-bit scale widths.
 void computeMultiplierAndShift(double scale, int32_t &multiplier,
                                int32_t &shift, int32_t scaleWidth);
 
 //// Builds ConvOpQuantizationAttr from input and weight.

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

Vector_Op<"extract_map", [NoSideEffect]>,
     Arguments<(ins AnyVector:$vector, Variadic<Index>:$ids)>,
     Results<(outs AnyVector)> {
   let summary = "vector extract map operation";
   let description = [{
     Takes an N-D vector and extracts a sub-part of the vector starting at id
     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.
     For example if the source type is `vector<64x4x32xf32>` and the destination
     type is `vector<4x4x2xf32>`, the first id maps to dimension 0 and the second
     id to dimension 2.
 
     Similarly to vector.tuple_get, this operation is used for progressive

mlir/include/mlir/IR/ImplicitLocOpBuilder.h

 
 #ifndef MLIR_IR_IMPLICITLOCOPBUILDER_H
 #define MLIR_IR_IMPLICITLOCOPBUILDER_H
 
 #include "mlir/IR/Builders.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 {
 public:
   /// Create an ImplicitLocOpBuilder using the insertion point and listener from
   /// an existing OpBuilder.
   ImplicitLocOpBuilder(Location loc, const OpBuilder &builder)
       : OpBuilder(builder), curLoc(loc) {}
public:
   }
 
 private:
   Location curLoc;
 };
 
 } // namespace mlir
 
-#endif // MLIR_IR_IMPLICITLOCOPBUILDER_H
+#endif // MLIR_IR_IMPLICITLOCOPBUILDER_H
 

mlir/include/mlir/IR/OpDefinition.h

static LogicalResult verifyTrait(Operation *op) {
                << TerminatorOpType::getOperationName() << '\'';
       }
 
       return success();
     }
 
     /// 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,
                                  Location loc) {
       ::mlir::impl::ensureRegionTerminator(region, builder, loc,
                                            buildTerminator);
     }
     static void ensureTerminator(Region &region, OpBuilder &builder,

mlir/include/mlir/Pass/PassRegistry.h

public:
   LogicalResult
   addToPipeline(OpPassManager &pm,
                 function_ref<LogicalResult(const Twine &)> errorHandler) const;
 
 private:
   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.
   PassNameCLParser(StringRef arg, StringRef description);
   ~PassNameCLParser();
 
   /// Returns true if this parser contains any valid options to add.
   bool hasAnyOccurrences() const;

mlir/include/mlir/Support/IndentedOstream.h

public:
   }
 
   /// Decreases the indent and returning this raw_indented_ostream.
   raw_indented_ostream &unindent() {
     currentIndent = std::max(0, currentIndent - indentSize);
     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;
     currentIndent = with;
     return *this;
   }
 
 private:

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

 
 protected:
   /// Mappings between original and translated values, used for lookups.
   llvm::StringMap<llvm::Function *> functionMapping;
   DenseMap<Value, llvm::Value *> valueMapping;
   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;
 };
 
 } // namespace LLVM
 } // namespace mlir
 
 #endif // MLIR_TARGET_LLVMIR_MODULETRANSLATION_H

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

 /// Utility class to translate MLIR LLVM dialect types to LLVM IR. Stores the
 /// translation state, in particular any identified structure types that can be
 /// reused in further translation.
 class TypeToLLVMIRTranslator {
 public:
   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.
   unsigned getPreferredAlignment(Type type, const llvm::DataLayout &layout);
 
   /// Translates the given MLIR LLVM dialect type to LLVM IR.
   llvm::Type *translateType(Type type);
 

mlir/include/mlir/Transforms/Bufferize.h

 public:
   BufferizeTypeConverter();
 };
 
 /// Marks ops used by bufferization for type conversion materializations as
 /// "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
 /// populateEliminateBufferizeMaterializationsPatterns.
 void populateBufferizeMaterializationLegality(ConversionTarget &target);
 
 /// Populate patterns to eliminate bufferize materializations.
 ///
 /// In particular, these are the tensor_load/tensor_to_memref ops.
 void populateEliminateBufferizeMaterializationsPatterns(
     MLIRContext *context, BufferizeTypeConverter &typeConverter,
     OwningRewritePatternList &patterns);
 
 } // end namespace mlir
 
 #endif // MLIR_TRANSFORMS_BUFFERIZE_H

mlir/lib/Analysis/AffineStructures.cpp

FlatAffineConstraints::findIntegerSample() const {
   return Simplex(*this).findIntegerSample();
 }
 
 /// Helper to evaluate an affine expression at a point.
 /// The expression is a list of coefficients for the dimensions followed by the
 /// 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];
   return value;
 }
 
 /// A point satisfies an equality iff the value of the equality at the
 /// expression is zero, and it satisfies an inequality iff the value of the

mlir/lib/Bindings/Python/IRModules.cpp

if (index < 0 || index >= dunderLen()) {
       throw SetPyError(PyExc_IndexError,
                        "attempt to access out of bounds region");
     }
     MlirRegion region = mlirOperationGetRegion(operation->get(), index);
     return PyRegion(operation, region);
   }
 
   static void bind(py::module &m) {
-    py::class_<PyRegionList>(m, "ReqionSequence")
+    py::class_<PyRegionList>(m, "RegionSequence")
         .def("__len__", &PyRegionList::dunderLen)
         .def("__getitem__", &PyRegionList::dunderGetItem);
   }
 
 private:
   PyOperationRef operation;
 };
 

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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/Passes.h"

mlir/lib/Conversion/GPUCommon/ConvertKernelFuncToBlob.cpp

const llvm::Target *target =
         llvm::TargetRegistry::lookupTarget("", triple, error);
     if (target == nullptr) {
       emitError(loc, "cannot initialize target triple");
       return {};
     }
     targetMachine.reset(target->createTargetMachine(triple.str(), targetChip,
                                                     features, {}, {}));
     if (targetMachine == nullptr) {
-      emitError(loc, "connot initialize target machine");
+      emitError(loc, "cannot initialize target machine");
       return {};
     }
   }
 
   llvmModule.setDataLayout(targetMachine->createDataLayout());
 
   auto targetISA = translateModuleToISA(llvmModule, *targetMachine);
 

mlir/lib/Conversion/PDLToPDLInterp/Predicate.h

PredicateUniquer() {
     registerSingletonStorageType<TypeQuestion>();
   }
 };
 
 //===----------------------------------------------------------------------===//
 // PredicateBuilder
 //===----------------------------------------------------------------------===//
 
-/// This class provides utilties for constructing predicates.
+/// This class provides utilities for constructing predicates.
 class PredicateBuilder {
 public:
   PredicateBuilder(PredicateUniquer &uniquer, MLIRContext *ctx)
       : uniquer(uniquer), ctx(ctx) {}
 
   //===--------------------------------------------------------------------===//
   // Positions
   //===--------------------------------------------------------------------===//

mlir/lib/Conversion/SPIRVToLLVM/ConvertLaunchFuncToLLVMCalls.cpp

matchAndRewrite(gpu::LaunchFuncOp launchOp, ArrayRef<Value> operands,
 
     // Traverse kernel operands that were converted to MemRefDescriptors. For
     // each operand, create a global variable and copy data from operand to it.
     Location loc = launchOp.getLoc();
     SmallVector<CopyInfo, 4> copyInfo;
     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>();
       if (!memRefType)
         return failure();
 
       // Calculate the size of the memref and get the pointer to the allocated
       // buffer.

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

AsyncParallelForRewrite::matchAndRewrite(scf::ParallelOp op,
   using LoopBuilder = std::function<LoopBodyBuilder(size_t loopIdx)>;
 
   // Builds inner loop nest inside async.execute operation that does all the
   // work concurrently.
   LoopBuilder workLoopBuilder = [&](size_t loopIdx) -> LoopBodyBuilder {
     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],
             op.step()[loopIdx + 1], ValueRange(), workLoopBuilder(loopIdx + 1));
         b.create<scf::YieldOp>(loc);
         return;
       }
 

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

bool isOpaque() const {
       assert(isIdentified() &&
              "'opaque' bit is meaningless on literal structs");
       return opaque;
     }
 
     /// 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;
     }
 
     /// Returns the list of type contained in the key of a literal struct.
     ArrayRef<Type> getTypeList() const {
       assert(!isIdentified() &&
              "identified struct key cannot have a type list");
       return types;
LLVMStructTypeStorage(const KeyTy &key) {
     // If the struct is being constructed directly as opaque, mark it as
     // initialized.
     llvm::Bitfield::set<MutableFlagInitialized>(identifiedBodySizeAndFlags,
                                                 key.isOpaque());
     llvm::Bitfield::set<MutableFlagOpaque>(identifiedBodySizeAndFlags,
                                            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,
                                           const KeyTy &key) {
     return new (allocator.allocate<LLVMStructTypeStorage>())
         LLVMStructTypeStorage(key.copyIntoAllocator(allocator));
   }
 

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

for (auto dependence : fusableDependences.lookup(op)) {
       if (!consumerLoopToProducerLoop) {
         op.emitRemark("failed to get map from consumer loop to producer loop");
         return {};
       }
       // todo: This condition is only an implementation limitation. When fusing
       // 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 {};
       }
 
       std::set<unsigned> candidates;
       for (AffineExpr expr : consumerLoopToProducerLoop->getResults()) {
         unsigned position = expr.cast<AffineDimExpr>().getPosition();
for (auto operandIndex :
         return FusableOpDependencesTy{};
       }
 
       unsigned consumerIdx =
           fusableDependence->indexingOpView->getOperandNumber();
       AffineMap consumerMap = op.getIndexingMap(consumerIdx);
       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{};
       }
 
       // Check if the producer is already a fusion candidate. Cannot fuse this
       // dependence if it has a different indexing map when used in the
       // consumer.
       if (fusedProducerIndexingMap.count(producerOp.getOperation()) &&

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

public:
   /// Adds a new, initially empty, set. Returns its index.
   unsigned addSet() {
     unsigned s = latSets.size();
     latSets.emplace_back(SmallVector<unsigned, 16>());
     return s;
   }
 
   /// 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) {
     unsigned p = latPoints.size();
     llvm::BitVector nb = llvm::BitVector(latPoints[p0].bits);
     nb |= latPoints[p1].bits;
     unsigned e = addExp(kind, latPoints[p0].exp, latPoints[p1].exp);
     latPoints.push_back(LatPoint(nb, e));

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

static LogicalResult verify(OperationOp op) {
   auto opResults = op.results();
   if (resultTypes.size() != opResults.size()) {
     return op.emitOpError() << "expected the same number of result values and "
                                "result type constraints, got "
                             << opResults.size() << " results and "
                             << 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)))
       return failure();
   }
 
   return verifyHasBindingUseInMatcher(op, "`pdl.operation` or `pdl.rewrite`");
 }

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

struct spirv::detail::StructTypeStorage : public TypeStorage {
   ///   - an ArrayRef<Type> for member types;
   ///   - an ArrayRef<StructType::OffsetInfo> for member offset info;
   ///   - an ArrayRef<StructType::MemberDecorationInfo> for member decoration
   ///     info.
   ///
   /// 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>,
                  ArrayRef<StructType::MemberDecorationInfo>>;
 
   /// For identified structs, return true if the given key contains the same
   /// identifier.
   ///

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

 //===- ModuleCombiner.cpp - MLIR SPIR-V Module Combiner ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements the the SPIR-V module combiner library.
+// This file implements the SPIR-V module combiner library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/SPIRV/Linking/ModuleCombiner.h"
 
 #include "mlir/Dialect/SPIRV/IR/SPIRVDialect.h"
 #include "mlir/Dialect/SPIRV/IR/SPIRVOps.h"
 #include "mlir/IR/Builders.h"

 /// Computes a hash code to represent the argument SymbolOpInterface based on
 /// all the Op's attributes except for the symbol name.
 ///
 /// \return the hash code computed from the Op's attributes as described above.
 ///
 /// 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());
 
   for (auto attr : symbolOp->getAttrs()) {
     if (attr.first == SymbolTable::getSymbolAttrName())
       continue;
     hashCode = llvm::hash_combine(hashCode, attr);
combine(llvm::MutableArrayRef<spirv::ModuleOp> modules,
   auto combinedModule = combinedModuleBuilder.create<spirv::ModuleOp>(
       modules[0].getLoc(), addressingModel, memoryModel);
   combinedModuleBuilder.setInsertionPointToStart(&*combinedModule.getBody());
 
   // In some cases, a symbol in the (current state of the) combined module is
   // 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;
 
   for (auto module : modules) {
     if (module.addressing_model() != addressingModel ||
         module.memory_model() != memoryModel) {
       module.emitError(
           "input modules differ in addressing model and/or memory model");
       return nullptr;
     }
 
     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.
     for (auto &op : combinedModule.getBlock().without_terminator()) {
       if (auto symbolOp = dyn_cast<SymbolOpInterface>(op)) {
         StringRef oldSymName = symbolOp.getName();
 
         if (!isa<FuncOp>(op) &&
for (auto &op : combinedModule.getBlock().without_terminator()) {
             module.emitError("unable to find original ModuleOp for symbol ")
                 << oldSymName;
             return nullptr;
           }
 
           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.
           symNameToModuleMap[newSymName] = originalModule;
         }
       }
     }
 

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

LogicalResult matchAndRewrite(DimOp dim,
     // was not mutated.
     rewriter.setInsertionPointAfter(reshape);
     rewriter.replaceOpWithNewOp<LoadOp>(dim, reshape.shape(),
                                         llvm::makeArrayRef({dim.index()}));
     return success();
   }
 };
 
-/// 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;
 
   LogicalResult matchAndRewrite(DimOp dimOp,
                                 PatternRewriter &rewriter) const override {
     auto castOp = dimOp.memrefOrTensor().getDefiningOp<CastOpTy>();
     if (!castOp)

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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // 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.
 //
 //===----------------------------------------------------------------------===//
 
 #include "PassDetail.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Dialect/StandardOps/Transforms/Passes.h"
 #include "mlir/IR/PatternMatch.h"

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

 // If lower=[b, c], target=[a, b, c], [b, c] reshaped into [1, b, c].
 // If lower=[a], target=[a, a], [a] reshaped into [1, a] instead of [a, 1].
 // If lower=[a], target=[a, b, a], [a] reshaped into [1, 1, a].
 // If lower=[], target=[a, b, c], [] reshaped into [1, 1, 1].
 
 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();
 
   reshapeOutputShape.assign(higherRank, 1);
 
   int64_t higherLeftIndex = 0;
   int64_t higherRightIndex = higherRank;
   int64_t lowerLeftIndex = 0;

mlir/lib/Dialect/Vector/VectorOps.cpp

LogicalResult matchAndRewrite(ExtractStridedSliceOp op,
     auto broadcast = op.vector().getDefiningOp<BroadcastOp>();
     if (!broadcast)
       return failure();
     auto srcVecType = broadcast.source().getType().dyn_cast<VectorType>();
     unsigned srcRrank = srcVecType ? srcVecType.getRank() : 0;
     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;
     for (unsigned i = 0; i < srcRrank; i++) {
       if (srcVecType.getDimSize(i) != dstVecType.getDimSize(i + rankDiff)) {
         lowerDimMatch = false;
         break;
       }

mlir/lib/IR/AsmPrinter.cpp

void print(Operation *op) {
 
     // Otherwise print with the generic assembly form.
     printGenericOp(op);
   }
 
 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,
                     /*printBlockTerminators=*/true);
     }
 
     // Visit all the types used in the operation.
     for (Type type : op->getOperandTypes())

 void AliasInitializer::visit(Type type) {
   if (!visitedTypes.insert(type).second)
     return;
 
   // Try to generate an alias for this type.
   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())
       visit(input);
     for (auto result : funcType.getResults())
       visit(result);
   } else if (auto shapedType = type.dyn_cast<ShapedType>()) {
     visit(shapedType.getElementType());

mlir/lib/Rewrite/ByteCode.h

 private:
   /// Execute the given byte code starting at the provided instruction `inst`.
   /// `matches` is an optional field provided when this function is executed in
   /// a matching context.
   void executeByteCode(const ByteCodeField *inst, PatternRewriter &rewriter,
                        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
   std::vector<const void *> uniquedData;
 
   /// A vector containing the generated bytecode for the matcher.
   SmallVector<ByteCodeField, 64> matcherByteCode;
 

mlir/lib/Target/SPIRV/Serialization.cpp

if (auto ptrType = type.dyn_cast<spirv::PointerType>()) {
     }
   }
   return false;
 }
 
 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);
 }
 
 LogicalResult
 Serializer::processTypeImpl(Location loc, Type type, uint32_t &typeID,
                             llvm::SetVector<StringRef> &serializationCtx) {
   typeID = getTypeID(type);

mlir/lib/Transforms/BufferUtils.cpp

 //===- BufferUtils.cpp - buffer transformation utilities ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements utilties for buffer optimization passes.
+// This file implements utilities for buffer optimization passes.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Transforms/BufferUtils.h"
 #include "PassDetail.h"
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Operation.h"

mlir/lib/Transforms/Utils/FoldUtils.cpp

static Operation *materializeConstant(Dialect *dialect, OpBuilder &builder,
 
   // Ask the dialect to materialize a constant operation for this value.
   if (auto *constOp = dialect->materializeConstant(builder, value, type, loc)) {
     assert(insertPt == builder.getInsertionPoint());
     assert(matchPattern(constOp, m_Constant()));
     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.
   //
   // The special case is needed because in the interim state while we are
   // splitting out those dialects from std, the std dialect depends on the
   // tensor dialect, which makes it impossible for the tensor dialect to use
   // std.constant (it would be a cyclic dependency) as part of its
   // materializeConstant hook.

mlir/lib/Transforms/Utils/LoopUtils.cpp

 /// lexicographically increasing order on the vector of loop indices. This
 /// function will return failure when any dependence component is negative along
 /// any of `origLoops`.
 LogicalResult
 checkTilingLegality(MutableArrayRef<mlir::AffineForOp> origLoops) {
   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) {
   // Check if the supplied for op's are all successively nested.
   assert(!input.empty() && "no loops in input band");
   assert(input.size() == tileSizes.size() && "Too few/many tile sizes");
 
   assert(isPerfectlyNested(input) && "input loops not perfectly nested");

mlir/lib/Transforms/Utils/RegionUtils.cpp

for (int operand : llvm::seq<int>(0, lhsIt->getNumOperands())) {
       // Otherwise, these operands must have the same logical order within the
       // parent block.
       if (leaderData.getOrderOf(lhsOperand) != blockData.getOrderOf(rhsOperand))
         return failure();
     }
 
     // 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
     if (rhsIt->isUsedOutsideOfBlock(mergeBlock) ||
         lhsIt->isUsedOutsideOfBlock(leaderBlock)) {
       return failure();
     }
   }