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

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

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

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

330

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

1437–1438

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

1458–1459

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

1480–1481

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

1494–1515

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

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

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

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

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

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

Can you explain why this is needed?

[clayborg]

include/lldb/Symbol/ObjectFile.h

372

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

I just forgot to check if (fixed).

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

806–818

Nice catch

1437–1438

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

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

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

4080–4082

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

300–312

Is DW_AT_GNU_dwo_name always a relative path?

653–661

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

949

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

1633

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

1640

This will crash due to attribute_symbol_file always being nullptr.

1651–1655

This is currently always nullptr, so this is dead code

1674

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.

1713–1725

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...

1742–1767

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...

1807–1808

We don't check DW_AT_specification or DW_AT_abstract_origin...

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

4102

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

300–312

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

653–661

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

1633

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

942–947

These 3 lines would be nicer as:

for (const auto &die_ref : die_refs)
{

1355–1366

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.

1369–1385

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

1355–1366

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.

1369–1385

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().

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.

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:

source/Plugins/SymbolFile/DWARF/CMakeLists.txt

add_lldb_library(lldbPluginSymbolFileDWARF
   DWARFDefines.cpp
   DWARFDIECollection.cpp
   DWARFFormValue.cpp
   DWARFLocationDescription.cpp
   DWARFLocationList.cpp
   LogChannelDWARF.cpp
   NameToDIE.cpp
   SymbolFileDWARF.cpp
+  SymbolFileDWARFDwo.cpp
   SymbolFileDWARFDebugMap.cpp
   UniqueDWARFASTType.cpp
   )

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 "SymbolFileDWARF.h"
+#include "SymbolFileDWARFDwo.h"
 
 class NameToDIE;
 
 class DWARFCompileUnit
 {
 public:
     enum Producer 
     {
public:
     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) { m_addr_base = addr_base; }
     void        ClearDIEs(bool keep_compile_unit_die);
     void        BuildAddressRangeTable (SymbolFileDWARF* dwarf2Data,
                                         DWARFDebugAranges* debug_aranges);
 
     void
     SetBaseAddress(dw_addr_t base_addr)
     {
         m_base_addr = 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;
     }
 
     DWARFDebugInfoEntry*
     GetDIEAtIndexUnchecked (uint32_t idx)
//
     lldb::LanguageType
     GetLanguageType();
 
     bool
     IsDWARF64() const;
 
     bool
     GetIsOptimized ();
     
+    SymbolFileDWARFDwo*
+    GetDwoSymbolFile()
+    {
+        // Extract the compile unit DIE as that one contains the dwo symbol file information
+        ExtractDIEsIfNeeded(true);
+        return m_dwo_symbol_file.get();
+    }
+
 protected:
     SymbolFileDWARF*    m_dwarf2Data;
+    lldb::ObjectFileSP  m_dwo_obj_file;
+    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
     
     void
     ParseProducerInfo ();
 private:
     DISALLOW_COPY_AND_ASSIGN (DWARFCompileUnit);
 };
 
 #endif  // SymbolFileDWARF_DWARFCompileUnit_h_

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

 //                        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)
         else
             m_die_array[0].Dump(m_dwarf2Data, this, strm, UINT32_MAX);        
         verbose_log->PutCString (strm.GetString().c_str());
     }
 
     return m_die_array.size();
 }
 
+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;
+    
+    const char* comp_dir = cu_die.GetAttributeValueAsString(m_dwarf2Data,
+                                                            this,
+                                                            DW_AT_comp_dir,
+                                                            nullptr);
+    if (!comp_dir)
+        return;
+
+    FileSpec dwo_file(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;
+    m_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 (m_dwo_obj_file == nullptr)
+        return;
+
+    m_dwo_symbol_file.reset(new SymbolFileDWARFDwo(m_dwo_obj_file.get(), this));
+    
+    DWARFCompileUnit* dwo_cu = m_dwo_symbol_file->GetCompileUnit();
+    if (dwo_cu)
+    {
+        m_dwarf2Data->AddDwoSymbolFile(m_dwo_symbol_file.get());
+        dwo_cu->SetAddrBase(cu_die.GetAttributeValueAsUnsigned(m_dwarf2Data,
+                                                               this,
+                                                               DW_AT_GNU_addr_base,
+                                                               0));
+    }
+    else
+    {
+        // Can't parse the compile unit in the dwo file. Clear our data about it so we won't try it
+        // again
+        m_dwo_obj_file.reset();
+        m_dwo_symbol_file.reset();
+    }
+}
 
 dw_offset_t
 DWARFCompileUnit::GetAbbrevOffset() const
 {
     return m_abbrevs ? m_abbrevs->GetOffset() : DW_INVALID_OFFSET;
 }
 
 
if (debug_aranges->GetNumRanges() == num_debug_aranges)
                 {
                     LineTable::FileAddressRanges file_ranges;
                     const bool append = true;
                     const size_t num_ranges = line_table->GetContiguousFileAddressRanges (file_ranges, append);
                     for (uint32_t idx=0; idx<num_ranges; ++idx)
                     {
                         const LineTable::FileAddressRanges::Entry &range = file_ranges.GetEntryRef(idx);
                         debug_aranges->AppendRange(cu_offset, range.GetRangeBase(), range.GetRangeEnd());
-                        printf ("0x%8.8x: [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 ")\n", GetOffset(), range.GetRangeBase(), range.GetRangeEnd());
                     }
                 }
             }
             else
                 debug_map_sym_file->AddOSOARanges(dwarf2Data,debug_aranges);
         }
     }
     
DWARFCompileUnit::GetDIEPtrContainingOffset(dw_offset_t die_offset)
     {
         ExtractDIEsIfNeeded (false);
         DWARFDebugInfoEntry compare_die;
         compare_die.SetOffset(die_offset);
         DWARFDebugInfoEntry::iterator end = m_die_array.end();
         DWARFDebugInfoEntry::iterator pos = lower_bound(m_die_array.begin(), end, compare_die, CompareDIEOffset);
         if (pos != end)
         {
             if (die_offset >= (*pos).GetOffset())
             {
                 DWARFDebugInfoEntry::iterator next = pos + 1;
                 if (next != end)
                 {
                     if (die_offset < (*next).GetOffset())
                         return &(*pos);
                 }
             }
         }
     }
     return NULL;    // Not found in any compile units
 }
 
 
 
 size_t

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

