[LLVM] Fix some Clang-tidy modernize-use-bool-literals and Include What You Use warnings in unittests and utils; other minor fixes

[Eugene.Zelenko]

Summary

I checked this patch on my own build on RHEL 6. Regressions were OK.

[compnerd]

utils/PerfectShuffle/PerfectShuffle.cpp

425

This is horrible. We shouldnt leave dead code, and this should really be moved into a DEBUG() statement. However, that is beyond the scope of this particular change, and that isnt your fault.

utils/TableGen/CodeGenDAGPatterns.cpp

2011

Is this used in the rest of the scope?

[Eugene.Zelenko]

utils/TableGen/CodeGenDAGPatterns.cpp

2011

No, it used only in loop.

[mehdi_amini]

utils/TableGen/CodeGenDAGPatterns.cpp

2011

(Which reminds that patches uploaded with full context are easier to review)

For this particular change, I rather read:

unsigned FirstChild = isCommIntrinsic ? 1 : 0; // First operand is intrinsic id.
for (unsigned Child = FirstChild, Last = getNumChildren()-1; Child != Last; ++Child)
      if (OnlyOnRHSOfCommutative(getChild(Child))) {
        Reason="Immediate value must be on the RHS of commutative operators!";

[Eugene.Zelenko]

Change loop.

unittests/ADT/TestGraph.h

 
 #include "llvm/ADT/GraphTraits.h"
 #include <cassert>
-#include <climits>
 #include <utility>
 
 #ifndef LLVM_UNITTESTS_ADT_TEST_GRAPH_H

 template <unsigned N>
 class Graph {
 private:
-  // Disable copying.
-  Graph(const Graph&);
-  Graph& operator=(const Graph&);
+  Graph(const Graph&) = delete;
+  Graph& operator=(const Graph&) = delete;
 
   static void ValidateIndex(unsigned Idx) {
     assert(Idx < N && "Invalid node index!");
   }
+
 public:
-
   /// NodeSubset - A subset of the graph's nodes.
   class NodeSubset {
     typedef unsigned char BitVector; // Where the limitation N <= 8 comes from.
     BitVector Elements;
+
     NodeSubset(BitVector e) : Elements(e) {}
+
   public:
     /// NodeSubset - Default constructor, creates an empty subset.
     NodeSubset() : Elements(0) {

 private:
   /// Nodes - The list of nodes for this graph.
   NodeType Nodes[N];
+
 public:
-
   /// Graph - Default constructor.  Creates an empty graph.
   Graph() {
     // Let each node know which node it is.  This allows us to find the start of

         return Reachable;
 
       // Rinse and repeat.
-    } while (1);
+    } while (true);
   }
 
   /// ChildIterator - Visit all children of a node.

     /// yet been visited.
     NodeSubset Children;
 
-    ChildIterator(); // Disable default constructor.
+    ChildIterator() = delete;
+
   protected:
     ChildIterator(NodeType *F, NodeSubset C) : FirstNode(F), Children(C) {}
 

   }
 };
 
-} // End namespace llvm
+} // end namespace llvm
 
-#endif
+#endif // LLVM_UNITTESTS_ADT_TEST_GRAPH_H

unittests/Analysis/LoopPassManagerTest.cpp

 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/LoopPassManager.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Dominators.h"
-#include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/Support/SourceMgr.h"
+#include <algorithm>
+#include <memory>
+#include <vector>
 
 using namespace llvm;
 

       EXPECT_TRUE(EXPECTED[I] == ACTUAL[I]) << "Element " << I << " is "       \
                                             << ACTUAL[I] << ". Expected "      \
                                             << EXPECTED[I] << ".";             \
-  } while (0)
+  } while (false)
 
 TEST_F(LoopPassManagerTest, Basic) {
   LoopAnalysisManager LAM(true);

   // cached results for everything.
   EXPECT_EQ(4, LoopAnalysisRuns);
 }
-}
+
+} // end anonymous namespace

