Make CompilerType::getBitSize() / getByteSize() return an optional result. (NFC)

[aprantl]

Summary

My apologies for the horrible patch.

The code in LLDB assumes that CompilerType and friends use the size 0 as a sentinel value to signal an error. This works for C++, where no zero-sized type exists, but in many other programming languages (including I believe C) types of size zero are possible and even common. This is a particular pain point in swift-lldb, where extra code exists to double-check that a type is *really* of size zero and not an error at various locations.

To remedy this situation, this patch starts by converting CompilerType::getBitSize() and getByteSize() to return an optional result. To avoid wasting space, I hand-rolled my own optional data type assuming that no type is larger than what fits into 63 bits. Follow-up patches would make similar changes to the ValueObject hierarchy.

[labath]

Overall, I am pretty sure we will end up with some kind of a special Optional class sooner or later. However, it's not clear to me whether this is the place to start. What kind of space this is saving? I would expect that size matters when you store something as a data member in a class, because you can have zillion of instances of that class on the heap. However, all the uses of this I see are local (stack) variables, where the size does not matter that much, and so you might as well have used an Optional. Have I missed something?

Overall, I think a good way to keep things sane would be to keep these specialized Optional classes as implementation details of classes, and convert to a real Optional as soon as it goes out to the rest of the world. This would be more consistent with how the rest of llvm does this (see llvm::VersionTuple for instance, which also does some storage optimizations, though without a special class). This would allow us to use the richer Optional interface in most of the places (e.g. Optional has special overloads of operator==, which allow you to compare an Optional<T> with plain T), while still keeping the size footprint in check.

[teemperor]

+1. Especially since our assumption that everything related to C++ is of non-zero size is also not entirely correct. Empty structs for example are actually size 0 for Clang until we reach code gen where we set their size to 1. That's why we have this bug where we can't call functions that return an empty struct.

[aprantl]

Thanks Pavel, your argument of optimizing storage over interfaces makes perfect sense. Using an Optional instead.

[davide]

I hit an incarnation of this problem, and I was able to get away with a localized fix in:
[lldb] r344982 - [ValueObject] Stop assuming types are non-zero sized.

Of course, your approach is principled and it's IMHO clearly the right way forward.
I didn't check every single callsite, as the patch is mechanical enough, but the general idea looks good to me.

[clayborg]

Looks good to me

[zturner]

I had to stop commenting because there's too many occurrences, but please remove auto pretty much throughout the patch. A reader of the code will not necessarily be aware or remember that the function returns an Optional, and they will read the code as "if the size is 0, report an error". So I think the type should be spelled explicitly in all cases.

include/lldb/Target/ProcessStructReader.h

70

I think we shouldn't use auto here, although this is a minor nit and I don't feel strongly.

73

Can we use make_shared here?

source/API/SBType.cpp

107–108

TypeImpl::GetCompilerType needs to return an Optional also, otherwise you will have the same issue here with zero-size types.

source/Commands/CommandObjectMemory.cpp

527–528

Can you remove auto here? It's definitely not obvious that it's returning an Optional here, so I originally read this as "if the size is 0, return an error".

650

Same, please remove auto.

1072

auto

source/Core/Value.cpp

227–229

If the ast type is valid (if-check just above), then is it actually possible for this method to fail?

349–351

Same here. Can this actually fail?

source/Core/ValueObject.cpp

759–762

auto

827–828

auto

1826–1828

auto

1829–1831

This should probably be auto synthetic_child = std::make_shared<ValueObjectChild>(...);

[zturner]

include/lldb/Target/ProcessStructReader.h

70

I actually changed my mind here. I didn't feel strongly at first because I thought this was a uint64_t. As I read through more of the patch, I realized it was an Optional<uint64_t>, which totally changes the semantics. So now I do feel more strongly

[shafik]

Sorry for the late review

lldb/trunk/include/lldb/Target/ProcessStructReader.h

70 ↗

