[lldb] Fix bitfield incorrectly printing when field crosses a storage unit

[CharKeaney]

Summary

This patch resolves an issue where bitfields will not be
printed correctly if a field crosses a storage unit.

The issue is caused by lldb internally storing bitfield
field's offsets as unsigned rather than signed values.
Negative offsets can be created when a field crosses a
storage unit.

The issue is resolved by changing lldb's internal representation
for bitfield field offsets to be stored using signed values.
Also, in the code responsible for extracting data for printing,
the mechanism must be changed such that it can handle negative
offsets appropriately.

This patch includes a test case to test that the issue is resolved.

[DavidSpickett]

Thanks for working on this. Due to llvm dev and vacation it took me a while to get to this.

lldb/test/API/commands/expression/expr-bitfield-on-boundary/Makefile

3

Add a comment here to explain why we need dwarf v2 specifically.

Which I think is because in v4 the encoding is done such that you won't get a negative offset?

lldb/test/API/commands/expression/expr-bitfield-on-boundary/main.cpp

3

Comment here that b is going across the byte boundary.

Maybe on the packed too, iirc without packed it would assign one whole byte to each of a and b.

9

b is going to be across the boundary, should we use a value that is also across the boundary?

Something like 9, so you have 0b1001. One bit on both sides of the boundary. Just in case lldb actually is dropping one side of the value and we aren't checking for that.

lldb/unittests/Platform/PlatformSiginfoTest.cpp

62

Are you reasonably sure you found all these cases? Don't want to loose the sign because of an implicit cast.

If not, -Wconversion is worth a go though lldb probably has hundreds of those already. Perhaps compare the number of those warnings before and after this change.

[DavidSpickett]

Ping!

[DavidSpickett]

Note that this fixes https://github.com/llvm/llvm-project/issues/58769 in the commit message ("fixes #<the issue number>").

Also ping again! If you don't have the time to work on this in the near future, perhaps I can do the finishing touches and get it in (with you as co-author)? Would really like to see this issue fixed.

lldb/source/Utility/DataExtractor.cpp

588

Remove the {} when using single line ifs.

[jwnhy]

Hi, guys, I have met this issue #61706.

The case I provided shows that even without DWARF v2, this problem still exists.

I wonder if such modification is really needed or not.

Also, I am not sure changing all these to int actually fixes the issue here.

In fact, in UpdateValue, the m_byte_offset also changed by the overhang_bytes in line .
For a bitfield not aligned to *type_bit_size, moving overhang_bytes will cause truncation in the bitfield.

#pragma pack(1)
struct  {
  signed f0 : 27;
  unsigned f5 : 30;
} g_96 = {5070, 1795821};
int main() {return 0;}

The structure in memory is represented as 0xdb37680013ce, adding m_byte_offset with overhang_bytes results in 0xdb37, with last five bits lost.

This patchset may fix the underflow problem of m_bitfield_bit_offset, but does not fix the truncation issue...

Not knowing there is a WIP patch, I have created another smaller patch, which just checks... (if it's not ok to hijack the thread, plz tell me...I am really newbie...)
https://reviews.llvm.org/D146919

I wonder if it's ok I take over this issue?

lldb/include/lldb/Core/DumpDataExtractor.h

 ///     in the output. This does not apply to certain formats.
 ///
 /// \return
 ///     The offset at which dumping ended.
 lldb::offset_t
 DumpDataExtractor(const DataExtractor &DE, Stream *s, lldb::offset_t offset,
                   lldb::Format item_format, size_t item_byte_size,
                   size_t item_count, size_t num_per_line, uint64_t base_addr,
-                  uint32_t item_bit_size, uint32_t item_bit_offset,
+                  uint32_t item_bit_size, int32_t item_bit_offset,
                   ExecutionContextScope *exe_scope = nullptr,
                   bool show_memory_tags = false);
 
 void DumpHexBytes(Stream *s, const void *src, size_t src_len,
                   uint32_t bytes_per_line, lldb::addr_t base_addr);
 }
 
 #endif

lldb/include/lldb/Core/ValueObject.h

lldb::ValueObjectSP GetValueForExpressionPath(
       ExpressionPathAftermath *final_task_on_target = nullptr);
 
   virtual bool IsInScope() { return true; }
 
   virtual lldb::offset_t GetByteOffset() { return 0; }
 
   virtual uint32_t GetBitfieldBitSize() { return 0; }
 
-  virtual uint32_t GetBitfieldBitOffset() { return 0; }
+  virtual int32_t GetBitfieldBitOffset() { return 0; }
 
   bool IsBitfield() {
     return (GetBitfieldBitSize() != 0) || (GetBitfieldBitOffset() != 0);
   }
 
   virtual bool IsArrayItemForPointer() {
     return m_flags.m_is_array_item_for_pointer;
   }

lldb/include/lldb/Core/ValueObjectChild.h

public:
   ~ValueObjectChild() override;
 
   llvm::Optional<uint64_t> GetByteSize() override { return m_byte_size; }
 
   lldb::offset_t GetByteOffset() override { return m_byte_offset; }
 
   uint32_t GetBitfieldBitSize() override { return m_bitfield_bit_size; }
 
-  uint32_t GetBitfieldBitOffset() override { return m_bitfield_bit_offset; }
+  int32_t GetBitfieldBitOffset() override { return m_bitfield_bit_offset; }
 
   lldb::ValueType GetValueType() const override;
 
   size_t CalculateNumChildren(uint32_t max) override;
 
   ConstString GetTypeName() override;
 
   ConstString GetQualifiedTypeName() override;
protected:
 
   CompilerType GetCompilerTypeImpl() override { return m_compiler_type; }
 
   CompilerType m_compiler_type;
   ConstString m_type_name;
   uint64_t m_byte_size;
   int32_t m_byte_offset;
   uint8_t m_bitfield_bit_size;
