Subzero: Use a "known" version of clang-format.

crosstest/test_bitmanip_main.cpp

 //===- subzero/crosstest/test_bitmanip_main.cpp - Driver for tests. -------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Driver for cross testing bit manipulation intrinsics.
@@ skipping 46 matching lines @@
 const static size_t NumValues = sizeof(Values) / sizeof(*Values);
 
 template <typename Type>
 void testBitManip(size_t &TotalTests, size_t &Passes, size_t &Failures) {
   typedef Type (*FuncType)(Type);
   static struct {
     const char *Name;
     FuncType FuncLlc;
     FuncType FuncSz;
   } Funcs[] = {
-#define X(inst)                                                             \
-  {                                                                         \
-    STR(inst), test_##inst, Subzero_::test_##inst                           \
-  },                                                                        \
-  {                                                                         \
-    STR(inst) "_alloca", test_alloca_##inst, Subzero_::test_alloca_##inst   \
-  },                                                                        \
-  {                                                                         \
-    STR(inst) "_const", test_const_##inst, Subzero_::test_const_##inst      \
-  },
-      BMI_OPS
+#define X(inst)                                                                \
+  { STR(inst), test_##inst, Subzero_::test_##inst }                            \
+  , {STR(inst) "_alloca", test_alloca_##inst, Subzero_::test_alloca_##inst},   \
+      {STR(inst) "_const", test_const_##inst, Subzero_::test_const_##inst},
+        BMI_OPS
 #undef X
-  };
+    };
   const static size_t NumFuncs = sizeof(Funcs) / sizeof(*Funcs);
 
   for (size_t f = 0; f < NumFuncs; ++f) {
     for (size_t i = 0; i < NumValues; ++i) {
       Type Value = static_cast<Type>(Values[i]);
       ++TotalTests;
       Type ResultSz = Funcs[f].FuncSz(Value);
       Type ResultLlc = Funcs[f].FuncLlc(Value);
       if (ResultSz == ResultLlc) {
         ++Passes;
       } else {
         ++Failures;
-        std::cout << "test_" << Funcs[f].Name
-                  << (CHAR_BIT * sizeof(Type)) << "("
-                  << static_cast<uint64_t>(Value)
+        std::cout << "test_" << Funcs[f].Name << (CHAR_BIT * sizeof(Type))
+                  << "(" << static_cast<uint64_t>(Value)
                   << "): sz=" << static_cast<uint64_t>(ResultSz)
-                  << " llc=" << static_cast<uint64_t>(ResultLlc)
-                  << "\n";
+                  << " llc=" << static_cast<uint64_t>(ResultLlc) << "\n";
       }
     }
   }
 }
 
 template <typename Type>
 void testByteSwap(size_t &TotalTests, size_t &Passes, size_t &Failures) {
   typedef Type (*FuncType)(Type);
   static struct {
     const char *Name;
@@ skipping 30 matching lines @@
   testBitManip<uint32_t>(TotalTests, Passes, Failures);
   testBitManip<uint64_t>(TotalTests, Passes, Failures);
   testByteSwap<uint16_t>(TotalTests, Passes, Failures);
   testByteSwap<uint32_t>(TotalTests, Passes, Failures);
   testByteSwap<uint64_t>(TotalTests, Passes, Failures);
 
   std::cout << "TotalTests=" << TotalTests << " Passes=" << Passes
             << " Failures=" << Failures << "\n";
   return Failures;
 }