[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

 //===- llvm/unittest/ADT/TestGraph.h - Graph for testing ------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Common graph data structure for testing.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/GraphTraits.h"
 #include <cassert>
-#include <climits>
 #include <utility>
 
 #ifndef LLVM_UNITTESTS_ADT_TEST_GRAPH_H
 #define LLVM_UNITTESTS_ADT_TEST_GRAPH_H
 
 namespace llvm {
 
 /// Graph<N> - A graph with N nodes.  Note that N can be at most 8.
 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:
 
+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) {
       assert(N <= sizeof(BitVector)*CHAR_BIT && "Graph too big!");
     }
 
     /// Comparison operators.
     bool operator==(const NodeSubset &other) const {

   };
 
   /// NodeType - Node index and set of children of the node.
   typedef std::pair<unsigned, NodeSubset> NodeType;
 
 private:
   /// Nodes - The list of nodes for this graph.
   NodeType Nodes[N];
-public:
 
+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
     // the Nodes array given a pointer to any element of it.
     for (unsigned i = 0; i != N; ++i)
       Nodes[i].first = i;
   }
 

         if (Previous.count(i))
           Reachable = Reachable.Join(Nodes[i].second);
 
       // If nothing changed then we have found all reachable nodes.
       if (Reachable == Previous)
         return Reachable;
 
       // Rinse and repeat.
-    } while (1);
+    } while (true);
   }
 
   /// ChildIterator - Visit all children of a node.
   class ChildIterator {
     friend class Graph;
 
     /// FirstNode - Pointer to first node in the graph's Nodes array.
     NodeType *FirstNode;
     /// Children - Set of nodes which are children of this one and that haven't
     /// yet been visited.
     NodeSubset Children;
 
-    ChildIterator(); // Disable default constructor.
+    ChildIterator() = delete;
+
   protected:
     ChildIterator(NodeType *F, NodeSubset C) : FirstNode(F), Children(C) {}
 
   public:
     /// ChildIterator - Copy constructor.
     ChildIterator(const ChildIterator& other) : FirstNode(other.FirstNode),
       Children(other.Children) {}
 

   static ChildIteratorType child_begin(NodeRef Node) {
     return Graph<N>::child_begin(Node);
   }
   static ChildIteratorType child_end(NodeRef Node) {
     return Graph<N>::child_end(Node);
   }
 };
 
-} // End namespace llvm
+} // end namespace llvm
 
-#endif
+#endif // LLVM_UNITTESTS_ADT_TEST_GRAPH_H

unittests/Analysis/LoopPassManagerTest.cpp

 //===- llvm/unittest/Analysis/LoopPassManagerTest.cpp - LPM tests ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #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;
 
 namespace {
 
 class TestLoopAnalysis {
   /// \brief Private static data to provide unique ID.
   static char PassID;

 
 #define EXPECT_N_ELEMENTS_EQ(N, EXPECTED, ACTUAL)                              \
   do {                                                                         \
     EXPECT_EQ(N##UL, ACTUAL.size());                                           \
     for (int I = 0; I < N; ++I)                                                \
       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);
   int LoopAnalysisRuns = 0;
   LAM.registerPass([&] { return TestLoopAnalysis(LoopAnalysisRuns); });
 
   FunctionAnalysisManager FAM(true);
   // We need DominatorTreeAnalysis for LoopAnalysis.

   EXPECT_N_ELEMENTS_EQ(4, ExpectedLoops, VisitedLoops2);
   // The block from loop.g.0 won't be counted, since it wasn't cached.
   EXPECT_EQ(5, AnalyzedBlockCount2);
 
   // The first LPM runs the loop analysis for all four loops, the second uses
   // cached results for everything.
   EXPECT_EQ(4, LoopAnalysisRuns);
 }
-}
+
+} // end anonymous namespace

unittests/ExecutionEngine/MCJIT/MCJITTestAPICommon.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_UNITTESTS_EXECUTIONENGINE_MCJIT_MCJITTESTAPICOMMON_H
 #define LLVM_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
 // inherits from MCJITTestBase. See MCJITTest.cpp for examples.
 #define SKIP_UNSUPPORTED_PLATFORM \
   do \
     if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) \
       return; \
-  while(0)
+  while (false)
 
 namespace llvm {
 
 class MCJITTestAPICommon {
 protected:
   MCJITTestAPICommon()
     : HostTriple(sys::getProcessTriple())
   {
bool ArchSupportsMCJIT() {
     if (!is_contained(SupportedArchs, Host.getArch()))
       return false;
 
     // If ARCH is supported and has no specific sub-arch support
     if (!is_contained(HasSubArchs, Host.getArch()))
       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;
   }
 
   /// Returns true if the host OS is known to support MCJIT
   bool OSSupportsMCJIT() {
     Triple Host(HostTriple);
#endif // LLVM_ON_WIN32
   std::string HostTriple;
   SmallVector<Triple::ArchType, 4> SupportedArchs;
   SmallVector<Triple::ArchType, 1> HasSubArchs;
   SmallVector<std::string, 2> SupportedSubArchs; // We need to own the memory
   SmallVector<Triple::OSType, 4> UnsupportedOSs;
   SmallVector<Triple::EnvironmentType, 1> UnsupportedEnvironments;
 };
 
-} // namespace llvm
-
-#endif
+} // end namespace llvm
 
+#endif // LLVM_UNITTESTS_EXECUTIONENGINE_MCJIT_MCJITTESTAPICOMMON_H

unittests/Support/LEB128Test.cpp

 //===- llvm/unittest/Support/LEB128Test.cpp - LEB128 function tests -------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #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 {
 
 TEST(LEB128Test, EncodeSLEB128) {
 #define EXPECT_SLEB128_EQ(EXPECTED, VALUE) \
   do { \
     /* encodeSLEB128(uint64_t, raw_ostream &) */ \
     std::string Expected(EXPECTED, sizeof(EXPECTED) - 1); \
     std::string Actual; \
     raw_string_ostream Stream(Actual); \
     encodeSLEB128(VALUE, Stream); \
     Stream.flush(); \
     EXPECT_EQ(Expected, Actual); \
-  } while (0)
+  } while (false)
 
   // Encode SLEB128
   EXPECT_SLEB128_EQ("\x00", 0);
   EXPECT_SLEB128_EQ("\x01", 1);
   EXPECT_SLEB128_EQ("\x7f", -1);
   EXPECT_SLEB128_EQ("\x3f", 63);
   EXPECT_SLEB128_EQ("\x41", -63);
   EXPECT_SLEB128_EQ("\x40", -64);

     Stream.flush(); \
     EXPECT_EQ(Expected, Actual1); \
     \
     /* encodeULEB128(uint64_t, uint8_t *, unsigned) */ \
     uint8_t Buffer[32]; \
     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);
   EXPECT_ULEB128_EQ("\x01", 1, 0);
   EXPECT_ULEB128_EQ("\x3f", 63, 0);
   EXPECT_ULEB128_EQ("\x40", 64, 0);
   EXPECT_ULEB128_EQ("\x7f", 0x7f, 0);
   EXPECT_ULEB128_EQ("\x80\x01", 0x80, 0);

 TEST(LEB128Test, DecodeULEB128) {
 #define EXPECT_DECODE_ULEB128_EQ(EXPECTED, VALUE) \
   do { \
     unsigned ActualSize = 0; \
     uint64_t Actual = decodeULEB128(reinterpret_cast<const uint8_t *>(VALUE), \
                                     &ActualSize); \
     EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \
     EXPECT_EQ(EXPECTED, Actual); \
-  } while (0)
+  } while (false)
 
   // Decode ULEB128
   EXPECT_DECODE_ULEB128_EQ(0u, "\x00");
   EXPECT_DECODE_ULEB128_EQ(1u, "\x01");
   EXPECT_DECODE_ULEB128_EQ(63u, "\x3f");
   EXPECT_DECODE_ULEB128_EQ(64u, "\x40");
   EXPECT_DECODE_ULEB128_EQ(0x7fu, "\x7f");
   EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x01");

 TEST(LEB128Test, DecodeSLEB128) {
 #define EXPECT_DECODE_SLEB128_EQ(EXPECTED, VALUE) \
   do { \
     unsigned ActualSize = 0; \
     int64_t Actual = decodeSLEB128(reinterpret_cast<const uint8_t *>(VALUE), \
                                     &ActualSize); \
     EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \
     EXPECT_EQ(EXPECTED, Actual); \
-  } while (0)
+  } while (false)
 
   // Decode SLEB128
   EXPECT_DECODE_SLEB128_EQ(0L, "\x00");
   EXPECT_DECODE_SLEB128_EQ(1L, "\x01");
   EXPECT_DECODE_SLEB128_EQ(63L, "\x3f");
   EXPECT_DECODE_SLEB128_EQ(-64L, "\x40");
   EXPECT_DECODE_SLEB128_EQ(-63L, "\x41");
   EXPECT_DECODE_SLEB128_EQ(-1L, "\x7f");

   EXPECT_EQ(9u, getULEB128Size(0x4000000000000000ULL));
   EXPECT_EQ(9u, getULEB128Size(0x7fffffffffffffffULL));
 
   EXPECT_EQ(10u, getULEB128Size(0x8000000000000000ULL));
 
   EXPECT_EQ(10u, getULEB128Size(UINT64_MAX));
 }
 
