[mlir] NFC: fix trivial typos fix typos under docs, test, and tools directories

mlir/docs/CAPI.md

 #### `StringRef`
 
 Numerous MLIR functions return instances of `StringRef` to refer to a non-owning
 segment of a string. This segment may or may not be null-terminated. In C API,
 these are represented as instances of `MlirStringRef` structure that contains a
 pointer to the first character of the string fragment (`str`) and the fragment
 length (`length`). Note that the fragment is _not necessarily_ null-terminated,
 the `length` field must be used to identify the last character. `MlirStringRef`
-is a non-owning pointer, the caller is in charge of perfoming the copy or
+is a non-owning pointer, the caller is in charge of performing the copy or
 ensuring that the pointee outlives all uses of `MlirStringRef`.
 
 ### Printing
 
 IR objects can be printed using `mlirXPrint(MlirX, MlirStringCallback, void *)`
 functions. These functions accept take arguments a callback with signature `void
 (*)(const char *, intptr_t, void *)` and a pointer to user-defined data. They
 call the callback and supply it with chunks of the string representation,

mlir/docs/ConversionToLLVMDialect.md

memref<1x? x vector<4xf32>> -> !llvm.struct<(ptr<vec<4 x float>>,
                                              ptr<vec<4 x float>>, i64,
                                              array<1 x i64>, array<1 x i64>)>
 ```
 
 #### Bare Pointer Convention
 
 Ranked memrefs with static shape and default layout can be converted into an
 LLVM dialect pointer to their element type. Only the default alignment is
-supported in such cases, e.g. the `alloc` operation cannot have an alignemnt
+supported in such cases, e.g. the `alloc` operation cannot have an alignment
 attribute.
 
 Examples:
 
 ```mlir
 memref<f32> -> !llvm.ptr<float>
 memref<10x42 x f32> -> !llvm.ptr<float>
 

 // another point-to-function.
 !llvm.func<void (ptr<func<void (ptr<func<i64 (i32)>>)>>)>
 ```
 
 #### Memrefs as Function Arguments
 
 When used as function arguments, both ranked and unranked memrefs are converted
 into a list of arguments that represents each _scalar_ component of their
-descriptor. This is intended for some comaptibility with C ABI, in which
+descriptor. This is intended for some compatibility with C ABI, in which
 structure types would need to be passed by-pointer leading to the need for
 allocations and related issues, as well as for aliasing annotations, which are
 currently attached to pointer in function arguments. Having scalar components
-means that each size and stride is passed as an invidivual value.
+means that each size and stride is passed as an individual value.
 
 When used as function results, memrefs are converted as usual, i.e. each memref
 is converted to a descriptor struct (default convention) or to a pointer (bare
 pointer convention).
 
 Examples:
 
 ```mlir

mlir/docs/Dialects/LLVM.md

 transitively contained in the same struct. In the latter case, only the
 identifier is printed. For example, the structure containing the pointer to
 itself is represented as `!llvm.struct<"A", (ptr<"A">)>`, and the structure `A`
 containing two pointers to the structure `B` containing a pointer to the
 structure `A` is represented as `!llvm.struct<"A", (ptr<"B", (ptr<"A">)>,
 ptr<"B", (ptr<"A">))>`. Note that the structure `B` is "unrolled" for both
 elements. _A structure with the same name but different body is a syntax error._
 **The user must ensure structure name uniqueness across all modules processed in
-a given MLIR context.** Stucture names are arbitrary string literals and may
+a given MLIR context.** Structure names are arbitrary string literals and may
 include, e.g., spaces and keywords.
 
 Identified structs may be _opaque_. In this case, the body is unknown but the
 structure type is considered _initialized_ and is valid in the IR.
 
 #### Literal Structure Types
 
 Literal structures are uniqued according to the list of elements they contain,

mlir/docs/Dialects/TOSA.md

 TOSA was developed after parallel efforts to rationalize the top-down picture
 from multiple high-level frameworks, as well as a bottom-up view of different
 hardware target concerns (CPU, GPU and NPU), and reflects a set of choices
 that attempt to manage both sets of requirements.
 
 ## TOSA and Tensor Level Expressiveness
 
 TOSA endeavors to provide an operator set that tries to fulfil the following
-expressivenes goals at the *tensor level of abstraction* :
+expressiveness goals at the *tensor level of abstraction* :
 
 ### Complete
 
 This is driven by the top-down perspective, needing to express as much of
 multiple high level frameworks fully in TOSA, as possible. This was originally
 done from an operator frequency analysis done upon dozens of high level
