Add split dwarf support to SymbolFileDWARF

[tberghammer]

Summary

Add basic fission support to SymbolFileDWARF

• Create new dwo symbol file class
• Add handling for .dwo sections
• Change indexes in SymbolFileDWARF to store compile unit offset next to DIE offset
• Propagate queries from dwarf compile unit to the dwo compile unit where applicable

[clayborg]

I see the need for a lot of this, but I feel like there are way too many places where we do this:

SymbolFileDWARFDwo* dwo_symbol_file = dwarf_cu->GetDwoSymbolFile();
if (dwo_symbol_file)
    return dwo_symbol_file->XXXX (...);

I would like us to more cleanly abstract ourselves from SymbolFileDWARFDwo. Ideally we wouldn't even see "SymbolFileDWARFDwo" anywhere inside SymbolFileDWARF because it has been abstracted behind DWARFCompileUnit and DWARFDebugInfoEntry and any other low level classes that need to know about them.

So I would like to see if the following is possible:

• DWARFCompileUnit should return the DIEs from the DWO file when DWARFCompileUnit::GetCompileUnitDIEOnly() or DWARFCompileUnit::DIE() is called.
• Any code that was doing the pattern from above that was calling dwarf_cu->GetDwoSymbolFile() and deferring to the DWO symbol file should just work normally if the correct DIEs are being handed out.
• All references to SymbolFileDWARFDwo should be removed from SymbolFileDWARF if we abstract things correctly.

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

16 ↗

