Misc typos

[• luzpaz]

Summary

Found via codespell -q 3 -I ../clang-whitelist.txt
Where whitelist consists of:

archtype
cas
classs
checkk
compres
definit
frome
iff
inteval
ith
lod
methode
nd
optin
ot
pres
statics
te
thru

[• luzpaz]

Rebased and re-diffed

[• luzpaz]

Please advise how to proceed

[tra]

You may want to split the patch into smaller pieces -- per leaf directory, for example.
That way potential reviewers would at least be able to see the changes (hundreds of files in one patch is a bit too much), and the subset of changes would be small enough for someone to own it (or at least familiar enough with it to give approval).

[alexfh]

Thanks!
I've looked through all the fixes. Most of them look reasonable. I've reverted a few files where I found something suspicious or outright wrong and will commit the rest of the patch after I ensure the tests pass.

These files couldn't be patched:

include/clang/Basic/AttrDocs.td
lib/Basic/VirtualFileSystem.cpp
lib/CodeGen/CGExpr.cpp
lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp
lib/Driver/ToolChains/Hexagon.cpp
lib/Sema/Sema.cpp
lib/StaticAnalyzer/Core/CoreEngine.cpp
test/CodeGenCXX/ms-integer-static-data-members.cpp

The list of the files I reverted:

lib/ARCMigrate/FileRemapper.cpp
lib/AST/ExprConstant.cpp
lib/Frontend/CacheTokens.cpp
lib/Frontend/CompilerInvocation.cpp
lib/Headers/htmintrin.h
lib/Parse/Parser.cpp
lib/Sema/SemaDeclCXX.cpp
lib/Sema/SemaLookup.cpp
test/CodeGen/builtins-arm-exclusive.c
test/CodeGen/vectorcall.c
test/Modules/odr_hash.cpp
test/Sema/warn-documentation-fixits.cpp
test/Sema/warn-documentation-unknown-command.cpp

[alexfh]

Feel free to send the rest of the fixes as a separate patch.

bindings/python/clang/cindex.py

 CursorKind.UNEXPOSED_EXPR = CursorKind(100)
 
 # An expression that refers to some value declaration, such as a function,
-# varible, or enumerator.
+# variable, or enumerator.
 CursorKind.DECL_REF_EXPR = CursorKind(101)
 
 # An expression that refers to a member of a struct, union, class, Objective-C

         return conf.lib.clang_getCursorDefinition(self)
 
     def get_usr(self):
-        """Return the Unified Symbol Resultion (USR) for the entity referenced
+        """Return the Unified Symbol Resolution (USR) for the entity referenced
         by the given cursor (or None).
 
         A Unified Symbol Resolution (USR) is a string that identifies a

cmake/caches/Apple-stage2.cmake

 set(LLVM_BUILD_EXTERNAL_COMPILER_RT ON CACHE BOOL "Build Compiler-RT with just-built clang")
 set(COMPILER_RT_ENABLE_IOS ON CACHE BOOL "Build iOS Compiler-RT libraries")
 
-set(LLVM_CREATE_XCODE_TOOLCHAIN ON CACHE BOOL "Generate targets to create and install an Xcode compatable toolchain")
+set(LLVM_CREATE_XCODE_TOOLCHAIN ON CACHE BOOL "Generate targets to create and install an Xcode compatible toolchain")
 
 # Make unit tests (if present) part of the ALL target
 set(LLVM_BUILD_TESTS ON CACHE BOOL "")

docs/LibASTMatchersReference.html

 
 
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt;</td><td class="name" onclick="toggle('forEachOverridden0')"><a name="forEachOverridden0Anchor">forEachOverridden</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1CXXMethodDecl.html">CXXMethodDecl</a>&gt; InnerMatcher</td></tr>
-<tr><td colspan="4" class="doc" id="forEachOverridden0"><pre>Matches each method overriden by the given method. This matcher may
+<tr><td colspan="4" class="doc" id="forEachOverridden0"><pre>Matches each method overridden by the given method. This matcher may
 produce multiple matches.
 
 Given

docs/SanitizerCoverage.rst

 
     sancov -symbolize my_program.123.sancov my_program > my_program.123.symcov
 
-The ``.symcov`` file can be browsed overlayed over the source code by
+The ``.symcov`` file can be browsed overlaid over the source code by
 running ``tools/sancov/coverage-report-server.py`` script that will start
 an HTTP server.
 

docs/analyzer/DesignDiscussions/InitializerLists.rst

 how model std::initializer_list better.
 
 According to the standard, std::initializer_list<T> is an object that has
-methods begin(), end(), and size(), where begin() returns a pointer to continous
+methods begin(), end(), and size(), where begin() returns a pointer to continuous
 array of size() objects of type T, and end() is equal to begin() plus size().
 The standard does hint that it should be possible to implement
 std::initializer_list<T> as a pair of pointers, or as a pointer and a size

docs/doxygen.cfg.in

 # defined cascading style sheet that is included after the standard style sheets
 # created by doxygen. Using this option one can overrule certain style aspects.
 # This is preferred over using HTML_STYLESHEET since it does not replace the
-# standard style sheet and is therefor more robust against future updates.
+# standard style sheet and is therefore more robust against future updates.
 # Doxygen will copy the style sheet file to the output directory. For an example
 # see the documentation.
 # This tag requires that the tag GENERATE_HTML is set to YES.

