Fix a some silly warnings

[artagnon]

Er, silly mistake (build failure)

source/Commands/CommandObjectMemory.cpp

OptionGroupReadMemory () :
         m_output_as_binary (false),
         m_view_as_type()
     {
     }
 
     ~OptionGroupReadMemory () override
     {
     }
-    
-    
     uint32_t
     GetNumDefinitions () override
     {
         return sizeof (g_option_table) / sizeof (OptionDefinition);
     }
-    
     const OptionDefinition*
     GetDefinitions () override
     {
         return g_option_table;
     }
-    
     Error
     SetOptionValue (CommandInterpreter &interpreter,
                     uint32_t option_idx,
                     const char *option_arg) override
     {
         Error error;
         const int short_option = g_option_table[option_idx].short_option;
-        
         switch (short_option)
         {
             case 'l':
                 error = m_num_per_line.SetValueFromString (option_arg);
                 if (m_num_per_line.GetCurrentValue() == 0)
                     error.SetErrorStringWithFormat("invalid value for --num-per-line option '%s'", option_arg);
                 break;
 
             case 'b':
                 m_output_as_binary = true;
                 break;
-                
             case 't':
                 error = m_view_as_type.SetValueFromString (option_arg);
                 break;
-            
             case 'r':
                 m_force = true;
                 break;
-                
             default:
                 error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                 break;
         }
         return error;
     }
-    
     void
     OptionParsingStarting (CommandInterpreter &interpreter) override
     {
         m_num_per_line.Clear();
         m_output_as_binary = false;
         m_view_as_type.Clear();
         m_force = false;
     }
-    
     Error
     FinalizeSettings (Target *target, OptionGroupFormat& format_options)
     {
         Error error;
         OptionValueUInt64 &byte_size_value = format_options.GetByteSizeValue();
         OptionValueUInt64 &count_value = format_options.GetCountValue();
         const bool byte_size_option_set = byte_size_value.OptionWasSet();
         const bool num_per_line_option_set = m_num_per_line.OptionWasSet();
         const bool count_option_set = format_options.GetCountValue().OptionWasSet();
-        
         switch (format_options.GetFormat())
         {
             default:
                 break;
-                
             case eFormatBoolean:
                 if (!byte_size_option_set)
                     byte_size_value = 1;
                 if (!num_per_line_option_set)
                     m_num_per_line = 1;
                 if (!count_option_set)
                     format_options.GetCountValue() = 8;
                 break;
-                
             case eFormatCString:
                 break;
 
             case eFormatInstruction:
                 if (count_option_set)
                     byte_size_value = target->GetArchitecture().GetMaximumOpcodeByteSize();
                 m_num_per_line = 1;
                 break;
 
             case eFormatAddressInfo:
                 if (!byte_size_option_set)
                     byte_size_value = target->GetArchitecture().GetAddressByteSize();
                 m_num_per_line = 1;
                 if (!count_option_set)
                     format_options.GetCountValue() = 8;
                 break;
 
             case eFormatPointer:
                 byte_size_value = target->GetArchitecture().GetAddressByteSize();
                 if (!num_per_line_option_set)
                     m_num_per_line = 4;
                 if (!count_option_set)
                     format_options.GetCountValue() = 8;
                 break;
-                
             case eFormatBinary:
             case eFormatFloat:
             case eFormatOctal:
             case eFormatDecimal:
             case eFormatEnum:
             case eFormatUnicode16:
             case eFormatUnicode32:
             case eFormatUnsigned:
             case eFormatHexFloat:
                 if (!byte_size_option_set)
                     byte_size_value = 4;
                 if (!num_per_line_option_set)
                     m_num_per_line = 1;
                 if (!count_option_set)
                     format_options.GetCountValue() = 8;
                 break;
-            
             case eFormatBytes:
             case eFormatBytesWithASCII:
                 if (byte_size_option_set)
                 {
                     if (byte_size_value > 1)
                         error.SetErrorStringWithFormat ("display format (bytes/bytes with ascii) conflicts with the specified byte size %" PRIu64 "\n"
                                                         "\tconsider using a different display format or don't specify the byte size",
                                                         byte_size_value.GetCurrentValue());
FinalizeSettings (Target *target, OptionGroupFormat& format_options)
                         default:
                             m_num_per_line = 1;
                             break;
                     }
                 }
                 if (!count_option_set)
                     count_value = 8;
                 break;
-                
             case eFormatVectorOfChar:
             case eFormatVectorOfSInt8:
             case eFormatVectorOfUInt8:
             case eFormatVectorOfSInt16:
             case eFormatVectorOfUInt16:
             case eFormatVectorOfSInt32:
             case eFormatVectorOfUInt32:
             case eFormatVectorOfSInt64:
public:
 
     bool
     AnyOptionWasSet () const
     {
         return m_num_per_line.OptionWasSet() ||
                m_output_as_binary ||
                m_view_as_type.OptionWasSet();
     }
-    
     OptionValueUInt64 m_num_per_line;
     bool m_output_as_binary;
     OptionValueString m_view_as_type;
     bool m_force;
 };
 
 
 
