Merge pull request #213 from CodaFi/docer

Drop some triple Ses

Author: CodaFi

Sources/LLVM/MDBuilder.swift

@@ -413,12 +413,12 @@ extension MDBuilder {
   ///   - accessType: The type of the accessed value.  This is the type that
   ///     corresponds to the type of the destination value in a `load`
   ///     instruction, or the type of the source value in a `store` instruction.
-  ///   - offset: The ofset of the memory accesss into the base type.  If the
+  ///   - offset: The ofset of the memory access into the base type.  If the
   ///     base type is scalar, this value must be 0.
   ///   - size: The size of the access in bytes.
   ///   - immutable: If true, accesses to this memory are never writes.
   ///     This corresponds to the `const` memory qualifier in C and C++.
-  /// - Returns: A metadata node representing a TBAA accesss tag.
+  /// - Returns: A metadata node representing a TBAA access tag.
   public func buildTBAAAccessTag(
     baseType: MDNode, accessType: MDNode,
     offset: Size, size: Size, immutable: Bool = false

Sources/LLVM/PassPipeliner.swift

@@ -9,7 +9,7 @@ import llvmshims
 /// A `PassPipeliner` handles the creation of a related set of optimization
 /// passes called a "pipeline".  Grouping passes is done for multiple reasons,
 /// chief among them is that optimizer passes are extremely sensitive to their
-/// ordering relative to other passses.  In addition, pass groupings allow for
+/// ordering relative to other passes.  In addition, pass groupings allow for
 /// the clean segregation of otherwise unrelated passes.  For example, a
 /// pipeline might consist of "mandatory" passes such as Jump Threading, LICM,
 /// and DCE in one pipeline and "diagnostic" passes in another.

Sources/LLVM/Triple.swift

@@ -187,7 +187,7 @@ public struct Triple: Equatable {
 
   /// Normalizes a target triple format string.
   ///
-  /// The normalization processs converts an arbitrary machine specification
+  /// The normalization process converts an arbitrary machine specification
   /// into the canonical triple form.  In particular, it handles the
   /// common case in which otherwise valid components are in the wrong order.
   ///