Fix (and improve) the support for C99 variable length array types

[aprantl]

Summary

Clang recently improved its DWARF support for C VLA types. The DWARF now looks like this:

0x00000051:         DW_TAG_variable [4]  
                     DW_AT_location( fbreg -32 )
                     DW_AT_name( "__vla_expr" )
                     DW_AT_type( {0x000000d3} ( long unsigned int ) )
                     DW_AT_artificial( true )
...
0x000000da:     DW_TAG_array_type [10] *
                 DW_AT_type( {0x000000cc} ( int ) )

0x000000df:         DW_TAG_subrange_type [11]  
                     DW_AT_type( {0x000000e9} ( __ARRAY_SIZE_TYPE__ ) )
                     DW_AT_count( {0x00000051} )

Without this patch LLDB will naively interpret the DIE offset 0x51 as the static size of the array, which is clearly wrong.
This patch uses LLDB's dynamic type mechanism to re-parse VLA types with an optional execution context, to dynamically resolve the size of the array correctly. These dynamic types are not being cached, since they are only valid in a single execution context.

See the testcase for an example:

   4   int foo(int a) {
   5   	  int vla[a];
   6   	  for (int i = 0; i < a; ++i)
   7   	    vla[i] = i;
   8   	
-> 9   	  pause(); // break here
   10  	  return vla[a-1];
   11  	}
   12  	

(lldb) fr v vla
(int [4]) vla = ([0] = 0, [1] = 1, [2] = 2, [3] = 3)
(lldb) quit

[jingham]

This seems good to me, but Greg is more expert than I so I'd wait on his okay.

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

1901–1907

You have to do this twice, maybe there should be a method to add the results to the DIE to Type map?

[aprantl]

Factor out caching of types as suggested. Thanks!

[clayborg]

Parsing a type shouldn't need an execution context and we shouldn't be re-parsing a type over and over for each frame. We should be encoding the array expression somewhere that we can access it when we need to get the number of children using the current execution context.

The way I would prefer to see this:

• Revert all SymbolFile changes that added an execution context to type parsing
• Change the type parsing logic in SymbolFileDWARF to store the array count expression in some format in the TypeSystem (ClangASTContext.cpp) that is associated with the clang opaque type via clang type metadata maybe?
• Change "virtual uint32_t TypeSystem::GetNumChildren(...);" and "virtual CompilerType TypeSystem::GetChildCompilerTypeAtIndex(...);" to take an execution context that defaults to nothing like you did with the type parsing in the first patch. This execution context can be used to evaluate the count expression as needed. We can attempt to grab the count expression from the clang opaque type that we stored in the above step, and if one exists, use the current frame to evaluate it correctly.

source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

213–229

We must abstract this via the TypeSystem stuff and make this happen via the CompilerType interface. What happens when "in_value" is a swift type or other type from the type system? Crash

[davide]

source/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

213–229

My understanding is that it is not possible today to get here with a swift type. In fact, GetDynamicTypeAndAddress in swift will be always called on a SwiftLanguageRuntime.

That said, I'm not necessarily advocating against the abstraction, just pointing out that this is just a theoretical concern, and given this is an internal API in the debugger, it could be possibly enforced by an assertion to make sure people don't change the status quo accidentally.

[aprantl]

I now spent (way too much :-) time experimenting with alternative implementations of this patch. In https://reviews.llvm.org/D53961 there is a version that changes GetNumChildren() to take an execution context. I don't think that doing it this way is a good solution either and here's why:

If we move the logic to GetNumChildren; we can print the array elements, but the type remains unchanged, which makes for a worse user experience.

With VLAs implemented as dynamic types we get

(lldb) fr v vla
(int [4]) vla = ([0] = 1, [1] = 2)

if we only change GetNumChildren() we get

(lldb) fr v vla
(int []) vla = ([0] = 1, [1] = 2)

which is less nice, since we no longer see the size of the array.

What i'm proposing is to keep the implementation as a dynamic type in ItaniumABILanguageRuntime.cpp but reduce the surface area of the execution context pass-through in DWARFASTParserClang.cpp. Similar to what I did in https://reviews.llvm.org/D53961 we can add a ResolveDynamicArrayUID(uid, exe_ctx) method that only creates an array type. Since we need to re-create a fresh clang type at every execution context anyway, going through the single-function array-only DWARF parser seems like the right trade-off to me. Let me know what you think!

[clayborg]

The only other thing you would need to change to get the usability back in check when doing things in GetNumChildren() would be to have the function that gets the typename take on optional execution context for dynamic types. The ValueObject can easily pass its execution context when getting the typename. Anyone who doesn't would continue to get the "int []" as the typename which isn't really lying either way. Thoughts?

[aprantl]

To me a VLA fulfills all properties of a dynamic type so not modeling it as a dynamic type feels backwards to me. But not having to deal with temporary clang types might be worth the trade-off.

The only other thing you would need to change to get the usability back in check when doing things in GetNumChildren() would be to have the function that gets the typename take on optional execution context for dynamic types. The ValueObject can easily pass its execution context when getting the typename. Anyone who doesn't would continue to get the "int []" as the typename which isn't really lying either way. Thoughts?

I didn't realize that the string int [] is produced by ValueObject itself; I think this makes this option more palatable to me. I'll give it a try.

[aprantl]

I didn't realize that the string int [] is produced by ValueObject itself; I think this makes this option more palatable to me. I'll give it a try.

So, it turns out it isn't. The only way to get the length into the typename is to hack ClangASTContext::GetTypeName to replace the training "[]" of what clang returns as the typename with a different string. The main problem with this is that this will only work for outermost types.

