Fix warnings.

[clayborg]

Looks fine.

[clayborg]

You might want to put comments on your "(void)unused_variable;" lines to let people know it is there to make sure that we don't get unused variable warnings so people know not to take them out. It might be a good idea to make a macro that would make this more clear. Maybe something in lldb-defines.h like:

#define UNUSED_IF_ASSERT_DISABLED(x) ((void)(x))

[brucem]

I saw your comment after I had done the merge and was doing the build + push. I'll revisit this soon with a comprehensive way to address this.

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

#else
     debugserver_launch_info.SetLaunchInSeparateProcessGroup(false);
     debugserver_launch_info.SetMonitorProcessCallback(ReapDebugserverProcess, this, false);
 
     std::string platform_scheme;
     std::string platform_ip;
     int platform_port;
     std::string platform_path;
     bool ok = UriParser::Parse(GetConnection()->GetURI().c_str(), platform_scheme, platform_ip, platform_port, platform_path);
+    (void)ok;
     assert(ok);
     Error error = StartDebugserverProcess (
                                      platform_ip.c_str(),
                                      port,
                                      debugserver_launch_info,
                                      port);
 
     lldb::pid_t debugserver_pid = debugserver_launch_info.GetProcessID();

source/Symbol/ClangASTImporter.cpp

ClangASTImporter::Minion::ExecuteDeportWorkQueues ()
     while (!m_decls_to_deport->empty())
     {
         NamedDecl *decl = *m_decls_to_deport->begin();
         
         m_decls_already_deported->insert(decl);
         m_decls_to_deport->erase(decl);
         
         DeclOrigin &origin = to_context_md->m_origins[decl];
+        (void)origin;
         
         assert (origin.ctx == m_source_ctx);    // otherwise we should never have added this
                                                 // because it doesn't need to be deported
         
         Decl *original_decl = to_context_md->m_origins[decl].decl;
         
         ClangASTContext::GetCompleteDecl (m_source_ctx, original_decl);
         

source/Target/Process.cpp

if (m_breakpoint_site_list.FindInRange (addr, addr + size, bp_sites_in_range))
             bp_sites_in_range.ForEach([this, addr, size, &bytes_written, &ubuf, &error](BreakpointSite *bp) -> void {
                 
                 if (error.Success())
                 {
                     addr_t intersect_addr;
                     size_t intersect_size;
                     size_t opcode_offset;
                     const bool intersects = bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset);
+                    (void)intersects;
                     assert(intersects);
                     assert(addr <= intersect_addr && intersect_addr < addr + size);
                     assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
                     assert(opcode_offset + intersect_size <= bp->GetByteSize());
                     
                     // Check for bytes before this breakpoint
                     const addr_t curr_addr = addr + bytes_written;
                     if (intersect_addr > curr_addr)

tools/debugserver/source/CMakeLists.txt

 set(LLVM_NO_RTTI 1)
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/..)
 include_directories(${LLDB_SOURCE_DIR}/source)
 
 if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
   include_directories(MacOSX)
   #include_directories(${CMAKE_CURRENT_BINARY_DIR}/MacOSX)
 
   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -Wl,-sectcreate,__TEXT,__info_plist,${CMAKE_CURRENT_SOURCE_DIR}/../resources/lldb-debugserver-Info.plist")
 endif()
 
+check_cxx_compiler_flag("-Wno-gnu-zero-variadic-macro-arguments"
+                        CXX_SUPPORTS_NO_GNU_ZERO_VARIADIC_MACRO_ARGUMENTS)
+if (CXX_SUPPORTS_NO_GNU_ZERO_VARIADIC_MACRO_ARGUMENTS)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-gnu-zero-variadic-macro-arguments")
+endif ()
+
+check_cxx_compiler_flag("-Wno-vla-extension"
+                        CXX_SUPPORTS_NO_VLA_EXTENSION)
+if (CXX_SUPPORTS_NO_VLA_EXTENSION)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-vla-extension")
+endif ()
+
+check_cxx_compiler_flag("-Wno-zero-length-array"
+                        CXX_SUPPORTS_NO_ZERO_LENGTH_ARRAY)
+if (CXX_SUPPORTS_NO_ZERO_LENGTH_ARRAY)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-zero-length-array")
+endif ()
+
+check_cxx_compiler_flag("-Wno-extended-offsetof"
+                        CXX_SUPPORTS_NO_EXTENDED_OFFSETOF)
+if (CXX_SUPPORTS_NO_EXTENDED_OFFSETOF)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-extended-offsetof")
+endif ()
+
 add_definitions(
   -DDEBUGSERVER_VERSION_STR="${LLDB_VERSION}"
   )
 
 add_library(lldbDebugserverCommon
   #${dnbconfig_header}
   debugserver.cpp
   DNBArch.cpp

tools/debugserver/source/DNB.cpp

if (processSP.get())
                     {
                         ::snprintf (err_str, err_len, "failed to get the task for process %i", pid);
                     }
                 }
             }
             else
             {
                 bool res = AddProcessToMap(pid, processSP);
+                (void)res;
                 assert(res && "Couldn't add process to map!");
                 return pid;
             }
         }
     }
     return INVALID_NUB_PROCESS;
 }
 
