Make DWARFParsing more thread-safe

[friss]

Summary

Debug information is read lazily so a lot of the state of the reader
is constructred incrementally. There's also nothing preventing symbol
queries to be performed at the same time by multiple threads. This
lead to a series of crashes where the data structures used for
bookkeeping got corrupted because of concurrent modification.

This patch uses a brute-force approach where every such data-structure
got converted to a thread-safe version. I'm happy to discuss
alternatives, and also to hear ideas about whatever preformance testing
I can do to asses the impact of this patch.

[zturner]

Long term I think one potentially interesting possibility for solving a lot of these threading and lazy evaluation issues is to make a task queue that runs all related operations on a single thread and returns a future you can wait on. This way, the core data structures themselves do not need synchronization because they are only ever accessed from one thread. I actually have a patch in progress to make this kind of infrastructure, which I actually needed for a different reason, but it would work equally well here.

Mostly just putting this out there as an idea for down the road, not that you should do it right now.

[friss]

In D48393#1138398, @zturner wrote:

Long term I think one potentially interesting possibility for solving a lot of these threading and lazy evaluation issues is to make a task queue that runs all related operations on a single thread and returns a future you can wait on. This way, the core data structures themselves do not need synchronization because they are only ever accessed from one thread. I actually have a patch in progress to make this kind of infrastructure, which I actually needed for a different reason, but it would work equally well here.

Mostly just putting this out there as an idea for down the road, not that you should do it right now.

It's an interesting idea, which comes with a couple of tradeoffs:

• We would be essentially serializing the DWARF parsing. I do not know if it needs to be a goal that we're able to do efficient multi-threaded parsing, but it's an obvious consequence which would need to be discussed.
• I have worked on a codebase relying heavily of serialized thread queues and something equivalent to futures to schedule work. Let's say that it was... interesting to debug. If we did this, we don't need to go to the same extremes though. (Also I'm wondering, would tasks running serially be allowed to enqueue other tasks and wait for them? Or would this be forbidden?)

I like the simplification aspect of it though. It is basically equivalent to adding locks at a higher abstraction level than the data-structures like I did. I was pondering that too, but I wasn't sure 1/ which level would be best and 2/ how to be sure I was not going to deadlock the whole thing.

[labath]

I am not sure this will actually solve the problems you are seeing. This may avoid corrupting the internal DenseMap data structures, but it will not make the algorithm using them actually correct.
For example the pattern in ParseTypeFromDWARF is:

1. check the "already parsed map". If the DIE is already parsed then you're done.
2. if the map contains the magic "DIE_IS_BEING_PARSED" key, abort (recursive dwarf references)
3. otherwise, insert the "DIE_IS_BEING_PARSED" key into the map
4. do the parsing, which potentially involves recursive ParseTypeFromDWARF calls
5. insert the parsed type into the map

What you do is make each of the steps (1), (3), (5) atomic individually. However, the whole algorithm is not correct unless the whole sequence is atomic as a whole. Otherwise, if you have two threads trying to parse the same DIE (directly or indirectly), one of them could see the intermediate DIE_IS_BEING_PARSED and incorrectly assume that it encountered recursive types.

So, I think that locking at a higher level would be better. Doing that will certainly be tricky though...

[clayborg]

In D48393#1138989, @labath wrote:

I am not sure this will actually solve the problems you are seeing. This may avoid corrupting the internal DenseMap data structures, but it will not make the algorithm using them actually correct.
For example the pattern in ParseTypeFromDWARF is:

1. check the "already parsed map". If the DIE is already parsed then you're done.
2. if the map contains the magic "DIE_IS_BEING_PARSED" key, abort (recursive dwarf references)
3. otherwise, insert the "DIE_IS_BEING_PARSED" key into the map
4. do the parsing, which potentially involves recursive ParseTypeFromDWARF calls
5. insert the parsed type into the map

What you do is make each of the steps (1), (3), (5) atomic individually. However, the whole algorithm is not correct unless the whole sequence is atomic as a whole. Otherwise, if you have two threads trying to parse the same DIE (directly or indirectly), one of them could see the intermediate DIE_IS_BEING_PARSED and incorrectly assume that it encountered recursive types.

We need to make #1 atomic.
#2 would need to somehow know if the type is already being parsed recursively by the current thread. If so, then do what we do now. If not, we need a way to wait on the completion of this type so the other parsing thread can complete it and put it into the map, at which time we grab the right value from the map
So #6 step would need to be added so after we do put it into the map, we can notify other threads that might be waiting

So, I think that locking at a higher level would be better. Doing that will certainly be tricky though...

[zturner]

Related question: Is the laziness done to save memory, startup time, or
both?

[labath]

In D48393#1139270, @clayborg wrote:

In D48393#1138989, @labath wrote:

I am not sure this will actually solve the problems you are seeing. This may avoid corrupting the internal DenseMap data structures, but it will not make the algorithm using them actually correct.
For example the pattern in ParseTypeFromDWARF is:

1. check the "already parsed map". If the DIE is already parsed then you're done.
2. if the map contains the magic "DIE_IS_BEING_PARSED" key, abort (recursive dwarf references)
3. otherwise, insert the "DIE_IS_BEING_PARSED" key into the map
4. do the parsing, which potentially involves recursive ParseTypeFromDWARF calls
5. insert the parsed type into the map

What you do is make each of the steps (1), (3), (5) atomic individually. However, the whole algorithm is not correct unless the whole sequence is atomic as a whole. Otherwise, if you have two threads trying to parse the same DIE (directly or indirectly), one of them could see the intermediate DIE_IS_BEING_PARSED and incorrectly assume that it encountered recursive types.

We need to make #1 atomic.
#2 would need to somehow know if the type is already being parsed recursively by the current thread. If so, then do what we do now. If not, we need a way to wait on the completion of this type so the other parsing thread can complete it and put it into the map, at which time we grab the right value from the map
So #6 step would need to be added so after we do put it into the map, we can notify other threads that might be waiting

It's even more complicated than that, in case you really have reference cycles, you can have multiple threads starting parsing from different points in that cycle, and getting deadlocked waiting for the DIE_IS_BEING_PARSED results from each other.

The only sane algorithm I can come up right now is to make the list of parsed dies local to each thread/parsing entity (e.g. via a "visited" list), and only update the global map once the parsing has completed (successfully or not). This can potentially duplicate some effort where one thread parses a type only to find out that it has already been parsed, but hopefully that is not going to be the common case. The alternative is some complicated resource cycle detection scheme.

[JDevlieghere]

In D48393#1139327, @labath wrote:

It's even more complicated than that, in case you really have reference cycles, you can have multiple threads starting parsing from different points in that cycle, and getting deadlocked waiting for the DIE_IS_BEING_PARSED results from each other.

The only sane algorithm I can come up right now is to make the list of parsed dies local to each thread/parsing entity (e.g. via a "visited" list), and only update the global map once the parsing has completed (successfully or not). This can potentially duplicate some effort where one thread parses a type only to find out that it has already been parsed, but hopefully that is not going to be the common case. The alternative is some complicated resource cycle detection scheme.

I gave this a shot in D52406 but I'm afraid it's too simple to be correct. Pavel, could you give it a look and let me know whether that was what you had in mind?

[clayborg]

A little background might help here: The lldb_private::Module lock is used to prevent multiple queries into the DWARF from stomping on each other.

Multi-threaded DWARF parsing was primarily added to speed up indexing and the only place it is used. Is that not true? Indexing is just creating name tables and the accelerator tables we need so that we can partially parse the DWARF later. No type parsing should be happening when indexing. All other accesses to the DWARF must be done via a SymbolFile API that takes the module lock to stop multiple threads from stomping on each other. So my main point is we need to use the module lock to avoid having multiple threads doing important work that will cause crashes. The only multi-threaded access to DWARF currently should be in the indexing only and no important parsing stuff should be going on. If we discover places where multiple threads are making accesses, we just need to ensure they take the module lock and everything should just work.

In D48393#1139290, @zturner wrote:

Related question: Is the laziness done to save memory, startup time, or both?

Both. Memory is the bigger issue here though. We want to only parse what we need when we need it so if someone was to use LLDB for symbolication, they don't incur the cost of parsing all types in any compile units that get touched (like would happen with GDB). Since we convert all DWARF types into clang AST types, parsing more types than needed can cause a lot of memory to be used.

[JDevlieghere]

Thanks for the information, Greg!

In D48393#1243588, @clayborg wrote:

A little background might help here: The lldb_private::Module lock is used to prevent multiple queries into the DWARF from stomping on each other.

Multi-threaded DWARF parsing was primarily added to speed up indexing and the only place it is used. Is that not true? Indexing is just creating name tables and the accelerator tables we need so that we can partially parse the DWARF later. No type parsing should be happening when indexing. All other accesses to the DWARF must be done via a SymbolFile API that takes the module lock to stop multiple threads from stomping on each other. So my main point is we need to use the module lock to avoid having multiple threads doing important work that will cause crashes.

Looking at SymbolFileDWARF, we only have two methods that take the module lock: PreloadSymbols and CompleteType.

The only multi-threaded access to DWARF currently should be in the indexing only and no important parsing stuff should be going on.

Surely there can be a lot more going on, like two debuggers executing an expression at the same time?

If we discover places where multiple threads are making accesses, we just need to ensure they take the module lock and everything should just work.

So what you're saying is that we should add the module lock to every endpoint in SymbolFileDWARF that can potentially modify our internal data structures (i.e. parsing)?

[labath]

In D48393#1243195, @JDevlieghere wrote:

In D48393#1139327, @labath wrote:

The only sane algorithm I can come up right now is to make the list of parsed dies local to each thread/parsing entity (e.g. via a "visited" list), and only update the global map once the parsing has completed (successfully or not). This can potentially duplicate some effort where one thread parses a type only to find out that it has already been parsed, but hopefully that is not going to be the common case. The alternative is some complicated resource cycle detection scheme.

I gave this a shot in D52406 but I'm afraid it's too simple to be correct. Pavel, could you give it a look and let me know whether that was what you had in mind?

Yeah, I don't think this will make things fully correct. This avoids the problem when two threads are misinterpreting the DIE_IS_BEING_PARSED markers left by the other thread. However, it is still not correct when two threads are parsing the same DIE concurrently. Imagine the following sequence of events:

• thread A starts parsing DIE 1, checks that it still hasn't been parsed, inserts the DIE_IS_BEING_PARSED into the local map.
• thread B does the same
• thread A finishes parsing DIE 1. constructs a clang AST (C1) for it sets it as the map value
• thread B does the same overwrites the value with C2
• thread A carries on using C1
• thread B carries on using C2

This sounds like something that is not supposed to happen, though I don't really know what the consequences of that are. Also I am not entirely convinced that the mere construction of C1 and C2 does not touch some global structures (which would not be protected by a lock).

I agree with Greg that it would be best to restrict things such that there is only one instance of parsing going on at any given time for a single module. I think this was pretty much the state we reached when this thread fizzled out the last time (there are some extra emails that are not showing in phabricator history, the interesting ones start around here: http://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180618/041937.html). I think the main part that needed to be resolved is whether we need to go anything special when resolving debug info references *between* modules (e.g. to prevent A/B deadlocks).

[clayborg]

In D48393#1244426, @JDevlieghere wrote:

Thanks for the information, Greg!

In D48393#1243588, @clayborg wrote:

A little background might help here: The lldb_private::Module lock is used to prevent multiple queries into the DWARF from stomping on each other.

Multi-threaded DWARF parsing was primarily added to speed up indexing and the only place it is used. Is that not true? Indexing is just creating name tables and the accelerator tables we need so that we can partially parse the DWARF later. No type parsing should be happening when indexing. All other accesses to the DWARF must be done via a SymbolFile API that takes the module lock to stop multiple threads from stomping on each other. So my main point is we need to use the module lock to avoid having multiple threads doing important work that will cause crashes.

Looking at SymbolFileDWARF, we only have two methods that take the module lock: PreloadSymbols and CompleteType.

Most of the locking happens at the SymbolVendor level IIRC. But all virtual function SymbolFile entry points need to take the module lock.

The only multi-threaded access to DWARF currently should be in the indexing only and no important parsing stuff should be going on.

Surely there can be a lot more going on, like two debuggers executing an expression at the same time?

That doesn't matter. One of them will index the DWARF. Both will be able to field requests via the virtual functions defined in lldb_private::SymbolFile (usually via the lldb_private::SymbolVendor (a class that can combine multiple object files/symbol files)) so any query must use the module lock. This is no different than two threads making two different requests from a SymbolFileDWARF.

If we discover places where multiple threads are making accesses, we just need to ensure they take the module lock and everything should just work.

So what you're saying is that we should add the module lock to every endpoint in SymbolFileDWARF that can potentially modify our internal data structures (i.e. parsing)?

Yes, any virtual lldb_private::SymbolFile entry point should lock the recursive module mutex. Check SymbolVendor as no one directly grabs a SymbolFile and uses it, they all go through the module which uses the symbol vendor. So the locking will often occur at the module level or the symbol vendor level.

[clayborg]

In D48393#1244649, @labath wrote:

I agree with Greg that it would be best to restrict things such that there is only one instance of parsing going on at any given time for a single module. I think this was pretty much the state we reached when this thread fizzled out the last time (there are some extra emails that are not showing in phabricator history, the interesting ones start around here: http://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180618/041937.html). I think the main part that needed to be resolved is whether we need to go anything special when resolving debug info references *between* modules (e.g. to prevent A/B deadlocks).

We don't have to worry about references between modules as no module loads _ANY_ debug info from another module. If a module only has a forward declaration to a type, we leave it as a forward declaration. Why do we do this? So we can cache modules in LLDB and use all the parsed state in the next debug session if we rerun. Lets say you have liba.so that has a type "struct Foo { int x; };" and libb.so has a "struct Foo; Foo *foo_ptr;". libb.so has debug info for "foo_ptr" that says it is a forward declaration. At expression evaluation time, we will end up digging up the correct definition for "struct Foo" from liba.so, but we must do that each time we evaluate an expression. If we change liba.so with "struct Foo { int x; int y; };" and re-run, we don't need to reload any debug info for libb.so (or keep track of any definitions we might have loaded from another file to know when liba.so changes that we need to invalidate any number of types in other shared libraries). So because of this, we don't run into the problem. The variable displaying infrastructure in ValueObject and the expression parser know how to locate types when they need to. This keeps everything clean in the debug info parsing code.

[friss]

In D48393#1245049, @clayborg wrote:

In D48393#1244649, @labath wrote:

I agree with Greg that it would be best to restrict things such that there is only one instance of parsing going on at any given time for a single module. I think this was pretty much the state we reached when this thread fizzled out the last time (there are some extra emails that are not showing in phabricator history, the interesting ones start around here: http://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180618/041937.html). I think the main part that needed to be resolved is whether we need to go anything special when resolving debug info references *between* modules (e.g. to prevent A/B deadlocks).

We don't have to worry about references between modules as no module loads _ANY_ debug info from another module.

What about -gmodules? I don't remember where the module debug info is stored, I think it is not shared so your statement would conceptually hold, but I'm not sure anymore.

[clayborg]

In D48393#1245342, @friss wrote:

In D48393#1245049, @clayborg wrote:

In D48393#1244649, @labath wrote:

I agree with Greg that it would be best to restrict things such that there is only one instance of parsing going on at any given time for a single module. I think this was pretty much the state we reached when this thread fizzled out the last time (there are some extra emails that are not showing in phabricator history, the interesting ones start around here: http://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180618/041937.html). I think the main part that needed to be resolved is whether we need to go anything special when resolving debug info references *between* modules (e.g. to prevent A/B deadlocks).

We don't have to worry about references between modules as no module loads _ANY_ debug info from another module.

What about -gmodules? I don't remember where the module debug info is stored, I think it is not shared so your statement would conceptually hold, but I'm not sure anymore.

We load the -gmodules DWARF and a stand alone file and then copy the AST types over into the AST for the SymbolFileDWARF that uses them. So we are good with -gmodules.

include/lldb/Core/ThreadSafeDenseMap.h

public:
   ThreadSafeDenseMap(unsigned map_initial_capacity = 0)
       : m_map(map_initial_capacity), m_mutex() {}
 
   void Insert(_KeyType k, _ValueType v) {
     std::lock_guard<_MutexType> guard(m_mutex);
     m_map.insert(std::make_pair(k, v));
   }
 
+  void Set(_KeyType k, _ValueType v) {
+    std::lock_guard<_MutexType> guard(m_mutex);
+    m_map[k] = v;
+  }
+
+  void ApplyToEntry(_KeyType k,
+                    llvm::function_ref<void(_ValueType &)> mutator) {
+    std::lock_guard<_MutexType> guard(m_mutex);
+    mutator(m_map[k]);
+  }
+
   void Erase(_KeyType k) {
     std::lock_guard<_MutexType> guard(m_mutex);
     m_map.erase(k);
   }
 
   _ValueType Lookup(_KeyType k) {
     std::lock_guard<_MutexType> guard(m_mutex);
     return m_map.lookup(k);

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

 //===-- DWARFASTParserClang.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_DWARFASTParserClang_h_
 #define SymbolFileDWARF_DWARFASTParserClang_h_
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 #include "clang/AST/CharUnits.h"
-#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 
 // Project includes
 #include "DWARFASTParser.h"
 #include "DWARFDefines.h"
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/PluginInterface.h"
+#include "lldb/Core/ThreadSafeDenseMap.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 
 class DWARFDebugInfoEntry;
 class DWARFDIECollection;
 
 class DWARFASTParserClang : public DWARFASTParser {
 public:
protected:
 
   //----------------------------------------------------------------------
   // 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;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *>
+  typedef lldb_private::ThreadSafeDenseMap<const DWARFDebugInfoEntry *,
+                                           clang::DeclContext *>
       DIEToDeclContextMap;
-  // typedef llvm::DenseMap<const clang::DeclContext *, DIEPointerSet>
-  // DeclContextToDIEMap;
-  typedef std::multimap<const clang::DeclContext *, const DWARFDIE>
+  typedef std::vector<DWARFDIE> DIEList;
+  typedef lldb_private::ThreadSafeDenseMap<const clang::DeclContext *,
+                                           std::unique_ptr<DIEList>>
       DeclContextToDIEMap;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *>
+  typedef lldb_private::ThreadSafeDenseMap<const DWARFDebugInfoEntry *,
+                                           clang::Decl *>
       DIEToDeclMap;
-  typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap;
+  typedef lldb_private::ThreadSafeDenseMap<const clang::Decl *, DIEPointerSet>
+      DeclToDIEMap;
 
   lldb_private::ClangASTContext &m_ast;
   DIEToDeclMap m_die_to_decl;
   DeclToDIEMap m_decl_to_die;
   DIEToDeclContextMap m_die_to_decl_ctx;
   DeclContextToDIEMap m_decl_ctx_to_die;
   std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_ap;
 };
 
 #endif // SymbolFileDWARF_DWARFASTParserClang_h_

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

TypeSP DWARFASTParserClang::ParseTypeFromDWO(const DWARFDIE &die, Log *log) {
 
   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));
 
   dwarf->GetTypeList()->Insert(type_sp);
-  dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+  dwarf->GetDIEToType().Set(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);
   }
if (log) {
           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());
+    Type *type_ptr = dwarf->GetDIEToType().Lookup(die.GetDIE());
     TypeList *type_list = dwarf->GetTypeList();
     if (type_ptr == NULL) {
       if (type_is_new_ptr)
         *type_is_new_ptr = true;
 
       const dw_tag_t tag = die.Tag();
 
       bool is_forward_declaration = false;
if (type_ptr == NULL) {
       case DW_TAG_pointer_type:
       case DW_TAG_reference_type:
       case DW_TAG_rvalue_reference_type:
       case DW_TAG_const_type:
       case DW_TAG_restrict_type:
       case DW_TAG_volatile_type:
       case DW_TAG_unspecified_type: {
         // Set a bit that lets us know that we are currently parsing this
-        dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
+        dwarf->GetDIEToType().Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
         const size_t num_attributes = die.GetAttributes(attributes);
         uint32_t encoding = 0;
         DWARFFormValue encoding_uid;
 
         if (num_attributes > 0) {
           uint32_t i;
           for (i = 0; i < num_attributes; ++i) {
if (type_ptr == NULL) {
           }
         }
 
         type_sp.reset(
             new Type(die.GetID(), dwarf, type_name_const_str, byte_size, NULL,
                      DIERef(encoding_uid).GetUID(dwarf), encoding_data_type,
                      &decl, clang_type, resolve_state));
 
-        dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+        dwarf->GetDIEToType().Set(die.GetDIE(), type_sp.get());
       } break;
 
       case DW_TAG_structure_type:
       case DW_TAG_union_type:
       case DW_TAG_class_type: {
         // Set a bit that lets us know that we are currently parsing this
-        dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
+        dwarf->GetDIEToType().Set(die.GetDIE(), DIE_IS_BEING_PARSED);
         bool byte_size_valid = false;
 
         LanguageType class_language = eLanguageTypeUnknown;
         bool is_complete_objc_class = false;
         size_t calling_convention 
                 = llvm::dwarf::CallingConvention::DW_CC_normal;
         
         const size_t num_attributes = die.GetAttributes(attributes);
if (type_ptr == NULL) {
             unique_decl.Clear();
           }
 
           if (dwarf->GetUniqueDWARFASTTypeMap().Find(
                   unique_typename, die, unique_decl,
                   byte_size_valid ? byte_size : -1, *unique_ast_entry_ap)) {
             type_sp = unique_ast_entry_ap->m_type_sp;
             if (type_sp) {
-              dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+              dwarf->GetDIEToType().Set(die.GetDIE(), type_sp.get());
               return type_sp;
             }
           }
         }
 
         DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                      DW_TAG_value_to_name(tag), type_name_cstr);
 
if (type_ptr == NULL) {
                     static_cast<void *>(this), die.GetOffset(),
                     DW_TAG_value_to_name(tag), type_name_cstr,
                     type_sp->GetID());
               }
 
               // We found a real definition for this type elsewhere so lets use
               // it and cache the fact that we found a complete type for this
               // die
-              dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+              dwarf->GetDIEToType().Set(die.GetDIE(), type_sp.get());
               return type_sp;
             }
           }
         }
 
         if (is_forward_declaration) {
           // We have a forward declaration to a type and we need to try and
           // find a full declaration. We look in the current type index just in
if (type_ptr == NULL) {
                   log, "SymbolFileDWARF(%p) - 0x%8.8x: %s type \"%s\" is a "
                        "forward declaration, complete type is 0x%8.8" PRIx64,
                   static_cast<void *>(this), die.GetOffset(),
                   DW_TAG_value_to_name(tag), type_name_cstr, type_sp->GetID());
             }
 
             // We found a real definition for this type elsewhere so lets use
             // it and cache the fact that we found a complete type for this die
-            dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+            dwarf->GetDIEToType().Set(die.GetDIE(), type_sp.get());
             clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(
                 dwarf->DebugInfo()->GetDIE(DIERef(type_sp->GetID(), dwarf)));
             if (defn_decl_ctx)
               LinkDeclContextToDIE(defn_decl_ctx, die);
             return type_sp;
           }
         }
         assert(tag_decl_kind != -1);
         bool clang_type_was_created = false;
         clang_type.SetCompilerType(
-            &m_ast, dwarf->GetForwardDeclDieToClangType().lookup(die.GetDIE()));
+            &m_ast, dwarf->GetForwardDeclDieToClangType().Lookup(die.GetDIE()));
         if (!clang_type) {
           clang::DeclContext *decl_ctx =
               GetClangDeclContextContainingDIE(die, nullptr);
 
           // If your decl context is a record that was imported from another
           // AST context (in the gmodules case), we need to make sure the type
           // backing the Decl is complete before adding children to it. This is
           // not an issue in the non-gmodules case because the debug info will
if (type_ptr == NULL) {
                 class_language != eLanguageTypeObjC_plus_plus)
               ClangASTContext::StartTagDeclarationDefinition(clang_type);
 
             // Leave this as a forward declaration until we need to know the
             // details of the type. lldb_private::Type will automatically call
             // the SymbolFile virtual function
             // "SymbolFileDWARF::CompleteType(Type *)" When the definition
             // needs to be defined.
-            assert(!dwarf->GetForwardDeclClangTypeToDie().count(
+            DIERef ref;
+            (void)ref;
+            assert(!dwarf->GetForwardDeclClangTypeToDie().Lookup(
                        ClangUtil::RemoveFastQualifiers(clang_type)
-                           .GetOpaqueQualType()) &&
+                           .GetOpaqueQualType(),
+                       ref) &&
                    "Type already in the forward declaration map!");
             // Can't assume m_ast.GetSymbolFile() is actually a
             // SymbolFileDWARF, it can be a SymbolFileDWARFDebugMap for Apple
             // binaries.
-            dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] =
-                clang_type.GetOpaqueQualType();
-            dwarf->GetForwardDeclClangTypeToDie()
-                [ClangUtil::RemoveFastQualifiers(clang_type)
-                     .GetOpaqueQualType()] = die.GetDIERef();
+            dwarf->GetForwardDeclDieToClangType().Set(
+                die.GetDIE(), clang_type.GetOpaqueQualType());
+            dwarf->GetForwardDeclClangTypeToDie().Set(
+                ClangUtil::RemoveFastQualifiers(clang_type).GetOpaqueQualType(),
+                die.GetDIERef());
             m_ast.SetHasExternalStorage(clang_type.GetOpaqueQualType(), true);
           }
         }
         
         // If we made a clang type, set the trivial abi if applicable: We only
         // do this for pass by value - which implies the Trivial ABI. There
         // isn't a way to assert that something that would normally be pass by
         // value is pass by reference, so we ignore that attribute if set.
         if (calling_convention == llvm::dwarf::DW_CC_pass_by_value) {
           clang::CXXRecordDecl *record_decl =
                   m_ast.GetAsCXXRecordDecl(clang_type.GetOpaqueQualType());
           if (record_decl) {
             record_decl->setHasTrivialSpecialMemberForCall();
           }
         }
 
       } break;
 
       case DW_TAG_enumeration_type: {
         // Set a bit that lets us know that we are currently parsing this
-        dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
+        dwarf->GetDIEToType().Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
         bool is_scoped = false;
         DWARFFormValue encoding_form;
 
         const size_t num_attributes = die.GetAttributes(attributes);
         if (num_attributes > 0) {
           uint32_t i;
 
if (type_ptr == NULL) {
                     static_cast<void *>(this), die.GetOffset(),
                     DW_TAG_value_to_name(tag), type_name_cstr,
                     type_sp->GetID());
               }
 
               // We found a real definition for this type elsewhere so lets use
               // it and cache the fact that we found a complete type for this
               // die
-              dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+              dwarf->GetDIEToType().Set(die.GetDIE(), type_sp.get());
               clang::DeclContext *defn_decl_ctx =
                   GetCachedClangDeclContextForDIE(dwarf->DebugInfo()->GetDIE(
                       DIERef(type_sp->GetID(), dwarf)));
               if (defn_decl_ctx)
                 LinkDeclContextToDIE(defn_decl_ctx, die);
               return type_sp;
             }
           }
           DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                        DW_TAG_value_to_name(tag), type_name_cstr);
 
           CompilerType enumerator_clang_type;
           clang_type.SetCompilerType(
               &m_ast,
-              dwarf->GetForwardDeclDieToClangType().lookup(die.GetDIE()));
+              dwarf->GetForwardDeclDieToClangType().Lookup(die.GetDIE()));
           if (!clang_type) {
             if (encoding_form.IsValid()) {
               Type *enumerator_type =
                   dwarf->ResolveTypeUID(DIERef(encoding_form));
               if (enumerator_type)
                 enumerator_clang_type = enumerator_type->GetFullCompilerType();
             }
 
if (type_ptr == NULL) {
           }
         }
       } break;
 
       case DW_TAG_inlined_subroutine:
       case DW_TAG_subprogram:
       case DW_TAG_subroutine_type: {
         // Set a bit that lets us know that we are currently parsing this
-        dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
+        dwarf->GetDIEToType().Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
         DWARFFormValue type_die_form;
         bool is_variadic = false;
         bool is_inline = false;
         bool is_static = false;
         bool is_virtual = false;
         bool is_explicit = false;
         bool is_artificial = false;

                                                class_type, failures);
 
                     // FIXME do something with these failures that's smarter
                     // than
                     // just dropping them on the ground.  Unfortunately classes
                     // don't like having stuff added to them after their
                     // definitions are complete...
 
