GetNumChildren() version of D53530

[aprantl]

Summary

This revision contains an alternative implementation of D53530.

The ClangASTMetadata only allows for a single pointer-sized field for storage, and we the DWARF Die conveniently stores all the dynamic array properties in one place, so I didn't introduce another abstraction at the TypeSystem layer.

include/lldb/Symbol/ClangASTContext.h

public:
   lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
                              uint64_t &count) override;
 
   lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override;
 
   size_t GetTypeBitAlign(lldb::opaque_compiler_type_t type) override;
 
   uint32_t GetNumChildren(lldb::opaque_compiler_type_t type,
-                          bool omit_empty_base_classes) override;
+                          bool omit_empty_base_classes,
+                          ExecutionContextScope *exe_scope) override;
 
   CompilerType GetBuiltinTypeByName(const ConstString &name) override;
 
   lldb::BasicType
   GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override;
 
   static lldb::BasicType
   GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type,

include/lldb/Symbol/CompilerType.h

public:
   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) const;
+  uint32_t GetNumChildren(bool omit_empty_base_classes,
+                          ExecutionContextScope *exe_scope) const;
 
   lldb::BasicType GetBasicTypeEnumeration() const;
 
   static lldb::BasicType GetBasicTypeEnumeration(const ConstString &name);
 
   //----------------------------------------------------------------------
   // If this type is an enumeration, iterate through all of its enumerators
   // using a callback. If the callback returns true, keep iterating, else abort

include/lldb/Symbol/GoASTContext.h

uint64_t GetBitSize(lldb::opaque_compiler_type_t type,
                       ExecutionContextScope *exe_scope) override;
 
   lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
                              uint64_t &count) override;
 
   lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override;
 
   uint32_t GetNumChildren(lldb::opaque_compiler_type_t type,
-                          bool omit_empty_base_classes) override;
+                          bool omit_empty_base_classes,
+                          ExecutionContextScope *exe_scope) override;
 
   lldb::BasicType
   GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override;
 
   CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
                                                    size_t bit_size) override;
 
   uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;

include/lldb/Symbol/JavaASTContext.h

public:
   uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;
 
   CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
                                std::string &name, uint64_t *bit_offset_ptr,
                                uint32_t *bitfield_bit_size_ptr,
                                bool *is_bitfield_ptr) override;
 
   uint32_t GetNumChildren(lldb::opaque_compiler_type_t type,
-                          bool omit_empty_base_classes) override;
+                          bool omit_empty_base_classes,
+                          ExecutionContextScope *exe_scope) override;
 
   uint32_t GetNumDirectBaseClasses(lldb::opaque_compiler_type_t type) override;
 
   uint32_t GetNumVirtualBaseClasses(lldb::opaque_compiler_type_t type) override;
 
   CompilerType GetDirectBaseClassAtIndex(lldb::opaque_compiler_type_t type,
                                          size_t idx,
                                          uint32_t *bit_offset_ptr) override;

include/lldb/Symbol/OCamlASTContext.h

uint64_t GetBitSize(lldb::opaque_compiler_type_t type,
                       ExecutionContextScope *exe_scope) override;
 
   lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
                              uint64_t &count) override;
 
   lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override;
 
   uint32_t GetNumChildren(lldb::opaque_compiler_type_t type,
-                          bool omit_empty_base_classes) override;
+                          bool omit_empty_base_classes,
+                          ExecutionContextScope *exe_scope) override;
 
   lldb::BasicType
   GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override;
 
   CompilerType GetBuiltinTypeForEncodingAndBitSize(lldb::Encoding encoding,
                                                    size_t bit_size) override;
 
   uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;

include/lldb/Symbol/SymbolFile.h

public:
   }
   virtual bool
   ParseImportedModules(const SymbolContext &sc,
                        std::vector<ConstString> &imported_modules) = 0;
   virtual size_t ParseFunctionBlocks(const SymbolContext &sc) = 0;
   virtual size_t ParseTypes(const SymbolContext &sc) = 0;
   virtual size_t ParseVariablesForContext(const SymbolContext &sc) = 0;
   virtual Type *ResolveTypeUID(lldb::user_id_t type_uid) = 0;
+
+
+  struct ArrayInfo {
+    int64_t first_index;
+    llvm::SmallVector<uint64_t, 1> element_orders;
+    uint32_t byte_stride;
+    uint32_t bit_stride;
+  };
+  virtual llvm::Optional<ArrayInfo>
+  GetDynamicArrayInfoForUID(lldb::user_id_t type_uid,
+                            const lldb_private::ExecutionContext *exe_ctx) = 0;
   virtual bool CompleteType(CompilerType &compiler_type) = 0;
   virtual void ParseDeclsForContext(CompilerDeclContext decl_ctx) {}
   virtual CompilerDecl GetDeclForUID(lldb::user_id_t uid) {
     return CompilerDecl();
   }
   virtual CompilerDeclContext GetDeclContextForUID(lldb::user_id_t uid) {
     return CompilerDeclContext();
   }

include/lldb/Symbol/TypeSystem.h

