[lldb][NFC] Use static_cast instead of reinterpret_cast where possible

[teemperor]

Summary

There are a few places in LLDB where we do a reinterpret_cast for conversions that we could also do with static_cast. This patch moves all this code to static_cast.

[shafik]

lldb/tools/debugserver/source/MacOSX/MachProcess.mm

1745

static_cast<uint64_t>(addr) and static_cast<uint64_t>(length)

1777

static_cast<uint64_t>(addr) and static_cast<uint64_t>(length)

You can use -Wold-style-cast to warm on C-style casts.

2306

static_cast<uint64_t>(buf_size)

2466

static_cast<uint64_t>(buf_size)

[shafik]

This is a great change! Moving to stricter casts clarifies intent and reduces the chance that later changes can introduce bugs accidentally.

[labath]

cool

[teemperor]

lldb/tools/debugserver/source/MacOSX/MachProcess.mm

1745

Uhm, I agree with removing those C casts, but I don't want to start removing a few random C casts in a patch that is about removing reinterpret_cast (and you anyway already opened a review for removing C casts). I'll can make a separate patch for all the C casts (or we could fix those APIs to not be unsafe variadic functions which would remove the need to cast everything).

lldb/source/API/SBEvent.cpp

SBEvent::operator bool() const {
   // See comments in SBEvent::get()....
   return SBEvent::get() != nullptr;
 }
 
 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
   LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
                             (const lldb::SBEvent &), event);
 
-  return reinterpret_cast<const char *>(
+  return static_cast<const char *>(
       EventDataBytes::GetBytesFromEvent(event.get()));
 }
 
 bool SBEvent::GetDescription(SBStream &description) {
   LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
                      description);
 
   Stream &strm = description.ref();

lldb/source/Core/Debugger.cpp