unittests/ExecutionEngine/MCJIT/MCJITTestAPICommon.h

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Triple.h"
-#include "llvm/IR/LegacyPassManager.h"
 #include "llvm/InitializePasses.h"
+#include "llvm/PassRegistry.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/TargetSelect.h"
+#include <string>
 
 // Used to skip tests on unsupported architectures and operating systems.
 // To skip a test, add this macro at the top of a test-case in a suite that

   do \
     if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) \
       return; \
-  while(0)
+  while (false)
 
 namespace llvm {
 

       return true;
 
     // If ARCH has sub-arch support, find it
-    SmallVectorImpl<std::string>::const_iterator I = SupportedSubArchs.begin();
-    for(; I != SupportedSubArchs.end(); ++I)
-      if (Host.getArchName().startswith(I->c_str()))
+    for (const auto &I : SupportedSubArchs)
+      if (Host.getArchName().startswith(I))
         return true;
 
     return false;

   SmallVector<Triple::EnvironmentType, 1> UnsupportedEnvironments;
 };
 
-} // namespace llvm
+} // end namespace llvm
 
-#endif
-
+#endif // LLVM_UNITTESTS_EXECUTIONENGINE_MCJIT_MCJITTESTAPICOMMON_H

unittests/Support/LEB128Test.cpp

 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
-#include "llvm/Support/DataTypes.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/raw_ostream.h"
+#include <cstdint>
 #include <string>
+
 using namespace llvm;
 
 namespace {

     encodeSLEB128(VALUE, Stream); \
     Stream.flush(); \
     EXPECT_EQ(Expected, Actual); \
-  } while (0)
+  } while (false)
 
   // Encode SLEB128
   EXPECT_SLEB128_EQ("\x00", 0);

     unsigned Size = encodeULEB128(VALUE, Buffer, PAD); \
     std::string Actual2(reinterpret_cast<const char *>(Buffer), Size); \
     EXPECT_EQ(Expected, Actual2); \
-  } while (0)
+  } while (false)
 
   // Encode ULEB128
   EXPECT_ULEB128_EQ("\x00", 0, 0);

                                     &ActualSize); \
     EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \
     EXPECT_EQ(EXPECTED, Actual); \
-  } while (0)
+  } while (false)
 
   // Decode ULEB128
   EXPECT_DECODE_ULEB128_EQ(0u, "\x00");

                                     &ActualSize); \
     EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \
     EXPECT_EQ(EXPECTED, Actual); \
-  } while (0)
+  } while (false)
 
   // Decode SLEB128
   EXPECT_DECODE_SLEB128_EQ(0L, "\x00");

   EXPECT_EQ(10u, getULEB128Size(UINT64_MAX));
 }
 
-}  // anonymous namespace
+} // end anonymous namespace

unittests/Support/ThreadPool.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/ThreadPool.h"
-
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Host.h"
-#include "llvm/Support/TargetSelect.h"
-
 #include "gtest/gtest.h"
+#include <atomic>
+#include <cstddef>
+#include <mutex>
 
 using namespace llvm;
 

   SmallVector<Triple::ArchType, 4> UnsupportedArchs;
   SmallVector<Triple::OSType, 4> UnsupportedOSs;
   SmallVector<Triple::EnvironmentType, 1> UnsupportedEnvironments;
+
 protected:
   // This is intended for platform as a temporary "XFAIL"
   bool isUnsupportedOSOrEnvironment() {

   std::condition_variable WaitMainThread;
   std::mutex WaitMainThreadMutex;
   bool MainThreadReady;
-
 };
 
 #define CHECK_UNSUPPORTED() \
   do { \
     if (isUnsupportedOSOrEnvironment()) \
       return; \
-  } while (0); \
+  } while (false); \
 
 TEST_F(ThreadPoolTest, AsyncBarrier) {
   CHECK_UNSUPPORTED();

utils/FileCheck/FileCheck.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/Twine.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/SMLoc.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <cassert>
 #include <cctype>
+#include <cstdlib>
 #include <map>
+#include <memory>
 #include <string>
 #include <system_error>
+#include <utility>
 #include <vector>
+
 using namespace llvm;
 
 static cl::opt<std::string>

 //===----------------------------------------------------------------------===//
 
 namespace Check {
+
   enum CheckType {
     CheckNone = 0,
     CheckPlain,

     /// CheckBadNot - Found -NOT combined with another CHECK suffix.
     CheckBadNot
   };
-}
 
+} // end namespace Check
+
 class Pattern {
   SMLoc PatternLoc;
 

   size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM);
 };
 