virtual uint64_t GetBitSize(lldb::opaque_compiler_type_t type,
                               ExecutionContextScope *exe_scope) = 0;
 
   virtual lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
                                      uint64_t &count) = 0;
 
   virtual lldb::Format GetFormat(lldb::opaque_compiler_type_t type) = 0;
 
   virtual uint32_t GetNumChildren(lldb::opaque_compiler_type_t type,
-                                  bool omit_empty_base_classes) = 0;
+                                  bool omit_empty_base_classes,
+                                  ExecutionContextScope *exe_scope) = 0;
 
   virtual CompilerType GetBuiltinTypeByName(const ConstString &name);
 
   virtual lldb::BasicType
   GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) = 0;
 
   virtual void ForEachEnumerator(
       lldb::opaque_compiler_type_t type,

packages/Python/lldbsuite/test/lang/c/vla/Makefile

+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules

packages/Python/lldbsuite/test/lang/c/vla/TestVLA.py

+import lldb
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+
+
+class TestVLA(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def test_vla(self):
+        self.build()
+        _, process, _, _ = lldbutil.run_to_source_breakpoint(
+            self, "break here", lldb.SBFileSpec('main.c'))
+
+        for i in range(2):
+            self.expect("fr v vla[%d]"%i, substrs=["int", "%d"%i])
+            self.expect("expr vla[%d]"%i, substrs=["int", "%d"%i])
+        array = ["int []" #[2]
+                 , "1", "2"]
+        self.expect("fr v -d run-target -- vla", substrs=array)
+
+        process.Continue()
+        for i in range(4):
+            self.expect("fr v vla[%d]"%i, substrs=["int", "%d"%i])
+            self.expect("expr vla[%d]"%i, substrs=["int", "%d"%i])
+        array = ["int []" #[4]
+                 , "1", "2", "3", "4"]
+        self.expect("fr v -d run-target -- vla", substrs=array)

packages/Python/lldbsuite/test/lang/c/vla/main.c

+void pause() {}
+
+int foo(int a) {
+  int vla[a];
+
+  for (int i = 0; i < a; ++i)
+    vla[i] = i;
+
+  pause(); // break here
+  return vla[a-1];
+}
+
+int main (void) {
+  return foo(2) + foo(4);
+}

source/Core/ValueObjectCast.cpp

ValueObjectCast::ValueObjectCast(ValueObject &parent, const ConstString &name,
   m_value.SetCompilerType(cast_type);
 }
 
 ValueObjectCast::~ValueObjectCast() {}
 
 CompilerType ValueObjectCast::GetCompilerTypeImpl() { return m_cast_type; }
 
 size_t ValueObjectCast::CalculateNumChildren(uint32_t max) {
-  auto children_count = GetCompilerType().GetNumChildren(true);
+  ExecutionContext exe_ctx(GetExecutionContextRef());
+  auto children_count = GetCompilerType().GetNumChildren(
+      true, exe_ctx.GetBestExecutionContextScope());
   return children_count <= max ? children_count : max;
 }
 
 uint64_t ValueObjectCast::GetByteSize() {
   ExecutionContext exe_ctx(GetExecutionContextRef());
   return m_value.GetValueByteSize(nullptr, &exe_ctx);
 }
 

source/Core/ValueObjectChild.cpp

 
 ValueObjectChild::~ValueObjectChild() {}
 
 lldb::ValueType ValueObjectChild::GetValueType() const {
   return m_parent->GetValueType();
 }
 
 size_t ValueObjectChild::CalculateNumChildren(uint32_t max) {
-  auto children_count = GetCompilerType().GetNumChildren(true);
+  ExecutionContext exe_ctx(GetExecutionContextRef());
+  auto children_count = GetCompilerType().GetNumChildren(
+      true, exe_ctx.GetBestExecutionContextScope());
   return children_count <= max ? children_count : max;
 }
 
 static void AdjustForBitfieldness(ConstString &name,
                                   uint8_t bitfield_bit_size) {
   if (name && bitfield_bit_size) {
     const char *compiler_type_name = name.AsCString();
     if (compiler_type_name) {

source/Core/ValueObjectConstResult.cpp

if (m_byte_size == 0)
     SetByteSize(
         GetCompilerType().GetByteSize(exe_ctx.GetBestExecutionContextScope()));
   return m_byte_size;
 }
 
 void ValueObjectConstResult::SetByteSize(size_t size) { m_byte_size = size; }
 
 size_t ValueObjectConstResult::CalculateNumChildren(uint32_t max) {
-  auto children_count = GetCompilerType().GetNumChildren(true);
+  ExecutionContext exe_ctx(GetExecutionContextRef());
+  auto children_count = GetCompilerType().GetNumChildren(
+      true, exe_ctx.GetBestExecutionContextScope());
   return children_count <= max ? children_count : max;
 }
 
 ConstString ValueObjectConstResult::GetTypeName() {
   if (m_type_name.IsEmpty())
     m_type_name = GetCompilerType().GetConstTypeName();
   return m_type_name;
 }

source/Core/ValueObjectDynamicValue.cpp

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

source/Core/ValueObjectMemory.cpp

 }
 
 size_t ValueObjectMemory::CalculateNumChildren(uint32_t max) {
   if (m_type_sp) {
     auto child_count = m_type_sp->GetNumChildren(true);
     return child_count <= max ? child_count : max;
   }
 
+  ExecutionContext exe_ctx(GetExecutionContextRef());
   const bool omit_empty_base_classes = true;
-  auto child_count = m_compiler_type.GetNumChildren(omit_empty_base_classes);
+  auto child_count = m_compiler_type.GetNumChildren(
+      omit_empty_base_classes, exe_ctx.GetBestExecutionContextScope());
   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);
 }

source/Core/ValueObjectRegister.cpp

 
 ConstString ValueObjectRegister::GetTypeName() {
   if (m_type_name.IsEmpty())
     m_type_name = GetCompilerType().GetConstTypeName();
   return m_type_name;
 }
 
 size_t ValueObjectRegister::CalculateNumChildren(uint32_t max) {
-  auto children_count = GetCompilerType().GetNumChildren(true);
+  ExecutionContext exe_ctx(GetExecutionContextRef());
+  auto children_count = GetCompilerType().GetNumChildren(
+      true, exe_ctx.GetBestExecutionContextScope());
   return children_count <= max ? children_count : max;
 }
 
 uint64_t ValueObjectRegister::GetByteSize() { return m_reg_info.byte_size; }
 
 bool ValueObjectRegister::UpdateValue() {
   m_error.Clear();
   ExecutionContext exe_ctx(GetExecutionContextRef());

source/Core/ValueObjectVariable.cpp

 }
 
 size_t ValueObjectVariable::CalculateNumChildren(uint32_t max) {
   CompilerType type(GetCompilerType());
 
   if (!type.IsValid())
     return 0;
 
+  ExecutionContext exe_ctx(GetExecutionContextRef());
   const bool omit_empty_base_classes = true;
-  auto child_count = type.GetNumChildren(omit_empty_base_classes);
+  auto child_count = type.GetNumChildren(
+      omit_empty_base_classes, exe_ctx.GetBestExecutionContextScope());
   return child_count <= max ? child_count : max;
 }
 
 uint64_t ValueObjectVariable::GetByteSize() {
   ExecutionContext exe_ctx(GetExecutionContextRef());
 
   CompilerType type(GetCompilerType());
 

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

if (m_byte_size > 2 * sizeof(uint64_t)) {
         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);
+    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();
     }
 
     // case 2: homogeneous double or float aggregate
     CompilerType elem_type;
     if (m_type.IsHomogeneousAggregate(&elem_type)) {

source/Plugins/Language/CPlusPlus/BlockPointer.cpp

m_block_struct_type = clang_ast_context->CreateStructForIdentifier(
                         {reserved_name, reserved_type},
                         {FuncPtr_name, FuncPtr_type}});
   }
 
   ~BlockPointerSyntheticFrontEnd() override = default;
 
   size_t CalculateNumChildren() override {
     const bool omit_empty_base_classes = false;
-    return m_block_struct_type.GetNumChildren(omit_empty_base_classes);
+    return m_block_struct_type.GetNumChildren(omit_empty_base_classes, nullptr);
   }
 
   lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
     if (!m_block_struct_type.IsValid()) {
       return lldb::ValueObjectSP();
     }
 
     if (idx >= CalculateNumChildren()) {

source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

 //===-- DWARFASTParser.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFASTParser_h_
 #define SymbolFileDWARF_DWARFASTParser_h_
 
 #include "DWARFDefines.h"
 #include "lldb/Core/PluginInterface.h"
+#include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 
 class DWARFDIE;
+namespace lldb_private {
+class ExecutionContext;
+}
+class SymbolFileDWARF;
 
 class DWARFASTParser {
 public:
   virtual ~DWARFASTParser() {}
 
   virtual lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
                                           const DWARFDIE &die,
                                           lldb_private::Log *log,
public:
   virtual lldb_private::CompilerDeclContext
   GetDeclContextForUIDFromDWARF(const DWARFDIE &die) = 0;
 
   virtual lldb_private::CompilerDeclContext
   GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) = 0;
 
   virtual std::vector<DWARFDIE>
   GetDIEForDeclContext(lldb_private::CompilerDeclContext decl_context) = 0;
+
+  static llvm::Optional<lldb_private::SymbolFile::ArrayInfo>
+  ParseChildArrayInfo(const DWARFDIE &parent_die,
+                      const lldb_private::ExecutionContext *exe_ctx = nullptr);
 };
 
 #endif // SymbolFileDWARF_DWARFASTParser_h_

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

 #include "DWARFDefines.h"
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 
 class DWARFDebugInfoEntry;
 class DWARFDIECollection;
+class SymbolFileDWARF;
 
 class DWARFASTParserClang : public DWARFASTParser {
 public:
   DWARFASTParserClang(lldb_private::ClangASTContext &ast);
 
   ~DWARFASTParserClang() override;
 
   // DWARFASTParser interface.
ParseChildParameters(const lldb_private::SymbolContext &sc,
                        clang::DeclContext *containing_decl_ctx,
                        const DWARFDIE &parent_die, bool skip_artificial,
                        bool &is_static, bool &is_variadic,
                        bool &has_template_params,
                        std::vector<lldb_private::CompilerType> &function_args,
                        std::vector<clang::ParmVarDecl *> &function_param_decls,
                        unsigned &type_quals);
 
-  void ParseChildArrayInfo(const lldb_private::SymbolContext &sc,
-                           const DWARFDIE &parent_die, int64_t &first_index,
-                           std::vector<uint64_t> &element_orders,
-                           uint32_t &byte_stride, uint32_t &bit_stride);
-
   size_t ParseChildEnumerators(const lldb_private::SymbolContext &sc,
                                lldb_private::CompilerType &compiler_type,
                                bool is_signed, uint32_t enumerator_byte_size,
                                const DWARFDIE &parent_die);
 
   lldb_private::Type *GetTypeForDIE(const DWARFDIE &die);
 
   clang::Decl *GetClangDeclForDIE(const DWARFDIE &die);

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 
           DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                        DW_TAG_value_to_name(tag), type_name_cstr);
 
           DIERef type_die_ref(type_die_form);
           Type *element_type = dwarf->ResolveTypeUID(type_die_ref);
 
           if (element_type) {
-            std::vector<uint64_t> element_orders;
-            ParseChildArrayInfo(sc, die, first_index, element_orders,
-                                byte_stride, bit_stride);
+            auto array_info = ParseChildArrayInfo(die);
+            if (array_info) {
+              first_index = array_info->first_index;
+              byte_stride = array_info->byte_stride;
+              bit_stride = array_info->bit_stride;
+            }
             if (byte_stride == 0 && bit_stride == 0)
               byte_stride = element_type->GetByteSize();
             CompilerType array_element_type =
                 element_type->GetForwardCompilerType();
 
             if (ClangASTContext::IsCXXClassType(array_element_type) &&
                 array_element_type.GetCompleteType() == false) {
               ModuleSP module_sp = die.GetModule();

                                        "start its definition.\nPlease file a "
                                        "bug and attach the file at the start "
                                        "of this error message",
                                        type_die_ref.die_offset);
               }
             }
 
             uint64_t array_element_bit_stride = byte_stride * 8 + bit_stride;
