Pass `CompileUnit *` along `DWARFDIE` for DWZ

[jankratochvil]

Summary

This patch passes CompileUnit * along DWARFDIE for DWZ.

[labath]

It's been a while since we had that discussion, but the way I'm remembering it, sizeof(DWARFDIE) was not my biggest concern with this stuff (though I may have been echoing the concerns of some other people). What I was trying to prevent is diverging even more from the llvm dwarf implementation. In that sense, changing lldb's DWARFDIE without a matching change to the llvm counterpart is equally bad. I don't think the first two options are ever going to make it into llvm. The third might, but even that may be a hard sell -- a slightly more tractable option might be to reuse the low-order bits in the DWARFDIE via PointerIntPair. We might be able to get those eight bits that way.

But all of that seems peripheral to me. The main thing I was trying to achieve was to have the low-level DWARF code (DWARFUnit, DWARFDIE, ... -- basically the things that are in the llvm dwarf parser right now) not require access to anything outside of what is available to them. If there's a thing which requires more info, it should be built on top of this lower layer, not trying to reach out from inside it. Once it's outside, a lot of options become available. If there is a lldb_private::CompileUnit in the vicinity of this code, it could just fetch the language from there. Or, we can have some sort of a SuperDWARFDIE, which includes the language, or the main compile unit (either lldb or dwarf) to pass around as a single entity (using PointerIntPair would be an optimization of that). Or, instead of SuperDWARFDIE we could use a DIERef, a user_id_t, or some of the other reference kinds we have already..

As for this patch, I don't see any big problem with changing the representation in this case, but given that it's motivation is to able to later change DWARFDIE, I don't think its really useful/needed.

The test changes are cool, and I'd encourage you to split them off into a separate patch.

[clayborg]

Is this something we can store in the DWARFUnit? Seems like it would be nice to be able to ask the DWARFUnit for its DWZ Unit? Then no changes are needed to DWARFDie since it could get the language by checking the DWARFUnit first and then fall back to the DWZ DwarfUnit that is a member of the first DWARFUnit?

[jankratochvil]

In D73206#1837138, @clayborg wrote:

Is this something we can store in the DWARFUnit? Seems like it would be nice to be able to ask the DWARFUnit for its DWZ Unit? Then no changes are needed to DWARFDie since it could get the language by checking the DWARFUnit first and then fall back to the DWZ DwarfUnit that is a member of the first DWARFUnit?

DWARFDebugInfoEntry is a part of DWARFPartialUnit::m_die_array (DWARFPartialUnit=DW_TAG_partial_unit). One DWARFPartialUnit can be (and it is in real world DWZ debuginfos) included (by DW_TAG_imported_unit::DW_AT_import) into two different DW_TAG_compile_units each having different DW_TAG_compile_unit::DW_AT_language.
So no, the language cannot be stored in any DWARFUnit and neither in DWARFDebugInfoEntry. Unless we make a new copy of DWARFPartialUnit for each DW_TAG_imported_unit::DW_AT_import which was my former implementation (2) which you turned down as needlessly ineffective.
Your follow-up is appreciated.
(I need to prepare more my reply to @labath.)

[labath]

BTW, I am currently trying to clean up the dwo/dwp code, and here (I think) I ran into a very similar problem to what you are encountering.

Dwo units currently contain a backlink to the skeleton unit that uses them, and we have a fairly convoluted system (that's the part I'm trying to clean up) to ensure that each time we are parsing a dwo unit, we are able to go back to the skeleton unit which uses it (and then to a lldb_private::CompileUnit). Now, in principle, there is nothing wrong with that because the skeleton and split units are in a 1:1 relationship. However, the llvm parser does not have such a backlink. And although I don't think it would be unreasonable to have the llvm parser include this backlink, given that the dwz unit cannot make use of that (not 1:1), I think it would be a good idea to come up with a different solution for this, and then have both dwo and dwz use that.

Overall I think the intention of passing another DWARFUnit pointer to identify the "compile unit that we're actually parsing stuff into" is reasonable (as with DWZ, the idea that a DWARFUnit somehow corresponds to an lldb CompileUnit is completely breaking down). But I don't think we should be making that a part of the DWARFDIE (and thereby inflitrating it into everything). Instead I think it should be something on top of that. Whether that needs to be a separate class/struct (std::pair<DWARFUnit, DWARFDIE>?) or just and additional argument to the functions that need it is still not fully clear to me...

[jankratochvil]

In D73206#1838165, @labath wrote:

Whether that needs to be a separate class/struct (std::pair<DWARFUnit, DWARFDIE>?) or just and additional argument to the functions that need it is still not fully clear to me...

I also do not find that clear.

In this code there are:

• 19 FIXMEindex - we need to store DWARFCompileUnit * into manual/apple/debug_names index, it is storing now CompileUnit * but I think that could be fixed + converted at some places
• 11 FIXMEunused - I think in these cases (non-DWARF debug info) the nullptr is OK for CompileUnit * as nobody uses it there
• 3 FIXMEDeclContext - those (in fact 2) cases may be tricky, I have tried it but I started to get lost in it, hopefully solvable
• 1 FIXMETypeuser_id_t - it is needed only for SBModule::GetTypeByID() and I think one needs to embed the DWZ main CU into lldb::user_id_t only in SBValue::GetID(). One cannot embed it to all lldb::user_id_t instances inside LLDB as then the DWZ main CU needs to be in DWARFDIE and that has been denied.

Does this look an acceptable approach to pursue it further?

This patch is applicable on top of non-regressing implementation using the DWARFDIE::m_main_cu:

• git clone -b dwz git://git.jankratochvil.net/lldb

This patch should only compile, it has no chance to run without crashes so far.

[labath]

Thanks for exploring this.

From a high-level, this approach looks like it could be viable. However, you have taken this a lot further than I would have expected. What I was expecting to see would be that a bunch of the DWARF internal functions would get an extra argument (be it a CompileUnit, DWARFUnit, or whatever), but I did not expect that this would also appear on the "generic" interfaces. My idea was that the external interface would keep getting just a single user_id_t, but then during the process of decoding that integer into a DWARFDie, we would also produce the additional CompileUnit object.

Now, that doesn't mean that adding a CompileUnit argument to these functions too is a bad idea. Quite the opposite -- _if it actually works_, it would be great because it would give us a lot more freedom in encoding the information into the user_id_t value. However, I have some doubts about that. For example, right now we don't create any CompileUnit objects for types in DWARF type units, and I'm not sure how much we want to change that because of the sheer number of type units. That means we'd still have to have a way to encode a precise type location in a user_id_t without a CompileUnit, though maybe we would be ablle to assume that a CompileUnit is always available in the DWZ case (?).

This duality does make me think that we'd be better off in not adding the CompileUnit arguments and encoding everything into a user_id_t. However, I am not sure if we really have a choice here -- it may be that this information is so complex that it will not be possible to reasonably encode it into 64 bits.

PS. It would be easier to evaluate this if this was based on master instead of some patch which is taking the source in the direction we don't want to go it.

[jankratochvil]

In D73206#1859944, @labath wrote:

From a high-level, this approach looks like it could be viable. However, you have taken this a lot further than I would have expected. What I was expecting to see would be that a bunch of the DWARF internal functions would get an extra argument (be it a CompileUnit, DWARFUnit, or whatever), but I did not expect that this would also appear on the "generic" interfaces. My idea was that the external interface would keep getting just a single user_id_t, but then during the process of decoding that integer into a DWARFDie, we would also produce the additional CompileUnit object.

In such case there need to be two kinds of user_id_t. One internal to DWARF/ not containing MainCU and one for "generic" interfaces which does contain MainCU. Because internally if user_id_t contains MainCU then already also DWARFDIE and DIERef must contain MainCU - see for example ElaboratingDIEIterator calling DWARFDIE::GetID where is no chance to know the MainCU (without heavy refactorization to pass it down the call chain) - and the code does not really need to know MainCU, it is just using user_id_t as a unique DIE identifier.

Now, that doesn't mean that adding a CompileUnit argument to these functions too is a bad idea. Quite the opposite -- _if it actually works_, it would be great because it would give us a lot more freedom in encoding the information into the user_id_t value. However, I have some doubts about that. For example, right now we don't create any CompileUnit objects for types in DWARF type units, and I'm not sure how much we want to change that because of the sheer number of type units. That means we'd still have to have a way to encode a precise type location in a user_id_t without a CompileUnit, though maybe we would be ablle to assume that a CompileUnit is always available in the DWZ case (?).

Yes, if there is no CompileUnit available then DWZ is not used for that type and the DWARFUnit itself can be used. CompileUnit * can remain nullptr when not known.

The new plan:

• SymbolFile and SB* API should say unchanged with MainCUs encoded into user_id_t they use
• types like Function do contain CompileUnit * but still it may be easier for the APIs to encode MainCU into their user_id_t.
• indexes contain now DIERef. They should contain rather a new MainCU-extended variant of DIERef.
• DWARFASTParser (+DWARFASTParserClang) API - there must be an additional CompileUnit * parameter as it uses DWARFDIE. (DWARFDIE cannot fit MainCU into its 16 bytes.)
• DWARFMappedHash also must have new MainCU field I think.
• NameToDIE should be using the new MainCU-enhanced DIERef.

Given that user_id_t and DIERef will exist both with and without MainCU (depending on which code is using them) it would be nice to make a new MainCU-extended inherited type for them so that their mistaken use is compile-time checked. But user_id_t is just an integer typedef so it would need to be class-wrapped. For user_id_t one needs to also make a new MainCU-extended type of UserID.

This duality does make me think that we'd be better off in not adding the CompileUnit arguments and encoding everything into a user_id_t. However, I am not sure if we really have a choice here -- it may be that this information is so complex that it will not be possible to reasonably encode it into 64 bits.

That my DWZ branch (git clone -b dwz git://git.jankratochvil.net/lldb) already encodes MainCU to all of DWARFDIE (becoming 24B instead of 16B), DIERef (staying 8B) and user_id_t (staying 8B, reducing DWO unit number from 31 bits to 29 bits). One can encode MainCU into the DWO field as both can never exist together.

PS. It would be easier to evaluate this if this was based on master instead of some patch which is taking the source in the direction we don't want to go it.

I need to verify the new refactorization satisfies all the requirements of my existing functional non-regressing DWZ implementation I have. I would then have to create a second proof of concept patch being to post here based on master. Which I hope is not required for your review before its real implementation. I understand the final refactorization patch will be based on master and DWZ will be rebased on top of it.

[labath]

In D73206#1866280, @jankratochvil wrote:

In D73206#1859944, @labath wrote:

From a high-level, this approach looks like it could be viable. However, you have taken this a lot further than I would have expected. What I was expecting to see would be that a bunch of the DWARF internal functions would get an extra argument (be it a CompileUnit, DWARFUnit, or whatever), but I did not expect that this would also appear on the "generic" interfaces. My idea was that the external interface would keep getting just a single user_id_t, but then during the process of decoding that integer into a DWARFDie, we would also produce the additional CompileUnit object.

In such case there need to be two kinds of user_id_t. One internal to DWARF/ not containing MainCU and one for "generic" interfaces which does contain MainCU. Because internally if user_id_t contains MainCU then already also DWARFDIE and DIERef must contain MainCU - see for example ElaboratingDIEIterator calling DWARFDIE::GetID where is no chance to know the MainCU (without heavy refactorization to pass it down the call chain) - and the code does not really need to know MainCU, it is just using user_id_t as a unique DIE identifier.

Well.. I think we should avoid using user_id_t in places where we don't have enough information to construct one. I have removed the usage in ElaboratingDIEIterator with 034c2c6771d318f962bbf001f00ee11e542e1180.

...
The new plan:

• SymbolFile and SB* API should say unchanged with MainCUs encoded into user_id_t they use
• types like Function do contain CompileUnit * but still it may be easier for the APIs to encode MainCU into their user_id_t.

SG, I agree that would be better, since it requires less refactoring throughout.

• indexes contain now DIERef. They should contain rather a new MainCU-extended variant of DIERef.

The indexes need to *produce* an "extended" DIERef. Internally, they can contain whatever they want. This is particularly important for the manual index, where simply introducing a new field would be a pretty big memory hit, I think. However, it should be fairly easy to design a more compact encoding scheme specifically for the use in the manual index.

In fact, if we make the index functions produce results piecemeal rather than in one big chunk, then we could make them return DWARFDIEs (and compile units or whatever) directly. The reason these functions return DIERefs now is that DIERefs are cheap to construct, and we don't want to construct all DWARFDIEs if the user only cares about one result. If the user can abort iteration, then we can get rid of DIERefs in these functions, as the first thing that the user does to them anyway is to convert them to a DWARFDIE.

• DWARFASTParser (+DWARFASTParserClang) API - there must be an additional CompileUnit * parameter as it uses DWARFDIE. (DWARFDIE cannot fit MainCU into its 16 bytes.)

Yep. It may be interesting to try this out on regular dwo first. Right now, dwo dodges this problem by storing a CompileUnit pointer on both skeleton and split units. If we can make this work without the split unit back pointer, then we can come move closer to how things work in llvm, and also pave the way for the dwz stuff.

• DWARFMappedHash also must have new MainCU field I think.

This is only used in conjunction with apple accelerators. I don't think dwz will ever be a thing there, so you can just ignore dwz here (type units and dwo are also ignored here).

• NameToDIE should be using the new MainCU-enhanced DIERef.

This is only used in the manual index, where we can do something custom if needed.

Given that user_id_t and DIERef will exist both with and without MainCU (depending on which code is using them) it would be nice to make a new MainCU-extended inherited type for them so that their mistaken use is compile-time checked. But user_id_t is just an integer typedef so it would need to be class-wrapped. For user_id_t one needs to also make a new MainCU-extended type of UserID.

I think it would be good to have only one kind of "user id". What are the cases where you need a main-cu-less user id?

PS. It would be easier to evaluate this if this was based on master instead of some patch which is taking the source in the direction we don't want to go it.

I need to verify the new refactorization satisfies all the requirements of my existing functional non-regressing DWZ implementation I have. I would then have to create a second proof of concept patch being to post here based on master. Which I hope is not required for your review before its real implementation. I understand the final refactorization patch will be based on master and DWZ will be rebased on top of it.

This is enough for to get a very high level idea of where you're going, but it gets tricky when I want to look at some specific details. For instance, some of the changes in this patch seem trivial and non-controversial, but that's only because they are based on changes in the other patch, and those are the changes I had problems with..

[jankratochvil]

In D73206#1871895, @labath wrote:

Yep. It may be interesting to try this out on regular dwo first. Right now, dwo dodges this problem by storing a CompileUnit pointer on both skeleton and split units. If we can make this work without the split unit back pointer, then we can come move closer to how things work in llvm, and also pave the way for the dwz stuff.

Just clarifying if you would therefore like to remove these two items:

SymbolFileDWARF &SymbolFileDWARFDwo::GetBaseSymbolFile() { return m_base_symbol_file; }
SymbolFileDWARF &SymbolFileDWARFDwo::m_base_symbol_file;

[labath]

In D73206#1928710, @jankratochvil wrote:

In D73206#1871895, @labath wrote:

Yep. It may be interesting to try this out on regular dwo first. Right now, dwo dodges this problem by storing a CompileUnit pointer on both skeleton and split units. If we can make this work without the split unit back pointer, then we can come move closer to how things work in llvm, and also pave the way for the dwz stuff.

Just clarifying if you would therefore like to remove these two items:

SymbolFileDWARF &SymbolFileDWARFDwo::GetBaseSymbolFile() { return m_base_symbol_file; }
SymbolFileDWARF &SymbolFileDWARFDwo::m_base_symbol_file;

Eventually I'd like to delete the entire SymbolFileDWARFDwo class. Right now, it serves almost no useful purpose -- nearly all of its methods just redirect to the "base" symbol file in interesting (and confusing) ways. But I'm not sure that removing GetBaseSymbolFile is the right way to start that, as without it you cannot implement the redirection.

The way I was considering doing this was first ensuring that all other objects which store a SymbolFileDWARF pointer are updated to point to the "base" object. But there are probably even other things that need to be done before that, such as moving the lower-level dwarf stuff from SymbolFileDWARF to DWARFContext. Then the "base" DWARFContext could be directly responsible for creating "dwo" DWARFContexts (just like it is in llvm) and SymbolFileDWARFDwo could be removed. I am not sure how much work all of that is though...

Where are you going with that question? If it's stopping you from doing anything, I can try to look into that a bit closer...

[jankratochvil]

In D73206#1928869, @labath wrote:

But I'm not sure that removing GetBaseSymbolFile is the right way to start that, as without it you cannot implement the redirection.

Current code is:

SymbolFileDWARF::DIEToTypePtr &SymbolFileDWARFDwo::GetDIEToType() { return GetBaseSymbolFile().GetDIEToType(); }
typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *> DIEToTypePtr;

There will need to be the following change for DWZ anyway - as the same DWARFDebugInfoEntry * can lead to different Types depending on its Main CU:

typedef llvm::DenseMap<std::pair<DWARFUnit *, const DWARFDebugInfoEntry *>, lldb_private::Type *> DIEToTypePtr;

Where the pair.first would be DWARFUnit *main_cu for DWZ. And so then the SymbolFileDWARFDwo redirection can be done from that main_cu pointer (with some interface refactorization).

Where are you going with that question? If it's stopping you from doing anything, I can try to look into that a bit closer...

As I have currently some difficulties unifying the DWZ MainCU tracking with DWO MainCU tracking. DWZ deals only with DW_TAG_compile_unit and not with DW_TAG_type_unit as DWZ can unify+reference types more effectively using DW_FORM_ref*. While DWO deals also with DWARFTypeUnit. Each DWZ DWARFCompileUnit has corresponding CompileUnit but DWARFTypeUnit does not have any. So in SymbolFileDWARF::GetTypeForDIE for DWO it will use the second code path:

SymbolContextScope *scope;
if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU()))
  scope = GetCompUnitForDWARFCompUnit(*dwarf_cu);
else
  scope = GetObjectFile()->GetModule().get();

Therefore this code of mine no longer works as comp_unit==nullptr for DWARFTypeUnits:

DWARFUnit *main_unit = dwarf->GetDWARFCompileUnit(sc.comp_unit);

So either I would need to add new tracking DWARFUnit *main_unit even to functions which already have SymbolContext &sc parameter. Or more probably I need to somehow track the skeleton file some other way (looking it up from sc.module_sp by its hash?).
Without DWO support it is easier as I no longer have to work on the DWO MainCU tracking which is a task of its own. Also I could use the type DWARFCompileUnit *main_unit which saves some downcastings.

So I am asking if the DWO support together with DWZ brings some real improvements as it complicates the situation for the DWZ support.

Just for illustration: https://people.redhat.com/jkratoch/lldb-main_unit-DWARFUnit.patch or the non-DWO start of simplification: https://people.redhat.com/jkratoch/lldb-main_unit-DWARFCompileUnit.patch

[jankratochvil]

Here is some preview of the style I chose. It is sure regression free.
It is not intended for serious review but any ideas are sure welcome.
I plan to rebase my DWZ patchset on top of it to verify how complete it is.

[labath]

Overall, I think this is workable. The main thing I don't like about the current state is the introduction of user_id_t into the index classes. It forces a bunch of conversions for a flow that really should be simple.

I guess that was to avoid main-cu-ificating the DIERef class? I think (and I think I've already said this) the right thing to do here would be to change the index classes to be callback-based. Then the memory footprint is out of the equation (no vector<DIERef>, and the indexes can return a "main cu pair" or something of sorts, as that is what their callers will convert this to anyway.

I still see other issues (too much knowledge of "main cus" inside DWARFDie, inconsistent DWARFCompileUnit/CompileUnit usage in DWARFASTParser), but handling these can wait a bit...

[jankratochvil]

In D73206#1949516, @labath wrote:

The main thing I don't like about the current state is the introduction of user_id_t into the index classes. It forces a bunch of conversions for a flow that really should be simple.

I guess that was to avoid main-cu-ificating the DIERef class?

Yes, that was the purpose of D74637. To have two different small (8 bytes) DIE references, one with MainCU (chosen to be user_id_t) and one without MainCU (chosen to be DIERef).

I think (and I think I've already said this) the right thing to do here would be to change the index classes to be callback-based. Then the memory footprint is out of the equation (no vector<DIERef>, and the indexes can return a "main cu pair" or something of sorts, as that is what their callers will convert this to anyway.

OK, I can make an unrelated trunk-based refactorization for DWARFIndex descendants to use callbacks.

Internally ManualDWARFIndex and DebugNamesDWARFIndex need to store also MainCU so user_id_t looks to me as their best choice for their internal storage. It is true AppleDWARFIndex does not need MainCU so that would prevent its DIERef->user_id_t conversion, that is the only win there I can see. One could also refactor AppleDWARFIndex even more to use user_id_t natively. Would then be there still a win with the callback?

Or is the callback preferred unrelated to any DIERef vs. user_id_t?

[labath]

The internal representation of DebugNames and Apple indexes is fixed by the relevant (pseudo-)standards, so we can't really change it. The question is how to efficiently (and cleanly) convert from the internal representation to some common thing. The conversion from AppleIndex to DIERef is trivial (which is not surprising as it was the first and the overall design was optimized for that). With debug_names, the situation gets more tricky. The internal representation of debug_names uses CU-relative DIE offsets, but DIERef wants an absolute offset. That means the index has to do more work to produce the common representation. And it needs to do that for all results, even though a lot of the index users are really interested only in a single entry. With the switch to user_id_t, _all_ indexes would have to do some extra work to encode it, only for their users to have to immediately decode it back. Having a iterator/callback based api would allow us to minimize the impact of that, as it would only need to happen for the entries that are really used. And /I think/ we could make it interface returns DWARFDies directly, and each index converts to that using the most direct approach available.

Another aspect is that is seems fundamentally wrong to use an representation which requires knowledge of multiple SymbolFiles when dealing with entities which are statically know to come from a single file (here, I mean SymbolFileDWARFDebugMap -- I'm glossing over SymbolFileDWARFDwos as those aren't really standalone files, and I hope that class will go away soon).

[jankratochvil]

In D73206#1954668, @labath wrote:

Having a iterator/callback based api would allow us to minimize the impact of that, as it would only need to happen for the entries that are really used. And /I think/ we could make it interface returns DWARFDies directly, and each index converts to that using the most direct approach available.

When I tried to rebase this patch on top of D77327 it looks like:

<<<<<<< HEAD = D77327
  bool GetObjCMethods(lldb_private::ConstString class_name,
                      llvm::function_ref<bool(DIERef ref)> callback) override;
||||||| aed2fdb1671
  size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
                                 DIEArray &method_die_offsets) override;
=======
  size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
                                 std::vector<lldb::user_id_t> &method_die_offsets) override;
>>>>>>> user_id_t

So IIUC I should convert it first to: llvm::function_ref<bool(DWARFDIE die)> callback
Going to try that.

[jankratochvil]

@labath now with existing callbacks

llvm::function_ref<bool(DWARFDIE die)> callback

I am going to add DWARFCompileUnit *main_unit somewhere. BTW it can be nullptr, for example for DIES from type units. In my WIP patches I was putting it in front (as main_unit sort of contains the die):

llvm::function_ref<bool(DWARFCompileUnit *main_unit, DWARFDIE die)> callback

or do you prefer it added at the end?

llvm::function_ref<bool(DWARFDIE die, DWARFCompileUnit *main_unit)> callback

This applies also to API like:

clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die) {

vs..

clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(const DWARFDIE &die, DWARFCompileUnit *main_unit) {

I want to prevent using default parameters:

clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(const DWARFDIE &die, DWARFCompileUnit *main_unit = nullptr) {

as that would easily lead to forgetting to delegate main_unit which would only be discovered during DWZ tests (and only if they test such specific API function).

[labath]

Yes, having main_unit come first seems reasonably hierarchical. I'm still unsure as to whether lldb_private::CompileUnit would not be better, but let's have a look at this first...

[jankratochvil]

This is only to get an idea what I am preparing, not for detailed reading. Maybe it should be split even more? It contains both main_unit addition to callbacks:

 void DebugNamesDWARFIndex::GetGlobalVariables(
-    const DWARFUnit &cu, llvm::function_ref<bool(DWARFDIE die)> callback) {
+    const DWARFUnit &cu,
+    llvm::function_ref<bool(DWARFCompileUnit *main_unit, DWARFDIE die)>
+        callback) {

and also data structure extensions like:

-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
+  typedef llvm::DenseMap<
+      std::pair<DWARFCompileUnit *, const DWARFDebugInfoEntry *>,
+      lldb_private::Type *>
       DIEToTypePtr;
...
-  dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+  dwarf->GetDIEToType()[die.MainCUtoDIEPair(main_unit)] = type_sp.get();

With some needed infrastructure for MainCUtoDIEPair & co.

[jankratochvil]

Replaced by D96236.

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.h

 //===-- AppleDWARFIndex.h --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_APPLEDWARFINDEX_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_APPLEDWARFINDEX_H
 
 #include "Plugins/SymbolFile/DWARF/DWARFIndex.h"
 #include "Plugins/SymbolFile/DWARF/HashedNameToDIE.h"
+#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
+#include "lldb/Symbol/ObjectFile.h"
 
 namespace lldb_private {
 class AppleDWARFIndex : public DWARFIndex {
 public:
   static std::unique_ptr<AppleDWARFIndex>
-  Create(Module &module, DWARFDataExtractor apple_names,
+  Create(SymbolFileDWARF &dwarf, DWARFDataExtractor apple_names,
          DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types,
          DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str);
 
   AppleDWARFIndex(
-      Module &module, std::unique_ptr<DWARFMappedHash::MemoryTable> apple_names,
+      SymbolFileDWARF &dwarf, std::unique_ptr<DWARFMappedHash::MemoryTable> apple_names,
       std::unique_ptr<DWARFMappedHash::MemoryTable> apple_namespaces,
       std::unique_ptr<DWARFMappedHash::MemoryTable> apple_types,
       std::unique_ptr<DWARFMappedHash::MemoryTable> apple_objc)
-      : DWARFIndex(module), m_apple_names_up(std::move(apple_names)),
+      : DWARFIndex(*dwarf.GetObjectFile()->GetModule()), m_dwarf(dwarf), m_apple_names_up(std::move(apple_names)),
         m_apple_namespaces_up(std::move(apple_namespaces)),
         m_apple_types_up(std::move(apple_types)),
         m_apple_objc_up(std::move(apple_objc)) {}
 
   void Preload() override {}
 
-  void GetGlobalVariables(ConstString basename, DIEArray &offsets) override;
+  void GetGlobalVariables(ConstString basename, std::vector<lldb::user_id_t> &offsets) override;
   void GetGlobalVariables(const RegularExpression &regex,
-                          DIEArray &offsets) override;
-  void GetGlobalVariables(const DWARFUnit &cu, DIEArray &offsets) override;
-  void GetObjCMethods(ConstString class_name, DIEArray &offsets) override;
+                          std::vector<lldb::user_id_t> &offsets) override;
+  void GetGlobalVariables(const DWARFUnit &cu, std::vector<lldb::user_id_t> &offsets) override;
+  void GetObjCMethods(ConstString class_name, std::vector<lldb::user_id_t> &offsets) override;
   void GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
-                            DIEArray &offsets) override;
-  void GetTypes(ConstString name, DIEArray &offsets) override;
-  void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) override;
-  void GetNamespaces(ConstString name, DIEArray &offsets) override;
+                            std::vector<lldb::user_id_t> &offsets) override;
+  void GetTypes(ConstString name, std::vector<lldb::user_id_t> &offsets) override;
+  void GetTypes(const DWARFDeclContext &context, std::vector<lldb::user_id_t> &offsets) override;
+  void GetNamespaces(ConstString name, std::vector<lldb::user_id_t> &offsets) override;
   void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
-                    std::vector<DWARFDIE> &dies) override;
-  void GetFunctions(const RegularExpression &regex, DIEArray &offsets) override;
+                    std::vector<std::pair<DWARFCompileUnit *, DWARFDIE>> &dies) override;
+  void GetFunctions(const RegularExpression &regex, std::vector<lldb::user_id_t> &offsets) override;
 
-  void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) override;
+  void ReportInvalidDIEID(lldb::user_id_t uid, llvm::StringRef name) override;
   void Dump(Stream &s) override;
 
 private:
+  SymbolFileDWARF &m_dwarf;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_names_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_namespaces_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_types_up;
   std::unique_ptr<DWARFMappedHash::MemoryTable> m_apple_objc_up;
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_APPLEDWARFINDEX_H

lldb/source/Plugins/SymbolFile/DWARF/AppleDWARFIndex.cpp

 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/Function.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 std::unique_ptr<AppleDWARFIndex> AppleDWARFIndex::Create(
-    Module &module, DWARFDataExtractor apple_names,
+    SymbolFileDWARF &dwarf, DWARFDataExtractor apple_names,
     DWARFDataExtractor apple_namespaces, DWARFDataExtractor apple_types,
     DWARFDataExtractor apple_objc, DWARFDataExtractor debug_str) {
   auto apple_names_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
       apple_names, debug_str, ".apple_names");
   if (!apple_names_table_up->IsValid())
     apple_names_table_up.reset();
 
   auto apple_namespaces_table_up =
std::unique_ptr<AppleDWARFIndex> AppleDWARFIndex::Create(
   auto apple_objc_table_up = std::make_unique<DWARFMappedHash::MemoryTable>(
       apple_objc, debug_str, ".apple_objc");
   if (!apple_objc_table_up->IsValid())
     apple_objc_table_up.reset();
 
   if (apple_names_table_up || apple_names_table_up || apple_types_table_up ||
       apple_objc_table_up)
     return std::make_unique<AppleDWARFIndex>(
-        module, std::move(apple_names_table_up),
+        dwarf, std::move(apple_names_table_up),
         std::move(apple_namespaces_table_up), std::move(apple_types_table_up),
         std::move(apple_objc_table_up));
 
   return nullptr;
 }
 