include/clang-c/Index.h

    * for "int x", indicating that the current argument will initialize that
    * parameter. After typing further, to \c add(17, (where the code-completion
    * point is after the ","), the code-completion string will contain a
-   * "current paremeter" chunk to "int y".
+   * "current parameter" chunk to "int y".
    */
   CXCompletionChunk_CurrentParameter,
   /**

  * user types punctuation characters or whitespace, at which point the
  * code-completion location will coincide with the cursor. For example, if \c p
  * is a pointer, code-completion might be triggered after the "-" and then
- * after the ">" in \c p->. When the code-completion location is afer the ">",
+ * after the ">" in \c p->. When the code-completion location is after the ">",
  * the completion results will provide, e.g., the members of the struct that
  * "p" points to. The client is responsible for placing the cursor at the
  * beginning of the token currently being typed, then filtering the results

include/clang/AST/ASTContext.h

   /// \brief Apply Objective-C protocol qualifiers to the given type.
   /// \param allowOnPointerType specifies if we can apply protocol
   /// qualifiers on ObjCObjectPointerType. It can be set to true when
-  /// contructing the canonical type of a Objective-C type parameter.
+  /// constructing the canonical type of a Objective-C type parameter.
   QualType applyObjCProtocolQualifiers(QualType type,
       ArrayRef<ObjCProtocolDecl *> protocols, bool &hasError,
       bool allowOnPointerType = false) const;

include/clang/AST/ASTTypeTraits.h

   /// \brief Imposes an order on \c DynTypedNode.
   ///
   /// Supports comparison of nodes that support memoization.
-  /// FIXME: Implement comparsion for other node types (currently
+  /// FIXME: Implement comparison for other node types (currently
   /// only Stmt, Decl, Type and NestedNameSpecifier return memoization data).
   bool operator<(const DynTypedNode &Other) const {
     if (!NodeKind.isSame(Other.NodeKind))

include/clang/AST/CanonicalType.h

   }
 };
 
-/// \brief Replacable canonical proxy adaptor class that provides the link
+/// \brief Replaceable canonical proxy adaptor class that provides the link
 /// between a canonical type and the accessors of the type.
 ///
 /// The CanProxyAdaptor is a replaceable class template that is instantiated

include/clang/AST/Comment.h

   
   /// CurrentDecl is the declaration with which the FullComment is associated.
   ///
-  /// It can be different from \c CommentDecl.  It happens when we we decide
+  /// It can be different from \c CommentDecl.  It happens when we decide
   /// that the comment originally attached to \c CommentDecl is fine for
   /// \c CurrentDecl too (for example, for a redeclaration or an overrider of
   /// \c CommentDecl).

include/clang/AST/CommentLexer.h

 
   /// Integer value associated with a token.
   ///
-  /// If the token is a konwn command, contains command ID and TextPtr is
+  /// If the token is a known command, contains command ID and TextPtr is
   /// unused (command spelling can be found with CommandTraits).  Otherwise,
   /// contains the length of the string that starts at TextPtr.
   unsigned IntVal;

include/clang/AST/DataCollection.h

 /// To collect data from Stmt nodes, subclass ConstStmtVisitor and include
 /// StmtDataCollectors.inc after defining the macros that you need. This
 /// provides data collection implementations for most Stmt kinds. Note
-/// that that code requires some conditions to be met:
+/// that the code requires some conditions to be met:
 ///
 ///   - There must be a method addData(const T &Data) that accepts strings,
 ///     integral types as well as QualType. All data is forwarded using

include/clang/AST/DeclCXX.h

   /// \brief Determine whether this class has a user-declared copy assignment
   /// operator.
   ///
-  /// When false, a copy assigment operator will be implicitly declared.
+  /// When false, a copy assignment operator will be implicitly declared.
   bool hasUserDeclaredCopyAssignment() const {
     return data().UserDeclaredSpecialMembers & SMF_CopyAssignment;
   }

   }
 
   // \brief Determine whether this type is an Interface Like type for
-  // __interface inheritence purposes.
+  // __interface inheritance purposes.
   bool isInterfaceLike() const;
 
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }

include/clang/AST/Expr.h

   bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx) const;
 
   /// EvaluateAsBooleanCondition - Return true if this is a constant
-  /// which we we can fold and convert to a boolean condition using
+  /// which we can fold and convert to a boolean condition using
   /// any crazy technique that we want to, even if the expression has
   /// side-effects.
   bool EvaluateAsBooleanCondition(bool &Result, const ASTContext &Ctx) const;

   static Opcode negateComparisonOp(Opcode Opc) {
     switch (Opc) {
     default:
-      llvm_unreachable("Not a comparsion operator.");
+      llvm_unreachable("Not a comparison operator.");
     case BO_LT: return BO_GE;
     case BO_GT: return BO_LE;
     case BO_LE: return BO_GT;

   static Opcode reverseComparisonOp(Opcode Opc) {
     switch (Opc) {
     default:
-      llvm_unreachable("Not a comparsion operator.");
+      llvm_unreachable("Not a comparison operator.");
     case BO_LT: return BO_GT;
     case BO_GT: return BO_LT;
     case BO_LE: return BO_GE;

include/clang/AST/ExternalASTMerger.h

   /// Add a set of ASTContexts as possible origins.
   ///
   /// Usually the set will be initialized in the constructor, but long-lived
-  /// ExternalASTMergers may neeed to import from new sources (for example,
+  /// ExternalASTMergers may need to import from new sources (for example,
   /// newly-parsed source files).
   ///
   /// Ensures that Importers does not gain duplicate entries as a result.

include/clang/AST/NestedNameSpecifier.h

   NestedNameSpecifierLoc(NestedNameSpecifier *Qualifier, void *Data)
       : Qualifier(Qualifier), Data(Data) {}
 
-  /// \brief Evalutes true when this nested-name-specifier location is
+  /// \brief Evaluates true when this nested-name-specifier location is
   /// non-empty.
   explicit operator bool() const { return Qualifier; }
 
-  /// \brief Evalutes true when this nested-name-specifier location is
+  /// \brief Evaluates true when this nested-name-specifier location is
   /// empty.
   bool hasQualifier() const { return Qualifier; }
 

include/clang/AST/RecursiveASTVisitor.h

 /// from which they were produced.
 ///
 /// By default, this visitor preorder traverses the AST. If postorder traversal
-/// is needed, the \c shouldTraversePostOrder method needs to be overriden
+/// is needed, the \c shouldTraversePostOrder method needs to be overridden
 /// to return \c true.
 template <typename Derived> class RecursiveASTVisitor {
 public:

include/clang/AST/StmtOpenMP.h

     /// Distribute Loop condition used when composing 'omp distribute'
     ///  with 'omp for' in a same construct
     Expr *Cond;
-    /// Update of LowerBound for statically sheduled omp loops for
+    /// Update of LowerBound for statically scheduled omp loops for
     /// outer loop in combined constructs (e.g. 'distribute parallel for')
     Expr *NLB;
-    /// Update of UpperBound for statically sheduled omp loops for
+    /// Update of UpperBound for statically scheduled omp loops for
     /// outer loop in combined constructs (e.g. 'distribute parallel for')
     Expr *NUB;
   };

     Expr *ST;
     /// \brief EnsureUpperBound -- expression UB = min(UB, NumIterations).
     Expr *EUB;
-    /// \brief Update of LowerBound for statically sheduled 'omp for' loops.
+    /// \brief Update of LowerBound for statically scheduled 'omp for' loops.
     Expr *NLB;
-    /// \brief Update of UpperBound for statically sheduled 'omp for' loops.
+    /// \brief Update of UpperBound for statically scheduled 'omp for' loops.
     Expr *NUB;
     /// \brief PreviousLowerBound - local variable passed to runtime in the
     /// enclosing schedule or null if that does not apply.

include/clang/AST/Type.h

   TagDecl *getAsTagDecl() const;
 
   /// If this is a pointer or reference to a RecordType, return the
-  /// CXXRecordDecl that that type refers to.
+  /// CXXRecordDecl that the type refers to.
   ///
   /// If this is not a pointer or reference, or the type being pointed to does
   /// not refer to a CXXRecordDecl, returns NULL.

include/clang/ASTMatchers/ASTMatchers.h

           InnerMatcher.matches(*Parent, Finder, Builder));
 }
 
-/// \brief Matches each method overriden by the given method. This matcher may
+/// \brief Matches each method overridden by the given method. This matcher may
 /// produce multiple matches.
 ///
 /// Given

include/clang/Analysis/Analyses/ThreadSafetyTraverse.h

 
 // Defines an interface used to traverse SExprs.  Traversals have been made as
 // generic as possible, and are intended to handle any kind of pass over the
-// AST, e.g. visiters, copying, non-destructive rewriting, destructive
+// AST, e.g. visitors, copying, non-destructive rewriting, destructive
 // (in-place) rewriting, hashing, typing, etc.
 //
 // Traversals implement the functional notion of a "fold" operation on SExprs.

include/clang/Analysis/CloneDetection.h

 /// The result of findClones can be further constrained with the constrainClones
 /// method.
 ///
-/// This class only searches for clones in exectuable source code
+/// This class only searches for clones in executable source code
 /// (e.g. function bodies). Other clones (e.g. cloned comments or declarations)
 /// are not supported.
 class CloneDetector {

include/clang/Basic/Attr.td

   /// vectorize: vectorizes loop operations if State == Enable.
   /// vectorize_width: vectorize loop operations with width 'Value'.
   /// interleave: interleave multiple loop iterations if State == Enable.
-  /// interleave_count: interleaves 'Value' loop interations.
+  /// interleave_count: interleaves 'Value' loop iterations.
   /// unroll: fully unroll loop if State == Enable.
   /// unroll_count: unrolls loop 'Value' times.
   /// distribute: attempt to distribute loop if State == Enable

include/clang/Basic/AttrDocs.td

 Note that this attribute merely informs the compiler that a function always
 returns a sufficiently aligned pointer. It does not cause the compiler to 
 emit code to enforce that alignment.  The behavior is undefined if the returned
-poitner is not sufficiently aligned.
+pointer is not sufficiently aligned.
   }];
 }
 

   let Category = DocCatFunction;
   let Content = [{
 Clang supports the GNU style ``__attribute__((nothrow))`` and Microsoft style
-``__declspec(nothrow)`` attribute as an equivilent of `noexcept` on function
+``__declspec(nothrow)`` attribute as an equivalent of `noexcept` on function
 declarations. This attribute informs the compiler that the annotated function
 does not throw an exception. This prevents exception-unwinding. This attribute
 is particularly useful on functions in the C Standard Library that are

 with different ABI versions supported. For example, a newer version of a class
 could have a different set of data members and thus have a different size. Using
 the ``abi_tag`` attribute, it is possible to have different mangled names for
-a global variable of the class type. Therefor, the old code could keep using
+a global variable of the class type. Therefore, the old code could keep using
 the old manged name and the new code will use the new mangled name with tags.
   }];
 }

include/clang/Basic/DiagnosticSemaKinds.td

   "did you intend to use '#pragma pack (pop)' instead of '#pragma pack()'?">;
 // Follow the Microsoft implementation.
 def warn_pragma_pack_show : Warning<"value of #pragma pack(show) == %0">;
-def warn_pragma_pack_pop_identifer_and_alignment : Warning<
+def warn_pragma_pack_pop_identifier_and_alignment : Warning<
   "specifying both a name and alignment to 'pop' is undefined">;
 def warn_pragma_pop_failed : Warning<"#pragma %0(pop, ...) failed: %1">,
   InGroup<IgnoredPragmas>;

include/clang/Basic/SourceManager.h

 
   /// \brief The starting offset of the latest batch of loaded SLocEntries.
   ///
-  /// This is LoadedSLocEntryTable.back().Offset, except that that entry might
+  /// This is LoadedSLocEntryTable.back().Offset, except that entry might
   /// not have been loaded, so that value would be unknown.
   unsigned CurrentLoadedOffset;
 

     return false;
   }
 
-  /// \brief Disable overridding the contents of a file, previously enabled
+  /// \brief Disable overriding the contents of a file, previously enabled
   /// with #overrideFileContents.
   ///
   /// This should be called before parsing has begun.

include/clang/Basic/Version.h

   /// This supports LLVM residing in a separate repository from clang.
   std::string getLLVMRepositoryPath();
 
-  /// \brief Retrieves the repository revision number (or identifer) from which
+  /// \brief Retrieves the repository revision number (or identifier) from which
   /// this Clang was built.
   std::string getClangRevision();
 
-  /// \brief Retrieves the repository revision number (or identifer) from which
+  /// \brief Retrieves the repository revision number (or identifier) from which
   /// LLVM was built.
   ///
   /// If Clang and LLVM are in the same repository, this returns the same

include/clang/CodeGen/ConstantInitBuilder.h

   /// (2) finishing the entire builder.
   ///
   /// This is useful for emitting certain kinds of structure which
-  /// contain some sort of summary field, generaly a count, before any
+  /// contain some sort of summary field, generally a count, before any
   /// of the data.  By emitting a placeholder first, the structure can
   /// be emitted eagerly.
   PlaceholderPosition addPlaceholder() {

include/clang/Driver/Multilib.h

   /// Union this set of multilibs with another
   void combineWith(const MultilibSet &MS);
 
-  /// Remove all of thie multilibs from the set
+  /// Remove all of the multilibs from the set
   void clear() { Multilibs.clear(); }
 
   iterator begin() { return Multilibs.begin(); }

include/clang/Frontend/ASTUnit.h

   ///
   /// Cache contains only source locations from preamble so it is
   /// guaranteed that they stay valid when the SourceManager is recreated.
-  /// This cache is used when loading preambule to increase performance
+  /// This cache is used when loading preamble to increase performance
   /// of that loading. It must be cleared when preamble is recreated.
   llvm::StringMap<SourceLocation> PreambleSrcLocCache;
 

include/clang/Frontend/PrecompiledPreamble.h

   /// Requires that CanReuse() is true.
   /// For in-memory preambles, PrecompiledPreamble instance continues to own the
   /// MemoryBuffer with the Preamble after this method returns. The caller is
-  /// reponsible for making sure the PrecompiledPreamble instance outlives the
+  /// responsible for making sure the PrecompiledPreamble instance outlives the
   /// compiler run and the AST that will be using the PCH.
   void AddImplicitPreamble(CompilerInvocation &CI,
                            IntrusiveRefCntPtr<vfs::FileSystem> &VFS,

include/clang/Lex/HeaderSearch.h

                       unsigned angledDirIdx, unsigned systemDirIdx,
                       bool noCurDirSearch) {
     assert(angledDirIdx <= systemDirIdx && systemDirIdx <= dirs.size() &&
-        "Directory indicies are unordered");
+        "Directory indices are unordered");
     SearchDirs = dirs;
     AngledDirIdx = angledDirIdx;
     SystemDirIdx = systemDirIdx;

include/clang/Lex/ModuleMap.h

   llvm::DenseMap<const DirectoryEntry *, Module *> UmbrellaDirs;
 
   /// \brief A generation counter that is used to test whether modules of the
-  /// same name may shadow or are illegal redefintions.
+  /// same name may shadow or are illegal redefinitions.
   ///
   /// Modules from earlier scopes may shadow modules from later ones.
   /// Modules from the same scope may not have the same name.

include/clang/Lex/TokenLexer.h

   /// the tokens just expanded through __VA_OPT__ processing.  These (sub)
   /// sequence of tokens are folded into one stringified token.
   ///
-  /// \param[in] VCtx - contains relevent contextual information about the
+  /// \param[in] VCtx - contains relevant contextual information about the
   /// state of the tokens around and including the __VA_OPT__ token, necessary
   /// for stringification.
   void stringifyVAOPTContents(SmallVectorImpl<Token> &ReplacementToks,

include/clang/Parse/Parser.h

 
     /// \brief Whether this member function had an associated template
     /// scope. When true, D is a template declaration.
-    /// othewise, it is a member function declaration.
+    /// otherwise, it is a member function declaration.
     bool TemplateScope;
 
     /// DefaultArgs - Contains the parameters of the function and

 
     /// \brief Whether this class had an associated template
     /// scope. When true, TagOrTemplate is a template declaration;
-    /// othewise, it is a tag declaration.
+    /// otherwise, it is a tag declaration.
     bool TemplateScope : 1;
 
     /// \brief Whether this class is an __interface.

include/clang/Sema/AttributeList.h

   }
 
   /// Type tag information is stored immediately following the arguments, if
-  /// any, at the end of the object.  They are mutually exlusive with
+  /// any, at the end of the object.  They are mutually exclusive with
   /// availability slots.
   TypeTagForDatatypeData &getTypeTagForDatatypeDataSlot() {
     return *reinterpret_cast<TypeTagForDatatypeData*>(getArgsBuffer()+NumArgs);

include/clang/Sema/TypoCorrection.h

 
   /// \brief Simple predicate used by the default RankCandidate to
   /// determine whether to return an edit distance of 0 or InvalidDistance.
-  /// This can be overrided by validators that only need to determine if a
+  /// This can be overridden by validators that only need to determine if a
   /// candidate is viable, without ranking potentially viable candidates.
-  /// Only ValidateCandidate or RankCandidate need to be overriden by a
+  /// Only ValidateCandidate or RankCandidate need to be overridden by a
   /// callback wishing to check the viability of correction candidates.
   /// The default predicate always returns true if the candidate is not a type
   /// name or keyword, true for types if WantTypeSpecifiers is true, and true

include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

   /// specified.
   /// @param [in] C The optional checker parameter that can be used to restrict
   /// the search to the options of this particular checker (and its parents
-  /// dependening on search mode).
+  /// depending on search mode).
   /// @param [in] SearchInParents If set to true and the searched option was not
   /// specified for the given checker the options for the parent packages will
   /// be searched as well. The inner packages take precedence over the outer

   /// specified.
   /// @param [in] C The optional checker parameter that can be used to restrict
   /// the search to the options of this particular checker (and its parents
-  /// dependening on search mode).
+  /// depending on search mode).
   /// @param [in] SearchInParents If set to true and the searched option was not
   /// specified for the given checker the options for the parent packages will
   /// be searched as well. The inner packages take precedence over the outer

   /// specified.
   /// @param [in] C The optional checker parameter that can be used to restrict
   /// the search to the options of this particular checker (and its parents
-  /// dependening on search mode).
+  /// depending on search mode).
   /// @param [in] SearchInParents If set to true and the searched option was not
   /// specified for the given checker the options for the parent packages will
   /// be searched as well. The inner packages take precedence over the outer

   /// specified.
   /// @param [in] C The optional checker parameter that can be used to restrict
   /// the search to the options of this particular checker (and its parents
-  /// dependening on search mode).
+  /// depending on search mode).
   /// @param [in] SearchInParents If set to true and the searched option was not
   /// specified for the given checker the options for the parent packages will
   /// be searched as well. The inner packages take precedence over the outer

include/clang/StaticAnalyzer/Core/BugReporter/BugType.h

-//===---  BugType.h - Bug Information Desciption ----------------*- C++ -*-===//
+//===---  BugType.h - Bug Information Description ----------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h

   /// @param FuncName The name of the function that will be matched.
   ///
   /// @param RequiredArgs The number of arguments that is expected to match a
-  /// call. Omit this parameter to match every occurance of call with a given
+  /// call. Omit this parameter to match every occurrence of call with a given
   /// name regardless the number of arguments.
   CallDescription(StringRef FuncName, unsigned RequiredArgs = NoArgRequirement)
       : FuncName(FuncName), RequiredArgs(RequiredArgs) {}

include/clang/StaticAnalyzer/Core/PathSensitive/CoreEngine.h

   /// the builder dies.
   ExplodedNodeSet &Frontier;
 
-  /// Checkes if the results are ready.
+  /// Checks if the results are ready.
   virtual bool checkResults() {
     return Finalized;
   }

include/clang/StaticAnalyzer/Core/PathSensitive/SVals.h

 /// \brief Value representing pointer-to-member.
 ///
 /// This value is qualified as NonLoc because neither loading nor storing
-/// operations are aplied to it. Instead, the analyzer uses the L-value coming
+/// operations are applied to it. Instead, the analyzer uses the L-value coming
 /// from pointer-to-member applied to an object.
 /// This SVal is represented by a DeclaratorDecl which can be a member function
 /// pointer or a member data pointer and a list of CXXBaseSpecifiers. This list

include/clang/Tooling/FileMatchTrie.h

   ///
   /// Returns file name stored in this trie that is equivalent to 'FileName'
   /// according to 'Comparator', if it can be uniquely identified. If there
-  /// are no matches an empty \c StringRef is returned. If there are ambigious
+  /// are no matches an empty \c StringRef is returned. If there are ambiguous
   /// matches, an empty \c StringRef is returned and a corresponding message
   /// written to 'Error'.
   StringRef findEquivalent(StringRef FileName,

include/clang/Tooling/Refactoring/RefactoringActionRule.h

 class RefactoringActionRule : public RefactoringActionRuleBase {
 public:
   /// Returns true when the rule has a source selection requirement that has
-  /// to be fullfilled before refactoring can be performed.
+  /// to be fulfilled before refactoring can be performed.
   virtual bool hasSelectionRequirement() = 0;
 
   /// Traverses each refactoring option used by the rule and invokes the

include/clang/Tooling/Refactoring/RefactoringResultConsumer.h

 public:
   virtual ~RefactoringResultConsumer() {}
 
-  /// Handles an initation or an invication error. An initiation error typically
-  /// has a \c DiagnosticError payload that describes why initation failed.
+  /// Handles an initiation or an invication error. An initiation error typically
+  /// has a \c DiagnosticError payload that describes why initiation failed.
   virtual void handleError(llvm::Error Err) = 0;
 
   /// Handles the source replacements that are produced by a refactoring action.

include/clang/Tooling/Refactoring/Rename/RenamingAction.h

   Expected<AtomicChanges>
   createSourceReplacements(RefactoringRuleContext &Context) override;
 
-  // A NamedDecl which indentifies the symbol being renamed.
+  // A NamedDecl which identifies the symbol being renamed.
   const NamedDecl *ND;
   // The new qualified name to change the symbol to.
   std::string NewQualifiedName;

include/clang/Tooling/Refactoring/Rename/SymbolName.h

 /// A name of a symbol.
 ///
 /// Symbol's name can be composed of multiple strings. For example, Objective-C
-/// methods can contain multiple argument lables:
+/// methods can contain multiple argument labels:
 ///
 /// \code
 /// - (void) myMethodNamePiece: (int)x anotherNamePieces:(int)y;

include/clang/Tooling/Tooling.h

   ///
   /// \param Action Tool action.
   ///
-  /// \returns 0 on success; 1 if any error occured; 2 if there is no error but
+  /// \returns 0 on success; 1 if any error occurred; 2 if there is no error but
   /// some files are skipped due to missing compile commands.
   int run(ToolAction *Action);
 

lib/ARCMigrate/FileRemapper.cpp

 
 const FileEntry *FileRemapper::getOriginalFile(StringRef filePath) {
   const FileEntry *file = FileMgr->getFile(filePath);
-  // If we are updating a file that overriden an original file,
+  // If we are updating a file that overridden an original file,
   // actually update the original file.
   llvm::DenseMap<const FileEntry *, const FileEntry *>::iterator
     I = ToFromMappings.find(file);

lib/ARCMigrate/ObjCMT.cpp

   for (unsigned i = 0, e = Attrs1.size(); i != e; i++) {
     bool match = false;
     for (unsigned j = 0, f = Attrs2.size(); j != f; j++) {
-      // Matching attribute kind only. Except for Availabilty attributes,
+      // Matching attribute kind only. Except for Availability attributes,
       // we are not getting into details of the attributes. For all practical purposes
       // this is sufficient.
       if (Attrs1[i]->getKind() == Attrs2[j]->getKind()) {

lib/AST/ASTContext.cpp

   CollectInheritedProtocols(IDecl, InheritedProtocols);
   if (InheritedProtocols.empty())
     return false;
-  // Check that if every protocol in list of id<plist> conforms to a protcol
+  // Check that if every protocol in list of id<plist> conforms to a protocol
   // of IDecl's, then bridge casting is ok.
   bool Conforms = false;
   for (auto *Proto : OPT->quals()) {

       S += "{objc_class=}";
       return;
     }
-    // TODO: Double check to make sure this intentially falls through.
+    // TODO: Double check to make sure this intentionally falls through.
     LLVM_FALLTHROUGH;
   }
   

     if (OPT->isObjCClassType() || OPT->isObjCQualifiedClassType()) {
       // FIXME: Consider if we need to output qualifiers for 'Class<p>'.
       // Since this is a binary compatibility issue, need to consult with runtime
-      // folks. Fortunately, this is a *very* obsure construct.
+      // folks. Fortunately, this is a *very* obscure construct.
       S += '#';
       return;
     }

lib/AST/DeclCXX.cpp

                                     SOEnd = M->second.end();
            SO != SOEnd && !Done; ++SO) {
         assert(SO->second.size() > 0 && 
-               "All virtual functions have overridding virtual functions");
+               "All virtual functions have overriding virtual functions");
         
         // C++ [class.abstract]p4:
         //   A class is abstract if it contains or inherits at least one

   ASTContext &Context = getASTContext();
   CanQualType ParamType = Context.getCanonicalType(Param->getType());
   
-  // Is it the same as our our class type?
+  // Is it the same as our class type?
   CanQualType ClassTy 
     = Context.getCanonicalType(Context.getTagDeclType(getParent()));
   if (ParamType.getUnqualifiedType() != ClassTy)

lib/AST/DeclObjC.cpp

   if (!Container)
     return;
 
-  // In categories look for overriden methods from protocols. A method from
-  // category is not "overriden" since it is considered as the "same" method
+  // In categories look for overridden methods from protocols. A method from
+  // category is not "overridden" since it is considered as the "same" method
   // (same USR) as the one from the interface.
   if (const ObjCCategoryDecl *
         Category = dyn_cast<ObjCCategoryDecl>(Container)) {

lib/AST/ExprConstant.cpp

     unsigned Index;
 
     // FIXME: Adding this to every 'CallStackFrame' may have a nontrivial impact
-    // on the overall stack usage of deeply-recursing constexpr evaluataions.
+    // on the overall stack usage of deeply-recursing constexpr evaluations.
     // (We should cache this map rather than recomputing it repeatedly.)
     // But let's try this and see how it goes; we can look into caching the map
     // as a later change.

     APValue *EvaluatingDeclValue;
 
     /// EvaluatingObject - Pair of the AST node that an lvalue represents and
-    /// the call index that that lvalue was allocated in.
+    /// the call index that lvalue was allocated in.
     typedef std::pair<APValue::LValueBase, unsigned> EvaluatingObject;
 
     /// EvaluatingConstructors - Set of objects that are currently being

   }
 
   CompleteObject Obj = findCompleteObject(Info, E, AK_Assign, LVal, LValType);
-  return Obj && modifySubobject(Info, E, Obj, LVal.Designator, Val);
-}
-
-namespace {
-struct CompoundAssignSubobjectHandler {
-  EvalInfo &Info;
+  return Obj && modifySubobject(Info, E, Obj, LVal.Designator, Val);
+}
+
+namespace {
+struct CompoundAssignSubobjectHandler {
+  EvalInfo &Info;
   const Expr *E;
   QualType PromotedLHSType;
   BinaryOperatorKind Opcode;

   return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
 }
 
-namespace {
-struct IncDecSubobjectHandler {
-  EvalInfo &Info;
-  const UnaryOperator *E;
-  AccessKinds AccessKind;
-  APValue *Old;
-
+namespace {
+struct IncDecSubobjectHandler {
+  EvalInfo &Info;
+  const UnaryOperator *E;
+  AccessKinds AccessKind;
+  APValue *Old;
+
   typedef bool result_type;
 
   bool checkConst(QualType QT) {

     }
 
     bool WasNegative = Value.isNegative();
-    if (AccessKind == AK_Increment) {
-      ++Value;
-
-      if (!WasNegative && Value.isNegative() && E->canOverflow()) {
-        APSInt ActualValue(Value, /*IsUnsigned*/true);
-        return HandleOverflow(Info, E, ActualValue, SubobjType);
-      }
-    } else {
-      --Value;
-
-      if (WasNegative && !Value.isNegative() && E->canOverflow()) {
-        unsigned BitWidth = Value.getBitWidth();
-        APSInt ActualValue(Value.sext(BitWidth + 1), /*IsUnsigned*/false);
-        ActualValue.setBit(BitWidth);
+    if (AccessKind == AK_Increment) {
+      ++Value;
+
+      if (!WasNegative && Value.isNegative() && E->canOverflow()) {
+        APSInt ActualValue(Value, /*IsUnsigned*/true);
+        return HandleOverflow(Info, E, ActualValue, SubobjType);
+      }
+    } else {
+      --Value;
+
+      if (WasNegative && !Value.isNegative() && E->canOverflow()) {
+        unsigned BitWidth = Value.getBitWidth();
+        APSInt ActualValue(Value.sext(BitWidth + 1), /*IsUnsigned*/false);
+        ActualValue.setBit(BitWidth);
         return HandleOverflow(Info, E, ActualValue, SubobjType);
       }
     }

     Info.FFDiag(E);
     return false;
   }
-
-  AccessKinds AK = IsIncrement ? AK_Increment : AK_Decrement;
-  CompleteObject Obj = findCompleteObject(Info, E, AK, LVal, LValType);
-  IncDecSubobjectHandler Handler = {Info, cast<UnaryOperator>(E), AK, Old};
-  return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
-}
-
+
+  AccessKinds AK = IsIncrement ? AK_Increment : AK_Decrement;
+  CompleteObject Obj = findCompleteObject(Info, E, AK, LVal, LValType);
+  IncDecSubobjectHandler Handler = {Info, cast<UnaryOperator>(E), AK, Old};
+  return Obj && findSubobject(Info, E, Obj, LVal.Designator, Handler);
+}
+
 /// Build an lvalue for the object argument of a member function call.
 static bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object,
                                    LValue &This) {

     return Visit(E->getSubExpr());
   case UO_Minus: {
     if (!Visit(E->getSubExpr()))
-      return false;
-    if (!Result.isInt()) return Error(E);
-    const APSInt &Value = Result.getInt();
-    if (Value.isSigned() && Value.isMinSignedValue() && E->canOverflow() &&
-        !HandleOverflow(Info, E, -Value.extend(Value.getBitWidth() + 1),
-                        E->getType()))
-      return false;
+      return false;
+    if (!Result.isInt()) return Error(E);
+    const APSInt &Value = Result.getInt();
+    if (Value.isSigned() && Value.isMinSignedValue() && E->canOverflow() &&
+        !HandleOverflow(Info, E, -Value.extend(Value.getBitWidth() + 1),
+                        E->getType()))
+      return false;
     return Success(-Value, E);
   }
   case UO_Not: {

   case BO_Mul:
     if (Result.isComplexFloat()) {
       // This is an implementation of complex multiplication according to the
-      // constraints laid out in C11 Annex G. The implemention uses the
+      // constraints laid out in C11 Annex G. The implementation uses the
       // following naming scheme:
       //   (a + ib) * (c + id)
       ComplexValue LHS = Result;

   case BO_Div:
     if (Result.isComplexFloat()) {
       // This is an implementation of complex division according to the
-      // constraints laid out in C11 Annex G. The implemention uses the
+      // constraints laid out in C11 Annex G. The implementation uses the
       // following naming scheme:
       //   (a + ib) / (c + id)
       ComplexValue LHS = Result;

lib/AST/MicrosoftMangle.cpp

           if (const auto *ND = dyn_cast<NamedDecl>(MC))
             mangleUnqualifiedName(ND);
       // MS ABI and Itanium manglings are in inverted scopes.  In the case of a
-      // RecordDecl, mangle the entire scope hierachy at this point rather than
+      // RecordDecl, mangle the entire scope hierarchy at this point rather than
       // just the unqualified name to get the ordering correct.
       if (const auto *RD = dyn_cast<RecordDecl>(DC))
         mangleName(RD);

lib/AST/Stmt.cpp

   if (Initialized)
     return StmtClassInfo[E];
 
-  // Intialize the table on the first use.
+  // Initialize the table on the first use.
   Initialized = true;
 #define ABSTRACT_STMT(STMT)
 #define STMT(CLASS, PARENT) \

lib/AST/VTableBuilder.cpp

       }
 
       // In case we need a return adjustment, we'll add a new slot for
-      // the overrider. Mark the overriden method as shadowed by the new slot.
+      // the overrider. Mark the overridden method as shadowed by the new slot.
       OverriddenMethodInfo.Shadowed = true;
 
       // Force a special name mangling for a return-adjusting thunk

lib/ASTMatchers/Dynamic/Parser.cpp

   }
 }
 
-/// \brief Parse an <Expresssion>
+/// \brief Parse an <Expression>
 bool Parser::parseExpressionImpl(VariantValue *Value) {
   switch (Tokenizer->nextTokenKind()) {
   case TokenInfo::TK_Literal:

lib/Analysis/CloneDetection.cpp

     for (unsigned i = 0; i < StmtsByHash.size() - 1; ++i) {
       const auto Current = StmtsByHash[i];
 
-      // It's likely that we just found an sequence of StmtSequences that
+      // It's likely that we just found a sequence of StmtSequences that
       // represent a CloneGroup, so we create a new group and start checking and
       // adding the StmtSequences in this sequence.
       CloneDetector::CloneGroup NewGroup;

lib/Analysis/ThreadSafetyCommon.cpp

 }
 
 void SExprBuilder::enterCFGBlock(const CFGBlock *B) {
-  // Intialize TIL basic block and add it to the CFG.
+  // Initialize TIL basic block and add it to the CFG.
   CurrentBB = lookupBlock(B);
   CurrentBB->reservePredecessors(B->pred_size());
   Scfg->add(CurrentBB);

     til::BasicBlock *BB1 = *It ? lookupBlock(*It) : nullptr;
     ++It;
     til::BasicBlock *BB2 = *It ? lookupBlock(*It) : nullptr;
-    // FIXME: make sure these arent' critical edges.
+    // FIXME: make sure these aren't critical edges.
     auto *Tm = new (Arena) til::Branch(C, BB1, BB2);
     CurrentBB->setTerminator(Tm);
   }

lib/Basic/DiagnosticIDs.cpp

       Result = diag::Severity::Error;
   }
 
-  // If -Wfatal-errors is enabled, map errors to fatal unless explicity
+  // If -Wfatal-errors is enabled, map errors to fatal unless explicitly
   // disabled.
   if (Result == diag::Severity::Error) {
     if (State->ErrorsAsFatal && !Mapping.hasNoErrorAsFatal())

lib/Basic/SourceManager.cpp

   //     0   -> SourceLocation()
   //     100 -> Expanded loc #1
   //     110 -> SourceLocation()
-  // and we found a new macro FileID that lexed from offet 105 with length 3,
+  // and we found a new macro FileID that lexed from offset 105 with length 3,
   // the new map will be:
   //     0   -> SourceLocation()
   //     100 -> Expanded loc #1

lib/Basic/Targets/PPC.cpp

     Builder.defineMacro("_CALL_ELF", "2");
 
   // This typically is only for a new enough linker (bfd >= 2.16.2 or gold), but
-  // our suppport post-dates this and it should work on all 64-bit ppc linux
+  // our support post-dates this and it should work on all 64-bit ppc linux
   // platforms. It is guaranteed to work on all elfv2 platforms.
   if (getTriple().getOS() == llvm::Triple::Linux && PointerWidth == 64)
     Builder.defineMacro("_CALL_LINUX", "1");

lib/Basic/Targets/X86.cpp

   case 'y': // Any MMX register.
   case 'v': // Any {X,Y,Z}MM register (Arch & context dependent)
   case 'x': // Any SSE register.
-  case 'k': // Any AVX512 mask register (same as Yk, additionaly allows k0
+  case 'k': // Any AVX512 mask register (same as Yk, additionally allows k0
             // for intermideate k reg operations).
   case 'Q': // Any register accessible as [r]h: a, b, c, and d.
   case 'R': // "Legacy" registers: ax, bx, cx, dx, di, si, sp, bp.

lib/Basic/VirtualFileSystem.cpp

 }
 
 namespace {
-/// Provide a file wrapper with an overriden status.
+/// Provide a file wrapper with an overridden status.
 class FileWithFixedStatus : public File {
   std::unique_ptr<File> InnerFile;
   Status S;

lib/CodeGen/BackendUtil.cpp

   case 2:
     switch (Opts.OptimizeSize) {
     default:
-      llvm_unreachable("Invalide optimization level for size!");
+      llvm_unreachable("Invalid optimization level for size!");
 
     case 0:
       return PassBuilder::O2;

lib/CodeGen/CGBlocks.cpp

 /// buildBlockDescriptor - Build the block descriptor meta-data for a block.
 /// buildBlockDescriptor is accessed from 5th field of the Block_literal
 /// meta-data and contains stationary information about the block literal.
-/// Its definition will have 4 (or optinally 6) words.
+/// Its definition will have 4 (or optionally 6) words.
 /// \code
 /// struct Block_descriptor {
 ///   unsigned long reserved;

     info.BlockSize = CharUnits::fromQuantity(Offset);
   } else {
     // The header is basically 'struct { void *; int; int; void *; void *; }'.
-    // Assert that that struct is packed.
+    // Assert that the struct is packed.
     assert(CGM.getIntSize() <= CGM.getPointerSize());
     assert(CGM.getIntAlign() <= CGM.getPointerAlign());
     assert((2 * CGM.getIntSize()).isMultipleOf(CGM.getPointerAlign()));

         const CGBlockInfo::Capture &enclosingCapture =
             BlockInfo->getCapture(variable);
 
-        // This is a [[type]]*, except that a byref entry wil just be an i8**.
+        // This is a [[type]]*, except that a byref entry will just be an i8**.
         src = Builder.CreateStructGEP(LoadBlockStruct(),
                                       enclosingCapture.getIndex(),
                                       enclosingCapture.getOffset(),

lib/CodeGen/CGBuiltin.cpp

   }
 
   // The encompassing type must have a width greater than or equal to the width
-  // of the specified types.  Aditionally, if the encompassing type is signed,
+  // of the specified types.  Additionally, if the encompassing type is signed,
   // its width must be strictly greater than the width of any unsigned types
   // given.
   unsigned Width = 0;

 
   // LLVM only supports 0 and 2, make sure that we pass along that as a boolean.
   Value *Min = Builder.getInt1((Type & 2) != 0);
-  // For GCC compatability, __builtin_object_size treat NULL as unknown size.
+  // For GCC compatibility, __builtin_object_size treat NULL as unknown size.
   Value *NullIsUnknown = Builder.getTrue();
   return Builder.CreateCall(F, {Ptr, Min, NullIsUnknown});
 }

   case Builtin::BI__sync_synchronize: {
     // We assume this is supposed to correspond to a C++0x-style
     // sequentially-consistent fence (i.e. this is only usable for
-    // synchonization, not device I/O or anything like that). This intrinsic
+    // synchronization, not device I/O or anything like that). This intrinsic
     // is really badly designed in the sense that in theory, there isn't
     // any way to safely use it... but in practice, it mostly works
     // to use it with non-atomic loads and stores to get acquire/release

       llvm::Triple::getArchTypePrefix(getTarget().getTriple().getArch());
   if (!Prefix.empty()) {
     IntrinsicID = Intrinsic::getIntrinsicForGCCBuiltin(Prefix.data(), Name);
-    // NOTE we dont need to perform a compatibility flag check here since the
+    // NOTE we don't need to perform a compatibility flag check here since the
     // intrinsics are declared in Builtins*.def via LANGBUILTIN which filter the
     // MS builtins via ALL_MS_LANGUAGES and are filtered earlier.
     if (IntrinsicID == Intrinsic::not_intrinsic)

lib/CodeGen/CGDebugInfo.cpp

   return FullName;
 }
 
-/// \return the approproate DWARF tag for a composite type.
+/// \return the appropriate DWARF tag for a composite type.
 static llvm::dwarf::Tag getTagForRecord(const RecordDecl *RD) {
    llvm::dwarf::Tag Tag;
   if (RD->isStruct() || RD->isInterface())

     llvm::raw_svector_ostream OS(ConfigMacros);
     const auto &PPOpts = CGM.getPreprocessorOpts();
     unsigned I = 0;
-    // Translate the macro definitions back into a commmand line.
+    // Translate the macro definitions back into a command line.
     for (auto &M : PPOpts.Macros) {
       if (++I > 1)
         OS << " ";

   case llvm::dwarf::DW_TAG_structure_type:
   case llvm::dwarf::DW_TAG_union_type:
   case llvm::dwarf::DW_TAG_class_type:
-    // Immediatley resolve to a distinct node.
+    // Immediately resolve to a distinct node.
     RealDecl =
         llvm::MDNode::replaceWithDistinct(llvm::TempDICompositeType(RealDecl));
     break;

     const RecordDecl *RD = RT->getDecl();
     if (RD->isUnion() && RD->isAnonymousStructOrUnion()) {
       // GDB has trouble finding local variables in anonymous unions, so we emit
-      // artifical local variables for each of the members.
+      // artificial local variables for each of the members.
       //
       // FIXME: Remove this code as soon as GDB supports this.
       // The debug info verifier in LLVM operates based on the assumption that a

lib/CodeGen/CGExpr.cpp

   llvm_unreachable("bad evaluation kind");
 }
 
-/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
+/// EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will
 /// always be accessible even if no aggregate location is provided.
 RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) {
   AggValueSlot AggSlot = AggValueSlot::ignored();

lib/CodeGen/CGExprAgg.cpp

     if (isToAtomic) {
       AggValueSlot valueDest = Dest;
       if (!valueDest.isIgnored() && CGF.CGM.isPaddedAtomicType(atomicType)) {
-        // Zero-initialize.  (Strictly speaking, we only need to intialize
+        // Zero-initialize.  (Strictly speaking, we only need to initialize
         // the padding at the end, but this is simpler.)
         if (!Dest.isZeroed())
           CGF.EmitNullInitialization(Dest.getAddress(), atomicType);

lib/CodeGen/CGExprComplex.cpp

     return Visit(E->getInit(0));
   }
 
-  // Empty init list intializes to null
+  // Empty init list initializes to null
   assert(E->getNumInits() == 0 && "Unexpected number of inits");
   QualType Ty = E->getType()->castAs<ComplexType>()->getElementType();
   llvm::Type* LTy = CGF.ConvertType(Ty);

lib/CodeGen/CGObjCMac.cpp

 
   // This could be 32bit int or 64bit integer depending on the architecture.
   // Cast it to 64bit integer value, if it is a 32bit integer ivar offset value
-  //  as this is what caller always expectes.
+  //  as this is what caller always expects.
   if (ObjCTypes.IvarOffsetVarTy == ObjCTypes.IntTy)
     IvarOffsetValue = CGF.Builder.CreateIntCast(
         IvarOffsetValue, ObjCTypes.LongTy, true, "ivar.conv");

lib/CodeGen/CGOpenCLRuntime.h

 
   llvm::PointerType *getSamplerType(const Type *T);
 
-  // \brief Returnes a value which indicates the size in bytes of the pipe
+  // \brief Returns a value which indicates the size in bytes of the pipe
   // element.
   virtual llvm::Value *getPipeElemSize(const Expr *PipeArg);
 
-  // \brief Returnes a value which indicates the alignment in bytes of the pipe
+  // \brief Returns a value which indicates the alignment in bytes of the pipe
   // element.
   virtual llvm::Value *getPipeElemAlign(const Expr *PipeArg);
 

lib/CodeGen/CGOpenMPRuntime.h

   /// Base declarations for the reduction items.
   SmallVector<const VarDecl *, 4> BaseDecls;
 
-  /// Emits lvalue for shared expresion.
+  /// Emits lvalue for shared expression.
   LValue emitSharedLValue(CodeGenFunction &CGF, const Expr *E);
   /// Emits upper bound for shared expression (if array section).
   LValue emitSharedLValueUB(CodeGenFunction &CGF, const Expr *E);

 
   /// Translates the native parameter of outlined function if this is required
   /// for target.
-  /// \param FD Field decl from captured record for the paramater.
+  /// \param FD Field decl from captured record for the parameter.
   /// \param NativeParam Parameter itself.
   virtual const VarDecl *translateParameter(const FieldDecl *FD,
                                             const VarDecl *NativeParam) const {

 
   /// Translates the native parameter of outlined function if this is required
   /// for target.
-  /// \param FD Field decl from captured record for the paramater.
+  /// \param FD Field decl from captured record for the parameter.
   /// \param NativeParam Parameter itself.
   const VarDecl *translateParameter(const FieldDecl *FD,
                                     const VarDecl *NativeParam) const override;

lib/CodeGen/CGOpenMPRuntime.cpp

   // Right now we only generate metadata for function that contain target
   // regions.
 
-  // If we do not have entries, we dont need to do anything.
+  // If we do not have entries, we don't need to do anything.
   if (OffloadEntriesInfoManager.empty())
     return;
 

         CGF.VoidPtrTy);
   }
 
-  // NOTE: routine and part_id fields are intialized by __kmpc_omp_task_alloc()
+  // NOTE: routine and part_id fields are initialized by __kmpc_omp_task_alloc()
   // libcall.
   // Build kmp_int32 __kmpc_omp_task_with_deps(ident_t *, kmp_int32 gtid,
   // kmp_task_t *new_task, kmp_int32 ndeps, kmp_depend_info_t *dep_list,

     return;
   TaskResultTy Result =
       emitTaskInit(CGF, Loc, D, TaskFunction, SharedsTy, Shareds, Data);
-  // NOTE: routine and part_id fields are intialized by __kmpc_omp_task_alloc()
+  // NOTE: routine and part_id fields are initialized by __kmpc_omp_task_alloc()
   // libcall.
   // Call to void __kmpc_taskloop(ident_t *loc, int gtid, kmp_task_t *task, int
   // if_val, kmp_uint64 *lb, kmp_uint64 *ub, kmp_int64 st, int nogroup, int

       bool IsFirstComponentList, bool IsImplicit) const {
 
     // The following summarizes what has to be generated for each map and the
-    // types bellow. The generated information is expressed in this order:
+    // types below. The generated information is expressed in this order:
     // base pointer, section pointer, size, flags
     // (to add to the ones that come from the map type and modifier).
     //

lib/CodeGen/CGOpenMPRuntimeNVPTX.h

 
   /// Translates the native parameter of outlined function if this is required
   /// for target.
-  /// \param FD Field decl from captured record for the paramater.
+  /// \param FD Field decl from captured record for the parameter.
   /// \param NativeParam Parameter itself.
   const VarDecl *translateParameter(const FieldDecl *FD,
                                     const VarDecl *NativeParam) const override;

lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp

   // Get the array of arguments.
   SmallVector<llvm::Value *, 8> Args;
 
-  // TODO: suppport SIMD and pass actual values
+  // TODO: support SIMD and pass actual values
   Args.emplace_back(llvm::ConstantPointerNull::get(
       CGM.Int32Ty->getPointerTo()));
   Args.emplace_back(llvm::ConstantPointerNull::get(

lib/CodeGen/CGRecordLayoutBuilder.cpp

 ///   because LLVM reads from the complete type it can generate incorrect code
 ///   if we do not clip the tail padding off of the bitfield in the complete
 ///   layout.  This introduces a somewhat awkward extra unnecessary clip stage.
-///   The location of the clip is stored internally as a sentinal of type
+///   The location of the clip is stored internally as a sentinel of type
 ///   SCISSOR.  If LLVM were updated to read base types (which it probably
 ///   should because locations of things such as VBases are bogus in the llvm
 ///   type anyway) then we could eliminate the SCISSOR.

 struct CGRecordLowering {
   // MemberInfo is a helper structure that contains information about a record
   // member.  In additional to the standard member types, there exists a
-  // sentinal member type that ensures correct rounding.
+  // sentinel member type that ensures correct rounding.
   struct MemberInfo {
     CharUnits Offset;
     enum InfoKind { VFPtr, VBPtr, Field, Base, VBase, Scissor } Kind;

   void clipTailPadding();
   /// \brief Determines if we need a packed llvm struct.
   void determinePacked(bool NVBaseType);
-  /// \brief Inserts padding everwhere it's needed.
+  /// \brief Inserts padding everywhere it's needed.
   void insertPadding();
   /// \brief Fills out the structures that are ultimately consumed.
   void fillOutputFields();

   // non-virtual sub-object and an unpacked complete object or vise versa.
   if (NVSize % NVAlignment)
     Packed = true;
-  // Update the alignment of the sentinal.
+  // Update the alignment of the sentinel.
   if (!Packed)
     Members.back().Data = getIntNType(Context.toBits(Alignment));
 }

lib/CodeGen/CGStmt.cpp

     Builder.ClearInsertionPoint();
   }
 
-  // Emit the result value, even if unused, to evalute the side effects.
+  // Emit the result value, even if unused, to evaluate the side effects.
   const Expr *RV = S.getRetValue();
 
   // Treat block literals in a return expression as if they appeared

lib/CodeGen/CGStmtOpenMP.cpp

       EmitDecl(*PvtVD);
 
       // The initialization variables reached its purpose in the emission
-      // ofthe previous declaration, so we don't need it anymore.
+      // of the previous declaration, so we don't need it anymore.
       LocalDeclMap.erase(InitVD);
 
       // Return the address of the private variable.

       CGF.EmitStmt(S.getInnermostCapturedStmt()->getCapturedStmt());
     };
 
-    // Codegen that selects wheather to generate the privatization code or not.
+    // Codegen that selects whether to generate the privatization code or not.
     auto &&PrivCodeGen = [&S, &Info, &PrivatizeDevicePointers,
                           &InnermostCodeGen](CodeGenFunction &CGF,
                                              PrePostActionTy &Action) {

lib/CodeGen/CGVTables.cpp

   llvm_unreachable("Invalid TemplateSpecializationKind!");
 }
 
-/// This is a callback from Sema to tell us that that a particular vtable is
+/// This is a callback from Sema to tell us that a particular vtable is
 /// required to be emitted in this translation unit.
 ///
 /// This is only called for vtables that _must_ be emitted (mainly due to key

lib/CodeGen/CodeGenFunction.h

   /// True if we need emit the life-time markers.
   const bool ShouldEmitLifetimeMarkers;
 
-  /// Add OpenCL kernel arg metadata and the kernel attribute meatadata to
+  /// Add OpenCL kernel arg metadata and the kernel attribute metadata to
   /// the function metadata.
   void EmitOpenCLKernelMetadata(const FunctionDecl *FD,
                                 llvm::Function *Fn);

 
   void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr *Init);
 
-  /// Struct with all informations about dynamic [sub]class needed to set vptr.
+  /// Struct with all information about dynamic [sub]class needed to set vptr.
   struct VPtr {
     BaseSubobject Base;
     const CXXRecordDecl *NearestVBase;

lib/CodeGen/CodeGenModule.h

   /// Return the llvm::Constant for the address of the given global variable.
   /// If Ty is non-null and if the global doesn't exist, then it will be created
   /// with the specified type instead of whatever the normal requested type
-  /// would be. If IsForDefinition is true, it is guranteed that an actual
+  /// would be. If IsForDefinition is true, it is guaranteed that an actual
   /// global with type Ty will be returned, not conversion of a variable with
   /// the same mangled name but some other type.
   llvm::Constant *GetAddrOfGlobalVar(const VarDecl *D,

     DeferredVTables.push_back(RD);
   }
 
-  /// Emit code for a singal global function or var decl. Forward declarations
+  /// Emit code for a single global function or var decl. Forward declarations
   /// are emitted lazily.
   void EmitGlobal(GlobalDecl D);
 

lib/CodeGen/CodeGenModule.cpp

 /// If D is non-null, it specifies a decl that correspond to this.  This is used
 /// to set the attributes on the global when it is first created.
 ///
-/// If IsForDefinition is true, it is guranteed that an actual global with
+/// If IsForDefinition is true, it is guaranteed that an actual global with
 /// type Ty will be returned, not conversion of a variable with the same
 /// mangled name but some other type.
 llvm::Constant *

 /// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
 /// given global variable.  If Ty is non-null and if the global doesn't exist,
 /// then it will be created with the specified type instead of whatever the
-/// normal requested type would be. If IsForDefinition is true, it is guranteed
+/// normal requested type would be. If IsForDefinition is true, it is guaranteed
 /// that an actual global with type Ty will be returned, not conversion of a
 /// variable with the same mangled name but some other type.
 llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,

     return true;
 
   // A variable cannot be both common and exist in a section.
-  // We dont try to determine which is the right section in the front-end.
+  // We don't try to determine which is the right section in the front-end.
   // If no specialized section name is applicable, it will resort to default.
   if (D->hasAttr<PragmaClangBSSSectionAttr>() ||
       D->hasAttr<PragmaClangDataSectionAttr>() ||

     if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
         isa<CXXRecordDecl>(InitVD->getLexicalDeclContext())) {
       // Temporaries defined inside a class get linkonce_odr linkage because the
-      // class can be defined in multipe translation units.
+      // class can be defined in multiple translation units.
       Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
     } else {
       // There is no need for this temporary to have external linkage if the

lib/CodeGen/CoverageMappingGen.cpp

       auto Region = CounterMappingRegion::makeSkipped(
           *CovFileID, SR.LineStart, SR.ColumnStart, SR.LineEnd, SR.ColumnEnd);
       // Make sure that we only collect the regions that are inside
-      // the souce code of this function.
+      // the source code of this function.
       if (Region.LineStart >= FileLineRanges[*CovFileID].first &&
           Region.LineEnd <= FileLineRanges[*CovFileID].second)
         MappingRegions.push_back(Region);

lib/CodeGen/ItaniumCXXABI.cpp

     return;
 
   /// Initialize the 'this' slot. In the Itanium C++ ABI, no prologue
-  /// adjustments are required, becuase they are all handled by thunks.
+  /// adjustments are required, because they are all handled by thunks.
   setCXXABIThisValue(CGF, loadIncomingCXXThis(CGF));
 
   /// Initialize the 'vtt' slot if needed.

lib/CodeGen/MicrosoftCXXABI.cpp

 // BaseClassArray: Contains a list of classes in a hierarchy.  BaseClassArray is
 //   somewhat of a misnomer because the most derived class is also in the list
 //   as well as multiple copies of virtual bases (if they occur multiple times
-//   in the hiearchy.)  The BaseClassArray contains one BaseClassDescriptor for
+//   in the hierarchy.)  The BaseClassArray contains one BaseClassDescriptor for
 //   every path in the hierarchy, in pre-order depth first order.  Note, we do
 //   not declare a specific llvm type for BaseClassArray, it's merely an array
 //   of BaseClassDescriptor pointers.

                                   SourceLocation(),
                                   &getContext().Idents.get("is_most_derived"),
                                   getContext().IntTy, ImplicitParamDecl::Other);
-  // Only add the parameter to the list if thie class has virtual bases.
+  // Only add the parameter to the list if the class has virtual bases.
   if (RD->getNumVBases() > 0)
     FunctionArgs.push_back(&IsMostDerived);
 

lib/CodeGen/TargetInfo.h

   virtual llvm::SyncScope::ID getLLVMSyncScopeID(SyncScope S,
                                                  llvm::LLVMContext &C) const;
 
-  /// Inteface class for filling custom fields of a block literal for OpenCL.
+  /// Interface class for filling custom fields of a block literal for OpenCL.
   class TargetOpenCLBlockHelper {
   public:
     typedef std::pair<llvm::Value *, StringRef> ValueTy;

lib/CodeGen/VarBypassDetector.cpp

   case Stmt::CaseStmtClass:
   case Stmt::DefaultStmtClass:
   case Stmt::LabelStmtClass:
-    llvm_unreachable("the loop bellow handles labels and cases");
+    llvm_unreachable("the loop below handles labels and cases");
     break;
 
   default:

lib/Driver/Driver.cpp

 
   // Handle Apple-specific options available here.
   if (Target.isOSBinFormatMachO()) {
-    // If an explict Darwin arch name is given, that trumps all.
+    // If an explicit Darwin arch name is given, that trumps all.
     if (!DarwinArchName.empty()) {
       tools::darwin::setTripleTypeForMachOArchName(Target, DarwinArchName);
       return Target;

lib/Driver/ToolChains/Arch/ARM.cpp

 
     // Disable hardware FP features which have been enabled.
     // FIXME: Disabling vfp2 and neon should be enough as all the other
-    //        features are dependant on these 2 features in LLVM. However
+    //        features are dependent on these 2 features in LLVM. However
     //        there is currently no easy way to test this in clang, so for
     //        now just be explicit and disable all known dependent features
     //        as well.

lib/Driver/ToolChains/Clang.cpp

 void Clang::AddRISCVTargetArgs(const ArgList &Args,
                                ArgStringList &CmdArgs) const {
   // FIXME: currently defaults to the soft-float ABIs. Will need to be
-  // expanded to select ilp32f, ilp32d, lp64f, lp64d when appropiate.
+  // expanded to select ilp32f, ilp32d, lp64f, lp64d when appropriate.
   const char *ABIName = nullptr;
   const llvm::Triple &Triple = getToolChain().getTriple();
   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))

   // Handle various floating point optimization flags, mapping them to the
   // appropriate LLVM code generation flags. This is complicated by several
   // "umbrella" flags, so we do this by stepping through the flags incrementally
-  // adjusting what we think is enabled/disabled, then at the end settting the
+  // adjusting what we think is enabled/disabled, then at the end setting the
   // LLVM flags based on the final state.
   bool HonorINFs = true;
   bool HonorNaNs = true;

                     !IsWindowsMSVC || IsMSVC2015Compatible))
     CmdArgs.push_back("-fno-threadsafe-statics");
 
-  // -fno-delayed-template-parsing is default, except when targetting MSVC.
+  // -fno-delayed-template-parsing is default, except when targeting MSVC.
   // Many old Windows SDK versions require this to parse.
   // FIXME: MSVC introduced /Zc:twoPhase- to disable this behavior in their
   // compiler. We should be able to disable this by default at some point.

lib/Driver/ToolChains/CommonArgs.cpp

     RWPI = true;
   }
 
-  // ROPI and RWPI are not comaptible with PIC or PIE.
+  // ROPI and RWPI are not compatible with PIC or PIE.
   if ((ROPI || RWPI) && (PIC || PIE))
     ToolChain.getDriver().Diag(diag::err_drv_ropi_rwpi_incompatible_with_pic);
 

lib/Driver/ToolChains/Cuda.cpp

         StringRef GpuArch = FileName.slice(
             LibDeviceName.size(), FileName.find('.', LibDeviceName.size()));
         LibDeviceMap[GpuArch] = FilePath.str();
-        // Insert map entries for specifc devices with this compute
+        // Insert map entries for specific devices with this compute
         // capability. NVCC's choice of the libdevice library version is
         // rather peculiar and depends on the CUDA version.
         if (GpuArch == "compute_20") {

lib/Driver/ToolChains/Hexagon.cpp

   // Handle -mhvx-length=, -mhvx-double.
   if (Arg *A = Args.getLastArg(options::OPT_mhexagon_hvx_length_EQ,
                                options::OPT_mhexagon_hvx_double)) {
-    // These falgs are valid only if HVX in enabled.
+    // These flags are valid only if HVX in enabled.
     if (!HasHVX)
       D.Diag(diag::err_drv_invalid_hvx_length);
     else if (A->getOption().matches(options::OPT_mhexagon_hvx_length_EQ))

lib/Format/UnwrappedLineParser.h

   // token.
   //
   // NextTok specifies the next token. A null pointer NextTok is supported, and
-  // signifies either the absense of a next token, or that the next token
+  // signifies either the absence of a next token, or that the next token
   // shouldn't be taken into accunt for the analysis.
   void distributeComments(const SmallVectorImpl<FormatToken *> &Comments,
                           const FormatToken *NextTok);

lib/Frontend/ASTMerge.cpp

-//===-- ASTMerge.cpp - AST Merging Frontent Action --------------*- C++ -*-===//
+//===-- ASTMerge.cpp - AST Merging Frontend Action --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //

lib/Frontend/CacheTokens.cpp

   // Next write out PPCond.
   Offset PPCondOff = (Offset) Out.tell();
 
-  // Write out the size of PPCond so that clients can identifer empty tables.
+  // Write out the size of PPCond so that clients can identifier empty tables.
   Emit32(PPCond.size());
 
   for (unsigned i = 0, e = PPCond.size(); i!=e; ++i) {

lib/Frontend/CompilerInstance.cpp

         // case of timeout, build it ourselves.
         Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout)
             << Module->Name;
-        // Clear the lock file so that future invokations can make progress.
+        // Clear the lock file so that future invocations can make progress.
         Locked.unsafeRemoveLockFile();
         continue;
       }

lib/Frontend/CompilerInvocation.cpp

       for (const auto &arg : ASL) {
         StringRef ArgStr(arg);
         Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end());
-        // using \00 to seperate each commandline options.
+        // using \00 to separate each commandline options.
         Opts.CmdArgs.push_back('\0');
       }
     }

                                   VT.getSubminor().getValueOr(0);
   }
 
-  // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
+  // Mimicking gcc's behavior, trigraphs are only enabled if -trigraphs
   // is specified, or -std is set to a conforming mode.
   // Trigraphs are disabled by default in c++1z onwards.
   Opts.Trigraphs = !Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17;

     parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
                         Diags, LangOpts.Sanitize);
   } else {
-    // Other LangOpts are only initialzed when the input is not AST or LLVM IR.
+    // Other LangOpts are only initialized when the input is not AST or LLVM IR.
     // FIXME: Should we really be calling this for an InputKind::Asm input?
     ParseLangArgs(LangOpts, Args, DashX, Res.getTargetOpts(),
                   Res.getPreprocessorOpts(), Diags);

lib/Frontend/DiagnosticRenderer.cpp

   }
 }
 
-/// \brief Helper to recursivly walk up the include stack and print each layer
+/// \brief Helper to recursively walk up the include stack and print each layer
 /// on the way back down.
 void DiagnosticRenderer::emitIncludeStackRecursively(FullSourceLoc Loc) {
   if (Loc.isInvalid()) {

   emitImportStackRecursively(NextImportLoc.first, NextImportLoc.second);
 }
 
-/// \brief Helper to recursivly walk up the import stack and print each layer
+/// \brief Helper to recursively walk up the import stack and print each layer
 /// on the way back down.
 void DiagnosticRenderer::emitImportStackRecursively(FullSourceLoc Loc,
                                                     StringRef ModuleName) {

 }
 
 /// Check if all the locations in the range have the same macro argument
-/// expansion, and that that expansion starts with ArgumentLoc.
+/// expansion, and that the expansion starts with ArgumentLoc.
 static bool checkRangeForMacroArgExpansion(CharSourceRange Range,
                                            const SourceManager &SM,
                                            SourceLocation ArgumentLoc) {

lib/Frontend/ModuleDependencyCollector.cpp

 
   // Change path to all upper case and ask for its real path, if the latter
   // exists and is equal to Path, it's not case sensitive. Default to case
-  // sensitive in the absense of realpath, since this is what the VFSWriter
+  // sensitive in the absence of realpath, since this is what the VFSWriter
   // already expects when sensitivity isn't setup.
   for (auto &C : Path)
     UpperDest.push_back(toUppercase(C));

lib/Frontend/Rewrite/RewriteModernObjC.cpp

    if (Ivar->getAccessControl() == ObjCIvarDecl::Private ||
        Ivar->getAccessControl() == ObjCIvarDecl::Package ||
        Class->getVisibility() == HiddenVisibility)
-     Visibility shoud be: HiddenVisibility;
+     Visibility should be: HiddenVisibility;
    else
-     Visibility shoud be: DefaultVisibility;
+     Visibility should be: DefaultVisibility;
   */
   
   Result += "\n";

lib/Frontend/SerializedDiagnosticPrinter.cpp

   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Diagnostc text.
   Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
   
-  // Emit abbrevation for RECORD_CATEGORY.
+  // Emit abbreviation for RECORD_CATEGORY.
   Abbrev = std::make_shared<BitCodeAbbrev>();
   Abbrev->Add(BitCodeAbbrevOp(RECORD_CATEGORY));
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 16)); // Category ID.

   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));      // Category text.
   Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
 