-}  // anonymous namespace
+} // end anonymous namespace

unittests/Support/ThreadPool.cpp

 //========- unittests/Support/ThreadPools.cpp - ThreadPools.h tests --========//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #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;
 
 // Fixture for the unittests, allowing to *temporarily* disable the unittests
 // on a particular platform
 class ThreadPoolTest : public testing::Test {
   Triple Host;
   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() {
     Triple Host(Triple::normalize(sys::getProcessTriple()));
 
     if (find(UnsupportedEnvironments, Host.getEnvironment()) !=
         UnsupportedEnvironments.end())
       return true;

     WaitMainThread.notify_all();
   }
 
   void SetUp() override { MainThreadReady = false; }
 
   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();
   // test that async & barrier work together properly.
 
   std::atomic_int checked_in{0};
 
   ThreadPool Pool;

utils/FileCheck/FileCheck.cpp

 //
 // This program exits with an error status of 2 on error, exit status of 0 if
 // the file matched the expected contents, and exit status of 1 if it did not
 // contain the expected contents.
 //
 //===----------------------------------------------------------------------===//
 
 #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>
 CheckFilename(cl::Positional, cl::desc("<check-file>"), cl::Required);
 
 static cl::opt<std::string>
 InputFilename("input-file", cl::desc("File to check (defaults to stdin)"),
               cl::init("-"), cl::value_desc("filename"));

 
 typedef cl::list<std::string>::const_iterator prefix_iterator;
 
 //===----------------------------------------------------------------------===//
 // Pattern Handling Code.
 //===----------------------------------------------------------------------===//
 
 namespace Check {
+
   enum CheckType {
     CheckNone = 0,
     CheckPlain,
     CheckNext,
     CheckSame,
     CheckNot,
     CheckDAG,
     CheckLabel,
 
     /// MatchEOF - When set, this pattern only matches the end of file. This is
     /// used for trailing CHECK-NOTs.
     CheckEOF,
     /// CheckBadNot - Found -NOT combined with another CHECK suffix.
     CheckBadNot
   };
-}
+
+} // end namespace Check
 
 class Pattern {
   SMLoc PatternLoc;
 
   /// FixedStr - If non-empty, this pattern is a fixed string match with the
   /// specified fixed string.
   StringRef FixedStr;
 

   /// \brief Finds the closing sequence of a regex variable usage or
   /// definition. Str has to point in the beginning of the definition
   /// (right after the opening sequence).
   /// \return offset of the closing sequence within Str, or npos if it was not
   /// found.
   size_t FindRegexVarEnd(StringRef Str, SourceMgr &SM);
 };
 
-
 bool Pattern::ParsePattern(StringRef PatternStr,
                            StringRef Prefix,
                            SourceMgr &SM,
                            unsigned LineNumber) {
   bool MatchFullLinesHere = MatchFullLines && CheckTy != Check::CheckNot;
 
   this->LineNumber = LineNumber;
   PatternLoc = SMLoc::getFromPointer(PatternStr.data());

   if (!Expr.empty()) {
     if (Expr[0] == '+')
       Expr = Expr.substr(1);
     else if (Expr[0] != '-')
       return false;
     if (Expr.getAsInteger(10, Offset))
       return false;
   }
-  Value = llvm::itostr(LineNumber + Offset);
+  Value = itostr(LineNumber + Offset);
   return true;
 }
 
 /// Match - Match the pattern string against the input buffer Buffer.  This
 /// returns the position that is matched or npos if there is no match.  If
 /// there is a match, the size of the matched string is returned in MatchLen.
 size_t Pattern::Match(StringRef Buffer, size_t &MatchLen,
                       StringMap<StringRef> &VariableTable) const {

                     Value.begin(), Value.end());
       InsertOffset += Value.size();
     }
 
     // Match the newly constructed regex.
     RegExToMatch = TmpStr;
   }
 
-
   SmallVector<StringRef, 4> MatchInfo;
   if (!Regex(RegExToMatch, Regex::Newline).match(Buffer, &MatchInfo))
     return StringRef::npos;
 
   // Successful regex match.
   assert(!MatchInfo.empty() && "Didn't get any match");
   StringRef FullMatch = MatchInfo[0];
 

       Str = Str.substr(1);
       Offset++;
     }
   }
 
   return StringRef::npos;
 }
 
