[lldb] fix cannot convert from 'nullptr' to 'lldb::thread_result_t'

[kwk]

Summary

On Windows lldb::thread_result_t resolves to typedef unsigned thread_result_t; and on other platforms it resolves to typedef void *thread_result_t;.
Therefore one cannot use nullptr when returning from a function that returns thread_result_t.

I've made this change because a windows build bot fails with these errors:

FAILED: tools/lldb/source/Core/CMakeFiles/lldbCore.dir/Communication.cpp.obj
C:\PROGRA~2\MICROS~1\2017\COMMUN~1\VC\Tools\MSVC\1416~1.270\bin\Hostx64\x64\cl.exe /nologo /TP -DGTEST_HAS_RTTI=0 -DLLDB_CONFIGURATION_RELEASE -DLLDB_DISABLE_CURSES -DLLDB_DISABLE_LIBEDIT -DLLDB_PYTHON_HOME="\"C:/Program Files (x86)/Microsoft Visual Studio/Shared/Python36_64\"" -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_ENABLE_EXTENDED_ALIGNED_STORAGE -D_HAS_EXCEPTIONS=0 -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools\lldb\source\Core -IE:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\Core -Itools\lldb\include -IE:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\include -Iinclude -IE:\build_slave\lldb-x64-windows-ninja\llvm\include -I"C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python36_64\Include" -IE:\build_slave\lldb-x64-windows-ninja\llvm\tools\clang\include -Itools\lldb\..\clang\include -IE:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\. /DWIN32 /D_WINDOWS /Zc:inline /Zc:strictStrings /Oi /Zc:rvalueCast /W4 -wd4141 -wd4146 -wd4180 -wd4244 -wd4258 -wd4267 -wd4291 -wd4345 -wd4351 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 -wd4709 -wd4324 -w14062 -we4238 /MD /O2 /Ob2 /DNDEBUG -wd4018 -wd4068 -wd4150 -wd4201 -wd4251 -wd4521 -wd4530 /EHs-c- /GR- /showIncludes /Fotools\lldb\source\Core\CMakeFiles\lldbCore.dir\Communication.cpp.obj /Fdtools\lldb\source\Core\CMakeFiles\lldbCore.dir\lldbCore.pdb /FS -c E:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\Core\Communication.cpp
E:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\Core\Communication.cpp(362): error C2440: 'return': cannot convert from 'nullptr' to 'lldb::thread_result_t'
E:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\Core\Communication.cpp(362): note: A native nullptr can only be converted to bool or, using reinterpret_cast, to an integral type

and