(On Diff #181813)

I will also second the sentiment on the auto, it does not improve readability.

lldb/trunk/source/API/SBType.cpp

106 ↗

(On Diff #181813)

The early exit is more readable here and also has a lower mental load.

lldb/trunk/source/Commands/CommandObjectMemory.cpp

647 ↗

(On Diff #181813)

This does not appear to be NFC

1069 ↗

(On Diff #181813)

NFC?

lldb/trunk/source/Core/Value.cpp

227 ↗

(On Diff #181813)

This might read better as two steps, get the value and then check it.

lldb/trunk/source/Expression/Materializer.cpp

50 ↗

(On Diff #181813)

What value does m_size have otherwise?

800 ↗

(On Diff #181813)

NFC?

lldb/trunk/source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

2372 ↗

(On Diff #181813)

switch?

lldb/trunk/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp

827 ↗

(On Diff #181813)

Looks like you chopped out the if (compiler_type) check

lldb/trunk/source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

1720 ↗

(On Diff #181813)

There are a lot of checks for base_byte_size so it is not clear what value vfp_byte_size will have if base_byte_size is empty.

The flow looks a lot different but hard to track what will be set and not set.

1788 ↗

(On Diff #181813)

make_shared?

lldb/trunk/source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

2343 ↗

(On Diff #181813)

switch?

lldb/trunk/source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp

379 ↗

(On Diff #181813)

Looks the if (!compiler_type) was removed.

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

228 ↗

(On Diff #181813)

Unrelated formatting changes?

243 ↗

(On Diff #181813)

Unrelated formatting changes?

268 ↗

(On Diff #181813)

Formatting?

[aprantl]

I changed all the autos back to full types in r351237.

lldb/trunk/source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp

827 ↗

(On Diff #181813)

That's intentional since GetByteSize also checks for IsValid().

include/lldb/Symbol/CompilerType.h

public:
   CompilerType GetBasicTypeFromAST(lldb::BasicType basic_type) const;
 
   //----------------------------------------------------------------------
   // Exploring the type
   //----------------------------------------------------------------------
 
   struct IntegralTemplateArgument;
 
-  uint64_t GetByteSize(ExecutionContextScope *exe_scope) const;
-
-  uint64_t GetBitSize(ExecutionContextScope *exe_scope) const;
+  llvm::Optional<uint64_t> GetByteSize(ExecutionContextScope *exe_scope) const;
+  llvm::Optional<uint64_t> GetBitSize(ExecutionContextScope *exe_scope) const;
 
   lldb::Encoding GetEncoding(uint64_t &count) const;
 
   lldb::Format GetFormat() const;
 
   size_t GetTypeBitAlign() const;
 
   uint32_t GetNumChildren(bool omit_empty_base_classes,

include/lldb/Target/ProcessStructReader.h

for (size_t idx = 0; idx < struct_type.GetNumFields(); idx++) {
       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);
       // no support for things larger than a uint64_t (yet)
-      if (size > 8)
+      if (!size || *size > 8)
         return;
       ConstString const_name = ConstString(name.c_str());
       size_t byte_index = static_cast<size_t>(bit_offset / 8);
       m_fields[const_name] =
-          FieldImpl{field_type, byte_index, static_cast<size_t>(size)};
+          FieldImpl{field_type, byte_index, static_cast<size_t>(*size)};
     }
-    size_t total_size = struct_type.GetByteSize(nullptr);
-    lldb::DataBufferSP buffer_sp(new DataBufferHeap(total_size, 0));
+    auto total_size = struct_type.GetByteSize(nullptr);
+    if (!total_size)
+      return;
+    lldb::DataBufferSP buffer_sp(new DataBufferHeap(*total_size, 0));
     Status error;
     process->ReadMemoryFromInferior(base_addr, buffer_sp->GetBytes(),
-                                    total_size, error);
+                                    *total_size, error);
     if (error.Fail())
       return;
     m_data = DataExtractor(buffer_sp, m_byte_order, m_addr_byte_size);
   }
 
   template <typename RetType>
   RetType GetField(ConstString name, RetType fail_value = RetType()) {
     auto iter = m_fields.find(name), end = m_fields.end();

source/API/SBType.cpp

 bool SBType::IsValid() const {
   if (m_opaque_sp.get() == NULL)
     return false;
 
   return m_opaque_sp->IsValid();
 }
 
 uint64_t SBType::GetByteSize() {
-  if (!IsValid())
-    return 0;
-
-  return m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr);
+  if (IsValid())
+    if (auto size = m_opaque_sp->GetCompilerType(false).GetByteSize(nullptr))
+      return *size;
 }
 
 bool SBType::IsPointerType() {
   if (!IsValid())
     return false;
   return m_opaque_sp->GetCompilerType(true).IsPointerType();
 }
 

source/Commands/CommandObjectMemory.cpp

#undef ALL_KEYWORDS
         else {
           result.AppendError("unable make a pointer type\n");
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
         --pointer_count;
       }
 
-      m_format_options.GetByteSizeValue() = clang_ast_type.GetByteSize(nullptr);
-
-      if (m_format_options.GetByteSizeValue() == 0) {
+      auto size = clang_ast_type.GetByteSize(nullptr);
+      if (!size) {
         result.AppendErrorWithFormat(
             "unable to get the byte size of the type '%s'\n",
             view_as_type_cstr);
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
+      m_format_options.GetByteSizeValue() = *size;
 
       if (!m_format_options.GetCountValue().OptionWasSet())
         m_format_options.GetCountValue() = 1;
     } else {
       error = m_memory_options.FinalizeSettings(target, m_format_options);
     }
 
     // Look for invalid combinations of settings
#undef ALL_KEYWORDS
     DataBufferSP data_sp;
     size_t bytes_read = 0;
     if (clang_ast_type.GetOpaqueQualType()) {
       // Make sure we don't display our type as ASCII bytes like the default
       // memory read
       if (!m_format_options.GetFormatValue().OptionWasSet())
         m_format_options.GetFormatValue().SetCurrentValue(eFormatDefault);
 
-      bytes_read = clang_ast_type.GetByteSize(nullptr) *
-                   m_format_options.GetCountValue().GetCurrentValue();
+      auto size = clang_ast_type.GetByteSize(nullptr);
+      if (!size) {
+        result.AppendError("can't get size of type");
+        return false;
+      }
+      bytes_read = *size * m_format_options.GetCountValue().GetCurrentValue();
 
       if (argc > 0)
-        addr = addr + (clang_ast_type.GetByteSize(nullptr) *
-                       m_memory_options.m_offset.GetCurrentValue());
+        addr = addr + (*size * m_memory_options.m_offset.GetCurrentValue());
     } else if (m_format_options.GetFormatValue().GetCurrentValue() !=
                eFormatCString) {
       data_sp.reset(new DataBufferHeap(total_byte_size, '\0'));
       if (data_sp->GetBytes() == nullptr) {
         result.AppendErrorWithFormat(
             "can't allocate 0x%" PRIx32
             " bytes for the memory read buffer, specify a smaller size to read",
             (uint32_t)total_byte_size);
bool DoExecute(Args &command, CommandReturnObject &result) override {
     else if (m_memory_options.m_expr.OptionWasSet()) {
       StackFrame *frame = m_exe_ctx.GetFramePtr();
       ValueObjectSP result_sp;
       if ((eExpressionCompleted ==
            process->GetTarget().EvaluateExpression(
                m_memory_options.m_expr.GetStringValue(), frame, result_sp)) &&
           result_sp) {
         uint64_t value = result_sp->GetValueAsUnsigned(0);
-        switch (result_sp->GetCompilerType().GetByteSize(nullptr)) {
+        auto size = result_sp->GetCompilerType().GetByteSize(nullptr);
+        if (!size)
+          return false;
+        switch (*size) {
         case 1: {
           uint8_t byte = (uint8_t)value;
           buffer.CopyData(&byte, 1);
         } break;
         case 2: {
           uint16_t word = (uint16_t)value;
           buffer.CopyData(&word, 2);
         } break;

source/Core/Value.cpp

case eContextTypeRegisterInfo: // RegisterInfo *
     break;
 
   case eContextTypeInvalid:
   case eContextTypeLLDBType: // Type *
   case eContextTypeVariable: // Variable *
   {
     const CompilerType &ast_type = GetCompilerType();
     if (ast_type.IsValid())
-      byte_size = ast_type.GetByteSize(
-          exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr);
+      if (auto size = ast_type.GetByteSize(
+              exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr))
+        byte_size = *size;
   } break;
   }
 
   if (error_ptr) {
     if (byte_size == 0) {
       if (error_ptr->Success())
         error_ptr->SetErrorString("Unable to determine byte size.");
     } else {
case eValueTypeScalar: {
     if (ast_type.IsValid())
       data.SetAddressByteSize(ast_type.GetPointerByteSize());
     else
       data.SetAddressByteSize(sizeof(void *));
 
     uint32_t limit_byte_size = UINT32_MAX;
 
     if (ast_type.IsValid()) {
-      limit_byte_size = ast_type.GetByteSize(
-          exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr);
+      if (auto size = ast_type.GetByteSize(
+              exe_ctx ? exe_ctx->GetBestExecutionContextScope() : nullptr))
+        limit_byte_size = *size;
     }
 
     if (limit_byte_size <= m_value.GetByteSize()) {
       if (m_value.GetData(data, limit_byte_size))
         return error; // Success;
     }
 
     error.SetErrorStringWithFormat("extracting data from value failed");

source/Core/ValueObject.cpp

size_t ValueObject::GetPointeeData(DataExtractor &data, uint32_t item_idx,
   if (!(is_pointer_type || is_array_type))
     return 0;
 
   if (item_count == 0)
     return 0;
 
   ExecutionContext exe_ctx(GetExecutionContextRef());
 
-  const uint64_t item_type_size = pointee_or_element_compiler_type.GetByteSize(
+  auto item_type_size = pointee_or_element_compiler_type.GetByteSize(
       exe_ctx.GetBestExecutionContextScope());
-  const uint64_t bytes = item_count * item_type_size;
-  const uint64_t offset = item_idx * item_type_size;
+  if (!item_type_size)
+    return 0;
+  const uint64_t bytes = item_count * *item_type_size;
+  const uint64_t offset = item_idx * *item_type_size;
 
   if (item_idx == 0 && item_count == 1) // simply a deref
   {
     if (is_pointer_type) {
       Status error;
       ValueObjectSP pointee_sp = Dereference(error);
       if (error.Fail() || pointee_sp.get() == NULL)
         return 0;
case eAddressTypeLoad: {
             addr + offset, heap_buf_ptr->GetBytes(), bytes, error);
         if (error.Success() || bytes_read > 0) {
           data.SetData(data_sp);
           return bytes_read;
         }
       }
     } break;
     case eAddressTypeHost: {
-      const uint64_t max_bytes =
+      auto max_bytes =
           GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope());
-      if (max_bytes > offset) {
-        size_t bytes_read = std::min<uint64_t>(max_bytes - offset, bytes);
+      if (max_bytes && *max_bytes > offset) {
+        size_t bytes_read = std::min<uint64_t>(*max_bytes - offset, bytes);
         addr = m_value.GetScalar().ULongLong(LLDB_INVALID_ADDRESS);
         if (addr == 0 || addr == LLDB_INVALID_ADDRESS)
           break;
         heap_buf_ptr->CopyData((uint8_t *)(addr + offset), bytes_read);
         data.SetData(data_sp);
         return bytes_read;
       }
     } break;
ValueObjectSP ValueObject::GetSyntheticChildAtOffset(
   // 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(name_const_str);
 
   if (synthetic_child_sp.get())
     return synthetic_child_sp;
 
   if (!can_create)
-    return ValueObjectSP();
+    return {};
 
   ExecutionContext exe_ctx(GetExecutionContextRef());
-
-  ValueObjectChild *synthetic_child = new ValueObjectChild(
-      *this, type, name_const_str,
-      type.GetByteSize(exe_ctx.GetBestExecutionContextScope()), offset, 0, 0,
+  auto size = type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
+  if (!size)
+    return {};
+  ValueObjectChild *synthetic_child =
+      new ValueObjectChild(*this, type, name_const_str, *size, offset, 0, 0,
                            false, false, eAddressTypeInvalid, 0);
   if (synthetic_child) {
     AddSyntheticChild(name_const_str, synthetic_child);
     synthetic_child_sp = synthetic_child->GetSP();
     synthetic_child_sp->SetName(name_const_str);
     synthetic_child_sp->m_is_child_at_offset = true;
   }
   return synthetic_child_sp;
 }
ValueObjectSP ValueObject::GetSyntheticBase(uint32_t offset,
   // 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(name_const_str);
 
   if (synthetic_child_sp.get())
     return synthetic_child_sp;
 
   if (!can_create)
-    return ValueObjectSP();
+    return {};
 
   const bool is_base_class = true;
 
   ExecutionContext exe_ctx(GetExecutionContextRef());
-
-  ValueObjectChild *synthetic_child = new ValueObjectChild(
-      *this, type, name_const_str,
-      type.GetByteSize(exe_ctx.GetBestExecutionContextScope()), offset, 0, 0,
+  auto size = type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
+  if (!size)
+    return {};
+  ValueObjectChild *synthetic_child =
+      new ValueObjectChild(*this, type, name_const_str, *size, offset, 0, 0,
                            is_base_class, false, eAddressTypeInvalid, 0);
   if (synthetic_child) {
     AddSyntheticChild(name_const_str, synthetic_child);
     synthetic_child_sp = synthetic_child->GetSP();
     synthetic_child_sp->SetName(name_const_str);
   }
   return synthetic_child_sp;
 }
 

source/Core/ValueObjectConstResult.cpp

 }
 
 lldb::ValueType ValueObjectConstResult::GetValueType() const {
   return eValueTypeConstResult;
 }
 
 uint64_t ValueObjectConstResult::GetByteSize() {
   ExecutionContext exe_ctx(GetExecutionContextRef());
-
-  if (m_byte_size == 0)
-    SetByteSize(
-        GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope()));
+  if (m_byte_size == 0) {
+    if (auto size =
+        GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope()))
+      SetByteSize(*size);
+  }
   return m_byte_size;
 }
 
 void ValueObjectConstResult::SetByteSize(size_t size) { m_byte_size = size; }
 
 size_t ValueObjectConstResult::CalculateNumChildren(uint32_t max) {
   ExecutionContext exe_ctx(GetExecutionContextRef());
   auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);

source/Core/ValueObjectMemory.cpp

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

source/Core/ValueObjectVariable.cpp

 uint64_t ValueObjectVariable::GetByteSize() {
   ExecutionContext exe_ctx(GetExecutionContextRef());
 
   CompilerType type(GetCompilerType());
 
   if (!type.IsValid())
     return 0;
 
-  return type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
+  auto size = type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
+  return size ? *size : 0;
 }
 
 lldb::ValueType ValueObjectVariable::GetValueType() const {
   if (m_variable_sp)
     return m_variable_sp->GetScope();
   return lldb::eValueTypeInvalid;
 }
 

source/DataFormatters/TypeFormat.cpp

if (context_type == Value::eContextTypeRegisterInfo) {
           }
         } else {
           Status error;
           valobj->GetData(data, error);
           if (error.Fail())
             return false;
         }
 
+        ExecutionContextScope *exe_scope =
+            exe_ctx.GetBestExecutionContextScope();
+        auto size = compiler_type.GetByteSize(exe_scope);
+        if (!size)
+          return false;
         StreamString sstr;
-        ExecutionContextScope *exe_scope(
-            exe_ctx.GetBestExecutionContextScope());
         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"
-            compiler_type.GetByteSize(
-                exe_scope),                 // Byte size of item in "m_data"
+            &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);
         // 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

source/DataFormatters/VectorType.cpp

 static size_t CalculateNumChildren(
     CompilerType container_type, CompilerType element_type,
     lldb_private::ExecutionContextScope *exe_scope =
         nullptr // does not matter here because all we trade in are basic types
     ) {
   auto container_size = container_type.GetByteSize(exe_scope);
   auto element_size = element_type.GetByteSize(exe_scope);
 
-  if (element_size) {
-    if (container_size % element_size)
+  if (container_size && element_size && *element_size) {
+    if (*container_size % *element_size)
       return 0;
-    return container_size / element_size;
+    return *container_size / *element_size;
   }
   return 0;
 }
 
 namespace lldb_private {
 namespace formatters {
 
 class VectorTypeSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   VectorTypeSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
       : SyntheticChildrenFrontEnd(*valobj_sp), m_parent_format(eFormatInvalid),
         m_item_format(eFormatInvalid), m_child_type(), m_num_children(0) {}
 
   ~VectorTypeSyntheticFrontEnd() override = default;
 
   size_t CalculateNumChildren() override { return m_num_children; }
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
     if (idx >= CalculateNumChildren())
-      return lldb::ValueObjectSP();
-    auto offset = idx * m_child_type.GetByteSize(nullptr);
+      return {};
+    auto size = m_child_type.GetByteSize(nullptr);
+    if (!size)
+      return {};
+    auto offset = idx * *size;
     StreamString idx_name;
     idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
     ValueObjectSP child_sp(m_backend.GetSyntheticChildAtOffset(
         offset, m_child_type, true, ConstString(idx_name.GetString())));
     if (!child_sp)
       return child_sp;
 
     child_sp->SetFormat(m_item_format);

source/Expression/Materializer.cpp

uint32_t Materializer::AddStructMember(Entity &entity) {
   ret = m_current_offset;
 
   m_current_offset += size;
 
   return ret;
 }
 
 void Materializer::Entity::SetSizeAndAlignmentFromType(CompilerType &type) {
-  m_size = type.GetByteSize(nullptr);
+  if (auto size = type.GetByteSize(nullptr))
+    m_size = *size;
 
   uint32_t bit_alignment = type.GetTypeBitAlign();
 
   if (bit_alignment % 8) {
     bit_alignment += 8;
     bit_alignment &= ~((uint32_t)0x111u);
   }
 
if (!m_is_program_reference) {
                            "but one exists");
         return;
       }
 
       const lldb::addr_t load_addr = process_address + m_offset;
 
       ExecutionContextScope *exe_scope = map.GetBestExecutionContextScope();
 
-      size_t byte_size = m_type.GetByteSize(exe_scope);
+      auto byte_size = m_type.GetByteSize(exe_scope);
+      if (!byte_size) {
+        err.SetErrorString("can't get size of type");
+        return;
+      }
       size_t bit_align = m_type.GetTypeBitAlign();
       size_t byte_align = (bit_align + 7) / 8;
 
       if (!byte_align)
         byte_align = 1;
 
       Status alloc_error;
       const bool zero_memory = true;
 
       m_temporary_allocation = map.Malloc(
-          byte_size, byte_align,
+          *byte_size, byte_align,
           lldb::ePermissionsReadable | lldb::ePermissionsWritable,
           IRMemoryMap::eAllocationPolicyMirror, zero_memory, alloc_error);
-      m_temporary_allocation_size = byte_size;
+      m_temporary_allocation_size = *byte_size;
 
       if (!alloc_error.Success()) {
         err.SetErrorStringWithFormat(
             "couldn't allocate a temporary region for the result: %s",
             alloc_error.AsCString());
         return;
       }
 

source/Plugins/ABI/MacOSX-arm/ABIMacOSX_arm.cpp

for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
 
     if (!value)
       return false;
 
     CompilerType compiler_type = value->GetCompilerType();
     if (compiler_type) {
       bool is_signed = false;
       size_t bit_width = 0;
-      if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-        bit_width = compiler_type.GetBitSize(&thread);
-      } else if (compiler_type.IsPointerOrReferenceType()) {
-        bit_width = compiler_type.GetBitSize(&thread);
-      } else {
+      auto bit_size = compiler_type.GetBitSize(&thread);
+      if (!bit_size)
+        return false;
+      if (compiler_type.IsIntegerOrEnumerationType(is_signed))
+        bit_width = *bit_size;
+      else if (compiler_type.IsPointerOrReferenceType())
+        bit_width = *bit_size;
+      else
         // We only handle integer, pointer and reference types currently...
         return false;
-      }
 
       if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
         if (value_idx < 4) {
           // Arguments 1-4 are in r0-r3...
           const RegisterInfo *arg_reg_info = nullptr;
           // Search by generic ID first, then fall back to by name
           uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
               eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
ValueObjectSP ABIMacOSX_arm::GetReturnValueObjectImpl(
 
   bool is_signed;
 
   // Get the pointer to the first stack argument so we have a place to start
   // when reading data
 
   const RegisterInfo *r0_reg_info = reg_ctx->GetRegisterInfoByName("r0", 0);
   if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-    size_t bit_width = compiler_type.GetBitSize(&thread);
+    auto bit_width = compiler_type.GetBitSize(&thread);
+    if (!bit_width)
+      return return_valobj_sp;
 
-    switch (bit_width) {
+    switch (*bit_width) {
     default:
       return return_valobj_sp;
     case 128:
       if (IsArmv7kProcess()) {
         // "A composite type not larger than 16 bytes is returned in r0-r3. The
         // format is as if the result had been stored in memory at a word-
         // aligned address and then loaded into r0-r3 with an ldm instruction"
         {
           const RegisterInfo *r1_reg_info =
               reg_ctx->GetRegisterInfoByName("r1", 0);
           const RegisterInfo *r2_reg_info =
               reg_ctx->GetRegisterInfoByName("r2", 0);
           const RegisterInfo *r3_reg_info =
               reg_ctx->GetRegisterInfoByName("r3", 0);
           if (r1_reg_info && r2_reg_info && r3_reg_info) {
-            const size_t byte_size = compiler_type.GetByteSize(&thread);
+            auto byte_size = compiler_type.GetByteSize(&thread);
+            if (!byte_size)
+              return return_valobj_sp;
             ProcessSP process_sp(thread.GetProcess());
-            if (byte_size <= r0_reg_info->byte_size + r1_reg_info->byte_size +
+            if (*byte_size <= r0_reg_info->byte_size + r1_reg_info->byte_size +
                                   r2_reg_info->byte_size +
                                   r3_reg_info->byte_size &&
                 process_sp) {
               std::unique_ptr<DataBufferHeap> heap_data_ap(
-                  new DataBufferHeap(byte_size, 0));
+                  new DataBufferHeap(*byte_size, 0));
               const ByteOrder byte_order = process_sp->GetByteOrder();
               RegisterValue r0_reg_value;
               RegisterValue r1_reg_value;
               RegisterValue r2_reg_value;
               RegisterValue r3_reg_value;
               if (reg_ctx->ReadRegister(r0_reg_info, r0_reg_value) &&
                   reg_ctx->ReadRegister(r1_reg_info, r1_reg_value) &&
                   reg_ctx->ReadRegister(r2_reg_info, r2_reg_value) &&

source/Plugins/ABI/MacOSX-arm64/ABIMacOSX_arm64.cpp

for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
     // We currently only support extracting values with Clang QualTypes. Do we
     // care about others?
     Value *value = values.GetValueAtIndex(value_idx);
 
     if (!value)
       return false;
 
     CompilerType value_type = value->GetCompilerType();
-    if (value_type) {
-      bool is_signed = false;
-      size_t bit_width = 0;
-      if (value_type.IsIntegerOrEnumerationType(is_signed)) {
-        bit_width = value_type.GetBitSize(&thread);
-      } else if (value_type.IsPointerOrReferenceType()) {
-        bit_width = value_type.GetBitSize(&thread);
-      } else {
-        // We only handle integer, pointer and reference types currently...
-        return false;
-      }
+    auto bit_size = value_type.GetBitSize(&thread);
+    if (!bit_size)
+      return false;
+
+      bit_width = *bit_size;
+      bit_width = *bit_size;
 
-      if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
-        if (value_idx < 8) {
-          // Arguments 1-6 are in x0-x5...
-          const RegisterInfo *reg_info = nullptr;
-          // Search by generic ID first, then fall back to by name
-          uint32_t arg_reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
-              eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + value_idx);
-          if (arg_reg_num != LLDB_INVALID_REGNUM) {
-            reg_info = reg_ctx->GetRegisterInfoAtIndex(arg_reg_num);
-          } else {
-            switch (value_idx) {
-            case 0:
-              reg_info = reg_ctx->GetRegisterInfoByName("x0");
-              break;
-            case 1:
-              reg_info = reg_ctx->GetRegisterInfoByName("x1");
-              break;
-            case 2:
-              reg_info = reg_ctx->GetRegisterInfoByName("x2");
-              break;
-            case 3:
-              reg_info = reg_ctx->GetRegisterInfoByName("x3");
-              break;
-            case 4:
-              reg_info = reg_ctx->GetRegisterInfoByName("x4");
-              break;
-            case 5:
-              reg_info = reg_ctx->GetRegisterInfoByName("x5");
-              break;
-            case 6:
-              reg_info = reg_ctx->GetRegisterInfoByName("x6");
-              break;
-            case 7:
-              reg_info = reg_ctx->GetRegisterInfoByName("x7");
-              break;
-            }
-          }
 
-          if (reg_info) {
-            RegisterValue reg_value;
 
-            if (reg_ctx->ReadRegister(reg_info, reg_value)) {
-              if (is_signed)
-                reg_value.SignExtend(bit_width);
-              if (!reg_value.GetScalarValue(value->GetScalar()))
-                return false;
-              continue;
-            }
-          }
-          return false;
-        } else {
-          if (sp == 0) {
-            // Read the stack pointer if we already haven't read it
-            sp = reg_ctx->GetSP(0);
-            if (sp == 0)
-              return false;
-          }
 
-          // Arguments 5 on up are on the stack
-          const uint32_t arg_byte_size = (bit_width + (8 - 1)) / 8;
-          Status error;
-          if (!exe_ctx.GetProcessRef().ReadScalarIntegerFromMemory(
-                  sp, arg_byte_size, is_signed, value->GetScalar(), error))
-            return false;
 
-          sp += arg_byte_size;
-          // Align up to the next 8 byte boundary if needed
-          if (sp % 8) {
-            sp >>= 3;
-            sp += 1;
-            sp <<= 3;
-          }
-        }
-      }
-    }
-  }
   return true;
 }
 
 Status
 ABIMacOSX_arm64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
                                       lldb::ValueObjectSP &new_value_sp) {
   Status error;
   if (!new_value_sp) {

 
 static bool LoadValueFromConsecutiveGPRRegisters(
     ExecutionContext &exe_ctx, RegisterContext *reg_ctx,
     const CompilerType &value_type,
     bool is_return_value, // false => parameter, true => return value
     uint32_t &NGRN,       // NGRN (see ABI documentation)
     uint32_t &NSRN,       // NSRN (see ABI documentation)
     DataExtractor &data) {
-  const size_t byte_size = value_type.GetByteSize(nullptr);
-
-  if (byte_size == 0)
+  auto byte_size = value_type.GetByteSize(nullptr);
+  if (!byte_size || *byte_size == 0)
     return false;
 
   std::unique_ptr<DataBufferHeap> heap_data_ap(
-      new DataBufferHeap(byte_size, 0));
+      new DataBufferHeap(*byte_size, 0));
   const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
   Status error;
 
   CompilerType base_type;
   const uint32_t homogeneous_count =
       value_type.IsHomogeneousAggregate(&base_type);
   if (homogeneous_count > 0 && homogeneous_count <= 8) {
     // Make sure we have enough registers
     if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) {
       if (!base_type)
         return false;
-      const size_t base_byte_size = base_type.GetByteSize(nullptr);
+      auto base_byte_size = base_type.GetByteSize(nullptr);
+      if (!base_byte_size)
+        return false;
       uint32_t data_offset = 0;
 
       for (uint32_t i = 0; i < homogeneous_count; ++i) {
         char v_name[8];
         ::snprintf(v_name, sizeof(v_name), "v%u", NSRN);
         const RegisterInfo *reg_info =
             reg_ctx->GetRegisterInfoByName(v_name, 0);
         if (reg_info == nullptr)
           return false;
 
-        if (base_byte_size > reg_info->byte_size)
+        if (*base_byte_size > reg_info->byte_size)
           return false;
 
         RegisterValue reg_value;
 
         if (!reg_ctx->ReadRegister(reg_info, reg_value))
           return false;
 
         // Make sure we have enough room in "heap_data_ap"
-        if ((data_offset + base_byte_size) <= heap_data_ap->GetByteSize()) {
+        if ((data_offset + *base_byte_size) <= heap_data_ap->GetByteSize()) {
           const size_t bytes_copied = reg_value.GetAsMemoryData(
-              reg_info, heap_data_ap->GetBytes() + data_offset, base_byte_size,
+              reg_info, heap_data_ap->GetBytes() + data_offset, *base_byte_size,
               byte_order, error);
-          if (bytes_copied != base_byte_size)
+          if (bytes_copied != *base_byte_size)
             return false;
           data_offset += bytes_copied;
           ++NSRN;
         } else
           return false;
       }
       data.SetByteOrder(byte_order);
       data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
       data.SetData(DataBufferSP(heap_data_ap.release()));
       return true;
     }
   }
 
   const size_t max_reg_byte_size = 16;
-  if (byte_size <= max_reg_byte_size) {
-    size_t bytes_left = byte_size;
+  if (*byte_size <= max_reg_byte_size) {
+    size_t bytes_left = *byte_size;
     uint32_t data_offset = 0;
-    while (data_offset < byte_size) {
+    while (data_offset < *byte_size) {
       if (NGRN >= 8)
         return false;
 
       uint32_t reg_num = reg_ctx->ConvertRegisterKindToRegisterNumber(
           eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN);
       if (reg_num == LLDB_INVALID_REGNUM)
         return false;
 
ValueObjectSP ABIMacOSX_arm64::GetReturnValueObjectImpl(
 
   // value.SetContext (Value::eContextTypeClangType, return_compiler_type);
   value.SetCompilerType(return_compiler_type);
 
   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
   if (!reg_ctx)
     return return_valobj_sp;
 
-  const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
+  auto byte_size = return_compiler_type.GetByteSize(nullptr);
+  if (!byte_size)
+    return return_valobj_sp;
 
   const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
   if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
     value.SetValueType(Value::eValueTypeScalar);
 
     bool success = false;
     if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
       // Extract the register context so we can read arguments from registers
-      if (byte_size <= 8) {
+      if (*byte_size <= 8) {
         const RegisterInfo *x0_reg_info =
             reg_ctx->GetRegisterInfoByName("x0", 0);
         if (x0_reg_info) {
           uint64_t raw_value =
               thread.GetRegisterContext()->ReadRegisterAsUnsigned(x0_reg_info,
                                                                   0);
           const bool is_signed = (type_flags & eTypeIsSigned) != 0;
-          switch (byte_size) {
+          switch (*byte_size) {
           default:
             break;
           case 16: // uint128_t
             // In register x0 and x1
             {
               const RegisterInfo *x1_reg_info =
                   reg_ctx->GetRegisterInfoByName("x1", 0);
 
               if (x1_reg_info) {
-                if (byte_size <=
+                if (*byte_size <=
                     x0_reg_info->byte_size + x1_reg_info->byte_size) {
                   std::unique_ptr<DataBufferHeap> heap_data_ap(
-                      new DataBufferHeap(byte_size, 0));
+                      new DataBufferHeap(*byte_size, 0));
                   const ByteOrder byte_order =
                       exe_ctx.GetProcessRef().GetByteOrder();
                   RegisterValue x0_reg_value;
                   RegisterValue x1_reg_value;
                   if (reg_ctx->ReadRegister(x0_reg_info, x0_reg_value) &&
                       reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) {
                     Status error;
                     if (x0_reg_value.GetAsMemoryData(
if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
             break;
           }
         }
       }
     } else if (type_flags & eTypeIsFloat) {
       if (type_flags & eTypeIsComplex) {
         // Don't handle complex yet.
       } else {
-        if (byte_size <= sizeof(long double)) {
+        if (*byte_size <= sizeof(long double)) {
           const RegisterInfo *v0_reg_info =
               reg_ctx->GetRegisterInfoByName("v0", 0);
           RegisterValue v0_value;
           if (reg_ctx->ReadRegister(v0_reg_info, v0_value)) {
             DataExtractor data;
             if (v0_value.GetData(data)) {
               lldb::offset_t offset = 0;
-              if (byte_size == sizeof(float)) {
+              if (*byte_size == sizeof(float)) {
                 value.GetScalar() = data.GetFloat(&offset);
                 success = true;
-              } else if (byte_size == sizeof(double)) {
+              } else if (*byte_size == sizeof(double)) {
                 value.GetScalar() = data.GetDouble(&offset);
                 success = true;
-              } else if (byte_size == sizeof(long double)) {
+              } else if (*byte_size == sizeof(long double)) {
                 value.GetScalar() = data.GetLongDouble(&offset);
                 success = true;
               }
             }
           }
         }
       }
     }
 
     if (success)
       return_valobj_sp = ValueObjectConstResult::Create(
           thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if (type_flags & eTypeIsVector) {
-    if (byte_size > 0) {
+    if (*byte_size > 0) {
 
       const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
 
       if (v0_info) {
-        if (byte_size <= v0_info->byte_size) {
+        if (*byte_size <= v0_info->byte_size) {
           std::unique_ptr<DataBufferHeap> heap_data_ap(
-              new DataBufferHeap(byte_size, 0));
+              new DataBufferHeap(*byte_size, 0));
           const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
           RegisterValue reg_value;
           if (reg_ctx->ReadRegister(v0_info, reg_value)) {
             Status error;
             if (reg_value.GetAsMemoryData(v0_info, heap_data_ap->GetBytes(),
                                           heap_data_ap->GetByteSize(),
                                           byte_order, error)) {
               DataExtractor data(DataBufferSP(heap_data_ap.release()),

source/Plugins/ABI/MacOSX-i386/ABIMacOSX_i386.cpp

for (value_index = 0; value_index < num_values; ++value_index) {
     Value *value = values.GetValueAtIndex(value_index);
 
     if (!value)
       return false;
 
     // We currently only support extracting values with Clang QualTypes. Do we
     // care about others?
     CompilerType compiler_type(value->GetCompilerType());
-    if (compiler_type) {
+    auto bit_size = compiler_type.GetBitSize(&thread);
+    if (bit_size) {
       bool is_signed;
-
-      if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-        ReadIntegerArgument(value->GetScalar(),
-                            compiler_type.GetBitSize(&thread), is_signed,
+      if (compiler_type.IsIntegerOrEnumerationType(is_signed))
+        ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed,
                             thread.GetProcess().get(), current_stack_argument);
-      } else if (compiler_type.IsPointerType()) {
-        ReadIntegerArgument(value->GetScalar(),
-                            compiler_type.GetBitSize(&thread), false,
+      else if (compiler_type.IsPointerType())
+        ReadIntegerArgument(value->GetScalar(), *bit_size, false,
                             thread.GetProcess().get(), current_stack_argument);
-      }
-    }
-  }
 
   return true;
 }
 
 Status ABIMacOSX_i386::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
                                             lldb::ValueObjectSP &new_value_sp) {
   Status error;
   if (!new_value_sp) {
ABIMacOSX_i386::GetReturnValueObjectImpl(Thread &thread,
 
   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
   if (!reg_ctx)
     return return_valobj_sp;
 
   bool is_signed;
 
   if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-    size_t bit_width = compiler_type.GetBitSize(&thread);
-
+    auto bit_width = compiler_type.GetBitSize(&thread);
+    if (!bit_width)
+      return return_valobj_sp;
     unsigned eax_id =
         reg_ctx->GetRegisterInfoByName("eax", 0)->kinds[eRegisterKindLLDB];
     unsigned edx_id =
         reg_ctx->GetRegisterInfoByName("edx", 0)->kinds[eRegisterKindLLDB];
 
-    switch (bit_width) {
+    switch (*bit_width) {
     default:
     case 128:
       // Scalar can't hold 128-bit literals, so we don't handle this
       return return_valobj_sp;
     case 64:
       uint64_t raw_value;
       raw_value =
           thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &

source/Plugins/ABI/SysV-arm/ABISysV_arm.cpp

for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
 
     if (!value)
       return false;
 
     CompilerType compiler_type = value->GetCompilerType();
     if (compiler_type) {
       bool is_signed = false;
       size_t bit_width = 0;
-      if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-        bit_width = compiler_type.GetBitSize(&thread);
-      } else if (compiler_type.IsPointerOrReferenceType()) {
-        bit_width = compiler_type.GetBitSize(&thread);
+      if (compiler_type.IsIntegerOrEnumerationType(is_signed) ||
+          compiler_type.IsPointerOrReferenceType()) {
+        if (auto size = compiler_type.GetBitSize(&thread))
+          bit_width = *size;
       } else {
         // We only handle integer, pointer and reference types currently...
         return false;
       }
 
       if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
         if (value_idx < 4) {
           // Arguments 1-4 are in r0-r3...
ValueObjectSP ABISysV_arm::GetReturnValueObjectImpl(
   uint8_t vfp_count = 0;
   uint8_t vfp_byte_size = 0;
 
   // Get the pointer to the first stack argument so we have a place to start
   // when reading data
 
   const RegisterInfo *r0_reg_info =
       reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
-  size_t bit_width = compiler_type.GetBitSize(&thread);
-  size_t byte_size = compiler_type.GetByteSize(&thread);
+  auto bit_width = compiler_type.GetBitSize(&thread);
+  auto byte_size = compiler_type.GetByteSize(&thread);
+  if (!bit_width || !byte_size)
+    return return_valobj_sp;
 
   if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-    switch (bit_width) {
+    switch (*bit_width) {
     default:
       return return_valobj_sp;
     case 64: {
       const RegisterInfo *r1_reg_info = reg_ctx->GetRegisterInfo(
           eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2);
       uint64_t raw_value;
       raw_value = reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
       raw_value |= ((uint64_t)(reg_ctx->ReadRegisterAsUnsigned(r1_reg_info, 0) &
case 8:
       break;
     }
   } else if (compiler_type.IsPointerType()) {
     uint32_t ptr =
         thread.GetRegisterContext()->ReadRegisterAsUnsigned(r0_reg_info, 0) &
         UINT32_MAX;
     value.GetScalar() = ptr;
   } else if (compiler_type.IsVectorType(nullptr, nullptr)) {
-    if (IsArmHardFloat(thread) && (byte_size == 8 || byte_size == 16)) {
+    if (IsArmHardFloat(thread) && (*byte_size == 8 || *byte_size == 16)) {
       is_vfp_candidate = true;
       vfp_byte_size = 8;
-      vfp_count = (byte_size == 8 ? 1 : 2);
-    } else if (byte_size <= 16) {
+      vfp_count = (*byte_size == 8 ? 1 : 2);
+    } else if (*byte_size <= 16) {
       DataBufferHeap buffer(16, 0);
       uint32_t *buffer_ptr = (uint32_t *)buffer.GetBytes();
 
-      for (uint32_t i = 0; 4 * i < byte_size; ++i) {
+      for (uint32_t i = 0; 4 * i < *byte_size; ++i) {
         const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
             eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
         buffer_ptr[i] =
             reg_ctx->ReadRegisterAsUnsigned(reg_info, 0) & UINT32_MAX;
       }
-      value.SetBytes(buffer.GetBytes(), byte_size);
+      value.SetBytes(buffer.GetBytes(), *byte_size);
     } else {
-      if (!GetReturnValuePassedInMemory(thread, reg_ctx, byte_size, value))
+      if (!GetReturnValuePassedInMemory(thread, reg_ctx, *byte_size, value))
         return return_valobj_sp;
     }
   } else if (compiler_type.IsFloatingPointType(float_count, is_complex)) {
     if (float_count == 1 && !is_complex) {
-      switch (bit_width) {
+      switch (*bit_width) {
       default:
         return return_valobj_sp;
       case 64: {
         static_assert(sizeof(double) == sizeof(uint64_t), "");
 
         if (IsArmHardFloat(thread)) {
           RegisterValue reg_value;
           const RegisterInfo *d0_reg_info =
if (float_count == 1 && !is_complex) {
           value.GetScalar() = *reinterpret_cast<float *>(&raw_value);
         }
         break;
       }
       }
     } else if (is_complex && float_count == 2) {
       if (IsArmHardFloat(thread)) {
         is_vfp_candidate = true;
-        vfp_byte_size = byte_size / 2;
+        vfp_byte_size = *byte_size / 2;
         vfp_count = 2;
-      } else if (!GetReturnValuePassedInMemory(thread, reg_ctx, bit_width / 8,
+      } else if (!GetReturnValuePassedInMemory(thread, reg_ctx, *bit_width / 8,
                                                value))
         return return_valobj_sp;
     } else
       // not handled yet
       return return_valobj_sp;
   } else if (compiler_type.IsAggregateType()) {
     if (IsArmHardFloat(thread)) {
       CompilerType base_type;
       const uint32_t homogeneous_count =
           compiler_type.IsHomogeneousAggregate(&base_type);
 
       if (homogeneous_count > 0 && homogeneous_count <= 4) {
+        auto base_byte_size = base_type.GetByteSize(nullptr);
         if (base_type.IsVectorType(nullptr, nullptr)) {
-          uint64_t base_byte_size = base_type.GetByteSize(nullptr);
-          if (base_byte_size == 8 || base_byte_size == 16) {
+          if (base_byte_size &&
+              (*base_byte_size == 8 || *base_byte_size == 16)) {
             is_vfp_candidate = true;
             vfp_byte_size = 8;
-            vfp_count =
-                (base_type.GetByteSize(nullptr) == 8 ? homogeneous_count
-                                                     : homogeneous_count * 2);
+            vfp_count = (*base_byte_size == 8 ? homogeneous_count
           }
         } else if (base_type.IsFloatingPointType(float_count, is_complex)) {
           if (float_count == 1 && !is_complex) {
             is_vfp_candidate = true;
-            vfp_byte_size = base_type.GetByteSize(nullptr);
+            if (base_byte_size)
+              vfp_byte_size = *base_byte_size;
             vfp_count = homogeneous_count;
           }
         }
       } else if (homogeneous_count == 0) {
         const uint32_t num_children = compiler_type.GetNumFields();
 
         if (num_children > 0 && num_children <= 2) {
           uint32_t index = 0;
           for (index = 0; index < num_children; index++) {
             std::string name;
             base_type =
                 compiler_type.GetFieldAtIndex(index, name, NULL, NULL, NULL);
 
             if (base_type.IsFloatingPointType(float_count, is_complex)) {
+              auto base_byte_size = base_type.GetByteSize(nullptr);
               if (float_count == 2 && is_complex) {
-                if (index != 0 &&
-                    vfp_byte_size != base_type.GetByteSize(nullptr))
+                if (index != 0 && base_byte_size &&
+                    vfp_byte_size != *base_byte_size)
                   break;
-                else
-                  vfp_byte_size = base_type.GetByteSize(nullptr);
+                else if (base_byte_size)
+                  vfp_byte_size = *base_byte_size;
               } else
                 break;
             } else
               break;
           }
 
           if (index == num_children) {
             is_vfp_candidate = true;
             vfp_byte_size = (vfp_byte_size >> 1);
             vfp_count = (num_children << 1);
           }
         }
       }
     }
 
-    if (byte_size <= 4) {
+    if (*byte_size <= 4) {
       RegisterValue r0_reg_value;
       uint32_t raw_value =
           reg_ctx->ReadRegisterAsUnsigned(r0_reg_info, 0) & UINT32_MAX;
-      value.SetBytes(&raw_value, byte_size);
+      value.SetBytes(&raw_value, *byte_size);
     } else if (!is_vfp_candidate) {
-      if (!GetReturnValuePassedInMemory(thread, reg_ctx, byte_size, value))
+      if (!GetReturnValuePassedInMemory(thread, reg_ctx, *byte_size, value))
         return return_valobj_sp;
     }
   } else {
     // not handled yet
     return return_valobj_sp;
   }
 
   if (is_vfp_candidate) {
     ProcessSP process_sp(thread.GetProcess());
     ByteOrder byte_order = process_sp->GetByteOrder();
 
-    DataBufferSP data_sp(new DataBufferHeap(byte_size, 0));
+    DataBufferSP data_sp(new DataBufferHeap(*byte_size, 0));
     uint32_t data_offset = 0;
 
     for (uint32_t reg_index = 0; reg_index < vfp_count; reg_index++) {
       uint32_t regnum = 0;
 
       if (vfp_byte_size == 4)
         regnum = dwarf_s0 + reg_index;
       else if (vfp_byte_size == 8)
for (uint32_t reg_index = 0; reg_index < vfp_count; reg_index++) {
             byte_order, error);
         if (bytes_copied != vfp_byte_size)
           break;
 
         data_offset += bytes_copied;
       }
     }
 
-    if (data_offset == byte_size) {
+    if (data_offset == *byte_size) {
       DataExtractor data;
       data.SetByteOrder(byte_order);
       data.SetAddressByteSize(process_sp->GetAddressByteSize());
       data.SetData(data_sp);
 
       return ValueObjectConstResult::Create(&thread, compiler_type,
                                             ConstString(""), data);
     } else { // Some error occurred while getting values from registers

source/Plugins/ABI/SysV-arm64/ABISysV_arm64.cpp

for (uint32_t value_idx = 0; value_idx < num_values; ++value_idx) {
 
     if (!value)
       return false;
 
     CompilerType value_type = value->GetCompilerType();
     if (value_type) {
       bool is_signed = false;
       size_t bit_width = 0;
+      auto bit_size = value_type.GetBitSize(&thread);
+      if (!bit_size)
+        return false;
       if (value_type.IsIntegerOrEnumerationType(is_signed)) {
-        bit_width = value_type.GetBitSize(&thread);
+        bit_width = *bit_size;
       } else if (value_type.IsPointerOrReferenceType()) {
-        bit_width = value_type.GetBitSize(&thread);
+        bit_width = *bit_size;
       } else {
         // We only handle integer, pointer and reference types currently...
         return false;
       }
 
       if (bit_width <= (exe_ctx.GetProcessRef().GetAddressByteSize() * 8)) {
         if (value_idx < 8) {
           // Arguments 1-8 are in x0-x7...

 
 static bool LoadValueFromConsecutiveGPRRegisters(
     ExecutionContext &exe_ctx, RegisterContext *reg_ctx,
     const CompilerType &value_type,
     bool is_return_value, // false => parameter, true => return value
     uint32_t &NGRN,       // NGRN (see ABI documentation)
     uint32_t &NSRN,       // NSRN (see ABI documentation)
     DataExtractor &data) {
-  const size_t byte_size = value_type.GetByteSize(nullptr);
+  auto byte_size = value_type.GetByteSize(nullptr);
 
-  if (byte_size == 0)
+  if (byte_size || *byte_size == 0)
     return false;
 
   std::unique_ptr<DataBufferHeap> heap_data_ap(
-      new DataBufferHeap(byte_size, 0));
+      new DataBufferHeap(*byte_size, 0));
   const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
   Status error;
 
   CompilerType base_type;
   const uint32_t homogeneous_count =
       value_type.IsHomogeneousAggregate(&base_type);
   if (homogeneous_count > 0 && homogeneous_count <= 8) {
     // Make sure we have enough registers
     if (NSRN < 8 && (8 - NSRN) >= homogeneous_count) {
       if (!base_type)
         return false;
-      const size_t base_byte_size = base_type.GetByteSize(nullptr);
+      auto base_byte_size = base_type.GetByteSize(nullptr);
+      if (!base_byte_size)
+        return false;
       uint32_t data_offset = 0;
 
       for (uint32_t i = 0; i < homogeneous_count; ++i) {
         char v_name[8];
         ::snprintf(v_name, sizeof(v_name), "v%u", NSRN);
         const RegisterInfo *reg_info =
             reg_ctx->GetRegisterInfoByName(v_name, 0);
         if (reg_info == nullptr)
           return false;
 
-        if (base_byte_size > reg_info->byte_size)
+        if (*base_byte_size > reg_info->byte_size)
           return false;
 
         RegisterValue reg_value;
 
         if (!reg_ctx->ReadRegister(reg_info, reg_value))
           return false;
 
         // Make sure we have enough room in "heap_data_ap"
-        if ((data_offset + base_byte_size) <= heap_data_ap->GetByteSize()) {
+        if ((data_offset + *base_byte_size) <= heap_data_ap->GetByteSize()) {
           const size_t bytes_copied = reg_value.GetAsMemoryData(
-              reg_info, heap_data_ap->GetBytes() + data_offset, base_byte_size,
+              reg_info, heap_data_ap->GetBytes() + data_offset, *base_byte_size,
               byte_order, error);
-          if (bytes_copied != base_byte_size)
+          if (bytes_copied != *base_byte_size)
             return false;
           data_offset += bytes_copied;
           ++NSRN;
         } else
           return false;
       }
       data.SetByteOrder(byte_order);
       data.SetAddressByteSize(exe_ctx.GetProcessRef().GetAddressByteSize());
       data.SetData(DataBufferSP(heap_data_ap.release()));
       return true;
     }
   }
 
   const size_t max_reg_byte_size = 16;
-  if (byte_size <= max_reg_byte_size) {
-    size_t bytes_left = byte_size;
+  if (*byte_size <= max_reg_byte_size) {
+    size_t bytes_left = *byte_size;
     uint32_t data_offset = 0;
-    while (data_offset < byte_size) {
+    while (data_offset < *byte_size) {
       if (NGRN >= 8)
         return false;
 
       const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
           eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + NGRN);
       if (reg_info == nullptr)
         return false;
 
ValueObjectSP ABISysV_arm64::GetReturnValueObjectImpl(
 
   // value.SetContext (Value::eContextTypeClangType, return_compiler_type);
   value.SetCompilerType(return_compiler_type);
 
   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
   if (!reg_ctx)
     return return_valobj_sp;
 
-  const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
+  auto byte_size = return_compiler_type.GetByteSize(nullptr);
+  if (!byte_size)
+    return return_valobj_sp;
 
   const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
   if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
     value.SetValueType(Value::eValueTypeScalar);
 
     bool success = false;
     if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
       // Extract the register context so we can read arguments from registers
-      if (byte_size <= 8) {
+      if (*byte_size <= 8) {
         const RegisterInfo *x0_reg_info = nullptr;
         x0_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
                                                LLDB_REGNUM_GENERIC_ARG1);
         if (x0_reg_info) {
           uint64_t raw_value =
               thread.GetRegisterContext()->ReadRegisterAsUnsigned(x0_reg_info,
                                                                   0);
           const bool is_signed = (type_flags & eTypeIsSigned) != 0;
-          switch (byte_size) {
+          switch (*byte_size) {
           default:
             break;
           case 16: // uint128_t
             // In register x0 and x1
             {
               const RegisterInfo *x1_reg_info = nullptr;
               x1_reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
                                                      LLDB_REGNUM_GENERIC_ARG2);
 
               if (x1_reg_info) {
-                if (byte_size <=
+                if (*byte_size <=
                     x0_reg_info->byte_size + x1_reg_info->byte_size) {
                   std::unique_ptr<DataBufferHeap> heap_data_ap(
-                      new DataBufferHeap(byte_size, 0));
+                      new DataBufferHeap(*byte_size, 0));
                   const ByteOrder byte_order =
                       exe_ctx.GetProcessRef().GetByteOrder();
                   RegisterValue x0_reg_value;
                   RegisterValue x1_reg_value;
                   if (reg_ctx->ReadRegister(x0_reg_info, x0_reg_value) &&
                       reg_ctx->ReadRegister(x1_reg_info, x1_reg_value)) {
                     Status error;
                     if (x0_reg_value.GetAsMemoryData(
if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
             break;
           }
         }
       }
     } else if (type_flags & eTypeIsFloat) {
       if (type_flags & eTypeIsComplex) {
         // Don't handle complex yet.
       } else {
-        if (byte_size <= sizeof(long double)) {
+        if (*byte_size <= sizeof(long double)) {
           const RegisterInfo *v0_reg_info =
               reg_ctx->GetRegisterInfoByName("v0", 0);
           RegisterValue v0_value;
           if (reg_ctx->ReadRegister(v0_reg_info, v0_value)) {
             DataExtractor data;
             if (v0_value.GetData(data)) {
               lldb::offset_t offset = 0;
-              if (byte_size == sizeof(float)) {
+              if (*byte_size == sizeof(float)) {
                 value.GetScalar() = data.GetFloat(&offset);
                 success = true;
-              } else if (byte_size == sizeof(double)) {
+              } else if (*byte_size == sizeof(double)) {
                 value.GetScalar() = data.GetDouble(&offset);
                 success = true;
-              } else if (byte_size == sizeof(long double)) {
+              } else if (*byte_size == sizeof(long double)) {
                 value.GetScalar() = data.GetLongDouble(&offset);
                 success = true;
               }
             }
           }
         }
       }
     }
 
     if (success)
       return_valobj_sp = ValueObjectConstResult::Create(
           thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
-  } else if (type_flags & eTypeIsVector && byte_size <= 16) {
-    if (byte_size > 0) {
+  } else if (type_flags & eTypeIsVector && *byte_size <= 16) {
+    if (*byte_size > 0) {
       const RegisterInfo *v0_info = reg_ctx->GetRegisterInfoByName("v0", 0);
 
       if (v0_info) {
         std::unique_ptr<DataBufferHeap> heap_data_ap(
-            new DataBufferHeap(byte_size, 0));
+            new DataBufferHeap(*byte_size, 0));
         const ByteOrder byte_order = exe_ctx.GetProcessRef().GetByteOrder();
         RegisterValue reg_value;
         if (reg_ctx->ReadRegister(v0_info, reg_value)) {
           Status error;
           if (reg_value.GetAsMemoryData(v0_info, heap_data_ap->GetBytes(),
                                         heap_data_ap->GetByteSize(), byte_order,
                                         error)) {
             DataExtractor data(DataBufferSP(heap_data_ap.release()), byte_order,
                                exe_ctx.GetProcessRef().GetAddressByteSize());
             return_valobj_sp = ValueObjectConstResult::Create(
                 &thread, return_compiler_type, ConstString(""), data);
           }
         }
       }
     }
   } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass ||
-             (type_flags & eTypeIsVector && byte_size > 16)) {
+             (type_flags & eTypeIsVector && *byte_size > 16)) {
     DataExtractor data;
 
     uint32_t NGRN = 0; // Search ABI docs for NGRN
     uint32_t NSRN = 0; // Search ABI docs for NSRN
     const bool is_return_value = true;
     if (LoadValueFromConsecutiveGPRRegisters(
             exe_ctx, reg_ctx, return_compiler_type, is_return_value, NGRN, NSRN,
             data)) {

source/Plugins/ABI/SysV-i386/ABISysV_i386.cpp

bool ABISysV_i386::GetArgumentValues(Thread &thread, ValueList &values) const {
   for (value_index = 0; value_index < num_values; ++value_index) {
     Value *value = values.GetValueAtIndex(value_index);
 
     if (!value)
       return false;
 
     // Currently: Support for extracting values with Clang QualTypes only.
     CompilerType compiler_type(value->GetCompilerType());
-    if (compiler_type) {
+    auto bit_size = compiler_type.GetBitSize(&thread);
+    if (bit_size) {
       bool is_signed;
       if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-        ReadIntegerArgument(value->GetScalar(),
-                            compiler_type.GetBitSize(&thread), is_signed,
+        ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed,
                             thread.GetProcess().get(), current_stack_argument);
       } else if (compiler_type.IsPointerType()) {
-        ReadIntegerArgument(value->GetScalar(),
-                            compiler_type.GetBitSize(&thread), false,
+        ReadIntegerArgument(value->GetScalar(), *bit_size, false,
                             thread.GetProcess().get(), current_stack_argument);
       }
     }
   }
   return true;
 }
 
 Status ABISysV_i386::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
if (type_flags & eTypeIsPointer) // 'Pointer'
     value.SetValueType(Value::eValueTypeScalar);
     value.GetScalar() = ptr;
     return_valobj_sp = ValueObjectConstResult::Create(
         thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if ((type_flags & eTypeIsScalar) ||
              (type_flags & eTypeIsEnumeration)) //'Integral' + 'Floating Point'
   {
     value.SetValueType(Value::eValueTypeScalar);
-    const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
+    auto byte_size = return_compiler_type.GetByteSize(nullptr);
+    if (!byte_size)
+      return return_valobj_sp;
     bool success = false;
 
     if (type_flags & eTypeIsInteger) // 'Integral' except enum
     {
       const bool is_signed = ((type_flags & eTypeIsSigned) != 0);
       uint64_t raw_value =
           thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
           0xffffffff;
       raw_value |=
           (thread.GetRegisterContext()->ReadRegisterAsUnsigned(edx_id, 0) &
            0xffffffff)
           << 32;
 
-      switch (byte_size) {
+      switch (*byte_size) {
       default:
         break;
 
       case 16:
         // For clang::BuiltinType::UInt128 & Int128 ToDo: Need to decide how to
         // handle it
         break;
 
if (type_flags & eTypeIsInteger) // 'Integral' except enum
           thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
           0xffffffff;
       value.SetValueType(Value::eValueTypeScalar);
       value.GetScalar() = enm;
       return_valobj_sp = ValueObjectConstResult::Create(
           thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
     } else if (type_flags & eTypeIsFloat) // 'Floating Point'
     {
-      if (byte_size <= 12) // handles float, double, long double, __float80
+      if (*byte_size <= 12) // handles float, double, long double, __float80
       {
         const RegisterInfo *st0_info = reg_ctx->GetRegisterInfoByName("st0", 0);
         RegisterValue st0_value;
 
         if (reg_ctx->ReadRegister(st0_info, st0_value)) {
           DataExtractor data;
           if (st0_value.GetData(data)) {
             lldb::offset_t offset = 0;
             long double value_long_double = data.GetLongDouble(&offset);
 
-            if (byte_size == 4) // float is 4 bytes
-            {
+            // float is 4 bytes.
+            if (*byte_size == 4) {
               float value_float = (float)value_long_double;
               value.GetScalar() = value_float;
               success = true;
-            } else if (byte_size == 8) // double is 8 bytes
-            {
+            } else if (*byte_size == 8) {
+              // double is 8 bytes
               // On Android Platform: long double is also 8 bytes It will be
               // handled here only.
               double value_double = (double)value_long_double;
               value.GetScalar() = value_double;
               success = true;
-            } else if (byte_size ==
-                       12) // long double and __float80 are 12 bytes on i386
-            {
+            } else if (*byte_size == 12) {
+              // long double and __float80 are 12 bytes on i386.
               value.GetScalar() = value_long_double;
               success = true;
             }
           }
         }
 
         if (success)
           return_valobj_sp = ValueObjectConstResult::Create(
               thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
-      } else if (byte_size == 16) // handles __float128
+      } else if (*byte_size == 16) // handles __float128
       {
         lldb::addr_t storage_addr = (uint32_t)(
             thread.GetRegisterContext()->ReadRegisterAsUnsigned(eax_id, 0) &
             0xffffffff);
         return_valobj_sp = ValueObjectMemory::Create(
             &thread, "", Address(storage_addr, nullptr), return_compiler_type);
       }
     } else // Neither 'Integral' nor 'Floating Point'
     {
       // If flow reaches here then check type_flags This type_flags is
       // unhandled
     }
   } else if (type_flags & eTypeIsComplex) // 'Complex Floating Point'
   {
     // ToDo: Yet to be implemented
   } else if (type_flags & eTypeIsVector) // 'Packed'
   {
-    const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
-    if (byte_size > 0) {
+    auto byte_size = return_compiler_type.GetByteSize(nullptr);
+    if (byte_size && *byte_size > 0) {
       const RegisterInfo *vec_reg = reg_ctx->GetRegisterInfoByName("xmm0", 0);
       if (vec_reg == nullptr)
         vec_reg = reg_ctx->GetRegisterInfoByName("mm0", 0);
 
       if (vec_reg) {
-        if (byte_size <= vec_reg->byte_size) {
+        if (*byte_size <= vec_reg->byte_size) {
           ProcessSP process_sp(thread.GetProcess());
           if (process_sp) {
             std::unique_ptr<DataBufferHeap> heap_data_ap(
-                new DataBufferHeap(byte_size, 0));
+                new DataBufferHeap(*byte_size, 0));
             const ByteOrder byte_order = process_sp->GetByteOrder();
             RegisterValue reg_value;
             if (reg_ctx->ReadRegister(vec_reg, reg_value)) {
               Status error;
               if (reg_value.GetAsMemoryData(vec_reg, heap_data_ap->GetBytes(),
                                             heap_data_ap->GetByteSize(),
                                             byte_order, error)) {
                 DataExtractor data(DataBufferSP(heap_data_ap.release()),
                                    byte_order, process_sp->GetTarget()
                                                    .GetArchitecture()
                                                    .GetAddressByteSize());
                 return_valobj_sp = ValueObjectConstResult::Create(
                     &thread, return_compiler_type, ConstString(""), data);
               }
             }
           }
-        } else if (byte_size <= vec_reg->byte_size * 2) {
+        } else if (*byte_size <= vec_reg->byte_size * 2) {
           const RegisterInfo *vec_reg2 =
               reg_ctx->GetRegisterInfoByName("xmm1", 0);
           if (vec_reg2) {
             ProcessSP process_sp(thread.GetProcess());
             if (process_sp) {
               std::unique_ptr<DataBufferHeap> heap_data_ap(
-                  new DataBufferHeap(byte_size, 0));
+                  new DataBufferHeap(*byte_size, 0));
               const ByteOrder byte_order = process_sp->GetByteOrder();
               RegisterValue reg_value;
               RegisterValue reg_value2;
               if (reg_ctx->ReadRegister(vec_reg, reg_value) &&
                   reg_ctx->ReadRegister(vec_reg2, reg_value2)) {
 
                 Status error;
                 if (reg_value.GetAsMemoryData(vec_reg, heap_data_ap->GetBytes(),

source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp

if (!reg_ctx)
     return return_valobj_sp;
 
   bool is_signed = false;
   bool is_complex = false;
   uint32_t count = 0;
 
   // In MIPS register "r2" (v0) holds the integer function return values
   const RegisterInfo *r2_reg_info = reg_ctx->GetRegisterInfoByName("r2", 0);
-  size_t bit_width = return_compiler_type.GetBitSize(&thread);
+  auto bit_width = return_compiler_type.GetBitSize(&thread);
+  if (!bit_width)
+    return return_valobj_sp;
   if (return_compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-    switch (bit_width) {
+    switch (*bit_width) {
     default:
       return return_valobj_sp;
     case 64: {
       const RegisterInfo *r3_reg_info = reg_ctx->GetRegisterInfoByName("r3", 0);
       uint64_t raw_value;
       raw_value = reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX;
       raw_value |= ((uint64_t)(reg_ctx->ReadRegisterAsUnsigned(r3_reg_info, 0) &
                                UINT32_MAX))
if (return_compiler_type.IsIntegerOrEnumerationType(is_signed)) {
     return_valobj_sp = ValueObjectMemory::Create(
         &thread, "", Address(mem_address, nullptr), return_compiler_type);
     return return_valobj_sp;
   } else if (return_compiler_type.IsFloatingPointType(count, is_complex)) {
     if (IsSoftFloat(fp_flag)) {
       uint64_t raw_value = reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0);
       if (count != 1 && is_complex)
         return return_valobj_sp;
-      switch (bit_width) {
+      switch (*bit_width) {
       default:
         return return_valobj_sp;
       case 32:
         static_assert(sizeof(float) == sizeof(uint32_t), "");
         value.GetScalar() = *((float *)(&raw_value));
         break;
       case 64:
         static_assert(sizeof(double) == sizeof(uint64_t), "");
else {
       const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);
       RegisterValue f0_value;
       DataExtractor f0_data;
       reg_ctx->ReadRegister(f0_info, f0_value);
       f0_value.GetData(f0_data);
       lldb::offset_t offset = 0;
 
       if (count == 1 && !is_complex) {
-        switch (bit_width) {
+        switch (*bit_width) {
         default:
           return return_valobj_sp;
         case 64: {
           static_assert(sizeof(double) == sizeof(uint64_t), "");
           const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
           RegisterValue f1_value;
           DataExtractor f1_data;
           reg_ctx->ReadRegister(f1_info, f1_value);

source/Plugins/ABI/SysV-mips64/ABISysV_mips64.cpp

ValueObjectSP ABISysV_mips64::GetReturnValueObjectImpl(
 
   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
   if (!reg_ctx)
     return return_valobj_sp;
 
   Target *target = exe_ctx.GetTargetPtr();
   const ArchSpec target_arch = target->GetArchitecture();
   ByteOrder target_byte_order = target_arch.GetByteOrder();
-  const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
+  auto byte_size = return_compiler_type.GetByteSize(nullptr);
+  if (!byte_size)
+    return return_valobj_sp;
   const uint32_t type_flags = return_compiler_type.GetTypeInfo(nullptr);
   uint32_t fp_flag =
       target_arch.GetFlags() & lldb_private::ArchSpec::eMIPS_ABI_FP_mask;
 
   const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0);
   const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0);
 
   if (type_flags & eTypeIsScalar || type_flags & eTypeIsPointer) {
     value.SetValueType(Value::eValueTypeScalar);
 
     bool success = false;
     if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
       // Extract the register context so we can read arguments from registers
       // In MIPS register "r2" (v0) holds the integer function return values
 
       uint64_t raw_value = reg_ctx->ReadRegisterAsUnsigned(r2_info, 0);
 
       const bool is_signed = (type_flags & eTypeIsSigned) != 0;
-      switch (byte_size) {
+      switch (*byte_size) {
       default:
         break;
 
       case sizeof(uint64_t):
         if (is_signed)
           value.GetScalar() = (int64_t)(raw_value);
         else
           value.GetScalar() = (uint64_t)(raw_value);
if (type_flags & eTypeIsInteger || type_flags & eTypeIsPointer) {
         success = true;
         break;
       }
     } else if (type_flags & eTypeIsFloat) {
       if (type_flags & eTypeIsComplex) {
         // Don't handle complex yet.
       } else if (IsSoftFloat(fp_flag)) {
         uint64_t raw_value = reg_ctx->ReadRegisterAsUnsigned(r2_info, 0);
-        switch (byte_size) {
+        switch (*byte_size) {
         case 4:
           value.GetScalar() = *((float *)(&raw_value));
           success = true;
           break;
         case 8:
           value.GetScalar() = *((double *)(&raw_value));
           success = true;
           break;
         case 16:
           uint64_t result[2];
           if (target_byte_order == eByteOrderLittle) {
             result[0] = raw_value;
             result[1] = reg_ctx->ReadRegisterAsUnsigned(r3_info, 0);
             value.GetScalar() = *((long double *)(result));
           } else {
             result[0] = reg_ctx->ReadRegisterAsUnsigned(r3_info, 0);
             result[1] = raw_value;
             value.GetScalar() = *((long double *)(result));
           }
           success = true;
           break;
         }
 
       } else {
-        if (byte_size <= sizeof(long double)) {
+        if (*byte_size <= sizeof(long double)) {
           const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);
 
           RegisterValue f0_value;
           DataExtractor f0_data;
 
           reg_ctx->ReadRegister(f0_info, f0_value);
 
           f0_value.GetData(f0_data);
 
           lldb::offset_t offset = 0;
-          if (byte_size == sizeof(float)) {
+          if (*byte_size == sizeof(float)) {
             value.GetScalar() = (float)f0_data.GetFloat(&offset);
             success = true;
-          } else if (byte_size == sizeof(double)) {
+          } else if (*byte_size == sizeof(double)) {
             value.GetScalar() = (double)f0_data.GetDouble(&offset);
             success = true;
-          } else if (byte_size == sizeof(long double)) {
+          } else if (*byte_size == sizeof(long double)) {
             const RegisterInfo *f2_info =
                 reg_ctx->GetRegisterInfoByName("f2", 0);
             RegisterValue f2_value;
             DataExtractor f2_data;
             reg_ctx->ReadRegister(f2_info, f2_value);
             DataExtractor *copy_from_extractor = nullptr;
             DataBufferSP data_sp(new DataBufferHeap(16, 0));
             DataExtractor return_ext(
                 data_sp, target_byte_order,
                 target->GetArchitecture().GetAddressByteSize());
 
             if (target_byte_order == eByteOrderLittle) {
               copy_from_extractor = &f0_data;
               copy_from_extractor->CopyByteOrderedData(
-                  0, 8, data_sp->GetBytes(), byte_size - 8, target_byte_order);
+                  0, 8, data_sp->GetBytes(), *byte_size - 8, target_byte_order);
               f2_value.GetData(f2_data);
               copy_from_extractor = &f2_data;
               copy_from_extractor->CopyByteOrderedData(
-                  0, 8, data_sp->GetBytes() + 8, byte_size - 8,
+                  0, 8, data_sp->GetBytes() + 8, *byte_size - 8,
                   target_byte_order);
             } else {
               copy_from_extractor = &f0_data;
               copy_from_extractor->CopyByteOrderedData(
-                  0, 8, data_sp->GetBytes() + 8, byte_size - 8,
+                  0, 8, data_sp->GetBytes() + 8, *byte_size - 8,
                   target_byte_order);
               f2_value.GetData(f2_data);
               copy_from_extractor = &f2_data;
               copy_from_extractor->CopyByteOrderedData(
-                  0, 8, data_sp->GetBytes(), byte_size - 8, target_byte_order);
+                  0, 8, data_sp->GetBytes(), *byte_size - 8, target_byte_order);
             }
 
             return_valobj_sp = ValueObjectConstResult::Create(
                 &thread, return_compiler_type, ConstString(""), return_ext);
             return return_valobj_sp;
           }
         }
       }
     }
 
     if (success)
       return_valobj_sp = ValueObjectConstResult::Create(
           thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if (type_flags & eTypeIsStructUnion || type_flags & eTypeIsClass ||
              type_flags & eTypeIsVector) {
     // Any structure of up to 16 bytes in size is returned in the registers.
-    if (byte_size <= 16) {
+    if (*byte_size <= 16) {
       DataBufferSP data_sp(new DataBufferHeap(16, 0));
       DataExtractor return_ext(data_sp, target_byte_order,
                                target->GetArchitecture().GetAddressByteSize());
 
       RegisterValue r2_value, r3_value, f0_value, f1_value, f2_value;
       // Tracks how much bytes of r2 and r3 registers we've consumed so far
       uint32_t integer_bytes = 0;
 
if (*byte_size <= 16) {
           reg_ctx->ReadRegister(f2_info, f2_value);
 
           f0_value.GetData(f0_data);
 
           for (uint32_t idx = 0; idx < num_children; idx++) {
             CompilerType field_compiler_type =
                 return_compiler_type.GetFieldAtIndex(
                     idx, name, &field_bit_offset, nullptr, nullptr);
-            const size_t field_byte_width =
-                field_compiler_type.GetByteSize(nullptr);
+            auto field_byte_width = field_compiler_type.GetByteSize(nullptr);
+            if (!field_byte_width)
+              return return_valobj_sp;
 
             DataExtractor *copy_from_extractor = nullptr;
             uint64_t return_value[2];
             offset_t offset = 0;
 
             if (idx == 0) {
               // This case is for long double type.
-              if (field_byte_width == 16) {
+              if (*field_byte_width == 16) {
 
                 // If structure contains long double type, then it is returned
                 // in fp0/fp1 registers.
                 if (target_byte_order == eByteOrderLittle) {
                   return_value[0] = f0_data.GetU64(&offset);
                   reg_ctx->ReadRegister(f1_info, f1_value);
                   f1_value.GetData(f1_data);
                   offset = 0;
                   return_value[1] = f1_data.GetU64(&offset);
                 } else {
                   return_value[1] = f0_data.GetU64(&offset);
                   reg_ctx->ReadRegister(f1_info, f1_value);
                   f1_value.GetData(f1_data);
                   offset = 0;
                   return_value[0] = f1_data.GetU64(&offset);
                 }
 
-                f0_data.SetData(return_value, field_byte_width,
+                f0_data.SetData(return_value, *field_byte_width,
                                 target_byte_order);
               }
               copy_from_extractor = &f0_data; // This is in f0, copy from
                                               // register to our result
                                               // structure
             } else {
               f2_value.GetData(f2_data);
               // This is in f2, copy from register to our result structure
               copy_from_extractor = &f2_data;
             }
 
             // Sanity check to avoid crash
             if (!copy_from_extractor ||
-                field_byte_width > copy_from_extractor->GetByteSize())
+                *field_byte_width > copy_from_extractor->GetByteSize())
               return return_valobj_sp;
 
             // copy the register contents into our data buffer
             copy_from_extractor->CopyByteOrderedData(
-                0, field_byte_width,
-                data_sp->GetBytes() + (field_bit_offset / 8), field_byte_width,
+                0, *field_byte_width,
+                data_sp->GetBytes() + (field_bit_offset / 8), *field_byte_width,
                 target_byte_order);
           }
 
           // The result is in our data buffer.  Create a variable object out of
           // it
           return_valobj_sp = ValueObjectConstResult::Create(
               &thread, return_compiler_type, ConstString(""), return_ext);
 
           return return_valobj_sp;
         }
       }
 
       // If we reach here, it means this structure either contains more than
       // two fields or it contains at least one non floating point type. In
       // that case, all fields are returned in GP return registers.
       for (uint32_t idx = 0; idx < num_children; idx++) {
         uint64_t field_bit_offset = 0;
         bool is_signed;
         uint32_t padding;
 
         CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex(
             idx, name, &field_bit_offset, nullptr, nullptr);
-        const size_t field_byte_width =
-            field_compiler_type.GetByteSize(nullptr);
+        auto field_byte_width = field_compiler_type.GetByteSize(nullptr);
 
         // if we don't know the size of the field (e.g. invalid type), just
         // bail out
-        if (field_byte_width == 0)
+        if (!field_byte_width || *field_byte_width == 0)
           break;
 
         uint32_t field_byte_offset = field_bit_offset / 8;
 
         if (field_compiler_type.IsIntegerOrEnumerationType(is_signed) ||
             field_compiler_type.IsPointerType() ||
             field_compiler_type.IsFloatingPointType(count, is_complex)) {
           padding = field_byte_offset - integer_bytes;
 
           if (integer_bytes < 8) {
             // We have not yet consumed r2 completely.
-            if (integer_bytes + field_byte_width + padding <= 8) {
+            if (integer_bytes + *field_byte_width + padding <= 8) {
               // This field fits in r2, copy its value from r2 to our result
               // structure
-              integer_bytes = integer_bytes + field_byte_width +
+              integer_bytes = integer_bytes + *field_byte_width +
                               padding; // Increase the consumed bytes.
               use_r2 = 1;
             } else {
               // There isn't enough space left in r2 for this field, so this
               // will be in r3.
-              integer_bytes = integer_bytes + field_byte_width +
+              integer_bytes = integer_bytes + *field_byte_width +
                               padding; // Increase the consumed bytes.
               use_r3 = 1;
             }
           }
           // We already have consumed at-least 8 bytes that means r2 is done,
           // and this field will be in r3. Check if this field can fit in r3.
-          else if (integer_bytes + field_byte_width + padding <= 16) {
-            integer_bytes = integer_bytes + field_byte_width + padding;
+          else if (integer_bytes + *field_byte_width + padding <= 16) {
+            integer_bytes = integer_bytes + *field_byte_width + padding;
             use_r3 = 1;
           } else {
             // There isn't any space left for this field, this should not
             // happen as we have already checked the overall size is not
             // greater than 16 bytes. For now, return a nullptr return value
             // object.
             return return_valobj_sp;
           }
         }
       }
       // Vector types up to 16 bytes are returned in GP return registers
       if (type_flags & eTypeIsVector) {
-        if (byte_size <= 8)
+        if (*byte_size <= 8)
           use_r2 = 1;
         else {
           use_r2 = 1;
           use_r3 = 1;
         }
       }
 
       if (use_r2) {

source/Plugins/ABI/SysV-ppc/ABISysV_ppc.cpp

for (value_index = 0; value_index < num_values; ++value_index) {
     Value *value = values.GetValueAtIndex(value_index);
 
     if (!value)
       return false;
 
     // We currently only support extracting values with Clang QualTypes. Do we
     // care about others?
     CompilerType compiler_type = value->GetCompilerType();
-    if (!compiler_type)
+    auto bit_size = compiler_type.GetBitSize(&thread);
+    if (!bit_size)
       return false;
     bool is_signed;
-
-    if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-      ReadIntegerArgument(value->GetScalar(), compiler_type.GetBitSize(&thread),
-                          is_signed, thread, argument_register_ids,
-                          current_argument_register, current_stack_argument);
-    } else if (compiler_type.IsPointerType()) {
-      ReadIntegerArgument(value->GetScalar(), compiler_type.GetBitSize(&thread),
-                          false, thread, argument_register_ids,
-                          current_argument_register, current_stack_argument);
-    }
+    if (compiler_type.IsIntegerOrEnumerationType(is_signed))
+      ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,
+                          argument_register_ids, current_argument_register,
+                          current_stack_argument);
+    else if (compiler_type.IsPointerType())
+      ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,
+                          argument_register_ids, current_argument_register,
+                          current_stack_argument);
   }
 
   return true;
 }
 
 Status ABISysV_ppc::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
                                          lldb::ValueObjectSP &new_value_sp) {
   Status error;
if (num_bytes <= 8) {
       error.SetErrorString("We don't support returning longer than 64 bit "
                            "integer values at present.");
     }
   } else if (compiler_type.IsFloatingPointType(count, is_complex)) {
     if (is_complex)
       error.SetErrorString(
           "We don't support returning complex values at present");
     else {
-      size_t bit_width = compiler_type.GetBitSize(frame_sp.get());
-      if (bit_width <= 64) {
+      auto bit_width = compiler_type.GetBitSize(frame_sp.get());
+      if (!bit_width) {
+        error.SetErrorString("can't get type size");
+        return error;
+      }
+      if (*bit_width <= 64) {
         DataExtractor data;
         Status data_error;
         size_t num_bytes = new_value_sp->GetData(data, data_error);
         if (data_error.Fail()) {
           error.SetErrorStringWithFormat(
               "Couldn't convert return value to raw data: %s",
               data_error.AsCString());
           return error;
ValueObjectSP ABISysV_ppc::GetReturnValueObjectSimple(
   const uint32_t type_flags = return_compiler_type.GetTypeInfo();
   if (type_flags & eTypeIsScalar) {
     value.SetValueType(Value::eValueTypeScalar);
 
     bool success = false;
     if (type_flags & eTypeIsInteger) {
       // Extract the register context so we can read arguments from registers
 
-      const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
+      auto byte_size = return_compiler_type.GetByteSize(nullptr);
+      if (!byte_size)
+        return return_valobj_sp;
       uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
           reg_ctx->GetRegisterInfoByName("r3", 0), 0);
       const bool is_signed = (type_flags & eTypeIsSigned) != 0;
-      switch (byte_size) {
+      switch (*byte_size) {
       default:
         break;
 
       case sizeof(uint64_t):
         if (is_signed)
           value.GetScalar() = (int64_t)(raw_value);
         else
           value.GetScalar() = (uint64_t)(raw_value);
if (type_flags & eTypeIsInteger) {
           value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
         success = true;
         break;
       }
     } else if (type_flags & eTypeIsFloat) {
       if (type_flags & eTypeIsComplex) {
         // Don't handle complex yet.
       } else {
-        const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
-        if (byte_size <= sizeof(long double)) {
+        auto byte_size = return_compiler_type.GetByteSize(nullptr);
+        if (byte_size && *byte_size <= sizeof(long double)) {
           const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
           RegisterValue f1_value;
           if (reg_ctx->ReadRegister(f1_info, f1_value)) {
             DataExtractor data;
             if (f1_value.GetData(data)) {
               lldb::offset_t offset = 0;
-              if (byte_size == sizeof(float)) {
+              if (*byte_size == sizeof(float)) {
                 value.GetScalar() = (float)data.GetFloat(&offset);
                 success = true;
-              } else if (byte_size == sizeof(double)) {
+              } else if (*byte_size == sizeof(double)) {
                 value.GetScalar() = (double)data.GetDouble(&offset);
                 success = true;
               }
             }
           }
         }
       }
     }
 
     if (success)
       return_valobj_sp = ValueObjectConstResult::Create(
           thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if (type_flags & eTypeIsPointer) {
     unsigned r3_id =
         reg_ctx->GetRegisterInfoByName("r3", 0)->kinds[eRegisterKindLLDB];
     value.GetScalar() =
         (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0);
     value.SetValueType(Value::eValueTypeScalar);
     return_valobj_sp = ValueObjectConstResult::Create(
         thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if (type_flags & eTypeIsVector) {
-    const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
-    if (byte_size > 0) {
+    auto byte_size = return_compiler_type.GetByteSize(nullptr);
+    if (byte_size && *byte_size > 0) {
       const RegisterInfo *altivec_reg = reg_ctx->GetRegisterInfoByName("v2", 0);
       if (altivec_reg) {
-        if (byte_size <= altivec_reg->byte_size) {
+        if (*byte_size <= altivec_reg->byte_size) {
           ProcessSP process_sp(thread.GetProcess());
           if (process_sp) {
             std::unique_ptr<DataBufferHeap> heap_data_ap(
-                new DataBufferHeap(byte_size, 0));
+                new DataBufferHeap(*byte_size, 0));
             const ByteOrder byte_order = process_sp->GetByteOrder();
             RegisterValue reg_value;
             if (reg_ctx->ReadRegister(altivec_reg, reg_value)) {
               Status error;
               if (reg_value.GetAsMemoryData(
                       altivec_reg, heap_data_ap->GetBytes(),
                       heap_data_ap->GetByteSize(), byte_order, error)) {
                 DataExtractor data(DataBufferSP(heap_data_ap.release()),
-                                   byte_order, process_sp->GetTarget()
-                                                   .GetArchitecture()
-                                                   .GetAddressByteSize());
+                                   byte_order,
+                                   process_sp->GetTarget()
                 return_valobj_sp = ValueObjectConstResult::Create(
                     &thread, return_compiler_type, ConstString(""), data);
               }
             }
           }
         }
       }
     }
ValueObjectSP ABISysV_ppc::GetReturnValueObjectImpl(
   return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
   if (return_valobj_sp)
     return return_valobj_sp;
 
   RegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
   if (!reg_ctx_sp)
     return return_valobj_sp;
 
-  const size_t bit_width = return_compiler_type.GetBitSize(&thread);
+  auto bit_width = return_compiler_type.GetBitSize(&thread);
+  if (!bit_width)
+    return return_valobj_sp;
   if (return_compiler_type.IsAggregateType()) {
     Target *target = exe_ctx.GetTargetPtr();
     bool is_memory = true;
-    if (bit_width <= 128) {
+    if (*bit_width <= 128) {
       ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder();
       DataBufferSP data_sp(new DataBufferHeap(16, 0));
       DataExtractor return_ext(data_sp, target_byte_order,
                                target->GetArchitecture().GetAddressByteSize());
 
       const RegisterInfo *r3_info = reg_ctx_sp->GetRegisterInfoByName("r3", 0);
       const RegisterInfo *rdx_info =
           reg_ctx_sp->GetRegisterInfoByName("rdx", 0);
if (*bit_width <= 128) {
         std::string name;
         uint64_t field_bit_offset = 0;
         bool is_signed;
         bool is_complex;
         uint32_t count;
 
         CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex(
             idx, name, &field_bit_offset, nullptr, nullptr);
-        const size_t field_bit_width = field_compiler_type.GetBitSize(&thread);
+        auto field_bit_width = field_compiler_type.GetBitSize(&thread);
+        if (!field_bit_width)
+          return return_valobj_sp;
 
         // If there are any unaligned fields, this is stored in memory.
-        if (field_bit_offset % field_bit_width != 0) {
+        if (field_bit_offset % *field_bit_width != 0) {
           is_memory = true;
           break;
         }
 
-        uint32_t field_byte_width = field_bit_width / 8;
+        uint32_t field_byte_width = *field_bit_width / 8;
         uint32_t field_byte_offset = field_bit_offset / 8;
 
         DataExtractor *copy_from_extractor = nullptr;
         uint32_t copy_from_offset = 0;
 
         if (field_compiler_type.IsIntegerOrEnumerationType(is_signed) ||
             field_compiler_type.IsPointerType()) {
           if (integer_bytes < 8) {
if (*bit_width <= 128) {
           } else {
             // The last field didn't fit.  I can't see how that would happen
             // w/o the overall size being greater than 16 bytes.  For now,
             // return a nullptr return value object.
             return return_valobj_sp;
           }
         } else if (field_compiler_type.IsFloatingPointType(count, is_complex)) {
           // Structs with long doubles are always passed in memory.
-          if (field_bit_width == 128) {
+          if (*field_bit_width == 128) {
             is_memory = true;
             break;
-          } else if (field_bit_width == 64) {
+          } else if (*field_bit_width == 64) {
             copy_from_offset = 0;
             fp_bytes += field_byte_width;
-          } else if (field_bit_width == 32) {
+          } else if (*field_bit_width == 32) {
             // This one is kind of complicated.  If we are in an "eightbyte"
             // with another float, we'll be stuffed into an xmm register with
             // it.  If we are in an "eightbyte" with one or more ints, then we
             // will be stuffed into the appropriate GPR with them.
             bool in_gpr;
             if (field_byte_offset % 8 == 0) {
               // We are at the beginning of one of the eightbytes, so check the
               // next element (if any)

source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

for (value_index = 0; value_index < num_values; ++value_index) {
     Value *value = values.GetValueAtIndex(value_index);
 
     if (!value)
       return false;
 
     // We currently only support extracting values with Clang QualTypes. Do we
     // care about others?
     CompilerType compiler_type = value->GetCompilerType();
-    if (!compiler_type)
+    auto bit_size = compiler_type.GetBitSize(&thread);
+    if (!bit_size)
       return false;
     bool is_signed;
 
     if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-      ReadIntegerArgument(value->GetScalar(), compiler_type.GetBitSize(&thread),
-                          is_signed, thread, argument_register_ids,
-                          current_argument_register, current_stack_argument);
+      ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,
+                          argument_register_ids, current_argument_register,
+                          current_stack_argument);
     } else if (compiler_type.IsPointerType()) {
-      ReadIntegerArgument(value->GetScalar(), compiler_type.GetBitSize(&thread),
-                          false, thread, argument_register_ids,
-                          current_argument_register, current_stack_argument);
+      ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,
+                          argument_register_ids, current_argument_register,
+                          current_stack_argument);
     }
   }
 
   return true;
 }
 
 Status ABISysV_ppc64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
                                            lldb::ValueObjectSP &new_value_sp) {
if (num_bytes <= 8) {
       error.SetErrorString("We don't support returning longer than 64 bit "
                            "integer values at present.");
     }
   } else if (compiler_type.IsFloatingPointType(count, is_complex)) {
     if (is_complex)
       error.SetErrorString(
           "We don't support returning complex values at present");
     else {
-      size_t bit_width = compiler_type.GetBitSize(frame_sp.get());
-      if (bit_width <= 64) {
+      auto bit_width = compiler_type.GetBitSize(frame_sp.get());
+      if (!bit_width) {
+        error.SetErrorString("can't get size of type");
+        return error;
+      }
+      if (*bit_width <= 64) {
         DataExtractor data;
         Status data_error;
         size_t num_bytes = new_value_sp->GetData(data, data_error);
         if (data_error.Fail()) {
           error.SetErrorStringWithFormat(
               "Couldn't convert return value to raw data: %s",
               data_error.AsCString());
           return error;
private:
   uint32_t m_addr_size;
 
   // methods
 
   // constructor
   ReturnValueExtractor(Thread &thread, CompilerType &type,
                        RegisterContext *reg_ctx, ProcessSP process_sp)
       : m_thread(thread), m_type(type),
-        m_byte_size(m_type.GetByteSize(nullptr)),
+        m_byte_size(m_type.GetByteSize(nullptr) ? *m_type.GetByteSize(nullptr)
+                                                : 0),
         m_data_ap(new DataBufferHeap(m_byte_size, 0)), m_reg_ctx(reg_ctx),
         m_process_sp(process_sp), m_byte_order(process_sp->GetByteOrder()),
         m_addr_size(
             process_sp->GetTarget().GetArchitecture().GetAddressByteSize()) {}
 
   // build a new scalar value
   ValueSP NewScalarValue(CompilerType &type) {
     ValueSP value_sp(new Value);
ValueSP GetIntegerValue(uint32_t reg_index) {
     return value_sp;
   }
 
   // get a floating point value on the specified register
   ValueSP GetFloatValue(CompilerType &type, uint32_t reg_index) {
     uint64_t raw_data;
     auto reg = GetFPR(reg_index);
     if (!reg.GetRawData(raw_data))
-      return ValueSP();
+      return {};
 
     // build value from data
     ValueSP value_sp(NewScalarValue(type));
 
     DataExtractor de(&raw_data, sizeof(raw_data), m_byte_order, m_addr_size);
 
     offset_t offset = 0;
-    size_t byte_size = type.GetByteSize(nullptr);
-    switch (byte_size) {
+    auto byte_size = type.GetByteSize(nullptr);
+    if (!byte_size)
+      return {};
+    switch (*byte_size) {
     case sizeof(float):
       value_sp->GetScalar() = (float)de.GetDouble(&offset);
       break;
 
     case sizeof(double):
       value_sp->GetScalar() = de.GetDouble(&offset);
       break;
 
private:
 
   // get a struct return value
   ValueObjectSP GetStructValueObject() {
     // case 1: get from stack
     if (m_byte_size > 2 * sizeof(uint64_t)) {
       uint64_t addr;
       auto reg = GetGPR(0);
       if (!reg.GetRawData(addr))
-        return ValueObjectSP();
+        return {};
 
       Status error;
       size_t rc = m_process_sp->ReadMemory(addr, m_data_ap->GetBytes(),
                                            m_byte_size, error);
       if (rc != m_byte_size) {
         LLDB_LOG(m_log, LOG_PREFIX "Failed to read memory pointed by r3");
         return ValueObjectSP();
       }
       return BuildValueObject();
     }
 
     // get number of children
     const bool omit_empty_base_classes = true;
     uint32_t n = m_type.GetNumChildren(omit_empty_base_classes, nullptr);
     if (!n) {
       LLDB_LOG(m_log, LOG_PREFIX "No children found in struct");
-      return ValueObjectSP();
+      return {};
     }
 
     // case 2: homogeneous double or float aggregate
     CompilerType elem_type;
     if (m_type.IsHomogeneousAggregate(&elem_type)) {
       uint32_t type_flags = elem_type.GetTypeInfo();
-      uint64_t elem_size = elem_type.GetByteSize(nullptr);
+      auto elem_size = elem_type.GetByteSize(nullptr);
+      if (!elem_size)
+        return {};
       if (type_flags & eTypeIsComplex || !(type_flags & eTypeIsFloat)) {
         LLDB_LOG(m_log,
                  LOG_PREFIX "Unexpected type found in homogeneous aggregate");
-        return ValueObjectSP();
+        return {};
       }
 
       for (uint32_t i = 0; i < n; i++) {
         ValueSP val_sp = GetFloatValue(elem_type, i);
         if (!val_sp)
-          return ValueObjectSP();
+          return {};
 
         // copy to buffer
         Status error;
         size_t rc = val_sp->GetScalar().GetAsMemoryData(
-            m_data_ap->GetBytes() + m_dst_offs, elem_size, m_byte_order, error);
-        if (rc != elem_size) {
+            m_data_ap->GetBytes() + m_dst_offs, *elem_size, m_byte_order, error);
+        if (rc != *elem_size) {
           LLDB_LOG(m_log, LOG_PREFIX "Failed to get float data");
-          return ValueObjectSP();
+          return {};
         }
-        m_dst_offs += elem_size;
+        m_dst_offs += *elem_size;
       }
       return BuildValueObject();
     }
 
     // case 3: get from GPRs
 
     // first, check if this is a packed struct or not
     ClangASTContext *ast =

source/Plugins/ABI/SysV-s390x/ABISysV_s390x.cpp

for (value_index = 0; value_index < num_values; ++value_index) {
     Value *value = values.GetValueAtIndex(value_index);
 
     if (!value)
       return false;
 
     // We currently only support extracting values with Clang QualTypes. Do we
     // care about others?
     CompilerType compiler_type = value->GetCompilerType();
-    if (!compiler_type)
+    auto bit_size = compiler_type.GetBitSize(&thread);
+    if (!bit_size)
       return false;
     bool is_signed;
 
     if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-      ReadIntegerArgument(value->GetScalar(), compiler_type.GetBitSize(&thread),
-                          is_signed, thread, argument_register_ids,
-                          current_argument_register, current_stack_argument);
+      ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,
+                          argument_register_ids, current_argument_register,
+                          current_stack_argument);
     } else if (compiler_type.IsPointerType()) {
-      ReadIntegerArgument(value->GetScalar(), compiler_type.GetBitSize(&thread),
-                          false, thread, argument_register_ids,
-                          current_argument_register, current_stack_argument);
+      ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,
+                          argument_register_ids, current_argument_register,
+                          current_stack_argument);
     }
   }
 
   return true;
 }
 
 Status ABISysV_s390x::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
                                            lldb::ValueObjectSP &new_value_sp) {
if (num_bytes <= 8) {
       error.SetErrorString("We don't support returning longer than 64 bit "
                            "integer values at present.");
     }
   } else if (compiler_type.IsFloatingPointType(count, is_complex)) {
     if (is_complex)
       error.SetErrorString(
           "We don't support returning complex values at present");
     else {
-      size_t bit_width = compiler_type.GetBitSize(frame_sp.get());
-      if (bit_width <= 64) {
+      auto bit_width = compiler_type.GetBitSize(frame_sp.get());
+      if (!bit_width) {
+        error.SetErrorString("can't get type size");
+        return error;
+      }
+      if (*bit_width <= 64) {
         const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);
         RegisterValue f0_value;
         DataExtractor data;
         Status data_error;
         size_t num_bytes = new_value_sp->GetData(data, data_error);
         if (data_error.Fail()) {
           error.SetErrorStringWithFormat(
               "Couldn't convert return value to raw data: %s",
ValueObjectSP ABISysV_s390x::GetReturnValueObjectSimple(
   const uint32_t type_flags = return_compiler_type.GetTypeInfo();
   if (type_flags & eTypeIsScalar) {
     value.SetValueType(Value::eValueTypeScalar);
 
     bool success = false;
     if (type_flags & eTypeIsInteger) {
       // Extract the register context so we can read arguments from registers
 
-      const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
+      auto byte_size = return_compiler_type.GetByteSize(nullptr);
+      if (!byte_size)
+        return return_valobj_sp;
       uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
           reg_ctx->GetRegisterInfoByName("r2", 0), 0);
       const bool is_signed = (type_flags & eTypeIsSigned) != 0;
-      switch (byte_size) {
+      switch (*byte_size) {
       default:
         break;
 
       case sizeof(uint64_t):
         if (is_signed)
           value.GetScalar() = (int64_t)(raw_value);
         else
           value.GetScalar() = (uint64_t)(raw_value);
if (type_flags & eTypeIsInteger) {
           value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
         success = true;
         break;
       }
     } else if (type_flags & eTypeIsFloat) {
       if (type_flags & eTypeIsComplex) {
         // Don't handle complex yet.
       } else {
-        const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
-        if (byte_size <= sizeof(long double)) {
+        auto byte_size = return_compiler_type.GetByteSize(nullptr);
+        if (byte_size && *byte_size <= sizeof(long double)) {
           const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);
           RegisterValue f0_value;
           if (reg_ctx->ReadRegister(f0_info, f0_value)) {
             DataExtractor data;
             if (f0_value.GetData(data)) {
               lldb::offset_t offset = 0;
-              if (byte_size == sizeof(float)) {
+              if (*byte_size == sizeof(float)) {
                 value.GetScalar() = (float)data.GetFloat(&offset);
                 success = true;
-              } else if (byte_size == sizeof(double)) {
+              } else if (*byte_size == sizeof(double)) {
                 value.GetScalar() = (double)data.GetDouble(&offset);
                 success = true;
-              } else if (byte_size == sizeof(long double)) {
+              } else if (*byte_size == sizeof(long double)) {
                 // Don't handle long double yet.
               }
             }
           }
         }
       }
     }
 

source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

for (value_index = 0; value_index < num_values; ++value_index) {
     Value *value = values.GetValueAtIndex(value_index);
 
     if (!value)
       return false;
 
     // We currently only support extracting values with Clang QualTypes. Do we
     // care about others?
     CompilerType compiler_type = value->GetCompilerType();
-    if (!compiler_type)
+    auto bit_size = compiler_type.GetBitSize(&thread);
+    if (!bit_size)
       return false;
     bool is_signed;
 
     if (compiler_type.IsIntegerOrEnumerationType(is_signed)) {
-      ReadIntegerArgument(value->GetScalar(), compiler_type.GetBitSize(&thread),
-                          is_signed, thread, argument_register_ids,
-                          current_argument_register, current_stack_argument);
+      ReadIntegerArgument(value->GetScalar(), *bit_size, is_signed, thread,
+                          argument_register_ids, current_argument_register,
+                          current_stack_argument);
     } else if (compiler_type.IsPointerType()) {
-      ReadIntegerArgument(value->GetScalar(), compiler_type.GetBitSize(&thread),
-                          false, thread, argument_register_ids,
-                          current_argument_register, current_stack_argument);
+      ReadIntegerArgument(value->GetScalar(), *bit_size, false, thread,
+                          argument_register_ids, current_argument_register,
+                          current_stack_argument);
     }
   }
 
   return true;
 }
 
 Status ABISysV_x86_64::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
                                             lldb::ValueObjectSP &new_value_sp) {
if (num_bytes <= 8) {
       error.SetErrorString("We don't support returning longer than 64 bit "
                            "integer values at present.");
     }
   } else if (compiler_type.IsFloatingPointType(count, is_complex)) {
     if (is_complex)
       error.SetErrorString(
           "We don't support returning complex values at present");
     else {
-      size_t bit_width = compiler_type.GetBitSize(frame_sp.get());
-      if (bit_width <= 64) {
+      auto bit_width = compiler_type.GetBitSize(frame_sp.get());
+      if (!bit_width) {
+        error.SetErrorString("can't get type size");
+        return error;
+      }
+      if (*bit_width <= 64) {
         const RegisterInfo *xmm0_info =
             reg_ctx->GetRegisterInfoByName("xmm0", 0);
         RegisterValue xmm0_value;
         DataExtractor data;
         Status data_error;
         size_t num_bytes = new_value_sp->GetData(data, data_error);
         if (data_error.Fail()) {
           error.SetErrorStringWithFormat(
ValueObjectSP ABISysV_x86_64::GetReturnValueObjectSimple(
   const uint32_t type_flags = return_compiler_type.GetTypeInfo();
   if (type_flags & eTypeIsScalar) {
     value.SetValueType(Value::eValueTypeScalar);
 
     bool success = false;
     if (type_flags & eTypeIsInteger) {
       // Extract the register context so we can read arguments from registers
 
-      const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
+      auto byte_size = return_compiler_type.GetByteSize(nullptr);
+      if (!byte_size)
+        return return_valobj_sp;
       uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(
           reg_ctx->GetRegisterInfoByName("rax", 0), 0);
       const bool is_signed = (type_flags & eTypeIsSigned) != 0;
-      switch (byte_size) {
+      switch (*byte_size) {
       default:
         break;
 
       case sizeof(uint64_t):
         if (is_signed)
           value.GetScalar() = (int64_t)(raw_value);
         else
           value.GetScalar() = (uint64_t)(raw_value);
if (type_flags & eTypeIsInteger) {
           value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
         success = true;
         break;
       }
     } else if (type_flags & eTypeIsFloat) {
       if (type_flags & eTypeIsComplex) {
         // Don't handle complex yet.
       } else {
-        const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
-        if (byte_size <= sizeof(long double)) {
+        auto byte_size = return_compiler_type.GetByteSize(nullptr);
+        if (byte_size && *byte_size <= sizeof(long double)) {
           const RegisterInfo *xmm0_info =
               reg_ctx->GetRegisterInfoByName("xmm0", 0);
           RegisterValue xmm0_value;
           if (reg_ctx->ReadRegister(xmm0_info, xmm0_value)) {
             DataExtractor data;
             if (xmm0_value.GetData(data)) {
               lldb::offset_t offset = 0;
-              if (byte_size == sizeof(float)) {
+              if (*byte_size == sizeof(float)) {
                 value.GetScalar() = (float)data.GetFloat(&offset);
                 success = true;
-              } else if (byte_size == sizeof(double)) {
+              } else if (*byte_size == sizeof(double)) {
                 value.GetScalar() = (double)data.GetDouble(&offset);
                 success = true;
-              } else if (byte_size == sizeof(long double)) {
+              } else if (*byte_size == sizeof(long double)) {
                 // Don't handle long double since that can be encoded as 80 bit
                 // floats...
               }
             }
           }
         }
       }
     }
 
     if (success)
       return_valobj_sp = ValueObjectConstResult::Create(
           thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if (type_flags & eTypeIsPointer) {
     unsigned rax_id =
         reg_ctx->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB];
     value.GetScalar() =
         (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id,
                                                                       0);
     value.SetValueType(Value::eValueTypeScalar);
     return_valobj_sp = ValueObjectConstResult::Create(
         thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
   } else if (type_flags & eTypeIsVector) {
-    const size_t byte_size = return_compiler_type.GetByteSize(nullptr);
-    if (byte_size > 0) {
+    auto byte_size = return_compiler_type.GetByteSize(nullptr);
+    if (byte_size && *byte_size > 0) {
       const RegisterInfo *altivec_reg =
           reg_ctx->GetRegisterInfoByName("xmm0", 0);
       if (altivec_reg == nullptr)
         altivec_reg = reg_ctx->GetRegisterInfoByName("mm0", 0);
 
       if (altivec_reg) {
-        if (byte_size <= altivec_reg->byte_size) {
+        if (*byte_size <= altivec_reg->byte_size) {
           ProcessSP process_sp(thread.GetProcess());
           if (process_sp) {
             std::unique_ptr<DataBufferHeap> heap_data_ap(
-                new DataBufferHeap(byte_size, 0));
+                new DataBufferHeap(*byte_size, 0));
             const ByteOrder byte_order = process_sp->GetByteOrder();
             RegisterValue reg_value;
             if (reg_ctx->ReadRegister(altivec_reg, reg_value)) {
               Status error;
               if (reg_value.GetAsMemoryData(
                       altivec_reg, heap_data_ap->GetBytes(),
                       heap_data_ap->GetByteSize(), byte_order, error)) {
                 DataExtractor data(DataBufferSP(heap_data_ap.release()),
                                    byte_order, process_sp->GetTarget()
                                                    .GetArchitecture()
                                                    .GetAddressByteSize());
                 return_valobj_sp = ValueObjectConstResult::Create(
                     &thread, return_compiler_type, ConstString(""), data);
               }
             }
           }
-        } else if (byte_size <= altivec_reg->byte_size * 2) {
+        } else if (*byte_size <= altivec_reg->byte_size * 2) {
           const RegisterInfo *altivec_reg2 =
               reg_ctx->GetRegisterInfoByName("xmm1", 0);
           if (altivec_reg2) {
             ProcessSP process_sp(thread.GetProcess());
             if (process_sp) {
               std::unique_ptr<DataBufferHeap> heap_data_ap(
-                  new DataBufferHeap(byte_size, 0));
+                  new DataBufferHeap(*byte_size, 0));
               const ByteOrder byte_order = process_sp->GetByteOrder();
               RegisterValue reg_value;
               RegisterValue reg_value2;
               if (reg_ctx->ReadRegister(altivec_reg, reg_value) &&
                   reg_ctx->ReadRegister(altivec_reg2, reg_value2)) {
 
                 Status error;
                 if (reg_value.GetAsMemoryData(
ValueObjectSP ABISysV_x86_64::GetReturnValueObjectImpl(
   return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type);
   if (return_valobj_sp)
     return return_valobj_sp;
 
   RegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
   if (!reg_ctx_sp)
     return return_valobj_sp;
 
-  const size_t bit_width = return_compiler_type.GetBitSize(&thread);
+  auto bit_width = return_compiler_type.GetBitSize(&thread);
+  if (!bit_width)
+    return return_valobj_sp;
   if (return_compiler_type.IsAggregateType()) {
     Target *target = exe_ctx.GetTargetPtr();
     bool is_memory = true;
-    if (bit_width <= 128) {
+    if (*bit_width <= 128) {
       ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder();
       DataBufferSP data_sp(new DataBufferHeap(16, 0));
       DataExtractor return_ext(data_sp, target_byte_order,
                                target->GetArchitecture().GetAddressByteSize());
 
       const RegisterInfo *rax_info =
           reg_ctx_sp->GetRegisterInfoByName("rax", 0);
       const RegisterInfo *rdx_info =
if (*bit_width <= 128) {
         std::string name;
         uint64_t field_bit_offset = 0;
         bool is_signed;
         bool is_complex;
         uint32_t count;
 
         CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex(
             idx, name, &field_bit_offset, nullptr, nullptr);
-        const size_t field_bit_width = field_compiler_type.GetBitSize(&thread);
+        auto field_bit_width = field_compiler_type.GetBitSize(&thread);
 
         // if we don't know the size of the field (e.g. invalid type), just
         // bail out
-        if (field_bit_width == 0)
+        if (!field_bit_width || *field_bit_width == 0)
           break;
 
         // If there are any unaligned fields, this is stored in memory.
-        if (field_bit_offset % field_bit_width != 0) {
+        if (field_bit_offset % *field_bit_width != 0) {
           is_memory = true;
           break;
         }
 
-        uint32_t field_byte_width = field_bit_width / 8;
+        uint32_t field_byte_width = *field_bit_width / 8;
         uint32_t field_byte_offset = field_bit_offset / 8;
 
         DataExtractor *copy_from_extractor = nullptr;
         uint32_t copy_from_offset = 0;
 
         if (field_compiler_type.IsIntegerOrEnumerationType(is_signed) ||
             field_compiler_type.IsPointerType()) {
           if (integer_bytes < 8) {
if (*bit_width <= 128) {
           } else {
             // The last field didn't fit.  I can't see how that would happen
             // w/o the overall size being greater than 16 bytes.  For now,
             // return a nullptr return value object.
             return return_valobj_sp;
           }
         } else if (field_compiler_type.IsFloatingPointType(count, is_complex)) {
           // Structs with long doubles are always passed in memory.
-          if (field_bit_width == 128) {
+          if (*field_bit_width == 128) {
             is_memory = true;
             break;
-          } else if (field_bit_width == 64) {
+          } else if (*field_bit_width == 64) {
             // These have to be in a single xmm register.
             if (fp_bytes == 0)
               copy_from_extractor = &xmm0_data;
             else
               copy_from_extractor = &xmm1_data;
 
             copy_from_offset = 0;
             fp_bytes += field_byte_width;
-          } else if (field_bit_width == 32) {
+          } else if (*field_bit_width == 32) {
             // This one is kind of complicated.  If we are in an "eightbyte"
             // with another float, we'll be stuffed into an xmm register with
             // it.  If we are in an "eightbyte" with one or more ints, then we
             // will be stuffed into the appropriate GPR with them.
             bool in_gpr;
             if (field_byte_offset % 8 == 0) {
               // We are at the beginning of one of the eightbytes, so check the
               // next element (if any)

source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

if (m_result_is_pointer) {
     m_result_type = lldb_private::TypeFromParser(
         result_var->getType().getAsOpaquePtr(),
         lldb_private::ClangASTContext::GetASTContext(
             &result_decl->getASTContext()));
   }
 
   lldb::TargetSP target_sp(m_execution_unit.GetTarget());
   lldb_private::ExecutionContext exe_ctx(target_sp, true);
-  if (m_result_type.GetBitSize(exe_ctx.GetBestExecutionContextScope()) == 0) {
+  auto bit_size =
+      m_result_type.GetBitSize(exe_ctx.GetBestExecutionContextScope());
+  if (!bit_size) {
     lldb_private::StreamString type_desc_stream;
     m_result_type.DumpTypeDescription(&type_desc_stream);
 
     if (log)
-      log->Printf("Result type has size 0");
+      log->Printf("Result type has unknown size");
 
     m_error_stream.Printf("Error [IRForTarget]: Size of result type '%s' "
                           "couldn't be determined\n",
                           type_desc_stream.GetData());
     return false;
   }
 
   if (log) {
     lldb_private::StreamString type_desc_stream;
     m_result_type.DumpTypeDescription(&type_desc_stream);
 
     log->Printf("Result decl type: \"%s\"", type_desc_stream.GetData());
   }
 
   m_result_name = lldb_private::ConstString("$RESULT_NAME");
 
   if (log)
     log->Printf("Creating a new result global: \"%s\" with size 0x%" PRIx64,
-                m_result_name.GetCString(), m_result_type.GetByteSize(nullptr));
+                m_result_name.GetCString(),
+                m_result_type.GetByteSize(nullptr)
+                    ? *m_result_type.GetByteSize(nullptr)
+                    : 0);
 
   // Construct a new result global and set up its metadata
 
   GlobalVariable *new_result_global = new GlobalVariable(
       (*m_module), result_global->getType()->getElementType(),
       false,                              /* not constant */
       GlobalValue::ExternalLinkage, NULL, /* no initializer */
       m_result_name.GetCString());
if (name[0] == '$') {
       //
       // We also do this for any user-declared persistent variables.
       compiler_type = compiler_type.GetPointerType();
       value_type = PointerType::get(global_variable->getType(), 0);
     } else {
       value_type = global_variable->getType();
     }
 
-    const uint64_t value_size = compiler_type.GetByteSize(nullptr);
+    auto value_size = compiler_type.GetByteSize(nullptr);
+    if (!value_size)
+      return false;
     lldb::offset_t value_alignment =
         (compiler_type.GetTypeBitAlign() + 7ull) / 8ull;
 
     if (log) {
       log->Printf("Type of \"%s\" is [clang \"%s\", llvm \"%s\"] [size %" PRIu64
                   ", align %" PRIu64 "]",
                   name.c_str(),
                   lldb_private::ClangUtil::GetQualType(compiler_type)
                       .getAsString()
                       .c_str(),
-                  PrintType(value_type).c_str(), value_size, value_alignment);
+                  PrintType(value_type).c_str(), *value_size, value_alignment);
     }
 
     if (named_decl &&
         !m_decl_map->AddValueToStruct(
             named_decl, lldb_private::ConstString(name.c_str()), llvm_value_ptr,
-            value_size, value_alignment)) {
+            *value_size, value_alignment)) {
       if (!global_variable->hasExternalLinkage())
         return true;
       else
         return true;
     }
   } else if (dyn_cast<llvm::Function>(llvm_value_ptr)) {
     if (log)
       log->Printf("Function pointers aren't handled right now");

source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp

bool lldb_private::formatters::WCharStringSummaryProvider(
 
   // Get a wchar_t basic type from the current type system
   CompilerType wchar_compiler_type =
       valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeWChar);
 
   if (!wchar_compiler_type)
     return false;
 
-  const uint32_t wchar_size = wchar_compiler_type.GetBitSize(
-      nullptr); // Safe to pass NULL for exe_scope here
+  // Safe to pass nullptr for exe_scope here.
+  auto size = wchar_compiler_type.GetBitSize(nullptr);
+  if (!size)
+    return false;
+  const uint32_t wchar_size = *size;
 
   StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
   options.SetLocation(valobj_addr);
   options.SetProcessSP(process_sp);
   options.SetStream(&stream);
   options.SetPrefixToken("L");
 
   switch (wchar_size) {
bool lldb_private::formatters::WCharSummaryProvider(
 
   // Get a wchar_t basic type from the current type system
   CompilerType wchar_compiler_type =
       valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeWChar);
 
   if (!wchar_compiler_type)
     return false;
 
-  const uint32_t wchar_size = wchar_compiler_type.GetBitSize(
-      nullptr); // Safe to pass NULL for exe_scope here
+    // Safe to pass nullptr for exe_scope here.
+  auto size = wchar_compiler_type.GetBitSize(nullptr);
+  if (!size)
+    return false;
+  const uint32_t wchar_size = *size;
 
   StringPrinter::ReadBufferAndDumpToStreamOptions options(valobj);
   options.SetData(data);
   options.SetStream(&stream);
   options.SetPrefixToken("L");
   options.SetQuote('\'');
   options.SetSourceSize(1);
   options.SetBinaryZeroIsTerminator(false);

source/Plugins/Language/CPlusPlus/LibCxx.cpp

m_pair_ptr = valobj_sp
                          nullptr)
                      .get();
     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; 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);
+      CompilerType pair_type(
+          __i_->GetCompilerType().GetTypeTemplateArgument(0));
+      std::string name;
+      uint64_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;
       }
 
       auto addr(m_pair_ptr->GetValueAsUnsigned(LLDB_INVALID_ADDRESS));
       m_pair_ptr = nullptr;
-      if (addr && addr!=LLDB_INVALID_ADDRESS) {
-        ClangASTContext *ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(pair_type.GetTypeSystem());
+      if (addr && addr != LLDB_INVALID_ADDRESS) {
+        ClangASTContext *ast_ctx =
+            llvm::dyn_cast_or_null<ClangASTContext>(pair_type.GetTypeSystem());
         if (!ast_ctx)
           return false;
-        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",pair_type}
-        });
-        DataBufferSP buffer_sp(new DataBufferHeap(tree_node_type.GetByteSize(nullptr),0));
+        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", pair_type}});
+        auto size = tree_node_type.GetByteSize(nullptr);
+        if (!size)
+          return false;
+        DataBufferSP buffer_sp(new DataBufferHeap(*size, 0));
         ProcessSP process_sp(target_sp->GetProcessSP());
         Status error;
-        process_sp->ReadMemory(addr, buffer_sp->GetBytes(), buffer_sp->GetByteSize(), error);
+        process_sp->ReadMemory(addr, buffer_sp->GetBytes(),
+                               buffer_sp->GetByteSize(), error);
         if (error.Fail())
           return false;
-        DataExtractor extractor(buffer_sp, process_sp->GetByteOrder(), process_sp->GetAddressByteSize());
-        auto pair_sp = CreateValueObjectFromData("pair", extractor, valobj_sp->GetExecutionContextRef(), tree_node_type);
+        DataExtractor extractor(buffer_sp, process_sp->GetByteOrder(),
+                                process_sp->GetAddressByteSize());
+        auto pair_sp = CreateValueObjectFromData(
+            "pair", extractor, valobj_sp->GetExecutionContextRef(),
+            tree_node_type);
         if (pair_sp)
-          m_pair_sp = pair_sp->GetChildAtIndex(4,true);
+          m_pair_sp = pair_sp->GetChildAtIndex(4, true);
       }
     }
   }
 
   return false;
 }
 
 size_t lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::
bool lldb_private::formatters::LibcxxWStringSummaryProvider(
   }
   location_sp->GetPointeeData(extractor, 0, size);
 
   // std::wstring::size() is measured in 'characters', not bytes
   auto wchar_t_size = valobj.GetTargetSP()
                           ->GetScratchClangASTContext()
                           ->GetBasicType(lldb::eBasicTypeWChar)
                           .GetByteSize(nullptr);
+  if (!wchar_t_size)
+    return false;
 
   options.SetData(extractor);
   options.SetStream(&stream);
   options.SetPrefixToken("L");
   options.SetQuote('"');
   options.SetSourceSize(size);
   options.SetBinaryZeroIsTerminator(false);
 
-  switch (wchar_t_size) {
+  switch (*wchar_t_size) {
   case 1:
     StringPrinter::ReadBufferAndDumpToStream<
         lldb_private::formatters::StringPrinter::StringElementType::UTF8>(
         options);
     break;
 
   case 2:
     lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStream<

source/Plugins/Language/CPlusPlus/LibCxxBitset.cpp

ValueObjectSP BitsetFrontEnd::GetChildAtIndex(size_t idx) {
 
   if (m_elements[idx])
     return m_elements[idx];
 
   ExecutionContext ctx = m_backend.GetExecutionContextRef().Lock(false);
   CompilerType type;
   ValueObjectSP chunk;
   // For small bitsets __first_ is not an array, but a plain size_t.
-  if (m_first->GetCompilerType().IsArrayType(&type, nullptr, nullptr))
-    chunk = m_first->GetChildAtIndex(
-        idx / type.GetBitSize(ctx.GetBestExecutionContextScope()), true);
-  else {
+  if (m_first->GetCompilerType().IsArrayType(&type, nullptr, nullptr)) {
+    auto bit_size = type.GetBitSize(ctx.GetBestExecutionContextScope());
+    if (!bit_size || *bit_size == 0)
+      return {};
+    chunk = m_first->GetChildAtIndex(idx / *bit_size, true);
+  } else {
     type = m_first->GetCompilerType();
     chunk = m_first;
   }
   if (!type || !chunk)
-    return ValueObjectSP();
+    return {};
 
-  size_t chunk_idx = idx % type.GetBitSize(ctx.GetBestExecutionContextScope());
+  auto bit_size = type.GetBitSize(ctx.GetBestExecutionContextScope());
+  if (!bit_size || *bit_size == 0)
+    return {};
+  size_t chunk_idx = idx % *bit_size;
   uint8_t value = !!(chunk->GetValueAsUnsigned(0) & (uint64_t(1) << chunk_idx));
   DataExtractor data(&value, sizeof(value), m_byte_order, m_byte_size);
 
   m_elements[idx] = CreateValueObjectFromData(llvm::formatv("[{0}]", idx).str(),
                                               data, ctx, m_bool_type);
 
   return m_elements[idx];
 }
 
 SyntheticChildrenFrontEnd *formatters::LibcxxBitsetSyntheticFrontEndCreator(
     CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
   if (valobj_sp)
     return new BitsetFrontEnd(*valobj_sp);
   return nullptr;
 }

source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp

bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
   static ConstString g___begin_("__begin_");
 
   m_start = nullptr;
   m_num_elements = 0;
   m_element_type = m_backend.GetCompilerType().GetTypeTemplateArgument(0);
   if (!m_element_type.IsValid())
     return false;
 
-  m_element_size = m_element_type.GetByteSize(nullptr);
-
-  if (m_element_size > 0)
-    m_start =
-        m_backend.GetChildMemberWithName(g___begin_, true)
-            .get(); // store raw pointers or end up with a circular dependency
+  if (auto size = m_element_type.GetByteSize(nullptr)) {
+    m_element_size = *size;
+    // Store raw pointers or end up with a circular dependency.
+    m_start = m_backend.GetChildMemberWithName(g___begin_, true).get();
+  }
 
   return false;
 }
 
 bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
     MightHaveChildren() {
   return true;
 }

source/Plugins/Language/CPlusPlus/LibCxxVector.cpp

bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::Update() {
   }
   default:
     return false;
   }
 
   if (!data_type_finder_sp)
     return false;
   m_element_type = data_type_finder_sp->GetCompilerType().GetPointeeType();
-  m_element_size = m_element_type.GetByteSize(nullptr);
+  if (auto size = m_element_type.GetByteSize(nullptr)) {
+    m_element_size = *size;
 
     if (m_element_size > 0) {
       // store raw pointers or end up with a circular dependency
       m_start =
           m_backend.GetChildMemberWithName(ConstString("__begin_"), true).get();
       m_finish =
           m_backend.GetChildMemberWithName(ConstString("__end_"), true).get();
     }
+  }
   return false;
 }
 
 bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
     MightHaveChildren() {
   return true;
 }
 

 
 lldb::ValueObjectSP
 lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::GetChildAtIndex(
     size_t idx) {
   auto iter = m_children.find(idx), end = m_children.end();
   if (iter != end)
     return iter->second;
   if (idx >= m_count)
-    return ValueObjectSP();
+    return {};
   if (m_base_data_address == 0 || m_count == 0)
-    return ValueObjectSP();
+    return {};
   if (!m_bool_type)
-    return ValueObjectSP();
+    return {};
   size_t byte_idx = (idx >> 3); // divide by 8 to get byte index
   size_t bit_index = (idx & 7); // efficient idx % 8 for bit index
   lldb::addr_t byte_location = m_base_data_address + byte_idx;
   ProcessSP process_sp(m_exe_ctx_ref.GetProcessSP());
   if (!process_sp)
-    return ValueObjectSP();
+    return {};
   uint8_t byte = 0;
   uint8_t mask = 0;
   Status err;
   size_t bytes_read = process_sp->ReadMemory(byte_location, &byte, 1, err);
   if (err.Fail() || bytes_read == 0)
-    return ValueObjectSP();
+    return {};
   mask = 1 << bit_index;
   bool bit_set = ((byte & mask) != 0);
-  DataBufferSP buffer_sp(
-      new DataBufferHeap(m_bool_type.GetByteSize(nullptr), 0));
+  auto size = m_bool_type.GetByteSize(nullptr);
+  if (!size)
+    return {};
+  DataBufferSP buffer_sp(new DataBufferHeap(*size, 0));
   if (bit_set && buffer_sp && buffer_sp->GetBytes()) {
     // regardless of endianness, anything non-zero is true
     *(buffer_sp->GetBytes()) = 1;
   }
   StreamString name;
   name.Printf("[%" PRIu64 "]", (uint64_t)idx);
   ValueObjectSP retval_sp(CreateValueObjectFromData(
       name.GetString(),

source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

case eAddressTypeLoad: {
         return false;
 
       CompilerType wchar_compiler_type =
           valobj.GetCompilerType().GetBasicTypeFromAST(lldb::eBasicTypeWChar);
 
       if (!wchar_compiler_type)
         return false;
 
-      const uint32_t wchar_size = wchar_compiler_type.GetBitSize(
-          nullptr); // Safe to pass NULL for exe_scope here
+      // Safe to pass nullptr for exe_scope here.
+      auto size = wchar_compiler_type.GetBitSize(nullptr);
+      if (!size)
+        return false;
+      const uint32_t wchar_size = *size;
 
       StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
       Status error;
       lldb::addr_t addr_of_data =
           process_sp->ReadPointerFromMemory(addr_of_string, error);
       if (error.Fail() || addr_of_data == 0 ||
           addr_of_data == LLDB_INVALID_ADDRESS)
         return false;

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp

descriptor.Describe(nullptr, nullptr, nullptr, [this, process,
                                                        uint64_t size) -> bool {
     const bool for_expression = false;
     const bool stop_loop = false;
     LLDB_LOGV(log, "name = {0}, encoding = {1}, offset_ptr = {2:x}, size = {3}",
               name, type, offset_ptr, size);
     CompilerType ivar_type =
         encoding_to_type_sp->RealizeType(type, for_expression);
     if (ivar_type) {
+      auto ivar_size = ivar_type.GetByteSize(nullptr);
       LLDB_LOGV(log,
                 "name = {0}, encoding = {1}, offset_ptr = {2:x}, size = "
                 "{3}, type_size = {4}",
-                name, type, offset_ptr, size, ivar_type.GetByteSize(nullptr));
+                name, type, offset_ptr, size, ivar_size ? *ivar_size : 0);
       Scalar offset_scalar;
       Status error;
       const int offset_ptr_size = 4;
       const bool is_signed = false;
       size_t read = process->ReadScalarIntegerFromMemory(
           offset_ptr, offset_ptr_size, is_signed, offset_scalar, error);
       if (error.Success() && 4 == read) {
         LLDB_LOGV(log, "offset_ptr = {0:x} --> {1}", offset_ptr,

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 
           CompilerType pointee_clang_type =
               pointee_type->GetForwardCompilerType();
           CompilerType class_clang_type = class_type->GetLayoutCompilerType();
 
           clang_type = ClangASTContext::CreateMemberPointerType(
               class_clang_type, pointee_clang_type);
 
-          byte_size = clang_type.GetByteSize(nullptr);
-
+          if (auto clang_type_size = clang_type.GetByteSize(nullptr)) {
+            byte_size = *clang_type_size;
             type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str,
                                    byte_size, NULL, LLDB_INVALID_UID,
                                    Type::eEncodingIsUID, NULL, clang_type,
                                    Type::eResolveStateForward));
           }
+        }
 
         break;
       }
       default:
         dwarf->GetObjectFile()->GetModule()->ReportError(
             "{0x%8.8x}: unhandled type tag 0x%4.4x (%s), please file a bug and "
             "attach the file at the start of this error message",
             die.GetOffset(), tag, DW_TAG_value_to_name(tag));
if (num_attributes > 0) {
           template_param_infos.names.push_back(name);
         else
           template_param_infos.names.push_back(NULL);
 
         // Get the signed value for any integer or enumeration if available
         clang_type.IsIntegerOrEnumerationType(is_signed);
 
         if (tag == DW_TAG_template_value_parameter && uval64_valid) {
-          llvm::APInt apint(clang_type.GetBitSize(nullptr), uval64, is_signed);
+          auto size = clang_type.GetBitSize(nullptr);
+          if (!size)
+            return false;
+          llvm::APInt apint(*size, uval64, is_signed);
           template_param_infos.args.push_back(
               clang::TemplateArgument(*ast, llvm::APSInt(apint, !is_signed),
                                       ClangUtil::GetQualType(clang_type)));
         } else {
           template_param_infos.args.push_back(
               clang::TemplateArgument(ClangUtil::GetQualType(clang_type)));
         }
       } else {

source/Symbol/ClangASTContext.cpp

if (ast) {
     lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration(name);
     return ClangASTContext::GetBasicType(ast, basic_type);
   }
   return CompilerType();
 }
 
 uint32_t ClangASTContext::GetPointerByteSize() {
   if (m_pointer_byte_size == 0)
-    m_pointer_byte_size = GetBasicType(lldb::eBasicTypeVoid)
-                              .GetPointerType()
-                              .GetByteSize(nullptr);
+    if (auto size = GetBasicType(lldb::eBasicTypeVoid)
+                        .GetByteSize(nullptr))
+      m_pointer_byte_size = *size;
   return m_pointer_byte_size;
 }
 
 CompilerType ClangASTContext::GetBasicType(lldb::BasicType basic_type) {
   return GetBasicType(getASTContext(), basic_type);
 }
 
 CompilerType ClangASTContext::GetBasicType(ASTContext *ast,
if (type) {
     if (!array_eletype)
       return CompilerType();
 
     CompilerType element_type(getASTContext(),
                               array_eletype->getCanonicalTypeUnqualified());
 
     // TODO: the real stride will be >= this value.. find the real one!
     if (stride)
-      *stride = element_type.GetByteSize(nullptr);
+      if (auto size = element_type.GetByteSize(nullptr))
+        *stride = *size;
 
     return element_type;
   }
   return CompilerType();
 }
 
 CompilerType ClangASTContext::GetArrayType(lldb::opaque_compiler_type_t type,
                                            uint64_t size) {
if (idx_is_valid && GetCompleteType(type)) {
                                .getQuantity() *
                            8;
 
             // Base classes should be a multiple of 8 bits in size
             child_byte_offset = bit_offset / 8;
             CompilerType base_class_clang_type(getASTContext(),
                                                base_class->getType());
             child_name = base_class_clang_type.GetTypeName().AsCString("");
-            uint64_t base_class_clang_type_bit_size =
-                base_class_clang_type.GetBitSize(
-                    exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
+            auto size = base_class_clang_type.GetBitSize(
+            if (!size)
+              return {};
+            uint64_t base_class_clang_type_bit_size = *size;
 
             // Base classes bit sizes should be a multiple of 8 bits in size
             assert(base_class_clang_type_bit_size % 8 == 0);
             child_byte_size = base_class_clang_type_bit_size / 8;
             child_is_base_class = true;
             return base_class_clang_type;
           }
           // We don't increment the child index in the for loop since we might
if (idx_is_valid && GetCompleteType(type)) {
           // Print the member type if requested
           // Print the member name and equal sign
           child_name.assign(field->getNameAsString());
 
           // Figure out the type byte size (field_type_info.first) and
           // alignment (field_type_info.second) from the AST context.
           CompilerType field_clang_type(getASTContext(), field->getType());
           assert(field_idx < record_layout.getFieldCount());
-          child_byte_size = field_clang_type.GetByteSize(
+          auto size = field_clang_type.GetByteSize(
               exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
+          if (!size)
+            return {};
+          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 (ClangASTContext::FieldIsBitfield(getASTContext(), *field,
                                                child_bitfield_bit_size)) {
             child_bitfield_bit_offset = bit_offset % child_bit_size;
if (idx_is_valid) {
             valobj ? valobj->GetName().GetCString() : NULL;
         if (parent_name) {
           child_name.assign(1, '*');
           child_name += parent_name;
         }
 
         // We have a pointer to an simple type
         if (idx == 0 && pointee_clang_type.GetCompleteType()) {
-          child_byte_size = pointee_clang_type.GetByteSize(
-              exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
+          if (auto size = pointee_clang_type.GetByteSize(
+                  exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL)) {
+            child_byte_size = *size;
             child_byte_offset = 0;
             return pointee_clang_type;
           }
         }
       }
+    }
     break;
 
   case clang::Type::Vector:
   case clang::Type::ExtVector:
     if (idx_is_valid) {
       const clang::VectorType *array =
           llvm::cast<clang::VectorType>(parent_qual_type.getTypePtr());
       if (array) {
         CompilerType element_type(getASTContext(), array->getElementType());
         if (element_type.GetCompleteType()) {
           char element_name[64];
           ::snprintf(element_name, sizeof(element_name), "[%" PRIu64 "]",
                      static_cast<uint64_t>(idx));
           child_name.assign(element_name);
-          child_byte_size = element_type.GetByteSize(
-              exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
+          if (auto size = element_type.GetByteSize(
+                  exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL)) {
+            child_byte_size = *size;
             child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
             return element_type;
           }
         }
       }
+    }
     break;
 
   case clang::Type::ConstantArray:
   case clang::Type::IncompleteArray:
     if (ignore_array_bounds || idx_is_valid) {
       const clang::ArrayType *array = GetQualType(type)->getAsArrayTypeUnsafe();
       if (array) {
         CompilerType element_type(getASTContext(), array->getElementType());
         if (element_type.GetCompleteType()) {
           child_name = llvm::formatv("[{0}]", idx);
-          child_byte_size = element_type.GetByteSize(
-              exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
+          if (auto size = element_type.GetByteSize(
+                  exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL)) {
+            child_byte_size = *size;
             child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
             return element_type;
           }
         }
       }
+    }
     break;
 
   case clang::Type::Pointer: {
     CompilerType pointee_clang_type(GetPointeeType(type));
 
     // Don't dereference "void *" pointers
     if (pointee_clang_type.IsVoidType())
       return CompilerType();
if (transparent_pointers && pointee_clang_type.IsAggregateType()) {
           valobj ? valobj->GetName().GetCString() : NULL;
       if (parent_name) {
         child_name.assign(1, '*');
         child_name += parent_name;
       }
 
       // We have a pointer to an simple type
       if (idx == 0) {
-        child_byte_size = pointee_clang_type.GetByteSize(
-            exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
+        if (auto size = pointee_clang_type.GetByteSize(
+                exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL)) {
+          child_byte_size = *size;
           child_byte_offset = 0;
           return pointee_clang_type;
         }
       }
+    }
     break;
   }
 
   case clang::Type::LValueReference:
   case clang::Type::RValueReference:
     if (idx_is_valid) {
       const clang::ReferenceType *reference_type =
           llvm::cast<clang::ReferenceType>(parent_qual_type.getTypePtr());
if (idx_is_valid) {
             valobj ? valobj->GetName().GetCString() : NULL;
         if (parent_name) {
           child_name.assign(1, '&');
           child_name += parent_name;
         }
 
         // We have a pointer to an simple type
         if (idx == 0) {
-          child_byte_size = pointee_clang_type.GetByteSize(
-              exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
+          if (auto size = pointee_clang_type.GetByteSize(
+                  exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL)) {
+            child_byte_size = *size;
             child_byte_offset = 0;
             return pointee_clang_type;
           }
         }
       }
+    }
     break;
 
   case clang::Type::Typedef: {
     CompilerType typedefed_clang_type(
         getASTContext(), llvm::cast<clang::TypedefType>(parent_qual_type)
                              ->getDecl()
                              ->getUnderlyingType());
     return typedefed_clang_type.GetChildCompilerTypeAtIndex(

source/Symbol/CompilerType.cpp

CompilerType::GetBasicTypeFromAST(lldb::BasicType basic_type) const {
   if (IsValid())
     return m_type_system->GetBasicTypeFromAST(basic_type);
   return CompilerType();
 }
 //----------------------------------------------------------------------
 // Exploring the type
 //----------------------------------------------------------------------
 
-uint64_t CompilerType::GetBitSize(ExecutionContextScope *exe_scope) const {
-  if (IsValid()) {
+llvm::Optional<uint64_t>
+CompilerType::GetBitSize(ExecutionContextScope *exe_scope) const {
+  if (IsValid())
     return m_type_system->GetBitSize(m_type, exe_scope);
-  }
-  return 0;
+  return {};
 }
 
-uint64_t CompilerType::GetByteSize(ExecutionContextScope *exe_scope) const {
-  return (GetBitSize(exe_scope) + 7) / 8;
+llvm::Optional<uint64_t>
+CompilerType::GetByteSize(ExecutionContextScope *exe_scope) const {
+  if (auto bit_size = GetBitSize(exe_scope))
+    return (*bit_size + 7) / 8;
+  return {};
 }
 
 size_t CompilerType::GetTypeBitAlign() const {
   if (IsValid())
     return m_type_system->GetTypeBitAlign(m_type);
   return 0;
 }
 
if (IsAggregateType()) {
     return false; // Aggregate types don't have scalar values
   } else {
     uint64_t count = 0;
     lldb::Encoding encoding = GetEncoding(count);
 
     if (encoding == lldb::eEncodingInvalid || count != 1)
       return false;
 
-    const uint64_t byte_size = GetByteSize(nullptr);
+    auto byte_size = GetByteSize(nullptr);
+    if (!byte_size)
+      return false;
     lldb::offset_t offset = data_byte_offset;
     switch (encoding) {
     case lldb::eEncodingInvalid:
       break;
     case lldb::eEncodingVector:
       break;
     case lldb::eEncodingUint:
-      if (byte_size <= sizeof(unsigned long long)) {
-        uint64_t uval64 = data.GetMaxU64(&offset, byte_size);
-        if (byte_size <= sizeof(unsigned int)) {
+      if (*byte_size <= sizeof(unsigned long long)) {
+        uint64_t uval64 = data.GetMaxU64(&offset, *byte_size);
+        if (*byte_size <= sizeof(unsigned int)) {
           value = (unsigned int)uval64;
           return true;
-        } else if (byte_size <= sizeof(unsigned long)) {
+        } else if (*byte_size <= sizeof(unsigned long)) {
           value = (unsigned long)uval64;
           return true;
-        } else if (byte_size <= sizeof(unsigned long long)) {
+        } else if (*byte_size <= sizeof(unsigned long long)) {
           value = (unsigned long long)uval64;
           return true;
         } else
           value.Clear();
       }
       break;
 
     case lldb::eEncodingSint:
-      if (byte_size <= sizeof(long long)) {
-        int64_t sval64 = data.GetMaxS64(&offset, byte_size);
-        if (byte_size <= sizeof(int)) {
+      if (*byte_size <= sizeof(long long)) {
+        int64_t sval64 = data.GetMaxS64(&offset, *byte_size);
+        if (*byte_size <= sizeof(int)) {
           value = (int)sval64;
           return true;
-        } else if (byte_size <= sizeof(long)) {
+        } else if (*byte_size <= sizeof(long)) {
           value = (long)sval64;
           return true;
-        } else if (byte_size <= sizeof(long long)) {
+        } else if (*byte_size <= sizeof(long long)) {
           value = (long long)sval64;
           return true;
         } else
           value.Clear();
       }
       break;
 
     case lldb::eEncodingIEEE754:
-      if (byte_size <= sizeof(long double)) {
+      if (*byte_size <= sizeof(long double)) {
         uint32_t u32;
         uint64_t u64;
-        if (byte_size == sizeof(float)) {
+        if (*byte_size == sizeof(float)) {
           if (sizeof(float) == sizeof(uint32_t)) {
             u32 = data.GetU32(&offset);
             value = *((float *)&u32);
             return true;
           } else if (sizeof(float) == sizeof(uint64_t)) {
             u64 = data.GetU64(&offset);
             value = *((float *)&u64);
             return true;
           }
-        } else if (byte_size == sizeof(double)) {
+        } else if (*byte_size == sizeof(double)) {
           if (sizeof(double) == sizeof(uint32_t)) {
             u32 = data.GetU32(&offset);
             value = *((double *)&u32);
             return true;
           } else if (sizeof(double) == sizeof(uint64_t)) {
             u64 = data.GetU64(&offset);
             value = *((double *)&u64);
             return true;
           }
-        } else if (byte_size == sizeof(long double)) {
+        } else if (*byte_size == sizeof(long double)) {
           if (sizeof(long double) == sizeof(uint32_t)) {
             u32 = data.GetU32(&offset);
             value = *((long double *)&u32);
             return true;
           } else if (sizeof(long double) == sizeof(uint64_t)) {
             u64 = data.GetU64(&offset);
             value = *((long double *)&u64);
             return true;
bool CompilerType::SetValueFromScalar(const Scalar &value, Stream &strm) {
   if (!IsAggregateType()) {
     strm.GetFlags().Set(Stream::eBinary);
     uint64_t count = 0;
     lldb::Encoding encoding = GetEncoding(count);
 
     if (encoding == lldb::eEncodingInvalid || count != 1)
       return false;
 
-    const uint64_t bit_width = GetBitSize(nullptr);
+    auto bit_width = GetBitSize(nullptr);
+    if (!bit_width)
+      return false;
+
     // This function doesn't currently handle non-byte aligned assignments
-    if ((bit_width % 8) != 0)
+    if ((*bit_width % 8) != 0)
       return false;
 
-    const uint64_t byte_size = (bit_width + 7) / 8;
+    const uint64_t byte_size = (*bit_width + 7) / 8;
     switch (encoding) {
     case lldb::eEncodingInvalid:
       break;
     case lldb::eEncodingVector:
       break;
     case lldb::eEncodingUint:
       switch (byte_size) {
       case 1:
bool CompilerType::ReadFromMemory(lldb_private::ExecutionContext *exe_ctx,
   // Can't convert a file address to anything valid without more context (which
   // Module it came from)
   if (address_type == eAddressTypeFile)
     return false;
 
   if (!GetCompleteType())
     return false;
 
-  const uint64_t byte_size =
+  auto byte_size =
       GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
-  if (data.GetByteSize() < byte_size) {
-    lldb::DataBufferSP data_sp(new DataBufferHeap(byte_size, '\0'));
+  if (!byte_size)
+    return false;
+
+  if (data.GetByteSize() < *byte_size) {
+    lldb::DataBufferSP data_sp(new DataBufferHeap(*byte_size, '\0'));
     data.SetData(data_sp);
   }
 
-  uint8_t *dst = const_cast<uint8_t *>(data.PeekData(0, byte_size));
+  uint8_t *dst = const_cast<uint8_t *>(data.PeekData(0, *byte_size));
   if (dst != nullptr) {
     if (address_type == eAddressTypeHost) {
       if (addr == 0)
         return false;
       // The address is an address in this process, so just copy it
-      memcpy(dst, reinterpret_cast<uint8_t *>(addr), byte_size);
+      memcpy(dst, reinterpret_cast<uint8_t *>(addr), *byte_size);
       return true;
     } else {
       Process *process = nullptr;
       if (exe_ctx)
         process = exe_ctx->GetProcessPtr();
       if (process) {
         Status error;
-        return process->ReadMemory(addr, dst, byte_size, error) == byte_size;
+        return process->ReadMemory(addr, dst, *byte_size, error) == *byte_size;
       }
     }
   }
   return false;
 }
 
 bool CompilerType::WriteToMemory(lldb_private::ExecutionContext *exe_ctx,
                                  lldb::addr_t addr, AddressType address_type,
                                  StreamString &new_value) {
   if (!IsValid())
     return false;
 
   // Can't convert a file address to anything valid without more context (which
   // Module it came from)
   if (address_type == eAddressTypeFile)
     return false;
 
   if (!GetCompleteType())
     return false;
 
-  const uint64_t byte_size =
+  auto byte_size =
       GetByteSize(exe_ctx ? exe_ctx->GetBestExecutionContextScope() : NULL);
+  if (!byte_size)
+    return false;
 
-  if (byte_size > 0) {
+  if (*byte_size > 0) {
     if (address_type == eAddressTypeHost) {
       // The address is an address in this process, so just copy it
-      memcpy((void *)addr, new_value.GetData(), byte_size);
+      memcpy((void *)addr, new_value.GetData(), *byte_size);
       return true;
     } else {
       Process *process = nullptr;
       if (exe_ctx)
         process = exe_ctx->GetProcessPtr();
       if (process) {
         Status error;
-        return process->WriteMemory(addr, new_value.GetData(), byte_size,
-                                    error) == byte_size;
+        return process->WriteMemory(addr, new_value.GetData(), *byte_size,
+                                    error) == *byte_size;
       }
     }
   }
   return false;
 }
 
 bool lldb_private::operator==(const lldb_private::CompilerType &lhs,
                               const lldb_private::CompilerType &rhs) {
   return lhs.GetTypeSystem() == rhs.GetTypeSystem() &&
          lhs.GetOpaqueQualType() == rhs.GetOpaqueQualType();
 }
 
 bool lldb_private::operator!=(const lldb_private::CompilerType &lhs,
                               const lldb_private::CompilerType &rhs) {
   return !(lhs == rhs);
 }

source/Symbol/Type.cpp

if (m_byte_size == 0) {
     case eEncodingIsConstUID:
     case eEncodingIsRestrictUID:
     case eEncodingIsVolatileUID:
     case eEncodingIsTypedefUID: {
       Type *encoding_type = GetEncodingType();
       if (encoding_type)
         m_byte_size = encoding_type->GetByteSize();
       if (m_byte_size == 0)
-        m_byte_size = GetLayoutCompilerType().GetByteSize(nullptr);
+        if (auto size = GetLayoutCompilerType().GetByteSize(nullptr))
+          m_byte_size = *size;
     } break;
 
     // If we are a pointer or reference, then this is just a pointer size;
     case eEncodingIsPointerUID:
     case eEncodingIsLValueReferenceUID:
     case eEncodingIsRValueReferenceUID: {
       if (ArchSpec arch = m_symbol_file->GetObjectFile()->GetArchitecture())
         m_byte_size = arch.GetAddressByteSize();