[LLDB][NFC][Reliability] Fixes for int overflow and uninitialized state

[fixathon]

Summary

Fixing potential int overflow and uninitialized variables.
These were found by Coverity static code inspection.

[shafik]

lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_x86.cpp

67

So we know that wp_index is never greater than 11?

77

You did not update 0xF to 0xFULL like you did the constants above. Was that on purpose?

[fixathon]

lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_x86.cpp

67

For this platform, based on the code and the hardcoded constant the range of wp_index is limited to 0-3 (inclusive)

77

Not on purpose. It's interesting this instance wasn't flagged by coverity likely because
max wp_index value is 3 and 0xF << 28 is still within the 32-bit limit of sizeof(int) the default type for 0xF literal. Then, the signed int will get converted to uint64_t for the bitwise-OR. It's a bit iffy due to the signed type, but should work.

Agreed it would be best be explicit and consistent and mark it as 0xFull. I could include this it into the next batch of reliability diffs next week.

lldb/source/Plugins/Instruction/ARM64/EmulateInstructionARM64.cpp

bool EmulateInstructionARM64::EmulateADDSUBImm(const uint32_t opcode) {
   boolean setflags = S == 1;
   uint64_t imm;
 
   switch (shift) {
   case 0:
     imm = imm12;
     break;
   case 1:
-    imm = imm12 << 12;
+    imm = static_cast<uint64_t>(imm12) << 12;
     break;
   default:
     return false; // UNDEFINED;
   }
   uint64_t result;
   uint64_t operand1 =
       ReadRegisterUnsigned(eRegisterKindLLDB, gpr_x0_arm64 + n, 0, &success);
   uint64_t operand2 = imm;

lldb/source/Plugins/Process/Utility/NativeRegisterContextDBReg_x86.cpp

 #include "Plugins/Process/Utility/lldb-x86-register-enums.h"
 
 using namespace lldb_private;
 
 // Returns mask/value for status bit of wp_index in DR6
 static inline uint64_t GetStatusBit(uint32_t wp_index) {
   // DR6: ...BBBB
   //         3210 <- status bits for bp./wp. i; 1 if hit
-  return 1 << wp_index;
+  return 1ULL << wp_index;
 }
 
 // Returns mask/value for global enable bit of wp_index in DR7
 static inline uint64_t GetEnableBit(uint32_t wp_index) {
   // DR7: ...GLGLGLGL
   //         33221100 <- global/local enable for bp./wp.; 1 if enabled
   // we use global bits because NetBSD kernel does not preserve local
   // bits reliably; Linux seems fine with either
-  return 1 << (2 * wp_index + 1);
+  return 1ULL << (2 * wp_index + 1);
 }
 
 // Returns mask for both enable bits of wp_index in DR7
 static inline uint64_t GetBothEnableBitMask(uint32_t wp_index) {
   // DR7: ...GLGLGLGL
   //         33221100 <- global/local enable for bp./wp.; 1 if enabled
-  return 3 << (2 * wp_index + 1);
+  return 3ULL << (2 * wp_index + 1);
 }
 
 // Returns value for type bits of wp_index in DR7
 static inline uint64_t GetWatchTypeBits(uint32_t watch_flags,
                                         uint32_t wp_index) {
   // DR7:
   // bit: 3322222222221111...
   //      1098765432109876...
   // val: SSTTSSTTSSTTSSTT...
   // wp.: 3333222211110000...
   //
   // where T - type is 01 for write, 11 for r/w
-  return watch_flags << (16 + 4 * wp_index);
+  return static_cast<uint64_t>(watch_flags) << (16 + 4 * wp_index);
 }
 
 // Returns value for size bits of wp_index in DR7
 static inline uint64_t GetWatchSizeBits(uint32_t size, uint32_t wp_index) {
   // DR7:
   // bit: 3322222222221111...
   //      1098765432109876...
   // val: SSTTSSTTSSTTSSTT...
   // wp.: 3333222211110000...
   //
   // where S - size is:
   // 00 for 1 byte
   // 01 for 2 bytes
   // 10 for 8 bytes
   // 11 for 4 bytes
-  return (size == 8 ? 0x2 : size - 1) << (18 + 4 * wp_index);
+  return static_cast<uint64_t>(size == 8 ? 0x2 : size - 1)
+         << (18 + 4 * wp_index);
 }
 
 // Returns bitmask for all bits controlling wp_index in DR7
 static inline uint64_t GetWatchControlBitmask(uint32_t wp_index) {
   // DR7:
   // bit: 33222222222211111111110000000000
   //      10987654321098765432109876543210
   // val: SSTTSSTTSSTTSSTTxxxxxxGLGLGLGLGL
   // wp.: 3333222211110000xxxxxxEE33221100
   return GetBothEnableBitMask(wp_index) | (0xF << (16 + 4 * wp_index));
 }
 
 // Bit mask for control bits regarding all watchpoints.
 static constexpr uint64_t watchpoint_all_control_bit_mask = 0xFFFF00FF;
 
 const RegisterInfo *NativeRegisterContextDBReg_x86::GetDR(int num) const {
   assert(num >= 0 && num <= 7);
   switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine()) {

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

void DWARFASTParserClang::ParseSingleMember(
   const uint64_t word_width = 32;
   CompilerType member_clang_type = member_type->GetLayoutCompilerType();
 
   if (attrs.accessibility == eAccessNone)
     attrs.accessibility = default_accessibility;
 
   uint64_t field_bit_offset = (attrs.member_byte_offset == UINT32_MAX
                                    ? 0
-                                   : (attrs.member_byte_offset * 8));
+                                   : (attrs.member_byte_offset * 8ULL));
 
   if (attrs.bit_size > 0) {
     FieldInfo this_field_info;
     this_field_info.bit_offset = field_bit_offset;
     this_field_info.bit_size = attrs.bit_size;
 
     if (attrs.data_bit_offset != UINT64_MAX) {
       this_field_info.bit_offset = attrs.data_bit_offset;

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

 
 void DWARFUnit::SetStrOffsetsBase(dw_offset_t str_offsets_base) {
   m_str_offsets_base = str_offsets_base;
 }
 
 dw_addr_t DWARFUnit::ReadAddressFromDebugAddrSection(uint32_t index) const {
   uint32_t index_size = GetAddressByteSize();
   dw_offset_t addr_base = GetAddrBase();
-  dw_addr_t offset = addr_base + index * index_size;
+  dw_addr_t offset = addr_base + static_cast<dw_addr_t>(index) * index_size;
   const DWARFDataExtractor &data =
       m_dwarf.GetDWARFContext().getOrLoadAddrData();
   if (data.ValidOffsetForDataOfSize(offset, index_size))
     return data.GetMaxU64_unchecked(&offset, index_size);
   return LLDB_INVALID_ADDRESS;
 }
 
 // It may be called only with m_die_array_mutex held R/W.
if (!range_list_or_error)
     return range_list_or_error.takeError();
 
   llvm::Expected<llvm::DWARFAddressRangesVector> llvm_ranges =
       range_list_or_error->getAbsoluteRanges(
           llvm::object::SectionedAddress{GetBaseAddress()},
           GetAddressByteSize(), [&](uint32_t index) {
             uint32_t index_size = GetAddressByteSize();
             dw_offset_t addr_base = GetAddrBase();
-            lldb::offset_t offset = addr_base + index * index_size;
+            lldb::offset_t offset =
+                addr_base + static_cast<lldb::offset_t>(index) * index_size;
             return llvm::object::SectionedAddress{
                 m_dwarf.GetDWARFContext().getOrLoadAddrData().GetMaxU64(
                     &offset, index_size)};
           });
   if (!llvm_ranges)
     return llvm_ranges.takeError();
 
   DWARFRangeList ranges;

lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

if (error.Success()) {
           //
           // struct introspection_dispatch_pending_items_array_s {
           //   uint32_t version;
           //   uint32_t size_of_item_info;
           //   introspection_dispatch_pending_item_info_s items[];
           //   }
 
           offset_t offset = 0;
-          int i = 0;
+          uint64_t i = 0;
           uint32_t version = extractor.GetU32(&offset);
           if (version == 1) {
             pending_item_refs.new_style = true;
             uint32_t item_size = extractor.GetU32(&offset);
             uint32_t start_of_array_offset = offset;
             while (offset < pending_items_pointer.items_buffer_size &&
-                   static_cast<size_t>(i) < pending_items_pointer.count) {
+                   i < pending_items_pointer.count) {
               offset = start_of_array_offset + (i * item_size);
               ItemRefAndCodeAddress item;
               item.item_ref = extractor.GetAddress(&offset);
               item.code_address = extractor.GetAddress(&offset);
               pending_item_refs.item_refs_and_code_addresses.push_back(item);
               i++;
             }
           } else {
             offset = 0;
             pending_item_refs.new_style = false;
             while (offset < pending_items_pointer.items_buffer_size &&
-                   static_cast<size_t>(i) < pending_items_pointer.count) {
+                   i < pending_items_pointer.count) {
               ItemRefAndCodeAddress item;
               item.item_ref = extractor.GetAddress(&offset);
               item.code_address = LLDB_INVALID_ADDRESS;
               pending_item_refs.item_refs_and_code_addresses.push_back(item);
               i++;
             }
           }
         }

lldb/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.cpp

bool x86AssemblyInspectionEngine::GetNonCallSiteUnwindPlanFromAssembly(
   std::vector<bool> saved_registers(32, false);
 
   // Once the prologue has completed we'll save a copy of the unwind
   // instructions If there is an epilogue in the middle of the function, after
   // that epilogue we'll reinstate the unwind setup -- we assume that some code
   // path jumps over the mid-function epilogue
 
   UnwindPlan::RowSP prologue_completed_row; // copy of prologue row of CFI
-  int prologue_completed_sp_bytes_offset_from_cfa; // The sp value before the
+  int prologue_completed_sp_bytes_offset_from_cfa = 0; // The sp value before the
                                                    // epilogue started executed
   bool prologue_completed_is_aligned = false;
   std::vector<bool> prologue_completed_saved_registers;
 
   while (current_func_text_offset < size) {
     int stack_offset, insn_len;
     int machine_regno;   // register numbers masked directly out of instructions
     uint32_t lldb_regno; // register numbers in lldb's eRegisterKindLLDB