[mlir]: NFC: Fix trivial typo in documents and comments

mlir/docs/Dialects/LLVM.md

 
 LLVM IR has broad support for first-class constants, which is not the case for
 MLIR. Instead, constants are defined in MLIR as regular SSA values produced by
 operations with specific traits. The LLVM dialect provides a set of operations
 that model LLVM IR constants. These operations do not correspond to LLVM IR
 instructions and are therefore prefixed with `llvm.mlir`.
 
 Inline constants can be created by `llvm.mlir.constant`, which currently
-supports integer, float, string or elements attributes (constant sturcts are not
+supports integer, float, string or elements attributes (constant structs are not
 currently supported). LLVM IR constant expressions are expected to be
 constructed as sequences of regular operations on SSA values produced by
 `llvm.mlir.constant`. Additionally, MLIR provides semantically-charged
 operations `llvm.mlir.undef` and `llvm.mlir.null` for the corresponding
 constants.
 
 LLVM IR globals can be defined using `llvm.mlir.global` at the module level,
 except for functions that are defined with `llvm.func`. Globals, both variables

mlir/docs/SPIRVToLLVMDialectConversion.md

 # SPIR-V Dialect to LLVM Dialect conversion manual
 
 This manual describes the conversion from [SPIR-V Dialect](Dialects/SPIR-V.md)
 to [LLVM Dialect](Dialects/LLVM.md). It assumes familiarity with both, and
-describes the design choices behind the modelling of SPIR-V conscepts in LLVM
+describes the design choices behind the modelling of SPIR-V concepts in LLVM
 Dialect. The conversion is an ongoing work, and is expected to grow as more
 features are implemented.
 
 Conversion can be performed by invoking an appropriate conversion pass:
 
 ```shell
 mlir-opt -convert-spirv-to-llvm <filename.mlir>
 ```

 **not** take it into account.
 
 SPIR-V Dialect                                | LLVM Dialect
 :-------------------------------------------: | :-------------------------:
 `!spv.ptr< <element-type>, <storage-class> >` | `!llvm.element-type*`
 
 ### Array types
 
-SPIR-V distiguishes between array type and run-time array type, the length of
+SPIR-V distinguishes between array type and run-time array type, the length of
 which is not known at compile time. In LLVM, it is possible to index beyond the
 end of the array. Therfore, runtime array can be implemented as a zero length
 array type.
 
 Moreover, SPIR-V supports the notion of array stride. Note that this is **not**
 supported by type conversion at the moment.
 
 SPIR-V Dialect                        | LLVM Dialect
*   `offset` and `count` may have different bitwidths from `base`. In this case,
     be:
 
     ```mlir
     // Zero extending offest after broadcasting
     %res_offset = llvm.zext %vec_offset: !llvm<"<2 x i8>"> to !llvm<"<2 x i32>">
     ```
 
     Also, note that if the bitwidth of `offset` or `count` is greater than the
-    bitwidth of `base`, truncation is still permitted. This is beacuse the ops have a
+    bitwidth of `base`, truncation is still permitted. This is because the ops have a
     defined behaviour with `offset` and `count` being less than the size of
     `base`. It creates a natural upper bound on what values `offset` and `count`
     can take, which is 64. This can be expressed in less than 8 bits.
 
 Now, having these two cases in mind, we can proceed with conversion for the ops
 and their operands.
 
 ##### `spv.BitFieldInsert`

 
 SPIR-V comparison ops are mapped to LLVM `icmp` and `fcmp` operations.
 
 SPIR-V Dialect op                     | LLVM Dialect op
 :-----------------------------------: | :-----------------------------------:
 `spv.IEqual`                          | `llvm.icmp "eq"`
 `spv.INotEqual`                       | `llvm.icmp "ne"`
 `spv.FOrdEqual`                       | `llvm.fcmp "oeq"`
-`spv.FOrdGreaterhan`                  | `llvm.fcmp "ogt"`
+`spv.FOrdGreaterThan`                 | `llvm.fcmp "ogt"`
 `spv.FOrdGreaterThanEqual`            | `llvm.fcmp "oge"`
 `spv.FOrdLessThan`                    | `llvm.fcmp "olt"`
 `spv.FOrdLessThanEqual`               | `llvm.fcmp "ole"`
 `spv.FOrdNotEqual`                    | `llvm.fcmp "one"`
 `spv.FUnordEqual`                     | `llvm.fcmp "ueq"`
-`spv.FUnordGreaterhan`                | `llvm.fcmp "ugt"`
+`spv.FUnordGreaterThan`               | `llvm.fcmp "ugt"`
 `spv.FUnordGreaterThanEqual`          | `llvm.fcmp "uge"`
 `spv.FUnordLessThan`                  | `llvm.fcmp "ult"`
 `spv.FUnordLessThanEqual`             | `llvm.fcmp "ule"`
 `spv.FUnordNotEqual`                  | `llvm.fcmp "une"`
 `spv.SGreaterThan`                    | `llvm.icmp "sgt"`
 `spv.SGreaterThanEqual`               | `llvm.icmp "sge"`
 `spv.SLessThan`                       | `llvm.icmp "slt"`
 `spv.SLessThanEqual`                  | `llvm.icmp "sle"`

 
 ### `spv.constant`
 
 At the moment `spv.constant` conversion supports scalar and vector constants
 **only**.
 
 #### Mapping
 
-`spv.constant` is mapped to `llvm.mlir.constant`. This is a strightforward
+`spv.constant` is mapped to `llvm.mlir.constant`. This is a straightforward
 conversion pattern with a special case when the argument is signed or unsigned.
 
 #### Special case
 
 SPIR-V constant can be a signed or unsigned integer. Since LLVM Dialect does not
-have signedness semantics, this case should be handeled separately. 
+have signedness semantics, this case should be handled separately.
 
 The conversion casts constant value attribute to a signless integer or a vector
 of signless integers. This is correct because in SPIR-V, like in LLVM, how to
 interpret an integer number is also dictated by the opcode. However, in reality
 hardware implementation might show unexpected behavior. Therefore, it is better
 to handle it case-by-case, given that the purpose of the conversion is not to
 cover all possible corner cases.
 

 ## Control flow conversion
 
 **Note: these conversions have not been implemented yet**
 
 ## Decorations conversion
 
 **Note: these conversions have not been implemented yet**
 
-## GLSL extended instriction set
+## GLSL extended instruction set
 
 **Note: these conversions have not been implemented yet**
 
 This section describes how SPIR-V ops from GLSL extended instructions set are
 mapped to LLVM Dialect.
 
 ### Direct conversions
 

mlir/lib/Analysis/Presburger/Simplex.cpp

for (unsigned i = simplexConstraintOffset; i < conIndex; i += 2) {
       //
       // After finding a column, we pivot with the column, after which we can
       // get the dual from the inequality in column position as explained above.
       if (simplex.con[i].orientation == Orientation::Column) {
         dual.push_back(-simplex.tableau(row, simplex.con[i].pos));
       } else {
         if (simplex.con[i + 1].orientation == Orientation::Row) {
           unsigned ineqRow = simplex.con[i + 1].pos;
-          // Since it is an equality, the the sample value must be zero.
+          // Since it is an equality, the sample value must be zero.
           assert(simplex.tableau(ineqRow, 1) == 0 &&
                  "Equality's sample value must be zero.");
           for (unsigned col = 2; col < simplex.nCol; ++col) {
             if (simplex.tableau(ineqRow, col) != 0) {
               simplex.pivot(ineqRow, col);
               break;
             }
           }

mlir/lib/Conversion/GPUToVulkan/ConvertLaunchFuncToVulkanCalls.cpp

return LLVM::LLVMType::getStructTy(
          llvmArrayRankElementSizeType, llvmArrayRankElementSizeType});
   }
 
   LLVM::LLVMType getVoidType() { return llvmVoidType; }
   LLVM::LLVMType getPointerType() { return llvmPointerType; }
   LLVM::LLVMType getInt32Type() { return llvmInt32Type; }
   LLVM::LLVMType getInt64Type() { return llvmInt64Type; }
 
-  /// Creates a LLVM global for the given `name`.
+  /// Creates an LLVM global for the given `name`.
   Value createEntryPointNameConstant(StringRef name, Location loc,
                                      OpBuilder &builder);
 
   /// Declares all needed runtime functions.
   void declareVulkanFunctions(Location loc);
 
   /// Checks whether the given LLVM::CallOp is a vulkan launch call op.
   bool isVulkanLaunchCallOp(LLVM::CallOp callOp) {

mlir/tools/mlir-tblgen/LLVMIRConversionGen.cpp

 static bool isOperandName(const tblgen::Operator &op, StringRef name) {
   for (int i = 0, e = op.getNumOperands(); i < e; ++i)
     if (op.getOperand(i).name == name)
       return true;
   return false;
 }
 
 // Emit to `os` the operator-name driven check and the call to LLVM IRBuilder
-// for one definition of a LLVM IR Dialect operation.  Return true on success.
+// for one definition of an LLVM IR Dialect operation.  Return true on success.
 static bool emitOneBuilder(const Record &record, raw_ostream &os) {
   auto op = tblgen::Operator(record);
 
   if (!record.getValue("llvmBuilder"))
     return emitError("no 'llvmBuilder' field for op " + op.getOperationName());
 
   // Return early if there is no builder specified.
   auto builderStrRef = record.getValueAsString("llvmBuilder");