-
 bool Pattern::ParsePattern(StringRef PatternStr,
                            StringRef Prefix,
                            SourceMgr &SM,

     if (Expr.getAsInteger(10, Offset))
       return false;
   }
-  Value = llvm::itostr(LineNumber + Offset);
+  Value = itostr(LineNumber + Offset);
   return true;
 }
 

     RegExToMatch = TmpStr;
   }
 
-
   SmallVector<StringRef, 4> MatchInfo;
   if (!Regex(RegExToMatch, Regex::Newline).match(Buffer, &MatchInfo))
     return StringRef::npos;

   return StringRef::npos;
 }
 
-
 //===----------------------------------------------------------------------===//
 // Check Strings.
 //===----------------------------------------------------------------------===//

                                                "IMPLICIT-CHECK", SM, 0);
   }
 
-
   std::vector<Pattern> DagNotMatches = ImplicitNegativeChecks;
 
   // LineNumber keeps track of the line on which CheckPrefix instances are
   // found.
   unsigned LineNumber = 1;
 
-  while (1) {
+  while (true) {
     Check::CheckType CheckTy;
     size_t PrefixLoc;
 

 static unsigned CountNumNewlinesBetween(StringRef Range,
                                         const char *&FirstNewLine) {
   unsigned NumNewLines = 0;
-  while (1) {
+  while (true) {
     // Scan for newline.
     Range = Range.substr(Range.find_first_of("\n\r"));
     if (Range.empty()) return NumNewLines;

utils/PerfectShuffle/PerfectShuffle.cpp

 #include <iomanip>
 #include <iostream>
 #include <vector>
+
 struct Operator;
 
 // Masks are 4-nibble hex numbers.  Values 0-7 in any nibble means that it takes

   ShuffleVal() : Cost(1000000) {}
 };
 
-
 /// ShufTab - This is the actual shuffle table that we are trying to generate.
 ///
 static ShuffleVal ShufTab[65536];

     :  Name(name), ShuffleMask(shufflemask), OpNum(opnum),Cost(cost) {
     TheOperators.push_back(this);
   }
+
   ~Operator() {
     assert(TheOperators.back() == this);
     TheOperators.pop_back();

   else if (ShufTab[Op].Arg0 == 0x4567)
     return "RHS";
   else {
-    assert(0 && "bad zero cost operation");
+    assert(false && "bad zero cost operation");
     abort();
   }
 }

   Vals[NumVals++] = Elt;
 }
 
-
 int main() {
   // Seed the table with accesses to the LHS and RHS.
   ShufTab[0x0123].Cost = 0;

           if (ShufTab[RHS].Cost + 1 >= MaxCost)
             continue;
 
-
           // Evaluate op(LHS,RHS)
           unsigned ResultMask = Op->getTransformedMask(LHS, RHS);
 

   if (CostArray[9])
     std::cout << "// " << CostArray[9] << " entries have higher cost!\n";
 
-
   // Build up the table to emit.
   std::cout << "\n// This table is 6561*4 = 26244 bytes in size.\n";
   std::cout << "static const unsigned PerfectShuffleTable[6561+1] = {\n";

   }
   std::cout << "  0\n};\n";
 
-  if (0) {
+  if (false) {
     // Print out the table.
     for (unsigned i = 0; i != 0x8889; ++i) {
       if (!isValidMask(i)) continue;

   }
 }
 
-
 #ifdef GENERATE_ALTIVEC
 
 ///===---------------------------------------------------------------------===//

utils/TableGen/AsmWriterEmitter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "AsmWriterInst.h"
+#include "CodeGenInstruction.h"
+#include "CodeGenRegisters.h"
 #include "CodeGenTarget.h"
 #include "SequenceToOffsetTable.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 #include <algorithm>
 #include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <deque>
+#include <iterator>
 #include <map>
+#include <set>
+#include <string>
+#include <tuple>
 #include <utility>
 #include <vector>
+
 using namespace llvm;
 
 #define DEBUG_TYPE "asm-writer-emitter"
 
 namespace {
+
 class AsmWriterEmitter {
   RecordKeeper &Records;
   CodeGenTarget Target;
   ArrayRef<const CodeGenInstruction *> NumberedInstructions;
   std::vector<AsmWriterInst> Instructions;
+
 public:
   AsmWriterEmitter(RecordKeeper &R);
 

                                  std::vector<unsigned> &InstOpsUsed,
                                  bool PassSubtarget) const;
 };
+
 } // end anonymous namespace
 
 static void PrintCases(std::vector<std::pair<std::string,

   O << "\n      break;\n";
 }
 
-
 /// EmitInstructions - Emit the last instruction in the vector and any other
 /// instructions that are suitably similar to it.
 static void EmitInstructions(std::vector<AsmWriterInst> &Insts,

                           std::vector<std::vector<unsigned>> &InstIdxs,
                           std::vector<unsigned> &InstOpsUsed,
                           bool PassSubtarget) const {
-
   // This vector parallels UniqueOperandCommands, keeping track of which
   // instructions each case are used for.  It is a comma separated string of
   // enums.

   }
 }
 
-
 static void UnescapeString(std::string &Str) {
   for (unsigned i = 0; i != Str.size(); ++i) {
     if (Str[i] == '\\' && i != Str.size()-1) {

 
   std::vector<std::vector<std::string>> TableDrivenOperandPrinters;
 
-  while (1) {
+  while (true) {
     std::vector<std::string> UniqueOperandCommands;
     std::vector<std::vector<unsigned>> InstIdxs;
     std::vector<unsigned> NumInstOpsHandled;

                      [](AsmWriterInst &Inst) { return Inst.Operands.empty(); });
   Instructions.erase(I, Instructions.end());
 
-
   // Because this is a vector, we want to emit from the end.  Reverse all of the
   // elements in the vector.
   std::reverse(Instructions.begin(), Instructions.end());

 }
 
 namespace {
+
 // IAPrinter - Holds information about an InstAlias. Two InstAliases match if
 // they both have the same conditionals. In which case, we cannot print out the
 // alias for that pattern.

 
   std::string Result;
   std::string AsmString;
+
 public:
   IAPrinter(std::string R, std::string AS)
       : Result(std::move(R)), AsmString(std::move(AS)) {}

 }
 
 namespace {
+
 struct AliasPriorityComparator {
   typedef std::pair<CodeGenInstAlias, int> ValueType;
   bool operator()(const ValueType &LHS, const ValueType &RHS) {

     return LHS.second > RHS.second;
   }
 };
-}
 
+} // end anonymous namespace
 
 void AsmWriterEmitter::EmitPrintAliasInstruction(raw_ostream &O) {
   Record *AsmWriter = Target.getAsmWriter();

         NumMIOps += Operand.getMINumOperands();
 
       std::string Cond;
-      Cond = std::string("MI->getNumOperands() == ") + llvm::utostr(NumMIOps);
+      Cond = std::string("MI->getNumOperands() == ") + utostr(NumMIOps);
       IAP.addCond(Cond);
 
       bool CantHandle = false;
 
       unsigned MIOpNum = 0;
       for (unsigned i = 0, e = LastOpNo; i != e; ++i) {
-        std::string Op = "MI->getOperand(" + llvm::utostr(MIOpNum) + ")";
+        std::string Op = "MI->getOperand(" + utostr(MIOpNum) + ")";
 
         const CodeGenInstAlias::ResultOperand &RO = CGA.ResultOperands[i];
 

                                     ".contains(" + Op + ".getReg())";
             } else {
               Cond = Op + ".getReg() == MI->getOperand(" +
-                     llvm::utostr(IAP.getOpIndex(ROName)) + ").getReg()";
+                     utostr(IAP.getOpIndex(ROName)) + ").getReg()";
             }
           } else {
             // Assume all printable operands are desired for now. This can be

                 break; // No conditions on this operand at all
             }
             Cond = Target.getName() + ClassName + "ValidateMCOperand(" +
-                   Op + ", STI, " + llvm::utostr(Entry) + ")";
+                   Op + ", STI, " + utostr(Entry) + ")";
           }
           // for all subcases of ResultOperand::K_Record:
           IAP.addCond(Cond);

           // MCInst will. An MCExpr could be present, for example.
           IAP.addCond(Op + ".isImm()");
 
-          Cond = Op + ".getImm() == " +
-                 llvm::utostr(CGA.ResultOperands[i].getImm());
+          Cond = Op + ".getImm() == " + utostr(CGA.ResultOperands[i].getImm());
           IAP.addCond(Cond);
           break;
         }

   EmitPrintAliasInstruction(O);
 }
 
-
 namespace llvm {
 
 void EmitAsmWriter(RecordKeeper &RK, raw_ostream &OS) {

   AsmWriterEmitter(RK).run(OS);
 }
 
-} // End llvm namespace
+} // end namespace llvm