Something that has been requested in the past is to support C structs with trailing array members, such as

struct variable_size {
  unsigned length;
  int __attribute__((size=.length)) elements[]; // I just made up this attribute, but you get the basic idea.
};

in a similar fashion. When printing such a struct, there's no way of safely injecting the size into array type string any more.
If we dynamically created the correctly-sized array type instead, this would work just fine.

I haven't yet understood the motivation behind why overriding GetNumChildren/GetTypeName/GetChildAtIndex is preferable over creating a dynamic type in the language runtime. Is there something that I need to know?

[clayborg]

In D53530#1284267, @aprantl wrote:

I didn't realize that the string int [] is produced by ValueObject itself; I think this makes this option more palatable to me. I'll give it a try.

So, it turns out it isn't. The only way to get the length into the typename is to hack ClangASTContext::GetTypeName to replace the training "[]" of what clang returns as the typename with a different string. The main problem with this is that this will only work for outermost types.

Something that has been requested in the past is to support C structs with trailing array members, such as

struct variable_size {
  unsigned length;
  int __attribute__((size=.length)) elements[]; // I just made up this attribute, but you get the basic idea.
};

in a similar fashion. When printing such a struct, there's no way of safely injecting the size into array type string any more.
If we dynamically created the correctly-sized array type instead, this would work just fine.

I haven't yet understood the motivation behind why overriding GetNumChildren/GetTypeName/GetChildAtIndex is preferable over creating a dynamic type in the language runtime. Is there something that I need to know?

Creating a new dynamic type every time you stop seems like a lot of work and a possible waste of memory. You will need to see if you already have such a type ("int[4]" already exists) and use it if it does each time you stop. Any type that can change dynamically should easily be able to be detected by the type system in GetNumChildren(...) with the right execution context and and a dynamic type name can also easily be calculated in the type system. One option would be to just display "int[]" and have a summary for any dynamic array types that says "size = 4". Then we don't have to touch the typename.

[aprantl]

Version that only overrides GetNumChildren to avoid creating dynamic clang types.

[aprantl]

Fair point. So here's a version that only overrides GetNumChildren(). I'll leave the type summary for a follow-up patch.

[aprantl]

Fix a bug in the testcase.

[clayborg]

Thanks for making the changes!

[aprantl]

Thanks for your patience!

[stella.stamenova]

TestVla fails on Windows: http://lab.llvm.org:8014/builders/lldb-x64-windows-ninja/builds/1129/steps/test/logs/stdio

AssertionError: False is not True : 'frame var vla' returns expected result, got '(int []) vla = {}'

I will have time to look in more detail later this week, but if you have any ideas in the mean time, that would be great.

[aprantl]

In D53530#1290664, @stella.stamenova wrote:

TestVla fails on Windows: http://lab.llvm.org:8014/builders/lldb-x64-windows-ninja/builds/1129/steps/test/logs/stdio

AssertionError: False is not True : 'frame var vla' returns expected result, got '(int []) vla = {}'

I will have time to look in more detail later this week, but if you have any ideas in the mean time, that would be great.

Is your bot using DWARF or CodeView as a debug info format? Because this test definitely requires DWARF.

[stella.stamenova]

In D53530#1290680, @aprantl wrote:

In D53530#1290664, @stella.stamenova wrote:

TestVla fails on Windows: http://lab.llvm.org:8014/builders/lldb-x64-windows-ninja/builds/1129/steps/test/logs/stdio

AssertionError: False is not True : 'frame var vla' returns expected result, got '(int []) vla = {}'

I will have time to look in more detail later this week, but if you have any ideas in the mean time, that would be great.

Is your bot using DWARF or CodeView as a debug info format? Because this test definitely requires DWARF.

I was under the impression that each test can control how to build the necessary payloads. Is that not the case?

[llvm-commits]

For dotest style tests, the debug format to test is chosen by the test driver. All the tests should run with any format, but sometimes there are bugs in one reader or another (or in one version of DWARF or another) so you can skip or xfail a test based on format. Sounds like this test should be skipped when the debug format is PDB, since it seems like either the PDB format doesn't express a way to find the actual size of the vla (or the current PDB reader doesn't process those records).

Jim

[jankratochvil]

There is a regression in trunk clang+lldb on Fedora 29 x86_64. Using either 7.0 clang or 7.0 lldb makes the testcases PASS but both trunk clang and trunk lldb makes the testcase FAIL.
This commit (rL346165) is the regressing one for LLDB, commit rL349207 by @dblaikie is the regressing one for clang.

TestChar1632T.py

FAIL:

Failure-TestChar1632T-Char1632TestCase-test_dwo-x86_64-redhat-llvm-monorepo-clang-bin-clang-8.log
runCmd: frame variable as16 as32
output: (char16_t []) as16 = {}
(char32_t []) as32 = {}

PASS:

Success-TestChar1632T-Char1632TestCase-test_dwo-x86_64-redhat-llvm-monorepo-clang-bin-clang-8.log
runCmd: frame variable as16 as32
output: (char16_t [64]) as16 = u"ﺸﺵۻ"
(char32_t [64]) as32 = U"ЕЙРГЖО"

clang-1	lldb-1	PASS
clang-1	lldb	PASS
clang	lldb-1	PASS
clang	lldb	FAIL

monorepo:
clang-1=d162fb426deb61f897038e07ebd2fcaae8e51c01^=b36eb520c704507990b039011cc02c3da181c461
clang =d162fb426deb61f897038e07ebd2fcaae8e51c01
lldb -1=0154738f9a1f73b5fe108671f61554b94eabf3fb^=91e3d2bffe38dbde2976cbb76cecce97a3e94af6
lldb =0154738f9a1f73b5fe108671f61554b94eabf3fb

