Subzero: Use C++11 member initializers where practical.

src/IceThreading.h

 //===- subzero/src/IceThreading.h - Threading functions ---------*- 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 threading-related functions.
@@ skipping 37 matching lines @@
 // and Back fields.  Front==Back indicates an empty queue.
 template <typename T, size_t MaxStaticSize = 128>
 class BoundedProducerConsumerQueue {
   BoundedProducerConsumerQueue() = delete;
   BoundedProducerConsumerQueue(const BoundedProducerConsumerQueue &) = delete;
   BoundedProducerConsumerQueue &
   operator=(const BoundedProducerConsumerQueue &) = delete;
 
 public:
   BoundedProducerConsumerQueue(bool Sequential, size_t MaxSize = MaxStaticSize)
-      : Back(0), Front(0), MaxSize(std::min(MaxSize, MaxStaticSize)),
-        Sequential(Sequential), IsEnded(false) {}
+      : MaxSize(std::min(MaxSize, MaxStaticSize)), Sequential(Sequential) {}
   void blockingPush(T *Item) {
     {
       std::unique_lock<GlobalLockType> L(Lock);
       // If the work queue is already "full", wait for a consumer to
       // grab an element and shrink the queue.
       Shrunk.wait(L, [this] { return size() < MaxSize || Sequential; });
       push(Item);
     }
     GrewOrEnded.notify_one();
   }
@@ skipping 35 matching lines @@
   ICE_CACHELINE_BOUNDARY;
   // GrewOrEnded is written by the producers and read by the
   // consumers.  It is notified (by the producer) when something is
   // added to the queue, in case consumers are waiting for a non-empty
   // queue.
   std::condition_variable GrewOrEnded;
   // Back is the index into WorkItems[] of where the next element will
   // be pushed.  (More precisely, Back&MaxStaticSize is the index.)
   // It is written by the producers, and read by all via size() and
   // empty().
-  size_t Back;
+  size_t Back = 0;
 
   ICE_CACHELINE_BOUNDARY;
   // Shrunk is notified (by the consumer) when something is removed
   // from the queue, in case a producer is waiting for the queue to
   // drop below maximum capacity.  It is written by the consumers and
   // read by the producers.
   std::condition_variable Shrunk;
   // Front is the index into WorkItems[] of the oldest element,
   // i.e. the next to be popped.  (More precisely Front&MaxStaticSize
   // is the index.)  It is written by the consumers, and read by all
   // via size() and empty().
-  size_t Front;
+  size_t Front = 0;
 
   ICE_CACHELINE_BOUNDARY;
 
   // MaxSize and Sequential are read by all and written by none.
   const size_t MaxSize;
   const bool Sequential;
   // IsEnded is read by the consumers, and only written once by the
   // producer.
-  bool IsEnded;
+  bool IsEnded = false;
 
   // The lock must be held when the following methods are called.
   bool empty() const { return Front == Back; }
   size_t size() const { return Back - Front; }
   void push(T *Item) {
     WorkItems[Back++ & MaxStaticSizeMask] = Item;
     assert(size() <= MaxStaticSize);
   }
   T *pop() {
     assert(!empty());
@@ skipping 52 matching lines @@
   const uint32_t Sequence;
   const ItemKind Kind;
   std::unique_ptr<VariableDeclarationList> GlobalInits;
   std::unique_ptr<Assembler> Function;
   std::unique_ptr<Cfg> RawFunc;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETHREADING_H