-
 //===----------------------------------------------------------------------===//
 // Check Strings.
 //===----------------------------------------------------------------------===//
 
 /// CheckString - This is a check that we found in the input file.
 struct CheckString {
   /// Pat - The pattern to match.
   Pattern Pat;

         CmdLine->getBuffer().substr(Prefix.size(), PatternString.size());
     SM.AddNewSourceBuffer(std::move(CmdLine), SMLoc());
 
     ImplicitNegativeChecks.push_back(Pattern(Check::CheckNot));
     ImplicitNegativeChecks.back().ParsePattern(PatternInBuffer,
                                                "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;
 
     // See if a prefix occurs in the memory buffer.
     StringRef UsedPrefix = FindFirstMatchingPrefix(Buffer,
                                                    LineNumber,
                                                    CheckTy,
                                                    PrefixLoc);

   PrintCheckFailed(SM, CheckStr.Loc, CheckStr.Pat, Buffer, VariableTable);
 }
 
 /// CountNumNewlinesBetween - Count the number of newlines in the specified
 /// range.
 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;
 
     ++NumNewLines;
 
     // Handle \n\r and \r\n as a single newline.
     if (Range.size() > 1 &&

utils/PerfectShuffle/PerfectShuffle.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include <cassert>
 #include <cstdlib>
 #include <iomanip>
 #include <iostream>
 #include <vector>
+
 struct Operator;
 
 // Masks are 4-nibble hex numbers.  Values 0-7 in any nibble means that it takes
 // an element from that value of the input vectors.  A value of 8 means the
 // entry is undefined.
 
 // Mask manipulation functions.
 static inline unsigned short MakeMask(unsigned V0, unsigned V1,

 struct ShuffleVal {
   Operator *Op;   // The Operation used to generate this value.
   unsigned Cost;  // Number of instrs used to generate this value.
   unsigned short Arg0, Arg1;  // Input operands for this value.
 
   ShuffleVal() : Cost(1000000) {}
 };
 
-
 /// ShufTab - This is the actual shuffle table that we are trying to generate.
 ///
 static ShuffleVal ShufTab[65536];
 
 /// TheOperators - All of the operators that this target supports.
 static std::vector<Operator*> TheOperators;
 
 /// Operator - This is a vector operation that is available for use.
 struct Operator {
   const char *Name;
   unsigned short ShuffleMask;
   unsigned short OpNum;
   unsigned Cost;
 
   Operator(unsigned short shufflemask, const char *name, unsigned opnum,
            unsigned cost = 1)
     :  Name(name), ShuffleMask(shufflemask), OpNum(opnum),Cost(cost) {
     TheOperators.push_back(this);
   }
+
   ~Operator() {
     assert(TheOperators.back() == this);
     TheOperators.pop_back();
   }
 
   bool isOnlyLHSOperator() const {
     return isOnlyLHSMask(ShuffleMask);
   }

 };
 
 static const char *getZeroCostOpName(unsigned short Op) {
   if (ShufTab[Op].Arg0 == 0x0123)
     return "LHS";
   else if (ShufTab[Op].Arg0 == 0x4567)
     return "RHS";
   else {
-    assert(0 && "bad zero cost operation");
+    assert(false && "bad zero cost operation");
     abort();
   }
 }
 
 static void PrintOperation(unsigned ValNo, unsigned short Vals[]) {
   unsigned short ThisOp = Vals[ValNo];
   std::cerr << "t" << ValNo;
   PrintMask(ThisOp, std::cerr);

   if (ShufTab[Arg0].Cost)
     EvaluateOps(Arg0, Vals, NumVals);
   if (Arg0 != Arg1 && ShufTab[Arg1].Cost)
     EvaluateOps(Arg1, Vals, NumVals);
 
   Vals[NumVals++] = Elt;
 }
 
-
 int main() {
   // Seed the table with accesses to the LHS and RHS.
   ShufTab[0x0123].Cost = 0;
   ShufTab[0x0123].Op = nullptr;
   ShufTab[0x0123].Arg0 = 0x0123;
   ShufTab[0x4567].Cost = 0;
   ShufTab[0x4567].Op = nullptr;
   ShufTab[0x4567].Arg0 = 0x4567;

           if (!isValidMask(RHS)) continue;
           if (ShufTab[RHS].Cost > 1000) continue;
 
           // If nothing involving this operand could possibly be cheaper than
           // what we already have, don't consider it.
           if (ShufTab[RHS].Cost + 1 >= MaxCost)
             continue;
 
-
           // Evaluate op(LHS,RHS)
           unsigned ResultMask = Op->getTransformedMask(LHS, RHS);
 
           if (ShufTab[ResultMask].Cost <= OpCount ||
               ShufTab[ResultMask].Cost <= ShufTab[LHS].Cost ||
               ShufTab[ResultMask].Cost <= ShufTab[RHS].Cost)
             continue;
 

   }
 
   for (unsigned i = 0; i != 9; ++i)
     if (CostArray[i])
       std::cout << "// " << CostArray[i] << " entries have cost " << i << "\n";
   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";
 
   for (unsigned i = 0; i != 0x8889; ++i) {
     if (!isValidMask(i)) continue;
 
     // CostSat - The cost of this operation saturated to two bits.

       } else {
         PrintMask(ShufTab[i].Arg1, std::cout);
       }
     }
     std::cout << "\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;
       if (ShufTab[i].Cost < 1000) {
         PrintMask(i, std::cerr);
         std::cerr << " - Cost " << ShufTab[i].Cost << " - ";
 
         unsigned short Vals[30];
         unsigned NumVals = 0;
         EvaluateOps(i, Vals, NumVals);
 
         for (unsigned j = 0, e = NumVals; j != e; ++j)
           PrintOperation(j, Vals);
         std::cerr << "\n";
       }
     }
   }
 }
 
-
 #ifdef GENERATE_ALTIVEC
 
 ///===---------------------------------------------------------------------===//
 /// The altivec instruction definitions.  This is the altivec-specific part of
 /// this file.
 ///===---------------------------------------------------------------------===//
 
 // Note that the opcode numbers here must match those in the PPC backend.

utils/TableGen/AsmWriterEmitter.cpp

 //===- AsmWriterEmitter.cpp - Generate an assembly writer -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This tablegen backend emits an assembly printer for the current target.
 // Note that this is currently fairly skeletal, but will grow over time.
 //
 //===----------------------------------------------------------------------===//
 
 #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);
 
   void run(raw_ostream &o);
 
 private:
   void EmitPrintInstruction(raw_ostream &o);
   void EmitGetRegisterName(raw_ostream &o);
   void EmitPrintAliasInstruction(raw_ostream &O);
 
   void FindUniqueOperandCommands(std::vector<std::string> &UOC,
                                  std::vector<std::vector<unsigned>> &InstIdxs,
                                  std::vector<unsigned> &InstOpsUsed,
                                  bool PassSubtarget) const;
 };