DNBProcessAttach (nub_process_t attach_pid, struct timespec *timeout, char *err_str, size_t err_len)
     if (processSP.get())
     {
         DNBLogThreadedIf(LOG_PROCESS, "(DebugNub) attaching to pid %d...", attach_pid);
         pid = processSP->AttachForDebug (attach_pid, err_str,  err_len);
 
         if (pid != INVALID_NUB_PROCESS)
         {
             bool res = AddProcessToMap(pid, processSP);
+            (void)res;
             assert(res && "Couldn't add process to map!");
             spawn_waitpid_thread(pid);
         }
     }
 
     while (pid != INVALID_NUB_PROCESS)
     {
         // Wait for process to start up and hit entry point

tools/debugserver/source/DNBArch.h

 
 struct DNBRegisterValue;
 struct DNBRegisterSetInfo;
 class DNBArchProtocol;
 class MachThread;
 
 typedef DNBArchProtocol * (* DNBArchCallbackCreate)(MachThread *thread);
 typedef const DNBRegisterSetInfo * (* DNBArchCallbackGetRegisterSetInfo)(nub_size_t *num_reg_sets);
-typedef const uint8_t * const (* DNBArchCallbackGetBreakpointOpcode)(nub_size_t byte_size);
+typedef const uint8_t * (* DNBArchCallbackGetBreakpointOpcode)(nub_size_t byte_size);
 
 typedef struct DNBArchPluginInfoTag
 {
     uint32_t cpu_type;
     DNBArchCallbackCreate               Create;
     DNBArchCallbackGetRegisterSetInfo   GetRegisterSetInfo;
     DNBArchCallbackGetBreakpointOpcode  GetBreakpointOpcode;
 } DNBArchPluginInfo;
 
 class DNBArchProtocol
 {
 public:
     static DNBArchProtocol *
     Create (MachThread *thread);
 
     static uint32_t
     GetRegisterCPUType ();
 
     static const DNBRegisterSetInfo * 
     GetRegisterSetInfo (nub_size_t *num_reg_sets);
 
-    static const uint8_t * const 
+    static const uint8_t *
     GetBreakpointOpcode (nub_size_t byte_size);
 
     static void
     RegisterArchPlugin (const DNBArchPluginInfo &arch_info);
 
     static uint32_t
     GetArchitecture ();
 
public:
     virtual bool            ThreadDidStop () = 0;
     virtual bool            NotifyException (MachException::Data& exc) { return false; }
     virtual uint32_t        NumSupportedHardwareBreakpoints() { return 0; }
     virtual uint32_t        NumSupportedHardwareWatchpoints() { return 0; }
     virtual uint32_t        EnableHardwareBreakpoint (nub_addr_t addr, nub_size_t size) { return INVALID_NUB_HW_INDEX; }
     virtual uint32_t        EnableHardwareWatchpoint (nub_addr_t addr, nub_size_t size, bool read, bool write, bool also_set_on_task) { return INVALID_NUB_HW_INDEX; }
     virtual bool            DisableHardwareBreakpoint (uint32_t hw_index) { return false; }
     virtual bool            DisableHardwareWatchpoint (uint32_t hw_index, bool also_set_on_task) { return false; }
-    virtual uint32_t        GetHardwareWatchpointHit() { return INVALID_NUB_HW_INDEX; }
+    virtual uint32_t        GetHardwareWatchpointHit(nub_addr_t &addr) { return INVALID_NUB_HW_INDEX; }
     virtual bool            StepNotComplete () { return false; }
 
 protected:
     friend class MachThread;
 
     uint32_t                GetNextRegisterStateSaveID ()
                             {
                                 return ++m_save_id;

tools/debugserver/source/DNBArch.cpp

 {
     const DNBArchPluginInfo *arch_info = GetArchInfo ();
     if (arch_info)
         return arch_info->Create (thread);
     return NULL;
 
 }
 
-const uint8_t * const 
+const uint8_t *
 DNBArchProtocol::GetBreakpointOpcode (nub_size_t byte_size)
 {
     const DNBArchPluginInfo *arch_info = GetArchInfo ();
     if (arch_info)
         return arch_info->GetBreakpointOpcode (byte_size);
     return NULL;
 }
 

tools/debugserver/source/DNBDataRef.cpp

(
     uint32_t numPerLine,
     const char *format
 )
 {
     uint32_t offset;
     uint32_t count;
     char str[1024];
     str[0] = '\0';
-    int str_offset = 0;
+    size_t str_offset = 0;
 
     for (offset = startOffset, count = 0; ValidOffset(offset) && offset < endOffset; ++count)
     {
         if ((count % numPerLine) == 0)
         {
             // Print out any previous string
             if (str[0] != '\0')
                 DNBLog("%s", str);

tools/debugserver/source/DNBRegisterInfo.cpp

 
 #define PRINT_COMMA_SEPARATOR do { if (pos < end) { if (i > 0) { strncpy(pos, ", ", end - pos); pos += 2; } } } while (0)
 
 void
 DNBRegisterValueClass::Dump(const char *pre, const char *post) const
 {
     if (info.name != NULL)
     {
-        int i;
         char str[1024];
         char *pos;
         char *end = str + sizeof(str);
         if (info.format == Hex)
         {
             switch (info.size)
             {
             case 0:     snprintf(str, sizeof(str), "%s", "error: invalid register size of zero."); break;
             case 1:     snprintf(str, sizeof(str), "0x%2.2x", value.uint8); break;
             case 2:     snprintf(str, sizeof(str), "0x%4.4x", value.uint16); break;
             case 4:     snprintf(str, sizeof(str), "0x%8.8x", value.uint32); break;
             case 8:     snprintf(str, sizeof(str), "0x%16.16llx", value.uint64); break;
             case 16:    snprintf(str, sizeof(str), "0x%16.16llx%16.16llx", value.v_uint64[0], value.v_uint64[1]); break;
             default:
                 strncpy(str, "0x", 3);
                 pos = str + 2;
-                for (i=0; i<info.size; ++i)
+                for (uint32_t i=0; i<info.size; ++i)
                 {
                     if (pos < end)
                         pos += snprintf(pos, end - pos, "%2.2x", (uint32_t)value.v_uint8[i]);
                 }
                 break;
             }
         }
         else
if (info.name != NULL)
             case Vector:
                 if (info.size > 0)
                 {
                     switch (info.format)
                     {
                     case VectorOfSInt8:
                         snprintf(str, sizeof(str), "%s", "sint8   { ");
                         pos = str + strlen(str);
-                        for (i=0; i<info.size; ++i)
+                        for (uint32_t i=0; i<info.size; ++i)
                         {
                             PRINT_COMMA_SEPARATOR;
                             if (pos < end)
                                 pos += snprintf(pos, end - pos, "%d", (int32_t)value.v_sint8[i]);
                         }
                         strlcat(str, " }", sizeof(str));
                         break;
 
                     default:
                         DNBLogError("unsupported vector format %d, defaulting to hex bytes.", info.format);
                     case VectorOfUInt8:
                         snprintf(str, sizeof(str), "%s", "uint8   { ");
                         pos = str + strlen(str);
-                        for (i=0; i<info.size; ++i)
+                        for (uint32_t i=0; i<info.size; ++i)
                         {
                             PRINT_COMMA_SEPARATOR;
                             if (pos < end)
                                 pos += snprintf(pos, end - pos, "%u", (uint32_t)value.v_uint8[i]);
                         }
                         break;
 
                     case VectorOfSInt16:
                         snprintf(str, sizeof(str), "%s", "sint16  { ");
                         pos = str + strlen(str);
-                        for (i=0; i<info.size/2; ++i)
+                        for (uint32_t i=0; i<info.size/2; ++i)
                         {
                             PRINT_COMMA_SEPARATOR;
                             if (pos < end)
                                 pos += snprintf(pos, end - pos, "%d", (int32_t)value.v_sint16[i]);
                         }
                         break;
 
                     case VectorOfUInt16:
                         snprintf(str, sizeof(str), "%s", "uint16  { ");
                         pos = str + strlen(str);
-                        for (i=0; i<info.size/2; ++i)
+                        for (uint32_t i=0; i<info.size/2; ++i)
                         {
                             PRINT_COMMA_SEPARATOR;
                             if (pos < end)
                                 pos += snprintf(pos, end - pos, "%u", (uint32_t)value.v_uint16[i]);
                         }
                         break;
 
                     case VectorOfSInt32:
                         snprintf(str, sizeof(str), "%s", "sint32  { ");
                         pos = str + strlen(str);
-                        for (i=0; i<info.size/4; ++i)
+                        for (uint32_t i=0; i<info.size/4; ++i)
                         {
                             PRINT_COMMA_SEPARATOR;
                             if (pos < end)
                                 pos += snprintf(pos, end - pos, "%d", (int32_t)value.v_sint32[i]);
                         }
                         break;
 
                     case VectorOfUInt32:
                         snprintf(str, sizeof(str), "%s", "uint32  { ");
                         pos = str + strlen(str);
-                        for (i=0; i<info.size/4; ++i)
+                        for (uint32_t i=0; i<info.size/4; ++i)
                         {
                             PRINT_COMMA_SEPARATOR;
                             if (pos < end)
                                 pos += snprintf(pos, end - pos, "%u", (uint32_t)value.v_uint32[i]);
                         }
                         break;
 
                     case VectorOfFloat32:
                         snprintf(str, sizeof(str), "%s", "float32 { ");
                         pos = str + strlen(str);
-                        for (i=0; i<info.size/4; ++i)
+                        for (uint32_t i=0; i<info.size/4; ++i)
                         {
                             PRINT_COMMA_SEPARATOR;
                             if (pos < end)
                                 pos += snprintf(pos, end - pos, "%f", value.v_float32[i]);
                         }
                         break;
 
                     case VectorOfUInt128:
                         snprintf(str, sizeof(str), "%s", "uint128 { ");
                         pos = str + strlen(str);
-                        for (i=0; i<info.size/16; ++i)
+                        for (uint32_t i=0; i<info.size/16; ++i)
                         {
                             PRINT_COMMA_SEPARATOR;
                             if (pos < end)
                                 pos += snprintf(pos, end - pos, "0x%16.16llx%16.16llx", value.v_uint64[i], value.v_uint64[i+1]);
                         }
                         break;
                     }
                     strlcat(str, " }", sizeof(str));

tools/debugserver/source/MacOSX/MachProcess.mm

MachProcess::MachProcess() :
     m_child_stderr      (-1),
     m_path              (),
     m_args              (),
     m_task              (this),
     m_flags             (eMachProcessFlagsNone),
     m_stdio_thread      (0),
     m_stdio_mutex       (PTHREAD_MUTEX_RECURSIVE),
     m_stdout_data       (),
-    m_thread_actions    (),
     m_profile_enabled   (false),
     m_profile_interval_usec (0),
     m_profile_thread    (0),
     m_profile_data_mutex(PTHREAD_MUTEX_RECURSIVE),
     m_profile_data      (),
-    m_thread_list        (),
-    m_activities         (),
+    m_thread_actions    (),
     m_exception_messages (),
     m_exception_messages_mutex (PTHREAD_MUTEX_RECURSIVE),
+    m_thread_list       (),
+    m_activities        (),
     m_state             (eStateUnloaded),
     m_state_mutex       (PTHREAD_MUTEX_RECURSIVE),
     m_events            (0, kAllEventsMask),
     m_private_events    (0, kAllEventsMask),
     m_breakpoints       (),
     m_watchpoints       (),
     m_name_to_addr_callback(NULL),
     m_name_to_addr_baton(NULL),
if (sysctl(mib, (unsigned)(sizeof(mib)/sizeof(int)), &processInfo, &bufsize, NULL, 0) == 0 && bufsize > 0)
             uint64_t pathname_ptr = pathname_address;
             bool still_reading = true;
             while (still_reading && ReadMemory (pathname_ptr, sizeof (strbuf) - 1, strbuf) == sizeof (strbuf) - 1)
             {
                 strbuf[sizeof(strbuf) - 1] = '\0';
                 info.pathname += strbuf;
                 pathname_ptr += sizeof (strbuf) - 1;
                 // Stop if we found nul byte indicating the end of the string
-                for (int i = 0; i < sizeof(strbuf) - 1; i++)
+                for (size_t i = 0; i < sizeof(strbuf) - 1; i++)
                 {
                     if (strbuf[i] == '\0')
                     {
                         still_reading = false;
                         break;
                     }
                 }
             }
MachProcess::WriteMemory (nub_addr_t addr, nub_size_t size, const void *buf)
     nub_size_t opcode_offset;
     const uint8_t *ubuf = (const uint8_t *)buf;
 
     for (size_t i=0; i<num_bps; ++i)
     {
         DNBBreakpoint *bp = bps[i];
 
         const bool intersects = bp->IntersectsRange(addr, size, &intersect_addr, &intersect_size, &opcode_offset);
+        (void)intersects;
         assert(intersects);
         assert(addr <= intersect_addr && intersect_addr < addr + size);
         assert(addr < intersect_addr + intersect_size && intersect_addr + intersect_size <= addr + size);
         assert(opcode_offset + intersect_size <= bp->ByteSize());
         
         // Check for bytes before this breakpoint
         const nub_addr_t curr_addr = addr + bytes_written;
         if (intersect_addr > curr_addr)

tools/debugserver/source/MacOSX/MachTask.mm

static void get_threads_profile_data(DNBProfileDataScanType scanType, task_t task, nub_process_t pid, std::vector<uint64_t> &threads_id, std::vector<std::string> &threads_name, std::vector<uint64_t> &threads_used_usec)
     kern_return_t kr;
     thread_act_array_t threads;
     mach_msg_type_number_t tcnt;
     
     kr = task_threads(task, &threads, &tcnt);
     if (kr != KERN_SUCCESS)
         return;
     
-    for (int i = 0; i < tcnt; i++)
+    for (mach_msg_type_number_t i = 0; i < tcnt; i++)
     {
         thread_identifier_info_data_t identifier_info;
         mach_msg_type_number_t count = THREAD_IDENTIFIER_INFO_COUNT;
         kr = ::thread_info(threads[i], THREAD_IDENTIFIER_INFO, (thread_info_t)&identifier_info, &count);
         if (kr != KERN_SUCCESS) continue;
         
         thread_basic_info_data_t basic_info;
         count = THREAD_BASIC_INFO_COUNT;
if (m_vm_memory.GetMemoryProfile(scanType, task, task_info, m_process->GetCPUType(), pid, vminfo, physical_memory, rprvt, rsize, vprvt, vsize, dirty_size, purgeable, anonymous))
                     profile_data_stream << "thread_used_name:";
                     const size_t len = threads_name[i].size();
                     if (len)
                     {
                         const char *thread_name = threads_name[i].c_str();
                         // Make sure that thread name doesn't interfere with our delimiter.
                         profile_data_stream << RAW_HEXBASE << std::setw(2);
                         const uint8_t *ubuf8 = (const uint8_t *)(thread_name);
-                        for (int j=0; j<len; j++)
+                        for (size_t j=0; j<len; j++)
                         {
                             profile_data_stream << (uint32_t)(ubuf8[j]);
                         }
                         // Reset back to DECIMAL.
                         profile_data_stream << DECIMAL;
                     }
                     profile_data_stream << ';';
                 }

 MachTask::ShutDownExcecptionThread()
 {
     DNBError err;
 
     err = RestoreExceptionPortInfo();
 
     // NULL our our exception port and let our exception thread exit
     mach_port_t exception_port = m_exception_port;
-    m_exception_port = NULL;
+    m_exception_port = 0;
 
     err.SetError(::pthread_cancel(m_exception_thread), DNBError::POSIX);
     if (DNBLogCheckLogBit(LOG_TASK) || err.Fail())
         err.LogThreaded("::pthread_cancel ( thread = %p )", m_exception_thread);
 
     err.SetError(::pthread_join(m_exception_thread, NULL), DNBError::POSIX);
     if (DNBLogCheckLogBit(LOG_TASK) || err.Fail())
         err.LogThreaded("::pthread_join ( thread = %p, value_ptr = NULL)", m_exception_thread);

tools/debugserver/source/MacOSX/MachThread.h

public:
 
     void            ThreadWillResume (const DNBThreadResumeAction *thread_action, bool others_stopped = false);
     bool            ShouldStop(bool &step_more);
     bool            IsStepping();
     bool            ThreadDidStop();
     bool            NotifyException(MachException::Data& exc);
     const MachException::Data& GetStopException() { return m_stop_exception; }
 
-    nub_size_t      GetNumRegistersInSet(int regSet) const;
-    const char *    GetRegisterSetName(int regSet) const;
+    nub_size_t      GetNumRegistersInSet(nub_size_t regSet) const;
+    const char *    GetRegisterSetName(nub_size_t regSet) const;
     const DNBRegisterInfo *
-                    GetRegisterInfo(int regSet, int regIndex) const;
-    void            DumpRegisterState(int regSet);
+                    GetRegisterInfo(nub_size_t regSet, nub_size_t regIndex) const;
+    void            DumpRegisterState(nub_size_t regSet);
     const DNBRegisterSetInfo *
                     GetRegisterSetInfo(nub_size_t *num_reg_sets ) const;
     bool            GetRegisterValue ( uint32_t reg_set_idx, uint32_t reg_idx, DNBRegisterValue *reg_value );
     bool            SetRegisterValue ( uint32_t reg_set_idx, uint32_t reg_idx, const DNBRegisterValue *reg_value );
     nub_size_t      GetRegisterContext (void *buf, nub_size_t buf_len);
     nub_size_t      SetRegisterContext (const void *buf, nub_size_t buf_len);
     uint32_t        SaveRegisterState ();
     bool            RestoreRegisterState (uint32_t save_id);

tools/debugserver/source/MacOSX/MachThread.cpp

 MachThread::SetState(nub_state_t state)
 {
     PTHREAD_MUTEX_LOCKER (locker, m_state_mutex);
     m_state = state;
     DNBLogThreadedIf(LOG_THREAD, "MachThread::SetState ( %s ) for tid = 0x%8.8" PRIx64 "", DNBStateAsString(state), m_unique_id);
 }
 
 nub_size_t
-MachThread::GetNumRegistersInSet(int regSet) const
+MachThread::GetNumRegistersInSet(nub_size_t regSet) const
 {
     if (regSet < m_num_reg_sets)
         return m_reg_sets[regSet].num_registers;
     return 0;
 }
 
 const char *
-MachThread::GetRegisterSetName(int regSet) const
+MachThread::GetRegisterSetName(nub_size_t regSet) const
 {
     if (regSet < m_num_reg_sets)
         return m_reg_sets[regSet].name;
     return NULL;
 }
 
 const DNBRegisterInfo *
-MachThread::GetRegisterInfo(int regSet, int regIndex) const
+MachThread::GetRegisterInfo(nub_size_t regSet, nub_size_t regIndex) const
 {
     if (regSet < m_num_reg_sets)
         if (regIndex < m_reg_sets[regSet].num_registers)
             return &m_reg_sets[regSet].registers[regIndex];
     return NULL;
 }
 void
-MachThread::DumpRegisterState(int regSet)
+MachThread::DumpRegisterState(nub_size_t regSet)
 {
     if (regSet == REGISTER_SET_ALL)
     {
         for (regSet = 1; regSet < m_num_reg_sets; regSet++)
             DumpRegisterState(regSet);
     }
     else
     {

tools/debugserver/source/MacOSX/MachVMMemory.cpp

MachVMMemory::Read(task_t task, nub_addr_t address, void *data, nub_size_t data_count)
 
     nub_size_t total_bytes_read = 0;
     nub_addr_t curr_addr = address;
     uint8_t *curr_data = (uint8_t*)data;
     while (total_bytes_read < data_count)
     {
         mach_vm_size_t curr_size = MaxBytesLeftInPage(task, curr_addr, data_count - total_bytes_read);
         mach_msg_type_number_t curr_bytes_read = 0;
-        vm_offset_t vm_memory = NULL;
+        vm_offset_t vm_memory = 0;
         m_err = ::mach_vm_read (task, curr_addr, curr_size, &vm_memory, &curr_bytes_read);
         
         if (DNBLogCheckLogBit(LOG_MEMORY))
             m_err.LogThreaded("::mach_vm_read ( task = 0x%4.4x, addr = 0x%8.8llx, size = %llu, data => %8.8p, dataCnt => %i )", task, (uint64_t)curr_addr, (uint64_t)curr_size, vm_memory, curr_bytes_read);
 
         if (m_err.Success())
         {
             if (curr_bytes_read != curr_size)

tools/debugserver/source/MacOSX/arm/DNBArchImpl.h

#endif
     virtual uint64_t        GetPC(uint64_t failValue);    // Get program counter
     virtual kern_return_t   SetPC(uint64_t value);
     virtual uint64_t        GetSP(uint64_t failValue);    // Get stack pointer
     virtual void            ThreadWillResume();
     virtual bool            ThreadDidStop();
     virtual bool            NotifyException(MachException::Data& exc);
 
     static DNBArchProtocol *Create (MachThread *thread);
-    static const uint8_t * const SoftwareBreakpointOpcode (nub_size_t byte_size);
+    static const uint8_t *  SoftwareBreakpointOpcode (nub_size_t byte_size);
     static uint32_t         GetCPUType();
 
     virtual uint32_t        NumSupportedHardwareBreakpoints();
     virtual uint32_t        NumSupportedHardwareWatchpoints();
     virtual uint32_t        EnableHardwareBreakpoint (nub_addr_t addr, nub_size_t size);
     virtual bool            DisableHardwareBreakpoint (uint32_t hw_break_index);
 
     virtual uint32_t        EnableHardwareWatchpoint (nub_addr_t addr, nub_size_t size, bool read, bool write, bool also_set_on_task);

tools/debugserver/source/MacOSX/arm/DNBArchImpl.cpp

 
 DNBArchProtocol *
 DNBArchMachARM::Create (MachThread *thread)
 {
     DNBArchMachARM *obj = new DNBArchMachARM (thread);
     return obj;
 }
 
-const uint8_t * const
+const uint8_t *
 DNBArchMachARM::SoftwareBreakpointOpcode (nub_size_t byte_size)
 {
     switch (byte_size)
     {
     case 2: return g_thumb_breakpoint_opcode;
     case 4: return g_arm_breakpoint_opcode;
     }
     return NULL;
if (buf && buf_len)
         ::memcpy (p, &m_state.context.gpr, sizeof(m_state.context.gpr));
         p += sizeof(m_state.context.gpr);
         ::memcpy (p, &m_state.context.vfp, sizeof(m_state.context.vfp));
         p += sizeof(m_state.context.vfp);
         ::memcpy (p, &m_state.context.exc, sizeof(m_state.context.exc));
         p += sizeof(m_state.context.exc);
 
         size_t bytes_written = p - (uint8_t *)buf;
+        (void)bytes_written;
         assert (bytes_written == size);
 
     }
     DNBLogThreadedIf (LOG_THREAD, "DNBArchMachARM::GetRegisterContext (buf = %p, len = %llu) => %llu", buf, (uint64_t)buf_len, (uint64_t)size);
     // Return the size of the register context even if NULL was passed in
     return size;
 }
 
if (size)
         ::memcpy (&m_state.context.gpr, p, sizeof(m_state.context.gpr));
         p += sizeof(m_state.context.gpr);
         ::memcpy (&m_state.context.vfp, p, sizeof(m_state.context.vfp));
         p += sizeof(m_state.context.vfp);
         ::memcpy (&m_state.context.exc, p, sizeof(m_state.context.exc));
         p += sizeof(m_state.context.exc);
         
         size_t bytes_written = p - (uint8_t *)buf;
+        (void)bytes_written;
         assert (bytes_written == size);
 
         if (SetGPRState() | SetVFPState() | SetEXCState())
             return 0;
     }
     DNBLogThreadedIf (LOG_THREAD, "DNBArchMachARM::SetRegisterContext (buf = %p, len = %llu) => %llu", buf, (uint64_t)buf_len, (uint64_t)size);
     return size;
 }

tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.h

public:
     virtual uint64_t        GetPC(uint64_t failValue);    // Get program counter
     virtual kern_return_t   SetPC(uint64_t value);
     virtual uint64_t        GetSP(uint64_t failValue);    // Get stack pointer
     virtual void            ThreadWillResume();
     virtual bool            ThreadDidStop();
     virtual bool            NotifyException(MachException::Data& exc);
 
     static DNBArchProtocol *Create (MachThread *thread);
-    static const uint8_t * const SoftwareBreakpointOpcode (nub_size_t byte_size);
+    static const uint8_t *  SoftwareBreakpointOpcode (nub_size_t byte_size);
     static uint32_t         GetCPUType();
 
     virtual uint32_t        NumSupportedHardwareWatchpoints();
     virtual uint32_t        EnableHardwareWatchpoint (nub_addr_t addr, nub_size_t size, bool read, bool write, bool also_set_on_task);
     virtual bool            DisableHardwareWatchpoint (uint32_t hw_break_index, bool also_set_on_task);
     virtual bool            DisableHardwareWatchpoint_helper (uint32_t hw_break_index, bool also_set_on_task);
 
 protected:

tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.cpp

 DNBArchProtocol *
 DNBArchMachARM64::Create (MachThread *thread)
 {
     DNBArchMachARM64 *obj = new DNBArchMachARM64 (thread);
 
     return obj;
 }
 
-const uint8_t * const
+const uint8_t *
 DNBArchMachARM64::SoftwareBreakpointOpcode (nub_size_t byte_size)
 {
     return g_arm_breakpoint_opcode;
 }
 
 uint32_t
 DNBArchMachARM64::GetCPUType()
 {
if (buf && buf_len)
         ::memcpy (p, &m_state.context.gpr, sizeof(m_state.context.gpr));
         p += sizeof(m_state.context.gpr);
         ::memcpy (p, &m_state.context.vfp, sizeof(m_state.context.vfp));
         p += sizeof(m_state.context.vfp);
         ::memcpy (p, &m_state.context.exc, sizeof(m_state.context.exc));
         p += sizeof(m_state.context.exc);
         
         size_t bytes_written = p - (uint8_t *)buf;
+        (void)bytes_written;
         assert (bytes_written == size);
     }
     DNBLogThreadedIf (LOG_THREAD, "DNBArchMachARM64::GetRegisterContext (buf = %p, len = %zu) => %zu", buf, buf_len, size);
     // Return the size of the register context even if NULL was passed in
     return size;
 }
 
 nub_size_t
if (size)
         ::memcpy (&m_state.context.gpr, p, sizeof(m_state.context.gpr));
         p += sizeof(m_state.context.gpr);
         ::memcpy (&m_state.context.vfp, p, sizeof(m_state.context.vfp));
         p += sizeof(m_state.context.vfp);
         ::memcpy (&m_state.context.exc, p, sizeof(m_state.context.exc));
         p += sizeof(m_state.context.exc);
         
         size_t bytes_written = p - (uint8_t *)buf;
+        (void)bytes_written;
         assert (bytes_written == size);
         SetGPRState();
         SetVFPState();
         SetEXCState();
     }
     DNBLogThreadedIf (LOG_THREAD, "DNBArchMachARM64::SetRegisterContext (buf = %p, len = %zu) => %zu", buf, buf_len, size);
     return size;
 }

tools/debugserver/source/MacOSX/i386/DNBArchImplI386.h

protected:
     kern_return_t SetGPRState ();
     kern_return_t SetFPUState ();
     kern_return_t SetEXCState ();
     kern_return_t SetDBGState (bool also_set_on_task);
 
     static DNBArchProtocol *
     Create (MachThread *thread);
     
-    static const uint8_t * const
+    static const uint8_t *
     SoftwareBreakpointOpcode (nub_size_t byte_size);
 
     static const DNBRegisterSetInfo *
     GetRegisterSetInfo(nub_size_t *num_reg_sets);
     
     static uint32_t
     GetRegisterContextSize();
 

tools/debugserver/source/MacOSX/i386/DNBArchImplI386.cpp

 
 DNBArchProtocol *
 DNBArchImplI386::Create (MachThread *thread)
 {
     DNBArchImplI386 *obj = new DNBArchImplI386 (thread);
     return obj;
 }
 
-const uint8_t * const
+const uint8_t *
 DNBArchImplI386::SoftwareBreakpointOpcode (nub_size_t byte_size)
 {
     static const uint8_t g_breakpoint_opcode[] = { 0xCC };
     if (byte_size == 1)
         return g_breakpoint_opcode;
     return NULL;
 }
 
if (buf && buf_len)
             }
             
             // Copy the exception registers
             memcpy(p, &m_state.context.exc, sizeof(EXC));
             p += sizeof(EXC);
             
             // make sure we end up with exactly what we think we should have
             size_t bytes_written = p - (uint8_t *)buf;
+            (void)bytes_written;
             assert (bytes_written == size);
         }
     }
     DNBLogThreadedIf (LOG_THREAD, "DNBArchImplI386::GetRegisterContext (buf = %p, len = %llu) => %llu", buf, (uint64_t)buf_len, (uint64_t)size);
     // Return the size of the register context even if NULL was passed in
     return size;
 }
 
if (size)
         }
         
         // Copy the exception registers
         memcpy(&m_state.context.exc, p, sizeof(EXC));
         p += sizeof(EXC);
         
         // make sure we end up with exactly what we think we should have
         size_t bytes_written = p - (uint8_t *)buf;
+        (void)bytes_written;
         assert (bytes_written == size);
         kern_return_t kret;
         if ((kret = SetGPRState()) != KERN_SUCCESS)
             DNBLogThreadedIf (LOG_THREAD, "DNBArchImplI386::SetRegisterContext (buf = %p, len = %llu) error: GPR regs failed to write: %u", buf, (uint64_t)buf_len, kret);
         if ((kret = SetFPUState()) != KERN_SUCCESS)
             DNBLogThreadedIf (LOG_THREAD, "DNBArchImplI386::SetRegisterContext (buf = %p, len = %llu) error: %s regs failed to write: %u", buf, (uint64_t)buf_len, CPUHasAVX() ? "AVX" : "FPU", kret);
         if ((kret = SetEXCState()) != KERN_SUCCESS)
             DNBLogThreadedIf (LOG_THREAD, "DNBArchImplI386::SetRegisterContext (buf = %p, len = %llu) error: EXP regs failed to write: %u", buf, (uint64_t)buf_len, kret);

tools/debugserver/source/MacOSX/ppc/DNBArchImpl.h

public:
     virtual bool            RegisterSetStateIsValid (int set) const;
 
     virtual uint64_t        GetPC(uint64_t failValue);    // Get program counter
     virtual kern_return_t   SetPC(uint64_t value);
     virtual uint64_t        GetSP(uint64_t failValue);    // Get stack pointer
     virtual bool            ThreadWillResume();
     virtual bool            ThreadDidStop();
 
-    static const uint8_t * const SoftwareBreakpointOpcode (nub_size_t byte_size);
+    static const uint8_t *  SoftwareBreakpointOpcode (nub_size_t byte_size);
     static uint32_t         GetCPUType();
 
 protected:
 
 
     kern_return_t    EnableHardwareSingleStep (bool enable);
 
     typedef enum RegisterSetTag

tools/debugserver/source/MacOSX/ppc/DNBArchImpl.cpp

 #include "MacOSX/ppc/DNBArchImpl.h"
 #include "MacOSX/MachThread.h"
 #include "DNBBreakpoint.h"
 #include "DNBLog.h"
 #include "DNBRegisterInfo.h"
 
 static const uint8_t g_breakpoint_opcode[] = { 0x7F, 0xC0, 0x00, 0x08 };
 
-const uint8_t * const
+const uint8_t *
 DNBArchMachPPC::SoftwareBreakpointOpcode (nub_size_t size)
 {
     if (size == 4)
         return g_breakpoint_opcode;
     return NULL;
 }
 
 uint32_t

tools/debugserver/source/MacOSX/x86_64/DNBArchImplX86_64.h

protected:
     kern_return_t SetGPRState ();
     kern_return_t SetFPUState ();
     kern_return_t SetEXCState ();
     kern_return_t SetDBGState (bool also_set_on_task);
 
     static DNBArchProtocol *
     Create (MachThread *thread);
     
-    static const uint8_t * const
+    static const uint8_t *
     SoftwareBreakpointOpcode (nub_size_t byte_size);
 
     static const DNBRegisterSetInfo *
     GetRegisterSetInfo(nub_size_t *num_reg_sets);
     
     static uint32_t GetRegisterContextSize();
 
     // Helper functions for watchpoint manipulations.

tools/debugserver/source/MacOSX/x86_64/DNBArchImplX86_64.cpp

 
 DNBArchProtocol *
 DNBArchImplX86_64::Create (MachThread *thread)
 {
     DNBArchImplX86_64 *obj = new DNBArchImplX86_64 (thread);
     return obj;
 }
 
-const uint8_t * const
+const uint8_t *
 DNBArchImplX86_64::SoftwareBreakpointOpcode (nub_size_t byte_size)
 {
     static const uint8_t g_breakpoint_opcode[] = { 0xCC };
     if (byte_size == 1)
         return g_breakpoint_opcode;
     return NULL;
 }
 
if (buf && buf_len)
             }
             
             // Copy the exception registers
             memcpy(p, &m_state.context.exc, sizeof(EXC));
             p += sizeof(EXC);
             
             // make sure we end up with exactly what we think we should have
             size_t bytes_written = p - (uint8_t *)buf;
+            (void)bytes_written;
             assert (bytes_written == size);
         }
 
     }
 
     DNBLogThreadedIf (LOG_THREAD, "DNBArchImplX86_64::GetRegisterContext (buf = %p, len = %llu) => %u", buf, (uint64_t)buf_len, size);
     // Return the size of the register context even if NULL was passed in
     return size;
if (size)
         }
         
         // Copy the exception registers
         memcpy(&m_state.context.exc, p, sizeof(EXC));
         p += sizeof(EXC);
         
         // make sure we end up with exactly what we think we should have
         size_t bytes_written = p - (uint8_t *)buf;