(On Diff #32972)

This shouldn't be needed here, just a forward declaration for SymbolFileDWARFDwo should do and then include this in DWARFCompileUnit.cpp. No one outside of this class should need to know anything about SymbolFileDWARFDwo. It should be an implementation detail that only DWARFCompileUnit and DWARFDebugInfoEntry need to know about.

208–214 ↗

(On Diff #32972)

Make protected and hide this from anyone but DWARFCompileUnit and DWARFDebugInfoEntry.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

330 ↗

(On Diff #32972)

I don't think the cast is needed anymore now that "cu" isn't const.

1437–1438 ↗

(On Diff #32972)

GetAttributeValue(...) should just "do the right thing" and look into the DWO file if needed. Then this change isn't needed.

1458–1459 ↗

(On Diff #32972)

GetAttributeValue(...) should just "do the right thing" and look into the DWO file if needed. Then this change isn't needed.

1480–1481 ↗

(On Diff #32972)

GetAttributeValue(...) should just "do the right thing" and look into the DWO file if needed. Then this change isn't needed.

1494–1515 ↗

(On Diff #32972)

GetAttributeValue(...) should just "do the right thing" and look into the DWO file if needed. This code will change a bit after that, but the check for the DWO file shouldn't be needed.

1535–1536 ↗

(On Diff #32972)

GetAttributeValue(...) should just "do the right thing" and look into the DWO file if needed. Then this change isn't needed.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

3997–3999 ↗

(On Diff #32972)

Not sure why this is needed? If each DWARFCompileUnit hands out the correct DIEs, then Index() will point us to the right things and this shouldn't be needed.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

66–67 ↗

(On Diff #32972)

Hopefully we don't need this if we abstract things correctly so that the DWARFCompileUnit hands out the correct DIEs from the DWO file and SymbolFileDWARF shouldn't need to know anything about DWO files.

419–423 ↗

(On Diff #32972)

Hopefully we don't need this if we abstract things correctly so that the DWARFCompileUnit hands out the correct DIEs from the DWO file and SymbolFileDWARF shouldn't need to know anything about DWO files.

478 ↗

(On Diff #32972)

Hopefully we don't need this if we abstract things correctly so that the DWARFCompileUnit hands out the correct DIEs from the DWO file and SymbolFileDWARF shouldn't need to know anything about DWO files.

source/Symbol/ObjectFile.cpp

604–625 ↗

(On Diff #32972)

Can you explain why this is needed?

[clayborg]

include/lldb/Symbol/ObjectFile.h

372 ↗

(On Diff #32972)

Why is this needed? Can you clarify. I don't like this change and would rather avoid it if possible.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

806–818 ↗

(On Diff #32972)

Shouldn't this be:

if (form_value.Form() == DW_FORM_addr || form_value.Form() == DW_FORM_GNU_addr_index)
    hi_pc = form_value.Address(dwarf2Data);
else
    hi_pc = form_value.Unsigned();
if (hi_pc != LLDB_INVALID_ADDRESS)
{
    if (lo_pc == LLDB_INVALID_ADDRESS)
        do_offset = hi_pc != LLDB_INVALID_ADDRESS;
    else
        hi_pc += lo_pc; // DWARF 4 introduces <offset-from-lo-pc> to save on relocations
}

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

371–384 ↗

(On Diff #32972)

Hopefully we don't need this if we abstract things correctly so that the DWARFCompileUnit hands out the correct DIEs from the DWO file and SymbolFileDWARF shouldn't need to know anything about DWO files.

404–417 ↗

(On Diff #32972)

Hopefully we don't need this if we abstract things correctly so that the DWARFCompileUnit hands out the correct DIEs from the DWO file and SymbolFileDWARF shouldn't need to know anything about DWO files.

1069–1074 ↗

(On Diff #32972)

Shouldn't:

const DWARFDebugInfoEntry* cu_die = dwarf_cu->GetCompileUnitDIEOnly ();

already return the right cu_die? Should clients of DWARFCompileUnit be required to do this kind of very specific check? I really want this to be hidden from us by abstracting this kind of thing inside DWARFCompileUnit.

1157–1159 ↗

(On Diff #32972)

Why is this necessary? If we hand out the correct DIE from the DWO file in the first place, this should just work with no modifications right?

1626–1631 ↗

(On Diff #32972)

It would be nice if this weren't linear. I think we have the same problem int SymbolFileDWARFDebugMap, but not being linear would be nice at some point.

1922–1925 ↗

(On Diff #32972)

It would be nice to abstract this behind DWARFCompileUnit. Below we end up calling dwarf_cu->LookupAddress(...). This seems like a better place to do this kind of thing...

2281–2286 ↗

(On Diff #32972)

Not sure why this is needed? If each DWARFCompileUnit hands out the correct DIEs, then Index() will point us to the right things and this shouldn't be needed.

2405–2410 ↗

(On Diff #32972)

Not sure why this is needed? If each DWARFCompileUnit hands out the correct DIEs, then Index() will point us to the right things and this shouldn't be needed.

3017–3023 ↗

(On Diff #32972)

Not sure why this is needed? If each DWARFCompileUnit hands out the correct DIEs, then Index() will point us to the right things and this shouldn't be needed.

3059–3061 ↗

(On Diff #32972)

If .debug_info wasn't there, then SymbolFileDWARF wouldn't have been instantiated. Is this truly needed? Did something change when DWO files are now used?

3086–3087 ↗

(On Diff #32972)

Not sure why this is needed? If each DWARFCompileUnit hands out the correct DIEs, then Index() will point us to the right things and this shouldn't be needed.

3149–3155 ↗

(On Diff #32972)

Not sure why this is needed? If each DWARFCompileUnit hands out the correct DIEs, then Index() will point us to the right things and this shouldn't be needed.

3265–3270 ↗

(On Diff #32972)

Not sure why this is needed? If each DWARFCompileUnit hands out the correct DIEs, then Index() will point us to the right things and this shouldn't be needed.

3723–3728 ↗

(On Diff #32972)

Not sure why this is needed? If each DWARFCompileUnit hands out the correct DIEs, then Index() will point us to the right things and this shouldn't be needed.

3909–3911 ↗

(On Diff #32972)

Not sure why this is needed? If each DWARFCompileUnit hands out the correct DIEs, then Index() will point us to the right things and this shouldn't be needed.

3934–3936 ↗

(On Diff #32972)

Not sure why this is needed? If each DWARFCompileUnit hands out the correct DIEs, then Index() will point us to the right things and this shouldn't be needed.

3975–3978 ↗

(On Diff #32972)

Not sure why this is needed? If each DWARFCompileUnit hands out the correct DIEs, then Index() will point us to the right things and this shouldn't be needed.

[tberghammer]

In the current version of the patch the compile units in the main object file hands out only the compile unit DIE with the information what is available in the main object file. I considered the other approach (hand out all DIEs by the DWARF compile unit in the main object file) but I dropped it for the following reasons:

• If we hand out DIEs from a dwo symbol file then each DIE have to store a pointer to the symbol file (or compile unit) it belongs to what is a significant memory overhead (we have more DIEs then Symbols) if we ever want to store all DIE in memory. Even worse is that we have to change all name to DIE index to contain a pointer (compile unit / dwo symbol file) and an offset to find the DIE belongs to (compared to just an offset now) what is more entry then the number DIEs.
• In an average debug session run from an IDE the user usually sets the breakpoints based on file name + line number, display some stack traces, some variables and do some stepping. If we can index each dwo file separately then we can handle all of these features without parsing the full debug info what can give us some significant speed benefits at debugger startup time.

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

208–214 ↗

(On Diff #32972)

I don't really like friend classes and have the opinion that inside a plugin we can let the visibility a bit more open, but don't feel to strongly about it. I can change it if zou prefer that way.

source/Symbol/ObjectFile.cpp

604–625 ↗

(On Diff #32972)

We create all of the dwo object files with the same module what we used for the executable object file (belongs to them). Because of it we have several section with the same section name (several dwo file + object file) what can't be stored inside a single module.

This check is to disable adding the sections in the dwo object file into the modules section list because they will be fetched by SymbolFileDWARFDwo::GetCachedSectionData what handles it correctly.

[abidh]

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

348 ↗

(On Diff #32972)

You are not using the DW_AT_GNU_dwo_id. Is this intentional or an oversight?

[tberghammer]

Fix the minor refactors requested in the review.

I haven't changed the approach to return all DIEs from the dwo file when indexing the main compile unit because I would like to hear your opinion about my concerns (see previous comment) about speed and memory usage first.

[clayborg]

I also question why Symbo

In D12291#231523, @tberghammer wrote:

In the current version of the patch the compile units in the main object file hands out only the compile unit DIE with the information what is available in the main object file. I considered the other approach (hand out all DIEs by the DWARF compile unit in the main object file) but I dropped it for the following reasons:

• If we hand out DIEs from a dwo symbol file then each DIE have to store a pointer to the symbol file (or compile unit) it belongs to what is a significant memory overhead (we have more DIEs then Symbols) if we ever want to store all DIE in memory. Even worse is that we have to change all name to DIE index to contain a pointer (compile unit / dwo symbol file) and an offset to find the DIE belongs to (compared to just an offset now) what is more entry then the number DIEs.

Can't we just store the SymbolFile inside the compile unit? We always need the compile unit to really do anything with a DIE anyway. We currently store the DWO file inside the compile unit so it seems that we could just store it once in the compile unit and avoid any extra cost.

• In an average debug session run from an IDE the user usually sets the breakpoints based on file name + line number, display some stack traces, some variables and do some stepping. If we can index each dwo file separately then we can handle all of these features without parsing the full debug info what can give us some significant speed benefits at debugger startup time.

I don't see how we can ever just index one DWO file? If we index one, we must index them all within an executable otherwise the index will be incomplete. If you set a file + line breakpoint, you can't rely on the file matching the compile unit because there could be inlined functions so you would always need to index all of them. Likewise with setting a breakpoint by function name, you will need to index all DWO files.

Maybe we can:

• Have a new class that we hand out for a DIE, maybe named DWARFDIE that contains:

class DWARFDIE
{
    DWARFCompileUnit *m_cu;
    DWARFDebugInfoEntry *m_die;
};

Then change all of the places we currently use a "DWARFCompileUnit *cu, DWARFDebugInfoEntry* die" (we always pass them around together) to use a DWARFDIE instead. This allows us to store the DIEs efficiently, yet pass them around in a slightly larger container for usage. This would allow our memory usage to stay very close to where it is (an extra pointer in the compile unit).

Then we modify DWARFCompileUnit to store the "SymbolFileDWARF *" that the compile unit comes from. We can still store the DWO file in the compile unit as well as you are already doing, we would just need to add a "SymbolFileDWARF *m_dwarf;" member variable for the non DWO case (and also for digging up the DW_TAG_compile_unit attributes that aren't in the DWO DW_TAG_compile_unit).

Then we just make sure that all code that hands out DIEs actually hands out DWARFDIE instances instead of returning a "DWARFDebugInfoEntry *" and also having an out parameter that fills in the compile unit.

Thoughts?

[tberghammer]

In D12291#232191, @clayborg wrote:

I also question why Symbo

In D12291#231523, @tberghammer wrote:

In the current version of the patch the compile units in the main object file hands out only the compile unit DIE with the information what is available in the main object file. I considered the other approach (hand out all DIEs by the DWARF compile unit in the main object file) but I dropped it for the following reasons:

• If we hand out DIEs from a dwo symbol file then each DIE have to store a pointer to the symbol file (or compile unit) it belongs to what is a significant memory overhead (we have more DIEs then Symbols) if we ever want to store all DIE in memory. Even worse is that we have to change all name to DIE index to contain a pointer (compile unit / dwo symbol file) and an offset to find the DIE belongs to (compared to just an offset now) what is more entry then the number DIEs.

Can't we just store the SymbolFile inside the compile unit? We always need the compile unit to really do anything with a DIE anyway. We currently store the DWO file inside the compile unit so it seems that we could just store it once in the compile unit and avoid any extra cost.

In the name to DIE indexes (in SymbolFileDWARF) currently we store only a DIE offset and we find the compile unit based on the fact that the DIE should be inside the range of the compile unit. The compile units leave in the dwo symbol files all start at address 0 so just a DIE offset isn't enough to find the compile unit. We can store the offset in 4 byte (we already do it, but I am not sure it is a good idea) and the compile unit index in another 4 byte what isn't a major overhead, but it can matter for large inferiors. Storing the symbol file in the DIE might be avoidable but then the DIE have to ask the compile unit for the correct symbol file when somebody queries it for an attribute (we don't want the caller of the GetAttribute* function to know about dwo files).

• In an average debug session run from an IDE the user usually sets the breakpoints based on file name + line number, display some stack traces, some variables and do some stepping. If we can index each dwo file separately then we can handle all of these features without parsing the full debug info what can give us some significant speed benefits at debugger startup time.

I don't see how we can ever just index one DWO file? If we index one, we must index them all within an executable otherwise the index will be incomplete. If you set a file + line breakpoint, you can't rely on the file matching the compile unit because there could be inlined functions so you would always need to index all of them. Likewise with setting a breakpoint by function name, you will need to index all DWO files.

I made a few measurements a few weeks ago and setting a file + line breakpoint re

Maybe we can:

• Have a new class that we hand out for a DIE, maybe named DWARFDIE that contains:

class DWARFDIE
{
    DWARFCompileUnit *m_cu;
    DWARFDebugInfoEntry *m_die;
};

Then change all of the places we currently use a "DWARFCompileUnit *cu, DWARFDebugInfoEntry* die" (we always pass them around together) to use a DWARFDIE instead. This allows us to store the DIEs efficiently, yet pass them around in a slightly larger container for usage. This would allow our memory usage to stay very close to where it is (an extra pointer in the compile unit).

Then we modify DWARFCompileUnit to store the "SymbolFileDWARF *" that the compile unit comes from. We can still store the DWO file in the compile unit as well as you are already doing, we would just need to add a "SymbolFileDWARF *m_dwarf;" member variable for the non DWO case (and also for digging up the DW_TAG_compile_unit attributes that aren't in the DWO DW_TAG_compile_unit).

Then we just make sure that all code that hands out DIEs actually hands out DWARFDIE instances instead of returning a "DWARFDebugInfoEntry *" and also having an out parameter that fills in the compile unit.

Thoughts?

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

348 ↗

(On Diff #32972)

I just forgot to check if (fixed).

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

806–818 ↗

(On Diff #32972)

Nice catch

1437–1438 ↗

(On Diff #32972)

I have to return a SymbolFileDWARF* from GetAttributeValue so Address and String fetching know where it have to find the referenced sections, but it made the code significantly simpler.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

3059–3061 ↗

(On Diff #32972)

You are right. I removed it

[tberghammer]

Sorry, first I manage to submit my comments without finishing them.

In D12291#232191, @clayborg wrote:

I also question why Symbo

In D12291#231523, @tberghammer wrote:

In the current version of the patch the compile units in the main object file hands out only the compile unit DIE with the information what is available in the main object file. I considered the other approach (hand out all DIEs by the DWARF compile unit in the main object file) but I dropped it for the following reasons:

• If we hand out DIEs from a dwo symbol file then each DIE have to store a pointer to the symbol file (or compile unit) it belongs to what is a significant memory overhead (we have more DIEs then Symbols) if we ever want to store all DIE in memory. Even worse is that we have to change all name to DIE index to contain a pointer (compile unit / dwo symbol file) and an offset to find the DIE belongs to (compared to just an offset now) what is more entry then the number DIEs.

Can't we just store the SymbolFile inside the compile unit? We always need the compile unit to really do anything with a DIE anyway. We currently store the DWO file inside the compile unit so it seems that we could just store it once in the compile unit and avoid any extra cost.

In the name to DIE indexes (in SymbolFileDWARF) currently we store only a DIE offset and we find the compile unit based on the fact that the DIE should be inside the range of the compile unit. The compile units leave in the dwo symbol files all start at address 0 so just a DIE offset isn't enough to find the compile unit. We can store the offset in 4 byte (we already do it, but I am not sure it is a good idea) and the compile unit index in another 4 byte what isn't a major overhead, but it can matter for large inferiors. Storing the symbol file in the DIE might be avoidable but then the DIE have to ask the compile unit for the correct symbol file when somebody queries it for an attribute (we don't want the caller of the GetAttribute* function to know about dwo files).

• In an average debug session run from an IDE the user usually sets the breakpoints based on file name + line number, display some stack traces, some variables and do some stepping. If we can index each dwo file separately then we can handle all of these features without parsing the full debug info what can give us some significant speed benefits at debugger startup time.

I don't see how we can ever just index one DWO file? If we index one, we must index them all within an executable otherwise the index will be incomplete. If you set a file + line breakpoint, you can't rely on the file matching the compile unit because there could be inlined functions so you would always need to index all of them. Likewise with setting a breakpoint by function name, you will need to index all DWO files.

I made a few measurements a few weeks ago and to set a file + line breakpoint we only need to parse the line table what is reasonably fast while parsing all DIEs is significantly slower. Setting a breakpoint based on function name require a full dwarf parsing, but if you use an IDE you almost never want to do it.

Maybe we can:

• Have a new class that we hand out for a DIE, maybe named DWARFDIE that contains:

class DWARFDIE
{
    DWARFCompileUnit *m_cu;
    DWARFDebugInfoEntry *m_die;
};

Then change all of the places we currently use a "DWARFCompileUnit *cu, DWARFDebugInfoEntry* die" (we always pass them around together) to use a DWARFDIE instead. This allows us to store the DIEs efficiently, yet pass them around in a slightly larger container for usage. This would allow our memory usage to stay very close to where it is (an extra pointer in the compile unit).

Then we modify DWARFCompileUnit to store the "SymbolFileDWARF *" that the compile unit comes from. We can still store the DWO file in the compile unit as well as you are already doing, we would just need to add a "SymbolFileDWARF *m_dwarf;" member variable for the non DWO case (and also for digging up the DW_TAG_compile_unit attributes that aren't in the DWO DW_TAG_compile_unit).

Then we just make sure that all code that hands out DIEs actually hands out DWARFDIE instances instead of returning a "DWARFDebugInfoEntry *" and also having an out parameter that fills in the compile unit.

Thoughts?

I like the idea about passing them around together especially as we already do it in a lot of case and it will have only a small overhead, but it don't help on the fact that the name to DIE indexes have to store a compile unit pointer (or a compile unit index). I am not sure how much we want to worry about the memory usage increase because I estimate it to be under 10% increase (without any measurements to prove it), but it will be significantly bigger then the effect of some changes in the Symbol class where you were quite concerned about increasing the size of it.

[clayborg]

For our DWARF in .o files, I have SymbolFileDWARFDebugMap which loads the DWARF from .o files. Each .o file is loaded in a completely unchanged version of SymbolFileDWARF. Any lldb::user_id_t that are generated use:

lldb::user_id_t
SymbolFileDWARF::MakeUserID (dw_offset_t die_offset) const
{
    return GetID() | die_offset;
}

For a normal DWARF file GetID() returns 0. When used under a SymbolFileDWARFDebugMap, we set the ID to the index of the DWARF file. This encodes the SymbolFileDWARF's index in SymbolFileDWARFDebugMap's array as the high 32 bits of any IDs that are passed around and allow us to hand out unique IDs where the DIE offset ORed with the SymbolFileDWARF index is the ID. The IDs are then trimmed down to the low 32 bits before the SymbolFileDWARF looks them up. Actually dw_offset_t is 32 bit, so even if you pass a 64 bit value to anything that looks up a DIE, it will get correctly truncated.

So this should be possible. If desired, I can first make a patch that implements the DWARFDIE stuff, then we can update this patch to deal with that after that is done?

[tberghammer]

If I understand you correctly then you are suggesting to create a class like SymbolFileDWARFDebugMap for handling object files with dwo files. I think that approach is practically have the same code flow as the current one (one symbol file which one stores a list of sub symbol files). The 2 main difference is having a separate top level symbol file class for it makes the abstraction a bit cleaner (we have to refer to the debug map symfile several place in SymbolFileDWARF) but also require more code where some of it is code duplication. With dwo files it is a bit more complicated to solve is because there is no easy way do find out if a file contains dwo entries or not and it is possible for an object file to have some compile unit with dwo entry and some compile unit what is present in the main symbol file (I don't think it is a common scenario).

If we would like to go in the direction with abstracting out the dwo handling more, then I would suggest to change the NameToDIE arrays to store lldb::user_id_t where the 32MSB represents the dwarf compile unit index and 32LSB is the DIE offset. Then each function what currently find a (dwarf) compile unit based on die offset can use the compile unit index while the rest of the dwo handling can be abstracted out into the DWARCompileUnit/DWARFDebugInfoEntry classes (+ possibly a few more DWARF class). My only concern with this approach is that we start storing 2 different information in the higher bits of user_id_t what can cause problems. (Is there a reason we want to abstract this feature out considering that it is almost standard dwarf?)

All in all I don't want to have a separate top level symbol file (referenced by a SymbolVendor) for handling dwo files because I think it is more work to maintain it and don't give us too much benefits. Next to it I am happy with most possible approach.

If you would like to help me with implementing the split dwarf handling then I welcome any help but currently I can focus this issue in most of my time and would like to get it working (with 100% test pass rate) before mid September so I would like to try to avoid situations where we start waiting on each other.

[clayborg]

Let me get the DWARFDIE abstraction in and we can see where we are after I get this in as we will see more of what is possible to abstract when this is done.

[tberghammer]

I though a bit more about the abstraction you plan to introduce (DWARFDIE) and I started to believe we don't need it at all. If we use lldb::user_id_t in the NameToDIE indexes where the first 4 byte is the compile unit offset (for dwo) or the compile unit index (for debug map) and the last 4 byte is the die offset then we will have all of the information we need.

In this setup DWARFCompileUnit::Index have to be changed to index the dwo dwarf files also and all function of DWARFDebugInfoEntry have to be changed to check if it was given the compile unit belongs to the actual DIE or it got a pointer to the DIE in the main object file. In the second case it re-calls itself with the correct SymbolFileDwarf and DWARCompileUnit objects. I think this approach will keep the dwo file handling in the DWARFCompileUnit and in the DWARFDebugInfoEntry classes.

What do you think?

[clayborg]

In D12291#233274, @tberghammer wrote:

I though a bit more about the abstraction you plan to introduce (DWARFDIE) and I started to believe we don't need it at all. If we use lldb::user_id_t in the NameToDIE indexes where the first 4 byte is the compile unit offset (for dwo) or the compile unit index (for debug map) and the last 4 byte is the die offset then we will have all of the information we need.

Even if we don't need it to implement the DWO feature, we still need it. There are many places where we pass around a DWARFCompileUnit and a DWARFDebugInfoEntry as two arguments and there are many places where the wrong DWARFCompileUnit might be being used for a DWARFDebugInfoEntry. So even if this doesn't help the DWO stuff, I really want to get this change in so this kind of error doesn't happen.

We should still pull the CU index + DWARF offset tricks you mention for sure.

In this setup DWARFCompileUnit::Index have to be changed to index the dwo dwarf files also and all function of DWARFDebugInfoEntry have to be changed to check if it was given the compile unit belongs to the actual DIE or it got a pointer to the DIE in the main object file. In the second case it re-calls itself with the correct SymbolFileDwarf and DWARCompileUnit objects. I think this approach will keep the dwo file handling in the DWARFCompileUnit and in the DWARFDebugInfoEntry classes.

Sounds good, but lets build this on top of my DWARFDIE stuff so we can guarantee that we can hand out a DWARFDIE and always have the right DWARFCompileUnit and DWARFDebugInfoEntry. I am almost done with my DWARFDIE changes. Should be later today.

[clayborg]

I got my DWARFDIE stuff in with:

% svn commit
Sending        include/lldb/Core/dwarf.h
Sending        include/lldb/Symbol/ClangASTContext.h
Sending        include/lldb/Symbol/TypeSystem.h
Sending        lldb.xcodeproj/project.pbxproj
Sending        source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.h
Sending        source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h
Sending        source/Plugins/SymbolFile/DWARF/CMakeLists.txt
Adding         source/Plugins/SymbolFile/DWARF/DWARFAttribute.cpp
Sending        source/Plugins/SymbolFile/DWARF/DWARFAttribute.h
Sending        source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp
Sending        source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h
Adding         source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp
Adding         source/Plugins/SymbolFile/DWARF/DWARFDIE.h
Sending        source/Plugins/SymbolFile/DWARF/DWARFDIECollection.cpp
Sending        source/Plugins/SymbolFile/DWARF/DWARFDIECollection.h
Sending        source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp
Sending        source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h
Sending        source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
Sending        source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h
Sending        source/Plugins/SymbolFile/DWARF/DWARFDebugPubnames.cpp
Sending        source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.cpp
Sending        source/Plugins/SymbolFile/DWARF/DWARFDebugRanges.h
Sending        source/Plugins/SymbolFile/DWARF/DWARFDeclContext.h
Sending        source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
Sending        source/Plugins/SymbolFile/DWARF/DWARFFormValue.h
Sending        source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
Sending        source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
Sending        source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp
Sending        source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h
Sending        source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.cpp
Sending        source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.h
Sending        source/Symbol/ClangASTContext.cpp
Sending        source/Symbol/TypeSystem.cpp
Sending        source/Target/Target.cpp
Transmitting file data ..................................
Committed revision 246100.

[tberghammer]

[RFC] DO NOT COMMIT!

Update the design based on the discussion for the previous diff.

The current version have ~35 failures with split dwarf (most of them hit an assertion in clang) and causes a minor regression in non-split dwarf handling. I am working on these issues, but would like to get a feedback about the current design because a major change there can shuffle up everything.

[tberghammer]

Added some inline comments to explain some implementation decisions

include/lldb/Symbol/ObjectFile.h

372 ↗

(On Diff #33676)

We create all of the dwo object files with the same module what we used for the executable object file (belongs to them). Because of it we have several section with the same section name (several dwo file + object file) what can't be stored inside a single module.

This check is to disable adding the sections in the dwo object file into the modules section list because they will be fetched by SymbolFileDWARFDwo::GetCachedSectionData what handles it correctly.

If we want to avoid it we have to create a separate module for each dwo file and then somehow link them together in a way that we can search for a section in both modules (because the dwo file uses sections from the main object file). I think implementing it that way would be significantly worse and I don't see any good option to handle section list fetching in a better way without creating an ObjectFileELFDwo class just because of it (what will have to be constructed separately because the plugin system have no efficient way to select it).

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

3706–3708 ↗

(On Diff #33676)

This check is necessary because we will call this function on a SymbolFileDWARF fetched from the symbol vendor held by the module what will be the object file while the DWARFDIE will come from a variable's user_id_t.

Pushing this call up to the call stack is not possible (this is the first point in the call chain where this check make sense). If we really want to avoid this check here, then we have to move this function into DWARFCompileUnit or into DWARFDIE where we will have exactly the same check, but the reference for the SymbolFileDWARF members will be a bit more verbose.

[clayborg]

See inlined comments.

Main fix themes:

• It would be great to try and avoid any manual function calls where we supply the compile unit and a DIE offset that we assume comes from that compile unit. I identified many places where this was happening and we might have more. It is OK in DWARFDebugInfoEntry in places, but everywhere else we should try to avoid. Also anywhere where we grab an attribute, we should store a FormValue instead of a dw_offset_t (or a DIERef) and use that.
• Modify DWARFDebugInfoEntry::GetAttributeValue() to handle looking through the DW_AT_specification and DW_AT_abstract_origin for attributes with a new default parameter "bool check_specification_or_abstract_origin = false". Add this parameter to all DWARFDebugInfoEntry::GetAttributeValueAs...() functions.

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

218 ↗

(On Diff #33676)

DIERef can and should be initialized with only the "form_value". It contains enough info to extract the correct reference. No need to pass in the die.GetCU()->GetOffset().

1148 ↗

(On Diff #33676)

We should store "specification_die_offset" as a FormValue so we don't possibly use the wrong compile unit here. FormValue contains all that is needed to decode a value. If the DW_AT_specification was actually from a DW_AT_abstract_origin where the abstract origin DIE contained a DW_AT_specification, this would use the wrong compile unit and be an invalid DIERef (or point to the wrong thing). In general, we need to avoid this kind of manual compile unit + offset to avoid these issues everywhere.

1170 ↗

(On Diff #33676)

Store abstract_origin_die_offset as a FormValue to avoid issues as mentioned above. No manual CU + offset anywhere.

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

316–328 ↗

(On Diff #33676)

Is DW_AT_GNU_dwo_name always a relative path?

660 ↗

(On Diff #33676)

Don't we need the compile unit to be encoded into the DIERef here?

source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

161 ↗

(On Diff #33676)

We probably should swift m_die->LookupAddress to take a "DWARFDIE *function_die, DWARFDIE *block_die" instead of "DWARFDebugInfoEntry* function_die, DWARFDebugInfoEntry* block_die". Then we can avoid doing the manual combination of CU + offset here.

184 ↗

(On Diff #33676)

The DWARFCompileUnit::GetID() already shifts the cu_offset over by 32, so we will just lose the compile unit bits here.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

610 ↗

(On Diff #33676)

I would like to avoid the manual CU + offset here if possible. We could make die_offsets into an array of DIERef objects.

1250 ↗

(On Diff #33676)

Not sure what you were thinking here? You init this with nullptr and then try to use it below? Did you mean to init this with dwarf2Data? If so then we don't need this? Otherwise, please fix

1262 ↗

(On Diff #33676)

This will crash due to attribute_symbol_file always being nullptr.

1273–1279 ↗

(On Diff #33676)

This is currently always nullptr, so this is dead code

1298 ↗

(On Diff #33676)

We should probably just modify DWARFDebugInfoEntry::GetAttributeValue() to take an extra parameter like:

bool check_specification_or_abstract_origin

If this is true DWARFDebugInfoEntry::GetAttributeValue() should look through the DW_AT_specification or DW_AT_abstract_origin. I think we have many many places that do this sort of:

• check this die for the attribute
• check the DW_AT_specification for the attribute
• check the DW_AT_abstract_origin for the attribute

If you do do this, we could make the extra parameter default to "bool check_specification_or_abstract_origin = false" so all code continues to behave as it currently does, then opt it where we need to. The more smarts we put into DWARFDebugInfoEntry::GetAttributeValue() the better off we will be seeing as the compile unit in the main executable file when using DWO files has some attributes in the main executable DW_TAG_compile_unit and some in the other. I don't believe we need anything from the other, but again, the more we centralize this in DWARFDebugInfoEntry::GetAttributeValue() the less problems we will have in the future.

We would also need to add this "bool check_specification_or_abstract_origin" parameter to all of the DWARFDebugInfoEntry::GetAttributeValueAsXXX() functions.

1336–1347 ↗

(On Diff #33676)

not sure if we are OK with not checking the DW_AT_specification or DW_AT_abstract_origin here? Seems like a bug that would be fixed with our new DWARFDebugInfoEntry::GetAttributeValue() with the "bool check_specification_or_abstract_origin" parameter...

1365–1387 ↗

(On Diff #33676)

not sure if we are OK with not checking the DW_AT_specification or DW_AT_abstract_origin here? Seems like a bug that would be fixed with our new DWARFDebugInfoEntry::GetAttributeValue() with the "bool check_specification_or_abstract_origin" parameter...

1427 ↗

(On Diff #33676)

We don't check DW_AT_specification or DW_AT_abstract_origin...

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

3732 ↗

(On Diff #33676)

Please store as a FormValue. We have a branch where we need this as a FormValue so this will ease merging.

[tberghammer]

Address review comments and fix other bugs found during testing

With the current version of the CL there is no regression under Linux-x86_64 without split dwarf and if split dwarf is enabled we have only 3 test failures + all MI test case (most likely a test case issue). If you are happy with the change in it's current form, then I plan to commit it in as it is now and continue iterating on the remaining failures upstream.

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

316–328 ↗

(On Diff #33676)

I haven't seen absolute path in it so far, but it can be absolute. Added code to handle it.

660 ↗

(On Diff #33676)

No, we don't want to specify the compile unit here. We already checked that the specified DIE offset isn't belongs to the current compile unit. In this case we should try to get a DIE based on offset from the current symbol file. This can happen when a DIE refers to a value in a different compile unit inside the same file based on DIE offset

source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

161 ↗

(On Diff #33676)

I would prefer to leave it as it is now because we have to do the manual combination at some point (because the returned DIE might be in a different CU then the current DIE) and moving it into LookupAddress will make that function even more complicated.

184 ↗

(On Diff #33676)

SymbolFileDWARF does it, but DWARFCompileUnit isn't. With shifting by 32 we lose the SymbolFileDWARF id, but that one isn't considered to be part of the DIE ID.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

1250 ↗

(On Diff #33676)

The function isn't used at all now, so I just removed it completely.

(I made the change here to fetch the block data from the correct symbol file, but one of the merge made it broken)

[clayborg]

A few changes.

I think this might create problems for DWARF in .o files on MacOSX. Are you able to test on MacOSX? We used to store the compile unit index in the upper 32 bits of the type ID and all of our compile units from each .o file have 0xb as their cu_offset, so I would think that DIERef would always cause us to grab the first compile unit...

source/Plugins/SymbolFile/DWARF/DIERef.cpp

34–44 ↗

(On Diff #33931)

For DWO files, won't every compile unit have offset 0x0000000b? Or do you use the actual compile unit DIE from the main executable?

I have doubts this will work for DWARF in .o files. We used to encode the compile unit index in the upper 32 bits because all of our compile units have a dw_offset_t that is 0xb..

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

603–605 ↗

(On Diff #33931)

These 3 lines would be nicer as:

for (const auto &die_ref : die_refs)
{

1025–1036 ↗

(On Diff #33931)

This will fail if a DIE can have both a DW_AT_specification and a DW_AT_abstract_origin. Not sure if that can happen. If it can, we will need to check each one individually. Probably best to just check both individually.

1039–1055 ↗

(On Diff #33931)

Don't you want to only do all of this code if:

if (Tag() == DW_TAG_compile_unit)

[tberghammer]

Address review comments, fix dsym handling and update the xcode project

With this patch there is no regression on Linux-x86_64 and on OSX-x86_64.

source/Plugins/SymbolFile/DWARF/DIERef.cpp

34–44 ↗

(On Diff #33931)

The concept of DIERef is to contain the offset of the compile unit in the main object file so based on a DIERef and a SymbolFileDWARF fro the main object file we can find the compile unit and the DIE. In case of dsym it changes a bit with storing the symbol file index in the cu_offset filed instead.

I fixed the implementation to set it up properly in case of dwo files

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

1025–1036 ↗

(On Diff #33931)

We haven't checked both of it previously either and I don't think we will ever have both a DW_AT_specification and a DW_AT_abstract_origin, but changed it to check both for just in case.

1039–1055 ↗

(On Diff #33931)

Yes I do.

The beginning of the function (line 987-995) handles the case for non DW_TAG_compile_unit with forwarding the query to the right compile unit and this part of the code is to handle the case when some data about the compile unit is in the main object file and some data is in the dwo file. This can't happen for any other DIE.

[clayborg]

One minor IsValid() fix in DWARFDIE to avoid crashes and this is good to go.

source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

28–35 ↗

(On Diff #34159)

Need to check IsValid() first and place all above code inside the if and have the else return a DIERef().

lldb/trunk/include/lldb/Symbol/ObjectFile.h

public:
     ///
     /// Section list parsing can be deferred by ObjectFile instances
     /// until this accessor is called the first time.
     ///
     /// @return
     ///     The list of sections contained in this object file.
     //------------------------------------------------------------------
     virtual SectionList *
-    GetSectionList ();
+    GetSectionList (bool update_module_section_list = true);
 
     virtual void
     CreateSections (SectionList &unified_section_list) = 0;
 
     //------------------------------------------------------------------
     /// Notify the ObjectFile that the file addresses in the Sections
     /// for this module have been changed.
     //------------------------------------------------------------------

lldb/trunk/lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     4CF52AF8142829390051E832 /* SBFileSpecList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4CF52AF7142829390051E832 /* SBFileSpecList.cpp */; };
     6D55B2901A8A806200A70529 /* GDBRemoteCommunicationServerCommon.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D55B28D1A8A806200A70529 /* GDBRemoteCommunicationServerCommon.cpp */; };
     6D55B2911A8A806200A70529 /* GDBRemoteCommunicationServerLLGS.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D55B28E1A8A806200A70529 /* GDBRemoteCommunicationServerLLGS.cpp */; };
     6D55B2921A8A806200A70529 /* GDBRemoteCommunicationServerPlatform.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D55B28F1A8A806200A70529 /* GDBRemoteCommunicationServerPlatform.cpp */; };
     6D55BAED1A8CD0A800A70529 /* PlatformAndroid.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D55BAE91A8CD08C00A70529 /* PlatformAndroid.cpp */; };
     6D55BAEE1A8CD0B200A70529 /* PlatformAndroidRemoteGDBServer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D55BAEB1A8CD08C00A70529 /* PlatformAndroidRemoteGDBServer.cpp */; };
     6D762BEE1B1605D2006C929D /* LLDBServerUtilities.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D762BEC1B1605CD006C929D /* LLDBServerUtilities.cpp */; };
     6D86CEA01B440F8500A7FBFA /* CommandObjectBugreport.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D86CE9E1B440F6B00A7FBFA /* CommandObjectBugreport.cpp */; };
+    6D95DC001B9DC057000E318A /* DIERef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D95DBFD1B9DC057000E318A /* DIERef.cpp */; };
+    6D95DC011B9DC057000E318A /* HashedNameToDIE.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D95DBFE1B9DC057000E318A /* HashedNameToDIE.cpp */; };
+    6D95DC021B9DC057000E318A /* SymbolFileDWARFDwo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D95DBFF1B9DC057000E318A /* SymbolFileDWARFDwo.cpp */; };
     8C2D6A53197A1EAF006989C9 /* MemoryHistory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C2D6A52197A1EAF006989C9 /* MemoryHistory.cpp */; };
     8C2D6A5E197A250F006989C9 /* MemoryHistoryASan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C2D6A5A197A1FDC006989C9 /* MemoryHistoryASan.cpp */; };
     8CCB017E19BA28A80009FD44 /* ThreadCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CCB017A19BA283D0009FD44 /* ThreadCollection.cpp */; };
     8CCB018219BA4E270009FD44 /* SBThreadCollection.h in Headers */ = {isa = PBXBuildFile; fileRef = 8CCB018119BA4E210009FD44 /* SBThreadCollection.h */; settings = {ATTRIBUTES = (Public, ); }; };
     8CCB018319BA51BF0009FD44 /* SBThreadCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CCB017F19BA4DD00009FD44 /* SBThreadCollection.cpp */; };
     8CF02AE919DCC01900B14BE0 /* InstrumentationRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CF02ADF19DCBF3B00B14BE0 /* InstrumentationRuntime.cpp */; };
     8CF02AEA19DCC02100B14BE0 /* AddressSanitizerRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CF02AE519DCBF8400B14BE0 /* AddressSanitizerRuntime.cpp */; };
     8CF02AEF19DD16B100B14BE0 /* InstrumentationRuntimeStopInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CF02AED19DD15CF00B14BE0 /* InstrumentationRuntimeStopInfo.cpp */; };

     6D55BAE91A8CD08C00A70529 /* PlatformAndroid.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = PlatformAndroid.cpp; sourceTree = "<group>"; };
     6D55BAEA1A8CD08C00A70529 /* PlatformAndroid.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PlatformAndroid.h; sourceTree = "<group>"; };
     6D55BAEB1A8CD08C00A70529 /* PlatformAndroidRemoteGDBServer.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = PlatformAndroidRemoteGDBServer.cpp; sourceTree = "<group>"; };
     6D55BAEC1A8CD08C00A70529 /* PlatformAndroidRemoteGDBServer.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PlatformAndroidRemoteGDBServer.h; sourceTree = "<group>"; };
     6D762BEC1B1605CD006C929D /* LLDBServerUtilities.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = LLDBServerUtilities.cpp; path = "tools/lldb-server/LLDBServerUtilities.cpp"; sourceTree = "<group>"; };
     6D762BED1B1605CD006C929D /* LLDBServerUtilities.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = LLDBServerUtilities.h; path = "tools/lldb-server/LLDBServerUtilities.h"; sourceTree = "<group>"; };
     6D86CE9E1B440F6B00A7FBFA /* CommandObjectBugreport.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = CommandObjectBugreport.cpp; path = source/Commands/CommandObjectBugreport.cpp; sourceTree = "<group>"; };
     6D86CE9F1B440F6B00A7FBFA /* CommandObjectBugreport.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = CommandObjectBugreport.h; path = source/Commands/CommandObjectBugreport.h; sourceTree = "<group>"; };
+    6D95DBFD1B9DC057000E318A /* DIERef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DIERef.cpp; sourceTree = "<group>"; };
+    6D95DBFE1B9DC057000E318A /* HashedNameToDIE.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = HashedNameToDIE.cpp; sourceTree = "<group>"; };
+    6D95DBFF1B9DC057000E318A /* SymbolFileDWARFDwo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SymbolFileDWARFDwo.cpp; sourceTree = "<group>"; };
+    6D95DC031B9DC06F000E318A /* DIERef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DIERef.h; sourceTree = "<group>"; };
+    6D95DC041B9DC06F000E318A /* SymbolFileDWARFDwo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SymbolFileDWARFDwo.h; sourceTree = "<group>"; };
     8C2D6A52197A1EAF006989C9 /* MemoryHistory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = MemoryHistory.cpp; path = source/Target/MemoryHistory.cpp; sourceTree = "<group>"; };
     8C2D6A54197A1EBE006989C9 /* MemoryHistory.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = MemoryHistory.h; path = include/lldb/Target/MemoryHistory.h; sourceTree = "<group>"; };
     8C2D6A5A197A1FDC006989C9 /* MemoryHistoryASan.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MemoryHistoryASan.cpp; sourceTree = "<group>"; };
     8C2D6A5B197A1FDC006989C9 /* MemoryHistoryASan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MemoryHistoryASan.h; sourceTree = "<group>"; };
     8CCB017A19BA283D0009FD44 /* ThreadCollection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ThreadCollection.cpp; path = source/Target/ThreadCollection.cpp; sourceTree = "<group>"; };
     8CCB017C19BA289B0009FD44 /* ThreadCollection.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = ThreadCollection.h; path = include/lldb/Target/ThreadCollection.h; sourceTree = "<group>"; };
     8CCB017F19BA4DD00009FD44 /* SBThreadCollection.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = SBThreadCollection.cpp; path = source/API/SBThreadCollection.cpp; sourceTree = "<group>"; };
     8CCB018119BA4E210009FD44 /* SBThreadCollection.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SBThreadCollection.h; path = include/lldb/API/SBThreadCollection.h; sourceTree = "<group>"; };
260C89B110F57C5600BB2B04 /* SymbolFile */ = {
         260C89DD10F57C5600BB2B04 /* Symtab */,
       );
       path = SymbolFile;
       sourceTree = "<group>";
     };
     260C89B210F57C5600BB2B04 /* DWARF */ = {
       isa = PBXGroup;
       children = (
+        6D95DC031B9DC06F000E318A /* DIERef.h */,
+        6D95DC041B9DC06F000E318A /* SymbolFileDWARFDwo.h */,
+        6D95DBFD1B9DC057000E318A /* DIERef.cpp */,
+        6D95DBFE1B9DC057000E318A /* HashedNameToDIE.cpp */,
+        6D95DBFF1B9DC057000E318A /* SymbolFileDWARFDwo.cpp */,
         260C89B310F57C5600BB2B04 /* DWARFAbbreviationDeclaration.cpp */,
         260C89B410F57C5600BB2B04 /* DWARFAbbreviationDeclaration.h */,
         269DDD451B8FD01A00D0DBD8 /* DWARFASTParser.h */,
         269DDD491B8FD1C300D0DBD8 /* DWARFASTParserClang.h */,
         269DDD481B8FD1C300D0DBD8 /* DWARFASTParserClang.cpp */,
         260C89B610F57C5600BB2B04 /* DWARFAttribute.h */,
         266E829C1B8E542C008FCA06 /* DWARFAttribute.cpp */,
         260C89B710F57C5600BB2B04 /* DWARFCompileUnit.cpp */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         E7723D441AC4A7FB002BA082 /* RegisterContextPOSIXCore_arm64.cpp in Sources */,
         233B007F1960CB280090E598 /* ProcessLaunchInfo.cpp in Sources */,
         2689005913353E0400698AC0 /* ValueObjectConstResult.cpp in Sources */,
         2689005A13353E0400698AC0 /* ValueObjectList.cpp in Sources */,
         2689005B13353E0400698AC0 /* ValueObjectRegister.cpp in Sources */,
         2689005C13353E0400698AC0 /* ValueObjectVariable.cpp in Sources */,
         264A58EE1A7DBCAD00A6B1B0 /* OptionValueFormatEntity.cpp in Sources */,
         8C2D6A53197A1EAF006989C9 /* MemoryHistory.cpp in Sources */,
+        6D95DC021B9DC057000E318A /* SymbolFileDWARFDwo.cpp in Sources */,
         942612F71B95000000EF842E /* LanguageCategory.cpp in Sources */,
         2689005D13353E0400698AC0 /* VMRange.cpp in Sources */,
         2689005E13353E0E00698AC0 /* ClangASTSource.cpp in Sources */,
         3FDFED0F19B7D269009756A7 /* ThisThread.cpp in Sources */,
         2689005F13353E0E00698AC0 /* ClangFunction.cpp in Sources */,
         2689006013353E0E00698AC0 /* ClangExpressionDeclMap.cpp in Sources */,
         2689006113353E0E00698AC0 /* ClangExpressionParser.cpp in Sources */,
         B5EFAE861AE53B1D007059F3 /* RegisterContextFreeBSD_arm.cpp in Sources */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         AF77E0A41A033D360096C0EA /* RegisterContextPOSIX_powerpc.cpp in Sources */,
         AF9B8F33182DB52900DA866F /* SystemRuntimeMacOSX.cpp in Sources */,
         2689008113353E2200698AC0 /* CommandObject.cpp in Sources */,
         3F8160A61AB9F7DD001DA9DF /* Logging.cpp in Sources */,
         26BF51F61B3C754400016294 /* ABISysV_i386.cpp in Sources */,
         2689008313353E2200698AC0 /* CommandObjectMultiword.cpp in Sources */,
         2689008413353E2200698AC0 /* CommandObjectRegexCommand.cpp in Sources */,
         2689008513353E2200698AC0 /* CommandReturnObject.cpp in Sources */,
+        6D95DC001B9DC057000E318A /* DIERef.cpp in Sources */,
         3FDFE53519A29327009756A7 /* HostInfoBase.cpp in Sources */,
         26474CBE18D0CB2D0073DEBA /* RegisterContextMach_i386.cpp in Sources */,
         2689008613353E2200698AC0 /* Options.cpp in Sources */,
         2689008713353E2200698AC0 /* ScriptInterpreter.cpp in Sources */,
         260A63191861009E00FECF8E /* IOHandler.cpp in Sources */,
         2689008D13353E4200698AC0 /* DynamicLoaderMacOSXDYLD.cpp in Sources */,
         2689008E13353E4200698AC0 /* DynamicLoaderStatic.cpp in Sources */,
         2689009613353E4200698AC0 /* ObjectContainerBSDArchive.cpp in Sources */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         AF1F7B07189C904B0087DB9C /* AppleGetPendingItemsHandler.cpp in Sources */,
         26B1FCC21338115F002886E2 /* Host.mm in Sources */,
         E778E9A21B062D1700247609 /* EmulateInstructionMIPS.cpp in Sources */,
         3FDFDDC6199D37ED009756A7 /* FileSystem.cpp in Sources */,
         26744EF11338317700EF765A /* GDBRemoteCommunicationClient.cpp in Sources */,
         26744EF31338317700EF765A /* GDBRemoteCommunicationServer.cpp in Sources */,
         264A97BF133918BC0017F0BE /* PlatformRemoteGDBServer.cpp in Sources */,
         EB8375E71B553DE800BA907D /* ThreadPlanCallFunctionUsingABI.cpp in Sources */,
+        6D95DC011B9DC057000E318A /* HashedNameToDIE.cpp in Sources */,
         2697A54D133A6305004E4240 /* PlatformDarwin.cpp in Sources */,
         26651A18133BF9E0005B64B7 /* Opcode.cpp in Sources */,
         3FDFED0B19B7C8DE009756A7 /* HostThreadMacOSX.mm in Sources */,
         266603CA1345B5A8004DA8B6 /* ConnectionSharedMemory.cpp in Sources */,
         2671A0D013482601003A87BB /* ConnectionMachPort.cpp in Sources */,
         4CABA9E0134A8BCD00539BDD /* ValueObjectMemory.cpp in Sources */,
         4CD0BD0F134BFADF00CB44D4 /* ValueObjectDynamicValue.cpp in Sources */,
         946216C21A97C080006E19CC /* OptionValueLanguage.cpp in Sources */,

lldb/trunk/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (!m_sections_ap.get() && ParseSectionHeaders())
             static ConstString g_sect_name_dwarf_debug_line (".debug_line");
             static ConstString g_sect_name_dwarf_debug_loc (".debug_loc");
             static ConstString g_sect_name_dwarf_debug_macinfo (".debug_macinfo");
             static ConstString g_sect_name_dwarf_debug_pubnames (".debug_pubnames");
             static ConstString g_sect_name_dwarf_debug_pubtypes (".debug_pubtypes");
             static ConstString g_sect_name_dwarf_debug_ranges (".debug_ranges");
             static ConstString g_sect_name_dwarf_debug_str (".debug_str");
             static ConstString g_sect_name_dwarf_debug_str_offsets (".debug_str_offsets");
+            static ConstString g_sect_name_dwarf_debug_abbrev_dwo (".debug_abbrev.dwo");
+            static ConstString g_sect_name_dwarf_debug_info_dwo (".debug_info.dwo");
+            static ConstString g_sect_name_dwarf_debug_line_dwo (".debug_line.dwo");
+            static ConstString g_sect_name_dwarf_debug_loc_dwo (".debug_loc.dwo");
+            static ConstString g_sect_name_dwarf_debug_str_dwo (".debug_str.dwo");
+            static ConstString g_sect_name_dwarf_debug_str_offsets_dwo (".debug_str_offsets.dwo");
             static ConstString g_sect_name_eh_frame (".eh_frame");
 
             SectionType sect_type = eSectionTypeOther;
 
             bool is_thread_specific = false;
 
             if      (name == g_sect_name_text)                  sect_type = eSectionTypeCode;
             else if (name == g_sect_name_data)                  sect_type = eSectionTypeData;
if (!m_sections_ap.get() && ParseSectionHeaders())
             // .debug_macinfo – Macro information
             // .debug_pubnames – Lookup table for mapping object and function names to compilation units
             // .debug_pubtypes – Lookup table for mapping type names to compilation units
             // .debug_ranges – Address ranges used in DW_AT_ranges attributes
             // .debug_str – String table used in .debug_info
             // MISSING? .gnu_debugdata - "mini debuginfo / MiniDebugInfo" section, http://sourceware.org/gdb/onlinedocs/gdb/MiniDebugInfo.html
             // MISSING? .debug-index - http://src.chromium.org/viewvc/chrome/trunk/src/build/gdb-add-index?pathrev=144644
             // MISSING? .debug_types - Type descriptions from DWARF 4? See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo
-            else if (name == g_sect_name_dwarf_debug_abbrev)      sect_type = eSectionTypeDWARFDebugAbbrev;
-            else if (name == g_sect_name_dwarf_debug_addr)        sect_type = eSectionTypeDWARFDebugAddr;
-            else if (name == g_sect_name_dwarf_debug_aranges)     sect_type = eSectionTypeDWARFDebugAranges;
-            else if (name == g_sect_name_dwarf_debug_frame)       sect_type = eSectionTypeDWARFDebugFrame;
-            else if (name == g_sect_name_dwarf_debug_info)        sect_type = eSectionTypeDWARFDebugInfo;
-            else if (name == g_sect_name_dwarf_debug_line)        sect_type = eSectionTypeDWARFDebugLine;
-            else if (name == g_sect_name_dwarf_debug_loc)         sect_type = eSectionTypeDWARFDebugLoc;
-            else if (name == g_sect_name_dwarf_debug_macinfo)     sect_type = eSectionTypeDWARFDebugMacInfo;
-            else if (name == g_sect_name_dwarf_debug_pubnames)    sect_type = eSectionTypeDWARFDebugPubNames;
-            else if (name == g_sect_name_dwarf_debug_pubtypes)    sect_type = eSectionTypeDWARFDebugPubTypes;
-            else if (name == g_sect_name_dwarf_debug_ranges)      sect_type = eSectionTypeDWARFDebugRanges;
-            else if (name == g_sect_name_dwarf_debug_str)         sect_type = eSectionTypeDWARFDebugStr;
-            else if (name == g_sect_name_dwarf_debug_str_offsets) sect_type = eSectionTypeDWARFDebugStrOffsets;
-            else if (name == g_sect_name_eh_frame)                sect_type = eSectionTypeEHFrame;
+            else if (name == g_sect_name_dwarf_debug_abbrev)          sect_type = eSectionTypeDWARFDebugAbbrev;
+            else if (name == g_sect_name_dwarf_debug_addr)            sect_type = eSectionTypeDWARFDebugAddr;
+            else if (name == g_sect_name_dwarf_debug_aranges)         sect_type = eSectionTypeDWARFDebugAranges;
+            else if (name == g_sect_name_dwarf_debug_frame)           sect_type = eSectionTypeDWARFDebugFrame;
+            else if (name == g_sect_name_dwarf_debug_info)            sect_type = eSectionTypeDWARFDebugInfo;
+            else if (name == g_sect_name_dwarf_debug_line)            sect_type = eSectionTypeDWARFDebugLine;
+            else if (name == g_sect_name_dwarf_debug_loc)             sect_type = eSectionTypeDWARFDebugLoc;
+            else if (name == g_sect_name_dwarf_debug_macinfo)         sect_type = eSectionTypeDWARFDebugMacInfo;
+            else if (name == g_sect_name_dwarf_debug_pubnames)        sect_type = eSectionTypeDWARFDebugPubNames;
+            else if (name == g_sect_name_dwarf_debug_pubtypes)        sect_type = eSectionTypeDWARFDebugPubTypes;
+            else if (name == g_sect_name_dwarf_debug_ranges)          sect_type = eSectionTypeDWARFDebugRanges;
+            else if (name == g_sect_name_dwarf_debug_str)             sect_type = eSectionTypeDWARFDebugStr;
+            else if (name == g_sect_name_dwarf_debug_str_offsets)     sect_type = eSectionTypeDWARFDebugStrOffsets;
+            else if (name == g_sect_name_dwarf_debug_abbrev_dwo)      sect_type = eSectionTypeDWARFDebugAbbrev;
+            else if (name == g_sect_name_dwarf_debug_info_dwo)        sect_type = eSectionTypeDWARFDebugInfo;
+            else if (name == g_sect_name_dwarf_debug_line_dwo)        sect_type = eSectionTypeDWARFDebugLine;
+            else if (name == g_sect_name_dwarf_debug_loc_dwo)         sect_type = eSectionTypeDWARFDebugLoc;
+            else if (name == g_sect_name_dwarf_debug_str_dwo)         sect_type = eSectionTypeDWARFDebugStr;
+            else if (name == g_sect_name_dwarf_debug_str_offsets_dwo) sect_type = eSectionTypeDWARFDebugStrOffsets;
+            else if (name == g_sect_name_eh_frame)                    sect_type = eSectionTypeEHFrame;
 
             switch (header.sh_type)
             {
                 case SHT_SYMTAB:
                     assert (sect_type == eSectionTypeOther);
                     sect_type = eSectionTypeELFSymbolTable;
                     break;
                 case SHT_DYNSYM:

lldb/trunk/source/Plugins/SymbolFile/DWARF/CMakeLists.txt

 add_lldb_library(lldbPluginSymbolFileDWARF
+  DIERef.cpp
   DWARFAbbreviationDeclaration.cpp
   DWARFASTParserClang.cpp
   DWARFAttribute.cpp
   DWARFCompileUnit.cpp
   DWARFDataExtractor.cpp
   DWARFDebugAbbrev.cpp
   DWARFDebugAranges.cpp
   DWARFDebugArangeSet.cpp
add_lldb_library(lldbPluginSymbolFileDWARF
   DWARFDIECollection.cpp
   DWARFFormValue.cpp
   DWARFLocationDescription.cpp
   DWARFLocationList.cpp
   HashedNameToDIE.cpp
   LogChannelDWARF.cpp
   NameToDIE.cpp
   SymbolFileDWARF.cpp
+  SymbolFileDWARFDwo.cpp
   SymbolFileDWARFDebugMap.cpp
   UniqueDWARFASTType.cpp
   )

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

+//===-- DIERef.h ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SymbolFileDWARF_DIERef_h_
+#define SymbolFileDWARF_DIERef_h_
+
+#include "lldb/Core/dwarf.h"
+#include "lldb/lldb-defines.h"
+
+class DWARFFormValue;
+
+struct DIERef
+{
+    DIERef();
+
+    explicit
+    DIERef(dw_offset_t d);
+
+    DIERef(dw_offset_t c, dw_offset_t d);
+
+    explicit
+    DIERef(lldb::user_id_t uid);
+
+    explicit
+    DIERef(const DWARFFormValue& form_value);
+
+    lldb::user_id_t
+    GetUID() const;
+
+    dw_offset_t cu_offset;
+    dw_offset_t die_offset;
+};
+
+typedef std::vector<DIERef> DIEArray;
+
+#endif  // SymbolFileDWARF_DIERef_h_

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

+//===-- DIERef.cpp ----------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DIERef.h"
+#include "DWARFCompileUnit.h"
+#include "DWARFFormValue.h"
+
+DIERef::DIERef() :
+    cu_offset(DW_INVALID_OFFSET),
+    die_offset(DW_INVALID_OFFSET)
+{}
+
+DIERef::DIERef(dw_offset_t d) :
+    cu_offset(DW_INVALID_OFFSET),
+    die_offset(d)
+{}
+
+DIERef::DIERef(dw_offset_t c, dw_offset_t d) :
+    cu_offset(c),
+    die_offset(d)
+{}
+
+DIERef::DIERef(lldb::user_id_t uid) :
+    cu_offset(uid>>32),
+    die_offset(uid&0xffffffff)
+{}
+
+DIERef::DIERef(const DWARFFormValue& form_value) :
+    cu_offset(DW_INVALID_OFFSET),
+    die_offset(DW_INVALID_OFFSET)
+{
+    if (form_value.IsValid())
+    {
+        const DWARFCompileUnit* dwarf_cu = form_value.GetCompileUnit();
+        if (dwarf_cu)
+        {
+            if (dwarf_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
+                cu_offset = dwarf_cu->GetBaseObjOffset();
+            else
+                cu_offset = dwarf_cu->GetOffset();
+        }
+        die_offset = form_value.Reference();
+    }
+}
+
+lldb::user_id_t
+DIERef::GetUID() const
+{
+    return ((lldb::user_id_t)cu_offset) << 32 | die_offset;
+}

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

if (die)
         //        if (log && dwarf_cu)
         //        {
         //            StreamString s;
         //            die->DumpLocation (this, dwarf_cu, s);
         //            dwarf->GetObjectFile()->GetModule()->LogMessage (log, "SymbolFileDwarf::%s %s", __FUNCTION__, s.GetData());
         //
         //        }
 
-        Type *type_ptr = dwarf->m_die_to_type.lookup (die.GetDIE());
+        Type *type_ptr = dwarf->GetDIEToType().lookup (die.GetDIE());
         TypeList* type_list = dwarf->GetTypeList();
         if (type_ptr == NULL)
         {
             if (type_is_new_ptr)
                 *type_is_new_ptr = true;
 
             const dw_tag_t tag = die.Tag();
 
if (die)
                 case DW_TAG_rvalue_reference_type:
                 case DW_TAG_typedef:
                 case DW_TAG_const_type:
                 case DW_TAG_restrict_type:
                 case DW_TAG_volatile_type:
                 case DW_TAG_unspecified_type:
                 {
                     // Set a bit that lets us know that we are currently parsing this
-                    dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+                    dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
 
                     const size_t num_attributes = die.GetAttributes (attributes);
                     uint32_t encoding = 0;
                     lldb::user_id_t encoding_uid = LLDB_INVALID_UID;
 
                     if (num_attributes > 0)
                     {
                         uint32_t i;
if (die)
                                             if (strchr (type_name_cstr, '&') == NULL)
                                                 type_name_cstr = NULL;
                                         }
                                         if (type_name_cstr)
                                             type_name_const_str.SetCString(type_name_cstr);
                                         break;
                                     case DW_AT_byte_size:   byte_size = form_value.Unsigned(); break;
                                     case DW_AT_encoding:    encoding = form_value.Unsigned(); break;
-                                    case DW_AT_type:        encoding_uid = form_value.Reference(); break;
+                                    case DW_AT_type:        encoding_uid = DIERef(form_value).GetUID(); break;
                                     default:
                                     case DW_AT_sibling:
                                         break;
                                 }
                             }
                         }
                     }
 
if (die)
                                              byte_size,
                                              NULL,
                                              encoding_uid,
                                              encoding_data_type,
                                              &decl,
                                              clang_type,
                                              resolve_state));
 
-                    dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
+                    dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
 
                     //                  Type* encoding_type = GetUniquedTypeForDIEOffset(encoding_uid, type_sp, NULL, 0, 0, false);
                     //                  if (encoding_type != NULL)
                     //                  {
                     //                      if (encoding_type != DIE_IS_BEING_PARSED)
                     //                          type_sp->SetEncodingType(encoding_type);
                     //                      else
                     //                          m_indirect_fixups.push_back(type_sp.get());
                     //                  }
                 }
                     break;
 
                 case DW_TAG_structure_type:
                 case DW_TAG_union_type:
                 case DW_TAG_class_type:
                 {
                     // Set a bit that lets us know that we are currently parsing this
-                    dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+                    dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
                     bool byte_size_valid = false;
 
                     LanguageType class_language = eLanguageTypeUnknown;
                     bool is_complete_objc_class = false;
                     //bool struct_is_class = false;
                     const size_t num_attributes = die.GetAttributes (attributes);
                     if (num_attributes > 0)
                     {
if (die)
                         // We have already parsed this type or from another
                         // compile unit. GCC loves to use the "one definition
                         // rule" which can result in multiple definitions
                         // of the same class over and over in each compile
                         // unit.
                         type_sp = unique_ast_entry_ap->m_type_sp;
                         if (type_sp)
                         {
-                            dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
+                            dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
                             return type_sp;
                         }
                     }
 
                     DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr);
 
                     int tag_decl_kind = -1;
                     AccessType default_accessibility = eAccessNone;
if (die)
                                                                                      DW_TAG_value_to_name(tag),
                                                                                      type_name_cstr,
                                                                                      type_sp->GetID());
                                 }
 
                                 // We found a real definition for this type elsewhere
                                 // so lets use it and cache the fact that we found
                                 // a complete type for this die
-                                dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
+                                dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
                                 return type_sp;
                             }
                         }
                     }
 
 
                     if (is_forward_declaration)
                     {
if (die)
                                                                                  DW_TAG_value_to_name(tag),
                                                                                  type_name_cstr,
                                                                                  type_sp->GetID());
                             }
 
                             // We found a real definition for this type elsewhere
                             // so lets use it and cache the fact that we found
                             // a complete type for this die
-                            dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
+                            dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
                             return type_sp;
                         }
                     }
                     assert (tag_decl_kind != -1);
                     bool clang_type_was_created = false;
-                    clang_type.SetCompilerType(&m_ast, dwarf->m_forward_decl_die_to_clang_type.lookup (die.GetDIE()));
+                    clang_type.SetCompilerType(&m_ast, dwarf->GetForwardDeclDieToClangType().lookup (die.GetDIE()));
                     if (!clang_type)
                     {
                         clang::DeclContext *decl_ctx = GetClangDeclContextContainingDIE (die, nullptr);
                         if (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 (die)
                                 class_language != eLanguageTypeObjC_plus_plus)
                                 ClangASTContext::StartTagDeclarationDefinition (clang_type);
 
                             // Leave this as a forward declaration until we need
                             // to know the details of the type. lldb_private::Type
                             // will automatically call the SymbolFile virtual function
                             // "SymbolFileDWARF::CompleteType(Type *)"
                             // When the definition needs to be defined.
-                            dwarf->m_forward_decl_die_to_clang_type[die.GetDIE()] = clang_type.GetOpaqueQualType();
-                            dwarf->m_forward_decl_clang_type_to_die[ClangASTContext::RemoveFastQualifiers(clang_type).GetOpaqueQualType()] = die.GetDIE();
+                            dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] = clang_type.GetOpaqueQualType();
+                            dwarf->GetForwardDeclClangTypeToDie()[ClangASTContext::RemoveFastQualifiers(clang_type).GetOpaqueQualType()] = die.GetDIERef();
                             m_ast.SetHasExternalStorage (clang_type.GetOpaqueQualType(), true);
                         }
                     }
-
                 }
                     break;
 
                 case DW_TAG_enumeration_type:
                 {
                     // Set a bit that lets us know that we are currently parsing this
-                    dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+                    dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
 
-                    lldb::user_id_t encoding_uid = DW_INVALID_OFFSET;
+                    DWARFFormValue encoding_form;
 
                     const size_t num_attributes = die.GetAttributes (attributes);
                     if (num_attributes > 0)
                     {
                         uint32_t i;
 
                         for (i=0; i<num_attributes; ++i)
                         {
                             attr = attributes.AttributeAtIndex(i);
                             if (attributes.ExtractFormValueAtIndex(i, form_value))
                             {
                                 switch (attr)
                                 {
                                     case DW_AT_decl_file:       decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
                                     case DW_AT_decl_line:       decl.SetLine(form_value.Unsigned()); break;
                                     case DW_AT_decl_column:     decl.SetColumn(form_value.Unsigned()); break;
                                     case DW_AT_name:
                                         type_name_cstr = form_value.AsCString();
                                         type_name_const_str.SetCString(type_name_cstr);
                                         break;
-                                    case DW_AT_type:            encoding_uid = form_value.Reference(); break;
+                                    case DW_AT_type:            encoding_form = form_value; break;
                                     case DW_AT_byte_size:       byte_size = form_value.Unsigned(); break;
                                     case DW_AT_accessibility:   break; //accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
                                     case DW_AT_declaration:     break; //is_forward_declaration = form_value.Boolean(); break;
                                     case DW_AT_allocated:
                                     case DW_AT_associated:
                                     case DW_AT_bit_stride:
                                     case DW_AT_byte_stride:
                                     case DW_AT_data_location:
                                     case DW_AT_description:
                                     case DW_AT_start_scope:
                                     case DW_AT_visibility:
                                     case DW_AT_specification:
                                     case DW_AT_abstract_origin:
                                     case DW_AT_sibling:
                                         break;
                                 }
                             }
                         }
 
                         DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr);
 
                         CompilerType enumerator_clang_type;
-                        clang_type.SetCompilerType (&m_ast, dwarf->m_forward_decl_die_to_clang_type.lookup (die.GetDIE()));
+                        clang_type.SetCompilerType (&m_ast, dwarf->GetForwardDeclDieToClangType().lookup (die.GetDIE()));
                         if (!clang_type)
                         {
-                            if (encoding_uid != DW_INVALID_OFFSET)
+                            if (encoding_form.IsValid())
                             {
-                                Type *enumerator_type = dwarf->ResolveTypeUID(encoding_uid);
+                                Type *enumerator_type = dwarf->ResolveTypeUID(DIERef(encoding_form).GetUID());
                                 if (enumerator_type)
                                     enumerator_clang_type = enumerator_type->GetFullCompilerType ();
                             }
 
                             if (!enumerator_clang_type)
                                 enumerator_clang_type = m_ast.GetBuiltinTypeForDWARFEncodingAndBitSize (NULL,
                                                                                                         DW_ATE_signed,
                                                                                                         byte_size * 8);
if (die)
 
                         LinkDeclContextToDIE(ClangASTContext::GetDeclContextForType(clang_type), die);
 
                         type_sp.reset( new Type (die.GetID(),
                                                  dwarf,
                                                  type_name_const_str,
                                                  byte_size,
                                                  NULL,
-                                                 encoding_uid,
+                                                 DIERef(encoding_form).GetUID(),
                                                  Type::eEncodingIsUID,
                                                  &decl,
                                                  clang_type,
                                                  Type::eResolveStateForward));
 
                         ClangASTContext::StartTagDeclarationDefinition (clang_type);
                         if (die.HasChildren())
                         {
                             SymbolContext cu_sc(die.GetLLDBCompileUnit());
                             bool is_signed = false;
                             enumerator_clang_type.IsIntegerType(is_signed);
                             ParseChildEnumerators(cu_sc, clang_type, is_signed, type_sp->GetByteSize(), die);
                         }
                         ClangASTContext::CompleteTagDeclarationDefinition (clang_type);
                     }
                 }
                     break;
 
                 case DW_TAG_inlined_subroutine:
                 case DW_TAG_subprogram:
                 case DW_TAG_subroutine_type:
                 {
                     // Set a bit that lets us know that we are currently parsing this
-                    dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+                    dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
 
-                    //const char *mangled = NULL;
-                    dw_offset_t type_die_offset = DW_INVALID_OFFSET;
+                    DWARFFormValue type_die_form;
                     bool is_variadic = false;
                     bool is_inline = false;
                     bool is_static = false;
                     bool is_virtual = false;
                     bool is_explicit = false;
                     bool is_artificial = false;
-                    dw_offset_t specification_die_offset = DW_INVALID_OFFSET;
-                    dw_offset_t abstract_origin_die_offset = DW_INVALID_OFFSET;
+                    DWARFFormValue specification_die_form;
+                    DWARFFormValue abstract_origin_die_form;
                     dw_offset_t object_pointer_die_offset = DW_INVALID_OFFSET;
 
                     unsigned type_quals = 0;
                     clang::StorageClass storage = clang::SC_None;//, Extern, Static, PrivateExtern
 
 
                     const size_t num_attributes = die.GetAttributes (attributes);
                     if (num_attributes > 0)
if (die)
                                     case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
                                     case DW_AT_name:
                                         type_name_cstr = form_value.AsCString();
                                         type_name_const_str.SetCString(type_name_cstr);
                                         break;
 
                                     case DW_AT_linkage_name:
                                     case DW_AT_MIPS_linkage_name:   break; // mangled = form_value.AsCString(&dwarf->get_debug_str_data()); break;
-                                    case DW_AT_type:                type_die_offset = form_value.Reference(); break;
+                                    case DW_AT_type:                type_die_form = form_value; break;
                                     case DW_AT_accessibility:       accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
                                     case DW_AT_declaration:         break; // is_forward_declaration = form_value.Boolean(); break;
                                     case DW_AT_inline:              is_inline = form_value.Boolean(); break;
                                     case DW_AT_virtuality:          is_virtual = form_value.Boolean();  break;
                                     case DW_AT_explicit:            is_explicit = form_value.Boolean();  break;
                                     case DW_AT_artificial:          is_artificial = form_value.Boolean();  break;
 
 
                                     case DW_AT_external:
                                         if (form_value.Unsigned())
                                         {
                                             if (storage == clang::SC_None)
                                                 storage = clang::SC_Extern;
                                             else
                                                 storage = clang::SC_PrivateExtern;
                                         }
                                         break;
 
                                     case DW_AT_specification:
-                                        specification_die_offset = form_value.Reference();
+                                        specification_die_form = form_value;
                                         break;
 
                                     case DW_AT_abstract_origin:
-                                        abstract_origin_die_offset = form_value.Reference();
+                                        abstract_origin_die_form = form_value;
                                         break;
 
                                     case DW_AT_object_pointer:
                                         object_pointer_die_offset = form_value.Reference();
                                         break;
 
                                     case DW_AT_allocated:
                                     case DW_AT_associated:
if (die)
                         }
                     }
 
                     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 (type_die_offset != DW_INVALID_OFFSET)
-                        func_type = dwarf->ResolveTypeUID(type_die_offset);
+                    if (type_die_form.IsValid())
+                        func_type = dwarf->ResolveTypeUID(DIERef(type_die_form).GetUID());
 
                     if (func_type)
                         return_clang_type = func_type->GetForwardCompilerType ();
                     else
                         return_clang_type = m_ast.GetBasicType(eBasicTypeVoid);
 
 
                     std::vector<CompilerType> function_param_types;
if (die)
                                         // DIEs in the DIE for "class_type"...
                                         SymbolFileDWARF *class_symfile = NULL;
                                         DWARFDIE class_type_die;
 
                                         SymbolFileDWARFDebugMap *debug_map_symfile = dwarf->GetDebugMapSymfile();
                                         if (debug_map_symfile)
                                         {
                                             class_symfile = debug_map_symfile->GetSymbolFileByOSOIndex(SymbolFileDWARFDebugMap::GetOSOIndexFromUserID(class_type->GetID()));
-                                            class_type_die = class_symfile->DebugInfo()->GetDIE (class_type->GetID());
+                                            class_type_die = class_symfile->DebugInfo()->GetDIE (DIERef(class_type->GetID()));
                                         }
                                         else
                                         {
                                             class_symfile = dwarf;
-                                            class_type_die = dwarf->DebugInfo()->GetDIE (class_type->GetID());
+                                            class_type_die = dwarf->DebugInfo()->GetDIE (DIERef(class_type->GetID()));
                                         }
                                         if (class_type_die)
                                         {
                                             DWARFDIECollection failures;
 
                                             CopyUniqueClassMethodTypes (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_ptr = dwarf->m_die_to_type[die.GetDIE()];
+                                            type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
                                             if (type_ptr && type_ptr != DIE_IS_BEING_PARSED)
                                             {
                                                 type_sp = type_ptr->shared_from_this();
                                                 break;
                                             }
                                         }
                                     }
 
-                                    if (specification_die_offset != DW_INVALID_OFFSET)
+                                    if (specification_die_form.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 = dwarf->DebugInfo()->GetDIE(specification_die_offset);
+                                        DWARFDIE spec_die = dwarf->DebugInfo()->GetDIE(DIERef(specification_die_form));
                                         clang::DeclContext *spec_clang_decl_ctx = GetClangDeclContextForDIE (spec_die);
                                         if (spec_clang_decl_ctx)
                                         {
                                             LinkDeclContextToDIE(spec_clang_decl_ctx, die);
                                         }
                                         else
                                         {
-                                            dwarf->GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64 ": DW_AT_specification(0x%8.8x) has no decl\n",
+                                            dwarf->GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64 ": DW_AT_specification(0x%8.8" PRIx64 ") has no decl\n",
                                                                                                 die.GetID(),
-                                                                                                specification_die_offset);
+                                                                                                specification_die_form.Reference());
                                         }
                                         type_handled = true;
                                     }
-                                    else if (abstract_origin_die_offset != DW_INVALID_OFFSET)
+                                    else if (abstract_origin_die_form.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 = dwarf->DebugInfo()->GetDIE (abstract_origin_die_offset);
+                                        DWARFDIE abs_die = dwarf->DebugInfo()->GetDIE (DIERef(abstract_origin_die_form));
                                         clang::DeclContext *abs_clang_decl_ctx = GetClangDeclContextForDIE (abs_die);
                                         if (abs_clang_decl_ctx)
                                         {
                                             LinkDeclContextToDIE (abs_clang_decl_ctx, die);
                                         }
                                         else
                                         {
-                                            dwarf->GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64 ": DW_AT_abstract_origin(0x%8.8x) has no decl\n",
+                                            dwarf->GetObjectFile()->GetModule()->ReportWarning ("0x%8.8" PRIx64 ": DW_AT_abstract_origin(0x%8.8" PRIx64 ") has no decl\n",
                                                                                                 die.GetID(),
-                                                                                                abstract_origin_die_offset);
+                                                                                                abstract_origin_die_form.Reference());
                                         }
                                         type_handled = true;
                                     }
                                     else
                                     {
                                         CompilerType class_opaque_type = class_type->GetForwardCompilerType ();
                                         if (ClangASTContext::IsCXXClassType(class_opaque_type))
                                         {

                                                 }
                                             }
                                             else
                                             {
                                                 // We were asked to parse the type for a method in a class, yet the
                                                 // class hasn't been asked to complete 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->m_die_to_type map. First
-                                                // we need to modify the dwarf->m_die_to_type so it doesn't think we are
+                                                // 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->m_die_to_type[die.GetDIE()] = NULL;
+                                                dwarf->GetDIEToType()[die.GetDIE()] = NULL;
 
                                                 // Now we get the full type to force our class type to complete itself
                                                 // using the clang::ExternalASTSource protocol which will parse all
                                                 // base classes and all methods (including the method for this DIE).
                                                 class_type->GetFullCompilerType ();
 
                                                 // The type for this DIE should have been filled in the function call above
-                                                type_ptr = dwarf->m_die_to_type[die.GetDIE()];
+                                                type_ptr = dwarf->GetDIEToType()[die.GetDIE()];
                                                 if (type_ptr && type_ptr != DIE_IS_BEING_PARSED)
                                                 {
                                                     type_sp = type_ptr->shared_from_this();
                                                     break;
                                                 }
 
                                                 // FIXME This is fixing some even uglier behavior but we really need to
                                                 // uniq the methods of each class as well as the class itself.

                                              Type::eResolveStateFull));
                     assert(type_sp.get());
                 }
                     break;
 
                 case DW_TAG_array_type:
                 {
                     // Set a bit that lets us know that we are currently parsing this
-                    dwarf->m_die_to_type[die.GetDIE()] = DIE_IS_BEING_PARSED;
+                    dwarf->GetDIEToType()[die.GetDIE()] = DIE_IS_BEING_PARSED;
 
-                    lldb::user_id_t type_die_offset = DW_INVALID_OFFSET;
+                    DWARFFormValue type_die_form;
                     int64_t first_index = 0;
                     uint32_t byte_stride = 0;
                     uint32_t bit_stride = 0;
                     bool is_vector = false;
                     const size_t num_attributes = die.GetAttributes (attributes);
 
                     if (num_attributes > 0)
                     {
                         uint32_t i;
                         for (i=0; i<num_attributes; ++i)
                         {
                             attr = attributes.AttributeAtIndex(i);
                             if (attributes.ExtractFormValueAtIndex(i, form_value))
                             {
                                 switch (attr)
                                 {
                                     case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
                                     case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
                                     case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
                                     case DW_AT_name:
                                         type_name_cstr = form_value.AsCString();
                                         type_name_const_str.SetCString(type_name_cstr);
                                         break;
 
-                                    case DW_AT_type:            type_die_offset = form_value.Reference(); break;
+                                    case DW_AT_type:            type_die_form = form_value; break;
                                     case DW_AT_byte_size:       break; // byte_size = form_value.Unsigned(); break;
                                     case DW_AT_byte_stride:     byte_stride = form_value.Unsigned(); break;
                                     case DW_AT_bit_stride:      bit_stride = form_value.Unsigned(); break;
                                     case DW_AT_GNU_vector:      is_vector = form_value.Boolean(); break;
                                     case DW_AT_accessibility:   break; // accessibility = DW_ACCESS_to_AccessType(form_value.Unsigned()); break;
                                     case DW_AT_declaration:     break; // is_forward_declaration = form_value.Boolean(); break;
                                     case DW_AT_allocated:
                                     case DW_AT_associated:
                                     case DW_AT_data_location:
                                     case DW_AT_description:
                                     case DW_AT_ordering:
                                     case DW_AT_start_scope:
                                     case DW_AT_visibility:
                                     case DW_AT_specification:
                                     case DW_AT_abstract_origin:
                                     case DW_AT_sibling:
                                         break;
                                 }
                             }
                         }
 
                         DEBUG_PRINTF ("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(), DW_TAG_value_to_name(tag), type_name_cstr);
 
-                        Type *element_type = dwarf->ResolveTypeUID(type_die_offset);
+                        Type *element_type = dwarf->ResolveTypeUID(DIERef(type_die_form).GetUID());
 
                         if (element_type)
                         {
                             std::vector<uint64_t> element_orders;
                             ParseChildArrayInfo(sc, die, first_index, element_orders, byte_stride, bit_stride);
                             if (byte_stride == 0 && bit_stride == 0)
                                 byte_stride = element_type->GetByteSize();
                             CompilerType array_element_type = element_type->GetForwardCompilerType ();

                                 clang_type = m_ast.CreateArrayType (array_element_type, 0, is_vector);
                             }
                             ConstString empty_name;
                             type_sp.reset( new Type (die.GetID(),
                                                      dwarf,
                                                      empty_name,
                                                      array_element_bit_stride / 8,
                                                      NULL,
-                                                     type_die_offset,
+                                                     DIERef(type_die_form).GetUID(),
                                                      Type::eEncodingIsUID,
                                                      &decl,
                                                      clang_type,
                                                      Type::eResolveStateFull));
                             type_sp->SetEncodingType (element_type);
                         }
                     }
                 }
                     break;
 
                 case DW_TAG_ptr_to_member_type:
                 {
-                    dw_offset_t type_die_offset = DW_INVALID_OFFSET;
-                    dw_offset_t containing_type_die_offset = DW_INVALID_OFFSET;
+                    DWARFFormValue type_die_form;
+                    DWARFFormValue containing_type_die_form;
 
                     const size_t num_attributes = die.GetAttributes (attributes);
 
                     if (num_attributes > 0) {
                         uint32_t i;
                         for (i=0; i<num_attributes; ++i)
                         {
                             attr = attributes.AttributeAtIndex(i);
                             if (attributes.ExtractFormValueAtIndex(i, form_value))
                             {
                                 switch (attr)
                                 {
                                     case DW_AT_type:
-                                        type_die_offset = form_value.Reference(); break;
+                                        type_die_form = form_value; break;
                                     case DW_AT_containing_type:
-                                        containing_type_die_offset = form_value.Reference(); break;
+                                        containing_type_die_form = form_value; break;
                                 }
                             }
                         }
                         
-                        Type *pointee_type = dwarf->ResolveTypeUID(type_die_offset);
-                        Type *class_type = dwarf->ResolveTypeUID(containing_type_die_offset);
+                        Type *pointee_type = dwarf->ResolveTypeUID(DIERef(type_die_form).GetUID());
+                        Type *class_type = dwarf->ResolveTypeUID(DIERef(containing_type_die_form).GetUID());
                         
                         CompilerType pointee_clang_type = pointee_type->GetForwardCompilerType ();
                         CompilerType class_clang_type = class_type->GetLayoutCompilerType ();
                         
                         clang_type = ClangASTContext::CreateMemberPointerType(pointee_clang_type, class_clang_type);
                         
                         byte_size = clang_type.GetByteSize(nullptr);
                         

                 if (symbol_context_scope != NULL)
                 {
                     type_sp->SetSymbolContextScope(symbol_context_scope);
                 }
                 
                 // We are ready to put this type into the uniqued list up at the module level
                 type_list->Insert (type_sp);
                 
-                dwarf->m_die_to_type[die.GetDIE()] = type_sp.get();
+                dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
             }
         }
         else if (type_ptr != DIE_IS_BEING_PARSED)
         {
             type_sp = type_ptr->shared_from_this();
         }
     }
     return type_sp;
switch (tag)
                         case DW_AT_name:
                             if (attributes.ExtractFormValueAtIndex(i, form_value))
                                 name = form_value.AsCString();
                             break;
 
                         case DW_AT_type:
                             if (attributes.ExtractFormValueAtIndex(i, form_value))
                             {
-                                const dw_offset_t type_die_offset = form_value.Reference();
-                                lldb_type = die.ResolveTypeUID(type_die_offset);
+                                lldb_type = die.ResolveTypeUID(DIERef(form_value).GetUID());
                                 if (lldb_type)
                                     clang_type = lldb_type->GetForwardCompilerType ();
                             }
                             break;
 
                         case DW_AT_const_value:
                             if (attributes.ExtractFormValueAtIndex(i, form_value))
                             {
switch (tag)
 
                             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 dw_offset_t die_offset = method_die_offsets[i];
-                                    DWARFDIE method_die = debug_info->GetDIE (die_offset);
+                                    const DIERef& die_ref = method_die_offsets[i];
+                                    DWARFDIE method_die = debug_info->GetDIE (die_ref);
 
                                     if (method_die)
                                         method_die.ResolveType ();
                                 }
                             }
 
                             for (DelayedPropertyList::iterator pi = delayed_properties.begin(), pe = delayed_properties.end();
                                  pi != pe;
if (die.GetDIENamesAndRanges (name,
             std::unique_ptr<Declaration> decl_ap;
             if (decl_file != 0 || decl_line != 0 || decl_column != 0)
                 decl_ap.reset(new Declaration (sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(decl_file),
                                                decl_line,
                                                decl_column));
 
             SymbolFileDWARF *dwarf = die.GetDWARF();
             // Supply the type _only_ if it has already been parsed
-            Type *func_type = dwarf->m_die_to_type.lookup (die.GetDIE());
+            Type *func_type = dwarf->GetDIEToType().lookup (die.GetDIE());
 
             assert(func_type == NULL || func_type != DIE_IS_BEING_PARSED);
 
             if (dwarf->FixupAddress (func_range.GetBaseAddress()))
             {
                 const user_id_t func_user_id = die.GetID();
                 func_sp.reset(new Function (sc.comp_unit,
                                             func_user_id,       // UserID is the DIE offset
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
                     const char *name = NULL;
                     const char *prop_name = NULL;
                     const char *prop_getter_name = NULL;
                     const char *prop_setter_name = NULL;
                     uint32_t prop_attributes = 0;
 
 
                     bool is_artificial = false;
-                    lldb::user_id_t encoding_uid = LLDB_INVALID_UID;
+                    DWARFFormValue encoding_form;
                     AccessType accessibility = eAccessNone;
                     uint32_t member_byte_offset = UINT32_MAX;
                     size_t byte_size = 0;
                     size_t bit_offset = 0;
                     size_t bit_size = 0;
                     bool is_external = false; // On DW_TAG_members, this means the member is static
                     uint32_t i;
                     for (i=0; i<num_attributes && !is_artificial; ++i)
                     {
                         const dw_attr_t attr = attributes.AttributeAtIndex(i);
                         DWARFFormValue form_value;
                         if (attributes.ExtractFormValueAtIndex(i, form_value))
                         {
                             switch (attr)
                             {
                                 case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
                                 case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
                                 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
                                 case DW_AT_name:        name = form_value.AsCString(); break;
-                                case DW_AT_type:        encoding_uid = form_value.Reference(); break;
+                                case DW_AT_type:        encoding_form = form_value; break;
                                 case DW_AT_bit_offset:  bit_offset = form_value.Unsigned(); break;
                                 case DW_AT_bit_size:    bit_size = form_value.Unsigned(); break;
                                 case DW_AT_byte_size:   byte_size = form_value.Unsigned(); break;
                                 case DW_AT_data_member_location:
                                     if (form_value.BlockData())
                                     {
                                         Value initialValue(0);
                                         Value memberOffset(0);
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
                         // having and extra pointer sized member in our
                         // class layouts.
                         is_artificial = true;
                     }
 
                     // Handle static members
                     if (is_external && member_byte_offset == UINT32_MAX)
                     {
-                        Type *var_type = die.ResolveTypeUID(encoding_uid);
+                        Type *var_type = die.ResolveTypeUID(DIERef(encoding_form).GetUID());
 
                         if (var_type)
                         {
                             if (accessibility == eAccessNone)
                                 accessibility = eAccessPublic;
                             ClangASTContext::AddVariableToRecordType (class_clang_type,
                                                                       name,
                                                                       var_type->GetLayoutCompilerType (),
                                                                       accessibility);
                         }
                         break;
                     }
 
                     if (is_artificial == false)
                     {
-                        Type *member_type = die.ResolveTypeUID(encoding_uid);
+                        Type *member_type = die.ResolveTypeUID(DIERef(encoding_form).GetUID());
 
                         clang::FieldDecl *field_decl = NULL;
                         if (tag == DW_TAG_member)
                         {
                             if (member_type)
                             {
                                 if (accessibility == eAccessNone)
                                     accessibility = default_accessibility;
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
 
                                         if (member_byte_offset >= parent_byte_size)
                                         {
                                             if (member_array_size != 1)
                                             {
                                                 module_sp->ReportError ("0x%8.8" PRIx64 ": DW_TAG_member '%s' refers to type 0x%8.8" PRIx64 " which extends beyond the bounds of 0x%8.8" PRIx64,
                                                                         die.GetID(),
                                                                         name,
-                                                                        encoding_uid,
+                                                                        encoding_form.Reference(),
                                                                         parent_die.GetID());
                                             }
 
                                             member_clang_type = m_ast.CreateArrayType(member_array_element_type, 0, false);
                                         }
                                     }
                                 }
 
                                 field_decl = ClangASTContext::AddFieldToRecordType (class_clang_type,
                                                                                     name,
                                                                                     member_clang_type,
                                                                                     accessibility,
                                                                                     bit_size);
 
                                 m_ast.SetMetadataAsUserID (field_decl, die.GetID());
 
                                 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.8" PRIx64 " which was unable to be parsed",
                                                             die.GetID(),
                                                             name,
-                                                            encoding_uid);
+                                                            encoding_form.Reference());
                                 else
                                     module_sp->ReportError ("0x%8.8" PRIx64 ": DW_TAG_member refers to type 0x%8.8" PRIx64 " which was unable to be parsed",
                                                             die.GetID(),
-                                                            encoding_uid);
+                                                            encoding_form.Reference());
                             }
                         }
 
                         if (prop_name != NULL && member_type)
                         {
                             clang::ObjCIvarDecl *ivar_decl = NULL;
 
                             if (field_decl)
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
                     default_accessibility = eAccessPrivate;
                 // TODO: implement DW_TAG_inheritance type parsing
                 DWARFAttributes attributes;
                 const size_t num_attributes = die.GetAttributes (attributes);
                 if (num_attributes > 0)
                 {
                     Declaration decl;
                     DWARFExpression location(die.GetCU());
-                    lldb::user_id_t encoding_uid = LLDB_INVALID_UID;
+                    DWARFFormValue encoding_form;
                     AccessType accessibility = default_accessibility;
                     bool is_virtual = false;
                     bool is_base_of_class = true;
                     off_t member_byte_offset = 0;
                     uint32_t i;
                     for (i=0; i<num_attributes; ++i)
                     {
                         const dw_attr_t attr = attributes.AttributeAtIndex(i);
                         DWARFFormValue form_value;
                         if (attributes.ExtractFormValueAtIndex(i, form_value))
                         {
                             switch (attr)
                             {
                                 case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
                                 case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
                                 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
-                                case DW_AT_type:        encoding_uid = form_value.Reference(); break;
+                                case DW_AT_type:        encoding_form = form_value; break;
                                 case DW_AT_data_member_location:
                                     if (form_value.BlockData())
                                     {
                                         Value initialValue(0);
                                         Value memberOffset(0);
                                         const DWARFDataExtractor& debug_info_data = die.GetDWARF()->get_debug_info_data();
                                         uint32_t block_length = form_value.Unsigned();
                                         uint32_t block_offset = form_value.BlockData() - debug_info_data.GetDataStart();
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
                                     break;
 
                                 default:
                                     break;
                             }
                         }
                     }
 
-                    Type *base_class_type = die.ResolveTypeUID(encoding_uid);
+                    Type *base_class_type = die.ResolveTypeUID(DIERef(encoding_form).GetUID());
                     if (base_class_type == NULL)
                     {
                         module_sp->ReportError("0x%8.8x: DW_TAG_inheritance failed to resolve the base class at 0x%8.8" PRIx64 " from enclosing type 0x%8.8x. \nPlease file a bug and attach the file at the start of this error message",
                                                die.GetOffset(),
-                                               encoding_uid,
+                                               encoding_form.Reference(),
                                                parent_die.GetOffset());
                         break;
                     }
 
                     CompilerType base_class_clang_type = base_class_type->GetFullCompilerType ();
                     assert (base_class_clang_type);
                     if (class_language == eLanguageTypeObjC)
                     {
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
             case DW_TAG_formal_parameter:
             {
                 DWARFAttributes attributes;
                 const size_t num_attributes = die.GetAttributes(attributes);
                 if (num_attributes > 0)
                 {
                     const char *name = NULL;
                     Declaration decl;
-                    dw_offset_t param_type_die_offset = DW_INVALID_OFFSET;
+                    DWARFFormValue param_type_die_form;
                     bool is_artificial = false;
                     // one of None, Auto, Register, Extern, Static, PrivateExtern
 
                     clang::StorageClass storage = clang::SC_None;
                     uint32_t i;
                     for (i=0; i<num_attributes; ++i)
                     {
                         const dw_attr_t attr = attributes.AttributeAtIndex(i);
                         DWARFFormValue form_value;
                         if (attributes.ExtractFormValueAtIndex(i, form_value))
                         {
                             switch (attr)
                             {
                                 case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
                                 case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
                                 case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
                                 case DW_AT_name:        name = form_value.AsCString();
                                     break;
-                                case DW_AT_type:        param_type_die_offset = form_value.Reference(); break;
+                                case DW_AT_type:        param_type_die_form = form_value; break;
                                 case DW_AT_artificial:  is_artificial = form_value.Boolean(); break;
                                 case DW_AT_location:
                                     //                          if (form_value.BlockData())
                                     //                          {
                                     //                              const DWARFDataExtractor& debug_info_data = debug_info();
                                     //                              uint32_t block_length = form_value.Unsigned();
                                     //                              DWARFDataExtractor location(debug_info_data, form_value.BlockData() - debug_info_data.GetDataStart(), block_length);
                                     //                          }
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
                             {
                                 if (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...
                                     if (name == NULL || ::strcmp(name, "this")==0)
                                     {
-                                        Type *this_type = die.ResolveTypeUID (param_type_die_offset);
+                                        Type *this_type = die.ResolveTypeUID (DIERef(param_type_die_form).GetUID());
                                         if (this_type)
                                         {
                                             uint32_t encoding_mask = this_type->GetEncodingMask();
                                             if (encoding_mask & Type::eEncodingIsPointerUID)
                                             {
                                                 is_static = false;
 
                                                 if (encoding_mask & (1u << Type::eEncodingIsConstUID))
for (DWARFDIE die = parent_die.GetFirstChild(); die.IsValid(); die = die.GetSibling())
                                         break;
                                 }
                             }
                         }
                     }
 
                     if (!skip)
                     {
-                        Type *type = die.ResolveTypeUID(param_type_die_offset);
+                        Type *type = die.ResolveTypeUID(DIERef(param_type_die_form).GetUID());
                         if (type)
                         {
                             function_param_types.push_back (type->GetForwardCompilerType ());
 
                             clang::ParmVarDecl *param_var_decl = m_ast.CreateParameterDeclaration (name,
                                                                                                    type->GetForwardCompilerType (),
                                                                                                    storage);
                             assert(param_var_decl);
if (fast_path)
             }
             else
             {
                 if (log)
                     log->Printf ("warning: tried to unique decl context from 0x%8.8x for 0x%8.8x, but none was found",
                                  src_die.GetOffset(), dst_die.GetOffset());
             }
 
-            Type *src_child_type = dst_die.GetDWARF()->m_die_to_type[src_die.GetDIE()];
+            Type *src_child_type = dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
             if (src_child_type)
             {
                 if (log)
                     log->Printf ("uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x",
                                  static_cast<void*>(src_child_type),
                                  src_child_type->GetID(),
                                  src_die.GetOffset(), dst_die.GetOffset());
-                dst_die.GetDWARF()->m_die_to_type[dst_die.GetDIE()] = src_child_type;
+                dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
             }
             else
             {
                 if (log)
                     log->Printf ("warning: tried to unique lldb_private::Type from 0x%8.8x for 0x%8.8x, but none was found", src_die.GetOffset(), dst_die.GetOffset());
             }
         }
     }
else
                         dst_dwarf_ast_parser->LinkDeclContextToDIE (src_decl_ctx, dst_die);
                     }
                     else
                     {
                         if (log)
                             log->Printf ("warning: tried to unique decl context from 0x%8.8x for 0x%8.8x, but none was found", src_die.GetOffset(), dst_die.GetOffset());
                     }
 
-                    Type *src_child_type = dst_die.GetDWARF()->m_die_to_type[src_die.GetDIE()];
+                    Type *src_child_type = dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
                     if (src_child_type)
                     {
                         if (log)
                             log->Printf ("uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x",
                                          static_cast<void*>(src_child_type),
                                          src_child_type->GetID(),
                                          src_die.GetOffset(),
                                          dst_die.GetOffset());
-                        dst_die.GetDWARF()->m_die_to_type[dst_die.GetDIE()] = src_child_type;
+                        dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
                     }
                     else
                     {
                         if (log)
                             log->Printf ("warning: tried to unique lldb_private::Type from 0x%8.8x for 0x%8.8x, but none was found", src_die.GetOffset(), dst_die.GetOffset());
                     }
                 }
                 else
if (src_size_artificial && dst_size_artificial)
                     dst_dwarf_ast_parser->LinkDeclContextToDIE (src_decl_ctx, dst_die);
                 }
                 else
                 {
                     if (log)
                         log->Printf ("warning: tried to unique decl context from 0x%8.8x for 0x%8.8x, but none was found", src_die.GetOffset(), dst_die.GetOffset());
                 }
                 
-                Type *src_child_type = dst_die.GetDWARF()->m_die_to_type[src_die.GetDIE()];
+                Type *src_child_type = dst_die.GetDWARF()->GetDIEToType()[src_die.GetDIE()];
                 if (src_child_type)
                 {
                     if (log)
                         log->Printf ("uniquing type %p (uid=0x%" PRIx64 ") from 0x%8.8x for 0x%8.8x",
                                      static_cast<void*>(src_child_type),
                                      src_child_type->GetID(),
                                      src_die.GetOffset(), dst_die.GetOffset());
-                    dst_die.GetDWARF()->m_die_to_type[dst_die.GetDIE()] = src_child_type;
+                    dst_die.GetDWARF()->GetDIEToType()[dst_die.GetDIE()] = src_child_type;
                 }
                 else
                 {
                     if (log)
                         log->Printf ("warning: tried to unique lldb_private::Type from 0x%8.8x for 0x%8.8x, but none was found", src_die.GetOffset(), dst_die.GetOffset());
                 }
             }
         }

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

 //===-- DWARFCompileUnit.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFCompileUnit_h_
 #define SymbolFileDWARF_DWARFCompileUnit_h_
 
 #include "lldb/lldb-enumerations.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFDIE.h"
-#include "SymbolFileDWARF.h"
 
 class NameToDIE;
+class SymbolFileDWARF;
+class SymbolFileDWARFDwo;
 
 class DWARFCompileUnit
 {
 public:
     enum Producer 
     {
         eProducerInvalid = 0,
         eProducerClang,
         eProducerGCC,
         eProducerLLVMGCC,
         eProcucerOther
     };
 
     DWARFCompileUnit(SymbolFileDWARF* dwarf2Data);
+    ~DWARFCompileUnit();
 
     bool        Extract(const lldb_private::DWARFDataExtractor &debug_info, lldb::offset_t *offset_ptr);
     size_t      ExtractDIEsIfNeeded (bool cu_die_only);
     DWARFDIE    LookupAddress(const dw_addr_t address);
     size_t      AppendDIEsWithTag (const dw_tag_t tag, DWARFDIECollection& matching_dies, uint32_t depth = UINT32_MAX) const;
     void        Clear();
     bool        Verify(lldb_private::Stream *s) const;
     void        Dump(lldb_private::Stream *s) const;
     dw_offset_t GetOffset() const { return m_offset; }
     lldb::user_id_t GetID () const;
     uint32_t    Size() const { return m_is_dwarf64 ? 23 : 11; /* Size in bytes of the compile unit header */ }
     bool        ContainsDIEOffset(dw_offset_t die_offset) const { return die_offset >= GetFirstDIEOffset() && die_offset < GetNextCompileUnitOffset(); }
     dw_offset_t GetFirstDIEOffset() const { return m_offset + Size(); }
     dw_offset_t GetNextCompileUnitOffset() const { return m_offset + m_length + (m_is_dwarf64 ? 12 : 4); }
     size_t      GetDebugInfoSize() const { return m_length + (m_is_dwarf64 ? 12 : 4) - Size(); /* Size in bytes of the .debug_info data associated with this compile unit. */ }
     uint32_t    GetLength() const { return m_length; }
     uint16_t    GetVersion() const { return m_version; }
     const DWARFAbbreviationDeclarationSet*  GetAbbreviations() const { return m_abbrevs; }
     dw_offset_t GetAbbrevOffset() const;
     uint8_t     GetAddressByteSize() const { return m_addr_size; }
     dw_addr_t   GetBaseAddress() const { return m_base_addr; }
-    dw_addr_t   GetAddrBase() const { return 0; } // TODO: Read out DW_AT_addr_base from the parent compile unit
+    dw_addr_t   GetAddrBase() const { return m_addr_base; }
+    void        SetAddrBase(dw_addr_t addr_base, dw_offset_t base_obj_offset);
     void        ClearDIEs(bool keep_compile_unit_die);
     void        BuildAddressRangeTable (SymbolFileDWARF* dwarf2Data,
                                         DWARFDebugAranges* debug_aranges);
 
+
     lldb_private::TypeSystem *
                 GetTypeSystem();
 
     DWARFFormValue::FixedFormSizes
                 GetFixedFormSizes ();
 
     void
     SetBaseAddress(dw_addr_t base_addr)
AddDIE (DWARFDebugInfoEntry& die)
         // the main compile unit DIE. The compile unit DIE is always
         // the first entry, so if our size is 1, then we are adding
         // the first compile unit child DIE and should reserve
         // the memory.
         if (m_die_array.empty())
             m_die_array.reserve(GetDebugInfoSize() / 24);
         m_die_array.push_back(die);
     }
     
+    void
+    AddCompileUnitDIE (DWARFDebugInfoEntry& die);
+
     bool
     HasDIEsParsed () const
     {
         return m_die_array.size() > 1;
     }
 
     DWARFDIE
     GetDIE (dw_offset_t die_offset);
public:
 
     void *
     GetUserData() const
     {
         return m_user_data;
     }
 
     void
-    SetUserData(void *d)
-    {
-        m_user_data = d;
-    }
+    SetUserData(void *d);
 
     bool
     Supports_DW_AT_APPLE_objc_complete_type ();
 
     bool
     DW_AT_decl_file_attributes_are_invalid();
 
     bool
     Supports_unnamed_objc_bitfields ();
 
     void
-    Index (const uint32_t cu_idx,
-           NameToDIE& func_basenames,
+    Index (NameToDIE& func_basenames,
            NameToDIE& func_fullnames,
            NameToDIE& func_methods,
            NameToDIE& func_selectors,
            NameToDIE& objc_class_selectors,
            NameToDIE& globals,
            NameToDIE& types,
            NameToDIE& namespaces);
 
public:
     GetLanguageType();
 
     bool
     IsDWARF64() const;
 
     bool
     GetIsOptimized ();
 
+    SymbolFileDWARFDwo*
+    GetDwoSymbolFile() const
+    {
+        return m_dwo_symbol_file.get();
+    }
+
+    dw_offset_t
+    GetBaseObjOffset() const
+    {
+        return m_base_obj_offset;
+    }
+
 protected:
     SymbolFileDWARF*    m_dwarf2Data;
+    std::unique_ptr<SymbolFileDWARFDwo> m_dwo_symbol_file;
     const DWARFAbbreviationDeclarationSet *m_abbrevs;
     void *              m_user_data;
     DWARFDebugInfoEntry::collection m_die_array;    // The compile unit debug information entry item
     std::unique_ptr<DWARFDebugAranges> m_func_aranges_ap;   // A table similar to the .debug_aranges table, but this one points to the exact DW_TAG_subprogram DIEs
     dw_addr_t           m_base_addr;
     dw_offset_t         m_offset;
     dw_offset_t         m_length;
     uint16_t            m_version;
     uint8_t             m_addr_size;
     Producer            m_producer;
     uint32_t            m_producer_version_major;
     uint32_t            m_producer_version_minor;
     uint32_t            m_producer_version_update;
     lldb::LanguageType  m_language_type;
     bool                m_is_dwarf64;
     lldb_private::LazyBool m_is_optimized;
-    
+    dw_addr_t           m_addr_base;       // Value of DW_AT_addr_base
+    dw_offset_t         m_base_obj_offset; // If this is a dwo compile unit this is the offset of
+                                           // the base compile unit in the main object file
     void
     ParseProducerInfo ();
+
+    static void
+    IndexPrivate (DWARFCompileUnit* dwarf_cu,
+                  const lldb::LanguageType cu_language,
+                  const DWARFFormValue::FixedFormSizes& fixed_form_sizes,
+                  const dw_offset_t cu_offset,
+                  NameToDIE& func_basenames,
+                  NameToDIE& func_fullnames,
+                  NameToDIE& func_methods,
+                  NameToDIE& func_selectors,
+                  NameToDIE& objc_class_selectors,
+                  NameToDIE& globals,
+                  NameToDIE& types,
+                  NameToDIE& namespaces);
+
 private:
 
     const DWARFDebugInfoEntry*
     GetCompileUnitDIEPtrOnly()
     {
         ExtractDIEsIfNeeded (true);
         if (m_die_array.empty())
             return NULL;

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

 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDIECollection.h"
 #include "DWARFFormValue.h"
 #include "LogChannelDWARF.h"
 #include "NameToDIE.h"
 #include "SymbolFileDWARF.h"
+#include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDebugMap.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std;
 
 
 extern int g_verbose;
DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF* dwarf2Data) :
     m_version       (0),
     m_addr_size     (DWARFCompileUnit::GetDefaultAddressSize()),
     m_producer      (eProducerInvalid),
     m_producer_version_major (0),
     m_producer_version_minor (0),
     m_producer_version_update (0),
     m_language_type (eLanguageTypeUnknown),
     m_is_dwarf64    (false),
-    m_is_optimized  (eLazyBoolCalculate)
+    m_is_optimized  (eLazyBoolCalculate),
+    m_addr_base (0),
+    m_base_obj_offset (DW_INVALID_OFFSET)
 {
 }
 
+DWARFCompileUnit::~DWARFCompileUnit()
+{}
+
 void
 DWARFCompileUnit::Clear()
 {
     m_offset        = DW_INVALID_OFFSET;
     m_length        = 0;
     m_version       = 0;
     m_abbrevs       = NULL;
     m_addr_size     = DWARFCompileUnit::GetDefaultAddressSize();
     m_base_addr     = 0;
     m_die_array.clear();
     m_func_aranges_ap.reset();
     m_user_data     = NULL;
     m_producer      = eProducerInvalid;
     m_language_type = eLanguageTypeUnknown;
     m_is_dwarf64    = false;
     m_is_optimized  = eLazyBoolCalculate;
+    m_addr_base     = 0;
+    m_base_obj_offset = DW_INVALID_OFFSET;
 }
 
 bool
 DWARFCompileUnit::Extract(const DWARFDataExtractor &debug_info, lldb::offset_t *offset_ptr)
 {
     Clear();
 
     m_offset = *offset_ptr;
if (m_die_array.size() > 1)
         // contents.
 
         // Save at least the compile unit DIE
         DWARFDebugInfoEntry::collection tmp_array;
         m_die_array.swap(tmp_array);
         if (keep_compile_unit_die)
             m_die_array.push_back(tmp_array.front());
     }
+
+    if (m_dwo_symbol_file)
+        m_dwo_symbol_file->GetCompileUnit()->ClearDIEs(keep_compile_unit_die);
 }
 
 //----------------------------------------------------------------------
 // ParseCompileUnitDIEsIfNeeded
 //
 // Parses a compile unit and indexes its DIEs if it hasn't already been
 // done.
 //----------------------------------------------------------------------

 //                        die.GetOffset(),
 //                        depth * 2, depth * 2, "",
 //                        DW_TAG_value_to_name (die.Tag()),
 //                        die.HasChildren() ? " *" : "");
 
         const bool null_die = die.IsNULL();
         if (depth == 0)
         {
-            uint64_t base_addr = die.GetAttributeValueAsUnsigned(m_dwarf2Data, this, DW_AT_low_pc, LLDB_INVALID_ADDRESS);
+            if (initial_die_array_size == 0)
+                AddCompileUnitDIE(die);
+            uint64_t base_addr = die.GetAttributeValueAsAddress(m_dwarf2Data, this, DW_AT_low_pc, LLDB_INVALID_ADDRESS);
             if (base_addr == LLDB_INVALID_ADDRESS)
-                base_addr = die.GetAttributeValueAsUnsigned(m_dwarf2Data, this, DW_AT_entry_pc, 0);
+                base_addr = die.GetAttributeValueAsAddress(m_dwarf2Data, this, DW_AT_entry_pc, 0);
             SetBaseAddress (base_addr);
-            if (initial_die_array_size == 0)
-                AddDIE (die);
             if (cu_die_only)
                 return 1;
         }
         else
         {
             if (null_die)
             {
                 if (prev_die_had_children)
if (verbose_log)
         Dump(&strm);
         if (m_die_array.empty())
             strm.Printf("error: no DIE for compile unit");
         else
             m_die_array[0].Dump(m_dwarf2Data, this, strm, UINT32_MAX);        
         verbose_log->PutCString (strm.GetString().c_str());
     }
 
+    if (!m_dwo_symbol_file)
         return m_die_array.size();
+
+    DWARFCompileUnit* dwo_cu = m_dwo_symbol_file->GetCompileUnit();
+    size_t dwo_die_count = dwo_cu->ExtractDIEsIfNeeded(cu_die_only);
+    return m_die_array.size() + dwo_die_count - 1; // We have 2 CU die, but we waht to count it only as one
 }
 
+void
+DWARFCompileUnit::AddCompileUnitDIE(DWARFDebugInfoEntry& die)
+{
+    assert (m_die_array.empty() && "Compile unit DIE already added");
+    AddDIE(die);
+    
+    DWARFDebugInfoEntry& cu_die = m_die_array.front();
+
+    const char* dwo_name = cu_die.GetAttributeValueAsString(m_dwarf2Data,
+                                                            this,
+                                                            DW_AT_GNU_dwo_name,
+                                                            nullptr);
+    if (!dwo_name)
+        return;
+
+    FileSpec dwo_file(dwo_name, true);
+    if (dwo_file.IsRelative())
+    {
+        const char* comp_dir = cu_die.GetAttributeValueAsString(m_dwarf2Data,
+                                                                this,
+                                                                DW_AT_comp_dir,
+                                                                nullptr);
+        if (!comp_dir)
+            return;
+
+        dwo_file.SetFile(comp_dir, true);
+        dwo_file.AppendPathComponent(dwo_name);
+    }
+
+    if (!dwo_file.Exists())
+        return;
+
+    DataBufferSP dwo_file_data_sp;
+    lldb::offset_t dwo_file_data_offset = 0;
+    ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(m_dwarf2Data->GetObjectFile()->GetModule(),
+                                                       &dwo_file,
+                                                       0 /* file_offset */,
+                                                       dwo_file.GetByteSize(),
+                                                       dwo_file_data_sp,
+                                                       dwo_file_data_offset);
+    if (dwo_obj_file == nullptr)
+        return;
+
+    std::unique_ptr<SymbolFileDWARFDwo> dwo_symbol_file(new SymbolFileDWARFDwo(dwo_obj_file, this));
+
+    DWARFCompileUnit* dwo_cu = dwo_symbol_file->GetCompileUnit();
+    if (!dwo_cu)
+        return; // Can't fetch the compile unit from the dwo file.
+
+    DWARFDIE dwo_cu_die = dwo_cu->GetCompileUnitDIEOnly();
+    if (!dwo_cu_die.IsValid())
+        return; // Can't fetch the compile unit DIE from the dwo file.
+
+    uint64_t main_dwo_id = cu_die.GetAttributeValueAsUnsigned(m_dwarf2Data,
+                                                              this,
+                                                              DW_AT_GNU_dwo_id,
+                                                              0);
+    uint64_t sub_dwo_id = dwo_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_dwo_id, 0);
+    if (main_dwo_id != sub_dwo_id)
+        return; // The 2 dwo ID isn't match. Don't use the dwo file as it belongs to a differectn compilation.
+
+    m_dwo_symbol_file = std::move(dwo_symbol_file);
+    
+    dw_addr_t addr_base = cu_die.GetAttributeValueAsUnsigned(m_dwarf2Data,
+                                                             this,
+                                                             DW_AT_GNU_addr_base,
+                                                             0);
+    dwo_cu->SetAddrBase(addr_base, m_offset);
+}
 
 dw_offset_t
 DWARFCompileUnit::GetAbbrevOffset() const
 {
     return m_abbrevs ? m_abbrevs->GetOffset() : DW_INVALID_OFFSET;
 }
 
 

 DWARFCompileUnit::SetDefaultAddressSize(uint8_t addr_size)
 {
     g_default_addr_size = addr_size;
 }
 
 lldb::user_id_t
 DWARFCompileUnit::GetID () const
 {
+    dw_offset_t local_id = m_base_obj_offset != DW_INVALID_OFFSET ? m_base_obj_offset : m_offset;
     if (m_dwarf2Data)
-        return m_dwarf2Data->MakeUserID(GetOffset());
+        return m_dwarf2Data->MakeUserID(local_id);
     else
-        return GetOffset();
+        return local_id;
 }
 
 void
 DWARFCompileUnit::BuildAddressRangeTable (SymbolFileDWARF* dwarf2Data,
                                           DWARFDebugAranges* debug_aranges)
 {
     // This function is usually called if there in no .debug_aranges section
     // in order to produce a compile unit level set of address ranges that
if (m_func_aranges_ap.get() == NULL)
         {
             m_dwarf2Data->GetObjectFile()->GetModule()->LogMessage (log,
                                                                     "DWARFCompileUnit::GetFunctionAranges() for compile unit at .debug_info[0x%8.8x]",
                                                                     GetOffset());
         }
         const DWARFDebugInfoEntry* die = DIEPtr();
         if (die)
             die->BuildFunctionAddressRangeTable (m_dwarf2Data, this, m_func_aranges_ap.get());
+
+        if (m_dwo_symbol_file)
+        {
+            DWARFCompileUnit* dwo_cu = m_dwo_symbol_file->GetCompileUnit();
+            const DWARFDebugInfoEntry* dwo_die = dwo_cu->DIEPtr();
+            if (dwo_die)
+                dwo_die->BuildFunctionAddressRangeTable (m_dwo_symbol_file.get(),
+                                                         dwo_cu,
+                                                         m_func_aranges_ap.get());
+        }
+        
         const bool minimize = false;
         m_func_aranges_ap->Sort(minimize);
     }
     return *m_func_aranges_ap.get();
 }
 
 DWARFDIE
 DWARFCompileUnit::LookupAddress (const dw_addr_t address)

 // grabbing the DIE from this compile unit. Otherwise we grab the DIE
 // from the DWARF file.
 //----------------------------------------------------------------------
 DWARFDIE
 DWARFCompileUnit::GetDIE (dw_offset_t die_offset)
 {
     if (die_offset != DW_INVALID_OFFSET)
     {
+        if (m_dwo_symbol_file)
+            return m_dwo_symbol_file->GetCompileUnit()->GetDIE(die_offset);
+
         if (ContainsDIEOffset(die_offset))
         {
             ExtractDIEsIfNeeded (false);
             DWARFDebugInfoEntry::iterator end = m_die_array.end();
             DWARFDebugInfoEntry::iterator pos = lower_bound(m_die_array.begin(), end, die_offset, CompareDIEOffset);
             if (pos != end)
             {
                 if (die_offset == (*pos).GetOffset())
                     return DWARFDIE(this, &(*pos));
             }
         }
         else
         {
-            return m_dwarf2Data->DebugInfo()->GetDIE (die_offset);
+            // Don't specify the compile unit offset as we don't know it because the DIE belongs to
+            // a different compile unit in the same symbol file.
+            return m_dwarf2Data->DebugInfo()->GetDIE (DIERef(die_offset));
         }
     }
     return DWARFDIE(); // Not found
 }
 
 size_t
 DWARFCompileUnit::AppendDIEsWithTag (const dw_tag_t tag, DWARFDIECollection& dies, uint32_t depth) const
 {

 //    const DWARFDebugInfoEntry* first_die = &m_die_array[0];
 //    const DWARFDebugInfoEntry* end = first_die + m_die_array.size();
 //    if (first_die <= die && die < end)
 //        m_global_die_indexes.push_back (die - first_die);
 //}
 
 
 void
-DWARFCompileUnit::Index (const uint32_t cu_idx,
-                         NameToDIE& func_basenames,
+DWARFCompileUnit::Index (NameToDIE& func_basenames,
                          NameToDIE& func_fullnames,
                          NameToDIE& func_methods,
                          NameToDIE& func_selectors,
                          NameToDIE& objc_class_selectors,
                          NameToDIE& globals,
                          NameToDIE& types,
                          NameToDIE& namespaces)
 {
-    DWARFFormValue::FixedFormSizes fixed_form_sizes =
-        DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), m_is_dwarf64);
-
     Log *log (LogChannelDWARF::GetLogIfAll (DWARF_LOG_LOOKUPS));
     
     if (log)
     {
         m_dwarf2Data->GetObjectFile()->GetModule()->LogMessage (log, 
                                                                 "DWARFCompileUnit::Index() for compile unit at .debug_info[0x%8.8x]",
                                                                 GetOffset());
     }
 
     const LanguageType cu_language = GetLanguageType();
+    DWARFFormValue::FixedFormSizes fixed_form_sizes =
+        DWARFFormValue::GetFixedFormSizesForAddressSize (GetAddressByteSize(), m_is_dwarf64);
+    
+    IndexPrivate(this,
+                 cu_language,
+                 fixed_form_sizes,
+                 GetOffset(),
+                 func_basenames,
+                 func_fullnames,
+                 func_methods,
+                 func_selectors,
+                 objc_class_selectors,
+                 globals,
+                 types,
+                 namespaces);
+
+    SymbolFileDWARFDwo* dwo_symbol_file = GetDwoSymbolFile();
+    if (dwo_symbol_file)
+    {
+        IndexPrivate(dwo_symbol_file->GetCompileUnit(),
+                     cu_language,
+                     fixed_form_sizes,
+                     GetOffset(),
+                     func_basenames,
+                     func_fullnames,
+                     func_methods,
+                     func_selectors,
+                     objc_class_selectors,
+                     globals,
+                     types,
+                     namespaces);
+    }
+}
+
+void
+DWARFCompileUnit::IndexPrivate (DWARFCompileUnit* dwarf_cu,
+                                const LanguageType cu_language,
+                                const DWARFFormValue::FixedFormSizes& fixed_form_sizes,
+                                const dw_offset_t cu_offset,
+                                NameToDIE& func_basenames,
+                                NameToDIE& func_fullnames,
+                                NameToDIE& func_methods,
+                                NameToDIE& func_selectors,
+                                NameToDIE& objc_class_selectors,
+                                NameToDIE& globals,
+                                NameToDIE& types,
+                                NameToDIE& namespaces)
+{
     DWARFDebugInfoEntry::const_iterator pos;
-    DWARFDebugInfoEntry::const_iterator begin = m_die_array.begin();
-    DWARFDebugInfoEntry::const_iterator end = m_die_array.end();
+    DWARFDebugInfoEntry::const_iterator begin = dwarf_cu->m_die_array.begin();
+    DWARFDebugInfoEntry::const_iterator end = dwarf_cu->m_die_array.end();
     for (pos = begin; pos != end; ++pos)
     {
         const DWARFDebugInfoEntry &die = *pos;
         
         const dw_tag_t tag = die.Tag();
     
         switch (tag)
         {
for (pos = begin; pos != end; ++pos)
         const char *name = NULL;
         const char *mangled_cstr = NULL;
         bool is_declaration = false;
         //bool is_artificial = false;
         bool has_address = false;
         bool has_location = false;
         bool is_global_or_static_variable = false;
         
-        dw_offset_t specification_die_offset = DW_INVALID_OFFSET;
-        const size_t num_attributes = die.GetAttributes(this, fixed_form_sizes, attributes);
+        DWARFFormValue specification_die_form;
+        const size_t num_attributes = die.GetAttributes(dwarf_cu, fixed_form_sizes, attributes);
         if (num_attributes > 0)
         {
             for (uint32_t i=0; i<num_attributes; ++i)
             {
                 dw_attr_t attr = attributes.AttributeAtIndex(i);
                 DWARFFormValue form_value;
                 switch (attr)
                 {
//                              }
                                 break;
                             }
                         }
                     }
                     break;
                     
                 case DW_AT_specification:
                     if (attributes.ExtractFormValueAtIndex(i, form_value))
-                        specification_die_offset = form_value.Reference();
+                        specification_die_form = form_value;
                     break;
                 }
             }
         }
 
         switch (tag)
         {
         case DW_TAG_subprogram:
             if (has_address)
             {
                 if (name)
                 {
                     ObjCLanguage::MethodName objc_method(name, true);
                     if (objc_method.IsValid(true))
                     {
                         ConstString objc_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 objc_class_name_no_category (objc_method.GetClassName());
-                        func_fullnames.Insert (ConstString(name), die.GetOffset());
+                        func_fullnames.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset()));
                         if (objc_class_name_with_category)
-                            objc_class_selectors.Insert(objc_class_name_with_category, die.GetOffset());
+                            objc_class_selectors.Insert(objc_class_name_with_category, DIERef(cu_offset, die.GetOffset()));
                         if (objc_class_name_no_category && objc_class_name_no_category != objc_class_name_with_category)
-                            objc_class_selectors.Insert(objc_class_name_no_category, die.GetOffset());
+                            objc_class_selectors.Insert(objc_class_name_no_category, DIERef(cu_offset, die.GetOffset()));
                         if (objc_selector_name)
-                            func_selectors.Insert (objc_selector_name, die.GetOffset());
+                            func_selectors.Insert (objc_selector_name, DIERef(cu_offset, die.GetOffset()));
                         if (objc_fullname_no_category_name)
-                            func_fullnames.Insert (objc_fullname_no_category_name, die.GetOffset());
+                            func_fullnames.Insert (objc_fullname_no_category_name, DIERef(cu_offset, die.GetOffset()));
                     }
                     // If we have a mangled name, then the DW_AT_name attribute
                     // is usually the method name without the class or any parameters
                     const DWARFDebugInfoEntry *parent = die.GetParent();
                     bool is_method = false;
                     if (parent)
                     {
                         dw_tag_t parent_tag = parent->Tag();
                         if (parent_tag == DW_TAG_class_type || parent_tag == DW_TAG_structure_type)
                         {
                             is_method = true;
                         }
                         else
                         {
-                            if (specification_die_offset != DW_INVALID_OFFSET)
+                            if (specification_die_form.IsValid())
                             {
-                                DWARFDIE specification_die = m_dwarf2Data->DebugInfo()->GetDIE (specification_die_offset);
+                                DWARFDIE specification_die = dwarf_cu->GetSymbolFileDWARF()->DebugInfo()->GetDIE (DIERef(specification_die_form));
                                 if (specification_die.GetParent().IsStructOrClass())
                                     is_method = true;
                             }
                         }
                     }
 
 
                     if (is_method)
-                        func_methods.Insert (ConstString(name), die.GetOffset());
+                        func_methods.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset()));
                     else
-                        func_basenames.Insert (ConstString(name), die.GetOffset());
+                        func_basenames.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset()));
 
                     if (!is_method && !mangled_cstr && !objc_method.IsValid(true))
-                        func_fullnames.Insert (ConstString(name), die.GetOffset());
+                        func_fullnames.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset()));
                 }
                 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 != mangled_cstr && ((mangled_cstr[0] == '_') || (name && ::strcmp(name, mangled_cstr) != 0)))
                     {
                         Mangled mangled (ConstString(mangled_cstr), true);
-                        func_fullnames.Insert (mangled.GetMangledName(), die.GetOffset());
+                        func_fullnames.Insert (mangled.GetMangledName(), DIERef(cu_offset, die.GetOffset()));
                         ConstString demangled = mangled.GetDemangledName(cu_language);
                         if (demangled)
-                            func_fullnames.Insert (demangled, die.GetOffset());
+                            func_fullnames.Insert (demangled, DIERef(cu_offset, die.GetOffset()));
                     }
                 }
             }
             break;
 
         case DW_TAG_inlined_subroutine:
             if (has_address)
             {
                 if (name)
-                    func_basenames.Insert (ConstString(name), die.GetOffset());
+                    func_basenames.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset()));
                 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 != mangled_cstr && ((mangled_cstr[0] == '_') || (::strcmp(name, mangled_cstr) != 0)))
                     {
                         Mangled mangled (ConstString(mangled_cstr), true);
-                        func_fullnames.Insert (mangled.GetMangledName(), die.GetOffset());
+                        func_fullnames.Insert (mangled.GetMangledName(), DIERef(cu_offset, die.GetOffset()));
                         ConstString demangled = mangled.GetDemangledName(cu_language);
                         if (demangled)
-                            func_fullnames.Insert (demangled, die.GetOffset());
+                            func_fullnames.Insert (demangled, DIERef(cu_offset, die.GetOffset()));
                     }
                 }
                 else
-                    func_fullnames.Insert (ConstString(name), die.GetOffset());
+                    func_fullnames.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset()));
             }
             break;
         
         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_subroutine_type:
         case DW_TAG_structure_type:
         case DW_TAG_union_type:
         case DW_TAG_typedef:
         case DW_TAG_unspecified_type:
             if (name && is_declaration == false)
             {
-                types.Insert (ConstString(name), die.GetOffset());
+                types.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset()));
             }
             break;
 
         case DW_TAG_namespace:
             if (name)
-                namespaces.Insert (ConstString(name), die.GetOffset());
+                namespaces.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset()));
             break;
 
         case DW_TAG_variable:
             if (name && has_location && is_global_or_static_variable)
             {
-                globals.Insert (ConstString(name), die.GetOffset());
+                globals.Insert (ConstString(name), DIERef(cu_offset, die.GetOffset()));
                 // 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)))
                 {
                     Mangled mangled (ConstString(mangled_cstr), true);
-                    globals.Insert (mangled.GetMangledName(), die.GetOffset());
+                    globals.Insert (mangled.GetMangledName(), DIERef(cu_offset, die.GetOffset()));
                     ConstString demangled = mangled.GetDemangledName(cu_language);
                     if (demangled)
-                        globals.Insert (demangled, die.GetOffset());
+                        globals.Insert (demangled, DIERef(cu_offset, die.GetOffset()));
                 }
             }
             break;
             
         default:
             continue;
         }
     }

 TypeSystem *
 DWARFCompileUnit::GetTypeSystem ()
 {
     if (m_dwarf2Data)
         return m_dwarf2Data->GetTypeSystemForLanguage(GetLanguageType());
     else
         return nullptr;
 }
+
+void
+DWARFCompileUnit::SetUserData(void *d)
+{
+    m_user_data = d;
+    if (m_dwo_symbol_file)
+        m_dwo_symbol_file->GetCompileUnit()->SetUserData(d);
+}
+
+void
+DWARFCompileUnit::SetAddrBase(dw_addr_t addr_base, dw_offset_t base_obj_offset)
+{
+    m_addr_base = addr_base;
+    m_base_obj_offset = base_obj_offset;
+}

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

 //===-- DWARFDIE.h ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFDIE_h_
 #define SymbolFileDWARF_DWARFDIE_h_
 
 #include "lldb/lldb-types.h"
 #include "lldb/Core/dwarf.h"
 
+struct DIERef;
 class DWARFASTParser;
 class DWARFAttributes;
 class DWARFCompileUnit;
 class DWARFDebugInfoEntry;
 class DWARFDeclContext;
 class DWARFDIECollection;
 class SymbolFileDWARF;
 
public:
     }
 
     DWARFDebugInfoEntry *
     GetDIE() const
     {
         return m_die;
     }
 
+    DIERef
+    GetDIERef() const;
+
     lldb_private::TypeSystem *
     GetTypeSystem () const;
 
     DWARFASTParser *
     GetDWARFParser () const;
 
     void
     Set (DWARFCompileUnit *cu, DWARFDebugInfoEntry *die)
public:
     GetAttributeValueAsUnsigned (const dw_attr_t attr, uint64_t fail_value) const;
 
     int64_t
     GetAttributeValueAsSigned (const dw_attr_t attr, int64_t fail_value) const;
 
     uint64_t
     GetAttributeValueAsReference (const dw_attr_t attr, uint64_t fail_value) const;
 
+    uint64_t
+    GetAttributeValueAsAddress (const dw_attr_t attr, uint64_t fail_value) const;
+
     size_t
     GetAttributes (DWARFAttributes &attributes, uint32_t depth = 0) const;
 
     bool
     GetDIENamesAndRanges (const char * &name,
                           const char * &mangled,
                           DWARFRangeList& ranges,
                           int& decl_file,

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

 #include "DWARFFormValue.h"
 #include "DWARFLocationDescription.h"
 #include "DWARFLocationList.h"
 #include "SymbolFileDWARF.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ObjectFile.h"
 
+DIERef
+DWARFDIE::GetDIERef() const
+{
+    if (!IsValid())
+        return DIERef();
+
+    dw_offset_t cu_offset = m_cu->GetOffset();
+    if (m_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
+        cu_offset = m_cu->GetBaseObjOffset();
+    return DIERef(cu_offset, m_die->GetOffset());
+}
+
 dw_tag_t
 DWARFDIE::Tag() const
 {
     if (m_die)
         return m_die->Tag();
     else
         return 0;
 }

 DWARFDIE::GetAttributeValueAsReference (const dw_attr_t attr, uint64_t fail_value) const
 {
     if (IsValid())
         return m_die->GetAttributeValueAsReference(GetDWARF(), GetCU(), attr, fail_value);
     else
         return fail_value;
 }
 
+uint64_t
+DWARFDIE::GetAttributeValueAsAddress (const dw_attr_t attr, uint64_t fail_value) const
+{
+    if (IsValid())
+        return m_die->GetAttributeValueAsAddress(GetDWARF(), GetCU(), attr, fail_value);
+    else
+        return fail_value;
+}
+
 
 DWARFDIE
 DWARFDIE::LookupDeepestBlock (lldb::addr_t file_addr) const
 {
     if (IsValid())
     {
         SymbolFileDWARF *dwarf= GetDWARF();
         DWARFCompileUnit *cu = GetCU();
         DWARFDebugInfoEntry* function_die = nullptr;
         DWARFDebugInfoEntry* block_die = nullptr;
         if (m_die->LookupAddress (file_addr,
                                   dwarf,
                                   cu,
                                   &function_die,
                                   &block_die))
         {
             if (block_die && block_die != function_die)
             {
                 if (cu->ContainsDIEOffset(block_die->GetOffset()))
                     return DWARFDIE(cu, block_die);
                 else
-                    return DWARFDIE(dwarf->DebugInfo()->GetCompileUnitContainingDIE(block_die->GetOffset()), block_die);
+                    return DWARFDIE(dwarf->DebugInfo()->GetCompileUnitContainingDIE(DIERef(cu->GetOffset(), block_die->GetOffset())), block_die);
             }
         }
     }
     return DWARFDIE();
 }
 
 lldb::user_id_t
 DWARFDIE::GetID () const
 {
     const dw_offset_t die_offset = GetOffset();
     if (die_offset != DW_INVALID_OFFSET)
     {
+        lldb::user_id_t id = 0;
         SymbolFileDWARF *dwarf = GetDWARF();
         if (dwarf)
-            return dwarf->MakeUserID(die_offset);
+            id = dwarf->MakeUserID(die_offset);
         else
-            return die_offset;
+            id = die_offset;
+
+        if (m_cu)
+        {
+            assert ((id&0xffffffff00000000ull) == 0 || m_cu->GetOffset() == 0);
+            id |= ((lldb::user_id_t)m_cu->GetOffset()) << 32;
+        }
+        return id;
     }
     return LLDB_INVALID_UID;
 }
 
 const char *
 DWARFDIE::GetName () const
 {
     if (IsValid())

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

typedef dw_offset_t (*Callback)(
         DWARFDebugInfoEntry* die,
         const dw_offset_t next_offset,
         const uint32_t depth,
         void* userData);
 
     DWARFDebugInfo();
     void SetDwarfData(SymbolFileDWARF* dwarf2Data);
 
-    DWARFDIE
-    LookupAddress(const dw_addr_t address,
-                  const dw_offset_t cu_offset);    // Can be valid (find in .debug_aranges), or DW_INVALID_OFFSET if we need to search manually
-
     size_t GetNumCompileUnits();
     bool ContainsCompileUnit (const DWARFCompileUnit *cu) const;
     DWARFCompileUnit* GetCompileUnitAtIndex (uint32_t idx);
     DWARFCompileUnit* GetCompileUnit (dw_offset_t cu_offset, uint32_t* idx_ptr = NULL);
-    DWARFCompileUnit* GetCompileUnitContainingDIE (dw_offset_t die_offset);
+    DWARFCompileUnit* GetCompileUnitContainingDIE (const DIERef& die_ref);
 
-    DWARFDIE GetDIE (dw_offset_t die_offset);
-    DWARFDIE GetDIEContainingOffset (dw_offset_t die_offset);
+    DWARFDIE GetDIE (const DIERef& die_ref);
 
     void Dump(lldb_private::Stream *s, const uint32_t die_offset, const uint32_t recurse_depth);
     static void Parse(SymbolFileDWARF* parser, Callback callback, void* userData);
     static void Verify(lldb_private::Stream *s, SymbolFileDWARF* dwarf2Data);
     static void Dump(lldb_private::Stream *s, SymbolFileDWARF* dwarf2Data, const uint32_t die_offset, const uint32_t recurse_depth);
     bool Find(const char* name, bool ignore_case, std::vector<dw_offset_t>& die_offsets) const;
     bool Find(lldb_private::RegularExpression& re, std::vector<dw_offset_t>& die_offsets) const;
 

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

if (m_cu_aranges_ap.get() == NULL && m_dwarf2Data)
         }
 
         const bool minimize = true;
         m_cu_aranges_ap->Sort (minimize);
     }
     return *m_cu_aranges_ap.get();
 }
 
-
-//----------------------------------------------------------------------
-// LookupAddress
-//----------------------------------------------------------------------
-DWARFDIE
-DWARFDebugInfo::LookupAddress (const dw_addr_t address,
-                               const dw_offset_t hint_die_offset)
-{
-    DWARFDIE die;
-    DWARFCompileUnit *cu = nullptr;
-    if (hint_die_offset != DW_INVALID_OFFSET)
-    {
-        cu = GetCompileUnit(hint_die_offset);
-    }
-    else
-    {
-        DWARFDebugAranges &cu_aranges = GetCompileUnitAranges ();
-        const dw_offset_t cu_offset = cu_aranges.FindAddress (address);
-        cu = GetCompileUnit(cu_offset);
-    }
-
-    if (cu)
-    {
-        die = cu->LookupAddress(address);
-    }
-    else
-    {
-        // The hint_die_offset may have been a pointer to the actual item that
-        // we are looking for
-        die = GetDIE(hint_die_offset);
-        if (die)
-        {
-            DWARFDebugInfoEntry* function_die = nullptr;
-
-            if (die.GetDIE()->LookupAddress (address, die.GetDWARF(), die.GetCU(), &function_die, nullptr))
-                die.Set (die.GetCU(), function_die);
-        }
-    }
-    return die;
-}
-
-
 void
 DWARFDebugInfo::ParseCompileUnitHeadersIfNeeded()
 {
     if (m_compile_units.empty())
     {
         if (m_dwarf2Data != NULL)
         {
             lldb::offset_t offset = 0;
if (cu_offset != DW_INVALID_OFFSET)
         }
     }
     if (idx_ptr)
         *idx_ptr = cu_idx;
     return cu_sp.get();
 }
 
 DWARFCompileUnit *
-DWARFDebugInfo::GetCompileUnitContainingDIE (dw_offset_t die_offset)
+DWARFDebugInfo::GetCompileUnitContainingDIE (const DIERef& die_ref)
 {
+    dw_offset_t search_offset = die_ref.die_offset;
+    bool is_cu_offset = false;
+    if (m_dwarf2Data->GetID() == 0 && die_ref.cu_offset != DW_INVALID_OFFSET)
+    {
+        is_cu_offset = true;
+        search_offset = die_ref.cu_offset;
+    }
+
     DWARFCompileUnitSP cu_sp;
-    if (die_offset != DW_INVALID_OFFSET)
+    if (search_offset != DW_INVALID_OFFSET)
     {
         ParseCompileUnitHeadersIfNeeded();
 
         // Watch out for single compile unit executable as they are pretty common
         const size_t num_cus = m_compile_units.size();
         if (num_cus == 1)
         {
-            if (m_compile_units[0]->ContainsDIEOffset(die_offset))
+            if ((is_cu_offset && m_compile_units[0]->GetOffset() == search_offset) ||
+                (!is_cu_offset && m_compile_units[0]->ContainsDIEOffset(search_offset)))
+            {
                 cu_sp = m_compile_units[0];
             }
+        }
         else if (num_cus)
         {
             CompileUnitColl::const_iterator end_pos = m_compile_units.end();
             CompileUnitColl::const_iterator begin_pos = m_compile_units.begin();
-            CompileUnitColl::const_iterator pos = std::upper_bound(begin_pos, end_pos, die_offset, OffsetLessThanCompileUnitOffset);
+            CompileUnitColl::const_iterator pos = std::upper_bound(begin_pos, end_pos, search_offset, OffsetLessThanCompileUnitOffset);
             if (pos != begin_pos)
             {
                 --pos;
-                if ((*pos)->ContainsDIEOffset(die_offset))
+                if ((is_cu_offset && (*pos)->GetOffset() == search_offset) ||
+                    (!is_cu_offset && (*pos)->ContainsDIEOffset(search_offset)))
+                {
                     cu_sp = *pos;
                 }
             }
         }
+    }
     return cu_sp.get();
 }
 
 //----------------------------------------------------------------------
 // GetDIE()
 //
 // Get the DIE (Debug Information Entry) with the specified offset.
 //----------------------------------------------------------------------
 DWARFDIE
-DWARFDebugInfo::GetDIE(dw_offset_t die_offset)
+DWARFDebugInfo::GetDIE(const DIERef& die_ref)
 {
-    DWARFCompileUnit *cu = GetCompileUnitContainingDIE(die_offset);
+    DWARFCompileUnit *cu = GetCompileUnitContainingDIE(die_ref);
     if (cu)
-        return cu->GetDIE (die_offset);
+        return cu->GetDIE (die_ref.die_offset);
     return DWARFDIE();    // Not found
 }
 
 //----------------------------------------------------------------------
 // Parse
 //
 // Parses the .debug_info section and uses the .debug_abbrev section
 // and various other sections in the SymbolFileDWARF class and calls the

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

bool        LookupAddress(
                     DWARFDebugInfoEntry** block_die);
 
     size_t      GetAttributes(
                     const DWARFCompileUnit* cu,
                     DWARFFormValue::FixedFormSizes fixed_form_sizes,
                     DWARFAttributes& attrs,
                     uint32_t curr_depth = 0) const; // "curr_depth" for internal use only, don't set this yourself!!!
 
-    dw_offset_t GetAttributeValue(
-                    SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
-                    const dw_attr_t attr,
-                    DWARFFormValue& formValue,
-                    dw_offset_t* end_attr_offset_ptr = NULL) const;
-
     const char* GetAttributeValueAsString(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
                     const dw_attr_t attr,
-                    const char* fail_value) const;
+                    const char* fail_value,
+                    bool check_specification_or_abstract_origin = false) const;
 
     uint64_t    GetAttributeValueAsUnsigned(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
                     const dw_attr_t attr,
-                    uint64_t fail_value) const;
+                    uint64_t fail_value,
+                    bool check_specification_or_abstract_origin = false) const;
 
     uint64_t    GetAttributeValueAsReference(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
                     const dw_attr_t attr,
-                    uint64_t fail_value) const;
+                    uint64_t fail_value,
+                    bool check_specification_or_abstract_origin = false) const;
 
     int64_t     GetAttributeValueAsSigned(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
                     const dw_attr_t attr,
-                    int64_t fail_value) const;
+                    int64_t fail_value,
+                    bool check_specification_or_abstract_origin = false) const;
+
+    uint64_t    GetAttributeValueAsAddress(
+                    SymbolFileDWARF* dwarf2Data,
+                    const DWARFCompileUnit* cu,
+                    const dw_attr_t attr,
+                    uint64_t fail_value,
+                    bool check_specification_or_abstract_origin = false) const;
 
     dw_addr_t   GetAttributeHighPC(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
                     dw_addr_t lo_pc,
-                    uint64_t fail_value) const;
+                    uint64_t fail_value,
+                    bool check_specification_or_abstract_origin = false) const;
 
     bool        GetAttributeAddressRange(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
                     dw_addr_t& lo_pc,
                     dw_addr_t& hi_pc,
-                    uint64_t fail_value) const;
+                    uint64_t fail_value,
+                    bool check_specification_or_abstract_origin = false) const;
     
     size_t      GetAttributeAddressRanges (
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
                     DWARFRangeList &ranges,
-                    bool check_hi_lo_pc) const;
-    
-    dw_offset_t GetAttributeValueAsLocation(
-                    SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
-                    const dw_attr_t attr,
-                    lldb_private::DWARFDataExtractor& data,
-                    uint32_t &block_size) const;
+                    bool check_hi_lo_pc,
+                    bool check_specification_or_abstract_origin = false) const;
 
     const char* GetName(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu) const;
 
     const char* GetMangledName(
                     SymbolFileDWARF* dwarf2Data,
                     const DWARFCompileUnit* cu,
SetEmptyChildren (bool b)
         m_empty_children = b;
     }
 
     static void
     DumpDIECollection (lldb_private::Stream &strm,
                        DWARFDebugInfoEntry::collection &die_collection);
 
 protected:
+    dw_offset_t GetAttributeValue(SymbolFileDWARF* dwarf2Data,
+                                  const DWARFCompileUnit* cu,
+                                  const dw_attr_t attr,
+                                  DWARFFormValue& formValue,
+                                  dw_offset_t* end_attr_offset_ptr = nullptr,
+                                  bool check_specification_or_abstract_origin = false) const;
+
     dw_offset_t m_offset;           // Offset within the .debug_info of the start of this entry
     uint32_t    m_parent_idx;       // How many to subtract from "this" to get the parent. If zero this die has no parent
     uint32_t    m_sibling_idx:31,   // How many to add to "this" to get the sibling.
                 m_empty_children:1; // If a DIE says it had children, yet it just contained a NULL tag, this will be set.
     uint32_t    m_abbr_idx:DIE_ABBR_IDX_BITSIZE,
                 m_has_children:1,   // Set to 1 if this DIE has children
                 m_tag:16;           // A copy of the DW_TAG value so we don't have to go through the compile unit abbrev table
-                
 };
 
 #endif  // SymbolFileDWARF_DWARFDebugInfoEntry_h_

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

 #include <algorithm>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ObjectFile.h"
 
 #include "DWARFCompileUnit.h"
-#include "SymbolFileDWARF.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDeclContext.h"
 #include "DWARFDIECollection.h"
 #include "DWARFFormValue.h"
 #include "DWARFLocationDescription.h"
 #include "DWARFLocationList.h"
 #include "DWARFDebugRanges.h"
+#include "SymbolFileDWARF.h"
+#include "SymbolFileDWARFDwo.h"
 
 using namespace lldb_private;
 using namespace std;
 extern int g_verbose;
 
 bool
 DWARFDebugInfoEntry::FastExtract
 (
if ((offset < cu_end_offset) && debug_info_data.ValidOffset(offset))
                     abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
 
                     if (isCompileUnitTag && ((attr == DW_AT_entry_pc) || (attr == DW_AT_low_pc)))
                     {
                         DWARFFormValue form_value(cu, form);
                         if (form_value.ExtractValue(debug_info_data, &offset))
                         {
                             if (attr == DW_AT_low_pc || attr == DW_AT_entry_pc)
-                                ((DWARFCompileUnit*)cu)->SetBaseAddress(form_value.Unsigned());
+                                const_cast<DWARFCompileUnit*>(cu)->SetBaseAddress(form_value.Address());
                         }
                     }
                     else
                     {
                         bool form_is_indirect = false;
                         do
                         {
                             form_is_indirect = false;
(
     int& decl_line,
     int& decl_column,
     int& call_file,
     int& call_line,
     int& call_column,
     DWARFExpression *frame_base
 ) const
 {
-    if (dwarf2Data == NULL)
+    if (dwarf2Data == nullptr)
         return false;
 
+    SymbolFileDWARFDwo* dwo_symbol_file = cu->GetDwoSymbolFile();
+    if (dwo_symbol_file)
+        return GetDIENamesAndRanges(dwo_symbol_file,
+                                    dwo_symbol_file->GetCompileUnit(),
+                                    name,
+                                    mangled,
+                                    ranges,
+                                    decl_file,
+                                    decl_line,
+                                    decl_column,
+                                    call_file,
+                                    call_line,
+                                    call_column,
+                                    frame_base);
+
     dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
     dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
-    std::vector<dw_offset_t> die_offsets;
+    std::vector<DIERef> die_refs;
     bool set_frame_base_loclist_addr = false;
     
     lldb::offset_t offset;
     const DWARFAbbreviationDeclaration* abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
 
     lldb::ModuleSP module = dwarf2Data->GetObjectFile()->GetModule();
 
     if (abbrevDecl)
if (abbrevDecl)
         {
             abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
             DWARFFormValue form_value(cu, form);
             if (form_value.ExtractValue(debug_info_data, &offset))
             {
                 switch (attr)
                 {
                 case DW_AT_low_pc:
-                    lo_pc = form_value.Unsigned();
+                    lo_pc = form_value.Address();
 
                     if (do_offset)
                         hi_pc += lo_pc;
                     do_offset = false;
                     break;
 
                 case DW_AT_entry_pc:
-                    lo_pc = form_value.Unsigned();
+                    lo_pc = form_value.Address();
                     break;
 
                 case DW_AT_high_pc:
-                    hi_pc = form_value.Unsigned();
-                    if (form_value.Form() != DW_FORM_addr)
+                    if (form_value.Form() == DW_FORM_addr ||
+                        form_value.Form() == DW_FORM_GNU_addr_index)
+                    {
+                        hi_pc = form_value.Address();
+                    }
+                    else
                     {
+                        hi_pc = form_value.Unsigned();
                         if (lo_pc == LLDB_INVALID_ADDRESS)
                             do_offset = hi_pc != LLDB_INVALID_ADDRESS;
                         else
                             hi_pc += lo_pc; // DWARF 4 introduces <offset-from-lo-pc> to save on relocations
                     }
                     break;
 
                 case DW_AT_ranges:
if (abbrevDecl)
 
                 case DW_AT_MIPS_linkage_name:
                 case DW_AT_linkage_name:
                     if (mangled == NULL)
                         mangled = form_value.AsCString();
                     break;
 
                 case DW_AT_abstract_origin:
-                    die_offsets.push_back(form_value.Reference());
+                    die_refs.emplace_back(form_value);
                     break;
 
                 case DW_AT_specification:
-                    die_offsets.push_back(form_value.Reference());
+                    die_refs.emplace_back(form_value);
                     break;
 
                 case DW_AT_decl_file:
                     if (decl_file == 0)
                         decl_file = form_value.Unsigned();
                     break;
 
                 case DW_AT_decl_line:
) const
     {
         dw_addr_t lowest_range_pc = ranges.GetMinRangeBase(0);
         assert (lowest_range_pc >= cu->GetBaseAddress());
         frame_base->SetLocationListSlide (lowest_range_pc - cu->GetBaseAddress());
     }
 
     if (ranges.IsEmpty() || name == NULL || mangled == NULL)
     {
-        std::vector<dw_offset_t>::const_iterator pos;
-        std::vector<dw_offset_t>::const_iterator end = die_offsets.end();
-        for (pos = die_offsets.begin(); pos != end; ++pos)
+        for (const DIERef& die_ref : die_refs)
         {
-            dw_offset_t die_offset = *pos;
-            if (die_offset != DW_INVALID_OFFSET)
+            if (die_ref.die_offset != DW_INVALID_OFFSET)
             {
-                DWARFDIE die = dwarf2Data->DebugInfo()->GetDIE(die_offset);
+                DWARFDIE die = dwarf2Data->DebugInfo()->GetDIE(die_ref);
                 if (die)
                     die.GetDIE()->GetDIENamesAndRanges(die.GetDWARF(), die.GetCU(), name, mangled, ranges, decl_file, decl_line, decl_column, call_file, call_line, call_column);
             }
         }
     }
     return !ranges.IsEmpty();
 }
 
DWARFDebugInfoEntry::GetAttributes (const DWARFCompileUnit* cu,
                                     DWARFAttributes& attributes,
                                     uint32_t curr_depth) const
 {
     SymbolFileDWARF* dwarf2Data = nullptr;
     const DWARFAbbreviationDeclaration* abbrevDecl = nullptr;
     lldb::offset_t offset = 0;
     if (cu)
     {
+        if (m_tag != DW_TAG_compile_unit)
+        {
+            SymbolFileDWARFDwo* dwo_symbol_file = cu->GetDwoSymbolFile();
+            if (dwo_symbol_file)
+                return GetAttributes(dwo_symbol_file->GetCompileUnit(),
+                                     fixed_form_sizes,
+                                     attributes,
+                                     curr_depth);
+        }
+
         dwarf2Data = cu->GetSymbolFileDWARF();
         abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
     }
 
     if (abbrevDecl)
     {
         const DWARFDataExtractor& debug_info_data = dwarf2Data->get_debug_info_data();
 

 //----------------------------------------------------------------------
 dw_offset_t
 DWARFDebugInfoEntry::GetAttributeValue
 (
     SymbolFileDWARF* dwarf2Data,
     const DWARFCompileUnit* cu,
     const dw_attr_t attr,
     DWARFFormValue& form_value,
-    dw_offset_t* end_attr_offset_ptr
+    dw_offset_t* end_attr_offset_ptr,
+    bool check_specification_or_abstract_origin
 ) const
 {
+    SymbolFileDWARFDwo* dwo_symbol_file = cu->GetDwoSymbolFile();
+    if (dwo_symbol_file && m_tag != DW_TAG_compile_unit)
+        return GetAttributeValue(dwo_symbol_file,
+                                 dwo_symbol_file->GetCompileUnit(),
+                                 attr,
+                                 form_value,
+                                 end_attr_offset_ptr,
+                                 check_specification_or_abstract_origin);
+
     lldb::offset_t offset;
     const DWARFAbbreviationDeclaration* abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
 
     if (abbrevDecl)
     {
         uint32_t attr_idx = abbrevDecl->FindAttributeIndex(attr);
 
         if (attr_idx != DW_INVALID_INDEX)
if (abbrevDecl)
             {
                 if (end_attr_offset_ptr)
                     *end_attr_offset_ptr = offset;
                 return attr_offset;
             }
         }
     }
 
+    if (check_specification_or_abstract_origin)
+    {
+        if (GetAttributeValue(dwarf2Data, cu, DW_AT_specification, form_value))
+        {
+            DWARFDIE die = const_cast<DWARFCompileUnit*>(cu)->GetDIE(form_value.Reference());
+            if (die)
+            {
+                dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(die.GetDWARF(),
+                                                                         die.GetCU(),
+                                                                         attr,
+                                                                         form_value,
+                                                                         end_attr_offset_ptr,
+                                                                         false);
+                if (die_offset)
+                    return die_offset;
+            }
+        }
+
+        if (GetAttributeValue(dwarf2Data, cu, DW_AT_abstract_origin, form_value))
+        {
+            DWARFDIE die = const_cast<DWARFCompileUnit*>(cu)->GetDIE(form_value.Reference());
+            if (die)
+            {
+                dw_offset_t die_offset = die.GetDIE()->GetAttributeValue(die.GetDWARF(),
+                                                                         die.GetCU(),
+                                                                         attr,
+                                                                         form_value,
+                                                                         end_attr_offset_ptr,
+                                                                         false);
+                if (die_offset)
+                    return die_offset;
+            }
+        }
+    }
+
+    if (!dwo_symbol_file)
         return 0;
+
+    DWARFCompileUnit* dwo_cu = dwo_symbol_file->GetCompileUnit();
+    if (!dwo_cu)
+        return 0;
+
+    DWARFDIE dwo_cu_die = dwo_cu->GetCompileUnitDIEOnly();
+    if (!dwo_cu_die.IsValid())
+        return 0;
+
+    return dwo_cu_die.GetDIE()->GetAttributeValue(dwo_symbol_file,
+                                                  dwo_cu,
+                                                  attr,
+                                                  form_value,
+                                                  end_attr_offset_ptr,
+                                                  check_specification_or_abstract_origin);
 }
 
 //----------------------------------------------------------------------
 // GetAttributeValueAsString
 //
 // Get the value of an attribute as a string return it. The resulting
 // pointer to the string data exists within the supplied SymbolFileDWARF
 // and will only be available as long as the SymbolFileDWARF is still around
 // and it's content doesn't change.
 //----------------------------------------------------------------------
 const char*
 DWARFDebugInfoEntry::GetAttributeValueAsString
 (
     SymbolFileDWARF* dwarf2Data,
     const DWARFCompileUnit* cu,
     const dw_attr_t attr,
-    const char* fail_value) const
+    const char* fail_value,
+    bool check_specification_or_abstract_origin) const
 {
     DWARFFormValue form_value;
-    if (GetAttributeValue(dwarf2Data, cu, attr, form_value))
+    if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr, check_specification_or_abstract_origin))
         return form_value.AsCString();
     return fail_value;
 }
 
 //----------------------------------------------------------------------
 // GetAttributeValueAsUnsigned
 //
 // Get the value of an attribute as unsigned and return it.
 //----------------------------------------------------------------------
 uint64_t
 DWARFDebugInfoEntry::GetAttributeValueAsUnsigned
 (
     SymbolFileDWARF* dwarf2Data,
     const DWARFCompileUnit* cu,
     const dw_attr_t attr,
-    uint64_t fail_value
+    uint64_t fail_value,
+    bool check_specification_or_abstract_origin
 ) const
 {
     DWARFFormValue form_value;
-    if (GetAttributeValue(dwarf2Data, cu, attr, form_value))
+    if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr, check_specification_or_abstract_origin))
         return form_value.Unsigned();
     return fail_value;
 }
 
 //----------------------------------------------------------------------
 // GetAttributeValueAsSigned
 //
 // Get the value of an attribute a signed value and return it.
 //----------------------------------------------------------------------
 int64_t
 DWARFDebugInfoEntry::GetAttributeValueAsSigned
 (
     SymbolFileDWARF* dwarf2Data,
     const DWARFCompileUnit* cu,
     const dw_attr_t attr,
-    int64_t fail_value
+    int64_t fail_value,
+    bool check_specification_or_abstract_origin
 ) const
 {
     DWARFFormValue form_value;
-    if (GetAttributeValue(dwarf2Data, cu, attr, form_value))
+    if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr, check_specification_or_abstract_origin))
         return form_value.Signed();
     return fail_value;
 }
 
 //----------------------------------------------------------------------
 // GetAttributeValueAsReference
 //
 // Get the value of an attribute as reference and fix up and compile
 // unit relative offsets as needed.
 //----------------------------------------------------------------------
 uint64_t
 DWARFDebugInfoEntry::GetAttributeValueAsReference
 (
     SymbolFileDWARF* dwarf2Data,
     const DWARFCompileUnit* cu,
     const dw_attr_t attr,
-    uint64_t fail_value
+    uint64_t fail_value,
+    bool check_specification_or_abstract_origin
 ) const
 {
     DWARFFormValue form_value;
-    if (GetAttributeValue(dwarf2Data, cu, attr, form_value))
+    if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr, check_specification_or_abstract_origin))
         return form_value.Reference();
     return fail_value;
 }
 
+uint64_t
+DWARFDebugInfoEntry::GetAttributeValueAsAddress
+(
+    SymbolFileDWARF* dwarf2Data,
+    const DWARFCompileUnit* cu,
+    const dw_attr_t attr,
+    uint64_t fail_value,
+    bool check_specification_or_abstract_origin
+) const
+{
+    DWARFFormValue form_value;
+    if (GetAttributeValue(dwarf2Data, cu, attr, form_value, nullptr, check_specification_or_abstract_origin))
+        return form_value.Address();
+    return fail_value;
+}
+
 //----------------------------------------------------------------------
 // GetAttributeHighPC
 //
 // Get the hi_pc, adding hi_pc to lo_pc when specified
 // as an <offset-from-low-pc>.
 //
 // Returns the hi_pc or fail_value.
 //----------------------------------------------------------------------
 dw_addr_t
 DWARFDebugInfoEntry::GetAttributeHighPC
 (
     SymbolFileDWARF* dwarf2Data,
     const DWARFCompileUnit* cu,
     dw_addr_t lo_pc,
-    uint64_t fail_value
+    uint64_t fail_value,
+    bool check_specification_or_abstract_origin
 ) const
 {
     DWARFFormValue form_value;
-    if (GetAttributeValue(dwarf2Data, cu, DW_AT_high_pc, form_value))
+    if (GetAttributeValue(dwarf2Data, cu, DW_AT_high_pc, form_value, nullptr, check_specification_or_abstract_origin))
     {
         dw_form_t form = form_value.Form();
         if (form == DW_FORM_addr || form == DW_FORM_GNU_addr_index)
             return form_value.Address();
         
         // DWARF4 can specify the hi_pc as an <offset-from-lowpc>
         return lo_pc + form_value.Unsigned();
     }

 //----------------------------------------------------------------------
 bool
 DWARFDebugInfoEntry::GetAttributeAddressRange
 (
     SymbolFileDWARF* dwarf2Data,
     const DWARFCompileUnit* cu,
     dw_addr_t& lo_pc,
     dw_addr_t& hi_pc,
-    uint64_t fail_value
+    uint64_t fail_value,
+    bool check_specification_or_abstract_origin
 ) const
 {
-    lo_pc = GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_low_pc, fail_value);
+    lo_pc = GetAttributeValueAsAddress(dwarf2Data, cu, DW_AT_low_pc, fail_value, check_specification_or_abstract_origin);
     if (lo_pc != fail_value)
     {
-        hi_pc = GetAttributeHighPC(dwarf2Data, cu, lo_pc, fail_value);
+        hi_pc = GetAttributeHighPC(dwarf2Data, cu, lo_pc, fail_value, check_specification_or_abstract_origin);
         if (hi_pc != fail_value)
           return true;
     }
     lo_pc = fail_value;
     hi_pc = fail_value;
     return false;
 }
 
 size_t
 DWARFDebugInfoEntry::GetAttributeAddressRanges (SymbolFileDWARF* dwarf2Data,
                                                 const DWARFCompileUnit* cu,
                                                 DWARFRangeList &ranges,
-                                                bool check_hi_lo_pc) const
+                                                bool check_hi_lo_pc,
+                                                bool check_specification_or_abstract_origin) const
 {
     ranges.Clear();
     
-    dw_offset_t debug_ranges_offset = GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_ranges, DW_INVALID_OFFSET);
+    dw_offset_t debug_ranges_offset = GetAttributeValueAsUnsigned(dwarf2Data,
+                                                                  cu,
+                                                                  DW_AT_ranges,
+                                                                  DW_INVALID_OFFSET,
+                                                                  check_specification_or_abstract_origin);
     if (debug_ranges_offset != DW_INVALID_OFFSET)
     {
         DWARFDebugRanges* debug_ranges = dwarf2Data->DebugRanges();
         
         debug_ranges->FindRanges(debug_ranges_offset, ranges);
         ranges.Slide (cu->GetBaseAddress());
     }
     else if (check_hi_lo_pc)
     {
         dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
         dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
-        if (GetAttributeAddressRange (dwarf2Data, cu, lo_pc, hi_pc, LLDB_INVALID_ADDRESS))
+        if (GetAttributeAddressRange (dwarf2Data, cu, lo_pc, hi_pc, LLDB_INVALID_ADDRESS, check_specification_or_abstract_origin))
         {
             if (lo_pc < hi_pc)
                 ranges.Append(DWARFRangeList::Entry(lo_pc, hi_pc - lo_pc));
         }
     }
     return ranges.GetSize();
 }
 
 //----------------------------------------------------------------------
-// GetAttributeValueAsLocation
-//
-// Get the value of an attribute as reference and fix up and compile
-// unit relative offsets as needed.
-//----------------------------------------------------------------------
-dw_offset_t
-DWARFDebugInfoEntry::GetAttributeValueAsLocation
-(
-    SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
-    const dw_attr_t attr,
-    DWARFDataExtractor& location_data,
-    uint32_t &block_size
-) const
-{
-    block_size = 0;
-    DWARFFormValue form_value;
-
-    // Empty out data in case we don't find anything
-    location_data.Clear();
-    dw_offset_t end_addr_offset = DW_INVALID_OFFSET;
-    const dw_offset_t attr_offset = GetAttributeValue(dwarf2Data, cu, attr, form_value, &end_addr_offset);
-    if (attr_offset)
-    {
-        const uint8_t* blockData = form_value.BlockData();
-        if (blockData)
-        {
-            // We have an inlined location list in the .debug_info section
-            const DWARFDataExtractor& debug_info = dwarf2Data->get_debug_info_data();
-            dw_offset_t block_offset = blockData - debug_info.GetDataStart();
-            block_size = (end_addr_offset - attr_offset) - form_value.Unsigned();
-            location_data.SetData(debug_info, block_offset, block_size);
-        }
-        else
-        {
-            // We have a location list offset as the value that is
-            // the offset into the .debug_loc section that describes
-            // the value over it's lifetime
-            lldb::offset_t debug_loc_offset = form_value.Unsigned();
-            if (dwarf2Data)
-            {
-                assert(dwarf2Data->get_debug_loc_data().GetAddressByteSize() == cu->GetAddressByteSize());
-                return DWARFLocationList::Extract(dwarf2Data->get_debug_loc_data(), &debug_loc_offset, location_data);
-            }
-        }
-    }
-    return attr_offset;
-}
-
-//----------------------------------------------------------------------
 // GetName
 //
 // Get value of the DW_AT_name attribute and return it if one exists,
 // else return NULL.
 //----------------------------------------------------------------------
 const char*
 DWARFDebugInfoEntry::GetName
 (
     SymbolFileDWARF* dwarf2Data,
     const DWARFCompileUnit* cu
 ) const
 {
-    DWARFFormValue form_value;
-    if (GetAttributeValue(dwarf2Data, cu, DW_AT_name, form_value))
-        return form_value.AsCString();
-    else if (GetAttributeValue(dwarf2Data, cu, DW_AT_specification, form_value))
-    {
-        DWARFDIE die = const_cast<DWARFCompileUnit*>(cu)->GetDIE(form_value.Reference());
-        if (die)
-            return die.GetName();
-    }
-    else if (GetAttributeValue(dwarf2Data, cu, DW_AT_abstract_origin, form_value))
-    {
-        DWARFDIE die = const_cast<DWARFCompileUnit*>(cu)->GetDIE(form_value.Reference());
-        if (die)
-            return die.GetName();
-    }
-    return nullptr;
+    return GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr, true);
 }
 
-
 //----------------------------------------------------------------------
 // GetMangledName
 //
 // Get value of the DW_AT_MIPS_linkage_name attribute and return it if
 // one exists, else return the value of the DW_AT_name attribute
 //----------------------------------------------------------------------
 const char*
 DWARFDebugInfoEntry::GetMangledName
 (
     SymbolFileDWARF* dwarf2Data,
     const DWARFCompileUnit* cu,
     bool substitute_name_allowed
 ) const
 {
     const char* name = nullptr;
-    DWARFFormValue form_value;
 
-    if (GetAttributeValue(dwarf2Data, cu, DW_AT_MIPS_linkage_name, form_value))
-        name = form_value.AsCString();
+    name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_MIPS_linkage_name, nullptr, true);
+    if (name)
+        return name;
 
-    if (GetAttributeValue(dwarf2Data, cu, DW_AT_linkage_name, form_value))
-        name = form_value.AsCString();
+    name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_linkage_name, nullptr, true);
+    if (name)
+        return name;
 
-    if (substitute_name_allowed && name == nullptr)
-    {
-        if (GetAttributeValue(dwarf2Data, cu, DW_AT_name, form_value))
-            name = form_value.AsCString();
-    }
+    if (!substitute_name_allowed)
+        return nullptr;
+
+    name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr, true);
     return name;
 }
 
 
 //----------------------------------------------------------------------
 // GetPubname
 //
 // Get value the name for a DIE as it should appear for a
 // .debug_pubnames or .debug_pubtypes section.
 //----------------------------------------------------------------------
 const char*
 DWARFDebugInfoEntry::GetPubname
 (
     SymbolFileDWARF* dwarf2Data,
     const DWARFCompileUnit* cu
 ) const
 {
-    const char* name = NULL;
+    const char* name = nullptr;
     if (!dwarf2Data)
         return name;
-    
-    DWARFFormValue form_value;
+    name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_MIPS_linkage_name, nullptr, true);
+    if (name)
+        return name;
 
-    if (GetAttributeValue(dwarf2Data, cu, DW_AT_MIPS_linkage_name, form_value))
-        name = form_value.AsCString();
-    else if (GetAttributeValue(dwarf2Data, cu, DW_AT_linkage_name, form_value))
-        name = form_value.AsCString();
-    else if (GetAttributeValue(dwarf2Data, cu, DW_AT_name, form_value))
-        name = form_value.AsCString();
-    else if (GetAttributeValue(dwarf2Data, cu, DW_AT_specification, form_value))
-    {
-        DWARFDIE die = const_cast<DWARFCompileUnit*>(cu)->GetDIE(form_value.Reference());
-        if (die)
-            name = die.GetPubname();
-    }
+    name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_linkage_name, nullptr, true);
+    if (name)
+        return name;
+
+    name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr, true);
     return name;
 }
 
 
 //----------------------------------------------------------------------
 // GetName
 //
 // Get value of the DW_AT_name attribute for a debug information entry
)
     {
         if (die.IsNULL())
         {
             s.PutCString("NULL");
             return true;
         }
         else
         {
-            DWARFFormValue form_value;
-            if (die.GetAttributeValue(dwarf2Data, cu, DW_AT_name, form_value))
-            {
-                const char* name = form_value.AsCString();
-                if (name)
-                {
-                    s.PutCString(name);
-                    return true;
-                }
-            }
-        }
-    }
+            const char* name = die.GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr, true);
     return false;
 }
 
 //----------------------------------------------------------------------
 // AppendTypeName
 //
 // Follows the type name definition down through all needed tags to
 // end up with a fully qualified type name and dump the results to
if (die.Extract(dwarf2Data, cu, &offset))
         if (die.IsNULL())
         {
             s.PutCString("NULL");
             return true;
         }
         else
         {
             const char* name = die.GetPubname(dwarf2Data, cu);
-        //  if (die.GetAttributeValue(dwarf2Data, cu, DW_AT_name, form_value))
-        //      name = form_value.AsCString(&dwarf2Data->get_debug_str_data());
             if (name)
                 s.PutCString(name);
             else
             {
                 bool result = true;
                 const DWARFAbbreviationDeclaration* abbrevDecl = die.GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
                 
                 if (abbrevDecl == NULL)
//  printf("0x%8.8x: %30s: address = 0x%8.8x - ", m_offset, DW_TAG_value_to_name(tag), address);
         case DW_TAG_partial_unit               : break;
         case DW_TAG_imported_unit              : break;
         case DW_TAG_shared_type                : break;
         default: break;
         }
 
         if (match_addr_range)
         {
-            dw_addr_t lo_pc = GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_low_pc, LLDB_INVALID_ADDRESS);
+            dw_addr_t lo_pc = GetAttributeValueAsAddress(dwarf2Data, cu, DW_AT_low_pc, LLDB_INVALID_ADDRESS);
             if (lo_pc != LLDB_INVALID_ADDRESS)
             {
                 dw_addr_t hi_pc = GetAttributeHighPC(dwarf2Data, cu, lo_pc, LLDB_INVALID_ADDRESS);
                 if (hi_pc != LLDB_INVALID_ADDRESS)
                 {
                     //  printf("\n0x%8.8x: %30s: address = 0x%8.8x  [0x%8.8x - 0x%8.8x) ", m_offset, DW_TAG_value_to_name(tag), address, lo_pc, hi_pc);
                     if ((lo_pc <= address) && (address < hi_pc))
                     {

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

public:
     uint64_t            Reference (dw_offset_t offset) const;
     bool                Boolean() const { return m_value.value.uval != 0; }
     uint64_t            Unsigned() const { return m_value.value.uval; }
     void                SetUnsigned(uint64_t uval) { m_value.value.uval = uval; }
     int64_t             Signed() const { return m_value.value.sval; }
     void                SetSigned(int64_t sval) { m_value.value.sval = sval; }
     const char*         AsCString() const;
     dw_addr_t           Address() const;
+    bool                IsValid() const { return m_form != 0; }
     bool                SkipValue(const lldb_private::DWARFDataExtractor& debug_info_data, lldb::offset_t *offset_ptr) const;
     static bool         SkipValue(const dw_form_t form, const lldb_private::DWARFDataExtractor& debug_info_data, lldb::offset_t *offset_ptr, const DWARFCompileUnit* cu);
     static bool         IsBlockForm(const dw_form_t form);
     static bool         IsDataForm(const dw_form_t form);
     static FixedFormSizes GetFixedFormSizesForAddressSize (uint8_t addr_size, bool is_dwarf64);
     static int          Compare (const DWARFFormValue& a, 
                                  const DWARFFormValue& b);
 protected:
     const DWARFCompileUnit* m_cu; // Compile unit for this form
     dw_form_t   m_form;     // Form for this value
     ValueType   m_value;    // Contains all data for the form
 };
 
 
 #endif  // SymbolFileDWARF_DWARFFormValue_h_

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

public:
     {
         // Always set for C++, only set for ObjC if this is the 
         // @implementation for class
         eTypeFlagClassIsImplementation  = ( 1u << 1 )
     };
 
     struct DIEInfo
     {
+        dw_offset_t cu_offset;
         dw_offset_t offset;  // The DIE offset
         dw_tag_t tag;
         uint32_t type_flags; // Any flags for this DIEInfo
         uint32_t qualified_name_hash; // A 32 bit hash of the fully qualified name
 
         DIEInfo ();
-        DIEInfo (dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h);
+        DIEInfo (dw_offset_t c, dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h);
     };
 
     struct Atom
     {
         AtomType type;
         dw_form_t form;
     };
 
protected:
                                             Pair &pair) const;
 
         size_t 
         FindByName (const char *name, DIEInfoArray &die_info_array);
 
         Result
         GetHashDataForName (const char *name,
                             lldb::offset_t* hash_data_offset_ptr,
-                            Pair &pair) const;
+                            Pair &pair) const override;
 
         const lldb_private::DWARFDataExtractor &m_data;
         const lldb_private::DWARFDataExtractor &m_string_table;
         std::string m_name;
     };
 
     static void
     ExtractDIEArray (const DIEInfoArray &die_info_array, DIEArray &die_offsets);
 
 protected:
     static void
     ExtractDIEArray (const DIEInfoArray &die_info_array,
                      const dw_tag_t tag,
                      DIEArray &die_offsets);
 
     static void
     ExtractDIEArray (const DIEInfoArray &die_info_array,
                      const dw_tag_t tag,
                      const uint32_t qualified_name_hash,
                      DIEArray &die_offsets);
 
-    
-
     static void
     ExtractClassOrStructDIEArray (const DIEInfoArray &die_info_array,
                                   bool return_implementation_only_if_available,
                                   DIEArray &die_offsets);
 
     static void
     ExtractTypesFromDIEArray (const DIEInfoArray &die_info_array,
                               uint32_t type_flag_mask,
                               uint32_t type_flag_value,
                               DIEArray &die_offsets);
 
     static const char *
     GetAtomTypeName (uint16_t atom);
 };
 