+
 } // end anonymous namespace
 
 static void PrintCases(std::vector<std::pair<std::string,
                        AsmWriterOperand> > &OpsToPrint, raw_ostream &O,
                        bool PassSubtarget) {
   O << "    case " << OpsToPrint.back().first << ":";
   AsmWriterOperand TheOp = OpsToPrint.back().second;
   OpsToPrint.pop_back();
 
   // Check to see if any other operands are identical in this list, and if so,
   // emit a case label for them.
   for (unsigned i = OpsToPrint.size(); i != 0; --i)
     if (OpsToPrint[i-1].second == TheOp) {
       O << "\n    case " << OpsToPrint[i-1].first << ":";
       OpsToPrint.erase(OpsToPrint.begin()+i-1);
     }
 
   // Finally, emit the code.
   O << "\n      " << TheOp.getCode(PassSubtarget);
   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,
                              raw_ostream &O, bool PassSubtarget) {
   AsmWriterInst FirstInst = Insts.back();
   Insts.pop_back();
 
   std::vector<AsmWriterInst> SimilarInsts;

   O << "    break;\n";
 }
 
 void AsmWriterEmitter::
 FindUniqueOperandCommands(std::vector<std::string> &UniqueOperandCommands,
                           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.
   std::vector<std::string> InstrsForCase;
   InstrsForCase.resize(UniqueOperandCommands.size());
   InstOpsUsed.assign(UniqueOperandCommands.size(), 0);
 
   for (size_t i = 0, e = Instructions.size(); i != e; ++i) {

     }
 
     if (!Instrs.empty())
       UniqueOperandCommands[i] = "    // " + Instrs + "\n" +
         UniqueOperandCommands[i];
   }
 }
 
-
 static void UnescapeString(std::string &Str) {
   for (unsigned i = 0; i != Str.size(); ++i) {
     if (Str[i] == '\\' && i != Str.size()-1) {
       switch (Str[i+1]) {
       default: continue;  // Don't execute the code after the switch.
       case 'a': Str[i] = '\a'; break;
       case 'b': Str[i] = '\b'; break;
       case 'e': Str[i] = 27; break;

   unsigned AsmStrBits = Log2_32_Ceil(MaxStringIdx+2);
 
   // To reduce code size, we compactify common instructions into a few bits
   // in the opcode-indexed table.
   unsigned BitsLeft = OpcodeInfoBits-AsmStrBits;
 
   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;
     FindUniqueOperandCommands(UniqueOperandCommands, InstIdxs,
                               NumInstOpsHandled, PassSubtarget);
 
     // If we ran out of operands to print, we're done.
     if (UniqueOperandCommands.empty()) break;

     BitsLeft -= NumBits;
   }
 
   // Okay, delete instructions with no operand info left.
   auto I = remove_if(Instructions,
                      [](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());
 
 
   // Now that we've emitted all of the operand info that fit into 64 bits, emit
   // information for those instructions that are left.  This is a less dense
   // encoding, but we expect the main 64-bit table to handle the majority of

     O << "  assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&\n"
       << "          \"Invalid alt name index for register!\");\n"
       << "  return AsmStrs+RegAsmOffset[RegNo-1];\n";
   }
   O << "}\n";
 }
 
 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.
 class IAPrinter {
   std::vector<std::string> Conds;
   std::map<StringRef, std::pair<int, int>> OpMap;
 
   std::string Result;
   std::string AsmString;
+
 public:
   IAPrinter(std::string R, std::string AS)
       : Result(std::move(R)), AsmString(std::move(AS)) {}
 
   void addCond(const std::string &C) { Conds.push_back(C); }
 
   void addOperand(StringRef Op, int OpIdx, int PrintMethodIdx = -1) {
     assert(OpIdx >= 0 && OpIdx < 0xFE && "Idx out of range");

   std::string FlatAsmString =
       CodeGenInstruction::FlattenAsmStringVariants(AsmString, Variant);
   AsmString = FlatAsmString;
 
   return AsmString.count(' ') + AsmString.count('\t');
 }
 
 namespace {
+
 struct AliasPriorityComparator {
   typedef std::pair<CodeGenInstAlias, int> ValueType;
   bool operator()(const ValueType &LHS, const ValueType &RHS) {
     if (LHS.second ==  RHS.second) {
       // We don't actually care about the order, but for consistency it
       // shouldn't depend on pointer comparisons.
       return LHS.first.TheDef->getName() < RHS.first.TheDef->getName();
     }
 
     // Aliases with larger priorities should be considered first.
     return LHS.second > RHS.second;
   }
 };
-}
 
+} // end anonymous namespace
 
 void AsmWriterEmitter::EmitPrintAliasInstruction(raw_ostream &O) {
   Record *AsmWriter = Target.getAsmWriter();
 
   O << "\n#ifdef PRINT_ALIAS_INSTR\n";
   O << "#undef PRINT_ALIAS_INSTR\n\n";
 
   //////////////////////////////

                      });
       }
 
       unsigned NumMIOps = 0;
       for (auto &Operand : CGA.ResultOperands)
         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];
 
         switch (RO.Kind) {
         case CodeGenInstAlias::ResultOperand::K_Record: {
           const Record *Rec = RO.getRecord();
           StringRef ROName = RO.getName();
           int PrintMethodIdx = -1;

               Record *R = CGA.ResultOperands[i].getRecord();
               if (R->isSubClassOf("RegisterOperand"))
                 R = R->getValueAsDef("RegClass");
               Cond = std::string("MRI.getRegClass(") + Target.getName() + "::" +
                      R->getName() + "RegClassID)"
                                     ".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
             // overridden in the InstAlias instantiation if necessary.
             IAP.addOperand(ROName, MIOpNum, PrintMethodIdx);
 
             // There might be an additional predicate on the MCOperand
             unsigned Entry = MCOpPredicateMap[Rec];
             if (!Entry) {
               if (!Rec->isValueUnset("MCOperandPredicate")) {
                 MCOpPredicates.push_back(Rec);
                 Entry = MCOpPredicates.size();
                 MCOpPredicateMap[Rec] = Entry;
               } else
                 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);
           break;
         }
         case CodeGenInstAlias::ResultOperand::K_Imm: {
           // Just because the alias has an immediate result, doesn't mean the
           // 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;
         }
         case CodeGenInstAlias::ResultOperand::K_Reg:
           // If this is zero_reg, something's playing tricks we're not
           // equipped to handle.
           if (!CGA.ResultOperands[i].getRegister()) {
             CantHandle = true;

 }
 
 void AsmWriterEmitter::run(raw_ostream &O) {
   EmitPrintInstruction(O);
   EmitGetRegisterName(O);
   EmitPrintAliasInstruction(O);
 }
 
-
 namespace llvm {
 
 void EmitAsmWriter(RecordKeeper &RK, raw_ostream &OS) {
   emitSourceFileHeader("Assembly Writer Source Fragment", OS);
   AsmWriterEmitter(RK).run(OS);
 }
 
-} // End llvm namespace
+} // end namespace llvm