-void AppleDWARFIndex::GetGlobalVariables(ConstString basename, DIEArray &offsets) {
-  if (m_apple_names_up)
-    m_apple_names_up->FindByName(basename.GetStringRef(), offsets);
+void AppleDWARFIndex::GetGlobalVariables(ConstString basename, std::vector<lldb::user_id_t> &offsets) {
+  if (!m_apple_names_up)
+    return;
+  DIEArray refs;
+  m_apple_names_up->FindByName(basename.GetStringRef(), refs);
+  offsets.reserve(offsets.size() + refs.size());
+  for (const auto ref : refs)
+    offsets.push_back(m_dwarf.GetUID(nullptr/* main_unit */, ref));
 }
 
 void AppleDWARFIndex::GetGlobalVariables(const RegularExpression &regex,
-                                         DIEArray &offsets) {
+                                         std::vector<lldb::user_id_t> &offsets) {
   if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
-  if (m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data))
-    DWARFMappedHash::ExtractDIEArray(hash_data, offsets);
+  if (!m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data))
+    return;
+
+  DIEArray refs;
+  DWARFMappedHash::ExtractDIEArray(hash_data, refs);
+  offsets.reserve(offsets.size() + refs.size());
+  for (const auto ref : refs)
+    offsets.push_back(m_dwarf.GetUID(nullptr/* main_unit */, ref));
 }
 
 void AppleDWARFIndex::GetGlobalVariables(const DWARFUnit &cu,
-                                         DIEArray &offsets) {
+                                         std::vector<lldb::user_id_t> &offsets) {
   if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
-  if (m_apple_names_up->AppendAllDIEsInRange(cu.GetOffset(),
+  if (!m_apple_names_up->AppendAllDIEsInRange(cu.GetOffset(),
                                              cu.GetNextUnitOffset(), hash_data))
-    DWARFMappedHash::ExtractDIEArray(hash_data, offsets);
+    return;
+  DIEArray refs;
+  DWARFMappedHash::ExtractDIEArray(hash_data, refs);
+  offsets.reserve(offsets.size() + refs.size());
+  for (const auto ref : refs)
+    offsets.push_back(m_dwarf.GetUID(nullptr/* main_unit */, ref));
 }
 
 void AppleDWARFIndex::GetObjCMethods(ConstString class_name,
-                                     DIEArray &offsets) {
-  if (m_apple_objc_up)
-    m_apple_objc_up->FindByName(class_name.GetStringRef(), offsets);
+                                     std::vector<lldb::user_id_t> &offsets) {
+  if (!m_apple_objc_up)
+    return;
+
+  DIEArray refs;
+  m_apple_objc_up->FindByName(class_name.GetStringRef(), refs);
+  offsets.reserve(offsets.size() + refs.size());
+  for (const auto ref : refs)
+    offsets.push_back(m_dwarf.GetUID(nullptr/* main_unit */, ref));
 }
 
 void AppleDWARFIndex::GetCompleteObjCClass(ConstString class_name,
                                            bool must_be_implementation,
-                                           DIEArray &offsets) {
-  if (m_apple_types_up) {
-    m_apple_types_up->FindCompleteObjCClassByName(
-        class_name.GetStringRef(), offsets, must_be_implementation);
-  }
+                                           std::vector<lldb::user_id_t> &offsets) {
+  if (!m_apple_types_up)
+    return;
+
+  DIEArray refs;
+        class_name.GetStringRef(), refs, must_be_implementation);
+  offsets.reserve(offsets.size() + refs.size());
+  for (const auto ref : refs)
+    offsets.push_back(m_dwarf.GetUID(nullptr/* main_unit */, ref));
 }
 
-void AppleDWARFIndex::GetTypes(ConstString name, DIEArray &offsets) {
-  if (m_apple_types_up)
-    m_apple_types_up->FindByName(name.GetStringRef(), offsets);
+void AppleDWARFIndex::GetTypes(ConstString name, std::vector<lldb::user_id_t> &offsets) {
+  if (!m_apple_types_up)
+    return;
+
+  DIEArray refs;
+  m_apple_types_up->FindByName(name.GetStringRef(), refs);
+  offsets.reserve(offsets.size() + refs.size());
+  for (const auto ref : refs)
+    offsets.push_back(m_dwarf.GetUID(nullptr/* main_unit */, ref));
 }
 
 void AppleDWARFIndex::GetTypes(const DWARFDeclContext &context,
-                               DIEArray &offsets) {
+                               std::vector<lldb::user_id_t> &offsets) {
   if (!m_apple_types_up)
     return;
 
   Log *log = LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                           DWARF_LOG_LOOKUPS);
   const bool has_tag = m_apple_types_up->GetHeader().header_data.ContainsAtom(
       DWARFMappedHash::eAtomTypeTag);
   const bool has_qualified_name_hash =
       m_apple_types_up->GetHeader().header_data.ContainsAtom(
           DWARFMappedHash::eAtomTypeQualNameHash);
+  DIEArray refs;
 
   const ConstString type_name(context[0].name);
   const dw_tag_t tag = context[0].tag;
   if (has_tag && has_qualified_name_hash) {
     const char *qualified_name = context.GetQualifiedName();
     const uint32_t qualified_name_hash = llvm::djbHash(qualified_name);
     if (log)
       m_module.LogMessage(log, "FindByNameAndTagAndQualifiedNameHash()");
     m_apple_types_up->FindByNameAndTagAndQualifiedNameHash(
-        type_name.GetStringRef(), tag, qualified_name_hash, offsets);
-    return;
-  }
-
-  if (has_tag) {
+        type_name.GetStringRef(), tag, qualified_name_hash, refs);
+  } else if (has_tag) {
     // When searching for a scoped type (for example,
     // "std::vector<int>::const_iterator") searching for the innermost
     // name alone ("const_iterator") could yield many false
     // positives. By searching for the parent type ("vector<int>")
     // first we can avoid extracting type DIEs from object files that
     // would fail the filter anyway.
     if (!has_qualified_name_hash && (context.GetSize() > 1) &&
         (context[1].tag == DW_TAG_class_type ||
          context[1].tag == DW_TAG_structure_type)) {
       DIEArray class_matches;
       m_apple_types_up->FindByName(context[1].name, class_matches);
       if (class_matches.empty())
         return;
     }
 
     if (log)
       m_module.LogMessage(log, "FindByNameAndTag()");
-    m_apple_types_up->FindByNameAndTag(type_name.GetStringRef(), tag, offsets);
-    return;
-  }
-
-  m_apple_types_up->FindByName(type_name.GetStringRef(), offsets);
-}
-
-void AppleDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
-  if (m_apple_namespaces_up)
-    m_apple_namespaces_up->FindByName(name.GetStringRef(), offsets);
+    DIEArray refs;
+    m_apple_types_up->FindByNameAndTag(type_name.GetStringRef(), tag, refs);
+  } else
+    m_apple_types_up->FindByName(type_name.GetStringRef(), refs);
+  offsets.reserve(offsets.size() + refs.size());
+  for (const auto ref : refs)
+    offsets.push_back(m_dwarf.GetUID(nullptr/* main_unit */, ref));
+}
+
+void AppleDWARFIndex::GetNamespaces(ConstString name, std::vector<lldb::user_id_t> &offsets) {
+  if (!m_apple_namespaces_up)
+    return;
+
+  DIEArray refs;
+  m_apple_namespaces_up->FindByName(name.GetStringRef(), refs);
+  offsets.reserve(offsets.size() + refs.size());
+  for (const auto ref : refs)
+    offsets.push_back(m_dwarf.GetUID(nullptr/* main_unit */, ref));
 }
 
 void AppleDWARFIndex::GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                                    const CompilerDeclContext &parent_decl_ctx,
                                    uint32_t name_type_mask,
-                                   std::vector<DWARFDIE> &dies) {
+                                   std::vector<std::pair<DWARFCompileUnit *, DWARFDIE>> &dies) {
   DIEArray offsets;
   m_apple_names_up->FindByName(name.GetStringRef(), offsets);
   for (const DIERef &die_ref : offsets) {
-    ProcessFunctionDIE(name.GetStringRef(), die_ref, dwarf, parent_decl_ctx,
+    ProcessFunctionDIE(name.GetStringRef(), dwarf.GetUID(nullptr/*main_unit*/, die_ref), dwarf, parent_decl_ctx,
                        name_type_mask, dies);
   }
 }
 
 void AppleDWARFIndex::GetFunctions(const RegularExpression &regex,
-                                   DIEArray &offsets) {
+                                   std::vector<lldb::user_id_t> &offsets) {
   if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
-  if (m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data))
-    DWARFMappedHash::ExtractDIEArray(hash_data, offsets);
+  if (!m_apple_names_up->AppendAllDIEsThatMatchingRegex(regex, hash_data))
+    return;
+
+  DIEArray refs;
+  DWARFMappedHash::ExtractDIEArray(hash_data, refs);
+  offsets.reserve(offsets.size() + refs.size());
+  for (const auto ref : refs)
+    offsets.push_back(m_dwarf.GetUID(nullptr/* main_unit */, ref));
 }
 
-void AppleDWARFIndex::ReportInvalidDIERef(const DIERef &ref,
+void AppleDWARFIndex::ReportInvalidDIEID(user_id_t uid,
                                           llvm::StringRef name) {
   m_module.ReportErrorIfModifyDetected(
       "the DWARF debug information has been modified (accelerator table had "
-      "bad die 0x%8.8x for '%s')\n",
-      ref.die_offset(), name.str().c_str());
+      "bad die 0x%8.8lx for '%s')\n",
+      uid, name.str().c_str());
 }
 
 void AppleDWARFIndex::Dump(Stream &s) {
   if (m_apple_names_up)
     s.PutCString(".apple_names index present\n");
   if (m_apple_namespaces_up)
     s.PutCString(".apple_namespaces index present\n");
   if (m_apple_types_up)
     s.PutCString(".apple_types index present\n");
   if (m_apple_objc_up)
     s.PutCString(".apple_objc index present\n");
   // TODO: Dump index contents
 }

lldb/source/Plugins/SymbolFile/DWARF/DIERef.h

if (m_dwo_num_valid != other.m_dwo_num_valid)
       return m_dwo_num_valid < other.m_dwo_num_valid;
     if (m_dwo_num_valid && (m_dwo_num != other.m_dwo_num))
       return m_dwo_num < other.m_dwo_num;
     if (m_section != other.m_section)
       return m_section < other.m_section;
     return m_die_offset < other.m_die_offset;
   }
 
+  bool operator==(DIERef other) const {
+    if (m_dwo_num_valid != other.m_dwo_num_valid
+      || m_section != other.m_section
+      || m_die_offset != other.m_die_offset)
+      return false;
+    if (m_dwo_num_valid && m_dwo_num != other.m_dwo_num)
+      return false;
+    return true;
+  }
+
 private:
   uint32_t m_dwo_num : 30;
   uint32_t m_dwo_num_valid : 1;
   uint32_t m_section : 1;
   dw_offset_t m_die_offset;
 };
 static_assert(sizeof(DIERef) == 8, "");
 

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

 #include "lldb/Symbol/CompilerDeclContext.h"
 
 class DWARFDIE;
 namespace lldb_private {
 class CompileUnit;
 class ExecutionContext;
 }
 class SymbolFileDWARF;
+class DWARFCompileUnit;
 
 class DWARFASTParser {
 public:
   virtual ~DWARFASTParser() {}
 
   virtual lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
                                           const DWARFDIE &die,
                                           bool *type_is_new_ptr) = 0;
 
   virtual lldb_private::Function *
   ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
                          const DWARFDIE &die) = 0;
 
   virtual bool
   CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) = 0;
 
   virtual lldb_private::CompilerDecl
-  GetDeclForUIDFromDWARF(const DWARFDIE &die) = 0;
+  GetDeclForUIDFromDWARF(DWARFCompileUnit *main_unit, const DWARFDIE &die) = 0;
 
   virtual lldb_private::CompilerDeclContext
-  GetDeclContextForUIDFromDWARF(const DWARFDIE &die) = 0;
+  GetDeclContextForUIDFromDWARF(DWARFCompileUnit *main_unit, const DWARFDIE &die) = 0;
 
   virtual lldb_private::CompilerDeclContext
-  GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) = 0;
+  GetDeclContextContainingUIDFromDWARF(DWARFCompileUnit *main_unit, const DWARFDIE &die) = 0;
 
   virtual void EnsureAllDIEsInDeclContextHaveBeenParsed(
       lldb_private::CompilerDeclContext decl_context) = 0;
 
   static llvm::Optional<lldb_private::SymbolFile::ArrayInfo>
   ParseChildArrayInfo(const DWARFDIE &parent_die,
                       const lldb_private::ExecutionContext *exe_ctx = nullptr);
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSER_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

 //===-- DWARFASTParserClang.h -----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERCLANG_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFASTPARSERCLANG_H
 
 #include "clang/AST/CharUnits.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include "DWARFASTParser.h"
 #include "DWARFDIE.h"
 #include "DWARFDefines.h"
 #include "DWARFFormValue.h"
 #include "LogChannelDWARF.h"
 #include "lldb/Core/PluginInterface.h"
public:
   ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
                          const DWARFDIE &die) override;
 
   bool
   CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &compiler_type) override;
 
   lldb_private::CompilerDecl
-  GetDeclForUIDFromDWARF(const DWARFDIE &die) override;
+  GetDeclForUIDFromDWARF(DWARFCompileUnit *main_unit, const DWARFDIE &die) override;
 
   void EnsureAllDIEsInDeclContextHaveBeenParsed(
       lldb_private::CompilerDeclContext decl_context) override;
 
   lldb_private::CompilerDeclContext
-  GetDeclContextForUIDFromDWARF(const DWARFDIE &die) override;
+  GetDeclContextForUIDFromDWARF(DWARFCompileUnit *main_unit, const DWARFDIE &die) override;
 
   lldb_private::CompilerDeclContext
-  GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) override;
+  GetDeclContextContainingUIDFromDWARF(DWARFCompileUnit *main_unit, const DWARFDIE &die) override;
 
   lldb_private::ClangASTImporter &GetClangASTImporter();
 
 protected:
   /// Protected typedefs and members.
   /// @{
   class DelayedAddObjCClassProperty;
   typedef std::vector<DelayedAddObjCClassProperty> DelayedPropertyList;
 
-  typedef llvm::SmallPtrSet<const DWARFDebugInfoEntry *, 4> DIEPointerSet;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *>
+  typedef llvm::SmallSet<std::pair<DWARFCompileUnit *, const DWARFDebugInfoEntry *>, 4> DIEPointerSet;
+  typedef llvm::DenseMap<std::pair<DWARFCompileUnit *, const DWARFDebugInfoEntry *>, clang::DeclContext *>
       DIEToDeclContextMap;
-  typedef std::multimap<const clang::DeclContext *, const DWARFDIE>
+  typedef std::multimap<const clang::DeclContext *, std::pair<DWARFCompileUnit *, const DWARFDIE>>
       DeclContextToDIEMap;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *>
+  typedef llvm::DenseMap<std::pair<DWARFCompileUnit *, const DWARFDebugInfoEntry *>, clang::Decl *>
       DIEToDeclMap;
   typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap;
 
   lldb_private::TypeSystemClang &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_up;
   /// @}
 
-  clang::DeclContext *GetDeclContextForBlock(const DWARFDIE &die);
+  clang::DeclContext *GetDeclContextForBlock(DWARFCompileUnit *main_unit, const DWARFDIE &die);
 
-  clang::BlockDecl *ResolveBlockDIE(const DWARFDIE &die);
+  clang::BlockDecl *ResolveBlockDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die);
 
-  clang::NamespaceDecl *ResolveNamespaceDIE(const DWARFDIE &die);
+  clang::NamespaceDecl *ResolveNamespaceDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die);
 
-  bool ParseTemplateDIE(const DWARFDIE &die,
+  bool ParseTemplateDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die,
                         lldb_private::TypeSystemClang::TemplateParameterInfos
                             &template_param_infos);
-  bool ParseTemplateParameterInfos(
+  bool ParseTemplateParameterInfos(DWARFCompileUnit *main_unit,
       const DWARFDIE &parent_die,
       lldb_private::TypeSystemClang::TemplateParameterInfos
           &template_param_infos);
 
-  bool ParseChildMembers(
+  bool ParseChildMembers(lldb_private::CompileUnit *comp_unit,
       const DWARFDIE &die, lldb_private::CompilerType &class_compiler_type,
       const lldb::LanguageType class_language,
       std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
       std::vector<int> &member_accessibilities,
       std::vector<DWARFDIE> &member_function_dies,
       DelayedPropertyList &delayed_properties,
       lldb::AccessType &default_accessibility, bool &is_a_class,
       lldb_private::ClangASTImporter::LayoutInfo &layout_info);
 
   size_t
-  ParseChildParameters(clang::DeclContext *containing_decl_ctx,
+  ParseChildParameters(lldb_private::CompileUnit *comp_unit, clang::DeclContext *containing_decl_ctx,
                        const DWARFDIE &parent_die, bool skip_artificial,
                        bool &is_static, bool &is_variadic,
                        bool &has_template_params,
                        std::vector<lldb_private::CompilerType> &function_args,
                        std::vector<clang::ParmVarDecl *> &function_param_decls,
                        unsigned &type_quals);
 
   size_t ParseChildEnumerators(lldb_private::CompilerType &compiler_type,
                                bool is_signed, uint32_t enumerator_byte_size,
                                const DWARFDIE &parent_die);
 
   /// Parse a structure, class, or union type DIE.
   lldb::TypeSP ParseStructureLikeDIE(const lldb_private::SymbolContext &sc,
                                      const DWARFDIE &die,
                                      ParsedDWARFTypeAttributes &attrs);
 
-  lldb_private::Type *GetTypeForDIE(const DWARFDIE &die);
+  lldb_private::Type *GetTypeForDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die);
 
-  clang::Decl *GetClangDeclForDIE(const DWARFDIE &die);
+  clang::Decl *GetClangDeclForDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die);
 
-  clang::DeclContext *GetClangDeclContextForDIE(const DWARFDIE &die);
+  clang::DeclContext *GetClangDeclContextForDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die);
 
-  clang::DeclContext *GetClangDeclContextContainingDIE(const DWARFDIE &die,
+  clang::DeclContext *GetClangDeclContextContainingDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die,
                                                        DWARFDIE *decl_ctx_die);
 
-  bool CopyUniqueClassMethodTypes(const DWARFDIE &src_class_die,
+  bool CopyUniqueClassMethodTypes(DWARFCompileUnit *main_unit, const DWARFDIE &src_class_die,
                                   const DWARFDIE &dst_class_die,
                                   lldb_private::Type *class_type,
                                   std::vector<DWARFDIE> &failures);
 
-  clang::DeclContext *GetCachedClangDeclContextForDIE(const DWARFDIE &die);
+  clang::DeclContext *GetCachedClangDeclContextForDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die);
 
-  void LinkDeclContextToDIE(clang::DeclContext *decl_ctx, const DWARFDIE &die);
+  void LinkDeclContextToDIE(clang::DeclContext *decl_ctx, DWARFCompileUnit *main_unit, const DWARFDIE &die);
 
   void LinkDeclToDIE(clang::Decl *decl, const DWARFDIE &die);
 
   /// If \p type_sp is valid, calculate and set its symbol context scope, and
   /// update the type list for its backing symbol file.
   ///
   /// Returns \p type_sp.
   lldb::TypeSP
struct FieldInfo {
     bool NextBitfieldOffsetIsValid(const uint64_t next_bit_offset) const {
       // Any subsequent bitfields must not overlap and must be at a higher
       // bit offset than any previous bitfield + size.
       return (bit_size + bit_offset) <= next_bit_offset;
     }
   };
 
   void
-  ParseSingleMember(const DWARFDIE &die, const DWARFDIE &parent_die,
+  ParseSingleMember(lldb_private::CompileUnit *comp_unit, const DWARFDIE &die, const DWARFDIE &parent_die,
                     lldb_private::CompilerType &class_clang_type,
                     const lldb::LanguageType class_language,
                     std::vector<int> &member_accessibilities,
                     lldb::AccessType &default_accessibility,
                     DelayedPropertyList &delayed_properties,
                     lldb_private::ClangASTImporter::LayoutInfo &layout_info,
                     FieldInfo &last_field_info);
 
   bool CompleteRecordType(const DWARFDIE &die, lldb_private::Type *type,
                           lldb_private::CompilerType &clang_type);
   bool CompleteEnumType(const DWARFDIE &die, lldb_private::Type *type,
                         lldb_private::CompilerType &clang_type);
 
   lldb::TypeSP ParseTypeModifier(const lldb_private::SymbolContext &sc,
                                  const DWARFDIE &die,
                                  ParsedDWARFTypeAttributes &attrs);
   lldb::TypeSP ParseEnum(const lldb_private::SymbolContext &sc,
                          const DWARFDIE &die, ParsedDWARFTypeAttributes &attrs);
-  lldb::TypeSP ParseSubroutine(const DWARFDIE &die,
+  lldb::TypeSP ParseSubroutine(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
                                ParsedDWARFTypeAttributes &attrs);
   // FIXME: attrs should be passed as a const reference.
-  lldb::TypeSP ParseArrayType(const DWARFDIE &die,
+  lldb::TypeSP ParseArrayType(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
                               ParsedDWARFTypeAttributes &attrs);
-  lldb::TypeSP ParsePointerToMemberType(const DWARFDIE &die,
+  lldb::TypeSP ParsePointerToMemberType(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
                                         const ParsedDWARFTypeAttributes &attrs);
 };
 
 /// Parsed form of all attributes that are relevant for type reconstruction.
 /// Some attributes are relevant for all kinds of types (declaration), while
 /// others are only meaningful to a specific type (is_virtual)
 struct ParsedDWARFTypeAttributes {
   explicit ParsedDWARFTypeAttributes(const DWARFDIE &die);

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

 //===-- DWARFASTParserClang.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdlib.h>
 
 #include "DWARFASTParserClang.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDeclContext.h"
 #include "DWARFDefines.h"
+#include "DWARFCompileUnit.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "UniqueDWARFASTType.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangASTImporter.h"
 #include "Plugins/ExpressionParser/Clang/ClangASTMetadata.h"
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
TypeSP DWARFASTParserClang::ParseTypeFromClangModule(const SymbolContext &sc,
   // Type::ResolveClangType() effectively ignores the ResolveState
   // inside type_sp and only looks at IsDefined(), so it never calls
   // ClangASTImporter::ASTImporterDelegate::ImportDefinitionTo(),
   // which does extra work for Objective-C classes. This would result
   // in only the forward declaration to be visible.
   if (pcm_type.IsDefined())
     GetClangASTImporter().RequireCompleteType(ClangUtil::GetQualType(type));
 
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(sc.module_sp->GetSymbolFile());
+  DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(sc.comp_unit);
   TypeSP type_sp(new Type(
-      die.GetID(), dwarf, pcm_type_sp->GetName(), pcm_type_sp->GetByteSize(),
-      nullptr, LLDB_INVALID_UID, Type::eEncodingInvalid,
+      die.GetID(main_unit), dwarf, pcm_type_sp->GetName(), pcm_type_sp->GetByteSize(),
+      sc.comp_unit, LLDB_INVALID_UID, Type::eEncodingInvalid,
       &pcm_type_sp->GetDeclaration(), type, Type::ResolveState::Forward));
 
   dwarf->GetTypeList().Insert(type_sp);
-  dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+  dwarf->GetDIEToType()[die.MainCUtoDIEPair(main_unit)] = type_sp.get();
   clang::TagDecl *tag_decl = TypeSystemClang::GetAsTagDecl(type);
   if (tag_decl)
-    LinkDeclContextToDIE(tag_decl, die);
+    LinkDeclContextToDIE(tag_decl, main_unit, die);
   else {
-    clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(die);
+    clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(main_unit, die);
     if (defn_decl_ctx)
-      LinkDeclContextToDIE(defn_decl_ctx, die);
+      LinkDeclContextToDIE(defn_decl_ctx, main_unit, die);
   }
 
   return type_sp;
 }
 
 static void CompleteExternalTagDeclType(TypeSystemClang &ast,
                                         ClangASTImporter &ast_importer,
                                         clang::DeclContext *decl_ctx,
if (type_is_new_ptr)
     *type_is_new_ptr = false;
 
   if (!die)
     return nullptr;
 
   Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                         DWARF_LOG_LOOKUPS));
 
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(sc.module_sp->GetSymbolFile());
+  DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(sc.comp_unit);
   if (log) {
     DWARFDIE context_die;
     clang::DeclContext *context =
-        GetClangDeclContextContainingDIE(die, &context_die);
+        GetClangDeclContextContainingDIE(main_unit, die, &context_die);
 
     dwarf->GetObjectFile()->GetModule()->LogMessage(
         log,
         "DWARFASTParserClang::ParseTypeFromDWARF "
         "(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.MainCUtoDIEPair(main_unit));
   if (type_ptr == DIE_IS_BEING_PARSED)
     return nullptr;
   if (type_ptr)
     return type_ptr->shared_from_this();
   // Set a bit that lets us know that we are currently parsing this
-  dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
+  dwarf->GetDIEToType()[die.MainCUtoDIEPair(main_unit)] = DIE_IS_BEING_PARSED;
 
   ParsedDWARFTypeAttributes attrs(die);
 
   if (DWARFDIE signature_die = attrs.signature.Reference()) {
     if (TypeSP type_sp =
             ParseTypeFromDWARF(sc, signature_die, type_is_new_ptr)) {
-      dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+      dwarf->GetDIEToType()[die.MainCUtoDIEPair(main_unit)] = type_sp.get();
       if (clang::DeclContext *decl_ctx =
-              GetCachedClangDeclContextForDIE(signature_die))
-        LinkDeclContextToDIE(decl_ctx, die);
+              GetCachedClangDeclContextForDIE(main_unit, signature_die))
+        LinkDeclContextToDIE(decl_ctx, main_unit, die);
       return type_sp;
     }
     return nullptr;
   }
 
   if (type_is_new_ptr)
     *type_is_new_ptr = true;
 
TypeSP DWARFASTParserClang::ParseTypeFromDWARF(const SymbolContext &sc,
   case DW_TAG_enumeration_type: {
     type_sp = ParseEnum(sc, die, attrs);
     break;
   }
 
   case DW_TAG_inlined_subroutine:
   case DW_TAG_subprogram:
   case DW_TAG_subroutine_type: {
-    type_sp = ParseSubroutine(die, attrs);
+    type_sp = ParseSubroutine(sc, die, attrs);
     break;
   }
   case DW_TAG_array_type: {
-    type_sp = ParseArrayType(die, attrs);
+    type_sp = ParseArrayType(sc, die, attrs);
     break;
   }
   case DW_TAG_ptr_to_member_type: {
-    type_sp = ParsePointerToMemberType(die, attrs);
+    type_sp = ParsePointerToMemberType(sc, die, attrs);
     break;
   }
   default:
     dwarf->GetObjectFile()->GetModule()->ReportError(
         "{0x%8.8x}: unhandled type tag 0x%4.4x (%s), please file a bug and "
         "attach the file at the start of this error message",
         die.GetOffset(), tag, DW_TAG_value_to_name(tag));
     break;
   }
 
   // TODO: We should consider making the switch above exhaustive to simplify
   // control flow in ParseTypeFromDWARF. Then, we could simply replace this
   // return statement with a call to llvm_unreachable.
   return UpdateSymbolContextScopeForType(sc, die, type_sp);
 }
 
 lldb::TypeSP
 DWARFASTParserClang::ParseTypeModifier(const SymbolContext &sc,
                                        const DWARFDIE &die,
                                        ParsedDWARFTypeAttributes &attrs) {
   Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                         DWARF_LOG_LOOKUPS));
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(sc.module_sp->GetSymbolFile());
+  DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(sc.comp_unit);
   const dw_tag_t tag = die.Tag();
-  LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
+  LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.MainDWARFUnit(main_unit));
   Type::ResolveState resolve_state = Type::ResolveState::Unresolved;
   Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
   TypeSP type_sp;
   CompilerType clang_type;
 
   if (tag == DW_TAG_typedef && attrs.type.IsValid()) {
     // Try to parse a typedef from the (DWARF embedded in the) Clang
     // module file first as modules can contain typedef'ed
if (cu_language == eLanguageTypeObjC ||
             resolve_state = Type::ResolveState::Full;
           }
         }
       }
     }
   }
 
   type_sp = std::make_shared<Type>(
-      die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
-      dwarf->GetUID(attrs.type.Reference()), encoding_data_type, &attrs.decl,
+      die.GetID(main_unit), dwarf, attrs.name, attrs.byte_size, sc.comp_unit,
+      dwarf->GetUID(main_unit, attrs.type.Reference()), encoding_data_type, &attrs.decl,
       clang_type, resolve_state);
 
-  dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+  dwarf->GetDIEToType()[die.MainCUtoDIEPair(main_unit)] = type_sp.get();
   return type_sp;
 }
 
 TypeSP DWARFASTParserClang::ParseEnum(const SymbolContext &sc,
                                       const DWARFDIE &die,
                                       ParsedDWARFTypeAttributes &attrs) {
   Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                         DWARF_LOG_LOOKUPS));
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(sc.module_sp->GetSymbolFile());
   const dw_tag_t tag = die.Tag();
   TypeSP type_sp;
 
+  DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(sc.comp_unit);
   if (attrs.is_forward_declaration) {
     type_sp = ParseTypeFromClangModule(sc, die, log);
     if (type_sp)
       return type_sp;
 
     DWARFDeclContext die_decl_ctx = SymbolFileDWARF::GetDWARFDeclContext(die);
 
     type_sp = dwarf->FindDefinitionTypeForDWARFDeclContext(die_decl_ctx);
if (type_sp) {
             static_cast<void *>(this), die.GetOffset(),
             DW_TAG_value_to_name(tag), attrs.name.GetCString(),
             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()[die.MainCUtoDIEPair(main_unit)] = type_sp.get();
       clang::DeclContext *defn_decl_ctx =
-          GetCachedClangDeclContextForDIE(dwarf->GetDIE(type_sp->GetID()));
+          GetCachedClangDeclContextForDIE(main_unit, dwarf->GetDIE(type_sp->GetID()));
       if (defn_decl_ctx)
-        LinkDeclContextToDIE(defn_decl_ctx, die);
+        LinkDeclContextToDIE(defn_decl_ctx, main_unit, 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;
   CompilerType clang_type;
   clang_type.SetCompilerType(
-      &m_ast, dwarf->GetForwardDeclDieToClangType().lookup(die.GetDIE()));
+      &m_ast, dwarf->GetForwardDeclDieToClangType().lookup(die.MainCUtoDIEPair(main_unit)));
   if (!clang_type) {
     if (attrs.type.IsValid()) {
       Type *enumerator_type =
-          dwarf->ResolveTypeUID(attrs.type.Reference(), true);
+          dwarf->ResolveTypeUID(main_unit, attrs.type.Reference(), true);
       if (enumerator_type)
         enumerator_clang_type = enumerator_type->GetFullCompilerType();
     }
 
     if (!enumerator_clang_type) {
       if (attrs.byte_size) {
         enumerator_clang_type = m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize(
             "", DW_ATE_signed, *attrs.byte_size * 8);
       } else {
         enumerator_clang_type = m_ast.GetBasicType(eBasicTypeInt);
       }
     }
 
     clang_type = m_ast.CreateEnumerationType(
-        attrs.name.GetCString(), GetClangDeclContextContainingDIE(die, nullptr),
+        attrs.name.GetCString(), GetClangDeclContextContainingDIE(main_unit, die, nullptr),
         attrs.decl, enumerator_clang_type, attrs.is_scoped_enum);
   } else {
     enumerator_clang_type = m_ast.GetEnumerationIntegerType(clang_type);
   }
 
-  LinkDeclContextToDIE(TypeSystemClang::GetDeclContextForType(clang_type), die);
+  LinkDeclContextToDIE(TypeSystemClang::GetDeclContextForType(clang_type), main_unit, die);
 
   type_sp = std::make_shared<Type>(
-      die.GetID(), dwarf, attrs.name, attrs.byte_size, nullptr,
-      dwarf->GetUID(attrs.type.Reference()), Type::eEncodingIsUID, &attrs.decl,
+      die.GetID(main_unit), dwarf, attrs.name, attrs.byte_size, sc.comp_unit,
+      dwarf->GetUID(main_unit, attrs.type.Reference()), Type::eEncodingIsUID, &attrs.decl,
       clang_type, Type::ResolveState::Forward);
 
   if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
     if (die.HasChildren()) {
       bool is_signed = false;
       enumerator_clang_type.IsIntegerType(is_signed);
       ParseChildEnumerators(clang_type, is_signed,
                             type_sp->GetByteSize().getValueOr(0), die);
     }
     TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
   } else {
     dwarf->GetObjectFile()->GetModule()->ReportError(
         "DWARF DIE at 0x%8.8x named \"%s\" was not able to start its "
         "definition.\nPlease file a bug and attach the file at the "
         "start of this error message",
         die.GetOffset(), attrs.name.GetCString());
   }
   return type_sp;
 }
 
-TypeSP DWARFASTParserClang::ParseSubroutine(const DWARFDIE &die,
+TypeSP DWARFASTParserClang::ParseSubroutine(const SymbolContext &sc, const DWARFDIE &die,
                            ParsedDWARFTypeAttributes &attrs) {
   Log *log(LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
                                         DWARF_LOG_LOOKUPS));
 
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(sc.module_sp->GetSymbolFile());
+  DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(sc.comp_unit);
   const dw_tag_t tag = die.Tag();
 
   bool is_variadic = false;
   bool is_static = false;
   bool has_template_params = false;
 
   unsigned type_quals = 0;
 
   std::string object_pointer_name;
   if (attrs.object_pointer) {
     const char *object_pointer_name_cstr = attrs.object_pointer.GetName();
     if (object_pointer_name_cstr)
       object_pointer_name = object_pointer_name_cstr;
   }
 
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                DW_TAG_value_to_name(tag), type_name_cstr);
 
   CompilerType return_clang_type;
   Type *func_type = NULL;
 
   if (attrs.type.IsValid())
-    func_type = dwarf->ResolveTypeUID(attrs.type.Reference(), true);
+    func_type = dwarf->ResolveTypeUID(main_unit, attrs.type.Reference(), true);
 
   if (func_type)
     return_clang_type = func_type->GetForwardCompilerType();
   else
     return_clang_type = m_ast.GetBasicType(eBasicTypeVoid);
 
   std::vector<CompilerType> function_param_types;
   std::vector<clang::ParmVarDecl *> function_param_decls;
 
   // Parse the function children for the parameters
 
   DWARFDIE decl_ctx_die;
   clang::DeclContext *containing_decl_ctx =
