Fix about a dozen compile warnings

[ki.stfu]

Summary

It fixes the following compile warnings:

1. '0' flag ignored with precision and ‘%d’ gnu_printf format
2. enumeral and non-enumeral type in conditional expression
3. format ‘%d’ expects argument of type ‘int’, but argument 4 has type ...
4. enumeration value ‘...’ not handled in switch
5. cast from type ‘const uint64_t* {aka ...}’ to type ‘int64_t* {aka ...}’ casts away qualifiers
6. extra ‘;’
7. comparison between signed and unsigned integer expressions
8. variable ‘register_operand’ set but not used
9. control reaches end of non-void function

[ki.stfu]

BTW, the following warnings remain:

1. unrecognized command line option ‘-Wno-vla-extension’
2. unrecognized command line option ‘-Wno-deprecated-register’
3. comparison of unsigned expression >= 0 is always true

[2782/3295] Building CXX object tools/lldb/source/Plugins/Instruction/ARM/CMakeFiles/lldbPluginInstructionARM.dir/EmulationStateARM.cpp.o
../tools/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp: In member function ‘bool EmulationStateARM::StorePseudoRegisterValue(uint32_t, uint64_t)’:
../tools/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp:69:17: warning: comparison of unsigned expression >= 0 is always true [-Wtype-limits]
   if ((dwarf_r0 <= reg_num) && (reg_num <= dwarf_cpsr))
                 ^
../tools/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp: In member function ‘uint64_t EmulationStateARM::ReadPseudoRegisterValue(uint32_t, bool&)’:
../tools/lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp:92:17: warning: comparison of unsigned expression >= 0 is always true [-Wtype-limits]
   if ((dwarf_r0 <= reg_num) && (reg_num <= dwarf_cpsr))
                 ^
...
[3136/3295] Building CXX object tools/lldb/source/Utility/CMakeFiles/lldbUtility.dir/ARM64_DWARF_Registers.cpp.o
../tools/lldb/source/Utility/ARM64_DWARF_Registers.cpp: In function ‘bool arm64_dwarf::GetRegisterInfo(unsigned int, lldb_private::RegisterInfo&)’:
../tools/lldb/source/Utility/ARM64_DWARF_Registers.cpp:175:15: warning: comparison of unsigned expression >= 0 is always true [-Wtype-limits]
   if (reg_num >= x0 && reg_num <= pc) {
               ^

4. format not a string literal and no format arguments

[3217/3295] Building CXX object tools/lldb/source/API/CMakeFiles/liblldb.dir/__/__/scripts/LLDBWrapPython.cpp.o
tools/lldb/scripts/LLDBWrapPython.cpp: In function ‘PyObject* _wrap_SBError_SetErrorStringWithFormat__SWIG_3(PyObject*, PyObject*)’:
tools/lldb/scripts/LLDBWrapPython.cpp:28426:70: warning: format not a string literal and no format arguments [-Wformat-security]
     result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2);
                                                                      ^

5. comparison between signed and unsigned integer expressions

