Fixed a ton of gcc compile warnings

[vharron]

Summary

Removed some unused variables, added some consts, changed some casts
to const_cast. I don't think any of these changes are very
controversial.

[vharron]

Fix

[chaoren]

I think it's a good idea to use static_cast/static_pointer_cast/reinterpret_cast over C-style casts.

[labath]

It probably does not make sense to go in and change everything again, but I would also prefer C++ casts next time - it makes things more explicit and easier to review. LGTM.

[clayborg]

Looks good overall. I don't like removing "const". Why does GCC warn on the first arg "const unsigned char* ptr"?

static inline void
WriteSwappedInt64(const unsigned char* ptr, unsigned offset, uint64_t value)

include/lldb/Core/DataEncoder.h

359–360

Why do we need to remove const here?

source/Core/DataEncoder.cpp

24–53

Why do we need to remove const here?

156

Why do we need to remove const here?

[vharron]

include/lldb/Core/DataEncoder.h

359–360

That buffer is the one that data encoder writes to. Internally, it is stored as a non-const pointer to enable these writes. I think it's wrong to provide a const guarantee in the interface when we know we're going to modify it.

source/Core/DataEncoder.cpp

24–53

ptr is going to be modified so we shouldn't be providing a const guarantee.

156

See first comment

[clayborg]

"ptr" isn't being modified in any of the WriteInt* functions...

source/Core/DataEncoder.cpp

53

How is "ptr" modified here? It is just casted and used in pointer math, but it isn't being modified...

[clayborg]

Never mind.. It is writing to the memory... I was thinking read, not with. Ignore me.

include/lldb/Core/DataEncoder.h

public:
     ///     The length in bytes of \a bytes.
     ///
     /// @param[in] byte_order
     ///     A byte order of the data that we are extracting from.
     ///
     /// @return
     ///     The number of bytes that this object now contains.
     //------------------------------------------------------------------
     uint32_t
-    SetData (const void *bytes, uint32_t length, lldb::ByteOrder byte_order);
+    SetData (void *bytes, uint32_t length, lldb::ByteOrder byte_order);
 
     //------------------------------------------------------------------
     /// Adopt a subset of shared data in \a data_sp.
     ///
     /// Copies the data shared pointer which adds a reference to the
     /// contained in \a data_sp. The shared data reference is reference
     /// counted to ensure the data lives as long as anyone still has a
     /// valid shared pointer to the data in \a data_sp. The byte order

include/lldb/Interpreter/CommandObject.h

public:
     GetOptions ();
 
     static const ArgumentTableEntry*
     GetArgumentTable ();
 
     static lldb::CommandArgumentType
     LookupArgumentName (const char *arg_name);
 
-    static ArgumentTableEntry *
+    static const ArgumentTableEntry *
     FindArgumentDataByType (lldb::CommandArgumentType arg_type);
 
     int
     GetNumArgumentEntries ();
 
     CommandArgumentEntry *
     GetArgumentEntryAtIndex (int idx);
 

source/Commands/CommandObjectMemory.cpp