-      GetClangDeclContextContainingDIE(die, &decl_ctx_die);
+      GetClangDeclContextContainingDIE(main_unit, die, &decl_ctx_die);
   const clang::Decl::Kind containing_decl_kind =
       containing_decl_ctx->getDeclKind();
 
   bool is_cxx_method = DeclKindIsCXXClass(containing_decl_kind);
   // Start off static. This will be set to false in
   // ParseChildParameters(...) if we find a "this" parameters as the
   // first parameter
   if (is_cxx_method) {
     is_static = true;
   }
 
   if (die.HasChildren()) {
     bool skip_artificial = true;
-    ParseChildParameters(containing_decl_ctx, die, skip_artificial, is_static,
+    ParseChildParameters(sc.comp_unit, containing_decl_ctx, die, skip_artificial, is_static,
                          is_variadic, has_template_params,
                          function_param_types, function_param_decls,
                          type_quals);
   }
 
   bool ignore_containing_context = false;
   // Check for templatized class member functions. If we had any
   // DW_TAG_template_type_parameter or DW_TAG_template_value_parameter
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
 
           clang::ObjCMethodDecl *objc_method_decl =
               m_ast.AddMethodToObjCObjectType(
                   class_opaque_type, attrs.name.GetCString(), clang_type,
                   attrs.accessibility, attrs.is_artificial, is_variadic,
                   attrs.is_objc_direct_call);
           type_handled = objc_method_decl != NULL;
           if (type_handled) {
-            LinkDeclContextToDIE(objc_method_decl, die);
-            m_ast.SetMetadataAsUserID(objc_method_decl, die.GetID());
+            LinkDeclContextToDIE(objc_method_decl, main_unit, die);
+            m_ast.SetMetadataAsUserID(objc_method_decl, die.GetID(main_unit));
           } else {
             dwarf->GetObjectFile()->GetModule()->ReportError(
                 "{0x%8.8x}: invalid Objective-C method 0x%4.4x (%s), "
                 "please file a bug and attach the file at the start of "
                 "this error message",
                 die.GetOffset(), tag, DW_TAG_value_to_name(tag));
           }
         }
       } else if (is_cxx_method) {
         // Look at the parent of this DIE and see if is is a class or
         // struct and see if this is actually a C++ method
-        Type *class_type = dwarf->ResolveType(decl_ctx_die);
+        Type *class_type = dwarf->ResolveType(main_unit, decl_ctx_die);
         if (class_type) {
           bool alternate_defn = false;
-          if (class_type->GetID() != decl_ctx_die.GetID() ||
+          if (class_type->GetID() != decl_ctx_die.GetID(main_unit) ||
               IsClangModuleFwdDecl(decl_ctx_die)) {
             alternate_defn = true;
 
             // We uniqued the parent class of this function to another
             // class so we now need to associate all dies under
             // "decl_ctx_die" to DIEs in the DIE for "class_type"...
             DWARFDIE class_type_die = dwarf->GetDIE(class_type->GetID());
 
             if (class_type_die) {
               std::vector<DWARFDIE> failures;
 
-              CopyUniqueClassMethodTypes(decl_ctx_die, class_type_die,
+              CopyUniqueClassMethodTypes(main_unit, decl_ctx_die, class_type_die,
                                          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 *type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
+              Type *type_ptr = dwarf->GetDIEToType()[die.MainCUtoDIEPair(main_unit)];
               if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {
                 return type_ptr->shared_from_this();
               }
             }
           }
 
           if (attrs.specification.IsValid()) {
             // We have a specification which we are going to base our
             // function prototype off of, so we need this type to be
             // completed so that the m_die_to_decl_ctx for the method in
             // the specification has a valid clang decl context.
             class_type->GetForwardCompilerType();
             // If we have a specification, then the function type should
             // have been made with the specification and not with this
             // die.
             DWARFDIE spec_die = attrs.specification.Reference();
             clang::DeclContext *spec_clang_decl_ctx =
-                GetClangDeclContextForDIE(spec_die);
+                GetClangDeclContextForDIE(main_unit, spec_die);
             if (spec_clang_decl_ctx) {
-              LinkDeclContextToDIE(spec_clang_decl_ctx, die);
+              LinkDeclContextToDIE(spec_clang_decl_ctx, main_unit, die);
             } else {
               dwarf->GetObjectFile()->GetModule()->ReportWarning(
                   "0x%8.8" PRIx64 ": DW_AT_specification(0x%8.8x"
                   ") has no decl\n",
-                  die.GetID(), spec_die.GetOffset());
+                  die.GetID(main_unit), spec_die.GetOffset());
             }
             type_handled = true;
           } else if (attrs.abstract_origin.IsValid()) {
             // We have a specification which we are going to base our
             // function prototype off of, so we need this type to be
             // completed so that the m_die_to_decl_ctx for the method in
             // the abstract origin has a valid clang decl context.
             class_type->GetForwardCompilerType();
 
             DWARFDIE abs_die = attrs.abstract_origin.Reference();
             clang::DeclContext *abs_clang_decl_ctx =
-                GetClangDeclContextForDIE(abs_die);
+                GetClangDeclContextForDIE(main_unit, abs_die);
             if (abs_clang_decl_ctx) {
-              LinkDeclContextToDIE(abs_clang_decl_ctx, die);
+              LinkDeclContextToDIE(abs_clang_decl_ctx, main_unit, die);
             } else {
               dwarf->GetObjectFile()->GetModule()->ReportWarning(
                   "0x%8.8" PRIx64 ": DW_AT_abstract_origin(0x%8.8x"
                   ") has no decl\n",
-                  die.GetID(), abs_die.GetOffset());
+                  die.GetID(main_unit), abs_die.GetOffset());
             }
             type_handled = true;
           } else {
             CompilerType class_opaque_type =
                 class_type->GetForwardCompilerType();
             if (TypeSystemClang::IsCXXClassType(class_opaque_type)) {
               if (class_opaque_type.IsBeingDefined() || alternate_defn) {
                 if (!is_static && !die.HasChildren()) {
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                            method_iter != record_decl->method_end();
                            method_iter++) {
                         clang::CXXMethodDecl *method_decl = *method_iter;
                         if (method_decl->getNameInfo().getAsString() ==
                             attrs.name.GetStringRef()) {
                           if (method_decl->getType() ==
                               ClangUtil::GetQualType(clang_type)) {
                             add_method = false;
-                            LinkDeclContextToDIE(method_decl, die);
+                            LinkDeclContextToDIE(method_decl, main_unit, die);
                             type_handled = true;
 
                             break;
                           }
                         }
                       }
                     }
                   }
 
                   if (add_method) {
                     llvm::PrettyStackTraceFormat stack_trace(
                         "SymbolFileDWARF::ParseType() is adding a method "
                         "%s to class %s in DIE 0x%8.8" PRIx64 " from %s",
                         attrs.name.GetCString(),
-                        class_type->GetName().GetCString(), die.GetID(),
+                        class_type->GetName().GetCString(), die.GetID(main_unit),
                         dwarf->GetObjectFile()
                             ->GetFileSpec()
                             .GetPath()
                             .c_str());
 
                     const bool is_attr_used = false;
                     // Neither GCC 4.2 nor clang++ currently set a valid
                     // accessibility in the DWARF for C++ methods...
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                             is_attr_used, attrs.is_artificial);
 
                     type_handled = cxx_method_decl != NULL;
                     // Artificial methods are always handled even when we
                     // don't create a new declaration for them.
                     type_handled |= attrs.is_artificial;
 
                     if (cxx_method_decl) {
-                      LinkDeclContextToDIE(cxx_method_decl, die);
+                      LinkDeclContextToDIE(cxx_method_decl, main_unit, die);
 
                       ClangASTMetadata metadata;
-                      metadata.SetUserID(die.GetID());
+                      metadata.SetUserID(die.GetID(main_unit));
 
                       if (!object_pointer_name.empty()) {
                         metadata.SetObjectPtrName(
                             object_pointer_name.c_str());
                         LLDB_LOGF(log,
                                   "Setting object pointer name: %s on method "
                                   "object %p.\n",
                                   object_pointer_name.c_str(),
if (tag == DW_TAG_subprogram || tag == DW_TAG_inlined_subroutine) {
                 // 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()[die.MainCUtoDIEPair(main_unit)] = 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 *type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
+                Type *type_ptr = dwarf->GetDIEToType()[die.MainCUtoDIEPair(main_unit)];
                 if (type_ptr && type_ptr != DIE_IS_BEING_PARSED) {
                   return type_ptr->shared_from_this();
                 }
 
                 // FIXME This is fixing some even uglier behavior but we
                 // really need to
                 // uniq the methods of each class as well as the class
                 // itself. <rdar://problem/11240464>
                 type_handled = true;
               }
             }
           }
         }
       }
     }
 
     if (!type_handled) {
       clang::FunctionDecl *function_decl = nullptr;
       clang::FunctionDecl *template_function_decl = nullptr;
 
       if (attrs.abstract_origin.IsValid()) {
         DWARFDIE abs_die = attrs.abstract_origin.Reference();
 
-        if (dwarf->ResolveType(abs_die)) {
+        if (dwarf->ResolveType(main_unit, abs_die)) {
           function_decl = llvm::dyn_cast_or_null<clang::FunctionDecl>(
-              GetCachedClangDeclContextForDIE(abs_die));
+              GetCachedClangDeclContextForDIE(main_unit, abs_die));
 
           if (function_decl) {
-            LinkDeclContextToDIE(function_decl, die);
+            LinkDeclContextToDIE(function_decl, main_unit, die);
           }
         }
       }
 
       if (!function_decl) {
         const char *name = attrs.name.GetCString();
 
         // We currently generate function templates with template parameters in
         // their name. In order to get closer to the AST that clang generates
         // we want to strip these from the name when creating the AST.
         if (attrs.mangled_name) {
           llvm::ItaniumPartialDemangler D;
           if (!D.partialDemangle(attrs.mangled_name))
             name = D.getFunctionBaseName(nullptr, nullptr);
         }
 
         // We just have a function that isn't part of a class
         function_decl = m_ast.CreateFunctionDeclaration(
             ignore_containing_context ? m_ast.GetTranslationUnitDecl()
                                       : containing_decl_ctx,
             name, clang_type, attrs.storage, attrs.is_inline);
 
         if (has_template_params) {
           TypeSystemClang::TemplateParameterInfos template_param_infos;
-          ParseTemplateParameterInfos(die, template_param_infos);
+          ParseTemplateParameterInfos(main_unit, die, template_param_infos);
           template_function_decl = m_ast.CreateFunctionDeclaration(
               ignore_containing_context ? m_ast.GetTranslationUnitDecl()
                                         : containing_decl_ctx,
               name, clang_type, attrs.storage, attrs.is_inline);
 
           clang::FunctionTemplateDecl *func_template_decl =
               m_ast.CreateFunctionTemplateDecl(containing_decl_ctx,
                                                template_function_decl, name,
                                                template_param_infos);
           m_ast.CreateFunctionTemplateSpecializationInfo(
               template_function_decl, func_template_decl, template_param_infos);
         }
 
         lldbassert(function_decl);
 
         if (function_decl) {
-          LinkDeclContextToDIE(function_decl, die);
+          LinkDeclContextToDIE(function_decl, main_unit, die);
 
           if (!function_param_decls.empty()) {
             m_ast.SetFunctionParameters(function_decl,
                                         &function_param_decls.front(),
                                         function_param_decls.size());
             if (template_function_decl)
               m_ast.SetFunctionParameters(template_function_decl,
                                           &function_param_decls.front(),
                                           function_param_decls.size());
           }
 
           ClangASTMetadata metadata;
-          metadata.SetUserID(die.GetID());
+          metadata.SetUserID(die.GetID(main_unit));
 
           if (!object_pointer_name.empty()) {
             metadata.SetObjectPtrName(object_pointer_name.c_str());
             LLDB_LOGF(log,
                       "Setting object pointer name: %s on function "
                       "object %p.",
                       object_pointer_name.c_str(),
                       static_cast<void *>(function_decl));
           }
           m_ast.SetMetadata(function_decl, metadata);
         }
       }
     }
   }
   return std::make_shared<Type>(
-      die.GetID(), dwarf, attrs.name, llvm::None, nullptr, LLDB_INVALID_UID,
+      die.GetID(main_unit), dwarf, attrs.name, llvm::None, sc.comp_unit, LLDB_INVALID_UID,
       Type::eEncodingIsUID, &attrs.decl, clang_type, Type::ResolveState::Full);
 }
 
-TypeSP DWARFASTParserClang::ParseArrayType(const DWARFDIE &die,
+TypeSP DWARFASTParserClang::ParseArrayType(const SymbolContext &sc, const DWARFDIE &die,
                                            ParsedDWARFTypeAttributes &attrs) {
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(sc.module_sp->GetSymbolFile());
 
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                DW_TAG_value_to_name(tag), type_name_cstr);
 
+  DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(sc.comp_unit);
   DWARFDIE type_die = attrs.type.Reference();
-  Type *element_type = dwarf->ResolveTypeUID(type_die, true);
+  Type *element_type = dwarf->ResolveTypeUID(main_unit, type_die, true);
 
   if (!element_type)
     return nullptr;
 
   llvm::Optional<SymbolFile::ArrayInfo> array_info = ParseChildArrayInfo(die);
   if (array_info) {
     attrs.byte_stride = array_info->byte_stride;
     attrs.bit_stride = array_info->bit_stride;
for (auto pos = array_info->element_orders.rbegin(); pos != end; ++pos) {
                                      : array_element_bit_stride;
     }
   } else {
     clang_type =
         m_ast.CreateArrayType(array_element_type, 0, attrs.is_vector);
   }
   ConstString empty_name;
   TypeSP type_sp = std::make_shared<Type>(
-      die.GetID(), dwarf, empty_name, array_element_bit_stride / 8, nullptr,
-      dwarf->GetUID(type_die), Type::eEncodingIsUID, &attrs.decl, clang_type,
+      die.GetID(main_unit), dwarf, empty_name, array_element_bit_stride / 8, sc.comp_unit,
+      dwarf->GetUID(main_unit, type_die), Type::eEncodingIsUID, &attrs.decl, clang_type,
       Type::ResolveState::Full);
   type_sp->SetEncodingType(element_type);
   const clang::Type *type = ClangUtil::GetQualType(clang_type).getTypePtr();
-  m_ast.SetMetadataAsUserID(type, die.GetID());
+  m_ast.SetMetadataAsUserID(type, die.GetID(main_unit));
   return type_sp;
 }
 
-TypeSP DWARFASTParserClang::ParsePointerToMemberType(
+TypeSP DWARFASTParserClang::ParsePointerToMemberType(const SymbolContext &sc,
     const DWARFDIE &die, const ParsedDWARFTypeAttributes &attrs) {
-  SymbolFileDWARF *dwarf = die.GetDWARF();
-  Type *pointee_type = dwarf->ResolveTypeUID(attrs.type.Reference(), true);
+  SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(sc.module_sp->GetSymbolFile());
+  DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(sc.comp_unit);
+  Type *pointee_type = dwarf->ResolveTypeUID(main_unit, attrs.type.Reference(), true);
   Type *class_type =
-      dwarf->ResolveTypeUID(attrs.containing_type.Reference(), true);
+      dwarf->ResolveTypeUID(main_unit, attrs.containing_type.Reference(), true);
 
   CompilerType pointee_clang_type = pointee_type->GetForwardCompilerType();
   CompilerType class_clang_type = class_type->GetLayoutCompilerType();
 
   CompilerType clang_type = TypeSystemClang::CreateMemberPointerType(
       class_clang_type, pointee_clang_type);
 
   if (llvm::Optional<uint64_t> clang_type_size =
-          clang_type.GetByteSize(nullptr)) {
-    return std::make_shared<Type>(die.GetID(), dwarf, attrs.name,
-                                  *clang_type_size, nullptr, LLDB_INVALID_UID,
+          clang_type.GetByteSize(nullptr))
+    return std::make_shared<Type>(die.GetID(main_unit), dwarf, attrs.name,
+                                  *clang_type_size, sc.comp_unit, LLDB_INVALID_UID,
                                   Type::eEncodingIsUID, nullptr, clang_type,
                                   Type::ResolveState::Forward);
-  }
   return nullptr;
 }
 
 TypeSP DWARFASTParserClang::UpdateSymbolContextScopeForType(
     const SymbolContext &sc, const DWARFDIE &die, TypeSP type_sp) {
   if (!type_sp)
     return type_sp;
 
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(sc.module_sp->GetSymbolFile());
   TypeList &type_list = dwarf->GetTypeList();
   DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die);
   dw_tag_t sc_parent_tag = sc_parent_die.Tag();
 
+  DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(sc.comp_unit);
   SymbolContextScope *symbol_context_scope = nullptr;
   if (sc_parent_tag == DW_TAG_compile_unit ||
       sc_parent_tag == DW_TAG_partial_unit) {
     symbol_context_scope = sc.comp_unit;
   } else if (sc.function != nullptr && sc_parent_die) {
     symbol_context_scope =
-        sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
+        sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID(main_unit));
     if (symbol_context_scope == nullptr)
       symbol_context_scope = sc.function;
   } else {
     symbol_context_scope = sc.module_sp.get();
   }
+  lldbassert(symbol_context_scope);
 
   if (symbol_context_scope != nullptr)
     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()[die.MainCUtoDIEPair(main_unit)] = type_sp.get();
   return type_sp;
 }
 
 TypeSP
 DWARFASTParserClang::ParseStructureLikeDIE(const SymbolContext &sc,
                                            const DWARFDIE &die,
                                            ParsedDWARFTypeAttributes &attrs) {
   TypeSP type_sp;
   CompilerType clang_type;
   const dw_tag_t tag = die.Tag();
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(sc.module_sp->GetSymbolFile());
   LanguageType cu_language = SymbolFileDWARF::GetLanguage(*die.GetCU());
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_TYPE_COMPLETION |
                                           DWARF_LOG_LOOKUPS);
 
   // UniqueDWARFASTType is large, so don't create a local variables on the
   // stack, put it on the heap. This function is often called recursively and
   // clang isn't good at sharing the stack space for variables in different
   // blocks.
if (Language::LanguageIsCPlusPlus(cu_language)) {
       unique_decl.Clear();
     }
 
     if (dwarf->GetUniqueDWARFASTTypeMap().Find(
             unique_typename, die, unique_decl, attrs.byte_size.getValueOr(-1),
             *unique_ast_entry_up)) {
       type_sp = unique_ast_entry_up->m_type_sp;
       if (type_sp) {
-        dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
+        DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(sc.comp_unit);
+        dwarf->GetDIEToType()[die.MainCUtoDIEPair(main_unit)] = type_sp.get();
         LinkDeclContextToDIE(
-            GetCachedClangDeclContextForDIE(unique_ast_entry_up->m_die), die);
+            GetCachedClangDeclContextForDIE(main_unit, unique_ast_entry_up->m_die), main_unit, die);
         return type_sp;
       }
     }
   }
 
   DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                DW_TAG_value_to_name(tag), type_name_cstr);
 
if (attrs.byte_size && *attrs.byte_size == 0 && attrs.name &&
     //  DW_AT_decl_file( "..." )
     //  DW_AT_decl_line( 1 )
     //
     // Note that there is no DW_AT_declaration and there are no children,
     // and the byte size is zero.
     attrs.is_forward_declaration = true;
   }
 
