[lldb][NFC] Pass a ValueObject to DumpTypeValue instead of bitfield size/offset pair

[teemperor]

Summary

This makes calling DumpTypeValue less tricky as it's not possible to mix up the size/offset
parameters. Also allows us to drop downstream swift patches that try to pass even more
ValueObject members as separate parameters to this function.

lldb/include/lldb/Symbol/ClangASTContext.h

void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
                  lldb::offset_t data_offset, size_t data_byte_size,
                  uint32_t bitfield_bit_size, uint32_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,
+                     ValueObject &value_object,
                      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) override; // Dump to stdout

lldb/include/lldb/Symbol/CompilerType.h

#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,
                  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,
+                     ValueObject &value_object,
                      ExecutionContextScope *exe_scope);
 
   void DumpSummary(ExecutionContext *exe_ctx, Stream *s,
                    const DataExtractor &data, lldb::offset_t data_offset,
                    size_t data_byte_size);
 
   void DumpTypeDescription() const; // Dump to stdout
 

lldb/include/lldb/Symbol/TypeSystem.h

virtual void DumpValue(lldb::opaque_compiler_type_t type,
                          lldb::offset_t data_offset, size_t data_byte_size,
                          uint32_t bitfield_bit_size,
                          uint32_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,
+                             ValueObject &value_object,
                              ExecutionContextScope *exe_scope) = 0;
 
   virtual void
   DumpTypeDescription(lldb::opaque_compiler_type_t type) = 0; // Dump to stdout
 
   virtual void DumpTypeDescription(lldb::opaque_compiler_type_t type,
                                    Stream *s) = 0;
 

lldb/source/DataFormatters/TypeFormat.cpp

if (context_type == Value::eContextTypeRegisterInfo) {
 
         ExecutionContextScope *exe_scope =
             exe_ctx.GetBestExecutionContextScope();
         llvm::Optional<uint64_t> size = compiler_type.GetByteSize(exe_scope);
         if (!size)
           return false;
         StreamString sstr;
         compiler_type.DumpTypeValue(
-            &sstr,                          // The stream to use for display
-            GetFormat(),                    // Format to display this type with
-            data,                           // Data to extract from
-            0,                              // Byte offset into "m_data"
-            *size,                          // Byte size of item in "m_data"
-            valobj->GetBitfieldBitSize(),   // Bitfield bit size
-            valobj->GetBitfieldBitOffset(), // Bitfield bit offset
-            exe_scope);
+            &sstr,       // The stream to use for display
+            GetFormat(), // Format to display this type with
+            data,        // Data to extract from
+            0,           // Byte offset into "m_data"
+            *size,       // Byte size of item in "m_data"
+            *valobj, exe_scope);
         // Given that we do not want to set the ValueObject's m_error for a
         // formatting error (or else we wouldn't be able to reformat until a
         // next update), an empty string is treated as a "false" return from
         // here, but that's about as severe as we get
         // CompilerType::DumpTypeValue() should always return something, even
         // if that something is an error message
         dest = sstr.GetString();
       }
if (!valobj_enum_type.IsValid())
     return false;
   DataExtractor data;
   Status error;
   valobj->GetData(data, error);
   if (error.Fail())
     return false;
   ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
   StreamString sstr;
+  assert(valobj->GetBitfieldBitSize() == 0);
+  assert(valobj->GetBitfieldBitOffset() == 0);
   valobj_enum_type.DumpTypeValue(&sstr, lldb::eFormatEnum, data, 0,
-                                 data.GetByteSize(), 0, 0,
+                                 data.GetByteSize(), *valobj,
                                  exe_ctx.GetBestExecutionContextScope());
   if (!sstr.GetString().empty())
     dest = sstr.GetString();
   return !dest.empty();
 }
 
 std::string TypeFormatImpl_EnumType::GetDescription() {
   StreamString sstr;
   sstr.Printf("as type %s%s%s%s", m_enum_type.AsCString("<invalid type>"),
               Cascades() ? "" : " (not cascading)",
               SkipsPointers() ? " (skip pointers)" : "",
               SkipsReferences() ? " (skip references)" : "");
   return sstr.GetString();
 }

lldb/source/Symbol/ClangASTContext.cpp

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,
-                          uint32_t bitfield_bit_size) {
+                          size_t byte_size, ValueObject &value_object) {
   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);
+      &offset, byte_size, value_object.GetBitfieldBitSize(),
+      value_object.GetBitfieldBitOffset());
   bool can_be_bitfield = true;
   uint64_t covered_bits = 0;
   int num_enumerators = 0;
 
   // Try to find an exact match for the value.
   // At the same time, we're applying a heuristic to determine whether we want
   // to print this enum as a bitfield. We're likely dealing with a bitfield if
   // every enumrator is either a one bit value or a superset of the previous
