Subzero: Rerun clang-format after LLVM 3.6 merge.

crosstest/test_bitmanip_main.cpp

@@ -28,31 +28,18 @@ namespace Subzero_ {
 }
 
 volatile uint64_t Values[] = {
-    0,                              1,
-    0x7e,                           0x7f,
-    0x80,                           0x81,
-    0xfe,                           0xff,
-    0x7ffe,                         0x7fff,
-    0x8000,                         0x8001,
-    0xfffe,                         0xffff,
-    0xc0de,                         0xabcd,
-    0xdcba,                         0x007fffff /*Max subnormal + */,
-    0x00800000 /*Min+ */,           0x7f7fffff /*Max+ */,
-    0x7f800000 /*+Inf*/,            0xff800000 /*-Inf*/,
-    0x7fa00000 /*SNaN*/,            0x7fc00000 /*QNaN*/,
-    0x7ffffffe,                     0x7fffffff,
-    0x80000000,                     0x80000001,
-    0xfffffffe,                     0xffffffff,
-    0x12345678,                     0xabcd1234,
-    0x1234dcba,                     0x100000000ll,
-    0x100000001ll,                  0x123456789abcdef1ll,
+    0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, 0x8000, 0x8001,
+    0xfffe, 0xffff, 0xc0de, 0xabcd, 0xdcba, 0x007fffff /*Max subnormal + */,
+    0x00800000 /*Min+ */, 0x7f7fffff /*Max+ */, 0x7f800000 /*+Inf*/,
+    0xff800000 /*-Inf*/, 0x7fa00000 /*SNaN*/, 0x7fc00000 /*QNaN*/, 0x7ffffffe,
+    0x7fffffff, 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff, 0x12345678,
+    0xabcd1234, 0x1234dcba, 0x100000000ll, 0x100000001ll, 0x123456789abcdef1ll,
     0x987654321ab1fedcll, 0x000fffffffffffffll /*Max subnormal + */,
     0x0010000000000000ll /*Min+ */, 0x7fefffffffffffffll /*Max+ */,
     0x7ff0000000000000ll /*+Inf*/, 0xfff0000000000000ll /*-Inf*/,
     0x7ff0000000000001ll /*SNaN*/, 0x7ff8000000000000ll /*QNaN*/,
-    0x7ffffffffffffffell,           0x7fffffffffffffffll,
-    0x8000000000000000ll,           0x8000000000000001ll,
-    0xfffffffffffffffell,           0xffffffffffffffffll};
+    0x7ffffffffffffffell, 0x7fffffffffffffffll, 0x8000000000000000ll,
+    0x8000000000000001ll, 0xfffffffffffffffell, 0xffffffffffffffffll};
 
 const static size_t NumValues = sizeof(Values) / sizeof(*Values);
 

crosstest/test_cast_main.cpp

@@ -148,29 +148,19 @@ int main(int argc, char **argv) {
   static const size_t NumValsSi32 = sizeof(ValsSi32) / sizeof(*ValsSi32);
 
   volatile uint64_t ValsUi64[] = {
-      0,                     1,                     0x7e,
-      0x7f,                  0x80,                  0x81,
-      0xfe,                  0xff,                  0x7ffe,
-      0x7fff,                0x8000,                0x8001,
-      0xfffe,                0xffff,                0x7ffffffe,
-      0x7fffffff,            0x80000000,            0x80000001,
-      0xfffffffe,            0xffffffff,            0x100000000ull,
-      0x100000001ull,        0x7ffffffffffffffeull, 0x7fffffffffffffffull,
-      0x8000000000000000ull, 0x8000000000000001ull, 0xfffffffffffffffeull,
-      0xffffffffffffffffull};
+      0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, 0x8000, 0x8001,
+      0xfffe, 0xffff, 0x7ffffffe, 0x7fffffff, 0x80000000, 0x80000001,
+      0xfffffffe, 0xffffffff, 0x100000000ull, 0x100000001ull,
+      0x7ffffffffffffffeull, 0x7fffffffffffffffull, 0x8000000000000000ull,
+      0x8000000000000001ull, 0xfffffffffffffffeull, 0xffffffffffffffffull};
   static const size_t NumValsUi64 = sizeof(ValsUi64) / sizeof(*ValsUi64);
 
   volatile int64_t ValsSi64[] = {
-      0,                    1,                    0x7e,
-      0x7f,                 0x80,                 0x81,
-      0xfe,                 0xff,                 0x7ffe,
-      0x7fff,               0x8000,               0x8001,
-      0xfffe,               0xffff,               0x7ffffffe,
-      0x7fffffff,           0x80000000,           0x80000001,
-      0xfffffffe,           0xffffffff,           0x100000000ll,
-      0x100000001ll,        0x7ffffffffffffffell, 0x7fffffffffffffffll,
-      0x8000000000000000ll, 0x8000000000000001ll, 0xfffffffffffffffell,
-      0xffffffffffffffffll};
+      0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, 0x8000, 0x8001,
+      0xfffe, 0xffff, 0x7ffffffe, 0x7fffffff, 0x80000000, 0x80000001,
+      0xfffffffe, 0xffffffff, 0x100000000ll, 0x100000001ll,
+      0x7ffffffffffffffell, 0x7fffffffffffffffll, 0x8000000000000000ll,
+      0x8000000000000001ll, 0xfffffffffffffffell, 0xffffffffffffffffll};
   static const size_t NumValsSi64 = sizeof(ValsSi64) / sizeof(*ValsSi64);
 
   static const double NegInf = -1.0 / 0.0;