+  DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(sc.comp_unit);
+
   if (attrs.class_language == eLanguageTypeObjC ||
       attrs.class_language == eLanguageTypeObjC_plus_plus) {
     if (!attrs.is_complete_objc_class &&
         die.Supports_DW_AT_APPLE_objc_complete_type()) {
       // We have a valid eSymbolTypeObjCClass class symbol whose name
       // matches the current objective C class that we are trying to find
       // and this DIE isn't the complete definition (we checked
       // is_complete_objc_class above and know it is false), so the real
if (!attrs.is_complete_objc_class &&
               static_cast<void *>(this), die.GetOffset(),
               DW_TAG_value_to_name(tag), attrs.name.GetCString(),
               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()[die.MainCUtoDIEPair(main_unit)] = type_sp.get();
         return type_sp;
       }
     }
   }
 
   if (attrs.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_sp) {
             "forward declaration, complete type is 0x%8.8" PRIx64,
             static_cast<void *>(this), die.GetOffset(),
             DW_TAG_value_to_name(tag), attrs.name.GetCString(),
             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()[die.MainCUtoDIEPair(main_unit)] = type_sp.get();
+      DWARFCompileUnit *main_unit;
+      DWARFDIE die = dwarf->GetDIEUnlocked(type_sp->GetID(), &main_unit);
       clang::DeclContext *defn_decl_ctx =
-          GetCachedClangDeclContextForDIE(dwarf->GetDIE(type_sp->GetID()));
+          GetCachedClangDeclContextForDIE(main_unit, die);
       if (defn_decl_ctx)
-        LinkDeclContextToDIE(defn_decl_ctx, die);
+        LinkDeclContextToDIE(defn_decl_ctx, main_unit, 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.MainCUtoDIEPair(main_unit)));
   if (!clang_type) {
     clang::DeclContext *decl_ctx =
-        GetClangDeclContextContainingDIE(die, nullptr);
+        GetClangDeclContextContainingDIE(main_unit, 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
     // always contain a full definition of parent types in that case.
     CompleteExternalTagDeclType(m_ast, GetClangASTImporter(), decl_ctx, die,
                                 attrs.name.GetCString());
 
     if (attrs.accessibility == eAccessNone && decl_ctx) {
       // Check the decl context that contains this class/struct/union. If
       // it is a class we must give it an accessibility.
       const clang::Decl::Kind containing_decl_kind = decl_ctx->getDeclKind();
       if (DeclKindIsCXXClass(containing_decl_kind))
         attrs.accessibility = default_accessibility;
     }
 
     ClangASTMetadata metadata;
-    metadata.SetUserID(die.GetID());
+    metadata.SetUserID(die.GetID(main_unit));
     metadata.SetIsDynamicCXXType(dwarf->ClassOrStructIsVirtual(die));
 
     if (attrs.name.GetStringRef().contains('<')) {
       TypeSystemClang::TemplateParameterInfos template_param_infos;
-      if (ParseTemplateParameterInfos(die, template_param_infos)) {
+      if (ParseTemplateParameterInfos(main_unit, die, template_param_infos)) {
         clang::ClassTemplateDecl *class_template_decl =
             m_ast.ParseClassTemplateDecl(decl_ctx, attrs.accessibility,
                                          attrs.name.GetCString(), tag_decl_kind,
                                          template_param_infos);
         if (!class_template_decl) {
           if (log) {
             dwarf->GetObjectFile()->GetModule()->LogMessage(
                 log,
if (!clang_type_was_created) {
           decl_ctx, attrs.accessibility, attrs.name.GetCString(), tag_decl_kind,
           attrs.class_language, &metadata, attrs.exports_symbols);
     }
   }
 
   // Store a forward declaration to this class type in case any
   // parameters in any class methods need it for the clang types for
   // function prototypes.
-  LinkDeclContextToDIE(m_ast.GetDeclContextForType(clang_type), die);
-  type_sp = std::make_shared<Type>(die.GetID(), dwarf, attrs.name,
-                                   attrs.byte_size, nullptr, LLDB_INVALID_UID,
+  LinkDeclContextToDIE(m_ast.GetDeclContextForType(clang_type), main_unit, die);
+  type_sp = std::make_shared<Type>(die.GetID(main_unit), dwarf, attrs.name,
+                                   attrs.byte_size, sc.comp_unit, LLDB_INVALID_UID,
                                    Type::eEncodingIsUID, &attrs.decl,
                                    clang_type, Type::ResolveState::Forward);
 
   type_sp->SetIsCompleteObjCClass(attrs.is_complete_objc_class);
 
   // Add our type to the unique type map so we don't end up creating many
   // copies of the same type over and over in the ASTContext for our
   // module
if (!die.HasChildren()) {
       // needs to be defined.
       assert(!dwarf->GetForwardDeclClangTypeToDie().count(
                  ClangUtil::RemoveFastQualifiers(clang_type)
                      .GetOpaqueQualType()) &&
              "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()] =
+      dwarf->GetForwardDeclDieToClangType()[die.MainCUtoDIEPair(main_unit)] =
           clang_type.GetOpaqueQualType();
       dwarf->GetForwardDeclClangTypeToDie().try_emplace(
           ClangUtil::RemoveFastQualifiers(clang_type).GetOpaqueQualType(),
-          *die.GetDIERef());
+          die.GetID(main_unit));
       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.
private:
   CompilerType m_property_opaque_type;
   clang::ObjCIvarDecl *m_ivar_decl;
   const char *m_property_setter_name;
   const char *m_property_getter_name;
   uint32_t m_property_attributes;
   std::unique_ptr<ClangASTMetadata> m_metadata_up;
 };
 
-bool DWARFASTParserClang::ParseTemplateDIE(
+bool DWARFASTParserClang::ParseTemplateDIE(DWARFCompileUnit *main_unit,
     const DWARFDIE &die,
     TypeSystemClang::TemplateParameterInfos &template_param_infos) {
   const dw_tag_t tag = die.Tag();
   bool is_template_template_argument = false;
 
   switch (tag) {
   case DW_TAG_GNU_template_parameter_pack: {
     template_param_infos.packed_args.reset(
       new TypeSystemClang::TemplateParameterInfos);
     for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
          child_die = child_die.GetSibling()) {
-      if (!ParseTemplateDIE(child_die, *template_param_infos.packed_args))
+      if (!ParseTemplateDIE(main_unit, child_die, *template_param_infos.packed_args))
         return false;
     }
     if (const char *name = die.GetName()) {
       template_param_infos.pack_name = name;
     }
     return true;
   }
   case DW_TAG_GNU_template_template_param:
if (num_attributes > 0) {
 
         case DW_AT_GNU_template_name:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             template_name = form_value.AsCString();
           break;
 
         case DW_AT_type:
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
-            Type *lldb_type = die.ResolveTypeUID(form_value.Reference());
+            Type *lldb_type = die.ResolveTypeUID(main_unit, form_value.Reference());
             if (lldb_type)
               clang_type = lldb_type->GetForwardCompilerType();
           }
           break;
 
         case DW_AT_const_value:
           if (attributes.ExtractFormValueAtIndex(i, form_value)) {
             uval64_valid = true;
case DW_TAG_template_value_parameter: {
     return true;
 
   default:
     break;
   }
   return false;
 }
 
-bool DWARFASTParserClang::ParseTemplateParameterInfos(
+bool DWARFASTParserClang::ParseTemplateParameterInfos(DWARFCompileUnit *main_unit,
     const DWARFDIE &parent_die,
     TypeSystemClang::TemplateParameterInfos &template_param_infos) {
 
   if (!parent_die)
     return false;
 
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     const dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_template_type_parameter:
     case DW_TAG_template_value_parameter:
     case DW_TAG_GNU_template_parameter_pack:
     case DW_TAG_GNU_template_template_param:
-      ParseTemplateDIE(die, template_param_infos);
+      ParseTemplateDIE(main_unit, die, template_param_infos);
       break;
 
     default:
       break;
     }
   }
   if (template_param_infos.args.empty())
     return false;
   return template_param_infos.args.size() == template_param_infos.names.size();
 }
 
 bool DWARFASTParserClang::CompleteRecordType(const DWARFDIE &die,
                                              lldb_private::Type *type,
                                              CompilerType &clang_type) {
   const dw_tag_t tag = die.Tag();
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  CompileUnit *comp_unit = type->GetSymbolContextScope()->CalculateSymbolContextCompileUnit();
+  SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(type->GetSymbolContextScope()->CalculateSymbolContextModule()->GetSymbolFile());
 
   ClangASTImporter::LayoutInfo layout_info;
 
   if (die.HasChildren()) {
     LanguageType class_language = eLanguageTypeUnknown;
     if (TypeSystemClang::IsObjCObjectOrInterfaceType(clang_type)) {
       class_language = eLanguageTypeObjC;
       // For objective C we don't start the definition when the class is
if (tag == DW_TAG_structure_type) {
       default_accessibility = eAccessPrivate;
     }
 
     std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases;
     std::vector<int> member_accessibilities;
     bool is_a_class = false;
     // Parse members and base classes first
     std::vector<DWARFDIE> member_function_dies;
+    DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(comp_unit);
 
     DelayedPropertyList delayed_properties;
-    ParseChildMembers(die, clang_type, class_language, bases,
+    ParseChildMembers(comp_unit, die, clang_type, class_language, bases,
                       member_accessibilities, member_function_dies,
                       delayed_properties, default_accessibility, is_a_class,
                       layout_info);
 
     // Now parse any methods if there were any...
     for (const DWARFDIE &die : member_function_dies)
-      dwarf->ResolveType(die);
+      dwarf->ResolveType(main_unit, die);
 
     if (class_language == eLanguageTypeObjC) {
       ConstString class_name(clang_type.GetTypeName());
       if (class_name) {
-        DIEArray method_die_offsets;
+        std::vector<lldb::user_id_t> method_die_offsets;
         dwarf->GetObjCMethodDIEOffsets(class_name, method_die_offsets);
 
         if (!method_die_offsets.empty()) {
-          DWARFDebugInfo &debug_info = dwarf->DebugInfo();
-
           const size_t num_matches = method_die_offsets.size();
           for (size_t i = 0; i < num_matches; ++i) {
-            const DIERef &die_ref = method_die_offsets[i];
-            DWARFDIE method_die = debug_info.GetDIE(die_ref);
+            user_id_t uid = method_die_offsets[i];
+            DWARFDIE method_die = dwarf->GetDIEUnlocked(uid);
 
             if (method_die)
-              method_die.ResolveType();
+              method_die.ResolveType(main_unit);
           }
         }
 
         for (DelayedPropertyList::iterator pi = delayed_properties.begin(),
                                            pe = delayed_properties.end();
              pi != pe; ++pi)
           pi->Finalize();
       }
if (TypeSystemClang::StartTagDeclarationDefinition(clang_type)) {
     TypeSystemClang::CompleteTagDeclarationDefinition(clang_type);
   }
   return (bool)clang_type;
 }
 
 bool DWARFASTParserClang::CompleteTypeFromDWARF(const DWARFDIE &die,
                                                 lldb_private::Type *type,
                                                 CompilerType &clang_type) {
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(type->GetSymbolContextScope()->CalculateSymbolContextModule()->GetSymbolFile());
 
   std::lock_guard<std::recursive_mutex> guard(
       dwarf->GetObjectFile()->GetModule()->GetMutex());
 
   // Disable external storage for this type so we don't get anymore
   // clang::ExternalASTSource queries for this type.
   m_ast.SetHasExternalStorage(clang_type.GetOpaqueQualType(), false);
 
   if (!die)
     return false;
 
   const dw_tag_t tag = die.Tag();
 
   Log *log =
       nullptr; // (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION));
   if (log)
     dwarf->GetObjectFile()->GetModule()->LogMessageVerboseBacktrace(
         log, "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
-        die.GetID(), die.GetTagAsCString(), type->GetName().AsCString());
+        die.GetID(nullptr), die.GetTagAsCString(), type->GetName().AsCString());
   assert(clang_type);
   DWARFAttributes attributes;
   switch (tag) {
   case DW_TAG_structure_type:
   case DW_TAG_union_type:
   case DW_TAG_class_type:
     return CompleteRecordType(die, type, clang_type);
   case DW_TAG_enumeration_type:
     return CompleteEnumType(die, type, clang_type);
   default:
     assert(false && "not a forward clang type decl!");
     break;
   }
 
   return false;
 }
 
 void DWARFASTParserClang::EnsureAllDIEsInDeclContextHaveBeenParsed(
     lldb_private::CompilerDeclContext decl_context) {
   auto opaque_decl_ctx =
       (clang::DeclContext *)decl_context.GetOpaqueDeclContext();
   for (auto it = m_decl_ctx_to_die.find(opaque_decl_ctx);
        it != m_decl_ctx_to_die.end() && it->first == opaque_decl_ctx;
-       it = m_decl_ctx_to_die.erase(it))
-    for (DWARFDIE decl = it->second.GetFirstChild(); decl;
+       it = m_decl_ctx_to_die.erase(it)) {
+    DWARFCompileUnit *main_unit = it->second.first;
+    for (DWARFDIE decl = it->second.second.GetFirstChild(); decl;
          decl = decl.GetSibling())
-      GetClangDeclForDIE(decl);
+      GetClangDeclForDIE(main_unit, decl);
+  }
 }
 
-CompilerDecl DWARFASTParserClang::GetDeclForUIDFromDWARF(const DWARFDIE &die) {
-  clang::Decl *clang_decl = GetClangDeclForDIE(die);
+CompilerDecl DWARFASTParserClang::GetDeclForUIDFromDWARF(DWARFCompileUnit *main_unit, const DWARFDIE &die) {
+  clang::Decl *clang_decl = GetClangDeclForDIE(main_unit, die);
   if (clang_decl != nullptr)
     return m_ast.GetCompilerDecl(clang_decl);
   return CompilerDecl();
 }
 
 CompilerDeclContext
-DWARFASTParserClang::GetDeclContextForUIDFromDWARF(const DWARFDIE &die) {
-  clang::DeclContext *clang_decl_ctx = GetClangDeclContextForDIE(die);
+DWARFASTParserClang::GetDeclContextForUIDFromDWARF(DWARFCompileUnit *main_unit, const DWARFDIE &die) {
+  clang::DeclContext *clang_decl_ctx = GetClangDeclContextForDIE(main_unit, die);
   if (clang_decl_ctx)
     return m_ast.CreateDeclContext(clang_decl_ctx);
   return CompilerDeclContext();
 }
 
 CompilerDeclContext
-DWARFASTParserClang::GetDeclContextContainingUIDFromDWARF(const DWARFDIE &die) {
+DWARFASTParserClang::GetDeclContextContainingUIDFromDWARF(DWARFCompileUnit *main_unit, const DWARFDIE &die) {
   clang::DeclContext *clang_decl_ctx =
-      GetClangDeclContextContainingDIE(die, nullptr);
+      GetClangDeclContextContainingDIE(main_unit, die, nullptr);
   if (clang_decl_ctx)
     return m_ast.CreateDeclContext(clang_decl_ctx);
   return CompilerDeclContext();
 }
 
 size_t DWARFASTParserClang::ParseChildEnumerators(
     lldb_private::CompilerType &clang_type, bool is_signed,
     uint32_t enumerator_byte_size, const DWARFDIE &parent_die) {
if (lowest_func_addr != LLDB_INVALID_ADDRESS &&
       ModuleSP module_sp(die.GetModule());
       func_range.GetBaseAddress().ResolveAddressUsingFileSections(
           lowest_func_addr, module_sp->GetSectionList());
       if (func_range.GetBaseAddress().IsValid())
         func_range.SetByteSize(highest_func_addr - lowest_func_addr);
     }
 
     if (func_range.GetBaseAddress().IsValid()) {
+      SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(comp_unit.GetModule()->GetSymbolFile());
+      DWARFCompileUnit *main_unit = dwarf->GetDWARFCompileUnit(&comp_unit);
       Mangled func_name;
       if (mangled)
         func_name.SetValue(ConstString(mangled), true);
       else if ((die.GetParent().Tag() == DW_TAG_compile_unit ||
                 die.GetParent().Tag() == DW_TAG_partial_unit) &&
                Language::LanguageIsCPlusPlus(
                    SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
                !Language::LanguageIsObjC(
if (func_range.GetBaseAddress().IsValid()) {
         std::vector<CompilerType> param_types;
         std::vector<clang::ParmVarDecl *> param_decls;
         StreamString sstr;
 
         DWARFDeclContext decl_ctx = SymbolFileDWARF::GetDWARFDeclContext(die);
         sstr << decl_ctx.GetQualifiedName();
 
         clang::DeclContext *containing_decl_ctx =
-            GetClangDeclContextContainingDIE(die, nullptr);
-        ParseChildParameters(containing_decl_ctx, die, true, is_static,
+            GetClangDeclContextContainingDIE(main_unit, die, nullptr);
+        ParseChildParameters(&comp_unit, containing_decl_ctx, die, true, is_static,
                              is_variadic, has_template_params, param_types,
                              param_decls, type_quals);
         sstr << "(";
         for (size_t i = 0; i < param_types.size(); i++) {
           if (i > 0)
             sstr << ", ";
           sstr << param_types[i].GetTypeName();
         }
         if (is_variadic)
           sstr << ", ...";
         sstr << ")";
         if (type_quals & clang::Qualifiers::Const)
           sstr << " const";
 
         func_name.SetValue(ConstString(sstr.GetString()), false);
       } else
         func_name.SetValue(ConstString(name), false);
 
       FunctionSP func_sp;
       std::unique_ptr<Declaration> decl_up;
       if (decl_file != 0 || decl_line != 0 || decl_column != 0)
         decl_up.reset(new Declaration(die.GetCU()->GetFile(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.MainCUtoDIEPair(main_unit));
 
       assert(func_type == nullptr || func_type != DIE_IS_BEING_PARSED);
 
       if (dwarf->FixupAddress(func_range.GetBaseAddress())) {
-        const user_id_t func_user_id = die.GetID();
+        const user_id_t func_user_id = die.GetID(main_unit);
         func_sp =
             std::make_shared<Function>(&comp_unit,
                                    func_user_id, // UserID is the DIE offset
                                    func_user_id, func_name, func_type,
                                        func_range); // first address range
 
         if (func_sp.get() != nullptr) {
           if (frame_base.IsValid())
             func_sp->GetFrameBaseExpression() = frame_base;
           comp_unit.AddFunction(func_sp);
           return func_sp.get();
         }
       }
     }
   }
   return nullptr;
 }
 
-void DWARFASTParserClang::ParseSingleMember(
+void DWARFASTParserClang::ParseSingleMember(CompileUnit *comp_unit,
     const DWARFDIE &die, const DWARFDIE &parent_die,
     lldb_private::CompilerType &class_clang_type,
     const lldb::LanguageType class_language,
     std::vector<int> &member_accessibilities,
     lldb::AccessType &default_accessibility,
     DelayedPropertyList &delayed_properties,
     lldb_private::ClangASTImporter::LayoutInfo &layout_info,
     FieldInfo &last_field_info) {
if (byte_size.getValueOr(0) == 0 && bit_offset < 0) {
       bit_offset = 0;
     }
 
     // FIXME: Make Clang ignore Objective-C accessibility for expressions
     if (class_language == eLanguageTypeObjC ||
         class_language == eLanguageTypeObjC_plus_plus)
       accessibility = eAccessNone;
 
+    DWARFCompileUnit *main_unit = nullptr;
+    if (comp_unit) {
+      SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(comp_unit->GetModule()->GetSymbolFile());
+      main_unit = dwarf->GetDWARFCompileUnit(comp_unit);
+    }
     // Handle static members
     if (is_external && member_byte_offset == UINT32_MAX) {
-      Type *var_type = die.ResolveTypeUID(encoding_form.Reference());
+      Type *var_type = die.ResolveTypeUID(main_unit, encoding_form.Reference());
 
       if (var_type) {
         if (accessibility == eAccessNone)
           accessibility = eAccessPublic;
         TypeSystemClang::AddVariableToRecordType(
             class_clang_type, name, var_type->GetLayoutCompilerType(),
             accessibility);
       }
       return;
     }
 
     if (!is_artificial) {
-      Type *member_type = die.ResolveTypeUID(encoding_form.Reference());
+      Type *member_type = die.ResolveTypeUID(main_unit, encoding_form.Reference());
 
       clang::FieldDecl *field_decl = nullptr;
       const uint64_t character_width = 8;
       const uint64_t word_width = 32;
       if (tag == DW_TAG_member) {
         if (member_type) {
           CompilerType member_clang_type = member_type->GetLayoutCompilerType();
 
if (!is_artificial) {
                  !last_field_info.NextBitfieldOffsetIsValid(
                      this_field_info.bit_offset))) {
               ObjectFile *objfile = die.GetDWARF()->GetObjectFile();
               objfile->GetModule()->ReportWarning(
                   "0x%8.8" PRIx64 ": %s bitfield named \"%s\" has invalid "
                   "bit offset (0x%8.8" PRIx64
                   ") member will be ignored. Please file a bug against the "
                   "compiler and include the preprocessed output for %s\n",
-                  die.GetID(), DW_TAG_value_to_name(tag), name,
+                  die.GetID(main_unit), DW_TAG_value_to_name(tag), name,
                   this_field_info.bit_offset, GetUnitName(parent_die).c_str());
               return;
             }
 
             // Update the field bit offset we will report for layout
             field_bit_offset = this_field_info.bit_offset;
 
             // Objective-C has invalid DW_AT_bit_offset values in older
if (!is_artificial) {
               if (member_byte_offset >= parent_byte_size) {
                 if (member_array_size != 1 &&
                     (member_array_size != 0 ||
                      member_byte_offset > parent_byte_size)) {
                   module_sp->ReportError(
                       "0x%8.8" PRIx64
                       ": DW_TAG_member '%s' refers to type 0x%8.8x"
                       " which extends beyond the bounds of 0x%8.8" PRIx64,
-                      die.GetID(), name, encoding_form.Reference().GetOffset(),
-                      parent_die.GetID());
+                      die.GetID(main_unit), name, encoding_form.Reference().GetOffset(),
+                      parent_die.GetID(main_unit));
                 }
 
                 member_clang_type =
                     m_ast.CreateArrayType(member_array_element_type, 0, false);
               }
             }
           }
 
if (!is_artificial) {
                   name);
             }
           }
 
           field_decl = TypeSystemClang::AddFieldToRecordType(
               class_clang_type, name, member_clang_type, accessibility,
               bit_size);
 
-          m_ast.SetMetadataAsUserID(field_decl, die.GetID());
+          m_ast.SetMetadataAsUserID(field_decl, die.GetID(main_unit));
 
           layout_info.field_offsets.insert(
               std::make_pair(field_decl, field_bit_offset));
         } else {
           if (name)
             module_sp->ReportError(
                 "0x%8.8" PRIx64 ": DW_TAG_member '%s' refers to type 0x%8.8x"
                 " which was unable to be parsed",
-                die.GetID(), name, encoding_form.Reference().GetOffset());
+                die.GetID(main_unit), name, encoding_form.Reference().GetOffset());
           else
             module_sp->ReportError(
                 "0x%8.8" PRIx64 ": DW_TAG_member refers to type 0x%8.8x"
                 " which was unable to be parsed",
-                die.GetID(), encoding_form.Reference().GetOffset());
+                die.GetID(main_unit), encoding_form.Reference().GetOffset());
         }
       }
 
       if (prop_name != nullptr && member_type) {
         clang::ObjCIvarDecl *ivar_decl = nullptr;
 
         if (field_decl) {
           ivar_decl = clang::dyn_cast<clang::ObjCIvarDecl>(field_decl);
           assert(ivar_decl != nullptr);
         }
 
         ClangASTMetadata metadata;
-        metadata.SetUserID(die.GetID());
+        metadata.SetUserID(die.GetID(main_unit));
         delayed_properties.push_back(DelayedAddObjCClassProperty(
             class_clang_type, prop_name, member_type->GetLayoutCompilerType(),
             ivar_decl, prop_setter_name, prop_getter_name, prop_attributes,
             &metadata));
 
         if (ivar_decl)
-          m_ast.SetMetadataAsUserID(ivar_decl, die.GetID());
+          m_ast.SetMetadataAsUserID(ivar_decl, die.GetID(main_unit));
       }
     }
   }
 }
 
-bool DWARFASTParserClang::ParseChildMembers(
+bool DWARFASTParserClang::ParseChildMembers(CompileUnit *comp_unit,
     const DWARFDIE &parent_die, CompilerType &class_clang_type,
     const LanguageType class_language,
     std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> &base_classes,
     std::vector<int> &member_accessibilities,
     std::vector<DWARFDIE> &member_function_dies,
     DelayedPropertyList &delayed_properties, AccessType &default_accessibility,
     bool &is_a_class, ClangASTImporter::LayoutInfo &layout_info) {
   if (!parent_die)
     return false;
 
   FieldInfo last_field_info;
 
   ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
   TypeSystemClang *ast =
       llvm::dyn_cast_or_null<TypeSystemClang>(class_clang_type.GetTypeSystem());
   if (ast == nullptr)
     return false;
 
+  DWARFCompileUnit *main_unit = nullptr;
+  if (comp_unit) {
+    SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(comp_unit->GetModule()->GetSymbolFile());
+    main_unit = dwarf->GetDWARFCompileUnit(comp_unit);
+  }
+
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_member:
     case DW_TAG_APPLE_property:
-      ParseSingleMember(die, parent_die, class_clang_type, class_language,
+      ParseSingleMember(comp_unit, die, parent_die, class_clang_type, class_language,
                         member_accessibilities, default_accessibility,
                         delayed_properties, layout_info, last_field_info);
       break;
 
     case DW_TAG_subprogram:
       // Let the type parsing code handle this one for us.
       member_function_dies.push_back(die);
       break;
case DW_TAG_inheritance: {
               break;
 
             default:
               break;
             }
           }
         }
 
-        Type *base_class_type = die.ResolveTypeUID(encoding_form.Reference());
+        Type *base_class_type = die.ResolveTypeUID(main_unit, encoding_form.Reference());
         if (base_class_type == nullptr) {
           module_sp->ReportError("0x%8.8x: DW_TAG_inheritance failed to "
                                  "resolve the base class at 0x%8.8x"
                                  " from enclosing type 0x%8.8x. \nPlease file "
                                  "a bug and attach the file at the start of "
                                  "this error message",
                                  die.GetOffset(),
                                  encoding_form.Reference().GetOffset(),
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
     default:
       break;
     }
   }
 
   return true;
 }
 
-size_t DWARFASTParserClang::ParseChildParameters(
+size_t DWARFASTParserClang::ParseChildParameters(CompileUnit *comp_unit,
     clang::DeclContext *containing_decl_ctx, const DWARFDIE &parent_die,
     bool skip_artificial, bool &is_static, bool &is_variadic,
     bool &has_template_params, std::vector<CompilerType> &function_param_types,
     std::vector<clang::ParmVarDecl *> &function_param_decls,
     unsigned &type_quals) {
   if (!parent_die)
     return 0;
 
+  DWARFCompileUnit *main_unit = nullptr;
+  if (comp_unit) {
+    SymbolFileDWARF *dwarf = llvm::cast<SymbolFileDWARF>(comp_unit->GetModule()->GetSymbolFile());
+    main_unit = dwarf->GetDWARFCompileUnit(comp_unit);
+  }
+
   size_t arg_idx = 0;
   for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
        die = die.GetSibling()) {
     const dw_tag_t tag = die.Tag();
     switch (tag) {
     case DW_TAG_formal_parameter: {
       DWARFAttributes attributes;
       const size_t num_attributes = die.GetAttributes(attributes);
case DW_TAG_formal_parameter: {
           // have to look at the const-ness of "this"...
           if (arg_idx == 0 &&
               DeclKindIsCXXClass(containing_decl_ctx->getDeclKind()) &&
               // Often times compilers omit the "this" name for the
               // specification DIEs, so we can't rely upon the name being in
               // the formal parameter DIE...
               (name == nullptr || ::strcmp(name, "this") == 0)) {
             Type *this_type =
-                die.ResolveTypeUID(param_type_die_form.Reference());
+                die.ResolveTypeUID(main_unit, param_type_die_form.Reference());
             if (this_type) {
               uint32_t encoding_mask = this_type->GetEncodingMask();
               if (encoding_mask & Type::eEncodingIsPointerUID) {
                 is_static = false;
 
                 if (encoding_mask & (1u << Type::eEncodingIsConstUID))
                   type_quals |= clang::Qualifiers::Const;
                 if (encoding_mask & (1u << Type::eEncodingIsVolatileUID))
                   type_quals |= clang::Qualifiers::Volatile;
               }
             }
           }
           skip = true;
         }
 
         if (!skip) {
-          Type *type = die.ResolveTypeUID(param_type_die_form.Reference());
+          Type *type = die.ResolveTypeUID(main_unit, param_type_die_form.Reference());
           if (type) {
             function_param_types.push_back(type->GetForwardCompilerType());
 
             clang::ParmVarDecl *param_var_decl =
                 m_ast.CreateParameterDeclaration(containing_decl_ctx, name,
                                                  type->GetForwardCompilerType(),
                                                  storage);
             assert(param_var_decl);
             function_param_decls.push_back(param_var_decl);
 
-            m_ast.SetMetadataAsUserID(param_var_decl, die.GetID());
+            m_ast.SetMetadataAsUserID(param_var_decl, die.GetID(main_unit));
           }
         }
       }
       arg_idx++;
     } break;
 
     case DW_TAG_unspecified_parameters:
       is_variadic = true;
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid();
     } break;
     default:
       break;
     }
   }
   return array_info;
 }
 
-Type *DWARFASTParserClang::GetTypeForDIE(const DWARFDIE &die) {
+Type *DWARFASTParserClang::GetTypeForDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die) {
   if (die) {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
+    SymbolFileDWARF *dwarf = &die.MainDWARFUnit(main_unit)->GetSymbolFileDWARF();
     DWARFAttributes attributes;
     const size_t num_attributes = die.GetAttributes(attributes);
     if (num_attributes > 0) {
       DWARFFormValue type_die_form;
       for (size_t i = 0; i < num_attributes; ++i) {
         dw_attr_t attr = attributes.AttributeAtIndex(i);
         DWARFFormValue form_value;
 
         if (attr == DW_AT_type &&
             attributes.ExtractFormValueAtIndex(i, form_value))
-          return dwarf->ResolveTypeUID(form_value.Reference(), true);
+          return dwarf->ResolveTypeUID(main_unit, form_value.Reference(), true);
       }
     }
   }
 
   return nullptr;
 }
 
-clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(const DWARFDIE &die) {
+clang::Decl *DWARFASTParserClang::GetClangDeclForDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die) {
   if (!die)
     return nullptr;
 
   switch (die.Tag()) {
   case DW_TAG_variable:
   case DW_TAG_constant:
   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());
+  auto diepair = die.MainCUtoDIEPair(main_unit);
+  DIEToDeclMap::iterator cache_pos = m_die_to_decl.find(diepair);
   if (cache_pos != m_die_to_decl.end())
     return cache_pos->second;
 
   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());
+    clang::Decl *decl = GetClangDeclForDIE(main_unit, spec_die);
+    m_die_to_decl[diepair] = decl;
+    m_decl_to_die[decl].insert(diepair);
     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());
+    clang::Decl *decl = GetClangDeclForDIE(main_unit, abstract_origin_die);
+    m_die_to_decl[diepair] = decl;
+    m_decl_to_die[decl].insert(diepair);
     return decl;
   }
 
+  SymbolFileDWARF *dwarf = &die.MainDWARFUnit(main_unit)->GetSymbolFileDWARF();
+
   clang::Decl *decl = nullptr;
   switch (die.Tag()) {
   case DW_TAG_variable:
   case DW_TAG_constant:
   case DW_TAG_formal_parameter: {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
-    Type *type = GetTypeForDIE(die);
+    Type *type = GetTypeForDIE(main_unit, die);
     if (dwarf && type) {
       const char *name = die.GetName();
       clang::DeclContext *decl_context =
           TypeSystemClang::DeclContextGetAsDeclContext(
-              dwarf->GetDeclContextContainingUID(die.GetID()));
+              dwarf->GetDeclContextContainingUID(die.GetID(main_unit)));
       decl = m_ast.CreateVariableDeclaration(
           decl_context, name,
           ClangUtil::GetQualType(type->GetForwardCompilerType()));
     }
     break;
   }
   case DW_TAG_imported_declaration: {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
     if (imported_uid) {
-      CompilerDecl imported_decl = SymbolFileDWARF::GetDecl(imported_uid);
+      CompilerDecl imported_decl = SymbolFileDWARF::GetDecl(main_unit, imported_uid);
       if (imported_decl) {
         clang::DeclContext *decl_context =
             TypeSystemClang::DeclContextGetAsDeclContext(
-                dwarf->GetDeclContextContainingUID(die.GetID()));
+                dwarf->GetDeclContextContainingUID(die.GetID(main_unit)));
         if (clang::NamedDecl *clang_imported_decl =
                 llvm::dyn_cast<clang::NamedDecl>(
                     (clang::Decl *)imported_decl.GetOpaqueDecl()))
           decl =
               m_ast.CreateUsingDeclaration(decl_context, clang_imported_decl);
       }
     }
     break;
   }
   case DW_TAG_imported_module: {
-    SymbolFileDWARF *dwarf = die.GetDWARF();
     DWARFDIE imported_uid = die.GetAttributeValueAsReferenceDIE(DW_AT_import);
 
     if (imported_uid) {
       CompilerDeclContext imported_decl_ctx =
-          SymbolFileDWARF::GetDeclContext(imported_uid);
+          SymbolFileDWARF::GetDeclContext(main_unit, imported_uid);
       if (imported_decl_ctx) {
         clang::DeclContext *decl_context =
             TypeSystemClang::DeclContextGetAsDeclContext(
-                dwarf->GetDeclContextContainingUID(die.GetID()));
+                dwarf->GetDeclContextContainingUID(die.GetID(main_unit)));
         if (clang::NamespaceDecl *ns_decl =
                 TypeSystemClang::DeclContextGetAsNamespaceDecl(
                     imported_decl_ctx))
           decl = m_ast.CreateUsingDirectiveDeclaration(decl_context, ns_decl);
       }
     }
     break;
   }
   default:
     break;
   }
 
-  m_die_to_decl[die.GetDIE()] = decl;
-  m_decl_to_die[decl].insert(die.GetDIE());
+  m_die_to_decl[diepair] = decl;
+  m_decl_to_die[decl].insert(diepair);
 
   return decl;
 }
 
 clang::DeclContext *
-DWARFASTParserClang::GetClangDeclContextForDIE(const DWARFDIE &die) {
+DWARFASTParserClang::GetClangDeclContextForDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die) {
   if (die) {
-    clang::DeclContext *decl_ctx = GetCachedClangDeclContextForDIE(die);
+    clang::DeclContext *decl_ctx = GetCachedClangDeclContextForDIE(main_unit, die);
     if (decl_ctx)
       return decl_ctx;
 
     bool try_parsing_type = true;
     switch (die.Tag()) {
     case DW_TAG_compile_unit:
     case DW_TAG_partial_unit:
       decl_ctx = m_ast.GetTranslationUnitDecl();
       try_parsing_type = false;
       break;
 
     case DW_TAG_namespace:
-      decl_ctx = ResolveNamespaceDIE(die);
+      decl_ctx = ResolveNamespaceDIE(main_unit, die);
       try_parsing_type = false;
       break;
 
     case DW_TAG_lexical_block:
-      decl_ctx = GetDeclContextForBlock(die);
+      decl_ctx = GetDeclContextForBlock(main_unit, die);
       try_parsing_type = false;
       break;
 
     default:
       break;
     }
 
     if (decl_ctx == nullptr && try_parsing_type) {
-      Type *type = die.GetDWARF()->ResolveType(die);
+      Type *type = die.MainDWARFUnit(main_unit)->GetSymbolFileDWARF().ResolveType(main_unit, die);
       if (type)
-        decl_ctx = GetCachedClangDeclContextForDIE(die);
+        decl_ctx = GetCachedClangDeclContextForDIE(main_unit, die);
     }
 
     if (decl_ctx) {
-      LinkDeclContextToDIE(decl_ctx, die);
+      LinkDeclContextToDIE(decl_ctx, main_unit, die);
       return decl_ctx;
     }
   }
   return nullptr;
 }
 
 static bool IsSubroutine(const DWARFDIE &die) {
   switch (die.Tag()) {
for (DWARFDIE context = block; context != function.GetParent();
     if (DWARFDIE child = FindAnyChildWithAbstractOrigin(context)) {
       return child;
     }
   }
   return DWARFDIE();
 }
 
 clang::DeclContext *
-DWARFASTParserClang::GetDeclContextForBlock(const DWARFDIE &die) {
+DWARFASTParserClang::GetDeclContextForBlock(DWARFCompileUnit *main_unit, const DWARFDIE &die) {
   assert(die.Tag() == DW_TAG_lexical_block);
   DWARFDIE containing_function_with_abstract_origin =
       GetContainingFunctionWithAbstractOrigin(die);
   if (!containing_function_with_abstract_origin) {
-    return (clang::DeclContext *)ResolveBlockDIE(die);
+    return (clang::DeclContext *)ResolveBlockDIE(main_unit, die);
   }
   DWARFDIE child = FindFirstChildWithAbstractOrigin(
       die, containing_function_with_abstract_origin);
   CompilerDeclContext decl_context =
-      GetDeclContextContainingUIDFromDWARF(child);
+      GetDeclContextContainingUIDFromDWARF(main_unit, child);
   return (clang::DeclContext *)decl_context.GetOpaqueDeclContext();
 }
 
-clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(const DWARFDIE &die) {
+clang::BlockDecl *DWARFASTParserClang::ResolveBlockDIE(DWARFCompileUnit *main_unit, 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()]);
+        llvm::cast_or_null<clang::BlockDecl>(m_die_to_decl_ctx[die.MainCUtoDIEPair(main_unit)]);
 
     if (!decl) {
       DWARFDIE decl_context_die;
       clang::DeclContext *decl_context =
-          GetClangDeclContextContainingDIE(die, &decl_context_die);
+          GetClangDeclContextContainingDIE(main_unit, die, &decl_context_die);
       decl = m_ast.CreateBlockDeclaration(decl_context);
 
       if (decl)
-        LinkDeclContextToDIE((clang::DeclContext *)decl, die);
+        LinkDeclContextToDIE((clang::DeclContext *)decl, main_unit, die);
     }
 
     return decl;
   }
   return nullptr;
 }
 
 clang::NamespaceDecl *
-DWARFASTParserClang::ResolveNamespaceDIE(const DWARFDIE &die) {
+DWARFASTParserClang::ResolveNamespaceDIE(DWARFCompileUnit *main_unit, 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()]);
+        static_cast<clang::NamespaceDecl *>(m_die_to_decl_ctx[die.MainCUtoDIEPair(main_unit)]);
     if (namespace_decl)
       return namespace_decl;
     else {
       const char *namespace_name = die.GetName();
       clang::DeclContext *containing_decl_ctx =
-          GetClangDeclContextContainingDIE(die, nullptr);
+          GetClangDeclContextContainingDIE(main_unit, die, nullptr);
       bool is_inline =
           die.GetAttributeValueAsUnsigned(DW_AT_export_symbols, 0) != 0;
 
       namespace_decl = m_ast.GetUniqueNamespaceDeclaration(
           namespace_name, containing_decl_ctx, is_inline);
       Log *log =
           nullptr; // (LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO));
       if (log) {
-        SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = &die.MainDWARFUnit(main_unit)->GetSymbolFileDWARF();
         if (namespace_name) {
           dwarf->GetObjectFile()->GetModule()->LogMessage(
               log,
               "ASTContext => %p: 0x%8.8" PRIx64
               ": DW_TAG_namespace with DW_AT_name(\"%s\") => "
               "clang::NamespaceDecl *%p (original = %p)",
-              static_cast<void *>(&m_ast.getASTContext()), die.GetID(),
+              static_cast<void *>(&m_ast.getASTContext()), die.GetID(main_unit),
               namespace_name, static_cast<void *>(namespace_decl),
               static_cast<void *>(namespace_decl->getOriginalNamespace()));
         } else {
           dwarf->GetObjectFile()->GetModule()->LogMessage(
               log,
               "ASTContext => %p: 0x%8.8" PRIx64
               ": DW_TAG_namespace (anonymous) => clang::NamespaceDecl *%p "
               "(original = %p)",
-              static_cast<void *>(&m_ast.getASTContext()), die.GetID(),
+              static_cast<void *>(&m_ast.getASTContext()), die.GetID(main_unit),
               static_cast<void *>(namespace_decl),
               static_cast<void *>(namespace_decl->getOriginalNamespace()));
         }
       }
 
       if (namespace_decl)
-        LinkDeclContextToDIE((clang::DeclContext *)namespace_decl, die);
+        LinkDeclContextToDIE((clang::DeclContext *)namespace_decl, main_unit, die);
       return namespace_decl;
     }
   }
   return nullptr;
 }
 
-clang::DeclContext *DWARFASTParserClang::GetClangDeclContextContainingDIE(
+clang::DeclContext *DWARFASTParserClang::GetClangDeclContextContainingDIE(DWARFCompileUnit *main_unit,
     const DWARFDIE &die, DWARFDIE *decl_ctx_die_copy) {
-  SymbolFileDWARF *dwarf = die.GetDWARF();
+  SymbolFileDWARF *dwarf = &die.MainDWARFUnit(main_unit)->GetSymbolFileDWARF();
 
   DWARFDIE decl_ctx_die = dwarf->GetDeclContextDIEContainingDIE(die);
 
   if (decl_ctx_die_copy)
     *decl_ctx_die_copy = decl_ctx_die;
 
   if (decl_ctx_die) {
     clang::DeclContext *clang_decl_ctx =
-        GetClangDeclContextForDIE(decl_ctx_die);
+        GetClangDeclContextForDIE(main_unit, decl_ctx_die);
     if (clang_decl_ctx)
       return clang_decl_ctx;
   }
   return m_ast.GetTranslationUnitDecl();
 }
 
 clang::DeclContext *
-DWARFASTParserClang::GetCachedClangDeclContextForDIE(const DWARFDIE &die) {
+DWARFASTParserClang::GetCachedClangDeclContextForDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die) {
   if (die) {
-    DIEToDeclContextMap::iterator pos = m_die_to_decl_ctx.find(die.GetDIE());
+    DIEToDeclContextMap::iterator pos = m_die_to_decl_ctx.find(die.MainCUtoDIEPair(main_unit));
     if (pos != m_die_to_decl_ctx.end())
       return pos->second;
   }
   return nullptr;
 }
 
 void DWARFASTParserClang::LinkDeclContextToDIE(clang::DeclContext *decl_ctx,
-                                               const DWARFDIE &die) {
-  m_die_to_decl_ctx[die.GetDIE()] = decl_ctx;
+                                               DWARFCompileUnit *main_unit, const DWARFDIE &die) {
+  m_die_to_decl_ctx[die.MainCUtoDIEPair(main_unit)] = 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.insert(std::make_pair(decl_ctx, die.MainCUtoDWARFDIEPair(main_unit)));
 }
 
-bool DWARFASTParserClang::CopyUniqueClassMethodTypes(
+bool DWARFASTParserClang::CopyUniqueClassMethodTypes(DWARFCompileUnit *main_unit,
     const DWARFDIE &src_class_die, const DWARFDIE &dst_class_die,
     lldb_private::Type *class_type, std::vector<DWARFDIE> &failures) {
   if (!class_type || !src_class_die || !dst_class_die)
     return false;
   if (src_class_die.Tag() != dst_class_die.Tag())
     return false;
 
   // We need to complete the class type so we can get all of the method types
bool DWARFASTParserClang::CopyUniqueClassMethodTypes(DWARFCompileUnit *main_unit,
   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[src_die.MainCUtoDIEPair(main_unit)];
       if (src_decl_ctx) {
         LLDB_LOGF(log, "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);
+        dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, main_unit, dst_die);
       } else {
         LLDB_LOGF(log,
                   "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()[src_die.MainCUtoDIEPair(main_unit)];
       if (src_child_type) {
         LLDB_LOGF(log,
                   "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()[dst_die.MainCUtoDIEPair(main_unit)] = src_child_type;
       } else {
         LLDB_LOGF(log,
                   "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[src_die.MainCUtoDIEPair(main_unit)];
           if (src_decl_ctx) {
             LLDB_LOGF(log, "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);
+            dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, main_unit, dst_die);
           } else {
             LLDB_LOGF(log,
                       "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()[src_die.MainCUtoDIEPair(main_unit)];
           if (src_child_type) {
             LLDB_LOGF(
                 log,
                 "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()] =
+            dst_die.GetDWARF()->GetDIEToType()[dst_die.MainCUtoDIEPair(main_unit)] =
                 src_child_type;
           } else {
             LLDB_LOGF(log,
                       "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 {
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[src_die.MainCUtoDIEPair(main_unit)];
         if (src_decl_ctx) {
           LLDB_LOGF(log, "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);
+          dst_dwarf_ast_parser->LinkDeclContextToDIE(src_decl_ctx, main_unit, dst_die);
         } else {
           LLDB_LOGF(log,
                     "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()[src_die.MainCUtoDIEPair(main_unit)];
         if (src_child_type) {
           LLDB_LOGF(
               log,
               "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()[dst_die.MainCUtoDIEPair(main_unit)] = src_child_type;
         } else {
           LLDB_LOGF(log,
                     "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());
         }
       }
     }

lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h

 #include "lldb/Core/dwarf.h"
 #include "lldb/lldb-types.h"
 
 #include "llvm/Support/Error.h"
 
 class DIERef;
 class DWARFASTParser;
 class DWARFAttributes;
+class DWARFCompileUnit;
 class DWARFUnit;
 class DWARFDebugInfoEntry;
 class DWARFDeclContext;
 class SymbolFileDWARF;
+class DWARFCompileUnit;
 
 class DWARFBaseDIE {
 public:
   DWARFBaseDIE() : m_cu(nullptr), m_die(nullptr) {}
 
   DWARFBaseDIE(DWARFUnit *cu, DWARFDebugInfoEntry *die)
       : m_cu(cu), m_die(die) {}
 
public:
   const char *GetTagAsCString() const;
 
   dw_offset_t GetOffset() const;
 
   // Get the LLDB user ID for this DIE. This is often just the DIE offset,
   // but it might have a SymbolFileDWARF::GetID() in the high 32 bits if
   // we are doing Darwin DWARF in .o file, or DWARF stand alone debug
   // info.
-  lldb::user_id_t GetID() const;
+  lldb::user_id_t GetID(DWARFCompileUnit *main_unit) const;
 
   const char *GetName() const;
 
   lldb::ModuleSP GetModule() const;
 
   // Getting attribute values from the DIE.
   //
   // GetAttributeValueAsXXX() functions should only be used if you are

lldb/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp

 uint64_t DWARFBaseDIE::GetAttributeValueAsAddress(const dw_attr_t attr,
                                               uint64_t fail_value) const {
   if (IsValid())
     return m_die->GetAttributeValueAsAddress(GetCU(), attr, fail_value);
   else
     return fail_value;
 }
 
-lldb::user_id_t DWARFBaseDIE::GetID() const {
+lldb::user_id_t DWARFBaseDIE::GetID(DWARFCompileUnit *main_unit) const {
   if (IsValid())
-    return GetDWARF()->GetUID(*this);
+    return GetDWARF()->GetUID(main_unit, *this);
   return LLDB_INVALID_UID;
 }
 
 const char *DWARFBaseDIE::GetName() const {
   if (IsValid())
     return m_die->GetName(m_cu);
   else
     return nullptr;

lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

 class DWARFCompileUnit : public DWARFUnit {
 public:
   void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) override;
 
   void Dump(lldb_private::Stream *s) const override;
 
   static bool classof(const DWARFUnit *unit) { return !unit->IsTypeUnit(); }
 
+  DWARFCompileUnit &GetNonSkeletonUnit();
+
 private:
   DWARFCompileUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid,
                    const DWARFUnitHeader &header,
                    const DWARFAbbreviationDeclarationSet &abbrevs,
                    DIERef::Section section, bool is_dwo)
       : DWARFUnit(dwarf, uid, header, abbrevs, section, is_dwo) {}
 
   DISALLOW_COPY_AND_ASSIGN(DWARFCompileUnit);
 
   friend class DWARFUnit;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFCOMPILEUNIT_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

if (sc.comp_unit) {
               file_ranges.GetEntryRef(idx);
           debug_aranges->AppendRange(GetOffset(), range.GetRangeBase(),
                                      range.GetRangeEnd());
         }
       }
     }
   }
 }
+
+DWARFCompileUnit &DWARFCompileUnit::GetNonSkeletonUnit() {
+  return llvm::cast<DWARFCompileUnit>(DWARFUnit::GetNonSkeletonUnit());
+}

lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.h

public:
 
   const char *GetQualifiedName(std::string &storage) const;
 
   using DWARFBaseDIE::GetName;
   void GetName(lldb_private::Stream &s) const;
 
   void AppendTypeName(lldb_private::Stream &s) const;
 
-  lldb_private::Type *ResolveType() const;
+  lldb_private::Type *ResolveType(DWARFCompileUnit *main_unit) const;
 
   // Resolve a type by UID using this DIE's DWARF file
-  lldb_private::Type *ResolveTypeUID(const DWARFDIE &die) const;
+  lldb_private::Type *ResolveTypeUID(DWARFCompileUnit *main_unit, const DWARFDIE &die) const;
 
   // Functions for obtaining DIE relations and references
 
   DWARFDIE
   GetParent() const;
 
   DWARFDIE
   GetFirstChild() const;
public:
   DWARFDIE
   GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const;
 
   bool GetDIENamesAndRanges(const char *&name, const char *&mangled,
                             DWARFRangeList &ranges, int &decl_file,
                             int &decl_line, int &decl_column, int &call_file,
                             int &call_line, int &call_column,
                             lldb_private::DWARFExpression *frame_base) const;
+
+  DWARFCompileUnit *MainDWARFCompileUnit(DWARFCompileUnit *main_unit) const;
+  DWARFUnit *MainDWARFUnit(DWARFCompileUnit *main_unit) const;
+  std::pair<DWARFCompileUnit *, DWARFDIE> MainCUtoDWARFDIEPair(DWARFCompileUnit *main_unit) const;
+  std::pair<DWARFCompileUnit *, DWARFDebugInfoEntry *> MainCUtoDIEPair(DWARFCompileUnit *main_unit) const;
+
+protected:
+  DWARFCompileUnit *MainDWARFCompileUnitOrNull(DWARFCompileUnit *main_unit) const;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDIE_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

 //===-- DWARFDIE.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFDIE.h"
 
 #include "DWARFASTParser.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFDeclContext.h"
-#include "DWARFUnit.h"
+#include "DWARFCompileUnit.h"
+#include "SymbolFileDWARFDwo.h"
 
 using namespace lldb_private;
 
 namespace {
 
 /// Iterate through all DIEs elaborating (i.e. reachable by a chain of
 /// DW_AT_specification and DW_AT_abstract_origin attributes) a given DIE. For
 /// convenience, the starting die is included in the sequence as the first
void DWARFDIE::AppendTypeName(Stream &s) const {
   case DW_TAG_reference_type:
     s.PutChar('&');
     break;
   default:
     break;
   }
 }
 
-lldb_private::Type *DWARFDIE::ResolveType() const {
+lldb_private::Type *DWARFDIE::ResolveType(DWARFCompileUnit *main_unit) const {
   if (IsValid())
-    return GetDWARF()->ResolveType(*this, true);
+    return MainDWARFUnit(main_unit)->GetSymbolFileDWARF().ResolveType(main_unit, *this, true);
   else
     return nullptr;
 }
 
-lldb_private::Type *DWARFDIE::ResolveTypeUID(const DWARFDIE &die) const {
-  if (SymbolFileDWARF *dwarf = GetDWARF())
-    return dwarf->ResolveTypeUID(die, true);
+lldb_private::Type *DWARFDIE::ResolveTypeUID(DWARFCompileUnit *main_unit, const DWARFDIE &die) const {
+  if (SymbolFileDWARF *dwarf = &MainDWARFUnit(main_unit)->GetSymbolFileDWARF())
+    return dwarf->ResolveTypeUID(main_unit, die, true);
   return nullptr;
 }
 
 std::vector<DWARFDIE> DWARFDIE::GetDeclContextDIEs() const {
   if (!IsValid())
     return {};
 
   std::vector<DWARFDIE> result;
bool DWARFDIE::GetDIENamesAndRanges(
     lldb_private::DWARFExpression *frame_base) const {
   if (IsValid()) {
     return m_die->GetDIENamesAndRanges(
         GetCU(), name, mangled, ranges, decl_file, decl_line, decl_column,
         call_file, call_line, call_column, frame_base);
   } else
     return false;
 }
+
+DWARFCompileUnit *DWARFDIE::MainDWARFCompileUnit(DWARFCompileUnit *main_unit) const {
+  if (llvm::isa<DWARFTypeUnit>(GetCU()))
+    return nullptr;
+  if (!main_unit)
+    main_unit = llvm::dyn_cast<DWARFCompileUnit>(GetCU());
+  lldbassert(main_unit);
+#if 0
+  if (main_unit)
+    main_unit = &main_unit->GetNonSkeletonUnit();
+#endif
+  return main_unit;
+}
+
+DWARFUnit *DWARFDIE::MainDWARFUnit(DWARFCompileUnit *main_unit) const {
+  main_unit = MainDWARFCompileUnit(main_unit);
+  if (main_unit)
+    return main_unit;
+  return GetCU();
+}
+
+// FIXME: Is it possible to unify it with MainDWARFCompileUnit()?
+DWARFCompileUnit *DWARFDIE::MainDWARFCompileUnitOrNull(DWARFCompileUnit *main_unit) const {
+  if (GetCU()->GetDwoSymbolFile())
+    return nullptr;
+  if (llvm::isa<SymbolFileDWARFDwo>(&GetCU()->GetSymbolFileDWARF()))
+    return nullptr;
+  return MainDWARFCompileUnit(main_unit);
+}
+
+std::pair<DWARFCompileUnit *, DWARFDIE> DWARFDIE::MainCUtoDWARFDIEPair(DWARFCompileUnit *main_unit) const {
+  return std::make_pair(MainDWARFCompileUnitOrNull(main_unit), *this);
+}
+
+std::pair<DWARFCompileUnit *, DWARFDebugInfoEntry *> DWARFDIE::MainCUtoDIEPair(DWARFCompileUnit *main_unit) const {
+  return std::make_pair(MainDWARFCompileUnitOrNull(main_unit), GetDIE());
+}

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

enum {
     eDumpFlag_Verbose = (1 << 0),  // Verbose dumping
     eDumpFlag_ShowForm = (1 << 1), // Show the DW_form type
     eDumpFlag_ShowAncestors =
         (1 << 2) // Show all parent DIEs when dumping single DIEs
   };
 
   llvm::Expected<DWARFDebugAranges &> GetCompileUnitAranges();
 
+  lldb::user_id_t GetUID(DWARFCompileUnit *main_unit, DIERef ref) const { return m_dwarf.GetUID(main_unit, ref); }
+
 protected:
   typedef std::vector<DWARFUnitSP> UnitColl;
 
   SymbolFileDWARF &m_dwarf;
   lldb_private::DWARFContext &m_context;
 
   llvm::once_flag m_units_once_flag;
   UnitColl m_units;

lldb/source/Plugins/SymbolFile/DWARF/DWARFIndex.h

public:
   DWARFIndex(Module &module) : m_module(module) {}
   virtual ~DWARFIndex();
 
   virtual void Preload() = 0;
 
   /// Finds global variables with the given base name. Any additional filtering
   /// (e.g., to only retrieve variables from a given context) should be done by
   /// the consumer.
-  virtual void GetGlobalVariables(ConstString basename, DIEArray &offsets) = 0;
+  virtual void GetGlobalVariables(ConstString basename, std::vector<lldb::user_id_t> &offsets) = 0;
 
   virtual void GetGlobalVariables(const RegularExpression &regex,
-                                  DIEArray &offsets) = 0;
-  virtual void GetGlobalVariables(const DWARFUnit &cu, DIEArray &offsets) = 0;
-  virtual void GetObjCMethods(ConstString class_name, DIEArray &offsets) = 0;
+                                  std::vector<lldb::user_id_t> &offsets) = 0;
+  virtual void GetGlobalVariables(const DWARFUnit &cu, std::vector<lldb::user_id_t> &offsets) = 0;
+  virtual void GetObjCMethods(ConstString class_name, std::vector<lldb::user_id_t> &offsets) = 0;
   virtual void GetCompleteObjCClass(ConstString class_name,
                                     bool must_be_implementation,
-                                    DIEArray &offsets) = 0;
-  virtual void GetTypes(ConstString name, DIEArray &offsets) = 0;
-  virtual void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) = 0;
-  virtual void GetNamespaces(ConstString name, DIEArray &offsets) = 0;
+                                    std::vector<lldb::user_id_t> &offsets) = 0;
+  virtual void GetTypes(ConstString name, std::vector<lldb::user_id_t> &offsets) = 0;
+  virtual void GetTypes(const DWARFDeclContext &context, std::vector<lldb::user_id_t> &offsets) = 0;
+  virtual void GetNamespaces(ConstString name, std::vector<lldb::user_id_t> &offsets) = 0;
   virtual void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                             const CompilerDeclContext &parent_decl_ctx,
                             uint32_t name_type_mask,
-                            std::vector<DWARFDIE> &dies) = 0;
+                            std::vector<std::pair<DWARFCompileUnit *, DWARFDIE>> &dies) = 0;
   virtual void GetFunctions(const RegularExpression &regex,
-                            DIEArray &offsets) = 0;
+                            std::vector<lldb::user_id_t> &offsets) = 0;
 
-  virtual void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) = 0;
+  virtual void ReportInvalidDIEID(lldb::user_id_t uid, llvm::StringRef name) = 0;
   virtual void Dump(Stream &s) = 0;
 
 protected:
   Module &m_module;
 
   /// Helper function implementing common logic for processing function dies. If
   /// the function given by "ref" matches search criteria given by
   /// "parent_decl_ctx" and "name_type_mask", it is inserted into the "dies"
   /// vector.
-  void ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
+  void ProcessFunctionDIE(llvm::StringRef name, lldb::user_id_t uid,
                           SymbolFileDWARF &dwarf,
                           const CompilerDeclContext &parent_decl_ctx,
-                          uint32_t name_type_mask, std::vector<DWARFDIE> &dies);
+                          uint32_t name_type_mask, std::vector<std::pair<DWARFCompileUnit *, DWARFDIE>> &dies);
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFINDEX_H

lldb/source/Plugins/SymbolFile/DWARF/DWARFIndex.cpp

 //===-- DWARFIndex.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/DWARF/DWARFIndex.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
+#include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 DWARFIndex::~DWARFIndex() = default;
 
-void DWARFIndex::ProcessFunctionDIE(llvm::StringRef name, DIERef ref,
+void DWARFIndex::ProcessFunctionDIE(llvm::StringRef name, user_id_t uid,
                                     SymbolFileDWARF &dwarf,
                                     const CompilerDeclContext &parent_decl_ctx,
                                     uint32_t name_type_mask,
-                                    std::vector<DWARFDIE> &dies) {
-  DWARFDIE die = dwarf.GetDIE(ref);
+                                    std::vector<std::pair<DWARFCompileUnit *, DWARFDIE>> &dies) {
+  DWARFCompileUnit *main_unit;
+  DWARFDIE die = dwarf.GetDIEUnlocked(uid, &main_unit);
   if (!die) {
-    ReportInvalidDIERef(ref, name);
+    ReportInvalidDIEID(uid, name);
     return;
   }
 
   // Exit early if we're searching exclusively for methods or selectors and
   // we have a context specified (no methods in namespaces).
   uint32_t looking_for_nonmethods =
       name_type_mask & ~(eFunctionNameTypeMethod | eFunctionNameTypeSelector);
   if (!looking_for_nonmethods && parent_decl_ctx.IsValid())
     return;
 
   // Otherwise, we need to also check that the context matches. If it does not
   // match, we do nothing.
-  if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
+  if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, main_unit, die))
     return;
 
+  auto diepair = die.MainCUtoDWARFDIEPair(main_unit);
+
   // In case of a full match, we just insert everything we find.
   if (name_type_mask & eFunctionNameTypeFull) {
-    dies.push_back(die);
+    dies.push_back(diepair);
     return;
   }
 
   // If looking for ObjC selectors, we need to also check if the name is a
   // possible selector.
   if (name_type_mask & eFunctionNameTypeSelector &&
       ObjCLanguage::IsPossibleObjCMethodName(die.GetName())) {
-    dies.push_back(die);
+    dies.push_back(diepair);
     return;
   }
 
   bool looking_for_methods = name_type_mask & lldb::eFunctionNameTypeMethod;
   bool looking_for_functions = name_type_mask & lldb::eFunctionNameTypeBase;
   if (looking_for_methods || looking_for_functions) {
     // If we're looking for either methods or functions, we definitely want this
     // die. Otherwise, only keep it if the die type matches what we are
     // searching for.
     if ((looking_for_methods && looking_for_functions) ||
         looking_for_methods == die.IsMethod())
-      dies.push_back(die);
+      dies.push_back(diepair);
   }
 }

lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.h

 class DebugNamesDWARFIndex : public DWARFIndex {
 public:
   static llvm::Expected<std::unique_ptr<DebugNamesDWARFIndex>>
   Create(Module &module, DWARFDataExtractor debug_names,
          DWARFDataExtractor debug_str, SymbolFileDWARF &dwarf);
 
   void Preload() override { m_fallback.Preload(); }
 
-  void GetGlobalVariables(ConstString basename, DIEArray &offsets) override;
+  void GetGlobalVariables(ConstString basename, std::vector<lldb::user_id_t> &offsets) override;
   void GetGlobalVariables(const RegularExpression &regex,
-                          DIEArray &offsets) override;
-  void GetGlobalVariables(const DWARFUnit &cu, DIEArray &offsets) override;
-  void GetObjCMethods(ConstString class_name, DIEArray &offsets) override {}
+                          std::vector<lldb::user_id_t> &offsets) override;
+  void GetGlobalVariables(const DWARFUnit &cu, std::vector<lldb::user_id_t> &offsets) override;
+  void GetObjCMethods(ConstString class_name, std::vector<lldb::user_id_t> &offsets) override {}
   void GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
-                            DIEArray &offsets) override;
-  void GetTypes(ConstString name, DIEArray &offsets) override;
-  void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) override;
-  void GetNamespaces(ConstString name, DIEArray &offsets) override;
+                            std::vector<lldb::user_id_t> &offsets) override;
+  void GetTypes(ConstString name, std::vector<lldb::user_id_t> &offsets) override;
+  void GetTypes(const DWARFDeclContext &context, std::vector<lldb::user_id_t> &offsets) override;
+  void GetNamespaces(ConstString name, std::vector<lldb::user_id_t> &offsets) override;
   void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
-                    std::vector<DWARFDIE> &dies) override;
+                    std::vector<std::pair<DWARFCompileUnit *, DWARFDIE>> &dies) override;
   void GetFunctions(const RegularExpression &regex,
-                    DIEArray &offsets) override;
+                    std::vector<lldb::user_id_t> &offsets) override;
 
-  void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) override {}
+  void ReportInvalidDIEID(lldb::user_id_t uid, llvm::StringRef name) override {}
   void Dump(Stream &s) override;
 
 private:
   DebugNamesDWARFIndex(Module &module,
                        std::unique_ptr<llvm::DWARFDebugNames> debug_names_up,
                        DWARFDataExtractor debug_names_data,
                        DWARFDataExtractor debug_str_data,
                        SymbolFileDWARF &dwarf)
private:
   DWARFDataExtractor m_debug_names_data;
   DWARFDataExtractor m_debug_str_data;
 
   using DebugNames = llvm::DWARFDebugNames;
   std::unique_ptr<DebugNames> m_debug_names_up;
   ManualDWARFIndex m_fallback;
 
   llvm::Optional<DIERef> ToDIERef(const DebugNames::Entry &entry);
-  void Append(const DebugNames::Entry &entry, DIEArray &offsets);
+  void Append(const DebugNames::Entry &entry, std::vector<lldb::user_id_t> &offsets);
 
   static void MaybeLogLookupError(llvm::Error error,
                                   const DebugNames::NameIndex &ni,
                                   llvm::StringRef name);
 
   static llvm::DenseSet<dw_offset_t> GetUnits(const DebugNames &debug_names);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DEBUGNAMESDWARFINDEX_H

lldb/source/Plugins/SymbolFile/DWARF/DebugNamesDWARFIndex.cpp

DebugNamesDWARFIndex::ToDIERef(const DebugNames::Entry &entry) {
   if (llvm::Optional<uint64_t> die_offset = entry.getDIEUnitOffset())
     return DIERef(cu->GetSymbolFileDWARF().GetDwoNum(),
                   DIERef::Section::DebugInfo, cu->GetOffset() + *die_offset);
 
   return llvm::None;
 }
 
 void DebugNamesDWARFIndex::Append(const DebugNames::Entry &entry,
-                                  DIEArray &offsets) {
+                                  std::vector<lldb::user_id_t> &offsets) {
   if (llvm::Optional<DIERef> ref = ToDIERef(entry))
-    offsets.push_back(*ref);
+    // FIXME: DWZ
+    offsets.push_back(m_debug_info.GetUID(nullptr/*main_unit*/,*ref));
 }
 
 void DebugNamesDWARFIndex::MaybeLogLookupError(llvm::Error error,
                                                const DebugNames::NameIndex &ni,
                                                llvm::StringRef name) {
   // Ignore SentinelErrors, log everything else.
   LLDB_LOG_ERROR(
       LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS),
       handleErrors(std::move(error), [](const DebugNames::SentinelError &) {}),
       "Failed to parse index entries for index at {1:x}, name {2}: {0}",
       ni.getUnitOffset(), name);
 }
 
 void DebugNamesDWARFIndex::GetGlobalVariables(ConstString basename,
-                                              DIEArray &offsets) {
+                                              std::vector<lldb::user_id_t> &offsets) {
   m_fallback.GetGlobalVariables(basename, offsets);
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(basename.GetStringRef())) {
     if (entry.tag() != DW_TAG_variable)
       continue;
 
     Append(entry, offsets);
   }
 }
 
 void DebugNamesDWARFIndex::GetGlobalVariables(const RegularExpression &regex,
-                                              DIEArray &offsets) {
+                                              std::vector<lldb::user_id_t> &offsets) {
   m_fallback.GetGlobalVariables(regex, offsets);
 
   for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
     for (DebugNames::NameTableEntry nte: ni) {
       if (!regex.Execute(nte.getString()))
         continue;
 
       uint64_t entry_offset = nte.getEntryOffset();
       llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset);
       for (; entry_or; entry_or = ni.getEntry(&entry_offset)) {
         if (entry_or->tag() != DW_TAG_variable)
           continue;
 
         Append(*entry_or, offsets);
       }
       MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
     }
   }
 }
 
 void DebugNamesDWARFIndex::GetGlobalVariables(const DWARFUnit &cu,
-                                              DIEArray &offsets) {
+                                              std::vector<lldb::user_id_t> &offsets) {
   m_fallback.GetGlobalVariables(cu, offsets);
 
   uint64_t cu_offset = cu.GetOffset();
   for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
     for (DebugNames::NameTableEntry nte: ni) {
       uint64_t entry_offset = nte.getEntryOffset();
       llvm::Expected<DebugNames::Entry> entry_or = ni.getEntry(&entry_offset);
       for (; entry_or; entry_or = ni.getEntry(&entry_offset)) {
         if (entry_or->tag() != DW_TAG_variable)
           continue;
         if (entry_or->getCUOffset() != cu_offset)
           continue;
 
         Append(*entry_or, offsets);
       }
       MaybeLogLookupError(entry_or.takeError(), ni, nte.getString());
     }
   }
 }
 
 void DebugNamesDWARFIndex::GetCompleteObjCClass(ConstString class_name,
                                                 bool must_be_implementation,
-                                                DIEArray &offsets) {
+                                                std::vector<lldb::user_id_t> &offsets) {
   m_fallback.GetCompleteObjCClass(class_name, must_be_implementation, offsets);
 
   // Keep a list of incomplete types as fallback for when we don't find the
   // complete type.
+  // FIXME: DWZ
   DIEArray incomplete_types;
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(class_name.GetStringRef())) {
     if (entry.tag() != DW_TAG_structure_type &&
         entry.tag() != DW_TAG_class_type)
       continue;
 
for (const DebugNames::Entry &entry :
 
     // FIXME: We should return DWARFDIEs so we don't have to resolve it twice.
     DWARFDIE die = m_debug_info.GetDIE(*ref);
     if (!die)
       continue;
 
     if (die.GetAttributeValueAsUnsigned(DW_AT_APPLE_objc_complete_type, 0)) {
       // If we find the complete version we're done.
-      offsets.push_back(*ref);
+      // FIXME: DWZ
+      offsets.push_back(m_debug_info.GetUID(nullptr/*main_unit*/,*ref));
       return;
     } else {
       incomplete_types.push_back(*ref);
     }
   }
 
-  offsets.insert(offsets.end(), incomplete_types.begin(),
-                 incomplete_types.end());
+  offsets.reserve(offsets.size() + incomplete_types.size());
+  for (const auto ref : incomplete_types)
+    // FIXME: DWZ
+    offsets.push_back(m_debug_info.GetUID(nullptr/*main_unit*/,ref));
 }
 