-  // Emit abbrevation for RECORD_SOURCE_RANGE.
+  // Emit abbreviation for RECORD_SOURCE_RANGE.
   Abbrev = std::make_shared<BitCodeAbbrev>();
   Abbrev->Add(BitCodeAbbrevOp(RECORD_SOURCE_RANGE));
   AddRangeLocationAbbrev(*Abbrev);

lib/Headers/__clang_cuda_builtin_vars.h

 #define __DELETE
 #endif
 
-// Make sure nobody can create instances of the special varible types.  nvcc
+// Make sure nobody can create instances of the special variable types.  nvcc
 // also disallows taking address of special variables, so we disable address-of
 // operator as well.
 #define __CUDA_DISALLOW_BUILTINVAR_ACCESS(TypeName)                            \

lib/Headers/__wmmintrin_aes.h

   return (__m128i)__builtin_ia32_aesimc128((__v2di)__V);
 }
 
-/// \brief Generates a round key for AES encyption, operating on 128-bit data
+/// \brief Generates a round key for AES encryption, operating on 128-bit data
 ///    specified in the first source operand and using an 8-bit round constant
 ///    specified by the second source operand, and writes the result to the
 ///    destination.

lib/Headers/htmintrin.h

 #define _TEXASRU_TRANSLATION_INVALIDATION_CONFLICT(TEXASRU) \
   _TEXASRU_EXTRACT_BITS(TEXASRU, 14, 1)
 