-            if (element_orders.size() > 0) {
+            if (array_info && array_info->element_orders.size() > 0) {
               uint64_t num_elements = 0;
-              std::vector<uint64_t>::const_reverse_iterator pos;
-              std::vector<uint64_t>::const_reverse_iterator end =
-                  element_orders.rend();
-              for (pos = element_orders.rbegin(); pos != end; ++pos) {
+              auto end = array_info->element_orders.rend();
+              for (auto pos = array_info->element_orders.rbegin(); pos != end;
+                   ++pos) {
                 num_elements = *pos;
                 clang_type = m_ast.CreateArrayType(array_element_type,
                                                    num_elements, is_vector);
                 array_element_type = clang_type;
                 array_element_bit_stride =
                     num_elements ? array_element_bit_stride * num_elements
                                  : array_element_bit_stride;
               }
             } else {
               clang_type =
                   m_ast.CreateArrayType(array_element_type, 0, is_vector);
             }
             ConstString empty_name;
             type_sp.reset(new Type(
                 die.GetID(), dwarf, empty_name, array_element_bit_stride / 8,
                 NULL, DIERef(type_die_form).GetUID(dwarf), Type::eEncodingIsUID,
                 &decl, clang_type, Type::eResolveStateFull));
             type_sp->SetEncodingType(element_type);
+            m_ast.SetMetadataAsUserID(clang_type.GetOpaqueQualType(),
+                                      die.GetID());
           }
         }
       } break;
 
       case DW_TAG_ptr_to_member_type: {
         DWARFFormValue type_die_form;
         DWARFFormValue containing_type_die_form;
 
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
 
     default:
       break;
     }
   }
   return arg_idx;
 }
 