(
     DWARFCompileUnitSP& cu_sp,
     DWARFDebugInfoEntry* die,
     const dw_offset_t next_offset,
     const uint32_t curr_depth,
     void* userData
 )
 {
     DumpInfo* dumpInfo = (DumpInfo*)userData;
-
-    const DWARFCompileUnit* cu = cu_sp.get();
+    DWARFCompileUnit* cu = cu_sp.get();
 
     Stream *s = dumpInfo->strm;
     bool show_parents = s->GetFlags().Test(DWARFDebugInfo::eDumpFlag_ShowAncestors);
 
     if (die)
     {
         // Are we dumping everything?
         if (dumpInfo->die_offset == DW_INVALID_OFFSET)
(
     DWARFCompileUnitSP& cu_sp,
     DWARFDebugInfoEntry* die,
     const dw_offset_t next_offset,
     const uint32_t curr_depth,
     void* userData
 )
 {
     FindCallbackStringInfo* info = (FindCallbackStringInfo*)userData;
-    const DWARFCompileUnit* cu = cu_sp.get();
+    DWARFCompileUnit* cu = cu_sp.get();
 
     if (die)
     {
         const char* die_name = die->GetName(dwarf2Data, cu);
         if (die_name)
         {
             if (info->regex)
             {

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

void        Clear ()
                     m_has_children   = false;
                     m_tag            = 0;
                 }
 
     bool        Contains (const DWARFDebugInfoEntry *die) const;
 
     void        BuildAddressRangeTable(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     DWARFDebugAranges* debug_aranges) const;
 
     void        BuildFunctionAddressRangeTable(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     DWARFDebugAranges* debug_aranges) const;
 
     bool        FastExtract(
                     const lldb_private::DWARFDataExtractor& debug_info_data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     const DWARFFormValue::FixedFormSizes& fixed_form_sizes,
                     lldb::offset_t* offset_ptr);
 
     bool        Extract(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     lldb::offset_t* offset_ptr);
 
     bool        LookupAddress(
                     const dw_addr_t address,
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     DWARFDebugInfoEntry** function_die,
                     DWARFDebugInfoEntry** block_die);
 
     size_t      GetAttributes(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     DWARFFormValue::FixedFormSizes fixed_form_sizes,
                     DWARFDebugInfoEntry::Attributes& 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,
+                    DWARFCompileUnit* cu,
                     const dw_attr_t attr,
                     const char* fail_value) const;
 
     uint64_t    GetAttributeValueAsUnsigned(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     const dw_attr_t attr,
                     uint64_t fail_value) const;
 
     uint64_t    GetAttributeValueAsReference(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     const dw_attr_t attr,
                     uint64_t fail_value) const;
 
     int64_t     GetAttributeValueAsSigned(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     const dw_attr_t attr,
                     int64_t fail_value) const;
 
+    uint64_t    GetAttributeValueAsAddress(
+                    SymbolFileDWARF* dwarf2Data,
+                    DWARFCompileUnit* cu,
+                    const dw_attr_t attr,
+                    uint64_t fail_value) const;
+
     dw_addr_t   GetAttributeHighPC(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     dw_addr_t lo_pc,
                     uint64_t fail_value) const;
 
     bool        GetAttributeAddressRange(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     dw_addr_t& lo_pc,
                     dw_addr_t& hi_pc,
                     uint64_t fail_value) const;
     
     size_t      GetAttributeAddressRanges (
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     DWARFDebugRanges::RangeList &ranges,
                     bool check_hi_lo_pc) const;
     
     dw_offset_t GetAttributeValueAsLocation(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     const dw_attr_t attr,
                     lldb_private::DWARFDataExtractor& data,
                     uint32_t &block_size) const;
 
     const char* GetName(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu) const;
+                    DWARFCompileUnit* cu) const;
 
     const char* GetMangledName(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     bool substitute_name_allowed = true) const;
 
     const char* GetPubname(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu) const;
+                    DWARFCompileUnit* cu) const;
 
     static bool GetName(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     const dw_offset_t die_offset,
                     lldb_private::Stream &s);
 
     static bool AppendTypeName(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     const dw_offset_t die_offset,
                     lldb_private::Stream &s);
 
     const char * GetQualifiedName (
                     SymbolFileDWARF* dwarf2Data, 
                     DWARFCompileUnit* cu,
                     std::string &storage) const;
     

 //                    bool compare_children);
 
     static bool OffsetLessThan (
                     const DWARFDebugInfoEntry& a,
                     const DWARFDebugInfoEntry& b);
 
     void        Dump(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     lldb_private::Stream &s,
                     uint32_t recurse_depth) const;
 
     void        DumpAncestry(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     const DWARFDebugInfoEntry* oldest,
                     lldb_private::Stream &s,
                     uint32_t recurse_depth) const;
 
     static void DumpAttribute(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     const lldb_private::DWARFDataExtractor& debug_info_data,
                     lldb::offset_t *offset_ptr,
                     lldb_private::Stream &s,
                     dw_attr_t attr,
                     dw_form_t form);
     // This one dumps the comp unit name, objfile name and die offset for this die so the stream S.
     void          DumpLocation(
                     SymbolFileDWARF* dwarf2Data,
                     DWARFCompileUnit* cu,
                     lldb_private::Stream &s) const;
                     
     bool        GetDIENamesAndRanges(
                     SymbolFileDWARF* dwarf2Data,
-                    const DWARFCompileUnit* cu,
+                    DWARFCompileUnit* cu,
                     const char * &name,
                     const char * &mangled,
                     DWARFDebugRanges::RangeList& rangeList,
                     int& decl_file,
                     int& decl_line,
                     int& decl_column,
                     int& call_file,
                     int& call_line,
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,
+                                  DWARFCompileUnit* cu,
+                                  const dw_attr_t attr,
+                                  DWARFFormValue& formValue,
+                                  dw_offset_t* end_attr_offset_ptr = nullptr) const;
+
+    dw_offset_t GetAttributeValueForDwoCompileUnit(SymbolFileDWARF* dwarf2Data,
+                                                   DWARFCompileUnit* cu,
+                                                   const dw_attr_t attr,
+                                                   DWARFFormValue& formValue,
+                                                   dw_offset_t* end_attr_offset_ptr = nullptr) 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_

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

 }
 
 
 
 bool
 DWARFDebugInfoEntry::FastExtract
 (
     const DWARFDataExtractor& debug_info_data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     const DWARFFormValue::FixedFormSizes& fixed_form_sizes,
     lldb::offset_t *offset_ptr
 )
 {
     m_offset = *offset_ptr;
     m_parent_idx = 0;
     m_sibling_idx = 0;
     m_empty_children = false;

 // Extract a debug info entry for a given compile unit from the
 // .debug_info and .debug_abbrev data within the SymbolFileDWARF class
 // starting at the given offset
 //----------------------------------------------------------------------
 bool
 DWARFDebugInfoEntry::Extract
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     lldb::offset_t *offset_ptr
 )
 {
     const DWARFDataExtractor& debug_info_data = dwarf2Data->get_debug_info_data();
 //    const DWARFDataExtractor& debug_str_data = dwarf2Data->get_debug_str_data();
     const uint32_t cu_end_offset = cu->GetNextCompileUnitOffset();
     lldb::offset_t offset = *offset_ptr;
 //  if (offset >= cu_end_offset)
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());
+                            {
+                                dw_addr_t base_address = form_value.Address(dwarf2Data);
+                                ((DWARFCompileUnit*)cu)->SetBaseAddress(base_address);
+                            }
                         }
                     }
                     else
                     {
                         bool form_is_indirect = false;
                         do
                         {
                             form_is_indirect = false;

 //
 // Dumps all of a debug information entries parents up until oldest and
 // all of it's attributes to the specified stream.
 //----------------------------------------------------------------------
 void
 DWARFDebugInfoEntry::DumpAncestry
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     const DWARFDebugInfoEntry* oldest,
     Stream &s,
     uint32_t recurse_depth
 ) const
 {
     const DWARFDebugInfoEntry* parent = GetParent();
     if (parent && parent != oldest)
         parent->DumpAncestry(dwarf2Data, cu, oldest, s, 0);

 // Gets the valid address ranges for a given DIE by looking for a
 // DW_AT_low_pc/DW_AT_high_pc pair, DW_AT_entry_pc, or DW_AT_ranges
 // attributes.
 //----------------------------------------------------------------------
 bool
 DWARFDebugInfoEntry::GetDIENamesAndRanges
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     const char * &name,
     const char * &mangled,
     DWARFDebugRanges::RangeList& ranges,
     int& decl_file,
     int& decl_line,
     int& decl_column,
     int& call_file,
     int& call_line,
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(dwarf2Data);
 
                     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(dwarf2Data);
                     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)
+                    {
+                        form_value.Address(dwarf2Data);
+                    }
+                    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:
                     {
                         const DWARFDebugRanges* debug_ranges = dwarf2Data->DebugRanges();
                         debug_ranges->FindRanges(form_value.Unsigned(), ranges);
                         // All DW_AT_ranges are relative to the base address of the
                         // compile unit. We add the compile unit base address to make
if (set_frame_base_loclist_addr)
         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)
         {
             DWARFCompileUnitSP cu_sp_ptr;
             const DWARFDebugInfoEntry* die = NULL;
             dw_offset_t die_offset = *pos;
             if (die_offset != DW_INVALID_OFFSET)
             {
                 die = dwarf2Data->DebugInfo()->GetDIEPtr(die_offset, &cu_sp_ptr);
                 if (die)
                     die->GetDIENamesAndRanges(dwarf2Data, cu_sp_ptr.get(), name, mangled, ranges, decl_file, decl_line, decl_column, call_file, call_line, call_column);
             }
         }
     }
     return !ranges.IsEmpty();
 }
 
 //----------------------------------------------------------------------
 // Dump
 //
 // Dumps a debug information entry and all of it's attributes to the
 // specified stream.
 //----------------------------------------------------------------------
 void
 DWARFDebugInfoEntry::Dump
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     Stream &s,
     uint32_t recurse_depth
 ) const
 {
     const DWARFDataExtractor& debug_info_data = dwarf2Data->get_debug_info_data();
     lldb::offset_t offset = m_offset;
 
     if (debug_info_data.ValidOffset(offset))

 // Dumps a debug information entry attribute along with it's form. Any
 // special display of attributes is done (disassemble location lists,
 // show enumeration values for attributes, etc).
 //----------------------------------------------------------------------
 void
 DWARFDebugInfoEntry::DumpAttribute
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     const DWARFDataExtractor& debug_info_data,
     lldb::offset_t *offset_ptr,
     Stream &s,
     dw_attr_t attr,
     dw_form_t form
 )
 {
     bool verbose    = s.GetVerbose();

 // specification or abstract origin attributes and including those in
 // the results. Any duplicate attributes will have the first instance
 // take precedence (this can happen for declaration attributes).
 //----------------------------------------------------------------------
 size_t
 DWARFDebugInfoEntry::GetAttributes
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     DWARFFormValue::FixedFormSizes fixed_form_sizes,
     DWARFDebugInfoEntry::Attributes& attributes,
     uint32_t curr_depth
 ) const
 {
     lldb::offset_t offset;
     const DWARFAbbreviationDeclaration* abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
 

 // attribute if it was properly extracted into form_value, or zero
 // if we fail since an offset of zero is invalid for an attribute (it
 // would be a compile unit header).
 //----------------------------------------------------------------------
 dw_offset_t
 DWARFDebugInfoEntry::GetAttributeValue
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     const dw_attr_t attr,
     DWARFFormValue& form_value,
     dw_offset_t* end_attr_offset_ptr
 ) const
 {
     lldb::offset_t offset;
     const DWARFAbbreviationDeclaration* abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
 
if (abbrevDecl)
                     *end_attr_offset_ptr = offset;
                 return attr_offset;
             }
         }
     }
 
     return 0;
 }
 
