fix a few spelling errors and typos

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@67758 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/utils/TableGen/ClangDiagnosticsEmitter.cpp b/utils/TableGen/ClangDiagnosticsEmitter.cpp
index 38bbf8eee6ccb5f56e0bf03124ca69efbb647e44..3d353518e204b9f0a6f48db3de262d27574aee11 100644 (file)
--- a/utils/TableGen/ClangDiagnosticsEmitter.cpp
+++ b/utils/TableGen/ClangDiagnosticsEmitter.cpp
@@ -24,7 +24,7 @@
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
-// Generic routines for all Clang TableGen backens.
+// Generic routines for all Clang TableGen backends.
 //===----------------------------------------------------------------------===//
 
 typedef std::vector<Record*> RecordVector;

diff --git a/utils/TableGen/CodeGenDAGPatterns.cpp b/utils/TableGen/CodeGenDAGPatterns.cpp
index c5e6bdffcfcda6556c9ed50d11b49f6df7cc9d51..9061d0f04912f75827522e65eaf98a36f8d3f670 100644 (file)
--- a/utils/TableGen/CodeGenDAGPatterns.cpp
+++ b/utils/TableGen/CodeGenDAGPatterns.cpp
@@ -352,7 +352,7 @@ bool SDTypeConstraint::ApplyTypeConstraint(TreePatternNode *N,
     default:         // Too many VT's to pick from.
     case 0: break;   // No info yet.
     case 1: 
-      // Only one VT of this flavor.  Cannot ever satisify the constraints.
+      // Only one VT of this flavor.  Cannot ever satisfy the constraints.
       return NodeToApply->UpdateNodeType(MVT::Other, TP);  // throw
     case 2:
       // If we have exactly two possible types, the little operand must be the
@@ -1048,7 +1048,7 @@ static bool OnlyOnRHSOfCommutative(TreePatternNode *N) {
 
 /// canPatternMatch - If it is impossible for this pattern to match on this
 /// target, fill in Reason and return false.  Otherwise, return true.  This is
-/// used as a santity check for .td files (to prevent people from writing stuff
+/// used as a sanity check for .td files (to prevent people from writing stuff
 /// that can never possibly work), and to prevent the pattern permuter from
 /// generating stuff that is useless.
 bool TreePatternNode::canPatternMatch(std::string &Reason, 
@@ -1261,7 +1261,7 @@ TreePatternNode *TreePattern::ParseTreePattern(DagInit *Dag) {
 }
 
 /// InferAllTypes - Infer/propagate as many types throughout the expression
-/// patterns as possible.  Return true if all types are infered, false
+/// patterns as possible.  Return true if all types are inferred, false
 /// otherwise.  Throw an exception if a type contradiction is found.
 bool TreePattern::InferAllTypes() {
   bool MadeChange = true;
@@ -1351,7 +1351,7 @@ void CodeGenDAGPatterns::ParseNodeInfo() {
     Nodes.pop_back();
   }
 
-  // Get the buildin intrinsic nodes.
+  // Get the builtin intrinsic nodes.
   intrinsic_void_sdnode     = getSDNodeNamed("intrinsic_void");
   intrinsic_w_chain_sdnode  = getSDNodeNamed("intrinsic_w_chain");
   intrinsic_wo_chain_sdnode = getSDNodeNamed("intrinsic_wo_chain");
@@ -1405,7 +1405,7 @@ void CodeGenDAGPatterns::ParsePatternFragments() {
     DagInit *OpsList = Fragments[i]->getValueAsDag("Operands");
     DefInit *OpsOp = dynamic_cast<DefInit*>(OpsList->getOperator());
     // Special cases: ops == outs == ins. Different names are used to
-    // improve readibility.
+    // improve readability.
     if (!OpsOp ||
         (OpsOp->getDef()->getName() != "ops" &&
          OpsOp->getDef()->getName() != "outs" &&
@@ -2260,9 +2260,9 @@ static void GenerateVariantsOf(TreePatternNode *N,
   // Look up interesting info about the node.
   const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(N->getOperator());
 
-  // If this node is associative, reassociate.
+  // If this node is associative, re-associate.
   if (NodeInfo.hasProperty(SDNPAssociative)) {
-    // Reassociate by pulling together all of the linked operators 
+    // Re-associate by pulling together all of the linked operators 
     std::vector<TreePatternNode*> MaximalChildren;
     GatherChildrenOfAssociativeOpcode(N, MaximalChildren);
 
@@ -2366,7 +2366,7 @@ void CodeGenDAGPatterns::GenerateVariants() {
   
   // Loop over all of the patterns we've collected, checking to see if we can
   // generate variants of the instruction, through the exploitation of
-  // identities.  This permits the target to provide agressive matching without
+  // identities.  This permits the target to provide aggressive matching without
   // the .td file having to contain tons of variants of instructions.
   //
   // Note that this loop adds new patterns to the PatternsToMatch list, but we

diff --git a/utils/TableGen/CodeGenDAGPatterns.h b/utils/TableGen/CodeGenDAGPatterns.h
index a3e0af6d6110a6410d7350bd899531cc789b01e0..615802beeb30d6f0ee91a15d60b1e741e2586348 100644 (file)
--- a/utils/TableGen/CodeGenDAGPatterns.h
+++ b/utils/TableGen/CodeGenDAGPatterns.h
@@ -365,7 +365,7 @@ public:
   }
   
   /// InferAllTypes - Infer/propagate as many types throughout the expression
-  /// patterns as possible.  Return true if all types are infered, false
+  /// patterns as possible.  Return true if all types are inferred, false
   /// otherwise.  Throw an exception if a type contradiction is found.
   bool InferAllTypes();
   

diff --git a/utils/TableGen/CodeGenIntrinsics.h b/utils/TableGen/CodeGenIntrinsics.h
index fea868b8c0612ac1b6ba9879a563ad69299546e1..7e7bdf989acf8c17f35cb92300c9a5fde9642341 100644 (file)
--- a/utils/TableGen/CodeGenIntrinsics.h
+++ b/utils/TableGen/CodeGenIntrinsics.h
@@ -34,7 +34,7 @@ namespace llvm {
     /// parameter values of an intrinsic. If the number of return values is > 1,
     /// then the intrinsic implicitly returns a first-class aggregate. The
     /// numbering of the types starts at 0 with the first return value and
-    /// continues from there throug the parameter list. This is useful for
+    /// continues from there through the parameter list. This is useful for
     /// "matching" types.
     struct IntrinsicSignature {
       /// RetVTs - The MVT::SimpleValueType for each return type. Note that this

diff --git a/utils/TableGen/DAGISelEmitter.cpp b/utils/TableGen/DAGISelEmitter.cpp
index 5b12f71602a6665ca1a9b6d0c510148826cc2d5a..447e0517d9dc4aaecbf48a93ee91734a1e2139a1 100644 (file)
--- a/utils/TableGen/DAGISelEmitter.cpp
+++ b/utils/TableGen/DAGISelEmitter.cpp
@@ -1610,7 +1610,7 @@ void DAGISelEmitter::EmitPatterns(std::vector<std::pair<const PatternToMatch*,
     // in this group share the same next line, emit it inline now.  Do this
     // until we run out of common predicates.
     while (!ErasedPatterns && Patterns.back().second.back().first == 1) {
-      // Check that all of fhe patterns in Patterns end with the same predicate.
+      // Check that all of the patterns in Patterns end with the same predicate.
       bool AllEndWithSamePredicate = true;
       for (unsigned i = 0, e = Patterns.size(); i != e; ++i)
         if (Patterns[i].second.back() != Patterns.back().second.back()) {

diff --git a/utils/TableGen/IntrinsicEmitter.cpp b/utils/TableGen/IntrinsicEmitter.cpp
index 8800a778164d1d7c80a55a1713cc4f5c2ad7cc02..a63efbe93b99d55ec65da74dedd20e3ba75ffe3f 100644 (file)
--- a/utils/TableGen/IntrinsicEmitter.cpp
+++ b/utils/TableGen/IntrinsicEmitter.cpp
@@ -236,7 +236,7 @@ static void EmitTypeGenerate(std::ostream &OS, const Record *ArgType,
   }
 }
 
-/// RecordListComparator - Provide a determinstic comparator for lists of
+/// RecordListComparator - Provide a deterministic comparator for lists of
 /// records.
 namespace {
   typedef std::pair<std::vector<Record*>, std::vector<Record*> > RecPair;

diff --git a/utils/TableGen/SubtargetEmitter.cpp b/utils/TableGen/SubtargetEmitter.cpp
index b05b9968a2e83a149f09152e63f82c2a5a44d601..cb36a76f432a059ede9679778cdf7b1b1c0f90eb 100644 (file)
--- a/utils/TableGen/SubtargetEmitter.cpp
+++ b/utils/TableGen/SubtargetEmitter.cpp
@@ -78,7 +78,7 @@ void SubtargetEmitter::FeatureKeyValues(std::ostream &OS) {
     
     if (CommandLineName.empty()) continue;
     
-    // Emit as { "feature", "decription", feactureEnum, i1 | i2 | ... | in }
+    // Emit as { "feature", "description", featureEnum, i1 | i2 | ... | in }
     OS << "  { "
        << "\"" << CommandLineName << "\", "
        << "\"" << Desc << "\", "

diff --git a/utils/TableGen/TGParser.cpp b/utils/TableGen/TGParser.cpp
index 9d579c2ef7e3de829202fc0203ed35620f5400ab..32ac719966c1b21074dd205c411f6bc1c7892005 100644 (file)
--- a/utils/TableGen/TGParser.cpp
+++ b/utils/TableGen/TGParser.cpp
@@ -527,7 +527,7 @@ Init *TGParser::ParseSimpleValue(Record *CurRec) {
     std::string Val = Lex.getCurStrVal();
     Lex.Lex();
     
-    // Handle multiple consequtive concatenated strings.
+    // Handle multiple consecutive concatenated strings.
     while (Lex.getCode() == tgtok::StrVal) {
       Val += Lex.getCurStrVal();
       Lex.Lex();

diff --git a/utils/TableGen/TGSourceMgr.cpp b/utils/TableGen/TGSourceMgr.cpp
index e4d1c40dc6ca4d6435b22725c187f1c6337eae55..42bc75246c9f8ba27347293a7a3dc6d1ac06f9b2 100644 (file)
--- a/utils/TableGen/TGSourceMgr.cpp
+++ b/utils/TableGen/TGSourceMgr.cpp
@@ -98,7 +98,7 @@ void TGSourceMgr::PrintError(TGLoc ErrorLoc, const std::string &Msg) const {
     ++LineEnd;
   // Print out the line.
   OS << std::string(LineStart, LineEnd) << "\n";
-  // Print out spaces before the carat.
+  // Print out spaces before the caret.
   for (const char *Pos = LineStart; Pos != ErrorLoc.getPointer(); ++Pos)
     OS << (*Pos == '\t' ? '\t' : ' ');
   OS << "^\n";