utils/TableGen/CodeGenDAGPatterns.cpp

 //===- CodeGenDAGPatterns.cpp - Read DAG patterns from .td file -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the CodeGenDAGPatterns class, which is used to read and
 // represent the patterns present in a .td file for instructions.
 //
 //===----------------------------------------------------------------------===//
 
 #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"
 
 //===----------------------------------------------------------------------===//
 //  EEVT::TypeSet Implementation
 //===----------------------------------------------------------------------===//
 
 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(MVT::SimpleValueType VT, TreePattern &TP) {
   if (VT == MVT::iAny)
     EnforceInteger(TP);
   else if (VT == MVT::fAny)
     EnforceFloatingPoint(TP);
   else if (VT == MVT::vAny)
     EnforceVector(TP);
   else {
     assert((VT < MVT::LAST_VALUETYPE || VT == MVT::iPTR ||
             VT == MVT::iPTRAny || VT == MVT::Any) && "Not a concrete type!");
     TypeVec.push_back(VT);
   }
 }
 
-
 EEVT::TypeSet::TypeSet(ArrayRef<MVT::SimpleValueType> VTList) {
   assert(!VTList.empty() && "empty list?");
   TypeVec.append(VTList.begin(), VTList.end());
 
   if (!VTList.empty())
     assert(VTList[0] != MVT::iAny && VTList[0] != MVT::vAny &&
            VTList[0] != MVT::fAny);
 

 }
 
 /// hasVectorTypes - Return true if this TypeSet contains a vAny or a vector
 /// value type.
 bool EEVT::TypeSet::hasVectorTypes() const {
   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);
     if (i) Result += ':';
     Result += VTName;
   }
 
   if (TypeVec.size() == 1)

   if (TypeVec.empty()) {
     TP.error("Type inference contradiction found, '" +
              InputSet.getName() + "' needs to be a vector");
     return false;
   }
   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.
 bool EEVT::TypeSet::EnforceSmallerThan(EEVT::TypeSet &Other, TreePattern &TP) {
   if (TP.hasError())
     return false;
 
   // Both operands must be integer or FP, but we don't care which.

     for (const std::string &DepVar : DepVars) {
       DEBUG(errs() << DepVar << " ");
     }
     DEBUG(errs() << "]");
   }
 }
 #endif
 
-
 //===----------------------------------------------------------------------===//
 // TreePredicateFn Implementation
 //===----------------------------------------------------------------------===//
 
 /// TreePredicateFn constructor.  Here 'N' is a subclass of PatFrag.
 TreePredicateFn::TreePredicateFn(TreePattern *N) : PatFragRec(N) {
   assert((getPredCode().empty() || getImmCode().empty()) &&
         ".td file corrupt: can't have a node predicate *and* an imm predicate");
 }
 
 std::string TreePredicateFn::getPredCode() const {
   return PatFragRec->getRecord()->getValueAsString("PredicateCode");
 }
 
 std::string TreePredicateFn::getImmCode() const {
   return PatFragRec->getRecord()->getValueAsString("ImmediateCode");
 }
 
-
 /// isAlwaysTrue - Return true if this is a noop predicate.
 bool TreePredicateFn::isAlwaysTrue() const {
   return getPredCode().empty() && getImmCode().empty();
 }
 
 /// Return the name to use in the generated code to reference this, this is
 /// "Predicate_foo" if from a pattern fragment "foo".
 std::string TreePredicateFn::getFnName() const {

   
   return Result + getPredCode();
 }
 
 //===----------------------------------------------------------------------===//
 // 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.
 static unsigned getPatternSize(const TreePatternNode *P,
                                const CodeGenDAGPatterns &CGP) {
   unsigned Size = 3;  // The node itself.
   // If the root node is a ConstantSDNode, increases its size.
   // e.g. (set R32:$dst, 0).

 
 /// Compute the complexity metric for the input pattern.  This roughly
 /// corresponds to the number of nodes that are covered.
 int PatternToMatch::
 getPatternComplexity(const CodeGenDAGPatterns &CGP) const {
   return getPatternSize(getSrcPattern(), CGP) + getAddedComplexity();
 }
 
-
 /// getPredicateCheck - Return a single string containing all of this
 /// pattern's predicates concatenated with "&&" operators.
 ///
 std::string PatternToMatch::getPredicateCheck() const {
   SmallVector<Record *, 4> PredicateRecs;
   for (Init *I : Predicates->getValues()) {
     if (DefInit *Pred = dyn_cast<DefInit>(I)) {
       Record *Def = Pred->getDef();

   else if (Operand->isSubClassOf("RegisterOperand"))
     RC = Operand->getValueAsDef("RegClass");
 
   assert(RC && "Unknown operand type");
   CodeGenTarget &Tgt = TP.getDAGPatterns().getTargetInfo();
   return UpdateNodeType(ResNo, Tgt.getRegisterClass(RC).getValueTypes(), TP);
 }
 
-
 //===----------------------------------------------------------------------===//
 // SDNodeInfo implementation
 //
 SDNodeInfo::SDNodeInfo(Record *R) : Def(R) {
   EnumName    = R->getValueAsString("Opcode");
   SDClassName = R->getValueAsString("SDClass");
   Record *TypeProfile = R->getValueAsDef("TypeProfile");
   NumResults = TypeProfile->getValueAsInt("NumResults");

       Properties |= 1 << SDNPVariadic;
     } else {
       PrintFatalError("Unknown SD Node property '" +
                       Property->getName() + "' on node '" +
                       R->getName() + "'!");
     }
   }
 
-
   // Parse the type constraints.
   std::vector<Record*> ConstraintList =
     TypeProfile->getValueAsListOfDefs("Constraints");
   TypeConstraints.assign(ConstraintList.begin(), ConstraintList.end());
 }
 
 /// getKnownType - If the type constraints on this node imply a fixed type
 /// (e.g. all stores return void, etc), then return it as an

   for (const TreePredicateFn &Pred : PredicateFns)
     OS << "<<P:" << Pred.getFnName() << ">>";
   if (TransformFn)
     OS << "<<X:" << TransformFn->getName() << ">>";
   if (!getName().empty())
     OS << ":$" << getName();
 
 }
+
 void TreePatternNode::dump() const {
   print(errs());
 }
 
 /// isIsomorphicTo - Return true if this node is recursively
 /// isomorphic to the specified node.  For this comparison, the node's
 /// entire state is considered. The assigned name is ignored, since
 /// nodes with differing names are considered isomorphic. However, if

 void TreePatternNode::RemoveAllTypes() {
   // Reset to unknown type.
   std::fill(Types.begin(), Types.end(), EEVT::TypeSet());
   if (isLeaf()) return;
   for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
     getChild(i)->RemoveAllTypes();
 }
 
-
 /// SubstituteFormalArguments - Replace the formal arguments in this tree
 /// with actual values specified by ArgMap.
 void TreePatternNode::
 SubstituteFormalArguments(std::map<std::string, TreePatternNode*> &ArgMap) {
   if (isLeaf()) return;
 
   for (unsigned i = 0, e = getNumChildren(); i != e; ++i) {
     TreePatternNode *Child = getChild(i);

         setChild(i, NewChild);
       }
     } else {
       getChild(i)->SubstituteFormalArguments(ArgMap);
     }
   }
 }
 