CommandObjectMemoryRead (CommandInterpreter &interpreter) :
         m_prev_memory_options (),
         m_prev_outfile_options (),
         m_prev_varobj_options()
     {
         CommandArgumentEntry arg1;
         CommandArgumentEntry arg2;
         CommandArgumentData start_addr_arg;
         CommandArgumentData end_addr_arg;
-        
         // Define the first (and only) variant of this arg.
         start_addr_arg.arg_type = eArgTypeAddressOrExpression;
         start_addr_arg.arg_repetition = eArgRepeatPlain;
-        
         // There is only one variant this argument could be; put it into the argument entry.
         arg1.push_back (start_addr_arg);
-        
         // Define the first (and only) variant of this arg.
         end_addr_arg.arg_type = eArgTypeAddressOrExpression;
         end_addr_arg.arg_repetition = eArgRepeatOptional;
-        
         // There is only one variant this argument could be; put it into the argument entry.
         arg2.push_back (end_addr_arg);
-        
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
-        
         // Add the "--format" and "--count" options to group 1 and 3
-        m_option_group.Append (&m_format_options, 
-                               OptionGroupFormat::OPTION_GROUP_FORMAT | OptionGroupFormat::OPTION_GROUP_COUNT, 
+        m_option_group.Append (&m_format_options,
+                               OptionGroupFormat::OPTION_GROUP_FORMAT | OptionGroupFormat::OPTION_GROUP_COUNT,
                                LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3);
-        m_option_group.Append (&m_format_options, 
-                               OptionGroupFormat::OPTION_GROUP_GDB_FMT, 
+        m_option_group.Append (&m_format_options,
+                               OptionGroupFormat::OPTION_GROUP_GDB_FMT,
                                LLDB_OPT_SET_1 | LLDB_OPT_SET_3);
         // Add the "--size" option to group 1 and 2
-        m_option_group.Append (&m_format_options, 
-                               OptionGroupFormat::OPTION_GROUP_SIZE, 
+        m_option_group.Append (&m_format_options,
+                               OptionGroupFormat::OPTION_GROUP_SIZE,
                                LLDB_OPT_SET_1 | LLDB_OPT_SET_2);
         m_option_group.Append (&m_memory_options);
         m_option_group.Append (&m_outfile_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3);
         m_option_group.Append (&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_3);
         m_option_group.Finalize();
     }
 
     ~CommandObjectMemoryRead () override
DoExecute (Args& command, CommandReturnObject &result) override
         if ((argc == 0 && m_next_addr == LLDB_INVALID_ADDRESS) || argc > 2)
         {
             result.AppendErrorWithFormat ("%s takes a start address expression with an optional end address expression.\n", m_cmd_name.c_str());
             result.AppendRawWarning("Expressions should be quoted if they contain spaces or other special characters.\n");
             result.SetStatus(eReturnStatusFailed);
             return false;
         }
 
-        CompilerType clang_ast_type;        
+        CompilerType clang_ast_type;
         Error error;
 
         const char *view_as_type_cstr = m_memory_options.m_view_as_type.GetCurrentValue();
         if (view_as_type_cstr && view_as_type_cstr[0])
         {
             // We are viewing memory as a type
-            
             SymbolContext sc;
             const bool exact_match = false;
             TypeList type_list;
             uint32_t reference_count = 0;
             uint32_t pointer_count = 0;
             size_t idx;
-            
 #define ALL_KEYWORDS        \
     KEYWORD("const")        \
     KEYWORD("volatile")     \
     KEYWORD("restrict")     \
     KEYWORD("struct")       \
     KEYWORD("class")        \
     KEYWORD("union")
-            
 #define KEYWORD(s) s,
             static const char *g_keywords[] =
             {
                 ALL_KEYWORDS
             };
 #undef KEYWORD
 
 #define KEYWORD(s) (sizeof(s) - 1),
             static const int g_keyword_lengths[] =
             {
                 ALL_KEYWORDS
             };
 #undef KEYWORD
-            
 #undef ALL_KEYWORDS
-            
             static size_t g_num_keywords = sizeof(g_keywords) / sizeof(const char *);
             std::string type_str(view_as_type_cstr);
-            
             // Remove all instances of g_keywords that are followed by spaces
             for (size_t i = 0; i < g_num_keywords; ++i)
             {
                 const char *keyword = g_keywords[i];
                 int keyword_len = g_keyword_lengths[i];
-                
                 idx = 0;
                 while ((idx = type_str.find (keyword, idx)) != std::string::npos)
                 {
                     if (type_str[idx + keyword_len] == ' ' || type_str[idx + keyword_len] == '\t')
                     {
                         type_str.erase(idx, keyword_len+1);
                         idx = 0;
                     }
                     else
                     {
                         idx += keyword_len;
                     }
                 }
             }
             bool done = type_str.empty();
-            // 
+            //
             idx = type_str.find_first_not_of (" \t");
             if (idx > 0 && idx != std::string::npos)
                 type_str.erase (0, idx);
             while (!done)
             {
                 // Strip trailing spaces
                 if (type_str.empty())
                     done = true;
#undef ALL_KEYWORDS
                         break;
 
                     default:
                         done = true;
                         break;
                     }
                 }
             }
-                    
             ConstString lookup_type_name(type_str.c_str());
             StackFrame *frame = m_exe_ctx.GetFramePtr();
             if (frame)
             {
                 sc = frame->GetSymbolContext (eSymbolContextModule);
                 if (sc.module_sp)
                 {
                     sc.module_sp->FindTypes (sc,
                                              lookup_type_name,
                                              exact_match,
-                                             1, 
+                                             1,
                                              type_list);
                 }
             }
             if (type_list.GetSize() == 0)
             {
-                target->GetImages().FindTypes (sc, 
-                                               lookup_type_name, 
-                                               exact_match, 
-                                               1, 
+                target->GetImages().FindTypes (sc,
+                                               lookup_type_name,
+                                               exact_match,
+                                               1,
                                                type_list);
             }
-            
             if (type_list.GetSize() == 0 && lookup_type_name.GetCString() && *lookup_type_name.GetCString() == '$')
             {
                 if (ClangPersistentVariables *persistent_vars = llvm::dyn_cast_or_null<ClangPersistentVariables>(target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC)))
                 {
                     clang::TypeDecl *tdecl = persistent_vars->GetPersistentType(ConstString(lookup_type_name));
-                    
                     if (tdecl)
                     {
                         clang_ast_type.SetCompilerType(ClangASTContext::GetASTContext(&tdecl->getASTContext()),(const lldb::opaque_compiler_type_t)tdecl->getTypeForDecl());
                     }
                 }
             }
-            
             if (clang_ast_type.IsValid() == false)
             {
                 if (type_list.GetSize() == 0)
                 {
                     result.AppendErrorWithFormat ("unable to find any types that match the raw type '%s' for full type '%s'\n",
                                                   lookup_type_name.GetCString(),
                                                   view_as_type_cstr);
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
                 else
                 {
                     TypeSP type_sp (type_list.GetTypeAtIndex(0));
                     clang_ast_type = type_sp->GetFullCompilerType ();
                 }
             }
-            
             while (pointer_count > 0)
             {
                 CompilerType pointer_type = clang_ast_type.GetPointerType();
                 if (pointer_type.IsValid())
                     clang_ast_type = pointer_type;
                 else
                 {
                     result.AppendError ("unable make a pointer type\n");
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
                 --pointer_count;
             }
 
             m_format_options.GetByteSizeValue() = clang_ast_type.GetByteSize(nullptr);
-            
             if (m_format_options.GetByteSizeValue() == 0)
             {
-                result.AppendErrorWithFormat ("unable to get the byte size of the type '%s'\n", 
+                result.AppendErrorWithFormat ("unable to get the byte size of the type '%s'\n",
                                               view_as_type_cstr);
                 result.SetStatus(eReturnStatusFailed);
                 return false;
             }
-            
             if (!m_format_options.GetCountValue().OptionWasSet())
                 m_format_options.GetCountValue() = 1;
         }
         else
         {
             error = m_memory_options.FinalizeSettings (target, m_format_options);
         }
 
#undef ALL_KEYWORDS
                 return false;
             }
 
             total_byte_size = end_addr - addr;
             item_count = total_byte_size / item_byte_size;
         }
 
         uint32_t max_unforced_size = target->GetMaximumMemReadSize();
-        
         if (total_byte_size > max_unforced_size && !m_memory_options.m_force)
         {
             result.AppendErrorWithFormat("Normally, \'memory read\' will not read over %" PRIu32 " bytes of data.\n",max_unforced_size);
             result.AppendErrorWithFormat("Please use --force to override this restriction just once.\n");
             result.AppendErrorWithFormat("or set target.max-memory-read-size if you will often need a larger limit.\n");
             return false;
         }
-        
         DataBufferSP data_sp;
         size_t bytes_read = 0;
         if (clang_ast_type.GetOpaqueQualType())
         {
             // Make sure we don't display our type as ASCII bytes like the default memory read
             if (m_format_options.GetFormatValue().OptionWasSet() == false)
                 m_format_options.GetFormatValue().SetCurrentValue(eFormatDefault);
 
#undef ALL_KEYWORDS
                 }
                 else
                 {
                     result.AppendErrorWithFormat("failed to read memory from 0x%" PRIx64 ".\n", addr);
                 }
                 result.SetStatus(eReturnStatusFailed);
                 return false;
             }
-            
             if (bytes_read < total_byte_size)
                 result.AppendWarningWithFormat("Not all bytes (%" PRIu64 "/%" PRIu64 ") were able to be read from 0x%" PRIx64 ".\n", (uint64_t)bytes_read, (uint64_t)total_byte_size, addr);
         }
         else
         {
             // we treat c-strings as a special case because they do not have a fixed size
             if (m_format_options.GetByteSizeValue().OptionWasSet() && !m_format_options.HasGDBFormat())
                 item_byte_size = m_format_options.GetByteSizeValue().GetCurrentValue();
#undef ALL_KEYWORDS
                 Error error;
                 size_t read = target->ReadCStringFromMemory(data_addr, &buffer[0], item_byte_size+1, error);
                 if (error.Fail())
                 {
                     result.AppendErrorWithFormat("failed to read memory from 0x%" PRIx64 ".\n", addr);
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
-                
                 if (item_byte_size == read)
                 {
                     result.AppendWarningWithFormat("unable to find a NULL terminated string at 0x%" PRIx64 ".Consider increasing the maximum read length.\n", data_addr);
                     --read;
                     break_on_no_NULL = true;
                 }
                 else
                     ++read; // account for final NULL byte
-                
                 memcpy(data_ptr, &buffer[0], read);
                 data_ptr += read;
                 data_addr += read;
                 bytes_read += read;
                 item_count++; // if we break early we know we only read item_count strings
-                
                 if (break_on_no_NULL)
                     break;
             }
             data_sp.reset(new DataBufferHeap(data_sp->GetBytes(),bytes_read+1));
         }
 
         m_next_addr = addr + bytes_read;
         m_prev_byte_size = bytes_read;
         m_prev_format_options = m_format_options;
         m_prev_memory_options = m_memory_options;
         m_prev_outfile_options = m_outfile_options;
         m_prev_varobj_options = m_varobj_options;
         m_prev_clang_ast_type = clang_ast_type;
 
         StreamFile outfile_stream;
         Stream *output_stream = NULL;
         const FileSpec &outfile_spec = m_outfile_options.GetFile().GetCurrentValue();
         if (outfile_spec)
         {
             char path[PATH_MAX];
             outfile_spec.GetPath (path, sizeof(path));
-            
             uint32_t open_options = File::eOpenOptionWrite | File::eOpenOptionCanCreate;
             const bool append = m_outfile_options.GetAppend().GetCurrentValue();
             if (append)
                 open_options |= File::eOpenOptionAppend;
-            
             if (outfile_stream.GetFile ().Open (path, open_options).Success())
             {
                 if (m_memory_options.m_output_as_binary)
                 {
                     const size_t bytes_written = outfile_stream.Write (data_sp->GetBytes(), bytes_read);
                     if (bytes_written > 0)
                     {
-                        result.GetOutputStream().Printf ("%zi bytes %s to '%s'\n", 
-                                                         bytes_written, 
-                                                         append ? "appended" : "written", 
+                        result.GetOutputStream().Printf ("%zi bytes %s to '%s'\n",
+                                                         bytes_written,
+                                                         append ? "appended" : "written",
                                                          path);
                         return true;
                     }
-                    else 
+                    else
                     {
                         result.AppendErrorWithFormat("Failed to write %" PRIu64 " bytes to '%s'.\n", (uint64_t)bytes_read, path);
                         result.SetStatus(eReturnStatusFailed);
                         return false;
                     }
                 }
                 else
                 {
                     // We are going to write ASCII to the file just point the
                     // output_stream to our outfile_stream...
                     output_stream = &outfile_stream;
                 }
             }
-            else 
+            else
             {
                 result.AppendErrorWithFormat("Failed to open file '%s' for %s.\n", path, append ? "append" : "write");
                 result.SetStatus(eReturnStatusFailed);
                 return false;
             }
         }
-        else 
+        else
         {
             output_stream = &result.GetOutputStream();
         }
 
 
         ExecutionContextScope *exe_scope = m_exe_ctx.GetBestExecutionContextScope();
         if (clang_ast_type.GetOpaqueQualType())
         {
             for (uint32_t i = 0; i<item_count; ++i)
             {
                 addr_t item_addr = addr + (i * item_byte_size);
                 Address address (item_addr);
                 StreamString name_strm;
                 name_strm.Printf ("0x%" PRIx64, item_addr);
-                ValueObjectSP valobj_sp (ValueObjectMemory::Create (exe_scope, 
-                                                                    name_strm.GetString().c_str(), 
-                                                                    address, 
+                ValueObjectSP valobj_sp (ValueObjectMemory::Create (exe_scope,
+                                                                    name_strm.GetString().c_str(),
+                                                                    address,
                                                                     clang_ast_type));
                 if (valobj_sp)
                 {
                     Format format = m_format_options.GetFormat();
                     if (format != eFormatDefault)
                         valobj_sp->SetFormat (format);
 
                     DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions(eLanguageRuntimeDescriptionDisplayVerbosityFull,format));
-                    
                     valobj_sp->Dump(*output_stream,options);
                 }
                 else
                 {
-                    result.AppendErrorWithFormat ("failed to create a value object for: (%s) %s\n", 
-                                                  view_as_type_cstr, 
+                    result.AppendErrorWithFormat ("failed to create a value object for: (%s) %s\n",
+                                                  view_as_type_cstr,
                                                   name_strm.GetString().c_str());
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }
             }
             return true;
         }
 
         result.SetStatus(eReturnStatusSuccessFinishResult);
-        DataExtractor data (data_sp, 
-                            target->GetArchitecture().GetByteOrder(), 
+        DataExtractor data (data_sp,
+                            target->GetArchitecture().GetByteOrder(),
                             target->GetArchitecture().GetAddressByteSize(),
                             target->GetArchitecture().GetDataByteSize());
-        
         Format format = m_format_options.GetFormat();
         if ( ( (format == eFormatChar) || (format == eFormatCharPrintable) )
             && (item_byte_size != 1))
         {
             // if a count was not passed, or it is 1
             if (m_format_options.GetCountValue().OptionWasSet() == false || item_count == 1)
             {
                 // this turns requests such as
#undef ALL_KEYWORDS
     }
 
     OptionGroupOptions m_option_group;
     OptionGroupFormat m_format_options;
     OptionGroupReadMemory m_memory_options;
     OptionGroupOutputFile m_outfile_options;
     OptionGroupValueObjectDisplay m_varobj_options;
     lldb::addr_t m_next_addr;
-    lldb::addr_t m_prev_byte_size; 
+    lldb::addr_t m_prev_byte_size;
     OptionGroupFormat m_prev_format_options;
     OptionGroupReadMemory m_prev_memory_options;
     OptionGroupOutputFile m_prev_outfile_options;
     OptionGroupValueObjectDisplay m_prev_varobj_options;
     CompilerType m_prev_clang_ast_type;
 };
 
 OptionDefinition
 g_memory_find_option_table[] =
 {
     { LLDB_OPT_SET_1, false, "expression", 'e', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeExpression, "Evaluate an expression to obtain a byte pattern."},
     { LLDB_OPT_SET_2, false, "string", 's', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeName,   "Use text to find a byte pattern."},
     { LLDB_OPT_SET_1|LLDB_OPT_SET_2, false, "count", 'c', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeCount,   "How many times to perform the search."},
     { LLDB_OPT_SET_1|LLDB_OPT_SET_2, false, "dump-offset", 'o', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeOffset,   "When dumping memory for a match, an offset from the match location to start dumping from."},
 };
 
 //----------------------------------------------------------------------
 // Find the specified data in memory
 //----------------------------------------------------------------------
 class CommandObjectMemoryFind : public CommandObjectParsed
 {
 public:
-  
   class OptionGroupFindMemory : public OptionGroup
   {
   public:
     OptionGroupFindMemory () :
       OptionGroup(),
       m_count(1),
       m_offset(0)
     {
     }
-    
     ~OptionGroupFindMemory () override
     {
     }
-    
     uint32_t
     GetNumDefinitions () override
     {
       return sizeof (g_memory_find_option_table) / sizeof (OptionDefinition);
     }
-    
     const OptionDefinition*
     GetDefinitions () override
     {
       return g_memory_find_option_table;
     }
-    
     Error
     SetOptionValue (CommandInterpreter &interpreter,
                     uint32_t option_idx,
                     const char *option_arg) override
     {
         Error error;
         const int short_option = g_memory_find_option_table[option_idx].short_option;
-      
         switch (short_option)
         {
         case 'e':
               m_expr.SetValueFromString(option_arg);
               break;
-          
         case 's':
               m_string.SetValueFromString(option_arg);
               break;
-          
         case 'c':
               if (m_count.SetValueFromString(option_arg).Fail())
                   error.SetErrorString("unrecognized value for count");
               break;
-                
         case 'o':
                if (m_offset.SetValueFromString(option_arg).Fail())
                    error.SetErrorString("unrecognized value for dump-offset");
                 break;
 
         default:
               error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
               break;
         }
         return error;
     }
-    
     void
     OptionParsingStarting (CommandInterpreter &interpreter) override
     {
         m_expr.Clear();
         m_string.Clear();
         m_count.Clear();
     }
-    
       OptionValueString m_expr;
       OptionValueString m_string;
       OptionValueUInt64 m_count;
       OptionValueUInt64 m_offset;
   };
-  
   CommandObjectMemoryFind (CommandInterpreter &interpreter) :
   CommandObjectParsed (interpreter,
                        "memory find",
                        "Find a value in the memory of the process being debugged.",
                        NULL,
                        eCommandRequiresProcess | eCommandProcessMustBeLaunched),
   m_option_group (interpreter),
   m_memory_options ()
   {
     CommandArgumentEntry arg1;
     CommandArgumentEntry arg2;
     CommandArgumentData addr_arg;
     CommandArgumentData value_arg;
-    
     // Define the first (and only) variant of this arg.
     addr_arg.arg_type = eArgTypeAddressOrExpression;
     addr_arg.arg_repetition = eArgRepeatPlain;
-    
     // There is only one variant this argument could be; put it into the argument entry.
     arg1.push_back (addr_arg);
-    
     // Define the first (and only) variant of this arg.
     value_arg.arg_type = eArgTypeAddressOrExpression;
     value_arg.arg_repetition = eArgRepeatPlain;
-    
     // There is only one variant this argument could be; put it into the argument entry.
     arg2.push_back (value_arg);
-    
     // Push the data for the first argument into the m_arguments vector.
     m_arguments.push_back (arg1);
     m_arguments.push_back (arg2);
-    
     m_option_group.Append (&m_memory_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_2);
     m_option_group.Finalize();
   }
-  
   ~CommandObjectMemoryFind () override
   {
   }
-  
   Options *
   GetOptions () override
   {
     return &m_option_group;
   }
-  
 protected:
   bool
   DoExecute (Args& command, CommandReturnObject &result) override
   {
       // No need to check "process" for validity as eCommandRequiresProcess ensures it is valid
       Process *process = m_exe_ctx.GetProcessPtr();
 
       const size_t argc = command.GetArgumentCount();
DoExecute (Args& command, CommandReturnObject &result) override
           return false;
       }
 
       if (high_addr <= low_addr)
       {
           result.AppendError("starting address must be smaller than ending address");
           return false;
       }
-      
       lldb::addr_t found_location = LLDB_INVALID_ADDRESS;
-      
       DataBufferHeap buffer;
-      
       if (m_memory_options.m_string.OptionWasSet())
           buffer.CopyData(m_memory_options.m_string.GetStringValue(), strlen(m_memory_options.m_string.GetStringValue()));
       else if (m_memory_options.m_expr.OptionWasSet())
       {
           StackFrame* frame = m_exe_ctx.GetFramePtr();
           ValueObjectSP result_sp;
           if ((eExpressionCompleted == process->GetTarget().EvaluateExpression(m_memory_options.m_expr.GetStringValue(), frame, result_sp)) &&
               result_sp.get())
DoExecute (Args& command, CommandReturnObject &result) override
               return false;
           }
       }
       else
       {
           result.AppendError("please pass either a block of text, or an expression to evaluate.");
           return false;
       }
-      
       size_t count = m_memory_options.m_count.GetCurrentValue();
       found_location = low_addr;
       bool ever_found = false;
       while (count)
       {
           found_location = Search(found_location, high_addr, buffer.GetBytes(), buffer.GetByteSize());
           if (found_location == LLDB_INVALID_ADDRESS)
           {
DoExecute (Args& command, CommandReturnObject &result) override
               data.Dump(&result.GetOutputStream(), 0, lldb::eFormatBytesWithASCII, 1, dumpbuffer.GetByteSize(), 16, found_location+m_memory_options.m_offset.GetCurrentValue(), 0, 0);
               result.GetOutputStream().EOL();
           }
 
           --count;
           found_location++;
           ever_found = true;
       }
-      
       result.SetStatus(lldb::eReturnStatusSuccessFinishResult);
       return true;
   }
-    
     lldb::addr_t
     Search (lldb::addr_t low,
             lldb::addr_t high,
             uint8_t* buffer,
             size_t buffer_size)
     {
         Process *process = m_exe_ctx.GetProcessPtr();
         DataBufferHeap heap(buffer_size, 0);
         for (auto ptr = low;
              ptr < high;
              ptr++)
         {
             Error error;
             process->ReadMemory(ptr, heap.GetBytes(), buffer_size, error);
             if (error.Fail())
                 return LLDB_INVALID_ADDRESS;
             if (memcmp(heap.GetBytes(), buffer, buffer_size) == 0)
                 return ptr;
         }
         return LLDB_INVALID_ADDRESS;
     }
-  
     OptionGroupOptions m_option_group;
     OptionGroupFindMemory m_memory_options;
 };
 
 
 OptionDefinition
 g_memory_write_option_table[] =
 {
public:
         {
         }
 
         uint32_t
         GetNumDefinitions () override
         {
             return sizeof (g_memory_write_option_table) / sizeof (OptionDefinition);
         }
-      
         const OptionDefinition*
         GetDefinitions () override
         {
             return g_memory_write_option_table;
         }
-      
         Error
         SetOptionValue (CommandInterpreter &interpreter,
                         uint32_t option_idx,
                         const char *option_arg) override
         {
             Error error;
             const int short_option = g_memory_write_option_table[option_idx].short_option;
-          
             switch (short_option)
             {
                 case 'i':
                     m_infile.SetFile (option_arg, true);
                     if (!m_infile.Exists())
                     {
                         m_infile.Clear();
                         error.SetErrorStringWithFormat("input file does not exist: '%s'", option_arg);
                     }
                     break;
-                
                 case 'o':
                     {
                         bool success;
                         m_infile_offset = StringConvert::ToUInt64(option_arg, 0, 0, &success);
                         if (!success)
                         {
                             error.SetErrorStringWithFormat("invalid offset string '%s'", option_arg);
                         }
                     }
                     break;
-                    
                 default:
                     error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
                     break;
             }
             return error;
         }
-        
         void
         OptionParsingStarting (CommandInterpreter &interpreter) override
         {
             m_infile.Clear();
             m_infile_offset = 0;
         }
 
         FileSpec m_infile;
CommandObjectMemoryWrite (CommandInterpreter &interpreter) :
         m_option_group (interpreter),
         m_format_options (eFormatBytes, 1, UINT64_MAX),
         m_memory_options ()
     {
         CommandArgumentEntry arg1;
         CommandArgumentEntry arg2;
         CommandArgumentData addr_arg;
         CommandArgumentData value_arg;
-        
         // Define the first (and only) variant of this arg.
         addr_arg.arg_type = eArgTypeAddress;
         addr_arg.arg_repetition = eArgRepeatPlain;
-        
         // There is only one variant this argument could be; put it into the argument entry.
         arg1.push_back (addr_arg);
-        
         // Define the first (and only) variant of this arg.
         value_arg.arg_type = eArgTypeValue;
         value_arg.arg_repetition = eArgRepeatPlus;
-        
         // There is only one variant this argument could be; put it into the argument entry.
         arg2.push_back (value_arg);
-        
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
         m_arguments.push_back (arg2);
-        
         m_option_group.Append (&m_format_options, OptionGroupFormat::OPTION_GROUP_FORMAT, LLDB_OPT_SET_1);
         m_option_group.Append (&m_format_options, OptionGroupFormat::OPTION_GROUP_SIZE  , LLDB_OPT_SET_1|LLDB_OPT_SET_2);
         m_option_group.Append (&m_memory_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_2);
         m_option_group.Finalize();
 
     }
 
     ~CommandObjectMemoryWrite () override
DoExecute (Args& command, CommandReturnObject &result) override
 
         if (m_memory_options.m_infile)
         {
             if (argc < 1)
             {
                 result.AppendErrorWithFormat ("%s takes a destination address when writing file contents.\n", m_cmd_name.c_str());
                 result.SetStatus(eReturnStatusFailed);
                 return false;
-            }       
+            }
         }
         else if (argc < 2)
         {
             result.AppendErrorWithFormat ("%s takes a destination address and at least one value.\n", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
         }
 
DoExecute (Args& command, CommandReturnObject &result) override
 
         if (addr == LLDB_INVALID_ADDRESS)
         {
             result.AppendError("invalid address expression\n");
             result.AppendError(error.AsCString());
             result.SetStatus(eReturnStatusFailed);
             return false;
         }
-        
         if (m_memory_options.m_infile)
         {
             size_t length = SIZE_MAX;
             if (item_byte_size > 1)
                 length = item_byte_size;
             lldb::DataBufferSP data_sp (m_memory_options.m_infile.ReadFileContents (m_memory_options.m_infile_offset, length));
             if (data_sp)
             {
                 length = data_sp->GetByteSize();
                 if (length > 0)
                 {
                     Error error;
                     size_t bytes_written = process->WriteMemory (addr, data_sp->GetBytes(), length, error);
-                    
                     if (bytes_written == length)
                     {
                         // All bytes written
                         result.GetOutputStream().Printf("%" PRIu64 " bytes were written to 0x%" PRIx64 "\n", (uint64_t)bytes_written, addr);
                         result.SetStatus(eReturnStatusSuccessFinishResult);
                     }
                     else if (bytes_written > 0)
                     {
                         // Some byte written
                         result.GetOutputStream().Printf("%" PRIu64 " bytes of %" PRIu64 " requested were written to 0x%" PRIx64 "\n", (uint64_t)bytes_written, (uint64_t)length, addr);
                         result.SetStatus(eReturnStatusSuccessFinishResult);
                     }
-                    else 
+                    else
                     {
                         result.AppendErrorWithFormat ("Memory write to 0x%" PRIx64 " failed: %s.\n", addr, error.AsCString());
                         result.SetStatus(eReturnStatusFailed);
                     }
                 }
             }
             else
             {
DoExecute (Args& command, CommandReturnObject &result) override
             case eFormatVectorOfSInt8:
             case eFormatVectorOfUInt8:
             case eFormatVectorOfSInt16:
             case eFormatVectorOfUInt16:
             case eFormatVectorOfSInt32:
             case eFormatVectorOfUInt32:
             case eFormatVectorOfSInt64:
             case eFormatVectorOfUInt64:
+            case eFormatVectorOfFloat16:
             case eFormatVectorOfFloat32:
             case eFormatVectorOfFloat64:
             case eFormatVectorOfUInt128:
             case eFormatOSType:
             case eFormatComplexInteger:
             case eFormatAddressInfo:
             case eFormatHexFloat:
             case eFormatInstruction:
             case eFormatVoid:
                 result.AppendError("unsupported format for writing memory");
                 result.SetStatus(eReturnStatusFailed);
                 return false;
 
             case eFormatDefault:
             case eFormatBytes:
             case eFormatHex:
             case eFormatHexUppercase:
             case eFormatPointer:
-                
                 // Decode hex bytes
                 uval64 = StringConvert::ToUInt64(value_str, UINT64_MAX, 16, &success);
                 if (!success)
                 {
                     result.AppendErrorWithFormat ("'%s' is not a valid hex string value.\n", value_str);
                     result.SetStatus(eReturnStatusFailed);
                     return false;
                 }

 };
 
 //----------------------------------------------------------------------
 // Get malloc/free history of a memory address.
 //----------------------------------------------------------------------
 class CommandObjectMemoryHistory : public CommandObjectParsed
 {
 public:
-    
     CommandObjectMemoryHistory (CommandInterpreter &interpreter) :
     CommandObjectParsed (interpreter,
                          "memory history",
                          "Prints out the recorded stack traces for allocation/deallocation of a memory address.",
                          NULL,
                          eCommandRequiresTarget | eCommandRequiresProcess | eCommandProcessMustBePaused | eCommandProcessMustBeLaunched)
     {
         CommandArgumentEntry arg1;
         CommandArgumentData addr_arg;
-        
         // Define the first (and only) variant of this arg.
         addr_arg.arg_type = eArgTypeAddress;
         addr_arg.arg_repetition = eArgRepeatPlain;
-        
         // There is only one variant this argument could be; put it into the argument entry.
         arg1.push_back (addr_arg);
-        
         // Push the data for the first argument into the m_arguments vector.
         m_arguments.push_back (arg1);
     }
-    
     ~CommandObjectMemoryHistory () override
     {
     }
-    
     const char *
     GetRepeatCommand (Args &current_command_args, uint32_t index) override
     {
         return m_cmd_name.c_str();
     }
-    
 protected:
     bool
     DoExecute (Args& command, CommandReturnObject &result) override
     {
         const size_t argc = command.GetArgumentCount();
-        
         if (argc == 0 || argc > 1)
         {
             result.AppendErrorWithFormat ("%s takes an address expression", m_cmd_name.c_str());
             result.SetStatus(eReturnStatusFailed);
             return false;
         }
-        
         Error error;
         lldb::addr_t addr = Args::StringToAddress (&m_exe_ctx,
                                                    command.GetArgumentAtIndex(0),
                                                    LLDB_INVALID_ADDRESS,
                                                    &error);
-        
         if (addr == LLDB_INVALID_ADDRESS)
         {
             result.AppendError("invalid address expression");
             result.AppendError(error.AsCString());
             result.SetStatus(eReturnStatusFailed);
             return false;
         }
-        
         Stream *output_stream = &result.GetOutputStream();
-        
         const ProcessSP &process_sp = m_exe_ctx.GetProcessSP();
         const MemoryHistorySP &memory_history = MemoryHistory::FindPlugin(process_sp);
-        
         if (! memory_history.get())
         {
             result.AppendError("no available memory history provider");
             result.SetStatus(eReturnStatusFailed);
             return false;
         }
-        
         HistoryThreads thread_list = memory_history->GetHistoryThreads(addr);
-        
         for (auto thread : thread_list) {
             thread->GetStatus(*output_stream, 0, UINT32_MAX, 0);
         }
-        
         result.SetStatus(eReturnStatusSuccessFinishResult);
-        
         return true;
     }
-    
 };
 
 
 //-------------------------------------------------------------------------
 // CommandObjectMemory
 //-------------------------------------------------------------------------
 
 CommandObjectMemory::CommandObjectMemory (CommandInterpreter &interpreter) :

tools/debugserver/source/RNBRemote.cpp

 }
 
 // This makes use of asynchronous bit 'A' in the gdb remote protocol.
 rnb_err_t
 RNBRemote::SendAsyncProfileDataPacket (char *buf, nub_size_t buf_size)
 {
     if (buf_size == 0)
         return rnb_success;
-    
     std::string packet("A");
     packet.append(buf, buf_size);
     return SendPacket(packet);
 }
 
 // Given a std::string packet contents to send, possibly encode/compress it.
 // If compression is enabled, the returned std::string will be in one of two
 // forms:
-// 
+//
 //    N<original packet contents uncompressed>
 //    C<size of original decompressed packet>:<packet compressed with the requested compression scheme>
 //
 // If compression is not requested, the original packet contents are returned
 
-std::string 
+std::string
 RNBRemote::CompressString (const std::string &orig)
 {
     std::string compressed;
     compression_types compression_type = GetCompressionType();
     if (compression_type != compression_types::none)
     {
         bool compress_this_packet = false;
 
         if (orig.size() > m_compression_minsize)
         {
             compress_this_packet = true;
         }
 
         if (compress_this_packet)
         {
             const size_t encoded_data_buf_size = orig.size() + 128;
             std::vector<uint8_t> encoded_data (encoded_data_buf_size);
             size_t compressed_size = 0;
 
 #if defined (HAVE_LIBCOMPRESSION)
             if (compression_decode_buffer && compression_type == compression_types::lz4)
             {
-                compressed_size = compression_encode_buffer (encoded_data.data(), 
+                compressed_size = compression_encode_buffer (encoded_data.data(),
                                                              encoded_data_buf_size,
                                                              (uint8_t*) orig.c_str(),
                                                              orig.size(),
                                                              nullptr,
                                                              COMPRESSION_LZ4_RAW);
             }
             if (compression_decode_buffer && compression_type == compression_types::zlib_deflate)
             {
-                compressed_size = compression_encode_buffer (encoded_data.data(), 
+                compressed_size = compression_encode_buffer (encoded_data.data(),
                                                              encoded_data_buf_size,
                                                              (uint8_t*) orig.c_str(),
                                                              orig.size(),
                                                              nullptr,
                                                              COMPRESSION_ZLIB);
             }
             if (compression_decode_buffer && compression_type == compression_types::lzma)
             {
-                compressed_size = compression_encode_buffer (encoded_data.data(), 
+                compressed_size = compression_encode_buffer (encoded_data.data(),
                                                              encoded_data_buf_size,
                                                              (uint8_t*) orig.c_str(),
                                                              orig.size(),
                                                              nullptr,
                                                              COMPRESSION_LZMA);
             }
             if (compression_decode_buffer && compression_type == compression_types::lzfse)
             {
-                compressed_size = compression_encode_buffer (encoded_data.data(), 
+                compressed_size = compression_encode_buffer (encoded_data.data(),
                                                              encoded_data_buf_size,
                                                              (uint8_t*) orig.c_str(),
                                                              orig.size(),
                                                              nullptr,
                                                              COMPRESSION_LZFSE);
             }
 #endif
 
RNBRemote::ThreadFunctionReadRemoteData(void *arg)
     if (remoteSP.get() != NULL)
     {
 
 #if defined (__APPLE__)
         pthread_setname_np ("read gdb-remote packets thread");
 #if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
         struct sched_param thread_param;
         int thread_sched_policy;
-        if (pthread_getschedparam(pthread_self(), &thread_sched_policy, &thread_param) == 0) 
+        if (pthread_getschedparam(pthread_self(), &thread_sched_policy, &thread_param) == 0)
         {
             thread_param.sched_priority = 47;
             pthread_setschedparam(pthread_self(), thread_sched_policy, &thread_param);
         }
 #endif
 #endif
 
         RNBRemote* remote = remoteSP.get();
         PThreadEvent& events = remote->Context().Events();
         events.SetEvents (RNBContext::event_read_thread_running);
         // START: main receive remote command thread loop
         bool done = false;
         while (!done)
         {
             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);
                     done = true;
                     break;
 
                 case rnb_not_connected:
                     DNBLogThreadedIf (LOG_RNB_REMOTE, "RNBSocket::GetCommData returned not connected...");
                     done = true;

 
 static cpu_type_t
 best_guess_cpu_type ()
 {
 #if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
     if (sizeof (char *) == 8)
     {
         return CPU_TYPE_ARM64;
-    }   
+    }
     else
     {
         return CPU_TYPE_ARM;
-    }   
+    }
 #elif defined (__i386__) || defined (__x86_64__)
     if (sizeof (char*) == 8)
     {
         return CPU_TYPE_X86_64;
     }
     else
     {
         return CPU_TYPE_I386;
     }
 #endif
     return 0;
 }
 
 
 /* Read the bytes in STR which are GDB Remote Protocol binary encoded bytes
  (8-bit bytes).
- This encoding uses 0x7d ('}') as an escape character for 
+ This encoding uses 0x7d ('}') as an escape character for
  0x7d ('}'), 0x23 ('#'), 0x24 ('$'), 0x2a ('*').
  LEN is the number of bytes to be processed.  If a character is escaped,
  it is 2 characters for LEN.  A LEN of -1 means decode-until-nul-byte
  (end of string).  */
 
 std::vector<uint8_t>
 decode_binary_data (const char *str, size_t len)
 {
if (g_dynamic_register_map.empty())
             if (reg_sets[set].registers == NULL)
                 continue;
 
             for (uint32_t reg=0; reg < reg_sets[set].num_registers; ++reg)
             {
                 register_map_entry_t reg_entry = {
                     regnum++,                           // register number starts at zero and goes up with no gaps
                     reg_data_offset,                    // Offset into register context data, no gaps between registers
-                    reg_sets[set].registers[reg]        // DNBRegisterInfo
+                    reg_sets[set].registers[reg],       // DNBRegisterInfo
+                    0
                 };
 
                 name_to_regnum[reg_entry.nub_info.name] = reg_entry.debugserver_regnum;
 
                 if (reg_entry.nub_info.value_regs == NULL)
                 {
                     reg_data_offset += reg_entry.nub_info.size;
                 }
 
                 g_dynamic_register_map.push_back (reg_entry);
             }
         }
-        
         // Now we must find any registers whose values are in other registers and fix up
         // the offsets since we removed all gaps...
         for (auto &reg_entry: g_dynamic_register_map)
         {
             if (reg_entry.nub_info.value_regs)
             {
                 uint32_t new_offset = UINT32_MAX;
                 for (size_t i=0; reg_entry.nub_info.value_regs[i] != NULL; ++i)
                 {
                     const char *name = reg_entry.nub_info.value_regs[i];
                     auto pos = name_to_regnum.find(name);
                     if (pos != name_to_regnum.end())
                     {
                         regnum = pos->second;
                         reg_entry.value_regnums.push_back(regnum);
                         if (regnum < g_dynamic_register_map.size())
                         {
                             // The offset for value_regs registers is the offset within the register with the lowest offset
                             const uint32_t reg_offset = g_dynamic_register_map[regnum].offset + reg_entry.nub_info.offset;
                             if (new_offset > reg_offset)
                                 new_offset = reg_offset;
                         }
                     }
                 }
-                
                 if (new_offset != UINT32_MAX)
                 {
                     reg_entry.offset = new_offset;
                 }
                 else
                 {
                     DNBLogThreaded("no offset was calculated entry for register %s", reg_entry.nub_info.name);
                     reg_entry.offset = UINT32_MAX;
if (g_dynamic_register_map.empty())
                     if (pos != name_to_regnum.end())
                     {
                         regnum = pos->second;
                         reg_entry.invalidate_regnums.push_back(regnum);
                     }
                 }
             }
         }
-        
-        
 //        for (auto &reg_entry: g_dynamic_register_map)
 //        {
 //            DNBLogThreaded("%4i: size = %3u, pseudo = %i, name = %s",
 //                           reg_entry.offset,
 //                           reg_entry.nub_info.size,
 //                           reg_entry.nub_info.value_regs != NULL,
 //                           reg_entry.nub_info.name);
 //        }
if (reg_num < g_num_reg_entries)
             case GENERIC_REGNUM_ARG3:   ostrm << "generic:arg3;"; break;
             case GENERIC_REGNUM_ARG4:   ostrm << "generic:arg4;"; break;
             case GENERIC_REGNUM_ARG5:   ostrm << "generic:arg5;"; break;
             case GENERIC_REGNUM_ARG6:   ostrm << "generic:arg6;"; break;
             case GENERIC_REGNUM_ARG7:   ostrm << "generic:arg7;"; break;
             case GENERIC_REGNUM_ARG8:   ostrm << "generic:arg8;"; break;
             default: break;
         }
-        
         if (!reg_entry->value_regnums.empty())
         {
             ostrm << "container-regs:";
             for (size_t i=0, n=reg_entry->value_regnums.size(); i < n; ++i)
             {
                 if (i > 0)
                     ostrm << ',';
                 ostrm << RAW_HEXBASE << reg_entry->value_regnums[i];
while (p && *p != '\0')
         {
             p += sizeof ("bitmask=") - 1;
             while (p && *p != '\0' && *p != ';')
             {
                 if (*p == '|')
                     p++;
 
 // to regenerate the LOG_ entries (not including the LOG_RNB entries)
-// $ for logname in `grep '^#define LOG_' DNBDefs.h | egrep -v 'LOG_HI|LOG_LO' | awk '{print $2}'` 
-// do 
+// $ for logname in `grep '^#define LOG_' DNBDefs.h | egrep -v 'LOG_HI|LOG_LO' | awk '{print $2}'`
+// do
 //   echo "                else if (strncmp (p, \"$logname\", sizeof (\"$logname\") - 1) == 0)"
-//   echo "                {" 
+//   echo "                {"
 //   echo "                    p += sizeof (\"$logname\") - 1;"
 //   echo "                    bitmask |= $logname;"
 //   echo "                }"
 // done
                 if (strncmp (p, "LOG_VERBOSE", sizeof ("LOG_VERBOSE") - 1) == 0)
                 {
                     p += sizeof ("LOG_VERBOSE") - 1;
                     bitmask |= LOG_VERBOSE;
if (!m_ctx.HasValidProcessID())
         // QSetSTDIN
         // QSetSTDOUT
         // QSetSTDERR
         StringExtractor packet(p);
         packet.SetFilePos (7);
         char ch = packet.GetChar();
         while (packet.GetChar() != ':')
             /* Do nothing. */;
-            
         switch (ch)
         {
             case 'I': // STDIN
                 packet.GetHexByteString (m_ctx.GetSTDIN());
                 success = !m_ctx.GetSTDIN().empty();
                 break;
 
             case 'O': // STDOUT
if (!m_ctx.HasValidProcessID())
         }
         if (success)
             return SendPacket ("OK");
         return SendPacket ("E57");
     }
     return SendPacket ("E58");
 }
 
-rnb_err_t 
+rnb_err_t
 RNBRemote::HandlePacket_QSetWorkingDir (const char *p)
 {
     // Only set the working directory if we don't already have a process
     if (!m_ctx.HasValidProcessID())
     {
         StringExtractor packet(p += sizeof ("QSetWorkingDir:") - 1);
         if (packet.GetHexByteString (m_ctx.GetWorkingDir()))
         {
RNBRemote::HandlePacket_QSetDetachOnError (const char *p)
     switch (*p)
     {
         case '0': should_detach = false; break;
         case '1': should_detach = true; break;
         default:
           return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "Invalid value for QSetDetachOnError - should be 0 or 1");
           break;
     }
-    
     m_ctx.SetDetachOnError(should_detach);
     return SendPacket ("OK");
 }
 
 rnb_err_t
 RNBRemote::HandlePacket_QListThreadsInStopReply (const char *p)
 {
     // If this packet is received, it allows us to send an extra key/value

 {
     /* This sets the environment for the target program.  The packet is of the form:
 
         QEnvironmentHexEncoded:VARIABLE=VALUE
 
         The VARIABLE=VALUE part is sent hex-encoded so characters like '#' with special
         meaning in the remote protocol won't break it.
     */
-       
-    DNBLogThreadedIf (LOG_RNB_REMOTE, "%8u RNBRemote::%s Handling QEnvironmentHexEncoded: \"%s\"", 
+    DNBLogThreadedIf (LOG_RNB_REMOTE, "%8u RNBRemote::%s Handling QEnvironmentHexEncoded: \"%s\"",
         (uint32_t)m_comm.Timer().ElapsedMicroSeconds(true), __FUNCTION__, p);
 
     p += sizeof ("QEnvironmentHexEncoded:") - 1;
-        
     std::string arg;
     const char *c;
     c = p;
     while (*c != '\0')
       {
         if (*(c + 1) == '\0')
         {
             return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "non-hex char in arg on 'QEnvironmentHexEncoded' pkt");
while (*c != '\0')
             return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "non-hex char in arg on 'QEnvironmentHexEncoded' pkt");
           }
         arg.push_back(ch);
         c += 2;
       }
 
     RNBContext& ctx = Context();
     if (arg.length() > 0)
-      ctx.PushEnvironment (arg.c_str());  
+      ctx.PushEnvironment (arg.c_str());
 
     return SendPacket ("OK");
 }
 
 
 rnb_err_t
 RNBRemote::HandlePacket_QLaunchArch (const char *p)
 {
register_value_in_hex_fixed_width (std::ostream& ostrm,
     if (reg != NULL)
     {
         DNBRegisterValue reg_value;
         if (reg_value_ptr == NULL)
         {
             if (DNBThreadGetRegisterValueByID (pid, tid, reg->nub_info.set, reg->nub_info.reg, &reg_value))
                 reg_value_ptr = &reg_value;
         }
-        
         if (reg_value_ptr)
         {
             append_hex_value (ostrm, reg_value_ptr->value.v_uint8, reg->nub_info.size, false);
         }
         else
         {
             // If we fail to read a register value, check if it has a default
             // fail value. If it does, return this instead in case some of
if (DNBThreadGetStopReason (pid, tid, &tid_stop_info))
         ostrm << RAWHEX8(signum & 0xff);
 
         ostrm << std::hex << "thread:" << tid << ';';
 
         const char *thread_name = DNBThreadGetName (pid, tid);
         if (thread_name && thread_name[0])
         {
             size_t thread_name_len = strlen(thread_name);
-            
 
             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;
if (DNBThreadGetStopReason (pid, tid, &tid_stop_info))
                 {
                     if (!DNBThreadGetRegisterValueByID (pid, tid, g_reg_entries[reg].nub_info.set, g_reg_entries[reg].nub_info.reg, &reg_value))
                         continue;
 
                     debugserver_regnum_with_fixed_width_hex_register_value (ostrm, pid, tid, &g_reg_entries[reg], &reg_value);
                 }
             }
         }
-        
         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 << ';';
switch (pid_state)
                 }
 
                 // If we have an empty exit packet, lets fill one in to be safe.
                 if (!pid_exited_packet[0])
                 {
                     strncpy (pid_exited_packet, "W00", sizeof(pid_exited_packet)-1);
                     pid_exited_packet[sizeof(pid_exited_packet)-1] = '\0';
                 }
-                
                 const char *exit_info = DNBProcessGetExitInfo (pid);
                 if (exit_info != NULL && *exit_info != '\0')
                 {
                     std::ostringstream exit_packet;
                     exit_packet << pid_exited_packet;
                     exit_packet << ';';
                     exit_packet << RAW_HEXBASE << "description";
                     exit_packet << ':';
RNBRemote::HandlePacket_m (const char *p)
     return SendPacket (ostrm.str ());
 }
 
 // Read memory, sent it up as binary data.
 // Usage:  xADDR,LEN
 // ADDR and LEN are both base 16.
 
 // Responds with 'OK' for zero-length request
-// or 
+// or
 //
 // DATA
 //
 // where DATA is the binary data payload.
 
 rnb_err_t
 RNBRemote::HandlePacket_x (const char *p)
 {
if (!m_ctx.HasValidProcessID())
         return SendPacket ("E11");
     }
 
     if (g_num_reg_entries == 0)
         InitializeRegisters ();
 
     StringExtractor packet(p);
     packet.SetFilePos(1); // Skip the 'G'
-    
     nub_process_t pid = m_ctx.ProcessID();
     nub_thread_t tid = ExtractThreadIDFromThreadSuffix (p);
     if (tid == INVALID_NUB_THREAD)
         return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "No thread specified in p packet");
 
     // Get the register context size first by calling with NULL buffer
     nub_size_t reg_ctx_size = DNBThreadGetRegisterContext(pid, tid, NULL, 0);
     if (reg_ctx_size)
     {
         // Now allocate enough space for the entire register context
         std::vector<uint8_t> reg_ctx;
         reg_ctx.resize(reg_ctx_size);
-        
         const nub_size_t bytes_extracted = packet.GetHexBytes (&reg_ctx[0], reg_ctx.size(), 0xcc);
         if (bytes_extracted == reg_ctx.size())
         {
             // Now write the register context
             reg_ctx_size = DNBThreadSetRegisterContext(pid, tid, reg_ctx.data(), reg_ctx.size());
             if (reg_ctx_size == reg_ctx.size())
                 return SendPacket ("OK");
-            else 
+            else
                 return SendPacket ("E55");
         }
         else
         {
             DNBLogError("RNBRemote::HandlePacket_G(%s): extracted %llu of %llu bytes, size mismatch\n", p, (uint64_t)bytes_extracted, (uint64_t)reg_ctx_size);
             return SendPacket ("E64");
         }
     }
if (remoteSP.get() != NULL)
             return false;
         else
             return true;
     }
     return true;
 }
 
 
-// FORMAT: _MXXXXXX,PPP   
+// FORMAT: _MXXXXXX,PPP
 //      XXXXXX: big endian hex chars
 //      PPP: permissions can be any combo of r w x chars
 //
 // RESPONSE: XXXXXX
 //      XXXXXX: hex address of the newly allocated memory
 //      EXX: error code
 //
 // EXAMPLES:
 //      _M123000,rw
 //      _M123000,rwx
 //      _M123000,xw
 
 rnb_err_t
 RNBRemote::HandlePacket_AllocateMemory (const char *p)
 {
     StringExtractor packet (p);
     packet.SetFilePos(2); // Skip the "_M"
-    
     nub_addr_t size = packet.GetHexMaxU64 (StringExtractor::BigEndian, 0);
     if (size != 0)
     {
         if (packet.GetChar() == ',')
         {
             uint32_t permissions = 0;
             char ch;
             bool success = true;
             while (success && (ch = packet.GetChar()) != '\0')
             {
                 switch (ch)
                 {
                 case 'r':   permissions |= eMemoryPermissionsReadable; break;
                 case 'w':   permissions |= eMemoryPermissionsWritable; break;
                 case 'x':   permissions |= eMemoryPermissionsExecutable; break;
                 default:    success = false; break;
                 }
             }
-            
             if (success)
             {
                 nub_addr_t addr = DNBProcessMemoryAllocate (m_ctx.ProcessID(), size, permissions);
                 if (addr != INVALID_NUB_ADDRESS)
                 {
                     std::ostringstream ostrm;
                     ostrm << RAW_HEXBASE << addr;
                     return SendPacket (ostrm.str ());
                 }
             }
         }
     }
     return SendPacket ("E53");
 }
 
-// FORMAT: _mXXXXXX   
+// FORMAT: _mXXXXXX
 //      XXXXXX: address that was previously allocated
 //
 // RESPONSE: XXXXXX
 //      OK: address was deallocated
 //      EXX: error code
 //
-// EXAMPLES: 
+// EXAMPLES:
 //      _m123000
 
 rnb_err_t
 RNBRemote::HandlePacket_DeallocateMemory (const char *p)
 {
     StringExtractor packet (p);
     packet.SetFilePos(2); // Skip the "_m"
     nub_addr_t addr = packet.GetHexMaxU64 (StringExtractor::BigEndian, INVALID_NUB_ADDRESS);
RNBRemote::HandlePacket_SaveRegisterState (const char *p)
     nub_thread_t tid = ExtractThreadIDFromThreadSuffix (p);
     if (tid == INVALID_NUB_THREAD)
     {
         if (m_thread_suffix_supported)
             return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "No thread specified in QSaveRegisterState packet");
         else
             return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "No thread was is set with the Hg packet");
     }
-    
     // Get the register context size first by calling with NULL buffer
     const uint32_t save_id = DNBThreadSaveRegisterState(pid, tid);
     if (save_id != 0)
     {
         char response[64];
         snprintf (response, sizeof(response), "%u", save_id);
         return SendPacket (response);
     }
RNBRemote::HandlePacket_RestoreRegisterState (const char *p)
     nub_thread_t tid = ExtractThreadIDFromThreadSuffix (p);
     if (tid == INVALID_NUB_THREAD)
     {
         if (m_thread_suffix_supported)
             return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "No thread specified in QSaveRegisterState packet");
         else
             return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "No thread was is set with the Hg packet");
     }
-    
     StringExtractor packet (p);
     packet.SetFilePos(strlen("QRestoreRegisterState:")); // Skip the "QRestoreRegisterState:"
     const uint32_t save_id = packet.GetU32(0);
-                      
     if (save_id != 0)
     {
         // Get the register context size first by calling with NULL buffer
         if (DNBThreadRestoreRegisterState(pid, tid, save_id))
             return SendPacket ("OK");
         else
             return SendPacket ("E77");
     }
else if (strstr (p, "vCont") == p)
         return rnb_success;
     }
     else if (strstr (p, "vAttach") == p)
     {
         nub_process_t attach_pid = INVALID_NUB_PROCESS;        // attach_pid will be set to 0 if the attach fails
         nub_process_t pid_attaching_to = INVALID_NUB_PROCESS;  // pid_attaching_to is the original pid specified
         char err_str[1024]={'\0'};
         std::string attach_name;
-        
         if (strstr (p, "vAttachWait;") == p)
         {
             p += strlen("vAttachWait;");
             if (!GetProcessNameFrom_vAttach(p, attach_name))
             {
                 return HandlePacket_ILLFORMED (__FILE__, __LINE__, p, "non-hex char in arg on 'vAttachWait' pkt");
             }
             const bool ignore_existing = true;
#if defined (__APPLE__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101000)
                 pid_attaching_to = DNBProcessGetPIDByName (attach_name.c_str());
             }
             if (pid_attaching_to != INVALID_NUB_PROCESS && strcmp (err_str, "No such process") != 0)
             {
                 // csr_check(CSR_ALLOW_TASK_FOR_PID) will be nonzero if System Integrity Protection is in effect.
                 if (csr_check(CSR_ALLOW_TASK_FOR_PID) != 0)
                 {
                     bool attach_failed_due_to_sip = false;
-                    
                     if (rootless_allows_task_for_pid (pid_attaching_to) == 0)
                     {
                         attach_failed_due_to_sip = true;
                     }
 
                     if (attach_failed_due_to_sip == false)
                     {
                         int csops_flags = 0;
                         int retval = ::csops (pid_attaching_to, CS_OPS_STATUS, &csops_flags, sizeof (csops_flags));
                         if (retval != -1 && (csops_flags & CS_RESTRICT))
                         {
                             attach_failed_due_to_sip = true;
                         }
                     }
                     if (attach_failed_due_to_sip)
                     {
                         SendPacket ("E87");  // E87 is the magic value which says that we are not allowed to attach
                         DNBLogError ("Attach failed because process does not allow attaching: \"%s\".", err_str);
                         return rnb_err;
                     }
                 }
             }
-                
 #endif
 
             SendPacket ("E01");  // E01 is our magic error value for attach failed.
             DNBLogError ("Attach failed: \"%s\".", err_str);
             return rnb_err;
         }
     }
 
RNBRemote::HandlePacket_c (const char *p)
     return rnb_success;
 }
 
 rnb_err_t
 RNBRemote::HandlePacket_MemoryRegionInfo (const char *p)
 {
     /* This packet will find memory attributes (e.g. readable, writable, executable, stack, jitted code)
        for the memory region containing a given address and return that information.
-       
-       Users of this packet must be prepared for three results:  
+       Users of this packet must be prepared for three results:
 
            Region information is returned
            Region information is unavailable for this address because the address is in unmapped memory
            Region lookup cannot be performed on this platform or process is not yet launched
-           This packet isn't implemented 
+           This packet isn't implemented
 
        Examples of use:
           qMemoryRegionInfo:3a55140
           start:3a50000,size:100000,permissions:rwx
 
           qMemoryRegionInfo:0
           error:address in unmapped region
 
RNBRemote::HandlePacket_MemoryRegionInfo (const char *p)
     DNBProcessMemoryRegionInfo (m_ctx.ProcessID(), address, &region_info);
     std::ostringstream ostrm;
 
         // start:3a50000,size:100000,permissions:rwx
     ostrm << "start:" << std::hex << region_info.addr << ';';
 
     if (region_info.size > 0)
         ostrm << "size:"  << std::hex << region_info.size << ';';
-        
     if (region_info.permissions)
     {
         ostrm << "permissions:";
-        
         if (region_info.permissions & eMemoryPermissionsReadable)
             ostrm << 'r';
         if (region_info.permissions & eMemoryPermissionsWritable)
             ostrm << 'w';
         if (region_info.permissions & eMemoryPermissionsExecutable)
             ostrm << 'x';
         ostrm << ';';
     }
     return SendPacket (ostrm.str());
 }
 
 // qGetProfileData;scan_type:0xYYYYYYY
 rnb_err_t
 RNBRemote::HandlePacket_GetProfileData (const char *p)
 {
     nub_process_t pid = m_ctx.ProcessID();
     if (pid == INVALID_NUB_PROCESS)
         return SendPacket ("OK");
-    
     StringExtractor packet(p += sizeof ("qGetProfileData"));
     DNBProfileDataScanType scan_type = eProfileAll;
     std::string name;
     std::string value;
     while (packet.GetNameColonValue(name, value))
     {
         if (name.compare ("scan_type") == 0)
         {
             std::istringstream iss(value);
             uint32_t int_value = 0;
             if (iss >> std::hex >> int_value)
             {
                 scan_type = (DNBProfileDataScanType)int_value;
             }
         }
     }
-    
     std::string data = DNBProcessGetProfileData(pid, scan_type);
     if (!data.empty())
     {
         return SendPacket (data.c_str());
     }
     else
     {
         return SendPacket ("OK");
while (packet.GetNameColonValue(name, value))
             std::istringstream iss(value);
             uint32_t int_value = 0;
             if (iss >> std::hex >> int_value)
             {
                 scan_type = (DNBProfileDataScanType)int_value;
             }
         }
     }
-    
     if (interval_usec == 0)
     {
         enable = 0;
     }
-    
     DNBProcessSetEnableAsyncProfiling(pid, enable, interval_usec, scan_type);
     return SendPacket ("OK");
 }
 
 // QEnableCompression:type:<COMPRESSION-TYPE>;minsize:<MINIMUM PACKET SIZE TO COMPRESS>;
 //
 // type: must be a type previously reported by the qXfer:features: SupportedCompressions list
 //
 // minsize: is optional; by default the qXfer:features: DefaultCompressionMinSize value is used
-// debugserver may have a better idea of what a good minimum packet size to compress is than lldb. 
+// debugserver may have a better idea of what a good minimum packet size to compress is than lldb.
 
 rnb_err_t
 RNBRemote::HandlePacket_QEnableCompression (const char *p)
 {
     p += sizeof ("QEnableCompression:") - 1;
 
     size_t new_compression_minsize = m_compression_minsize;
     const char *new_compression_minsize_str = strstr (p, "minsize:");
else
         return SendPacket ("E79");
     }
 }
 
 rnb_err_t
 RNBRemote::HandlePacket_WatchpointSupportInfo (const char *p)
 {
     /* This packet simply returns the number of supported hardware watchpoints.
-       
        Examples of use:
           qWatchpointSupportInfo:
           num:4
 
           qWatchpointSupportInfo
           OK                   // this packet is implemented by the remote nub
     */
 

 
 static bool
 GetHostCPUType (uint32_t &cputype, uint32_t &cpusubtype, uint32_t &is_64_bit_capable, bool &promoted_to_64)
 {
     static uint32_t g_host_cputype = 0;
     static uint32_t g_host_cpusubtype = 0;
     static uint32_t g_is_64_bit_capable = 0;
     static bool g_promoted_to_64 = false;
-    
     if (g_host_cputype == 0)
     {
         g_promoted_to_64 = false;
         size_t len = sizeof(uint32_t);
         if  (::sysctlbyname("hw.cputype", &g_host_cputype, &len, NULL, 0) == 0)
         {
             len = sizeof (uint32_t);
             if  (::sysctlbyname("hw.cpu64bit_capable", &g_is_64_bit_capable, &len, NULL, 0) == 0)
             {
                 if (g_is_64_bit_capable && ((g_host_cputype & CPU_ARCH_ABI64) == 0))
                 {
                     g_promoted_to_64 = true;
                     g_host_cputype |= CPU_ARCH_ABI64;
                 }
             }
         }
-        
         len = sizeof(uint32_t);
         if (::sysctlbyname("hw.cpusubtype", &g_host_cpusubtype, &len, NULL, 0) == 0)
         {
             if (g_promoted_to_64 &&
                 g_host_cputype == CPU_TYPE_X86_64 && g_host_cpusubtype == CPU_SUBTYPE_486)
                 g_host_cpusubtype = CPU_SUBTYPE_X86_64_ALL;
         }
     }
-    
     cputype = g_host_cputype;
     cpusubtype = g_host_cpusubtype;
     is_64_bit_capable = g_is_64_bit_capable;
     promoted_to_64 = g_promoted_to_64;
     return g_host_cputype != 0;
 }
 
 rnb_err_t

 
 static std::string g_target_xml;
 
 void
 UpdateTargetXML ()
 {
     std::ostringstream s;
     s << g_target_xml_header << std::endl;
-    
     // Set the architecture
     //s << "<architecture>" << arch "</architecture>" << std::endl;
-    
     // Set the OSABI
     //s << "<osabi>abi-name</osabi>"
 
     GenerateTargetXMLRegisters(s);
-    
     s << g_target_xml_footer << std::endl;
 
     // Save the XML output in case it gets retrieved in chunks
     g_target_xml = s.str();
 }
 
 rnb_err_t
 RNBRemote::HandlePacket_qXfer (const char *command)
RNBRemote::HandlePacket_qXfer (const char *command)
     return SendPacket ("E82");
 }
 
 
 rnb_err_t
 RNBRemote::HandlePacket_qGDBServerVersion (const char *p)
 {
     std::ostringstream strm;
-    
 #if defined(DEBUGSERVER_PROGRAM_NAME)
     strm << "name:" DEBUGSERVER_PROGRAM_NAME ";";
 #else
     strm << "name:debugserver;";
 #endif
     strm << "version:" << DEBUGSERVER_VERSION_NUM << ";";
 
     return SendPacket (strm.str());

 //        uint64_t dti_queue_index = get_integer_value_for_key_name_from_json ("dti_queue_index", p);
 //        uint64_t dti_voucher_index = get_integer_value_for_key_name_from_json ("dti_voucher_index", p);
 
         if (tid != INVALID_NUB_ADDRESS)
         {
             nub_addr_t pthread_t_value = DNBGetPThreadT (pid, tid);
 
             uint64_t tsd_address = INVALID_NUB_ADDRESS;
-            if (plo_pthread_tsd_entry_size != INVALID_NUB_ADDRESS 
-                && plo_pthread_tsd_base_offset != INVALID_NUB_ADDRESS 
+            if (plo_pthread_tsd_entry_size != INVALID_NUB_ADDRESS
+                && plo_pthread_tsd_base_offset != INVALID_NUB_ADDRESS
                 && plo_pthread_tsd_entry_size != INVALID_NUB_ADDRESS)
             {
                 tsd_address = DNBGetTSDAddressForThread (pid, tid, plo_pthread_tsd_base_address_offset, plo_pthread_tsd_base_offset, plo_pthread_tsd_entry_size);
             }
 
             bool timed_out = false;
             Genealogy::ThreadActivitySP thread_activity_sp;
 
             // If the pthread_t value is invalid, or if we were able to fetch the thread's TSD base
             // and got an invalid value back, then we have a thread in early startup or shutdown and
             // it's possible that gathering the genealogy information for this thread go badly.
-            // Ideally fetching this info for a thread in these odd states shouldn't matter - but 
+            // Ideally fetching this info for a thread in these odd states shouldn't matter - but
             // we've seen some problems with these new SPI and threads in edge-casey states.
 
             double genealogy_fetch_time = 0;
             if (pthread_t_value != INVALID_NUB_ADDRESS && tsd_address != INVALID_NUB_ADDRESS)
             {
                 DNBTimer timer(false);
                 thread_activity_sp = DNBGetGenealogyInfoForThread (pid, tid, timed_out);
                 genealogy_fetch_time = timer.ElapsedMicroSeconds(false) / 1000000.0;
             }
 
-            std::unordered_set<uint32_t> process_info_indexes; // an array of the process info #'s seen 
+            std::unordered_set<uint32_t> process_info_indexes; // an array of the process info #'s seen
 
             json << "{";
 
             bool need_to_print_comma = false;
 
             if (thread_activity_sp && timed_out == false)
             {
                 const Genealogy::Activity *activity = &thread_activity_sp->current_activity;
if (::sysctl (procpid_mib, 4, &proc_kinfo, &proc_kinfo_size, NULL, 0) == 0)
             rep << "parent-pid:" << std::hex << proc_kinfo.kp_eproc.e_ppid << ";";
             rep << "real-uid:" << std::hex << proc_kinfo.kp_eproc.e_pcred.p_ruid << ";";
             rep << "real-gid:" << std::hex << proc_kinfo.kp_eproc.e_pcred.p_rgid << ";";
             rep << "effective-uid:" << std::hex << proc_kinfo.kp_eproc.e_ucred.cr_uid << ";";
             if (proc_kinfo.kp_eproc.e_ucred.cr_ngroups > 0)
                 rep << "effective-gid:" << std::hex << proc_kinfo.kp_eproc.e_ucred.cr_groups[0] << ";";
         }
     }
-    
     cpu_type_t cputype = DNBProcessGetCPUType (pid);
     if (cputype == 0)
     {
         DNBLog ("Unable to get the process cpu_type, making a best guess.");
         cputype = best_guess_cpu_type();
     }
 
     if (cputype != 0)
RNBRemote::HandlePacket_qProcessInfo (const char *p)
     else
     {
         bool is_ios_simulator = false;
         if (cputype == CPU_TYPE_X86 || cputype == CPU_TYPE_X86_64)
         {
             // Check for iOS simulator binaries by getting the process argument
             // and environment and checking for SIMULATOR_UDID in the environment
             int proc_args_mib[3] = { CTL_KERN, KERN_PROCARGS2, (int)pid };
-            
             uint8_t arg_data[8192];
             size_t arg_data_size = sizeof(arg_data);
             if (::sysctl (proc_args_mib, 3, arg_data, &arg_data_size , NULL, 0) == 0)
             {
                 DNBDataRef data (arg_data, arg_data_size, false);
                 DNBDataRef::offset_t offset = 0;
                 uint32_t argc = data.Get32 (&offset);
                 const char *cstr;
-                
                 cstr = data.GetCStr (&offset);
                 if (cstr)
                 {
                     // Skip NULLs
                     while (1)
                     {
                         const char *p = data.PeekCStr(offset);
                         if ((p == NULL) || (*p != '\0'))
                             break;
                         ++offset;
                     }
                     // Now skip all arguments
                     for (uint32_t i = 0; i < argc; ++i)
                     {
                         data.GetCStr(&offset);
                     }
-                    
                     // Now iterate across all environment variables
                     while ((cstr = data.GetCStr(&offset)))
                     {
                         if (strncmp(cstr, "SIMULATOR_UDID=", strlen("SIMULATOR_UDID=")) == 0)
                         {
                             is_ios_simulator = true;
                             break;
                         }
                         if (cstr[0] == '\0')
                             break;
-                        
                     }
                 }
             }
         }
         if (is_ios_simulator)
             rep << "ostype:ios;";
         else
             rep << "ostype:macosx;";

tools/debugserver/source/debugserver.cpp

while (pid != INVALID_NUB_PROCESS)
         {
             if (set_events & (eEventProcessRunningStateChanged | eEventProcessStoppedStateChanged))
             {
                 nub_state_t pid_state = DNBProcessGetState (pid);
                 DNBLogThreadedIf (LOG_RNB_EVENTS, "%s process %4.4x state changed (eEventProcessStateChanged): %s", __FUNCTION__, pid, DNBStateAsString(pid_state));
 
                 switch (pid_state)
                 {
-                    default:
                     case eStateInvalid:
                     case eStateUnloaded:
                     case eStateAttaching:
                     case eStateLaunching:
                     case eStateSuspended:
                         break;  // Ignore
 
                     case eStateRunning:

 RNBRunLoopPlatform (RNBRemote *remote)
 {
     RNBRunLoopMode mode = eRNBRunLoopModePlatformMode;
     RNBContext& ctx = remote->Context();
 
     while (mode == eRNBRunLoopModePlatformMode)
     {
         std::string set_events_str;
-        const uint32_t event_mask = RNBContext::event_read_packet_available | 
+        const uint32_t event_mask = RNBContext::event_read_packet_available |
                                     RNBContext::event_read_thread_exiting;
-                
         DNBLogThreadedIf (LOG_RNB_EVENTS, "%s ctx.Events().WaitForSetEvents(0x%08x) ...",__FUNCTION__, event_mask);
         nub_event_t set_events = ctx.Events().WaitForSetEvents(event_mask);
         DNBLogThreadedIf (LOG_RNB_EVENTS, "%s ctx.Events().WaitForSetEvents(0x%08x) => 0x%08x (%s)",__FUNCTION__, event_mask, set_events, ctx.EventsAsString(set_events, set_events_str));
-        
         if (set_events)
         {
             if (set_events & RNBContext::event_read_packet_available)
             {
                 if (remote->HandleReceivedPacket() == rnb_not_connected)
                     mode = eRNBRunLoopModeExit;
             }
-            
             if (set_events & RNBContext::event_read_thread_exiting)
             {
                 mode = eRNBRunLoopModeExit;
             }
             ctx.Events().ResetEvents(set_events);
         }
-    }    
+    }
     return eRNBRunLoopModeExit;
 }
 
 //----------------------------------------------------------------------
 // Convenience function to set up the remote listening port
 // Returns 1 for success 0 for failure.
 //----------------------------------------------------------------------
 
 static void
 PortWasBoundCallbackUnixSocket (const void *baton, in_port_t port)
 {
     //::printf ("PortWasBoundCallbackUnixSocket (baton = %p, port = %u)\n", baton, port);
-    
     const char *unix_socket_name = (const char *)baton;
-    
     if (unix_socket_name && unix_socket_name[0])
     {
         // We were given a unix socket name to use to communicate the port
         // that we ended up binding to back to our parent process
         struct sockaddr_un saddr_un;
         int s = ::socket (AF_UNIX, SOCK_STREAM, 0);
         if (s < 0)
         {
             perror("error: socket (AF_UNIX, SOCK_STREAM, 0)");
             exit(1);
         }
-        
         saddr_un.sun_family = AF_UNIX;
         ::strncpy(saddr_un.sun_path, unix_socket_name, sizeof(saddr_un.sun_path) - 1);
         saddr_un.sun_path[sizeof(saddr_un.sun_path) - 1] = '\0';
         saddr_un.sun_len = SUN_LEN (&saddr_un);
-        
         if (::connect (s, (struct sockaddr *)&saddr_un, static_cast<socklen_t>(SUN_LEN (&saddr_un))) < 0)
         {
             perror("error: connect (socket, &saddr_un, saddr_un_len)");
             exit(1);
         }
-        
         //::printf ("connect () sucess!!\n");
-        
-        
         // We were able to connect to the socket, now write our PID so whomever
         // launched us will know this process's ID
         RNBLogSTDOUT ("Listening to port %i...\n", port);
-        
         char pid_str[64];
         const int pid_str_len = ::snprintf (pid_str, sizeof(pid_str), "%u", port);
         const ssize_t bytes_sent = ::send (s, pid_str, pid_str_len, 0);
-        
         if (pid_str_len != bytes_sent)
         {
             perror("error: send (s, pid_str, pid_str_len, 0)");
             exit (1);
         }
-        
         //::printf ("send () sucess!!\n");
-        
         // We are done with the socket
         close (s);
     }
 }
 
 static void
 PortWasBoundCallbackNamedPipe (const void *baton, uint16_t port)
 {

 {
     const char *argv_sub_zero = argv[0]; // save a copy of argv[0] for error reporting post-launch
 
 #if defined (__APPLE__)
     pthread_setname_np ("main thread");
 #if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
     struct sched_param thread_param;
     int thread_sched_policy;
-    if (pthread_getschedparam(pthread_self(), &thread_sched_policy, &thread_param) == 0) 
+    if (pthread_getschedparam(pthread_self(), &thread_sched_policy, &thread_param) == 0)
     {
         thread_param.sched_priority = 47;
         pthread_setschedparam(pthread_self(), thread_sched_policy, &thread_param);
     }
 
     ::proc_set_wakemon_params (getpid(), 500, 0); // Allow up to 500 wakeups/sec to avoid EXC_RESOURCE for normal use.
 #endif
 #endif
 
     g_isatty = ::isatty (STDIN_FILENO);
 
     //  ::printf ("uid=%u euid=%u gid=%u egid=%u\n",
     //            getuid(),
     //            geteuid(),
     //            getgid(),
     //            getegid());
 
 
     //    signal (SIGINT, signal_handler);
     signal (SIGPIPE, signal_handler);
     signal (SIGHUP, signal_handler);
-    
     // We're always sitting in waitpid or kevent waiting on our target process' death,
     // we don't need no stinking SIGCHLD's...
-    
     sigset_t sigset;
     sigemptyset(&sigset);
     sigaddset(&sigset, SIGCHLD);
     sigprocmask(SIG_BLOCK, &sigset, NULL);
 
     g_remoteSP.reset (new RNBRemote ());
-    
-    
     RNBRemote *remote = g_remoteSP.get();
     if (remote == NULL)
     {
         RNBLogSTDERR ("error: failed to create a remote connection class\n");
         return -1;
     }
-    
     RNBContext& ctx = remote->Context();
 
     int i;
     int attach_pid = INVALID_NUB_PROCESS;
 
     FILE* log_file = NULL;
     uint32_t log_flags = 0;
     // Parse our options

 #if !defined (DNBLOG_ENABLED)
     compile_options += "(no-logging) ";
 #endif
 
     RNBRunLoopMode start_mode = eRNBRunLoopModeExit;
 
     char short_options[512];
     uint32_t short_options_idx = 0;
-    
      // Handle the two case that don't have short options in g_long_options
     short_options[short_options_idx++] = 'k';
     short_options[short_options_idx++] = 't';
-    
     for (i=0; g_long_options[i].name != NULL; ++i)
     {
         if (isalpha(g_long_options[i].val))
         {
             short_options[short_options_idx++] = g_long_options[i].val;
             switch (g_long_options[i].has_arg)
             {
                 default:
-                case no_argument: 
+                case no_argument:
                     break;
 
                 case optional_argument:
                     short_options[short_options_idx++] = ':';
                     // Fall through to required_argument case below...
                 case required_argument:
                     short_options[short_options_idx++] = ':';
                     break;
             }
         }
     }
     // NULL terminate the short option string.
     short_options[short_options_idx++] = '\0';
-    
 #if __GLIBC__
     optind = 0;
 #else
     optreset = 1;
     optind = 1;
 #endif
 
     while ((ch = getopt_long_only(argc, argv, short_options, g_long_options, &long_option_index)) != -1)
while ((ch = getopt_long_only(argc, argv, short_options, g_long_options, &long_option_index)) != -1)
                     waitfor_duration = static_cast<useconds_t>(strtoul(optarg, &end, 0));
                     if (end == NULL || *end != '\0')
                     {
                         RNBLogSTDERR ("error: invalid waitfor-duration option value '%s'.\n", optarg);
                         exit (7);
                     }
                 }
                 break;
-                
             case 'K':
                 g_detach_on_error = false;
 
             case 'W':
                 if (optarg && optarg[0])
                     working_dir.assign(optarg);
                 break;
 
#endif
                     else if (strcasecmp(optarg, "stderr") == 0)
                         log_file = stderr;
                     else
                     {
                         log_file = fopen(optarg, "w");
                         if (log_file != NULL)
                             setlinebuf(log_file);
                     }
-                    
                     if (log_file == NULL)
                     {
                         const char *errno_str = strerror(errno);
                         RNBLogSTDERR ("Failed to open log file '%s' for writing: errno = %i (%s)", optarg, errno, errno_str ? errno_str : "unknown error");
                     }
                 }
                 break;
 
#endif
 
             case 'I':
                 ctx.GetSTDIN().assign(optarg);
                 break;
 
             case 'O':
                 ctx.GetSTDOUT().assign(optarg);
                 break;
-            
             case 'E':
                 ctx.GetSTDERR().assign(optarg);
                 break;
 
             case 'n':
                 no_stdio = true;
                 break;
-                
             case 'S':
                 // Put debugserver into a new session. Terminals group processes
                 // into sessions and when a special terminal key sequences
                 // (like control+c) are typed they can cause signals to go out to
                 // all processes in a session. Using this --setsid (-S) option
                 // will cause debugserver to run in its own sessions and be free
                 // from such issues.
                 //
                 // This is useful when debugserver is spawned from a command
                 // line application that uses debugserver to do the debugging,
                 // yet that application doesn't want debugserver receiving the
                 // signals sent to the session (i.e. dying when anyone hits ^C).
                 setsid();
                 break;
             case 'D':
                 g_disable_aslr = 1;
                 break;
-            
             case 'p':
                 start_mode = eRNBRunLoopModePlatformMode;
                 break;
 
             case 'u':
                 unix_socket_name.assign (optarg);
                 break;
 
             case 'P':
                 named_pipe_path.assign (optarg);
                 break;
-                
             case 'e':
                 // Pass a single specified environment variable down to the process that gets launched
                 remote->Context().PushEnvironment(optarg);
                 break;
-            
             case 'F':
                 // Pass the current environment down to the process that gets launched
                 {
                     char **host_env = *_NSGetEnviron();
                     char *env_entry;
                     size_t i;
                     for (i=0; (env_entry = host_env[i]) != NULL; ++i)
                         remote->Context().PushEnvironment(env_entry);
                 }
                 break;
         }
     }
-    
     if (arch_name.empty())
     {
-#if defined (__arm__) 
+#if defined (__arm__)
         arch_name.assign ("arm");
 #endif
     }
     else
     {
         DNBSetArchitecture (arch_name.c_str());
     }
 
if (!working_dir.empty())
         if (remote->Context().SetWorkingDirectory (working_dir.c_str()) == false)
         {
             RNBLogSTDERR ("error: working directory doesn't exist '%s'.\n", working_dir.c_str());
             exit (8);
         }
     }
 
     remote->Context().SetDetachOnError(g_detach_on_error);
-    
     remote->Initialize();
 
     // It is ok for us to set NULL as the logfile (this will disable any logging)
 
     if (log_file != NULL)
     {
         DNBLogSetLogCallback(FileLogCallback, log_file);
         // If our log file was set, yet we have no log flags, log everything!
#endif
                     }
                     if (mode != eRNBRunLoopModeExit)
                         RNBLogSTDOUT ("Waiting for debugger instructions for process %d.\n", attach_pid);
                 }
                 break;
 
             case eRNBRunLoopModeInferiorLaunching:
                 {
-                    mode = RNBRunLoopLaunchInferior (remote, 
+                    mode = RNBRunLoopLaunchInferior (remote,
                                                      ctx.GetSTDINPath(),
                                                      ctx.GetSTDOUTPath(),
                                                      ctx.GetSTDERRPath(),
                                                      no_stdio);
 
                     if (mode == eRNBRunLoopModeInferiorExecuting)
                     {
                         if (port != INT32_MAX)
#endif
                     if (!ConnectRemote (remote, host.c_str(), port, reverse_connect, named_pipe_path.c_str(), unix_socket_name.c_str()))
                         mode = eRNBRunLoopModeExit;
                 }
                 else if (str[0] == '/')
                 {
                     if (remote->Comm().OpenFile (str))
                         mode = eRNBRunLoopModeExit;
                 }
-                
                 if (mode != eRNBRunLoopModeExit)
                     mode = RNBRunLoopPlatform (remote);
                 break;
 
             default:
                 mode = eRNBRunLoopModeExit;
             case eRNBRunLoopModeExit:
                 break;