Unify the return value of GetByteSize to an llvm::Optional<uint64_t> (NFC-ish)

[aprantl]

Summary

This cleanup patch unifies all methods called GetByteSize in the ValueObject hierarchy to return an optional, like the methods in CompilerType do. This means fewer magic 0 values, which could fix bugs down the road in languages where types can have a size of zero, such as Swift and C (but not C++).

[aprantl]

lldb/source/Target/StackFrame.cpp

1445

Yeah, I know.

[shafik]

LGTM

lldb/source/Expression/Materializer.cpp

283–284

Why does this need a cast?

lldb/include/lldb/Core/ValueObject.h

public:
   CompilerType GetCompilerType();
 
   // this vends a TypeImpl that is useful at the SB API layer
   virtual TypeImpl GetTypeImpl();
 
   virtual bool CanProvideValue();
 
   // Subclasses must implement the functions below.
-  virtual uint64_t GetByteSize() = 0;
+  virtual llvm::Optional<uint64_t> GetByteSize() = 0;
 
   virtual lldb::ValueType GetValueType() const = 0;
 
   // Subclasses can implement the functions below.
   virtual ConstString GetTypeName();
 
   virtual ConstString GetDisplayTypeName();
 

lldb/include/lldb/Core/ValueObjectCast.h

 class ValueObjectCast : public ValueObject {
 public:
   ~ValueObjectCast() override;
 
   static lldb::ValueObjectSP Create(ValueObject &parent,
                                     ConstString name,
                                     const CompilerType &cast_type);
 
-  uint64_t GetByteSize() override;
+  llvm::Optional<uint64_t> GetByteSize() override;
 
   size_t CalculateNumChildren(uint32_t max) override;
 
   lldb::ValueType GetValueType() const override;
 
   bool IsInScope() override;
 
   ValueObject *GetParent() override {

lldb/include/lldb/Core/ValueObjectChild.h

 
 namespace lldb_private {
 
 // A child of another ValueObject.
 class ValueObjectChild : public ValueObject {
 public:
   ~ValueObjectChild() override;
 
-  uint64_t GetByteSize() override { return m_byte_size; }
+  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; }
 
   lldb::ValueType GetValueType() const override;

lldb/include/lldb/Core/ValueObjectConstResult.h

public:
   static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
                                     Value &value, ConstString name,
                                     Module *module = nullptr);
 
   // When an expression fails to evaluate, we return an error
   static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
                                     const Status &error);
 
-  uint64_t GetByteSize() override;
+  llvm::Optional<uint64_t> GetByteSize() override;
 
   lldb::ValueType GetValueType() const override;
 
   size_t CalculateNumChildren(uint32_t max) override;
 
   ConstString GetTypeName() override;
 
   ConstString GetDisplayTypeName() override;
public:
   lldb::ValueObjectSP Cast(const CompilerType &compiler_type) override;
 
 protected:
   bool UpdateValue() override;
 
   CompilerType GetCompilerTypeImpl() override;
 
   ConstString m_type_name;
-  uint64_t m_byte_size;
+  llvm::Optional<uint64_t> m_byte_size;
 
   ValueObjectConstResultImpl m_impl;
 
 private:
   friend class ValueObjectConstResultImpl;
 
   ValueObjectConstResult(ExecutionContextScope *exe_scope,
                          ValueObjectManager &manager,

lldb/include/lldb/Core/ValueObjectDynamicValue.h

 class Status;
 
 // A ValueObject that represents memory at a given address, viewed as some
 // set lldb type.
 class ValueObjectDynamicValue : public ValueObject {
 public:
   ~ValueObjectDynamicValue() override;
 
-  uint64_t GetByteSize() override;
+  llvm::Optional<uint64_t> GetByteSize() override;
 
   ConstString GetTypeName() override;
 
   ConstString GetQualifiedTypeName() override;
 
   ConstString GetDisplayTypeName() override;
 
   size_t CalculateNumChildren(uint32_t max) override;

lldb/include/lldb/Core/ValueObjectMemory.h

static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
                                     const Address &address,
                                     lldb::TypeSP &type_sp);
 
   static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
                                     llvm::StringRef name,
                                     const Address &address,
                                     const CompilerType &ast_type);
 
-  uint64_t GetByteSize() override;
+  llvm::Optional<uint64_t> GetByteSize() override;
 
   ConstString GetTypeName() override;
 
   ConstString GetDisplayTypeName() override;
 
   size_t CalculateNumChildren(uint32_t max) override;
 
   lldb::ValueType GetValueType() const override;

lldb/include/lldb/Core/ValueObjectRegister.h

 class ValueObjectRegisterSet : public ValueObject {
 public:
   ~ValueObjectRegisterSet() override;
 
   static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
                                     lldb::RegisterContextSP &reg_ctx_sp,
                                     uint32_t set_idx);
 
-  uint64_t GetByteSize() override;
+  llvm::Optional<uint64_t> GetByteSize() override;
 
   lldb::ValueType GetValueType() const override {
     return lldb::eValueTypeRegisterSet;
   }
 
   ConstString GetTypeName() override;
 
   ConstString GetQualifiedTypeName() override;

 class ValueObjectRegister : public ValueObject {
 public:
   ~ValueObjectRegister() override;
 
   static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
                                     lldb::RegisterContextSP &reg_ctx_sp,
                                     uint32_t reg_num);
 
-  uint64_t GetByteSize() override;
+  llvm::Optional<uint64_t> GetByteSize() 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

 // real information
 // This is currently used to implement Python-based children and filters but
 // 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;
+  llvm::Optional<uint64_t> GetByteSize() override;
 
   ConstString GetTypeName() override;
 
   ConstString GetQualifiedTypeName() override;
 
   ConstString GetDisplayTypeName() override;
 
   bool MightHaveChildren() override;

lldb/include/lldb/Core/ValueObjectVariable.h

 // have children.
 class ValueObjectVariable : public ValueObject {
 public:
   ~ValueObjectVariable() override;
 
   static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
                                     const lldb::VariableSP &var_sp);
 
-  uint64_t GetByteSize() override;
+  llvm::Optional<uint64_t> GetByteSize() override;
 
   ConstString GetTypeName() override;
 
   ConstString GetQualifiedTypeName() override;
 
   ConstString GetDisplayTypeName() override;
 
   size_t CalculateNumChildren(uint32_t max) override;

lldb/include/lldb/Expression/ExpressionVariable.h

public:
   enum LLVMCastKind { eKindClang, eKindSwift, eKindGo, kNumKinds };
 
   LLVMCastKind getKind() const { return m_kind; }
 
   ExpressionVariable(LLVMCastKind kind) : m_flags(0), m_kind(kind) {}
 
   virtual ~ExpressionVariable();
 
-  size_t GetByteSize() { return m_frozen_sp->GetByteSize(); }
+  llvm::Optional<uint64_t> GetByteSize() { return m_frozen_sp->GetByteSize(); }
 
   ConstString GetName() { return m_frozen_sp->GetName(); }
 
   lldb::ValueObjectSP GetValueObject() { return m_frozen_sp; }
 
   uint8_t *GetValueBytes();
 
   void ValueUpdated() { m_frozen_sp->ValueUpdated(); }

lldb/include/lldb/Target/StackFrameRecognizer.h

static lldb::ValueObjectSP Create(ValueObject &parent, lldb::ValueType type) {
     return (new ValueObjectRecognizerSynthesizedValue(parent, type))->GetSP();
   }
   ValueObjectRecognizerSynthesizedValue(ValueObject &parent,
                                         lldb::ValueType type)
       : ValueObject(parent), m_type(type) {
     SetName(parent.GetName());
   }
 
-  uint64_t GetByteSize() override { return m_parent->GetByteSize(); }
+  llvm::Optional<uint64_t> GetByteSize() override {
+    return m_parent->GetByteSize();
+  }
   lldb::ValueType GetValueType() const override { return m_type; }
   bool UpdateValue() override {
     if (!m_parent->UpdateValueIfNeeded()) return false;
     m_value = m_parent->GetValue();
     return true;
   }
   size_t CalculateNumChildren(uint32_t max = UINT32_MAX) override {
     return m_parent->GetNumChildren(max);

lldb/source/API/SBValue.cpp

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

lldb/source/Commands/CommandObjectWatchpoint.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
 
     if (valobj_sp) {
       AddressType addr_type;
       addr = valobj_sp->GetAddressOf(false, &addr_type);
       if (addr_type == eAddressTypeLoad) {
         // We're in business.
         // Find out the size of this variable.
         size = m_option_watchpoint.watch_size == 0
-                   ? valobj_sp->GetByteSize()
+                   ? valobj_sp->GetByteSize().getValueOr(0)
                    : m_option_watchpoint.watch_size;
       }
       compiler_type = valobj_sp->GetCompilerType();
     } else {
       const char *error_cstr = error.AsCString(nullptr);
       if (error_cstr)
         result.GetErrorStream().Printf("error: %s\n", error_cstr);
       else

lldb/source/Core/ValueObject.cpp

bool ValueObject::SetData(DataExtractor &data, Status &error) {
   if (!UpdateValueIfNeeded(false)) {
     error.SetErrorString("unable to read value");
     return false;
   }
 
   uint64_t count = 0;
   const Encoding encoding = GetCompilerType().GetEncoding(count);
 
-  const size_t byte_size = GetByteSize();
+  const size_t byte_size = GetByteSize().getValueOr(0);
 
   Value::ValueType value_type = m_value.GetValueType();
 
   switch (value_type) {
   case Value::eValueTypeScalar: {
     Status set_error =
         m_value.GetScalar().SetValueFromData(data, encoding, byte_size);
 
bool ValueObject::SetValueFromCString(const char *value_str, Status &error) {
   if (!UpdateValueIfNeeded(false)) {
     error.SetErrorString("unable to read value");
     return false;
   }
 
   uint64_t count = 0;
   const Encoding encoding = GetCompilerType().GetEncoding(count);
 
-  const size_t byte_size = GetByteSize();
+  const size_t byte_size = GetByteSize().getValueOr(0);
 
   Value::ValueType value_type = m_value.GetValueType();
 
   if (value_type == Value::eValueTypeScalar) {
     // If the value is already a scalar, then let the scalar change itself:
     m_value.GetScalar().SetValueFromCString(value_str, encoding, byte_size);
   } else if (byte_size <= 16) {
     // If the value fits in a scalar, then make a new scalar and again let the
if (IsScalarType()) {
     // Check if we have already created a synthetic array member in this valid
     // object. If we have we will re-use it.
     synthetic_child_sp = GetSyntheticChild(index_const_str);
     if (!synthetic_child_sp) {
       uint32_t bit_field_size = to - from + 1;
       uint32_t bit_field_offset = from;
       if (GetDataExtractor().GetByteOrder() == eByteOrderBig)
         bit_field_offset =
-            GetByteSize() * 8 - bit_field_size - bit_field_offset;
+            GetByteSize().getValueOr(0) * 8 - bit_field_size - bit_field_offset;
       // We haven't made a synthetic array member for INDEX yet, so lets make
       // one and cache it for any future reference.
       ValueObjectChild *synthetic_child = new ValueObjectChild(
-          *this, GetCompilerType(), index_const_str, GetByteSize(), 0,
-          bit_field_size, bit_field_offset, false, false, eAddressTypeInvalid,
-          0);
+          *this, GetCompilerType(), index_const_str,
+          GetByteSize().getValueOr(0), 0, bit_field_size, bit_field_offset,
+          false, false, eAddressTypeInvalid, 0);
 
       // Cache the value if we got one back...
       if (synthetic_child) {
         AddSyntheticChild(index_const_str, synthetic_child);
         synthetic_child_sp = synthetic_child->GetSP();
         synthetic_child_sp->SetName(ConstString(index_str));
         synthetic_child_sp->m_is_bitfield_for_scalar = true;
       }

lldb/source/Core/ValueObjectCast.cpp

 
 size_t ValueObjectCast::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 ValueObjectCast::GetByteSize() {
+llvm::Optional<uint64_t> ValueObjectCast::GetByteSize() {
   ExecutionContext exe_ctx(GetExecutionContextRef());
   return m_value.GetValueByteSize(nullptr, &exe_ctx);
 }
 
 lldb::ValueType ValueObjectCast::GetValueType() const {
   // Let our parent answer global, local, argument, etc...
   return m_parent->GetValueType();
 }

lldb/source/Core/ValueObjectConstResult.cpp

ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
                                              const Status &error) {
   auto manager_sp = ValueObjectManager::Create();
   return (new ValueObjectConstResult(exe_scope, *manager_sp, error))->GetSP();
 }
 
 ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
                                                ValueObjectManager &manager,
                                                const Status &error)
-    : ValueObject(exe_scope, manager), m_type_name(), m_byte_size(0),
-      m_impl(this) {
+    : ValueObject(exe_scope, manager), m_impl(this) {
   m_error = error;
   SetIsConstant();
 }
 
 ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
                                                ValueObjectManager &manager,
                                                const Value &value,
                                                ConstString name, Module *module)
-    : ValueObject(exe_scope, manager), m_type_name(), m_byte_size(0),
-      m_impl(this) {
+    : ValueObject(exe_scope, manager), m_impl(this) {
   m_value = value;
   m_name = name;
   ExecutionContext exe_ctx;
   exe_scope->CalculateExecutionContext(exe_ctx);
   m_error = m_value.GetValueAsData(&exe_ctx, m_data, module);
 }
 
 ValueObjectConstResult::~ValueObjectConstResult() {}
 
 CompilerType ValueObjectConstResult::GetCompilerTypeImpl() {
   return m_value.GetCompilerType();
 }
 
 lldb::ValueType ValueObjectConstResult::GetValueType() const {
   return eValueTypeConstResult;
 }
 
-uint64_t ValueObjectConstResult::GetByteSize() {
+llvm::Optional<uint64_t> ValueObjectConstResult::GetByteSize() {
   ExecutionContext exe_ctx(GetExecutionContextRef());
-  if (m_byte_size == 0) {
+  if (!m_byte_size) {
     if (auto size =
         GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope()))
       SetByteSize(*size);
   }
   return m_byte_size;
 }
 
 void ValueObjectConstResult::SetByteSize(size_t size) { m_byte_size = size; }

lldb/source/Core/ValueObjectDynamicValue.cpp

size_t ValueObjectDynamicValue::CalculateNumChildren(uint32_t max) {
   if (success && m_dynamic_type_info.HasType()) {
     ExecutionContext exe_ctx(GetExecutionContextRef());
     auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
     return children_count <= max ? children_count : max;
   } else
     return m_parent->GetNumChildren(max);
 }
 
-uint64_t ValueObjectDynamicValue::GetByteSize() {
+llvm::Optional<uint64_t> ValueObjectDynamicValue::GetByteSize() {
   const bool success = UpdateValueIfNeeded(false);
   if (success && m_dynamic_type_info.HasType()) {
     ExecutionContext exe_ctx(GetExecutionContextRef());
     return m_value.GetValueByteSize(nullptr, &exe_ctx);
   } else
     return m_parent->GetByteSize();
 }
 

lldb/source/Core/ValueObjectMemory.cpp

size_t ValueObjectMemory::CalculateNumChildren(uint32_t max) {
 
   ExecutionContext exe_ctx(GetExecutionContextRef());
   const bool omit_empty_base_classes = true;
   auto child_count =
       m_compiler_type.GetNumChildren(omit_empty_base_classes, &exe_ctx);
   return child_count <= max ? child_count : max;
 }
 
-uint64_t ValueObjectMemory::GetByteSize() {
+llvm::Optional<uint64_t> ValueObjectMemory::GetByteSize() {
   ExecutionContext exe_ctx(GetExecutionContextRef());
   if (m_type_sp)
-    return m_type_sp->GetByteSize(exe_ctx.GetBestExecutionContextScope())
-        .getValueOr(0);
-  return m_compiler_type.GetByteSize(exe_ctx.GetBestExecutionContextScope())
-      .getValueOr(0);
+    return m_type_sp->GetByteSize(exe_ctx.GetBestExecutionContextScope());
+  return m_compiler_type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
 }
 
 lldb::ValueType ValueObjectMemory::GetValueType() const {
   // RETHINK: Should this be inherited from somewhere?
   return lldb::eValueTypeVariableGlobal;
 }
 
 bool ValueObjectMemory::UpdateValue() {

lldb/source/Core/ValueObjectRegister.cpp

size_t ValueObjectRegisterSet::CalculateNumChildren(uint32_t max) {
   const RegisterSet *reg_set = m_reg_ctx_sp->GetRegisterSet(m_reg_set_idx);
   if (reg_set) {
     auto reg_count = reg_set->num_registers;
     return reg_count <= max ? reg_count : max;
   }
   return 0;
 }
 
-uint64_t ValueObjectRegisterSet::GetByteSize() { return 0; }
+llvm::Optional<uint64_t> ValueObjectRegisterSet::GetByteSize() { return 0; }
 
 bool ValueObjectRegisterSet::UpdateValue() {
   m_error.Clear();
   SetValueDidChange(false);
   ExecutionContext exe_ctx(GetExecutionContextRef());
   StackFrame *frame = exe_ctx.GetFramePtr();
   if (frame == nullptr)
     m_reg_ctx_sp.reset();

 }
 
 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; }
+llvm::Optional<uint64_t> ValueObjectRegister::GetByteSize() {
+  return m_reg_info.byte_size;
+}
 
 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(); }
+llvm::Optional<uint64_t> ValueObjectSynthetic::GetByteSize() {
+  return m_parent->GetByteSize();
+}
 
 lldb::ValueType ValueObjectSynthetic::GetValueType() const {
   return m_parent->GetValueType();
 }
 
 void ValueObjectSynthetic::CreateSynthFilter() {
   ValueObject *valobj_for_frontend = m_parent;
   if (m_synth_sp->WantsDereference())

lldb/source/Core/ValueObjectVariable.cpp

if (!type.IsValid())
     return 0;
 
   ExecutionContext exe_ctx(GetExecutionContextRef());
   const bool omit_empty_base_classes = true;
   auto child_count = type.GetNumChildren(omit_empty_base_classes, &exe_ctx);
   return child_count <= max ? child_count : max;
 }
 
-uint64_t ValueObjectVariable::GetByteSize() {
+llvm::Optional<uint64_t> ValueObjectVariable::GetByteSize() {
   ExecutionContext exe_ctx(GetExecutionContextRef());
 
   CompilerType type(GetCompilerType());
 
   if (!type.IsValid())
-    return 0;
+    return {};
 
-  return type.GetByteSize(exe_ctx.GetBestExecutionContextScope()).getValueOr(0);
+  return type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
 }
 
 lldb::ValueType ValueObjectVariable::GetValueType() const {
   if (m_variable_sp)
     return m_variable_sp->GetScope();
   return lldb::eValueTypeInvalid;
 }
 

lldb/source/Expression/ExpressionVariable.cpp

 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb_private;
 
 ExpressionVariable::~ExpressionVariable() {}
 
 uint8_t *ExpressionVariable::GetValueBytes() {
-  const size_t byte_size = m_frozen_sp->GetByteSize();
-  if (byte_size > 0) {
-    if (m_frozen_sp->GetDataExtractor().GetByteSize() < byte_size) {
-      m_frozen_sp->GetValue().ResizeData(byte_size);
+  llvm::Optional<uint64_t> byte_size = m_frozen_sp->GetByteSize();
+  if (byte_size && *byte_size) {
+    if (m_frozen_sp->GetDataExtractor().GetByteSize() < *byte_size) {
+      m_frozen_sp->GetValue().ResizeData(*byte_size);
       m_frozen_sp->GetValue().GetData(m_frozen_sp->GetDataExtractor());
     }
     return const_cast<uint8_t *>(
         m_frozen_sp->GetDataExtractor().GetDataStart());
   }
   return nullptr;
 }
 

lldb/source/Expression/Materializer.cpp

void MakeAllocation(IRMemoryMap &map, Status &err) {
 
     // Allocate a spare memory area to store the persistent variable's
     // contents.
 
     Status allocate_error;
     const bool zero_memory = false;
 
     lldb::addr_t mem = map.Malloc(
-        m_persistent_variable_sp->GetByteSize(), 8,
+        m_persistent_variable_sp->GetByteSize().getValueOr(0), 8,
         lldb::ePermissionsReadable | lldb::ePermissionsWritable,
         IRMemoryMap::eAllocationPolicyMirror, zero_memory, allocate_error);
 
     if (!allocate_error.Success()) {
       err.SetErrorStringWithFormat(
           "couldn't allocate a memory area to store %s: %s",
           m_persistent_variable_sp->GetName().GetCString(),
           allocate_error.AsCString());
if (m_persistent_variable_sp->m_flags &
           ~ExpressionVariable::EVNeedsAllocation;
     }
 
     // Write the contents of the variable to the area.
 
     Status write_error;
 
     map.WriteMemory(mem, m_persistent_variable_sp->GetValueBytes(),
-                    m_persistent_variable_sp->GetByteSize(), write_error);
+                    m_persistent_variable_sp->GetByteSize().getValueOr(0),
+                    write_error);
 
     if (!write_error.Success()) {
       err.SetErrorStringWithFormat(
           "couldn't write %s to the target: %s",
           m_persistent_variable_sp->GetName().AsCString(),
           write_error.AsCString());
       return;
     }
if ((m_persistent_variable_sp->m_flags &
               read_error.AsCString());
           return;
         }
 
         m_persistent_variable_sp->m_live_sp = ValueObjectConstResult::Create(
             map.GetBestExecutionContextScope(),
             m_persistent_variable_sp.get()->GetCompilerType(),
             m_persistent_variable_sp->GetName(), location, eAddressTypeLoad,
-            m_persistent_variable_sp->GetByteSize());
+            m_persistent_variable_sp->GetByteSize().getValueOr(0));
 
         if (frame_top != LLDB_INVALID_ADDRESS &&
             frame_bottom != LLDB_INVALID_ADDRESS && location >= frame_bottom &&
             location <= frame_top) {
           // If the variable is resident in the stack frame created by the
           // expression, then it cannot be relied upon to stay around.  We
           // treat it as needing reallocation.
           m_persistent_variable_sp->m_flags |=
if ((m_persistent_variable_sp->m_flags &
 
       if (m_persistent_variable_sp->m_flags &
               ExpressionVariable::EVNeedsFreezeDry ||
           m_persistent_variable_sp->m_flags &
               ExpressionVariable::EVKeepInTarget) {
         LLDB_LOGF(log, "Dematerializing %s from 0x%" PRIx64 " (size = %llu)",
                   m_persistent_variable_sp->GetName().GetCString(),
                   (uint64_t)mem,
-                  (unsigned long long)m_persistent_variable_sp->GetByteSize());
+                  (unsigned long long)m_persistent_variable_sp->GetByteSize()
+                      .getValueOr(0));
 
         // Read the contents of the spare memory area
 
         m_persistent_variable_sp->ValueUpdated();
 
         Status read_error;
 
         map.ReadMemory(m_persistent_variable_sp->GetValueBytes(), mem,
-                       m_persistent_variable_sp->GetByteSize(), read_error);
+                       m_persistent_variable_sp->GetByteSize().getValueOr(0), read_error);
 
         if (!read_error.Success()) {
           err.SetErrorStringWithFormat(
               "couldn't read the contents of %s from memory: %s",
               m_persistent_variable_sp->GetName().GetCString(),
               read_error.AsCString());
           return;
         }
dump_stream.Printf("0x%" PRIx64 ": EntityPersistentVariable (%s)\n",
 
       lldb::addr_t target_address;
 
       map.ReadPointerFromMemory(&target_address, load_addr, err);
 
       if (!err.Success()) {
         dump_stream.Printf("  <could not be read>\n");
       } else {
-        DataBufferHeap data(m_persistent_variable_sp->GetByteSize(), 0);
+        DataBufferHeap data(
+            m_persistent_variable_sp->GetByteSize().getValueOr(0), 0);
 
         map.ReadMemory(data.GetBytes(), target_address,
-                       m_persistent_variable_sp->GetByteSize(), err);
+                       m_persistent_variable_sp->GetByteSize().getValueOr(0), err);
 
         if (!err.Success()) {
           dump_stream.Printf("  <could not be read>\n");
         } else {
           DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16,
                        target_address);
 
           dump_stream.PutChar('\n');
if (m_temporary_allocation != LLDB_INVALID_ADDRESS) {
             m_variable_sp->GetName().AsCString());
         return;
       }
 
       lldb_private::DataExtractor data;
 
       Status extract_error;
 
-      map.GetMemoryData(data, m_temporary_allocation, valobj_sp->GetByteSize(),
-                        extract_error);
+      map.GetMemoryData(data, m_temporary_allocation,
+                        valobj_sp->GetByteSize().getValueOr(0), extract_error);
 
       if (!extract_error.Success()) {
         err.SetErrorStringWithFormat("couldn't get the data for variable %s",
                                      m_variable_sp->GetName().AsCString());
         return;
       }
 
       bool actually_write = true;
void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
     if (can_persist && m_keep_in_memory) {
       ret->m_live_sp = ValueObjectConstResult::Create(exe_scope, m_type, name,
                                                       address, eAddressTypeLoad,
                                                       map.GetAddressByteSize());
     }
 
     ret->ValueUpdated();
 
-    const size_t pvar_byte_size = ret->GetByteSize();
+    const size_t pvar_byte_size = ret->GetByteSize().getValueOr(0);
     uint8_t *pvar_data = ret->GetValueBytes();
 
     map.ReadMemory(pvar_data, address, pvar_byte_size, read_error);
 
     if (!read_error.Success()) {
       err.SetErrorString(
           "Couldn't dematerialize a result variable: couldn't read its memory");
       return;

lldb/source/Target/StackFrame.cpp

for (int ci = 0, ce = parent->GetNumChildren(); ci != ce; ++ci) {
     const bool can_create = true;
     ValueObjectSP child_sp = parent->GetChildAtIndex(ci, can_create);
 
     if (!child_sp) {
       return ValueObjectSP();
     }
 
     int64_t child_offset = child_sp->GetByteOffset();
-    int64_t child_size = child_sp->GetByteSize();
+    int64_t child_size = child_sp->GetByteSize().getValueOr(0);
 
     if (offset >= child_offset && offset < (child_offset + child_size)) {
       return GetValueForOffset(frame, child_sp, offset - child_offset);
     }
   }
 
   if (offset == 0) {
     return parent;
ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame,
   Status error;
   ValueObjectSP pointee = base->Dereference(error);
     
   if (!pointee) {
     return ValueObjectSP();
   }
 
   if (offset >= 0 && uint64_t(offset) >= pointee->GetByteSize()) {
-    int64_t index = offset / pointee->GetByteSize();
-    offset = offset % pointee->GetByteSize();
+    int64_t index = offset / pointee->GetByteSize().getValueOr(1);
+    offset = offset % pointee->GetByteSize().getValueOr(1);
     const bool can_create = true;
     pointee = base->GetSyntheticArrayMember(index, can_create);
   }
 
   if (!pointee || error.Fail()) {
     return ValueObjectSP();
   }