-
 #endif  // SymbolFileDWARF_HashedNameToDIE_h_

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

 //===-- HashedNameToDIE.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "HashedNameToDIE.h"
 
 void
 DWARFMappedHash::ExtractDIEArray (const DIEInfoArray &die_info_array, DIEArray &die_offsets)
 {
     const size_t count = die_info_array.size();
     for (size_t i=0; i<count; ++i)
-        die_offsets.push_back (die_info_array[i].offset);
+        die_offsets.emplace_back(die_info_array[i].cu_offset, die_info_array[i].offset);
 }
 
 void
 DWARFMappedHash::ExtractDIEArray (const DIEInfoArray &die_info_array,
                                   const dw_tag_t tag,
                                   DIEArray &die_offsets)
 {
     if (tag == 0)
     {
         ExtractDIEArray (die_info_array, die_offsets);
     }
     else
     {
         const size_t count = die_info_array.size();
         for (size_t i=0; i<count; ++i)
         {
             const dw_tag_t die_tag = die_info_array[i].tag;
             bool tag_matches = die_tag == 0 || tag == die_tag;
             if (!tag_matches)
             {
                 if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
                     tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
             }
             if (tag_matches)
-                die_offsets.push_back (die_info_array[i].offset);
+                die_offsets.emplace_back(die_info_array[i].cu_offset, die_info_array[i].offset);
         }
     }
 }
 
 void
 DWARFMappedHash::ExtractDIEArray (const DIEInfoArray &die_info_array,
                                   const dw_tag_t tag,
                                   const uint32_t qualified_name_hash,
else
             const dw_tag_t die_tag = die_info_array[i].tag;
             bool tag_matches = die_tag == 0 || tag == die_tag;
             if (!tag_matches)
             {
                 if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
                     tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
             }
             if (tag_matches)
-                die_offsets.push_back (die_info_array[i].offset);
+                die_offsets.emplace_back(die_info_array[i].cu_offset, die_info_array[i].offset);
         }
     }
 }
 
 void
 DWARFMappedHash::ExtractClassOrStructDIEArray (const DIEInfoArray &die_info_array,
                                                bool return_implementation_only_if_available,
                                                DIEArray &die_offsets)
 {
     const size_t count = die_info_array.size();
     for (size_t i=0; i<count; ++i)
     {
         const dw_tag_t die_tag = die_info_array[i].tag;
         if (die_tag == 0 || die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
         {
             if (die_info_array[i].type_flags & eTypeFlagClassIsImplementation)
             {
                 if (return_implementation_only_if_available)
                 {
                     // We found the one true definition for this class, so
                     // only return that
                     die_offsets.clear();                        
-                    die_offsets.push_back (die_info_array[i].offset);
+                    die_offsets.emplace_back(die_info_array[i].cu_offset, die_info_array[i].offset);
                     return;
                 }
                 else
                 {
                     // Put the one true definition as the first entry so it
                     // matches first
-                    die_offsets.insert (die_offsets.begin(), die_info_array[i].offset);
+                    die_offsets.emplace(die_offsets.begin(), die_info_array[i].cu_offset, die_info_array[i].offset);
                 }
             }
             else
             {
-                die_offsets.push_back (die_info_array[i].offset);
+                die_offsets.emplace_back(die_info_array[i].cu_offset, die_info_array[i].offset);
             }
         }
     }
 }
 
 void
 DWARFMappedHash::ExtractTypesFromDIEArray (const DIEInfoArray &die_info_array,
                                            uint32_t type_flag_mask,
                                            uint32_t type_flag_value,
                                            DIEArray &die_offsets)
 {
     const size_t count = die_info_array.size();
     for (size_t i=0; i<count; ++i)
     {
         if ((die_info_array[i].type_flags & type_flag_mask) == type_flag_value)
-            die_offsets.push_back (die_info_array[i].offset);
+            die_offsets.emplace_back(die_info_array[i].cu_offset, die_info_array[i].offset);
     }
 }
 
 const char *
 DWARFMappedHash::GetAtomTypeName (uint16_t atom)
 {
     switch (atom)
     {
         case eAtomTypeNULL:         return "NULL";
         case eAtomTypeDIEOffset:    return "die-offset";
         case eAtomTypeCUOffset:     return "cu-offset";
         case eAtomTypeTag:          return "die-tag";
         case eAtomTypeNameFlags:    return "name-flags";
         case eAtomTypeTypeFlags:    return "type-flags";
         case eAtomTypeQualNameHash: return "qualified-name-hash";
     }
     return "<invalid>";
 }
 
 DWARFMappedHash::DIEInfo::DIEInfo () :
+    cu_offset (DW_INVALID_OFFSET),
     offset (DW_INVALID_OFFSET),
     tag (0),
     type_flags (0),
     qualified_name_hash (0)
 {
 }
 
-DWARFMappedHash::DIEInfo::DIEInfo (dw_offset_t o, dw_tag_t t, uint32_t f, uint32_t h) :
+DWARFMappedHash::DIEInfo::DIEInfo (dw_offset_t c,
+                                   dw_offset_t o,
+                                   dw_tag_t t,
+                                   uint32_t f,
+                                   uint32_t h) :
+    cu_offset (c),
     offset (o),
     tag (t),
     type_flags (f),
     qualified_name_hash (h)
 {
 }
 
 DWARFMappedHash::Prologue::Prologue (dw_offset_t _die_base_offset) :

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

 //===-- NameToDIE.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_NameToDIE_h_
 #define SymbolFileDWARF_NameToDIE_h_
 
-#include "lldb/Core/UniqueCStringMap.h"
-
 #include <functional>
 
+#include "lldb/Core/dwarf.h"
+#include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/lldb-defines.h"
+#include "DIERef.h"
 
 class SymbolFileDWARF;
 
-typedef std::vector<uint32_t> DIEArray;
-
 class NameToDIE
 {
 public:
-    NameToDIE () :   
+    NameToDIE () :
         m_map()
     {
     }
-    
     ~NameToDIE ()
     {
     }
-    
     void
     Dump (lldb_private::Stream *s);
 
     void
-    Insert (const lldb_private::ConstString& name, uint32_t die_offset);
+    Insert (const lldb_private::ConstString& name, const DIERef& die_ref);
 
     void
     Finalize();
 
     size_t
-    Find (const lldb_private::ConstString &name, 
-          DIEArray &info_array) const;
+    Find (const lldb_private::ConstString &name, DIEArray &info_array) const;
     
     size_t
-    Find (const lldb_private::RegularExpression& regex, 
-          DIEArray &info_array) const;
+    Find (const lldb_private::RegularExpression& regex, DIEArray &info_array) const;
 
     size_t
-    FindAllEntriesForCompileUnit (uint32_t cu_offset, 
-                                  uint32_t cu_end_offset, 
-                                  DIEArray &info_array) const;
+    FindAllEntriesForCompileUnit (dw_offset_t cu_offset, DIEArray &info_array) const;
 
     void
-    ForEach (std::function <bool(const char *name, uint32_t die_offset)> const &callback) const;
+    ForEach (std::function <bool(const char *name, const DIERef& die_ref)> const &callback) const;
 
 protected:
-    lldb_private::UniqueCStringMap<uint32_t> m_map;
-
+    lldb_private::UniqueCStringMap<DIERef> m_map;
 };
 
 #endif  // SymbolFileDWARF_NameToDIE_h_

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

 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Symbol/ObjectFile.h"
 
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugInfoEntry.h"
 #include "SymbolFileDWARF.h"
+
 using namespace lldb;
 using namespace lldb_private;
 
 void
 NameToDIE::Finalize()
 {
     m_map.Sort ();
     m_map.SizeToFit ();
 }
 
 void
-NameToDIE::Insert (const ConstString& name, uint32_t die_offset)
+NameToDIE::Insert (const ConstString& name, const DIERef& die_ref)
 {
-    m_map.Append(name.GetCString(), die_offset);
+    m_map.Append(name.GetCString(), die_ref);
 }
 
 size_t
 NameToDIE::Find (const ConstString &name, DIEArray &info_array) const
 {
     return m_map.GetValues (name.GetCString(), info_array);
 }
 
 size_t
 NameToDIE::Find (const RegularExpression& regex, DIEArray &info_array) const
 {
     return m_map.GetValues (regex, info_array);
 }
 
 size_t
-NameToDIE::FindAllEntriesForCompileUnit (uint32_t cu_offset, 
-                                         uint32_t cu_end_offset, 
-                                         DIEArray &info_array) const
+NameToDIE::FindAllEntriesForCompileUnit (dw_offset_t cu_offset, DIEArray &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 uint32_t die_offset = m_map.GetValueAtIndexUnchecked(i);
-        if (cu_offset < die_offset && die_offset < cu_end_offset)
-            info_array.push_back (die_offset);
+        const DIERef& die_ref = m_map.GetValueAtIndexUnchecked(i);
+        if (cu_offset == die_ref.cu_offset)
+            info_array.push_back (die_ref);
     }
     return info_array.size() - initial_size;
 }
 
 void
 NameToDIE::Dump (Stream *s)
 {
     const uint32_t size = m_map.GetSize();
     for (uint32_t i=0; i<size; ++i)
     {
         const char *cstr = m_map.GetCStringAtIndex(i);
-        s->Printf("%p: {0x%8.8x} \"%s\"\n", (const void *)cstr, m_map.GetValueAtIndexUnchecked(i), cstr);
+        const DIERef& die_ref = m_map.GetValueAtIndexUnchecked(i);
+        s->Printf("%p: {0x%8.8x/0x%8.8x} \"%s\"\n", cstr, die_ref.cu_offset, die_ref.die_offset, cstr);
     }
 }
 
 void