git:
clang = b4b260e17979210464c395ee00e6c985f305a16e = https://reviews.llvm.org/rL349207
lldb = 8fea0d8957787360d7e5abefc7b6a94991c07f85 = https://reviews.llvm.org/rL346165 = https://reviews.llvm.org/D53530

GDB seems to handle the clang output OK:

gdb -batch -ex 'b 42' -ex r -ex 'p as16' -ex 'p as32' ./lldb-test-build.noindex/lang/cpp/char1632_t/TestChar1632T.test_dwo/a.out
...
$1 = u"色ハ匂ヘト散リヌルヲ\000\000\000\000\000\000y\000\000\000\xde08@\000\000᯿\001\000\000ᰰ\001\000\000ﾐ\xffff\xffff\xffffѰ\000\000\000ᇁ\000Ҡ\000ᕭ@\000\000ῠ翿\000\000\000\000\000ᔠ@\000\000ၐ@\000"
$2 = U"෴\000РГЖО\000\000\000\000\x6562b026\000\xf7ffea80翿\xf7b89061翿\xf7c55c60翿ɐ\000\xf7c564f8翿\xf7b1d5ad翿\002\000\xf7b198d7翿\000\000\x405000\000ɰ\000\xfffff000\xffffffff\000\000\000\000\000\000\000\000\000\000\xf7c55cc0翿#\000\000\000\xffffff90\xffffffff\xf7c55c60翿ɐ\000\xf7b1a909翿ɀ\000\000"

Using for the test:

PYTHONPATH=$PWD/lib64/python2.7/site-packages:$PWD/lib64/python2.7/site-packages/lldb" LD_LIBRARY_PATH=$PWD/lib:$PWD/lib64/python2.7/site-packages/lldb" ../llvm-monorepo/lldb/test/dotest.py --executable /PATH/TO/bin/lldb -C $PWD/bin/clang --log-success -t ../llvm-monorepo/lldb/packages/Python/lldbsuite/test/  -p TestChar1632T.py

[jankratochvil]

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

3476 ↗

(On Diff #172639)

Here it could accidentally follow a number as DIE reference, addressed by: D56068

include/lldb/Symbol/SymbolFile.h

ParseCompileUnitIsOptimized(const lldb_private::SymbolContext &sc) {
     return false;
   }
   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;
+  virtual Type *
+  ResolveTypeUID(lldb::user_id_t type_uid,
+                 const lldb_private::ExecutionContextRef 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/Variable.h

public:
   // namespace)::i", this function will allow a generic match function that can
   // be called by commands and expression parsers to make sure we match
   // anything we come across.
   bool NameMatches(const ConstString &name) const;
 
   bool NameMatches(const RegularExpression &regex) const;
 
   Type *GetType();
  
   lldb::LanguageType GetLanguage() const;
 
   lldb::ValueType GetScope() const { return m_scope; }
 
   bool IsExternal() const { return m_external; }
 
   bool IsArtificial() const { return m_artificial; }
 

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/Plugins/LanguageRuntime/CPlusPlus/ItaniumABI/ItaniumABILanguageRuntime.cpp

 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
+#include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StopInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
bool ItaniumABILanguageRuntime::GetDynamicTypeAndAddress(
   class_type_or_name.Clear();
   value_type = Value::ValueType::eValueTypeScalar;
 
   // Only a pointer or reference type can have a different dynamic and static
   // type:
   if (!CouldHaveDynamicValue(in_value))
     return false;
 
+  ExecutionContext exe_ctx(in_value.GetExecutionContextRef());
+  
+  // Handle variables with incomplete array types.
+  auto *type = in_value.GetCompilerType().GetOpaqueQualType();
+  auto qual_type = clang::QualType::getFromOpaquePtr(type).getCanonicalType();
+  if (qual_type->getTypeClass() == clang::Type::IncompleteArray) {
+    if (auto variable = in_value.GetVariable()) {
+      auto *lldb_type = variable->GetType();
+      auto *symbol_file = lldb_type->GetSymbolFile();
+      auto uid = lldb_type->GetID();
+      if (auto dyn_type = symbol_file->ResolveTypeUID(uid, exe_ctx)) {
+        class_type_or_name.SetCompilerType(dyn_type->GetFullCompilerType());
+        value_type = Value::ValueType::eValueTypeLoadAddress;
+        dynamic_address = in_value.GetAddressOf();
+        return true;
+      }
+    }
+  }
+
   // First job, pull out the address at 0 offset from the object.
   AddressType address_type;
   lldb::addr_t original_ptr = in_value.GetPointerValue(&address_type);
   if (original_ptr == LLDB_INVALID_ADDRESS)
     return false;
 
-  ExecutionContext exe_ctx(in_value.GetExecutionContextRef());
-
   Process *process = exe_ctx.GetProcessPtr();
-
   if (process == nullptr)
     return false;
 
   Status error;
   const lldb::addr_t vtable_address_point =
       process->ReadPointerFromMemory(original_ptr, error);
 
   if (!error.Success() || vtable_address_point == LLDB_INVALID_ADDRESS)

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/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
+#include "lldb/Target/ExecutionContext.h"
 
 class DWARFDIE;
 
 class DWARFASTParser {
 public:
   virtual ~DWARFASTParser() {}
 
-  virtual lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
-                                          const DWARFDIE &die,
-                                          lldb_private::Log *log,
-                                          bool *type_is_new_ptr) = 0;
+  virtual lldb::TypeSP
+  ParseTypeFromDWARF(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
+                     lldb_private::Log *log, bool *type_is_new_ptr,
+                     const lldb_private::ExecutionContextRef exe_ctx = {}) = 0;
 
   virtual lldb_private::Function *
   ParseFunctionFromDWARF(const lldb_private::SymbolContext &sc,
                          const DWARFDIE &die) = 0;
 
   virtual bool
   CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) = 0;

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

 
 class DWARFASTParserClang : public DWARFASTParser {
 public:
   DWARFASTParserClang(lldb_private::ClangASTContext &ast);
 
   ~DWARFASTParserClang() override;
 
   // DWARFASTParser interface.
-  lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
-                                  const DWARFDIE &die, lldb_private::Log *log,
-                                  bool *type_is_new_ptr) override;
+  lldb::TypeSP ParseTypeFromDWARF(
+      const lldb_private::SymbolContext &sc, const DWARFDIE &die,
+      lldb_private::Log *log, bool *type_is_new_ptr,
+      const lldb_private::ExecutionContextRef exe_ctx = {}) override;
 
   lldb_private::Function *
   ParseFunctionFromDWARF(const lldb_private::SymbolContext &sc,
                          const DWARFDIE &die) override;
 
   bool
   CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) override;
ParseChildParameters(const lldb_private::SymbolContext &sc,
                        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);
+                           uint32_t &byte_stride, uint32_t &bit_stride,
+                           const lldb_private::ExecutionContextRef exe_ctx);
 
   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);
 