-                    type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
+                    type_ptr = dwarf->GetDIEToType().Lookup(die.GetDIE());
                     if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {
                       type_sp = type_ptr->shared_from_this();
                       break;
                     }
                   }
                 }
 
                 if (specification_die_form.IsValid()) {

                       // itself through the clang::ExternalASTSource protocol,
                       // so we need to just have the class complete itself and
                       // do things the right way, then our
                       // DIE should then have an entry in the
                       // dwarf->GetDIEToType() map. First
                       // we need to modify the dwarf->GetDIEToType() so it
                       // doesn't think we are trying to parse this DIE
                       // anymore...
-                      dwarf->GetDIEToType()[die.GetDIE()] = NULL;
+                      dwarf->GetDIEToType().Set(die.GetDIE(), NULL);
 
                       // Now we get the full type to force our class type to
                       // complete itself using the clang::ExternalASTSource
                       // protocol which will parse all base classes and all
                       // methods (including the method for this DIE).
                       class_type->GetFullCompilerType();
 
                       // The type for this DIE should have been filled in the
                       // function call above
-                      type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
+                      type_ptr = dwarf->GetDIEToType().Lookup(die.GetDIE());
                       if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {
                         type_sp = type_ptr->shared_from_this();
                         break;
                       }
 
                       // FIXME This is fixing some even uglier behavior but we
                       // really need to
                       // uniq the methods of each class as well as the class

         type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str, 0, NULL,
                                LLDB_INVALID_UID, Type::eEncodingIsUID, &decl,
                                clang_type, Type::eResolveStateFull));
         assert(type_sp.get());
       } break;
 
       case DW_TAG_array_type: {
         // Set a bit that lets us know that we are currently parsing this
-        dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
+        dwarf->GetDIEToType().Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
         DWARFFormValue type_die_form;
         int64_t first_index = 0;
         uint32_t byte_stride = 0;
         uint32_t bit_stride = 0;
         bool is_vector = false;
         const size_t num_attributes = die.GetAttributes(attributes);
 

         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();
+        dwarf->GetDIEToType().Set(die.GetDIE(), type_sp.get());
       }
     } else if (type_ptr != DIE_IS_BEING_PARSED) {
       type_sp = type_ptr->shared_from_this();
     }
   }
   return type_sp;
 }
 