if (listener_sp->GetEvent(event_sp, llvm::None)) {
           } else if (broadcaster_class == broadcaster_class_thread) {
             HandleThreadEvent(event_sp);
           } else if (broadcaster == m_command_interpreter_up.get()) {
             if (event_type &
                 CommandInterpreter::eBroadcastBitQuitCommandReceived) {
               done = true;
             } else if (event_type &
                        CommandInterpreter::eBroadcastBitAsynchronousErrorData) {
-              const char *data = reinterpret_cast<const char *>(
+              const char *data = static_cast<const char *>(
                   EventDataBytes::GetBytesFromEvent(event_sp.get()));
               if (data && data[0]) {
                 StreamSP error_sp(GetAsyncErrorStream());
                 if (error_sp) {
                   error_sp->PutCString(data);
                   error_sp->Flush();
                 }
               }
             } else if (event_type & CommandInterpreter::
                                         eBroadcastBitAsynchronousOutputData) {
-              const char *data = reinterpret_cast<const char *>(
+              const char *data = static_cast<const char *>(
                   EventDataBytes::GetBytesFromEvent(event_sp.get()));
               if (data && data[0]) {
                 StreamSP output_sp(GetAsyncOutputStream());
                 if (output_sp) {
                   output_sp->PutCString(data);
                   output_sp->Flush();
                 }
               }

lldb/source/Host/common/NativeProcessProtocol.cpp

NativeProcessProtocol::ReadCStringFromMemory(lldb::addr_t addr, char *buffer,
   char *curr_buffer = buffer;
   total_bytes_read = 0;
   Status status;
 
   while (bytes_left > 0 && status.Success()) {
     addr_t cache_line_bytes_left =
         cache_line_size - (curr_addr % cache_line_size);
     addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
-    status = ReadMemory(curr_addr, reinterpret_cast<void *>(curr_buffer),
+    status = ReadMemory(curr_addr, static_cast<void *>(curr_buffer),
                         bytes_to_read, bytes_read);
 
     if (bytes_read == 0)
       break;
 
     void *str_end = std::memchr(curr_buffer, '\0', bytes_read);
     if (str_end != nullptr) {
       total_bytes_read =
-          (size_t)(reinterpret_cast<char *>(str_end) - buffer + 1);
+          static_cast<size_t>((static_cast<char *>(str_end) - buffer + 1));
       status.Clear();
       break;
     }
 
     total_bytes_read += bytes_read;
     curr_buffer += bytes_read;
     curr_addr += bytes_read;
     bytes_left -= bytes_read;

lldb/source/Host/macosx/objcxx/Host.mm

 }
 
 static bool AddPosixSpawnFileAction(void *_file_actions, const FileAction *info,
                                     Log *log, Status &error) {
   if (info == NULL)
     return false;
 
   posix_spawn_file_actions_t *file_actions =
-      reinterpret_cast<posix_spawn_file_actions_t *>(_file_actions);
+      static_cast<posix_spawn_file_actions_t *>(_file_actions);
 
   switch (info->GetAction()) {
   case FileAction::eFileActionNone:
     error.Clear();
     break;
 
   case FileAction::eFileActionClose:
     if (info->GetFD() == -1)
dispatch_source_t source = ::dispatch_source_create(
       DISPATCH_SOURCE_TYPE_PROC, pid, mask,
       ::dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0));
 
   LLDB_LOGF(log,
             "Host::StartMonitoringChildProcess "
             "(callback, pid=%i, monitor_signals=%i) "
             "source = %p\n",
             static_cast<int>(pid), monitor_signals,
-            reinterpret_cast<void *>(source));
+            static_cast<void *>(source));
 
   if (source) {
     Host::MonitorChildProcessCallback callback_copy = callback;
     ::dispatch_source_set_cancel_handler(source, ^{
       dispatch_release(source);
     });
     ::dispatch_source_set_event_handler(source, ^{
 

lldb/source/Host/posix/PipePosix.cpp

Status PipePosix::ReadWithTimeout(void *buf, size_t size,
   SelectHelper select_helper;
   select_helper.SetTimeout(timeout);
   select_helper.FDSetRead(fd);
 
   Status error;
   while (error.Success()) {
     error = select_helper.Select();
     if (error.Success()) {
-      auto result = ::read(fd, reinterpret_cast<char *>(buf) + bytes_read,
-                           size - bytes_read);
+      auto result =
+          ::read(fd, static_cast<char *>(buf) + bytes_read, size - bytes_read);
       if (result != -1) {
         bytes_read += result;
         if (bytes_read == size || result == 0)
           break;
       } else if (errno == EINTR) {
         continue;
       } else {
         error.SetErrorToErrno();
Status PipePosix::Write(const void *buf, size_t size, size_t &bytes_written) {
   SelectHelper select_helper;
   select_helper.SetTimeout(std::chrono::seconds(0));
   select_helper.FDSetWrite(fd);
 
   Status error;
   while (error.Success()) {
     error = select_helper.Select();
     if (error.Success()) {
-      auto result =
-          ::write(fd, reinterpret_cast<const char *>(buf) + bytes_written,
+      auto result = ::write(fd, static_cast<const char *>(buf) + bytes_written,
                             size - bytes_written);
       if (result != -1) {
         bytes_written += result;
         if (bytes_written == size)
           break;
       } else if (errno == EINTR) {
         continue;
       } else {
         error.SetErrorToErrno();
       }
     }
   }
   return error;
 }

lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

bool ASTResultSynthesizer::SynthesizeBodyResult(CompoundStmt *Body,
 
   StmtResult result_initialization_stmt_result(m_sema->ActOnDeclStmt(
       result_decl_group_ptr, SourceLocation(), SourceLocation()));
 
   ////////////////////////////////////////////////
   // replace the old statement with the new one
   //
 
-  *last_stmt_ptr =
-      reinterpret_cast<Stmt *>(result_initialization_stmt_result.get());
+  *last_stmt_ptr = static_cast<Stmt *>(result_initialization_stmt_result.get());
 
   return true;
 }
 
 void ASTResultSynthesizer::HandleTranslationUnit(ASTContext &Ctx) {
   if (m_passthrough)
     m_passthrough->HandleTranslationUnit(Ctx);
 }

lldb/source/Plugins/ExpressionParser/Clang/ClangDeclVendor.cpp

uint32_t ClangDeclVendor::FindDecls(ConstString name, bool append,
                                     uint32_t max_matches,
                                     std::vector<clang::NamedDecl *> &decls) {
   if (!append)
     decls.clear();
 
   std::vector<CompilerDecl> compiler_decls;
   uint32_t ret = FindDecls(name, /*append*/ false, max_matches, compiler_decls);
   for (CompilerDecl compiler_decl : compiler_decls) {
-    clang::Decl *d =
-        reinterpret_cast<clang::Decl *>(compiler_decl.GetOpaqueDecl());
+    clang::Decl *d = static_cast<clang::Decl *>(compiler_decl.GetOpaqueDecl());
     clang::NamedDecl *nd = llvm::cast<clang::NamedDecl>(d);
     decls.push_back(nd);
   }
   return ret;
 }

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

if (error.Fail()) {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationServerLLGS::%s failed, read of "
               "requested register %" PRIu32 " (%s) failed: %s",
               __FUNCTION__, reg_index, reg_info->name, error.AsCString());
     return SendErrorResponse(0x15);
   }
 
   const uint8_t *const data =
-      reinterpret_cast<const uint8_t *>(reg_value.GetBytes());
+      static_cast<const uint8_t *>(reg_value.GetBytes());
   if (!data) {
     LLDB_LOGF(log,
               "GDBRemoteCommunicationServerLLGS::%s failed to get data "
               "bytes from requested register %" PRIu32,
               __FUNCTION__, reg_index);
     return SendErrorResponse(0x15);
   }
 

lldb/source/Target/Target.cpp

 void TargetProperties::SetRequireHardwareBreakpoints(bool b) {
   const uint32_t idx = ePropertyRequireHardwareBreakpoints;
   m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
 }
 
 void TargetProperties::Arg0ValueChangedCallback(void *target_property_ptr,
                                                 OptionValue *) {
   TargetProperties *this_ =
-      reinterpret_cast<TargetProperties *>(target_property_ptr);
+      static_cast<TargetProperties *>(target_property_ptr);
   this_->m_launch_info.SetArg0(this_->GetArg0());
 }
 
 void TargetProperties::RunArgsValueChangedCallback(void *target_property_ptr,
                                                    OptionValue *) {
   TargetProperties *this_ =
-      reinterpret_cast<TargetProperties *>(target_property_ptr);
+      static_cast<TargetProperties *>(target_property_ptr);
   Args args;
   if (this_->GetRunArguments(args))
     this_->m_launch_info.GetArguments() = args;
 }
 
 void TargetProperties::EnvVarsValueChangedCallback(void *target_property_ptr,
                                                    OptionValue *) {
   TargetProperties *this_ =
-      reinterpret_cast<TargetProperties *>(target_property_ptr);
+      static_cast<TargetProperties *>(target_property_ptr);
   this_->m_launch_info.GetEnvironment() = this_->GetEnvironment();
 }
 
 void TargetProperties::InputPathValueChangedCallback(void *target_property_ptr,
                                                      OptionValue *) {
   TargetProperties *this_ =
-      reinterpret_cast<TargetProperties *>(target_property_ptr);
+      static_cast<TargetProperties *>(target_property_ptr);
   this_->m_launch_info.AppendOpenFileAction(
       STDIN_FILENO, this_->GetStandardInputPath(), true, false);
 }
 
 void TargetProperties::OutputPathValueChangedCallback(void *target_property_ptr,
                                                       OptionValue *) {
   TargetProperties *this_ =
-      reinterpret_cast<TargetProperties *>(target_property_ptr);
+      static_cast<TargetProperties *>(target_property_ptr);
   this_->m_launch_info.AppendOpenFileAction(
       STDOUT_FILENO, this_->GetStandardOutputPath(), false, true);
 }
 
 void TargetProperties::ErrorPathValueChangedCallback(void *target_property_ptr,
                                                      OptionValue *) {
   TargetProperties *this_ =
-      reinterpret_cast<TargetProperties *>(target_property_ptr);
+      static_cast<TargetProperties *>(target_property_ptr);
   this_->m_launch_info.AppendOpenFileAction(
       STDERR_FILENO, this_->GetStandardErrorPath(), false, true);
 }
 
 void TargetProperties::DetachOnErrorValueChangedCallback(
     void *target_property_ptr, OptionValue *) {
   TargetProperties *this_ =
-      reinterpret_cast<TargetProperties *>(target_property_ptr);
+      static_cast<TargetProperties *>(target_property_ptr);
   if (this_->GetDetachOnError())
     this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDetachOnError);
   else
     this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDetachOnError);
 }
 
 void TargetProperties::DisableASLRValueChangedCallback(
     void *target_property_ptr, OptionValue *) {
   TargetProperties *this_ =
-      reinterpret_cast<TargetProperties *>(target_property_ptr);
+      static_cast<TargetProperties *>(target_property_ptr);
   if (this_->GetDisableASLR())
     this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableASLR);
   else
     this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableASLR);
 }
 
 void TargetProperties::DisableSTDIOValueChangedCallback(
     void *target_property_ptr, OptionValue *) {
   TargetProperties *this_ =
-      reinterpret_cast<TargetProperties *>(target_property_ptr);
+      static_cast<TargetProperties *>(target_property_ptr);
   if (this_->GetDisableSTDIO())
     this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableSTDIO);
   else
     this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableSTDIO);
 }
 
 // Target::TargetEventData
 

lldb/source/Utility/DataExtractor.cpp

: m_start(nullptr), m_end(nullptr),
       m_byte_order(endian::InlHostByteOrder()), m_addr_size(sizeof(void *)),
       m_data_sp(), m_target_byte_size(1) {}
 
 // This constructor allows us to use data that is owned by someone else. The
 // data must stay around as long as this object is valid.
 DataExtractor::DataExtractor(const void *data, offset_t length,
                              ByteOrder endian, uint32_t addr_size,
                              uint32_t target_byte_size /*=1*/)
-    : m_start(const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(data))),
-      m_end(const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(data)) +
-            length),
+    : m_start(const_cast<uint8_t *>(static_cast<const uint8_t *>(data))),
+      m_end(const_cast<uint8_t *>(static_cast<const uint8_t *>(data)) + length),
       m_byte_order(endian), m_addr_size(addr_size), m_data_sp(),
       m_target_byte_size(target_byte_size) {
   assert(addr_size == 4 || addr_size == 8);
 }
 
 // Make a shared pointer reference to the shared data in "data_sp" and set the
 // endian swapping setting to "swap", and the address size to "addr_size". The
 // shared data reference will ensure the data lives as long as any

 lldb::offset_t DataExtractor::SetData(const void *bytes, offset_t length,
                                       ByteOrder endian) {
   m_byte_order = endian;
   m_data_sp.reset();
   if (bytes == nullptr || length == 0) {
     m_start = nullptr;
     m_end = nullptr;
   } else {
-    m_start = const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(bytes));
+    m_start = const_cast<uint8_t *>(static_cast<const uint8_t *>(bytes));
     m_end = m_start + length;
   }
   return GetByteSize();
 }
 
 // Assign the data for this object to be a subrange in "data" starting
 // "data_offset" bytes into "data" and ending "data_length" bytes later. If
 // "data_offset" is not a valid offset into "data", then this object will

lldb/source/Utility/Environment.cpp

 //===-- Environment.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/Environment.h"
 
 using namespace lldb_private;
 
 char *Environment::Envp::make_entry(llvm::StringRef Key,
                                     llvm::StringRef Value) {
   const size_t size = Key.size() + 1 /*=*/ + Value.size() + 1 /*\0*/;
-  char *Result = reinterpret_cast<char *>(
+  char *Result = static_cast<char *>(
       Allocator.Allocate(sizeof(char) * size, alignof(char)));
   char *Next = Result;
 
   Next = std::copy(Key.begin(), Key.end(), Next);
   *Next++ = '=';
   Next = std::copy(Value.begin(), Value.end(), Next);
   *Next++ = '\0';
 
   return Result;
 }
 
 Environment::Envp::Envp(const Environment &Env) {
-  Data = reinterpret_cast<char **>(
+  Data = static_cast<char **>(
       Allocator.Allocate(sizeof(char *) * (Env.size() + 1), alignof(char *)));
   char **Next = Data;
   for (const auto &KV : Env)
     *Next++ = make_entry(KV.first(), KV.second);
   *Next++ = nullptr;
 }
 
 Environment::Environment(const char *const *Env) {

lldb/source/Utility/Scalar.cpp

) {
   return Scalar::e_void;
 }
 
 Scalar::Scalar() : m_type(e_void), m_float(static_cast<float>(0)) {}
 
 bool Scalar::GetData(DataExtractor &data, size_t limit_byte_size) const {
   size_t byte_size = GetByteSize();
   if (byte_size > 0) {
-    const uint8_t *bytes = reinterpret_cast<const uint8_t *>(GetBytes());
+    const uint8_t *bytes = static_cast<const uint8_t *>(GetBytes());
 
     if (limit_byte_size < byte_size) {
       if (endian::InlHostByteOrder() == eByteOrderLittle) {
         // On little endian systems if we want fewer bytes from the current
         // type we just specify fewer bytes since the LSByte is first...
         byte_size = limit_byte_size;
       } else if (endian::InlHostByteOrder() == eByteOrderBig) {
         // On big endian systems if we want fewer bytes from the current type
const void *Scalar::GetBytes() const {
   case e_sint128:
   case e_uint128:
     apint_words = m_integer.getRawData();
     if (endian::InlHostByteOrder() == eByteOrderBig) {
       swapped_words[0] = apint_words[1];
       swapped_words[1] = apint_words[0];
       apint_words = swapped_words;
     }
-    return reinterpret_cast<const void *>(apint_words);
+    return static_cast<const void *>(apint_words);
   case e_sint256:
   case e_uint256:
     apint_words = m_integer.getRawData();
     if (endian::InlHostByteOrder() == eByteOrderBig) {
       swapped_words[0] = apint_words[3];
       swapped_words[1] = apint_words[2];
       swapped_words[2] = apint_words[1];
       swapped_words[3] = apint_words[0];
       apint_words = swapped_words;
     }
-    return reinterpret_cast<const void *>(apint_words);
+    return static_cast<const void *>(apint_words);
   case e_sint512:
   case e_uint512:
     apint_words = m_integer.getRawData();
     if (endian::InlHostByteOrder() == eByteOrderBig) {
       swapped_words[0] = apint_words[7];
       swapped_words[1] = apint_words[6];
       swapped_words[2] = apint_words[5];
       swapped_words[3] = apint_words[4];
       swapped_words[4] = apint_words[3];
       swapped_words[5] = apint_words[2];
       swapped_words[6] = apint_words[1];
       swapped_words[7] = apint_words[0];
       apint_words = swapped_words;
     }
-    return reinterpret_cast<const void *>(apint_words);
+    return static_cast<const void *>(apint_words);
   case e_float:
     flt_val = m_float.convertToFloat();
-    return reinterpret_cast<const void *>(&flt_val);
+    return static_cast<const void *>(&flt_val);
   case e_double:
     dbl_val = m_float.convertToDouble();
-    return reinterpret_cast<const void *>(&dbl_val);
+    return static_cast<const void *>(&dbl_val);
   case e_long_double:
     llvm::APInt ldbl_val = m_float.bitcastToAPInt();
     apint_words = ldbl_val.getRawData();
     // getRawData always returns a pointer to an array of two uint64_t values,
     // where the least-significant word always comes first.  On big-endian
     // systems we need to swap the two words.
     if (endian::InlHostByteOrder() == eByteOrderBig) {
       swapped_words[0] = apint_words[1];
       swapped_words[1] = apint_words[0];
       apint_words = swapped_words;
     }
-    return reinterpret_cast<const void *>(apint_words);
+    return static_cast<const void *>(apint_words);
   }
   return nullptr;
 }
 
 size_t Scalar::GetByteSize() const {
   switch (m_type) {
   case e_void:
     break;

lldb/source/Utility/StreamString.cpp

 
 StreamString::~StreamString() {}
 
 void StreamString::Flush() {
   // Nothing to do when flushing a buffer based stream...
 }
 
 size_t StreamString::WriteImpl(const void *s, size_t length) {
-  m_packet.append(reinterpret_cast<const char *>(s), length);
+  m_packet.append(static_cast<const char *>(s), length);
   return length;
 }
 
 void StreamString::Clear() {
   m_packet.clear();
   m_bytes_written = 0;
 }
 

lldb/tools/debugserver/source/MacOSX/DarwinLog/DarwinLogCollector.cpp

DNBLogThreadedIf(LOG_DARWIN_LOG, "DarwinLogCollector::%s(): removing %lu "
                    __FUNCTION__, returned_events.size());
   return returned_events;
 }
 
 void DarwinLogCollector::CancelActivityStream() {
   if (!m_activity_stream)
     return;
 
-  DNBLogThreadedIf(LOG_DARWIN_LOG, "DarwinLogCollector::%s(): canceling "
-                                   "activity stream %p",
-                   __FUNCTION__, reinterpret_cast<void *>(m_activity_stream));
+  DNBLogThreadedIf(LOG_DARWIN_LOG,
+                   "DarwinLogCollector::%s(): canceling "
+                   __FUNCTION__, static_cast<void *>(m_activity_stream));
   (*s_os_activity_stream_cancel)(m_activity_stream);
   m_activity_stream = nullptr;
 }

lldb/tools/debugserver/source/MacOSX/MachProcess.mm

DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Interrupt() - process already "
                                   "stopped, no interrupt sent");
   }
   return false;
 }
 
 bool MachProcess::Signal(int signal, const struct timespec *timeout_abstime) {
   DNBLogThreadedIf(LOG_PROCESS,
                    "MachProcess::Signal (signal = %d, timeout = %p)", signal,
-                   reinterpret_cast<const void *>(timeout_abstime));
+                   static_cast<const void *>(timeout_abstime));
   nub_state_t state = GetState();
   if (::kill(ProcessID(), signal) == 0) {
     // If we were running and we have a timeout, wait for the signal to stop
     if (IsRunning(state) && timeout_abstime) {
-      DNBLogThreadedIf(LOG_PROCESS, "MachProcess::Signal (signal = %d, timeout "
-                                    "= %p) waiting for signal to stop "
-                                    "process...",
-                       signal, reinterpret_cast<const void *>(timeout_abstime));
+      DNBLogThreadedIf(LOG_PROCESS,
+                       "MachProcess::Signal (signal = %d, timeout "
+                       signal, static_cast<const void *>(timeout_abstime));
       m_private_events.WaitForSetEvents(eEventProcessStoppedStateChanged,
                                         timeout_abstime);
       state = GetState();
       DNBLogThreadedIf(
           LOG_PROCESS,
           "MachProcess::Signal (signal = %d, timeout = %p) state = %s", signal,
-          reinterpret_cast<const void *>(timeout_abstime),
-          DNBStateAsString(state));
+          static_cast<const void *>(timeout_abstime), DNBStateAsString(state));
       return !IsRunning(state);
     }
     DNBLogThreadedIf(
         LOG_PROCESS,
         "MachProcess::Signal (signal = %d, timeout = %p) not waiting...",
-        signal, reinterpret_cast<const void *>(timeout_abstime));
+        signal, static_cast<const void *>(timeout_abstime));
     return true;
   }
   DNBError err(errno, DNBError::POSIX);
   err.LogThreadedIfError("kill (pid = %d, signo = %i)", ProcessID(), signal);
   return false;
 }
 
 bool MachProcess::SendEvent(const char *event, DNBError &send_err) {
DNBBreakpoint *MachProcess::CreateBreakpoint(nub_addr_t addr, nub_size_t length,
 
   DNBBreakpoint *bp = m_breakpoints.FindByAddress(addr);
   if (bp)
     bp->Retain();
   else
     bp = m_breakpoints.Add(addr, length, hardware);
 
   if (EnableBreakpoint(addr)) {
-    DNBLogThreadedIf(LOG_BREAKPOINTS, "MachProcess::CreateBreakpoint ( addr = "
-                                      "0x%8.8llx, length = %llu) => %p",
-                     (uint64_t)addr, (uint64_t)length,
-                     reinterpret_cast<void *>(bp));
+    DNBLogThreadedIf(LOG_BREAKPOINTS,
+                     "MachProcess::CreateBreakpoint ( addr = "
+                     (uint64_t)addr, (uint64_t)length, static_cast<void *>(bp));
     return bp;
   } else if (bp->Release() == 0) {
     m_breakpoints.Remove(addr);
   }
   // We failed to enable the breakpoint
   return NULL;
 }
 
DNBBreakpoint *MachProcess::CreateWatchpoint(nub_addr_t addr, nub_size_t length,
   // watchpoint
   if (wp)
     return NULL;
 
   wp = m_watchpoints.Add(addr, length, hardware);
   wp->SetIsWatchpoint(watch_flags);
 
   if (EnableWatchpoint(addr)) {
-    DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = "
-                                      "0x%8.8llx, length = %llu) => %p",
-                     (uint64_t)addr, (uint64_t)length,
-                     reinterpret_cast<void *>(wp));
+    DNBLogThreadedIf(LOG_WATCHPOINTS,
+                     "MachProcess::CreateWatchpoint ( addr = "
+                     (uint64_t)addr, (uint64_t)length, static_cast<void *>(wp));
     return wp;
   } else {
     DNBLogThreadedIf(LOG_WATCHPOINTS, "MachProcess::CreateWatchpoint ( addr = "
                                       "0x%8.8llx, length = %llu) => FAILED",
                      (uint64_t)addr, (uint64_t)length);
     m_watchpoints.Remove(addr);
   }
   // We failed to enable the watchpoint
void MachProcess::AppendSTDOUT(char *s, size_t len) {
   m_events.SetEvents(eEventStdioAvailable);
 
   // Wait for the event bit to reset if a reset ACK is requested
   m_events.WaitForResetAck(eEventStdioAvailable);
 }
 
 size_t MachProcess::GetAvailableSTDOUT(char *buf, size_t buf_size) {
   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (&%p[%llu]) ...", __FUNCTION__,
-                   reinterpret_cast<void *>(buf), (uint64_t)buf_size);
+                   static_cast<void *>(buf), (uint64_t)buf_size);
   PTHREAD_MUTEX_LOCKER(locker, m_stdio_mutex);
   size_t bytes_available = m_stdout_data.size();
   if (bytes_available > 0) {
     if (bytes_available > buf_size) {
       memcpy(buf, m_stdout_data.data(), buf_size);
       m_stdout_data.erase(0, buf_size);
       bytes_available = buf_size;
     } else {
void MachProcess::SignalAsyncProfileData(const char *info) {
   m_events.SetEvents(eEventProfileDataAvailable);
 
   // Wait for the event bit to reset if a reset ACK is requested
   m_events.WaitForResetAck(eEventProfileDataAvailable);
 }
 
 size_t MachProcess::GetAsyncProfileData(char *buf, size_t buf_size) {
   DNBLogThreadedIf(LOG_PROCESS, "MachProcess::%s (&%p[%llu]) ...", __FUNCTION__,
-                   reinterpret_cast<void *>(buf), (uint64_t)buf_size);
+                   static_cast<void *>(buf), (uint64_t)buf_size);
   PTHREAD_MUTEX_LOCKER(locker, m_profile_data_mutex);
   if (m_profile_data.empty())
     return 0;
 
   size_t bytes_available = m_profile_data.front().size();
   if (bytes_available > 0) {
     if (bytes_available > buf_size) {
       memcpy(buf, m_profile_data.front().data(), buf_size);
pid_t MachProcess::LaunchForDebug(
     bool no_stdio, nub_launch_flavor_t launch_flavor, int disable_aslr,
     const char *event_data, DNBError &launch_err) {
   // Clear out and clean up from any current state
   Clear();
 
   DNBLogThreadedIf(LOG_PROCESS,
                    "%s( path = '%s', argv = %p, envp = %p, "
                    "launch_flavor = %u, disable_aslr = %d )",
-                   __FUNCTION__, path, reinterpret_cast<const void *>(argv),
-                   reinterpret_cast<const void *>(envp), launch_flavor,
+                   __FUNCTION__, path, static_cast<const void *>(argv),
+                   static_cast<const void *>(envp), launch_flavor,
                    disable_aslr);
 
   // Fork a child process for debugging
   SetState(eStateLaunching);
 
   switch (launch_flavor) {
   case eLaunchFlavorForkExec:
     m_pid = MachProcess::ForkChildForPTraceDebugging(path, argv, envp, this,

 
 pid_t MachProcess::PosixSpawnChildForPTraceDebugging(
     const char *path, cpu_type_t cpu_type, char const *argv[],
     char const *envp[], const char *working_directory, const char *stdin_path,
     const char *stdout_path, const char *stderr_path, bool no_stdio,
     MachProcess *process, int disable_aslr, DNBError &err) {
   posix_spawnattr_t attr;
   short flags;
-  DNBLogThreadedIf(LOG_PROCESS, "%s ( path='%s', argv=%p, envp=%p, "
-                                "working_dir=%s, stdin=%s, stdout=%s "
-                                "stderr=%s, no-stdio=%i)",
-                   __FUNCTION__, path, reinterpret_cast<const void *>(argv),
-                   reinterpret_cast<const void *>(envp), working_directory,
+  DNBLogThreadedIf(LOG_PROCESS,
+                   "%s ( path='%s', argv=%p, envp=%p, "
+                   __FUNCTION__, path, static_cast<const void *>(argv),
+                   static_cast<const void *>(envp), working_directory,
                    stdin_path, stdout_path, stderr_path, no_stdio);
 
   err.SetError(::posix_spawnattr_init(&attr), DNBError::POSIX);
   if (err.Fail() || DNBLogCheckLogBit(LOG_PROCESS))
     err.LogThreaded("::posix_spawnattr_init ( &attr )");
   if (err.Fail())
     return INVALID_NUB_PROCESS;
 

lldb/tools/debugserver/source/MacOSX/MachThread.cpp

MachThread::MachThread(MachProcess *process, bool is_64_bit,
 
   // Get the thread state so we know if a thread is in a state where we can't
   // muck with it and also so we get the suspend count correct in case it was
   // already suspended
   GetBasicInfo();
   DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE,
                    "MachThread::MachThread ( process = %p, tid = 0x%8.8" PRIx64
                    ", seq_id = %u )",
-                   reinterpret_cast<void *>(&m_process), m_unique_id, m_seq_id);
+                   static_cast<void *>(&m_process), m_unique_id, m_seq_id);
 }
 
 MachThread::~MachThread() {
   DNBLogThreadedIf(LOG_THREAD | LOG_VERBOSE,
                    "MachThread::~MachThread() for tid = 0x%8.8" PRIx64 " (%u)",
                    m_unique_id, m_seq_id);
 }