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

src/IceInstX8632.h

 //===- subzero/src/IceInstX8632.h - Low-level x86 instructions --*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the InstX8632 and OperandX8632 classes and
@@ skipping 16 matching lines @@
 
 class TargetX8632;
 
 // OperandX8632 extends the Operand hierarchy.  Its subclasses are
 // OperandX8632Mem and VariableSplit.
 class OperandX8632 : public Operand {
   OperandX8632(const OperandX8632 &) = delete;
   OperandX8632 &operator=(const OperandX8632 &) = delete;
 
 public:
-  enum OperandKindX8632 {
-    k__Start = Operand::kTarget,
-    kMem,
-    kSplit
-  };
+  enum OperandKindX8632 { k__Start = Operand::kTarget, kMem, kSplit };
   using Operand::dump;
   void dump(const Cfg *, Ostream &Str) const override {
     if (ALLOW_DUMP)
       Str << "<OperandX8632>";
   }
 
 protected:
   OperandX8632(OperandKindX8632 Kind, Type Ty)
       : Operand(static_cast<OperandKind>(Kind), Ty) {}
   ~OperandX8632() override {}
@@ skipping 51 matching lines @@
 // of i32 locations (Low and High).  This is needed for some cases
 // of the Bitcast instruction.  Since it's not possible for integer
 // registers to access the XMM registers and vice versa, the
 // lowering forces the f64 to be spilled to the stack and then
 // accesses through the VariableSplit.
 class VariableSplit : public OperandX8632 {
   VariableSplit(const VariableSplit &) = delete;
   VariableSplit &operator=(const VariableSplit &) = delete;
 
 public:
-  enum Portion {
-    Low,
-    High
-  };
+  enum Portion { Low, High };
   static VariableSplit *create(Cfg *Func, Variable *Var, Portion Part) {
     return new (Func->allocate<VariableSplit>()) VariableSplit(Func, Var, Part);
   }
   int32_t getOffset() const { return Part == High ? 4 : 0; }
 
   x86::Address toAsmAddress(const Cfg *Func) const;
   void emit(const Cfg *Func) const override;
   using OperandX8632::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
@@ skipping 1330 matching lines @@
   InstX8632Pop(Cfg *Func, Variable *Dest);
   ~InstX8632Pop() override {}
 };
 
 class InstX8632Push : public InstX8632 {
   InstX8632Push(const InstX8632Push &) = delete;
   InstX8632Push &operator=(const InstX8632Push &) = delete;
 
 public:
   static InstX8632Push *create(Cfg *Func, Variable *Source) {
-    return new (Func->allocate<InstX8632Push>())
-        InstX8632Push(Func, Source);
+    return new (Func->allocate<InstX8632Push>()) InstX8632Push(Func, Source);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Push); }
 
 private:
   InstX8632Push(Cfg *Func, Variable *Source);
   ~InstX8632Push() override {}
 };
@@ skipping 111 matching lines @@
 template <> void InstX8632Pinsr::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movsx::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Movzx::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pmull::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Pshufd::emitIAS(const Cfg *Func) const;
 template <> void InstX8632Shufps::emitIAS(const Cfg *Func) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTX8632_H