-
 /// InlinePatternFragments - If this pattern refers to any pattern
 /// fragments, inline them into place, giving us a pattern without any
 /// PatFrag references.
 TreePatternNode *TreePatternNode::InlinePatternFragments(TreePattern &TP) {
   if (TP.hasError())
     return nullptr;
 
   if (isLeaf())

 
   if (R->isSubClassOf("Operand"))
     return EEVT::TypeSet(getValueType(R->getValueAsDef("Type")));
 
   TP.error("Unknown node flavor used in pattern: " + R->getName());
   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::
 getIntrinsicInfo(const CodeGenDAGPatterns &CDP) const {
   if (getOperator() != CDP.get_intrinsic_void_sdnode() &&
       getOperator() != CDP.get_intrinsic_w_chain_sdnode() &&
       getOperator() != CDP.get_intrinsic_wo_chain_sdnode())
     return nullptr;

   }
 
   Record *Operator = getOperator();
   if (!Operator->isSubClassOf("SDNode")) return false;
 
   return CGP.getSDNodeInfo(Operator).hasProperty(Property);
 }
 
-
-
-
 /// TreeHasProperty - Return true if any node in this tree has the specified
 /// property.
 bool TreePatternNode::TreeHasProperty(SDNP Property,
                                       const CodeGenDAGPatterns &CGP) const {
   if (NodeHasProperty(Property, CGP))
     return true;
   for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
     if (getChild(i)->TreeHasProperty(Property, CGP))

   if (getNumChildren() != 1) {
     TP.error("Node transform '" + getOperator()->getName() +
              "' requires one operand!");
     return false;
   }
 
   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.
 #if 0
   if (!hasTypeSet() || !getChild(0)->hasTypeSet()) {
     bool MadeChange = UpdateNodeType(getChild(0)->getExtType(), TP);
     MadeChange |= getChild(0)->UpdateNodeType(getExtType(), TP);
     return MadeChange;
   }
 #endif
   return MadeChange;
 }
 
 /// OnlyOnRHSOfCommutative - Return true if this value is only allowed on the
 /// RHS of a commutative operation, not the on LHS.
 static bool OnlyOnRHSOfCommutative(TreePatternNode *N) {
   if (!N->isLeaf() && N->getOperator()->getName() == "imm")
     return true;
   if (N->isLeaf() && isa<IntInit>(N->getLeafValue()))
     return true;
   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
 /// that can never possibly work), and to prevent the pattern permuter from
 /// generating stuff that is useless.
 bool TreePatternNode::canPatternMatch(std::string &Reason,
                                       const CodeGenDAGPatterns &CDP) {
   if (isLeaf()) return true;

   // If this node is a commutative operator, check that the LHS isn't an
   // immediate.
   const SDNodeInfo &NodeInfo = CDP.getSDNodeInfo(getOperator());
   bool isCommIntrinsic = isCommutativeIntrinsic(CDP);
   if (NodeInfo.hasProperty(SDNPCommutative) || isCommIntrinsic) {
     // 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.
-      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!";
+      // First operand is intrinsic id.
+      unsigned FirstChild = isCommIntrinsic ? 1 : 0;
+      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!";
           return false;
         }
     }
   }
 
   return true;
 }
 

 void TreePattern::ComputeNamedNodes(TreePatternNode *N) {
   if (!N->getName().empty())
     NamedNodes[N->getName()].push_back(N);
 
   for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i)
     ComputeNamedNodes(N->getChild(i));
 }
 
-
 TreePatternNode *TreePattern::ParseTreePattern(Init *TheInit, StringRef OpName){
   if (DefInit *DI = dyn_cast<DefInit>(TheInit)) {
     Record *R = DI->getDef();
 
     // Direct reference to a leaf DagNode or PatFrag?  Turn it into a
     // TreePatternNode of its own.  For example:
     ///   (foo GPR, imm) -> (foo GPR, (imm))
     if (R->isSubClassOf("SDNode") || R->isSubClassOf("PatFrag"))

   for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i) {
     TreePatternNode *Child = N->getChild(i);
     MadeChange |= SimplifyTree(Child);
     N->setChild(i, Child);
   }
   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.
 bool TreePattern::
 InferAllTypes(const StringMap<SmallVector<TreePatternNode*,1> > *InNamedTypes) {
   if (NamedNodes.empty())
     ComputeNamedNodes();
 

 void CodeGenDAGPatterns::ParseComplexPatterns() {
   std::vector<Record*> AMs = Records.getAllDerivedDefinitions("ComplexPattern");
   while (!AMs.empty()) {
     ComplexPatterns.insert(std::make_pair(AMs.back(), AMs.back()));
     AMs.pop_back();
   }
 }
 
-
 /// 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
 /// inside a pattern fragment to a pattern fragment.
 ///
 void CodeGenDAGPatterns::ParsePatternFragments(bool OutFrags) {
   std::vector<Record*> Fragments = Records.getAllDerivedDefinitions("PatFrag");
 

 }
 
 //===----------------------------------------------------------------------===//
 // Instruction Analysis
 //===----------------------------------------------------------------------===//
 
 class InstAnalyzer {
   const CodeGenDAGPatterns &CDP;
+
 public:
   bool hasSideEffects;
   bool mayStore;
   bool mayLoad;
   bool isBitcast;
   bool isVariadic;
 
   InstAnalyzer(const CodeGenDAGPatterns &cdp)

       if (IntInfo->ModRef & CodeGenIntrinsic::MR_Mod)
         mayStore = true;// Intrinsics that can write to memory are 'mayStore'.
 
       if (IntInfo->ModRef >= CodeGenIntrinsic::ReadWriteMem)
         // ReadWriteMem intrinsics can have other strange effects.
         hasSideEffects = true;
     }
   }
-
 };
 
 static bool InferFromPattern(CodeGenInstruction &InstInfo,
                              const InstAnalyzer &PatInfo,
                              Record *PatDef) {
   bool Error = false;
 
   // Remember where InstInfo got its flags.

                                      SrcPattern,
                                      TheInst.getResultPattern(),
                                      TheInst.getImpResults(),
                                      Instr->getValueAsInt("AddedComplexity"),
                                      Instr->getID()));
   }
 }
 