crosstest/test_icmp_main.cpp

@@ -54,8 +54,8 @@ void testsInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
 #undef X
 #define X(cmp, op)                                                             \
   {                                                                            \
-    STR(cmp), (FuncTypeUnsigned)(FuncTypeSigned) icmp##cmp,                    \
-        (FuncTypeUnsigned)(FuncTypeSigned) Subzero_::icmp##cmp                 \
+    STR(cmp), (FuncTypeUnsigned)(FuncTypeSigned)icmp##cmp,                     \
+        (FuncTypeUnsigned)(FuncTypeSigned)Subzero_::icmp##cmp                  \
   }                                                                            \
   ,
           ICMP_S_TABLE
@@ -141,8 +141,8 @@ void testsVecInt(size_t &TotalTests, size_t &Passes, size_t &Failures) {
 #undef X
 #define X(cmp, op)                                                             \
   {                                                                            \
-    STR(cmp), (FuncTypeUnsigned)(FuncTypeSigned) icmp##cmp,                    \
-        (FuncTypeUnsigned)(FuncTypeSigned) Subzero_::icmp##cmp                 \
+    STR(cmp), (FuncTypeUnsigned)(FuncTypeSigned)icmp##cmp,                     \
+        (FuncTypeUnsigned)(FuncTypeSigned)Subzero_::icmp##cmp                  \
   }                                                                            \
   ,
           ICMP_S_TABLE

crosstest/test_sync_atomic_main.cpp

@@ -33,27 +33,17 @@ namespace Subzero_ {
 }
 
 volatile uint64_t Values[] = {
-    0,                               1,
-    0x7e,                            0x7f,
-    0x80,                            0x81,
-    0xfe,                            0xff,
-    0x7ffe,                          0x7fff,
-    0x8000,                          0x8001,
-    0xfffe,                          0xffff,
-    0x007fffff /*Max subnormal + */, 0x00800000 /*Min+ */,
-    0x7f7fffff /*Max+ */,            0x7f800000 /*+Inf*/,
-    0xff800000 /*-Inf*/,             0x7fa00000 /*SNaN*/,
-    0x7fc00000 /*QNaN*/,             0x7ffffffe,
-    0x7fffffff,                      0x80000000,
-    0x80000001,                      0xfffffffe,
-    0xffffffff,                      0x100000000ll,
+    0, 1, 0x7e, 0x7f, 0x80, 0x81, 0xfe, 0xff, 0x7ffe, 0x7fff, 0x8000, 0x8001,
+    0xfffe, 0xffff, 0x007fffff /*Max subnormal + */, 0x00800000 /*Min+ */,
+    0x7f7fffff /*Max+ */, 0x7f800000 /*+Inf*/, 0xff800000 /*-Inf*/,
+    0x7fa00000 /*SNaN*/, 0x7fc00000 /*QNaN*/, 0x7ffffffe, 0x7fffffff,
+    0x80000000, 0x80000001, 0xfffffffe, 0xffffffff, 0x100000000ll,
     0x100000001ll, 0x000fffffffffffffll /*Max subnormal + */,
     0x0010000000000000ll /*Min+ */, 0x7fefffffffffffffll /*Max+ */,
     0x7ff0000000000000ll /*+Inf*/, 0xfff0000000000000ll /*-Inf*/,
     0x7ff0000000000001ll /*SNaN*/, 0x7ff8000000000000ll /*QNaN*/,
-    0x7ffffffffffffffell,            0x7fffffffffffffffll,
-    0x8000000000000000ll,            0x8000000000000001ll,
-    0xfffffffffffffffell,            0xffffffffffffffffll};
+    0x7ffffffffffffffell, 0x7fffffffffffffffll, 0x8000000000000000ll,
+    0x8000000000000001ll, 0xfffffffffffffffell, 0xffffffffffffffffll};
 
 const static size_t NumValues = sizeof(Values) / sizeof(*Values);
 