+dw_offset_t
+DWARFDebugInfoEntry::GetAttributeValueForDwoCompileUnit
+(
+    SymbolFileDWARF* dwarf2Data,
+    DWARFCompileUnit* cu,
+    const dw_attr_t attr,
+    DWARFFormValue& form_value,
+    dw_offset_t* end_attr_offset_ptr
+) const
+{
+    if (m_tag != DW_TAG_compile_unit)
+        return 0;
+        
+    SymbolFileDWARFDwo* dwo_sym_file = cu->GetDwoSymbolFile();
+    if (!dwo_sym_file)
+        return 0;
+    
+    DWARFCompileUnit* dwo_cu = dwo_sym_file->GetCompileUnit();
+    if (!dwo_cu)
+        return 0;
+
+    const DWARFDebugInfoEntry* dwo_cu_die = dwo_cu->GetCompileUnitDIEOnly();
+    if (!dwo_cu_die)
+        return 0;
+
+    return dwo_cu_die->GetAttributeValue(dwo_sym_file, dwo_cu, attr, form_value, end_attr_offset_ptr);
+}
+
 //----------------------------------------------------------------------
 // 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,
+    DWARFCompileUnit* cu,
     const dw_attr_t attr,
     const char* fail_value) const
 {
     DWARFFormValue form_value;
     if (GetAttributeValue(dwarf2Data, cu, attr, form_value))
         return form_value.AsCString(dwarf2Data);
+    
+    if (m_tag != DW_TAG_compile_unit)
+        return fail_value;
+        
+    SymbolFileDWARFDwo* dwo_sym_file = cu->GetDwoSymbolFile();
+    if (!dwo_sym_file)
+        return fail_value;
+    
+    DWARFCompileUnit* dwo_cu = dwo_sym_file->GetCompileUnit();
+    if (!dwo_cu)
+        return fail_value;
+
+    const DWARFDebugInfoEntry* dwo_cu_die = dwo_cu->GetCompileUnitDIEOnly();
+    if (!dwo_cu_die)
         return fail_value;
+
+    return dwo_cu_die->GetAttributeValueAsString(dwo_sym_file, dwo_cu, attr, fail_value);
 }
 
 //----------------------------------------------------------------------
 // GetAttributeValueAsUnsigned
 //
 // Get the value of an attribute as unsigned and return it.
 //----------------------------------------------------------------------
 uint64_t
 DWARFDebugInfoEntry::GetAttributeValueAsUnsigned
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     const dw_attr_t attr,
     uint64_t fail_value
 ) const
 {
     DWARFFormValue form_value;
-    if (GetAttributeValue(dwarf2Data, cu, attr, form_value))
+    if (GetAttributeValue(dwarf2Data, cu, attr, form_value) ||
+        GetAttributeValueForDwoCompileUnit(dwarf2Data, cu, attr, form_value))
         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,
+    DWARFCompileUnit* cu,
     const dw_attr_t attr,
     int64_t fail_value
 ) const
 {
     DWARFFormValue form_value;
-    if (GetAttributeValue(dwarf2Data, cu, attr, form_value))
+    if (GetAttributeValue(dwarf2Data, cu, attr, form_value) ||
+        GetAttributeValueForDwoCompileUnit(dwarf2Data, cu, attr, form_value))
         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,
+    DWARFCompileUnit* cu,
     const dw_attr_t attr,
     uint64_t fail_value
 ) const
 {
     DWARFFormValue form_value;
-    if (GetAttributeValue(dwarf2Data, cu, attr, form_value))
+    if (GetAttributeValue(dwarf2Data, cu, attr, form_value) ||
+        GetAttributeValueForDwoCompileUnit(dwarf2Data, cu, attr, form_value))
         return form_value.Reference();
     return fail_value;
 }
 