-#define _TEXASR_IMPLEMENTAION_SPECIFIC(TEXASR) \
+#define _TEXASR_IMPLEMENTATION_SPECIFIC(TEXASR) \
   _TEXASR_EXTRACT_BITS(TEXASR, 15, 1)
-#define _TEXASRU_IMPLEMENTAION_SPECIFIC(TEXASRU) \
+#define _TEXASRU_IMPLEMENTATION_SPECIFIC(TEXASRU) \
   _TEXASRU_EXTRACT_BITS(TEXASRU, 15, 1)
 
 #define _TEXASR_INSTRUCTION_FETCH_CONFLICT(TEXASR) \

lib/Headers/htmxlintrin.h

 
 /* These intrinsics are being made available for compatibility with
    the IBM XL compiler.  For documentation please see the "z/OS XL
-   C/C++ Programming Guide" publically available on the web.  */
+   C/C++ Programming Guide" publicly available on the web.  */
 
 static __inline long __attribute__((__always_inline__, __nodebug__))
 __TM_simple_begin ()

lib/Headers/stdint.h

  *
  * To accommodate targets that are missing types that are exactly 8, 16, 32, or
  * 64 bits wide, this implementation takes an approach of cascading
- * redefintions, redefining __int_leastN_t to successively smaller exact-width
+ * redefinitions, redefining __int_leastN_t to successively smaller exact-width
  * types. It is therefore important that the types are defined in order of
  * descending widths.
  *

  * As in the type definitions, this section takes an approach of
  * successive-shrinking to determine which limits to use for the standard (8,
  * 16, 32, 64) bit widths when they don't have exact representations. It is
- * therefore important that the defintions be kept in order of decending
+ * therefore important that the definitions be kept in order of decending
  * widths.
  *
  * Note that C++ should not check __STDC_LIMIT_MACROS here, contrary to the

lib/Lex/HeaderSearch.cpp

   // module.private.modulemap that are supposed to define private submodules --
   // may have different flavors of names: FooPrivate, Foo_Private and Foo.Private.
   //
-  // Foo.Private is now depracated in favor of Foo_Private. Users of FooPrivate
+  // Foo.Private is now deprecated in favor of Foo_Private. Users of FooPrivate
   // should also rename to Foo_Private. Representing private as submodules
   // could force building unwanted dependencies into the parent module and cause
   // dependency cycles.

lib/Lex/Lexer.cpp

 StringRef Lexer::getImmediateMacroName(SourceLocation Loc,
                                        const SourceManager &SM,
                                        const LangOptions &LangOpts) {
-  assert(Loc.isMacroID() && "Only reasonble to call this on macros");
+  assert(Loc.isMacroID() && "Only reasonable to call this on macros");
 
   // Find the location of the immediate macro expansion.
   while (true) {

 
 StringRef Lexer::getImmediateMacroNameForDiagnostics(
     SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts) {
-  assert(Loc.isMacroID() && "Only reasonble to call this on macros");
+  assert(Loc.isMacroID() && "Only reasonable to call this on macros");
   // Walk past macro argument expanions.
   while (SM.isMacroArgExpansion(Loc))
     Loc = SM.getImmediateExpansionRange(Loc).first;

 }
 
 /// We have just read the // characters from input.  Skip until we find the
-/// newline character thats terminate the comment.  Then update BufferPtr and
+/// newline character that terminates the comment.  Then update BufferPtr and
 /// return.
 ///
 /// If we're in KeepCommentMode or any CommentHandler has inserted

       // want to lex this as a comment.  There is one problem with this though,
       // that in one particular corner case, this can change the behavior of the
       // resultant program.  For example, In  "foo //**/ bar", C89 would lex
-      // this as "foo / bar" and langauges with Line comments would lex it as
+      // this as "foo / bar" and languages with Line comments would lex it as
       // "foo".  Check to see if the character after the second slash is a '*'.
       // If so, we will lex that as a "/" instead of the start of a comment.
       // However, we never do this if we are just preprocessing.

lib/Lex/MacroArgs.cpp

   // If the last character of the string is a \, and if it isn't escaped, this
   // is an invalid string literal, diagnose it as specified in C99.
   if (Result.back() == '\\') {
-    // Count the number of consequtive \ characters.  If even, then they are
+    // Count the number of consecutive \ characters.  If even, then they are
     // just escaped backslashes, otherwise it's an error.
     unsigned FirstNonSlash = Result.size()-2;
     // Guaranteed to find the starting " if nothing else.

lib/Lex/PPDirectives.cpp

   // Read the rest of the line raw.  We do this because we don't want macros
   // to be expanded and we don't require that the tokens be valid preprocessing
   // tokens.  For example, this is allowed: "#warning `   'foo".  GCC does
-  // collapse multiple consequtive white space between tokens, but this isn't
+  // collapse multiple consecutive white space between tokens, but this isn't
   // specified by the standard.
   SmallString<128> Message;
   CurLexer->ReadToEndOfLine(&Message);

lib/Lex/PTHLexer.cpp

     // Compute the actual memory address of the '#' token data for this entry.
     HashEntryI = TokBuf + Offset;
 
-    // Optmization: "Sibling jumping".  #if...#else...#endif blocks can
+    // Optimization: "Sibling jumping".  #if...#else...#endif blocks can
     //  contain nested blocks.  In the side-table we can jump over these
     //  nested blocks instead of doing a linear search if the next "sibling"
     //  entry is not at a location greater than LastHashTokPtr.

lib/Lex/TokenLexer.cpp

       bool VaArgsPseudoPaste = false;
       // If this is the GNU ", ## __VA_ARGS__" extension, and we just learned
       // that __VA_ARGS__ expands to multiple tokens, avoid a pasting error when
-      // the expander trys to paste ',' with the first token of the __VA_ARGS__
+      // the expander tries to paste ',' with the first token of the __VA_ARGS__
       // expansion.
       if (NonEmptyPasteBefore && ResultToks.size() >= 2 &&
           ResultToks[ResultToks.size()-2].is(tok::comma) &&

lib/Parse/ParseDecl.cpp

 
   SourceLocation Loc = Tok.getLocation();
   // If we see an identifier that is not a type name, we normally would
-  // parse it as the identifer being declared.  However, when a typename
+  // parse it as the identifier being declared.  However, when a typename
   // is typo'd or the definition is not included, this will incorrectly
   // parse the typename as the identifier name and fall over misparsing
   // later parts of the diagnostic.

                                  getLangOpts());
       break;
     case tok::kw___uptr:
-      // GNU libc headers in C mode use '__uptr' as an identifer which conflicts
+      // GNU libc headers in C mode use '__uptr' as an identifier which conflicts
       // with the MS modifier keyword.
       if ((AttrReqs & AR_DeclspecAttributesParsed) && !getLangOpts().CPlusPlus &&
           IdentifierRequired && DS.isEmpty() && NextToken().is(tok::semi)) {

lib/Parse/ParsePragma.cpp

 
 namespace {
 
-/// Describes the stage at which attribute subject rule parsing was interruped.
+/// Describes the stage at which attribute subject rule parsing was interrupted.
 enum class MissingAttributeSubjectRulesRecoveryPoint {
   Comma,
   ApplyTo,

     TokenVector.push_back(Tok);
     AnnotTok.setAnnotationEndLoc(Tok.getLocation());
   }
-  // Add a sentinal EoF token to the end of the list.
+  // Add a sentinel EoF token to the end of the list.
   TokenVector.push_back(EoF);
   // We must allocate this array with new because EnterTokenStream is going to
   // delete it later.

lib/Parse/Parser.cpp

 
   // Look up and classify the identifier. We don't perform any typo-correction
   // after a scope specifier, because in general we can't recover from typos
-  // there (eg, after correcting 'A::tempalte B<X>::C' [sic], we would need to
+  // there (eg, after correcting 'A::template B<X>::C' [sic], we would need to
   // jump back into scope specifier parsing).
   Sema::NameClassification Classification = Actions.ClassifyName(
       getCurScope(), SS, Name, NameLoc, Next, IsAddressOfOperand,

lib/Sema/Sema.cpp

 
   FunctionScopes.push_back(new FunctionScopeInfo(Diags));
 
-  // Initilization of data sharing attributes stack for OpenMP
+  // Initialization of data sharing attributes stack for OpenMP
   InitDataSharingAttributesStack();
 
   std::unique_ptr<sema::SemaPPCallbacks> Callbacks =

lib/Sema/SemaAttr.cpp

   // "#pragma pack(pop, identifier, n) is undefined"
   if (Action & Sema::PSK_Pop) {
     if (Alignment && !SlotLabel.empty())
-      Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifer_and_alignment);
+      Diag(PragmaLoc, diag::warn_pragma_pack_pop_identifier_and_alignment);
     if (PackStack.Stack.empty())
       Diag(PragmaLoc, diag::warn_pragma_pop_failed) << "pack" << "stack empty";
   }

lib/Sema/SemaCast.cpp

       }
     }
   }
-  // Allow arbitray objective-c pointer conversion with static casts.
+  // Allow arbitrary objective-c pointer conversion with static casts.
   if (SrcType->isObjCObjectPointerType() &&
       DestType->isObjCObjectPointerType()) {
     Kind = CK_BitCast;

lib/Sema/SemaChecking.cpp

   case Mips::BI__builtin_msa_srlri_h: i = 1; l = 0; u = 15; break;
   case Mips::BI__builtin_msa_binsli_h:
   case Mips::BI__builtin_msa_binsri_h: i = 2; l = 0; u = 15; break;
-  // These intrinsics take an unsigned 5 bit immedate.
+  // These intrinsics take an unsigned 5 bit immediate.
   // The first block of intrinsics actually have an unsigned 5 bit field,
   // not a df/n field.
   case Mips::BI__builtin_msa_clei_u_b:

                        Loc, IsStringLocation, StringRange, FixIt);
 }
 
-/// \brief If the format string is not within the funcion call, emit a note
+/// \brief If the format string is not within the function call, emit a note
 /// so that the function call and string are in diagnostic messages.
 ///
 /// \param InFunctionCall if true, the format string is within the function

       ::CheckBoolLikeConversion(S, U->getSubExpr(), CC);
 }
 
