[NFC] Fix "form/from" typos

[ldionne]

LGTM, thanks! I don't think you need to wait for other owners to approve before landing this, this is pretty clearly an improvement.

[pfusik]

In D142007#4062211, @ldionne wrote:

LGTM, thanks! I don't think you need to wait for other owners to approve before landing this, this is pretty clearly an improvement.

I have no commit access, could you please commit this for me?

[pfusik]

@ldionne Can you check it in?

[Mordante]

In D142007#4071765, @pfusik wrote:

@ldionne Can you check it in?

Can you provide your name and email address to we can attribute the patch to you?

[pfusik]

In D142007#4072036, @Mordante wrote:

Can you provide your name and email address to we can attribute the patch to you?

Piotr Fusik <fox AT scene.pl>

[Mordante]

Thanks for your contribution, I just landed this patch on your behalf.

clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp

 
 ProgramStateRef
 ObjCLoopChecker::checkPointerEscape(ProgramStateRef State,
                                     const InvalidatedSymbols &Escaped,
                                     const CallEvent *Call,
                                     PointerEscapeKind Kind) const {
   SymbolRef ImmutableReceiver = getMethodReceiverIfKnownImmutable(Call);
 
-  // Remove the invalidated symbols form the collection count map.
+  // Remove the invalidated symbols from the collection count map.
   for (InvalidatedSymbols::const_iterator I = Escaped.begin(),
        E = Escaped.end();
        I != E; ++I) {
     SymbolRef Sym = *I;
 
     // Don't invalidate this symbol's count if we know the method being called
     // is declared on an immutable class. This isn't completely correct if the
     // receiver is also passed as an argument, but in most uses of NSArray,

libcxx/include/__format/extended_grapheme_cluster_table.h

 
 /// The entries of the extended grapheme cluster bondary property table.
 ///
 /// The data is generated from
 /// - https://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakProperty.txt
 /// - https://www.unicode.org/Public/UCD/latest/ucd/emoji/emoji-data.txt
 ///
 /// The data has 3 values
-/// - bits [0, 3] The property. One of the values generated form the datafiles
+/// - bits [0, 3] The property. One of the values generated from the datafiles
 ///   of \ref __property
 /// - bits [4, 10] The size of the range.
 /// - bits [11, 31] The lower bound code point of the range. The upper bound of
 ///   the range is lower bound + size.
 ///
 /// The 7 bits for the size allow a maximum range of 128 elements. Some ranges
 /// in the Unicode tables are larger. They are stored in multiple consecutive
 /// ranges in the data table. An alternative would be to store the sizes in a

libcxx/utils/generate_extended_grapheme_cluster_table.py

 DATA_ARRAY_TEMPLATE = """
 /// The entries of the extended grapheme cluster bondary property table.
 ///
 /// The data is generated from
 /// - https://www.unicode.org/Public/UCD/latest/ucd/auxiliary/GraphemeBreakProperty.txt
 /// - https://www.unicode.org/Public/UCD/latest/ucd/emoji/emoji-data.txt
 ///
 /// The data has 3 values
-/// - bits [0, 3] The property. One of the values generated form the datafiles
+/// - bits [0, 3] The property. One of the values generated from the datafiles
 ///   of \\ref __property
 /// - bits [4, 10] The size of the range.
 /// - bits [11, 31] The lower bound code point of the range. The upper bound of
 ///   the range is lower bound + size.
 ///
 /// The 7 bits for the size allow a maximum range of 128 elements. Some ranges
 /// in the Unicode tables are larger. They are stored in multiple consecutive
 /// ranges in the data table. An alternative would be to store the sizes in a

lldb/include/lldb/Host/File.h

public:
   /// NOTE: This function is thread safe in that clients manager their
   /// own file position markers and reads on other threads won't mess up the
   /// current read.
   ///
   /// \param[in] dst
   ///     A buffer where to put the bytes that are read.
   ///
   /// \param[in,out] num_bytes
-  ///     The number of bytes to read form the current file position
+  ///     The number of bytes to read from the current file position
   ///     which gets modified with the number of bytes that were read.
   ///
   /// \param[in,out] offset
   ///     The offset within the file from which to read \a num_bytes
   ///     bytes. This offset gets incremented by the number of bytes
   ///     that were read.
   ///
   /// \return

lldb/source/Plugins/CMakeLists.txt

 set(LLDB_ENUM_PLUGINS "")
 
 # FIXME: ProcessWindowsCommon needs to be initialized after all other process
 # plugins but before ProcessGDBRemote.
 set(LLDB_PROCESS_WINDOWS_PLUGIN "")
 set(LLDB_PROCESS_GDB_PLUGIN "")
 
 foreach(p ${LLDB_ALL_PLUGINS})
-  # Strip lldbPlugin form the plugin name.
+  # Strip lldbPlugin from the plugin name.
   string(SUBSTRING ${p} 10 -1 pStripped)
   if(${pStripped} MATCHES "^ScriptInterpreter*")
     set(LLDB_ENUM_PLUGINS "${LLDB_ENUM_PLUGINS}LLDB_SCRIPT_PLUGIN(${pStripped})\n")
   elseif(${pStripped} STREQUAL "ProcessWindowsCommon")
     set(LLDB_PROCESS_WINDOWS_PLUGIN "LLDB_PLUGIN(${pStripped})\n")
   elseif(${pStripped} STREQUAL "ProcessGDBRemote")
     set(LLDB_PROCESS_GDB_PLUGIN "LLDB_PLUGIN(${pStripped})\n")
   else()

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

public:
 
   clang::TranslationUnitDecl *GetTranslationUnitDecl() {
     return getASTContext().getTranslationUnitDecl();
   }
 
   static bool AreTypesSame(CompilerType type1, CompilerType type2,
                            bool ignore_qualifiers = false);
 
-  /// Creates a CompilerType form the given QualType with the current
+  /// Creates a CompilerType from the given QualType with the current
   /// TypeSystemClang instance as the CompilerType's typesystem.
   /// \param qt The QualType for a type that belongs to the ASTContext of this
   ///           TypeSystemClang.
   /// \return The CompilerType representing the given QualType. If the
   ///         QualType's type pointer is a nullptr then the function returns an
   ///         invalid CompilerType.
   CompilerType GetType(clang::QualType qt) {
     if (qt.getTypePtrOrNull() == nullptr)

llvm/lib/Analysis/IVDescriptors.cpp

if (!Preheader || !Latch)
     return false;
 
   // Ensure the phi node's incoming blocks are the loop preheader and latch.
   if (Phi->getBasicBlockIndex(Preheader) < 0 ||
       Phi->getBasicBlockIndex(Latch) < 0)
     return false;
 
   // Get the previous value. The previous value comes from the latch edge while
-  // the initial value comes form the preheader edge.
+  // the initial value comes from the preheader edge.
   auto *Previous = dyn_cast<Instruction>(Phi->getIncomingValueForBlock(Latch));
 
   // If Previous is a phi in the header, go through incoming values from the
   // latch until we find a non-phi value. Use this as the new Previous, all uses
   // in the header will be dominated by the original phi, but need to be moved
   // after the non-phi previous value.
   SmallPtrSet<PHINode *, 4> SeenPhis;
   while (auto *PrevPhi = dyn_cast_or_null<PHINode>(Previous)) {

llvm/lib/CodeGen/CodeGenPrepare.cpp

for (auto &BB : F) {
     // This doesn't change the successor order of the just created branch
     // instruction (or any other instruction).
     if (Opc == Instruction::Or)
       std::swap(TBB, FBB);
 
     // Replace the old BB with the new BB.
     TBB->replacePhiUsesWith(&BB, TmpBB);
 
-    // Add another incoming edge form the new BB.
+    // Add another incoming edge from the new BB.
     for (PHINode &PN : FBB->phis()) {
       auto *Val = PN.getIncomingValueForBlock(&BB);
       PN.addIncoming(Val, TmpBB);
     }
 
     // Update the branch weights (from SelectionDAGBuilder::
     // FindMergedConditions).
     if (Opc == Instruction::Or) {

llvm/lib/Target/AArch64/AArch64ISelDAGToDAG.cpp

static bool isBitfieldExtractOpFromAnd(SelectionDAG *CurDAG, SDNode *N,
   assert((VT == MVT::i32 || VT == MVT::i64) &&
          "Type checking must have been done before calling this function");
 
   // FIXME: simplify-demanded-bits in DAGCombine will probably have
   // changed the AND node to a 32-bit mask operation. We'll have to
   // undo that as part of the transform here if we want to catch all
   // the opportunities.
   // Currently the NumberOfIgnoredLowBits argument helps to recover
-  // form these situations when matching bigger pattern (bitfield insert).
+  // from these situations when matching bigger pattern (bitfield insert).
 
   // For unsigned extracts, check for a shift right and mask
   uint64_t AndImm = 0;
   if (!isOpcWithIntImmediate(N, ISD::AND, AndImm))
     return false;
 
   const SDNode *Op0 = N->getOperand(0).getNode();
 

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

case Intrinsic::assume: {
     /// Canonicalize Knowledge in operand bundles.
     if (EnableKnowledgeRetention && II->hasOperandBundles()) {
       for (unsigned Idx = 0; Idx < II->getNumOperandBundles(); Idx++) {
         auto &BOI = II->bundle_op_info_begin()[Idx];
         RetainedKnowledge RK =
           llvm::getKnowledgeFromBundle(cast<AssumeInst>(*II), BOI);
         if (BOI.End - BOI.Begin > 2)
           continue; // Prevent reducing knowledge in an align with offset since
-                    // extracting a RetainedKnowledge form them looses offset
+                    // extracting a RetainedKnowledge from them looses offset
                     // information
         RetainedKnowledge CanonRK =
           llvm::simplifyRetainedKnowledge(cast<AssumeInst>(II), RK,
                                           &getAssumptionCache(),
                                           &getDominatorTree());
         if (CanonRK == RK)
           continue;
         if (!CanonRK) {

llvm/lib/Transforms/Scalar/ConstantHoisting.cpp

for (auto CC = std::next(ConstCandVec.begin()), E = ConstCandVec.end();
     MinValItr = CC;
   }
   // Finalize the last base constant search.
   findAndMakeBaseConstant(MinValItr, ConstCandVec.end(), ConstInfoVec);
 }
 
 /// Updates the operand at Idx in instruction Inst with the result of
 ///        instruction Mat. If the instruction is a PHI node then special
-///        handling for duplicate values form the same incoming basic block is
+///        handling for duplicate values from the same incoming basic block is
 ///        required.
 /// \return The update will always succeed, but the return value indicated if
 ///         Mat was used for the update or not.
 static bool updateOperand(Instruction *Inst, unsigned Idx, Instruction *Mat) {
   if (auto PHI = dyn_cast<PHINode>(Inst)) {
     // Check if any previous operand of the PHI node has the same incoming basic
     // block. This is a very odd case that happens when the incoming basic block
     // has a switch statement. In this case use the same value as the previous

llvm/test/DebugInfo/ARM/PR26163.ll

 ; because the function validThroughout has a special code path for single
 ; locations with a constant value that start in the prologue.
 ;
 ; CHECK:      DW_TAG_inlined_subroutine
 ; CHECK:        DW_TAG_variable
 ; CHECK-NEXT:     DW_AT_location (DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4)
 ; CHECK-NEXT:     DW_AT_abstract_origin
 
-; Created form the following test case (PR26163) with
+; Created from the following test case (PR26163) with
 ; clang -cc1 -triple armv4t--freebsd11.0-gnueabi -emit-obj -debug-info-kind=standalone -O2 -x c test.c
 ;
 ; typedef unsigned int  size_t;
 ; struct timeval {
 ;   long long tv_sec;
 ;   int tv_usec;
 ; };
 ;

llvm/tools/llvm-exegesis/lib/Clustering.cpp

for (const ClusterId &CID : ClusterIDs) {
       // Mark to-be-moved points as belonging to the new cluster.
       std::for_each(it, OldCluster.PointIndices.end(),
                     [this, &UnstableCluster](size_t P) {
                       ClusterIdForPoint_[P] = UnstableCluster.Id;
                     });
       // Actually append to-be-moved points to the new cluster.
       UnstableCluster.PointIndices.insert(UnstableCluster.PointIndices.end(),
                                           it, OldCluster.PointIndices.end());
-      // And finally, remove "to-be-moved" points form the old cluster.
+      // And finally, remove "to-be-moved" points from the old cluster.
       OldCluster.PointIndices.erase(it, OldCluster.PointIndices.end());
       // Now, the old cluster may end up being empty, but let's just keep it
       // in whatever state it ended up. Purging empty clusters isn't worth it.
     };
     assert(UnstableCluster.PointIndices.size() > 1 &&
            "New unstable cluster should end up with more than one point.");
     assert(UnstableCluster.PointIndices.size() >= ClusterIDs.size() &&
            "New unstable cluster should end up with no less points than there "

llvm/unittests/ExecutionEngine/MCJIT/MCJITCAPITest.cpp

 //===- MCJITTest.cpp - Unit tests for the MCJIT -----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This test suite verifies basic MCJIT functionality when invoked form the C
+// This test suite verifies basic MCJIT functionality when invoked from the C
 // API.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MCJITTestAPICommon.h"
 #include "llvm-c/Analysis.h"
 #include "llvm-c/Core.h"
 #include "llvm-c/ExecutionEngine.h"

llvm/unittests/FuzzMutate/RandomIRBuilderTest.cpp

for (int i = 0; i < 10; ++i) {
       Value *Src =
           IB.findOrCreateSource(BB, &*BB.begin(), Srcs, IVDescr.SourcePreds[2]);
       ASSERT_TRUE(IVDescr.SourcePreds[2].matches(Srcs, Src));
     }
   }
 }
 
 TEST(RandomIRBuilderTest, ShuffleVectorSink) {
-  // Check that we will never use shuffle vector mask as a sink form the
+  // Check that we will never use shuffle vector mask as a sink from the
   // unrelated operation.
 
   LLVMContext Ctx;
   const char *SourceCode =
       "define void @test(<4 x i32> %a) {\n"
       "  %S1 = shufflevector <4 x i32> %a, <4 x i32> %a, <4 x i32> undef\n"
       "  %S2 = shufflevector <4 x i32> %a, <4 x i32> %a, <4 x i32> undef\n"
       "  ret void\n"

mlir/lib/Dialect/Transform/IR/TransformDialect.cpp

#include "mlir/Dialect/Transform/IR/TransformOps.cpp.inc"
   initializeTypes();
 
   pdl::OperationType::attachInterface<
       PDLOperationTypeTransformHandleTypeInterfaceImpl>(*getContext());
 }
 
 void transform::TransformDialect::mergeInPDLMatchHooks(
     llvm::StringMap<PDLConstraintFunction> &&constraintFns) {
-  // Steal the constraint functions form the given map.
+  // Steal the constraint functions from the given map.
   for (auto &it : constraintFns)
     pdlMatchHooks.registerConstraintFunction(it.getKey(), std::move(it.second));
 }
 
 const llvm::StringMap<PDLConstraintFunction> &
 transform::TransformDialect::getPDLConstraintHooks() const {
   return pdlMatchHooks.getConstraintFunctions();
 }