[mlir] NFC: Fix trivial typo

[mehdi_amini]

Thanks!

mlir/docs/Dialects/LLVM.md

 LLVM IR function attributes have their value represented in the string form.
 
 Example:
 
 ```mlir
 llvm.func @func() attributes {
   passthrough = ["noinline",           // value-less attribute
                  ["alignstack", "4"],  // integer attribute with value
-                 ["other", "attr"]]    // attrbute unknown to LLVM
+                 ["other", "attr"]]    // attribute unknown to LLVM
 } {
   llvm.return
 }
 ```
 
 If the attribute is not known to LLVM IR, it will be attached as a string
 attribute.
 

mlir/docs/Dialects/Standard.md

 Starts a non-blocking DMA operation that transfers data from a source memref to
 a destination memref. The operands include the source and destination memref's
 each followed by its indices, size of the data transfer in terms of the number
 of elements (of the elemental type of the memref), a tag memref with its
 indices, and optionally two additional arguments corresponding to the stride (in
 terms of number of elements) and the number of elements to transfer per stride.
 The tag location is used by a dma_wait operation to check for completion. The
 indices of the source memref, destination memref, and the tag memref have the
-same restrictions as any load/store operation in a affine context (whenever DMA
+same restrictions as any load/store operation in an affine context (whenever DMA
 operations appear in an affine context). See
 [restrictions on dimensions and symbols](Affine.md#restrictions-on-dimensions-and-symbols)
 in affine contexts. This allows powerful static analysis and transformations in
 the presence of such DMAs including rescheduling, pipelining / overlap with
 computation, and checking for matching start/end operations. The source and
 destination memref need not be of the same dimensionality, but need to have the
 same elemental type.
 

mlir/docs/LangRef.md

 #### AffineMap Attribute
 
 Syntax:
 
 ```
 affine-map-attribute ::= `affine_map` `<` affine-map `>`
 ```
 
-An affine-map attribute is an attribute that represents a affine-map object.
+An affine-map attribute is an attribute that represents an affine-map object.
 
 #### Array Attribute
 
 Syntax:
 
 ```
 array-attribute ::= `[` (attribute-value (`,` attribute-value)*)? `]`
 ```

mlir/docs/RationaleLinalgDialect.md

 To enable search, compiler transformations should be fine-grained,
 [composable](#declarative_transformations) and expose tuning parameters that
 can modify their behavior, guided by lessons from previous experience
 with [Tensor Comprehensions](#lessonstc).
 
 Of course, we are not advocating for using ML everywhere in the stack
 immediately: low-level compilation and machine models are still quite performant
 in LLVM. However, for the high-level and mid-level optimization problems,
-models need to be conditioned (probalistically) on the low-level
+models need to be conditioned (probabilistically) on the low-level
 compiler which acts as a blackbox. For these reasons we prioritize the
 design of IR and transformations with search-friendly properties over
 building cost models.
 Still, this  does not mean Linalg refuses cost models: instead we
 prefer to invest in infrastructure that will enable [ML-based
 techniques to automatically build cost
 models](http://homepages.inf.ed.ac.uk/hleather/publications/2009_autofeatures_cgo.pdf).
 

mlir/docs/doxygen.cfg.in

 # the HTML documentation. When you change the font size after a successful
 # doxygen run you need to manually remove any form_*.png images from the HTML
 # output directory to force them to be regenerated.
 # Minimum value: 8, maximum value: 50, default value: 10.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
 FORMULA_FONTSIZE       = 10
 
-# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
 # generated for formulas are transparent PNGs. Transparent PNGs are not
 # supported properly for IE 6.0, but are supported on all modern browsers.
 #
 # Note that when changing this option you need to delete any form_*.png files in
 # the HTML output directory before the changes have effect.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 

mlir/examples/toy/Ch7/mlir/Dialect.cpp

static void print(mlir::OpAsmPrinter &printer, ConstantOp op) {
   printer << op.value();
 }
 
 /// Verify that the given attribute value is valid for the given type.
 static mlir::LogicalResult verifyConstantForType(mlir::Type type,
                                                  mlir::Attribute opaqueValue,
                                                  mlir::Operation *op) {
   if (type.isa<mlir::TensorType>()) {
-    // Check that the value is a elements attribute.
+    // Check that the value is an elements attribute.
     auto attrValue = opaqueValue.dyn_cast<mlir::DenseFPElementsAttr>();
     if (!attrValue)
       return op->emitError("constant of TensorType must be initialized by "
                            "a DenseFPElementsAttr, got ")
              << opaqueValue;
 
     // If the return type of the constant is not an unranked tensor, the shape
     // must match the shape of the attribute holding the data.

mlir/include/mlir/Analysis/SliceAnalysis.h

 /// to avoid passing through certain types of operation in a configurable
 /// manner.
 using TransitiveFilter = std::function<bool(Operation *)>;
 
 /// Fills `forwardSlice` with the computed forward slice (i.e. all
 /// the transitive uses of op), **without** including that operation.
 ///
 /// This additionally takes a TransitiveFilter which acts as a frontier:
-/// when looking at uses transitively, a operation that does not pass the
+/// when looking at uses transitively, an operation that does not pass the
 /// filter is never propagated through. This allows in particular to carve out
 /// the scope within a ForInst or the scope within an IfInst.
 ///
 /// The implementation traverses the use chains in postorder traversal for
-/// efficiency reasons: if a operation is already in `forwardSlice`, no
+/// efficiency reasons: if an operation is already in `forwardSlice`, no
 /// need to traverse its uses again. Since use-def chains form a DAG, this
 /// terminates.
 ///
 /// Upon return to the root call, `forwardSlice` is filled with a
 /// postorder list of uses (i.e. a reverse topological order). To get a proper
 /// topological order, we just just reverse the order in `forwardSlice` before
 /// returning.
 ///
void getForwardSlice(
     Operation *op, llvm::SetVector<Operation *> *forwardSlice,
     TransitiveFilter filter = /* pass-through*/
     [](Operation *) { return true; });
 
 /// Fills `backwardSlice` with the computed backward slice (i.e.
 /// all the transitive defs of op), **without** including that operation.
 ///
 /// This additionally takes a TransitiveFilter which acts as a frontier:
-/// when looking at defs transitively, a operation that does not pass the
+/// when looking at defs transitively, an operation that does not pass the
 /// filter is never propagated through. This allows in particular to carve out
 /// the scope within a ForInst or the scope within an IfInst.
 ///
 /// The implementation traverses the def chains in postorder traversal for
-/// efficiency reasons: if a operation is already in `backwardSlice`, no
+/// efficiency reasons: if an operation is already in `backwardSlice`, no
 /// need to traverse its definitions again. Since useuse-def chains form a DAG,
 /// this terminates.
 ///
 /// Upon return to the root call, `backwardSlice` is filled with a
 /// postorder list of defs. This happens to be a topological order, from the
 /// point of view of the use-def chains.
 ///
 /// Example starting from node 8

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h

public:
   LLVM::LLVMType convertFunctionTypeCWrapper(FunctionType type);
 
   /// Creates descriptor structs from individual values constituting them.
   Operation *materializeConversion(PatternRewriter &rewriter, Type type,
                                    ArrayRef<Value> values,
                                    Location loc) override;
 
   /// Gets the LLVM representation of the index type. The returned type is an
-  /// integer type with the size confgured for this type converter.
+  /// integer type with the size configured for this type converter.
   LLVM::LLVMType getIndexType();
 
   /// Gets the bitwidth of the index type when converted to LLVM.
   unsigned getIndexTypeBitwidth() { return customizations.indexBitwidth; }
 
 protected:
   /// LLVM IR module used to parse/create types.
   llvm::Module *module;
ConvertOpToLLVMPattern(LLVMTypeConverter &typeConverter,
                          PatternBenefit benefit = 1)
       : ConvertToLLVMPattern(OpTy::getOperationName(),
                              &typeConverter.getContext(), typeConverter,
                              benefit) {}
 };
 
 namespace LLVM {
 namespace detail {
-/// Replaces the given operaiton "op" with a new operation of type "targetOp"
+/// Replaces the given operation "op" with a new operation of type "targetOp"
 /// and given operands.
 LogicalResult oneToOneRewrite(Operation *op, StringRef targetOp,
                               ValueRange operands,
                               LLVMTypeConverter &typeConverter,
                               ConversionPatternRewriter &rewriter);
 
 LogicalResult vectorOneToOneRewrite(Operation *op, StringRef targetOp,
                                     ValueRange operands,
                                     LLVMTypeConverter &typeConverter,
                                     ConversionPatternRewriter &rewriter);
 } // namespace detail
 } // namespace LLVM
 
 /// Generic implementation of one-to-one conversion from "SourceOp" to
 /// "TargetOp" where the latter belongs to the LLVM dialect or an equivalent.
 /// Upholds a convention that multi-result operations get converted into an
 /// operation returning the LLVM IR structure type, in which case individual
-/// values must be extacted from using LLVM::ExtractValueOp before being used.
+/// values must be extracted from using LLVM::ExtractValueOp before being used.
 template <typename SourceOp, typename TargetOp>
 class OneToOneConvertToLLVMPattern : public ConvertOpToLLVMPattern<SourceOp> {
 public:
   using ConvertOpToLLVMPattern<SourceOp>::ConvertOpToLLVMPattern;
   using Super = OneToOneConvertToLLVMPattern<SourceOp, TargetOp>;
 
   /// Converts the type of the result to an LLVM type, pass operands as is,
   /// preserve attributes.

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h

 /// LLVM using the bare pointer calling convention for MemRef function
 /// arguments. If `useAlloca` is set, the patterns for AllocOp and DeallocOp
 /// will generate `llvm.alloca` instead of calls to "malloc".
 void populateStdToLLVMBarePtrConversionPatterns(
     LLVMTypeConverter &converter, OwningRewritePatternList &patterns,
     bool useAlloca = false);
 
 /// Value to pass as bitwidth for the index type when the converter is expected
-/// to derive the bitwith from the LLVM data layout.
+/// to derive the bitwidth from the LLVM data layout.
 static constexpr unsigned kDeriveIndexBitwidthFromDataLayout = 0;
 
 /// Creates a pass to convert the Standard dialect into the LLVMIR dialect.
 /// By default stdlib malloc/free are used for allocating MemRef payloads.
 /// Specifying `useAlloca-true` emits stack allocations instead. In the future
 /// this may become an enum when we have concrete uses for other options.
 std::unique_ptr<OpPassBase<ModuleOp>> createLowerToLLVMPass(
     bool useAlloca = false, bool useBarePtrCallConv = false,
     bool emitCWrappers = false,
     unsigned indexBitwidth = kDeriveIndexBitwidthFromDataLayout);
 
 } // namespace mlir
 
 #endif // MLIR_CONVERSION_STANDARDTOLLVM_CONVERTSTANDARDTOLLVMPASS_H_

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

def MatmulOp : LinalgStructured_Op<"matmul", [NInputs<2>, NOutputs<1>]> {
   let hasFolder = 1;
 }
 
 /// A base class for pooling operation such as conv. The arguments must contain
 /// optional arguments `strides`, `dilations` and `padding` with following type:
 ///   OptionalAttr<I64ArrayAttr>:$strides
 ///   OptionalAttr<I64ArrayAttr>:$dilations
 ///   OptionalAttr<I64ElementsAttr>:$padding
-/// `stirdes` denotes the step of each window along the dimension.
+/// `strides` denotes the step of each window along the dimension.
 class PoolingBase_Op<string mnemonic, list<OpTrait> props>
   : LinalgStructured_Op<mnemonic, props> {
   let description = [{
     Performs an N-D pooling operation similarly to the description in the TF
     documentation:
     https://www.tensorflow.org/api_docs/python/tf/nn/pool
 
     Different from the description, this operation doesn't perform on batch and

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

 //===----------------------------------------------------------------------===//
 // AssumeAlignmentOp
 //===----------------------------------------------------------------------===//
 
 def AssumeAlignmentOp : Std_Op<"assume_alignment"> {
   let summary =
       "assertion that gives alignment information to the input memref";
   let description = [{
-    The `assume_alignment` operation takes a memref and a integer of alignment
+    The `assume_alignment` operation takes a memref and an integer of alignment
     value, and internally annotates the buffer with the given alignment. If
     the buffer isn't aligned to the given alignment, the behavior is undefined.
 
     This operation doesn't affect the semantics of a correct program. It's for
     optimization only, and the optimization is best-effort.
   }];
   let arguments = (ins AnyMemRef:$memref,
                        Confined<I32Attr, [IntPositive]>:$alignment);

mlir/include/mlir/IR/Attributes.h

public:
 
   /// Return if the given 'index' refers to a valid element in this attribute.
   bool isValidIndex(ArrayRef<uint64_t> index) const;
 
   /// Returns the number of elements held by this attribute.
   int64_t getNumElements() const;
 
   /// Generates a new ElementsAttr by mapping each int value to a new
-  /// underlying APInt. The new values can represent either a integer or float.
+  /// underlying APInt. The new values can represent either an integer or float.
   /// This ElementsAttr should contain integers.
   ElementsAttr mapValues(Type newElementType,
                          function_ref<APInt(const APInt &)> mapping) const;
 
   /// Generates a new ElementsAttr by mapping each float value to a new
-  /// underlying APInt. The new values can represent either a integer or float.
+  /// underlying APInt. The new values can represent either an integer or float.
   /// This ElementsAttr should contain floats.
   ElementsAttr mapValues(Type newElementType,
                          function_ref<APInt(const APFloat &)> mapping) const;
 
   /// Method for support type inquiry through isa, cast and dyn_cast.
   static bool classof(Attribute attr) {
     return attr.getKind() >= StandardAttributes::FIRST_ELEMENTS_ATTR &&
            attr.getKind() <= StandardAttributes::LAST_ELEMENTS_ATTR;
public:
   //===--------------------------------------------------------------------===//
 
   /// Return a new DenseElementsAttr that has the same data as the current
   /// attribute, but has been reshaped to 'newType'. The new type must have the
   /// same total number of elements as well as element type.
   DenseElementsAttr reshape(ShapedType newType);
 
   /// Generates a new DenseElementsAttr by mapping each int value to a new
-  /// underlying APInt. The new values can represent either a integer or float.
+  /// underlying APInt. The new values can represent either an integer or float.
   /// This underlying type must be an DenseIntElementsAttr.
   DenseElementsAttr mapValues(Type newElementType,
                               function_ref<APInt(const APInt &)> mapping) const;
 
   /// Generates a new DenseElementsAttr by mapping each float value to a new
-  /// underlying APInt. the new values can represent either a integer or float.
+  /// underlying APInt. the new values can represent either an integer or float.
   /// This underlying type must be an DenseFPElementsAttr.
   DenseElementsAttr
   mapValues(Type newElementType,
             function_ref<APInt(const APFloat &)> mapping) const;
 
 protected:
   /// Get iterators to the raw APInt values for each element in this attribute.
   IntElementIterator raw_int_begin() const {

mlir/include/mlir/IR/StandardTypes.h

verifyConstructionInvariants(Location loc, unsigned width,
                                SignednessSemantics signedness);
 
   /// Return the bitwidth of this integer type.
   unsigned getWidth() const;
 
   /// Return the signedness semantics of this integer type.
   SignednessSemantics getSignedness() const;
 
-  /// Return true if this is a singless integer type.
+  /// Return true if this is a signless integer type.
   bool isSignless() const { return getSignedness() == Signless; }
   /// Return true if this is a signed integer type.
   bool isSigned() const { return getSignedness() == Signed; }
   /// Return true if this is an unsigned integer type.
   bool isUnsigned() const { return getSignedness() == Unsigned; }
 
   /// Methods for support type inquiry through isa, cast, and dyn_cast.
   static bool kindof(unsigned kind) { return kind == StandardTypes::Integer; }

mlir/include/mlir/Pass/AnalysisManager.h

public:
   }
 
   // Query for a cached entry of the given analysis on the current operation.
   template <typename AnalysisT>
   Optional<std::reference_wrapper<AnalysisT>> getCachedAnalysis() const {
     return impl->analyses.getCachedAnalysis<AnalysisT>();
   }
 
-  /// Query for a analysis of a child operation, constructing it if necessary.
+  /// Query for an analysis of a child operation, constructing it if necessary.
   template <typename AnalysisT> AnalysisT &getChildAnalysis(Operation *op) {
     return slice(op).template getAnalysis<AnalysisT>();
   }
 
   /// Query for a cached analysis of a child operation, or return null.
   template <typename AnalysisT>
   Optional<std::reference_wrapper<AnalysisT>>
   getCachedChildAnalysis(Operation *op) const {

mlir/include/mlir/TableGen/Pattern.h

public:
 
   // Returns true if the given `symbol` is bound.
   bool contains(StringRef symbol) const;
 
   // Returns an iterator to the information of the given symbol named as `key`.
   const_iterator find(StringRef key) const;
 
   // Returns the number of static values of the given `symbol` corresponds to.
-  // A static value is a operand/result declared in ODS. Normally a symbol only
+  // A static value is an operand/result declared in ODS. Normally a symbol only
   // represents one static value, but symbols bound to op results can represent
   // more than one if the op is a multi-result op.
   int getStaticValueCount(StringRef symbol) const;
 
   // Returns a string containing the C++ expression for referencing this
   // symbol as a value (if this symbol represents one static value) or a value
   // range (if this symbol represents multiple static values). `fmt` is used to
   // format each value. `separator` is used to separate values if `symbol`

mlir/lib/Conversion/GPUToSPIRV/ConvertGPUToSPIRV.cpp

public:
   matchAndRewrite(loop::YieldOp terminatorOp, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.eraseOp(terminatorOp);
     return success();
   }
 };
 
 /// Pattern lowering GPU block/thread size/id to loading SPIR-V invocation
-/// builin variables.
+/// builtin variables.
 template <typename SourceOp, spirv::BuiltIn builtin>
 class LaunchConfigConversion : public SPIRVOpLowering<SourceOp> {
 public:
   using SPIRVOpLowering<SourceOp>::SPIRVOpLowering;
 
   LogicalResult
   matchAndRewrite(SourceOp op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override;

mlir/lib/Conversion/LoopsToGPU/LoopsToGPU.cpp

 /// affine maps. The first `map` is used to compute the actual index for
 /// substitution from the hardware id. The second `bound` is used to compute the
 /// launch dimension for the hardware id from the number of iterations the
 /// mapped loop is performing. Note that the number of iterations might be
 /// imprecise if the corresponding loop-bounds are loop-dependent. In such case,
 /// the hardware id might iterate over additional indices. The transformation
 /// caters for this by predicating the created sequence of instructions on
 /// the actual loop bound. This only works if an static upper bound for the
-/// dynamic loop bound can be defived, currently via analyzing `affine.min`
+/// dynamic loop bound can be derived, currently via analyzing `affine.min`
 /// operations.
 LogicalResult
 ParallelToGpuLaunchLowering::matchAndRewrite(ParallelOp parallelOp,
                                              PatternRewriter &rewriter) const {
   // Create a launch operation. We start with bound one for all grid/block
   // sizes. Those will be refined later as we discover them from mappings.
   Location loc = parallelOp.getLoc();
   Value constantOne = rewriter.create<ConstantIndexOp>(parallelOp.getLoc(), 1);

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

if (coords.empty())
       break;
     assert(coords.size() == info.arraySizes.size());
     auto position = builder.getI64ArrayAttr(coords);
     fun(position);
   }
 }
 ////////////// End Support for Lowering operations on n-D vectors //////////////
 
-/// Replaces the given operaiton "op" with a new operation of type "targetOp"
+/// Replaces the given operation "op" with a new operation of type "targetOp"
 /// and given operands.
 LogicalResult LLVM::detail::oneToOneRewrite(
     Operation *op, StringRef targetOp, ValueRange operands,
     LLVMTypeConverter &typeConverter, ConversionPatternRewriter &rewriter) {
   unsigned numResults = op->getNumResults();
 
   Type packedType;
   if (numResults != 0) {
if (srcType.isa<MemRefType>() && dstType.isa<MemRefType>()) {
               .create<LLVM::BitcastOp>(
                   loc, targetStructType.cast<LLVM::LLVMType>().getPointerTo(),
                   ptr)
               .getResult();
       // struct = LoadOp castPtr
       auto loadOp = rewriter.create<LLVM::LoadOp>(loc, castPtr);
       rewriter.replaceOp(op, loadOp.getResult());
     } else {
-      llvm_unreachable("Unsuppored unranked memref to unranked memref cast");
+      llvm_unreachable("Unsupported unranked memref to unranked memref cast");
     }
   }
 };
 
 struct DialectCastOpLowering
     : public ConvertOpToLLVMPattern<LLVM::DialectCastOp> {
   using ConvertOpToLLVMPattern<LLVM::DialectCastOp>::ConvertOpToLLVMPattern;
 
for (int i = viewMemRefType.getRank() - 1; i >= 0; --i) {
       targetMemRef.setStride(rewriter, loc, i, newStride);
     }
 
     rewriter.replaceOp(op, {targetMemRef});
     return success();
   }
 };
 
-/// Conversion pattern that transforms a op into:
+/// Conversion pattern that transforms an op into:
 ///   1. An `llvm.mlir.undef` operation to create a memref descriptor
 ///   2. Updates to the descriptor to introduce the data ptr, offset, size
 ///      and stride.
 /// The view op is replaced by the descriptor.
 struct ViewOpLowering : public ConvertOpToLLVMPattern<ViewOp> {
   using ConvertOpToLLVMPattern<ViewOp>::ConvertOpToLLVMPattern;
 
   // Build and return the value for the idx^th shape dimension, either by

mlir/lib/Conversion/StandardToSPIRV/ConvertStandardToSPIRV.cpp

 static bool isBoolScalarOrVector(Type type) {
   if (type.isInteger(1))
     return true;
   if (auto vecType = type.dyn_cast<VectorType>())
     return vecType.getElementType().isInteger(1);
   return false;
 }
 
-/// Converts the given `srcAttr` into a boolean attribute if it holds a integral
-/// value. Returns null attribute if conversion fails.
+/// Converts the given `srcAttr` into a boolean attribute if it holds an
+/// integral value. Returns null attribute if conversion fails.
 static BoolAttr convertBoolAttr(Attribute srcAttr, Builder builder) {
   if (auto boolAttr = srcAttr.dyn_cast<BoolAttr>())
     return boolAttr;
   if (auto intAttr = srcAttr.dyn_cast<IntegerAttr>())
     return builder.getBoolAttr(intAttr.getValue().getBoolValue());
   return BoolAttr();
 }
 

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

if (!kernelGPUFunction && !kernelLLVMFunction)
              << kernelName << "' is undefined";
     if (!kernelFunc->getAttrOfType<mlir::UnitAttr>(
             GPUDialect::getKernelFuncAttrName()))
       return launchOp.emitOpError("kernel function is missing the '")
              << GPUDialect::getKernelFuncAttrName() << "' attribute";
 
     // TODO(ntv,zinenko,herhut): if the kernel function has been converted to
     // the LLVM dialect but the caller hasn't (which happens during the
-    // separate compilation), do not check type correspondance as it would
+    // separate compilation), do not check type correspondence as it would
     // require the verifier to be aware of the LLVM type conversion.
     if (kernelLLVMFunction)
       return success();
 
     unsigned actualNumArguments = launchOp.getNumKernelOperands();
     unsigned expectedNumArguments = kernelGPUFunction.getNumArguments();
     if (expectedNumArguments != actualNumArguments)
       return launchOp.emitOpError("got ")

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

private:
 
   /// Returns an accumulator factory that creates an op of type T.
   template <typename T> AccumulatorFactory getFactory() {
     return [&](Value lhs, Value rhs) {
       return create<T>(lhs.getType(), lhs, rhs);
     };
   }
 
-  /// Returns an accumulator for comparaison such as min, max. T is the type
+  /// Returns an accumulator for comparison such as min, max. T is the type
   /// of the compare op.
   template <typename T, typename PredicateEnum, PredicateEnum predicate>
   AccumulatorFactory getCmpFactory() const {
     return [&](Value lhs, Value rhs) {
       Value cmp = rewriter.create<T>(loc, predicate, lhs, rhs);
       return rewriter.create<SelectOp>(loc, cmp, lhs, rhs);
     };
   }

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

static gpu::GPUFuncOp outlineKernelFuncImpl(gpu::LaunchOp launchOp,
 
   // Clone the region of the gpu.launch operation into the gpu.func operation.
   // TODO(ravishankarm): If cloneInto can be modified such that if a mapping for
   // a block exists, that block will be used to clone operations into (at the
   // end of the block), instead of creating a new block, this would be much
   // cleaner.
   launchOpBody.cloneInto(&outlinedFuncBody, map);
 
-  // Branch from enty of the gpu.func operation to the block that is cloned from
-  // the entry block of the gpu.launch operation.
+  // Branch from entry of the gpu.func operation to the block that is cloned
+  // from the entry block of the gpu.launch operation.
   Block &launchOpEntry = launchOpBody.front();
   Block *clonedLaunchOpEntry = map.lookup(&launchOpEntry);
   builder.setInsertionPointToEnd(&entryBlock);
   builder.create<BranchOp>(loc, clonedLaunchOpEntry);
 
   outlinedFunc.walk([](gpu::TerminatorOp op) {
     OpBuilder replacer(op);
     replacer.create<gpu::ReturnOp>(op.getLoc());

mlir/lib/Dialect/LoopOps/Transforms/ParallelLoopSpecialization.cpp

-//===- ParallelLoopSpecialization.cpp - loop.parallel specializeation -----===//
+//===- ParallelLoopSpecialization.cpp - loop.parallel specialization ------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Specializes parallel loops for easier unrolling and vectorization.

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

static LogicalResult verify(spirv::UnreachableOp unreachableOp) {
   auto *block = op->getBlock();
   // Fast track: if this is in entry block, its invalid. Otherwise, if no
   // predecessors, it's valid.
   if (block->isEntryBlock())
     return unreachableOp.emitOpError("cannot be used in reachable block");
   if (block->hasNoPredecessors())
     return success();
 
-  // TODO(antiagainst): further verification needs to analyze reachablility from
+  // TODO(antiagainst): further verification needs to analyze reachability from
   // the entry block.
 
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // spv.Variable
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/Vector/VectorOps.cpp

static LogicalResult verify(ReshapeOp op) {
   if (inputVectorType.getRank() != inputShapeRank + numFixedVectorSizes)
     return op.emitError("invalid input shape for vector type ")
            << inputVectorType;
 
   if (outputVectorType.getRank() != outputShapeRank + numFixedVectorSizes)
     return op.emitError("invalid output shape for vector type ")
            << outputVectorType;
 
-  // Verify that the 'fixedVectorSizes' match a input/output vector shape
+  // Verify that the 'fixedVectorSizes' match an input/output vector shape
   // suffix.
   unsigned inputVectorRank = inputVectorType.getRank();
   for (unsigned i = 0; i < numFixedVectorSizes; ++i) {
     unsigned index = inputVectorRank - numFixedVectorSizes - i;
     if (fixedVectorSizes[i] != inputVectorType.getShape()[index])
       return op.emitError("fixed vector size must match input vector for dim ")
              << i;
   }

mlir/lib/IR/AttributeDetail.h

auto val = APInt(APFloat::getSizeInBits(semantics),
                      {getTrailingObjects<uint64_t>(), numObjects});
     return APFloat(semantics, val);
   }
 
   const llvm::fltSemantics &semantics;
   size_t numObjects;
 };
 
-/// An attribute representing a integral value.
+/// An attribute representing an integral value.
 struct IntegerAttributeStorage final
     : public AttributeStorage,
       public llvm::TrailingObjects<IntegerAttributeStorage, uint64_t> {
   using KeyTy = std::pair<Type, APInt>;
 
   IntegerAttributeStorage(Type type, size_t numObjects)
       : AttributeStorage(type), numObjects(numObjects) {
     assert((type.isIndex() || type.isa<IntegerType>()) && "invalid type");

mlir/lib/IR/Operation.cpp

 }
 
 Block *llvm::ilist_traits<::mlir::Operation>::getContainingBlock() {
   size_t Offset(size_t(&((Block *)nullptr->*Block::getSublistAccess(nullptr))));
   iplist<Operation> *Anchor(static_cast<iplist<Operation> *>(this));
   return reinterpret_cast<Block *>(reinterpret_cast<char *>(Anchor) - Offset);
 }
 
-/// This is a trait method invoked when a operation is added to a block.  We
+/// This is a trait method invoked when an operation is added to a block.  We
 /// keep the block pointer up to date.
 void llvm::ilist_traits<::mlir::Operation>::addNodeToList(Operation *op) {
-  assert(!op->getBlock() && "already in a operation block!");
+  assert(!op->getBlock() && "already in an operation block!");
   op->block = getContainingBlock();
 
   // Invalidate the order on the operation.
   op->orderIndex = Operation::kInvalidOrderIdx;
 }
 
-/// This is a trait method invoked when a operation is removed from a block.
+/// This is a trait method invoked when an operation is removed from a block.
 /// We keep the block pointer up to date.
 void llvm::ilist_traits<::mlir::Operation>::removeNodeFromList(Operation *op) {
-  assert(op->block && "not already in a operation block!");
+  assert(op->block && "not already in an operation block!");
   op->block = nullptr;
 }
 
-/// This is a trait method invoked when a operation is moved from one block
+/// This is a trait method invoked when an operation is moved from one block
 /// to another.  We keep the block pointer up to date.
 void llvm::ilist_traits<::mlir::Operation>::transferNodesFromList(
     ilist_traits<Operation> &otherList, op_iterator first, op_iterator last) {
   Block *curParent = getContainingBlock();
 
   // Invalidate the ordering of the parent block.
   curParent->invalidateOpOrder();
 

mlir/lib/IR/SymbolTable.cpp

for (Block &block : *worklist.pop_back_val()) {
             worklist.push_back(&region);
         }
       }
     }
   }
   return WalkResult::advance();
 }
 /// Walk all of the uses, for any symbol, that are nested within the given
-/// operaion 'from', invoking the provided callback for each. This does not
+/// operation 'from', invoking the provided callback for each. This does not
 /// traverse into any nested symbol tables.
 static Optional<WalkResult> walkSymbolUses(
     Operation *from,
     function_ref<WalkResult(SymbolTable::SymbolUse, ArrayRef<int>)> callback) {
   // If this operation has regions, and it, as well as its dialect, isn't
   // registered then conservatively fail. The operation may define a
   // symbol table, so we can't opaquely know if we should traverse to find
   // nested uses.

mlir/lib/Pass/PassTiming.cpp

struct PassTiming : public PassInstrumentation {
   /// collection. The timers are mapped to the parent info to merge into.
   DenseMap<PipelineParentInfo, SmallVector<Timer::ChildrenMap::value_type, 4>>
       pipelinesToMerge;
 };
 } // end anonymous namespace
 
 void PassTiming::runBeforePipeline(const OperationName &name,
                                    const PipelineParentInfo &parentInfo) {
-  // We don't actually want to time the piplelines, they gather their total
+  // We don't actually want to time the pipelines, they gather their total
   // from their held passes.
   getTimer(name.getAsOpaquePointer(), TimerKind::Pipeline,
            [&] { return ("'" + name.getStringRef() + "' Pipeline").str(); });
 }
 
 void PassTiming::runAfterPipeline(const OperationName &name,
                                   const PipelineParentInfo &parentInfo) {
   // Pop the timer for the pipeline.

mlir/lib/Transforms/Utils/LoopUtils.cpp

if (!depthToLoops.empty()) {
     assert(depthToLoops.back().empty() && "Last loop level is not empty?");
     depthToLoops.pop_back();
   }
 }
 
 // TODO: if necessary, this can be extended to also compose in any
 // affine.applys, fold to constant if all result dimensions of the map are
 // constant (canonicalizeMapAndOperands below already does this for single
-// result bound maps), and use simplifyMap to perform algebraic simplication.
+// result bound maps), and use simplifyMap to perform algebraic simplification.
 AffineForOp mlir::createCanonicalizedAffineForOp(
     OpBuilder b, Location loc, ValueRange lbOperands, AffineMap lbMap,
     ValueRange ubOperands, AffineMap ubMap, int64_t step) {
   SmallVector<Value, 4> lowerOperands(lbOperands);
   SmallVector<Value, 4> upperOperands(ubOperands);
 
   fullyComposeAffineMapAndOperands(&lbMap, &lowerOperands);
   canonicalizeMapAndOperands(&lbMap, &lowerOperands);

mlir/test/Conversion/AffineToStandard/lower-affine.mlir

affine.for %i = 0 to 42 {
     }
   }
   return
 }
 
 #map_7_values = affine_map<(d0, d1, d2, d3, d4, d5, d6) -> (d0, d1, d2, d3, d4, d5, d6)>
 
 // Check that the "min" (cmpi "slt" + select) reduction sequence is emitted
-// correctly for a an affine map with 7 results.
+// correctly for an affine map with 7 results.
 
 // CHECK-LABEL: func @min_reduction_tree
 // CHECK-NEXT:   %[[c0:.*]] = constant 0 : index
 // CHECK-NEXT:   %[[c01:.+]] = cmpi "slt", %{{.*}}, %{{.*}} : index
 // CHECK-NEXT:   %[[r01:.+]] = select %[[c01]], %{{.*}}, %{{.*}} : index
 // CHECK-NEXT:   %[[c012:.+]] = cmpi "slt", %[[r01]], %{{.*}} : index
 // CHECK-NEXT:   %[[r012:.+]] = select %[[c012]], %[[r01]], %{{.*}} : index
 // CHECK-NEXT:   %[[c0123:.+]] = cmpi "slt", %[[r012]], %{{.*}} : index

mlir/test/Dialect/SPIRV/types.mlir

 // -----
 
 // expected-error @+1 {{cannot use '!llvm.i32' to compose SPIR-V types}}
 func @llvm_type(!spv.array<4x!llvm.i32>) -> ()
 
 // -----
 
 // expected-error @+1 {{ArrayStride must be greater than zero}}
-func @array_type_zero_stide(!spv.array<4xi32 [0]>) -> ()
+func @array_type_zero_stride(!spv.array<4xi32 [0]>) -> ()
 
 // -----
 
 // expected-error @+1 {{expected array length greater than 0}}
 func @array_type_zero_length(!spv.array<0xf32>) -> ()
 
 // -----
 

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

legalizerConversionMode(
                        "analysis", "Perform an analysis conversion"),
             clEnumValN(TestLegalizePatternDriver::ConversionMode::Full, "full",
                        "Perform a full conversion"),
             clEnumValN(TestLegalizePatternDriver::ConversionMode::Partial,
                        "partial", "Perform a partial conversion")));
 
 //===----------------------------------------------------------------------===//
 // ConversionPatternRewriter::getRemappedValue testing. This method is used
-// to get the remapped value of a original value that was replaced using
+// to get the remapped value of an original value that was replaced using
 // ConversionPatternRewriter.
 namespace {
 /// Converter that replaces a one-result one-operand OneVResOneVOperandOp1 with
 /// a one-operand two-result OneVResOneVOperandOp1 by replicating its original
 /// operand twice.
 ///
 /// Example:
 ///   %1 = test.one_variadic_out_one_variadic_in1"(%0)

mlir/test/mlir-tblgen/op-format-spec.td

 def OptionalInvalidK : TestFormat_Op<"optional_invalid_k", [{
   ($arg^)
 }]>, Arguments<(ins Variadic<I64>:$arg)>;
 
 //===----------------------------------------------------------------------===//
 // Variables
 //===----------------------------------------------------------------------===//
 
-// CHECK: error: expected variable to refer to a argument, result, or successor
+// CHECK: error: expected variable to refer to an argument, result, or successor
 def VariableInvalidA : TestFormat_Op<"variable_invalid_a", [{
   $unknown_arg attr-dict
 }]>;
 // CHECK: error: attribute 'attr' is already bound
 def VariableInvalidB : TestFormat_Op<"variable_invalid_b", [{
   $attr $attr attr-dict
 }]>, Arguments<(ins I64Attr:$attr)>;
 // CHECK: error: operand 'operand' is already bound

mlir/tools/mlir-tblgen/OpFormatGen.cpp

static void genElementPrinter(Element *element, OpMethodBody &body,
   if (shouldEmitSpace || !lastWasPunctuation)
     body << "  p << \" \";\n";
   lastWasPunctuation = false;
   shouldEmitSpace = true;
 
   if (auto *attr = dyn_cast<AttributeVariable>(element)) {
     const NamedAttribute *var = attr->getVar();
 
-    // If we are formatting as a enum, symbolize the attribute as a string.
+    // If we are formatting as an enum, symbolize the attribute as a string.
     if (canFormatEnumAttr(var)) {
       const EnumAttr &enumAttr = cast<EnumAttr>(var->attr);
       body << "  p << \"\\\"\" << " << enumAttr.getSymbolToStringFnName() << "("
            << var->name << "()) << \"\\\"\";\n";
       return;
     }
 
     // Elide the attribute type if it is buildable.
if (const auto *successor = findArg(op.getSuccessors(), name)) {
     if (!isTopLevel)
       return emitError(loc, "successors can only be used at the top level");
     if (hasAllSuccessors || !seenSuccessors.insert(successor).second)
       return emitError(loc, "successor '" + name + "' is already bound");
     element = std::make_unique<SuccessorVariable>(successor);
     return success();
   }
   return emitError(
-      loc, "expected variable to refer to a argument, result, or successor");
+      loc, "expected variable to refer to an argument, result, or successor");
 }
 
 LogicalResult FormatParser::parseDirective(std::unique_ptr<Element> &element,
                                            bool isTopLevel) {
   Token dirTok = curToken;
   consumeToken();
 
   switch (dirTok.getKind()) {

mlir/tools/mlir-tblgen/RewriterGen.cpp

private:
 
   using ChildNodeIndexNameMap = DenseMap<unsigned, std::string>;
 
   // Emits a local variable for each value and attribute to be used for creating
   // an op.
   void createSeparateLocalVarsForOpArgs(DagNode node,
                                         ChildNodeIndexNameMap &childNodeNames);
 
-  // Emits the concrete arguments used to call a op's builder.
+  // Emits the concrete arguments used to call an op's builder.
   void supplyValuesForOpArgs(DagNode node,
                              const ChildNodeIndexNameMap &childNodeNames);
 
   // Emits the local variables for holding all values as a whole and all named
   // attributes as a whole to be used for creating an op.
   void createAggregateLocalVarsForOpArgs(
       DagNode node, const ChildNodeIndexNameMap &childNodeNames);
 

mlir/tools/mlir-vulkan-runner/VulkanRuntime.h

 
 /// Vulkan runtime.
 /// The purpose of this class is to run SPIR-V compute shader on Vulkan
 /// device.
 /// Before the run, user must provide and set resource data with descriptors,
 /// SPIR-V shader, number of work groups and entry point. After the creation of
 /// VulkanRuntime, special methods must be called in the following
 /// sequence: initRuntime(), run(), updateHostMemoryBuffers(), destroy();
-/// each method in the sequence returns succes or failure depends on the Vulkan
+/// each method in the sequence returns success or failure depends on the Vulkan
 /// result code.
 class VulkanRuntime {
 public:
   explicit VulkanRuntime() = default;
   VulkanRuntime(const VulkanRuntime &) = delete;
   VulkanRuntime &operator=(const VulkanRuntime &) = delete;
 
   /// Sets needed data for Vulkan runtime.

mlir/tools/mlir-vulkan-runner/VulkanRuntime.cpp

for (const auto &resourceDataBindingPair : resourceDataMap) {
       VkDescriptorType descriptorType = {};
       VkBufferUsageFlagBits bufferUsage = {};
 
       // Check that descriptor set has storage class map.
       const auto resourceStorageClassMapIt =
           resourceStorageClassData.find(descriptorSetIndex);
       if (resourceStorageClassMapIt == resourceStorageClassData.end()) {
         llvm::errs()
-            << "cannot find storge class for resource in descriptor set: "
+            << "cannot find storage class for resource in descriptor set: "
             << descriptorSetIndex;
         return failure();
       }
 
       // Check that specific descriptor binding has storage class.
       const auto &resourceStorageClassMap = resourceStorageClassMapIt->second;
       const auto resourceStorageClassIt =
           resourceStorageClassMap.find(resourceDataBindingPair.first);

mlir/utils/spirv/gen_spirv_dialect.py

 def snake_casify(name):
   """Turns the given name to follow snake_case convention."""
   name = re.sub('\W+', '', name).split()
   name = [s.lower() for s in name]
   return '_'.join(name)
 
 
 def map_spec_operand_to_ods_argument(operand):
-  """Maps a operand in SPIR-V JSON spec to an op argument in ODS.
+  """Maps an operand in SPIR-V JSON spec to an op argument in ODS.
 
   Arguments:
     - A dict containing the operand's kind, quantifier, and name
 
   Returns:
     - A string containing both the type and name for the argument
   """
   kind = operand['kind']
- capability_mapping: mapping from duplicated capability symbols to the
                    canonicalized symbol chosen for SPIRVBase.td.
 
   Returns:
     - A string containing all the TableGen op definitions
   """
   with open(path, 'r') as f:
     content = f.read()
 
-  # Split the file into chuncks, each containing one op.
+  # Split the file into chunks, each containing one op.
   ops = content.split(AUTOGEN_OP_DEF_SEPARATOR)
   header = ops[0]
   footer = ops[-1]
   ops = ops[1:-1]
 
   # For each existing op, extract the manually-written sections out to retain
   # them when re-generating the ops. Also append the existing ops to filter
   # list.