static bool DumpEnumValue(const clang::QualType &qual_type, Stream *s,
 
   // If there is a remainder that is not covered by the value, print it as hex.
   if (remaining_value)
     s->Printf("0x%" PRIx64, remaining_value);
 
   return true;
 }
 
-bool ClangASTContext::DumpTypeValue(
-    lldb::opaque_compiler_type_t type, 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,
+bool ClangASTContext::DumpTypeValue(lldb::opaque_compiler_type_t type,
+                                    Stream *s, lldb::Format format,
+                                    const DataExtractor &data,
+                                    lldb::offset_t byte_offset,
+                                    size_t byte_size, ValueObject &value_object,
                                     ExecutionContextScope *exe_scope) {
   if (!type)
     return false;
   if (IsAggregateType(type)) {
     return false;
   } else {
     clang::QualType qual_type(GetQualType(type));
 
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
 
     if (type_class == clang::Type::Elaborated) {
       qual_type = llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType();
-      return DumpTypeValue(qual_type.getAsOpaquePtr(), s, format, data, byte_offset, byte_size,
-                           bitfield_bit_size, bitfield_bit_offset, exe_scope);
+      return DumpTypeValue(qual_type.getAsOpaquePtr(), s, format, data,
+                           byte_offset, byte_size, value_object, exe_scope);
     }
 
     switch (type_class) {
     case clang::Type::Typedef: {
       clang::QualType typedef_qual_type =
           llvm::cast<clang::TypedefType>(qual_type)
               ->getDecl()
               ->getUnderlyingType();
       CompilerType typedef_clang_type(this, typedef_qual_type.getAsOpaquePtr());
       if (format == eFormatDefault)
         format = typedef_clang_type.GetFormat();
       clang::TypeInfo typedef_type_info =
           getASTContext()->getTypeInfo(typedef_qual_type);
       uint64_t typedef_byte_size = typedef_type_info.Width / 8;
 
       return typedef_clang_type.DumpTypeValue(
           s,
           format,            // The format with which to display the element
           data,              // Data buffer containing all bytes for this type
           byte_offset,       // Offset into "data" where to grab value from
           typedef_byte_size, // Size of this type in bytes
-          bitfield_bit_size, // Size in bits of a bitfield value, if zero don't
-                             // treat as a bitfield
-          bitfield_bit_offset, // Offset in bits of a bitfield value if
-                               // bitfield_bit_size != 0
-          exe_scope);
+          value_object, exe_scope);
     } break;
 
     case clang::Type::Enum:
       // If our format is enum or default, show the enumeration value as its
       // enumeration string value, else just display it as requested.
       if ((format == eFormatEnum || format == eFormatDefault) &&
           GetCompleteType(type))
         return DumpEnumValue(qual_type, s, data, byte_offset, byte_size,
-                             bitfield_bit_offset, bitfield_bit_size);
+                             value_object.GetBitfieldBitOffset(),
+                             value_object.GetBitfieldBitSize());
       // format was not enum, just fall through and dump the value as
       // requested....
       LLVM_FALLTHROUGH;
 
     default:
       // We are down to a scalar type that we just need to display.
       {
         uint32_t item_count = 1;
default:
           byte_size = 2;
           break;
 
         case eFormatUnicode32:
           item_count = byte_size / 4;
           byte_size = 4;
           break;
         }
-        return DumpDataExtractor(data, s, byte_offset, format, byte_size,
-                                 item_count, UINT32_MAX, LLDB_INVALID_ADDRESS,
-                                 bitfield_bit_size, bitfield_bit_offset,
-                                 exe_scope);
+        return DumpDataExtractor(
+            data, s, byte_offset, format, byte_size, item_count, UINT32_MAX,
+            LLDB_INVALID_ADDRESS, value_object.GetBitfieldBitSize(),
+            value_object.GetBitfieldBitOffset(), exe_scope);
       }
       break;
     }
   }
   return false;
 }
 
 void ClangASTContext::DumpSummary(lldb::opaque_compiler_type_t type,

lldb/source/Symbol/CompilerType.cpp

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,
+                                 ValueObject &value_object,
                                  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);
+                                      byte_size, value_object, exe_scope);
 }
 
 void CompilerType::DumpSummary(ExecutionContext *exe_ctx, Stream *s,
                                const DataExtractor &data,
                                lldb::offset_t data_byte_offset,
                                size_t data_byte_size) {
   if (IsValid())
     m_type_system->DumpSummary(m_type, exe_ctx, s, data, data_byte_offset,