-
 typedef std::pair<const TreePatternNode*, unsigned> NameRecord;
 
 static void FindNames(const TreePatternNode *P,
                       std::map<std::string, NameRecord> &Names,
                       TreePattern *PatternTop) {
   if (!P->getName().empty()) {
     NameRecord &Rec = Names[P->getName()];
     // If this is the first instance of the name, remember the node.

   for (const auto &Entry : SrcNames)
     if (DstNames[Entry.first].first == nullptr &&
         SrcNames[Entry.first].second == 1)
       Pattern->error("Pattern has dead named input: $" + Entry.first);
 
   PatternsToMatch.push_back(PTM);
 }
 
-
-
 void CodeGenDAGPatterns::InferInstructionFlags() {
   ArrayRef<const CodeGenInstruction*> Instructions =
     Target.getInstructionsByEnumValue();
 
   // First try to infer flags from the primary instruction pattern, if any.
   SmallVector<CodeGenInstruction*, 8> Revisit;
   unsigned Errors = 0;
   for (unsigned i = 0, e = Instructions.size(); i != e; ++i) {

       PrintError(InstInfo->TheDef->getLoc(),
                  "Can't infer mayStore from patterns");
     if (InstInfo->mayLoad_Unset)
       PrintError(InstInfo->TheDef->getLoc(),
                  "Can't infer mayLoad from patterns");
   }
 }
 
-
 /// Verify instruction flags against pattern node properties.
 void CodeGenDAGPatterns::VerifyInstructionFlags() {
   unsigned Errors = 0;
   for (ptm_iterator I = ptm_begin(), E = ptm_end(); I != E; ++I) {
     const PatternToMatch &PTM = *I;
     SmallVector<Record*, 8> Instrs;
     getInstructionsInTree(PTM.getDstPattern(), Instrs);
     if (Instrs.empty())

                                  CodeGenDAGPatterns &CDP,
                                  const MultipleUseVarSet &DepVars) {
   std::vector<std::vector<TreePatternNode*> > ChildVariants;
   ChildVariants.push_back(LHS);
   ChildVariants.push_back(RHS);
   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.
   if (!N->getName().empty() || !N->getPredicateFns().empty() ||
       N->getTransformFn()) {
     Children.push_back(N);
     return;
   }

         Variants.push_back(ChildVariants[i]);
       CombineChildVariants(N, Variants, OutVariants, CDP, DepVars);
     } else if (NC == 2)
       CombineChildVariants(N, ChildVariants[1], ChildVariants[0],
                            OutVariants, CDP, DepVars);
   }
 }
 
-
 // GenerateVariants - Generate variants.  For example, commutative patterns can
 // match multiple ways.  Add them to PatternsToMatch as well.
 void CodeGenDAGPatterns::GenerateVariants() {
   DEBUG(errs() << "Generating instruction variants.\n");
 
   // 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 aggressive matching without

utils/TableGen/CodeGenInstruction.cpp

 //===- CodeGenInstruction.cpp - CodeGen Instruction Class Wrapper ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the CodeGenInstruction class.
 //
 //===----------------------------------------------------------------------===//
 
 #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;
 
 //===----------------------------------------------------------------------===//
 // CGIOperandList Implementation
 //===----------------------------------------------------------------------===//
 
 CGIOperandList::CGIOperandList(Record *R) : TheDef(R) {
   isPredicable = false;

                       Twine(i) + " has the same name as a previous operand!");
 
     OperandList.emplace_back(Rec, ArgName, PrintMethod, EncoderMethod,
                              OperandNamespace + "::" + OperandType, MIOperandNo,
                              NumOps, MIOpInfo);
     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.
 ///
 unsigned CGIOperandList::getOperandNamed(StringRef Name) const {
   unsigned OpIdx;
   if (hasOperandNamed(Name, OpIdx)) return OpIdx;
   PrintFatalError("'" + TheDef->getName() +

       eidx = CStr.length();
 
     ParseConstraint(CStr.substr(bidx, eidx - bidx), Ops);
     bidx = CStr.find_first_not_of(delims, eidx);
   }
 }
 
 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;
     if (OpName.empty()) break;
 
     // Figure out which operand this is.
     std::pair<unsigned,unsigned> Op = ParseOperandName(OpName, false);
 
     // Mark the operand as not-to-be encoded.
     if (Op.second >= OperandList[Op.first].DoNotEncode.size())
       OperandList[Op.first].DoNotEncode.resize(Op.second+1);
     OperandList[Op.first].DoNotEncode[Op.second] = true;
   }
-
 }
 
 //===----------------------------------------------------------------------===//
 // CodeGenInstruction Implementation
 //===----------------------------------------------------------------------===//
 
 CodeGenInstruction::CodeGenInstruction(Record *R)
   : TheDef(R), Operands(R), InferredFrom(nullptr) {

   assert(FirstImplicitDef->isSubClassOf("Register"));
   const std::vector<MVT::SimpleValueType> &RegVTs =
     TargetInfo.getRegisterVTs(FirstImplicitDef);
   if (RegVTs.size() == 1)
     return RegVTs[0];
   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)
       if (Cur[VariantsStart] == '{' &&
           (VariantsStart == 0 || (Cur[VariantsStart-1] != '$' &&
                                   Cur[VariantsStart-1] != '\\')))
         break;
 

     assert(VariantsEnd != Cur.size() &&
            "Unterminated variants in assembly string!");
     Cur = Cur.substr(VariantsEnd + 1);
   }
 
   return Res;
 }
 
-
 //===----------------------------------------------------------------------===//
 /// CodeGenInstAlias Implementation
 //===----------------------------------------------------------------------===//
 
 /// tryAliasOpMatch - This is a helper function for the CodeGenInstAlias
 /// constructor.  It checks if an argument in an InstAlias pattern matches
 /// the corresponding operand of the instruction.  It returns true on a
 /// successful match, with ResOp set to the result operand to be used.

utils/TableGen/CodeGenRegisters.cpp

 // This file defines structures to encapsulate information gleaned from the
 // target register and register class definitions.
 //
 //===----------------------------------------------------------------------===//
 
 #include "CodeGenRegisters.h"
 #include "CodeGenTarget.h"
 #include "llvm/ADT/IntEqClasses.h"
-#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallPtrSet.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/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;
 
 #define DEBUG_TYPE "regalloc-emitter"
 
 //===----------------------------------------------------------------------===//
 //                             CodeGenSubRegIndex
 //===----------------------------------------------------------------------===//

 }
 
 const std::string &CodeGenRegister::getName() const {
   assert(TheDef && "no def");
   return TheDef->getName();
 }
 
 namespace {
+
 // Iterate over all register units in a set of registers.
 class RegUnitIterator {
   CodeGenRegister::Vec::const_iterator RegI, RegE;
   CodeGenRegister::RegUnitList::iterator UnitI, UnitE;
 
 public:
   RegUnitIterator(const CodeGenRegister::Vec &Regs):
     RegI(Regs.begin()), RegE(Regs.end()), UnitI(), UnitE() {

     while (UnitI == UnitE) {
       if (++RegI == RegE)
         break;
       UnitI = (*RegI)->getRegUnits().begin();
       UnitE = (*RegI)->getRegUnits().end();
     }
   }
 };
-} // namespace
+
+} // end anonymous namespace
 
 // Return true of this unit appears in RegUnits.
 static bool hasRegUnit(CodeGenRegister::RegUnitList &RegUnits, unsigned Unit) {
   return RegUnits.test(Unit);
 }
 
 // Inherit register units from subregisters.
 // Return true if the RegUnits changed.

 //===----------------------------------------------------------------------===//
 //                               RegisterTuples
 //===----------------------------------------------------------------------===//
 
 // A RegisterTuples def is used to generate pseudo-registers from lists of
 // 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");
     unsigned Dim = Indices.size();
     ListInit *SubRegs = Def->getValueAsListInit("SubRegs");
     if (Dim != SubRegs->size())
       PrintFatalError(Def->getLoc(), "SubRegIndices and SubRegs size mismatch");
     if (Dim < 2)

         }
 
         // Everything else is copied from Proto.
         NewReg->addValue(RV);
       }
     }
   }
 };
