[mlir] NFC: fix trivial typo in documents

[bondhugula]

Thanks!

mlir/docs/ConversionToLLVMDialect.md

 
 ```cpp
 template<typename T, size_t N>
 struct MemRefDescriptor {
   T *allocated;
   T *aligned;
   intptr_t offset;
   intptr_t sizes[N];
-  intptr_t stides[N];
+  intptr_t strides[N];
 };
 ```
 
 If enabled, the option will do the following. For _external_ functions declared
 in the MLIR module.
 
 1. Declare a new function `_mlir_ciface_<original name>` where memref arguments
    are converted to pointer-to-struct and the remaining arguments are converted

mlir/docs/CreatingADialect.md

 mlir/lib/Conversion/XCommon, for example
 mlir/lib/Conversion/GPUCommon.
 
 ## CMake best practices
 
 Each conversion typically exists in a separate library, declared with
 add_mlir_conversion_library().  Conversion libraries typically depend
 on their source and target dialects, but may also depend on other
-dialects (e.g. MLIRStandard).  Typically this dependence is specifid
+dialects (e.g. MLIRStandard).  Typically this dependence is specified
 using target_link_libraries() and the PUBLIC keyword.  For instance:
 
 ```cmake
 
 add_mlir_conversion_library(MLIRBarToFoo
   BarToFoo.cpp
 
    ADDITIONAL_HEADER_DIRS

mlir/docs/Diagnostics.md

 ```c++
 DiagnosticEngine engine = ctx->getDiagEngine();
 
 /// Handle the reported diagnostic.
 // Return success to signal that the diagnostic has either been fully processed,
 // or failure if the diagnostic should be propagated to the previous handlers.
 DiagnosticEngine::HandlerID id = engine.registerHandler(
     [](Diagnostic &diag) -> LogicalResult {
-  bool should_propage_diagnostic = ...;
-  return failure(should_propage_diagnostic);
+  bool should_propagate_diagnostic = ...;
+  return failure(should_propagate_diagnostic);
 });
 
 
 // We can also elide the return value completely, in which the engine assumes
 // that all diagnostics are consumed(i.e. a success() result).
 DiagnosticEngine::HandlerID id = engine.registerHandler([](Diagnostic &diag) {
   return;
 });

mlir/docs/OpDefinitions.md

1. All operand and result types must appear within the format using the various
    `type` directives, either individually or with the `operands` or `results`
    directives.
 1. The `attr-dict` directive must always be present.
 1. Must not contain overlapping information; e.g. multiple instances of
    'attr-dict', types, operands, etc.
    -  Note that `attr-dict` does not overlap with individual attributes. These
       attributes will simply be elided when printing the attribute dictionary.
 
-##### Type Inferrence
+##### Type Inference
 
 One requirement of the format is that the types of operands and results must
 always be present. In certain instances, the type of a variable may be deduced
 via type constraints or other information available. In these cases, the type of
 that variable may be elided from the format.
 
 * Buildable Types
 

mlir/docs/RationaleLinalgDialect.md

 - The early gains provided by reusing established infrastructures
 (HalideIR and ISL schedule trees) turned into more impedance mismatch
 problems than could be solved with a small tactical investment.
 - Tensor Comprehensions emitted CUDA code which was then JIT compiled
 with NVCC from a textual representation. While this was a pragmatic
 short-term solution it made it hard to perform low-level rewrites that
 would have helped with register reuse in the ***compute-bound regime***.
 - The same reliance on emitting CUDA code made it difficult to