tools/lldb/scripts/LLDBWrapPython.cpp: In function ‘PyObject* _wrap_SBTarget_BreakpointCreateByNames__SWIG_0(PyObject*, PyObject*)’:
tools/lldb/scripts/LLDBWrapPython.cpp:55744:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
       for (i = 0; i < arg3; i++) {
                     ^
tools/lldb/scripts/LLDBWrapPython.cpp: In function ‘PyObject* _wrap_SBTarget_BreakpointCreateByNames__SWIG_1(PyObject*, PyObject*)’:
tools/lldb/scripts/LLDBWrapPython.cpp:55836:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
       for (i = 0; i < arg3; i++) {
                     ^
tools/lldb/scripts/LLDBWrapPython.cpp: In function ‘PyObject* _wrap_SBTarget_BreakpointCreateByNames__SWIG_2(PyObject*, PyObject*)’:
tools/lldb/scripts/LLDBWrapPython.cpp:55937:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
       for (i = 0; i < arg3; i++) {
                     ^

[ki.stfu]

Remove obvious comment

[ki.stfu]

Apply clang-format

[zturner]

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

1462–1467

I find this code pretty ugly because of how the line breaks. Can you change this to:

uint32_t segment_permissions = 0;
if (load_cmd.initprot & VM_PROT_READ)
  segment_permissions |= ePermissionsReadable;
if (load_cmd.initprot & VM_PROT_WRITE)
  segment_permissions |= ePermissionsWritable;
if (load_cmd.initprot & VM_PROT_EXECUTE)
  segment_permissions |= ePermissionsExecutable;

or, alternatively:

// global scope
static uint32_t translateSegmentPermissions(uint32_t initprot) {
  return ((initprot & VM_PROT_READ) ? ePermissionsReadable : 0u) |
              (initprot & VM_PROT_WRITE) ? ePermissionsWritable : 0u) |
              (initprot & VM_PROT_EXECUTE) ? ePermissionsExecutable : 0u);
}

// at this location
const uint32_t segment_permissions = translateSegmentPermissions(load_cmd.initprot);

source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

521

Am I missing something? Why isn't this just result = static_cast<int64_t>(uval);

source/Target/StackFrame.cpp

1425

Probably only of theoretical interest since I don't think pointee->GetByteSize() can ever return 0, but maybe this should be offset >= 0

1591

How about just delete this variable instead?

[ki.stfu]

Fixes per Zachary's comments

[ki.stfu]

source/Target/StackFrame.cpp

1425

Good point. Thanks!

[ki.stfu]

Rebase against ToT

[ki.stfu]

Apply clang-format

source/Core/Log.cpp

if (stream_sp) {
 
     // Add a sequence ID if requested
     if (m_options.Test(LLDB_LOG_OPTION_PREPEND_SEQUENCE))
       header.Printf("%u ", ++g_sequence_id);
 
     // Timestamp if requested
     if (m_options.Test(LLDB_LOG_OPTION_PREPEND_TIMESTAMP)) {
       TimeValue now = TimeValue::Now();
-      header.Printf("%9d.%09.9d ", now.seconds(), now.nanoseconds());
+      header.Printf("%9d.%9.9d ", now.seconds(), now.nanoseconds());
     }
 
     // Add the process and thread if requested
     if (m_options.Test(LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD))
       header.Printf("[%4.4x/%4.4" PRIx64 "]: ", getpid(),
                     Host::GetCurrentThreadID());
 
     // Add the thread name if requested

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

for (SectionHeaderCollIter I = m_section_headers.begin();
       else if (name == g_sect_name_arm_exidx)
         sect_type = eSectionTypeARMexidx;
       else if (name == g_sect_name_arm_extab)
         sect_type = eSectionTypeARMextab;
       else if (name == g_sect_name_go_symtab)
         sect_type = eSectionTypeGoSymtab;
 
       const uint32_t permissions =
-          ((header.sh_flags & SHF_ALLOC) ? ePermissionsReadable : 0) |
-          ((header.sh_flags & SHF_WRITE) ? ePermissionsWritable : 0) |
-          ((header.sh_flags & SHF_EXECINSTR) ? ePermissionsExecutable : 0);
+          ((header.sh_flags & SHF_ALLOC) ? ePermissionsReadable : 0u) |
+          ((header.sh_flags & SHF_WRITE) ? ePermissionsWritable : 0u) |
+          ((header.sh_flags & SHF_EXECINSTR) ? ePermissionsExecutable : 0u);
       switch (header.sh_type) {
       case SHT_SYMTAB:
         assert(sect_type == eSectionTypeOther);
         sect_type = eSectionTypeELFSymbolTable;
         break;
       case SHT_DYNSYM:
         assert(sect_type == eSectionTypeOther);
         sect_type = eSectionTypeELFDynamicSymbols;

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

for (i = 0; i < m_header.ncmds; ++i) {
                   m_length);
 
               // Tuncase the length
               load_cmd.filesize = m_length - load_cmd.fileoff;
             }
           }
           if (m_data.GetU32(&offset, &load_cmd.maxprot, 4)) {
             const uint32_t segment_permissions =
                 ((load_cmd.initprot & VM_PROT_READ) ? ePermissionsReadable
-                                                    : 0) |
+                                                    : 0u) |
                 ((load_cmd.initprot & VM_PROT_WRITE) ? ePermissionsWritable
-                                                     : 0) |
+                                                     : 0u) |
                 ((load_cmd.initprot & VM_PROT_EXECUTE) ? ePermissionsExecutable
-                                                       : 0);
+                                                       : 0u);
 
             const bool segment_is_encrypted =
                 (load_cmd.flags & SG_PROTECTED_VERSION_1) != 0;
 
             // Keep a list of mach segments around in case we need to
             // get at data that isn't stored in the abstracted Sections.
             m_mach_segments.push_back(load_cmd);
 