-NameToDIE::ForEach (std::function <bool(const char *name, uint32_t die_offset)> const &callback) const
+NameToDIE::ForEach (std::function <bool(const char *name, const DIERef& die_ref)> 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)))
+        if (!callback(m_map.GetCStringAtIndexUnchecked(i), m_map.GetValueAtIndexUnchecked (i)))
             break;
     }
 }

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

 class SymbolFileDWARFDebugMap;
 
 #define DIE_IS_BEING_PARSED ((lldb_private::Type*)1)
 
 class SymbolFileDWARF : public lldb_private::SymbolFile, public lldb_private::UserID
 {
 public:
     friend class SymbolFileDWARFDebugMap;
+    friend class SymbolFileDWARFDwo;
     friend class DebugMapModule;
     friend class DWARFCompileUnit;
     friend class DWARFASTParserClang;
 
     //------------------------------------------------------------------
     // Static Functions
     //------------------------------------------------------------------
     static void
public:
     const DWARFDebugInfo*
     DebugInfo() const;
 
     DWARFDebugRanges*
     DebugRanges();
     const DWARFDebugRanges*
     DebugRanges() const;
 
-    const lldb_private::DWARFDataExtractor&
+    virtual const lldb_private::DWARFDataExtractor&
     GetCachedSectionData (uint32_t got_flag, 
                           lldb::SectionType sect_type, 
                           lldb_private::DWARFDataExtractor &data);
 
     static bool
     SupportedVersion(uint16_t version);
 
     DWARFDIE
GetObjCMethodDIEOffsets (lldb_private::ConstString class_name,
                              DIEArray &method_die_offsets);
 
     bool
     Supports_DW_AT_APPLE_objc_complete_type (DWARFCompileUnit *cu);
 
     static DWARFDIE
     GetParentSymbolContextDIE(const DWARFDIE &die);
 
+    virtual lldb::CompUnitSP
+    ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx);
+
 protected:
+    typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *> DIEToTypePtr;
+    typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP> DIEToVariableSP;
+    typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::clang_type_t> DIEToClangType;
+    typedef llvm::DenseMap<lldb::clang_type_t, DIERef> ClangTypeToDIE;
 
     enum
     {
         flagsGotDebugAbbrevData     = (1 << 0),
         flagsGotDebugAddrData       = (1 << 1),
         flagsGotDebugArangesData    = (1 << 2),
         flagsGotDebugFrameData      = (1 << 3),
         flagsGotDebugInfoData       = (1 << 4),
protected:
     DeclContextMatchesThisSymbolFile (const lldb_private::CompilerDeclContext *decl_ctx);
 
     bool
     DIEInDeclContext (const lldb_private::CompilerDeclContext *parent_decl_ctx,
                       const DWARFDIE &die);
 
     DISALLOW_COPY_AND_ASSIGN (SymbolFileDWARF);
 
-    lldb::CompUnitSP
-    ParseCompileUnit (DWARFCompileUnit* dwarf_cu,
-                      uint32_t cu_idx);
-
-    DWARFCompileUnit*
+    virtual DWARFCompileUnit*
     GetDWARFCompileUnit (lldb_private::CompileUnit *comp_unit);
 
     DWARFCompileUnit*
     GetNextUnparsedDWARFCompileUnit (DWARFCompileUnit* prev_cu);
 
     bool
     GetFunction (const DWARFDIE &die,
                  lldb_private::SymbolContext& sc);
ParseVariables (const lldb_private::SymbolContext& sc,
                     bool parse_children,
                     lldb_private::VariableList* cc_variable_list = NULL);
 
     bool
     ClassOrStructIsVirtual (const DWARFDIE &die);
 
     // Given a die_offset, figure out the symbol context representing that die.
     bool
-    ResolveFunction (dw_offset_t offset,
+    ResolveFunction (const DIERef& die_ref,
                      bool include_inlines,
                      lldb_private::SymbolContextList& sc_list);
 
     bool
     ResolveFunction (const DWARFDIE &die,
                      bool include_inlines,
                      lldb_private::SymbolContextList& sc_list);
 
protected:
     void
     ParseFunctions (const DIEArray &die_offsets,
                     bool include_inlines,
                     lldb_private::SymbolContextList& sc_list);
 
     lldb::TypeSP
     GetTypeForDIE (const DWARFDIE &die);
 
-    uint32_t
-    FindTypes (std::vector<dw_offset_t> die_offsets,
-               uint32_t max_matches,
-               lldb_private::TypeList& types);
-
     void
     Index();
     
     void
     DumpIndexes();
 
     void
     SetDebugMapModule (const lldb::ModuleSP &module_sp)
     {
         m_debug_map_module_wp = module_sp;
     }
 
     SymbolFileDWARFDebugMap *
     GetDebugMapSymfile ();
 
     DWARFDIE
-    FindBlockContainingSpecification (dw_offset_t func_die_offset,
-                                      dw_offset_t spec_block_die_offset);
+    FindBlockContainingSpecification (const DIERef& func_die_ref, dw_offset_t spec_block_die_offset);
 
     DWARFDIE
-    FindBlockContainingSpecification (const DWARFDIE &die,
-                                      dw_offset_t spec_block_die_offset);
+    FindBlockContainingSpecification (const DWARFDIE &die, dw_offset_t spec_block_die_offset);
     
     UniqueDWARFASTTypeMap &
     GetUniqueDWARFASTTypeMap ();
     
     bool
     UserIDMatches (lldb::user_id_t uid) const
     {
         const lldb::user_id_t high_uid = uid & 0xffffffff00000000ull;
-        if (high_uid)
+        if (high_uid != 0 && GetID() != 0)
             return high_uid == GetID();
         return true;
     }
     
     bool
     DIEDeclContextsMatch (const DWARFDIE &die1,
                           const DWARFDIE &die2);
     
protected:
     typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, lldb_private::Variable *> GlobalVariableMap;
 
     GlobalVariableMap &
     GetGlobalAranges();
     
     void
     UpdateExternalModuleListIfNeeded();
 
+    virtual DIEToTypePtr&
+    GetDIEToType() { return m_die_to_type; }
+
+    virtual DIEToVariableSP&
+    GetDIEToVariable() { return m_die_to_variable_sp; }
+    
+    virtual DIEToClangType&
+    GetForwardDeclDieToClangType() { return m_forward_decl_die_to_clang_type; }
+
+    virtual ClangTypeToDIE&
+    GetForwardDeclClangTypeToDie() { return m_forward_decl_clang_type_to_die; }
+
     lldb::ModuleWP                        m_debug_map_module_wp;
     SymbolFileDWARFDebugMap *             m_debug_map_symfile;
     lldb_private::Flags                   m_flags;
     lldb_private::DWARFDataExtractor      m_dwarf_data;
     lldb_private::DWARFDataExtractor      m_data_debug_abbrev;
     lldb_private::DWARFDataExtractor      m_data_debug_addr;
     lldb_private::DWARFDataExtractor      m_data_debug_aranges;
     lldb_private::DWARFDataExtractor      m_data_debug_frame;
protected:
     NameToDIE                           m_namespace_index;          // All type DIE offsets
     bool                                m_indexed:1,
                                         m_using_apple_tables:1,
                                         m_fetched_external_modules:1;
     lldb_private::LazyBool              m_supports_DW_AT_APPLE_objc_complete_type;
 
     std::unique_ptr<DWARFDebugRanges>     m_ranges;
     UniqueDWARFASTTypeMap m_unique_ast_type_map;
-    typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *> DIEToTypePtr;
-    typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP> DIEToVariableSP;
-    typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::clang_type_t> DIEToClangType;
-    typedef llvm::DenseMap<lldb::clang_type_t, const DWARFDebugInfoEntry *> ClangTypeToDIE;
     DIEToTypePtr m_die_to_type;
     DIEToVariableSP m_die_to_variable_sp;
     DIEToClangType m_forward_decl_die_to_clang_type;
     ClangTypeToDIE m_forward_decl_clang_type_to_die;
 };
 
 #endif  // SymbolFileDWARF_SymbolFileDWARF_h_

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

 #include "DWARFDebugLine.h"
 #include "DWARFDebugPubnames.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFDIECollection.h"
 #include "DWARFFormValue.h"
 #include "DWARFLocationList.h"
 #include "LogChannelDWARF.h"
+#include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDebugMap.h"
 
 #include <map>
 
 #include <ctype.h>
 #include <string.h>
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
if (dwarf_cu)
         CompileUnit *comp_unit = (CompileUnit*)dwarf_cu->GetUserData();
         if (comp_unit)
         {
             // We already parsed this compile unit, had out a shared pointer to it
             cu_sp = comp_unit->shared_from_this();
         }
         else
         {
-            if (GetDebugMapSymfile ())
+            if (dwarf_cu->GetSymbolFileDWARF() != this)
+            {
+                return dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(dwarf_cu, cu_idx);
+            }
+            else if (GetDebugMapSymfile ())
             {
                 // Let the debug map create the compile unit
                 cu_sp = m_debug_map_symfile->GetCompileUnit(this);
                 dwarf_cu->SetUserData(cu_sp.get());
             }
             else
             {
                 ModuleSP module_sp (m_obj_file->GetModule());

 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextForUID (lldb::user_id_t type_uid)
 {
     if (UserIDMatches(type_uid))
     {
         DWARFDebugInfo* debug_info = DebugInfo();
         if (debug_info)
         {
-            DWARFDIE die = debug_info->GetDIE(type_uid);
+            DWARFDIE die = debug_info->GetDIE(DIERef(type_uid));
             if (die)
             {
                 DWARFASTParser *dwarf_ast = die.GetDWARFParser();
                 if (dwarf_ast)
                     return dwarf_ast->GetDeclContextForUIDFromDWARF(die);
             }
         }
     }
     return CompilerDeclContext();
 }
 
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextContainingUID (lldb::user_id_t type_uid)
 {
     if (UserIDMatches(type_uid))
     {
         DWARFDebugInfo* debug_info = DebugInfo();
         if (debug_info)
         {
-            DWARFDIE die = debug_info->GetDIE(type_uid);
+            DWARFDIE die = debug_info->GetDIE(DIERef(type_uid));
             if (die)
             {
                 DWARFASTParser *dwarf_ast = die.GetDWARFParser();
                 if (dwarf_ast)
                     return dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
             }
         }
     }
     return CompilerDeclContext();
 }
 
 
 Type*
 SymbolFileDWARF::ResolveTypeUID (lldb::user_id_t type_uid)
 {
     if (UserIDMatches(type_uid))
     {
         DWARFDebugInfo* debug_info = DebugInfo();
         if (debug_info)
         {
-            DWARFDIE type_die = debug_info->GetDIE (type_uid);
+            DWARFDIE type_die = debug_info->GetDIE (DIERef(type_uid));
             if (type_die)
             {
                 const bool assert_not_being_parsed = true;
                 return ResolveTypeUID (type_die, assert_not_being_parsed);
             }
         }
     }
     return NULL;

 
 // 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 clang_type.
 bool
 SymbolFileDWARF::HasForwardDeclForClangType (const CompilerType &clang_type)
 {
     CompilerType clang_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(clang_type);
-    return m_forward_decl_clang_type_to_die.lookup (clang_type_no_qualifiers.GetOpaqueQualType()) != nullptr;
+    return GetForwardDeclClangTypeToDie().count (clang_type_no_qualifiers.GetOpaqueQualType());
 }
 
 
 bool
 SymbolFileDWARF::CompleteType (CompilerType &clang_type)
 {
     // We have a struct/union/class/enum that needs to be fully resolved.
     CompilerType clang_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(clang_type);
-    const DWARFDebugInfoEntry* die = m_forward_decl_clang_type_to_die.lookup (clang_type_no_qualifiers.GetOpaqueQualType());
-    if (die == NULL)
+    auto die_it = GetForwardDeclClangTypeToDie().find (clang_type_no_qualifiers.GetOpaqueQualType());
+    if (die_it == GetForwardDeclClangTypeToDie().end())
     {
         // We have already resolved this type...
         return true;
     }
     // 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.
-    m_forward_decl_clang_type_to_die.erase (clang_type_no_qualifiers.GetOpaqueQualType());
+    GetForwardDeclClangTypeToDie().erase (clang_type_no_qualifiers.GetOpaqueQualType());
 
     DWARFDebugInfo* debug_info = DebugInfo();
-    DWARFDIE dwarf_die (debug_info->GetCompileUnitContainingDIE (die->GetOffset()), die);
-    Type *type = m_die_to_type.lookup (die);
+    
+    DWARFDIE dwarf_die = debug_info->GetDIE(die_it->getSecond());
+    Type *type = GetDIEToType().lookup (dwarf_die.GetDIE());
 
     Log *log (LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO|DWARF_LOG_TYPE_COMPLETION));
     if (log)
         GetObjectFile()->GetModule()->LogMessageVerboseBacktrace (log,
                                                                   "0x%8.8" PRIx64 ": %s '%s' resolving forward declaration...",
                                                                   dwarf_die.GetID(),
                                                                   dwarf_die.GetTagAsCString(),
                                                                   type->GetName().AsCString());
     assert (clang_type);
     DWARFASTParser *dwarf_ast = dwarf_die.GetDWARFParser();
     if (dwarf_ast)
         return dwarf_ast->CompleteTypeFromDWARF (dwarf_die, type, clang_type);
     return false;
 }
 
 Type*
 SymbolFileDWARF::ResolveType (const DWARFDIE &die, bool assert_not_being_parsed)
 {
     if (die)
     {
-        Type *type = m_die_to_type.lookup (die.GetDIE());
+        Type *type = GetDIEToType().lookup (die.GetDIE());
 
         if (type == NULL)
             type = GetTypeForDIE (die).get();
 
         if (assert_not_being_parsed)
         { 
             if (type != DIE_IS_BEING_PARSED)
                 return type;

 void
 SymbolFileDWARF::UpdateExternalModuleListIfNeeded()
 {
     if (m_fetched_external_modules)
         return;
     m_fetched_external_modules = true;
     
     DWARFDebugInfo * debug_info = DebugInfo();
-    debug_info->GetNumCompileUnits();
-    
     const uint32_t num_compile_units = GetNumCompileUnits();
     for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
     {
         DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
         
         const DWARFDIE die = dwarf_cu->GetCompileUnitDIEOnly();
         if (die && die.HasChildren() == false)
         {
if (debug_info)
         uint32_t cu_idx = 0;
         const uint32_t num_compile_units = GetNumCompileUnits();
         for (cu_idx = 0; cu_idx < num_compile_units; ++cu_idx)
         {
             DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
 
             bool clear_dies = dwarf_cu->ExtractDIEsIfNeeded (false) > 1;
 
-            dwarf_cu->Index (cu_idx,
-                             m_function_basename_index,
+            dwarf_cu->Index (m_function_basename_index,
                              m_function_fullname_index,
                              m_function_method_index,
                              m_function_selector_index,
                              m_objc_class_selectors_index,
                              m_global_index, 
                              m_type_index,
                              m_namespace_index);
             
if (num_die_matches)
         SymbolContext sc;
         sc.module_sp = m_obj_file->GetModule();
         assert (sc.module_sp);
 
         DWARFDebugInfo* debug_info = DebugInfo();
         bool done = false;
         for (size_t i=0; i<num_die_matches && !done; ++i)
         {
-            const dw_offset_t die_offset = die_offsets[i];
-            DWARFDIE die = debug_info->GetDIE (die_offset);
+            const DIERef& die_ref = die_offsets[i];
+            DWARFDIE die = debug_info->GetDIE (die_ref);
 
             if (die)
             {
                 switch (die.Tag())
                 {
                     default:
                     case DW_TAG_subprogram:
                     case DW_TAG_inlined_subroutine:
if (num_die_matches)
                         break;
                 }
             }
             else
             {
                 if (m_using_apple_tables)
                 {
                     GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')\n",
-                                                                               die_offset, name.GetCString());
+                                                                               die_ref.die_offset, name.GetCString());
                 }
             }
         }
     }
 
     // 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)
SymbolFileDWARF::FindGlobalVariables(const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables)
     if (!append)
         variables.Clear();
 
     // Remember how many variables are in the list before we search in case
     // we are appending the results to a variable list.
     const uint32_t original_size = variables.GetSize();
 
     DIEArray die_offsets;
-    
     if (m_using_apple_tables)
     {
         if (m_apple_names_ap.get())
         {
             DWARFMappedHash::DIEInfoArray hash_data_array;
             if (m_apple_names_ap->AppendAllDIEsThatMatchingRegex (regex, hash_data_array))
                 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets);
         }
SymbolFileDWARF::FindGlobalVariables(const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables)
     assert (sc.module_sp);
     
     const size_t num_matches = die_offsets.size();
     if (num_matches)
     {
         DWARFDebugInfo* debug_info = DebugInfo();
         for (size_t i=0; i<num_matches; ++i)
         {
-            const dw_offset_t die_offset = die_offsets[i];
-            DWARFDIE die = debug_info->GetDIE (die_offset);
+            const DIERef& die_ref = die_offsets[i];
+            DWARFDIE die = debug_info->GetDIE (die_ref);
             
             if (die)
             {
                 sc.comp_unit = GetCompUnitForDWARFCompUnit(die.GetCU(), UINT32_MAX);
 
                 ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
 
                 if (variables.GetSize() - original_size >= max_matches)
                     break;
             }
             else
             {
                 if (m_using_apple_tables)
                 {
                     GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for regex '%s')\n",
-                                                                               die_offset, regex.GetText());
+                                                                               die_ref.die_offset, regex.GetText());
                 }
             }            
         }
     }
 
     // Return the number of variable that were appended to the list
     return variables.GetSize() - original_size;
 }
 
 
 bool
-SymbolFileDWARF::ResolveFunction (dw_offset_t die_offset,
+SymbolFileDWARF::ResolveFunction (const DIERef& die_ref,
                                   bool include_inlines,
                                   SymbolContextList& sc_list)
 {
-    DWARFDIE die = DebugInfo()->GetDIE (die_offset);
+    DWARFDIE die = DebugInfo()->GetDIE (die_ref);
     return ResolveFunction (die, include_inlines, sc_list);
 }
     
 
 bool
 SymbolFileDWARF::ResolveFunction (const DWARFDIE &orig_die,
                                   bool include_inlines,
                                   SymbolContextList& sc_list)

 SymbolFileDWARF::ParseFunctions (const DIEArray &die_offsets,
                                  bool include_inlines,
                                  SymbolContextList& sc_list)
 {
     const size_t num_matches = die_offsets.size();
     if (num_matches)
     {
         for (size_t i=0; i<num_matches; ++i)
-        {
-            const dw_offset_t die_offset = die_offsets[i];
-            ResolveFunction (die_offset, include_inlines, sc_list);
-        }
+            ResolveFunction (die_offsets[i], include_inlines, sc_list);
     }
 }
 
 bool
 SymbolFileDWARF::DIEInDeclContext (const CompilerDeclContext *decl_ctx,
                                    const DWARFDIE &die)
 {
     // If we have no parent decl context to match this DIE matches, and if the parent
if (m_using_apple_tables)
             if (name_type_mask & eFunctionNameTypeFull)
             {
                 // If they asked for the full name, match what they typed.  At some point we may
                 // want to canonicalize this (strip double spaces, etc.  For now, we just add all the
                 // dies that we find by exact match.
                 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets);
                 for (uint32_t i = 0; i < num_matches; i++)
                 {
-                    const dw_offset_t die_offset = die_offsets[i];
-                    DWARFDIE die = info->GetDIE (die_offset);
+                    const DIERef& die_ref = die_offsets[i];
+                    DWARFDIE die = info->GetDIE (die_ref);
                     if (die)
                     {
                         if (!DIEInDeclContext(parent_decl_ctx, die))
                             continue; // The containing decl contexts don't match
 
                         if (resolved_dies.find(die.GetDIE()) == resolved_dies.end())
                         {
                             if (ResolveFunction (die, include_inlines, sc_list))
                                 resolved_dies.insert(die.GetDIE());
                         }
                     }
                     else
                     {
                         GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')", 
-                                                                                   die_offset, name_cstr);
+                                                                                   die_ref.die_offset, name_cstr);
                     }                                    
                 }
             }
 
             if (name_type_mask & eFunctionNameTypeSelector)
             {
                 if (parent_decl_ctx && parent_decl_ctx->IsValid())
                     return 0; // no selectors in namespaces
                     
                 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets);
                 // Now make sure these are actually ObjC methods.  In this case we can simply look up the name,
                 // and if it is an ObjC method name, we're good.
                 
                 for (uint32_t i = 0; i < num_matches; i++)
                 {
-                    const dw_offset_t die_offset = die_offsets[i];
-                    DWARFDIE die = info->GetDIE (die_offset);
+                    const DIERef& die_ref = die_offsets[i];
+                    DWARFDIE die = info->GetDIE (die_ref);
                     if (die)
                     {
                         const char *die_name = die.GetName();
                         if (ObjCLanguage::IsPossibleObjCMethodName(die_name))
                         {
                             if (resolved_dies.find(die.GetDIE()) == resolved_dies.end())
                             {
                                 if (ResolveFunction (die, include_inlines, sc_list))
                                     resolved_dies.insert(die.GetDIE());
                             }
                         }
                     }
                     else
                     {
                         GetObjectFile()->GetModule()->ReportError ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')",
-                                                                   die_offset, name_cstr);
+                                                                   die_ref.die_offset, name_cstr);
                     }                                    
                 }
                 die_offsets.clear();
             }
             
             if (((name_type_mask & eFunctionNameTypeMethod) && !parent_decl_ctx) || name_type_mask & eFunctionNameTypeBase)
             {
                 // The apple_names table stores just the "base name" of C++ methods in the table.  So we have to
                 // extract the base name, look that up, and if there is any other information in the name we were
                 // passed in we have to post-filter based on that.
                 
                 // FIXME: Arrange the logic above so that we don't calculate the base name twice:
                 num_matches = m_apple_names_ap->FindByName (name_cstr, die_offsets);
                 
                 for (uint32_t i = 0; i < num_matches; i++)
                 {
-                    const dw_offset_t die_offset = die_offsets[i];
-                    DWARFDIE die = info->GetDIE (die_offset);
+                    const DIERef& die_ref = die_offsets[i];
+                    DWARFDIE die = info->GetDIE (die_ref);
                     if (die)
                     {
                         if (!DIEInDeclContext(parent_decl_ctx, die))
                             continue; // The containing decl contexts don't match
 
 
                         // If we get to here, the die is good, and we should add it:
                         if (resolved_dies.find(die.GetDIE()) == resolved_dies.end() && ResolveFunction (die, include_inlines, sc_list))
if (m_using_apple_tables)
                                                     sc_list.RemoveContextAtIndex(sc_list.GetSize()-1);
                                                     keep_die = false;
                                                 }
                                             }
                                         }
                                         else
                                         {
                                             GetObjectFile()->GetModule()->ReportWarning ("function at die offset 0x%8.8x had no function type",
-                                                                                         die_offset);
+                                                                                         die_ref.die_offset);
                                         }
                                     }
                                 }
                             }
                             if (keep_die)
                                 resolved_dies.insert(die.GetDIE());
                         }
                     }
                     else
                     {
                         GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x for '%s')",