utils/TableGen/CodeGenDAGPatterns.cpp

 //===----------------------------------------------------------------------===//
 
 #include "CodeGenDAGPatterns.h"
+#include "CodeGenInstruction.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 #include <algorithm>
+#include <cassert>
+#include <cstdint>
 #include <cstdio>
+#include <iterator>
+#include <map>
 #include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
 using namespace llvm;
 
 #define DEBUG_TYPE "dag-patterns"

 static inline bool isInteger(MVT::SimpleValueType VT) {
   return MVT(VT).isInteger();
 }
+
 static inline bool isFloatingPoint(MVT::SimpleValueType VT) {
   return MVT(VT).isFloatingPoint();
 }
+
 static inline bool isVector(MVT::SimpleValueType VT) {
   return MVT(VT).isVector();
 }
+
 static inline bool isScalar(MVT::SimpleValueType VT) {
   return !MVT(VT).isVector();
 }

   }
 }
 
-
 EEVT::TypeSet::TypeSet(ArrayRef<MVT::SimpleValueType> VTList) {
   assert(!VTList.empty() && "empty list?");
   TypeVec.append(VTList.begin(), VTList.end());

   return any_of(TypeVec, isVector);
 }
 
-
 std::string EEVT::TypeSet::getName() const {
   if (TypeVec.empty()) return "<empty>";
 
   std::string Result;
 
   for (unsigned i = 0, e = TypeVec.size(); i != e; ++i) {
-    std::string VTName = llvm::getEnumName(TypeVec[i]);
+    std::string VTName = getEnumName(TypeVec[i]);
     // Strip off MVT:: prefix if present.
     if (VTName.substr(0,5) == "MVT::")
       VTName = VTName.substr(5);

   return MadeChange;
 }
 
-
-
 /// EnforceSmallerThan - 'this' must be a smaller VT than Other. For vectors
 /// this should be based on the element type. Update this and other based on
 /// this information.

 }
 #endif
 