-void DWARFASTParserClang::ParseChildArrayInfo(
-    const SymbolContext &sc, const DWARFDIE &parent_die, int64_t &first_index,
-    std::vector<uint64_t> &element_orders, uint32_t &byte_stride,
-    uint32_t &bit_stride) {
+llvm::Optional<SymbolFile::ArrayInfo>
+DWARFASTParser::ParseChildArrayInfo(const DWARFDIE &parent_die,
+                                    const ExecutionContext *exe_ctx) {
+  SymbolFile::ArrayInfo array_info;
   if (!parent_die)
-    return;
+    return llvm::None;
 
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     const dw_tag_t tag = die.Tag();
     switch (tag) {
     case DW_TAG_subrange_type: {
       DWARFAttributes attributes;
       const size_t num_child_attributes = die.GetAttributes(attributes);
       if (num_child_attributes > 0) {
         uint64_t num_elements = 0;
         uint64_t lower_bound = 0;
         uint64_t upper_bound = 0;
         bool upper_bound_valid = false;
         uint32_t i;
         for (i = 0; i < num_child_attributes; ++i) {
           const dw_attr_t attr = attributes.AttributeAtIndex(i);
           DWARFFormValue form_value;
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
             switch (attr) {
             case DW_AT_name:
               break;
 
             case DW_AT_count:
+              if (DWARFDIE var_die = die.GetReferencedDIE(DW_AT_count)) {
+                if (var_die.Tag() == DW_TAG_variable)
+                  if (exe_ctx) {
+                    if (auto frame = exe_ctx->GetFrameSP()) {
+                      Status error;
+                      lldb::VariableSP var_sp;
+                      auto valobj_sp = frame->GetValueForVariableExpressionPath(
+                          var_die.GetName(), eNoDynamicValues, 0, var_sp,
+                          error);
+                      if (valobj_sp) {
+                        num_elements = valobj_sp->GetValueAsUnsigned(0);
+                        break;
+                      }
+                    }
+                  }
+                } else
                 num_elements = form_value.Unsigned();
               break;
 
             case DW_AT_bit_stride:
-              bit_stride = form_value.Unsigned();
+              array_info.bit_stride = form_value.Unsigned();
               break;
 
             case DW_AT_byte_stride:
-              byte_stride = form_value.Unsigned();
+              array_info.byte_stride = form_value.Unsigned();
               break;
 
             case DW_AT_lower_bound:
               lower_bound = form_value.Unsigned();
               break;
 
             case DW_AT_upper_bound:
               upper_bound_valid = true;
case DW_TAG_subrange_type: {
           }
         }
 
         if (num_elements == 0) {
           if (upper_bound_valid && upper_bound >= lower_bound)
             num_elements = upper_bound - lower_bound + 1;
         }
 
-        element_orders.push_back(num_elements);
+        array_info.element_orders.push_back(num_elements);
       }
     } break;
     }
   }
+  return array_info;
 }
 
+//llvm::Optional<SymbolFile::ArrayInfo>
+//DWARFASTParser::ParseChildArrayInfo(lldb::user_id_t uid, SymbolFile *sym_file,
+//                                    const ExecutionContext *exe_ctx) {
+//  return ParseChildArrayInfo(
+//      static_cast<SymbolFileDWARF *>(sym_file)->GetDIEFromUID(uid), exe_ctx);
+//}
+
 Type *DWARFASTParserClang::GetTypeForDIE(const DWARFDIE &die) {
   if (die) {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     DWARFAttributes attributes;
     const size_t num_attributes = die.GetAttributes(attributes);
     if (num_attributes > 0) {
       DWARFFormValue type_die_form;
       for (size_t i = 0; i < num_attributes; ++i) {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
   size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc) override;
 
   size_t ParseTypes(const lldb_private::SymbolContext &sc) override;
 
   size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
+  llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
+      lldb::user_id_t type_uid,
+      const lldb_private::ExecutionContext *exe_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
 
   lldb_private::Type *ResolveType(const DWARFDIE &die,
                                   bool assert_not_being_parsed = true,
                                   bool resolve_function_context = false);
 
   SymbolFileDWARF *GetDWARFForUID(lldb::user_id_t uid);

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Type *SymbolFileDWARF::ResolveTypeUID(lldb::user_id_t type_uid) {
   // SymbolFileDWARF::GetDIEFromUID() for details.
   DWARFDIE type_die = GetDIEFromUID(type_uid);
   if (type_die)
     return type_die.ResolveType();
   else
     return nullptr;
 }
 
+llvm::Optional<SymbolFile::ArrayInfo>
+SymbolFileDWARF::GetDynamicArrayInfoForUID(
+    lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
+  DWARFDIE type_die = GetDIEFromUID(type_uid);
+  if (type_die)
+    return DWARFASTParser::ParseChildArrayInfo(type_die, exe_ctx);
+  else
+    return llvm::None;
+}
+
 Type *SymbolFileDWARF::ResolveTypeUID(const DIERef &die_ref) {
   return ResolveType(GetDIE(die_ref), true);
 }
 
 Type *SymbolFileDWARF::ResolveTypeUID(const DWARFDIE &die,
                                       bool assert_not_being_parsed) {
   if (die) {
     Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

bool ParseImportedModules(
       const lldb_private::SymbolContext &sc,
       std::vector<lldb_private::ConstString> &imported_modules) override;
   size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc) override;
   size_t ParseTypes(const lldb_private::SymbolContext &sc) override;
   size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
+  llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
+      lldb::user_id_t type_uid,
+      const lldb_private::ExecutionContext *exe_ctx) override;
+
   lldb_private::CompilerDeclContext
   GetDeclContextForUID(lldb::user_id_t uid) override;
   lldb_private::CompilerDeclContext
   GetDeclContextContainingUID(lldb::user_id_t uid) override;
   void
   ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

if (first_comp_unit_info <= comp_unit_info &&
         comp_unit_info <= last_comp_unit_info)
       return comp_unit_info - first_comp_unit_info;
   }
   return UINT32_MAX;
 }
 
 SymbolFileDWARF *
 SymbolFileDWARFDebugMap::GetSymbolFileByOSOIndex(uint32_t oso_idx) {
-  if (oso_idx < m_compile_unit_infos.size())
+  unsigned size = m_compile_unit_infos.size();
+  if (oso_idx < size)
     return GetSymbolFileByCompUnitInfo(&m_compile_unit_infos[oso_idx]);
   return NULL;
 }
 
 SymbolFileDWARF *
 SymbolFileDWARFDebugMap::GetSymbolFileAsSymbolFileDWARF(SymbolFile *sym_file) {
   if (sym_file &&
       sym_file->GetPluginName() == SymbolFileDWARF::GetPluginNameStatic())

 Type *SymbolFileDWARFDebugMap::ResolveTypeUID(lldb::user_id_t type_uid) {
   const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid);
   SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
   if (oso_dwarf)
     return oso_dwarf->ResolveTypeUID(type_uid);
   return NULL;
 }
 
+llvm::Optional<SymbolFile::ArrayInfo>
+SymbolFileDWARFDebugMap::GetDynamicArrayInfoForUID(
+    lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
+  const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid);
+  SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
+  if (oso_dwarf)
+    return oso_dwarf->GetDynamicArrayInfoForUID(type_uid, exe_ctx);
+  return llvm::None;
+}
+
 bool SymbolFileDWARFDebugMap::CompleteType(CompilerType &compiler_type) {
   bool success = false;
   if (compiler_type) {
     ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
       if (oso_dwarf->HasForwardDeclForClangType(compiler_type)) {
         oso_dwarf->CompleteType(compiler_type);
         success = true;
         return true;

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

uint32_t FindGlobalVariables(const ConstString &name,
                                uint32_t max_matches,
                                VariableList &variables) override;
 
   size_t ParseTypes(const SymbolContext &sc) override;
   size_t ParseVariablesForContext(const SymbolContext &sc) override {
     return 0;
   }
   Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
+  llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
+      lldb::user_id_t type_uid,
+      const lldb_private::ExecutionContext *exe_ctx) override;
+
   bool CompleteType(CompilerType &compiler_type) override;
   uint32_t ResolveSymbolContext(const Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
                                 SymbolContext &sc) override;
 
   size_t GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
                   TypeList &type_list) override;
 

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

Type *SymbolFileNativePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
   TypeIndex ti(type_id.index);
   if (ti.isNoneType())
     return nullptr;
 
   TypeSP type_sp = CreateAndCacheType(uid);
   return &*type_sp;
 }
 
+llvm::Optional<SymbolFile::ArrayInfo>
+SymbolFileNativePDB::GetDynamicArrayInfoForUID(
+    lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
+  return llvm::None;
+}
+
+
 bool SymbolFileNativePDB::CompleteType(CompilerType &compiler_type) {
   // If this is not in our map, it's an error.
   clang::TagDecl *tag_decl = m_clang->GetAsTagDecl(compiler_type);
   lldbassert(tag_decl);
   auto status_iter = m_decl_to_status.find(tag_decl);
   lldbassert(status_iter != m_decl_to_status.end());
 
   // If it's already complete, just return.

source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
   size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc) override;
 
   size_t ParseTypes(const lldb_private::SymbolContext &sc) override;
 
   size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
+  llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
+      lldb::user_id_t type_uid,
+      const lldb_private::ExecutionContext *exe_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
 
   lldb_private::CompilerDecl GetDeclForUID(lldb::user_id_t uid) override;
 
   lldb_private::CompilerDeclContext
   GetDeclContextForUID(lldb::user_id_t uid) override;
 

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

if (result) {
     m_types.insert(std::make_pair(type_uid, result));
     auto type_list = GetTypeList();
     if (type_list)
       type_list->Insert(result);
   }
   return result.get();
 }
 
