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

src/IceAssemblerX8632.h

 //===- subzero/src/assembler_ia32.h - Assembler for x86-32 ------*- C++ -*-===//
 //
 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===----------------------------------------------------------------------===//
 //
@@ skipping 30 matching lines @@
 
 const int MAX_NOP_SIZE = 8;
 
 enum ScaleFactor { TIMES_1 = 0, TIMES_2 = 1, TIMES_4 = 2, TIMES_8 = 3 };
 
 class Immediate {
   Immediate(const Immediate &) = delete;
   Immediate &operator=(const Immediate &) = delete;
 
 public:
-  explicit Immediate(int32_t value) : value_(value), fixup_(nullptr) {}
+  explicit Immediate(int32_t value) : value_(value) {}
 
   Immediate(RelocOffsetT offset, AssemblerFixup *fixup)
       : value_(offset), fixup_(fixup) {
     // Use the Offset in the "value" for now. If we decide to process fixups,
     // we'll need to patch that offset with the true value.
   }
 
   int32_t value() const { return value_; }
   AssemblerFixup *fixup() const { return fixup_; }
 
   bool is_int8() const {
     // We currently only allow 32-bit fixups, and they usually have value = 0,
     // so if fixup_ != nullptr, it shouldn't be classified as int8/16.
     return fixup_ == nullptr && Utils::IsInt(8, value_);
   }
   bool is_uint8() const {
     return fixup_ == nullptr && Utils::IsUint(8, value_);
   }
   bool is_uint16() const {
     return fixup_ == nullptr && Utils::IsUint(16, value_);
   }
 
 private:
   const int32_t value_;
-  AssemblerFixup *fixup_;
+  AssemblerFixup *fixup_ = nullptr;
 };
 
 class Operand {
 public:
   Operand(const Operand &other) : length_(other.length_), fixup_(other.fixup_) {
     memmove(&encoding_[0], &other.encoding_[0], other.length_);
   }
 
   Operand &operator=(const Operand &other) {
     length_ = other.length_;
@@ skipping 149 matching lines @@
     // Use the Offset in the displacement for now. If we decide to process
     // fixups later, we'll need to patch up the emitted displacement.
     result.SetDisp32(Offset);
     result.SetFixup(fixup);
     return result;
   }
 
   static Address ofConstPool(Assembler *Asm, const Constant *Imm);
 
 private:
-  Address() {} // Needed by Address::Absolute.
+  Address() = default; // Needed by Address::Absolute.
 };
 
 class Label {
   Label(const Label &) = delete;
   Label &operator=(const Label &) = delete;
 
 public:
-  Label() : position_(0), num_unresolved_(0) {
+  Label() {
 #ifndef NDEBUG
     for (int i = 0; i < kMaxUnresolvedBranches; i++) {
       unresolved_near_positions_[i] = -1;
     }
 #endif // !NDEBUG
   }
 
-  ~Label() {}
+  ~Label() = default;
 
   void FinalCheck() const {
     // Assert if label is being destroyed with unresolved branches pending.
     assert(!IsLinked());
     assert(!HasNear());
   }
 
   // TODO(jvoung): why are labels offset by this?
   static const uint32_t kWordSize = sizeof(uint32_t);
 
@@ skipping 43 matching lines @@
   }
 
   void NearLinkTo(intptr_t position) {
     assert(!IsBound());
     assert(num_unresolved_ < kMaxUnresolvedBranches);
     unresolved_near_positions_[num_unresolved_++] = position;
   }
 
   static const int kMaxUnresolvedBranches = 20;
 
-  intptr_t position_;
-  intptr_t num_unresolved_;
+  intptr_t position_ = 0;
+  intptr_t num_unresolved_ = 0;
   // TODO(stichnot,jvoung): Can this instead be
   // llvm::SmallVector<intptr_t, kMaxUnresolvedBranches> ?
   intptr_t unresolved_near_positions_[kMaxUnresolvedBranches];
 
   friend class AssemblerX8632;
 };
 
 class AssemblerX8632 : public Assembler {
   AssemblerX8632(const AssemblerX8632 &) = delete;
   AssemblerX8632 &operator=(const AssemblerX8632 &) = delete;
@@ skipping 577 matching lines @@
 inline void AssemblerX8632::emitFixup(AssemblerFixup *fixup) {
   Buffer.emitFixup(fixup);
 }
 
 inline void AssemblerX8632::emitOperandSizeOverride() { emitUint8(0x66); }
 
 } // end of namespace X8632
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEASSEMBLERX8632_H