+uint64_t
+DWARFDebugInfoEntry::GetAttributeValueAsAddress
+(
+    SymbolFileDWARF* dwarf2Data,
+    DWARFCompileUnit* cu,
+    const dw_attr_t attr,
+    uint64_t fail_value
+) const
+{
+    DWARFFormValue form_value;
+    if (GetAttributeValue(dwarf2Data, cu, attr, form_value))
+        return form_value.Address(dwarf2Data);
+    
+    if (m_tag != DW_TAG_compile_unit)
+        return fail_value;
+        
+    SymbolFileDWARFDwo* dwo_sym_file = cu->GetDwoSymbolFile();
+    if (!dwo_sym_file)
+        return fail_value;
+    
+    DWARFCompileUnit* dwo_cu = dwo_sym_file->GetCompileUnit();
+    if (!dwo_cu)
+        return fail_value;
+
+    const DWARFDebugInfoEntry* dwo_cu_die = dwo_cu->GetCompileUnitDIEOnly();
+    if (!dwo_cu_die)
+        return fail_value;
+
+    return dwo_cu_die->GetAttributeValueAsAddress(dwo_sym_file, dwo_cu, attr, 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,
+    DWARFCompileUnit* cu,
     dw_addr_t lo_pc,
     uint64_t fail_value
 ) const
 {
     DWARFFormValue form_value;
-    if (GetAttributeValue(dwarf2Data, cu, DW_AT_high_pc, form_value))
+    if (GetAttributeValue(dwarf2Data, cu, DW_AT_high_pc, form_value) ||
+        GetAttributeValueForDwoCompileUnit(dwarf2Data, cu, DW_AT_high_pc, form_value))
     {
         dw_form_t form = form_value.Form();
         if (form == DW_FORM_addr || form == DW_FORM_GNU_addr_index)
             return form_value.Address(dwarf2Data);
         
         // DWARF4 can specify the hi_pc as an <offset-from-lowpc>
         return lo_pc + form_value.Unsigned();
     }
     return fail_value;
 }
 
 //----------------------------------------------------------------------
 // GetAttributeAddressRange
 //
 // Get the lo_pc and hi_pc, adding hi_pc to lo_pc when specified
 // as an <offset-from-low-pc>.
 //
 // Returns true or sets lo_pc and hi_pc to fail_value.
 //----------------------------------------------------------------------
 bool
 DWARFDebugInfoEntry::GetAttributeAddressRange
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     dw_addr_t& lo_pc,
     dw_addr_t& hi_pc,
     uint64_t fail_value
 ) const
 {
-    lo_pc = GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_low_pc, fail_value);
+    lo_pc = GetAttributeValueAsAddress(dwarf2Data, cu, DW_AT_low_pc, fail_value);
     if (lo_pc != fail_value)
     {
         hi_pc = GetAttributeHighPC(dwarf2Data, cu, lo_pc, fail_value);
         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,
+                                               DWARFCompileUnit* cu,
                                                DWARFDebugRanges::RangeList &ranges,
                                                bool check_hi_lo_pc) const
 {
     ranges.Clear();
     
     dw_offset_t ranges_offset = GetAttributeValueAsUnsigned(dwarf2Data, cu, DW_AT_ranges, DW_INVALID_OFFSET);
     if (ranges_offset != DW_INVALID_OFFSET)
     {

 //
 // 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,
+    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
+    DWARFCompileUnit* cu
 ) const
 {
+    const char* dw_at_name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr);
+    if (dw_at_name)
+        return dw_at_name;
+
     DWARFFormValue form_value;
-    if (GetAttributeValue(dwarf2Data, cu, DW_AT_name, form_value))
-        return form_value.AsCString(dwarf2Data);
-    else if (GetAttributeValue(dwarf2Data, cu, DW_AT_specification, form_value))
+    if (GetAttributeValue(dwarf2Data, cu, DW_AT_specification, form_value))
     {
         DWARFCompileUnitSP cu_sp_ptr;
-        const DWARFDebugInfoEntry* die = const_cast<SymbolFileDWARF*>(dwarf2Data)->DebugInfo()->GetDIEPtr(form_value.Reference(), &cu_sp_ptr);
+        const DWARFDebugInfoEntry* die = dwarf2Data->DebugInfo()->GetDIEPtr(form_value.Reference(), &cu_sp_ptr);
         if (die)
             return die->GetName(dwarf2Data, cu_sp_ptr.get());
     }
     else if (GetAttributeValue(dwarf2Data, cu, DW_AT_abstract_origin, form_value))
     {
         DWARFCompileUnitSP cu_sp_ptr;
-        const DWARFDebugInfoEntry* die = const_cast<SymbolFileDWARF*>(dwarf2Data)->DebugInfo()->GetDIEPtr(form_value.Reference(), &cu_sp_ptr);
+        const DWARFDebugInfoEntry* die = dwarf2Data->DebugInfo()->GetDIEPtr(form_value.Reference(), &cu_sp_ptr);
         if (die)
             return die->GetName(dwarf2Data, cu_sp_ptr.get());
     }
     return nullptr;
 }
 
 
 //----------------------------------------------------------------------
 // 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,
+    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(dwarf2Data);
+    name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_MIPS_linkage_name, nullptr);
+    if (name)
+        return name;
 
-    if (GetAttributeValue(dwarf2Data, cu, DW_AT_linkage_name, form_value))
-        name = form_value.AsCString(dwarf2Data);
+    name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_linkage_name, nullptr);
+    if (name)
+        return name;
 
-    if (substitute_name_allowed && name == nullptr)
-    {
-        if (GetAttributeValue(dwarf2Data, cu, DW_AT_name, form_value))
-            name = form_value.AsCString(dwarf2Data);
-    }
+    if (!substitute_name_allowed)
+        return nullptr;
+
+    name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr);
     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
+    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);
+    if (name)
+        return name;
 