-/// Diagnose integer type and any valid implicit convertion to it.
+/// Diagnose integer type and any valid implicit conversion to it.
 static bool checkOpenCLEnqueueIntType(Sema &S, Expr *E, const QualType &IntT) {
   // Taking into account implicit conversions,
   // allow any integer.

 
     // If the parameter is a c++ class type and it has to be destructed in the
     // callee function, declare the destructor so that it can be called by the
-    // callee function. Do not perfom any direct access check on the dtor here.
+    // callee function. Do not perform any direct access check on the dtor here.
     if (!Param->isInvalidDecl()) {
       if (CXXRecordDecl *ClassDecl = Param->getType()->getAsCXXRecordDecl()) {
         if (!ClassDecl->isInvalidDecl() &&

lib/Sema/SemaCodeComplete.cpp

 ///
 /// \param Block The most relevant type location for that block type.
 ///
-/// \param SuppressBlockName Determines wether or not the name of the block
+/// \param SuppressBlockName Determines whether or not the name of the block
 /// declaration is included in the resulting string.
 static std::string
 formatBlockPlaceholder(const PrintingPolicy &Policy, const NamedDecl *BlockDecl,

lib/Sema/SemaCoroutine.cpp

 
 // See if return type is coroutine-handle and if so, invoke builtin coro-resume
 // on its address. This is to enable experimental support for coroutine-handle
-// returning await_suspend that results in a guranteed tail call to the target
+// returning await_suspend that results in a guaranteed tail call to the target
 // coroutine.
 static Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E,
                            SourceLocation Loc) {

lib/Sema/SemaDecl.cpp

 } // end anonymous namespace
 
 /// \brief Report an error regarding overriding, along with any relevant
-/// overriden methods.
+/// overridden methods.
 ///
 /// \param DiagID the primary error to report.
 /// \param MD the overriding method.

   } else if (VDecl->isFileVarDecl()) {
     // In C, extern is typically used to avoid tentative definitions when
     // declaring variables in headers, but adding an intializer makes it a
-    // defintion. This is somewhat confusing, so GCC and Clang both warn on it.
+    // definition. This is somewhat confusing, so GCC and Clang both warn on it.
     // In C++, extern is often used to give implictly static const variables
     // external linkage, so don't warn in that case. If selectany is present,
     // this might be header code intended for C and C++ inclusion, so apply the

                                             SOEnd = M->second.end();
                    SO != SOEnd; ++SO) {
                 assert(SO->second.size() > 0 &&
-                       "Virtual function without overridding functions?");
+                       "Virtual function without overriding functions?");
                 if (SO->second.size() == 1)
                   continue;
 

lib/Sema/SemaDeclAttr.cpp

 /// \param Ctx The context that the reference occurred in
 /// \param ReferringDecl The exact declaration that was referenced.
 /// \param OffendingDecl A related decl to \c ReferringDecl that has an
-/// availability attribute corrisponding to \c K attached to it. Note that this
+/// availability attribute corresponding to \c K attached to it. Note that this
 /// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and
 /// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl
 /// and OffendingDecl is the EnumDecl.

lib/Sema/SemaDeclCXX.cpp

         ME = dyn_cast<MemberExpr>(ME->getBase()->IgnoreParenImpCasts());
       }
 
-      // Binding a reference to an unintialized field is not an
+      // Binding a reference to an uninitialized field is not an
       // uninitialized use.
       if (CheckReferenceOnly && !ReferenceField)
         return true;

   SmallVector<CXXMethodDecl *, 8> OverloadedMethods;
 
 private:
-  /// Check whether any most overriden method from MD in Methods
+  /// Check whether any most overridden method from MD in Methods
   static bool CheckMostOverridenMethods(
       const CXXMethodDecl *MD,
       const llvm::SmallPtrSetImpl<const CXXMethodDecl *> &Methods) {

 };
 } // end anonymous namespace
 
-/// \brief Add the most overriden methods from MD to Methods
+/// \brief Add the most overridden methods from MD to Methods
 static void AddMostOverridenMethods(const CXXMethodDecl *MD,
                         llvm::SmallPtrSetImpl<const CXXMethodDecl *>& Methods) {
   if (MD->size_overridden_methods() == 0)

   FHVM.Method = MD;
   FHVM.S = this;
 
-  // Keep the base methods that were overriden or introduced in the subclass
+  // Keep the base methods that were overridden or introduced in the subclass
   // by 'using' in a set. A base method not in this set is hidden.
   CXXRecordDecl *DC = MD->getParent();
   DeclContext::lookup_result R = DC->lookup(MD->getDeclName());

 
   // Salient point: SS doesn't have to name a base class as long as
   // lookup only finds members from base classes.  Therefore we can
-  // diagnose here only if we can prove that that can't happen,
+  // diagnose here only if we can prove that can't happen,
   // i.e. if the class hierarchies provably don't intersect.
 
   // TODO: it would be nice if "definitely valid" results were cached

   Expr *Comparison
     = new (S.Context) BinaryOperator(IterationVarRefRVal.build(S, Loc),
                      IntegerLiteral::Create(S.Context, Upper, SizeType, Loc),
-                                     BO_NE, S.Context.BoolTy,
-                                     VK_RValue, OK_Ordinary, Loc, FPOptions());
-
-  // Create the pre-increment of the iteration variable. We can determine
-  // whether the increment will overflow based on the value of the array
-  // bound.
-  Expr *Increment = new (S.Context)
-      UnaryOperator(IterationVarRef.build(S, Loc), UO_PreInc, SizeType,
-                    VK_LValue, OK_Ordinary, Loc, Upper.isMaxValue());
-
-  // Construct the loop that copies all elements of this array.
-  return S.ActOnForStmt(
+                                     BO_NE, S.Context.BoolTy,
+                                     VK_RValue, OK_Ordinary, Loc, FPOptions());
+
+  // Create the pre-increment of the iteration variable. We can determine
+  // whether the increment will overflow based on the value of the array
+  // bound.
+  Expr *Increment = new (S.Context)
+      UnaryOperator(IterationVarRef.build(S, Loc), UO_PreInc, SizeType,
+                    VK_LValue, OK_Ordinary, Loc, Upper.isMaxValue());
+
+  // Construct the loop that copies all elements of this array.
+  return S.ActOnForStmt(
       Loc, Loc, InitStmt,
       S.ActOnCondition(nullptr, Loc, Comparison, Sema::ConditionKind::Boolean),
       S.MakeFullDiscardedValueExpr(Increment), Loc, Copy.get());

lib/Sema/SemaDeclObjC.cpp

             // This is because method will be implemented in the primary class 
             // or one of its super class implementation.
             
-            // Ugly, but necessary. Method declared in protcol might have
+            // Ugly, but necessary. Method declared in protocol might have
             // have been synthesized due to a property declared in the class which
             // uses the protocol.
             if (ObjCMethodDecl *MethodInClass =

            MethodInterface->isSuperClassOf(BoundInterface) ||
            BoundInterface->isSuperClassOf(MethodInterface);
   }
-  llvm_unreachable("unknow method context");
+  llvm_unreachable("unknown method context");
 }
 
 /// We first select the type of the method: Instance or Factory, then collect

lib/Sema/SemaExpr.cpp

   }
 
   // Semantic analysis for initializers is done by ActOnDeclarator() and
-  // CheckInitializer() - it requires knowledge of the object being intialized.
+  // CheckInitializer() - it requires knowledge of the object being initialized.
 
   InitListExpr *E = new (Context) InitListExpr(Context, LBraceLoc, InitArgList,
                                                RBraceLoc);

   QualType IntTy = Int->get()->getType().getUnqualifiedType();
 
   // Determine if the integer constant can be expressed as a floating point
-  // number of the appropiate type.
+  // number of the appropriate type.
   llvm::APSInt Result;
   bool CstInt = Int->get()->EvaluateAsInt(Result, S.Context);
   uint64_t Bits = 0;

     OK = Input.get()->getObjectKind();
     break;
   case UO_Coawait:
-    // It's unnessesary to represent the pass-through operator co_await in the
+    // It's unnecessary to represent the pass-through operator co_await in the
     // AST; just return the input expression instead.
     assert(!Input.get()->getType()->isDependentType() &&
                    "the co_await expression must be non-dependant before "

lib/Sema/SemaExprCXX.cpp

   //      constraint that in the conversion the reference must bind directly to
   //      an lvalue.
   //   -- If E2 is an xvalue: E1 can be converted to match E2 if E1 can be
-  //      implicitly conveted to the type "rvalue reference to R2", subject to
+  //      implicitly converted to the type "rvalue reference to R2", subject to
   //      the constraint that the reference must bind directly.
   if (To->isLValue() || To->isXValue()) {
     QualType T = To->isLValue() ? Self.Context.getLValueReferenceType(ToType)

lib/Sema/SemaExprObjC.cpp

               // to select a better one.
               Method = Methods[0];
 
-              // If we find an instance method, emit waring.
+              // If we find an instance method, emit warning.
               if (Method->isInstanceMethod()) {
                 if (const ObjCInterfaceDecl *ID =
                     dyn_cast<ObjCInterfaceDecl>(Method->getDeclContext())) {

lib/Sema/SemaInit.cpp

 }
 
 /// Determine whether an expression is a non-referenceable glvalue (one to
-/// which a reference can never bind). Attemting to bind a reference to
+/// which a reference can never bind). Attempting to bind a reference to
 /// such a glvalue will always create a temporary.
 static bool isNonReferenceableGLValue(Expr *E) {
   return E->refersToBitField() || E->refersToVectorElement();

lib/Sema/SemaLookup.cpp

   }
   // Do not transform this into an iterator-based loop. The loop body can
   // trigger the creation of further types (through lazy deserialization) and
-  // invalide iterators into this list.
+  // invalid iterators into this list.
   auto &Types = SemaRef.getASTContext().getTypes();
   for (unsigned I = 0; I != Types.size(); ++I) {
     const auto *TI = Types[I];

           SS->getScopeRep()->print(OldOStream, SemaRef.getPrintingPolicy());
           OldOStream << Typo->getName();
           // If correction candidate would be an identical written qualified
-          // identifer, then the existing CXXScopeSpec probably included a
+          // identifier, then the existing CXXScopeSpec probably included a
           // typedef that didn't get accounted for properly.
           if (OldOStream.str() == NewQualified)
             break;

lib/Sema/SemaOverload.cpp

         Expr::Classification ObjectClassification;
         if (Args.size() > 0) {
           if (Expr *E = Args[0]) {
-            // Use the explit base to restrict the lookup:
+            // Use the explicit base to restrict the lookup:
             ObjectType = E->getType();
             ObjectClassification = E->Classify(Context);
           } // .. else there is an implit base.

         QualType ObjectType;
         Expr::Classification ObjectClassification;
         if (Expr *E = Args[0]) {
-          // Use the explit base to restrict the lookup:
+          // Use the explicit base to restrict the lookup:
           ObjectType = E->getType();
           ObjectClassification = E->Classify(Context);
         } // .. else there is an implit base.

       << Fn->getSourceRange();
     CandidateSet->NoteCandidates(SemaRef, OCD_AllCandidates, Args);
 
-    // We emitted an error for the unvailable/deleted function call but keep
+    // We emitted an error for the unavailable/deleted function call but keep
     // the call in the AST.
     FunctionDecl *FDecl = (*Best)->Function;
     Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);

       if (Opc == BO_Comma)
         break;
 
-      // For class as left operand for assignment or compound assigment
+      // For class as left operand for assignment or compound assignment
       // operator do not fall through to handling in built-in, but report that
       // no overloaded assignment operator found
       ExprResult Result = ExprError();

lib/Sema/SemaStmt.cpp

         // FIXME: This results in codegen generating IR that recalculates the
         // run-time number of elements (as opposed to just using the IR Value
         // that corresponds to the run-time value of each bound that was
-        // generated when the array was created.) If this proves too embarassing
+        // generated when the array was created.) If this proves too embarrassing
         // even for unoptimized IR, consider passing a magic-value/cookie to
         // codegen that then knows to simply use that initial llvm::Value (that
         // corresponds to the bound at time of array creation) within

 
   if (ReturnsReference) {
     // Loop variable creates a temporary.  Suggest either to go with
-    // non-reference loop variable to indiciate a copy is made, or
+    // non-reference loop variable to indicate a copy is made, or
     // the correct time to bind a const reference.
     SemaRef.Diag(VD->getLocation(), diag::warn_for_range_const_reference_copy)
         << VD << VariableType << E->getType();

 /// DiagnoseForRangeVariableCopies - Diagnose three cases and fixes for them.
 /// 1) for (const foo &x : foos) where foos only returns a copy.  Suggest
 ///    using "const foo x" to show that a copy is made
-/// 2) for (const bar &x : foos) where bar is a temporary intialized by bar.
+/// 2) for (const bar &x : foos) where bar is a temporary initialized by bar.
 ///    Suggest either "const bar x" to keep the copying or "const foo& x" to
 ///    prevent the copy.
 /// 3) for (const foo x : foos) where x is constructed from a reference foo.

lib/Sema/SemaTemplate.cpp

       return false;
 
     case TSK_ExplicitInstantiationDeclaration:
-      // We're explicity instantiating a definition for something for which we
+      // We're explicitly instantiating a definition for something for which we
       // were previously asked to suppress instantiations. That's fine.
 
       // C++0x [temp.explicit]p4:

lib/Sema/SemaTemplateDeduction.cpp

       return Y;
     }
 
-    // If we deduced two declarations, make sure they they refer to the
+    // If we deduced two declarations, make sure that they refer to the
     // same declaration.
     if (Y.getKind() == TemplateArgument::Declaration &&
         isSameDeclaration(X.getAsDecl(), Y.getAsDecl()))

lib/Sema/SemaType.cpp

 
   // Handle the cases where address space should not be deduced.
   //
-  // The pointee type of a pointer type is alwasy deduced since a pointer always
+  // The pointee type of a pointer type is always deduced since a pointer always
   // points to some memory location which should has an address space.
   //
   // There are situations that at the point of certain declarations, the address
   // space may be unknown and better to be left as default. For example, when
-  // definining a typedef or struct type, they are not associated with any
+  // defining a typedef or struct type, they are not associated with any
   // specific address space. Later on, they may be used with any address space
   // to declare a variable.
   //

lib/Sema/TreeTransform.h

 /// subclasses to customize any of its operations. Thus, a subclass can
 /// override any of the transformation or rebuild operators by providing an
 /// operation with the same signature as the default implementation. The
-/// overridding function should not be virtual.
+/// overriding function should not be virtual.
 ///
 /// Semantic tree transformations are split into two stages, either of which
 /// can be replaced by a subclass. The "transform" step transforms an AST node

lib/Serialization/ASTReader.cpp

   }
 
   // Check if there was a request to override the contents of the file
-  // that was part of the precompiled header. Overridding such a file
+  // that was part of the precompiled header. Overriding such a file
   // can lead to problems when lexing using the source locations from the
   // PCH.
   SourceManager &SM = getSourceManager();

lib/Serialization/ASTWriter.cpp

 /// lexically declared within the given DeclContext.
 ///
 /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the
-/// bistream, or 0 if no block was written.
+/// bitstream, or 0 if no block was written.
 uint64_t ASTWriter::WriteDeclContextLexicalBlock(ASTContext &Context,
                                                  DeclContext *DC) {
   if (DC->decls_empty())

lib/StaticAnalyzer/Checkers/ChrootChecker.cpp

   if (!II_chdir)
     II_chdir = &Ctx.Idents.get("chdir");
 
-  // Ingnore chroot and chdir.
+  // Ignore chroot and chdir.
   if (FD->getIdentifier() == II_chroot || FD->getIdentifier() == II_chdir)
     return;
 

lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp

 }
 
 static bool isObjCTypeParamDependent(QualType Type) {
-  // It is illegal to typedef parameterized types inside an interface. Therfore
+  // It is illegal to typedef parameterized types inside an interface. Therefore
   // an Objective-C type can only be dependent on a type parameter when the type
   // parameter structurally present in the type itself.
   class IsObjCTypeParamDependentTypeVisitor

lib/StaticAnalyzer/Checkers/IvarInvalidationChecker.cpp

 //  been called on them. An invalidation method should either invalidate all
 //  the ivars or call another invalidation method (on self).
 //
-//  Partial invalidor annotation allows to addess cases when ivars are
+//  Partial invalidor annotation allows to address cases when ivars are
 //  invalidated by other methods, which might or might not be called from
 //  the invalidation method. The checker checks that each invalidation
 //  method and all the partial methods cumulatively invalidate all ivars.

lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

 void EmptyLocalizationContextChecker::MethodCrawler::VisitObjCMessageExpr(
     const ObjCMessageExpr *ME) {
 
-  // FIXME: We may be able to use PPCallbacks to check for empy context
+  // FIXME: We may be able to use PPCallbacks to check for empty context
   // comments as part of preprocessing and avoid this re-lexing hack.
   const ObjCInterfaceDecl *OD = ME->getReceiverInterface();
   if (!OD)

   // Generate the bug report.
   BR.EmitBasicReport(AC->getDecl(), Checker, "Plural Misuse",
                      "Localizability Issue (Apple)",
-                     "Plural cases are not supported accross all languages. "
+                     "Plural cases are not supported across all languages. "
                      "Use a .stringsdict file instead",
                      PathDiagnosticLocation(S, BR.getSourceManager(), AC));
 }

lib/StaticAnalyzer/Checkers/NonnullGlobalConstantsChecker.cpp

 
 } // namespace
 
-/// Lazily initialize cache for required identifier informations.
+/// Lazily initialize cache for required identifier information.
 void NonnullGlobalConstantsChecker::initIdentifierInfo(ASTContext &Ctx) const {
   if (NSStringII)
     return;

lib/StaticAnalyzer/Checkers/NullabilityChecker.cpp

 // initial direct violation has been discovered, and (3) warning after a direct
 // violation that has been implicitly or explicitly suppressed (for
 // example, with a cast of NULL to _Nonnull). In essence, once an invariant
-// violation is detected on a path, this checker will be esentially turned off
+// violation is detected on a path, this checker will be essentially turned off
 // for the rest of the analysis
 //
 // The analyzer takes this approach (rather than generating a sink node) to

lib/StaticAnalyzer/Checkers/RetainCountChecker.cpp

   }
 
   const RetainSummary *find(IdentifierInfo* II, Selector S) {
-    // FIXME: Class method lookup.  Right now we dont' have a good way
+    // FIXME: Class method lookup.  Right now we don't have a good way
     // of going between IdentifierInfo* and the class hierarchy.
     MapTy::iterator I = M.find(ObjCSummaryKey(II, S));
 

lib/StaticAnalyzer/Core/CoreEngine.cpp

     auto BE = N->getLocation().getAs<BlockEntrance>();
 
     if (!BE) {
-      // Assume the choice of the order of the preceeding block entrance was
+      // Assume the choice of the order of the preceding block entrance was
       // correct.
       StackUnexplored.push_back(U);
     } else {

lib/StaticAnalyzer/Core/ExprEngineCXX.cpp

       defaultEvalCall(Bldr, *I, *Call, CallOpts);
   }
 
-  // If the CFG was contructed without elements for temporary destructors
+  // If the CFG was constructed without elements for temporary destructors
   // and the just-called constructor created a temporary object then
   // stop exploration if the temporary object has a noreturn constructor.
   // This can lose coverage because the destructor, if it were present

lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp

 
 /// Adjusts a return value when the called function's return type does not
 /// match the caller's expression type. This can happen when a dynamic call
-/// is devirtualized, and the overridding method has a covariant (more specific)
+/// is devirtualized, and the overriding method has a covariant (more specific)
 /// return type than the parent's method. For C++ objects, this means we need
 /// to add base casts.
 static SVal adjustReturnValue(SVal V, QualType ExpectedTy, QualType ActualTy,

lib/StaticAnalyzer/Core/Store.cpp

     const MemRegion *Uncasted = MR->StripCasts(/*IncludeBaseCasts=*/false);
     if (Uncasted == MR) {
       // We reached the bottom of the hierarchy and did not find the derived
-      // class. We we must be casting the base to derived, so the cast should
+      // class. We must be casting the base to derived, so the cast should
       // fail.
       break;
     }

lib/StaticAnalyzer/Frontend/ModelInjector.cpp

 
   // The preprocessor enters to the main file id when parsing is started, so
   // the main file id is changed to the model file during parsing and it needs
-  // to be reseted to the former main file id after parsing of the model file
+  // to be reset to the former main file id after parsing of the model file
   // is done.
   SM.setMainFileID(mainFileID);
 }

lib/Tooling/ASTDiff/ASTDiff.cpp

   else if (AST.getLangOpts().CPlusPlus11)
     if (auto *Tag = dyn_cast<TagDecl>(Context))
       ContextPrefix = Tag->getQualifiedNameAsString();
-  // Strip the qualifier, if Val refers to somthing in the current scope.
+  // Strip the qualifier, if Val refers to something in the current scope.
   // But leave one leading ':' in place, so that we know that this is a
   // relative path.
   if (!ContextPrefix.empty() && StringRef(Val).startswith(ContextPrefix))

lib/Tooling/Core/Replacement.cpp

 llvm::Expected<Replacements>
 Replacements::mergeIfOrderIndependent(const Replacement &R) const {
   Replacements Rs(R);
-  // A Replacements set containg a single replacement that is `R` referring to
+  // A Replacements set containing a single replacement that is `R` referring to
   // the code after the existing replacements `Replaces` are applied.
   Replacements RsShiftedByReplaces(getReplacementInChangedCode(R));
   // A Replacements set that is `Replaces` referring to the code after `R` is

lib/Tooling/FileMatchTrie.cpp

   ///
   /// To find the best matching node for a given path 'p', the
   /// \c findEquivalent() function is called recursively for each path segment
-  /// (back to fron) of 'p' until a node 'n' is reached that does not ..
+  /// (back to front) of 'p' until a node 'n' is reached that does not ..
   /// - .. have children. In this case it is checked
   ///   whether the stored path is equivalent to 'p'. If yes, the best match is
   ///   found. Otherwise continue with the parent node as if this node did not

lib/Tooling/Refactoring/Rename/USRLocFinder.cpp

     llvm::Error Err = ReplaceChange.replace(
         SM, CharSourceRange::getTokenRange(Start, End), Text);
     if (Err) {
-      llvm::errs() << "Faile to add replacement to AtomicChange: "
+      llvm::errs() << "Failed to add replacement to AtomicChange: "
                    << llvm::toString(std::move(Err)) << "\n";
       return;
     }

test/ASTMerge/namespace/test.cpp

 
 void testImport() {
   typedef TestUnresolvedTypenameAndValueDecls::Derived<int> Imported;
-  Imported a; // Successfull instantiation
+  Imported a; // Successful instantiation
   static_assert(sizeof(Imported::foo) == sizeof(int));
   static_assert(sizeof(TestUnresolvedTypenameAndValueDecls::Derived<double>::NewUnresolvedUsingType) == sizeof(double));
 }

test/Analysis/analyzeOneFunction.m

 -(id)myMethod {
   Test1 *cell = [[[Test1 alloc] init] autorelease];
 
-  NSString *string1 = [[NSString alloc] initWithFormat:@"test %f", 0.0]; // No warning: this function is not analized.
+  NSString *string1 = [[NSString alloc] initWithFormat:@"test %f", 0.0]; // No warning: this function is not analyzed.
   cell.text = string1;
 
   return cell;

test/Analysis/copypaste/macro-complexity.cpp

 }
 
 // Now we actually use the macro to generate the same AST as above. They
-// shouldn't be reported because the macros only slighly increase the complexity
+// shouldn't be reported because the macros only slightly increase the complexity
 // value and the resulting code will never pass the MinimumCloneComplexity
 // constraint.
 

test/Analysis/dead-stores.c

     rdar8405222_aux(i);
 }
 
-// Look through chains of assignements, e.g.: int x = y = 0, when employing
+// Look through chains of assignments, e.g.: int x = y = 0, when employing
 // silencing heuristics.
 int radar11185138_foo() {
   int x, y;

test/Analysis/dynamic_type_check.m

 
 void testForwardDeclarations(NSString* str) {
   id obj = str;
-  // Do not warn, since no information is available wether MyType is a sub or
+  // Do not warn, since no information is available whether MyType is a sub or
   // super class of any other type.
   MyType *num = obj; // no warning
   (void)num;

test/Analysis/localization.m

 
 - (NSString *)test1:(int)plural {
     if (plural) {
-        return MCLocalizedString(@"TYPE_PLURAL"); // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return MCLocalizedString(@"TYPE_PLURAL"); // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     }
     return MCLocalizedString(@"TYPE");
 }
 
 - (NSString *)test2:(int)numOfReminders {
     if (numOfReminders > 0) {
-        return [NSString stringWithFormat:@"%@, %@", @"Test", (numOfReminders != 1) ? [NSString stringWithFormat:NSLocalizedString(@"%@ Reminders", @"Plural count of reminders"), numOfReminders] : [NSString stringWithFormat:NSLocalizedString(@"1 reminder", @"One reminder")]]; // expected-warning 2 {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note 2 {{Plural}}
+        return [NSString stringWithFormat:@"%@, %@", @"Test", (numOfReminders != 1) ? [NSString stringWithFormat:NSLocalizedString(@"%@ Reminders", @"Plural count of reminders"), numOfReminders] : [NSString stringWithFormat:NSLocalizedString(@"1 reminder", @"One reminder")]]; // expected-warning 2 {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note 2 {{Plural}}
     } 
     return nil;
 }

     NSString *count;
     if (self.unreadArticlesCount > 1)
     {
-        count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Stories", @"Plural count for new stories")]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        count = [count stringByAppendingFormat:@"%@", KHLocalizedString(@"New Stories", @"Plural count for new stories")]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     } else {
-        count = [count stringByAppendingFormat:@"%@",  KHLocalizedString(@"New Story", @"One new story")]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        count = [count stringByAppendingFormat:@"%@",  KHLocalizedString(@"New Story", @"One new story")]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     }
 }
 
 - (NSString *)test4:(int)count {
     if ( count == 1 )
     {
-        return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     } else {
-        return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     }
 }
 

   int test = count == 1;
     if (test)
     {
-        return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return [NSString stringWithFormat:KHLocalizedString(@"value.singular",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     } else {
-        return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return [NSString stringWithFormat:KHLocalizedString(@"value.plural",nil), count]; // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     }
 }
 

     if (someOtherVariable)
           return KHLocalizedString(@"OK",nil); // no-warning
     } else {
-        return KHLocalizedString(@"value.plural",nil); // expected-warning {{Plural cases are not supported accross all languages. Use a .stringsdict file}} expected-note {{Plural}}
+        return KHLocalizedString(@"value.plural",nil); // expected-warning {{Plural cases are not supported across all languages. Use a .stringsdict file}} expected-note {{Plural}}
     }
   return nil;
 }

test/Analysis/misc-ps-region-store.m

 }
 
 // Tests that we correctly handle that 'number' is perfectly constrained
-// after 'if (nunber == 0)', allowing us to resolve that
+// after 'if (number == 0)', allowing us to resolve that
 // numbers[number] == numbers[0].
 void pr8015_D_FIXME() {
   int number = pr8015_A();

test/Analysis/new.cpp

 // unix.Malloc does not know about operators new/delete.
 void testDeleteMallocked() {
   int *x = (int *)malloc(sizeof(int));
-  delete x; // FIXME: Shoud detect pointer escape and keep silent after 'delete' is modeled properly.
+  delete x; // FIXME: Should detect pointer escape and keep silent after 'delete' is modeled properly.
 } // expected-warning{{Potential leak of memory pointed to by 'x'}}
 
 void testDeleteOpAfterFree() {

test/Analysis/nullability.mm

 @end
 
 @implementation SubClassWithInitializers
-// Note: Because this is overridding
+// Note: Because this is overriding
 // -[ClassWithInitializers initWithNonnullReturnAndSelfCheckingIdiom],
 // the return type of this method becomes implicitly id _Nonnull.
 - (id)initWithNonnullReturnAndSelfCheckingIdiom {

test/Analysis/objc-properties.m

   id _nonSynth;
 }
 
-  @property (assign, nonatomic) MyClass* A; // explicitely synthesized, not implemented, non-default ivar name
+  @property (assign, nonatomic) MyClass* A; // explicitly synthesized, not implemented, non-default ivar name
 
   @property (assign) MyClass* X;  // automatically synthesized, not implemented
 

test/Analysis/objc/direct-ivar-assignment-in-annotated-functions.m

   MyClass* _NotA __attribute__((annotate("objc_allow_direct_instance_variable_assignment")));
 }
 
-  @property (assign, nonatomic) MyClass* A; // explicitely synthesized, not implemented, non-default ivar name
+  @property (assign, nonatomic) MyClass* A; // explicitly synthesized, not implemented, non-default ivar name
 
   @property (assign) MyClass* X;  // automatically synthesized, not implemented
 

test/Analysis/retain-release-path-notes.m

 }
 
 +(void)test {
-  // initX is inlined since we explicitely mark it as interesting
+  // initX is inlined since we explicitly mark it as interesting
   id x = [[MyObj alloc] initX]; // expected-warning {{Potential leak of an object}}
                                 // expected-note@-1 {{Method returns an instance of MyObj with a +1 retain count}}
                                 // expected-note@-2 {{Calling 'initX'}}

test/Analysis/string.c

 
 // The analyzer_eval call below should evaluate to true. We are being too 
 // aggressive in marking the (length of) src symbol dead. The length of dst 
-// depends on src. This could be explicitely specified in the checker or the 
+// depends on src. This could be explicitly specified in the checker or the 
 // logic for handling MetadataSymbol in SymbolManager needs to change.
 void strcat_symbolic_src_length(char *src) {
   char dst[8] = "1234";

test/CXX/special/class.init/class.inhctor.init/p1.cpp

   constexpr B b(1);
   constexpr B c(1);
   static_assert(b.a == 1, "p should be initialized before B() is executed");
-  static_assert(c.a == 7, "b not initialzed properly");
+  static_assert(c.a == 7, "b not initialized properly");
 }
 
 namespace default_args {

test/CodeGen/arm64_vdup.c

   // CHECK-LABEL: test_vdupq_n_f16
   return vdupq_n_f16(*a1);
   // match that an element is inserted into parts 0-7.  The backend better
-  // turn that into a single dup intruction
+  // turn that into a single dup instruction
   // CHECK: insertelement {{.*, i32 0 *$}}
   // CHECK: insertelement {{.*, i32 1 *$}}
   // CHECK: insertelement {{.*, i32 2 *$}}

test/CodeGen/builtins-arm-exclusive.c

   sum += __builtin_arm_ldrex((double *)addr);
 // CHECK: [[TMP4:%.*]] = bitcast i8* %addr to double*
 // CHECK: [[TMP5:%.*]] = bitcast double* [[TMP4]] to i8*
-// CHECK: [[STRUCTRES:%.*]] = call { i32, i32 } @llvm.arm.ldrexd(i8* [[TMP5]])
-// CHECK: [[RESHI:%.*]] = extractvalue { i32, i32 } [[STRUCTRES]], 1
-// CHECK: [[RESLO:%.*]] = extractvalue { i32, i32 } [[STRUCTRES]], 0
+// CHECK: [[STRUCTURES:%.*]] = call { i32, i32 } @llvm.arm.ldrexd(i8* [[TMP5]])
+// CHECK: [[RESHI:%.*]] = extractvalue { i32, i32 } [[STRUCTURES]], 1
+// CHECK: [[RESLO:%.*]] = extractvalue { i32, i32 } [[STRUCTURES]], 0
 // CHECK: [[RESHI64:%.*]] = zext i32 [[RESHI]] to i64
 // CHECK: [[RESLO64:%.*]] = zext i32 [[RESLO]] to i64
 // CHECK: [[RESHIHI:%.*]] = shl nuw i64 [[RESHI64]], 32

   sum += __builtin_arm_ldaex((double *)addr);
 // CHECK: [[TMP4:%.*]] = bitcast i8* %addr to double*
 // CHECK: [[TMP5:%.*]] = bitcast double* [[TMP4]] to i8*
-// CHECK: [[STRUCTRES:%.*]] = call { i32, i32 } @llvm.arm.ldaexd(i8* [[TMP5]])
-// CHECK: [[RESHI:%.*]] = extractvalue { i32, i32 } [[STRUCTRES]], 1
-// CHECK: [[RESLO:%.*]] = extractvalue { i32, i32 } [[STRUCTRES]], 0
+// CHECK: [[STRUCTURES:%.*]] = call { i32, i32 } @llvm.arm.ldaexd(i8* [[TMP5]])
+// CHECK: [[RESHI:%.*]] = extractvalue { i32, i32 } [[STRUCTURES]], 1
+// CHECK: [[RESLO:%.*]] = extractvalue { i32, i32 } [[STRUCTURES]], 0
 // CHECK: [[RESHI64:%.*]] = zext i32 [[RESHI]] to i64
 // CHECK: [[RESLO64:%.*]] = zext i32 [[RESLO]] to i64
 // CHECK: [[RESHIHI:%.*]] = shl nuw i64 [[RESHI64]], 32

 
   return __builtin_arm_ldrex(addr);
 // CHECK-ARM64: [[ADDR8:%.*]] = bitcast i128* %addr to i8*
-// CHECK-ARM64: [[STRUCTRES:%.*]] = call { i64, i64 } @llvm.aarch64.ldxp(i8* [[ADDR8]])
-// CHECK-ARM64: [[RESHI:%.*]] = extractvalue { i64, i64 } [[STRUCTRES]], 1
-// CHECK-ARM64: [[RESLO:%.*]] = extractvalue { i64, i64 } [[STRUCTRES]], 0
+// CHECK-ARM64: [[STRUCTURES:%.*]] = call { i64, i64 } @llvm.aarch64.ldxp(i8* [[ADDR8]])
+// CHECK-ARM64: [[RESHI:%.*]] = extractvalue { i64, i64 } [[STRUCTURES]], 1
+// CHECK-ARM64: [[RESLO:%.*]] = extractvalue { i64, i64 } [[STRUCTURES]], 0
 // CHECK-ARM64: [[RESHI64:%.*]] = zext i64 [[RESHI]] to i128
 // CHECK-ARM64: [[RESLO64:%.*]] = zext i64 [[RESLO]] to i128
 // CHECK-ARM64: [[RESHIHI:%.*]] = shl nuw i128 [[RESHI64]], 64

 
   return __builtin_arm_ldaex(addr);
 // CHECK-ARM64: [[ADDR8:%.*]] = bitcast i128* %addr to i8*
-// CHECK-ARM64: [[STRUCTRES:%.*]] = call { i64, i64 } @llvm.aarch64.ldaxp(i8* [[ADDR8]])
-// CHECK-ARM64: [[RESHI:%.*]] = extractvalue { i64, i64 } [[STRUCTRES]], 1
-// CHECK-ARM64: [[RESLO:%.*]] = extractvalue { i64, i64 } [[STRUCTRES]], 0
+// CHECK-ARM64: [[STRUCTURES:%.*]] = call { i64, i64 } @llvm.aarch64.ldaxp(i8* [[ADDR8]])
+// CHECK-ARM64: [[RESHI:%.*]] = extractvalue { i64, i64 } [[STRUCTURES]], 1
+// CHECK-ARM64: [[RESLO:%.*]] = extractvalue { i64, i64 } [[STRUCTURES]], 0
 // CHECK-ARM64: [[RESHI64:%.*]] = zext i64 [[RESHI]] to i128
 // CHECK-ARM64: [[RESLO64:%.*]] = zext i64 [[RESLO]] to i128
 // CHECK-ARM64: [[RESHIHI:%.*]] = shl nuw i128 [[RESHI64]], 64

test/CodeGen/debug-info-block-out-return.c

 // CHECK: !DILocalVariable(name: ".block_descriptor", arg: 1,{{.*}}line: 2,
 // CHECK: !DILocalVariable(name: "param", arg: 2,{{.*}}line: 2,
 
-// Line directive so we don't have to worry about how many lines preceed the
+// Line directive so we don't have to worry about how many lines precede the
 // test code (as the line number is mangled in with the argument number as shown
 // above)
 #line 1

test/CodeGen/pr3518.c

 // RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
 // PR 3518
-// Some of the objects were coming out as unintialized (external) before 3518
+// Some of the objects were coming out as uninitialized (external) before 3518
 // was fixed.  Internal names are different between llvm-gcc and clang so they
 // are not tested.
 

test/CodeGen/vectorcall.c

 // Vectorcall in both architectures allows passing of an HVA as long as there is room,
 // even if it is not one of the first 6 arguments.  First pass puts p4 into a
 // register on both.  p9 ends up in a register in x86 only.  Second pass puts p1
-// in a register, does NOT put p7 in a register (since theres no room), then puts 
+// in a register, does NOT put p7 in a register (since there's no room), then puts 
 // p8 in a register.
 void __vectorcall HVAAnywhere(struct HFA2 p1, int p2, int p3, float p4, int p5, int p6, struct HFA4 p7, struct HFA2 p8, float p9){}
 // X32: define dso_local x86_vectorcallcc void @"\01HVAAnywhere@@88"(%struct.HFA2 inreg %p1.coerce, i32 inreg %p2, i32 inreg %p3, float %p4, i32 %p5, i32 %p6, %struct.HFA4* %p7, %struct.HFA2 inreg %p8.coerce, float %p9)

test/CodeGenCUDA/device-stub.cu

 // CHECK-DAG: call{{.*}}cudaRegisterVar(i8** %0, {{.*}}ext_constant_var{{.*}}i32 1, i32 4, i32 1, i32 0
 // CHECK: ret void
 
-// Test that we've built contructor..
+// Test that we've built constructor..
 // CHECK: define internal void @__cuda_module_ctor
 //   .. that calls __cudaRegisterFatBinary(&__cuda_fatbin_wrapper)
 // CHECK: call{{.*}}cudaRegisterFatBinary{{.*}}__cuda_fatbin_wrapper

test/CodeGenCUDA/propagate-metadata.cu

 // RUN:   -fcuda-is-device -menable-unsafe-fp-math -triple nvptx-unknown-unknown \
 // RUN: | FileCheck %s --check-prefix=CHECK --check-prefix=FAST
 
-// Wrap everything in extern "C" so we don't ahve to worry about name mangling
+// Wrap everything in extern "C" so we don't have to worry about name mangling
 // in the IR.
 extern "C" {
 #ifdef LIB

test/CodeGenCXX/abstract-class-ctors-dtors.cpp

 // RUN: %clang_cc1 %s -triple x86_64-apple-darwin10 -emit-llvm -o - | FileCheck %s
 
-// Check that we dont emit the complete constructor/destructor for this class.
+// Check that we don't emit the complete constructor/destructor for this class.
 struct A {
   virtual void f() = 0;
   A();

test/CodeGenCXX/ctor-dtor-alias.cpp

 // RUN: %clang_cc1 %s -triple i686-pc-windows-gnu -emit-llvm -o - -mconstructor-aliases -O1 -disable-llvm-passes | FileCheck --check-prefix=COFF %s
 
 namespace test1 {
-// Test that we produce the apropriate comdats when creating aliases to
+// Test that we produce the appropriate comdats when creating aliases to
 // weak_odr constructors and destructors.
 
 // CHECK1: @_ZN5test16foobarIvEC1Ev = weak_odr alias void {{.*}} @_ZN5test16foobarIvEC2Ev

test/CodeGenCXX/debug-info-class-nolimit.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin -debug-info-kind=standalone -o - -emit-llvm %s | FileCheck %s
 
 // We had a bug in -fstandalone-debug where UnicodeString would not be completed
-// when it was required to be complete. This orginally manifested as an
+// when it was required to be complete. This originally manifested as an
 // assertion in CodeView emission on Windows with some dllexport stuff, but it's
 // more general than that.
 

test/CodeGenCXX/duplicate-mangled-name.cpp

 
 #else
 
-#error Unknwon test
+#error Unknown test
 
 #endif
 

test/CodeGenCXX/ms-integer-static-data-members.cpp

 // No initialization.
 // CHECK-DAG: @"\01?NoInit_Ref@S@@2HB" = external dso_local constant i32
 
-// Inline initialization, no real definiton, not referenced.
+// Inline initialization, no real definition, not referenced.
 // CHECK-NOT: @"\01?Inline_NotDef_NotRef@S@@2HB" = {{.*}} constant i32 5
 
-// Inline initialization, no real definiton, referenced.
+// Inline initialization, no real definition, referenced.
 // CHECK-DAG: @"\01?Inline_NotDef_Ref@S@@2HB" = linkonce_odr dso_local constant i32 5, comdat, align 4
 
-// Inline initialization, real definiton, not referenced.
+// Inline initialization, real definition, not referenced.
 // CHECK-NOT: @"\01?Inline_Def_NotRef@S@@2HB" = dso_local constant i32 5, align 4
 
-// Inline initialization, real definiton, referenced.
+// Inline initialization, real definition, referenced.
 // CHECK-DAG: @"\01?Inline_Def_Ref@S@@2HB" = linkonce_odr dso_local constant i32 5, comdat, align 4
 
 // Out-of-line initialization.

test/CodeGenOpenCL/amdgpu-nullptr.cl

 // CHECK: @p5 = common local_unnamed_addr addrspace(1) global i8* null, align 8
 generic char *p5;
 
-// Test default initialization of sturcture.
+// Test default initialization of structure.
 
 // CHECK: @S1 = weak local_unnamed_addr addrspace(1) global %struct.StructTy1 { i8 addrspace(5)* null, i8 addrspace(3)* addrspacecast (i8* null to i8 addrspace(3)*), i8 addrspace(4)* null, i8 addrspace(1)* null, i8* null }, align 8
 StructTy1 S1;

                                         (size_t)((generic char*)NULL));
 }
 
-// Test comparision between null pointers.
+// Test comparison between null pointers.
 #define TEST_EQ00(addr1, addr2) int test_eq00_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)0; }
 #define TEST_EQ0N(addr1, addr2) int test_eq0N_##addr1##_##addr2(void) { return (addr1 char*)0 == (addr2 char*)NULL; }
 #define TEST_EQN0(addr1, addr2) int test_eqN0_##addr1##_##addr2(void) { return (addr1 char*)NULL == (addr2 char*)0; }

test/Driver/config-file2.c

 //--- Invocation `clang --config x86_64-qqq2 -m32` loads `x86_64-qqq2.cfg` if `i386-qqq2.cfg` and `i386.cfg` do not exist.
 //
 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq2 -m32 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD2
-// note: target is overriden due to -m32
+// note: target is overridden due to -m32
 // CHECK-RELOAD2: Target: i386
 // CHECK-RELOAD2: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64-qqq2.cfg
 

 //--- Invocation `clang --config x86_64-qqq2 -target i386` loads `x86_64-qqq2.cfg` if `i386-qqq2.cfg` and `i386.cfg` do not exist.
 //
 // RUN: %clang --config-system-dir=%S/Inputs/config --config-user-dir= --config x86_64-qqq2 -target i386 -c %s -### 2>&1 | FileCheck %s -check-prefix CHECK-RELOAD5
-// note: target is overriden due to -target i386
+// note: target is overridden due to -target i386
 // CHECK-RELOAD5: Target: i386
 // CHECK-RELOAD5: Configuration file: {{.*}}Inputs{{.}}config{{.}}x86_64-qqq2.cfg
 

test/Driver/cuda-options.cu

 // RUN:    -check-prefix HOST -check-prefix INCLUDES-DEVICE \
 // RUN:    -check-prefix LINK %s
 
-// Verify that --cuda-gpu-arch option passes the correct GPU archtecture to
+// Verify that --cuda-gpu-arch option passes the correct GPU architecture to
 // device compilation.
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-gpu-arch=sm_30 -c %s 2>&1 \
 // RUN: | FileCheck -check-prefix DEVICE -check-prefix DEVICE-NOSAVE \

 // RUN:    -check-prefix HOST-AS -check-prefix NOLINK %s
 
 // Verify that --[no-]cuda-gpu-arch arguments are handled correctly.
-// a) --no-cuda-gpu-arch=X negates preceeding --cuda-gpu-arch=X
+// a) --no-cuda-gpu-arch=X negates preceding --cuda-gpu-arch=X
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \
 // RUN:   --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \
 // RUN:   --no-cuda-gpu-arch=sm_35 \
 // RUN:   -c %s 2>&1 \
 // RUN: | FileCheck -check-prefixes NOARCH-SM20,ARCH-SM30,NOARCH-SM35 %s
 
-// b) --no-cuda-gpu-arch=X negates more than one preceeding --cuda-gpu-arch=X
+// b) --no-cuda-gpu-arch=X negates more than one preceding --cuda-gpu-arch=X
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \
 // RUN:   --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \
 // RUN:   --no-cuda-gpu-arch=sm_35 \
 // RUN:   -c %s 2>&1 \
 // RUN: | FileCheck -check-prefixes NOARCH-SM20,ARCH-SM30,NOARCH-SM35 %s
 
-// c) if --no-cuda-gpu-arch=X negates all preceeding --cuda-gpu-arch=X
+// c) if --no-cuda-gpu-arch=X negates all preceding --cuda-gpu-arch=X
 //    we default to sm_20 -- same as if no --cuda-gpu-arch were passed.
 // RUN: %clang -### -target x86_64-linux-gnu --cuda-device-only \
 // RUN:   --cuda-gpu-arch=sm_35 --cuda-gpu-arch=sm_30 \

test/Driver/darwin-version.c

 // CHECK-VERSION-TNO-SAME-NOT: overriding
 // CHECK-VERSION-TNO-SAME-NOT: argument unused during compilation
 
-// Target with OS version is not overriden by -m<os>-version-min variables:
+// Target with OS version is not overridden by -m<os>-version-min variables:
 
 // RUN: %clang -target x86_64-apple-macos10.11.2 -mmacos-version-min=10.6 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV1 %s

 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TIGNORE-OSV4 %s
 // CHECK-VERSION-TIGNORE-OSV4: "thumbv7k-apple-watchos3.0.0"
 
-// Target without OS version inlcudes the OS given by -m<os>-version-min arguments:
+// Target without OS version includes the OS given by -m<os>-version-min arguments:
 
 // RUN: %clang -target x86_64-apple-macos -mmacos-version-min=10.11 -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG1 %s

 // RUN:   FileCheck --check-prefix=CHECK-VERSION-USE-OS-ARG4 %s
 // CHECK-VERSION-USE-OS-ARG4: "thumbv7k-apple-watchos4.0.0"
 
-// Target with OS version is not overriden by environment variables:
+// Target with OS version is not overridden by environment variables:
 
 // RUN: env MACOSX_DEPLOYMENT_TARGET=10.1 \
 // RUN:   %clang -target i386-apple-macos10.5 -c %s -### 2>&1 | \

 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TWATCHOS-CMD %s
 // CHECK-VERSION-TWATCHOS-CMD: "thumbv7k-apple-watchos3.0.0"
 
-// Target with OS version is not overriden by the SDK:
+// Target with OS version is not overridden by the SDK:
 
 // RUN: %clang -target armv7-apple-ios9 -Wno-missing-sysroot -isysroot SDKs/iPhoneOS11.0.sdk -c -### %s 2>&1 | \
 // RUN: FileCheck --check-prefix=CHECK-VERSION-TIOS-SDK %s

 // RUN: FileCheck --check-prefix=CHECK-VERSION-TTVOS-SDK %s
 // CHECK-VERSION-TTVOS-SDK: thumbv7-apple-tvos9
 
-// Target with OS version is not overriden by arch:
+// Target with OS version is not overridden by arch:
 
 // RUN: %clang -target uknown-apple-macos10.11.2 -arch=armv7k -c %s -### 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-VERSION-TIGNORE-ARCH1 %s

test/Driver/fsanitize-blacklist.c

 // CHECK-NO-SANITIZE-NOT: -fsanitize-blacklist
 
 // Ignore -fsanitize-blacklist flag if there is no -fsanitize flag.
-// Now, check for the absense of -fdepfile-entry flags.
+// Now, check for the absence of -fdepfile-entry flags.
 // RUN: %clang -target x86_64-linux-gnu -fsanitize-blacklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SANITIZE2 --check-prefix=DELIMITERS
 // CHECK-NO-SANITIZE2-NOT: -fdepfile-entry
 

test/Driver/hexagon-hvx.c

 // RUN:  2>&1 | FileCheck -check-prefix=CHECK-NOHVX %s
 // CHECK-NOHVX-NOT: "-target-feature" "+hvx
 
-// Hvx target feature should be added if -mno-hvx doesnot occur last
+// Hvx target feature should be added if -mno-hvx doesn't occur last
 // RUN: %clang -c %s -### -target hexagon-unknown-elf -mv62 -mno-hvx -mhvx\
 // RUN:  2>&1 | FileCheck -check-prefix=CHECK-HVXFEAT %s
 // CHECK-HVXFEAT: "-target-feature" "+hvxv62"

test/Driver/rtti-options.cpp

 // Check that we emit warnings/errors for different combinations of
-// exceptions, rtti, and vptr sanitizer flags when targetting the PS4.
+// exceptions, rtti, and vptr sanitizer flags when targeting the PS4.
 // No warnings/errors should be emitted for unknown, except if combining
 // the vptr sanitizer with -fno-rtti
 

test/Headers/ms-null-ms-header-vs-stddef.cpp

 // RUN: %clang_cc1 -fsyntax-only -triple i386-mingw32 %s
 
 // Something in MSVC's headers (pulled in e.g. by <crtdefs.h>) defines __null
-// to something, mimick that.
+// to something, mimic that.
 #define __null
 
 #include <stddef.h>

test/Index/headerfile-comment-to-html.m

     \brief Test that headerfile can come after brief.
     \headerfile VTDevice.h <VTFoundation/VTDevice.h>
 
-    More property decription goes here.
+    More property description goes here.
 */
 @interface VTDevice : Device
 @end
-// CHECK: headerfile-comment-to-html.m:[[@LINE-2]]:12: ObjCInterfaceDecl=VTDevice:{{.*}} FullCommentAsXML=[<Other file="{{[^"]+}}headerfile-comment-to-html.m" line="[[@LINE-2]]" column="12"><Name>VTDevice</Name><USR>c:objc(cs)VTDevice</USR><Headerfile><Para> VTDevice.h &lt;VTFoundation/VTDevice.h&gt;</Para></Headerfile><Declaration>@interface VTDevice : Device\n@end</Declaration><Abstract><Para> Test that headerfile can come after brief.    </Para></Abstract><Discussion><Para>    More property decription goes here.</Para></Discussion></Other>]
+// CHECK: headerfile-comment-to-html.m:[[@LINE-2]]:12: ObjCInterfaceDecl=VTDevice:{{.*}} FullCommentAsXML=[<Other file="{{[^"]+}}headerfile-comment-to-html.m" line="[[@LINE-2]]" column="12"><Name>VTDevice</Name><USR>c:objc(cs)VTDevice</USR><Headerfile><Para> VTDevice.h &lt;VTFoundation/VTDevice.h&gt;</Para></Headerfile><Declaration>@interface VTDevice : Device\n@end</Declaration><Abstract><Para> Test that headerfile can come after brief.    </Para></Abstract><Discussion><Para>    More property description goes here.</Para></Discussion></Other>]
 // CHECK-NEXT:  CommentAST=[
 // CHECK-NEXT:    (CXComment_FullComment
 // CHECK-NEXT:       (CXComment_Paragraph IsWhitespace

 // CHECK-NEXT:           (CXComment_Text Text=[<VTFoundation])
 // CHECK-NEXT:           (CXComment_Text Text=[/VTDevice.h>])))
 // CHECK-NEXT:       (CXComment_Paragraph
-// CHECK-NEXT:         (CXComment_Text Text=[    More property decription goes here.])))]
+// CHECK-NEXT:         (CXComment_Text Text=[    More property description goes here.])))]
 
 /*!
   \headerfile  <stdio.h>

test/Misc/ast-print-pragmas-xfail.cpp

 
 void run1(int *List, int Length) {
   int i = 0;
-// CEHCK: #pragma loop vectorize(4)
+// CHECK: #pragma loop vectorize(4)
 // CHECK-NEXT: #pragma loop interleave(8)
 // CHECK-NEXT: #pragma loop vectorize(enable)
 // CHECK-NEXT: #pragma loop interleave(enable)

test/Misc/warning-flags.c

 CHECK-NEXT:   warn_pp_convert_to_positive
 CHECK-NEXT:   warn_pp_expr_overflow
 CHECK-NEXT:   warn_pp_line_decimal
-CHECK-NEXT:   warn_pragma_pack_pop_identifer_and_alignment
+CHECK-NEXT:   warn_pragma_pack_pop_identifier_and_alignment
 CHECK-NEXT:   warn_pragma_pack_show
 CHECK-NEXT:   warn_property_getter_owning_mismatch
 CHECK-NEXT:   warn_register_objc_catch_parm

test/Modules/odr_hash.cpp

 };
 #else
 S10 s10;
-// expected-error@second.h:* {{'Field::S10' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with no initalizer}}
+// expected-error@second.h:* {{'Field::S10' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with no initializer}}
 // expected-note@first.h:* {{but in 'FirstModule' found field 'x' with an initializer}}
 #endif
 

 #if defined(FIRST)
 struct S { };
 void S_Constructors() {
-  // Trigger creation of implicit contructors
+  // Trigger creation of implicit constructors
   S foo;
   S bar = foo;
   S baz(bar);

   private:
 };
 void T_Constructors() {
-  // Trigger creation of implicit contructors
+  // Trigger creation of implicit constructors
   T foo;
   T bar = foo;
   T baz(bar);

test/OpenMP/target_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s

test/OpenMP/target_parallel_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s

test/OpenMP/target_parallel_for_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s

test/OpenMP/target_parallel_for_simd_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s

test/OpenMP/target_simd_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s

test/OpenMP/target_teams_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s

test/OpenMP/target_teams_distribute_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s

test/OpenMP/target_teams_distribute_parallel_for_simd_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s

test/OpenMP/target_teams_distribute_simd_codegen_registration.cpp

 // RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=45 -x c++ -triple i386-unknown-unknown -fopenmp-targets=i386-pc-linux-gnu -std=c++11 -fopenmp-is-device -fopenmp-host-ir-file-path %t-x86-host.bc -include-pch %t -verify %s -emit-llvm -o - | FileCheck --check-prefix SIMD-ONLY1 %s
 // SIMD-ONLY1-NOT: {{__kmpc|__tgt}}
 
-// Check that no target code is emmitted if no omptests flag was provided.
+// Check that no target code is emitted if no omptests flag was provided.
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck %s -check-prefix=CHECK-NTARGET
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 -x c++ -triple powerpc64le-unknown-unknown -emit-llvm %s -o - | FileCheck --check-prefix SIMD-ONLY2 %s

test/Parser/brackets.c

   // CHECK: fix-it:{{.*}}:{[[@LINE-6]]:10-[[@LINE-6]]:10}:"[]"
 
   int c = a[0];
-  int d = b[0]; // No undeclared identifer error here.
+  int d = b[0]; // No undeclared identifier error here.
 
   int *e = a;
-  int *f = b; // No undeclared identifer error here.
+  int *f = b; // No undeclared identifier error here.
 }
 
 struct S {

test/Parser/brackets.cpp

   // CHECK: fix-it:{{.*}}:{[[@LINE-6]]:10-[[@LINE-6]]:10}:"[]"
 
   int c = a[0];
-  int d = b[0];  // No undeclared identifer error here.
+  int d = b[0];  // No undeclared identifier error here.
 
   int *e = a;
-  int *f = b;  // No undeclared identifer error here.
+  int *f = b;  // No undeclared identifier error here.
 
   int[1] g[2];
   // expected-error@-1{{brackets are not allowed here; to declare an array, place the brackets after the name}}

test/Preprocessor/macro_paste_commaext.c

 // RUN: %clang_cc1 %s -E | FileCheck --strict-whitespace --match-full-lines %s
 
 // In the following tests, note that the output is sensitive to the
-// whitespace *preceeding* the varargs argument, as well as to
+// whitespace *preceding* the varargs argument, as well as to
 // interior whitespace. AFAIK, this is the only case where whitespace
-// preceeding an argument matters, and might be considered a bug in
+// preceding an argument matters, and might be considered a bug in
 // GCC. Nevertheless, since this feature is a GCC extension in the
 // first place, we'll follow along.
 

test/Sema/attr-availability-tvos.c

   f3_tvos(0);
   f4_tvos(0); // expected-error{{'f4_tvos' is unavailable: obsoleted in tvOS 3.0}}
   // We get no warning here because any explicit 'tvos' availability causes
-  // the ios availablity to not implicitly become 'tvos' availability.  Otherwise we'd get
+  // the ios availability to not implicitly become 'tvos' availability.  Otherwise we'd get
   // a deprecated warning.
   f5_tvos(0); // no-warning
   f5_attr_reversed_tvos(0); // no-warning

test/Sema/attr-availability-watchos.c

   f3_watchos(0);
   f4_watchos(0); // expected-error{{'f4_watchos' is unavailable: obsoleted in watchOS 3.0}}
   // We get no warning here because any explicit 'watchos' availability causes
-  // the ios availablity to not implicitly become 'watchos' availability.  Otherwise we'd get
+  // the ios availability to not implicitly become 'watchos' availability.  Otherwise we'd get
   // a deprecated warning.
   f5_watchos(0); // no-warning
   f5_attr_reversed_watchos(0); // no-warning

test/Sema/pr30372.c

 // REQUIRES: x86-registered-target
 // RUN: %clang_cc1 %s -triple i386-pc-windows-msvc18.0.0 -disable-free -fms-volatile -fms-extensions -fms-compatibility -fms-compatibility-version=18 -std=c++11 -x c++
 
-// Check that the parser catching an 'error' from forward declaration of "location" does not lexer out it's subsequent declation.
+// Check that the parser catching an 'error' from forward declaration of "location" does not lexer out it's subsequent declaration.
 
 void foo() {
   __asm {

test/Sema/self-comparison.c

   return array1 >= array1; // expected-warning{{self-comparison always evaluates to true}}
 
   //
-  // compare differrent arrays
+  // compare different arrays
   //
   return array1 == array2; // expected-warning{{array comparison always evaluates to false}}
   return array1 != array2; // expected-warning{{array comparison always evaluates to true}}

test/Sema/tls.c

 // RUN: %clang_cc1 -triple x86_64-pc-win32 -fsyntax-only %s
 // RUN: %clang_cc1 -triple i386-pc-win32 -fsyntax-only %s
 
-// OpenBSD suppports TLS.
+// OpenBSD supports TLS.
 // RUN: %clang_cc1 -triple x86_64-pc-openbsd -fsyntax-only %s
 // RUN: %clang_cc1 -triple i386-pc-openbsd -fsyntax-only %s
 
-// Haiku does not suppport TLS.
+// Haiku does not support TLS.
 // RUN: not %clang_cc1 -triple i586-pc-haiku -fsyntax-only %s
 
 __thread int x;

test/Sema/uninit-variables.c

 
 int test15b() {
   // Warn here with the self-init, since it does result in a use of
-  // an unintialized variable and this is the root cause.
+  // an uninitialized variable and this is the root cause.
   int x = x; // expected-warning {{variable 'x' is uninitialized when used within its own initialization}}
   return x;
 }

test/Sema/vector-gcc-compat.c

   v2i64_a >>= 1;
 }
 
-// For operations with floating point types, we check that interger constants
+// For operations with floating point types, we check that integer constants
 // can be respresented, or failing that checking based on the integer types.
 void floatTestConstant(void) {
   // Test that constants added to floats must be expressible as floating point

test/Sema/vector-gcc-compat.cpp

   v2i64_a >>= 1;
 }
 
-// For operations with floating point types, we check that interger constants
+// For operations with floating point types, we check that integer constants
 // can be respresented, or failing that checking based on the integer types.
 void floatTestConstant(void) {
   // Test that constants added to floats must be expressible as floating point

test/Sema/warn-documentation-fixits.cpp

 // rdar://12381408
 // expected-warning@+2  {{unknown command tag name 'retur'; did you mean 'return'?}}
 /// \brief testing fixit
-/// \retur int in FooBar
+/// \return int in FooBar
 int FooBar();
 
 // expected-warning@+1  {{unknown command tag name 'fooba'; did you mean 'foobar'?}}

test/Sema/warn-documentation-unknown-command.cpp

 int test_unknown_comand_1;
 
 // expected-warning@+1 {{unknown command tag name 'retur'; did you mean 'return'?}}
-/// \retur aaa
+/// \return aaa
 int test_unknown_comand_2();
 
 // RUN: c-index-test -test-load-source all -Wdocumentation-unknown-command %s > /dev/null 2> %t.err

test/Sema/warn-documentation.m

 
 // rdar://14124644
 @interface test_vararg1
-/// @param[in] arg somthing
+/// @param[in] arg something
 /// @param[in] ... This is vararg
 - (void) VarArgMeth : (id)arg, ...;
 @end
 
 @implementation test_vararg1
-/// @param[in] arg somthing
+/// @param[in] arg something
 /// @param[in] ... This is vararg
 - (void) VarArgMeth : (id)arg, ... {}
 @end

test/Sema/warn-string-conversion.c

 #define assert2(expr) \
   ((expr) ? do_nothing() : assert_error())
 
-// Expection for common assert form.
+// Exception for common assert form.
 void test1() {
   assert1(0 && "foo");
   assert1("foo" && 0);

test/SemaCUDA/function-template-overload.cu

 __device__ HDType overload_hd(int a); // OK.
 
 // Verify that target attributes are taken into account when we
-// explicitly specialize or instantiate function tempaltes.
+// explicitly specialize or instantiate function templates.
 template <> __host__ HType overload_hd(int a);
 // expected-error@-1 {{no function template matches function template specialization 'overload_hd'}}
 template __host__ HType overload_hd(long a);

test/SemaCXX/conditional-expr.cpp

   i1 = i1 ? i1 : I();
   I i2(i1 ? I() : J());
   I i3(i1 ? J() : I());
-  // "the type [it] woud have if E2 were converted to an rvalue"
+  // "the type [it] would have if E2 were converted to an rvalue"
   vfn pfn = i1 ? F() : test;
   pfn = i1 ? test : F();
   (void)(i1 ? A() : B()); // expected-error {{conversion from 'B' to 'A' is ambiguous}}

test/SemaCXX/err_typecheck_assign_const_filecheck.cpp

   // CHECK-NOT: note:
 }
 
-// Only display notes for relavent cases.
+// Only display notes for relevant cases.
 void test5(const A Ca) {
   Ca.Mb.c.d.Ce.num = 5;
   // CHECK-NOT: error:

test/SemaCXX/type-traits.cpp

   int d;
 };
 
-static_assert(!has_unique_object_representations<VirtuallyInheritsFromNoPadding>::value, "No virtual inheritence");
+static_assert(!has_unique_object_representations<VirtuallyInheritsFromNoPadding>::value, "No virtual inheritance");
 
 struct Padding {
   char a;

test/SemaCXX/uninitialized.cpp

 int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
 int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
 
-// Thes don't warn as they don't require the value.
+// These don't warn as they don't require the value.
 int g = sizeof(g);
 void* ptr = &ptr;
 int h = bar(&h);

   int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
   int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
 
-  // Thes don't warn as they don't require the value.
+  // These don't warn as they don't require the value.
   int g = sizeof(g);
   void* ptr = &ptr;
   int h = bar(&h);

     int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
     int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
 
-    // Thes don't warn as they don't require the value.
+    // These don't warn as they don't require the value.
     int g = sizeof(g);
     void* ptr = &ptr;
     int h = bar(&h);

   static int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
   static int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
 
-  // Thes don't warn as they don't require the value.
+  // These don't warn as they don't require the value.
   static int g = sizeof(g);
   int gg = g;  // Silence unneeded warning
   static void* ptr = &ptr;

     static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}}
     static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}}
 
-    // Thes don't warn as they don't require the value.
+    // These don't warn as they don't require the value.
     static int g = sizeof(g);
     static void* ptr = &ptr;
     static int h = bar(&h);

       static int e = static_cast<long>(e) + 1; // expected-warning {{static variable 'e' is suspiciously used within its own initialization}}
       static int f = foo(f); // expected-warning {{static variable 'f' is suspiciously used within its own initialization}}
 
-      // Thes don't warn as they don't require the value.
+      // These don't warn as they don't require the value.
       static int g = sizeof(g);
       static void* ptr = &ptr;
       static int h = bar(&h);

test/SemaCXX/vector.cpp

   (void)(Cond? to_c16 : to_c16e);
   (void)(Cond? to_ll16e : to_ll16);
 
-  // These 2 are convertable with -flax-vector-conversions (default)
+  // These 2 are convertible with -flax-vector-conversions (default)
   (void)(Cond? to_c16 : to_ll16);
   (void)(Cond? to_c16e : to_ll16e);
 }

test/SemaCXX/warn-thread-safety-analysis.cpp

 namespace thread_annot_lock_61_modified {
   // Modified to fix the compiler errors
   // Test the fix for a bug introduced by the support of pass-by-reference
-  // paramters.
+  // parameters.
   struct Foo { Foo &operator<< (bool) {return *this;} };
   Foo &getFoo();
   struct Bar { Foo &func () {return getFoo();} };

     bool b = mu.TryLock();
 
     while (cond) {
-      if (b) {   // b should be uknown at this point b/c of the loop
+      if (b) {   // b should be unknown at this point b/c of the loop
         a = 10;  // expected-warning {{writing variable 'a' requires holding mutex 'mu' exclusively}}
       }
       b = !b;

test/SemaCXX/warn-unreachable.cpp

   test_unreachable_templates<TestUnreachableB>(); 
 }
 
-// Do warn about explict template specializations, as they represent
+// Do warn about explicit template specializations, as they represent
 // actual concrete functions that somebody wrote.
 
 template <typename T> void funcToSpecialize() {}

test/SemaObjC/arc-peformselector.m

   return [self performSelector : @selector(PlusZero)];
   return [self performSelector : @selector(PlusOne)]; // expected-error {{performSelector names a selector which retains the object}}
 
-  // Avoid the unkown selector warning for more complicated performSelector
+  // Avoid the unknown selector warning for more complicated performSelector
   // variations because it produces too many false positives.
   [self performSelector: sel1 withObject:0 afterDelay:0 inModes:0];
 

test/SemaObjC/compare-qualified-class.m

 @implementation OtherClass
 - (ClassA<ProtocolY> *)aMethod {
     // This does not work, even though ClassB subclasses from A and conforms to Y
-    // because the property type explicity adds ProtocolX conformance
+    // because the property type explicitly adds ProtocolX conformance
     // even though ClassB already conforms to ProtocolX
     return self.aProperty;
 }

test/SemaObjC/property-ivar-mismatch.m

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
-// Test that arithmatic types on property and its ivar have exact match.
+// Test that arithmetic types on property and its ivar have exact match.
 
 @interface Test4 
 {

tools/c-index-test/c-index-test.c

     printf(" CommentXMLValid");
   else if (status > 0) {
     xmlErrorPtr Error = xmlGetLastError();
-    printf(" CommentXMLInvalid [not vaild XML: %s]", Error->message);
+    printf(" CommentXMLInvalid [not valid XML: %s]", Error->message);
   } else
     printf(" libXMLError");
 

tools/clang-format/clang-format.el

                              nil nil clang-format-executable
                              nil `(,temp-buffer ,temp-file) nil
                              `("-output-replacements-xml"
-                               ;; Gaurd against a nil assume-file-name.
+                               ;; Guard against a nil assume-file-name.
                                ;; If the clang-format option -assume-filename
                                ;; is given a blank string it will crash as per
                                ;; the following bug report

tools/libclang/CIndex.cpp

     return;
 
   // Ignore base anonymous struct/union fields, otherwise they will shadow the
-  // real field that that we are interested in.
+  // real field that we are interested in.
   if (auto *SubME = dyn_cast<MemberExpr>(M->getBase())) {
     if (auto *FD = dyn_cast_or_null<FieldDecl>(SubME->getMemberDecl())) {
       if (FD->isAnonymousStructOrUnion()) {

 }
 
  /// \brief If the given cursor is the "templated" declaration
- /// descibing a class or function template, return the class or
+ /// describing a class or function template, return the class or
  /// function template.
 static const Decl *maybeGetTemplateCursor(const Decl *D) {
   if (!D)

tools/libclang/CXCursor.h

 void getOverriddenCursors(CXCursor cursor,
                           SmallVectorImpl<CXCursor> &overridden);
   
-/// \brief Create an opaque  pool used for fast generation of overriden
+/// \brief Create an opaque pool used for fast generation of overridden
 /// CXCursor arrays.
 void *createOverridenCXCursorsPool();
 
-/// \brief Dispose of the overriden CXCursors pool.
+/// \brief Dispose of the overridden CXCursors pool.
 void disposeOverridenCXCursorsPool(void *pool);
   
 /// \brief Returns a index/location pair for a selector identifier if the cursor

tools/libclang/CXCursor.cpp

   assert(cxcursor::getCursorTU(backRefCursor) == TU);
   Vec->push_back(backRefCursor);
 
-  // Get the overriden cursors.
+  // Get the overridden cursors.
   cxcursor::getOverriddenCursors(cursor, *Vec);
   
-  // Did we get any overriden cursors?  If not, return Vec to the pool
+  // Did we get any overridden cursors?  If not, return Vec to the pool
   // of available cursor vectors.
   if (Vec->size() == 1) {
     pool.AvailableCursors.push_back(Vec);
     return;
   }
 
-  // Now tell the caller about the overriden cursors.
+  // Now tell the caller about the overridden cursors.
   assert(Vec->size() > 1);
   *overridden = &((*Vec)[1]);
   *num_overridden = Vec->size() - 1;

tools/scan-build-py/README.md

     This is the default behaviour, can be enforced with `--override-compiler`
     flag.
 
-2.  Use special library to intercept compiler calls durring the build process.
+2.  Use special library to intercept compiler calls during the build process.
     The analyzer run against each modules after the build finished.
     Use `--intercept-first` flag to get this model.
 
-3.  Use compiler wrappers to intercept compiler calls durring the build process.
+3.  Use compiler wrappers to intercept compiler calls during the build process.
     The analyzer run against each modules after the build finished.
     Use `--intercept-first` and `--override-compiler` flags together to get
     this model.

 output still kept.
 
 The 2. and 3. generate the compilation database first, and filters out those
-modules which are not exists. So, it's suitable for incremental analysis durring
+modules which are not exists. So, it's suitable for incremental analysis during
 the development.
 
 The 2. mode is available only on FreeBSD and Linux. Where library preload

tools/scan-build-py/libscanbuild/analyze.py

     When static analyzer run against project configure step, it should be
     silent and no need to run the analyzer or generate report.
 
-    To run `scan-build` against the configure step might be neccessary,
+    To run `scan-build` against the configure step might be necessary,
     when compiler wrappers are used. That's the moment when build setup
     check the compiler and capture the location for the build process. """
 

     of the compilation database.
 
     This complex task is decomposed into smaller methods which are calling
-    each other in chain. If the analyzis is not possibe the given method
+    each other in chain. If the analyzis is not possible the given method
     just return and break the chain.
 
     The passed parameter is a python dictionary. Each method first check

tools/scan-build-py/libscanbuild/arguments.py

         '-maxloop',
         metavar='<loop count>',
         type=int,
-        help="""Specifiy the number of times a block can be visited before
+        help="""Specify the number of times a block can be visited before
         giving up. Increase for more comprehensive coverage at a cost of
         speed.""")
     advanced.add_argument(

tools/scan-build/bin/scan-build

   }
   close(DETECT_XCODE);
 
-  # If --override-compiler is explicitely requested, resort to the old
+  # If --override-compiler is explicitly requested, resort to the old
   # behavior regardless of Xcode version.
   if ($Options{OverrideCompiler}) {
     $oldBehavior = 1;

 
  -maxloop <loop count>
 
-   Specifiy the number of times a block can be visited before giving up.
+   Specify the number of times a block can be visited before giving up.
    Default is 4. Increase for more comprehensive coverage at a cost of speed.
 
  -internal-stats

tools/scan-build/man/scan-build.1

 uses a simpler, less powerful constraint model used by checker-0.160
 and earlier.
 .It Fl maxloop Ar N
-Specifiy the number of times a block can be visited before giving
+Specify the number of times a block can be visited before giving
 up. Default is 4. Increase for more comprehensive coverage at a
 cost of speed.
 .It Fl no-failure-reports

tools/scan-view/share/startfile.py

                                 preexec_fn=setsid, startupinfo=startupinfo)
 
         # It is assumed that this kind of tools (gnome-open, kfmclient,
-        # exo-open, xdg-open and open for OSX) immediately exit after lauching
+        # exo-open, xdg-open and open for OSX) immediately exit after launching
         # the specific application
         returncode = pipe.wait()
         if hasattr(self, 'fixreturncode'):

 if sys.platform[:3] == 'win':
 
     class Start(BaseController):
-        '''Controller for the win32 start progam through os.startfile.'''
+        '''Controller for the win32 start program through os.startfile.'''
 
         def open(self, filename):
             try:

 
 
 def open(filename):
-    '''Open a file or an URL in the registered default application.'''
+    '''Open a file or a URL in the registered default application.'''
 
     return _open(filename)

utils/TableGen/NeonEmitter.cpp

   ListInit *Body;
   /// The architectural #ifdef guard.
   std::string Guard;
-  /// Set if the Unvailable bit is 1. This means we don't generate a body,
+  /// Set if the Unavailable bit is 1. This means we don't generate a body,
   /// just an "unavailable" attribute on a declaration.
   bool IsUnavailable;
   /// Is this intrinsic safe for big-endian? or does it need its arguments

utils/bash-autocomplete.sh

 {
   local cur prev words cword arg flags w1 w2
   # If latest bash-completion is not supported just initialize COMPREPLY and
-  # initialize variables by setting manualy.
+  # initialize variables by setting manually.
   _init_completion -n 2> /dev/null
   if [[ "$?" != 0 ]]; then
     COMPREPLY=()

utils/check_cfc/check_cfc.py

 
 def get_temp_file_name(suffix):
     """Get a temporary file name with a particular suffix. Let the caller be
-    reponsible for deleting it."""
+    responsible for deleting it."""
     tf = tempfile.NamedTemporaryFile(suffix=suffix, delete=False)
     tf.close()
     return tf.name

utils/clangdiag.py

     target = frame.GetThread().GetProcess().GetTarget()
     diagtool = getDiagtool(target)
     name = subprocess.check_output([diagtool, "find-diagnostic-id", id]).rstrip();
-    # Make sure we only consider errors, warnings, and extentions.
+    # Make sure we only consider errors, warnings, and extensions.
     # FIXME: Make this configurable?
     prefixes = ['err_', 'warn_', 'exp_']
     if len([prefix for prefix in prefixes+[''] if name.startswith(prefix)][0]):

     numOfBreakpoints = target.GetNumBreakpoints()
 
     if args.id:
-        # Make sure we only consider errors, warnings, and extentions.
+        # Make sure we only consider errors, warnings, and extensions.
         # FIXME: Make this configurable?
         prefixes = ['err_', 'warn_', 'exp_']
         if len([prefix for prefix in prefixes+[''] if args.id.startswith(prefix)][0]):

www/OpenProjects.html

 
 <li><b>Configuration Manager</b>: Clang/LLVM works on a large number of
 architectures and operating systems and can cross-compile to a similarly large
-number of configurations, but the pitfalls of chosing the command-line
+number of configurations, but the pitfalls of choosing the command-line
 options, making sure the right sub-architecture is chosen and that the correct
 optional elements of your particular system can be a pain.
 

www/analyzer/alpha_checks.html

 NSString *reminderText = 
   NSLocalizedString(@"None", @"Indicates no reminders");
 if (reminderCount == 1) {
-  // Warning: Plural cases are not supported accross all languages. 
+  // Warning: Plural cases are not supported across all languages. 
   // Use a .stringsdict file instead
   reminderText = 
     NSLocalizedString(@"1 Reminder", @"Indicates single reminder");
 } else if (reminderCount >= 2) {
-  // Warning: Plural cases are not supported accross all languages.
+  // Warning: Plural cases are not supported across all languages.
   // Use a .stringsdict file instead
   reminderText = 
     [NSString stringWithFormat:

   size_t ts;
   scanf("%zd", &ts); // 'ts' marked as tainted
   int *p = (int *)malloc(ts * sizeof(int)); 
-    // warn: untrusted data as bufer size
+    // warn: untrusted data as buffer size
 }
 </pre></div></div></td></tr>
 

www/analyzer/available_checks.html

 <div class="example"><pre>
 void test() {
   int x;
-  x |= 1; // warn: left expression is unitialized
+  x |= 1; // warn: left expression is uninitialized
 }
 </pre></div></div></td></tr>
 

www/diagnostics.html

 
 <h2>Template Type Diffing</h2>
 
-<p>Templates types can be long and difficult to read.  Moreso when part of an
+<p>Templates types can be long and difficult to read.  More so when part of an
 error message.  Instead of just printing out the type name, Clang has enough
 information to remove the common elements and highlight the differences.  To
 show the template structure more clearly, the templated type can also be

www/features.html

 options for performance analysis. Many detailed benchmarks can be found online.</p>
 
 <p>Compile time performance is important, but when using clang as an API, often
-memory use is even moreso: the less memory the code takes the more code you can
+memory use is even more so: the less memory the code takes the more code you can
 fit into memory at a time (useful for whole program analysis tools, for
 example).</p>
 

www/get_involved.html

 itself, to benefit the whole Clang community. But not every idea--not
 even every great idea--should become part of Clang. Extensions
 (particularly language extensions) pose a long-term maintenance burden
-on Clang, and therefore the benefits of the extension must outweight
+on Clang, and therefore the benefits of the extension must outweigh
 those costs. Hence, these are the seven criteria used to evaluate the
 merits of a proposed extension:</p>