Spelling siloptimizer

* access
* accessed
* accesses
* accessor
* acquiring
* across
* activated
* additive
* address
* addresses'
* aggregated
* analysis
* and
* appropriately
* archetype
* argument
* associated
* availability
* barriers
* because
* been
* beginning
* belongs
* beneficial
* blocks
* borrow
* builtin
* cannot
* canonical
* canonicalize
* clazz
* cleanup
* coalesceable
* coalesced
* comparisons
* completely
* component
* computed
* concrete
* conjunction
* conservatively
* constituent
* construct
* consuming
* containing
* covered
* creates
* critical
* dataflow
* declaration
* defined
* defining
* definition
* deinitialization
* deliberately
* dependencies
* dependent
* deserialized
* destroy
* deterministic
* deterministically
* devirtualizes
* diagnostic
* diagnostics
* differentiation
* disable
* discipline
* dominate
* dominates
* don't
* element
* eliminate
* eliminating
* elimination
* embedded
* encounter
* epilogue
* epsilon
* escape
* escaping
* essential
* evaluating
* evaluation
* evaluator
* executing
* existential
* existentials
* explicit
* expression
* extended
* extension
* extract
* for
* from
* function
* generic
* guarantee
* guaranteed
* happened
* heuristic
* however
* identifiable
* immediately
* implementation
* improper
* include
* infinite
* initialize
* initialized
* initializer
* inside
* instruction
* interference
* interferes
* interleaved
* internal
* intersection
* intractable
* intrinsic
* invalidates
* irreducible
* irrelevant
* language
* lifetime
* literal
* looks
* materialize
* meaning
* mergeable
* might
* mimics
* modification
* modifies
* multiple
* mutating
* necessarily
* necessary
* needsmultiplecopies
* nonetheless
* nothing
* occurred
* occurs
* optimization
* optimizing
* original
* outside
* overflow
* overlapping
* overridden
* owned
* ownership
* parallel
* parameter
* paths
* patterns
* pipeline
* plottable
* possible
* potentially
* practically
* preamble
* precede
* preceding
* predecessor
* preferable
* preparation
* probably
* projection
* properties
* property
* protocol
* reabstraction
* reachable
* recognized
* recursive
* recursively
* redundant
* reentrancy
* referenced
* registry
* reinitialization
* reload
* represent
* requires
* response
* responsible
* retrieving
* returned
* returning
* returns
* rewriting
* rewritten
* sample
* scenarios
* scope
* should
* sideeffects
* similar
* simplify
* simplifycfg
* somewhat
* spaghetti
* specialization
* specializations
* specialized
* specially
* statistically
* substitute
* substitution
* succeeds
* successful
* successfully
* successor
* superfluous
* surprisingly
* suspension
* swift
* targeted
* that
* that our
* the
* therefore
* this
* those
* threshold
* through
* transform
* transformation
* truncated
* ultimate
* unchecked
* uninitialized
* unlikely
* unmanaged
* unoptimized key
* updataflow
* usefulness
* utilities
* villain
* whenever
* writes

Signed-off-by: Josh Soref <[email protected]>

Author: jsoref

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))