-
 //===----------------------------------------------------------------------===//
 // TreePredicateFn Implementation
 //===----------------------------------------------------------------------===//

   return PatFragRec->getRecord()->getValueAsString("ImmediateCode");
 }
 
-
 /// isAlwaysTrue - Return true if this is a noop predicate.
 bool TreePredicateFn::isAlwaysTrue() const {
   return getPredCode().empty() && getImmCode().empty();

 // PatternToMatch implementation
 //
 
-
 /// getPatternSize - Return the 'size' of this pattern.  We want to match large
 /// patterns before small ones.  This is used to determine the size of a
 /// pattern.

   return getPatternSize(getSrcPattern(), CGP) + getAddedComplexity();
 }
 
-
 /// getPredicateCheck - Return a single string containing all of this
 /// pattern's predicates concatenated with "&&" operators.
 ///

   return UpdateNodeType(ResNo, Tgt.getRegisterClass(RC).getValueTypes(), TP);
 }
 
-
 //===----------------------------------------------------------------------===//
 // SDNodeInfo implementation
 //

     }
   }
 
-
   // Parse the type constraints.
   std::vector<Record*> ConstraintList =
     TypeProfile->getValueAsListOfDefs("Constraints");

     OS << ":$" << getName();
 
 }
+
 void TreePatternNode::dump() const {
   print(errs());
 }

     getChild(i)->RemoveAllTypes();
 }
 
