suppress compiler warning (mostly -Wsign-compare)

[jasonmolenda]

One small comment but otherwise looks good to me, fwiw.

tools/debugserver/source/RNBRemote.cpp

2219

I think 'i' should be size_t to match buf_size, right? That's how you changed the decl in the for loop below.

[chilledheart]

It is a choice based on some reasons:

1. i is going to negative here where the loop stops. So i must be signed

type.

2. i should be large enough to hold a unsigned size_t. If type int is

sufficient in the previous case, type long is larger.
3.As I know, size_t is unsigned long under OS X.

[jasonmolenda]

Good point, thanks.

[emaste]

Looks fine to me.

[emaste]

What's next here? Did this get committed?

[chilledheart]

Hi emaste

Sorry for the late coming back. It is still not committed yet.

I am applying this patch against the latest lldb and double-checking it. It won't be long this time.

[chilledheart]

rebase to trunk

[chilledheart]

Although there are still some Wsign-compare warnings outside this patch, I think this diff is good enough for its own purpose.

I am fine with landing it if there is no further issue.

BTW Here are the warnings I faced on Linux:

/home/chilledheart/sources-llvm/llvm_lldb/tools/lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp:749:35: warning: comparison of integers of different signs: 'int' and 'uint32_t' (aka 'unsigned int') [-Wsign-compare]
                if (machine_regno == m_machine_fp_regnum)
                    ~~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~~~~~~
/home/chilledheart/sources-llvm/llvm_lldb/tools/lldb/source/Plugins/UnwindAssembly/x86/UnwindAssembly-x86.cpp:845:53: warning: comparison of integers of different signs: 'int' and 'lldb::addr_t' (aka 'unsigned long') [-Wsign-compare]
            if (current_func_text_offset + insn_len < m_func_bounds.GetByteSize())
                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~
2 warnings generated.

[jasonmolenda]

Those new warnings from UnwindAssembly-x86.cpp are my fault. I'll fix them later today.

[chilledheart]

I am abandoning this patch and it will be really helpful if someone can follow the latest code of lldb and fix Wsign-compare warnings.

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 == static_cast<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.size(); ++i)
+        for (size_t i = 0; i != s.size(); ++i)
             cksum += s[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;
switch (return_packet[0])
         case '\x03':
             break;
 
         case '$':
         {
             int packet_checksum = 0;
             if (!m_noack_mode)
             {
-                for (int i = return_packet.size() - 2; i < return_packet.size(); ++i)
+                for (size_t i = return_packet.size() - 2; i < return_packet.size(); ++i)
                 {
                     char checksum_char = tolower (return_packet[i]);
                     if (!isxdigit (checksum_char))
                     {
                         m_comm.Write ("-", 1);
                         DNBLogThreadedIf (LOG_RNB_REMOTE, "%8u RNBRemote::%s error: packet with invalid checksum characters: %s", (uint32_t)m_comm.Timer().ElapsedMicroSeconds(true), __FUNCTION__, return_packet.c_str());
                         return rnb_err;
                     }
#endif
         {
             rnb_err_t err = remote->GetCommData();
 
             switch (err)
             {
                 case rnb_success:
                     break;
 
-                default:
-                case rnb_err:
-                    DNBLogThreadedIf (LOG_RNB_REMOTE, "RNBSocket::GetCommData returned error %u", err);
+                case rnb_not_connected:
+                    DNBLogThreadedIf (LOG_RNB_REMOTE, "RNBSocket::GetCommData returned not connected...");
                     done = true;
                     break;
 
-                case rnb_not_connected:
-                    DNBLogThreadedIf (LOG_RNB_REMOTE, "RNBSocket::GetCommData returned not connected...");
+                case rnb_err:
+                default:
+                    DNBLogThreadedIf (LOG_RNB_REMOTE, "RNBSocket::GetCommData returned error %u", err);
                     done = true;
                     break;
             }
         }
         // START: main receive remote command thread loop
         events.ResetEvents (RNBContext::event_read_thread_running);
         events.SetEvents (RNBContext::event_read_thread_exiting);
     }

 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 == static_cast<size_t>(-1))
         len = strlen (str);
 
     while (len--)
     {
         unsigned char c = *str;
         if (c == 0x7d && len > 0)
         {
             len--;
else
         Context().PushProcessEvent(p);
     }
     return SendPacket ("OK");
 }
 
 void
 append_hex_value (std::ostream& ostrm, const uint8_t* buf, size_t buf_size, bool swap)
 {
-    int i;
     if (swap)
     {
-        for (i = buf_size-1; i >= 0; i--)
+        for (long i = buf_size-1; i >= 0; i--)
             ostrm << RAWHEX8(buf[i]);
     }
     else
     {
-        for (i = 0; i < buf_size; i++)
+        for (size_t i = 0; i < buf_size; i++)
             ostrm << RAWHEX8(buf[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] << ";";
         }
         return SendPacket (ostrm.str ());
     }
     return SendPacket("E51");
 }
 
 /* '?'
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 (uint32_t 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)
     {
         return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "Comma sep missing in X packet");
     }
 
     /* Advance 'p' to the number of bytes to be read.  */
     p += (c - p) + 1;
 
     errno = 0;
-    int length = strtoul (p, NULL, 16);
+    unsigned length = strtoul (p, NULL, 16);
     if (errno != 0)
     {
         return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "Invalid length in x packet");
     }
 
     // zero length read means this is a test of whether that packet is implemented or not.
     if (length == 0)
     {
for (int i = 0; i < bytes_read; i++)
         else
         {
             buf_quoted.push_back(buf[i]);
         }
     }
     length = buf_quoted.size();
 
     std::ostringstream ostrm;
-    for (int i = 0; i < length; i++)
+    for (unsigned i = 0; i < length; i++)
         ostrm << buf_quoted[i];
 
     return SendPacket (ostrm.str ());
 }
 
 rnb_err_t
 RNBRemote::HandlePacket_X (const char *p)
 {
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 == static_cast<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 == static_cast<uint32_t>(-1) &&
+        reg_entry->nub_info.reg == static_cast<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 == static_cast<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 == static_cast<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;