+llvm::Optional<SymbolFile::ArrayInfo> SymbolFilePDB::GetDynamicArrayInfoForUID(
+    lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
+  return llvm::None;
+}
+
 bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
   std::lock_guard<std::recursive_mutex> guard(
       GetObjectFile()->GetModule()->GetMutex());
 
   ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
   if (!clang_ast_ctx)
     return false;

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.h

public:
   size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc) override;
 
   size_t ParseTypes(const lldb_private::SymbolContext &sc) override;
 
   size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override;
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
+  llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
+      lldb::user_id_t type_uid,
+      const lldb_private::ExecutionContext *exe_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
 
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

 size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) {
   return 0;
 }
 
 Type *SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) {
   return NULL;
 }
 
+llvm::Optional<SymbolFile::ArrayInfo>
+SymbolFileSymtab::GetDynamicArrayInfoForUID(
+    lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
+  return llvm::None;
+}
+
 bool SymbolFileSymtab::CompleteType(lldb_private::CompilerType &compiler_type) {
   return false;
 }
 
 uint32_t SymbolFileSymtab::ResolveSymbolContext(const Address &so_addr,
                                                 SymbolContextItem resolve_scope,
                                                 SymbolContext &sc) {
   if (m_obj_file->GetSymtab() == NULL)

source/Symbol/ClangASTContext.cpp

if (check_superclass)
       class_interface_decl = class_interface_decl->getSuperClass();
     else
       break;
   }
   return false;
 }
 
 uint32_t ClangASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
