[lldb] NFC modernize codebase with modernize-use-nullptr

Summary:
NFC = [[ https://llvm.org/docs/Lexicon.html#nfc | Non functional change ]]

This commit is the result of modernizing the LLDB codebase by using
`nullptr` instread of `0` or `NULL`. See
https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-nullptr.html
for more information.

This is the command I ran and I to fix and format the code base:

```
run-clang-tidy.py \
	-header-filter='.*' \
	-checks='-*,modernize-use-nullptr' \
	-fix ~/dev/llvm-project/lldb/.* \
	-format \
	-style LLVM \
	-p ~/llvm-builds/debug-ninja-gcc
```

NOTE: There were also changes to `llvm/utils/unittest` but I did not
include them because I felt that maybe this library shall be updated in
isolation somehow.

NOTE: I know this is a rather large commit but it is a nobrainer in most
parts.

Reviewers: martong, espindola, shafik, #lldb, JDevlieghere

Reviewed By: JDevlieghere

Subscribers: arsenm, jvesely, nhaehnle, hiraditya, JDevlieghere, teemperor, rnkovacs, emaste, kubamracek, nemanjai, ki.stfu, javed.absar, arichardson, kbarton, jrtc27, MaskRay, atanasyan, dexonsmith, arphaman, jfb, jsji, jdoerfert, lldb-commits, llvm-commits

Tags: #lldb, #llvm

Differential Revision: https://reviews.llvm.org/D61847

llvm-svn: 361484

Author: kwk

lldb/include/lldb/Breakpoint/BreakpointResolver.h

@@ -209,7 +209,7 @@ class BreakpointResolver : public Searcher {
                           const char *) = delete;
 
   lldb::BreakpointLocationSP AddLocation(Address loc_addr,
-                                         bool *new_location = NULL);
+                                         bool *new_location = nullptr);
 
   Breakpoint *m_breakpoint; // This is the breakpoint we add locations to.
   lldb::addr_t m_offset;    // A random offset the user asked us to add to any

lldb/source/API/SBAddress.cpp

@@ -83,7 +83,7 @@ bool SBAddress::IsValid() const {
 SBAddress::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBAddress, operator bool);
 
-  return m_opaque_up != NULL && m_opaque_up->IsValid();
+  return m_opaque_up != nullptr && m_opaque_up->IsValid();
 }
 
 void SBAddress::Clear() {
@@ -186,7 +186,7 @@ Address *SBAddress::operator->() { return m_opaque_up.get(); }
 const Address *SBAddress::operator->() const { return m_opaque_up.get(); }
 
 Address &SBAddress::ref() {
-  if (m_opaque_up == NULL)
+  if (m_opaque_up == nullptr)
     m_opaque_up.reset(new Address());
   return *m_opaque_up;
 }
@@ -208,7 +208,7 @@ bool SBAddress::GetDescription(SBStream &description) {
   // case there isn't one already...
   Stream &strm = description.ref();
   if (m_opaque_up->IsValid()) {
-    m_opaque_up->Dump(&strm, NULL, Address::DumpStyleResolvedDescription,
+    m_opaque_up->Dump(&strm, nullptr, Address::DumpStyleResolvedDescription,
                       Address::DumpStyleModuleWithFileAddress, 4);
     StreamString sstrm;
     //        m_opaque_up->Dump (&sstrm, NULL,

lldb/source/API/SBBlock.cpp

@@ -25,7 +25,7 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBBlock::SBBlock() : m_opaque_ptr(NULL) {
+SBBlock::SBBlock() : m_opaque_ptr(nullptr) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBlock);
 }
 
@@ -44,7 +44,7 @@ const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
   return LLDB_RECORD_RESULT(*this);
 }
 
-SBBlock::~SBBlock() { m_opaque_ptr = NULL; }
+SBBlock::~SBBlock() { m_opaque_ptr = nullptr; }
 
 bool SBBlock::IsValid() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid);
@@ -53,14 +53,14 @@ bool SBBlock::IsValid() const {
 SBBlock::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, operator bool);
 
-  return m_opaque_ptr != NULL;
+  return m_opaque_ptr != nullptr;
 }
 
 bool SBBlock::IsInlined() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined);
 
   if (m_opaque_ptr)
-    return m_opaque_ptr->GetInlinedFunctionInfo() != NULL;
+    return m_opaque_ptr->GetInlinedFunctionInfo() != nullptr;
   return false;
 }
 
@@ -77,10 +77,10 @@ const char *SBBlock::GetInlinedName() const {
         language = function->GetLanguage();
       else
         language = lldb::eLanguageTypeUnknown;
-      return inlined_info->GetName(language).AsCString(NULL);
+      return inlined_info->GetName(language).AsCString(nullptr);
     }
   }