-void DebugNamesDWARFIndex::GetTypes(ConstString name, DIEArray &offsets) {
+void DebugNamesDWARFIndex::GetTypes(ConstString name, std::vector<lldb::user_id_t> &offsets) {
   m_fallback.GetTypes(name, offsets);
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     if (isType(entry.tag()))
       Append(entry, offsets);
   }
 }
 
 void DebugNamesDWARFIndex::GetTypes(const DWARFDeclContext &context,
-                                    DIEArray &offsets) {
+                                    std::vector<lldb::user_id_t> &offsets) {
   m_fallback.GetTypes(context, offsets);
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(context[0].name)) {
     if (entry.tag() == context[0].tag)
       Append(entry, offsets);
   }
 }
 
-void DebugNamesDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
+void DebugNamesDWARFIndex::GetNamespaces(ConstString name, std::vector<lldb::user_id_t> &offsets) {
   m_fallback.GetNamespaces(name, offsets);
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     if (entry.tag() == DW_TAG_namespace)
       Append(entry, offsets);
   }
 }
 
 void DebugNamesDWARFIndex::GetFunctions(
     ConstString name, SymbolFileDWARF &dwarf,
     const CompilerDeclContext &parent_decl_ctx, uint32_t name_type_mask,
-    std::vector<DWARFDIE> &dies) {
+    std::vector<std::pair<DWARFCompileUnit *, DWARFDIE>> &dies) {
 
-  std::vector<DWARFDIE> v;
+  std::vector<std::pair<DWARFCompileUnit *, DWARFDIE>> v;
   m_fallback.GetFunctions(name, dwarf, parent_decl_ctx, name_type_mask, v);
 
   for (const DebugNames::Entry &entry :
        m_debug_names_up->equal_range(name.GetStringRef())) {
     Tag tag = entry.tag();
     if (tag != DW_TAG_subprogram && tag != DW_TAG_inlined_subroutine)
       continue;
 
     if (llvm::Optional<DIERef> ref = ToDIERef(entry))
-      ProcessFunctionDIE(name.GetStringRef(), *ref, dwarf, parent_decl_ctx,
+      // FIXME: DWZ
+      ProcessFunctionDIE(name.GetStringRef(), dwarf.GetUID(nullptr/*main_unit*/, *ref), dwarf, parent_decl_ctx,
                          name_type_mask, v);
   }
 
-  std::set<DWARFDebugInfoEntry *> seen;
-  for (DWARFDIE die : v)
-    if (seen.insert(die.GetDIE()).second)
-      dies.push_back(die);
+  std::set<std::pair<DWARFCompileUnit *, DWARFDebugInfoEntry *>> seen;
+  for (const auto &diepair : v)
+    if (seen.insert(std::make_pair(diepair.first, diepair.second.GetDIE())).second)
+      // FIXME: DWZ
+      dies.push_back(std::make_pair(diepair.first, diepair.second));
 }
 
 void DebugNamesDWARFIndex::GetFunctions(const RegularExpression &regex,
-                                        DIEArray &offsets) {
+                                        std::vector<lldb::user_id_t> &offsets) {
   m_fallback.GetFunctions(regex, offsets);
 
   for (const DebugNames::NameIndex &ni: *m_debug_names_up) {
     for (DebugNames::NameTableEntry nte: ni) {
       if (!regex.Execute(nte.getString()))
         continue;
 
       uint64_t entry_offset = nte.getEntryOffset();

lldb/source/Plugins/SymbolFile/DWARF/HashedNameToDIE.h

 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_HASHEDNAMETODIE_H
 
 #include <vector>
 
 #include "lldb/Core/MappedHash.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/lldb-defines.h"
 
 #include "DWARFDefines.h"
 #include "DWARFFormValue.h"
 #include "NameToDIE.h"
+#include "DIERef.h"
 
 class DWARFMappedHash {
 public:
   enum AtomType : uint16_t {
     eAtomTypeNULL = 0u,
     /// DIE offset, check form for encoding.
     eAtomTypeDIEOffset = 1u,
     /// DIE offset of the compiler unit header that contains the item in

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.h

 public:
   ManualDWARFIndex(Module &module, SymbolFileDWARF &dwarf,
                    llvm::DenseSet<dw_offset_t> units_to_avoid = {})
       : DWARFIndex(module), m_dwarf(&dwarf),
         m_units_to_avoid(std::move(units_to_avoid)) {}
 
   void Preload() override { Index(); }
 
-  void GetGlobalVariables(ConstString basename, DIEArray &offsets) override;
+  void GetGlobalVariables(ConstString basename, std::vector<lldb::user_id_t> &offsets) override;
   void GetGlobalVariables(const RegularExpression &regex,
-                          DIEArray &offsets) override;
-  void GetGlobalVariables(const DWARFUnit &unit, DIEArray &offsets) override;
-  void GetObjCMethods(ConstString class_name, DIEArray &offsets) override;
+                          std::vector<lldb::user_id_t> &offsets) override;
+  void GetGlobalVariables(const DWARFUnit &unit, std::vector<lldb::user_id_t> &offsets) override;
+  void GetObjCMethods(ConstString class_name, std::vector<lldb::user_id_t> &offsets) override;
   void GetCompleteObjCClass(ConstString class_name, bool must_be_implementation,
-                            DIEArray &offsets) override;
-  void GetTypes(ConstString name, DIEArray &offsets) override;
-  void GetTypes(const DWARFDeclContext &context, DIEArray &offsets) override;
-  void GetNamespaces(ConstString name, DIEArray &offsets) override;
+                            std::vector<lldb::user_id_t> &offsets) override;
+  void GetTypes(ConstString name, std::vector<lldb::user_id_t> &offsets) override;
+  void GetTypes(const DWARFDeclContext &context, std::vector<lldb::user_id_t> &offsets) override;
+  void GetNamespaces(ConstString name, std::vector<lldb::user_id_t> &offsets) override;
   void GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                     const CompilerDeclContext &parent_decl_ctx,
                     uint32_t name_type_mask,
-                    std::vector<DWARFDIE> &dies) override;
-  void GetFunctions(const RegularExpression &regex, DIEArray &offsets) override;
+                    std::vector<std::pair<DWARFCompileUnit *, DWARFDIE>> &dies) override;
+  void GetFunctions(const RegularExpression &regex, std::vector<lldb::user_id_t> &offsets) override;
 
-  void ReportInvalidDIERef(const DIERef &ref, llvm::StringRef name) override {}
+  void ReportInvalidDIEID(lldb::user_id_t uid, llvm::StringRef name) override {}
   void Dump(Stream &s) override;
 
 private:
   struct IndexSet {
     NameToDIE function_basenames;
     NameToDIE function_fullnames;
     NameToDIE function_methods;
     NameToDIE function_selectors;
     NameToDIE objc_class_selectors;
     NameToDIE globals;
     NameToDIE types;
     NameToDIE namespaces;
   };
   void Index();
   void IndexUnit(DWARFUnit &unit, SymbolFileDWARFDwo *dwp, IndexSet &set);
 
-  static void IndexUnitImpl(DWARFUnit &unit,
+  static void IndexUnitImpl(DWARFUnit &unit, DWARFCompileUnit *main_unit,
                             const lldb::LanguageType cu_language,
                             IndexSet &set);
 
   /// The DWARF file which we are indexing. Set to nullptr after the index is
   /// built.
   SymbolFileDWARF *m_dwarf;
   /// Which dwarf units should we skip while building the index.
   llvm::DenseSet<dw_offset_t> m_units_to_avoid;
 
   IndexSet m_set;
 };
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_MANUALDWARFINDEX_H

lldb/source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

 //===-- ManualDWARFIndex.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/DWARF/ManualDWARFIndex.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDeclContext.h"
 #include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h"
+#include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Host/TaskPool.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb_private;
 using namespace lldb;
void ManualDWARFIndex::IndexUnit(DWARFUnit &unit, SymbolFileDWARFDwo *dwp,
 
   if (log) {
     m_module.LogMessage(
         log, "ManualDWARFIndex::IndexUnit for unit at .debug_info[0x%8.8x]",
         unit.GetOffset());
   }
 
   const LanguageType cu_language = SymbolFileDWARF::GetLanguage(unit);
+  DWARFCompileUnit *main_unit = llvm::dyn_cast<DWARFCompileUnit>(&unit);
 
-  IndexUnitImpl(unit, cu_language, set);
+  IndexUnitImpl(unit, main_unit, cu_language, set);
 
   if (SymbolFileDWARFDwo *dwo_symbol_file = unit.GetDwoSymbolFile()) {
     // Type units in a dwp file are indexed separately, so we just need to
     // process the split unit here. However, if the split unit is in a dwo file,
     // then we need to process type units here.
     if (dwo_symbol_file == dwp) {
-      IndexUnitImpl(unit.GetNonSkeletonUnit(), cu_language, set);
+      IndexUnitImpl(unit.GetNonSkeletonUnit(), main_unit, cu_language, set);
     } else {
       DWARFDebugInfo &dwo_info = dwo_symbol_file->DebugInfo();
       for (size_t i = 0; i < dwo_info.GetNumUnits(); ++i)
-        IndexUnitImpl(*dwo_info.GetUnitAtIndex(i), cu_language, set);
+        IndexUnitImpl(*dwo_info.GetUnitAtIndex(i), main_unit, cu_language, set);
     }
   }
 }
 
-void ManualDWARFIndex::IndexUnitImpl(DWARFUnit &unit,
+void ManualDWARFIndex::IndexUnitImpl(DWARFUnit &unit, DWARFCompileUnit *main_unit,
                                      const LanguageType cu_language,
                                      IndexSet &set) {
   for (const DWARFDebugInfoEntry &die : unit.dies()) {
     const dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_array_type:
     case DW_TAG_base_type:
if (num_attributes > 0) {
         case DW_AT_specification:
           if (attributes.ExtractFormValueAtIndex(i, form_value))
             specification_die_form = form_value;
           break;
         }
       }
     }
 
-    DIERef ref = *DWARFDIE(&unit, &die).GetDIERef();
+    user_id_t uid = DWARFDIE(&unit, &die).GetID(main_unit);
     switch (tag) {
     case DW_TAG_inlined_subroutine:
     case DW_TAG_subprogram:
       if (has_address) {
         if (name) {
           bool is_objc_method = false;
           if (cu_language == eLanguageTypeObjC ||
               cu_language == eLanguageTypeObjC_plus_plus) {
             ObjCLanguage::MethodName objc_method(name, true);
             if (objc_method.IsValid(true)) {
               is_objc_method = true;
               ConstString class_name_with_category(
                   objc_method.GetClassNameWithCategory());
               ConstString objc_selector_name(objc_method.GetSelector());
               ConstString objc_fullname_no_category_name(
                   objc_method.GetFullNameWithoutCategory(true));
               ConstString class_name_no_category(objc_method.GetClassName());
-              set.function_fullnames.Insert(ConstString(name), ref);
+              set.function_fullnames.Insert(ConstString(name), uid);
               if (class_name_with_category)
-                set.objc_class_selectors.Insert(class_name_with_category, ref);
+                set.objc_class_selectors.Insert(class_name_with_category, uid);
               if (class_name_no_category &&
                   class_name_no_category != class_name_with_category)
-                set.objc_class_selectors.Insert(class_name_no_category, ref);
+                set.objc_class_selectors.Insert(class_name_no_category, uid);
               if (objc_selector_name)
-                set.function_selectors.Insert(objc_selector_name, ref);
+                set.function_selectors.Insert(objc_selector_name, uid);
               if (objc_fullname_no_category_name)
                 set.function_fullnames.Insert(objc_fullname_no_category_name,
-                                              ref);
+                                              uid);
             }
           }
           // If we have a mangled name, then the DW_AT_name attribute is
           // usually the method name without the class or any parameters
           bool is_method = DWARFDIE(&unit, &die).IsMethod();
 
           if (is_method)
-            set.function_methods.Insert(ConstString(name), ref);
+            set.function_methods.Insert(ConstString(name), uid);
           else
-            set.function_basenames.Insert(ConstString(name), ref);
+            set.function_basenames.Insert(ConstString(name), uid);
 
           if (!is_method && !mangled_cstr && !is_objc_method)
-            set.function_fullnames.Insert(ConstString(name), ref);
+            set.function_fullnames.Insert(ConstString(name), uid);
         }
         if (mangled_cstr) {
           // Make sure our mangled name isn't the same string table entry as
           // our name. If it starts with '_', then it is ok, else compare the
           // string to make sure it isn't the same and we don't end up with
           // duplicate entries
           if (name && name != mangled_cstr &&
               ((mangled_cstr[0] == '_') ||
                (::strcmp(name, mangled_cstr) != 0))) {
-            set.function_fullnames.Insert(ConstString(mangled_cstr), ref);
+            set.function_fullnames.Insert(ConstString(mangled_cstr), uid);
           }
         }
       }
       break;
 
     case DW_TAG_array_type:
     case DW_TAG_base_type:
     case DW_TAG_class_type:
     case DW_TAG_constant:
     case DW_TAG_enumeration_type:
     case DW_TAG_string_type:
     case DW_TAG_structure_type:
     case DW_TAG_subroutine_type:
     case DW_TAG_typedef:
     case DW_TAG_union_type:
     case DW_TAG_unspecified_type:
       if (name && !is_declaration)
-        set.types.Insert(ConstString(name), ref);
+        set.types.Insert(ConstString(name), uid);
       if (mangled_cstr && !is_declaration)
-        set.types.Insert(ConstString(mangled_cstr), ref);
+        set.types.Insert(ConstString(mangled_cstr), uid);
       break;
 
     case DW_TAG_namespace:
       if (name)
-        set.namespaces.Insert(ConstString(name), ref);
+        set.namespaces.Insert(ConstString(name), uid);
       break;
 
     case DW_TAG_variable:
       if (name && has_location_or_const_value && is_global_or_static_variable) {
-        set.globals.Insert(ConstString(name), ref);
+        set.globals.Insert(ConstString(name), uid);
         // Be sure to include variables by their mangled and demangled names if
         // they have any since a variable can have a basename "i", a mangled
         // named "_ZN12_GLOBAL__N_11iE" and a demangled mangled name
         // "(anonymous namespace)::i"...
 
         // Make sure our mangled name isn't the same string table entry as our
         // name. If it starts with '_', then it is ok, else compare the string
         // to make sure it isn't the same and we don't end up with duplicate
         // entries
         if (mangled_cstr && name != mangled_cstr &&
             ((mangled_cstr[0] == '_') || (::strcmp(name, mangled_cstr) != 0))) {
-          set.globals.Insert(ConstString(mangled_cstr), ref);
+          set.globals.Insert(ConstString(mangled_cstr), uid);
         }
       }
       break;
 
     default:
       continue;
     }
   }
 }
 