-create cost models when time came. This made it artifically harder to
+create cost models when time came. This made it artificially harder to
 prune out bad solutions than necessary. This resulted in excessive
 runtime evaluation, as reported in the paper [Machine Learning Systems
 are Stuck in a Rut](https://dl.acm.org/doi/10.1145/3317550.3321441).
 
 Many of those issues are naturally addressed by implementing these ideas
 in the MLIR infrastructure.
 
 ### Lessons from Polyhedral compilers<a name="lessonspolyhedral"></a>

mlir/include/mlir/Dialect/GPU/GPUOps.td

 
 def GPU_ReturnOp : GPU_Op<"return", [HasParent<"GPUFuncOp">, NoSideEffect,
                                      Terminator]>,
     Arguments<(ins Variadic<AnyType>:$operands)>, Results<(outs)> {
   let summary = "Terminator for GPU functions.";
   let description = [{
     A terminator operation for regions that appear in the body of  `gpu.func`
     functions. The operands to the `gpu.return` are the result values returned
-    by an incovation of the `gpu.func`.
+    by an invocation of the `gpu.func`.
   }];
 
   let builders = [OpBuilder<"Builder *builder, OperationState &result", " // empty">];
 
   let parser = [{ return parseReturnOp(parser, result); }];
   let printer = [{ p << getOperationName(); }];
   let verifier = [{ return ::verify(*this); }];
 }

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

$res = mb.CreateMatrixMultiply(
       $rhs_columns.getZExtValue());
   }];
   let assemblyFormat = "$lhs `,` $rhs attr-dict "
     "`:` `(` type($lhs) `,` type($rhs) `)` `->` type($res)";
 }
 
 /// Create a llvm.matrix.transpose call, transposing a `rows` x `columns` 2-D
 /// `matrix`, as specified in the LLVM MatrixBuilder.
