Subzero: Convert NULL->nullptr.

src/IceInst.h

 //===- subzero/src/IceInst.h - High-level instructions ----------*- 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 Inst class and its target-independent
@@ skipping 303 matching lines @@
   // optimized to an unconditional branch.
   static InstBr *create(Cfg *Func, Operand *Source, CfgNode *TargetTrue,
                         CfgNode *TargetFalse) {
     return new (Func->allocate<InstBr>())
         InstBr(Func, Source, TargetTrue, TargetFalse);
   }
   // Create an unconditional branch.
   static InstBr *create(Cfg *Func, CfgNode *Target) {
     return new (Func->allocate<InstBr>()) InstBr(Func, Target);
   }
-  bool isUnconditional() const { return getTargetTrue() == NULL; }
+  bool isUnconditional() const { return getTargetTrue() == nullptr; }
   Operand *getCondition() const {
     assert(!isUnconditional());
     return getSrc(0);
   }
   CfgNode *getTargetTrue() const { return TargetTrue; }
   CfgNode *getTargetFalse() const { return TargetFalse; }
   CfgNode *getTargetUnconditional() const {
     assert(isUnconditional());
     return getTargetFalse();
   }
   NodeList getTerminatorEdges() const override;
   bool isUnconditionalBranch() const override { return isUnconditional(); }
   bool repointEdge(CfgNode *OldNode, CfgNode *NewNode) override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return Inst->getKind() == Br; }
 
 private:
   // Conditional branch
   InstBr(Cfg *Func, Operand *Source, CfgNode *TargetTrue, CfgNode *TargetFalse);
   // Unconditional branch
   InstBr(Cfg *Func, CfgNode *Target);
   ~InstBr() override {}
 
   CfgNode *TargetFalse; // Doubles as unconditional branch target
-  CfgNode *TargetTrue;  // NULL if unconditional branch
+  CfgNode *TargetTrue;  // nullptr if unconditional branch
 };
 
 // Call instruction.  The call target is captured as getSrc(0), and
 // arg I is captured as getSrc(I+1).
 class InstCall : public InstHighLevel {
   InstCall(const InstCall &) = delete;
   InstCall &operator=(const InstCall &) = delete;
 
 public:
   static InstCall *create(Cfg *Func, SizeT NumArgs, Variable *Dest,
@@ skipping 248 matching lines @@
 };
 
 // Ret instruction.  The return value is captured in getSrc(0), but if
 // there is no return value (void-type function), then
 // getSrcSize()==0 and hasRetValue()==false.
 class InstRet : public InstHighLevel {
   InstRet(const InstRet &) = delete;
   InstRet &operator=(const InstRet &) = delete;
 
 public:
-  static InstRet *create(Cfg *Func, Operand *RetValue = NULL) {
+  static InstRet *create(Cfg *Func, Operand *RetValue = nullptr) {
     return new (Func->allocate<InstRet>()) InstRet(Func, RetValue);
   }
   bool hasRetValue() const { return getSrcSize(); }
   Operand *getRetValue() const {
     assert(hasRetValue());
     return getSrc(0);
   }
   NodeList getTerminatorEdges() const override { return NodeList(); }
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return Inst->getKind() == Ret; }
@@ skipping 124 matching lines @@
 // It's generally useful to set the optional source operand to be the
 // dest variable of the instruction that actually produces the FakeDef
 // dest.  Otherwise, the original instruction could be dead-code
 // eliminated if its dest operand is unused, and therefore the FakeDef
 // dest wouldn't be properly initialized.
 class InstFakeDef : public InstHighLevel {
   InstFakeDef(const InstFakeDef &) = delete;
   InstFakeDef &operator=(const InstFakeDef &) = delete;
 
 public:
-  static InstFakeDef *create(Cfg *Func, Variable *Dest, Variable *Src = NULL) {
+  static InstFakeDef *create(Cfg *Func, Variable *Dest,
+                             Variable *Src = nullptr) {
     return new (Func->allocate<InstFakeDef>()) InstFakeDef(Func, Dest, Src);
   }
   void emit(const Cfg *Func) const override;
   void emitIAS(const Cfg * /* Func */) const override {}
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return Inst->getKind() == FakeDef; }
 
 private:
   InstFakeDef(Cfg *Func, Variable *Dest, Variable *Src);
   ~InstFakeDef() override {}
@@ skipping 90 matching lines @@
   static void noteHead(Ice::Inst *, Ice::Inst *) {}
   void deleteNode(Ice::Inst *) {}
 
 private:
   mutable ilist_half_node<Ice::Inst> Sentinel;
 };
 
 } // end of namespace llvm
 
 #endif // SUBZERO_SRC_ICEINST_H