-void ManualDWARFIndex::GetGlobalVariables(ConstString basename, DIEArray &offsets) {
+void ManualDWARFIndex::GetGlobalVariables(ConstString basename, std::vector<lldb::user_id_t> &offsets) {
   Index();
   m_set.globals.Find(basename, offsets);
 }
 
 void ManualDWARFIndex::GetGlobalVariables(const RegularExpression &regex,
-                                          DIEArray &offsets) {
+                                          std::vector<lldb::user_id_t> &offsets) {
   Index();
   m_set.globals.Find(regex, offsets);
 }
 
 void ManualDWARFIndex::GetGlobalVariables(const DWARFUnit &unit,
-                                          DIEArray &offsets) {
+                                          std::vector<lldb::user_id_t> &offsets) {
   Index();
   m_set.globals.FindAllEntriesForUnit(unit, offsets);
 }
 
 void ManualDWARFIndex::GetObjCMethods(ConstString class_name,
-                                      DIEArray &offsets) {
+                                      std::vector<lldb::user_id_t> &offsets) {
   Index();
   m_set.objc_class_selectors.Find(class_name, offsets);
 }
 
 void ManualDWARFIndex::GetCompleteObjCClass(ConstString class_name,
                                             bool must_be_implementation,
-                                            DIEArray &offsets) {
+                                            std::vector<lldb::user_id_t> &offsets) {
   Index();
   m_set.types.Find(class_name, offsets);
 }
 
-void ManualDWARFIndex::GetTypes(ConstString name, DIEArray &offsets) {
+void ManualDWARFIndex::GetTypes(ConstString name, std::vector<lldb::user_id_t> &offsets) {
   Index();
   m_set.types.Find(name, offsets);
 }
 
 void ManualDWARFIndex::GetTypes(const DWARFDeclContext &context,
-                                DIEArray &offsets) {
+                                std::vector<lldb::user_id_t> &offsets) {
   Index();
   m_set.types.Find(ConstString(context[0].name), offsets);
 }
 
-void ManualDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
+void ManualDWARFIndex::GetNamespaces(ConstString name, std::vector<lldb::user_id_t> &offsets) {
   Index();
   m_set.namespaces.Find(name, offsets);
 }
 
 void ManualDWARFIndex::GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                                     const CompilerDeclContext &parent_decl_ctx,
                                     uint32_t name_type_mask,
-                                    std::vector<DWARFDIE> &dies) {
+                                    std::vector<std::pair<DWARFCompileUnit *, DWARFDIE>> &dies) {
   Index();
 
   if (name_type_mask & eFunctionNameTypeFull) {
-    DIEArray offsets;
+    std::vector<lldb::user_id_t> offsets;
     m_set.function_fullnames.Find(name, offsets);
-    for (const DIERef &die_ref: offsets) {
-      DWARFDIE die = dwarf.GetDIE(die_ref);
+    for (user_id_t uid : offsets) {
+      DWARFCompileUnit *main_unit;
+      DWARFDIE die = dwarf.GetDIEUnlocked(uid, &main_unit);
       if (!die)
         continue;
-      if (SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
-        dies.push_back(die);
+      if (SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, main_unit, die))
+        dies.push_back(die.MainCUtoDWARFDIEPair(main_unit));
     }
   }
   if (name_type_mask & eFunctionNameTypeBase) {
-    DIEArray offsets;
+    std::vector<lldb::user_id_t> offsets;
     m_set.function_basenames.Find(name, offsets);
-    for (const DIERef &die_ref: offsets) {
-      DWARFDIE die = dwarf.GetDIE(die_ref);
+    for (user_id_t uid : offsets) {
+      DWARFCompileUnit *main_unit;
+      DWARFDIE die = dwarf.GetDIEUnlocked(uid, &main_unit);
       if (!die)
         continue;
-      if (SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
-        dies.push_back(die);
+      if (SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, main_unit, die))
+        dies.push_back(die.MainCUtoDWARFDIEPair(main_unit));
     }
     offsets.clear();
   }
 
   if (name_type_mask & eFunctionNameTypeMethod && !parent_decl_ctx.IsValid()) {
-    DIEArray offsets;
+    std::vector<lldb::user_id_t> offsets;
     m_set.function_methods.Find(name, offsets);
-    for (const DIERef &die_ref: offsets) {
-      if (DWARFDIE die = dwarf.GetDIE(die_ref))
-        dies.push_back(die);
+    for (user_id_t uid : offsets) {
+      DWARFCompileUnit *main_unit;
+      if (DWARFDIE die = dwarf.GetDIEUnlocked(uid, &main_unit))
+        dies.push_back(die.MainCUtoDWARFDIEPair(main_unit));
     }
   }
 
   if (name_type_mask & eFunctionNameTypeSelector &&
       !parent_decl_ctx.IsValid()) {
-    DIEArray offsets;
+    std::vector<lldb::user_id_t> offsets;
     m_set.function_selectors.Find(name, offsets);
-    for (const DIERef &die_ref: offsets) {
-      if (DWARFDIE die = dwarf.GetDIE(die_ref))
-        dies.push_back(die);
+    for (user_id_t uid : offsets) {
+      DWARFCompileUnit *main_unit;
+      if (DWARFDIE die = dwarf.GetDIEUnlocked(uid, &main_unit))
+        dies.push_back(die.MainCUtoDWARFDIEPair(main_unit));
     }
   }
 }
 
 void ManualDWARFIndex::GetFunctions(const RegularExpression &regex,
-                                    DIEArray &offsets) {
+                                    std::vector<lldb::user_id_t> &offsets) {
   Index();
 
   m_set.function_basenames.Find(regex, offsets);
   m_set.function_fullnames.Find(regex, offsets);
 }
 
 void ManualDWARFIndex::Dump(Stream &s) {
   s.Format("Manual DWARF index for ({0}) '{1:F}':",

lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.h

 //===-- NameToDIE.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_NAMETODIE_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_NAMETODIE_H
 
 #include <functional>
 
-#include "DIERef.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/lldb-defines.h"
 
 class DWARFUnit;
 
 class NameToDIE {
 public:
   NameToDIE() : m_map() {}
 
   ~NameToDIE() {}
 
   void Dump(lldb_private::Stream *s);
 
-  void Insert(lldb_private::ConstString name, const DIERef &die_ref);
+  void Insert(lldb_private::ConstString name, lldb::user_id_t uid);
 
   void Append(const NameToDIE &other);
 
   void Finalize();
 
   size_t Find(lldb_private::ConstString name,
-              DIEArray &info_array) const;
+              std::vector<lldb::user_id_t> &info_array) const;
 
   size_t Find(const lldb_private::RegularExpression &regex,
-              DIEArray &info_array) const;
+              std::vector<lldb::user_id_t> &info_array) const;
 
   size_t FindAllEntriesForUnit(const DWARFUnit &unit,
-                               DIEArray &info_array) const;
+                               std::vector<lldb::user_id_t> &info_array) const;
 
   void
   ForEach(std::function<bool(lldb_private::ConstString name,
-                             const DIERef &die_ref)> const
+                             lldb::user_id_t uid)> const
               &callback) const;
 
 protected:
-  lldb_private::UniqueCStringMap<DIERef> m_map;
+  lldb_private::UniqueCStringMap<lldb::user_id_t> m_map;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_NAMETODIE_H

lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.cpp

 using namespace lldb;
 using namespace lldb_private;
 
 void NameToDIE::Finalize() {
   m_map.Sort();
   m_map.SizeToFit();
 }
 
-void NameToDIE::Insert(ConstString name, const DIERef &die_ref) {
-  m_map.Append(name, die_ref);
+void NameToDIE::Insert(ConstString name, user_id_t uid) {
+  m_map.Append(name, uid);
 }
 
-size_t NameToDIE::Find(ConstString name, DIEArray &info_array) const {
+size_t NameToDIE::Find(ConstString name, std::vector<lldb::user_id_t> &info_array) const {
   return m_map.GetValues(name, info_array);
 }
 
 size_t NameToDIE::Find(const RegularExpression &regex,
-                       DIEArray &info_array) const {
+                       std::vector<lldb::user_id_t> &info_array) const {
   return m_map.GetValues(regex, info_array);
 }
 
 size_t NameToDIE::FindAllEntriesForUnit(const DWARFUnit &unit,
-                                        DIEArray &info_array) const {
+                                        std::vector<lldb::user_id_t> &info_array) const {
   const size_t initial_size = info_array.size();
   const uint32_t size = m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {
-    const DIERef &die_ref = m_map.GetValueAtIndexUnchecked(i);
+    user_id_t uid = m_map.GetValueAtIndexUnchecked(i);
+    llvm::Optional<DIERef> die_ref_opt = unit.GetSymbolFileDWARF().GetDIERef(uid);
+    if (!die_ref_opt)
+      continue;
+    DIERef die_ref = *die_ref_opt;
     if (unit.GetSymbolFileDWARF().GetDwoNum() == die_ref.dwo_num() &&
         unit.GetDebugSection() == die_ref.section() &&
         unit.GetOffset() <= die_ref.die_offset() &&
         die_ref.die_offset() < unit.GetNextUnitOffset())
-      info_array.push_back(die_ref);
+      info_array.push_back(uid);
   }
   return info_array.size() - initial_size;
 }
 
 void NameToDIE::Dump(Stream *s) {
+  llvm::raw_ostream &OS = s->AsRawOstream();
   const uint32_t size = m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {
-    s->Format("{0} \"{1}\"\n", m_map.GetValueAtIndexUnchecked(i),
-              m_map.GetCStringAtIndexUnchecked(i));
+    user_id_t uid = m_map.GetValueAtIndexUnchecked(i);
+    uint32_t upper = (uid >> 32) & 0x1fffffff;
+    if (upper != 0x1fffffff)
+      OS << llvm::format_hex_no_prefix(upper, 8) << "/";
+    OS << (uid & (1ULL << 63) ? "TYPE" : "INFO");
+    if (uid & (1ULL << 61))
+      OS << "/DWZCOMMON";
+    else if (uid & (1ULL << 62))
+      OS << "/DWZ";
+    OS << "/" << llvm::format_hex_no_prefix(uid & 0xffffffff, 8) << " \"" << m_map.GetCStringAtIndexUnchecked(i).GetStringRef() << "\"\n";
   }
 }
 
 void NameToDIE::ForEach(
-    std::function<bool(ConstString name, const DIERef &die_ref)> const
+    std::function<bool(ConstString name, user_id_t uid)> const
         &callback) const {
   const uint32_t size = m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {
     if (!callback(m_map.GetCStringAtIndexUnchecked(i),
                   m_map.GetValueAtIndexUnchecked(i)))
       break;
   }
 }
 
 void NameToDIE::Append(const NameToDIE &other) {
   const uint32_t size = other.m_map.GetSize();
   for (uint32_t i = 0; i < size; ++i) {
     m_map.Append(other.m_map.GetCStringAtIndexUnchecked(i),
                  other.m_map.GetValueAtIndexUnchecked(i));
   }
 }

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
 
   lldb_private::Type *ResolveTypeUID(lldb::user_id_t type_uid) override;
   llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
       lldb::user_id_t type_uid,
       const lldb_private::ExecutionContext *exe_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
 
-  lldb_private::Type *ResolveType(const DWARFDIE &die,
+  lldb_private::Type *ResolveType(DWARFCompileUnit *main_unit, const DWARFDIE &die,
                                   bool assert_not_being_parsed = true,
                                   bool resolve_function_context = false);
 
   lldb_private::CompilerDecl GetDeclForUID(lldb::user_id_t uid) override;
 
   lldb_private::CompilerDeclContext
   GetDeclContextForUID(lldb::user_id_t uid) override;
 
public:
   GetDeclContextDIEContainingDIE(const DWARFDIE &die);
 
   bool
   HasForwardDeclForClangType(const lldb_private::CompilerType &compiler_type);
 
   lldb_private::CompileUnit *
   GetCompUnitForDWARFCompUnit(DWARFCompileUnit &dwarf_cu);
 
   virtual size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
-                                         DIEArray &method_die_offsets);
+                                         std::vector<lldb::user_id_t> &method_die_offsets);
 
   bool Supports_DW_AT_APPLE_objc_complete_type(DWARFUnit *cu);
 
   lldb_private::DebugMacrosSP ParseDebugMacros(lldb::offset_t *offset);
 
   static DWARFDIE GetParentSymbolContextDIE(const DWARFDIE &die);
 
   lldb::ModuleSP GetExternalModule(lldb_private::ConstString name);
 
   typedef std::map<lldb_private::ConstString, lldb::ModuleSP>
       ExternalTypeModuleMap;
 
   /// Return the list of Clang modules imported by this SymbolFile.
   const ExternalTypeModuleMap& getExternalTypeModules() const {
       return m_external_type_modules;
   }
 
   virtual DWARFDIE GetDIE(const DIERef &die_ref);
 
   DWARFDIE GetDIE(lldb::user_id_t uid);
 
-  lldb::user_id_t GetUID(const DWARFBaseDIE &die) {
-    return GetUID(die.GetDIERef());
-  }
+  DWARFDIE GetDIEUnlocked(lldb::user_id_t uid, DWARFCompileUnit **main_unit_return = nullptr);
+
+  lldb::user_id_t GetUID(DWARFCompileUnit *main_unit, const DWARFBaseDIE &die);
 
-  lldb::user_id_t GetUID(const llvm::Optional<DIERef> &ref) {
-    return ref ? GetUID(*ref) : LLDB_INVALID_UID;
+  lldb::user_id_t GetUID(DWARFCompileUnit *main_unit, const llvm::Optional<DIERef> &ref) {
+    return ref ? GetUID(main_unit, *ref) : LLDB_INVALID_UID;
   }
 
-  lldb::user_id_t GetUID(DIERef ref);
+  lldb::user_id_t GetUID(DWARFCompileUnit *main_unit, DIERef ref);
 
   std::shared_ptr<SymbolFileDWARFDwo>
   GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die);
 
   virtual llvm::Optional<uint32_t> GetDwoNum() { return llvm::None; }
 
   /// If this is a DWARF object with a single CU, return its DW_AT_dwo_id.
   llvm::Optional<uint64_t> GetDWOId();
 
   static bool
-  DIEInDeclContext(const lldb_private::CompilerDeclContext &parent_decl_ctx,
+  DIEInDeclContext(const lldb_private::CompilerDeclContext &parent_decl_ctx, DWARFCompileUnit *main_unit,
                    const DWARFDIE &die);
 
   std::vector<std::unique_ptr<lldb_private::CallEdge>>
   ParseCallEdgesInFunction(UserID func_id) override;
 
   void Dump(lldb_private::Stream &s) override;
 
   void DumpClangAST(lldb_private::Stream &s) override;
 
   lldb_private::DWARFContext &GetDWARFContext() { return m_context; }
 
   const std::shared_ptr<SymbolFileDWARFDwo> &GetDwpSymbolFile();
 
   lldb_private::FileSpec GetFile(DWARFUnit &unit, size_t file_idx);
 
   static llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystem(DWARFUnit &unit);
 
   static DWARFASTParser *GetDWARFParser(DWARFUnit &unit);
 
   // CompilerDecl related functions
 
-  static lldb_private::CompilerDecl GetDecl(const DWARFDIE &die);
+  static lldb_private::CompilerDecl GetDecl(DWARFCompileUnit *main_unit, const DWARFDIE &die);
 
-  static lldb_private::CompilerDeclContext GetDeclContext(const DWARFDIE &die);
+  static lldb_private::CompilerDeclContext GetDeclContext(DWARFCompileUnit *main_unit, const DWARFDIE &die);
 
   static lldb_private::CompilerDeclContext
-  GetContainingDeclContext(const DWARFDIE &die);
+  GetContainingDeclContext(DWARFCompileUnit *main_unit, const DWARFDIE &die);
 
   static DWARFDeclContext GetDWARFDeclContext(const DWARFDIE &die);
 
   static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
 
   static lldb::LanguageType GetLanguage(DWARFUnit &unit);
 
+  llvm::Optional<DIERef> GetDIERef(lldb::user_id_t uid) {
+    llvm::Optional<DecodedUID> decoded = DecodeUID(uid);
+    if (!decoded)
+      return {};
+    lldbassert(&decoded->dwarf==this); // FIXME:DWZ
+    return decoded->ref;
+  }
+
 protected:
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *>
+  typedef llvm::DenseMap<std::pair<DWARFCompileUnit *, const DWARFDebugInfoEntry *>, lldb_private::Type *>
       DIEToTypePtr;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP>
+  typedef llvm::DenseMap<std::pair<DWARFCompileUnit *, const DWARFDebugInfoEntry *>, lldb::VariableSP>
       DIEToVariableSP;
-  typedef llvm::DenseMap<const DWARFDebugInfoEntry *,
+  typedef llvm::DenseMap<std::pair<DWARFCompileUnit *, const DWARFDebugInfoEntry *>,
                          lldb::opaque_compiler_type_t>
       DIEToClangType;
-  typedef llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> ClangTypeToDIE;
+  typedef llvm::DenseMap<lldb::opaque_compiler_type_t, lldb::user_id_t> ClangTypeToDIE;
 
   DISALLOW_COPY_AND_ASSIGN(SymbolFileDWARF);
 
   virtual void LoadSectionData(lldb::SectionType sect_type,
                                lldb_private::DWARFDataExtractor &data);
 
   bool DeclContextMatchesThisSymbolFile(
       const lldb_private::CompilerDeclContext &decl_ctx);
 
   uint32_t CalculateNumCompileUnits() override;
 
   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
 
   lldb_private::TypeList &GetTypeList() override;
 
   lldb::CompUnitSP ParseCompileUnit(DWARFCompileUnit &dwarf_cu);
 
-  virtual DWARFUnit *
+  DWARFCompileUnit *
   GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit);
 
   DWARFUnit *GetNextUnparsedDWARFCompileUnit(DWARFUnit *prev_cu);
 
-  bool GetFunction(const DWARFDIE &die, lldb_private::SymbolContext &sc);
+  bool GetFunction(DWARFCompileUnit *main_unit, const DWARFDIE &die, lldb_private::SymbolContext &sc);
 
   lldb_private::Function *ParseFunction(lldb_private::CompileUnit &comp_unit,
                                         const DWARFDIE &die);
 
   size_t ParseBlocksRecursive(lldb_private::CompileUnit &comp_unit,
                               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);
 
-  lldb_private::Type *ResolveTypeUID(const DWARFDIE &die,
+  lldb_private::Type *ResolveTypeUID(DWARFCompileUnit *main_unit, const DWARFDIE &die,
                                      bool assert_not_being_parsed);
 
-  lldb_private::Type *ResolveTypeUID(const DIERef &die_ref);
+  lldb_private::Type *ResolveTypeUID(DWARFCompileUnit *main_unit, const DIERef &die_ref);
 
   lldb::VariableSP ParseVariableDIE(const lldb_private::SymbolContext &sc,
                                     const DWARFDIE &die,
                                     const lldb::addr_t func_low_pc);
 
   size_t ParseVariables(const lldb_private::SymbolContext &sc,
                         const DWARFDIE &orig_die,
                         const lldb::addr_t func_low_pc, bool parse_siblings,
                         bool parse_children,
                         lldb_private::VariableList *cc_variable_list = nullptr);
 
   bool ClassOrStructIsVirtual(const DWARFDIE &die);
 
   // Given a die_offset, figure out the symbol context representing that die.
-  bool ResolveFunction(const DWARFDIE &die, bool include_inlines,
+  bool ResolveFunction(DWARFCompileUnit *main_unit, const DWARFDIE &die, bool include_inlines,
                        lldb_private::SymbolContextList &sc_list);
 
   /// Resolve functions and (possibly) blocks for the given file address and a
   /// compile unit. The compile unit comes from the sc argument and it must be
   /// set. The results of the lookup (if any) are written back to the symbol
   /// context.
   void ResolveFunctionAndBlock(lldb::addr_t file_vm_addr, bool lookup_block,
                                lldb_private::SymbolContext &sc);
 
   virtual lldb::TypeSP
   FindDefinitionTypeForDWARFDeclContext(const DWARFDeclContext &die_decl_ctx);
 
   virtual lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
       const DWARFDIE &die, lldb_private::ConstString type_name,
       bool must_be_implementation);
 
   lldb_private::Symbol *
   GetObjCClassSymbol(lldb_private::ConstString objc_class_name);
 
-  lldb::TypeSP GetTypeForDIE(const DWARFDIE &die,
+  lldb::TypeSP GetTypeForDIE(DWARFCompileUnit *main_unit, const DWARFDIE &die,
                              bool resolve_function_context = false);
 
   void SetDebugMapModule(const lldb::ModuleSP &module_sp) {
     m_debug_map_module_wp = module_sp;
   }
 
   SymbolFileDWARFDebugMap *GetDebugMapSymfile();
 
protected:
   /// binary. Returns the adjusted address, or \p file_addr if no adjustment is
   /// needed, on success and LLDB_INVALID_ADDRESS otherwise.
   lldb::addr_t FixupAddress(lldb::addr_t file_addr);
 
   bool FixupAddress(lldb_private::Address &addr);
 
   typedef llvm::SetVector<lldb_private::Type *> TypeSet;
 
-  void GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
+  void GetTypes(DWARFCompileUnit *main_unit, const DWARFDIE &die, dw_offset_t min_die_offset,
                 dw_offset_t max_die_offset, uint32_t type_mask,
                 TypeSet &type_set);
 
   typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t,
                                         lldb_private::Variable *>
       GlobalVariableMap;
 
   GlobalVariableMap &GetGlobalAranges();
virtual ClangTypeToDIE &GetForwardDeclClangTypeToDie() {
     return m_forward_decl_clang_type_to_die;
   }
 
   void BuildCuTranslationTable();
   llvm::Optional<uint32_t> GetDWARFUnitIndex(uint32_t cu_idx);
 
   struct DecodedUID {
     SymbolFileDWARF &dwarf;
+    // FIXME: DWZ
+    uint32_t main_cu;
     DIERef ref;
   };
+  llvm::Optional<DecodedUID> DecodeUIDUnlocked(lldb::user_id_t uid);
   llvm::Optional<DecodedUID> DecodeUID(lldb::user_id_t uid);
 
   void FindDwpSymbolFile();
 
   const lldb_private::FileSpecList &GetTypeUnitSupportFiles(DWARFTypeUnit &tu);
 
   lldb::ModuleWP m_debug_map_module_wp;
   SymbolFileDWARFDebugMap *m_debug_map_symfile;

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 }
 
 TypeList &SymbolFileDWARF::GetTypeList() {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
     return debug_map_symfile->GetTypeList();
   return SymbolFile::GetTypeList();
 }
-void SymbolFileDWARF::GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
+void SymbolFileDWARF::GetTypes(DWARFCompileUnit *main_unit, const DWARFDIE &die, dw_offset_t min_die_offset,
                                dw_offset_t max_die_offset, uint32_t type_mask,
                                TypeSet &type_set) {
   if (die) {
     const dw_offset_t die_offset = die.GetOffset();
 
     if (die_offset >= max_die_offset)
       return;
 
if (die_offset >= min_die_offset) {
         add_type = (type_mask & eTypeClassMemberPointer) != 0;
         break;
       default:
         break;
       }
 
       if (add_type) {
         const bool assert_not_being_parsed = true;
-        Type *type = ResolveTypeUID(die, assert_not_being_parsed);
+        Type *type = ResolveTypeUID(main_unit, die, assert_not_being_parsed);
         if (type)
           type_set.insert(type);
       }
     }
 
     for (DWARFDIE child_die = die.GetFirstChild(); child_die.IsValid();
          child_die = child_die.GetSibling()) {
-      GetTypes(child_die, min_die_offset, max_die_offset, type_mask, type_set);
+      GetTypes(main_unit, child_die, min_die_offset, max_die_offset, type_mask, type_set);
     }
   }
 }
 
 void SymbolFileDWARF::GetTypes(SymbolContextScope *sc_scope,
                                TypeClass type_mask, TypeList &type_list)
 
 {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   TypeSet type_set;
 
   CompileUnit *comp_unit = nullptr;
-  DWARFUnit *dwarf_cu = nullptr;
   if (sc_scope)
     comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
 
   if (comp_unit) {
-    dwarf_cu = GetDWARFCompileUnit(comp_unit);
+    DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(comp_unit);
     if (!dwarf_cu)
       return;
-    GetTypes(dwarf_cu->DIE(), dwarf_cu->GetOffset(),
+    GetTypes(dwarf_cu, dwarf_cu->DIE(), dwarf_cu->GetOffset(),
              dwarf_cu->GetNextUnitOffset(), type_mask, type_set);
   } else {
     DWARFDebugInfo &info = DebugInfo();
     const size_t num_cus = info.GetNumUnits();
     for (size_t cu_idx = 0; cu_idx < num_cus; ++cu_idx) {
-      dwarf_cu = info.GetUnitAtIndex(cu_idx);
+      DWARFCompileUnit *dwarf_cu = llvm::dyn_cast_or_null<DWARFCompileUnit>(info.GetUnitAtIndex(cu_idx));
       if (dwarf_cu)
-        GetTypes(dwarf_cu->DIE(), 0, UINT32_MAX, type_mask, type_set);
+        GetTypes(dwarf_cu, dwarf_cu->DIE(), 0, UINT32_MAX, type_mask, type_set);
     }
   }
 
   std::set<CompilerType> compiler_type_set;
   for (Type *type : type_set) {
     CompilerType compiler_type = type->GetForwardCompilerType();
     if (compiler_type_set.find(compiler_type) == compiler_type_set.end()) {
       compiler_type_set.insert(compiler_type);
void SymbolFileDWARF::InitializeObject() {
 
   if (!GetGlobalPluginProperties()->IgnoreFileIndexes()) {
     DWARFDataExtractor apple_names, apple_namespaces, apple_types, apple_objc;
     LoadSectionData(eSectionTypeDWARFAppleNames, apple_names);
     LoadSectionData(eSectionTypeDWARFAppleNamespaces, apple_namespaces);
     LoadSectionData(eSectionTypeDWARFAppleTypes, apple_types);
     LoadSectionData(eSectionTypeDWARFAppleObjC, apple_objc);
 
     m_index = AppleDWARFIndex::Create(
-        *GetObjectFile()->GetModule(), apple_names, apple_namespaces,
+        *this, apple_names, apple_namespaces,
         apple_types, apple_objc, m_context.getOrLoadStrData());
 
     if (m_index)
       return;
 
     DWARFDataExtractor debug_names;
     LoadSectionData(eSectionTypeDWARFDebugNames, debug_names);
     if (debug_names.GetByteSize() > 0) {
llvm::call_once(m_info_once_flag, [&] {
     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
     Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION,
                        static_cast<void *>(this));
     m_info = std::make_unique<DWARFDebugInfo>(*this, m_context);
   });
   return *m_info;
 }
 
-DWARFUnit *
+DWARFCompileUnit *
 SymbolFileDWARF::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) {
   if (!comp_unit)
     return nullptr;
 
+  if (SymbolFileDWARFDwo *dwo = llvm::dyn_cast<SymbolFileDWARFDwo>(this))
+    return dwo->GetBaseSymbolFile().GetDWARFCompileUnit(comp_unit);
+
   // The compile unit ID is the index of the DWARF unit.
   DWARFUnit *dwarf_cu = DebugInfo().GetUnitAtIndex(comp_unit->GetID());
-  if (dwarf_cu && dwarf_cu->GetUserData() == nullptr)
+  if (!dwarf_cu)
+    return nullptr;
+
+  if (dwarf_cu->GetUserData() == nullptr)
     dwarf_cu->SetUserData(comp_unit);
-  return dwarf_cu;
+  else
+    lldbassert(dwarf_cu->GetUserData() == comp_unit);
+  return llvm::cast<DWARFCompileUnit>(dwarf_cu);
 }
 
 DWARFDebugRanges *SymbolFileDWARF::GetDebugRanges() {
   if (!m_ranges) {
     static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
     Timer scoped_timer(func_cat, "%s this = %p", LLVM_PRETTY_FUNCTION,
                        static_cast<void *>(this));
 
bool SymbolFileDWARF::FixupAddress(Address &addr) {
   if (debug_map_symfile) {
     return debug_map_symfile->LinkOSOAddress(addr);
   }
   // This is a normal DWARF file, no address fixups need to happen
   return true;
 }
 lldb::LanguageType SymbolFileDWARF::ParseLanguage(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
     return GetLanguage(*dwarf_cu);
   else
     return eLanguageTypeUnknown;
 }
 
 size_t SymbolFileDWARF::ParseFunctions(CompileUnit &comp_unit) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat, "SymbolFileDWARF::ParseFunctions");
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (!dwarf_cu)
     return 0;
 
   size_t functions_added = 0;
   dwarf_cu = &dwarf_cu->GetNonSkeletonUnit();
   for (DWARFDebugInfoEntry &entry : dwarf_cu->dies()) {
     if (entry.Tag() != DW_TAG_subprogram)
       continue;
 
     DWARFDIE die(dwarf_cu, &entry);
-    if (comp_unit.FindFunctionByUID(die.GetID()))
+    if (comp_unit.FindFunctionByUID(die.GetID(dwarf_cu)))
       continue;
     if (ParseFunction(comp_unit, die))
       ++functions_added;
   }
   // FixupTypes();
   return functions_added;
 }
 
if (error) {
                                            prologue, tu.GetPathStyle());
     }
   }
   return list;
 }
 
 bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
     return dwarf_cu->GetIsOptimized();
   return false;
 }
 
 bool SymbolFileDWARF::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<SourceModule> &imported_modules) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   assert(sc.comp_unit);
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (!dwarf_cu)
     return false;
   if (!ClangModulesDeclVendor::LanguageSupportsClangModules(
           sc.comp_unit->GetLanguage()))
     return false;
   UpdateExternalModuleListIfNeeded();
 
   const DWARFDIE die = dwarf_cu->DIE();
bool SymbolFileDWARF::ParseImportedModules(
   return true;
 }
 
 bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (comp_unit.GetLineTable() != nullptr)
     return true;
 
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (!dwarf_cu)
     return false;
 
   const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
   if (!dwarf_cu_die)
     return false;
 
   const dw_offset_t cu_line_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(
DWARFDebugMacroEntry::ReadMacroEntries(
       offset, this, debug_macros_sp);
 
   return debug_macros_sp;
 }
 
 bool SymbolFileDWARF::ParseDebugMacros(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu == nullptr)
     return false;
 
   const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
   if (!dwarf_cu_die)
     return false;
 
   lldb::offset_t sect_offset =
case DW_TAG_lexical_block: {
         // inlined functions. These will be parsed on their own as separate
         // entities.
 
         if (depth > 0)
           break;
 
         block = parent_block;
       } else {
-        BlockSP block_sp(new Block(die.GetID()));
+        DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+        BlockSP block_sp(new Block(die.GetID(dwarf_cu)));
         parent_block->AddChild(block_sp);
         block = block_sp.get();
       }
       DWARFRangeList ranges;
       const char *name = nullptr;
       const char *mangled_name = nullptr;
 
       int decl_file = 0;

 
 void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
   auto *type_system = decl_ctx.GetTypeSystem();
   if (type_system != nullptr)
     type_system->GetDWARFParser()->EnsureAllDIEsInDeclContextHaveBeenParsed(
         decl_ctx);
 }
 
-user_id_t SymbolFileDWARF::GetUID(DIERef ref) {
+user_id_t SymbolFileDWARF::GetUID(DWARFCompileUnit *main_unit, const DWARFBaseDIE &die) {
+  return GetUID(die.IsValid() && llvm::isa<DWARFCompileUnit>(die.GetCU()) ? main_unit : nullptr, die.GetDIERef());
+}
+
+user_id_t SymbolFileDWARF::GetUID(DWARFCompileUnit *main_unit, DIERef ref) {
   if (GetDebugMapSymfile())
     return GetID() | ref.die_offset();
 
-  return user_id_t(GetDwoNum().getValueOr(0x7fffffff)) << 32 |
+// FIXME: Expensive
+DWARFDIE dwarfdie_check=GetDIE(ref);
+lldbassert(dwarfdie_check.IsValid());
+lldbassert(*dwarfdie_check.GetDIERef() == ref);
+
+  // WARNING: Use ref.dwo_num(), GetDwoNum() may not be valid in 'this'.
+  bool has_main_cu = main_unit && (&main_unit->GetSymbolFileDWARF() != this || !main_unit->ContainsDIEOffset(ref.die_offset()));
+  bool is_dwz = has_main_cu && !ref.dwo_num().hasValue();
+  bool is_dwz_common = is_dwz && &main_unit->GetSymbolFileDWARF() != this;
+  lldbassert(!ref.dwo_num().hasValue() || *ref.dwo_num() < 0x1fffffff);
+  static_assert(sizeof(ref.die_offset()) * 8 == 32, "");
+
+  user_id_t retval = user_id_t(is_dwz ? main_unit->GetID() : ref.dwo_num().getValueOr(0x1fffffff)) << 32 |
          ref.die_offset() |
+         user_id_t(is_dwz_common) << 61 |
+         user_id_t(is_dwz) << 62 |
          (lldb::user_id_t(ref.section() == DIERef::Section::DebugTypes) << 63);
+
+// FIXME: Expensive
+DWARFCompileUnit *main_unit_check;
+lldbassert(GetDIEUnlocked(retval, &main_unit_check)==dwarfdie_check);
+lldbassert(main_unit_check==main_unit||main_unit_check==nullptr);
+lldbassert(!!main_unit_check==is_dwz);
+
+  return retval;
 }
 
 llvm::Optional<SymbolFileDWARF::DecodedUID>
-SymbolFileDWARF::DecodeUID(lldb::user_id_t uid) {
-  // This method can be called without going through the symbol vendor so we
-  // need to lock the module.
-  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
+SymbolFileDWARF::DecodeUIDUnlocked(lldb::user_id_t uid) {
   // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API we
   // must make sure we use the correct DWARF file when resolving things. On
   // MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
   // SymbolFileDWARF classes, one for each .o file. We can often end up with
   // references to other DWARF objects and we must be ready to receive a
   // "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
   // instance.
   if (SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile()) {
     SymbolFileDWARF *dwarf = debug_map->GetSymbolFileByOSOIndex(
         debug_map->GetOSOIndexFromUserID(uid));
     return DecodedUID{
-        *dwarf, {llvm::None, DIERef::Section::DebugInfo, dw_offset_t(uid)}};
+        *dwarf, 0xffffffff/*main_cu*/, {llvm::None, DIERef::Section::DebugInfo, dw_offset_t(uid)}};
   }
   dw_offset_t die_offset = uid;
   if (die_offset == DW_INVALID_OFFSET)
     return llvm::None;
 
   DIERef::Section section =
       uid >> 63 ? DIERef::Section::DebugTypes : DIERef::Section::DebugInfo;
 
-  llvm::Optional<uint32_t> dwo_num = uid >> 32 & 0x7fffffff;
-  if (*dwo_num == 0x7fffffff)
+  bool is_dwz = (uid >> 62) & 1;
+  // FIXME: DWZ
+  __attribute__((unused)) bool is_dwz_common = (uid >> 61) & 1;
+
+  llvm::Optional<uint32_t> dwo_num = uid >> 32 & 0x1fffffff;
+  if (*dwo_num == 0x1fffffff || is_dwz)
     dwo_num = llvm::None;
 
-  return DecodedUID{*this, {dwo_num, section, die_offset}};
+  llvm::Optional<uint32_t> main_cu = uid >> 32 & 0x1fffffff;
+  if (*main_cu == 0x1fffffff || !is_dwz)
+    main_cu = llvm::None;
+
+  return DecodedUID{*this, main_cu.hasValue() ? *main_cu : 0xffffffff, {dwo_num, section, die_offset}};
 }
 
-DWARFDIE
-SymbolFileDWARF::GetDIE(lldb::user_id_t uid) {
+llvm::Optional<SymbolFileDWARF::DecodedUID>
+SymbolFileDWARF::DecodeUID(lldb::user_id_t uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
 
-  llvm::Optional<DecodedUID> decoded = DecodeUID(uid);
+  return DecodeUIDUnlocked(uid);
+}
+
+DWARFDIE
+SymbolFileDWARF::GetDIEUnlocked(lldb::user_id_t uid, DWARFCompileUnit **main_unit_return) {
+  llvm::Optional<DecodedUID> decoded = DecodeUIDUnlocked(uid);
 
-  if (decoded)
-    return decoded->dwarf.GetDIE(decoded->ref);
+  if (decoded) {
+    DWARFDIE die = decoded->dwarf.GetDIE(decoded->ref);
+    if (main_unit_return) {
+      // FIXME: DWZ
+      *main_unit_return = decoded->main_cu == 0xffffffff ? nullptr : llvm::cast<DWARFCompileUnit>(DebugInfo().GetUnitAtIndex(decoded->main_cu));
+    }
+    return die;
+  }
 
   return DWARFDIE();
 }
 
+DWARFDIE
+SymbolFileDWARF::GetDIE(lldb::user_id_t uid) {
+  // This method can be called without going through the symbol vendor so we
+  // need to lock the module.
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
+
+  return GetDIEUnlocked(uid);
+}
+
 CompilerDecl SymbolFileDWARF::GetDeclForUID(lldb::user_id_t type_uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
   // SymbolFileDWARF::GetDIE(). See comments inside the
   // SymbolFileDWARF::GetDIE() for details.
-  if (DWARFDIE die = GetDIE(type_uid))
-    return GetDecl(die);
+  DWARFCompileUnit *main_unit;
+  if (DWARFDIE die = GetDIEUnlocked(type_uid, &main_unit))
+    return GetDecl(main_unit, die);
   return CompilerDecl();
 }
 
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextForUID(lldb::user_id_t type_uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
   // SymbolFileDWARF::GetDIE(). See comments inside the
   // SymbolFileDWARF::GetDIE() for details.
-  if (DWARFDIE die = GetDIE(type_uid))
-    return GetDeclContext(die);
+  DWARFCompileUnit *main_unit;
+  if (DWARFDIE die = GetDIEUnlocked(type_uid, &main_unit))
+    return GetDeclContext(main_unit, die);
   return CompilerDeclContext();
 }
 
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextContainingUID(lldb::user_id_t type_uid) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
   // SymbolFileDWARF::GetDIE(). See comments inside the
   // SymbolFileDWARF::GetDIE() for details.
-  if (DWARFDIE die = GetDIE(type_uid))
-    return GetContainingDeclContext(die);
+  DWARFCompileUnit *main_unit;
+  if (DWARFDIE die = GetDIEUnlocked(type_uid, &main_unit))
+    return GetContainingDeclContext(main_unit, die);
   return CompilerDeclContext();
 }
 
 Type *SymbolFileDWARF::ResolveTypeUID(lldb::user_id_t type_uid) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
   // SymbolFileDWARF::GetDIE(). See comments inside the
   // SymbolFileDWARF::GetDIE() for details.
-  if (DWARFDIE type_die = GetDIE(type_uid))
-    return type_die.ResolveType();
+  DWARFCompileUnit *main_unit;
+  if (DWARFDIE type_die = GetDIEUnlocked(type_uid, &main_unit))
+    return type_die.ResolveType(main_unit);
   else
     return nullptr;
 }
 
 llvm::Optional<SymbolFile::ArrayInfo>
 SymbolFileDWARF::GetDynamicArrayInfoForUID(
     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   if (DWARFDIE type_die = GetDIE(type_uid))
     return DWARFASTParser::ParseChildArrayInfo(type_die, exe_ctx);
   else
     return llvm::None;
 }
 
-Type *SymbolFileDWARF::ResolveTypeUID(const DIERef &die_ref) {
-  return ResolveType(GetDIE(die_ref), true);
+Type *SymbolFileDWARF::ResolveTypeUID(DWARFCompileUnit *main_unit, const DIERef &die_ref) {
+  return ResolveType(main_unit, GetDIE(die_ref), true);
 }
 
-Type *SymbolFileDWARF::ResolveTypeUID(const DWARFDIE &die,
+Type *SymbolFileDWARF::ResolveTypeUID(DWARFCompileUnit *main_unit, 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());
 
if (decl_ctx_die) {
                 decl_ctx_die.GetOffset());
         } break;
 
         default:
           break;
         }
       }
     }
-    return ResolveType(die);
+    return ResolveType(main_unit, die);
   }
   return nullptr;
 }
 
 // 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(
