[LLDB] Add GetByteOffset to SBValue interface for reading register offset

[omjavaid]

Summary

This patch adds GetByteOffset to SBValue interface for accessing register offset from register infos. This was needed to write tests to verify that AArch64 register sizes and offsets are updated when a thread updates vector granule register vg. A follow up test will make use of this API to test LLDB SVE register in multithreaded mode with dynamic update of size and offset.

[omjavaid]

@labath ping!

[labath]

The new API looks fairly confusing. This doesn't sound like something that the SB users should generally know or care about. What would the GetByteOffset function return in the generic case?
I don't find the explanation in the summary convincing. Presumably, you should be able to verify the proper behavior by checking the data (and its size) that the SBValue object holds. If that returns the right thing, who cares about the value of the offset field?

[omjavaid]

In D82865#2225978, @labath wrote:

The new API looks fairly confusing. This doesn't sound like something that the SB users should generally know or care about. What would the GetByteOffset function return in the generic case?
I don't find the explanation in the summary convincing. Presumably, you should be able to verify the proper behavior by checking the data (and its size) that the SBValue object holds. If that returns the right thing, who cares about the value of the offset field?

This was something which helped during development so I thought about implementing tests based on this but as you highlighted I wasnt sure if there is a proper client for this API function. I am gonna abandon this change and have updated test implementation removed dependence on GetByteOffset.

[labath]

Sounds good. FWIW, I wouldn't be opposed to some CLI command which would dump some low-level details of the register context, similar to how we have the "target modules dump" command tree for Module objects...

lldb/bindings/interface/SBValue.i

public:
     GetTypeName ();
 
     const char *
     GetDisplayTypeName ();
 
     size_t
     GetByteSize ();
 
+    size_t
+    GetByteOffset ();
+
     bool
     IsInScope ();
 
     lldb::Format
     GetFormat ();
 
     void
     SetFormat (lldb::Format format);

lldb/include/lldb/API/SBValue.h

public:
   const char *GetName();
 
   const char *GetTypeName();
 
   const char *GetDisplayTypeName();
 
   size_t GetByteSize();
 
+  size_t GetByteOffset();
+
   bool IsInScope();
 
   lldb::Format GetFormat();
 
   void SetFormat(lldb::Format format);
 
   const char *GetValue();
 

lldb/include/lldb/Core/ValueObjectRegister.h

public:
   ~ValueObjectRegister() override;
 
   static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
                                     lldb::RegisterContextSP &reg_ctx_sp,
                                     uint32_t reg_num);
 
   uint64_t GetByteSize() override;
 
+  uint64_t GetByteOffset() override;
+
   lldb::ValueType GetValueType() const override {
     return lldb::eValueTypeRegister;
   }
 
   ConstString GetTypeName() override;
 
   size_t CalculateNumChildren(uint32_t max) override;
 

lldb/include/lldb/Core/ValueObjectSyntheticFilter.h

 // you can bind it to any source of synthetic information and have it behave
 // accordingly
 class ValueObjectSynthetic : public ValueObject {
 public:
   ~ValueObjectSynthetic() override;
 
   uint64_t GetByteSize() override;
 
+  uint64_t GetByteOffset() override;
+
   ConstString GetTypeName() override;
 
   ConstString GetQualifiedTypeName() override;
 
   ConstString GetDisplayTypeName() override;
 
   bool MightHaveChildren() override;
 

lldb/source/API/SBValue.cpp

size_t SBValue::GetByteSize() {
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     result = value_sp->GetByteSize();
   }
 
   return result;
 }
 
+size_t SBValue::GetByteOffset() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBValue, GetByteOffset);
+
+  size_t result = 0;
+
+  ValueLocker locker;
+  lldb::ValueObjectSP value_sp(GetSP(locker));
+  if (value_sp) {
+    result = value_sp->GetByteOffset();
+  }
+
+  return result;
+}
+
 bool SBValue::IsInScope() {
   LLDB_RECORD_METHOD_NO_ARGS(bool, SBValue, IsInScope);
 
   bool result = false;
 
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {

lldb/source/Core/ValueObjectRegister.cpp

 size_t ValueObjectRegister::CalculateNumChildren(uint32_t max) {
   ExecutionContext exe_ctx(GetExecutionContextRef());
   auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
   return children_count <= max ? children_count : max;
 }
 
 uint64_t ValueObjectRegister::GetByteSize() { return m_reg_info.byte_size; }
 
+uint64_t ValueObjectRegister::GetByteOffset() { return m_reg_info.byte_offset; }
+
 bool ValueObjectRegister::UpdateValue() {
   m_error.Clear();
   ExecutionContext exe_ctx(GetExecutionContextRef());
   StackFrame *frame = exe_ctx.GetFramePtr();
   if (frame == nullptr) {
     m_reg_ctx_sp.reset();
     m_reg_value.Clear();
   }

lldb/source/Core/ValueObjectSyntheticFilter.cpp

bool ValueObjectSynthetic::MightHaveChildren() {
   if (m_might_have_children == eLazyBoolCalculate)
     m_might_have_children =
         (m_synth_filter_up->MightHaveChildren() ? eLazyBoolYes : eLazyBoolNo);
   return (m_might_have_children != eLazyBoolNo);
 }
 
 uint64_t ValueObjectSynthetic::GetByteSize() { return m_parent->GetByteSize(); }
 
+uint64_t ValueObjectSynthetic::GetByteOffset() {
+  return m_parent->GetByteOffset();
+}
+
 lldb::ValueType ValueObjectSynthetic::GetValueType() const {
   return m_parent->GetValueType();
 }
 
 void ValueObjectSynthetic::CreateSynthFilter() {
   ValueObject *valobj_for_frontend = m_parent;
   if (m_synth_sp->WantsDereference())
   {