-  uint8_t m_bitfield_bit_offset;
+  int8_t m_bitfield_bit_offset;
   bool m_is_base_class;
   bool m_is_deref_of_parent;
   llvm::Optional<LazyBool> m_can_update_with_invalid_exe_ctx;
 
   friend class ValueObject;
   friend class ValueObjectConstResult;
   friend class ValueObjectConstResultImpl;
 
   ValueObjectChild(ValueObject &parent, const CompilerType &compiler_type,
-                   ConstString name, uint64_t byte_size,
-                   int32_t byte_offset, uint32_t bitfield_bit_size,
-                   uint32_t bitfield_bit_offset, bool is_base_class,
-                   bool is_deref_of_parent,
+                   ConstString name, uint64_t byte_size, int32_t byte_offset,
+                   uint32_t bitfield_bit_size, int32_t bitfield_bit_offset,
+                   bool is_base_class, bool is_deref_of_parent,
                    AddressType child_ptr_or_ref_addr_type,
                    uint64_t language_flags);
 
   ValueObjectChild(const ValueObjectChild &) = delete;
   const ValueObjectChild &operator=(const ValueObjectChild &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_CORE_VALUEOBJECTCHILD_H

lldb/include/lldb/Symbol/CompilerType.h

public:
   /// the iteration.
   void ForEachEnumerator(
       std::function<bool(const CompilerType &integer_type, ConstString name,
                          const llvm::APSInt &value)> const &callback) const;
 
   uint32_t GetNumFields() const;
 
   CompilerType GetFieldAtIndex(size_t idx, std::string &name,
-                               uint64_t *bit_offset_ptr,
+                               int64_t *bit_offset_ptr,
                                uint32_t *bitfield_bit_size_ptr,
                                bool *is_bitfield_ptr) const;
 
   uint32_t GetNumDirectBaseClasses() const;
 
   uint32_t GetNumVirtualBaseClasses() const;
 
   CompilerType GetDirectBaseClassAtIndex(size_t idx,
-                                         uint32_t *bit_offset_ptr) const;
+                                         int32_t *bit_offset_ptr) const;
 
   CompilerType GetVirtualBaseClassAtIndex(size_t idx,
-                                          uint32_t *bit_offset_ptr) const;
+                                          int32_t *bit_offset_ptr) const;
 
   uint32_t GetIndexOfFieldWithName(const char *name,
                                    CompilerType *field_compiler_type = nullptr,
-                                   uint64_t *bit_offset_ptr = nullptr,
+                                   int64_t *bit_offset_ptr = nullptr,
                                    uint32_t *bitfield_bit_size_ptr = nullptr,
                                    bool *is_bitfield_ptr = nullptr) const;
 
   CompilerType GetChildCompilerTypeAtIndex(
       ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers,
       bool omit_empty_base_classes, bool ignore_array_bounds,
       std::string &child_name, uint32_t &child_byte_size,
       int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
-      uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
+      int32_t &child_bitfield_bit_offset, bool &child_is_base_class,
       bool &child_is_deref_of_parent, ValueObject *valobj,
       uint64_t &language_flags) const;
 
   /// Lookup a child given a name. This function will match base class names and
   /// member member names in "clang_type" only, not descendants.
   uint32_t GetIndexOfChildWithName(const char *name,
                                    bool omit_empty_base_classes) const;
 
#ifndef NDEBUG
   /// Convenience LLVM-style dump method for use in the debugger only.
   /// Don't call this function from actual code.
   LLVM_DUMP_METHOD void dump() const;
 #endif
 
   void DumpValue(ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
                  const DataExtractor &data, lldb::offset_t data_offset,
                  size_t data_byte_size, uint32_t bitfield_bit_size,
-                 uint32_t bitfield_bit_offset, bool show_types,
+                 int32_t bitfield_bit_offset, bool show_types,
                  bool show_summary, bool verbose, uint32_t depth);
 
   bool DumpTypeValue(Stream *s, lldb::Format format, const DataExtractor &data,
                      lldb::offset_t data_offset, size_t data_byte_size,
-                     uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
+                     uint32_t bitfield_bit_size, int32_t bitfield_bit_offset,
                      ExecutionContextScope *exe_scope);
 
   void DumpSummary(ExecutionContext *exe_ctx, Stream *s,
                    const DataExtractor &data, lldb::offset_t data_offset,
                    size_t data_byte_size);
 
   /// Dump to stdout.
   void DumpTypeDescription(lldb::DescriptionLevel level =

lldb/include/lldb/Symbol/TypeSystem.h

virtual void ForEachEnumerator(
       std::function<bool(const CompilerType &integer_type,
                          ConstString name,
                          const llvm::APSInt &value)> const &callback) {}
 
   virtual uint32_t GetNumFields(lldb::opaque_compiler_type_t type) = 0;
 
   virtual CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type,
                                        size_t idx, std::string &name,
-                                       uint64_t *bit_offset_ptr,
+                                       int64_t *bit_offset_ptr,
                                        uint32_t *bitfield_bit_size_ptr,
                                        bool *is_bitfield_ptr) = 0;
 
   virtual uint32_t
   GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) = 0;
 
   virtual uint32_t
   GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) = 0;
 
   virtual CompilerType
   GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
-                            uint32_t *bit_offset_ptr) = 0;
+                            int32_t *bit_offset_ptr) = 0;
 
   virtual CompilerType
   GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
-                             uint32_t *bit_offset_ptr) = 0;
+                             int32_t *bit_offset_ptr) = 0;
 
   virtual CompilerType GetChildCompilerTypeAtIndex(
       lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
       bool transparent_pointers, bool omit_empty_base_classes,
       bool ignore_array_bounds, std::string &child_name,
       uint32_t &child_byte_size, int32_t &child_byte_offset,
-      uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
+      uint32_t &child_bitfield_bit_size, int32_t &child_bitfield_bit_offset,
       bool &child_is_base_class, bool &child_is_deref_of_parent,
       ValueObject *valobj, uint64_t &language_flags) = 0;
 
   // Lookup a child given a name. This function will match base class names and
   // member member names in "clang_type" only, not descendants.
   virtual uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
                                            const char *name,
                                            bool omit_empty_base_classes) = 0;
#ifndef NDEBUG
   dump(lldb::opaque_compiler_type_t type) const = 0;
 #endif
 
   virtual void DumpValue(lldb::opaque_compiler_type_t type,
                          ExecutionContext *exe_ctx, Stream *s,
                          lldb::Format format, const DataExtractor &data,
                          lldb::offset_t data_offset, size_t data_byte_size,
                          uint32_t bitfield_bit_size,
-                         uint32_t bitfield_bit_offset, bool show_types,
+                         int32_t bitfield_bit_offset, bool show_types,
                          bool show_summary, bool verbose, uint32_t depth) = 0;
 
   virtual bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
                              lldb::Format format, const DataExtractor &data,
                              lldb::offset_t data_offset, size_t data_byte_size,
                              uint32_t bitfield_bit_size,