-  return NULL;
+  return nullptr;
 }
 
 SBFileSpec SBBlock::GetInlinedCallSiteFile() const {

lldb/source/API/SBBreakpointLocation.cpp

@@ -179,7 +179,7 @@ const char *SBBreakpointLocation::GetCondition() {
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->GetConditionText();
   }
-  return NULL;
+  return nullptr;
 }
 
 void SBBreakpointLocation::SetAutoContinue(bool auto_continue) {
@@ -357,7 +357,7 @@ const char *SBBreakpointLocation::GetThreadName() const {
         loc_sp->GetTarget().GetAPIMutex());
     return loc_sp->GetThreadName();
   }
-  return NULL;
+  return nullptr;
 }
 
 void SBBreakpointLocation::SetQueueName(const char *queue_name) {
@@ -382,7 +382,7 @@ const char *SBBreakpointLocation::GetQueueName() const {
         loc_sp->GetTarget().GetAPIMutex());
     loc_sp->GetQueueName();
   }
-  return NULL;
+  return nullptr;
 }
 
 bool SBBreakpointLocation::IsResolved() {

lldb/source/API/SBBroadcaster.cpp

@@ -16,20 +16,19 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(NULL) {
+SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(nullptr) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
 }
 
 SBBroadcaster::SBBroadcaster(const char *name)
-    : m_opaque_sp(new Broadcaster(NULL, name)), m_opaque_ptr(NULL) {
+    : m_opaque_sp(new Broadcaster(nullptr, name)), m_opaque_ptr(nullptr) {
   LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name);
 
   m_opaque_ptr = m_opaque_sp.get();
 }
 
 SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
-    : m_opaque_sp(owns ? broadcaster : NULL), m_opaque_ptr(broadcaster) {
-}
+    : m_opaque_sp(owns ? broadcaster : nullptr), m_opaque_ptr(broadcaster) {}
 
 SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
     : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
@@ -48,13 +47,13 @@ const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
   return LLDB_RECORD_RESULT(*this);
 }
 
-SBBroadcaster::~SBBroadcaster() { reset(NULL, false); }
+SBBroadcaster::~SBBroadcaster() { reset(nullptr, false); }
 
 void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
   LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
                      (uint32_t, bool), event_type, unique);
 
-  if (m_opaque_ptr == NULL)
+  if (m_opaque_ptr == nullptr)
     return;
 
   if (unique)
@@ -67,7 +66,7 @@ void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
   LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
                      (const lldb::SBEvent &, bool), event, unique);
 
-  if (m_opaque_ptr == NULL)
+  if (m_opaque_ptr == nullptr)
     return;
 
   EventSP event_sp = event.GetSP();
@@ -104,7 +103,7 @@ const char *SBBroadcaster::GetName() const {
 
   if (m_opaque_ptr)
     return m_opaque_ptr->GetBroadcasterName().GetCString();
-  return NULL;
+  return nullptr;
 }
 
 bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
@@ -144,14 +143,14 @@ bool SBBroadcaster::IsValid() const {
 SBBroadcaster::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool);
 
-  return m_opaque_ptr != NULL;
+  return m_opaque_ptr != nullptr;
 }
 
 void SBBroadcaster::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear);
 
   m_opaque_sp.reset();
-  m_opaque_ptr = NULL;
+  m_opaque_ptr = nullptr;
 }
 
 bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const {

lldb/source/API/SBCommunication.cpp

@@ -16,7 +16,7 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBCommunication::SBCommunication() : m_opaque(NULL), m_opaque_owned(false) {
+SBCommunication::SBCommunication() : m_opaque(nullptr), m_opaque_owned(false) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommunication);
 }
 
@@ -28,7 +28,7 @@ SBCommunication::SBCommunication(const char *broadcaster_name)
 SBCommunication::~SBCommunication() {
   if (m_opaque && m_opaque_owned)
     delete m_opaque;
-  m_opaque = NULL;
+  m_opaque = nullptr;
   m_opaque_owned = false;
 }
 
@@ -39,7 +39,7 @@ bool SBCommunication::IsValid() const {
 SBCommunication::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommunication, operator bool);
 
