Subzero: Convert NULL->nullptr.

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 44 matching lines @@
   // the operand.  This is so that the liveness operations can get
   // quick access to the variables of interest, without having to dig
   // so far into the operand.
   SizeT getNumVars() const { return NumVars; }
   Variable *getVar(SizeT I) const {
     assert(I < getNumVars());
     return Vars[I];
   }
   virtual void emit(const Cfg *Func) const = 0;
   // The dump(Func,Str) implementation must be sure to handle the
-  // situation where Func==NULL.
+  // situation where Func==nullptr.
   virtual void dump(const Cfg *Func, Ostream &Str) const = 0;
   void dump(const Cfg *Func) const {
     if (!ALLOW_DUMP)
       return;
     assert(Func);
     dump(Func, Func->getContext()->getStrDump());
   }
   void dump(Ostream &Str) const {
     if (ALLOW_DUMP)
-      dump(NULL, Str);
+      dump(nullptr, Str);
   }
 
   // Query whether this object was allocated in isolation, or added to
   // some higher-level pool.  This determines whether a containing
   // object's destructor should delete this object.  Generally,
   // constants are pooled globally, variables are pooled per-CFG, and
   // target-specific operands are not pooled.
   virtual bool isPooled() const { return false; }
 
   virtual ~Operand() {}
 
 protected:
   Operand(OperandKind Kind, Type Ty)
-      : Ty(Ty), Kind(Kind), NumVars(0), Vars(NULL) {}
+      : 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>
 inline StreamType &operator<<(StreamType &Str, const Operand &Op) {
@@ skipping 15 matching lines @@
   void dump(const Cfg *Func, Ostream &Str) const = 0;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kConst_Base && Kind <= kConst_Num;
   }
 
 protected:
   Constant(OperandKind Kind, Type Ty, uint32_t PoolEntryID)
       : Operand(Kind, Ty), PoolEntryID(PoolEntryID) {
-    Vars = NULL;
+    Vars = nullptr;
     NumVars = 0;
   }
   ~Constant() override {}
   // PoolEntryID is an integer that uniquely identifies the constant
   // within its constant pool.  It is used for building the constant
   // pool in the object code and for referencing its entries.
   const uint32_t PoolEntryID;
 };
 
 // ConstantPrimitive<> wraps a primitive type.
@@ skipping 314 matching lines @@
     return Live.overlaps(Other->Live, UseTrimmed);
   }
   bool rangeOverlapsStart(const Variable *Other) const {
     const bool UseTrimmed = true;
     return Live.overlapsInst(Other->Live.getStart(), UseTrimmed);
   }
 
   Variable *getLo() const { return LoVar; }
   Variable *getHi() const { return HiVar; }
   void setLoHi(Variable *Lo, Variable *Hi) {
-    assert(LoVar == NULL);
-    assert(HiVar == NULL);
+    assert(LoVar == nullptr);
+    assert(HiVar == nullptr);
     LoVar = Lo;
     HiVar = Hi;
   }
   // Creates a temporary copy of the variable with a different type.
   // Used primarily for syntactic correctness of textual assembly
   // emission.  Note that only basic information is copied, in
   // particular not IsArgument, IsImplicitArgument, IgnoreLiveness,
   // RegNumTmp, Weight, Live, LoVar, HiVar, VarsReal.
   Variable *asType(Type Ty);
 
   void emit(const Cfg *Func) const override;
   using Operand::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kVariable && Kind <= kVariable_Num;
   }
 
 protected:
   Variable(OperandKind K, Type Ty, SizeT Index)
       : Operand(K, Ty), Number(Index), NameIndex(Cfg::IdentifierIndexInvalid),
         IsArgument(false), IsImplicitArgument(false), IgnoreLiveness(false),
         StackOffset(0), RegNum(NoRegister), RegNumTmp(NoRegister), Weight(1),
-        LoVar(NULL), HiVar(NULL) {
+        LoVar(nullptr), HiVar(nullptr) {
     Vars = VarsReal;
     Vars[0] = this;
     NumVars = 1;
   }
   ~Variable() override {}
   // Number is unique across all variables, and is used as a
   // (bit)vector index for liveness analysis.
   const SizeT Number;
   Cfg::IdentifierIndexType NameIndex;
   bool IsArgument;
@@ skipping 46 matching lines @@
     MDS_SingleDef,
     MDS_MultiDefSingleBlock,
     MDS_MultiDefMultiBlock
   };
   enum MultiBlockState {
     MBS_Unknown,
     MBS_SingleBlock,
     MBS_MultiBlock
   };
   VariableTracking()
-      : MultiDef(MDS_Unknown), MultiBlock(MBS_Unknown), SingleUseNode(NULL),
-        SingleDefNode(NULL), FirstOrSingleDefinition(NULL) {}
+      : MultiDef(MDS_Unknown), MultiBlock(MBS_Unknown), SingleUseNode(nullptr),
+        SingleDefNode(nullptr), FirstOrSingleDefinition(nullptr) {}
   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; }
   void markUse(MetadataKind TrackingKind, const Inst *Instr,
                const CfgNode *Node, bool IsFromDef, bool IsImplicit);
   void markDef(MetadataKind TrackingKind, const Inst *Instr,
                const CfgNode *Node);
@@ skipping 31 matching lines @@
     return Var->getIndex() < Metadata.size();
   }
 
   // Returns whether the given Variable has multiple definitions.
   bool isMultiDef(const Variable *Var) const;
   // Returns the first definition instruction of the given Variable.
   // This is only valid for variables whose definitions are all within
   // the same block, e.g. T after the lowered sequence "T=B; T+=C;
   // A=T", for which getFirstDefinition(T) would return the "T=B"
   // instruction.  For variables with definitions span multiple
-  // blocks, NULL is returned.
+  // blocks, nullptr is returned.
   const Inst *getFirstDefinition(const Variable *Var) const;
   // Returns the definition instruction of the given Variable, when
-  // the variable has exactly one definition.  Otherwise, NULL is
+  // the variable has exactly one definition.  Otherwise, nullptr is
   // returned.
   const Inst *getSingleDefinition(const Variable *Var) const;
   // Returns the list of all definition instructions of the given
   // Variable.
   const InstDefList &getLatterDefinitions(const Variable *Var) const;
 
   // Returns whether the given Variable is live across multiple
   // blocks.  Mainly, this is used to partition Variables into
   // single-block versus multi-block sets for leveraging sparsity in
   // liveness analysis, and for implementing simple stack slot
   // coalescing.  As a special case, function arguments are always
   // considered multi-block because they are live coming into the
   // entry block.
   bool isMultiBlock(const Variable *Var) const;
   // Returns the node that the given Variable is used in, assuming
-  // isMultiBlock() returns false.  Otherwise, NULL is returned.
+  // isMultiBlock() returns false.  Otherwise, nullptr is returned.
   const CfgNode *getLocalUseNode(const Variable *Var) const;
 
 private:
   const Cfg *Func;
   MetadataKind Kind;
   std::vector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H