[mlir] NFC: fix trivial typos

fix typos in comments and documents

Reviewed By: jpienaar

Differential Revision: https://reviews.llvm.org/D90089

Author: kiszk

mlir/docs/OpDefinitions.md

@@ -797,7 +797,7 @@ A custom directive has two main parts: The `UserDirective` and the `Params`. A
 custom directive is transformed into a call to a `print*` and a `parse*` method
 when generating the C++ code for the format. The `UserDirective` is an
 identifier used as a suffix to these two calls, i.e., `custom<MyDirective>(...)`
-would result in calls to `parseMyDirective` and `printMyDirective` wihtin the
+would result in calls to `parseMyDirective` and `printMyDirective` within the
 parser and printer respectively. `Params` may be any combination of variables
 (i.e. Attribute, Operand, Successor, etc.), type directives, and `attr-dict`.
 The type directives must refer to a variable, but that variable need not also
@@ -1515,7 +1515,7 @@ def IntegerType : Test_Type<"TestInteger"> {
 
 The name of the C++ class which gets generated defaults to
 `<classParamName>Type` (e.g. `TestIntegerType` in the above example). This
-can be overridden via the the `cppClassName` field. The field `mnemonic` is
+can be overridden via the `cppClassName` field. The field `mnemonic` is
 to specify the asm name for parsing. It is optional and not specifying it
 will imply that no parser or printer methods are attached to this class.
 
@@ -1554,7 +1554,7 @@ The default storage constructor blindly copies fields by value. It does not
 know anything about the types. In this case, the ArrayRef<int> requires
 allocation with `dims = allocator.copyInto(dims)`.
 
-You can specify the necessary constuctor by specializing the `TypeParameter`
+You can specify the necessary constructor by specializing the `TypeParameter`
 tblgen class:
 
 ```tablegen

mlir/include/mlir-c/Diagnostics.h

@@ -21,7 +21,7 @@
 extern "C" {
 #endif
 
-/** An opaque reference to a dignostic, always owned by the diagnostics engine
+/** An opaque reference to a diagnostic, always owned by the diagnostics engine
  * (context). Must not be stored outside of the diagnostic handler. */
 struct MlirDiagnostic {
   void *ptr;

mlir/include/mlir-c/StandardAttributes.h

@@ -203,7 +203,7 @@ MlirAttribute mlirSymbolRefAttrGet(MlirContext ctx, intptr_t length,
  * live as long as the context in which the attribute lives. */
 MlirStringRef mlirSymbolRefAttrGetRootReference(MlirAttribute attr);
 
-/** Returns the stirng reference to the leaf referenced symbol. The data remains
+/** Returns the string reference to the leaf referenced symbol. The data remains
  * live as long as the context in which the attribute lives. */
 MlirStringRef mlirSymbolRefAttrGetLeafReference(MlirAttribute attr);
 

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

@@ -43,7 +43,7 @@ def Async_ExecuteOp :
     (`async.token` or `async.value`).
 
    `async.execute` operation takes `async.token` dependencies and `async.value`
-    operands separatly, and starts execution of the attached body region only
+    operands separately, and starts execution of the attached body region only
     when all tokens and values become ready.
 
     Example:

mlir/include/mlir/IR/OpBase.td

@@ -913,7 +913,7 @@ class SignlessIntegerAttrBase<I attrValType, string descr> :
   let returnType = [{ ::llvm::APInt }];
 }
 // Base class for signless integer attributes of fixed width that have a
-// correpsonding C++ type.
+// corresponding C++ type.
 class TypedSignlessIntegerAttrBase<I attrValType, string retType, string descr>
     : SignlessIntegerAttrBase<attrValType, descr> {
   let returnType = retType;
@@ -942,7 +942,7 @@ class SignedIntegerAttrBase<SI attrValType, string descr> :
   let returnType = [{ ::llvm::APInt }];
 }
 // Base class for signed integer attributes of fixed width that have a
-// correpsonding C++ type.
+// corresponding C++ type.
 class TypedSignedIntegerAttrBase<SI attrValType, string retType, string descr>
     : SignedIntegerAttrBase<attrValType, descr> {
   let returnType = retType;
@@ -971,7 +971,7 @@ class UnsignedIntegerAttrBase<UI attrValType, string descr> :
   let returnType = [{ ::llvm::APInt }];
 }
 // Base class for unsigned integer attributes of fixed width that have a
-// correpsonding C++ type.
+// corresponding C++ type.
 class TypedUnsignedIntegerAttrBase<UI attrValType, string retType, string descr>
     : UnsignedIntegerAttrBase<attrValType, descr> {
   let returnType = retType;

mlir/include/mlir/Reducer/Passes/OpReducer.h

@@ -8,7 +8,7 @@
 //
 // This file defines the OpReducer class. It defines a variant generator method
 // with the purpose of producing different variants by eliminating a
-// parametarizable type of operations from the  parent module.
+// parameterizable type of operations from the  parent module.
 //
 //===----------------------------------------------------------------------===//
 

mlir/include/mlir/Support/IndentedOstream.h

@@ -51,7 +51,7 @@ class raw_indented_ostream : public raw_ostream {
   }
 
   /// Re-indents by removing the leading whitespace from the first non-empty
-  /// line from every line of the the string, skipping over empty lines at the
+  /// line from every line of the string, skipping over empty lines at the
   /// start.
   raw_indented_ostream &reindent(StringRef str);
 

mlir/integration_test/Dialect/Vector/CPU/test-create-mask-v4i1.mlir

@@ -4,7 +4,7 @@
 // RUN: FileCheck %s
 
 // NOTE: This is similar to test-create-mask.mlir, but with a different length,
-//       because the v4i1 vector specifially exposed bugs in the LLVM backend.
+//       because the v4i1 vector specifically exposed bugs in the LLVM backend.
 
 func @entry() {
   %c0 = constant 0 : index

mlir/lib/Analysis/Presburger/Simplex.cpp

@@ -351,7 +351,7 @@ void Simplex::markEmpty() {
 }
 
 /// Add an inequality to the tableau. If coeffs is c_0, c_1, ... c_n, where n
-/// is the curent number of variables, then the corresponding inequality is
+/// is the current number of variables, then the corresponding inequality is
 /// c_n + c_0*x_0 + c_1*x_1 + ... + c_{n-1}*x_{n-1} >= 0.
 ///
 /// We add the inequality and mark it as restricted. We then try to make its
@@ -367,7 +367,7 @@ void Simplex::addInequality(ArrayRef<int64_t> coeffs) {
 }
 
 /// Add an equality to the tableau. If coeffs is c_0, c_1, ... c_n, where n
-/// is the curent number of variables, then the corresponding equality is
+/// is the current number of variables, then the corresponding equality is
 /// c_n + c_0*x_0 + c_1*x_1 + ... + c_{n-1}*x_{n-1} == 0.
 ///
 /// We simply add two opposing inequalities, which force the expression to
@@ -383,7 +383,7 @@ void Simplex::addEquality(ArrayRef<int64_t> coeffs) {
 unsigned Simplex::numVariables() const { return var.size(); }
 unsigned Simplex::numConstraints() const { return con.size(); }
 
-/// Return a snapshot of the curent state. This is just the current size of the
+/// Return a snapshot of the current state. This is just the current size of the
 /// undo log.
 unsigned Simplex::getSnapshot() const { return undoLog.size(); }
 

mlir/lib/Bindings/Python/IRModules.cpp

@@ -326,7 +326,7 @@ class PyBlockIterator {
 };
 
 /// Blocks are exposed by the C-API as a forward-only linked list. In Python,
-/// we present them as a more full-featured list-like container but optimzie
+/// we present them as a more full-featured list-like container but optimize
 /// it for forward iteration. Blocks are always owned by a region.
 class PyBlockList {
 public:
@@ -424,7 +424,7 @@ class PyOperationIterator {
 
 /// Operations are exposed by the C-API as a forward-only linked list. In
 /// Python, we present them as a more full-featured list-like container but
-/// optimzie it for forward iteration. Iterable operations are always owned
+/// optimize it for forward iteration. Iterable operations are always owned
 /// by a block.
 class PyOperationList {
 public:

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.cpp

@@ -34,7 +34,7 @@ class LaunchConfigConversion : public SPIRVOpLowering<SourceOp> {
                   ConversionPatternRewriter &rewriter) const override;
 };
 
-/// Pattern lowering subgoup size/id to loading SPIR-V invocation
+/// Pattern lowering subgroup size/id to loading SPIR-V invocation
 /// builtin variables.
 template <typename SourceOp, spirv::BuiltIn builtin>
 class SingleDimLaunchConfigConversion : public SPIRVOpLowering<SourceOp> {

mlir/lib/Conversion/SPIRVToLLVM/ConvertSPIRVToLLVM.cpp

@@ -108,7 +108,7 @@ static Value createFPConstant(Location loc, Type srcType, Type dstType,
       loc, dstType, rewriter.getFloatAttr(floatType, value));
 }
 
-/// Utility function for bitfiled ops:
+/// Utility function for bitfield ops:
 ///   - `BitFieldInsert`
 ///   - `BitFieldSExtract`
 ///   - `BitFieldUExtract`
@@ -163,7 +163,7 @@ static Value optionallyBroadcast(Location loc, Value value, Type srcType,
   return value;
 }
 
-/// Utility function for bitfiled ops: `BitFieldInsert`, `BitFieldSExtract` and
+/// Utility function for bitfield ops: `BitFieldInsert`, `BitFieldSExtract` and
 /// `BitFieldUExtract`.
 /// Broadcast `Offset` and `Count` to match the type of `Base`. If `Base` is of
 /// a vector type, construct a vector that has:
@@ -971,8 +971,8 @@ class LoopPattern : public SPIRVToLLVMConversion<spirv::LoopOp> {
 
     Location loc = loopOp.getLoc();
 
-    // Split the current block after `spv.loop`. The remaing ops will be used in
-    // `endBlock`.
+    // Split the current block after `spv.loop`. The remaining ops will be used
+    // in `endBlock`.
     Block *currentBlock = rewriter.getBlock();
     auto position = Block::iterator(loopOp);
     Block *endBlock = rewriter.splitBlock(currentBlock, position);
@@ -1028,7 +1028,7 @@ class SelectionPattern : public SPIRVToLLVMConversion<spirv::SelectionOp> {
 
     Location loc = op.getLoc();
 
-    // Split the current block after `spv.selection`. The remaing ops will be
+    // Split the current block after `spv.selection`. The remaining ops will be
     // used in `continueBlock`.
     auto *currentBlock = rewriter.getInsertionBlock();
     rewriter.setInsertionPointAfter(op);
@@ -1387,7 +1387,7 @@ void mlir::populateSPIRVToLLVMConversionPatterns(
 
       // Entry points and execution mode
       // Module generated from SPIR-V could have other "internal" functions, so
-      // having entry point and execution mode metadat can be useful. For now,
+      // having entry point and execution mode metadata can be useful. For now,
       // simply remove them.
       // TODO: Support EntryPoint/ExecutionMode properly.
       ErasePattern<spirv::EntryPointOp>, ErasePattern<spirv::ExecutionModeOp>,

mlir/lib/Conversion/ShapeToStandard/ShapeToStandard.cpp

@@ -132,7 +132,7 @@ LogicalResult BroadcastOpConverter::matchAndRewrite(
             },
             [&](OpBuilder &b, Location loc) {
               // The broadcasting logic is:
-              // - if one extent (here we arbitrariliy choose the extent from
+              // - if one extent (here we arbitrarily choose the extent from
               // the greater-rank operand) is equal to 1, then take the extent
               // from the other operand
               // - otherwise, take the extent as-is.

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

@@ -249,7 +249,7 @@ SmallVector<Type, 2> LLVMTypeConverter::convertUnrankedMemRefSignature() {
 LLVM::LLVMType LLVMTypeConverter::convertFunctionSignature(
     FunctionType funcTy, bool isVariadic,
     LLVMTypeConverter::SignatureConversion &result) {
-  // Select the argument converter depending on the calling convetion.
+  // Select the argument converter depending on the calling convention.
   auto funcArgConverter = options.useBarePtrCallConv
                               ? barePtrFuncArgTypeConverter
                               : structFuncArgTypeConverter;

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp

@@ -414,7 +414,7 @@ class CmpFOpPattern final : public SPIRVOpLowering<CmpFOp> {
                   ConversionPatternRewriter &rewriter) const override;
 };
 
-/// Converts integer compare operation on i1 type opearnds to SPIR-V ops.
+/// Converts integer compare operation on i1 type operands to SPIR-V ops.
 class BoolCmpIOpPattern final : public SPIRVOpLowering<CmpIOp> {
 public:
   using SPIRVOpLowering<CmpIOp>::SPIRVOpLowering;

mlir/lib/Conversion/VectorToROCDL/VectorToROCDL.cpp

@@ -100,7 +100,7 @@ class VectorTransferConversion : public ConvertToLLVMPattern {
       return failure();
 
     // Note that the dataPtr starts at the offset address specified by
-    // indices, so no need to calculat offset size in bytes again in
+    // indices, so no need to calculate offset size in bytes again in
     // the MUBUF instruction.
     Value dataPtr = getDataPtr(loc, memRefType, adaptor.memref(),
                                adaptor.indices(), rewriter);

mlir/lib/Dialect/GPU/Transforms/KernelOutlining.cpp

@@ -84,7 +84,7 @@ extractBeneficiaryOps(Operation *op,
     return false;
 
   for (Value operand : op->getOperands()) {
-    // It is already visisble in the kernel, keep going.
+    // It is already visible in the kernel, keep going.
     if (availableValues.count(operand))
       continue;
     // Else check whether it can be made available via sinking or already is a

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

@@ -79,7 +79,7 @@ struct LLVMStructTypeStorage : public TypeStorage {
     bool isIdentified() const { return identified; }
     bool isPacked() const {
       assert(!isIdentified() &&
-             "'packed' bit is not part of the key for identified stucts");
+             "'packed' bit is not part of the key for identified structs");
       return packed;
     }
     bool isOpaque() const {
@@ -196,7 +196,7 @@ struct LLVMStructTypeStorage : public TypeStorage {
   /// Constructs the storage from the given key. This sets up the uniquing key
   /// components and optionally the mutable component if they construction key
   /// has the relevant information. In the latter case, the struct is considered
-  /// as initalized and can no longer be mutated.
+  /// as initialized and can no longer be mutated.
   LLVMStructTypeStorage(const KeyTy &key) {
     if (!key.isIdentified()) {
       ArrayRef<LLVMType> types = key.getTypeList();

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

@@ -711,10 +711,10 @@ static SmallVector<SmallVector<AffineExpr, 2>, 2>
 convertReassociationIndicesToMaps(
     OpBuilder &b, ArrayRef<ReassociationIndices> reassociationIndices) {
   SmallVector<SmallVector<AffineExpr, 2>, 2> reassociationMaps;
-  for (const auto &indicies : reassociationIndices) {
+  for (const auto &indices : reassociationIndices) {
     SmallVector<AffineExpr, 2> reassociationMap;
-    reassociationMap.reserve(indicies.size());
-    for (int64_t index : indicies)
+    reassociationMap.reserve(indices.size());
+    for (int64_t index : indices)
       reassociationMap.push_back(b.getAffineDimExpr(index));
     reassociationMaps.push_back(std::move(reassociationMap));
   }

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

@@ -147,7 +147,7 @@ static void generateFusedTensorOpRegion(PatternRewriter &rewriter,
     }
 
     // If consumer is an indexed_generic op, map the indices to the block
-    // arguments directly. Otherwise, add the same type of arugment and map to
+    // arguments directly. Otherwise, add the same type of argument and map to
     // it.
     if (consumerArg.index() < numConsumerIndices) {
       mapper.map(consumerArg.value(),

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

@@ -80,7 +80,7 @@ void mlir::linalg::hoistViewAllocOps(FuncOp func) {
   }
 }
 
-/// Return true if we can prove that the transfer operations access dijoint
+/// Return true if we can prove that the transfer operations access disjoint
 /// memory.
 static bool isDisjoint(VectorTransferOpInterface transferA,
                        VectorTransferOpInterface transferB) {

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

@@ -161,7 +161,7 @@ struct LinalgOpInstancePromotionOptions {
   CopyCallbackFn copyInFn;
   CopyCallbackFn copyOutFn;
 
-  /// Allow the use of dynamicaly-sized buffers.
+  /// Allow the use of dynamically-sized buffers.
   bool dynamicBuffers;
   /// Alignment of promoted buffer.
   Optional<unsigned> alignment;

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

@@ -302,7 +302,7 @@ static Type parseArrayType(SPIRVDialect const &dialect,
 }
 
 // cooperative-matrix-type ::= `!spv.coopmatrix` `<` element-type ',' scope ','
-//                                                   rows ',' coloumns>`
+//                                                   rows ',' columns>`
 static Type parseCooperativeMatrixType(SPIRVDialect const &dialect,
                                        DialectAsmParser &parser) {
   if (parser.parseLess())
@@ -621,7 +621,7 @@ static Type parseStructType(SPIRVDialect const &dialect,
 
   StringRef identifier;
 
-  // Check if this is an idenitifed struct type.
+  // Check if this is an identified struct type.
   if (succeeded(parser.parseOptionalKeyword(&identifier))) {
     // Check if this is a possible recursive reference.
     if (succeeded(parser.parseOptionalGreater())) {

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

@@ -217,9 +217,9 @@ static ParseResult parseMemoryAccessAttributes(OpAsmParser &parser,
 }
 
 // TODO Make sure to merge this and the previous function into one template
-// parameterized by memroy access attribute name and alignment. Doing so now
+// parameterized by memory access attribute name and alignment. Doing so now
 // results in VS2017 in producing an internal error (at the call site) that's
-// not detailed enough to understand what is happenning.
+// not detailed enough to understand what is happening.
 static ParseResult parseSourceMemoryAccessAttributes(OpAsmParser &parser,
                                                      OperationState &state) {
   // Parse an optional list of attributes staring with '['
@@ -274,9 +274,9 @@ static void printMemoryAccessAttribute(
 }
 
 // TODO Make sure to merge this and the previous function into one template
-// parameterized by memroy access attribute name and alignment. Doing so now
+// parameterized by memory access attribute name and alignment. Doing so now
 // results in VS2017 in producing an internal error (at the call site) that's
-// not detailed enough to understand what is happenning.
+// not detailed enough to understand what is happening.
 template <typename MemoryOpTy>
 static void printSourceMemoryAccessAttribute(
     MemoryOpTy memoryOp, OpAsmPrinter &printer,
@@ -393,9 +393,9 @@ static LogicalResult verifyMemoryAccessAttribute(MemoryOpTy memoryOp) {
 }
 
 // TODO Make sure to merge this and the previous function into one template
-// parameterized by memroy access attribute name and alignment. Doing so now
+// parameterized by memory access attribute name and alignment. Doing so now
 // results in VS2017 in producing an internal error (at the call site) that's
-// not detailed enough to understand what is happenning.
+// not detailed enough to understand what is happening.
 template <typename MemoryOpTy>
 static LogicalResult verifySourceMemoryAccessAttribute(MemoryOpTy memoryOp) {
   // ODS checks for attributes values. Just need to verify that if the

mlir/lib/Dialect/SPIRV/SPIRVTypes.cpp

@@ -810,7 +810,7 @@ struct spirv::detail::StructTypeStorage : public TypeStorage {
       std::tuple<StringRef, ArrayRef<Type>, ArrayRef<StructType::OffsetInfo>,
                  ArrayRef<StructType::MemberDecorationInfo>>;
 
-  /// For idetified structs, return true if the given key contains the same
+  /// For identified structs, return true if the given key contains the same
   /// identifier.
   ///
   /// For literal structs, return true if the given key contains a matching list

mlir/lib/Dialect/SPIRV/Serialization/Serializer.cpp

@@ -1033,7 +1033,7 @@ bool Serializer::isInterfaceStructPtrType(Type type) const {
 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 seialize resursive references.
+  // to properly serialize resursive references.
   llvm::SetVector<StringRef> serializationCtx;
   return processTypeImpl(loc, type, typeID, serializationCtx);
 }
@@ -1170,7 +1170,7 @@ LogicalResult Serializer::prepareBasicType(
                             spirv::Opcode::OpTypeForwardPointer,
                             forwardPtrOperands);
 
-      // 2. Find the the pointee (enclosing) struct.
+      // 2. Find the pointee (enclosing) struct.
       auto structType = spirv::StructType::getIdentified(
           module.getContext(), pointeeStruct.getIdentifier());