-                                         bool omit_empty_base_classes) {
+                                         bool omit_empty_base_classes,
+                                         ExecutionContextScope *exe_scope) {
   if (!type)
     return 0;
 
   uint32_t num_children = 0;
   clang::QualType qual_type(GetQualType(type));
   const clang::Type::TypeClass type_class = qual_type->getTypeClass();
   switch (type_class) {
   case clang::Type::Builtin:
     switch (llvm::cast<clang::BuiltinType>(qual_type)->getKind()) {
     case clang::BuiltinType::ObjCId:    // child is Class
     case clang::BuiltinType::ObjCClass: // child is Class
       num_children = 1;
       break;
 
     default:
       break;
     }
     break;
 
   case clang::Type::Complex:
     return 0;
-
   case clang::Type::Record:
     if (GetCompleteQualType(getASTContext(), qual_type)) {
       const clang::RecordType *record_type =
           llvm::cast<clang::RecordType>(qual_type.getTypePtr());
       const clang::RecordDecl *record_decl = record_type->getDecl();
       assert(record_decl);
       const clang::CXXRecordDecl *cxx_record_decl =
           llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
case clang::Type::ObjCInterface:
     break;
 
   case clang::Type::ObjCObjectPointer: {
     const clang::ObjCObjectPointerType *pointer_type =
         llvm::cast<clang::ObjCObjectPointerType>(qual_type.getTypePtr());
     clang::QualType pointee_type = pointer_type->getPointeeType();
     uint32_t num_pointee_children =
         CompilerType(getASTContext(), pointee_type)
-            .GetNumChildren(omit_empty_base_classes);
+            .GetNumChildren(omit_empty_base_classes, exe_scope);
     // If this type points to a simple type, then it has 1 child
     if (num_pointee_children == 0)
       num_children = 1;
     else
       num_children = num_pointee_children;
   } break;
 
   case clang::Type::Vector:
   case clang::Type::ExtVector:
     num_children =
         llvm::cast<clang::VectorType>(qual_type.getTypePtr())->getNumElements();
     break;
 
   case clang::Type::ConstantArray:
     num_children = llvm::cast<clang::ConstantArrayType>(qual_type.getTypePtr())
                        ->getSize()
                        .getLimitedValue();
     break;
+  case clang::Type::IncompleteArray:
+    if (auto *metadata = GetMetadata(qual_type.getAsOpaquePtr())) {
+      if (auto *dwarf_parser = GetDWARFParser()) {
+        ExecutionContext exe_ctx;
+        if (exe_scope) {
+          exe_scope->CalculateExecutionContext(exe_ctx);
+          if (auto array_info = GetSymbolFile()->GetDynamicArrayInfoForUID(
+                  metadata->GetUserID(), &exe_ctx))
+
+            // Only 1-dimensional arrays are supported.
+            num_children = array_info->element_orders.size()
+                               ? array_info->element_orders.back()
+                               : 0;
+        }
+      }
+  }
+    break;
 
   case clang::Type::Pointer: {
     const clang::PointerType *pointer_type =
         llvm::cast<clang::PointerType>(qual_type.getTypePtr());
     clang::QualType pointee_type(pointer_type->getPointeeType());
     uint32_t num_pointee_children =
         CompilerType(getASTContext(), pointee_type)
-            .GetNumChildren(omit_empty_base_classes);
+      .GetNumChildren(omit_empty_base_classes, exe_scope);
     if (num_pointee_children == 0) {
       // We have a pointer to a pointee type that claims it has no children. We
       // will want to look at
       num_children = GetNumPointeeChildren(pointee_type);
     } else
       num_children = num_pointee_children;
   } break;
 
   case clang::Type::LValueReference:
   case clang::Type::RValueReference: {
     const clang::ReferenceType *reference_type =
         llvm::cast<clang::ReferenceType>(qual_type.getTypePtr());
     clang::QualType pointee_type = reference_type->getPointeeType();
     uint32_t num_pointee_children =
         CompilerType(getASTContext(), pointee_type)
-            .GetNumChildren(omit_empty_base_classes);
+            .GetNumChildren(omit_empty_base_classes, exe_scope);
     // If this type points to a simple type, then it has 1 child
     if (num_pointee_children == 0)
       num_children = 1;
     else
       num_children = num_pointee_children;
   } break;
 
   case clang::Type::Typedef:
     num_children =
         CompilerType(getASTContext(), llvm::cast<clang::TypedefType>(qual_type)
                                           ->getDecl()
                                           ->getUnderlyingType())
-            .GetNumChildren(omit_empty_base_classes);
+            .GetNumChildren(omit_empty_base_classes, exe_scope);
     break;
 
   case clang::Type::Auto:
     num_children =
         CompilerType(getASTContext(),
                      llvm::cast<clang::AutoType>(qual_type)->getDeducedType())
-            .GetNumChildren(omit_empty_base_classes);
+            .GetNumChildren(omit_empty_base_classes, exe_scope);
     break;
 
   case clang::Type::Elaborated:
     num_children =
         CompilerType(
             getASTContext(),
             llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType())
-            .GetNumChildren(omit_empty_base_classes);
+            .GetNumChildren(omit_empty_base_classes, exe_scope);
     break;
 
   case clang::Type::Paren:
     num_children =
         CompilerType(getASTContext(),
                      llvm::cast<clang::ParenType>(qual_type)->desugar())
-            .GetNumChildren(omit_empty_base_classes);
+            .GetNumChildren(omit_empty_base_classes, exe_scope);
     break;
   default:
     break;
   }
   return num_children;
 }
 
 CompilerType ClangASTContext::GetBuiltinTypeByName(const ConstString &name) {
CompilerType ClangASTContext::GetChildCompilerTypeAtIndex(
   clang::QualType parent_qual_type(GetCanonicalQualType(type));
   const clang::Type::TypeClass parent_type_class =
       parent_qual_type->getTypeClass();
   child_bitfield_bit_size = 0;
   child_bitfield_bit_offset = 0;
   child_is_base_class = false;
   language_flags = 0;
 
-  const bool idx_is_valid = idx < GetNumChildren(type, omit_empty_base_classes);
+  const bool idx_is_valid =
+      idx < GetNumChildren(type, omit_empty_base_classes,
+                           exe_ctx ? exe_ctx->GetBestExecutionContextScope()
+                                   : nullptr);
   int32_t bit_offset;
   switch (parent_type_class) {
   case clang::Type::Builtin:
     if (idx_is_valid) {
       switch (llvm::cast<clang::BuiltinType>(parent_qual_type)->getKind()) {
       case clang::BuiltinType::ObjCId:
       case clang::BuiltinType::ObjCClass:
         child_name = "isa";
if (idx_is_valid && GetCompleteType(type)) {
           clang::ObjCInterfaceDecl *superclass_interface_decl =
               class_interface_decl->getSuperClass();
           if (superclass_interface_decl) {
             if (omit_empty_base_classes) {
               CompilerType base_class_clang_type(
                   getASTContext(), getASTContext()->getObjCInterfaceType(
                                        superclass_interface_decl));
               if (base_class_clang_type.GetNumChildren(
-                      omit_empty_base_classes) > 0) {
+                      omit_empty_base_classes,
+                      exe_ctx ? exe_ctx->GetBestExecutionContextScope()
+                              : nullptr) > 0) {
                 if (idx == 0) {
                   clang::QualType ivar_qual_type(
                       getASTContext()->getObjCInterfaceType(
                           superclass_interface_decl));
 
                   child_name.assign(
                       superclass_interface_decl->getNameAsString());
 

source/Symbol/CompilerType.cpp

 
 lldb::Format CompilerType::GetFormat() const {
   if (!IsValid())
     return lldb::eFormatDefault;
 
   return m_type_system->GetFormat(m_type);
 }
 
-uint32_t CompilerType::GetNumChildren(bool omit_empty_base_classes) const {
+uint32_t CompilerType::GetNumChildren(bool omit_empty_base_classes,
+                                      ExecutionContextScope *exe_scope) const {
   if (!IsValid())
     return 0;
-  return m_type_system->GetNumChildren(m_type, omit_empty_base_classes);
+  return m_type_system->GetNumChildren(m_type, omit_empty_base_classes,
+                                       exe_scope);
 }
 
 lldb::BasicType CompilerType::GetBasicTypeEnumeration() const {
   if (IsValid())
     return m_type_system->GetBasicTypeEnumeration(m_type);
   return eBasicTypeInvalid;
 }
 

source/Symbol/GoASTContext.cpp

lldb::Format GoASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
   }
 }
 
 size_t GoASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) {
   return 0;
 }
 
 uint32_t GoASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
-                                      bool omit_empty_base_classes) {
+                                      bool omit_empty_base_classes,
+                                      ExecutionContextScope *exe_scope) {
   if (!type || !GetCompleteType(type))
     return 0;
   GoType *t = static_cast<GoType *>(type);
   if (t->GetGoKind() == GoType::KIND_PTR) {
     CompilerType elem = t->GetElementType();
     if (elem.IsAggregateType())
-      return elem.GetNumChildren(omit_empty_base_classes);
+      return elem.GetNumChildren(omit_empty_base_classes, exe_scope);
     return 1;
   } else if (GoArray *array = t->GetArray()) {
     return array->GetLength();
   } else if (t->IsTypedef()) {
-    return t->GetElementType().GetNumChildren(omit_empty_base_classes);
+    return t->GetElementType().GetNumChildren(omit_empty_base_classes,
+                                              exe_scope);
   }
 
   return GetNumFields(type);
 }
 
 uint32_t GoASTContext::GetNumFields(lldb::opaque_compiler_type_t type) {
   if (!type || !GetCompleteType(type))
     return 0;

source/Symbol/JavaASTContext.cpp

if (JavaObjectType *obj =
     if (bit_offset_ptr)
       *bit_offset_ptr = field->m_offset * 8;
     return field->m_type;
   }
   return CompilerType();
 }
 
 uint32_t JavaASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
-                                        bool omit_empty_base_classes) {
+                                        bool omit_empty_base_classes,
+                                        ExecutionContextScope *exe_scope) {
   GetCompleteType(type);
 
   if (JavaReferenceType *ref =
           llvm::dyn_cast<JavaReferenceType>(static_cast<JavaType *>(type)))
-    return ref->GetPointeeType().GetNumChildren(omit_empty_base_classes);
+    return ref->GetPointeeType().GetNumChildren(omit_empty_base_classes,
+                                                exe_scope);
 
   if (llvm::isa<JavaObjectType>(static_cast<JavaType *>(type)))
     return GetNumFields(type) + GetNumDirectBaseClasses(type);
 
   return 0;
 }
 
 uint32_t

source/Symbol/OCamlASTContext.cpp

lldb::Format OCamlASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
   return lldb::eFormatBytes;
 }
 
 size_t OCamlASTContext::GetTypeBitAlign(lldb::opaque_compiler_type_t type) {
   return 0;
 }
 
 uint32_t OCamlASTContext::GetNumChildren(lldb::opaque_compiler_type_t type,
-                                         bool omit_empty_base_classes) {
+                                         bool omit_empty_base_classes,
+                                         ExecutionContextScope *exe_scope) {
   if (!type || !GetCompleteType(type))
     return 0;
 
   return GetNumFields(type);
 }
 
 uint32_t OCamlASTContext::GetNumFields(lldb::opaque_compiler_type_t type) {
   if (!type || !GetCompleteType(type))

source/Symbol/Type.cpp

case eEncodingIsRValueReferenceUID: {
         m_byte_size = arch.GetAddressByteSize();
     } break;
     }
   }
   return m_byte_size;
 }
 
 uint32_t Type::GetNumChildren(bool omit_empty_base_classes) {
-  return GetForwardCompilerType().GetNumChildren(omit_empty_base_classes);
+  return GetForwardCompilerType().GetNumChildren(omit_empty_base_classes, nullptr);
 }
 
 bool Type::IsAggregateType() {
   return GetForwardCompilerType().IsAggregateType();
 }
 
 lldb::TypeSP Type::GetTypedefType() {
   lldb::TypeSP type_sp;

source/Symbol/Variable.cpp

if (compiler_type.IsValid()) {
         break;
 
       case eTypeClassObjCObject:
       case eTypeClassObjCInterface:
         break;
       case eTypeClassObjCObjectPointer:
       case eTypeClassPointer: {
         bool omit_empty_base_classes = true;
-        if (compiler_type.GetNumChildren(omit_empty_base_classes) > 0)
+        if (compiler_type.GetNumChildren(omit_empty_base_classes, nullptr) > 0)
           matches.AppendString((prefix_path + "->").str());
         else {
           matches.AppendString(prefix_path.str());
           word_complete = true;
         }
       } break;
       }
     } else {