-
 /// SubstituteFormalArguments - Replace the formal arguments in this tree
 /// with actual values specified by ArgMap.
 void TreePatternNode::

   }
 }
 
-
 /// InlinePatternFragments - If this pattern refers to any pattern
 /// fragments, inline them into place, giving us a pattern without any
 /// PatFrag references.

   return EEVT::TypeSet(MVT::Other, TP);
 }
 
-
 /// getIntrinsicInfo - If this node corresponds to an intrinsic, return the
 /// CodeGenIntrinsic information for it, otherwise return a null pointer.
 const CodeGenIntrinsic *TreePatternNode::

   return CGP.getSDNodeInfo(Operator).hasProperty(Property);
 }
 
-
-
-
 /// TreeHasProperty - Return true if any node in this tree has the specified
 /// property.
 bool TreePatternNode::TreeHasProperty(SDNP Property,

 
   bool MadeChange = getChild(0)->ApplyTypeConstraints(TP, NotRegisters);
 
-
   // If either the output or input of the xform does not have exact
   // type info. We assume they must be the same. Otherwise, it is perfectly
   // legal to transform from one type to a completely different type.

   return false;
 }
 
-
 /// 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 sanity check for .td files (to prevent people from writing stuff

     // Scan all of the operands of the node and make sure that only the last one
     // is a constant node, unless the RHS also is.
     if (!OnlyOnRHSOfCommutative(getChild(getNumChildren()-1))) {
-      bool Skip = isCommIntrinsic ? 1 : 0; // First operand is intrinsic id.
+      unsigned Skip = isCommIntrinsic ? 1 : 0; // First operand is intrinsic id.
       for (unsigned i = Skip, e = getNumChildren()-1; i != e; ++i)
         if (OnlyOnRHSOfCommutative(getChild(i))) {
           Reason="Immediate value must be on the RHS of commutative operators!";

     ComputeNamedNodes(N->getChild(i));
 }
 
-
 TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
   if (DefInit *DI = dyn_cast<DefInit>(TheInit)) {
     Record *R = DI->getDef();

   return MadeChange;
 }
 
-
-
 /// InferAllTypes - Infer/propagate as many types throughout the expression
 /// patterns as possible.  Return true if all types are inferred, false
 /// otherwise.  Flags an error if a type contradiction is found.

   }
 }
 
-
 /// ParsePatternFragments - Parse all of the PatFrag definitions in the .td
 /// file, building up the PatternFragments map.  After we've collected them all,
 /// inline fragments together as necessary, so that there are no references left

 
 class InstAnalyzer {
   const CodeGenDAGPatterns &CDP;
+
 public:
   bool hasSideEffects;
   bool mayStore;

         hasSideEffects = true;
     }
   }
-
 };
 
 static bool InferFromPattern(CodeGenInstruction &InstInfo,

   }
 }
 