src/IceInstX8632.cpp

@@ -1256,8 +1256,8 @@ void emitVariableBlendInst(const char *Opcode, const Inst *Inst,
   Inst->getDest()->emit(Func);
 }
 
-void
-emitIASVariableBlendInst(const Inst *Inst, const Cfg *Func,
+void emitIASVariableBlendInst(
+    const Inst *Inst, const Cfg *Func,
     const x86::AssemblerX86::XmmEmitterRegOp &Emitter) {
   assert(Inst->getSrcSize() == 3);
   assert(llvm::cast<Variable>(Inst->getSrc(2))->getRegNum() ==

src/IceIntrinsics.cpp

@@ -61,9 +61,7 @@ const struct IceIntrinsicsEntry_ {
       {IceType_void, IceType_i32},
       2},
      "nacl.atomic.fence"},
-      {{INTRIN(AtomicFenceAll, SideEffects_T, ReturnsTwice_F),
-        {IceType_void},
-        1},
+    {{INTRIN(AtomicFenceAll, SideEffects_T, ReturnsTwice_F), {IceType_void}, 1},
      "nacl.atomic.fence.all"},
     {{INTRIN(AtomicIsLockFree, SideEffects_F, ReturnsTwice_F),
       {IceType_i1, IceType_i32, IceType_i32},
@@ -202,8 +200,7 @@ const struct IceIntrinsicsEntry_ {
       {IceType_void, IceType_i32},
       2},
      "stackrestore"},
-      {{INTRIN(Trap, SideEffects_T, ReturnsTwice_F), {IceType_void}, 1},
-       "trap"}};
+    {{INTRIN(Trap, SideEffects_T, ReturnsTwice_F), {IceType_void}, 1}, "trap"}};
 const size_t IceIntrinsicsTableSize = llvm::array_lengthof(IceIntrinsicsTable);
 
 #undef INTRIN

src/IceTargetLoweringX8632.cpp

@@ -4120,8 +4120,8 @@ void TargetX8632::scalarizeArithmetic(InstArithmetic::OpKind Kind,
 // We can eliminate the sext operation by copying the result of pcmpeqd,
 // pcmpgtd, or cmpps (which produce sign extended results) to the result
 // of the sext operation.
-void
-TargetX8632::eliminateNextVectorSextInstruction(Variable *SignExtendedResult) {
+void TargetX8632::eliminateNextVectorSextInstruction(
+    Variable *SignExtendedResult) {
   if (InstCast *NextCast =
           llvm::dyn_cast_or_null<InstCast>(Context.getNextInst())) {
     if (NextCast->getCastKind() == InstCast::Sext &&

src/main.cpp

@@ -386,9 +386,8 @@ int main(int argc, char **argv) {
     SMDiagnostic Err;
     Ice::TimerMarker T1(Ice::TimerStack::TT_parse, &Ctx);
     raw_ostream *Verbose = LLVMVerboseErrors ? &errs() : nullptr;
-    std::unique_ptr<Module> Mod =
-        NaClParseIRFile(IRFilename, InputFileFormat, Err, Verbose,
-                        getGlobalContext());
+    std::unique_ptr<Module> Mod = NaClParseIRFile(
+        IRFilename, InputFileFormat, Err, Verbose, getGlobalContext());
     if (!Mod) {
       Err.print(argv[0], errs());
       return GetReturnValue(Ice::EC_Bitcode);