-                             uint32_t bitfield_bit_offset,
+                             int32_t bitfield_bit_offset,
                              ExecutionContextScope *exe_scope) = 0;
 
   /// Dump the type to stdout.
   virtual void DumpTypeDescription(
       lldb::opaque_compiler_type_t type,
       lldb::DescriptionLevel level = lldb::eDescriptionLevelFull) = 0;
 
   /// Print a description of the type to a stream. The exact implementation

lldb/include/lldb/Target/ProcessStructReader.h

if (!process)
       return;
     if (base_addr == 0 || base_addr == LLDB_INVALID_ADDRESS)
       return;
     m_byte_order = process->GetByteOrder();
     m_addr_byte_size = process->GetAddressByteSize();
 
     for (size_t idx = 0; idx < struct_type.GetNumFields(); idx++) {
       std::string name;
-      uint64_t bit_offset;
+      int64_t bit_offset;
       uint32_t bitfield_bit_size;
       bool is_bitfield;
       CompilerType field_type = struct_type.GetFieldAtIndex(
           idx, name, &bit_offset, &bitfield_bit_size, &is_bitfield);
       // no support for bitfields in here (yet)
       if (is_bitfield)
         return;
       auto size = field_type.GetByteSize(nullptr);

lldb/include/lldb/Utility/DataExtractor.h

public:
   ///     For big-endian data, this is the offset of the MSB of the
   ///     bitfield from the MSB of the integer.
   ///
   /// \return
   ///     The unsigned bitfield integer value that was extracted, or
   ///     zero on failure.
   uint64_t GetMaxU64Bitfield(lldb::offset_t *offset_ptr, size_t size,
                              uint32_t bitfield_bit_size,
-                             uint32_t bitfield_bit_offset) const;
+                             int32_t bitfield_bit_offset) const;
 
   /// Extract an signed integer of size \a size from \a *offset_ptr, then
   /// extract and sign-extend the bitfield from this value if \a
   /// bitfield_bit_size is non-zero.
   ///
   /// Extract a single signed integer value (sign-extending if required) and
   /// update the offset pointed to by \a offset_ptr. The size of the extracted
   /// integer is specified by the \a size argument. \a size must
public:
   ///     For big-endian data, this is the offset of the MSB of the
   ///     bitfield from the MSB of the integer.
   ///
   /// \return
   ///     The signed bitfield integer value that was extracted, or
   ///     zero on failure.
   int64_t GetMaxS64Bitfield(lldb::offset_t *offset_ptr, size_t size,
                             uint32_t bitfield_bit_size,
-                            uint32_t bitfield_bit_offset) const;
+                            int32_t bitfield_bit_offset) const;
 
   /// Get the current byte order value.
   ///
   /// \return
   ///     The current byte order value from this object's internal
   ///     state.
   lldb::ByteOrder GetByteOrder() const { return m_byte_order; }
 

lldb/source/API/SBType.cpp