-                                                                                   die_offset, name_cstr);
+                                                                                   die_ref.die_offset, name_cstr);
                     }                                    
                 }
                 die_offsets.clear();
             }
         }
     }
     else
     {
SymbolFileDWARF::FindTypes (const SymbolContext& sc,
     const size_t num_die_matches = die_offsets.size();
 
     if (num_die_matches)
     {
         const uint32_t initial_types_size = types.GetSize();
         DWARFDebugInfo* debug_info = DebugInfo();
         for (size_t i=0; i<num_die_matches; ++i)
         {
-            const dw_offset_t die_offset = die_offsets[i];
-            DWARFDIE die = debug_info->GetDIE (die_offset);
+            const DIERef& die_ref = die_offsets[i];
+            DWARFDIE die = debug_info->GetDIE (die_ref);
 
             if (die)
             {
                 if (!DIEInDeclContext(parent_decl_ctx, die))
                     continue; // The containing decl contexts don't match
 
                 Type *matching_type = ResolveType (die);
                 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
             {
                 if (m_using_apple_tables)
                 {
                     GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n",
-                                                                               die_offset, name.GetCString());
+                                                                               die_ref.die_offset, name.GetCString());
                 }
             }            
 
         }
         const uint32_t num_matches = types.GetSize() - initial_types_size;
         if (log && num_matches)
         {
             if (parent_decl_ctx)
if (info)
         }
         
         const size_t num_matches = die_offsets.size();
         if (num_matches)
         {
             DWARFDebugInfo* debug_info = DebugInfo();
             for (size_t i=0; i<num_matches; ++i)
             {
-                const dw_offset_t die_offset = die_offsets[i];
-                DWARFDIE die = debug_info->GetDIE (die_offset);
+                const DIERef& die_ref = die_offsets[i];
+                DWARFDIE die = debug_info->GetDIE (die_ref);
 
                 if (die)
                 {
                     if (!DIEInDeclContext (parent_decl_ctx, die))
                         continue; // The containing decl contexts don't match
 
                     DWARFASTParser *dwarf_ast = die.GetDWARFParser();
                     if (dwarf_ast)
                     {
                         namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF (die);
                         if (namespace_decl_ctx)
                             break;
                     }
                 }
                 else
                 {
                     if (m_using_apple_tables)
                     {
                         GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_namespaces accelerator table had bad die 0x%8.8x for '%s')\n",
-                                                                   die_offset, name.GetCString());
+                                                                   die_ref.die_offset, name.GetCString());
                     }
                 }            
 
             }
         }
     }
     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;
 }
 