FAILED: tools/lldb/source/Core/CMakeFiles/lldbCore.dir/Debugger.cpp.obj
C:\PROGRA~2\MICROS~1\2017\COMMUN~1\VC\Tools\MSVC\1416~1.270\bin\Hostx64\x64\cl.exe /nologo /TP -DGTEST_HAS_RTTI=0 -DLLDB_CONFIGURATION_RELEASE -DLLDB_DISABLE_CURSES -DLLDB_DISABLE_LIBEDIT -DLLDB_PYTHON_HOME="\"C:/Program Files (x86)/Microsoft Visual Studio/Shared/Python36_64\"" -DUNICODE -D_CRT_NONSTDC_NO_DEPRECATE -D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE -D_CRT_SECURE_NO_WARNINGS -D_ENABLE_EXTENDED_ALIGNED_STORAGE -D_HAS_EXCEPTIONS=0 -D_SCL_SECURE_NO_DEPRECATE -D_SCL_SECURE_NO_WARNINGS -D_UNICODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Itools\lldb\source\Core -IE:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\Core -Itools\lldb\include -IE:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\include -Iinclude -IE:\build_slave\lldb-x64-windows-ninja\llvm\include -I"C:\Program Files (x86)\Microsoft Visual Studio\Shared\Python36_64\Include" -IE:\build_slave\lldb-x64-windows-ninja\llvm\tools\clang\include -Itools\lldb\..\clang\include -IE:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\. /DWIN32 /D_WINDOWS /Zc:inline /Zc:strictStrings /Oi /Zc:rvalueCast /W4 -wd4141 -wd4146 -wd4180 -wd4244 -wd4258 -wd4267 -wd4291 -wd4345 -wd4351 -wd4456 -wd4457 -wd4458 -wd4459 -wd4503 -wd4624 -wd4722 -wd4100 -wd4127 -wd4512 -wd4505 -wd4610 -wd4510 -wd4702 -wd4245 -wd4706 -wd4310 -wd4701 -wd4703 -wd4389 -wd4611 -wd4805 -wd4204 -wd4577 -wd4091 -wd4592 -wd4319 -wd4709 -wd4324 -w14062 -we4238 /MD /O2 /Ob2 /DNDEBUG -wd4018 -wd4068 -wd4150 -wd4201 -wd4251 -wd4521 -wd4530 /EHs-c- /GR- /showIncludes /Fotools\lldb\source\Core\CMakeFiles\lldbCore.dir\Debugger.cpp.obj /Fdtools\lldb\source\Core\CMakeFiles\lldbCore.dir\lldbCore.pdb /FS -c E:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\Core\Debugger.cpp
E:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\Core\Debugger.cpp(1619): error C2440: 'return': cannot convert from 'nullptr' to 'lldb::thread_result_t'
E:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\Core\Debugger.cpp(1619): note: A native nullptr can only be converted to bool or, using reinterpret_cast, to an integral type
E:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\Core\Debugger.cpp(1664): error C2440: 'return': cannot convert from 'nullptr' to 'lldb::thread_result_t'
E:\build_slave\lldb-x64-windows-ninja\llvm\tools\lldb\source\Core\Debugger.cpp(1664): note: A native nullptr can only be converted to bool or, using reinterpret_cast, to an integral type

This is the failing build: http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/5035/steps/build/logs/stdio

[labath]

returning lldb::thread_result_t() is probably the best thing to do here...

[kwk]

Fixed second place where nullptr couldn't be converted

[kwk]

Return lldb::thread_result_t() instead of NULL

[kwk]

In D62305#1513642, @labath wrote:

returning lldb::thread_result_t() is probably the best thing to do here...

@labath I've followed your advice. Running tests for linux now.

[jankratochvil]

In D62305#1513642, @labath wrote:

returning lldb::thread_result_t() is probably the best thing to do here...

I would say return {}; is the best one, it has 118 uses in lldb/.

[labath]

In D62305#1513793, @jankratochvil wrote:

In D62305#1513642, @labath wrote:

returning lldb::thread_result_t() is probably the best thing to do here...

I would say return {}; is the best one, it has 118 uses in lldb/.

Yeah, that works too...

[kwk]

• Return empty lldb::thread_result_t as {}

[stella.stamenova]

It looks like this was not enough and the build is still broken. Please revert your change or fix it and then keep an eye on the Buildbot to make sure it turns to green again. Once it's broken, it won't continue sending failure emails, so you have to monitor it to make sure your change fixed it.

source/Core/Communication.cpp

lldb::thread_result_t Communication::ReadThread(lldb::thread_arg_t p) {
   log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_COMMUNICATION);
   if (log)
     log->Printf("%p Communication::ReadThread () thread exiting...", p);
 
   comm->m_read_thread_did_exit = true;
   // Let clients know that this thread is exiting
   comm->BroadcastEvent(eBroadcastBitNoMorePendingInput);
   comm->BroadcastEvent(eBroadcastBitReadThreadDidExit);
-  return nullptr;
+  return {};
 }
 
 void Communication::SetReadThreadBytesReceivedCallback(
     ReadThreadBytesReceived callback, void *callback_baton) {
   m_callback = callback;
   m_callback_baton = callback_baton;
 }
 

source/Core/Debugger.cpp

