Subzero: Convert NULL->nullptr.

src/IceIntrinsics.cpp

 //===- subzero/src/IceIntrinsics.cpp - Functions related to intrinsics ----===//
 //
 //                        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 Intrinsics utilities for matching and
@@ skipping 199 matching lines @@
     Map.insert(std::make_pair(IceString(Entry.IntrinsicName), Entry.Info));
   }
 }
 
 Intrinsics::~Intrinsics() {}
 
 const Intrinsics::FullIntrinsicInfo *
 Intrinsics::find(const IceString &Name) const {
   auto it = Map.find(Name);
   if (it == Map.end())
-    return NULL;
+    return nullptr;
   return &it->second;
 }
 
 bool Intrinsics::VerifyMemoryOrder(uint64_t Order) {
   // There is only one memory ordering for atomics allowed right now.
   return Order == Intrinsics::MemoryOrderSequentiallyConsistent;
 }
 
 Intrinsics::ValidateCallValue
 Intrinsics::FullIntrinsicInfo::validateCall(const Ice::InstCall *Call,
                                             SizeT &ArgIndex) const {
   assert(NumTypes >= 1);
   Variable *Result = Call->getDest();
-  if (Result == NULL) {
+  if (Result == nullptr) {
     if (Signature[0] != Ice::IceType_void)
       return Intrinsics::BadReturnType;
   } else if (Signature[0] != Result->getType()) {
     return Intrinsics::BadReturnType;
   }
   if (Call->getNumArgs() + 1 != NumTypes) {
     return Intrinsics::WrongNumOfArgs;
   }
   for (size_t i = 1; i < NumTypes; ++i) {
     if (Call->getArg(i - 1)->getType() != Signature[i]) {
       ArgIndex = i;
       return Intrinsics::WrongCallArgType;
     }
   }
   return Intrinsics::IsValidCall;
 }
 
 Type Intrinsics::FullIntrinsicInfo::getArgType(SizeT Index) const {
   assert(NumTypes > 1);
   assert(Index + 1 < NumTypes);
   return Signature[Index + 1];
 }
 
 } // end of namespace Ice