if (m_header.flags & 0x80000000u) {
           "dyld_shared_cache_", /* DYLD_SHARED_CACHE_BASE_NAME */
           header_arch.GetArchitectureName());
 
       snprintf(
           dsc_path_development, sizeof(dsc_path), "%s%s%s%s",
           "/System/Library/Caches/com.apple.dyld/", /* IPHONE_DYLD_SHARED_CACHE_DIR
                                                        */
           "dyld_shared_cache_", /* DYLD_SHARED_CACHE_BASE_NAME */
-          header_arch.GetArchitectureName(),
-          ".development");
+          header_arch.GetArchitectureName(), ".development");
 
       FileSpec dsc_nondevelopment_filespec(dsc_path, false);
       FileSpec dsc_development_filespec(dsc_path_development, false);
       FileSpec dsc_filespec;
 
       UUID dsc_uuid;
       UUID process_shared_cache_uuid;
 

source/Plugins/Process/elf-core/ProcessElfCore.cpp

if (last_entry && last_entry->GetRangeEnd() == range_entry.GetRangeBase() &&
     last_entry->data.SetRangeEnd(range_entry.data.GetRangeEnd());
   } else {
     m_core_aranges.Append(range_entry);
   }
 
   // Keep a separate map of permissions that that isn't coalesced so all ranges
   // are maintained.
   const uint32_t permissions =
-      ((header->p_flags & llvm::ELF::PF_R) ? lldb::ePermissionsReadable : 0) |
-      ((header->p_flags & llvm::ELF::PF_W) ? lldb::ePermissionsWritable : 0) |
-      ((header->p_flags & llvm::ELF::PF_X) ? lldb::ePermissionsExecutable : 0);
+      ((header->p_flags & llvm::ELF::PF_R) ? lldb::ePermissionsReadable : 0u) |
+      ((header->p_flags & llvm::ELF::PF_W) ? lldb::ePermissionsWritable : 0u) |
+      ((header->p_flags & llvm::ELF::PF_X) ? lldb::ePermissionsExecutable : 0u);
 
   m_core_range_infos.Append(
       VMRangeToPermissions::Entry(addr, header->p_memsz, permissions));
 
   return addr;
 }
 
 //----------------------------------------------------------------------

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

if (strcmp(response.GetStringRef().c_str(), "OK") == 0) {
                                      type_name.AsCString(),
                                      response.GetStringRef().c_str());
     }
   } else {
     // Can we get more data here on the failure?
     error.SetErrorStringWithFormat("configuring StructuredData feature %s "
                                    "failed when sending packet: "
                                    "PacketResult=%d",
-                                   type_name.AsCString(), result);
+                                   type_name.AsCString(), (int)result);
   }
   return error;
 }
 
 void GDBRemoteCommunicationClient::OnRunPacketSent(bool first) {
   GDBRemoteClientBase::OnRunPacketSent(first);
   m_curr_tid = LLDB_INVALID_THREAD_ID;
 }

source/Plugins/Process/minidump/MinidumpParser.cpp

case MinidumpCPUArchitecture::AMD64:
     arch_spec.GetTriple().setArch(llvm::Triple::ArchType::x86_64);
     break;
   case MinidumpCPUArchitecture::ARM:
     arch_spec.GetTriple().setArch(llvm::Triple::ArchType::arm);
     break;
   case MinidumpCPUArchitecture::ARM64:
     arch_spec.GetTriple().setArch(llvm::Triple::ArchType::aarch64);
     break;
+  default:
+    break;
   }
 
   return arch_spec;
 }
 
 const MinidumpMiscInfo *MinidumpParser::GetMiscInfo() {
   llvm::Optional<llvm::ArrayRef<uint8_t>> data =
       GetStream(MinidumpStreamType::MiscInfo);
 
   if (!data)
     return nullptr;
 
   return MinidumpMiscInfo::Parse(data.getValue());
 }

source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