CompilerType compiler_type_no_qualifiers =
       ClangUtil::RemoveFastQualifiers(compiler_type);
   auto die_it = GetForwardDeclClangTypeToDie().find(
       compiler_type_no_qualifiers.GetOpaqueQualType());
   if (die_it == GetForwardDeclClangTypeToDie().end()) {
     // We have already resolved this type...
     return true;
   }
 
-  DWARFDIE dwarf_die = GetDIE(die_it->getSecond());
+  DWARFCompileUnit *main_unit;
+  DWARFDIE dwarf_die = GetDIEUnlocked(die_it->getSecond(), &main_unit);
   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);
 
-    Type *type = GetDIEToType().lookup(dwarf_die.GetDIE());
+    Type *type = GetDIEToType().lookup(dwarf_die.MainCUtoDIEPair(main_unit));
+    lldbassert(type);
 
     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(),
+          dwarf_die.GetID(nullptr), dwarf_die.GetTagAsCString(),
           type->GetName().AsCString());
     assert(compiler_type);
     if (DWARFASTParser *dwarf_ast = GetDWARFParser(*dwarf_die.GetCU()))
       return dwarf_ast->CompleteTypeFromDWARF(dwarf_die, type, compiler_type);
   }
   return false;
 }
 
-Type *SymbolFileDWARF::ResolveType(const DWARFDIE &die,
+Type *SymbolFileDWARF::ResolveType(DWARFCompileUnit *main_unit, const DWARFDIE &die,
                                    bool assert_not_being_parsed,
                                    bool resolve_function_context) {
   if (die) {
-    Type *type = GetTypeForDIE(die, resolve_function_context).get();
+    Type *type = GetTypeForDIE(main_unit, die, resolve_function_context).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());
SymbolFileDWARF::GetCompUnitForDWARFCompUnit(DWARFCompileUnit &dwarf_cu) {
   if (non_dwo_cu->GetUserData() == nullptr) {
     // The symbol vendor doesn't know about this compile unit, we need to parse
     // and add it to the symbol vendor object.
     return ParseCompileUnit(*non_dwo_cu).get();
   }
   return static_cast<CompileUnit *>(non_dwo_cu->GetUserData());
 }
 
 size_t SymbolFileDWARF::GetObjCMethodDIEOffsets(ConstString class_name,
-                                                DIEArray &method_die_offsets) {
+                                                std::vector<lldb::user_id_t> &method_die_offsets) {
   method_die_offsets.clear();
   m_index->GetObjCMethods(class_name, method_die_offsets);
   return method_die_offsets.size();
 }
 
-bool SymbolFileDWARF::GetFunction(const DWARFDIE &die, SymbolContext &sc) {
+bool SymbolFileDWARF::GetFunction(DWARFCompileUnit *main_unit, const DWARFDIE &die, SymbolContext &sc) {
   sc.Clear(false);
 
-  if (die && llvm::isa<DWARFCompileUnit>(die.GetCU())) {
+  if (die && die.MainDWARFCompileUnit(main_unit)) {
     // Check if the symbol vendor already knows about this compile unit?
     sc.comp_unit =
-        GetCompUnitForDWARFCompUnit(llvm::cast<DWARFCompileUnit>(*die.GetCU()));
+        GetCompUnitForDWARFCompUnit(*die.MainDWARFCompileUnit(main_unit));
 
-    sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
+    sc.function = sc.comp_unit->FindFunctionByUID(die.GetID(main_unit)).get();
     if (sc.function == nullptr)
       sc.function = ParseFunction(*sc.comp_unit, die);
 
     if (sc.function) {
       sc.module_sp = sc.function->CalculateSymbolContextModule();
       return true;
     }
   }
 
   return false;
 }
 
 lldb::ModuleSP SymbolFileDWARF::GetExternalModule(ConstString name) {
   UpdateExternalModuleListIfNeeded();
   const auto &pos = m_external_type_modules.find(name);
   if (pos != m_external_type_modules.end())
     return pos->second;
   else
     return lldb::ModuleSP();
 }
 
 DWARFDIE
 SymbolFileDWARF::GetDIE(const DIERef &die_ref) {
   if (die_ref.dwo_num()) {
-    SymbolFileDWARF *dwarf = *die_ref.dwo_num() == 0x3fffffff
+    SymbolFileDWARF *dwarf = *die_ref.dwo_num() == 0x1ffffffe
                                  ? m_dwp_symfile.get()
                                  : this->DebugInfo()
                                        .GetUnitAtIndex(*die_ref.dwo_num())
                                        ->GetDwoSymbolFile();
     return dwarf->DebugInfo().GetDIE(die_ref);
   }
 
   return DebugInfo().GetDIE(die_ref);
SymbolFileDWARF::GlobalVariableMap &SymbolFileDWARF::GetGlobalAranges() {
   }
   return *m_global_aranges_up;
 }
 
 void SymbolFileDWARF::ResolveFunctionAndBlock(lldb::addr_t file_vm_addr,
                                               bool lookup_block,
                                               SymbolContext &sc) {
   assert(sc.comp_unit);
-  DWARFUnit &cu = GetDWARFCompileUnit(sc.comp_unit)->GetNonSkeletonUnit();
+  DWARFCompileUnit &cu = GetDWARFCompileUnit(sc.comp_unit)->GetNonSkeletonUnit();
   DWARFDIE function_die = cu.LookupAddress(file_vm_addr);
   DWARFDIE block_die;
   if (function_die) {
-    sc.function = sc.comp_unit->FindFunctionByUID(function_die.GetID()).get();
+    sc.function = sc.comp_unit->FindFunctionByUID(function_die.GetID(&cu)).get();
     if (sc.function == nullptr)
       sc.function = ParseFunction(*sc.comp_unit, function_die);
 
     if (sc.function && lookup_block)
       block_die = function_die.LookupDeepestBlock(file_vm_addr);
   }
 
   if (!sc.function || ! lookup_block)
     return;
 
   Block &block = sc.function->GetBlock(true);
   if (block_die)
-    sc.block = block.FindBlockByID(block_die.GetID());
+    sc.block = block.FindBlockByID(block_die.GetID(&cu));
   else
-    sc.block = block.FindBlockByID(function_die.GetID());
+    sc.block = block.FindBlockByID(function_die.GetID(&cu));
 }
 
 uint32_t SymbolFileDWARF::ResolveSymbolContext(const Address &so_addr,
                                                SymbolContextItem resolve_scope,
                                                SymbolContext &sc) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(func_cat,
void SymbolFileDWARF::FindGlobalVariables(
   llvm::StringRef basename;
   llvm::StringRef context;
   bool name_is_mangled = (bool)Mangled(name);
 
   if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name.GetCString(),
                                                       context, basename))
     basename = name.GetStringRef();
 
-  DIEArray die_offsets;
+  std::vector<lldb::user_id_t> die_offsets;
   m_index->GetGlobalVariables(ConstString(basename), die_offsets);
   const size_t num_die_matches = die_offsets.size();
   if (num_die_matches) {
     SymbolContext sc;
     sc.module_sp = m_objfile_sp->GetModule();
     assert(sc.module_sp);
 
     // Loop invariant: Variables up to this index have been checked for context
     // matches.
     uint32_t pruned_idx = original_size;
 
     bool done = false;
     for (size_t i = 0; i < num_die_matches && !done; ++i) {
-      const DIERef &die_ref = die_offsets[i];
-      DWARFDIE die = GetDIE(die_ref);
+      user_id_t uid = die_offsets[i];
+      DWARFCompileUnit *main_unit;
+      DWARFDIE die = GetDIEUnlocked(uid, &main_unit);
 
       if (die) {
         switch (die.Tag()) {
         default:
         case DW_TAG_subprogram:
         case DW_TAG_inlined_subroutine:
         case DW_TAG_try_block:
         case DW_TAG_catch_block:
           break;
 
         case DW_TAG_variable: {
           auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
           if (!dwarf_cu)
             continue;
           sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
 
           if (parent_decl_ctx) {
             if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
               CompilerDeclContext actual_parent_decl_ctx =
-                  dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
+                  dwarf_ast->GetDeclContextContainingUIDFromDWARF(main_unit, die);
               if (!actual_parent_decl_ctx ||
                   actual_parent_decl_ctx != parent_decl_ctx)
                 continue;
             }
           }
 
           ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false,
                          &variables);
           while (pruned_idx < variables.GetSize()) {
             VariableSP var_sp = variables.GetVariableAtIndex(pruned_idx);
             if (name_is_mangled ||
                 var_sp->GetName().GetStringRef().contains(name.GetStringRef()))
               ++pruned_idx;
             else
               variables.RemoveVariableAtIndex(pruned_idx);
           }
 
           if (variables.GetSize() - original_size >= max_matches)
             done = true;
         } break;
         }
       } else {
-        m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
+        m_index->ReportInvalidDIEID(uid, name.GetStringRef());
       }
     }
   }
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = variables.GetSize() - original_size;
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
GetObjectFile()->GetModule()->LogMessage(
         "SymbolFileDWARF::FindGlobalVariables (regex=\"%s\", "
         "max_matches=%u, variables)",
         regex.GetText().str().c_str(), max_matches);
   }
 
   // Remember how many variables are in the list before we search.
   const uint32_t original_size = variables.GetSize();
 
-  DIEArray die_offsets;
+  std::vector<lldb::user_id_t> die_offsets;
   m_index->GetGlobalVariables(regex, die_offsets);
 
   SymbolContext sc;
   sc.module_sp = m_objfile_sp->GetModule();
   assert(sc.module_sp);
 
   const size_t num_matches = die_offsets.size();
   if (num_matches) {
     for (size_t i = 0; i < num_matches; ++i) {
-      const DIERef &die_ref = die_offsets[i];
-      DWARFDIE die = GetDIE(die_ref);
+      user_id_t uid = die_offsets[i];
+      DWARFDIE die = GetDIE(uid);
 
       if (die) {
         DWARFCompileUnit *dwarf_cu =
             llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
         if (!dwarf_cu)
           continue;
         sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
 
         ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
 
         if (variables.GetSize() - original_size >= max_matches)
           break;
       } else
-        m_index->ReportInvalidDIERef(die_ref, regex.GetText());
+        m_index->ReportInvalidDIEID(uid, regex.GetText());
     }
   }
 }
 
-bool SymbolFileDWARF::ResolveFunction(const DWARFDIE &orig_die,
+bool SymbolFileDWARF::ResolveFunction(DWARFCompileUnit *main_unit, const DWARFDIE &orig_die,
                                       bool include_inlines,
                                       SymbolContextList &sc_list) {
   SymbolContext sc;
 
   if (!orig_die)
     return false;
 
   // If we were passed a die that is not a function, just return false...
while (true) {
       if (die) {
         if (die.Tag() == DW_TAG_subprogram)
           break;
       } else
         break;
     }
   }
   assert(die && die.Tag() == DW_TAG_subprogram);
-  if (GetFunction(die, sc)) {
+  if (GetFunction(main_unit, die, sc)) {
     Address addr;
     // Parse all blocks if needed
     if (inlined_die) {
       Block &function_block = sc.function->GetBlock(true);
-      sc.block = function_block.FindBlockByID(inlined_die.GetID());
+      sc.block = function_block.FindBlockByID(inlined_die.GetID(main_unit));
       if (sc.block == nullptr)
         sc.block = function_block.FindBlockByID(inlined_die.GetOffset());
       if (sc.block == nullptr || !sc.block->GetStartAddress(addr))
         addr.Clear();
     } else {
       sc.block = nullptr;
       addr = sc.function->GetAddressRange().GetBaseAddress();
     }
 
 
     if (auto section_sp = addr.GetSection()) {
       if (section_sp->GetPermissions() & ePermissionsExecutable) {
         sc_list.Append(sc);
         return true;
       }
     }
   }
 
   return false;
 }
 
-bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext &decl_ctx,
+bool SymbolFileDWARF::DIEInDeclContext(const CompilerDeclContext &decl_ctx, DWARFCompileUnit *main_unit,
                                        const DWARFDIE &die) {
   // If we have no parent decl context to match this DIE matches, and if the
   // parent decl context isn't valid, we aren't trying to look for any
   // particular decl context so any die matches.
   if (!decl_ctx.IsValid())
     return true;
 
   if (die) {
-    if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
+    if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.MainDWARFUnit(main_unit))) {
       if (CompilerDeclContext actual_decl_ctx =
-              dwarf_ast->GetDeclContextContainingUIDFromDWARF(die))
+              dwarf_ast->GetDeclContextContainingUIDFromDWARF(main_unit, die))
         return decl_ctx.IsContainedInLookup(actual_decl_ctx);
     }
   }
   return false;
 }
 
 void SymbolFileDWARF::FindFunctions(ConstString name,
                                     const CompilerDeclContext &parent_decl_ctx,
void SymbolFileDWARF::FindFunctions(ConstString name,
   if (name.IsEmpty())
     return;
 
   // Remember how many sc_list are in the list before we search in case we are
   // appending the results to a variable list.
 
   const uint32_t original_size = sc_list.GetSize();
 
-  llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
+  llvm::DenseSet<std::pair<DWARFCompileUnit *, const DWARFDebugInfoEntry *>> resolved_dies;
   DIEArray offsets;
 
-  std::vector<DWARFDIE> dies;
+  std::vector<std::pair<DWARFCompileUnit *, DWARFDIE>> dies;
   m_index->GetFunctions(name, *this, parent_decl_ctx, name_type_mask, dies);
-  for (const DWARFDIE &die : dies) {
-    if (resolved_dies.insert(die.GetDIE()).second)
-      ResolveFunction(die, include_inlines, sc_list);
+  for (const auto &diepair : dies) {
+    if (resolved_dies.insert(std::make_pair(diepair.first,diepair.second.GetDIE())).second)
+      ResolveFunction(diepair.first, diepair.second, include_inlines, sc_list);
   }
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = sc_list.GetSize() - original_size;
 
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
void SymbolFileDWARF::FindFunctions(const RegularExpression &regex,
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log) {
     GetObjectFile()->GetModule()->LogMessage(
         log, "SymbolFileDWARF::FindFunctions (regex=\"%s\", sc_list)",
         regex.GetText().str().c_str());
   }
 
-  DWARFDebugInfo &info = DebugInfo();
-  DIEArray offsets;
+  std::vector<lldb::user_id_t> offsets;
   m_index->GetFunctions(regex, offsets);
 
-  llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
-  for (DIERef ref : offsets) {
-    DWARFDIE die = info.GetDIE(ref);
+  llvm::DenseSet<std::pair<DWARFCompileUnit *, const DWARFDebugInfoEntry *>> resolved_dies;
+  for (user_id_t uid : offsets) {
+    DWARFCompileUnit *main_unit;
+    DWARFDIE die = GetDIEUnlocked(uid, &main_unit);
     if (!die) {
-      m_index->ReportInvalidDIERef(ref, regex.GetText());
+      m_index->ReportInvalidDIEID(uid, regex.GetText());
       continue;
     }
-    if (resolved_dies.insert(die.GetDIE()).second)
-      ResolveFunction(die, include_inlines, sc_list);
+    if (resolved_dies.insert(die.MainCUtoDIEPair(main_unit)).second)
+      ResolveFunction(main_unit, die, include_inlines, sc_list);
   }
 }
 
 void SymbolFileDWARF::GetMangledNamesForFunction(
     const std::string &scope_qualified_name,
     std::vector<ConstString> &mangled_names) {
   DWARFDebugInfo &info = DebugInfo();
   uint32_t num_comp_units = info.GetNumUnits();
else
           "SymbolFileDWARF::FindTypes (sc, name=\"%s\", parent_decl_ctx = "
           "NULL, max_matches=%u, type_list)",
           name.GetCString(), max_matches);
   }
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return;
 
-  DIEArray die_offsets;
+  std::vector<lldb::user_id_t> die_offsets;
   m_index->GetTypes(name, die_offsets);
   const size_t num_die_matches = die_offsets.size();
 
   for (size_t i = 0; i < num_die_matches; ++i) {
-    const DIERef &die_ref = die_offsets[i];
-    DWARFDIE die = GetDIE(die_ref);
+    user_id_t uid = die_offsets[i];
+    DWARFCompileUnit *main_unit;
+    DWARFDIE die = GetDIEUnlocked(uid, &main_unit);
     if (die) {
-      if (!DIEInDeclContext(parent_decl_ctx, die))
+      if (!DIEInDeclContext(parent_decl_ctx, main_unit, die))
         continue; // The containing decl contexts don't match
 
-      Type *matching_type = ResolveType(die, true, true);
+      Type *matching_type = ResolveType(main_unit, die, true, true);
       if (matching_type) {
         // We found a type pointer, now find the shared pointer form our type
         // list
         types.InsertUnique(matching_type->shared_from_this());
         if (types.GetSize() >= max_matches)
           break;
       }
     } else {
-      m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
+      m_index->ReportInvalidDIEID(uid, name.GetStringRef());
     }
   }
 
   // Next search through the reachable Clang modules. This only applies for
   // DWARF objects compiled with -gmodules that haven't been processed by
   // dsymutil.
   if (num_die_matches < max_matches) {
     UpdateExternalModuleListIfNeeded();
void SymbolFileDWARF::FindTypes(
   if (pattern.empty())
     return;
 
   ConstString name = pattern.back().name;
 
   if (!name)
     return;
 
-  DIEArray die_offsets;
+  std::vector<lldb::user_id_t> die_offsets;
   m_index->GetTypes(name, die_offsets);
   const size_t num_die_matches = die_offsets.size();
 
   for (size_t i = 0; i < num_die_matches; ++i) {
-    const DIERef &die_ref = die_offsets[i];
-    DWARFDIE die = GetDIE(die_ref);
+    user_id_t uid = die_offsets[i];
+    DWARFCompileUnit *main_unit;
+    DWARFDIE die = GetDIEUnlocked(uid, &main_unit);
 
     if (!die) {
-      m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
+      m_index->ReportInvalidDIEID(uid, name.GetStringRef());
       continue;
     }
     if (!languages[GetLanguage(*die.GetCU())])
       continue;
 
     llvm::SmallVector<CompilerContext, 4> die_context;
     die.GetDeclContext(die_context);
     if (!contextMatches(die_context, pattern))
       continue;
 
-    if (Type *matching_type = ResolveType(die, true, true)) {
+    if (Type *matching_type = ResolveType(main_unit, die, true, true)) {
       // We found a type pointer, now find the shared pointer form our type
       // list.
       types.InsertUnique(matching_type->shared_from_this());
     }
   }
 
   // Next search through the reachable Clang modules. This only applies for
   // DWARF objects compiled with -gmodules that haven't been processed by
GetObjectFile()->GetModule()->LogMessage(
         name.GetCString());
   }
 
   CompilerDeclContext namespace_decl_ctx;
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return namespace_decl_ctx;
 
-  DIEArray die_offsets;
+  std::vector<lldb::user_id_t> die_offsets;
   m_index->GetNamespaces(name, die_offsets);
   const size_t num_matches = die_offsets.size();
   if (num_matches) {
     for (size_t i = 0; i < num_matches; ++i) {
-      const DIERef &die_ref = die_offsets[i];
-      DWARFDIE die = GetDIE(die_ref);
+      user_id_t uid = die_offsets[i];
+      DWARFCompileUnit *main_unit;
+      DWARFDIE die = GetDIEUnlocked(uid, &main_unit);
 
       if (die) {
-        if (!DIEInDeclContext(parent_decl_ctx, die))
+        if (!DIEInDeclContext(parent_decl_ctx, main_unit, die))
           continue; // The containing decl contexts don't match
 
-        if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
-          namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
+        if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.MainDWARFUnit(main_unit))) {
+          namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(main_unit, die);
           if (namespace_decl_ctx)
             break;
         }
       } else {
-        m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
+        m_index->ReportInvalidDIEID(uid, name.GetStringRef());
       }
     }
   }
   if (log && namespace_decl_ctx) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => "
         "CompilerDeclContext(%p/%p) \"%s\"",
         name.GetCString(),
         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,
+TypeSP SymbolFileDWARF::GetTypeForDIE(DWARFCompileUnit *main_unit, 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.MainCUtoDIEPair(main_unit));
     if (type_ptr == nullptr) {
       SymbolContextScope *scope;
-      if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU()))
+      if (auto *dwarf_cu = die.MainDWARFCompileUnit(main_unit))
         scope = GetCompUnitForDWARFCompUnit(*dwarf_cu);
       else
         scope = GetObjectFile()->GetModule().get();
       assert(scope);
       SymbolContext sc(scope);
       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))
+          !GetFunction(main_unit, DWARFDIE(die.GetCU(), parent_die), sc))
         sc = sc_backup;
 
       type_sp = ParseType(sc, die, nullptr);
     } else if (type_ptr != DIE_IS_BEING_PARSED) {
       // Grab the existing type from the master types lists
       type_sp = type_ptr->shared_from_this();
     }
   }

 TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
     const DWARFDIE &die, ConstString type_name, bool must_be_implementation) {
 
   TypeSP type_sp;
 
   if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name)))
     return type_sp;
 
-  DIEArray die_offsets;
+  std::vector<lldb::user_id_t> die_offsets;
   m_index->GetCompleteObjCClass(type_name, must_be_implementation, die_offsets);
 
   const size_t num_matches = die_offsets.size();
 
   if (num_matches) {
     for (size_t i = 0; i < num_matches; ++i) {
-      const DIERef &die_ref = die_offsets[i];
-      DWARFDIE type_die = GetDIE(die_ref);
+      DWARFCompileUnit *main_unit;
+      user_id_t uid = die_offsets[i];
+      DWARFDIE type_die = GetDIEUnlocked(uid, &main_unit);
 
       if (type_die) {
         bool try_resolving_type = false;
 
         // Don't try and resolve the DIE we are looking for with the DIE
         // itself!
         if (type_die != die) {
           switch (type_die.Tag()) {
           case DW_TAG_class_type:
           case DW_TAG_structure_type:
             try_resolving_type = true;
             break;
           default:
             break;
           }
         }
 
         if (try_resolving_type) {
           if (must_be_implementation &&
               type_die.Supports_DW_AT_APPLE_objc_complete_type())
             try_resolving_type = type_die.GetAttributeValueAsUnsigned(
                 DW_AT_APPLE_objc_complete_type, 0);
 
           if (try_resolving_type) {
-            Type *resolved_type = ResolveType(type_die, false, true);
+            Type *resolved_type = ResolveType(main_unit, type_die, false, true);
             if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) {
               DEBUG_PRINTF("resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64
                            " (cu 0x%8.8" PRIx64 ")\n",
                            die.GetID(),
                            m_objfile_sp->GetFileSpec().GetFilename().AsCString(
                                "<Unknown>"),
                            type_die.GetID(), type_cu->GetID());
 
               if (die)
-                GetDIEToType()[die.GetDIE()] = resolved_type;
+                GetDIEToType()[die.MainCUtoDIEPair(main_unit)] = resolved_type;
               type_sp = resolved_type->shared_from_this();
               break;
             }
           }
         }
       } else {
-        m_index->ReportInvalidDIERef(die_ref, type_name.GetStringRef());
+        m_index->ReportInvalidDIEID(uid, type_name.GetStringRef());
       }
     }
   }
   return type_sp;
 }
 
 // This function helps to ensure that the declaration contexts match for two
 // different DIEs. Often times debug information will refer to a forward
