Subzero: Convert NULL->nullptr.

src/IceInst.cpp

 //===- subzero/src/IceInst.cpp - High-level instruction implementation ----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Inst class, primarily the various
@@ skipping 217 matching lines @@
 InstAssign::InstAssign(Cfg *Func, Variable *Dest, Operand *Source)
     : InstHighLevel(Func, Inst::Assign, 1, Dest) {
   addSource(Source);
 }
 
 // If TargetTrue==TargetFalse, we turn it into an unconditional
 // branch.  This ensures that, along with the 'switch' instruction
 // semantics, there is at most one edge from one node to another.
 InstBr::InstBr(Cfg *Func, Operand *Source, CfgNode *TargetTrue,
                CfgNode *TargetFalse)
-    : InstHighLevel(Func, Inst::Br, 1, NULL), TargetFalse(TargetFalse),
+    : InstHighLevel(Func, Inst::Br, 1, nullptr), TargetFalse(TargetFalse),
       TargetTrue(TargetTrue) {
   if (TargetTrue == TargetFalse) {
-    TargetTrue = NULL; // turn into unconditional version
+    TargetTrue = nullptr; // turn into unconditional version
   } else {
     addSource(Source);
   }
 }
 
 InstBr::InstBr(Cfg *Func, CfgNode *Target)
-    : InstHighLevel(Func, Inst::Br, 0, NULL), TargetFalse(Target),
-      TargetTrue(NULL) {}
+    : InstHighLevel(Func, Inst::Br, 0, nullptr), TargetFalse(Target),
+      TargetTrue(nullptr) {}
 
 NodeList InstBr::getTerminatorEdges() const {
   NodeList OutEdges;
   OutEdges.reserve(TargetTrue ? 2 : 1);
   OutEdges.push_back(TargetFalse);
   if (TargetTrue)
     OutEdges.push_back(TargetTrue);
   return OutEdges;
 }
 
@@ skipping 64 matching lines @@
 
 // Find the source operand corresponding to the incoming edge for the
 // given node.  TODO: This uses a linear-time search, which could be
 // improved if it becomes a problem.
 Operand *InstPhi::getOperandForTarget(CfgNode *Target) const {
   for (SizeT I = 0; I < getSrcSize(); ++I) {
     if (Labels[I] == Target)
       return getSrc(I);
   }
   llvm_unreachable("Phi target not found");
-  return NULL;
+  return nullptr;
 }
 
 // Updates liveness for a particular operand based on the given
 // predecessor edge.  Doesn't mark the operand as live if the Phi
 // instruction is dead or deleted.
 void InstPhi::livenessPhiOperand(LivenessBV &Live, CfgNode *Target,
                                  Liveness *Liveness) {
   if (isDeleted() || Dead)
     return;
   for (SizeT I = 0; I < getSrcSize(); ++I) {
@@ skipping 17 matching lines @@
   Variable *Dest = getDest();
   assert(Dest);
   Variable *NewSrc = Func->makeVariable(Dest->getType());
   if (ALLOW_DUMP)
     NewSrc->setName(Func, Dest->getName(Func) + "_phi");
   this->Dest = NewSrc;
   return InstAssign::create(Func, Dest, NewSrc);
 }
 
 InstRet::InstRet(Cfg *Func, Operand *RetValue)
-    : InstHighLevel(Func, Ret, RetValue ? 1 : 0, NULL) {
+    : InstHighLevel(Func, Ret, RetValue ? 1 : 0, nullptr) {
   if (RetValue)
     addSource(RetValue);
 }
 
 InstSelect::InstSelect(Cfg *Func, Variable *Dest, Operand *Condition,
                        Operand *SourceTrue, Operand *SourceFalse)
     : InstHighLevel(Func, Inst::Select, 3, Dest) {
   assert(typeElementType(Condition->getType()) == IceType_i1);
   addSource(Condition);
   addSource(SourceTrue);
   addSource(SourceFalse);
 }
 
 InstStore::InstStore(Cfg *Func, Operand *Data, Operand *Addr)
-    : InstHighLevel(Func, Inst::Store, 2, NULL) {
+    : InstHighLevel(Func, Inst::Store, 2, nullptr) {
   addSource(Data);
   addSource(Addr);
 }
 
 InstSwitch::InstSwitch(Cfg *Func, SizeT NumCases, Operand *Source,
                        CfgNode *LabelDefault)
-    : InstHighLevel(Func, Inst::Switch, 1, NULL), LabelDefault(LabelDefault),
+    : InstHighLevel(Func, Inst::Switch, 1, nullptr), LabelDefault(LabelDefault),
       NumCases(NumCases) {
   addSource(Source);
   Values = Func->allocateArrayOf<uint64_t>(NumCases);
   Labels = Func->allocateArrayOf<CfgNode *>(NumCases);
   // Initialize in case buggy code doesn't set all entries
   for (SizeT I = 0; I < NumCases; ++I) {
     Values[I] = 0;
-    Labels[I] = NULL;
+    Labels[I] = nullptr;
   }
 }
 
 void InstSwitch::addBranch(SizeT CaseIndex, uint64_t Value, CfgNode *Label) {
   assert(CaseIndex < NumCases);
   Values[CaseIndex] = Value;
   Labels[CaseIndex] = Label;
 }
 
 NodeList InstSwitch::getTerminatorEdges() const {
@@ skipping 14 matching lines @@
   for (SizeT I = 0; I < NumCases; ++I) {
     if (Labels[I] == OldNode) {
       Labels[I] = NewNode;
       return true;
     }
   }
   return false;
 }
 
 InstUnreachable::InstUnreachable(Cfg *Func)
-    : InstHighLevel(Func, Inst::Unreachable, 0, NULL) {}
+    : InstHighLevel(Func, Inst::Unreachable, 0, nullptr) {}
 
 InstFakeDef::InstFakeDef(Cfg *Func, Variable *Dest, Variable *Src)
     : InstHighLevel(Func, Inst::FakeDef, Src ? 1 : 0, Dest) {
   assert(Dest);
   if (Src)
     addSource(Src);
 }
 
 InstFakeUse::InstFakeUse(Cfg *Func, Variable *Src)
-    : InstHighLevel(Func, Inst::FakeUse, 1, NULL) {
+    : InstHighLevel(Func, Inst::FakeUse, 1, nullptr) {
   assert(Src);
   addSource(Src);
 }
 
 InstFakeKill::InstFakeKill(Cfg *Func, const Inst *Linked)
-    : InstHighLevel(Func, Inst::FakeKill, 0, NULL), Linked(Linked) {}
+    : InstHighLevel(Func, Inst::FakeKill, 0, nullptr), Linked(Linked) {}
 
 Type InstCall::getReturnType() const {
-  if (Dest == NULL)
+  if (Dest == nullptr)
     return IceType_void;
   return Dest->getType();
 }
 
 // ======================== Dump routines ======================== //
 
 void Inst::dumpDecorated(const Cfg *Func) const {
   if (!ALLOW_DUMP)
     return;
   Ostream &Str = Func->getContext()->getStrDump();
@@ skipping 352 matching lines @@
 
 void InstTarget::dump(const Cfg *Func) const {
   if (!ALLOW_DUMP)
     return;
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "[TARGET] ";
   Inst::dump(Func);
 }
 
 } // end of namespace Ice