-    if (GetAttributeValue(dwarf2Data, cu, DW_AT_MIPS_linkage_name, form_value))
-        name = form_value.AsCString(dwarf2Data);
-    else if (GetAttributeValue(dwarf2Data, cu, DW_AT_linkage_name, form_value))
-        name = form_value.AsCString(dwarf2Data);
-    else if (GetAttributeValue(dwarf2Data, cu, DW_AT_name, form_value))
-        name = form_value.AsCString(dwarf2Data);
-    else if (GetAttributeValue(dwarf2Data, cu, DW_AT_specification, form_value))
+    name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_linkage_name, nullptr);
+    if (name)
+        return name;
+
+    name = GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr);
+    if (name)
+        return name;
+
+    DWARFFormValue form_value;
+    if (GetAttributeValue(dwarf2Data, cu, DW_AT_specification, form_value))
     {
         // The specification DIE may be in another compile unit so we need
         // to get a die and its compile unit.
         DWARFCompileUnitSP cu_sp_ptr;
-        const DWARFDebugInfoEntry* die = const_cast<SymbolFileDWARF*>(dwarf2Data)->DebugInfo()->GetDIEPtr(form_value.Reference(), &cu_sp_ptr);
+        const DWARFDebugInfoEntry* die = dwarf2Data->DebugInfo()->GetDIEPtr(form_value.Reference(), &cu_sp_ptr);
         if (die)
             return die->GetPubname(dwarf2Data, cu_sp_ptr.get());
     }
     return name;
 }
 
 
 //----------------------------------------------------------------------
 // GetName
 //
 // Get value of the DW_AT_name attribute for a debug information entry
 // that exists at offset "die_offset" and place that value into the
 // supplied stream object. If the DIE is a NULL object "NULL" is placed
 // into the stream, and if no DW_AT_name attribute exists for the DIE
 // then nothing is printed.
 //----------------------------------------------------------------------
 bool
 DWARFDebugInfoEntry::GetName
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     const dw_offset_t die_offset,
     Stream &s
 )
 {
     if (dwarf2Data == NULL)
     {
         s.PutCString("NULL");
         return false;
     }
     
     DWARFDebugInfoEntry die;
     lldb::offset_t offset = die_offset;
     if (die.Extract(dwarf2Data, cu, &offset))
     {
         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(dwarf2Data);
-                if (name)
-                {
-                    s.PutCString(name);
-                    return true;
-                }
-            }
-        }
-    }
+            const char* name = die.GetAttributeValueAsString(dwarf2Data, cu, DW_AT_name, nullptr);
     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
 // the supplied stream. This is used to show the name of types given
 // a type identifier.
 //----------------------------------------------------------------------
 bool
 DWARFDebugInfoEntry::AppendTypeName
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     const dw_offset_t die_offset,
     Stream &s
 )
 {
     if (dwarf2Data == NULL)
     {
         s.PutCString("NULL");
         return false;
     }
     
     DWARFDebugInfoEntry die;
     lldb::offset_t offset = die_offset;
     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)

 
 //----------------------------------------------------------------------
 // BuildAddressRangeTable
 //----------------------------------------------------------------------
 void
 DWARFDebugInfoEntry::BuildAddressRangeTable
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     DWARFDebugAranges* debug_aranges
 ) const
 {
     if (m_tag)
     {
         if (m_tag == DW_TAG_subprogram)
         {
             dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;

 // except that the actual DIE offset for the function is placed in the
 // table instead of the compile unit offset (which is the way the
 // standard .debug_aranges section does it).
 //----------------------------------------------------------------------
 void
 DWARFDebugInfoEntry::BuildFunctionAddressRangeTable
 (
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     DWARFDebugAranges* debug_aranges
 ) const
 {
     if (m_tag)
     {
         if (m_tag == DW_TAG_subprogram)
         {
             dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;

 //----------------------------------------------------------------------
 // LookupAddress
 //----------------------------------------------------------------------
 bool
 DWARFDebugInfoEntry::LookupAddress
 (
     const dw_addr_t address,
     SymbolFileDWARF* dwarf2Data,
-    const DWARFCompileUnit* cu,
+    DWARFCompileUnit* cu,
     DWARFDebugInfoEntry** function_die,
     DWARFDebugInfoEntry** block_die
 )
 {
     bool found_address = false;
     if (m_tag)
     {
         bool check_children = false;
//  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))
                     {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 class DWARFDebugRanges;
 class DWARFDeclContext;
 class DWARFDIECollection;
 class DWARFFormValue;
 class SymbolFileDWARFDebugMap;
 
 #define DIE_IS_BEING_PARSED ((lldb_private::Type*)1)
 
+class SymbolFileDWARFDwo;
+
 class SymbolFileDWARF : public lldb_private::SymbolFile, public lldb_private::UserID
 {
 public:
     friend class SymbolFileDWARFDebugMap;
     friend class DebugMapModule;
     friend class DWARFCompileUnit;
     friend class lldb_private::ClangASTContext;
     //------------------------------------------------------------------
//------------------------------------------------------------------
                             ~SymbolFileDWARF() override;
 
     uint32_t        CalculateAbilities () override;
     void            InitializeObject() override;
 
     //------------------------------------------------------------------
     // Compile Unit function calls
     //------------------------------------------------------------------
-    uint32_t        GetNumCompileUnits() override;
-    lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
+    uint32_t                  GetNumCompileUnits() override;
+    lldb::CompUnitSP          ParseCompileUnitAtIndex(uint32_t index) override;
+    virtual lldb::CompUnitSP  ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx);
 
     lldb::LanguageType ParseCompileUnitLanguage (const lldb_private::SymbolContext& sc) override;
     size_t          ParseCompileUnitFunctions (const lldb_private::SymbolContext& sc) override;
     bool            ParseCompileUnitLineTable (const lldb_private::SymbolContext& sc) override;
     bool            ParseCompileUnitSupportFiles (const lldb_private::SymbolContext& sc, lldb_private::FileSpecList& support_files) override;
     bool            ParseImportedModules (const lldb_private::SymbolContext &sc, std::vector<lldb_private::ConstString> &imported_modules) override;
     size_t          ParseFunctionBlocks (const lldb_private::SymbolContext& sc) override;
     size_t          ParseTypes (const lldb_private::SymbolContext& sc) override;
public:
     const DWARFDebugAbbrev* DebugAbbrev() const;
 
     DWARFDebugInfo*         DebugInfo();
     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);
 
     const DWARFDebugInfoEntry *
-    GetDeclContextDIEContainingDIE (const DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die);
+    GetDeclContextDIEContainingDIE (DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die);
 
     lldb_private::Flags&
     GetFlags ()
     {
         return m_flags;
     }
 
     const lldb_private::Flags&
enum
         flagsGotAppleTypesData      = (1 << 14),
         flagsGotAppleNamespacesData = (1 << 15),
         flagsGotAppleObjCData       = (1 << 16)
     };
     
     bool                    NamespaceDeclMatchesThisSymbolFile (const lldb_private::ClangNamespaceDecl *namespace_decl);
 
     DISALLOW_COPY_AND_ASSIGN (SymbolFileDWARF);
-    lldb::CompUnitSP        ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx);
-    DWARFCompileUnit*       GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit);
+    virtual DWARFCompileUnit* GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit);
     DWARFCompileUnit*       GetNextUnparsedDWARFCompileUnit(DWARFCompileUnit* prev_cu);
     bool                    GetFunction (DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry* func_die, lldb_private::SymbolContext& sc);
     lldb_private::Function *        ParseCompileUnitFunction (const lldb_private::SymbolContext& sc, DWARFCompileUnit* dwarf_cu, const DWARFDebugInfoEntry *die);
     size_t                  ParseFunctionBlocks (const lldb_private::SymbolContext& sc,
                                                  lldb_private::Block *parent_block,
                                                  DWARFCompileUnit* dwarf_cu,
                                                  const DWARFDebugInfoEntry *die,
                                                  lldb::addr_t subprogram_low_pc,
protected:
                             
     bool                    ResolveFunction (DWARFCompileUnit *cu,
                                              const DWARFDebugInfoEntry *die,
                                              bool include_inlines,
                                              lldb_private::SymbolContextList& sc_list);
 
     bool                    FunctionDieMatchesPartialName (
                                 const DWARFDebugInfoEntry* die,
-                                const DWARFCompileUnit *dwarf_cu,
+                                DWARFCompileUnit *dwarf_cu,
                                 uint32_t name_type_mask,
                                 const char *partial_name,
                                 const char *base_name_start,
                                 const char *base_name_end);
 
     void                    FindFunctions(
                                 const lldb_private::ConstString &name, 
                                 const NameToDIE &name_to_die,
protected:
     lldb_private::Symbol *  GetObjCClassSymbol (const lldb_private::ConstString &objc_class_name);
 
     void                    ParseFunctions (const DIEArray &die_offsets,
                                             bool include_inlines,
                                             lldb_private::SymbolContextList& sc_list);
     lldb::TypeSP            GetTypeForDIE (DWARFCompileUnit *cu, 
                                            const DWARFDebugInfoEntry* 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;
                             }
protected:
 
     typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, lldb_private::Variable *> GlobalVariableMap;
 
     GlobalVariableMap &
     GetGlobalAranges();
     
     void
     UpdateExternalModuleListIfNeeded();
     
+    void
+    AddDwoSymbolFile(SymbolFileDWARFDwo* dwo_symbol_file)
+    {
+        m_dwo_symbol_files.push_back(dwo_symbol_file);
+    }
+
     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:
     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;
+    std::vector<SymbolFileDWARFDwo*> m_dwo_symbol_files;
 };
 
 #endif  // SymbolFileDWARF_SymbolFileDWARF_h_

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

SymbolFileDWARF::GetTypes (DWARFCompileUnit* cu,
                            const DWARFDebugInfoEntry *die,
                            dw_offset_t min_die_offset,
                            dw_offset_t max_die_offset,
                            uint32_t type_mask,
                            TypeSet &type_set)
 {
     if (cu)
     {
+        assert (cu->GetSymbolFileDWARF() == this);
         if (die)
         {
             const dw_offset_t die_offset = die->GetOffset();
             
             if (die_offset >= max_die_offset)
                 return;
             
             if (die_offset >= min_die_offset)
SymbolFileDWARF::GetTypes (SymbolContextScope *sc_scope,
     if (sc_scope)
         comp_unit = sc_scope->CalculateSymbolContextCompileUnit();
 
     if (comp_unit)
     {
         dwarf_cu = GetDWARFCompileUnit(comp_unit);
         if (dwarf_cu == 0)
             return 0;
+
+        SymbolFileDWARFDwo* dwo_symbol_file = dwarf_cu->GetDwoSymbolFile();
+        if (dwo_symbol_file)
+        {
+            dwarf_cu = dwo_symbol_file->GetCompileUnit();
+            dwo_symbol_file->GetTypes (dwarf_cu,
+                                       dwarf_cu->DIE(),
+                                       0,
+                                       UINT32_MAX,
+                                       type_mask,
+                                       type_set);
+        }
+        else
+        {
             GetTypes (dwarf_cu,
                       dwarf_cu->DIE(),
                       dwarf_cu->GetOffset(),
                       dwarf_cu->GetNextCompileUnitOffset(),
                       type_mask,
                       type_set);
         }
+    }
     else
     {
         DWARFDebugInfo* info = DebugInfo();
         if (info)
         {
             const size_t num_cus = info->GetNumCompileUnits();
             for (size_t cu_idx=0; cu_idx<num_cus; ++cu_idx)
             {
                 dwarf_cu = info->GetCompileUnitAtIndex(cu_idx);
                 if (dwarf_cu)
                 {
+                    SymbolFileDWARFDwo* dwo_symbol_file = dwarf_cu->GetDwoSymbolFile();
+                    if (dwo_symbol_file)
+                    {
+                        dwarf_cu = dwo_symbol_file->GetCompileUnit();
+                        dwo_symbol_file->GetTypes (dwarf_cu,
+                                                   dwarf_cu->DIE(),
+                                                   0,
+                                                   UINT32_MAX,
+                                                   type_mask,
+                                                   type_set);
+                    }
+                    else
+                    {
                         GetTypes (dwarf_cu,
                                   dwarf_cu->DIE(),
                                   0,
                                   UINT32_MAX,
                                   type_mask,
                                   type_set);
                     }
                 }
             }
         }
+    }
 //    if (m_using_apple_tables)
 //    {
 //        DWARFMappedHash::MemoryTable *apple_types = m_apple_types_ap.get();
 //        if (apple_types)
 //        {
 //            apple_types->ForEach([this, &type_set, apple_types, type_mask](const DWARFMappedHash::DIEInfoArray &die_info_array) -> bool {
 //
 //                for (auto die_info: die_info_array)
if (dwarf_cu)
                 cu_sp = m_debug_map_symfile->GetCompileUnit(this);
                 dwarf_cu->SetUserData(cu_sp.get());
             }
             else
             {
                 ModuleSP module_sp (m_obj_file->GetModule());
                 if (module_sp)
                 {
-                    const DWARFDebugInfoEntry * cu_die = dwarf_cu->GetCompileUnitDIEOnly ();
+                    const DWARFDebugInfoEntry* cu_die = dwarf_cu->GetCompileUnitDIEOnly ();
                     if (cu_die)
                     {
                         FileSpec cu_file_spec{cu_die->GetName(this, dwarf_cu), false};
                         if (cu_file_spec)
                         {
                             // If we have a full path to the compile unit, we don't need to resolve
                             // the file.  This can be expensive e.g. when the source files are NFS mounted.
                             if (cu_file_spec.IsRelative())
if (dwarf_cu)
                                     (FileSpec &)(*cu_sp) = cu_file_spec;
                                     // Also fix the invalid file spec which was copied from the compile unit.
                                     cu_sp->GetSupportFiles().Replace(0, cu_file_spec);
                                 }
                             }
 
                             dwarf_cu->SetUserData(cu_sp.get());
                             
+                            SymbolFileDWARFDwo* dwo_symbol_file = dwarf_cu->GetDwoSymbolFile();
+                            if (dwo_symbol_file)
+                            {
+                                DWARFCompileUnit* dwo_dwarf_cu = dwo_symbol_file->GetCompileUnit();
+                                dwo_dwarf_cu->SetUserData(cu_sp.get());
+                            }
+                            
                             // Figure out the compile unit index if we weren't given one
                             if (cu_idx == UINT32_MAX)
                                 DebugInfo()->GetCompileUnit(dwarf_cu->GetOffset(), &cu_idx);
                             
                             m_obj_file->GetModule()->GetSymbolVendor()->SetCompileUnitAtIndex(cu_idx, cu_sp);
                         }
                     }
                 }

 size_t
 SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc)
 {
     assert (sc.comp_unit);
     size_t functions_added = 0;
     DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
     if (dwarf_cu)
     {
+        SymbolFileDWARFDwo* dwo_symbol_file = dwarf_cu->GetDwoSymbolFile();
+        if (dwo_symbol_file)
+            return dwo_symbol_file->ParseFunctionBlocks(sc);
+
         DWARFDIECollection function_dies;
         const size_t num_functions = dwarf_cu->AppendDIEsWithTag (DW_TAG_subprogram, function_dies);
         size_t func_idx;
         for (func_idx = 0; func_idx < num_functions; ++func_idx)
         {
             const DWARFDebugInfoEntry *die = function_dies.GetDIEPtrAtIndex(func_idx);
             if (sc.comp_unit->FindFunctionByUID (MakeUserID(die->GetOffset())).get() == NULL)
             {

 
 
 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)
+    if (die == nullptr)
+    {
+        // Ask the child dwo files if any of them know about this type
+        for (SymbolFileDWARFDwo* dwo_symbol_file : m_dwo_symbol_files)
         {
+            if (dwo_symbol_file && dwo_symbol_file->HasForwardDeclForClangType(clang_type))
+                return dwo_symbol_file->CompleteType(clang_type);
+        }
+
         // 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());

 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 DWARFDebugInfoEntry *die = dwarf_cu->GetCompileUnitDIEOnly();
         if (die && die->HasChildren() == false)
         {
if (resolve_scope & (   eSymbolContextCompUnit  |
             {
                 uint32_t cu_idx = DW_INVALID_INDEX;
                 DWARFCompileUnit* dwarf_cu = debug_info->GetCompileUnit(cu_offset, &cu_idx).get();
                 if (dwarf_cu)
                 {
                     sc.comp_unit = GetCompUnitForDWARFCompUnit(dwarf_cu, cu_idx);
                     if (sc.comp_unit)
                     {
+                        SymbolFileDWARFDwo* dwo_symbol_file = dwarf_cu->GetDwoSymbolFile();
+                        if (dwo_symbol_file)
+                            return dwo_symbol_file->ResolveSymbolContext(so_addr, resolve_scope, sc);
+
                         resolved |= eSymbolContextCompUnit;
 
                         bool force_check_line_table = false;
                         if (resolve_scope & (eSymbolContextFunction | eSymbolContextBlock))
                         {
                             DWARFDebugInfoEntry *function_die = NULL;
                             DWARFDebugInfoEntry *block_die = NULL;
                             if (resolve_scope & eSymbolContextBlock)
SymbolFileDWARF::NamespaceDeclMatchesThisSymbolFile (const ClangNamespaceDecl *namespace_decl)
 
     if (log)
         GetObjectFile()->GetModule()->LogMessage(log, "Valid namespace does not match symbol file");
     
     return false;
 }
 
 uint32_t
-SymbolFileDWARF::FindGlobalVariables (const ConstString &name, const lldb_private::ClangNamespaceDecl *namespace_decl, bool append, uint32_t max_matches, VariableList& variables)
+SymbolFileDWARF::FindGlobalVariables (const ConstString &name,
+                                      const lldb_private::ClangNamespaceDecl *namespace_decl,
+                                      bool append,
+                                      uint32_t max_matches,
+                                      VariableList& variables)
 {
     Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
     if (log)
         GetObjectFile()->GetModule()->LogMessage (log,
                                                   "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", namespace_decl=%p, append=%u, max_matches=%u, variables)", 
                                                   name.GetCString(), 
                                                   static_cast<const void*>(namespace_decl),
if (m_using_apple_tables)
         }
     }
     else
     {
         // Index the DWARF if we haven't already
         if (!m_indexed)
             Index ();
 
+        for (SymbolFileDWARFDwo* dwo_symbol_file : m_dwo_symbol_files)
+            dwo_symbol_file->FindGlobalVariables(name,
+                                                 namespace_decl,
+                                                 true /* append */,
+                                                 max_matches,
+                                                 variables);
+
         m_global_index.Find (name, die_offsets);
     }
 
     const size_t num_die_matches = die_offsets.size();
     if (num_die_matches)
     {
         SymbolContext sc;
         sc.module_sp = m_obj_file->GetModule();
if (m_using_apple_tables)
                 DWARFMappedHash::ExtractDIEArray (hash_data_array, die_offsets);
         }
     }
     else
     {
         // Index the DWARF if we haven't already
         if (!m_indexed)
             Index ();
-        
+        for (SymbolFileDWARFDwo* dwo_symbol_file : m_dwo_symbol_files)
+            dwo_symbol_file->FindGlobalVariables(regex,
+                                                 true /* append */,
+                                                 max_matches,
+                                                 variables);
+
         m_global_index.Find (regex, die_offsets);
     }
 
     SymbolContext sc;
     sc.module_sp = m_obj_file->GetModule();
     assert (sc.module_sp);
     
     DWARFCompileUnit* dwarf_cu = NULL;
if (num_matches)
             const dw_offset_t die_offset = die_offsets[i];
             ResolveFunction (die_offset, dwarf_cu, include_inlines, sc_list);
         }
     }
 }
 
 bool
 SymbolFileDWARF::FunctionDieMatchesPartialName (const DWARFDebugInfoEntry* die,
-                                                const DWARFCompileUnit *dwarf_cu,
+                                                DWARFCompileUnit *dwarf_cu,
                                                 uint32_t name_type_mask, 
                                                 const char *partial_name,
                                                 const char *base_name_start,
                                                 const char *base_name_end)
 {
     // If we are looking only for methods, throw away all the ones that are or aren't in C++ classes:
     if (name_type_mask == eFunctionNameTypeMethod || name_type_mask == eFunctionNameTypeBase)
     {
else
             }
             die_offsets.clear();
         }
 
         if ((name_type_mask & eFunctionNameTypeSelector) && (!namespace_decl || !*namespace_decl))
         {
             FindFunctions (name, m_function_selector_index, include_inlines, sc_list);
         }
-        
+        for (SymbolFileDWARFDwo* dwo_symbol_file : m_dwo_symbol_files)
+            dwo_symbol_file->FindFunctions(name,
+                                           namespace_decl,
+                                           name_type_mask,
+                                           include_inlines,
+                                           true /* append */,
+                                           sc_list);
     }
 
     // Return the number of variable that were appended to the list
     const uint32_t num_matches = sc_list.GetSize() - original_size;
     
     if (log && num_matches > 0)
     {
         GetObjectFile()->GetModule()->LogMessage (log,
SymbolFileDWARF::FindFunctions(const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list)
     
     if (log)
     {
         GetObjectFile()->GetModule()->LogMessage (log,
                                                   "SymbolFileDWARF::FindFunctions (regex=\"%s\", append=%u, sc_list)", 
                                                   regex.GetText(), 
                                                   append);
     }
-    
+    DWARFDebugInfo* info = DebugInfo();
+    if (info == nullptr)
+        return 0;
 
     // If we aren't appending the results to this list, then clear the list
     if (!append)
         sc_list.Clear();
 
     // 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 = sc_list.GetSize();
 
     if (m_using_apple_tables)
     {
         if (m_apple_names_ap.get())
             FindFunctions (regex, *m_apple_names_ap, include_inlines, sc_list);
     }
     else
     {
         // Index the DWARF if we haven't already
         if (!m_indexed)
             Index ();
 
         FindFunctions (regex, m_function_basename_index, include_inlines, sc_list);
 
         FindFunctions (regex, m_function_fullname_index, include_inlines, sc_list);
+
+        for (SymbolFileDWARFDwo* dwo_symbol_file : m_dwo_symbol_files)
+            dwo_symbol_file->FindFunctions(regex, include_inlines, true, sc_list);
     }
 
     // Return the number of variable that were appended to the list
     return sc_list.GetSize() - original_size;
 }
 
 uint32_t
 SymbolFileDWARF::FindTypes (const SymbolContext& sc, 
if (log)
                                                       "SymbolFileDWARF::FindTypes (sc, name=\"%s\", clang::NamespaceDecl(NULL), append=%u, max_matches=%u, type_list)",
                                                       name.GetCString(), append,
                                                       max_matches);
     }
 
     // If we aren't appending the results to this list, then clear the list
     if (!append)
         types.Clear();
+    const uint32_t initial_types_size = types.GetSize();
 
     if (!NamespaceDeclMatchesThisSymbolFile(namespace_decl))
         return 0;
 
     DIEArray die_offsets;
 
     if (m_using_apple_tables)
     {
         if (m_apple_types_ap.get())
         {
             const char *name_cstr = name.GetCString();
             m_apple_types_ap->FindByName (name_cstr, die_offsets);
         }
     }
     else
     {
         if (!m_indexed)
             Index ();
 
         m_type_index.Find (name, die_offsets);
+
+        for (SymbolFileDWARFDwo* dwo_symbol_file : m_dwo_symbol_files)
+            dwo_symbol_file->FindTypes(sc,
+                                       name,
+                                       namespace_decl,
+                                       true /* append */,
+                                       max_matches,
+                                       types);
     }
 
     const size_t num_die_matches = die_offsets.size();
 
     if (num_die_matches)
     {
-        const uint32_t initial_types_size = types.GetSize();
         DWARFCompileUnit* dwarf_cu = NULL;
         const DWARFDebugInfoEntry* die = NULL;
         DWARFDebugInfo* debug_info = DebugInfo();
         for (size_t i=0; i<num_die_matches; ++i)
         {
             const dw_offset_t die_offset = die_offsets[i];
             die = debug_info->GetDIEPtrWithCompileUnitHint (die_offset, &dwarf_cu);
 
if (num_die_matches)
                 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());
                 }
             }            
 
         }
-        const uint32_t num_matches = types.GetSize() - initial_types_size;
-        if (log && num_matches)
-        {
-            if (namespace_decl)
-            {
-                GetObjectFile()->GetModule()->LogMessage (log,
-                                                          "SymbolFileDWARF::FindTypes (sc, name=\"%s\", clang::NamespaceDecl(%p) \"%s\", append=%u, max_matches=%u, type_list) => %u", 
-                                                          name.GetCString(),
-                                                          static_cast<void*>(namespace_decl->GetNamespaceDecl()),
-                                                          namespace_decl->GetQualifiedName().c_str(),
-                                                          append, max_matches,
-                                                          num_matches);
-            }
-            else
-            {
-                GetObjectFile()->GetModule()->LogMessage (log,
-                                                          "SymbolFileDWARF::FindTypes (sc, name=\"%s\", clang::NamespaceDecl(NULL), append=%u, max_matches=%u, type_list) => %u",
-                                                          name.GetCString(), 
-                                                          append, max_matches,
-                                                          num_matches);
-            }
-        }
-        return num_matches;
-    }
-    return 0;
-}
+    }
+
 
 
 ClangNamespaceDecl
 SymbolFileDWARF::FindNamespace (const SymbolContext& sc, 
                                 const ConstString &name,
                                 const lldb_private::ClangNamespaceDecl *parent_namespace_decl)
 {
     Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
if (info)
                 m_apple_namespaces_ap->FindByName (name_cstr, die_offsets);
             }
         }
         else
         {
             if (!m_indexed)
                 Index ();
 
+            for (SymbolFileDWARFDwo* dwo_symbol_file : m_dwo_symbol_files)
+            {
+                namespace_decl = dwo_symbol_file->FindNamespace(sc, name, parent_namespace_decl);
+                if (namespace_decl)
+                    return namespace_decl;
+            }
+
             m_namespace_index.Find (name, die_offsets);
         }
         
         DWARFCompileUnit* dwarf_cu = NULL;
         const DWARFDebugInfoEntry* die = NULL;
         const size_t num_matches = die_offsets.size();
         if (num_matches)
         {
if (log && namespace_decl.GetNamespaceDecl())
                                                   name.GetCString(),
                                                   static_cast<const void*>(namespace_decl.GetNamespaceDecl()),
                                                   namespace_decl.GetQualifiedName().c_str());
     }
 
     return namespace_decl;
 }
 
-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 (DWARFCompileUnit *dwarf_cu, const DWARFDebugInfoEntry* die)
 {
     TypeSP type_sp;
     if (die != NULL)
     {
         assert(dwarf_cu != NULL);
         Type *type_ptr = m_die_to_type.lookup (die);
if (die != NULL)
         }
 
     }
     return type_sp;
 }
 
 
 const DWARFDebugInfoEntry *
-SymbolFileDWARF::GetDeclContextDIEContainingDIE (const DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die)
+SymbolFileDWARF::GetDeclContextDIEContainingDIE (DWARFCompileUnit *cu, const DWARFDebugInfoEntry *die)
 {
     if (cu && die)
     {
         const DWARFDebugInfoEntry * const decl_die = die;
     
         while (die != NULL)
         {
             // If this is the original DIE that we are searching for a declaration 
if (dwarf_decl_ctx_count > 0)
                         m_apple_types_ap->FindByName (type_name.GetCString(), die_offsets);
                     }
                 }
             }
             else
             {
                 if (!m_indexed)
                     Index ();
-                
+                for (SymbolFileDWARFDwo* dwo_symbol_file : m_dwo_symbol_files)
+                {
+                    type_sp = dwo_symbol_file->FindDefinitionTypeForDWARFDeclContext(dwarf_decl_ctx);
+                    if (type_sp)
+                        return type_sp;
+                }
+                
                 m_type_index.Find (type_name, die_offsets);
             }
             
             const size_t num_matches = die_offsets.size();
             
             
             DWARFCompileUnit* type_cu = NULL;
             const DWARFDebugInfoEntry* type_die = NULL;

 size_t
 SymbolFileDWARF::ParseFunctionBlocks (const SymbolContext &sc)
 {
     assert(sc.comp_unit && sc.function);
     size_t functions_added = 0;
     DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
     if (dwarf_cu)
     {
+        SymbolFileDWARFDwo* dwo_symbol_file = dwarf_cu->GetDwoSymbolFile();
+        if (dwo_symbol_file)
+            return dwo_symbol_file->ParseFunctionBlocks(sc);
+
         dw_offset_t function_die_offset = sc.function->GetID();
         const DWARFDebugInfoEntry *function_die = dwarf_cu->GetDIEPtr(function_die_offset);
         if (function_die)
         {
             ParseFunctionBlocks(sc, &sc.function->GetBlock (false), dwarf_cu, function_die, LLDB_INVALID_ADDRESS, 0);
         }
     }
 
     return functions_added;
 }
 
 
 size_t
 SymbolFileDWARF::ParseTypes (const SymbolContext &sc)
 {
     // At least a compile unit must be valid
     assert(sc.comp_unit);
     size_t types_added = 0;
     DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
     if (dwarf_cu)
     {
+        SymbolFileDWARFDwo* dwo_symbol_file = dwarf_cu->GetDwoSymbolFile();
+        if (dwo_symbol_file)
+            return dwo_symbol_file->ParseTypes(sc);
+        
         if (sc.function)
         {
             dw_offset_t function_die_offset = sc.function->GetID();
             const DWARFDebugInfoEntry *func_die = dwarf_cu->GetDIEPtr(function_die_offset);
             if (func_die && func_die->HasChildren())
             {
                 types_added = ParseTypes(sc, dwarf_cu, func_die->GetFirstChild(), true, true);
             }
SymbolFileDWARF::ParseVariablesForContext (const SymbolContext& sc)
     if (sc.comp_unit != NULL)
     {
         DWARFDebugInfo* info = DebugInfo();
         if (info == NULL)
             return 0;
         
         if (sc.function)
         {
-            DWARFCompileUnit* dwarf_cu = info->GetCompileUnitContainingDIE(sc.function->GetID()).get();
-            
-            if (dwarf_cu == NULL)
+            DWARFCompileUnit* dwarf_cu = GetDWARFCompileUnit(sc.function->GetCompileUnit());
+            if (dwarf_cu == nullptr)
                 return 0;
-            
-            const DWARFDebugInfoEntry *function_die = dwarf_cu->GetDIEPtr(sc.function->GetID());
-            
-            dw_addr_t func_lo_pc = function_die->GetAttributeValueAsUnsigned (this, dwarf_cu, DW_AT_low_pc, LLDB_INVALID_ADDRESS);
+            SymbolFileDWARFDwo* dwo_symbol_file = dwarf_cu->GetDwoSymbolFile();
+            if (dwo_symbol_file)
+                return dwo_symbol_file->ParseVariablesForContext (sc);
+            const DWARFDebugInfoEntry *function_die = dwarf_cu->GetDIEPtr(sc.function->GetID());
+            dw_addr_t func_lo_pc = function_die->GetAttributeValueAsAddress (this, dwarf_cu, DW_AT_low_pc, LLDB_INVALID_ADDRESS);
             if (func_lo_pc != LLDB_INVALID_ADDRESS)
             {
                 const size_t num_variables = ParseVariables(sc, dwarf_cu, func_lo_pc, function_die->GetFirstChild(), true, true);
             
                 // Let all blocks know they have parse all their variables
                 sc.function->GetBlock (false).SetDidParseVariables (true, true);
                 return num_variables;
             }
         }
         else if (sc.comp_unit)
         {
             DWARFCompileUnit* dwarf_cu = info->GetCompileUnit(sc.comp_unit->GetID()).get();
 
-            if (dwarf_cu == NULL)
+            if (dwarf_cu == nullptr)
                 return 0;
             
+            SymbolFileDWARFDwo* dwo_symbol_file = dwarf_cu->GetDwoSymbolFile();
+            if (dwo_symbol_file)
+                return dwo_symbol_file->ParseVariablesForContext (sc);
+
             uint32_t vars_added = 0;
             VariableListSP variables (sc.comp_unit->GetVariableList(false));
             
             if (variables.get() == NULL)
             {
                 variables.reset(new VariableList());
                 sc.comp_unit->SetVariableList(variables);
 

 SymbolFileDWARF::ParseVariableDIE
 (
     const SymbolContext& sc,
     DWARFCompileUnit* dwarf_cu,
     const DWARFDebugInfoEntry *die,
     const lldb::addr_t func_low_pc
 )
 {
     VariableSP var_sp (m_die_to_variable_sp[die]);
     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))
     {
         DWARFDebugInfoEntry::Attributes attributes;
         const size_t num_attributes = die->GetAttributes(this,
                                                          dwarf_cu,
                                                          DWARFFormValue::FixedFormSizes(),
                                                          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;
             DWARFExpression location(dwarf_cu);
             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;
 

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_private::ObjectFile* 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:
+    DWARFCompileUnit* m_base_dwarf_cu;
+};
+
+#endif  // SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_

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(ObjectFile* objfile, DWARFCompileUnit* dwarf_cu) :
+    SymbolFileDWARF(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();
+}

source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.h

operator= (const UniqueDWARFASTType &rhs)
             m_declaration = rhs.m_declaration;
             m_byte_size = rhs.m_byte_size;
         }
         return *this;
     }
 
     lldb::TypeSP m_type_sp;
     SymbolFileDWARF *m_symfile;
-    const DWARFCompileUnit *m_cu;
+    DWARFCompileUnit *m_cu;
     const DWARFDebugInfoEntry *m_die;
     lldb_private::Declaration m_declaration;
     int32_t m_byte_size;
 };
 
 class UniqueDWARFASTTypeList
 {
 public:
public:
     void
     Append (const UniqueDWARFASTType &entry)
     {
         m_collection.push_back (entry);
     }
     
     bool
     Find (SymbolFileDWARF *symfile,
-          const DWARFCompileUnit *cu,
+          DWARFCompileUnit *cu,
           const DWARFDebugInfoEntry *die, 
           const lldb_private::Declaration &decl,
           const int32_t byte_size,
           UniqueDWARFASTType &entry) const;
     
 protected:
     typedef std::vector<UniqueDWARFASTType> collection;
     collection m_collection;
Insert (const lldb_private::ConstString &name,
             const UniqueDWARFASTType &entry)
     {
         m_collection[name.GetCString()].Append (entry);
     }
 
     bool
     Find (const lldb_private::ConstString &name, 
           SymbolFileDWARF *symfile,
-          const DWARFCompileUnit *cu,
+          DWARFCompileUnit *cu,
           const DWARFDebugInfoEntry *die, 
           const lldb_private::Declaration &decl,
           const int32_t byte_size,
           UniqueDWARFASTType &entry) const
     {
         const char *unique_name_cstr = name.GetCString();
         collection::const_iterator pos = m_collection.find (unique_name_cstr);
         if (pos != m_collection.end())

source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.cpp

 #include "lldb/Symbol/Declaration.h"
 
 #include "DWARFDebugInfoEntry.h"
 
 bool
 UniqueDWARFASTTypeList::Find 
 (
     SymbolFileDWARF *symfile,
-    const DWARFCompileUnit *cu,
+    DWARFCompileUnit *cu,
     const DWARFDebugInfoEntry *die, 
     const lldb_private::Declaration &decl,
     const int32_t byte_size,
     UniqueDWARFASTType &entry
 ) const
 {
     collection::const_iterator pos, end = m_collection.end();
     for (pos = m_collection.begin(); pos != end; ++pos)

source/Symbol/ObjectFile.cpp

if (module_sp)
         if (log)
             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();
 }