default:
     break;
   }
 
   return false;
 }
 
 std::vector<DWARFDIE> DWARFASTParserClang::GetDIEForDeclContext(
     lldb_private::CompilerDeclContext decl_context) {
-  std::vector<DWARFDIE> result;
-  for (auto it = m_decl_ctx_to_die.find(
-           (clang::DeclContext *)decl_context.GetOpaqueDeclContext());
-       it != m_decl_ctx_to_die.end(); it++)
-    result.push_back(it->second);
-  return result;
+  std::vector<DWARFDIE> res;
+  m_decl_ctx_to_die.ApplyToEntry(
+      (clang::DeclContext *)decl_context.GetOpaqueDeclContext(),
+      [&](std::unique_ptr<DIEList> &list) { res = *list; });
+  return res;
 }
 
 CompilerDecl DWARFASTParserClang::GetDeclForUIDFromDWARF(const DWARFDIE &die) {
   clang::Decl *clang_decl = GetClangDeclForDIE(die);
   if (clang_decl != nullptr)
     return CompilerDecl(&m_ast, clang_decl);
   return CompilerDecl();
 }
if (func_range.GetBaseAddress().IsValid()) {
       std::unique_ptr<Declaration> decl_ap;
       if (decl_file != 0 || decl_line != 0 || decl_column != 0)
         decl_ap.reset(new Declaration(
             sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
             decl_line, decl_column));
 
       SymbolFileDWARF *dwarf = die.GetDWARF();
       // Supply the type _only_ if it has already been parsed
-      Type *func_type = dwarf->GetDIEToType().lookup(die.GetDIE());
+      Type *func_type = dwarf->GetDIEToType().Lookup(die.GetDIE());
 
       assert(func_type == NULL || func_type != DIE_IS_BEING_PARSED);
 
       if (dwarf->FixupAddress(func_range.GetBaseAddress())) {
         const user_id_t func_user_id = die.GetID();
         func_sp.reset(new Function(sc.comp_unit,
                                    func_user_id, // UserID is the DIE offset
                                    func_user_id, func_name, func_type,
clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(const DWARFDIE &die) {
   case DW_TAG_formal_parameter:
   case DW_TAG_imported_declaration:
   case DW_TAG_imported_module:
     break;
   default:
     return nullptr;
   }
 
-  DIEToDeclMap::iterator cache_pos = m_die_to_decl.find(die.GetDIE());
-  if (cache_pos != m_die_to_decl.end())
-    return cache_pos->second;
+  clang::Decl *cached_value;
+  if (m_die_to_decl.Lookup(die.GetDIE(), cached_value))
+    return cached_value;
 
   if (DWARFDIE spec_die = die.GetReferencedDIE(DW_AT_specification)) {
     clang::Decl *decl = GetClangDeclForDIE(spec_die);
-    m_die_to_decl[die.GetDIE()] = decl;
-    m_decl_to_die[decl].insert(die.GetDIE());
+    m_die_to_decl.Set(die.GetDIE(), decl);
+    m_decl_to_die.ApplyToEntry(
+        decl, [=](DIEPointerSet &set) { set.insert(die.GetDIE()); });
     return decl;
   }
 
   if (DWARFDIE abstract_origin_die =
           die.GetReferencedDIE(DW_AT_abstract_origin)) {
     clang::Decl *decl = GetClangDeclForDIE(abstract_origin_die);
-    m_die_to_decl[die.GetDIE()] = decl;
-    m_decl_to_die[decl].insert(die.GetDIE());
+    m_die_to_decl.Set(die.GetDIE(), decl);
+    m_decl_to_die.ApplyToEntry(
+        decl, [=](DIEPointerSet &set) { set.insert(die.GetDIE()); });
     return decl;
   }
 
   clang::Decl *decl = nullptr;
   switch (die.Tag()) {
   case DW_TAG_variable:
   case DW_TAG_constant:
   case DW_TAG_formal_parameter: {
if (imported_uid) {
       }
     }
     break;
   }
   default:
     break;
   }
 
-  m_die_to_decl[die.GetDIE()] = decl;
-  m_decl_to_die[decl].insert(die.GetDIE());
+  m_die_to_decl.Set(die.GetDIE(), decl);
+  m_decl_to_die.ApplyToEntry(
+      decl, [=](DIEPointerSet &set) { set.insert(die.GetDIE()); });
 
   return decl;
 }
 
 clang::DeclContext *
 DWARFASTParserClang::GetClangDeclContextForDIE(const DWARFDIE &die) {
   if (die) {
     clang::DeclContext *decl_ctx = GetCachedClangDeclContextForDIE(die);
DWARFDIE child = FindFirstChildWithAbstractOrigin(
       die, containing_function_with_abstract_origin);
   CompilerDeclContext decl_context =
       GetDeclContextContainingUIDFromDWARF(child);
   return (clang::DeclContext *)decl_context.GetOpaqueDeclContext();
 }
 
 clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(const DWARFDIE &die) {
   if (die && die.Tag() == DW_TAG_lexical_block) {
-    clang::BlockDecl *decl =
-        llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.GetDIE()]);
+    clang::BlockDecl *decl = llvm::cast_or_null<clang::BlockDecl>(
+        m_die_to_decl_ctx.Lookup(die.GetDIE()));
 
     if (!decl) {
       DWARFDIE decl_context_die;
       clang::DeclContext *decl_context =
           GetClangDeclContextContainingDIE(die, &decl_context_die);
       decl = m_ast.CreateBlockDeclaration(decl_context);
 
       if (decl)
         LinkDeclContextToDIE((clang::DeclContext *)decl, die);
     }
 
     return decl;
   }
   return nullptr;
 }
 
 clang::NamespaceDecl *
 DWARFASTParserClang::ResolveNamespaceDIE(const DWARFDIE &die) {
   if (die && die.Tag() == DW_TAG_namespace) {
     // See if we already parsed this namespace DIE and associated it with a
     // uniqued namespace declaration
-    clang::NamespaceDecl *namespace_decl =
-        static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.GetDIE()]);
+    clang::NamespaceDecl *namespace_decl = static_cast<clang::NamespaceDecl *>(
+        m_die_to_decl_ctx.Lookup(die.GetDIE()));
     if (namespace_decl)
       return namespace_decl;
     else {
       const char *namespace_name = die.GetName();
       clang::DeclContext *containing_decl_ctx =
           GetClangDeclContextContainingDIE(die, nullptr);
       namespace_decl = m_ast.GetUniqueNamespaceDeclaration(namespace_name,
                                                            containing_decl_ctx);
if (clang_decl_ctx)
       return clang_decl_ctx;
   }
   return m_ast.GetTranslationUnitDecl();
 }
 
 clang::DeclContext *
 DWARFASTParserClang::GetCachedClangDeclContextForDIE(const DWARFDIE &die) {
   if (die) {
-    DIEToDeclContextMap::iterator pos = m_die_to_decl_ctx.find(die.GetDIE());
-    if (pos != m_die_to_decl_ctx.end())
-      return pos->second;
+    clang::DeclContext *cached_value;
+    if (m_die_to_decl_ctx.Lookup(die.GetDIE(), cached_value))
+      return cached_value;
   }
   return nullptr;
 }
 
 void DWARFASTParserClang::LinkDeclContextToDIE(clang::DeclContext *decl_ctx,
                                                const DWARFDIE &die) {
-  m_die_to_decl_ctx[die.GetDIE()] = decl_ctx;
+  m_die_to_decl_ctx.Set(die.GetDIE(), decl_ctx);
   // There can be many DIEs for a single decl context
   // m_decl_ctx_to_die[decl_ctx].insert(die.GetDIE());
-  m_decl_ctx_to_die.insert(std::make_pair(decl_ctx, die));
+  m_decl_ctx_to_die.ApplyToEntry(decl_ctx, [=](std::unique_ptr<DIEList> &dies) {
+    if (!dies)
+      dies = llvm::make_unique<DIEList>();
+    dies->push_back(die);
+  });
 }
 
 bool DWARFASTParserClang::CopyUniqueClassMethodTypes(
     const DWARFDIE &src_class_die, const DWARFDIE &dst_class_die,
     lldb_private::Type *class_type, DWARFDIECollection &failures) {
   if (!class_type || !src_class_die || !dst_class_die)
     return false;
   if (src_class_die.Tag() != dst_class_die.Tag())
bool DWARFASTParserClang::CopyUniqueClassMethodTypes(
   if (fast_path) {
     // We can do this quickly.  Just run across the tables index-for-index
     // since we know each node has matching names and tags.
     for (idx = 0; idx < src_size; ++idx) {
       src_die = src_name_to_die.GetValueAtIndexUnchecked(idx);
       dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx);
 
       clang::DeclContext *src_decl_ctx =
-          src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
+          src_dwarf_ast_parser->m_die_to_decl_ctx.Lookup(src_die.GetDIE());
       if (src_decl_ctx) {
         if (log)
           log->Printf("uniquing decl context %p from 0x%8.8x for 0x%8.8x",
                       static_cast<void *>(src_decl_ctx), src_die.GetOffset(),
                       dst_die.GetOffset());
         dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, dst_die);
       } else {
         if (log)
           log->Printf("warning: tried to unique decl context from 0x%8.8x for "
                       "0x%8.8x, but none was found",
                       src_die.GetOffset(), dst_die.GetOffset());
       }
 
       Type *src_child_type =
-          dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
+          dst_die.GetDWARF()->GetDIEToType().Lookup(src_die.GetDIE());
       if (src_child_type) {
         if (log)
           log->Printf(
               "uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x",
               static_cast<void *>(src_child_type), src_child_type->GetID(),
               src_die.GetOffset(), dst_die.GetOffset());
-        dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
+        dst_die.GetDWARF()->GetDIEToType().Set(dst_die.GetDIE(),
+                                               src_child_type);
       } else {
         if (log)
           log->Printf("warning: tried to unique lldb_private::Type from "
                       "0x%8.8x for 0x%8.8x, but none was found",
                       src_die.GetOffset(), dst_die.GetOffset());
       }
     }
   } else {
     // We must do this slowly.  For each member of the destination, look up a
     // member in the source with the same name, check its tag, and unique them
     // if everything matches up.  Report failures.
 
     if (!src_name_to_die.IsEmpty() && !dst_name_to_die.IsEmpty()) {
       src_name_to_die.Sort();
 
       for (idx = 0; idx < dst_size; ++idx) {
         ConstString dst_name = dst_name_to_die.GetCStringAtIndex(idx);
         dst_die = dst_name_to_die.GetValueAtIndexUnchecked(idx);
         src_die = src_name_to_die.Find(dst_name, DWARFDIE());
 
         if (src_die && (src_die.Tag() == dst_die.Tag())) {
           clang::DeclContext *src_decl_ctx =
-              src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
+              src_dwarf_ast_parser->m_die_to_decl_ctx.Lookup(src_die.GetDIE());
           if (src_decl_ctx) {
             if (log)
               log->Printf("uniquing decl context %p from 0x%8.8x for 0x%8.8x",
                           static_cast<void *>(src_decl_ctx),
                           src_die.GetOffset(), dst_die.GetOffset());
             dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, dst_die);
           } else {
             if (log)
               log->Printf("warning: tried to unique decl context from 0x%8.8x "
                           "for 0x%8.8x, but none was found",
                           src_die.GetOffset(), dst_die.GetOffset());
           }
 
           Type *src_child_type =
-              dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
+              dst_die.GetDWARF()->GetDIEToType().Lookup(src_die.GetDIE());
           if (src_child_type) {
             if (log)
               log->Printf("uniquing type %p (uid=0x%" PRIx64
                           ") from 0x%8.8x for 0x%8.8x",
                           static_cast<void *>(src_child_type),
                           src_child_type->GetID(), src_die.GetOffset(),
                           dst_die.GetOffset());
-            dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] =
-                src_child_type;
+            dst_die.GetDWARF()->GetDIEToType().Set(dst_die.GetDIE(),
+                                                   src_child_type);
           } else {
             if (log)
               log->Printf("warning: tried to unique lldb_private::Type from "
                           "0x%8.8x for 0x%8.8x, but none was found",
                           src_die.GetOffset(), dst_die.GetOffset());
           }
         } else {
           if (log)
for (idx = 0; idx < src_size_artificial; ++idx) {
           src_name_to_die_artificial.GetCStringAtIndex(idx);
       src_die = src_name_to_die_artificial.GetValueAtIndexUnchecked(idx);
       dst_die =
           dst_name_to_die_artificial.Find(src_name_artificial, DWARFDIE());
 
       if (dst_die) {
         // Both classes have the artificial types, link them
         clang::DeclContext *src_decl_ctx =
-            src_dwarf_ast_parser->m_die_to_decl_ctx[src_die.GetDIE()];
+            src_dwarf_ast_parser->m_die_to_decl_ctx.Lookup(src_die.GetDIE());
         if (src_decl_ctx) {
           if (log)
             log->Printf("uniquing decl context %p from 0x%8.8x for 0x%8.8x",
                         static_cast<void *>(src_decl_ctx), src_die.GetOffset(),
                         dst_die.GetOffset());
           dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, dst_die);
         } else {
           if (log)
             log->Printf("warning: tried to unique decl context from 0x%8.8x "
                         "for 0x%8.8x, but none was found",
                         src_die.GetOffset(), dst_die.GetOffset());
         }
 
         Type *src_child_type =
-            dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
+            dst_die.GetDWARF()->GetDIEToType().Lookup(src_die.GetDIE());
         if (src_child_type) {
           if (log)
             log->Printf(
                 "uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x",
                 static_cast<void *>(src_child_type), src_child_type->GetID(),
                 src_die.GetOffset(), dst_die.GetOffset());
-          dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
+          dst_die.GetDWARF()->GetDIEToType().Set(dst_die.GetDIE(),
+                                                 src_child_type);
         } else {
           if (log)
             log->Printf("warning: tried to unique lldb_private::Type from "
                         "0x%8.8x for 0x%8.8x, but none was found",
                         src_die.GetOffset(), dst_die.GetOffset());
         }
       }
     }

source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp

if (die) {
     SymbolFileDWARF *dwarf = die.GetDWARF();
     if (log) {
       dwarf->GetObjectFile()->GetModule()->LogMessage(
           log, "DWARFASTParserGo::ParseTypeFromDWARF (die = 0x%8.8x) %s name = "
                "'%s')",
           die.GetOffset(), DW_TAG_value_to_name(die.Tag()), die.GetName());
     }
 
-    Type *type_ptr = dwarf->m_die_to_type.lookup(die.GetDIE());
+    Type *type_ptr = dwarf->m_die_to_type.Lookup(die.GetDIE());
     TypeList *type_list = dwarf->GetTypeList();
     if (type_ptr == NULL) {
       if (type_is_new_ptr)
         *type_is_new_ptr = true;
 
       const dw_tag_t tag = die.Tag();
 
       bool is_forward_declaration = false;
if (type_ptr == NULL) {
       dw_attr_t attr;
 
       switch (tag) {
       case DW_TAG_base_type:
       case DW_TAG_pointer_type:
       case DW_TAG_typedef:
       case DW_TAG_unspecified_type: {
         // Set a bit that lets us know that we are currently parsing this
-        dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+        dwarf->m_die_to_type.Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
         const size_t num_attributes = die.GetAttributes(attributes);
         lldb::user_id_t encoding_uid = LLDB_INVALID_UID;
 
         if (num_attributes > 0) {
           uint32_t i;
           for (i = 0; i < num_attributes; ++i) {
             attr = attributes.AttributeAtIndex(i);
if (type_ptr == NULL) {
         case DW_TAG_typedef:
           encoding_data_type = Type::eEncodingIsTypedefUID;
           CompilerType impl;
           Type *type = dwarf->ResolveTypeUID(encoding_uid);
           if (type) {
             if (go_kind == 0 && type->GetName() == type_name_const_str) {
               // Go emits extra typedefs as a forward declaration. Ignore
               // these.
-              dwarf->m_die_to_type[die.GetDIE()] = type;
+              dwarf->m_die_to_type.Set(die.GetDIE(), type);
               return type->shared_from_this();
             }
             impl = type->GetForwardCompilerType();
             compiler_type =
                 m_ast.CreateTypedefType(go_kind, type_name_const_str, impl);
           }
           break;
         }
 
         type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str,
                                byte_size, NULL, encoding_uid,
                                encoding_data_type, &decl, compiler_type,
                                resolve_state));
 
-        dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
+        dwarf->m_die_to_type.Set(die.GetDIE(), type_sp.get());
       } break;
 
       case DW_TAG_structure_type: {
         // Set a bit that lets us know that we are currently parsing this
-        dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+        dwarf->m_die_to_type.Set(die.GetDIE(), DIE_IS_BEING_PARSED);
         bool byte_size_valid = false;
 
         const size_t num_attributes = die.GetAttributes(attributes);
         if (num_attributes > 0) {
           uint32_t i;
           for (i = 0; i < num_attributes; ++i) {
             attr = attributes.AttributeAtIndex(i);
             if (attributes.ExtractFormValueAtIndex(i, form_value)) {
if (type_ptr == NULL) {
                 type_name_const_str, die, decl,
                 byte_size_valid ? byte_size : -1, *unique_ast_entry_ap)) {
           // We have already parsed this type or from another compile unit. GCC
           // loves to use the "one definition rule" which can result in
           // multiple definitions of the same class over and over in each
           // compile unit.
           type_sp = unique_ast_entry_ap->m_type_sp;
           if (type_sp) {
-            dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
+            dwarf->m_die_to_type.Set(die.GetDIE(), type_sp.get());
             return type_sp;
           }
         }
 
         DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                      DW_TAG_value_to_name(tag), type_name_cstr);
 
         bool compiler_type_was_created = false;
         compiler_type.SetCompilerType(
             &m_ast,
-            dwarf->m_forward_decl_die_to_clang_type.lookup(die.GetDIE()));
+            dwarf->m_forward_decl_die_to_clang_type.Lookup(die.GetDIE()));
         if (!compiler_type) {
           compiler_type_was_created = true;
           compiler_type =
               m_ast.CreateStructType(go_kind, type_name_const_str, byte_size);
         }
 
         type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str,
                                byte_size, NULL, LLDB_INVALID_UID,
if (type_ptr == NULL) {
             // No children for this struct/union/class, lets finish it
             m_ast.CompleteStructType(compiler_type);
           } else if (compiler_type_was_created) {
             // Leave this as a forward declaration until we need to know the
             // details of the type. lldb_private::Type will automatically call
             // the SymbolFile virtual function
             // "SymbolFileDWARF::CompleteType(Type *)" When the definition
             // needs to be defined.
-            dwarf->m_forward_decl_die_to_clang_type[die.GetDIE()] =
-                compiler_type.GetOpaqueQualType();
-            dwarf->m_forward_decl_clang_type_to_die[compiler_type
-                                                        .GetOpaqueQualType()] =
-                die.GetDIERef();
+            dwarf->m_forward_decl_die_to_clang_type.Set(
+                die.GetDIE(), compiler_type.GetOpaqueQualType());
+            dwarf->m_forward_decl_clang_type_to_die.Set(
+                compiler_type.GetOpaqueQualType(), die.GetDIERef());
             // SetHasExternalStorage (compiler_type.GetOpaqueQualType(), true);
           }
         }
       } break;
 
       case DW_TAG_subprogram:
       case DW_TAG_subroutine_type: {
         // Set a bit that lets us know that we are currently parsing this
-        dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+        dwarf->m_die_to_type.Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
         bool is_variadic = false;
         clang::StorageClass storage =
             clang::SC_None; //, Extern, Static, PrivateExtern
 
         const size_t num_attributes = die.GetAttributes(attributes);
         if (num_attributes > 0) {
           uint32_t i;
if (type_ptr == NULL) {
         type_sp.reset(new Type(die.GetID(), dwarf, type_name_const_str, 0, NULL,
                                LLDB_INVALID_UID, Type::eEncodingIsUID, &decl,
                                compiler_type, Type::eResolveStateFull));
         assert(type_sp.get());
       } break;
 
       case DW_TAG_array_type: {
         // Set a bit that lets us know that we are currently parsing this
-        dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+        dwarf->m_die_to_type.Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
         lldb::user_id_t type_die_offset = DW_INVALID_OFFSET;
         int64_t first_index = 0;
         uint32_t byte_stride = 0;
         uint32_t bit_stride = 0;
         const size_t num_attributes = die.GetAttributes(attributes);
 
         if (num_attributes > 0) {
if (type_ptr == NULL) {
         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->m_die_to_type[die.GetDIE()] = type_sp.get();
+        dwarf->m_die_to_type.Set(die.GetDIE(), type_sp.get());
       }
     } else if (type_ptr != DIE_IS_BEING_PARSED) {
       type_sp = type_ptr->shared_from_this();
     }
   }
   return type_sp;
 }
 
if (func_range.GetBaseAddress().IsValid()) {
       std::unique_ptr<Declaration> decl_ap;
       if (decl_file != 0 || decl_line != 0 || decl_column != 0)
         decl_ap.reset(new Declaration(
             sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
             decl_line, decl_column));
 
       SymbolFileDWARF *dwarf = die.GetDWARF();
       // Supply the type _only_ if it has already been parsed
-      Type *func_type = dwarf->m_die_to_type.lookup(die.GetDIE());
+      Type *func_type = dwarf->m_die_to_type.Lookup(die.GetDIE());
 
       assert(func_type == NULL || func_type != DIE_IS_BEING_PARSED);
 
       if (dwarf->FixupAddress(func_range.GetBaseAddress())) {
         const user_id_t func_user_id = die.GetID();
         func_sp.reset(new Function(sc.comp_unit,
                                    func_user_id, // UserID is the DIE offset
                                    func_user_id, func_name, func_type,

source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp

 using namespace lldb_private;
 
 DWARFASTParserJava::DWARFASTParserJava(JavaASTContext &ast) : m_ast(ast) {}
 
 DWARFASTParserJava::~DWARFASTParserJava() {}
 
 TypeSP DWARFASTParserJava::ParseBaseTypeFromDIE(const DWARFDIE &die) {
   SymbolFileDWARF *dwarf = die.GetDWARF();
-  dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+  dwarf->m_die_to_type.Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
   ConstString type_name;
   uint64_t byte_size = 0;
 
   DWARFAttributes attributes;
   const size_t num_attributes = die.GetAttributes(attributes);
   for (uint32_t i = 0; i < num_attributes; ++i) {
     DWARFFormValue form_value;
TypeSP DWARFASTParserJava::ParseBaseTypeFromDIE(const DWARFDIE &die) {
   CompilerType compiler_type = m_ast.CreateBaseType(type_name);
   return std::make_shared<Type>(die.GetID(), dwarf, type_name, byte_size,
                                 nullptr, LLDB_INVALID_UID, Type::eEncodingIsUID,
                                 decl, compiler_type, Type::eResolveStateFull);
 }
 
 TypeSP DWARFASTParserJava::ParseArrayTypeFromDIE(const DWARFDIE &die) {
   SymbolFileDWARF *dwarf = die.GetDWARF();
-  dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+  dwarf->m_die_to_type.Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
   ConstString linkage_name;
   DWARFFormValue type_attr_value;
   lldb::addr_t data_offset = LLDB_INVALID_ADDRESS;
   DWARFExpression length_expression(die.GetCU());
 
   DWARFAttributes attributes;
   const size_t num_attributes = die.GetAttributes(attributes);
TypeSP type_sp(new Type(die.GetID(), dwarf, array_compiler_type.GetTypeName(),
                           Type::eEncodingIsUID, &decl, array_compiler_type,
                           Type::eResolveStateFull));
   type_sp->SetEncodingType(element_type);
   return type_sp;
 }
 
 TypeSP DWARFASTParserJava::ParseReferenceTypeFromDIE(const DWARFDIE &die) {
   SymbolFileDWARF *dwarf = die.GetDWARF();
-  dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+  dwarf->m_die_to_type.Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
   Declaration decl;
   DWARFFormValue type_attr_value;
 
   DWARFAttributes attributes;
   const size_t num_attributes = die.GetAttributes(attributes);
   for (uint32_t i = 0; i < num_attributes; ++i) {
     DWARFFormValue form_value;
TypeSP type_sp(
                reference_compiler_type, Type::eResolveStateFull));
   type_sp->SetEncodingType(pointee_type);
   return type_sp;
 }
 
 lldb::TypeSP DWARFASTParserJava::ParseClassTypeFromDIE(const DWARFDIE &die,
                                                        bool &is_new_type) {
   SymbolFileDWARF *dwarf = die.GetDWARF();
-  dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+  dwarf->m_die_to_type.Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
   Declaration decl;
   ConstString name;
   ConstString linkage_name;
   bool is_forward_declaration = false;
   uint32_t byte_size = 0;
 
   DWARFAttributes attributes;
lldb::TypeSP DWARFASTParserJava::ParseClassTypeFromDIE(const DWARFDIE &die,
   UniqueDWARFASTType unique_ast_entry;
   if (name) {
     std::string qualified_name;
     if (die.GetQualifiedName(qualified_name)) {
       name.SetCString(qualified_name.c_str());
       if (dwarf->GetUniqueDWARFASTTypeMap().Find(name, die, Declaration(), -1,
                                                  unique_ast_entry)) {
         if (unique_ast_entry.m_type_sp) {
-          dwarf->GetDIEToType()[die.GetDIE()] =
-              unique_ast_entry.m_type_sp.get();
+          dwarf->GetDIEToType().Set(die.GetDIE(),
+                                    unique_ast_entry.m_type_sp.get());
           is_new_type = false;
           return unique_ast_entry.m_type_sp;
         }
       }
     }
   }
 
   if (is_forward_declaration) {
     DWARFDeclContext die_decl_ctx;
     die.GetDWARFDeclContext(die_decl_ctx);
 
     TypeSP type_sp = dwarf->FindDefinitionTypeForDWARFDeclContext(die_decl_ctx);
     if (type_sp) {
       // We found a real definition for this type elsewhere so lets use it
-      dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+      dwarf->GetDIEToType().Set(die.GetDIE(), type_sp.get());
       is_new_type = false;
       return type_sp;
     }
   }
 
   CompilerType compiler_type(
-      &m_ast, dwarf->GetForwardDeclDieToClangType().lookup(die.GetDIE()));
+      &m_ast, dwarf->GetForwardDeclDieToClangType().Lookup(die.GetDIE()));
   if (!compiler_type)
     compiler_type = m_ast.CreateObjectType(name, linkage_name, byte_size);
 
   is_new_type = true;
   TypeSP type_sp(new Type(die.GetID(), dwarf, name,
                           -1, // byte size isn't specified
                           nullptr, LLDB_INVALID_UID, Type::eEncodingIsUID,
                           &decl, compiler_type, Type::eResolveStateForward));
 
   // Add our type to the unique type map
   unique_ast_entry.m_type_sp = type_sp;
   unique_ast_entry.m_die = die;
   unique_ast_entry.m_declaration = decl;
   unique_ast_entry.m_byte_size = -1;
   dwarf->GetUniqueDWARFASTTypeMap().Insert(name, unique_ast_entry);
 
   if (!is_forward_declaration) {
     // Leave this as a forward declaration until we need to know the details of
     // the type
-    dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] =
-        compiler_type.GetOpaqueQualType();
-    dwarf->GetForwardDeclClangTypeToDie()[compiler_type.GetOpaqueQualType()] =
-        die.GetDIERef();
+    dwarf->GetForwardDeclDieToClangType().Set(
+        die.GetDIE(), compiler_type.GetOpaqueQualType());
+    dwarf->GetForwardDeclClangTypeToDie().Set(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) {
   if (type_is_new_ptr)
     *type_is_new_ptr = false;
 
   if (!die)
     return nullptr;
 
   SymbolFileDWARF *dwarf = die.GetDWARF();
 
-  Type *type_ptr = dwarf->m_die_to_type.lookup(die.GetDIE());
+  Type *type_ptr = dwarf->m_die_to_type.Lookup(die.GetDIE());
   if (type_ptr == DIE_IS_BEING_PARSED)
     return nullptr;
   if (type_ptr != nullptr)
     return type_ptr->shared_from_this();
 
   TypeSP type_sp;
   if (type_is_new_ptr)
     *type_is_new_ptr = true;
if (sc_parent_tag == DW_TAG_compile_unit ||
     if (symbol_context_scope == nullptr)
       symbol_context_scope = sc.function;
   }
 
   if (symbol_context_scope != nullptr)
     type_sp->SetSymbolContextScope(symbol_context_scope);
 
   dwarf->GetTypeList()->Insert(type_sp);
-  dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
+  dwarf->m_die_to_type.Set(die.GetDIE(), type_sp.get());
 
   return type_sp;
 }
 
 lldb_private::Function *DWARFASTParserJava::ParseFunctionFromDWARF(
     const lldb_private::SymbolContext &sc, const DWARFDIE &die) {
   assert(die.Tag() == DW_TAG_subprogram);
 

source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.cpp

 using namespace lldb_private;
 
 DWARFASTParserOCaml::DWARFASTParserOCaml(OCamlASTContext &ast) : m_ast(ast) {}
 
 DWARFASTParserOCaml::~DWARFASTParserOCaml() {}
 
 TypeSP DWARFASTParserOCaml::ParseBaseTypeFromDIE(const DWARFDIE &die) {
   SymbolFileDWARF *dwarf = die.GetDWARF();
-  dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+  dwarf->m_die_to_type.Set(die.GetDIE(), DIE_IS_BEING_PARSED);
 
   ConstString type_name;
   uint64_t byte_size = 0;
 
   DWARFAttributes attributes;
   const size_t num_attributes = die.GetAttributes(attributes);
   for (uint32_t i = 0; i < num_attributes; ++i) {
     DWARFFormValue form_value;
lldb::TypeSP DWARFASTParserOCaml::ParseTypeFromDWARF(const SymbolContext &sc,
   if (type_is_new_ptr)
     *type_is_new_ptr = false;
 
   if (!die)
     return nullptr;
 
   SymbolFileDWARF *dwarf = die.GetDWARF();
 
-  Type *type_ptr = dwarf->m_die_to_type.lookup(die.GetDIE());
+  Type *type_ptr = dwarf->m_die_to_type.Lookup(die.GetDIE());
   if (type_ptr == DIE_IS_BEING_PARSED)
     return nullptr;
   if (type_ptr != nullptr)
     return type_ptr->shared_from_this();
 
   TypeSP type_sp;
   if (type_is_new_ptr)
     *type_is_new_ptr = true;
if (sc_parent_tag == DW_TAG_compile_unit ||
     if (symbol_context_scope == nullptr)
       symbol_context_scope = sc.function;
   }
 
   if (symbol_context_scope != nullptr)
     type_sp->SetSymbolContextScope(symbol_context_scope);
 
   dwarf->GetTypeList()->Insert(type_sp);
-  dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
+  dwarf->m_die_to_type.Set(die.GetDIE(), type_sp.get());
 
   return type_sp;
 }
 
 Function *DWARFASTParserOCaml::ParseFunctionFromDWARF(const SymbolContext &sc,
                                                       const DWARFDIE &die) {
   DWARFRangeList func_ranges;
   const char *name = NULL;
if (func_range.GetBaseAddress().IsValid()) {
       FunctionSP func_sp;
       std::unique_ptr<Declaration> decl_ap;
       if (decl_file != 0 || decl_line != 0 || decl_column != 0)
         decl_ap.reset(new Declaration(
             sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
             decl_line, decl_column));
 
       SymbolFileDWARF *dwarf = die.GetDWARF();
-      Type *func_type = dwarf->m_die_to_type.lookup(die.GetDIE());
+      Type *func_type = dwarf->m_die_to_type.Lookup(die.GetDIE());
 
       assert(func_type == NULL || func_type != DIE_IS_BEING_PARSED);
 
       if (dwarf->FixupAddress(func_range.GetBaseAddress())) {
         const user_id_t func_user_id = die.GetID();
         func_sp.reset(new Function(sc.comp_unit,
                                    func_user_id, // UserID is the DIE offset
                                    func_user_id, func_name, func_type,

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 #include <list>
 #include <map>
 #include <mutex>
 #include <set>
 #include <unordered_map>
 #include <vector>
 
 // Other libraries and framework includes
-#include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Utility/Flags.h"
 
 #include "lldb/Core/RangeMap.h"
+#include "lldb/Core/ThreadSafeDenseMap.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
public:
 
   static bool
   DIEInDeclContext(const lldb_private::CompilerDeclContext *parent_decl_ctx,
                    const DWARFDIE &die);
 
   void Dump(lldb_private::Stream &s) override;
 
 protected:
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
+  typedef lldb_private::ThreadSafeDenseMap<const DWARFDebugInfoEntry *,
+                                           lldb_private::Type *>
       DIEToTypePtr;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
+  typedef lldb_private::ThreadSafeDenseMap<const DWARFDebugInfoEntry *,
+                                           lldb::VariableSP>
       DIEToVariableSP;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
+  typedef lldb_private::ThreadSafeDenseMap<const DWARFDebugInfoEntry *,
                                            lldb::opaque_compiler_type_t>
       DIEToClangType;
-  typedef llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> ClangTypeToDIE;
+  typedef lldb_private::ThreadSafeDenseMap<lldb::opaque_compiler_type_t, DIERef>
+      ClangTypeToDIE;
 
   struct DWARFDataSegment {
     llvm::once_flag m_flag;
     lldb_private::DWARFDataExtractor m_data;
   };
 
   DISALLOW_COPY_AND_ASSIGN(SymbolFileDWARF);
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 
 // This function is used when SymbolFileDWARFDebugMap owns a bunch of
 // SymbolFileDWARF objects to detect if this DWARF file is the one that can
 // resolve a compiler_type.
 bool SymbolFileDWARF::HasForwardDeclForClangType(
     const CompilerType &compiler_type) {
   CompilerType compiler_type_no_qualifiers =
       ClangUtil::RemoveFastQualifiers(compiler_type);
-  if (GetForwardDeclClangTypeToDie().count(
-          compiler_type_no_qualifiers.GetOpaqueQualType())) {
+  DIERef ref;
+  if (GetForwardDeclClangTypeToDie().Lookup(
+          compiler_type_no_qualifiers.GetOpaqueQualType(), ref)) {
     return true;
   }
   TypeSystem *type_system = compiler_type.GetTypeSystem();
 
   ClangASTContext *clang_type_system =
       llvm::dyn_cast_or_null<ClangASTContext>(type_system);
   if (!clang_type_system)
     return false;
if (clang_type_system) {
     if (ast_parser &&
         ast_parser->GetClangASTImporter().CanImport(compiler_type))
       return ast_parser->GetClangASTImporter().CompleteType(compiler_type);
   }
 
   // We have a struct/union/class/enum that needs to be fully resolved.
   CompilerType compiler_type_no_qualifiers =
       ClangUtil::RemoveFastQualifiers(compiler_type);
-  auto die_it = GetForwardDeclClangTypeToDie().find(
-      compiler_type_no_qualifiers.GetOpaqueQualType());
-  if (die_it == GetForwardDeclClangTypeToDie().end()) {
+  DIERef ref;
+  if (!GetForwardDeclClangTypeToDie().Lookup(
+          compiler_type_no_qualifiers.GetOpaqueQualType(), ref)) {
     // We have already resolved this type...
     return true;
   }
 
-  DWARFDIE dwarf_die = GetDIE(die_it->getSecond());
+  DWARFDIE dwarf_die = GetDIE(ref);
   if (dwarf_die) {
     // Once we start resolving this type, remove it from the forward
     // declaration map in case anyone child members or other types require this
     // type to get resolved. The type will get resolved when all of the calls
     // to SymbolFileDWARF::ResolveClangOpaqueTypeDefinition are done.
-    GetForwardDeclClangTypeToDie().erase(die_it);
+    GetForwardDeclClangTypeToDie().Erase(
+        compiler_type_no_qualifiers.GetOpaqueQualType());
 
-    Type *type = GetDIEToType().lookup(dwarf_die.GetDIE());
+    Type *type = GetDIEToType().Lookup(dwarf_die.GetDIE());
 
     Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO |
                                           DWARF_LOG_TYPE_COMPLETION));
     if (log)
       GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
           log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
           dwarf_die.GetID(), dwarf_die.GetTagAsCString(),
           type->GetName().AsCString());
SymbolFileDWARF::FindNamespace(const SymbolContext &sc, const ConstString &name,
 
   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());
+    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;
for (size_t i = 0; i < num_matches; ++i) {
               DEBUG_PRINTF("resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64
                            " (cu 0x%8.8" PRIx64 ")\n",
                            die.GetID(),
                            m_obj_file->GetFileSpec().GetFilename().AsCString(
                                "<Unknown>"),
                            type_die.GetID(), type_cu->GetID());
 
               if (die)
-                GetDIEToType()[die.GetDIE()] = resolved_type;
+                GetDIEToType().Set(die.GetDIE(), resolved_type);
               type_sp = resolved_type->shared_from_this();
               break;
             }
           }
         }
       } else {
         m_index->ReportInvalidDIEOffset(die_ref.die_offset,
                                         type_name.GetStringRef());
VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
                                              const lldb::addr_t func_low_pc) {
   if (die.GetDWARF() != this)
     return die.GetDWARF()->ParseVariableDIE(sc, die, func_low_pc);
 
   VariableSP var_sp;
   if (!die)
     return var_sp;
 
-  var_sp = GetDIEToVariable()[die.GetDIE()];
+  var_sp = GetDIEToVariable().Lookup(die.GetDIE());
   if (var_sp)
     return var_sp; // Already been parsed!
 
   const dw_tag_t tag = die.Tag();
   ModuleSP module = GetObjectFile()->GetModule();
 
   if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
       (tag == DW_TAG_formal_parameter && sc.function)) {
if (num_attributes > 0) {
         // context wasn't filled in yet
         return var_sp;
       }
     }
     // Cache var_sp even if NULL (the variable was just a specification or was
     // missing vital information to be able to be displayed in the debugger
     // (missing location due to optimization, etc)) so we don't re-parse this
     // DIE over and over later...
-    GetDIEToVariable()[die.GetDIE()] = var_sp;
+    GetDIEToVariable().Set(die.GetDIE(), var_sp);
     if (spec_die)
-      GetDIEToVariable()[spec_die.GetDIE()] = var_sp;
+      GetDIEToVariable().Set(spec_die.GetDIE(), var_sp);
   }
   return var_sp;
 }
 
 DWARFDIE
 SymbolFileDWARF::FindBlockContainingSpecification(
     const DIERef &func_die_ref, dw_offset_t spec_block_die_offset) {
   // Give the concrete function die specified by "func_die_offset", find the
size_t SymbolFileDWARF::ParseVariables(const SymbolContext &sc,
   VariableListSP variable_list_sp;
 
   size_t vars_added = 0;
   DWARFDIE die = orig_die;
   while (die) {
     dw_tag_t tag = die.Tag();
 
     // Check to see if we have already parsed this variable or constant?
-    VariableSP var_sp = GetDIEToVariable()[die.GetDIE()];
+    VariableSP var_sp = GetDIEToVariable().Lookup(die.GetDIE());
     if (var_sp) {
       if (cc_variable_list)
         cc_variable_list->AddVariableIfUnique(var_sp);
     } else {
       // We haven't already parsed it, lets do that now.
       if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
           (tag == DW_TAG_formal_parameter && sc.function)) {
         if (variable_list_sp.get() == NULL) {