-networks in different frameworks, to select the most frequently occuring ones
+networks in different frameworks, to select the most frequently occurring ones
 and establish a common set of tensor-level operators that could express them.
 
 TOSA categorizes its operator set into classes and attempts to address major
 functional operations at the tensor level, including compute, reduction,
 elementwise transformations, comparison and control flow.
 
 ### Minimal
 

mlir/docs/PassManagement.md

*   Passes are expected to not modify operations at or above the current
         operation being processed. If the operation is not isolated, it may
         inadvertently modify or traverse the SSA use-list of an operation it is
         not supposed to.
 
 Passes can be added to a pass manager via `addPass`. The pass must either be an
 `op-specific` pass operating on the same operation type as `OpPassManager`, or
 an `op-agnostic` pass.
 
-An `OpPassManager` is generally creted by explicitly nesting a pipeline within
+An `OpPassManager` is generally created by explicitly nesting a pipeline within
 another existing `OpPassManager` via the `nest<>` method. This method takes the
 operation type that the nested pass manager will operate on. At the top-level, a
 `PassManager` acts as an `OpPassManager`. Nesting in this sense, corresponds to
 the [structural](Tutorials/UnderstandingTheIRStructure.md) nesting within
 [Regions](LangRef.md#regions) of the IR.
 
 For example, the following `.mlir`:
 

mlir/test/Dialect/Async/async-ref-counting-optimization.mlir

func @not_cancellable_operations_0(%arg0: !async.token, %arg1: i1) {
   async.drop_ref %arg0 {count = 1 : i32} : !async.token
   // CHECK: return
   return
 }
 
 // CHECK-LABEL: @not_cancellable_operations_1
 func @not_cancellable_operations_1(%arg0: !async.token, %arg1: i1) {
   // Same reason as above, although `async.execute` is inside the nested
-  // region or "regular" opeation.
+  // region or "regular" operation.
   //
   // NOTE: This test is not correct w.r.t. reference counting, and at runtime
   // would leak %arg0 value if %arg1 is false. IR like this will not be
   // constructed by automatic reference counting pass, because it would
   // place `async.add_ref` right before the `async.execute` inside `scf.if`.
   
   // CHECK: async.add_ref
   async.add_ref %arg0 {count = 1 : i32} : !async.token

mlir/test/Transforms/buffer-deallocation.mlir

 //      CHECK: }
 //      CHECK: test.copy(%[[ALLOC2]], %arg4)
 // CHECK-NEXT: dealloc %[[ALLOC2]]
 
 // -----
 
 // Test Case: structured control-flow loop with a nested if operation.
 // The loop yields buffers that have been defined outside of the loop and the
-// backeges only use the iteration arguments (or one of its aliases).
+// backedges only use the iteration arguments (or one of its aliases).
 // Therefore, we do not have to (and are not allowed to) free any buffers
 // that are passed via the backedges.
 
 // CHECK-LABEL: func @loop_nested_if_no_alloc
 func @loop_nested_if_no_alloc(
   %lb: index,
   %ub: index,
   %step: index,

mlir/test/Transforms/normalize-memrefs-ops.mlir

 // RUN: mlir-opt -normalize-memrefs %s | FileCheck %s
 
 // For all these cases, we test if MemRefs Normalization works with the test
 // operations.
 // * test.op_norm: this operation has the MemRefsNormalizable attribute. The tests
 //   that include this operation are constructed so that the normalization should
 //   happen.
 // * test_op_nonnorm: this operation does not have the MemRefsNormalization
-//   attribute. The tests that include this operation are contructed so that the
+//   attribute. The tests that include this operation are constructed so that the
 //    normalization should not happen.
 
 #map0 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2 floordiv 32, d3 floordiv 64, d2 mod 32, d3 mod 64)>
 
 // Test with op_norm and maps in arguments and in the operations in the function.
 
 // CHECK-LABEL: test_norm
 // CHECK-SAME: (%[[ARG0:.*]]: memref<1x16x1x1x32x64xf32>)

mlir/test/Transforms/promote-buffers-to-stack.mlir

 // CHECK-NEXT: %[[ALLOCA:.*]] = alloca()
 // CHECK-NEXT: scf.for
 //      CHECK: %[[ALLOC:.*]] = alloc()
 
 // -----
 
 // Test Case: structured control-flow loop with a nested if operation.
 // The loop yields buffers that have been defined outside of the loop and the
-// backeges only use the iteration arguments (or one of its aliases).
+// backedges only use the iteration arguments (or one of its aliases).
 // Therefore, we do not have to (and are not allowed to) free any buffers
 // that are passed via the backedges. The alloc is converted to an AllocaOp.
 
 // CHECK-LABEL: func @loop_nested_if_no_alloc
 func @loop_nested_if_no_alloc(
   %lb: index,
   %ub: index,
   %step: index,

mlir/test/lib/Dialect/Test/TestPatterns.cpp

 struct FoldingPattern : public RewritePattern {
 public:
   FoldingPattern(MLIRContext *context)
       : RewritePattern(TestOpInPlaceFoldAnchor::getOperationName(),
                        /*benefit=*/1, context) {}
 
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const override {
-    // Exercice OperationFolder API for a single-result operation that is folded
+    // Exercise OperationFolder API for a single-result operation that is folded
     // upon construction. The operation being created through the folder has an
     // in-place folder, and it should be still present in the output.
     // Furthermore, the folder should not crash when attempting to recover the
     // (unchanged) operation result.
     OperationFolder folder(op->getContext());
     Value result = folder.create<TestOpInPlaceFold>(
         rewriter, op->getLoc(), rewriter.getIntegerType(32), op->getOperand(0),
         rewriter.getI32IntegerAttr(0));

mlir/test/lib/Transforms/TestSparsification.cpp

 } // end anonymous namespace
 
 namespace mlir {
 namespace test {
 
 void registerTestSparsification() {
   PassRegistration<TestSparsification> sparsificationPass(
       "test-sparsification",
-      "Test automatic geneneration of sparse tensor code");
+      "Test automatic generation of sparse tensor code");
 }
 
 } // namespace test
 } // namespace mlir

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-gen.cpp

public:
   /// Print the C++ StructuredOpsInterface impl of `indexing_maps`.
   void printReferenceIndexingMaps(llvm::raw_ostream &os, StringRef cppOpName,
                                   ComprehensionParsingState &state);
 
   /// Print the C++ StructuredOpsInterface impl of `regionBuilder`.
   void printRegionBuilder(llvm::raw_ostream &os, StringRef cppOpName,
                           ComprehensionParsingState &state);
 
-  /// Print the C++ impl for named ops canonicalizers and fodlers.
+  /// Print the C++ impl for named ops canonicalizers and folders.
   void printCanonicalizersAndFolders(llvm::raw_ostream &os,
                                      StringRef cppOpName);
 
 private:
   //===--------------------------------------------------------------------===//
   // Internal bookkeeping of tensors.
   //===--------------------------------------------------------------------===//
   struct RegisteredTensor {

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 
 void OpEmitter::genNamedRegionGetters() {
   unsigned numRegions = op.getNumRegions();
   for (unsigned i = 0; i < numRegions; ++i) {
     const auto &region = op.getRegion(i);
     if (region.name.empty())
       continue;
 
-    // Generate the accessors for a varidiadic region.
+    // Generate the accessors for a variadic region.
     if (region.isVariadic()) {
       auto *m = opClass.addMethodAndPrune("::mlir::MutableArrayRef<Region>",
                                           region.name);
       m->body() << formatv("  return (*this)->getRegions().drop_front({0});",
                            i);
       continue;
     }
 
if (auto *t = dyn_cast<tblgen::NativeOpTrait>(&trait)) {
         body << formatv(checkAttrSizedValueSegmentsCode, "result_segment_sizes",
                         op.getNumResults(), "result");
       }
     }
   }
 
   FmtContext verifyCtx;
   populateSubstitutions(op, "odsAttrs.get", "getODSOperands",
-                        "<no results should be genarated>", verifyCtx);
+                        "<no results should be generated>", verifyCtx);
   genAttributeVerifier(op, "odsAttrs.get",
                        Twine("emitError(loc, \"'") + op.getOperationName() +
                            "' op \"",
                        /*emitVerificationRequiringOp*/ false, verifyCtx, body);
 
   body << "  return ::mlir::success();";
 }
 

mlir/tools/mlir-tblgen/TypeDefGen.cpp

 //===----------------------------------------------------------------------===//
 // GEN: TypeDef definitions
 //===----------------------------------------------------------------------===//
 
 /// Beginning of storage class.
 /// {0}: Storage class namespace.
 /// {1}: Storage class c++ name.
 /// {2}: Parameters parameters.
-/// {3}: Parameter initialzer string.
+/// {3}: Parameter initializer string.
 /// {4}: Parameter name list.
 /// {5}: Parameter types.
 static const char *const typeDefStorageClassBegin = R"(
 namespace {0} {{
   struct {1} : public ::mlir::TypeStorage {{
     {1} ({2})
       : {3} {{ }