bool CopyUniqueClassMethodTypes(const DWARFDIE &src_class_die,
                                   DWARFDIECollection &failures);
 
   clang::DeclContext *GetCachedClangDeclContextForDIE(const DWARFDIE &die);
 
   void LinkDeclContextToDIE(clang::DeclContext *decl_ctx, const DWARFDIE &die);
 
   void LinkDeclToDIE(clang::Decl *decl, const DWARFDIE &die);
 
-  lldb::TypeSP ParseTypeFromDWO(const DWARFDIE &die, lldb_private::Log *log);
+  lldb::TypeSP
+  ParseTypeFromDWO(const DWARFDIE &die, lldb_private::Log *log,
+                   const lldb_private::ExecutionContextRef exe_ctx = {});
 
   //----------------------------------------------------------------------
   // Return true if this type is a declaration to a type in an external
   // module.
   //----------------------------------------------------------------------
   lldb::ModuleSP GetModuleForType(const DWARFDIE &die);
 
   typedef llvm::SmallPtrSet<const DWARFDebugInfoEntry *, 4> DIEPointerSet;

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 #include <stdlib.h>
 
 #include "DWARFASTParserClang.h"
 #include "DWARFDIE.h"
 #include "DWARFDIECollection.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDeclContext.h"
 #include "DWARFDefines.h"
+#include "LogChannelDWARF.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "UniqueDWARFASTType.h"
 
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
static bool isClangModuleFwdDecl(const DWARFDIE &Die) {
   while (Parent.IsValid()) {
     if (Parent.Tag() == DW_TAG_module)
       return true;
     Parent = Parent.GetParent();
   }
   return false;
 }
 
-TypeSP DWARFASTParserClang::ParseTypeFromDWO(const DWARFDIE &die, Log *log) {
+TypeSP DWARFASTParserClang::ParseTypeFromDWO(
+    const DWARFDIE &die, Log *log,
+    const lldb_private::ExecutionContextRef exe_ctx) {
   ModuleSP dwo_module_sp = die.GetContainingDWOModule();
   if (!dwo_module_sp)
     return TypeSP();
 
   // This type comes from an external DWO module.
   std::vector<CompilerContext> dwo_context;
   die.GetDWOContext(dwo_context);
   TypeMap dwo_types;
for (const auto &NameModule : SymFile->getExternalTypeModules()) {
         break;
     }
   }
 
   const size_t num_dwo_types = dwo_types.GetSize();
   if (num_dwo_types != 1)
     return TypeSP();
 
-  // We found a real definition for this type in the Clang module, so lets use
+  // We found a real definition for this type in the Clang module, so let's use
   // it and cache the fact that we found a complete type for this die.
   TypeSP dwo_type_sp = dwo_types.GetTypeAtIndex(0);
   if (!dwo_type_sp)
     return TypeSP();
 
   lldb_private::CompilerType dwo_type = dwo_type_sp->GetForwardCompilerType();
 
   lldb_private::CompilerType type =
       GetClangASTImporter().CopyType(m_ast, dwo_type);
 
   if (!type)
     return TypeSP();
 
   SymbolFileDWARF *dwarf = die.GetDWARF();
   TypeSP type_sp(new Type(
       die.GetID(), dwarf, dwo_type_sp->GetName(), dwo_type_sp->GetByteSize(),
       NULL, LLDB_INVALID_UID, Type::eEncodingInvalid,
       &dwo_type_sp->GetDeclaration(), type, Type::eResolveStateForward));
 
+  // We are ready to put this type into the uniqued list up at the module
+  // level.
   dwarf->GetTypeList()->Insert(type_sp);
-  dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+  // Cache the type if it isn't context-specific.
+  auto &cache = dwarf->GetDIEToType();
+  if (exe_ctx.GetFrameSP())
+    cache.erase(die.GetDIE());
+  else
+    cache[die.GetDIE()] = type_sp.get();
+
   clang::TagDecl *tag_decl = ClangASTContext::GetAsTagDecl(type);
   if (tag_decl)
     LinkDeclContextToDIE(tag_decl, die);
   else {
     clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(die);
     if (defn_decl_ctx)
       LinkDeclContextToDIE(defn_decl_ctx, die);
   }
die.GetDWARF()->GetObjectFile()->GetModule()->ReportError(
         type_name_cstr ? type_name_cstr : "", die.GetOffset());
     // We need to make the type look complete otherwise, we might crash in
     // Clang when adding children.
     if (ClangASTContext::StartTagDeclarationDefinition(type))
       ClangASTContext::CompleteTagDeclarationDefinition(type);
   }
 }
 
-TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
-                                               const DWARFDIE &die, Log *log,
-                                               bool *type_is_new_ptr) {
+TypeSP DWARFASTParserClang::ParseTypeFromDWARF(
+    const SymbolContext &sc, const DWARFDIE &die, Log *log,
+    bool *type_is_new_ptr, const lldb_private::ExecutionContextRef exe_ctx) {
   TypeSP type_sp;
 
   if (type_is_new_ptr)
     *type_is_new_ptr = false;
 
   AccessType accessibility = eAccessNone;
   if (die) {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     if (log) {
       DWARFDIE context_die;
       clang::DeclContext *context =
           GetClangDeclContextContainingDIE(die, &context_die);
 
       dwarf->GetObjectFile()->GetModule()->LogMessage(
           log, "SymbolFileDWARF::ParseType (die = 0x%8.8x, decl_ctx = %p (die "
                "0x%8.8x)) %s name = '%s')",
           die.GetOffset(), static_cast<void *>(context),
           context_die.GetOffset(), die.GetTagAsCString(), die.GetName());
     }
     Type *type_ptr = dwarf->GetDIEToType().lookup(die.GetDIE());
-    TypeList *type_list = dwarf->GetTypeList();
-    if (type_ptr == NULL) {
+    // If an execution context is present, re-parse the type.
+    if (type_ptr == NULL || exe_ctx.GetFrameSP()) {
       if (type_is_new_ptr)
         *type_is_new_ptr = true;
 
       const dw_tag_t tag = die.Tag();
 
       bool is_forward_declaration = false;
       DWARFAttributes attributes;
       const char *type_name_cstr = NULL;

                        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);
+                                byte_stride, bit_stride, exe_ctx);
             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();

             symbol_context_scope = sc.function;
         }
 
         if (symbol_context_scope != NULL) {
           type_sp->SetSymbolContextScope(symbol_context_scope);
         }
 
         // We are ready to put this type into the uniqued list up at the module
-        // level
-        type_list->Insert(type_sp);
-
-        dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+        // level.
+        dwarf->GetTypeList()->Insert(type_sp);
+        // Cache the type if it isn't context-specific.
+        auto &cache = dwarf->GetDIEToType();
+        if (exe_ctx.GetFrameSP())
+          cache.erase(die.GetDIE());
+        else
+          cache[die.GetDIE()] = type_sp.get();
       }
     } else if (type_ptr != DIE_IS_BEING_PARSED) {
       type_sp = type_ptr->shared_from_this();
     }
   }
   return type_sp;
 }
 
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
     }
   }
   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) {
+    uint32_t &bit_stride, const lldb_private::ExecutionContextRef exe_ctx) {
   if (!parent_die)
     return;
 
   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: {
case DW_TAG_subrange_type: {
           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 (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);
+                      if (auto log = LogChannelDWARF::GetLogIfAll(
+                              DWARF_LOG_DEBUG_INFO))
+                        log->Printf("Reparsing array type; dynamic size=%lld",
+                                    num_elements);
+
+                      break;
+                    }
+                  }
+              } else
                 num_elements = form_value.Unsigned();
               break;
 
             case DW_AT_bit_stride:
               bit_stride = form_value.Unsigned();
               break;
 
             case DW_AT_byte_stride:
               byte_stride = form_value.Unsigned();

source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.h

 class DWARFDIECollection;
 
 class DWARFASTParserGo : public DWARFASTParser {
 public:
   DWARFASTParserGo(lldb_private::GoASTContext &ast);
 
   ~DWARFASTParserGo() override;
 
-  lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
-                                  const DWARFDIE &die, lldb_private::Log *log,
-                                  bool *type_is_new_ptr) override;
+  lldb::TypeSP ParseTypeFromDWARF(
+    const lldb_private::SymbolContext &sc, const DWARFDIE &die,
+    lldb_private::Log *log, bool *type_is_new_ptr,
+    const lldb_private::ExecutionContextRef exe_ctx = {}) override;
 
   lldb_private::Function *
   ParseFunctionFromDWARF(const lldb_private::SymbolContext &sc,
                          const DWARFDIE &die) override;
 
   bool CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                              lldb_private::CompilerType &go_type) override;
 