if (m_py_obj) {
     int overflow = 0;
     int64_t result = PyLong_AsLongLongAndOverflow(m_py_obj, &overflow);
     if (overflow != 0) {
       // We got an integer that overflows, like 18446744072853913392L
       // we can't use PyLong_AsLongLong() as it will return
       // 0xffffffffffffffff. If we use the unsigned long long
       // it will work as expected.
       const uint64_t uval = PyLong_AsUnsignedLongLong(m_py_obj);
-      result = *((int64_t *)&uval);
+      result = *((const int64_t *)&uval);
     }
     return result;
   }
   return UINT64_MAX;
 }
 
 void PythonInteger::SetInteger(int64_t value) {
   PythonObject::Reset(PyRefType::Owned, PyLong_FromLongLong(value));

source/Target/StackFrame.cpp

if (variable_list) {
                         "bitfield range %ld-%ld is not valid for \"(%s) %s\"",
                         child_index, child_index,
                         valobj_sp->GetTypeName().AsCString("<invalid type>"),
                         var_expr_path_strm.GetString().c_str());
                   }
                 } else {
                   ValueObjectSP synthetic = valobj_sp->GetSyntheticValue();
                   if (no_synth_child /* synthetic is forbidden */ ||
-                      !synthetic /* no synthetic */
-                      ||
-                      synthetic == valobj_sp) /* synthetic is the same as the
+                      !synthetic                 /* no synthetic */
+                      || synthetic == valobj_sp) /* synthetic is the same as the
                                                     original object */
                   {
                     valobj_sp->GetExpressionPath(var_expr_path_strm, false);
                     error.SetErrorStringWithFormat(
                         "\"(%s) %s\" is not an array type",
                         valobj_sp->GetTypeName().AsCString("<invalid type>"),
                         var_expr_path_strm.GetString().c_str());
                   } else if (
                       static_cast<uint32_t>(child_index) >=
if (!register_context.ReadRegister(info, reg_value)) {
       return std::make_pair(nullptr, 0);
     }
     if (reg_value.GetAsUInt64() == value) {
       return std::make_pair(&operand, 0);
     } else {
       return std::make_pair(nullptr, 0);
     }
   }
+  default:
+    return std::make_pair(nullptr, 0);
   }
 }
 
 std::pair<const Instruction::Operand *, int64_t>
 GetBaseExplainingDereference(const Instruction::Operand &operand,
                              RegisterContext &register_context,
                              lldb::addr_t addr) {
   if (operand.m_type == Instruction::Operand::Type::Dereference) {
     return GetBaseExplainingValue(operand.m_children[0], register_context,
                                   addr);
   }
   return std::make_pair(nullptr, 0);
 }
-};
+}
 
 lldb::ValueObjectSP StackFrame::GuessValueForAddress(lldb::addr_t addr) {
   TargetSP target_sp = CalculateTarget();
 
   const ArchSpec &target_arch = target_sp->GetArchitecture();
 
   AddressRange pc_range;
   pc_range.GetBaseAddress() = GetFrameCodeAddress();
ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame,
 
   if (!base->IsPointerOrReferenceType()) {
     return ValueObjectSP();
   }
 
   Error error;
   ValueObjectSP pointee = base->Dereference(error);
 
-  if (offset >= pointee->GetByteSize()) {
+  if (offset > 0 && uint64_t(offset) >= pointee->GetByteSize()) {
     int64_t index = offset / pointee->GetByteSize();
     offset = offset % pointee->GetByteSize();
     const bool can_create = true;
     pointee = base->GetSyntheticArrayMember(index, can_create);
   }
 
   if (!pointee || error.Fail()) {
     return ValueObjectSP();
if (is_in_return_register && instruction_sp->IsCall()) {
       continue;
     }
 
     llvm::SmallVector<Instruction::Operand, 2> operands;
     if (!instruction_sp->ParseOperands(operands) || operands.size() != 2) {
       continue;
     }
 
     Instruction::Operand *register_operand = nullptr;
     Instruction::Operand *origin_operand = nullptr;
     if (operands[0].m_type == Instruction::Operand::Type::Register &&
         operands[0].m_clobbered == true && operands[0].m_register == reg) {
       register_operand = &operands[0];
       origin_operand = &operands[1];
     } else if (operands[1].m_type == Instruction::Operand::Type::Register &&
                operands[1].m_clobbered == true &&
                operands[1].m_register == reg) {
       register_operand = &operands[1];
       origin_operand = &operands[0];
     } else {
       continue;
     }
 
+    // Ignore an unused-variable warning for a register operand.
+    (void)register_operand;
+
     // We have an origin operand.  Can we track its value down?
     switch (origin_operand->m_type) {
     default:
       break;
     case Instruction::Operand::Type::Register:
       source_path =
           DoGuessValueAt(frame, origin_operand->m_register, 0, disassembler,
                          variables, instruction_sp->GetAddress());