-
 typedef std::pair<const TreePatternNode*, unsigned> NameRecord;
 
 static void FindNames(const TreePatternNode *P,

   PatternsToMatch.push_back(PTM);
 }
 
-
-
 void CodeGenDAGPatterns::InferInstructionFlags() {
   ArrayRef<const CodeGenInstruction*> Instructions =
     Target.getInstructionsByEnumValue();

   }
 }
 
-
 /// Verify instruction flags against pattern node properties.
 void CodeGenDAGPatterns::VerifyInstructionFlags() {
   unsigned Errors = 0;

   CombineChildVariants(Orig, ChildVariants, OutVariants, CDP, DepVars);
 }
 
-
 static void GatherChildrenOfAssociativeOpcode(TreePatternNode *N,
                                      std::vector<TreePatternNode *> &Children) {
-  assert(N->getNumChildren()==2 &&"Associative but doesn't have 2 children!");
+  assert(N->getNumChildren() == 2 &&
+         "Associative but doesn't have 2 children!");
   Record *Operator = N->getOperator();
 
   // Only permit raw nodes.

   }
 }
 
-
 // GenerateVariants - Generate variants.  For example, commutative patterns can
 // match multiple ways.  Add them to PatternsToMatch as well.
 void CodeGenDAGPatterns::GenerateVariants() {

utils/TableGen/CodeGenInstruction.cpp

 
 #include "CodeGenInstruction.h"
 #include "CodeGenTarget.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
+#include <cassert>
+#include <cstdint>
+#include <cstddef>
 #include <set>
+
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//

     MIOperandNo += NumOps;
   }
 
-
   // Make sure the constraints list for each operand is large enough to hold
   // constraint info, even if none is present.
   for (unsigned i = 0, e = OperandList.size(); i != e; ++i)
     OperandList[i].Constraints.resize(OperandList[i].MINumOperands);
 }
 
-
 /// getOperandNamed - Return the index of the operand with the specified
 /// non-empty name.  If the instruction does not have an operand with the
 /// specified name, abort.

 }
 
 void CGIOperandList::ProcessDisableEncoding(std::string DisableEncoding) {
-  while (1) {
+  while (true) {
     std::pair<StringRef, StringRef> P = getToken(DisableEncoding, " ,\t");
     std::string OpName = P.first;
     DisableEncoding = P.second;

       OperandList[Op.first].DoNotEncode.resize(Op.second+1);
     OperandList[Op.first].DoNotEncode[Op.second] = true;
   }
-
 }
 
 //===----------------------------------------------------------------------===//

   return MVT::Other;
 }
 
-
 /// FlattenAsmStringVariants - Flatten the specified AsmString to only
 /// include text from the specified variant, returning the new string.
 std::string CodeGenInstruction::
 FlattenAsmStringVariants(StringRef Cur, unsigned Variant) {
-  std::string Res = "";
+  std::string Res;
 
-  for (;;) {
+  while (true) {
     // Find the start of the next variant string.
     size_t VariantsStart = 0;
     for (size_t e = Cur.size(); VariantsStart != e; ++VariantsStart)

   return Res;
 }
 
-
 //===----------------------------------------------------------------------===//
 /// CodeGenInstAlias Implementation
 //===----------------------------------------------------------------------===//

utils/TableGen/CodeGenRegisters.cpp

 #include "CodeGenRegisters.h"
 #include "CodeGenTarget.h"
 #include "llvm/ADT/IntEqClasses.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/TableGen/Error.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <iterator>
+#include <set>
+#include <tuple>
+#include <utility>
 
 using namespace llvm;
 

 }
 
 namespace {
+
 // Iterate over all register units in a set of registers.
 class RegUnitIterator {
   CodeGenRegister::Vec::const_iterator RegI, RegE;

     }
   }
 };
-} // namespace
 
