Merge pull request #42514 from jsoref/spelling-siloptimizer

Spelling siloptimizer

Author: tshortli

include/swift/SILOptimizer/Analysis/ARCAnalysis.h

@@ -117,7 +117,7 @@ valueHasARCDecrementOrCheckInInstructionRange(SILValue Op,
 /// in the predecessors. 
 ///
 /// The search stop when we encounter an instruction that may decrement
-/// the return'ed value, as we do not want to create a lifetime gap once the
+/// the returned value, as we do not want to create a lifetime gap once the
 /// retain is moved.
 class ConsumedResultToEpilogueRetainMatcher {
 public:

include/swift/SILOptimizer/Analysis/AccessStorageAnalysis.h

@@ -125,7 +125,7 @@ namespace swift {
 using AccessStorageSet = llvm::SmallDenseSet<StorageAccessInfo, 8>;
 
 /// Records each unique AccessStorage in a set of StorageAccessInfo
-/// objects. Hashing and equality only sees the AccesedStorage data. The
+/// objects. Hashing and equality only sees the AccessedStorage data. The
 /// additional StorageAccessInfo bits are recorded as results of this analysis.
 ///
 /// Any unidentified accesses are summarized as a single unidentifiedAccess

include/swift/SILOptimizer/Analysis/AccessSummaryAnalysis.h

@@ -108,7 +108,7 @@ class AccessSummaryAnalysis : public BottomUpIPAnalysis {
   public:
     FunctionSummary(unsigned argCount) : ArgAccesses(argCount) {}
 
-    /// Returns of summary of the the function accesses that argument at the
+    /// Returns of summary of the function accesses that argument at the
     /// given index.
     ArgumentSummary &getAccessForArgument(unsigned argument) {
       return ArgAccesses[argument];
@@ -229,7 +229,7 @@ class AccessSummaryAnalysis : public BottomUpIPAnalysis {
   void processFunction(FunctionInfo *info, FunctionOrder &order);
 
   /// Summarize how the function uses the given argument.
-  void processArgument(FunctionInfo *info, SILFunctionArgument *argment,
+  void processArgument(FunctionInfo *info, SILFunctionArgument *argument,
                         ArgumentSummary &summary, FunctionOrder &order);
 
   /// Summarize a partial_apply instruction.

include/swift/SILOptimizer/Analysis/AliasAnalysis.h

@@ -98,7 +98,7 @@ class AliasAnalysis {
 
   /// Set of instructions inside immutable-scopes.
   ///
-  /// Contains pairs of intructions: the first instruction is the begin-scope
+  /// Contains pairs of instructions: the first instruction is the begin-scope
   /// instruction (e.g. begin_access), the second instruction is an
   /// instruction inside the scope (only may-write instructions are considered).
   llvm::DenseSet<ScopeCacheKey> instsInImmutableScopes;

include/swift/SILOptimizer/Analysis/ArraySemantic.h

@@ -196,7 +196,7 @@ class ArraySemanticsCall {
   bool canInlineEarly() const;
 
   /// If this is a call to  ArrayUninitialized (or
-  /// ArrayUninitializedInstrinsic), identify the instructions that store
+  /// ArrayUninitializedIntrinsic), identify the instructions that store
   /// elements into the array indices. For every index, add the store
   /// instruction that stores to that index to \p ElementStoreMap.
   ///

include/swift/SILOptimizer/Analysis/ClosureScope.h

@@ -20,7 +20,7 @@
 ///
 /// Like CallerAnalysis, ClosureScope is top-down, but unlike CallerAnalysis, it
 /// does not require complex invalidation and recomputation. The underlying
-/// assumption is that no trasformation will add new references to existing
+/// assumption is that no transformation will add new references to existing
 /// non-escaping closures, with some exceptions like SILCloner.
 ///
 /// TODO: When this analysis is used across passes, fix SILCloner to update or
@@ -43,7 +43,7 @@
 /// cyclic because there's no way to name a non-escaping closure. So, in the
 /// long term the acyclic assumption made by this analysis is protected by
 /// non-reentrant semantics, and in the short-term it's safe because of the
-/// lanuguage's practical limitations.
+/// language's practical limitations.
 ///
 //===----------------------------------------------------------------------===//
 

include/swift/SILOptimizer/Analysis/DifferentiableActivityAnalysis.h

@@ -65,7 +65,7 @@ class DominanceAnalysis;
 class PostDominanceAnalysis;
 class DominanceInfo;
 class PostDominanceInfo;
-class SILFunciton;
+class SILFunction;
 
 class DifferentiableActivityCollection;
 class DifferentiableActivityAnalysis
@@ -166,7 +166,7 @@ class DifferentiableActivityInfo {
   /// - Incoming values, if the value is a basic block argument.
   void setUsefulAndPropagateToOperands(SILValue value,
                                        unsigned dependentVariableIndex);
-  /// Propagates usefulnesss to the operands of the given instruction.
+  /// Propagates usefulness to the operands of the given instruction.
   void propagateUseful(SILInstruction *inst, unsigned dependentVariableIndex);
   /// Marks the given address or class-typed value as useful and recursively
   /// propagates usefulness inwards (to operands) through projections. Skips

include/swift/SILOptimizer/Analysis/EpilogueARCAnalysis.h

@@ -83,7 +83,7 @@ class EpilogueARCContext {
   /// The exit blocks of the function.
   llvm::SmallPtrSet<SILBasicBlock *, 2> ExitBlocks;
 
-  /// Returns the EpligoyeARCBlockState for \p BB. If \p BB is unreachable,
+  /// Returns the EpilogueARCBlockState for \p BB. If \p BB is unreachable,
   /// returns None
   Optional<EpilogueARCBlockState *> getState(SILBasicBlock *BB) {
     // poNumber will be None for unreachable blocks

include/swift/SILOptimizer/Analysis/EscapeAnalysis.h

@@ -860,14 +860,14 @@ class EscapeAnalysis : public BottomUpIPAnalysis {
 
     /// Returns true if the graph could be computed.
     ///
-    /// For very large functions (> 10000 nodes), graphs are not cumputed to
+    /// For very large functions (> 10000 nodes), graphs are not computed to
     /// avoid quadratic complexity of the node merging algorithm.
     bool isValid() const {
       assert((valid || isEmpty()) && "invalid graph must not contain nodes");
       return valid;
     }
 
-    /// Invalides the graph in case it's getting too large.
+    /// Invalidates the graph in case it's getting too large.
     void invalidate() {
       clear();
       valid = false;

include/swift/SILOptimizer/Analysis/Reachability.h

@@ -81,7 +81,7 @@ class BackwardReachability {
     }
   }
 
-  // Data flow "meet": interesection of successor reachability.
+  // Data flow "meet": intersection of successor reachability.
   void solveBackward() {
     while (SILBasicBlock *block = cfgWorklist.popAndForget()) {
       if (!meetOverSuccessors(block))