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

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- 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 Operand class and its target-independent
@@ skipping 70 matching lines @@
   Operand(OperandKind Kind, Type Ty)
       : Ty(Ty), Kind(Kind), NumVars(0), Vars(nullptr) {}
 
   const Type Ty;
   const OperandKind Kind;
   // Vars and NumVars are initialized by the derived class.
   SizeT NumVars;
   Variable **Vars;
 };
 
-template<class StreamType>
+template <class StreamType>
 inline StreamType &operator<<(StreamType &Str, const Operand &Op) {
   Op.dump(Str);
   return Str;
 }
 
 // Constant is the abstract base class for constants.  All
 // constants are allocated from a global arena and are pooled.
 class Constant : public Operand {
   Constant(const Constant &) = delete;
   Constant &operator=(const Constant &) = delete;
@@ skipping 61 matching lines @@
       : Constant(K, Ty, PoolEntryID), Value(Value) {}
   ~ConstantPrimitive() override {}
   const PrimType Value;
 };
 
 typedef ConstantPrimitive<int32_t, Operand::kConstInteger32> ConstantInteger32;
 typedef ConstantPrimitive<int64_t, Operand::kConstInteger64> ConstantInteger64;
 typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
 typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
 
-template <> inline void ConstantInteger32::dump(const Cfg *, Ostream &Str) const {
+template <>
+inline void ConstantInteger32::dump(const Cfg *, Ostream &Str) const {
   if (!ALLOW_DUMP)
     return;
   if (getType() == IceType_i1)
     Str << (getValue() ? "true" : "false");
   else
     Str << static_cast<int32_t>(getValue());
 }
 
-template <> inline void ConstantInteger64::dump(const Cfg *, Ostream &Str) const {
+template <>
+inline void ConstantInteger64::dump(const Cfg *, Ostream &Str) const {
   if (!ALLOW_DUMP)
     return;
   assert(getType() == IceType_i64);
   Str << static_cast<int64_t>(getValue());
 }
 
 // RelocatableTuple bundles the parameters that are used to
 // construct an ConstantRelocatable.  It is done this way so that
 // ConstantRelocatable can fit into the global constant pool
 // template mechanism.
@@ skipping 44 matching lines @@
     return Kind == kConstRelocatable;
   }
 
 private:
   ConstantRelocatable(Type Ty, RelocOffsetT Offset, const IceString &Name,
                       bool SuppressMangling, uint32_t PoolEntryID)
       : Constant(kConstRelocatable, Ty, PoolEntryID), Offset(Offset),
         Name(Name), SuppressMangling(SuppressMangling) {}
   ~ConstantRelocatable() override {}
   const RelocOffsetT Offset; // fixed offset to add
-  const IceString Name; // optional for debug/dump
+  const IceString Name;      // optional for debug/dump
   bool SuppressMangling;
 };
 
 // ConstantUndef represents an unspecified bit pattern. Although it is
 // legal to lower ConstantUndef to any value, backends should try to
 // make code generation deterministic by lowering ConstantUndefs to 0.
 class ConstantUndef : public Constant {
   ConstantUndef(const ConstantUndef &) = delete;
   ConstantUndef &operator=(const ConstantUndef &) = delete;
 
@@ skipping 95 matching lines @@
 
   RegWeight getWeight() const { return Weight; }
   void setWeight(const RegWeight &NewWeight) { Weight = NewWeight; }
   void addWeight(uint32_t Delta) { Weight.addWeight(Delta); }
   void dump(Ostream &Str) const;
 
 private:
   typedef std::pair<InstNumberT, InstNumberT> RangeElementType;
   // RangeType is arena-allocated from the Cfg's allocator.
   typedef std::vector<RangeElementType, CfgLocalAllocator<RangeElementType>>
-  RangeType;
+      RangeType;
   RangeType Range;
   RegWeight Weight;
   // TrimmedBegin is an optimization for the overlaps() computation.
   // Since the linear-scan algorithm always calls it as overlaps(Cur)
   // and Cur advances monotonically according to live range start, we
   // can optimize overlaps() by ignoring all segments that end before
   // the start of Cur's range.  The linear-scan code enables this by
   // calling trim() on the ranges of interest as Cur advances.  Note
   // that linear-scan also has to initialize TrimmedBegin at the
   // beginning by calling untrim().
@@ skipping 159 matching lines @@
   VariableTracking &operator=(const VariableTracking &) = delete;
 
 public:
   enum MultiDefState {
     // TODO(stichnot): Consider using just a simple counter.
     MDS_Unknown,
     MDS_SingleDef,
     MDS_MultiDefSingleBlock,
     MDS_MultiDefMultiBlock
   };
-  enum MultiBlockState {
-    MBS_Unknown,
-    MBS_SingleBlock,
-    MBS_MultiBlock
-  };
+  enum MultiBlockState { MBS_Unknown, MBS_SingleBlock, MBS_MultiBlock };
   VariableTracking()
       : MultiDef(MDS_Unknown), MultiBlock(MBS_Unknown), SingleUseNode(nullptr),
         SingleDefNode(nullptr), FirstOrSingleDefinition(nullptr) {}
   VariableTracking(const VariableTracking &) = default;
   MultiDefState getMultiDef() const { return MultiDef; }
   MultiBlockState getMultiBlock() const { return MultiBlock; }
   const Inst *getFirstDefinition() const;
   const Inst *getSingleDefinition() const;
   const InstDefList &getLatterDefinitions() const { return Definitions; }
   const CfgNode *getNode() const { return SingleUseNode; }
@@ skipping 67 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H