if (listener_sp->GetEvent(event_sp, llvm::None)) {
           m_forward_listener_sp->AddEvent(event_sp);
       }
     }
   }
 }
 
 lldb::thread_result_t Debugger::EventHandlerThread(lldb::thread_arg_t arg) {
   ((Debugger *)arg)->DefaultEventHandler();
-  return nullptr;
+  return {};
 }
 
 bool Debugger::StartEventHandlerThread() {
   if (!m_event_handler_thread.IsJoinable()) {
     // We must synchronize with the DefaultEventHandler() thread to ensure it
     // is up and running and listening to events before we return from this
     // function. We do this by listening to events for the
     // eBroadcastBitEventThreadIsListening from the m_sync_broadcaster
if (m_event_handler_thread.IsJoinable()) {
     m_event_handler_thread.Join(nullptr);
   }
 }
 
 lldb::thread_result_t Debugger::IOHandlerThread(lldb::thread_arg_t arg) {
   Debugger *debugger = (Debugger *)arg;
   debugger->ExecuteIOHandlers();
   debugger->StopEventHandlerThread();
-  return nullptr;
+  return {};
 }
 
 bool Debugger::HasIOHandlerThread() { return m_io_handler_thread.IsJoinable(); }
 
 bool Debugger::StartIOHandlerThread() {
   if (!m_io_handler_thread.IsJoinable())
     m_io_handler_thread = ThreadLauncher::LaunchThread(
         "lldb.debugger.io-handler", IOHandlerThread, this, nullptr,

source/Host/common/TaskPool.cpp

if (m_thread_count < GetHardwareConcurrencyHint()) {
     lldb_private::ThreadLauncher::LaunchThread("task-pool.worker", WorkerPtr,
                                                this, nullptr, min_stack_size)
         .Release();
   }
 }
 
 lldb::thread_result_t TaskPoolImpl::WorkerPtr(void *pool) {
   Worker((TaskPoolImpl *)pool);
-  return nullptr;
+  return {};
 }
 
 void TaskPoolImpl::Worker(TaskPoolImpl *pool) {
   while (true) {
     std::unique_lock<std::mutex> lock(pool->m_tasks_mutex);
     if (pool->m_tasks.empty()) {
       pool->m_thread_count--;
       break;

source/Host/windows/HostProcessWindows.cpp

lldb::thread_result_t HostProcessWindows::MonitorThread(void *thread_arg) {
   MonitorInfo *info = static_cast<MonitorInfo *>(thread_arg);
   if (info) {
     ::WaitForSingleObject(info->process_handle, INFINITE);
     ::GetExitCodeProcess(info->process_handle, &exit_code);
     info->callback(::GetProcessId(info->process_handle), true, 0, exit_code);
     ::CloseHandle(info->process_handle);
     delete (info);
   }
-  return 0;
+  return {};
 }
 
 void HostProcessWindows::Close() {
   if (m_owns_handle && m_process != LLDB_INVALID_PROCESS)
     ::CloseHandle(m_process);
   m_process = nullptr;
 }

source/Plugins/Process/Windows/Common/DebuggerThread.cpp

lldb::thread_result_t DebuggerThread::DebuggerThreadLaunchRoutine(
   // throw away the process handle we got from CreateProcess because Windows
   // will give us another (potentially more useful?) handle when it sends us
   // the CREATE_PROCESS_DEBUG_EVENT.
   if (error.Success())
     DebugLoop();
   else
     m_debug_delegate->OnDebuggerError(error, 0);
 
-  return 0;
+  return {};
 }
 
 lldb::thread_result_t DebuggerThread::DebuggerThreadAttachRoutine(
     lldb::pid_t pid, const ProcessAttachInfo &attach_info) {
   // Grab a shared_ptr reference to this so that we know it won't get deleted
   // until after the thread routine has exited.
   std::shared_ptr<DebuggerThread> this_ref(shared_from_this());
 
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   LLDB_LOG(log, "preparing to attach to process '{0}' on background thread.",
            pid);
 
   if (!DebugActiveProcess((DWORD)pid)) {
     Status error(::GetLastError(), eErrorTypeWin32);
     m_debug_delegate->OnDebuggerError(error, 0);
-    return 0;
+    return {};
   }
 
   // The attach was successful, enter the debug loop.  From here on out, this
   // is no different than a create process operation, so all the same comments
   // in DebugLaunch should apply from this point out.
   DebugLoop();
 
-  return 0;
+  return {};
 }
 
 Status DebuggerThread::StopDebugging(bool terminate) {
   Status error;
 
   lldb::pid_t pid = m_process.GetProcessId();
 
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);