source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp

 using namespace lldb;
 using namespace lldb_private;
 DWARFASTParserGo::DWARFASTParserGo(GoASTContext &ast) : m_ast(ast) {}
 
 DWARFASTParserGo::~DWARFASTParserGo() {}
 
 TypeSP DWARFASTParserGo::ParseTypeFromDWARF(
     const lldb_private::SymbolContext &sc, const DWARFDIE &die,
-    lldb_private::Log *log, bool *type_is_new_ptr) {
+    lldb_private::Log *log, bool *type_is_new_ptr,
+    const lldb_private::ExecutionContextRef exe_ctx) {
   TypeSP type_sp;
 
   if (type_is_new_ptr)
     *type_is_new_ptr = false;
 
   if (die) {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     if (log) {

source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.h

 class DWARFDebugInfoEntry;
 class DWARFDIECollection;
 
 class DWARFASTParserJava : public DWARFASTParser {
 public:
   DWARFASTParserJava(lldb_private::JavaASTContext &ast);
   ~DWARFASTParserJava() override;
 
-  lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
-                                  const DWARFDIE &die, lldb_private::Log *log,
-                                  bool *type_is_new_ptr) override;
+  lldb::TypeSP ParseTypeFromDWARF(
+     const lldb_private::SymbolContext &sc, const DWARFDIE &die,
+     lldb_private::Log *log, bool *type_is_new_ptr,
+     const lldb_private::ExecutionContextRef exe_ctx = {}) override;
 
   lldb_private::Function *
   ParseFunctionFromDWARF(const lldb_private::SymbolContext &sc,
                          const DWARFDIE &die) override;
 
   bool CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                              lldb_private::CompilerType &java_type) override;
 

source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp

if (!is_forward_declaration) {
     dwarf->GetForwardDeclClangTypeToDie()[compiler_type.GetOpaqueQualType()] =
         die.GetDIERef();
   }
   return type_sp;
 }
 
 lldb::TypeSP DWARFASTParserJava::ParseTypeFromDWARF(
     const lldb_private::SymbolContext &sc, const DWARFDIE &die,
-    lldb_private::Log *log, bool *type_is_new_ptr) {
+    lldb_private::Log *log, bool *type_is_new_ptr,
+    const lldb_private::ExecutionContextRef exe_ctx) {
   if (type_is_new_ptr)
     *type_is_new_ptr = false;
 
   if (!die)
     return nullptr;
 
   SymbolFileDWARF *dwarf = die.GetDWARF();
 

source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.h

 class DWARFASTParserOCaml : public DWARFASTParser {
 public:
   DWARFASTParserOCaml(lldb_private::OCamlASTContext &ast);
 
   virtual ~DWARFASTParserOCaml();
 
   lldb::TypeSP ParseBaseTypeFromDIE(const DWARFDIE &die);
 
-  lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
-                                  const DWARFDIE &die, lldb_private::Log *log,
-                                  bool *type_is_new_ptr) override;
+  lldb::TypeSP ParseTypeFromDWARF(
+    const lldb_private::SymbolContext &sc, const DWARFDIE &die,
+    lldb_private::Log *log, bool *type_is_new_ptr,
+    const lldb_private::ExecutionContextRef exe_ctx = {}) override;
 
   lldb_private::Function *
   ParseFunctionFromDWARF(const lldb_private::SymbolContext &sc,
                          const DWARFDIE &die) override;
 
   bool
   CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) override {

source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.cpp

TypeSP DWARFASTParserOCaml::ParseBaseTypeFromDIE(const DWARFDIE &die) {
 
   Declaration decl;
   CompilerType compiler_type = m_ast.CreateBaseType(type_name, byte_size);
   return std::make_shared<Type>(die.GetID(), dwarf, type_name, byte_size,
                                 nullptr, LLDB_INVALID_UID, Type::eEncodingIsUID,
                                 decl, compiler_type, Type::eResolveStateFull);
 }
 
-lldb::TypeSP DWARFASTParserOCaml::ParseTypeFromDWARF(const SymbolContext &sc,
-                                                     const DWARFDIE &die,
-                                                     Log *log,
-                                                     bool *type_is_new_ptr) {
+lldb::TypeSP DWARFASTParserOCaml::ParseTypeFromDWARF(
+    const SymbolContext &sc, const DWARFDIE &die, Log *log,
+    bool *type_is_new_ptr, const lldb_private::ExecutionContextRef exe_ctx) {
   if (type_is_new_ptr)
     *type_is_new_ptr = false;
 
   if (!die)
     return nullptr;
 
   SymbolFileDWARF *dwarf = die.GetDWARF();
 

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;
+  lldb_private::Type *
+  ResolveTypeUID(lldb::user_id_t type_uid,
+                 const lldb_private::ExecutionContextRef 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);
+  lldb_private::Type *
+  ResolveType(const DWARFDIE &die, bool assert_not_being_parsed = true,
+              bool resolve_function_context = false,
+              const lldb_private::ExecutionContextRef exe_ctx = {});
 
   SymbolFileDWARF *GetDWARFForUID(lldb::user_id_t uid);
 
   DWARFDIE
   GetDIEFromUID(lldb::user_id_t uid);
 
   lldb_private::CompilerDecl GetDeclForUID(lldb::user_id_t uid) override;
 
size_t ParseFunctionBlocks(const lldb_private::SymbolContext &sc,
                              lldb_private::Block *parent_block,
                              const DWARFDIE &die,
                              lldb::addr_t subprogram_low_pc, uint32_t depth);
 
   size_t ParseTypes(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
                     bool parse_siblings, bool parse_children);
 
   lldb::TypeSP ParseType(const lldb_private::SymbolContext &sc,
-                         const DWARFDIE &die, bool *type_is_new);
+                         const DWARFDIE &die, bool *type_is_new,
+                         const lldb_private::ExecutionContextRef exe_ctx = {});
 
   lldb_private::Type *ResolveTypeUID(const DWARFDIE &die,
                                      bool assert_not_being_parsed);
 
   lldb_private::Type *ResolveTypeUID(const DIERef &die_ref);
 
   lldb::VariableSP ParseVariableDIE(const lldb_private::SymbolContext &sc,
                                     const DWARFDIE &die,
protected:
 
   virtual lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
       const DWARFDIE &die, const lldb_private::ConstString &type_name,
       bool must_be_implementation);
 
   lldb_private::Symbol *
   GetObjCClassSymbol(const lldb_private::ConstString &objc_class_name);
 
-  lldb::TypeSP GetTypeForDIE(const DWARFDIE &die,
-                             bool resolve_function_context = false);
+  /// If exe_ctx is non-null, the type may only be valid within that context.
+  lldb::TypeSP
+  GetTypeForDIE(const DWARFDIE &die, bool resolve_function_context = false,
+                const lldb_private::ExecutionContextRef exe_ctx = {});
 
   void SetDebugMapModule(const lldb::ModuleSP &module_sp) {
     m_debug_map_module_wp = module_sp;
   }
 
   SymbolFileDWARFDebugMap *GetDebugMapSymfile();
 
   DWARFDIE

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

SymbolFileDWARF::GetDeclContextContainingUID(lldb::user_id_t type_uid) {
   // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
   // SymbolFileDWARF::GetDIEFromUID() for details.
   DWARFDIE die = GetDIEFromUID(type_uid);
   if (die)
     return die.GetContainingDeclContext();
   return CompilerDeclContext();
 }
 
-Type *SymbolFileDWARF::ResolveTypeUID(lldb::user_id_t type_uid) {
+Type *SymbolFileDWARF::ResolveTypeUID(
+    lldb::user_id_t type_uid, const lldb_private::ExecutionContextRef exe_ctx) {
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
   // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
   // SymbolFileDWARF::GetDIEFromUID() for details.
   DWARFDIE type_die = GetDIEFromUID(type_uid);
   if (type_die)
-    return type_die.ResolveType();
-  else
-    return nullptr;
+    return ResolveType(type_die, true, false, exe_ctx);
 }
 
 Type *SymbolFileDWARF::ResolveTypeUID(const DIERef &die_ref) {
   return ResolveType(GetDIE(die_ref), true);
 }
 
-Type *SymbolFileDWARF::ResolveTypeUID(const DWARFDIE &die,
-                                      bool assert_not_being_parsed) {
+Type *SymbolFileDWARF::ResolveTypeUID(
+    const DWARFDIE &die, bool assert_not_being_parsed) {
   if (die) {
     Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
     if (log)
       GetObjectFile()->GetModule()->LogMessage(
           log, "SymbolFileDWARF::ResolveTypeUID (die = 0x%8.8x) %s '%s'",
           die.GetOffset(), die.GetTagAsCString(), die.GetName());
 
     // We might be coming in in the middle of a type tree (a class within a
if (dwarf_die) {
     assert(compiler_type);
     DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser();
     if (dwarf_ast)
       return dwarf_ast->CompleteTypeFromDWARF(dwarf_die, type, compiler_type);
   }
   return false;
 }
 
-Type *SymbolFileDWARF::ResolveType(const DWARFDIE &die,
-                                   bool assert_not_being_parsed,
-                                   bool resolve_function_context) {
+Type *
+SymbolFileDWARF::ResolveType(const DWARFDIE &die, bool assert_not_being_parsed,
+                             bool resolve_function_context,
+                             const lldb_private::ExecutionContextRef exe_ctx) {
   if (die) {
-    Type *type = GetTypeForDIE(die, resolve_function_context).get();
+    Type *type = GetTypeForDIE(die, resolve_function_context, exe_ctx).get();
 
     if (assert_not_being_parsed) {
       if (type != DIE_IS_BEING_PARSED)
         return type;
 
       GetObjectFile()->GetModule()->ReportError(
           "Parsing a die that is being parsed die: 0x%8.8x: %s %s",
           die.GetOffset(), die.GetTagAsCString(), die.GetName());
GetObjectFile()->GetModule()->LogMessage(
         static_cast<const void *>(namespace_decl_ctx.GetTypeSystem()),
         static_cast<const void *>(namespace_decl_ctx.GetOpaqueDeclContext()),
         namespace_decl_ctx.GetName().AsCString("<NULL>"));
   }
 
   return namespace_decl_ctx;
 }
 
-TypeSP SymbolFileDWARF::GetTypeForDIE(const DWARFDIE &die,
-                                      bool resolve_function_context) {
-  TypeSP type_sp;
-  if (die) {
-    Type *type_ptr = GetDIEToType().lookup(die.GetDIE());
-    if (type_ptr == NULL) {
-      CompileUnit *lldb_cu = GetCompUnitForDWARFCompUnit(die.GetCU());
-      assert(lldb_cu);
-      SymbolContext sc(lldb_cu);
-      const DWARFDebugInfoEntry *parent_die = die.GetParent().GetDIE();
-      while (parent_die != nullptr) {
-        if (parent_die->Tag() == DW_TAG_subprogram)
-          break;
-        parent_die = parent_die->GetParent();
-      }
-      SymbolContext sc_backup = sc;
-      if (resolve_function_context && parent_die != nullptr &&
-          !GetFunction(DWARFDIE(die.GetCU(), parent_die), sc))
-        sc = sc_backup;
+TypeSP SymbolFileDWARF::GetTypeForDIE(
+    const DWARFDIE &die, bool resolve_function_context,
+    const lldb_private::ExecutionContextRef exe_ctx) {
+  if (!die)
+    return {};
+  if (type_ptr == DIE_IS_BEING_PARSED)
+    return {};
+
+  // If an execution context is present, re-parse the type.
+  if (type_ptr && !exe_ctx.GetFrameSP()) {
+    // Grab the existing type from the master types lists
+    return type_ptr->shared_from_this();
+  }
+
+  // Parse the type.
+  while (parent_die) {
+  if (resolve_function_context && parent_die &&
 
-      type_sp = ParseType(sc, die, NULL);
-    } else if (type_ptr != DIE_IS_BEING_PARSED) {
-      // Grab the existing type from the master types lists
-      type_sp = type_ptr->shared_from_this();
-    }
-  }
-  return type_sp;
+  return ParseType(sc, die, NULL, exe_ctx);
 }
 
 DWARFDIE
 SymbolFileDWARF::GetDeclContextDIEContainingDIE(const DWARFDIE &orig_die) {
   if (orig_die) {
     DWARFDIE die = orig_die;
 
     while (die) {
if (type_name) {
           }
         }
       }
     }
   }
   return type_sp;
 }
 
-TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
-                                  bool *type_is_new_ptr) {
+TypeSP
+SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
+                           bool *type_is_new_ptr,
+                           const lldb_private::ExecutionContextRef exe_ctx) {
   TypeSP type_sp;
 
   if (die) {
     TypeSystem *type_system =
         GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
 
     if (type_system) {
       DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
       if (dwarf_ast) {
         Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
-        type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, log, type_is_new_ptr);
+        type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, log, type_is_new_ptr,
+                                                exe_ctx);
         if (type_sp) {
           TypeList *type_list = GetTypeList();
-          if (type_list)
+          if (type_list && !exe_ctx.GetFrameSP())
             type_list->Insert(type_sp);
 
           if (die.Tag() == DW_TAG_subprogram) {
             DIERef die_ref = die.GetDIERef();
             std::string scope_qualified_name(GetDeclContextForUID(die.GetID())
                                                  .GetScopeQualifiedName()
                                                  .AsCString(""));
             if (scope_qualified_name.size()) {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
   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;
+  lldb_private::Type *
+  ResolveTypeUID(lldb::user_id_t type_uid,
+                 const lldb_private::ExecutionContextRef 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

 size_t
 SymbolFileDWARFDebugMap::ParseVariablesForContext(const SymbolContext &sc) {
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
   if (oso_dwarf)
     return oso_dwarf->ParseVariablesForContext(sc);
   return 0;
 }
 
-Type *SymbolFileDWARFDebugMap::ResolveTypeUID(lldb::user_id_t type_uid) {
+Type *SymbolFileDWARFDebugMap::ResolveTypeUID(
+    lldb::user_id_t type_uid, const lldb_private::ExecutionContextRef exe_ctx) {
   const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid);
   SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
   if (oso_dwarf)
-    return oso_dwarf->ResolveTypeUID(type_uid);
+    return oso_dwarf->ResolveTypeUID(type_uid, exe_ctx);
   return NULL;
 }
 
 bool SymbolFileDWARFDebugMap::CompleteType(CompilerType &compiler_type) {
   bool success = false;
   if (compiler_type) {
     ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
       if (oso_dwarf->HasForwardDeclForClangType(compiler_type)) {

source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

public:
 
   size_t ParseTypes(const lldb_private::SymbolContext &sc) override {
     return 0;
   }
   size_t
   ParseVariablesForContext(const lldb_private::SymbolContext &sc) override {
     return 0;
   }
-  lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override {
+  lldb_private::Type *
+  ResolveTypeUID(lldb::user_id_t type_uid,
+                 const lldb_private::ExecutionContextRef exe_ctx) override {
     return nullptr;
   }
   bool CompleteType(lldb_private::CompilerType &compiler_type) override {
     return false;
   }
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
                                 uint32_t resolve_scope,
                                 lldb_private::SymbolContext &sc) override;

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;
+  lldb_private::Type *
+  ResolveTypeUID(lldb::user_id_t type_uid,
+                 const lldb_private::ExecutionContextRef 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 (sc.function) {
 
     // Parse variables in this compiland.
     num_added += ParseVariables(sc, *compiland);
   }
 
   return num_added;
 }
 
-lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
+lldb_private::Type *
+SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid,
+                              const lldb_private::ExecutionContextRef exe_ctx) {
   auto find_result = m_types.find(type_uid);
   if (find_result != m_types.end())
     return find_result->second.get();
 
   TypeSystem *type_system =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
   ClangASTContext *clang_type_system =
       llvm::dyn_cast_or_null<ClangASTContext>(type_system);

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;
+  lldb_private::Type *
+  ResolveTypeUID(lldb::user_id_t type_uid,
+                 const lldb_private::ExecutionContextRef exe_ctx = {}) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
 
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
                                 uint32_t resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,

source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

 }
 
 size_t SymbolFileSymtab::ParseTypes(const SymbolContext &sc) { return 0; }
 
 size_t SymbolFileSymtab::ParseVariablesForContext(const SymbolContext &sc) {
   return 0;
 }
 
-Type *SymbolFileSymtab::ResolveTypeUID(lldb::user_id_t type_uid) {
+Type *SymbolFileSymtab::ResolveTypeUID(
+    lldb::user_id_t type_uid, const lldb_private::ExecutionContextRef exe_ctx) {
   return NULL;
 }
 
 bool SymbolFileSymtab::CompleteType(lldb_private::CompilerType &compiler_type) {
   return false;
 }
 
 uint32_t SymbolFileSymtab::ResolveSymbolContext(const Address &so_addr,

source/Symbol/ClangASTContext.cpp

case clang::Type::Elaborated:
                                        .getAsOpaquePtr(),
                                    dynamic_pointee_type, check_cplusplus,
                                    check_objc);
 
     case clang::Type::Paren:
       return IsPossibleDynamicType(
           llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr(),
           dynamic_pointee_type, check_cplusplus, check_objc);
+
+    case clang::Type::IncompleteArray:
+      return true;
     default:
       break;
     }
 
     if (success) {
       // Check to make sure what we are pointing too is a possible dynamic C++
       // type We currently accept any "void *" (in case we have a class that
       // has been watered down to an opaque pointer) and virtual C++ classes.