bool SBType::GetDescription(SBStream &description,
   return true;
 }
 
 SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
   LLDB_INSTRUMENT_VA(this, idx);
 
   SBTypeMember sb_type_member;
   if (IsValid()) {
-    uint32_t bit_offset = 0;
+    int32_t bit_offset = 0;
     CompilerType base_class_type =
         m_opaque_sp->GetCompilerType(true).GetDirectBaseClassAtIndex(
             idx, &bit_offset);
     if (base_class_type.IsValid())
       sb_type_member.reset(new TypeMemberImpl(
           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
   }
   return sb_type_member;
 }
 
 SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
   LLDB_INSTRUMENT_VA(this, idx);
 
   SBTypeMember sb_type_member;
   if (IsValid()) {
-    uint32_t bit_offset = 0;
+    int32_t bit_offset = 0;
     CompilerType base_class_type =
         m_opaque_sp->GetCompilerType(true).GetVirtualBaseClassAtIndex(
             idx, &bit_offset);
     if (base_class_type.IsValid())
       sb_type_member.reset(new TypeMemberImpl(
           TypeImplSP(new TypeImpl(base_class_type)), bit_offset));
   }
   return sb_type_member;

 
 SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
   LLDB_INSTRUMENT_VA(this, idx);
 
   SBTypeMember sb_type_member;
   if (IsValid()) {
     CompilerType this_type(m_opaque_sp->GetCompilerType(false));
     if (this_type.IsValid()) {
-      uint64_t bit_offset = 0;
+      int64_t bit_offset = 0;
       uint32_t bitfield_bit_size = 0;
       bool is_bitfield = false;
       std::string name_sstr;
       CompilerType field_type(this_type.GetFieldAtIndex(
           idx, name_sstr, &bit_offset, &bitfield_bit_size, &is_bitfield));
       if (field_type.IsValid()) {
         ConstString name;
         if (!name_sstr.empty())

 
 bool SBTypeMember::GetDescription(lldb::SBStream &description,
                                   lldb::DescriptionLevel description_level) {
   LLDB_INSTRUMENT_VA(this, description, description_level);
 
   Stream &strm = description.ref();
 
   if (m_opaque_up) {
-    const uint32_t bit_offset = m_opaque_up->GetBitOffset();
-    const uint32_t byte_offset = bit_offset / 8u;
-    const uint32_t byte_bit_offset = bit_offset % 8u;
+    const int32_t bit_offset = m_opaque_up->GetBitOffset();
+    const int32_t byte_offset = bit_offset / 8u;
+    const int32_t byte_bit_offset = bit_offset % 8u;
     const char *name = m_opaque_up->GetName().GetCString();
     if (byte_bit_offset)
       strm.Printf("+%u + %u bits: (", byte_offset, byte_bit_offset);
     else
       strm.Printf("+%u: (", byte_offset);
 
     TypeImplSP type_impl_sp(m_opaque_up->GetTypeImpl());
     if (type_impl_sp)

lldb/source/Core/DumpDataExtractor.cpp

static const llvm::fltSemantics &GetFloatSemantics(const TargetSP &target_sp,
   }
   return llvm::APFloat::Bogus();
 }
 
 lldb::offset_t lldb_private::DumpDataExtractor(
     const DataExtractor &DE, Stream *s, offset_t start_offset,
     lldb::Format item_format, size_t item_byte_size, size_t item_count,
     size_t num_per_line, uint64_t base_addr,
-    uint32_t item_bit_size,   // If zero, this is not a bitfield value, if
-                              // non-zero, the value is a bitfield
-    uint32_t item_bit_offset, // If "item_bit_size" is non-zero, this is the
-                              // shift amount to apply to a bitfield
+    uint32_t item_bit_size,  // If zero, this is not a bitfield value, if
+    int32_t item_bit_offset, // If "item_bit_size" is non-zero, this is the
     ExecutionContextScope *exe_scope, bool show_memory_tags) {
   if (s == nullptr)
     return start_offset;
 
   if (item_format == eFormatPointer) {
     if (item_byte_size != 4 && item_byte_size != 8)
       item_byte_size = s->GetAddressByteSize();
   }

lldb/source/Core/ValueObject.cpp

ValueObject *ValueObject::CreateChildAtIndex(size_t idx,
   ValueObject *valobj = nullptr;
 
   bool omit_empty_base_classes = true;
   bool ignore_array_bounds = synthetic_array_member;
   std::string child_name_str;
   uint32_t child_byte_size = 0;
   int32_t child_byte_offset = 0;
   uint32_t child_bitfield_bit_size = 0;
-  uint32_t child_bitfield_bit_offset = 0;
+  int32_t child_bitfield_bit_offset = 0;
   bool child_is_base_class = false;
   bool child_is_deref_of_parent = false;
   uint64_t language_flags = 0;
 
   const bool transparent_pointers = !synthetic_array_member;
   CompilerType child_compiler_type;
 
   ExecutionContext exe_ctx(GetExecutionContextRef());
ValueObjectSP ValueObject::Dereference(Status &error) {
   if (is_pointer_or_reference_type) {
     bool omit_empty_base_classes = true;
     bool ignore_array_bounds = false;
 
     std::string child_name_str;
     uint32_t child_byte_size = 0;
     int32_t child_byte_offset = 0;
     uint32_t child_bitfield_bit_size = 0;
-    uint32_t child_bitfield_bit_offset = 0;
+    int32_t child_bitfield_bit_offset = 0;
     bool child_is_base_class = false;
     bool child_is_deref_of_parent = false;
     const bool transparent_pointers = false;
     CompilerType compiler_type = GetCompilerType();
     CompilerType child_compiler_type;
     uint64_t language_flags = 0;
 
     ExecutionContext exe_ctx(GetExecutionContextRef());

lldb/source/Core/ValueObjectChild.cpp

 #include <vector>
 
 #include <cstdio>
 #include <cstring>
 
 using namespace lldb_private;
 
 ValueObjectChild::ValueObjectChild(
-    ValueObject &parent, const CompilerType &compiler_type,
-    ConstString name, uint64_t byte_size, int32_t byte_offset,
-    uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
-    bool is_base_class, bool is_deref_of_parent,
+    ValueObject &parent, const CompilerType &compiler_type, ConstString name,
+    uint64_t byte_size, int32_t byte_offset, uint32_t bitfield_bit_size,
+    int32_t bitfield_bit_offset, bool is_base_class, bool is_deref_of_parent,
     AddressType child_ptr_or_ref_addr_type, uint64_t language_flags)
     : ValueObject(parent), m_compiler_type(compiler_type),
       m_byte_size(byte_size), m_byte_offset(byte_offset),
       m_bitfield_bit_size(bitfield_bit_size),
       m_bitfield_bit_offset(bitfield_bit_offset),
       m_is_base_class(is_base_class), m_is_deref_of_parent(is_deref_of_parent),
       m_can_update_with_invalid_exe_ctx() {
   m_name = name;

lldb/source/Core/ValueObjectConstResultImpl.cpp

ValueObject *ValueObjectConstResultImpl::CreateChildAtIndex(
   ValueObjectConstResultChild *valobj = nullptr;
 
   bool omit_empty_base_classes = true;
   bool ignore_array_bounds = synthetic_array_member;
   std::string child_name_str;
   uint32_t child_byte_size = 0;
   int32_t child_byte_offset = 0;
   uint32_t child_bitfield_bit_size = 0;
-  uint32_t child_bitfield_bit_offset = 0;
+  int32_t child_bitfield_bit_offset = 0;
   bool child_is_base_class = false;
   bool child_is_deref_of_parent = false;
   uint64_t language_flags;
 
   const bool transparent_pointers = !synthetic_array_member;
   CompilerType compiler_type = m_impl_backend->GetCompilerType();
   CompilerType child_compiler_type;
 

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc64.cpp

private:
   CompilerType GetChildType(uint32_t i, std::string &name, uint32_t &size) {
     // GetChild constant inputs
     const bool transparent_pointers = false;
     const bool omit_empty_base_classes = true;
     const bool ignore_array_bounds = false;
     // GetChild output params
     int32_t child_offs;
     uint32_t child_bitfield_bit_size;
-    uint32_t child_bitfield_bit_offset;
+    int32_t child_bitfield_bit_offset;
     bool child_is_base_class;
     bool child_is_deref_of_parent;
     ValueObject *valobj = nullptr;
     uint64_t language_flags;
     ExecutionContext exe_ctx;
     m_thread.CalculateExecutionContext(exe_ctx);
 
     return m_type.GetChildCompilerTypeAtIndex(

lldb/source/Plugins/ABI/X86/ABISysV_x86_64.cpp

static bool FlattenAggregateType(
 
   const uint32_t num_children = return_compiler_type.GetNumFields();
   for (uint32_t idx = 0; idx < num_children; ++idx) {
     std::string name;
     bool is_signed;
     uint32_t count;
     bool is_complex;
 
-    uint64_t field_bit_offset = 0;
+    int64_t field_bit_offset = 0;
     CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex(
         idx, name, &field_bit_offset, nullptr, nullptr);
     llvm::Optional<uint64_t> field_bit_width =
           field_compiler_type.GetBitSize(&thread);
 
     // if we don't know the size of the field (e.g. invalid type), exit
     if (!field_bit_width || *field_bit_width == 0) {
       return false;
     }
 
-    uint32_t field_byte_offset = field_bit_offset / 8 + data_byte_offset;
+    int32_t field_byte_offset = field_bit_offset / 8 + data_byte_offset;
 
     const uint32_t field_type_flags = field_compiler_type.GetTypeInfo();
     if (field_compiler_type.IsIntegerOrEnumerationType(is_signed) ||
         field_compiler_type.IsPointerType() ||
         field_compiler_type.IsFloatingPointType(count, is_complex)) {
       aggregate_field_offsets.push_back(field_byte_offset);
       aggregate_compiler_types.push_back(field_compiler_type);
     } else if (field_type_flags & eTypeHasChildren) {

lldb/source/Plugins/ABI/X86/ABIWindows_x86_64.cpp

static bool FlattenAggregateType(
 
   const uint32_t num_children = return_compiler_type.GetNumFields();
   for (uint32_t idx = 0; idx < num_children; ++idx) {
     std::string name;
     bool is_signed;
     uint32_t count;
     bool is_complex;
 
-    uint64_t field_bit_offset = 0;
+    int64_t field_bit_offset = 0;
     CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex(
         idx, name, &field_bit_offset, nullptr, nullptr);
     llvm::Optional<uint64_t> field_bit_width =
           field_compiler_type.GetBitSize(&thread);
 
     // if we don't know the size of the field (e.g. invalid type), exit
     if (!field_bit_width || *field_bit_width == 0) {
       return false;

lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp

lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
     const bool omit_empty_base_classes = false;
     const bool ignore_array_bounds = false;
     ValueObject *value_object = nullptr;
 
     std::string child_name;
     uint32_t child_byte_size = 0;
     int32_t child_byte_offset = 0;
     uint32_t child_bitfield_bit_size = 0;
-    uint32_t child_bitfield_bit_offset = 0;
+    int32_t child_bitfield_bit_offset = 0;
     bool child_is_base_class = false;
     bool child_is_deref_of_parent = false;
     uint64_t language_flags = 0;
 
     const CompilerType child_type =
         m_block_struct_type.GetChildCompilerTypeAtIndex(
             &exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
             ignore_array_bounds, child_name, child_byte_size, child_byte_offset,

lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp

if (m_pair_ptr) {
       auto __i_(valobj_sp->GetChildMemberWithName(g_i_, true));
       if (!__i_) {
         m_pair_ptr = nullptr;
         return false;
       }
       CompilerType pair_type(
           __i_->GetCompilerType().GetTypeTemplateArgument(0));
       std::string name;
-      uint64_t bit_offset_ptr;
+      int64_t bit_offset_ptr;
       uint32_t bitfield_bit_size_ptr;
       bool is_bitfield_ptr;
       pair_type = pair_type.GetFieldAtIndex(
           0, name, &bit_offset_ptr, &bitfield_bit_size_ptr, &is_bitfield_ptr);
       if (!pair_type) {
         m_pair_ptr = nullptr;
         return false;
       }
if (m_iter_ptr) {
 
     CompilerType node_type(iter_child->GetCompilerType()
                                .GetTypeTemplateArgument(0)
                                .GetPointeeType());
 
     CompilerType pair_type(node_type.GetTypeTemplateArgument(0));
 
     std::string name;
-    uint64_t bit_offset_ptr;
+    int64_t bit_offset_ptr;
     uint32_t bitfield_bit_size_ptr;
     bool is_bitfield_ptr;
 
     pair_type = pair_type.GetFieldAtIndex(
         0, name, &bit_offset_ptr, &bitfield_bit_size_ptr, &is_bitfield_ptr);
     if (!pair_type) {
       m_iter_ptr = nullptr;
       return false;

lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetDataType() {
   deref = m_backend.GetChildAtNamePath({g_tree_, g_pair3});
   if (!deref)
     return false;
   m_element_type = deref->GetCompilerType()
                        .GetTypeTemplateArgument(1)
                        .GetTypeTemplateArgument(1);
   if (m_element_type) {
     std::string name;
-    uint64_t bit_offset_ptr;
+    int64_t bit_offset_ptr;
     uint32_t bitfield_bit_size_ptr;
     bool is_bitfield_ptr;
     m_element_type = m_element_type.GetFieldAtIndex(
         0, name, &bit_offset_ptr, &bitfield_bit_size_ptr, &is_bitfield_ptr);
     m_element_type = m_element_type.GetTypedefedType();
     return m_element_type.IsValid();
   } else {
     m_element_type = m_backend.GetCompilerType().GetTypeTemplateArgument(0);
     return m_element_type.IsValid();
   }
 }
 
 void lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::GetValueOffset(
     const lldb::ValueObjectSP &node) {
   if (m_skip_size != UINT32_MAX)
     return;
   if (!node)
     return;
   CompilerType node_type(node->GetCompilerType());
-  uint64_t bit_offset;
+  int64_t bit_offset;
   if (node_type.GetIndexOfFieldWithName("__value_", nullptr, &bit_offset) !=
       UINT32_MAX) {
     m_skip_size = bit_offset / 8u;
   } else {
     TypeSystemClang *ast_ctx =
         llvm::dyn_cast_or_null<TypeSystemClang>(node_type.GetTypeSystem());
     if (!ast_ctx)
       return;
     CompilerType tree_node_type = ast_ctx->CreateStructForIdentifier(
         ConstString(),
         {{"ptr0", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
          {"ptr1", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
          {"ptr2", ast_ctx->GetBasicType(lldb::eBasicTypeVoid).GetPointerType()},
          {"cw", ast_ctx->GetBasicType(lldb::eBasicTypeBool)},
          {"payload", (m_element_type.GetCompleteType(), m_element_type)}});
     std::string child_name;
     uint32_t child_byte_size;
     int32_t child_byte_offset = 0;
     uint32_t child_bitfield_bit_size;
-    uint32_t child_bitfield_bit_offset;
+    int32_t child_bitfield_bit_offset;
     bool child_is_base_class;
     bool child_is_deref_of_parent;
     uint64_t language_flags;
     if (tree_node_type
             .GetChildCompilerTypeAtIndex(
                 nullptr, 4, true, true, true, child_name, child_byte_size,
                 child_byte_offset, child_bitfield_bit_size,
                 child_bitfield_bit_offset, child_is_base_class,

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

void ForEachEnumerator(
       lldb::opaque_compiler_type_t type,
       std::function<bool(const CompilerType &integer_type,
                          ConstString name,
                          const llvm::APSInt &value)> const &callback) override;
 
   uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;
 
   CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
-                               std::string &name, uint64_t *bit_offset_ptr,
+                               std::string &name, int64_t *bit_offset_ptr,
                                uint32_t *bitfield_bit_size_ptr,
                                bool *is_bitfield_ptr) override;
 
   uint32_t GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) override;
 
   uint32_t GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) override;
 
   CompilerType GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type,
                                          size_t idx,
-                                         uint32_t *bit_offset_ptr) override;
+                                         int32_t *bit_offset_ptr) override;
 
   CompilerType GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type,
                                           size_t idx,
-                                          uint32_t *bit_offset_ptr) override;
+                                          int32_t *bit_offset_ptr) override;
 
   static uint32_t GetNumPointeeChildren(clang::QualType type);
 
   CompilerType GetChildCompilerTypeAtIndex(
       lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
       bool transparent_pointers, bool omit_empty_base_classes,
       bool ignore_array_bounds, std::string &child_name,
       uint32_t &child_byte_size, int32_t &child_byte_offset,
-      uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
+      uint32_t &child_bitfield_bit_size, int32_t &child_bitfield_bit_offset,
       bool &child_is_base_class, bool &child_is_deref_of_parent,
       ValueObject *valobj, uint64_t &language_flags) override;
 
   // Lookup a child given a name. This function will match base class names and
   // member member names in "clang_type" only, not descendants.
   uint32_t GetIndexOfChildWithName(lldb::opaque_compiler_type_t type,
                                    const char *name,
                                    bool omit_empty_base_classes) override;
#endif
   ///       A stream to send the dumped AST node(s) to
   /// \param[in] symbol_name
   ///       The name of the symbol to dump, if it is empty dump all the symbols
   void DumpFromSymbolFile(Stream &s, llvm::StringRef symbol_name);
 
   void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
                  Stream *s, lldb::Format format, const DataExtractor &data,
                  lldb::offset_t data_offset, size_t data_byte_size,
-                 uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
+                 uint32_t bitfield_bit_size, int32_t bitfield_bit_offset,
                  bool show_types, bool show_summary, bool verbose,
                  uint32_t depth) override;
 
   bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
                      lldb::Format format, const DataExtractor &data,
                      lldb::offset_t data_offset, size_t data_byte_size,
-                     uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
+                     uint32_t bitfield_bit_size, int32_t bitfield_bit_offset,
                      ExecutionContextScope *exe_scope) override;
 
   void DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
                    Stream *s, const DataExtractor &data,
                    lldb::offset_t data_offset, size_t data_byte_size) override;
 
   void DumpTypeDescription(
       lldb::opaque_compiler_type_t type,

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

default:
     break;
   }
   return count;
 }
 
 static lldb::opaque_compiler_type_t
 GetObjCFieldAtIndex(clang::ASTContext *ast,
                     clang::ObjCInterfaceDecl *class_interface_decl, size_t idx,
-                    std::string &name, uint64_t *bit_offset_ptr,
+                    std::string &name, int64_t *bit_offset_ptr,
                     uint32_t *bitfield_bit_size_ptr, bool *is_bitfield_ptr) {
   if (class_interface_decl) {
     if (idx < (class_interface_decl->ivar_size())) {
       clang::ObjCInterfaceDecl::ivar_iterator ivar_pos,
           ivar_end = class_interface_decl->ivar_end();
       uint32_t ivar_idx = 0;
 
       for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end;
if (idx < (class_interface_decl->ivar_size())) {
       }
     }
   }
   return nullptr;
 }
 
 CompilerType TypeSystemClang::GetFieldAtIndex(lldb::opaque_compiler_type_t type,
                                               size_t idx, std::string &name,
-                                              uint64_t *bit_offset_ptr,
+                                              int64_t *bit_offset_ptr,
                                               uint32_t *bitfield_bit_size_ptr,
                                               bool *is_bitfield_ptr) {
   if (!type)
     return CompilerType();
 
   clang::QualType qual_type(RemoveWrappingTypes(GetCanonicalQualType(type)));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
TypeSystemClang::GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) {
 
   default:
     break;
   }
   return count;
 }
 
 CompilerType TypeSystemClang::GetDirectBaseClassAtIndex(
-    lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
+    lldb::opaque_compiler_type_t type, size_t idx, int32_t *bit_offset_ptr) {
   clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
       if (cxx_record_decl) {
CompilerType TypeSystemClang::GetDirectBaseClassAtIndex(
 
   default:
     break;
   }
   return CompilerType();
 }
 
 CompilerType TypeSystemClang::GetVirtualBaseClassAtIndex(
-    lldb::opaque_compiler_type_t type, size_t idx, uint32_t *bit_offset_ptr) {
+    lldb::opaque_compiler_type_t type, size_t idx, int32_t *bit_offset_ptr) {
   clang::QualType qual_type = RemoveWrappingTypes(GetCanonicalQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::CXXRecordDecl *cxx_record_decl =
           qual_type->getAsCXXRecordDecl();
       if (cxx_record_decl) {
uint32_t TypeSystemClang::GetNumPointeeChildren(clang::QualType type) {
   return 0;
 }
 
 CompilerType TypeSystemClang::GetChildCompilerTypeAtIndex(
     lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, size_t idx,
     bool transparent_pointers, bool omit_empty_base_classes,
     bool ignore_array_bounds, std::string &child_name,
     uint32_t &child_byte_size, int32_t &child_byte_offset,
-    uint32_t &child_bitfield_bit_size, uint32_t &child_bitfield_bit_offset,
+    uint32_t &child_bitfield_bit_size, int32_t &child_bitfield_bit_offset,
     bool &child_is_base_class, bool &child_is_deref_of_parent,
     ValueObject *valobj, uint64_t &language_flags) {
   if (!type)
     return CompilerType();
 
   auto get_exe_scope = [&exe_ctx]() {
     return exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr;
   };
if (idx_is_valid && GetCompleteType(type)) {
           child_byte_size = *size;
           const uint32_t child_bit_size = child_byte_size * 8;
 
           // Figure out the field offset within the current struct/union/class
           // type
           bit_offset = record_layout.getFieldOffset(field_idx);
           if (FieldIsBitfield(*field, child_bitfield_bit_size)) {
             child_bitfield_bit_offset = bit_offset % child_bit_size;
-            const uint32_t child_bit_offset =
+            const int32_t child_bit_offset =
                 bit_offset - child_bitfield_bit_offset;
             child_byte_offset = child_bit_offset / 8;
           } else {
             child_byte_offset = bit_offset / 8;
           }
 
           return field_clang_type;
         }
GetCanonicalQualType(full_type.GetOpaqueQualType())
         .dump(s.AsRawOstream(), getASTContext());
   }
 }
 
 void TypeSystemClang::DumpValue(
     lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
     lldb::Format format, const lldb_private::DataExtractor &data,
     lldb::offset_t data_byte_offset, size_t data_byte_size,
-    uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types,
+    uint32_t bitfield_bit_size, int32_t bitfield_bit_offset, bool show_types,
     bool show_summary, bool verbose, uint32_t depth) {
   if (!type)
     return;
 
   clang::QualType qual_type(GetQualType(type));
   switch (qual_type->getTypeClass()) {
   case clang::Type::Record:
     if (GetCompleteType(type)) {
       const clang::RecordType *record_type =
           llvm::cast<clang::RecordType>(qual_type.getTypePtr());
       const clang::RecordDecl *record_decl = record_type->getDecl();
       assert(record_decl);
-      uint32_t field_bit_offset = 0;
-      uint32_t field_byte_offset = 0;
+      int32_t field_bit_offset = 0;
+      int32_t field_byte_offset = 0;
       const clang::ASTRecordLayout &record_layout =
           getASTContext().getASTRecordLayout(record_decl);
       uint32_t child_idx = 0;
 
       const clang::CXXRecordDecl *cxx_record_decl =
           llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
       if (cxx_record_decl) {
         // We might have base classes to print out first
if (GetCompleteType(type)) {
         clang::TypeInfo field_type_info =
             getASTContext().getTypeInfo(field_type);
         assert(field_idx < record_layout.getFieldCount());
         // Figure out the field offset within the current struct/union/class
         // type
         field_bit_offset = record_layout.getFieldOffset(field_idx);
         field_byte_offset = field_bit_offset / 8;
         uint32_t field_bitfield_bit_size = 0;
-        uint32_t field_bitfield_bit_offset = 0;
+        int32_t field_bitfield_bit_offset = 0;
         if (FieldIsBitfield(*field, field_bitfield_bit_size))
           field_bitfield_bit_offset = field_bit_offset % 8;
 
         if (show_types) {
           std::string field_type_name(field_type.getAsString());
           if (field_bitfield_bit_size > 0)
             s->Printf("(%s:%u) ", field_type_name.c_str(),
                       field_bitfield_bit_size);
default:
     if (show_summary)
       DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size);
     break;
   }
 }
 
 static bool DumpEnumValue(const clang::QualType &qual_type, Stream *s,
                           const DataExtractor &data, lldb::offset_t byte_offset,
-                          size_t byte_size, uint32_t bitfield_bit_offset,
+                          size_t byte_size, int32_t bitfield_bit_offset,
                           uint32_t bitfield_bit_size) {
   const clang::EnumType *enutype =
       llvm::cast<clang::EnumType>(qual_type.getTypePtr());
   const clang::EnumDecl *enum_decl = enutype->getDecl();
   assert(enum_decl);
   lldb::offset_t offset = byte_offset;
   const uint64_t enum_svalue = data.GetMaxS64Bitfield(
       &offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
if (remaining_value)
     s->Printf("0x%" PRIx64, remaining_value);
 
   return true;
 }
 
 bool TypeSystemClang::DumpTypeValue(
     lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format,
     const lldb_private::DataExtractor &data, lldb::offset_t byte_offset,
-    size_t byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
+    size_t byte_size, uint32_t bitfield_bit_size, int32_t bitfield_bit_offset,
     ExecutionContextScope *exe_scope) {
   if (!type)
     return false;
   if (IsAggregateType(type)) {
     return false;
   } else {
     clang::QualType qual_type(GetQualType(type));
 

lldb/source/Symbol/CompilerType.cpp

 
 uint32_t CompilerType::GetNumFields() const {
   if (!IsValid())
     return 0;
   return m_type_system->GetNumFields(m_type);
 }
 
 CompilerType CompilerType::GetFieldAtIndex(size_t idx, std::string &name,
-                                           uint64_t *bit_offset_ptr,
+                                           int64_t *bit_offset_ptr,
                                            uint32_t *bitfield_bit_size_ptr,
                                            bool *is_bitfield_ptr) const {
   if (!IsValid())
     return CompilerType();
   return m_type_system->GetFieldAtIndex(m_type, idx, name, bit_offset_ptr,
                                         bitfield_bit_size_ptr, is_bitfield_ptr);
 }
 
 uint32_t CompilerType::GetNumDirectBaseClasses() const {
   if (IsValid())
     return m_type_system->GetNumDirectBaseClasses(m_type);
   return 0;
 }
 
 uint32_t CompilerType::GetNumVirtualBaseClasses() const {
   if (IsValid())
     return m_type_system->GetNumVirtualBaseClasses(m_type);
   return 0;
 }
 
 CompilerType
 CompilerType::GetDirectBaseClassAtIndex(size_t idx,
-                                        uint32_t *bit_offset_ptr) const {
+                                        int32_t *bit_offset_ptr) const {
   if (IsValid())
     return m_type_system->GetDirectBaseClassAtIndex(m_type, idx,
                                                     bit_offset_ptr);
   return CompilerType();
 }
 
 CompilerType
 CompilerType::GetVirtualBaseClassAtIndex(size_t idx,
-                                         uint32_t *bit_offset_ptr) const {
+                                         int32_t *bit_offset_ptr) const {
   if (IsValid())
     return m_type_system->GetVirtualBaseClassAtIndex(m_type, idx,
                                                      bit_offset_ptr);
   return CompilerType();
 }
 
 uint32_t CompilerType::GetIndexOfFieldWithName(
     const char *name, CompilerType *field_compiler_type_ptr,
-    uint64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr,
+    int64_t *bit_offset_ptr, uint32_t *bitfield_bit_size_ptr,
     bool *is_bitfield_ptr) const {
   unsigned count = GetNumFields();
   std::string field_name;
   for (unsigned index = 0; index < count; index++) {
     CompilerType field_compiler_type(
         GetFieldAtIndex(index, field_name, bit_offset_ptr,
                         bitfield_bit_size_ptr, is_bitfield_ptr));
     if (strcmp(field_name.c_str(), name) == 0) {
       if (field_compiler_type_ptr)
         *field_compiler_type_ptr = field_compiler_type;
       return index;
     }
   }
   return UINT32_MAX;
 }
 
 CompilerType CompilerType::GetChildCompilerTypeAtIndex(
     ExecutionContext *exe_ctx, size_t idx, bool transparent_pointers,
     bool omit_empty_base_classes, bool ignore_array_bounds,
     std::string &child_name, uint32_t &child_byte_size,
     int32_t &child_byte_offset, uint32_t &child_bitfield_bit_size,
-    uint32_t &child_bitfield_bit_offset, bool &child_is_base_class,
+    int32_t &child_bitfield_bit_offset, bool &child_is_base_class,
     bool &child_is_deref_of_parent, ValueObject *valobj,
     uint64_t &language_flags) const {
   if (!IsValid())
     return CompilerType();
   return m_type_system->GetChildCompilerTypeAtIndex(
       m_type, exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
       ignore_array_bounds, child_name, child_byte_size, child_byte_offset,
       child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,

 }
 
 // Dumping types
 
 void CompilerType::DumpValue(ExecutionContext *exe_ctx, Stream *s,
                              lldb::Format format, const DataExtractor &data,
                              lldb::offset_t data_byte_offset,
                              size_t data_byte_size, uint32_t bitfield_bit_size,
-                             uint32_t bitfield_bit_offset, bool show_types,
+                             int32_t bitfield_bit_offset, bool show_types,
                              bool show_summary, bool verbose, uint32_t depth) {
   if (!IsValid())
     return;
   m_type_system->DumpValue(m_type, exe_ctx, s, format, data, data_byte_offset,
                            data_byte_size, bitfield_bit_size,
                            bitfield_bit_offset, show_types, show_summary,
                            verbose, depth);
 }
 
 bool CompilerType::DumpTypeValue(Stream *s, lldb::Format format,
                                  const DataExtractor &data,
                                  lldb::offset_t byte_offset, size_t byte_size,
                                  uint32_t bitfield_bit_size,
-                                 uint32_t bitfield_bit_offset,
+                                 int32_t bitfield_bit_offset,
                                  ExecutionContextScope *exe_scope) {
   if (!IsValid())
     return false;
   return m_type_system->DumpTypeValue(m_type, s, format, data, byte_offset,
                                       byte_size, bitfield_bit_size,
                                       bitfield_bit_offset, exe_scope);
 }
 

lldb/source/Utility/DataExtractor.cpp

 
 int64_t DataExtractor::GetMaxS64(offset_t *offset_ptr, size_t byte_size) const {
   uint64_t u64 = GetMaxU64(offset_ptr, byte_size);
   return llvm::SignExtend64(u64, 8 * byte_size);
 }
 
 uint64_t DataExtractor::GetMaxU64Bitfield(offset_t *offset_ptr, size_t size,
                                           uint32_t bitfield_bit_size,
-                                          uint32_t bitfield_bit_offset) const {
+                                          int32_t bitfield_bit_offset) const {
   assert(bitfield_bit_size <= 64);
   uint64_t uval64 = GetMaxU64(offset_ptr, size);
 
   if (bitfield_bit_size == 0)
     return uval64;
 
   int32_t lsbcount = bitfield_bit_offset;
   if (m_byte_order == eByteOrderBig)
     lsbcount = size * 8 - bitfield_bit_offset - bitfield_bit_size;
 
-  if (lsbcount > 0)
+  if (lsbcount > 0) {
     uval64 >>= lsbcount;
+  } else {
+    uval64 <<= -lsbcount;
+  }
 
   uint64_t bitfield_mask =
       (bitfield_bit_size == 64
            ? std::numeric_limits<uint64_t>::max()
            : ((static_cast<uint64_t>(1) << bitfield_bit_size) - 1));
   if (!bitfield_mask && bitfield_bit_offset == 0 && bitfield_bit_size == 64)
     return uval64;
 
   uval64 &= bitfield_mask;
 
   return uval64;
 }
 
 int64_t DataExtractor::GetMaxS64Bitfield(offset_t *offset_ptr, size_t size,
                                          uint32_t bitfield_bit_size,
-                                         uint32_t bitfield_bit_offset) const {
+                                         int32_t bitfield_bit_offset) const {
   assert(size >= 1 && "GetMaxS64Bitfield size must be >= 1");
   assert(size <= 8 && "GetMaxS64Bitfield size must be <= 8");
   int64_t sval64 = GetMaxS64(offset_ptr, size);
   if (bitfield_bit_size == 0)
     return sval64;
   int32_t lsbcount = bitfield_bit_offset;
   if (m_byte_order == eByteOrderBig)
     lsbcount = size * 8 - bitfield_bit_offset - bitfield_bit_size;

lldb/test/API/commands/expression/expr-bitfield-on-boundary/Makefile

+CXX_SOURCES := main.cpp
+
+CXXFLAGS_EXTRAS := -gdwarf-2
+
+include Makefile.rules

lldb/test/API/commands/expression/expr-bitfield-on-boundary/TestExprBitfieldOnBoundary.py

+"""Test that we are able to print bitfield fields that cross a byte boundary"""
+
+import lldb
+from lldbsuite.test.lldbtest import *
+
+class  BitFieldExprOnBoundaryTestCase(TestBase):
+
+    def test_bitfield_expr_on_boundary(self):
+        """ Test that we are able to print bitfield fields that cross a byte boundary """
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, '// Break here', lldb.SBFileSpec("main.cpp"))
+        self.expect_expr("f", result_type="volatile Foo", result_children=[ValueCheck(name='a', value=r"'\x01'"), ValueCheck(name='b', value=r"'\x02'")])

lldb/test/API/commands/expression/expr-bitfield-on-boundary/main.cpp

+struct __attribute__((packed)) Foo {
+  unsigned char a : 7;
+  unsigned char b : 4;
+};
+
+int main() {
+  volatile struct Foo f;
+  f.a = 1;
+  f.b = 2;
+  return 0; // Break here
+}

lldb/unittests/Platform/PlatformSiginfoTest.cpp

void ExpectField(const CompilerType &siginfo_type, field_tuple field) {
     const char *path;
     uint64_t offset, size;
     std::tie(path, offset, size) = field;
 
     SCOPED_TRACE(path);
     CompilerType field_type = siginfo_type;
     uint64_t total_offset = 0;
     for (auto field_name : llvm::split(path, '.')) {
-      uint64_t bit_offset;
+      int64_t bit_offset;
       ASSERT_NE(field_type.GetIndexOfFieldWithName(field_name.str().c_str(),
                                                    &field_type, &bit_offset),
                 UINT32_MAX);
       total_offset += bit_offset;
     }
 
     EXPECT_EQ(total_offset, offset * 8);
     EXPECT_EQ(field_type.GetByteSize(nullptr), llvm::Optional<uint64_t>(size));