-  return m_opaque != NULL;
+  return m_opaque != nullptr;
 }
 
 bool SBCommunication::GetCloseOnEOF() {
@@ -64,7 +64,7 @@ ConnectionStatus SBCommunication::Connect(const char *url) {
   if (m_opaque) {
     if (!m_opaque->HasConnection())
       m_opaque->SetConnection(Host::CreateDefaultConnection(url).release());
-    return m_opaque->Connect(url, NULL);
+    return m_opaque->Connect(url, nullptr);
   }
   return eConnectionStatusNoConnection;
 }
@@ -115,7 +115,7 @@ size_t SBCommunication::Read(void *dst, size_t dst_len, uint32_t timeout_usec,
                                     ? Timeout<std::micro>(llvm::None)
                                     : std::chrono::microseconds(timeout_usec);
   if (m_opaque)
-    bytes_read = m_opaque->Read(dst, dst_len, timeout, status, NULL);
+    bytes_read = m_opaque->Read(dst, dst_len, timeout, status, nullptr);
   else
     status = eConnectionStatusNoConnection;
 
@@ -130,7 +130,7 @@ size_t SBCommunication::Write(const void *src, size_t src_len,
 
   size_t bytes_written = 0;
   if (m_opaque)
-    bytes_written = m_opaque->Write(src, src_len, status, NULL);
+    bytes_written = m_opaque->Write(src, src_len, status, nullptr);
   else
     status = eConnectionStatusNoConnection;
 

lldb/source/API/SBCompileUnit.cpp

@@ -20,7 +20,7 @@
 using namespace lldb;
 using namespace lldb_private;
 
-SBCompileUnit::SBCompileUnit() : m_opaque_ptr(NULL) {
+SBCompileUnit::SBCompileUnit() : m_opaque_ptr(nullptr) {
   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCompileUnit);
 }
 
@@ -41,7 +41,7 @@ const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) {
   return LLDB_RECORD_RESULT(*this);
 }
 
-SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = NULL; }
+SBCompileUnit::~SBCompileUnit() { m_opaque_ptr = nullptr; }
 
 SBFileSpec SBCompileUnit::GetFileSpec() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBCompileUnit,
@@ -108,8 +108,8 @@ uint32_t SBCompileUnit::FindLineEntryIndex(uint32_t start_idx, uint32_t line,
       file_spec = *m_opaque_ptr;
 
     index = m_opaque_ptr->FindLineEntry(
-        start_idx, line, inline_file_spec ? inline_file_spec->get() : NULL,
-        exact, NULL);
+        start_idx, line, inline_file_spec ? inline_file_spec->get() : nullptr,
+        exact, nullptr);
   }
 
   return index;
@@ -193,7 +193,7 @@ bool SBCompileUnit::IsValid() const {
 SBCompileUnit::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCompileUnit, operator bool);
 
-  return m_opaque_ptr != NULL;
+  return m_opaque_ptr != nullptr;
 }
 
 bool SBCompileUnit::operator==(const SBCompileUnit &rhs) const {

lldb/source/API/SBData.cpp

@@ -64,7 +64,7 @@ bool SBData::IsValid() {
 SBData::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBData, operator bool);
 
-  return m_opaque_sp.get() != NULL;
+  return m_opaque_sp.get() != nullptr;
 }
 
 uint8_t SBData::GetAddressByteSize() {
@@ -312,13 +312,13 @@ const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
   LLDB_RECORD_METHOD(const char *, SBData, GetString,
                      (lldb::SBError &, lldb::offset_t), error, offset);
 
-  const char *value = 0;
+  const char *value = nullptr;
   if (!m_opaque_sp.get()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     value = m_opaque_sp->GetCStr(&offset);
-    if (offset == old_offset || (value == NULL))
+    if (offset == old_offset || (value == nullptr))
       error.SetErrorString("unable to read data");
   }
   return value;
@@ -346,13 +346,13 @@ size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset,
                     (lldb::SBError &, lldb::offset_t, void *, size_t), error,
                     offset, buf, size);
 
-  void *ok = NULL;
+  void *ok = nullptr;
   if (!m_opaque_sp.get()) {
     error.SetErrorString("no value to read from");
   } else {
     uint32_t old_offset = offset;
     ok = m_opaque_sp->GetU8(&offset, buf, size);
-    if ((offset == old_offset) || (ok == NULL))
+    if ((offset == old_offset) || (ok == nullptr))
       error.SetErrorString("unable to read data");
   }
   return ok ? size : 0;

lldb/source/API/SBDeclaration.cpp

@@ -147,7 +147,7 @@ const lldb_private::Declaration *SBDeclaration::operator->() const {
 }
 
 lldb_private::Declaration &SBDeclaration::ref() {
-  if (m_opaque_up == NULL)
+  if (m_opaque_up == nullptr)
     m_opaque_up.reset(new lldb_private::Declaration());
   return *m_opaque_up;
 }

lldb/source/API/SBError.cpp

@@ -41,7 +41,7 @@ const char *SBError::GetCString() const {
 
   if (m_opaque_up)
     return m_opaque_up->AsCString();
-  return NULL;
+  return nullptr;
 }
 
 void SBError::Clear() {
@@ -144,11 +144,11 @@ bool SBError::IsValid() const {
 SBError::operator bool() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBError, operator bool);
 
-  return m_opaque_up != NULL;
+  return m_opaque_up != nullptr;
 }
 
 void SBError::CreateIfNeeded() {
-  if (m_opaque_up == NULL)
+  if (m_opaque_up == nullptr)
     m_opaque_up.reset(new Status());
 }
 
@@ -175,7 +175,8 @@ bool SBError::GetDescription(SBStream &description) {
       description.Printf("success");
     else {
       const char *err_string = GetCString();
-      description.Printf("error: %s", (err_string != NULL ? err_string : ""));
+      description.Printf("error: %s",
+                         (err_string != nullptr ? err_string : ""));
     }
   } else
     description.Printf("error: <NULL>");