-uint32_t
-SymbolFileDWARF::FindTypes(std::vector<dw_offset_t> die_offsets, uint32_t max_matches, TypeList& types)
-{
-    // Remember how many sc_list are in the list before we search in case
-    // we are appending the results to a variable list.
-    uint32_t original_size = types.GetSize();
-
-    const uint32_t num_die_offsets = die_offsets.size();
-    // Parse all of the types we found from the pubtypes matches
-    uint32_t i;
-    uint32_t num_matches = 0;
-    for (i = 0; i < num_die_offsets; ++i)
-    {
-        Type *matching_type = ResolveTypeUID (die_offsets[i]);
-        if (matching_type)
-        {
-            // We found a type pointer, now find the shared pointer form our type list
-            types.InsertUnique (matching_type->shared_from_this());
-            ++num_matches;
-            if (num_matches >= max_matches)
-                break;
-        }
-    }
-
-    // Return the number of variable that were appended to the list
-    return types.GetSize() - original_size;
-}
-
-
 TypeSP
 SymbolFileDWARF::GetTypeForDIE (const DWARFDIE &die)
 {
     TypeSP type_sp;
     if (die)
     {
-        Type *type_ptr = m_die_to_type.lookup (die.GetDIE());
+        Type *type_ptr = GetDIEToType().lookup (die.GetDIE());
         if (type_ptr == NULL)
         {
             CompileUnit* lldb_cu = GetCompUnitForDWARFCompUnit(die.GetCU());
             assert (lldb_cu);
             SymbolContext sc(lldb_cu);
             type_sp = ParseType(sc, die, NULL);
         }
         else if (type_ptr != DIE_IS_BEING_PARSED)
SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE (const DWARFDIE &die,
     
     const size_t num_matches = die_offsets.size();
     
     if (num_matches)
     {
         DWARFDebugInfo* debug_info = DebugInfo();
         for (size_t i=0; i<num_matches; ++i)
         {
-            const dw_offset_t die_offset = die_offsets[i];
-            DWARFDIE type_die = debug_info->GetDIE (die_offset);
+            const DIERef& die_ref = die_offsets[i];
+            DWARFDIE type_die = debug_info->GetDIE (die_ref);
             
             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)
                 {
if (num_matches)
                         {
                             DEBUG_PRINTF ("resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64 " (cu 0x%8.8" PRIx64 ")\n",
                                           die.GetID(),
                                           m_obj_file->GetFileSpec().GetFilename().AsCString("<Unknown>"),
                                           type_die.GetID(),
                                           type_cu->GetID());
                             
                             if (die)
-                                m_die_to_type[die.GetDIE()] = resolved_type;
+                                GetDIEToType()[die.GetDIE()] = resolved_type;
                             type_sp = resolved_type->shared_from_this();
                             break;
                         }
                     }
                 }
             }
             else
             {
                 if (m_using_apple_tables)
                 {
                     GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n",
-                                                               die_offset, type_name.GetCString());
+                                                               die_ref.die_offset, type_name.GetCString());
                 }
             }            
             
         }
     }
     return type_sp;
 }
 