if (type_name) {
         GetObjectFile()->GetModule()->LogMessage(
             log,
             "SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(tag=%"
             "s, qualified-name='%s')",
             DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
             dwarf_decl_ctx.GetQualifiedName());
       }
 
-      DIEArray die_offsets;
+      std::vector<lldb::user_id_t> die_offsets;
       m_index->GetTypes(dwarf_decl_ctx, die_offsets);
       const size_t num_matches = die_offsets.size();
 
       // Get the type system that we are looking to find a type for. We will
       // use this to ensure any matches we find are in a language that this
       // type system supports
       const LanguageType language = dwarf_decl_ctx.GetLanguage();
       TypeSystem *type_system = nullptr;
       if (language != eLanguageTypeUnknown) {
         auto type_system_or_err = GetTypeSystemForLanguage(language);
         if (auto err = type_system_or_err.takeError()) {
           LLDB_LOG_ERROR(
               lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
               std::move(err), "Cannot get TypeSystem for language {}",
               Language::GetNameForLanguageType(language));
         } else {
           type_system = &type_system_or_err.get();
         }
       }
       if (num_matches) {
         for (size_t i = 0; i < num_matches; ++i) {
-          const DIERef &die_ref = die_offsets[i];
-          DWARFDIE type_die = GetDIE(die_ref);
+          DWARFCompileUnit *main_unit;
+          user_id_t uid = die_offsets[i];
+          DWARFDIE type_die = GetDIEUnlocked(uid, &main_unit);
 
           if (type_die) {
             // Make sure type_die's langauge matches the type system we are
             // looking for. We don't want to find a "Foo" type from Java if we
             // are looking for a "Foo" type for C, C++, ObjC, or ObjC++.
             if (type_system &&
                 !type_system->SupportsLanguage(GetLanguage(*type_die.GetCU())))
               continue;
if (type_name) {
                     "qualified-name='%s') trying die=0x%8.8x (%s)",
                     DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
                     dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
                     type_dwarf_decl_ctx.GetQualifiedName());
               }
 
               // Make sure the decl contexts match all the way up
               if (dwarf_decl_ctx == type_dwarf_decl_ctx) {
-                Type *resolved_type = ResolveType(type_die, false);
+                Type *resolved_type = ResolveType(main_unit, type_die, false);
                 if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) {
                   type_sp = resolved_type->shared_from_this();
                   break;
                 }
               }
             } else {
               if (log) {
                 std::string qualified_name;
                 type_die.GetQualifiedName(qualified_name);
                 GetObjectFile()->GetModule()->LogMessage(
                     log,
                     "SymbolFileDWARF::"
                     "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
                     "qualified-name='%s') ignoring die=0x%8.8x (%s)",
                     DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
                     dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
                     qualified_name.c_str());
               }
             }
           } else {
-            m_index->ReportInvalidDIERef(die_ref, type_name.GetStringRef());
+            m_index->ReportInvalidDIEID(uid, type_name.GetStringRef());
           }
         }
       }
     }
   }
   return type_sp;
 }
 
TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
   if (!dwarf_ast)
     return {};
 
   TypeSP type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, type_is_new_ptr);
   if (type_sp) {
     GetTypeList().Insert(type_sp);
 
     if (die.Tag() == DW_TAG_subprogram) {
-      std::string scope_qualified_name(GetDeclContextForUID(die.GetID())
+      DWARFCompileUnit *main_unit = GetDWARFCompileUnit(sc.comp_unit);
+      std::string scope_qualified_name(GetDeclContextForUID(die.GetID(main_unit))
                                            .GetScopeQualifiedName()
                                            .AsCString(""));
       if (scope_qualified_name.size()) {
         m_function_scope_qualified_name_map[scope_qualified_name].insert(
             *die.GetDIERef());
       }
     }
   }
while (die) {
     if (isType(dwarf_tag) && tag != DW_TAG_subrange_type)
       ParseType(sc, die, &type_is_new);
 
     if (type_is_new)
       ++types_added;
 
     if (parse_children && die.HasChildren()) {
       if (die.Tag() == DW_TAG_subprogram) {
+        DWARFCompileUnit *main_unit = GetDWARFCompileUnit(sc.comp_unit);
         SymbolContext child_sc(sc);
-        child_sc.function = sc.comp_unit->FindFunctionByUID(die.GetID()).get();
+        child_sc.function = sc.comp_unit->FindFunctionByUID(die.GetID(main_unit)).get();
         types_added += ParseTypes(child_sc, die.GetFirstChild(), true, true);
       } else
         types_added += ParseTypes(sc, die.GetFirstChild(), true, true);
     }
 
     if (parse_siblings)
       die = die.GetSibling();
     else
       die.Clear();
   }
   return types_added;
 }
 
 size_t SymbolFileDWARF::ParseBlocksRecursive(Function &func) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   CompileUnit *comp_unit = func.GetCompileUnit();
   lldbassert(comp_unit);
 
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(comp_unit);
   if (!dwarf_cu)
     return 0;
 
   size_t functions_added = 0;
   const dw_offset_t function_die_offset = func.GetID();
   DWARFDIE function_die =
       dwarf_cu->GetNonSkeletonUnit().GetDIE(function_die_offset);
   if (function_die) {
     ParseBlocksRecursive(*comp_unit, &func.GetBlock(false), function_die,
                          LLDB_INVALID_ADDRESS, 0);
   }
 
   return functions_added;
 }
 
 size_t SymbolFileDWARF::ParseTypes(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   size_t types_added = 0;
-  DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu) {
     DWARFDIE dwarf_cu_die = dwarf_cu->DIE();
     if (dwarf_cu_die && dwarf_cu_die.HasChildren()) {
       SymbolContext sc;
       sc.comp_unit = &comp_unit;
+      sc.module_sp = sc.comp_unit->GetModule();
       types_added = ParseTypes(sc, dwarf_cu_die.GetFirstChild(), true, true);
     }
   }
 
   return types_added;
 }
 
 size_t SymbolFileDWARF::ParseVariablesForContext(const SymbolContext &sc) {
if (sc.function) {
 
       uint32_t vars_added = 0;
       VariableListSP variables(sc.comp_unit->GetVariableList(false));
 
       if (variables.get() == nullptr) {
         variables = std::make_shared<VariableList>();
         sc.comp_unit->SetVariableList(variables);
 
-        DIEArray die_offsets;
+        std::vector<lldb::user_id_t> die_offsets;
         m_index->GetGlobalVariables(dwarf_cu->GetNonSkeletonUnit(),
                                     die_offsets);
         const size_t num_matches = die_offsets.size();
         if (num_matches) {
           for (size_t i = 0; i < num_matches; ++i) {
-            const DIERef &die_ref = die_offsets[i];
-            DWARFDIE die = GetDIE(die_ref);
+            user_id_t uid = die_offsets[i];
+            DWARFDIE die = GetDIE(uid);
             if (die) {
               VariableSP var_sp(
                   ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
               if (var_sp) {
                 variables->AddVariableIfUnique(var_sp);
                 ++vars_added;
               }
             } else
-              m_index->ReportInvalidDIERef(die_ref, "");
+              m_index->ReportInvalidDIEID(uid, "");
           }
         }
       }
       return vars_added;
     }
   }
   return 0;
 }
 
 VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
                                              const DWARFDIE &die,
                                              const lldb::addr_t func_low_pc) {
-  if (die.GetDWARF() != this)
-    return die.GetDWARF()->ParseVariableDIE(sc, die, 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()];
+  DWARFCompileUnit *main_unit = GetDWARFCompileUnit(sc.comp_unit);
+
+  var_sp = GetDIEToVariable()[die.MainCUtoDIEPair(main_unit)];
   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) {
 
       if (symbol_context_scope == nullptr) {
         switch (parent_tag) {
         case DW_TAG_subprogram:
         case DW_TAG_inlined_subroutine:
         case DW_TAG_lexical_block:
           if (sc.function) {
             symbol_context_scope = sc.function->GetBlock(true).FindBlockByID(
-                sc_parent_die.GetID());
+                sc_parent_die.GetID(main_unit));
             if (symbol_context_scope == nullptr)
               symbol_context_scope = sc.function;
           }
           break;
 
         default:
           symbol_context_scope = sc.comp_unit;
           break;
         }
       }
 
       if (symbol_context_scope) {
         SymbolFileTypeSP type_sp(
-            new SymbolFileType(*this, GetUID(type_die_form.Reference())));
+            new SymbolFileType(*this, GetUID(main_unit, type_die_form.Reference())));
 
         if (const_value.Form() && type_sp && type_sp->GetType())
           location.UpdateValue(const_value.Unsigned(),
                                type_sp->GetType()->GetByteSize().getValueOr(0),
                                die.GetCU()->GetAddressByteSize());
 
         var_sp = std::make_shared<Variable>(
-            die.GetID(), name, mangled, type_sp, scope, symbol_context_scope,
+            die.GetID(main_unit), name, mangled, type_sp, scope, symbol_context_scope,
             scope_ranges, &decl, location, is_external, is_artificial,
             is_static_member);
 
         var_sp->SetLocationIsConstantValueData(location_is_const_value_data);
       } else {
         // Not ready to parse this variable yet. It might be a global or static
         // variable that is in a function scope and the function in the symbol
         // 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()[die.MainCUtoDIEPair(main_unit)] = var_sp;
     if (spec_die)
-      GetDIEToVariable()[spec_die.GetDIE()] = var_sp;
+      GetDIEToVariable()[spec_die.MainCUtoDIEPair(main_unit)] = 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,
                                        const DWARFDIE &orig_die,
                                        const lldb::addr_t func_low_pc,
                                        bool parse_siblings, bool parse_children,
                                        VariableList *cc_variable_list) {
   if (!orig_die)
     return 0;
 
   VariableListSP variable_list_sp;
+  DWARFCompileUnit *main_unit = GetDWARFCompileUnit(sc.comp_unit);
 
   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()[die.MainCUtoDIEPair(main_unit)];
     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() == nullptr) {
           DWARFDIE sc_parent_die = GetParentSymbolContextDIE(orig_die);
           dw_tag_t parent_tag = sc_parent_die.Tag();
           switch (parent_tag) {
           case DW_TAG_compile_unit:
           case DW_TAG_partial_unit:
             if (sc.comp_unit != nullptr) {
               variable_list_sp = sc.comp_unit->GetVariableList(false);
               if (variable_list_sp.get() == nullptr) {
                 variable_list_sp = std::make_shared<VariableList>();
               }
             } else {
               GetObjectFile()->GetModule()->ReportError(
                   "parent 0x%8.8" PRIx64 " %s with no valid compile unit in "
                   "symbol context for 0x%8.8" PRIx64 " %s.\n",
-                  sc_parent_die.GetID(), sc_parent_die.GetTagAsCString(),
-                  orig_die.GetID(), orig_die.GetTagAsCString());
+                  sc_parent_die.GetID(nullptr), sc_parent_die.GetTagAsCString(),
+                  orig_die.GetID(nullptr), orig_die.GetTagAsCString());
             }
             break;
 
           case DW_TAG_subprogram:
           case DW_TAG_inlined_subroutine:
           case DW_TAG_lexical_block:
             if (sc.function != nullptr) {
               // Check to see if we already have parsed the variables for the
               // given scope
 
               Block *block = sc.function->GetBlock(true).FindBlockByID(
-                  sc_parent_die.GetID());
+                  sc_parent_die.GetID(main_unit));
               if (block == nullptr) {
                 // This must be a specification or abstract origin with a
                 // concrete block counterpart in the current function. We need
                 // to find the concrete block so we can correctly add the
                 // variable to it
                 const DWARFDIE concrete_block_die =
                     FindBlockContainingSpecification(
                         GetDIE(sc.function->GetID()),
                         sc_parent_die.GetOffset());
                 if (concrete_block_die)
                   block = sc.function->GetBlock(true).FindBlockByID(
-                      concrete_block_die.GetID());
+                      concrete_block_die.GetID(main_unit));
               }
 
               if (block != nullptr) {
                 const bool can_create = false;
                 variable_list_sp = block->GetBlockVariableList(can_create);
                 if (variable_list_sp.get() == nullptr) {
                   variable_list_sp = std::make_shared<VariableList>();
                   block->SetVariableList(variable_list_sp);
                 }
               }
             }
             break;
 
           default:
             GetObjectFile()->GetModule()->ReportError(
                 "didn't find appropriate parent DIE for variable list for "
                 "0x%8.8" PRIx64 " %s.\n",
-                orig_die.GetID(), orig_die.GetTagAsCString());
+                orig_die.GetID(nullptr), orig_die.GetTagAsCString());
             break;
           }
         }
 
         if (variable_list_sp) {
           VariableSP var_sp(ParseVariableDIE(sc, die, func_low_pc));
           if (var_sp) {
             variable_list_sp->AddVariableIfUnique(var_sp);
if (FileSystem::Instance().Exists(dwp_filespec)) {
       lldb::offset_t dwp_file_data_offset = 0;
       ObjectFileSP dwp_obj_file = ObjectFile::FindPlugin(
           GetObjectFile()->GetModule(), &dwp_filespec, 0,
           FileSystem::Instance().GetByteSize(dwp_filespec), dwp_file_data_sp,
           dwp_file_data_offset);
       if (!dwp_obj_file)
         return;
       m_dwp_symfile =
-          std::make_shared<SymbolFileDWARFDwo>(*this, dwp_obj_file, 0x3fffffff);
+          std::make_shared<SymbolFileDWARFDwo>(*this, dwp_obj_file, 0x1ffffffe);
     }
   });
   return m_dwp_symfile;
 }
 
 llvm::Expected<TypeSystem &> SymbolFileDWARF::GetTypeSystem(DWARFUnit &unit) {
   return unit.GetSymbolFileDWARF().GetTypeSystemForLanguage(GetLanguage(unit));
 }
 
 DWARFASTParser *SymbolFileDWARF::GetDWARFParser(DWARFUnit &unit) {
   auto type_system_or_err = GetTypeSystem(unit);
   if (auto err = type_system_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Unable to get DWARFASTParser");
     return nullptr;
   }
   return type_system_or_err->GetDWARFParser();
 }
 
-CompilerDecl SymbolFileDWARF::GetDecl(const DWARFDIE &die) {
-  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
-    return dwarf_ast->GetDeclForUIDFromDWARF(die);
+CompilerDecl SymbolFileDWARF::GetDecl(DWARFCompileUnit *main_unit, const DWARFDIE &die) {
+  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.MainDWARFUnit(main_unit)))
+    return dwarf_ast->GetDeclForUIDFromDWARF(main_unit, die);
   return CompilerDecl();
 }
 
-CompilerDeclContext SymbolFileDWARF::GetDeclContext(const DWARFDIE &die) {
-  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
-    return dwarf_ast->GetDeclContextForUIDFromDWARF(die);
+CompilerDeclContext SymbolFileDWARF::GetDeclContext(DWARFCompileUnit *main_unit, const DWARFDIE &die) {
+  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.MainDWARFUnit(main_unit)))
+    return dwarf_ast->GetDeclContextForUIDFromDWARF(main_unit, die);
   return CompilerDeclContext();
 }
 
 CompilerDeclContext
-SymbolFileDWARF::GetContainingDeclContext(const DWARFDIE &die) {
-  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU()))
-    return dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
+SymbolFileDWARF::GetContainingDeclContext(DWARFCompileUnit *main_unit, const DWARFDIE &die) {
+  if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.MainDWARFUnit(main_unit)))
+    return dwarf_ast->GetDeclContextContainingUIDFromDWARF(main_unit, die);
   return CompilerDeclContext();
 }
 
 DWARFDeclContext SymbolFileDWARF::GetDWARFDeclContext(const DWARFDIE &die) {
   if (!die.IsValid())
     return {};
   DWARFDeclContext dwarf_decl_ctx =
       die.GetDIE()->GetDWARFDeclContext(die.GetCU());

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

public:
 
   SymbolFileDWARFDwo(SymbolFileDWARF &m_base_symbol_file,
                      lldb::ObjectFileSP objfile, uint32_t id);
 
   ~SymbolFileDWARFDwo() override = default;
 
   DWARFCompileUnit *GetDWOCompileUnitForHash(uint64_t hash);
 
   size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
-                                 DIEArray &method_die_offsets) override;
+                                 std::vector<lldb::user_id_t> &method_die_offsets) override;
 
   llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   DWARFDIE
   GetDIE(const DIERef &die_ref) override;
 
   llvm::Optional<uint32_t> GetDwoNum() override { return GetID() >> 32; }
 
+  SymbolFileDWARF &GetBaseSymbolFile() { return m_base_symbol_file; }
+
 protected:
   DIEToTypePtr &GetDIEToType() override;
 
   DIEToVariableSP &GetDIEToVariable() override;
 
   DIEToClangType &GetForwardDeclDieToClangType() override;
 
   ClangTypeToDIE &GetForwardDeclClangTypeToDie() override;
 
   UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() override;
 
   lldb::TypeSP FindDefinitionTypeForDWARFDeclContext(
       const DWARFDeclContext &die_decl_ctx) override;
 
   lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
       const DWARFDIE &die, lldb_private::ConstString type_name,
       bool must_be_implementation) override;
 
-  SymbolFileDWARF &GetBaseSymbolFile() { return m_base_symbol_file; }
-
   /// If this file contains exactly one compile unit, this function will return
   /// it. Otherwise it returns nullptr.
   DWARFCompileUnit *FindSingleCompileUnit();
 
   SymbolFileDWARF &m_base_symbol_file;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARFDWO_H

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

 }
 
 SymbolFileDWARF::ClangTypeToDIE &
 SymbolFileDWARFDwo::GetForwardDeclClangTypeToDie() {
   return GetBaseSymbolFile().GetForwardDeclClangTypeToDie();
 }
 
 size_t SymbolFileDWARFDwo::GetObjCMethodDIEOffsets(
-    lldb_private::ConstString class_name, DIEArray &method_die_offsets) {
+    lldb_private::ConstString class_name, std::vector<lldb::user_id_t> &method_die_offsets) {
   return GetBaseSymbolFile().GetObjCMethodDIEOffsets(class_name,
                                                      method_die_offsets);
 }
 
 UniqueDWARFASTTypeMap &SymbolFileDWARFDwo::GetUniqueDWARFASTTypeMap() {
   return GetBaseSymbolFile().GetUniqueDWARFASTTypeMap();
 }
 

lldb/test/Shell/SymbolFile/DWARF/DW_AT_low_pc-addrx.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_rnglists" \
 # RUN:   -o exit | FileCheck %s
 
 # CHECK-LABEL: image lookup -v -s lookup_rnglists
-# CHECK:  Function: id = {0x7fffffff0000002d}, name = "rnglists", range = [0x0000000000000000-0x0000000000000003)
-# CHECK:    Blocks: id = {0x7fffffff0000002d}, range = [0x00000000-0x00000003)
-# CHECK-NEXT:       id = {0x7fffffff00000043}, range = [0x00000001-0x00000002)
+# CHECK:  Function: id = {0x1fffffff0000002d}, name = "rnglists", range = [0x0000000000000000-0x0000000000000003)
+# CHECK:    Blocks: id = {0x1fffffff0000002d}, range = [0x00000000-0x00000003)
+# CHECK-NEXT:       id = {0x1fffffff00000043}, range = [0x00000001-0x00000002)
 
         .text
 rnglists:
         nop
 .Lblock1_begin:
 lookup_rnglists:
         nop
 .Lblock1_end:

lldb/test/Shell/SymbolFile/DWARF/array-sizes.s

 # This tests a bug where we would incorrectly parse the size of an array if that
 # size happened to match an existing DIE offset. This happened because we
 # misinterpreted that value as a reference to a DIE specifying the VLA size even
 # though the form was a data form (as it should be).
 
 # REQUIRES: lld, x86
 
 # RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: lldb-test symbols %t | FileCheck %s
 
-# CHECK: Variable{0x7fffffff0000001e}, name = "X"
-# CHECK-SAME: type = {7fffffff00000033} 0x{{[0-9A-F]*}} (char [56])
+# CHECK: Variable{0x1fffffff0000001e}, name = "X"
+# CHECK-SAME: type = {1fffffff00000033} 0x{{[0-9A-F]*}} (char [56])
 
 
 # Generated from "char X[47];"
 # The array size was modified by hand.
 
   .text
   .file "-"
   .file 1 "/tmp" "<stdin>"

lldb/test/Shell/SymbolFile/DWARF/debug-types-address-ranges.s

 # Check address lookup works correctly in the presence of type units.
 # Specifically check that we don't use the line table pointed to by the
 # DW_AT_stmt_list of the type unit (which used only for the file names) to
 # compute address range for the type unit as type units don't describe any
 # addresses. The addresses should always resolve to the relevant compile units.
 
 # REQUIRES: lld, x86
 
 # RUN: llvm-mc -dwarf-version=5 -triple x86_64-pc-linux %s -filetype=obj >%t.o
 # RUN: ld.lld %t.o -o %t -image-base=0x47000 -z separate-code
 # RUN: %lldb %t -o "image lookup -a 0x48000 -v" -o exit | FileCheck %s
 
 # CHECK:   CompileUnit: id = {0x00000001}, file = "/tmp/a.cc", language = "c++"
-# CHECK:      Function: id = {0x7fffffff0000006a}, name = "::_start({{.*}})", range = [0x0000000000048000-0x000000000004800c)
+# CHECK:      Function: id = {0x1fffffff0000006a}, name = "::_start({{.*}})", range = [0x0000000000048000-0x000000000004800c)
 # CHECK:     LineEntry: [0x0000000000048000-0x000000000004800a): /tmp/a.cc:4
 # CHECK:        Symbol: id = {0x00000002}, range = [0x0000000000048000-0x000000000004800c), name="_start"
-# CHECK:      Variable: id = {0x7fffffff00000075}, name = "v1", {{.*}} decl = a.cc:4
-# CHECK:      Variable: id = {0x7fffffff00000080}, name = "v2", {{.*}} decl = a.cc:4
+# CHECK:      Variable: id = {0x1fffffff00000075}, name = "v1", {{.*}} decl = a.cc:4
+# CHECK:      Variable: id = {0x1fffffff00000080}, name = "v2", {{.*}} decl = a.cc:4
 
 
 # Output generated via
 # clang -g -fdebug-types-section -gdwarf-5 -S
 # from
 # enum E1 { e1 };
 # enum E2 { e2 };
 # extern "C" void _start(E1 v1, E2 v2) {}

lldb/test/Shell/SymbolFile/DWARF/debug-types-dwarf5.s

 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s f1" -o exit | FileCheck %s
 
-# CHECK:  Function: id = {0x7fffffff0000003c}, name = "f1", range = [0x0000000000000000-0x0000000000000001)
-# CHECK:    Blocks: id = {0x7fffffff0000003c}, range = [0x00000000-0x00000001)
+# CHECK:  Function: id = {0x1fffffff0000003c}, name = "f1", range = [0x0000000000000000-0x0000000000000001)
+# CHECK:    Blocks: id = {0x1fffffff0000003c}, range = [0x00000000-0x00000001)
 
 
         .text
         .globl  f1
         .type   f1,@function
 f1:
         nop
 .Lfunc_end0:

lldb/test/Shell/SymbolFile/DWARF/debug_ranges-missing-section.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_ranges" -o exit 2>&1 | FileCheck %s
 
 # CHECK: DIE has DW_AT_ranges(0x47) attribute, but range extraction failed (No debug_ranges section),
-# CHECK:  Function: id = {0x7fffffff0000001c}, name = "ranges", range = [0x0000000000000000-0x0000000000000004)
-# CHECK:    Blocks: id = {0x7fffffff0000001c}, range = [0x00000000-0x00000004)
+# CHECK:  Function: id = {0x1fffffff0000001c}, name = "ranges", range = [0x0000000000000000-0x0000000000000004)
+# CHECK:    Blocks: id = {0x1fffffff0000001c}, range = [0x00000000-0x00000004)
 
         .text
         .p2align 12
         .globl  ranges
         .type   ranges,@function
 ranges:                                    # @ranges
         nop
 lookup_ranges:

lldb/test/Shell/SymbolFile/DWARF/debug_ranges.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_ranges" -o exit | FileCheck %s
 
-# CHECK:  Function: id = {0x7fffffff0000002b}, name = "ranges", range = [0x0000000000000000-0x0000000000000004)
-# CHECK:    Blocks: id = {0x7fffffff0000002b}, range = [0x00000000-0x00000004)
-# CHECK-NEXT:       id = {0x7fffffff0000003f}, ranges = [0x00000001-0x00000002)[0x00000003-0x00000004)
+# CHECK:  Function: id = {0x1fffffff0000002b}, name = "ranges", range = [0x0000000000000000-0x0000000000000004)
+# CHECK:    Blocks: id = {0x1fffffff0000002b}, range = [0x00000000-0x00000004)
+# CHECK-NEXT:       id = {0x1fffffff0000003f}, ranges = [0x00000001-0x00000002)[0x00000003-0x00000004)
 
         .text
         .p2align 12
 ranges:
         nop
 .Lblock1_begin:
 lookup_ranges:
         nop

lldb/test/Shell/SymbolFile/DWARF/debug_rnglists.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_rnglists" \
 # RUN:   -o "image lookup -v -s lookup_rnglists2" -o exit | FileCheck %s
 
 # CHECK-LABEL: image lookup -v -s lookup_rnglists
-# CHECK:  Function: id = {0x7fffffff00000030}, name = "rnglists", range = [0x0000000000000000-0x0000000000000004)
-# CHECK:    Blocks: id = {0x7fffffff00000030}, range = [0x00000000-0x00000004)
-# CHECK-NEXT:       id = {0x7fffffff00000046}, ranges = [0x00000001-0x00000002)[0x00000003-0x00000004)
+# CHECK:  Function: id = {0x1fffffff00000030}, name = "rnglists", range = [0x0000000000000000-0x0000000000000004)
+# CHECK:    Blocks: id = {0x1fffffff00000030}, range = [0x00000000-0x00000004)
+# CHECK-NEXT:       id = {0x1fffffff00000046}, ranges = [0x00000001-0x00000002)[0x00000003-0x00000004)
 
 # CHECK-LABEL: image lookup -v -s lookup_rnglists2
-# CHECK:  Function: id = {0x7fffffff0000007a}, name = "rnglists2", range = [0x0000000000000004-0x0000000000000007)
-# CHECK:    Blocks: id = {0x7fffffff0000007a}, range = [0x00000004-0x00000007)
-# CHECK-NEXT:       id = {0x7fffffff00000091}, range = [0x00000005-0x00000007)
+# CHECK:  Function: id = {0x1fffffff0000007a}, name = "rnglists2", range = [0x0000000000000004-0x0000000000000007)
+# CHECK:    Blocks: id = {0x1fffffff0000007a}, range = [0x00000004-0x00000007)
+# CHECK-NEXT:       id = {0x1fffffff00000091}, range = [0x00000005-0x00000007)
 
         .text
         .p2align 12
 rnglists:
         nop
 .Lblock1_begin:
 lookup_rnglists:
         nop

lldb/test/Shell/SymbolFile/DWARF/dwarf5_locations.s

 # This tests that lldb is able to process DW_OP_addrx tags introduced in dwarf5.
 
 # REQUIRES: lld, x86
 
 # RUN: llvm-mc -g -dwarf-version=5 -triple x86_64-unknown-linux-gnu %s -filetype=obj > %t.o
 # RUN: ld.lld -m elf_x86_64 %t.o -o %t 
 # RUN: lldb-test symbols %t | FileCheck %s
 
-# CHECK: Variable{0x7fffffff00000011}, name = "color"
+# CHECK: Variable{0x1fffffff00000011}, name = "color"
 # CHECK-SAME: location = DW_OP_addrx 0x0
 
         .text
         .section        .debug_str,"MS",@progbits,1
 .Lstr_offsets_base0:
         .asciz  "color"
 
         .section        .debug_str_offsets,"",@progbits

lldb/test/Shell/SymbolFile/DWARF/dwp-debug-types.s

 # CHECK-NEXT: }
 
 # CHECK-LABEL: target variable A
 # CHECK: (ENUM0) A = case0
 # CHECK: (ENUM1) A = case0
 
 # Make sure each entity is present in the index only once.
 # SYMBOLS:      Globals and statics:
-# SYMBOLS-DAG: 3fffffff/INFO/00000023 "A"
-# SYMBOLS-DAG: 3fffffff/INFO/0000005a "A"
+# SYMBOLS-DAG: 1ffffffe/INFO/00000023 "A"
+# SYMBOLS-DAG: 1ffffffe/INFO/0000005a "A"
 # SYMBOLS-EMPTY:
 
 # SYMBOLS: Types:
-# SYMBOLS-DAG: 3fffffff/TYPE/00000018 "ENUM0"
-# SYMBOLS-DAG: 3fffffff/TYPE/0000004d "ENUM1"
-# SYMBOLS-DAG: 3fffffff/TYPE/0000002d "int"
-# SYMBOLS-DAG: 3fffffff/TYPE/00000062 "int"
+# SYMBOLS-DAG: 1ffffffe/TYPE/00000018 "ENUM0"
+# SYMBOLS-DAG: 1ffffffe/TYPE/0000004d "ENUM1"
+# SYMBOLS-DAG: 1ffffffe/TYPE/0000002d "int"
+# SYMBOLS-DAG: 1ffffffe/TYPE/00000062 "int"
 # SYMBOLS-EMPTY:
 
 .ifdef MAIN
         .section        .debug_abbrev,"",@progbits
         .byte   1                       # Abbreviation Code
         .byte   17                      # DW_TAG_compile_unit
         .byte   0                       # DW_CHILDREN_no
         .ascii  "\260B"                 # DW_AT_GNU_dwo_name

lldb/unittests/SymbolFile/DWARF/DWARFASTParserClangTests.cpp

 //===-- DWARFASTParserClangTests.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Plugins/SymbolFile/DWARF/DWARFASTParserClang.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDIE.h"
+#include "Plugins/SymbolFile/DWARF/DWARFCompileUnit.h"
 #include "TestingSupport/Symbol/YAMLModuleTester.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
const char *yamldata =
       "        Values:          []\n";
 
   YAMLModuleTester t(yamldata, "i386-unknown-linux");
   ASSERT_TRUE((bool)t.GetDwarfUnit());
 
   TypeSystemClang ast_ctx("dummy ASTContext", HostInfoBase::GetTargetTriple());
   DWARFASTParserClangStub ast_parser(ast_ctx);
 
-  DWARFUnit *unit = t.GetDwarfUnit().get();
+  DWARFCompileUnit *unit = llvm::cast<DWARFCompileUnit>(t.GetDwarfUnit().get());
   const DWARFDebugInfoEntry *die_first = unit->DIE().GetDIE();
   const DWARFDebugInfoEntry *die_child0 = die_first->GetFirstChild();
   const DWARFDebugInfoEntry *die_child1 = die_child0->GetSibling();
   const DWARFDebugInfoEntry *die_child2 = die_child1->GetSibling();
   const DWARFDebugInfoEntry *die_child3 = die_child2->GetSibling();
   std::vector<DWARFDIE> dies = {
       DWARFDIE(unit, die_child0), DWARFDIE(unit, die_child1),
       DWARFDIE(unit, die_child2), DWARFDIE(unit, die_child3)};
   std::vector<clang::DeclContext *> decl_ctxs = {
       (clang::DeclContext *)1LL, (clang::DeclContext *)2LL,
       (clang::DeclContext *)2LL, (clang::DeclContext *)3LL};
   for (int i = 0; i < 4; ++i)
-    ast_parser.LinkDeclContextToDIE(decl_ctxs[i], dies[i]);
+    ast_parser.LinkDeclContextToDIE(decl_ctxs[i], unit, dies[i]);
   ast_parser.EnsureAllDIEsInDeclContextHaveBeenParsed(
       CompilerDeclContext(nullptr, decl_ctxs[1]));
 
   EXPECT_THAT(ast_parser.GetDeclContextToDIEMapKeys(),
               testing::UnorderedElementsAre(decl_ctxs[0], decl_ctxs[3]));
 }