+} // end anonymous namespace
+
 // Return true of this unit appears in RegUnits.
 static bool hasRegUnit(CodeGenRegister::RegUnitList &RegUnits, unsigned Unit) {
   return RegUnits.test(Unit);

 // sub-registers. We provide a SetTheory expander class that returns the new
 // registers.
 namespace {
+
 struct TupleExpander : SetTheory::Expander {
   void expand(SetTheory &ST, Record *Def, SetTheory::RecSet &Elts) override {
     std::vector<Record*> Indices = Def->getValueAsListOfDefs("SubRegIndices");

     }
   }
 };
-}
 
+} // end anonymous namespace
+
 //===----------------------------------------------------------------------===//
 //                            CodeGenRegisterClass
 //===----------------------------------------------------------------------===//

 }
 
 namespace llvm {
+
   raw_ostream &operator<<(raw_ostream &OS, const CodeGenRegisterClass::Key &K) {
     OS << "{ S=" << K.SpillSize << ", A=" << K.SpillAlignment;
     for (const auto R : *K.Members)
       OS << ", " << R->getName();
     return OS << " }";
   }
-}
 
+} // end namespace llvm
+
 // This is a simple lexicographical order that can be used to search for sets.
 // It is not the same as the topological order provided by TopoOrderRC.
 bool CodeGenRegisterClass::Key::

   auto *A = &PA;
   auto *B = &PB;
   if (A == B)
-    return 0;
+    return false;
 
   // Order by ascending spill size.
   if (A->SpillSize < B->SpillSize)

 }
 
 namespace {
+
 // UberRegSet is a helper class for computeRegUnitWeights. Each UberRegSet is
 // the transitive closure of the union of overlapping register
 // classes. Together, the UberRegSets form a partition of the registers. If we

 
   UberRegSet(): Weight(0) {}
 };
-} // namespace
 
+} // end anonymous namespace
+
 // Partition registers into UberRegSets, where each set is the transitive
 // closure of the union of overlapping register classes.
 //

 static void computeUberSets(std::vector<UberRegSet> &UberSets,
                             std::vector<UberRegSet*> &RegSets,
                             CodeGenRegBank &RegBank) {
-
   const auto &Registers = RegBank.getRegisters();
 
   // The Register EnumValue is one greater than its index into Registers.

       CodeGenRegister *SubReg = S->second;
       // Ignore non-leaf subregisters, their lane masks are fully covered by
       // the leaf subregisters anyway.
-      if (SubReg->getSubRegs().size() != 0)
+      if (!SubReg->getSubRegs().empty())
         continue;
       CodeGenSubRegIndex *SubRegIndex = S->first;
       const CodeGenRegister *SubRegister = S->second;

   }
 }
 
-
 //
 // Infer missing register classes.
 //

utils/TableGen/DAGISelMatcherOpt.cpp

 
 #include "DAGISelMatcher.h"
 #include "CodeGenDAGPatterns.h"
+#include "CodeGenTarget.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/CodeGen/MachineValueType.h"
+#include "llvm/Support/Casting.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
+#include <cassert>
+#include <memory>
+#include <utility>
+
 using namespace llvm;
 
 #define DEBUG_TYPE "isel-opt"

           Pattern.getSrcPattern()->NodeHasProperty(SDNPOutGlue, CGP))
         ResultsMatch = false;
       
-      
       // If the root result node defines more results than the source root node
       // *and* has a chain or glue input, then we can't match it because it
       // would end up replacing the extra result with the chain/glue.

   return nullptr;
 }
 
-
 /// FactorNodes - Turn matches like this:
 ///   Scope
 ///     OPC_CheckType i32

     // current sets of nodes and this node don't matter.  Look past it to see if
     // we can merge anything else into this matching group.
     unsigned Scan = OptionIdx;
-    while (1) {
+    while (true) {
       // If we ran out of stuff to scan, we're done.
       if (Scan == e) break;
       

     }
     return;
   }
-  
 
   // Reassemble the Scope node with the adjusted children.
   Scope->setNumChildren(NewOptionsToMatch.size());