-}
+
+} // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 //                            CodeGenRegisterClass
 //===----------------------------------------------------------------------===//
 
 static void sortAndUniqueRegisters(CodeGenRegister::Vec &M) {
   std::sort(M.begin(), M.end(), deref<llvm::less>());
   M.erase(std::unique(M.begin(), M.end(), deref<llvm::equal>()), M.end());

 }
 
 bool CodeGenRegisterClass::contains(const CodeGenRegister *Reg) const {
   return std::binary_search(Members.begin(), Members.end(), Reg,
                             deref<llvm::less>());
 }
 
 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::
 operator<(const CodeGenRegisterClass::Key &B) const {
   assert(Members && B.Members);
   return std::tie(*Members, SpillSize, SpillAlignment) <
          std::tie(*B.Members, B.SpillSize, B.SpillAlignment);

 /// Register classes with the same registers, spill size, and alignment form a
 /// clique.  They will be ordered alphabetically.
 ///
 static bool TopoOrderRC(const CodeGenRegisterClass &PA,
                         const CodeGenRegisterClass &PB) {
   auto *A = &PA;
   auto *B = &PB;
   if (A == B)
-    return 0;
+    return false;
 
   // Order by ascending spill size.
   if (A->SpillSize < B->SpillSize)
     return true;
   if (A->SpillSize > B->SpillSize)
     return false;
 
   // Order by ascending spill alignment.

     if (LaneMask == 0)
       LaneMask = 1;
 
     RegClass.LaneMask = LaneMask;
   }
 }
 
 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
 // consider overlapping register classes to be connected, then each UberRegSet
 // is a set of connected components.
 //
 // An UberRegSet will likely be a horizontal slice of register names of
 // the same width. Nontrivial subregisters should then be in a separate
 // UberRegSet. But this property isn't required for valid computation of
 // register unit weights.
 //
 // A Weight field caches the max per-register unit weight in each UberRegSet.
 //
 // A set of SingularDeterminants flags single units of some register in this set
 // for which the unit weight equals the set weight. These units should not have
 // their weight increased.
 struct UberRegSet {
   CodeGenRegister::Vec Regs;
   unsigned Weight;
   CodeGenRegister::RegUnitList SingularDeterminants;
 
   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.
 //
 // UberRegSets[0] is a special non-allocatable set.
 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.
   assert(Registers.size() == Registers.back().EnumValue &&
          "register enum value mismatch");
 
   // For simplicitly make the SetID the same as EnumValue.
   IntEqClasses UberSetIDs(Registers.size()+1);

     // Iterate through SubRegisters.
     typedef CodeGenRegister::SubRegMap SubRegMap;
     const SubRegMap &SubRegs = Register.getSubRegs();
     for (SubRegMap::const_iterator S = SubRegs.begin(),
          SE = SubRegs.end(); S != SE; ++S) {
       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;
       unsigned LaneMask = SubRegIndex->LaneMask;
       // Distribute LaneMask to Register Units touched.
       for (unsigned SUI : SubRegister->getRegUnits()) {
         bool Found = false;
         unsigned u = 0;

       // class.
       getOrCreateSubClass(RC, &SubSetVec, RC->getName() + "_with_" +
                                           SubIdx.getName() + "_in_" +
                                           SubRC.getName());
     }
   }
 }
 
-
 //
 // Infer missing register classes.
 //
 void CodeGenRegBank::computeInferredRegisterClasses() {
   assert(!RegClasses.empty());
   // When this function is called, the register classes have not been sorted
   // and assigned EnumValues yet.  That means getSubClasses(),
   // getSuperClasses(), and hasSubClass() functions are defunct.

utils/TableGen/DAGISelMatcherOpt.cpp

 //===- DAGISelMatcherOpt.cpp - Optimize a DAG Matcher ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the DAG Matcher optimizer.
 //
 //===----------------------------------------------------------------------===//
 
 #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"
 
 /// ContractNodes - Turn multiple matcher node patterns like 'MoveChild+Record'
 /// into single compound nodes like RecordChild.
 static void ContractNodes(std::unique_ptr<Matcher> &MatcherPtr,
                           const CodeGenDAGPatterns &CGP) {

       //
       // NOTE: Strictly speaking, we don't have to check for glue here
       // because the code in the pattern generator doesn't handle it right.  We
       // do it anyway for thoroughness.
       if (!EN->hasOutFlag() &&
           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.
 #if 0
       if ((EN->hasGlue() || EN->hasChain()) &&
           EN->getNumNonChainGlueVTs() > ... need to get no results reliably ...)
         ResultMatch = false;
 #endif

 /// matcher.
 static Matcher *FindNodeWithKind(Matcher *M, Matcher::KindTy Kind) {
   for (; M; M = M->getNext())
     if (M->getKind() == Kind)
       return M;
   return nullptr;
 }
 
-
 /// FactorNodes - Turn matches like this:
 ///   Scope
 ///     OPC_CheckType i32
 ///       ABC
 ///     OPC_CheckType i32
 ///       XYZ
 /// into:
 ///   OPC_CheckType i32

     while (OptionIdx != e && OptionsToMatch[OptionIdx]->isEqual(Optn))
       EqualMatchers.push_back(OptionsToMatch[OptionIdx++]);
 
     // If we found a non-equal matcher, see if it is contradictory with the
     // current node.  If so, we know that the ordering relation between the
     // 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;
       
       Matcher *ScanMatcher = OptionsToMatch[Scan];
       
       // If we found an entry that matches out matcher, merge it into the set to
       // handle.
       if (Optn->isEqual(ScanMatcher)) {

       MatcherPtr.reset(new SwitchTypeMatcher(Cases));
     } else {
       // If we factored and ended up with one case, create it now.
       MatcherPtr.reset(new CheckTypeMatcher(Cases[0].first, 0));
       MatcherPtr->setNext(Cases[0].second);
     }
     return;
   }
-  
 
   // Reassemble the Scope node with the adjusted children.
   Scope->setNumChildren(NewOptionsToMatch.size());
   for (unsigned i = 0, e = NewOptionsToMatch.size(); i != e; ++i)
     Scope->resetChild(i, NewOptionsToMatch[i]);
 }
 
 void
 llvm::OptimizeMatcher(std::unique_ptr<Matcher> &MatcherPtr,
                       const CodeGenDAGPatterns &CGP) {
   ContractNodes(MatcherPtr, CGP);
   FactorNodes(MatcherPtr);
 }