+        (void)bytes_written;
         assert (bytes_written == size);
 
         kern_return_t kret;
         if ((kret = SetGPRState()) != KERN_SUCCESS)
             DNBLogThreadedIf (LOG_THREAD, "DNBArchImplX86_64::SetRegisterContext (buf = %p, len = %llu) error: GPR regs failed to write: %u", buf, (uint64_t)buf_len, kret);
         if ((kret = SetFPUState()) != KERN_SUCCESS)
             DNBLogThreadedIf (LOG_THREAD, "DNBArchImplX86_64::SetRegisterContext (buf = %p, len = %llu) error: %s regs failed to write: %u", buf, (uint64_t)buf_len, CPUHasAVX() ? "AVX" : "FPU", kret);
         if ((kret = SetEXCState()) != KERN_SUCCESS)

tools/debugserver/source/RNBRemote.h

public:
 
     void            SetContinueThread (nub_thread_t tid)
                     {
                         m_continue_thread = tid;
                     }
 
     nub_thread_t    GetCurrentThread () const
                     {
-                        if (m_thread == 0 || m_thread == -1)
+                        if (m_thread == 0 || m_thread == (nub_thread_t)-1)
                             return DNBProcessGetCurrentThread (m_ctx.ProcessID());
                         return m_thread;
                     }
 
     void            SetCurrentThread (nub_thread_t tid)
                     {
                         DNBProcessSetCurrentThread (m_ctx.ProcessID(), tid);
                         m_thread = tid;

tools/debugserver/source/RNBRemote.cpp

RNBRemote::SendPacket (const std::string &s)
     char hexbuf[5];
 
     if (m_noack_mode)
     {
         sendpacket += "00";
     }
     else
     {
-        for (int i = 0; i != s_compressed.size(); ++i)
+        for (size_t i = 0; i != s_compressed.size(); ++i)
             cksum += s_compressed[i];
         snprintf (hexbuf, sizeof hexbuf, "%02x", cksum & 0xff);
         sendpacket += hexbuf;
     }
 
     rnb_err_t err = m_comm.Write (sendpacket.c_str(), sendpacket.size());
     if (err != rnb_success)
         return err;

 std::vector<uint8_t>
 decode_binary_data (const char *str, size_t len)
 {
     std::vector<uint8_t> bytes;
     if (len == 0)
     {
         return bytes;
     }
-    if (len == -1)
+    if (len == (size_t)-1)
         len = strlen (str);
 
     while (len--)
     {
         unsigned char c = *str;
         if (c == 0x7d && len > 0)
         {
             len--;
append_hex_value (std::ostream& ostrm, const void *buf, size_t buf_size, bool swap)
     const uint8_t *p = (const uint8_t *)buf;
     if (swap)
     {
         for (i = static_cast<int>(buf_size)-1; i >= 0; i--)
             ostrm << RAWHEX8(p[i]);
     }
     else
     {
-        for (i = 0; i < buf_size; i++)
+        for (size_t i = 0; i < buf_size; i++)
             ostrm << RAWHEX8(p[i]);
     }
 }
 
 void
 append_hexified_string (std::ostream& ostrm, const std::string &string)
 {
     size_t string_size = string.size();
if (DNBThreadGetStopReason (pid, tid, &tid_stop_info))
 
             if (::strcspn (thread_name, "$#+-;:") == thread_name_len)
                 ostrm << std::hex << "name:" << thread_name << ';';
             else
             {
                 // the thread name contains special chars, send as hex bytes
                 ostrm << std::hex << "hexname:";
                 uint8_t *u_thread_name = (uint8_t *)thread_name;
-                for (int i = 0; i < thread_name_len; i++)
+                for (size_t i = 0; i < thread_name_len; i++)
                     ostrm << RAWHEX8(u_thread_name[i]);
                 ostrm << ';';
             }
         }
 
         thread_identifier_info_data_t thread_ident_info;
         if (DNBThreadGetIdentifierInfo (pid, tid, &thread_ident_info))
         {
if (DNBThreadGetStopReason (pid, tid, &tid_stop_info))
         if (did_exec)
         {
             ostrm << "reason:exec;";
         }
         else if (tid_stop_info.details.exception.type)
         {
             ostrm << "metype:" << std::hex << tid_stop_info.details.exception.type << ';';
             ostrm << "mecount:" << std::hex << tid_stop_info.details.exception.data_count << ';';
-            for (int i = 0; i < tid_stop_info.details.exception.data_count; ++i)
+            for (nub_size_t i = 0; i < tid_stop_info.details.exception.data_count; ++i)
                 ostrm << "medata:" << std::hex << tid_stop_info.details.exception.data[i] << ';';
         }
 
         // Add expedited stack memory so stack backtracing doesn't need to read anything from the
         // frame pointer chain.
         StackMemoryMap stack_mmap;
         ReadStackMemory (pid, tid, stack_mmap, 1);
         if (!stack_mmap.empty())
if (bytes_read == 0)
         return SendPacket ("E08");
     }
 
     // "The reply may contain fewer bytes than requested if the server was able
     //  to read only part of the region of memory."
     length = bytes_read;
 
     std::ostringstream ostrm;
-    for (int i = 0; i < length; i++)
+    for (unsigned long i = 0; i < length; i++)
         ostrm << RAWHEX8(buf[i]);
     return SendPacket (ostrm.str ());
 }
 
 // Read memory, sent it up as binary data.
 // Usage:  xADDR,LEN
 // ADDR and LEN are both base 16.
 
RNBRemote::HandlePacket_x (const char *p)
     nub_size_t bytes_read = DNBProcessMemoryRead (m_ctx.ProcessID(), addr, buf.size(), &buf[0]);
     if (bytes_read == 0)
     {
         return SendPacket ("E80");
     }
 
     std::vector<uint8_t> buf_quoted;
     buf_quoted.reserve (bytes_read + 30);
-    for (int i = 0; i < bytes_read; i++)
+    for (nub_size_t i = 0; i < bytes_read; i++)
     {
         if (buf[i] == '#' || buf[i] == '$' || buf[i] == '}' || buf[i] == '*')
         {
             buf_quoted.push_back(0x7d);
             buf_quoted.push_back(buf[i] ^ 0x20);
         }
         else
         {
             buf_quoted.push_back(buf[i]);
         }
     }
     length = buf_quoted.size();
 
     std::ostringstream ostrm;
-    for (int i = 0; i < length; i++)
+    for (unsigned long i = 0; i < length; i++)
         ostrm << buf_quoted[i];
 
     return SendPacket (ostrm.str ());
 }
 
 rnb_err_t
 RNBRemote::HandlePacket_X (const char *p)
 {

 {
     uint32_t max_packet_size = 128 * 1024;  // 128KBytes is a reasonable max packet size--debugger can always use less
     char buf[256];
     snprintf (buf, sizeof(buf), "qXfer:features:read+;PacketSize=%x;qEcho+", max_packet_size);
 
     // By default, don't enable compression.  It's only worth doing when we are working
     // with a low speed communication channel.
     bool enable_compression = false;
+    (void)enable_compression;
 
     // Enable compression when debugserver is running on a watchOS device where communication may be over Bluetooth.
 #if defined (TARGET_OS_WATCH) && TARGET_OS_WATCH == 1
     enable_compression = true;
 #endif
 
 #if defined (HAVE_LIBCOMPRESSION)
     // libcompression is weak linked so test if compression_decode_buffer() is available
else
         reg_entry = NULL;
 
     std::ostringstream ostrm;
     if (reg_entry == NULL)
     {
         DNBLogError("RNBRemote::HandlePacket_p(%s): unknown register number %u requested\n", p, reg);
         ostrm << "00000000";
     }
-    else if (reg_entry->nub_info.reg == -1)
+    else if (reg_entry->nub_info.reg == (uint32_t)-1)
     {
         if (reg_entry->nub_info.size > 0)
         {
             std::basic_string<uint8_t> zeros(reg_entry->nub_info.size, '\0');
             append_hex_value(ostrm, zeros.data(), zeros.size(), false);
         }
     }
     else
RNBRemote::HandlePacket_P (const char *p)
 
     const register_map_entry_t *reg_entry;
 
     if (reg >= g_num_reg_entries)
         return SendPacket("E47");
 
     reg_entry = &g_reg_entries[reg];
 
-    if (reg_entry->nub_info.set == -1 && reg_entry->nub_info.reg == -1)
+    if (reg_entry->nub_info.set == (uint32_t)-1 && reg_entry->nub_info.reg == (uint32_t)-1)
     {
         DNBLogError("RNBRemote::HandlePacket_P(%s): unknown register number %u requested\n", p, reg);
         return SendPacket("E48");
     }
 
     DNBRegisterValue reg_value;
     reg_value.info = reg_entry->nub_info;
     packet.GetHexBytes (reg_value.value.v_sint8, reg_entry->nub_info.size, 0xcc);

 RNBRemote::HandlePacket_s (const char *p)
 {
     const nub_process_t pid = m_ctx.ProcessID();
     if (pid == INVALID_NUB_PROCESS)
         return SendPacket ("E32");
 
     // Hardware supported stepping not supported on arm
     nub_thread_t tid = GetContinueThread ();
-    if (tid == 0 || tid == -1)
+    if (tid == 0 || tid == (nub_thread_t)-1)
         tid = GetCurrentThread();
 
     if (tid == INVALID_NUB_THREAD)
         return SendPacket ("E33");
 
     DNBThreadResumeActions thread_actions;
     thread_actions.AppendAction(tid, eStateStepping);
 
if (*(p + 1) != '\0')
             if (errno != 0 && action.addr == 0)
             {
                 return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "Could not parse address in S packet");
             }
         }
     }
 
     action.tid = GetContinueThread ();
-    if (action.tid == 0 || action.tid == -1)
+    if (action.tid == 0 || action.tid == (nub_thread_t)-1)
         return SendPacket ("E40");
 
     nub_state_t tstate = DNBThreadGetState (pid, action.tid);
     if (tstate == eStateInvalid || tstate == eStateExited)
         return SendPacket ("E37");
 
 
     DNBThreadResumeActions thread_actions;

tools/debugserver/source/RNBServices.cpp

 //===-- RNBServices.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  Created by Christopher Friesen on 3/21/08.
 //
 //===----------------------------------------------------------------------===//
 
-#import "RNBServices.h"
+#include "RNBServices.h"
 
-#import <CoreFoundation/CoreFoundation.h>
+#include <CoreFoundation/CoreFoundation.h>
 #include <libproc.h>
-#import <unistd.h>
+#include <unistd.h>
 #include <sys/sysctl.h>
 #include "CFString.h"
 #include <vector>
-#import "DNBLog.h"
+#include "DNBLog.h"
 #include "MacOSX/CFUtils.h"
 
 // For now only SpringBoard has a notion of "Applications" that it can list for us.
 // So we have to use the SpringBoard API's here.
 #if defined (WITH_SPRINGBOARD) || defined (WITH_BKS)
-#import <SpringBoardServices/SpringBoardServices.h>
+#include <SpringBoardServices/SpringBoardServices.h>
 #endif
 
 // From DNB.cpp
 size_t GetAllInfos (std::vector<struct kinfo_proc>& proc_infos);
 
 int
 GetProcesses (CFMutableArrayRef plistMutableArray, bool all_users)
 {

tools/debugserver/source/RNBSocket.cpp

if (bytessent < 0)
         err.SetError(errno, DNBError::POSIX);
 
     if (err.Fail() || DNBLogCheckLogBit(LOG_RNB_COMM))
         err.LogThreaded("::write ( socket = %i, buffer = %p, length = %llu) => %i", m_fd, buffer, length, (uint64_t)bytessent);
 
     if (bytessent < 0)
         return rnb_err;
 
-    if (bytessent != length)
+    if ((size_t)bytessent != length)
         return rnb_err;
 
     DNBLogThreadedIf(LOG_RNB_PACKETS, "putpkt: %*s", (int)length, (char *)buffer);   // All data is string based in debugserver, so this is safe
     DNBLogThreadedIf(LOG_RNB_COMM, "sent: %*s", (int)length, (char *)buffer);
 
     return rnb_success;
 }
 

tools/debugserver/source/libdebugserver.cpp

case eStateStopped:
         nub_size_t prev_pid_stop_count = ctx.GetProcessStopCount();
         bool pid_stop_count_changed = ctx.SetProcessStopCount(DNBProcessGetStopCount(pid));
         if (pid_stop_count_changed)
         {
           remote->FlushSTDIO();
           
           if (ctx.GetProcessStopCount() == 1)
           {
-            DNBLogThreadedIf (LOG_RNB_MINIMAL, "%s (&remote, initialize=%i)  pid_state = %s pid_stop_count %u (old %u)) Notify??? no, first stop...", __FUNCTION__, (int)initialize, DNBStateAsString (pid_state), ctx.GetProcessStopCount(), prev_pid_stop_count);
+            DNBLogThreadedIf (LOG_RNB_MINIMAL, "%s (&remote, initialize=%i)  pid_state = %s pid_stop_count %zu (old %zu)) Notify??? no, first stop...", __FUNCTION__, (int)initialize, DNBStateAsString (pid_state), ctx.GetProcessStopCount(), prev_pid_stop_count);
           }
           else
           {
             
-            DNBLogThreadedIf (LOG_RNB_MINIMAL, "%s (&remote, initialize=%i)  pid_state = %s pid_stop_count %u (old %u)) Notify??? YES!!!", __FUNCTION__, (int)initialize, DNBStateAsString (pid_state), ctx.GetProcessStopCount(), prev_pid_stop_count);
+            DNBLogThreadedIf (LOG_RNB_MINIMAL, "%s (&remote, initialize=%i)  pid_state = %s pid_stop_count %zu (old %zu)) Notify??? YES!!!", __FUNCTION__, (int)initialize, DNBStateAsString (pid_state), ctx.GetProcessStopCount(), prev_pid_stop_count);
             remote->NotifyThatProcessStopped ();
           }
         }
         else
         {
-          DNBLogThreadedIf (LOG_RNB_MINIMAL, "%s (&remote, initialize=%i)  pid_state = %s pid_stop_count %u (old %u)) Notify??? skipping...", __FUNCTION__, (int)initialize, DNBStateAsString (pid_state), ctx.GetProcessStopCount(), prev_pid_stop_count);
+          DNBLogThreadedIf (LOG_RNB_MINIMAL, "%s (&remote, initialize=%i)  pid_state = %s pid_stop_count %zu (old %zu)) Notify??? skipping...", __FUNCTION__, (int)initialize, DNBStateAsString (pid_state), ctx.GetProcessStopCount(), prev_pid_stop_count);
         }
       }
       return eRNBRunLoopModeInferiorExecuting; 
       
     case eStateStepping:
     case eStateRunning:
       return eRNBRunLoopModeInferiorExecuting;