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 <jsoref@users.noreply.github.com>

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

include/swift/SILOptimizer/Differentiation/Common.h

@@ -48,7 +48,7 @@ raw_ostream &getADDebugStream();
 /// Given an element address from an `array.uninitialized_intrinsic` `apply`
 /// instruction, returns the `apply` instruction. The element address is either
 /// a `pointer_to_address` or `index_addr` instruction to the `RawPointer`
-/// result of the instrinsic:
+/// result of the intrinsic:
 ///
 ///     %result = apply %array.uninitialized_intrinsic : $(Array<T>, RawPointer)
 ///     (%array, %ptr) = destructure_tuple %result

include/swift/SILOptimizer/Differentiation/LinearMapInfo.h

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// Linear map struct and branching trace enum information for differentation.
+// Linear map struct and branching trace enum information for differentiation.
 //
 //===----------------------------------------------------------------------===//
 
@@ -33,7 +33,7 @@ namespace autodiff {
 class ADContext;
 
 /// Linear map struct and branching trace enum information for an original
-/// function and and derivative function (JVP or VJP).
+/// function and derivative function (JVP or VJP).
 ///
 /// Linear map structs contain all callee linear maps produced in a JVP/VJP
 /// basic block. A linear map struct is created for each basic block in the
@@ -81,7 +81,7 @@ class LinearMapInfo {
   /// corresponding linear map field declaration in the linear map struct.
   llvm::DenseMap<ApplyInst *, VarDecl *> linearMapFieldMap;
 
-  /// Mapping from predecessor-succcessor basic block pairs in the original
+  /// Mapping from predecessor-successor basic block pairs in the original
   /// function to the corresponding branching trace enum case.
   llvm::DenseMap<std::pair<SILBasicBlock *, SILBasicBlock *>, EnumElementDecl *>
       branchingTraceEnumCases;

include/swift/SILOptimizer/Differentiation/TangentBuilder.h

@@ -48,26 +48,26 @@ class TangentBuilder: public SILBuilder {
                           IsInitialization_t isInit);
 
   /// Emits an `AdditiveArithmetic.zero` of the given type. The type must be a
-  /// loadable type, and must conform to `AddditiveArithmetic` or be a tuple
+  /// loadable type, and must conform to `AdditiveArithmetic` or be a tuple
   /// thereof.
   SILValue emitZero(SILLocation loc, CanType type);
 
   /// Emits an `AdditiveArithmetic.+=` for the given destination buffer and
   /// operand. The type of the buffer and the operand must conform to
-  /// `AddditiveArithmetic` or be a tuple thereof. The operand will not be
+  /// `AdditiveArithmetic` or be a tuple thereof. The operand will not be
   /// consumed.
   void emitInPlaceAdd(SILLocation loc, SILValue destinationBuffer,
                       SILValue operand);
 
   /// Emits an `AdditiveArithmetic.+` for the given operands. The type of the
-  /// operands must conform to `AddditiveArithmetic` or be a tuple thereof. The
+  /// operands must conform to `AdditiveArithmetic` or be a tuple thereof. The
   /// operands will not be consumed.
   void emitAddIntoBuffer(SILLocation loc, SILValue destinationBuffer,
                          SILValue lhsAddress, SILValue rhsAddress);
 
   /// Emits an `AdditiveArithmetic.+` for the given operands. The type of the
   /// operands must be a loadable type, and must conform to
-  /// `AddditiveArithmetic` or be a tuple thereof. The operands will not be
+  /// `AdditiveArithmetic` or be a tuple thereof. The operands will not be
   /// consumed.
   SILValue emitAdd(SILLocation loc, SILValue lhs, SILValue rhs);
 };

include/swift/SILOptimizer/PassManager/Passes.def

@@ -58,7 +58,7 @@
 ///   This macro follows the same conventions as PASS(Id, Tag, Description),
 ///   but is used for function passes which are implemented in Swift.
 ///
-///   No further code is need on the C++ side. On the swift swift a function
+///   No further code is need on the C++ side. On the swift function
 ///   pass with the same name must be registered with 'registerPass()'.
 ///
 #ifndef SWIFT_FUNCTION_PASS

include/swift/SILOptimizer/Utils/BasicBlockOptUtils.h

@@ -56,7 +56,7 @@ class ReachableBlocks {
 };
 
 /// Computes the set of blocks from which a path to the return-block exists.
-/// This does not include pathes to a throw-block.
+/// This does not include paths to a throw-block.
 class ReachingReturnBlocks {
     BasicBlockWorklist worklist;
 
@@ -182,7 +182,7 @@ class SinkAddressProjections {
 /// instead.
 ///
 /// After cloning, call updateSSAAfterCloning. This is decoupled from cloning
-/// becaused some clients perform CFG edges updates after cloning but before
+/// because some clients perform CFG edges updates after cloning but before
 /// splitting CFG edges.
 class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
   using SuperTy = SILCloner<BasicBlockCloner>;
@@ -195,7 +195,7 @@ class BasicBlockCloner : public SILCloner<BasicBlockCloner> {
   /// Will cloning require an SSA update?
   bool needsSSAUpdate = false;
 
-  /// Transient object for analyzing a single address projction chain. It's
+  /// Transient object for analyzing a single address projection chain. It's
   /// state is reset each time analyzeAddressProjections is called.
   SinkAddressProjections sinkProj;
 

include/swift/SILOptimizer/Utils/CanonicalOSSALifetime.h

@@ -19,7 +19,7 @@
 /// The "extended lifetime" of the references defined by 'def' transitively
 /// includes the uses of 'def' itself along with the uses of any copies of
 /// 'def'. Canonicalization provably minimizes the OSSA lifetime and its copies
-/// by rewriting all copies and destroys. Only consusming uses that are not on
+/// by rewriting all copies and destroys. Only consuming uses that are not on
 /// the liveness boundary require a copy.
 ///
 /// Example #1: The last consuming use ends the reference lifetime.
@@ -281,7 +281,7 @@ class CanonicalizeOSSALifetime {
 
   /// Record all interesting debug_value instructions here rather then treating
   /// them like a normal use. An interesting debug_value is one that may lie
-  /// outisde the pruned liveness at the time it is discovered.
+  /// outside the pruned liveness at the time it is discovered.
   llvm::SmallPtrSet<DebugValueInst *, 8> debugValues;
 
   /// Visited set for general def-use traversal that prevents revisiting values.

include/swift/SILOptimizer/Utils/CanonicalizeInstruction.h

@@ -18,7 +18,7 @@
 ///
 /// Unlike SILCombine, these peepholes must work on 'raw' SIL form and should be
 /// limited to those necessary to aid in diagnostics and other mandatory
-/// pipelin/e passes. Optimization may only be done to the extent that it
+/// pipeline passes. Optimization may only be done to the extent that it
 /// neither interferes with diagnostics nor increases compile time.
 ///
 //===----------------------------------------------------------------------===//
@@ -37,7 +37,7 @@ namespace swift {
 /// Abstract base class. Implements all canonicalization transforms. Extended by
 /// passes to be notified of each SIL modification.
 struct CanonicalizeInstruction {
-  // May be overriden by passes.
+  // May be overridden by passes.
   static constexpr const char *defaultDebugType = "sil-canonicalize";
   const char *debugType = defaultDebugType;
   DeadEndBlocks &deadEndBlocks;

include/swift/SILOptimizer/Utils/ConstExpr.h

@@ -170,7 +170,7 @@ class ConstExprStepEvaluator {
   /// Try evaluating an instruction and if the evaluation fails, skip the
   /// instruction and make it effects non constant. Note that it may not always
   /// be possible to skip an instruction whose evaluation failed and
-  /// continue evalution (e.g. a conditional branch).
+  /// continue evaluation (e.g. a conditional branch).
   /// See `evaluate` and `skipByMakingEffectsNonConstant` functions for their
   /// semantics.
   /// \param instI instruction to be evaluated in the current interpreter state.

include/swift/SILOptimizer/Utils/Devirtualize.h

@@ -53,7 +53,7 @@ void getAllSubclasses(ClassHierarchyAnalysis *CHA,
 /// to the witness method.
 ///
 /// \p Module SILModule
-/// \p AI ApplySite that applies a procotol method
+/// \p AI ApplySite that applies a protocol method
 /// \p F SILFunction with convention @convention(witness_method)
 /// \p CRef a concrete ProtocolConformanceRef
 SubstitutionMap getWitnessMethodSubstitutions(SILModule &Module, ApplySite AI,

include/swift/SILOptimizer/Utils/Existential.h

@@ -30,7 +30,7 @@ namespace swift {
 ///   : $@convention(method) <τ_0_0 where τ_0_0 : P, τ_0_0 : Q>
 ///     (@guaranteed τ_0_0) -> @owned τ_0_0
 ///
-/// When successfull, ConcreteExistentialInfo can be used to determine the
+/// When successful, ConcreteExistentialInfo can be used to determine the
 /// concrete type of the opened existential.
 struct OpenedArchetypeInfo {
   OpenedArchetypeType *OpenedArchetype = nullptr;
@@ -85,15 +85,15 @@ struct ConcreteExistentialInfo {
 
   // Search for a recognized pattern in which the given existential value is
   // initialized to a concrete type. Constructs a valid ConcreteExistentialInfo
-  // object if successfull.
+  // object if successful.
   ConcreteExistentialInfo(SILValue existential, SILInstruction *user);
 
   // This constructor initializes a ConcreteExistentialInfo based on already
   // known ConcreteType and ProtocolDecl pair.
   ConcreteExistentialInfo(SILValue existential, SILInstruction *user,
                           CanType ConcreteType, ProtocolDecl *Protocol);
 
-  /// For scenerios where ConcreteExistentialInfo is created using a known
+  /// For scenarios where ConcreteExistentialInfo is created using a known
   /// ConcreteType and ProtocolDecl, the ConcreteValue can be null.
   bool isValid() const { return ConcreteType && !ExistentialSubs.empty(); }
 

include/swift/SILOptimizer/Utils/Generics.h

@@ -409,7 +409,7 @@ void checkCompletenessOfPrespecializations(SILModule &M);
 ApplySite replaceWithSpecializedFunction(ApplySite AI, SILFunction *NewF,
                                          const ReabstractionInfo &ReInfo);
 
-/// Returns a SILFunction for the symbol specified by FunctioName if it is
+/// Returns a SILFunction for the symbol specified by FunctionName if it is
 /// visible to the current SILModule. This is used to link call sites to
 /// externally defined specialization and should only be used when the function
 /// body is not required for further optimization or inlining (-Onone).

include/swift/SILOptimizer/Utils/InstModCallbacks.h

@@ -1,4 +1,4 @@
-//===--- InstModCallbacks.h - intruction modification callbacks -*- C++ -*-===//
+//===--- InstModCallbacks.h - instruction modification callbacks -*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -13,7 +13,7 @@
 /// InstModCallbacks: callbacks for instruction modification.
 ///
 /// Callbacks are generally problematic because a pass cannot anticipate the
-/// state that SIL will be in when lower-level utilties invoke the
+/// state that SIL will be in when lower-level utilities invoke the
 /// callback. This creates implicit coupling across the layers of SIL utilities.
 ///
 /// Alternatives:
@@ -98,7 +98,7 @@ struct InstModCallbacks {
   ///
   ///   instToDelete->eraseFromParent();
   ///
-  /// The reason this callback is reponsible for deleting the instruction is to
+  /// The reason this callback is responsible for deleting the instruction is to
   /// interoperate more easily with
   /// CanonicalizeInstruction::killInstruction(). This allows updates to choose
   /// whether to happen before or after deleting the instruction and possibly

include/swift/SILOptimizer/Utils/InstructionDeleter.h

@@ -24,7 +24,7 @@
 /// is highly bug prone and infeasible.
 ///
 /// 3. Fixup OSSA after deletion so SIL remains valid. Allowing OSSA to be
-/// invalid across API boundaries creates an intractible problem and makes it
+/// invalid across API boundaries creates an intractable problem and makes it
 /// impossible to design composable OSSA utilities.
 ///
 /// Strategies for SIL transformation:
@@ -53,7 +53,7 @@
 /// instruction iterators during deletion. This is because deleting a single
 /// instruction may require deleting other instructions, such as debug info and
 /// scope-ending instructions. In OSSA code, deleting an instruction may even
-/// cause new instructions to be inserted. This is best handled by aquiring an
+/// cause new instructions to be inserted. This is best handled by acquiring an
 /// UpdatingInstructionIterator from the InstructionDeleter. This is usually
 /// done via InstructionDeleter::updatingRange(SILBasicBlock *).
 /// InstructionDeleter::getIteratorRegistry().makeIterator() offers more
@@ -64,7 +64,7 @@
 /// For data structures that contain instruction pointers and persist across
 /// calls to forceDelete* or cleanupDeadInstructions... There is no need to
 /// create an updating iterator. Simply check Instruction::isDeleted() when
-/// retriving a pointer from the data structure.
+/// retrieving a pointer from the data structure.
 ///
 /// Using InstModCallbacks:
 ///
@@ -192,7 +192,7 @@ class InstructionDeleter {
   /// lifetimes of the operands of \c inst once it is deleted. This function
   /// will not clean up dead code resulting from the instruction's removal. To
   /// do so, invoke the method \c cleanupDeadCode of this instance, once the SIL
-  /// of the contaning function is made consistent.
+  /// of the containing function is made consistent.
   ///
   /// \pre the instruction to be deleted must not have any use other than
   /// incidental uses.
@@ -213,7 +213,7 @@ class InstructionDeleter {
   /// Clean up dead instructions that are tracked by this instance and all
   /// instructions that transitively become dead.
   ///
-  /// \pre the function contaning dead instructions must be consistent (i.e., no
+  /// \pre the function containing dead instructions must be consistent (i.e., no
   /// under or over releases). Note that if \c forceDelete call leaves the
   /// function body in an inconsistent state, it needs to be made consistent
   /// before this method is invoked.

include/swift/SILOptimizer/Utils/KeyPathProjector.h

@@ -62,7 +62,7 @@ class KeyPathProjector {
   /// Projects the key path to an address. Sets up the projection,
   /// invokes the callback, then tears down the projection.
   /// \param accessType The access type of the projected address.
-  /// \param callback A callback to invoke with the projected adddress.
+  /// \param callback A callback to invoke with the projected address.
   ///     The projected address is only valid from within \p callback.
   ///     If accessType is Get or Modify, the projected addres is an
   ///     initialized address type. If accessType is set, the projected