#undef ALL_KEYWORDS
                                                type_list);
             }
             
             if (type_list.GetSize() == 0 && lookup_type_name.GetCString() && *lookup_type_name.GetCString() == '$')
             {
                 clang::TypeDecl *tdecl = target->GetPersistentVariables().GetPersistentType(ConstString(lookup_type_name));
                 if (tdecl)
                 {
-                    clang_ast_type.SetClangType(&tdecl->getASTContext(),(lldb::clang_type_t)tdecl->getTypeForDecl());
+                    clang_ast_type.SetClangType(&tdecl->getASTContext(),(const lldb::clang_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",

source/Core/DataBufferHeap.cpp

if (src && src_len > 0)
         m_data.assign (src_u8, src_u8 + src_len);
     else
         m_data.clear();
 }
 
 void
 DataBufferHeap::AppendData (const void *src, uint64_t src_len)
 {
-    m_data.insert(m_data.end(), (uint8_t *)src, (uint8_t *)src + src_len);
+    m_data.insert(m_data.end(), (const uint8_t *)src, (const uint8_t *)src + src_len);
 }
 
 void
 DataBufferHeap::Clear()
 {
     buffer_t empty;
     m_data.swap(empty);
 }

source/Core/DataEncoder.cpp

 
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Host/Endian.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static inline void
-WriteInt16(const unsigned char* ptr, unsigned offset, uint16_t value) 
+WriteInt16(unsigned char* ptr, unsigned offset, uint16_t value)
 {
     *(uint16_t *)(ptr + offset) = value;
 }
 static inline void
-WriteInt32 (const unsigned char* ptr, unsigned offset, uint32_t value) 
+WriteInt32 (unsigned char* ptr, unsigned offset, uint32_t value)
 {
     *(uint32_t *)(ptr + offset) = value;
 }
 
 static inline void
-WriteInt64(const unsigned char* ptr, unsigned offset, uint64_t value) 
+WriteInt64(unsigned char* ptr, unsigned offset, uint64_t value)
 {
     *(uint64_t *)(ptr + offset) = value;
 }
 
 static inline void
-WriteSwappedInt16(const unsigned char* ptr, unsigned offset, uint16_t value) 
+WriteSwappedInt16(unsigned char* ptr, unsigned offset, uint16_t value)
 {
     *(uint16_t *)(ptr + offset) = llvm::ByteSwap_16(value);
 }
 
 static inline void
-WriteSwappedInt32 (const unsigned char* ptr, unsigned offset, uint32_t value) 
+WriteSwappedInt32 (unsigned char* ptr, unsigned offset, uint32_t value)
 {
     *(uint32_t *)(ptr + offset) = llvm::ByteSwap_32(value);
 }
 
 static inline void 
-WriteSwappedInt64(const unsigned char* ptr, unsigned offset, uint64_t value) 
+WriteSwappedInt64(unsigned char* ptr, unsigned offset, uint64_t value)
 {
     *(uint64_t *)(ptr + offset) = llvm::ByteSwap_64(value);
 }
 
 //----------------------------------------------------------------------
 // Default constructor.
 //----------------------------------------------------------------------
 DataEncoder::DataEncoder () :

 // long. The data is externally owned must be around at least as
 // long as this object points to the data. No copy of the data is
 // made, this object just refers to this data and can extract from
 // it. If this object refers to any shared data upon entry, the
 // reference to that data will be released. Is SWAP is set to true,
 // any data extracted will be endian swapped.
 //----------------------------------------------------------------------
 uint32_t
-DataEncoder::SetData (const void *bytes, uint32_t length, ByteOrder endian)
+DataEncoder::SetData (void *bytes, uint32_t length, ByteOrder endian)
 {
     m_byte_order = endian;
     m_data_sp.reset();
     if (bytes == NULL || length == 0)
     {
         m_start = NULL;
         m_end = NULL;
     }

source/Core/FormatEntity.cpp

switch (entry.type)
                 if (thread)
                 {
                     const char *format = "0x%4.4" PRIx64;
                     if (!entry.printf_format.empty())
                     {
                         // Watch for the special "tid" format...
                         if (entry.printf_format == "tid")
                         {
-                            bool handled = false;
                             Target &target = thread->GetProcess()->GetTarget();
                             ArchSpec arch (target.GetArchitecture ());
                             llvm::Triple::OSType ostype = arch.IsValid() ? arch.GetTriple().getOS() : llvm::Triple::UnknownOS;
                             if ((ostype == llvm::Triple::FreeBSD) || (ostype == llvm::Triple::Linux))
                             {
-                                handled = true;
                                 format = "%" PRIu64;
                             }
                         }
                         else
                         {
                             format = entry.printf_format.c_str();
                         }
                     }

source/DataFormatters/StringPrinter.cpp

switch (*buffer)
         case '\"':
             retval = {"\\\"",2};
             break;
         case '\\':
             retval = {"\\\\",2};
             break;
         default:
           if (isprint(*buffer))
               retval = {buffer,1};
           else
           {
-            retval = { new uint8_t[5],4,[] (const uint8_t* c) {delete[] c;} };
-            sprintf((char*)retval.GetBytes(),"\\x%02x",*buffer);
+              uint8_t* data = new uint8_t[5];
+              sprintf((char*)data,"\\x%02x",*buffer);
+              retval = {data, 4, [] (const uint8_t* c) {delete[] c;} };
               break;
           }
     }
     
     next = buffer + 1;
     return retval;
 }
 
 static char32_t
if (codepoint)
             case '\\':
                 retval = {"\\\\",2};
                 break;
             default:
                 if (isprint(codepoint))
                     retval = {buffer,utf8_encoded_len};
                 else
                 {
-                    retval = { new uint8_t[11],10,[] (const uint8_t* c) {delete[] c;} };
-                    sprintf((char*)retval.GetBytes(),"\\U%08x",codepoint);
+                    uint8_t* data = new uint8_t[11];
+                    sprintf((char*)data,"\\U%08x",codepoint);
+                    retval = { data,10,[] (const uint8_t* c) {delete[] c;} };
                     break;
                 }
         }
         
         next = buffer + utf8_encoded_len;
         return retval;
     }
     
DumpUTFBufferToStream (ConversionResult (*ConvertFunction) (const SourceDataType**,
     {
         const int bufferSPSize = data.GetByteSize();
         if (sourceSize == 0)
         {
             const int origin_encoding = 8*sizeof(SourceDataType);
             sourceSize = bufferSPSize/(origin_encoding / 4);
         }
         
-        SourceDataType *data_ptr = (SourceDataType*)data.GetDataStart();
-        SourceDataType *data_end_ptr = data_ptr + sourceSize;
+        const SourceDataType *data_ptr = (const SourceDataType*)data.GetDataStart();
+        const SourceDataType *data_end_ptr = data_ptr + sourceSize;
         
         while (data_ptr < data_end_ptr)
         {
             if (!*data_ptr)
             {
                 data_end_ptr = data_ptr;
                 break;
             }
             data_ptr++;
         }
         
-        data_ptr = (SourceDataType*)data.GetDataStart();
+        data_ptr = (const SourceDataType*)data.GetDataStart();
         
         lldb::DataBufferSP utf8_data_buffer_sp;
         UTF8* utf8_data_ptr = nullptr;
         UTF8* utf8_data_end_ptr = nullptr;
         
         if (ConvertFunction)
         {
             utf8_data_buffer_sp.reset(new DataBufferHeap(4*bufferSPSize,0));
             utf8_data_ptr = (UTF8*)utf8_data_buffer_sp->GetBytes();
             utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
-            ConvertFunction ( (const SourceDataType**)&data_ptr, data_end_ptr, &utf8_data_ptr, utf8_data_end_ptr, lenientConversion );
+            ConvertFunction ( &data_ptr, data_end_ptr, &utf8_data_ptr, utf8_data_end_ptr, lenientConversion );
             utf8_data_ptr = (UTF8*)utf8_data_buffer_sp->GetBytes(); // needed because the ConvertFunction will change the value of the data_ptr
         }
         else
         {
             // just copy the pointers - the cast is necessary to make the compiler happy
             // but this should only happen if we are reading UTF8 data
             utf8_data_ptr = (UTF8*)data_ptr;
             utf8_data_end_ptr = (UTF8*)data_end_ptr;

 {
 
 template <>
 bool
 ReadStringAndDumpToStream<StringElementType::ASCII> (ReadStringAndDumpToStreamOptions options)
 {
     assert(options.GetStream() && "need a Stream to print the string to");
     Error my_error;
-    size_t my_data_read;
 
     ProcessSP process_sp(options.GetProcessSP());
 
     if (process_sp.get() == nullptr || options.GetLocation() == 0)
         return false;
 
     size_t size;
 
     if (options.GetSourceSize() == 0)
         size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
     else if (!options.GetIgnoreMaxLength())
         size = std::min(options.GetSourceSize(),process_sp->GetTarget().GetMaximumSizeOfStringSummary());
     else
         size = options.GetSourceSize();
 
     lldb::DataBufferSP buffer_sp(new DataBufferHeap(size,0));
 
-    my_data_read = process_sp->ReadCStringFromMemory(options.GetLocation(), (char*)buffer_sp->GetBytes(), size, my_error);
+    process_sp->ReadCStringFromMemory(options.GetLocation(), (char*)buffer_sp->GetBytes(), size, my_error);
 
     if (my_error.Fail())
         return false;
 
     char prefix_token = options.GetPrefixToken();
     char quote = options.GetQuote();
 
     if (prefix_token != 0)
ReadUTFBufferAndDumpToStream (const ReadStringAndDumpToStreamOptions& options,
     lldb::DataBufferSP buffer_sp(new DataBufferHeap(bufferSPSize,0));
 
     if (!buffer_sp->GetBytes())
         return false;
 
     Error error;
     char *buffer = reinterpret_cast<char *>(buffer_sp->GetBytes());
 
-    size_t data_read = 0;
     if (needs_zero_terminator)
-        data_read = process_sp->ReadStringFromMemory(options.GetLocation(), buffer, bufferSPSize, error, type_width);
+        process_sp->ReadStringFromMemory(options.GetLocation(), buffer, bufferSPSize, error, type_width);
     else
-        data_read = process_sp->ReadMemoryFromInferior(options.GetLocation(), (char*)buffer_sp->GetBytes(), bufferSPSize, error);
+        process_sp->ReadMemoryFromInferior(options.GetLocation(), (char*)buffer_sp->GetBytes(), bufferSPSize, error);
 
     if (error.Fail())
     {
         options.GetStream()->Printf("unable to read data");
         return true;
     }
 
     DataExtractor data(buffer_sp, process_sp->GetByteOrder(), process_sp->GetAddressByteSize());

source/Expression/IRExecutionUnit.cpp

IRExecutionUnit::MemoryManager::allocateDataSection(uintptr_t Size,
                                                     unsigned SectionID,
                                                     llvm::StringRef SectionName,
                                                     bool IsReadOnly)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
     uint8_t *return_value = m_default_mm_ap->allocateDataSection(Size, Alignment, SectionID, SectionName, IsReadOnly);
 
+    uint32_t permissions = lldb::ePermissionsReadable;
+    if (IsReadOnly)
+        permissions |= lldb::ePermissionsWritable;
     m_parent.m_records.push_back(AllocationRecord((uintptr_t)return_value,
-                                                  lldb::ePermissionsReadable | (IsReadOnly ? 0 : lldb::ePermissionsWritable),
+                                                  permissions,
                                                   GetSectionTypeFromSectionName (SectionName, AllocationKind::Data),
                                                   Size,
                                                   Alignment,
                                                   SectionID,
                                                   SectionName.str().c_str()));
     if (log)
     {
         log->Printf("IRExecutionUnit::allocateDataSection(Size=0x%" PRIx64 ", Alignment=%u, SectionID=%u) = %p",

source/Host/common/Editline.cpp

#endif
     SetCurrentLine (m_current_line_index + 1);
     MoveCursor (CursorLocation::BlockEnd, CursorLocation::EditingPrompt);
     return CC_NEWLINE;
 }
 
 unsigned char
 Editline::DeleteNextCharCommand (int ch)
 {
-    LineInfoW * info = (LineInfoW *)el_wline (m_editline);
+    LineInfoW * info = const_cast<LineInfoW *>(el_wline (m_editline));
     
     // Just delete the next character normally if possible
     if (info->cursor < info->lastchar) 
     {
         info->cursor++;
         el_deletestr (m_editline, 1);
         return CC_REFRESH;
     }
Editline::DeleteNextCharCommand (int ch)
     DisplayInput (m_current_line_index);
     MoveCursor (CursorLocation::BlockEnd, CursorLocation::EditingCursor);
     return CC_REFRESH;
 }
 
 unsigned char
 Editline::DeletePreviousCharCommand (int ch)
 {
-    LineInfoW * info = (LineInfoW *)el_wline (m_editline);
+    LineInfoW * info = const_cast<LineInfoW *>(el_wline (m_editline));
     
     // Just delete the previous character normally when not at the start of a line
     if (info->cursor > info->buffer) 
     {
         el_deletestr (m_editline, 1);
         return CC_REFRESH;
     }
     
Editline::FixIndentationCommand (int ch)
     
     // Insert the character by hand prior to correction
     EditLineCharType inserted[] = { (EditLineCharType)ch, 0 };
     el_winsertstr (m_editline, inserted);
     SaveEditedLine();
     StringList lines = GetInputAsStringList (m_current_line_index + 1);
 
     // Determine the cursor position
-    LineInfoW * info = (LineInfoW *)el_wline (m_editline);
+    LineInfoW * info = const_cast<LineInfoW *>(el_wline (m_editline));
     int cursor_position = info->cursor - info->buffer;
     
     int indent_correction = m_fix_indentation_callback (this, lines, cursor_position, m_fix_indentation_callback_baton);
     
     // Adjust the input buffer to correct indentation
     if (indent_correction > 0)
     {
         info->cursor = info->buffer;

 }
 
 unsigned char
 Editline::RevertLineCommand (int ch)
 {
     el_winsertstr (m_editline, m_input_lines[m_current_line_index].c_str());
     if (m_revert_cursor_index >= 0)
     {
-        LineInfoW * info = (LineInfoW *)el_wline (m_editline);
+        LineInfoW * info = const_cast<LineInfoW *>(el_wline (m_editline));
         info->cursor = info->buffer + m_revert_cursor_index;
         if (info->cursor > info->lastchar)
         {
             info->cursor = info->lastchar;
         }
         m_revert_cursor_index = -1;
     }
     return CC_REFRESH;

source/Host/common/Symbols.cpp

LocateExecutableSymbolFileDsym (const ModuleSpec &module_spec)
     const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
     const ArchSpec *arch = module_spec.GetArchitecturePtr();
     const UUID *uuid = module_spec.GetUUIDPtr();
 
     Timer scoped_timer (__PRETTY_FUNCTION__,
                         "LocateExecutableSymbolFileDsym (file = %s, arch = %s, uuid = %p)",
                         exec_fspec ? exec_fspec->GetFilename().AsCString ("<NULL>") : "<NULL>",
                         arch ? arch->GetArchitectureName() : "<NULL>",
-                        uuid);
+                        (void*)uuid);
 
     FileSpec symbol_fspec;
     // First try and find the dSYM in the same directory as the executable or in
     // an appropriate parent directory
     if (LocateDSYMInVincinityOfExecutable (module_spec, symbol_fspec) == false)
     {
         // We failed to easily find the dSYM above, so use DebugSymbols
         LocateMacOSXFilesUsingDebugSymbols (module_spec, NULL, &symbol_fspec);
     }
     return symbol_fspec;
 }
 
 FileSpec
 Symbols::LocateExecutableObjectFile (const ModuleSpec &module_spec)
 {
     const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();
     const ArchSpec *arch = module_spec.GetArchitecturePtr();
     const UUID *uuid = module_spec.GetUUIDPtr();
     Timer scoped_timer (__PRETTY_FUNCTION__,
                         "LocateExecutableObjectFile (file = %s, arch = %s, uuid = %p)",
                         exec_fspec ? exec_fspec->GetFilename().AsCString ("<NULL>") : "<NULL>",
                         arch ? arch->GetArchitectureName() : "<NULL>",
-                        uuid);
+                        (void*)uuid);
 
     FileSpec objfile_fspec;
     ModuleSpecList module_specs;
     ModuleSpec matched_module_spec;
     if (exec_fspec &&
         ObjectFile::GetModuleSpecifications(*exec_fspec, 0, 0, module_specs) &&
         module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
     {

source/Interpreter/Args.cpp

 
 bool
 Args::IsPositionalArgument (const char *arg)
 {
     if (arg == nullptr)
         return false;
         
     bool is_positional = true;
-    char *cptr = (char *) arg;
+    const char *cptr = arg;
     
     if (cptr[0] == '%')
     {
         ++cptr;
         while (isdigit (cptr[0]))
             ++cptr;
         if (cptr[0] != '\0')
             is_positional = false;

source/Interpreter/CommandInterpreter.cpp

if (option_arg_vector_sp.get())
 
         for (size_t j = 0; j < cmd_args.GetArgumentCount(); ++j)
         {
             if (!used[j] && !wants_raw_input)
                 new_args.AppendArgument (cmd_args.GetArgumentAtIndex (j));
         }
 
         cmd_args.Clear();
-        cmd_args.SetArguments (new_args.GetArgumentCount(), (const char **) new_args.GetArgumentVector());
+        cmd_args.SetArguments (new_args.GetArgumentCount(), new_args.GetConstArgumentVector());
     }
     else
     {
         result.SetStatus (eReturnStatusSuccessFinishNoResult);
         // This alias was not created with any options; nothing further needs to be done, unless it is a command that
         // wants raw input, in which case we need to clear the rest of the data from cmd_args, since its in the raw
         // input string.
         if (wants_raw_input)
         {
             cmd_args.Clear();
-            cmd_args.SetArguments (new_args.GetArgumentCount(), (const char **) new_args.GetArgumentVector());
+            cmd_args.SetArguments (new_args.GetArgumentCount(), new_args.GetConstArgumentVector());
         }
         return;
     }
 
     result.SetStatus (eReturnStatusSuccessFinishNoResult);
     return;
 }
 
 
 int
 CommandInterpreter::GetOptionArgumentPosition (const char *in_string)
 {
     int position = 0;   // Any string that isn't an argument position, i.e. '%' followed by an integer, gets a position
                         // of zero.
 
-    char *cptr = (char *) in_string;
+    const char *cptr = in_string;
 
     // Does it start with '%'
     if (cptr[0] == '%')
     {
         ++cptr;
 
         // Is the rest of it entirely digits?
         if (isdigit (cptr[0]))

source/Interpreter/CommandObject.cpp

 CommandObject::GetArgumentEntryAtIndex (int idx)
 {
     if (static_cast<size_t>(idx) < m_arguments.size())
         return &(m_arguments[idx]);
 
     return nullptr;
 }
 
-CommandObject::ArgumentTableEntry *
+const CommandObject::ArgumentTableEntry *
 CommandObject::FindArgumentDataByType (CommandArgumentType arg_type)
 {
     const ArgumentTableEntry *table = CommandObject::GetArgumentTable();
 
     for (int i = 0; i < eArgTypeLastArg; ++i)
         if (table[i].arg_type == arg_type)
-            return (ArgumentTableEntry *) &(table[i]);
+            return &(table[i]);
 
     return nullptr;
 }
 
 void
 CommandObject::GetArgumentHelp (Stream &str, CommandArgumentType arg_type, CommandInterpreter &interpreter)
 {
     const ArgumentTableEntry* table = CommandObject::GetArgumentTable();
-    ArgumentTableEntry *entry = (ArgumentTableEntry *) &(table[arg_type]);
+    const ArgumentTableEntry *entry = &(table[arg_type]);
     
     // The table is *supposed* to be kept in arg_type order, but someone *could* have messed it up...
 
     if (entry->arg_type != arg_type)
         entry = CommandObject::FindArgumentDataByType (arg_type);
 
     if (!entry)
         return;
CommandObject::GetArgumentHelp (Stream &str, CommandArgumentType arg_type, CommandInterpreter &interpreter)
     }
     else
         interpreter.OutputFormattedHelpText (str, name_str.GetData(), "--", entry->help_text, name_str.GetSize());
 }
 
 const char *
 CommandObject::GetArgumentName (CommandArgumentType arg_type)
 {
-    ArgumentTableEntry *entry = (ArgumentTableEntry *) &(CommandObject::GetArgumentTable()[arg_type]);
+    const ArgumentTableEntry *entry = &(CommandObject::GetArgumentTable()[arg_type]);
 
     // The table is *supposed* to be kept in arg_type order, but someone *could* have messed it up...
 
     if (entry->arg_type != arg_type)
         entry = CommandObject::FindArgumentDataByType (arg_type);
 
     if (entry)
         return entry->arg_name;

source/Interpreter/Options.cpp

)
 
     uint32_t completion_mask = opt_defs[opt_defs_index].completion_type;
     
     if (completion_mask == 0)
     {
         lldb::CommandArgumentType option_arg_type = opt_defs[opt_defs_index].argument_type;
         if (option_arg_type != eArgTypeNone)
         {
-            CommandObject::ArgumentTableEntry *arg_entry = CommandObject::FindArgumentDataByType (opt_defs[opt_defs_index].argument_type);
+            const CommandObject::ArgumentTableEntry *arg_entry = CommandObject::FindArgumentDataByType (opt_defs[opt_defs_index].argument_type);
             if (arg_entry)
                 completion_mask = arg_entry->completion_type;
         }
     }
 
     if (completion_mask & CommandCompletions::eSourceFileCompletion
         || completion_mask & CommandCompletions::eSymbolCompletion)
     {

source/Interpreter/ScriptInterpreterPython.cpp

if (PyThreadState_GetDict())
                 m_saved_stderr.Reset ();
             }
         }
     }
 
     m_session_is_active = false;
 }
 
+static PyObject *
+PyFile_FromFile_Const(FILE *fp, const char *name, const char *mode, int (*close)(FILE *))
+{
+    // Read through the Python source, doesn't seem to modify these strings
+    return PyFile_FromFile(fp, const_cast<char*>(name), const_cast<char*>(mode), close);
+}
+
 bool
 ScriptInterpreterPython::EnterSession (uint16_t on_entry_flags,
                                        FILE *in,
                                        FILE *out,
                                        FILE *err)
 {
     // If we have already entered the session, without having officially 'left' it, then there is no need to 
     // 'enter' it again.
if (sys_module_dict)
         {
             // STDIN is enabled
             if (in == nullptr && in_sp)
                 in = in_sp->GetFile().GetStream();
             if (in)
             {
                 m_saved_stdin.Reset(sys_module_dict.GetItemForKey("stdin"));
                 // This call can deadlock your process if the file is locked
-                PyObject *new_file = PyFile_FromFile (in, (char *) "", (char *) "r", nullptr);
+                PyObject *new_file = PyFile_FromFile_Const (in, "", "r", nullptr);
                 sys_module_dict.SetItemForKey ("stdin", new_file);
                 Py_DECREF (new_file);
             }
         }
 
         if (out == nullptr && out_sp)
             out = out_sp->GetFile().GetStream();
         if (out)
         {
             m_saved_stdout.Reset(sys_module_dict.GetItemForKey("stdout"));
 
-            PyObject *new_file = PyFile_FromFile (out, (char *) "", (char *) "w", nullptr);
+            PyObject *new_file = PyFile_FromFile_Const (out, "", "w", nullptr);
             sys_module_dict.SetItemForKey ("stdout", new_file);
             Py_DECREF (new_file);
         }
         else
             m_saved_stdout.Reset();
 
         if (err == nullptr && err_sp)
             err = err_sp->GetFile().GetStream();
         if (err)
         {
             m_saved_stderr.Reset(sys_module_dict.GetItemForKey("stderr"));
 
-            PyObject *new_file = PyFile_FromFile (err, (char *) "", (char *) "w", nullptr);
+            PyObject *new_file = PyFile_FromFile_Const (err, "", "w", nullptr);
             sys_module_dict.SetItemForKey ("stderr", new_file);
             Py_DECREF (new_file);
         }
         else
             m_saved_stderr.Reset();
     }
 
     if (PyErr_Occurred())

source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp

for ( size_t i = 0; i < args.size( ); i++ )
 
         // write this argument onto the stack of the host process
         proc.get( )->WriteMemory( sp, arg.data, arg.size, error );
         if ( error.Fail( ) )
             return false;
 
         // update the argument with the target pointer
         //XXX: This is a gross hack for getting around the const
-        *((size_t*)(&arg.value)) = sp;
+        *const_cast<lldb::addr_t*>(&arg.value) = sp;
     }
 
-
 #if HEX_ABI_DEBUG
     // print the original stack pointer
     printf( "sp : %04" PRIx64 " \n", sp );
 #endif
 
     // make sure number of parameters matches prototype
     assert( prototype.getFunctionNumParams( ) == args.size( ) );
 

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

 //----------------------------------------------------------------------
 // Dump an image info structure to the file handle provided.
 //----------------------------------------------------------------------
 void
 DynamicLoaderMacOSXDYLD::DYLDImageInfo::PutToLog (Log *log) const
 {
     if (log == NULL)
         return;
-    uint8_t *u = (uint8_t *)uuid.GetBytes();
+    const uint8_t *u = (const uint8_t *)uuid.GetBytes();
 
     if (address == LLDB_INVALID_ADDRESS)
     {
         if (u)
         {
             log->Printf("\t                           modtime=0x%8.8" PRIx64 " uuid=%2.2X%2.2X%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X path='%s' (UNLOADED)",
                         mod_date,
                         u[ 0], u[ 1], u[ 2], u[ 3],

source/Plugins/Instruction/ARM/EmulationStateARM.cpp

EmulationStateARM::WritePseudoMemory (EmulateInstruction *instruction,
                                       const void *dst,
                                       size_t length)
 {
     if (!baton)
         return 0;
         
     bool success;
     EmulationStateARM *pseudo_state = (EmulationStateARM *) baton;
-    uint64_t value = *((uint64_t *) dst);
+    uint64_t value = *((const uint64_t *) dst);
     success = pseudo_state->StoreToPseudoAddress (addr, value, length);
     if (success)
         return length;
         
     return 0;
 }
     
 bool

source/Plugins/Platform/Android/AdbClient.cpp

AdbClient::ReadMessage (std::string &message)
 
     Error error;
     ConnectionStatus status;
 
     m_conn.Read (buffer, 4, kConnTimeout, status, &error);
     if (error.Fail ())
         return error;
 
-    int packet_len = 0;
+    unsigned int packet_len = 0;
     sscanf (buffer, "%x", &packet_len);
     std::string result (packet_len, 0);
     m_conn.Read (&result[0], packet_len, kConnTimeout, status, &error);
     if (error.Success ())
         result.swap (message);
 
     return error;
 }

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

PlatformDarwin::GetResumeCountForLaunchInfo (ProcessLaunchInfo &launch_info)
     else
         shell_name++;
     
     if (strcmp (shell_name, "sh") == 0)
     {
         // /bin/sh re-exec's itself as /bin/bash requiring another resume.
         // But it only does this if the COMMAND_MODE environment variable
         // is set to "legacy".
-        char * const *envp = (char * const*)launch_info.GetEnvironmentEntries().GetConstArgumentVector();
+        const char **envp = launch_info.GetEnvironmentEntries().GetConstArgumentVector();
         if (envp != NULL)
         {
             for (int i = 0; envp[i] != NULL; i++)
             {
                 if (strcmp (envp[i], "COMMAND_MODE=legacy" ) == 0)
                     return 2;
             }
         }
PlatformDarwin::DirectoryEnumerator(void *baton,
     
     if (SDKSupportsModules(enumerator_info->sdk_type, spec))
     {
         enumerator_info->found_path = spec;
         return FileSpec::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
     }
     
     return FileSpec::EnumerateDirectoryResult::eEnumerateDirectoryResultNext;
-};
+}
 
 FileSpec
 PlatformDarwin::FindSDKInXcodeForModules (SDKType sdk_type,
                                           const FileSpec &sdks_spec)
 {
     // Look inside Xcode for the required installed iOS SDK version
     
     if (!sdks_spec.IsDirectory())

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

else
             m_remote_platform_sp.reset();
     }
 
     if (error.Success() && m_remote_platform_sp)
     {
         if (m_options.get())
         {
             OptionGroupOptions* options = m_options.get();
-            OptionGroupPlatformRSync* m_rsync_options = (OptionGroupPlatformRSync*)options->GetGroupWithOption('r');
-            OptionGroupPlatformSSH* m_ssh_options = (OptionGroupPlatformSSH*)options->GetGroupWithOption('s');
-            OptionGroupPlatformCaching* m_cache_options = (OptionGroupPlatformCaching*)options->GetGroupWithOption('c');
+            const OptionGroupPlatformRSync* m_rsync_options = (OptionGroupPlatformRSync*)options->GetGroupWithOption('r');
+            const OptionGroupPlatformSSH* m_ssh_options = (OptionGroupPlatformSSH*)options->GetGroupWithOption('s');
+            const OptionGroupPlatformCaching* m_cache_options = (OptionGroupPlatformCaching*)options->GetGroupWithOption('c');
 
             if (m_rsync_options->m_rsync)
             {
                 SetSupportsRSync(true);
                 SetRSyncOpts(m_rsync_options->m_rsync_opts.c_str());
                 SetRSyncPrefix(m_rsync_options->m_rsync_prefix.c_str());
                 SetIgnoresRemoteHostname(m_rsync_options->m_ignores_remote_hostname);
             }

source/Plugins/Process/Linux/NativeProcessLinux.cpp

 NativeProcessLinux::Resume (const ResumeActionList &resume_actions)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
     if (log)
         log->Printf ("NativeProcessLinux::%s called: pid %" PRIu64, __FUNCTION__, GetID ());
 
     lldb::tid_t deferred_signal_tid = LLDB_INVALID_THREAD_ID;
     lldb::tid_t deferred_signal_skip_tid = LLDB_INVALID_THREAD_ID;
-    int deferred_signo = 0;
     NativeThreadProtocolSP deferred_signal_thread_sp;
     bool stepping = false;
     bool software_single_step = !SupportHardwareSingleStepping();
 
     Monitor::ScopedOperationLock monitor_lock(*m_monitor_up);
     Mutex::Locker locker (m_threads_mutex);
 
     if (software_single_step)
for (auto thread_sp : m_threads)
 
         case eStateSuspended:
         case eStateStopped:
             // if we haven't chosen a deferred signal tid yet, use this one.
             if (deferred_signal_tid == LLDB_INVALID_THREAD_ID)
             {
                 deferred_signal_tid = thread_sp->GetID ();
                 deferred_signal_thread_sp = thread_sp;
-                deferred_signo = SIGSTOP;
             }
             break;
 
         default:
             return Error ("NativeProcessLinux::%s (): unexpected state %s specified for pid %" PRIu64 ", tid %" PRIu64,
                     __FUNCTION__, StateAsCString (action->state), GetID (), thread_sp->GetID ());
         }
     }

source/Plugins/Process/Linux/ProcessLinux.h

public:
     static const char *
     GetPluginDescriptionStatic();
 
     //------------------------------------------------------------------
     // Constructors and destructors
     //------------------------------------------------------------------
     ProcessLinux(Target& target,
                  Listener &listener,
-                 FileSpec *core_file);
+                 const FileSpec *core_file);
 
     Error
     DoDetach(bool keep_stopped) override;
 
     bool
     DetachRequiresHalt() override { return true; }
 
     bool
public:
     void
     StopAllThreads(lldb::tid_t stop_tid) override;
 
     POSIXThread *
     CreateNewPOSIXThread(Process &process, lldb::tid_t tid) override;
 
 private:
 
-    FileSpec *m_core_file;
+    const FileSpec *m_core_file;
 
     // Flag to avoid recursion when stopping all threads.
     bool m_stopping_threads;
 };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif  // liblldb_ProcessLinux_H_

source/Plugins/Process/Linux/ProcessLinux.cpp

 }
 
 //------------------------------------------------------------------------------
 // Static functions.
 
 ProcessSP
 ProcessLinux::CreateInstance(Target &target, Listener &listener, const FileSpec *core_file)
 {
-    return ProcessSP(new ProcessLinux(target, listener, (FileSpec *)core_file));
+    return ProcessSP(new ProcessLinux(target, listener, core_file));
 }
 
 void
 ProcessLinux::Initialize()
 {
     static std::once_flag g_once_flag;
 
     std::call_once(g_once_flag, []() {
         PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                       GetPluginDescriptionStatic(),
                                       CreateInstance);
         ProcessPOSIXLog::Initialize(GetPluginNameStatic());
     });
 }
 
 //------------------------------------------------------------------------------
 // Constructors and destructors.
 
-ProcessLinux::ProcessLinux(Target& target, Listener &listener, FileSpec *core_file)
+ProcessLinux::ProcessLinux(Target& target, Listener &listener, const FileSpec *core_file)
     : ProcessPOSIX(target, listener, GetStaticLinuxSignalsSP ()), m_core_file(core_file), m_stopping_threads(false)
 {
 #if 0
     // FIXME: Putting this code in the ctor and saving the byte order in a
     // member variable is a hack to avoid const qual issues in GetByteOrder.
     ObjectFile *obj_file = GetTarget().GetExecutableModule()->GetObjectFile();
     m_byte_order = obj_file->GetByteOrder();
 #else

source/Plugins/Process/Linux/ProcessMonitor.cpp

for (bytes_written = 0; bytes_written < size; bytes_written += remainder)
                 return bytes_written;
             }
 
             if (log && ProcessPOSIXLog::AtTopNestLevel() &&
                 (log->GetMask().Test(POSIX_LOG_MEMORY_DATA_LONG) ||
                  (log->GetMask().Test(POSIX_LOG_MEMORY_DATA_SHORT) &&
                   size <= POSIX_LOG_MEMORY_SHORT_BYTES)))
                  log->Printf ("ProcessMonitor::%s() [%p]:0x%lx (0x%lx)", __FUNCTION__,
-                              (void*)vm_addr, *(unsigned long*)src, *(unsigned long*)buff);
+                              (void*)vm_addr, *(const unsigned long*)src, *(const unsigned long*)buff);
         }
 
         vm_addr += word_size;
         src += word_size;
     }
     if (log)
         ProcessPOSIXLog::DecNestLevel();
     return bytes_written;

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

if (IsConnected())
 
             if (binary_start_offset)
             {
                 StreamString strm;
                 // Print non binary data header
                 strm.Printf("<%4" PRIu64 "> send packet: %.*s", (uint64_t)bytes_written, (int)binary_start_offset, packet_data);
                 const uint8_t *p;
                 // Print binary data exactly as sent
-                for (p = (uint8_t*)packet_data + binary_start_offset; *p != '#'; ++p)
+                for (p = (const uint8_t*)packet_data + binary_start_offset; *p != '#'; ++p)
                     strm.Printf("\\x%2.2x", *p);
                 // Print the checksum
                 strm.Printf("%*s", (int)3, p);
                 log->PutCString(strm.GetString().c_str());
             }
             else
                 log->Printf("<%4" PRIu64 "> send packet: %.*s", (uint64_t)bytes_written, (int)packet_length, packet_data);
         }
#endif
         if (launch_info.GetLaunchInSeparateProcessGroup())
         {
             debugserver_args.AppendArgument("--setsid");
         }
 
         llvm::SmallString<PATH_MAX> named_pipe_path;
         Pipe port_pipe;
 
-        bool listen = false;
-        if (host_and_port[0])
+        if (host_and_port[0] && in_port == 0)
         {
             // Create a temporary file to get the stdout/stderr and redirect the
             // output of the command into this file. We will later read this file
             // if all goes well and fill the data into "command_output_ptr"
 
-            if (in_port == 0)
-            {
-                // Binding to port zero, we need to figure out what port it ends up
-                // using using a named pipe...
-                error = port_pipe.CreateWithUniqueName("debugserver-named-pipe", false, named_pipe_path);
-                if (error.Success())
-                {
-                    debugserver_args.AppendArgument("--named-pipe");
-                    debugserver_args.AppendArgument(named_pipe_path.c_str());
-                }
-                else
-                {
-                    if (log)
-                        log->Printf("GDBRemoteCommunication::%s() "
-                                "named pipe creation failed: %s",
-                                __FUNCTION__, error.AsCString());
-                    // let's try an unnamed pipe
-                    error = port_pipe.CreateNew(true);
-                    if (error.Fail())
-                    {
-                        if (log)
-                            log->Printf("GDBRemoteCommunication::%s() "
-                                    "unnamed pipe creation failed: %s",
-                                    __FUNCTION__, error.AsCString());
-                        return error;
-                    }
-                    int write_fd = port_pipe.GetWriteFileDescriptor();
-                    debugserver_args.AppendArgument("--pipe");
-                    debugserver_args.AppendArgument(std::to_string(write_fd).c_str());
-                    launch_info.AppendCloseFileAction(port_pipe.GetReadFileDescriptor());
-                }
-            }
-            else
-            {
-                listen = true;
-            }
-        }
-        else
-        {
             // No host and port given, so lets listen on our end and make the debugserver
             // connect to us..
             error = StartListenThread ("127.0.0.1", 0);
             if (error.Fail())
                 return error;
 
             ConnectionFileDescriptor *connection = (ConnectionFileDescriptor *)GetConnection ();
             // Wait for 10 seconds to resolve the bound port

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

if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for write all registers."))
     
                         response.GetStringRef().assign (G_packet, G_packet_len);
                         response.SetFilePos(1); // Skip the leading 'G'
 
                         // G_packet_len is hex-ascii characters plus prefix 'G' plus suffix thread specifier.
                         // This means buffer will be a little more than 2x larger than necessary but we resize
                         // it down once we've extracted all hex ascii chars from the packet.
                         DataBufferHeap buffer (G_packet_len, 0);
+
+                        const uint32_t bytes_extracted = response.GetHexBytes (buffer.GetBytes(),
+                                                                               buffer.GetByteSize(),
+                                                                               '\xcc');
+
                         DataExtractor restore_data (buffer.GetBytes(),
                                                     buffer.GetByteSize(),
                                                     m_reg_data.GetByteOrder(),
                                                     m_reg_data.GetAddressByteSize());
-    
-                        const uint32_t bytes_extracted = response.GetHexBytes ((void *)restore_data.GetDataStart(),
-                                                                               restore_data.GetByteSize(),
-                                                                               '\xcc');
-    
                         if (bytes_extracted < restore_data.GetByteSize())
                             restore_data.SetData(restore_data.GetDataStart(), bytes_extracted, m_reg_data.GetByteOrder());
     
                         const RegisterInfo *reg_info;
 
                         // The g packet contents may either include the slice registers (registers defined in
                         // terms of other registers, e.g. eax is a subset of rax) or not.  The slice registers 
                         // should NOT be in the g packet, but some implementations may incorrectly include them.

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

ProcessGDBRemote::GetLoadedModuleList (GDBLoadedModuleInfoList & list)
     }
 
     // parse individual library entries
     for (xmlNode * child = elm->children; child; child=child->next)
     {
         if (!child->name)
             continue;
 
-        if (strcmp ((char*)child->name, "library") != 0)
+        if (strcmp ((const char*)child->name, "library") != 0)
             continue;
 
         GDBLoadedModuleInfoList::LoadedModuleInfo module;
 
         for (xmlAttrPtr prop = child->properties; prop; prop=prop->next)
         {
-            if (strcmp ((char*)prop->name, "name") == 0)
+            if (strcmp ((const char*)prop->name, "name") == 0)
                 module.set_name (xmlExGetTextContent (prop));
 
             // the address of the link_map struct.
-            if (strcmp ((char*)prop->name, "lm") == 0)
+            if (strcmp ((const char*)prop->name, "lm") == 0)
             {
                 std::string val = xmlExGetTextContent (prop);
                 if (val.length() > 2)
                 {
                     uint32_t module_lm = std::stoul (val.c_str()+2, 0, 16);
                     module.set_link_map (module_lm);
                 }
             }
 
             // the displacement as read from the field 'l_addr' of the link_map struct.
-            if (strcmp ((char*)prop->name, "l_addr") == 0)
+            if (strcmp ((const char*)prop->name, "l_addr") == 0)
             {
                 std::string val = xmlExGetTextContent (prop);
                 if (val.length() > 2)
                 {
                     uint32_t module_base = std::stoul (val.c_str()+2, 0, 16);
                     module.set_base (module_base);
                 }
             }
 
             // the memory address of the libraries PT_DYAMIC section.
-            if (strcmp ((char*)prop->name, "l_ld") == 0)
+            if (strcmp ((const char*)prop->name, "l_ld") == 0)
             {
                 std::string val = xmlExGetTextContent (prop);
                 if (val.length() > 2)
                 {
                     uint32_t module_dyn = std::stoul (val.c_str()+2, 0, 16);
                     module.set_dynamic (module_dyn);
                 }
             }

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

do
         case DW_FORM_block4:    m_value.value.uval = data.GetU32(offset_ptr); is_block = true;          break;
         case DW_FORM_data2:     m_value.value.uval = data.GetU16(offset_ptr);                           break;
         case DW_FORM_data4:     m_value.value.uval = data.GetU32(offset_ptr);                           break;
         case DW_FORM_data8:     m_value.value.uval = data.GetU64(offset_ptr);                           break;
         case DW_FORM_string:    m_value.value.cstr = data.GetCStr(offset_ptr);
                                 // Set the string value to also be the data for inlined cstr form values only
                                 // so we can tell the difference between DW_FORM_string and DW_FORM_strp form
                                 // values;
-                                m_value.data = (uint8_t*)m_value.value.cstr;                            break;
+                                m_value.data = (const uint8_t*)m_value.value.cstr;                      break;
         case DW_FORM_exprloc:
         case DW_FORM_block:     m_value.value.uval = data.GetULEB128(offset_ptr); is_block = true;      break;
         case DW_FORM_block1:    m_value.value.uval = data.GetU8(offset_ptr); is_block = true;           break;
         case DW_FORM_data1:     m_value.value.uval = data.GetU8(offset_ptr);                            break;
         case DW_FORM_flag:      m_value.value.uval = data.GetU8(offset_ptr);                            break;
         case DW_FORM_sdata:     m_value.value.sval = data.GetSLEB128(offset_ptr);                       break;
         case DW_FORM_strp:      assert(m_cu);
                                 m_value.value.uval = data.GetMaxU64(offset_ptr, DWARFCompileUnit::IsDWARF64(m_cu) ? 8 : 4);  break;

source/Plugins/SymbolFile/DWARF/NameToDIE.cpp

 
 void
 NameToDIE::Dump (Stream *s)
 {
     const uint32_t size = m_map.GetSize();
     for (uint32_t i=0; i<size; ++i)
     {
         const char *cstr = m_map.GetCStringAtIndex(i);
-        s->Printf("%p: {0x%8.8x} \"%s\"\n", (void *)cstr, m_map.GetValueAtIndexUnchecked(i), cstr);
+        s->Printf("%p: {0x%8.8x} \"%s\"\n", (const void *)cstr, m_map.GetValueAtIndexUnchecked(i), cstr);
     }
 }
 
 void
 NameToDIE::ForEach (std::function <bool(const char *name, uint32_t die_offset)> const &callback) const
 {
     const uint32_t size = m_map.GetSize();
     for (uint32_t i=0; i<size; ++i)
     {
         if (!callback(m_map.GetCStringAtIndexUnchecked(i),
                       m_map.GetValueAtIndexUnchecked (i)))
             break;
     }
 }

source/Symbol/CompactUnwindInfo.cpp

enum
         UNWIND_X86_64_REG_NONE       = 0,
         UNWIND_X86_64_REG_RBX        = 1,
         UNWIND_X86_64_REG_R12        = 2,
         UNWIND_X86_64_REG_R13        = 3,
         UNWIND_X86_64_REG_R14        = 4,
         UNWIND_X86_64_REG_R15        = 5,
         UNWIND_X86_64_REG_RBP        = 6,
     };
-};
+}
 
 
 #ifndef UNWIND_SECOND_LEVEL_REGULAR
 #define UNWIND_SECOND_LEVEL_REGULAR 2
 #endif
 
 #ifndef UNWIND_SECOND_LEVEL_COMPRESSED
 #define UNWIND_SECOND_LEVEL_COMPRESSED 3

source/Symbol/DWARFCallFrameInfo.cpp

while (m_cfi_data.ValidOffset(offset) && offset < end_offset)
                         // expression. The required action is to change the rule for the
                         // register indicated by the register number to be an expression(E)
                         // rule where E is the DWARF expression. That is, the DWARF
                         // expression computes the address. The value of the CFA is
                         // pushed on the DWARF evaluation stack prior to execution of
                         // the DWARF expression.
                         reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
                         uint32_t block_len = (uint32_t)m_cfi_data.GetULEB128(&offset);
-                        const uint8_t *block_data = (uint8_t *)m_cfi_data.GetData(&offset, block_len);
+                        const uint8_t *block_data = (const uint8_t *)m_cfi_data.GetData(&offset, block_len);
 
                         reg_location.SetAtDWARFExpression(block_data, block_len);
                         row->SetRegisterInfo (reg_num, reg_location);
                     }
                     break;
 
                 case DW_CFA_offset_extended_sf  : // 0x11
                     {
while (m_cfi_data.ValidOffset(offset) && offset < end_offset)
                         // number, and a DW_FORM_block value representing a DWARF expression.
                         // The required action is to change the rule for the register indicated
                         // by the register number to be a val_expression(E) rule where E is the
                         // DWARF expression. That is, the DWARF expression computes the value of
                         // the given register. The value of the CFA is pushed on the DWARF
                         // evaluation stack prior to execution of the DWARF expression.
                         reg_num = (uint32_t)m_cfi_data.GetULEB128(&offset);
                         uint32_t block_len = (uint32_t)m_cfi_data.GetULEB128(&offset);
-                        const uint8_t* block_data = (uint8_t*)m_cfi_data.GetData(&offset, block_len);
+                        const uint8_t* block_data = (const uint8_t*)m_cfi_data.GetData(&offset, block_len);
 //#if defined(__i386__) || defined(__x86_64__)
 //                      // The EH frame info for EIP and RIP contains code that looks for traps to
 //                      // be a specific type and increments the PC.
 //                      // For i386:
 //                      // DW_CFA_val_expression where:
 //                      // eip = DW_OP_breg6(+28), DW_OP_deref, DW_OP_dup, DW_OP_plus_uconst(0x34),
 //                      //       DW_OP_deref, DW_OP_swap, DW_OP_plus_uconst(0), DW_OP_deref,
 //                      //       DW_OP_dup, DW_OP_lit3, DW_OP_ne, DW_OP_swap, DW_OP_lit4, DW_OP_ne,

source/Symbol/Symtab.cpp

Symtab::DumpSymbolHeader (Stream *s)
     s->Indent("Index   UserID DSX Type            File Address/Value Load Address       Size               Flags      Name\n");
     s->Indent("------- ------ --- --------------- ------------------ ------------------ ------------------ ---------- ----------------------------------\n");
 }
 
 
 static int
 CompareSymbolID (const void *key, const void *p)
 {
-    const user_id_t match_uid = *(user_id_t*) key;
-    const user_id_t symbol_uid = ((Symbol *)p)->GetID();
+    const user_id_t match_uid = *(const user_id_t*) key;
+    const user_id_t symbol_uid = ((const Symbol *)p)->GetID();
     if (match_uid < symbol_uid)
         return -1;
     if (match_uid > symbol_uid)
         return 1;
     return 0;
 }
 
 Symbol *
 Symtab::FindSymbolByID (lldb::user_id_t symbol_uid) const
 {
     Mutex::Locker locker (m_mutex);
 
     Symbol *symbol = (Symbol*)::bsearch (&symbol_uid, 
                                          &m_symbols[0], 
                                          m_symbols.size(), 
-                                         (uint8_t *)&m_symbols[1] - (uint8_t *)&m_symbols[0], 
+                                         sizeof(m_symbols[0]),
                                          CompareSymbolID);
     return symbol;
 }
 
 
 Symbol *
 Symtab::SymbolAtIndex(size_t idx)
 {

tools/driver/Driver.cpp

#endif
     return error;
 }
 
 static ::FILE *
 PrepareCommandsForSourcing (const char *commands_data, size_t commands_size, int fds[2])
 {
     enum PIPES { READ, WRITE }; // Constants 0 and 1 for READ and WRITE
 
-    bool success = true;
     ::FILE *commands_file = NULL;
     fds[0] = -1;
     fds[1] = -1;
     int err = 0;
 #ifdef _WIN32
     err = _pipe(fds, commands_size, O_BINARY);
 #else
     err = pipe(fds);
 #endif
     if (err == 0)
     {
         ssize_t nrwr = write(fds[WRITE], commands_data, commands_size);
         if (nrwr < 0)
         {
             fprintf(stderr, "error: write(%i, %p, %" PRIu64 ") failed (errno = %i) "
                             "when trying to open LLDB commands pipe\n",
                     fds[WRITE], commands_data, static_cast<uint64_t>(commands_size), errno);
-            success = false;
         }
         else if (static_cast<size_t>(nrwr) == commands_size)
         {
             // Close the write end of the pipe so when we give the read end to
             // the debugger/command interpreter it will exit when it consumes all
             // of the data
 #ifdef _WIN32
             _close(fds[WRITE]); fds[WRITE] = -1;
#endif
                 // Hand ownership if the FILE * over to the debugger for "commands_file".
             }
             else
             {
                 fprintf(stderr,
                         "error: fdopen(%i, \"r\") failed (errno = %i) when "
                         "trying to open LLDB commands pipe\n",
                         fds[READ], errno);
-                success = false;
             }
         }
     }
     else
     {
         fprintf(stderr, "error: can't create pipe file descriptors for LLDB commands\n");
-        success = false;
     }
 
     return commands_file;
 }
 
 void
 CleanupAfterCommandSourcing (int fds[2])
 {