More consistently use auto for emit*, nullptr in asm code.

src/assembler_ia32.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.
 //
 //===----------------------------------------------------------------------===//
 //
 //                        The Subzero Code Generator
@@ skipping 54 matching lines @@
 private:
   DisplacementRelocation(FixupKind Kind, const ConstantRelocatable *Sym)
       : AssemblerFixup(Kind, Sym) {}
 };
 
 class Immediate {
   Immediate(const Immediate &) = delete;
   Immediate &operator=(const Immediate &) = delete;
 
 public:
-  explicit Immediate(int32_t value) : value_(value), fixup_(NULL) {}
+  explicit Immediate(int32_t value) : value_(value), fixup_(nullptr) {}
 
   explicit Immediate(AssemblerFixup *fixup)
       : value_(fixup->value()->getOffset()), fixup_(fixup) {
     // Use the Offset in the "value" for now. If the symbol is part of
     // ".bss", then the relocation's symbol will be plain ".bss" and
     // the value will need to be adjusted further to be sym's
     // bss offset + Offset.
   }
 
   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_ != NULL, it shouldn't be classified as int8/16.
-    return fixup_ == NULL && Utils::IsInt(8, value_);
+    // 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_ == NULL && Utils::IsUint(8, value_); }
-  bool is_uint16() const { return fixup_ == NULL && Utils::IsUint(16, 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_;
 };
 
 class Operand {
 public:
   Operand(const Operand &other) : length_(other.length_), fixup_(other.fixup_) {
     memmove(&encoding_[0], &other.encoding_[0], other.length_);
@@ skipping 30 matching lines @@
   }
 
   int32_t disp32() const {
     assert(length_ >= 5);
     return bit_copy<int32_t>(encoding_[length_ - 4]);
   }
 
   AssemblerFixup *fixup() const { return fixup_; }
 
 protected:
-  Operand() : length_(0), fixup_(NULL) {} // Needed by subclass Address.
+  Operand() : length_(0), fixup_(nullptr) {} // Needed by subclass Address.
 
   void SetModRM(int mod, GPRRegister rm) {
     assert((mod & ~3) == 0);
     encoding_[0] = (mod << 6) | rm;
     length_ = 1;
   }
 
   void SetSIB(ScaleFactor scale, GPRRegister index, GPRRegister base) {
     assert(length_ == 1);
     assert((scale & ~3) == 0);
@@ skipping 13 matching lines @@
     length_ += disp_size;
   }
 
   void SetFixup(AssemblerFixup *fixup) { fixup_ = fixup; }
 
 private:
   uint8_t length_;
   uint8_t encoding_[6];
   AssemblerFixup *fixup_;
 
-  explicit Operand(GPRRegister reg) : fixup_(NULL) { SetModRM(3, reg); }
+  explicit Operand(GPRRegister reg) : fixup_(nullptr) { SetModRM(3, reg); }
 
   // Get the operand encoding byte at the given index.
   uint8_t encoding_at(intptr_t index) const {
     assert(index >= 0 && index < length_);
     return encoding_[index];
   }
 
   // Returns whether or not this operand is really the given register in
   // disguise. Used from the assembler to generate better encodings.
   bool IsRegister(GPRRegister reg) const {
@@ skipping 702 matching lines @@
 inline void AssemblerX86::EmitFixup(AssemblerFixup *fixup) {
   buffer_.EmitFixup(fixup);
 }
 
 inline void AssemblerX86::EmitOperandSizeOverride() { EmitUint8(0x66); }
 
 } // end of namespace x86
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ASSEMBLER_IA32_H_