-def LLVM_MatrixTranposeOp
+def LLVM_MatrixTransposeOp
     : LLVM_OneResultOp<"intr.matrix.transpose">,
       Arguments<(ins LLVM_Type:$matrix, I32Attr:$rows, I32Attr:$columns)> {
   string llvmBuilder = [{
     llvm::MatrixBuilder<decltype(builder)> mb(builder);
     $res = mb.CreateMatrixTranspose(
       $matrix, $rows.getZExtValue(), $columns.getZExtValue());
   }];
   let assemblyFormat = "$matrix attr-dict `:` type($matrix) `into` type($res)";

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOps.td

int64_t getLowPad(unsigned i) {
       assert(i < getNumWindowLoops());
       if (!padding().hasValue()) return 0;
       return padding().getValue().getValue<int64_t>({i, 0});
     }
 
     //   F(z0, ..., zN-1, q, k) *
     //     I(b, x0 + z0 - pad_low_0, ..., xN-1 + zN-1 - pad_low_N-1, q)
     //   ->  O(b, x0, ..., xN-1, k)
-    // for N equal to `nWindow`. If there is no padding attirbute, it will be
+    // for N equal to `nWindow`. If there is no padding attribute, it will be
     // ignored.
     llvm::Optional<SmallVector<AffineMap, 8>> referenceIndexingMaps() {
       MLIRContext *context = getContext();
       auto nWin = getNumWindowLoops();
       assert(nWin > 0 && "expected at least one window dimension");
       unsigned idx = 0;
       // In the following, AffineDimExprs are indexed in loop order:
       //   [ b, xs, k,           q,                     zs]

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td

InterfaceMethod<
       "Return the range over inputs (irrespective of type) and output buffers.",
       "Operation::operand_range", "getInputsAndOutputBuffers"
     >,
 
     //===------------------------------------------------------------------===//
     // Other interface methods.
     //===------------------------------------------------------------------===//
     InterfaceMethod<
-      "Return the reference iterators for this named op (if any are specied). "
-      "These reference iterators are used to specify the default behavior of "
-      "the op. Typically this would be a static method but in order to allow "
-      "rank-polymorphic ops, this needs to be per object instance. Named ops "
-      "must define referenceIterators, even if empty for the 0-D case. "
-      "Generic ops on the other hand have a None `referenceIterators`",
+      "Return the reference iterators for this named op (if any are "
+      "specified). These reference iterators are used to specify the default "
+      "behavior of the op. Typically this would be a static method but in "
+      "order to allow rank-polymorphic ops, this needs to be per object "
+      "instance. Named ops must define referenceIterators, even if empty for "
+      "the 0-D case. Generic ops on the other hand have a None "
+      "`referenceIterators`",
       "llvm::Optional<SmallVector<StringRef, 8>>", "referenceIterators"
     >,
     InterfaceMethod<
       "Return the reference indexing maps for this named op (if any are "
       "specified). Typically this would be a static method but in order to "
       "allow rank-polymorphic ops, this needs to be per object instance. Named "
       "ops must define referenceIterators, even if empty for the 0-D case. "
       "Generic ops on the other hand have a None `referenceIndexingMaps`",

mlir/include/mlir/Dialect/Quant/QuantOps.td

def quant_ConstFakeQuant : quant_Op<"const_fake_quant",
                                     [SameOperandsAndResultType, NoSideEffect]> {
   let summary =
       "Simulates the effect of uniform quantization with const range.";
 
   let description = [{
     Given a const min, max, num_bits and narrow_range attribute, applies the
     same uniform quantization simulation as is done by the TensorFlow
     fake_quant_with_min_max_args op. See the fakeQuantAttrsToType() utility
-    method and the quant-convert-simulated-quantization pass for futher details.
+    method and the quant-convert-simulated-quantization pass for further details.
   }];
 
   let arguments = (ins
     F32Tensor:$inputs,
     F32Attr:$min,
     F32Attr:$max,
     // The bitwidth of the quantization; between 2 and 16, inclusive.
     I64Attr:$num_bits,
def quant_ConstFakeQuantPerAxis : quant_Op<"const_fake_quant_per_axis",
                                     [SameOperandsAndResultType, NoSideEffect]> {
   let summary =
       "Simulates the effect of per axis uniform quantization with const range.";
 
   let description = [{
     Given a const min, max, num_bits and narrow_range attribute, applies the
     same per axis uniform quantization simulation as is done by the TensorFlow
     fake_quant_with_min_max_vars_per_channel op. See the fakeQuantAttrsToType()
-    utility method and the quant-convert-simulated-quantization pass for futher
+    utility method and the quant-convert-simulated-quantization pass for further
     details.
   }];
 
   let arguments = (ins
     F32Tensor:$inputs,
     F32ArrayAttr:$min,
     F32ArrayAttr:$max,
     // The quantized dimension of the inputs tensor.

mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td

 //===----------------------------------------------------------------------===//
 // SPIR-V op definitions
 //===----------------------------------------------------------------------===//
 
 // Base class for all SPIR-V ops.
 class SPV_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<SPIRV_Dialect, mnemonic, !listconcat(traits, [
          // TODO(antiagainst): We don't need all of the following traits for
-         // every op; only the suitabble ones should be added automatically
+         // every op; only the suitable ones should be added automatically
          // after ODS supports dialect-specific contents.
          DeclareOpInterfaceMethods<QueryMinVersionInterface>,
          DeclareOpInterfaceMethods<QueryMaxVersionInterface>,
          DeclareOpInterfaceMethods<QueryExtensionInterface>,
          DeclareOpInterfaceMethods<QueryCapabilityInterface>
        ])> {
   // Availability specification for this op itself.
   list<Availability> availability = [

mlir/include/mlir/Dialect/Shape/IR/ShapeOps.td

def ShapeDialect : Dialect {
   let summary = "Types and operations for shape dialect";
   let description = [{
     This dialect contains operations for shape inference.
 
     Note: Unless explicitly stated, all functions that return a shape and take
     shapes as input, return the invalid shape if one of its operands is an
     invalid shape. This avoids flagging multiple errors for one verification
     failure. The dialect itself does not specify how errors should be combined
-    (there are multiple different options, from always chosing first operand,
+    (there are multiple different options, from always choosing first operand,
     concatting etc. on how to combine them).
   }];
 
   let cppNamespace = "shape";
 }
 
 def Shape_ComponentType : DialectType<ShapeDialect,
     CPred<"$_self.isa<::mlir::shape::ComponentType>()">, "component type"> {

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

Vector_Op<"transpose", [NoSideEffect,
     Arguments<(ins AnyVector:$vector, I64ArrayAttr:$transp)>,
     Results<(outs AnyVector:$result)> {
   let summary = "vector transpose operation";
   let description = [{
     Takes a n-D vector and returns the transposed n-D vector defined by
     the permutation of ranks in the n-sized integer array attribute.
     In the operation
     ```mlir
-      %1 = vector.tranpose %0, [i_1, .., i_n]
+      %1 = vector.transpose %0, [i_1, .., i_n]
         : vector<d_1 x .. x d_n x f32>
         to vector<d_trans[0] x .. x d_trans[n-1] x f32>
     ```
     the transp array [i_1, .., i_n] must be a permutation of [0, .., n-1].
 
     Example:
     ```mlir
-    %1 = vector.tranpose %0, [1, 0] : vector<2x3xf32> to vector<3x2xf32>
+    %1 = vector.transpose %0, [1, 0] : vector<2x3xf32> to vector<3x2xf32>
 
      [ [a, b, c],       [ [a, d],
        [d, e, f] ]  ->    [b, e],
                           [c, f] ]
     ```
   }];
   let extraClassDeclaration = [{
     VectorType getVectorType() {

mlir/include/mlir/Interfaces/InferTypeOpInterface.td

StaticInterfaceMethod<
                     "ArrayRef<NamedAttribute>":$attributes,
                     "RegionRange":$regions,
                     "SmallVectorImpl<ShapedTypeComponents>&":
                       $inferredReturnShapes)
     >,
     InterfaceMethod<
       /*desc=*/[{Reify the shape computation for the operation.
 
-      Insert operations using the given OpBulder that computes the result shape.
+      Insert operations using the given OpBuilder that computes the result
+      shape.
       }],
       /*retTy=*/"LogicalResult",
       /*methodName=*/"reifyReturnTypeShapes",
       /*args=*/(ins "OpBuilder&":$builder,
                     "SmallVectorImpl<Value>&":$reifiedReturnShapes),
       /*methodBody=*/[{}],
       /*defaultImplementation=*/[{ return failure(); }]
     >,
   ];
 }
 
 #endif // MLIR_INFERTYPEOPINTERFACE

mlir/test/Conversion/StandardToSPIRV/std-types-to-spirv.mlir

 } // end module
 
 // -----
 
 //===----------------------------------------------------------------------===//
 // Tensor types
 //===----------------------------------------------------------------------===//
 
-// Check that tensor element types are kept untouched with proper capabilites.
+// Check that tensor element types are kept untouched with proper capabilities.
 module attributes {
   spv.target_env = #spv.target_env<
     #spv.vce<v1.0, [Int8, Int16, Int64, Float16, Float64], []>,
     {max_compute_workgroup_invocations = 128 : i32,
      max_compute_workgroup_size = dense<[128, 128, 64]> : vector<3xi32>}>
 } {
 
 // CHECK-LABEL: spv.func @int_tensor_types

mlir/test/IR/attribute.mlir

func @int_attrs_pass() {
   } : () -> ()
 
   return
 }
 
 // -----
 
 //===----------------------------------------------------------------------===//
-// Check that the maximum and minumum integer attribute values are
+// Check that the maximum and minimum integer attribute values are
 // representable and preserved during a round-trip.
 //===----------------------------------------------------------------------===//
 
 func @int_attrs_pass() {
   "test.in_range_attrs"() {
     // CHECK: attr_00 = -128 : i8
     attr_00 = -128 : i8,
     // CHECK-SAME: attr_01 = 127 : i8

mlir/test/mlir-tblgen/llvm-intrinsics.td

 // This checks that we can consume LLVM's Intrinsic definitions from TableGen
 // files and produce ODS. Unlike MLIR, LLVM's main Intrinsics.td file that
 // contains the definition of the Intrinsic class also includes files for
 // platform-specific intrinsics, so we need to give it to TableGen instead of
 // writing a local test source. We filter out platform-specific intrinsic
 // includes from the main file to avoid unnecessary dependencies and decrease
 // the test cost. The command-line flags further ensure a specific intrinsic is
-// processed and we only check the ouptut below.
+// processed and we only check the output below.
 // We also verify emission of type specialization for overloadable intrinsics.
 //
 // RUN: cat %S/../../../llvm/include/llvm/IR/Intrinsics.td \
 // RUN: | grep -v "llvm/IR/Intrinsics" \
 // RUN: | mlir-tblgen -gen-llvmir-intrinsics -I %S/../../../llvm/include/ --llvmir-intrinsics-filter=ptrmask \
 // RUN: | FileCheck %s
 
 // CHECK-LABEL: def LLVM_ptrmask