if (dwarf_decl_ctx_count > 0)
             const size_t num_matches = die_offsets.size();
             
             
             if (num_matches)
             {
                 DWARFDebugInfo* debug_info = DebugInfo();
                 for (size_t i=0; i<num_matches; ++i)
                 {
-                    const dw_offset_t die_offset = die_offsets[i];
-                    DWARFDIE type_die = debug_info->GetDIE (die_offset);
+                    const DIERef& die_ref = die_offsets[i];
+                    DWARFDIE type_die = debug_info->GetDIE (die_ref);
                     
                     if (type_die)
                     {
                         bool try_resolving_type = false;
                         
                         // Don't try and resolve the DIE we are looking for with the DIE itself!
                         const dw_tag_t type_tag = type_die.Tag();
                         // Make sure the tags match
if (dwarf_decl_ctx_count > 0)
                             }
                         }
                     }
                     else
                     {
                         if (m_using_apple_tables)
                         {
                             GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_types accelerator table had bad die 0x%8.8x for '%s')\n",
-                                                                                       die_offset, type_name.GetCString());
+                                                                                       die_ref.die_offset, type_name.GetCString());
                         }
                     }            
                     
                 }
             }
         }
     }
     return type_sp;
SymbolFileDWARF::ParseVariablesForContext (const SymbolContext& sc)
     if (sc.comp_unit != NULL)
     {
         DWARFDebugInfo* info = DebugInfo();
         if (info == NULL)
             return 0;
         
         if (sc.function)
         {
-            DWARFDIE function_die = info->GetDIE(sc.function->GetID());
+            DWARFDIE function_die = info->GetDIE(DIERef(sc.function->GetID()));
             
-            const dw_addr_t func_lo_pc = function_die.GetAttributeValueAsUnsigned (DW_AT_low_pc, LLDB_INVALID_ADDRESS);
+            const dw_addr_t func_lo_pc = function_die.GetAttributeValueAsAddress (DW_AT_low_pc, LLDB_INVALID_ADDRESS);
             if (func_lo_pc != LLDB_INVALID_ADDRESS)
             {
                 const size_t num_variables = ParseVariables(sc, function_die.GetFirstChild(), func_lo_pc, true, true);
             
                 // Let all blocks know they have parse all their variables
                 sc.function->GetBlock (false).SetDidParseVariables (true, true);
                 return num_variables;
             }
if (sc.comp_unit != NULL)
                 else
                 {
                     // Index if we already haven't to make sure the compile units
                     // get indexed and make their global DIE index list
                     if (!m_indexed)
                         Index ();
 
                     m_global_index.FindAllEntriesForCompileUnit (dwarf_cu->GetOffset(), 
-                                                                 dwarf_cu->GetNextCompileUnitOffset(), 
                                                                  die_offsets);
                 }
 
                 const size_t num_matches = die_offsets.size();
                 if (num_matches)
                 {
                     DWARFDebugInfo* debug_info = DebugInfo();
                     for (size_t i=0; i<num_matches; ++i)
                     {
-                        const dw_offset_t die_offset = die_offsets[i];
-                        DWARFDIE die = debug_info->GetDIE (die_offset);
+                        const DIERef& die_ref = die_offsets[i];
+                        DWARFDIE die = debug_info->GetDIE (die_ref);
                         if (die)
                         {
                             VariableSP var_sp (ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
                             if (var_sp)
                             {
                                 variables->AddVariableIfUnique (var_sp);
                                 ++vars_added;
                             }
                         }
                         else
                         {
                             if (m_using_apple_tables)
                             {
-                                GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x)\n", die_offset);
+                                GetObjectFile()->GetModule()->ReportErrorIfModifyDetected ("the DWARF debug information has been modified (.apple_names accelerator table had bad die 0x%8.8x)\n", die_ref.die_offset);
                             }
                         }            
 
                     }
                 }
             }
             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);
+
     VariableSP var_sp;
     if (!die)
         return var_sp;
 
-    var_sp = m_die_to_variable_sp[die.GetDIE()];
+    var_sp = GetDIEToVariable()[die.GetDIE()];
     if (var_sp)
         return var_sp;  // Already been parsed!
     
     const dw_tag_t tag = die.Tag();
     ModuleSP module = GetObjectFile()->GetModule();
     
     if ((tag == DW_TAG_variable) ||
         (tag == DW_TAG_constant) ||
         (tag == DW_TAG_formal_parameter && sc.function))
     {
         DWARFAttributes attributes;
         const size_t num_attributes = die.GetAttributes(attributes);
         if (num_attributes > 0)
         {
             const char *name = NULL;
             const char *mangled = NULL;
             Declaration decl;
             uint32_t i;
-            lldb::user_id_t type_uid = LLDB_INVALID_UID;
+            DWARFFormValue type_die_form;
             DWARFExpression location(die.GetCU());
             bool is_external = false;
             bool is_artificial = false;
             bool location_is_const_value_data = false;
             bool has_explicit_location = false;
             DWARFFormValue const_value;
             //AccessType accessibility = eAccessNone;
 
             for (i=0; i<num_attributes; ++i)
             {
                 dw_attr_t attr = attributes.AttributeAtIndex(i);
                 DWARFFormValue form_value;
                 
                 if (attributes.ExtractFormValueAtIndex(i, form_value))
                 {
                     switch (attr)
                     {
                     case DW_AT_decl_file:   decl.SetFile(sc.comp_unit->GetSupportFiles().GetFileSpecAtIndex(form_value.Unsigned())); break;
                     case DW_AT_decl_line:   decl.SetLine(form_value.Unsigned()); break;
                     case DW_AT_decl_column: decl.SetColumn(form_value.Unsigned()); break;
                     case DW_AT_name:        name = form_value.AsCString(); break;
                     case DW_AT_linkage_name:
                     case DW_AT_MIPS_linkage_name: mangled = form_value.AsCString(); break;
-                    case DW_AT_type:        type_uid = form_value.Reference(); break;
+                    case DW_AT_type:        type_die_form = form_value; break;
                     case DW_AT_external:    is_external = form_value.Boolean(); break;
                     case DW_AT_const_value:
                         // If we have already found a DW_AT_location attribute, ignore this attribute.
                         if (!has_explicit_location)
                         {
                             location_is_const_value_data = true;
                             // The constant value will be either a block, a data value or a string.
                             const DWARFDataExtractor& debug_info_data = get_debug_info_data();
if ((tag == DW_TAG_variable) ||
                 default:
                     symbol_context_scope = sc.comp_unit;
                     break;
                 }
             }
 
             if (symbol_context_scope)
             {
-                SymbolFileTypeSP type_sp(new SymbolFileType(*this, type_uid));
+                SymbolFileTypeSP type_sp(new SymbolFileType(*this, DIERef(type_die_form).GetUID()));
                 
                 if (const_value.Form() && type_sp && type_sp->GetType())
                     location.CopyOpcodeData(const_value.Unsigned(), type_sp->GetType()->GetByteSize(), die.GetCU()->GetAddressByteSize());
                 
                 var_sp.reset (new Variable (die.GetID(),
                                             name, 
                                             mangled,
                                             type_sp,
if ((tag == DW_TAG_variable) ||
                 // 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...
-        m_die_to_variable_sp[die.GetDIE()] = var_sp;
+        GetDIEToVariable()[die.GetDIE()] = var_sp;
     }
     return var_sp;
 }
 
 
 DWARFDIE
-SymbolFileDWARF::FindBlockContainingSpecification (dw_offset_t func_die_offset, 
+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 
     // concrete block whose DW_AT_specification or DW_AT_abstract_origin points
     // to "spec_block_die_offset"
-    return FindBlockContainingSpecification (DebugInfo()->GetDIE (func_die_offset), spec_block_die_offset);
+    return FindBlockContainingSpecification (DebugInfo()->GetDIE (func_die_ref), spec_block_die_offset);
 }
 
 
 DWARFDIE
 SymbolFileDWARF::FindBlockContainingSpecification(const DWARFDIE &die,
                                                   dw_offset_t spec_block_die_offset)
 {
     if (die)
SymbolFileDWARF::ParseVariables (const SymbolContext& sc,
 
     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 = m_die_to_variable_sp[die.GetDIE()];
+        VariableSP var_sp = GetDIEToVariable()[die.GetDIE()];
         if (var_sp)
         {
             if (cc_variable_list)
                 cc_variable_list->AddVariableIfUnique (var_sp);
         }
         else
         {
             // We haven't already parsed it, lets do that now.
while (die)
                                 
                                 Block *block = sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
                                 if (block == NULL)
                                 {
                                     // 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 (sc.function->GetID(),
+                                    const DWARFDIE concrete_block_die = FindBlockContainingSpecification (DIERef(sc.function->GetID()),
                                                                                                           sc_parent_die.GetOffset());
                                     if (concrete_block_die)
                                         block = sc.function->GetBlock(true).FindBlockByID(concrete_block_die.GetID());
                                 }
                                 
                                 if (block != NULL)
                                 {
                                     const bool can_create = false;
if (m_debug_map_symfile == NULL && !m_debug_map_module_wp.expired())
         {
             SymbolVendor *sym_vendor = module_sp->GetSymbolVendor();
             if (sym_vendor)
                 m_debug_map_symfile = (SymbolFileDWARFDebugMap *)sym_vendor->GetSymbolFile();
         }
     }
     return m_debug_map_symfile;
 }
-
-

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

+//===-- SymbolFileDWARFDwo.h ------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_
+#define SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "SymbolFileDWARF.h"
+
+class SymbolFileDWARFDwo : public SymbolFileDWARF
+{
+public:
+    SymbolFileDWARFDwo(lldb::ObjectFileSP objfile, DWARFCompileUnit* dwarf_cu);
+
+    virtual
+    ~SymbolFileDWARFDwo() = default;
+    
+    const lldb_private::DWARFDataExtractor&
+    GetCachedSectionData(uint32_t got_flag,
+                         lldb::SectionType sect_type,
+                         lldb_private::DWARFDataExtractor &data) override;
+    
+    lldb::CompUnitSP
+    ParseCompileUnit(DWARFCompileUnit* dwarf_cu, uint32_t cu_idx) override;
+
+    DWARFCompileUnit*
+    GetCompileUnit();
+
+    DWARFCompileUnit*
+    GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) override;
+
+protected:
+    DIEToTypePtr&
+    GetDIEToType() override;
+
+    DIEToVariableSP&
+    GetDIEToVariable() override;
+    
+    DIEToClangType&
+    GetForwardDeclDieToClangType() override;
+
+    ClangTypeToDIE&
+    GetForwardDeclClangTypeToDie() override;
+
+    lldb::ObjectFileSP m_obj_file_sp;
+    DWARFCompileUnit* m_base_dwarf_cu;
+};
+
+#endif  // SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_

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

+//===-- SymbolFileDWARFDwo.cpp ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SymbolFileDWARFDwo.h"
+
+#include "lldb/Core/Section.h"
+#include "lldb/Symbol/ObjectFile.h"
+
+#include "DWARFCompileUnit.h"
+#include "DWARFDebugInfo.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+SymbolFileDWARFDwo::SymbolFileDWARFDwo(ObjectFileSP objfile, DWARFCompileUnit* dwarf_cu) :
+    SymbolFileDWARF(objfile.get()),
+    m_obj_file_sp(objfile),
+    m_base_dwarf_cu(dwarf_cu)
+{
+}
+
+const lldb_private::DWARFDataExtractor&
+SymbolFileDWARFDwo::GetCachedSectionData(uint32_t got_flag,
+                                         lldb::SectionType sect_type,
+                                         lldb_private::DWARFDataExtractor &data)
+{
+    if (!m_flags.IsClear (got_flag))
+        return data;
+
+    const SectionList* section_list = m_obj_file->GetSectionList(false /* update_module_section_list */);
+    if (section_list)
+    {
+        SectionSP section_sp (section_list->FindSectionByType(sect_type, true));
+        if (section_sp)
+        {
+            // See if we memory mapped the DWARF segment?
+            if (m_dwarf_data.GetByteSize())
+            {
+                data.SetData(m_dwarf_data, section_sp->GetOffset(), section_sp->GetFileSize());
+                m_flags.Set (got_flag);
+                return data;
+            }
+
+            if (m_obj_file->ReadSectionData(section_sp.get(), data) != 0)
+            {
+                m_flags.Set (got_flag);
+                return data;
+            }
+
+            data.Clear();
+        }
+    }
+    return SymbolFileDWARF::GetCachedSectionData(got_flag, sect_type, data);
+}
+
+lldb::CompUnitSP
+SymbolFileDWARFDwo::ParseCompileUnit(DWARFCompileUnit* dwarf_cu, uint32_t cu_idx)
+{
+    assert(GetCompileUnit() == dwarf_cu && "SymbolFileDWARFDwo::ParseCompileUnit called with incompatible compile unit");
+    return m_base_dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(m_base_dwarf_cu, UINT32_MAX);
+}
+
+DWARFCompileUnit*
+SymbolFileDWARFDwo::GetCompileUnit()
+{
+    assert(GetNumCompileUnits() == 1 && "Only dwo files with 1 compile unit is supported");
+    return DebugInfo()->GetCompileUnitAtIndex(0);
+}
+
+DWARFCompileUnit*
+SymbolFileDWARFDwo::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit)
+{
+    return GetCompileUnit();
+}
+
+SymbolFileDWARF::DIEToTypePtr&
+SymbolFileDWARFDwo::GetDIEToType()
+{
+    return m_base_dwarf_cu->GetSymbolFileDWARF()->GetDIEToType();
+}
+
+SymbolFileDWARF::DIEToVariableSP&
+SymbolFileDWARFDwo::GetDIEToVariable()
+{
+    return m_base_dwarf_cu->GetSymbolFileDWARF()->GetDIEToVariable();
+}
+
+SymbolFileDWARF::DIEToClangType&
+SymbolFileDWARFDwo::GetForwardDeclDieToClangType()
+{
+    return m_base_dwarf_cu->GetSymbolFileDWARF()->GetForwardDeclDieToClangType();
+}
+
+SymbolFileDWARF::ClangTypeToDIE&
+SymbolFileDWARFDwo::GetForwardDeclClangTypeToDie()
+{
+    return m_base_dwarf_cu->GetSymbolFileDWARF()->GetForwardDeclClangTypeToDie();
+}

lldb/trunk/source/Symbol/ObjectFile.cpp

if (module_sp)
             log->Printf ("%p ObjectFile::ClearSymtab () symtab = %p",
                          static_cast<void*>(this),
                          static_cast<void*>(m_symtab_ap.get()));
         m_symtab_ap.reset();
     }
 }
 
 SectionList *
-ObjectFile::GetSectionList()
+ObjectFile::GetSectionList(bool update_module_section_list)
 {
     if (m_sections_ap.get() == nullptr)
     {
+        if (update_module_section_list)
+        {
             ModuleSP module_sp(GetModule());
             if (module_sp)
             {
                 lldb_private::Mutex::Locker locker(module_sp->GetMutex());
                 CreateSections(*module_sp->GetUnifiedSectionList());
             }
         }
+        else
+        {
+            SectionList unified_section_list;
+            CreateSections(unified_section_list);
+        }
+    }
     return m_sections_ap.get();
 }