Be lazier about loading .dwo files

[Eric]

Summary

This change makes sure that DwarfUnit does not load a .dwo file until necessary. I also take advantage of DWARF 5's guarantee that the first support file is also the primary file to make it possible to create a compile unit without loading the .dwo file.

[Eric]

Removing header files to make clang-tidy happy

[Eric]

Not sure what's going on with clang-tidy, but those headers still exist and in any case I didn't add them.

Change is ready for review.

[Eric]

Let me know if I should request this review from someone else. It is important for scalability, as this change, in combination with my follow-up change (https://reviews.llvm.org/D100771) eliminate the need to load all .dwo files in the most common debugging scenarios.

Thanks,

• Eric

[Eric]

Can I get a review on this please?

[Eric]

Ping on this

[dblaikie]

yeah, might need to track down folks who have some context here (I'm not sure who added the initial support for Split DWARF to lldb, for instance - but if they're still around/involved in the project, they'd probably be a reasonable reviewer) - maybe reaching out to them via email off-list (sometimes peoples email filters mean reviews/list mail can be hard to spot) or via chat mediums, etc.

[Eric]

Jan or Tamas, can either of you take a look?

[jankratochvil]

I do not see any functionality flaw in this patch, thanks. I just wrote down many coding style improvements.

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

74

Despite LLDB contains this style I got confirmed it is preferred to reduce the indentation.

352–353

No longer needed.

361–362

719

GetIsOptimized should now call GetLazyIsOptimized.

720

Just to reduce the indentation.

722

Just reduce the indentation.

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

318–319

336

(I am not a native English speaker but) could not it use some more obvious name such as s/ensured/loaded/ or s/ensured/searched/?

337

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

752

But that is not a topic of this patch so not required, it would need new rvalue SetSupportFiles implementation.

756

The two blocks of code:

+          if (ParseSupportFiles(dwarf_cu, module_sp, support_files) &&
+               support_files.GetSize() > 0) { ... }
+         if (need_non_skeleton) { ... }

could be put into a function (or lambda).

1029

I do not see how this is related to this patch. Isn't it a separate bugfix? I haven't tried it on OSX and this function is Apple-specific. I understand it is probably correct+needed but it should be at least moved to a different patch/review.

[jankratochvil]

This whole optimization should also have a testcase, it should be easy (tried it using log enable lldb object for a file built with -gdwarf-5 -gsplit-dwarf -gpubnames).

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

1029

I do not think it is needed here because it gets called by SymbolFileDWARF::ParseCompileUnit:

-> 745 	            bool is_optimized = dwarf_cu.GetNonSkeletonUnit().GetIsOptimized();

It also works fine for a file built with: clang -glldb -gsplit-dwarf -O3
For such change there should be a testcase.
Maybe there could rather be:

lldbassert(!m_dwo);

[Eric]

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

719

Done. I believe this preserves existing behavior regarding changes to m_is_optimized, though I'm not sure if that's desired.

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

336

Hope this is clearer!

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

752

It's a good idea, though -- copying the SupportFiles involves revalidating all the paths.

756

Why would this help?

1029

With my change, we may call GetLazyIsOptimized(), which may result in creating a CompileUnit where is_optimized is eLazyBoolCalculate, resulting in it being parsed on demand. Previously we always eagerly evaluated is_optimized when constructing the CompileUnit, meaning that this function was effectively dead code and also incorrect as far as I could tell.

[jankratochvil]

In D100299#2873864, @jankratochvil wrote:

This whole optimization should also have a testcase, it should be easy (tried it using log enable lldb object for a file built with -gdwarf-5 -gsplit-dwarf -gpubnames).

I haven't found you would write one. Wrote one as split-lazy-load.s: https://people.redhat.com/jkratoch/D100299-tests.patch

The testcases would be nice to review, maybe @dblaikie?

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

715

clang-format is right, please use it: clang/tools/clang-format/git-clang-format

719

GetIsOptimized is in SB API so the behavior should be preserved.

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

756

Less code duplication? Less lines of code? You don't like such change (the diff is after git-clang-format)?

1029

OK, I get it now. Thanks for the explanation, I made a test mistake before myself.
But that is definitely worth a testcase. Created one as split-optimized.s: https://people.redhat.com/jkratoch/D100299-tests.patch

lldb/source/Symbol/CompileUnit.cpp

184–185

A named rvalue reference is an lvalue. It would have no effect this way.
It should be a separate [nfc] patch.

[dblaikie]

In D100299#2884145, @jankratochvil wrote:

In D100299#2873864, @jankratochvil wrote:

This whole optimization should also have a testcase, it should be easy (tried it using log enable lldb object for a file built with -gdwarf-5 -gsplit-dwarf -gpubnames).

I haven't found you would write one. Wrote one as split-lazy-load.s: https://people.redhat.com/jkratoch/D100299-tests.patch

The testcases would be nice to review, maybe @dblaikie?

I'm not especilaly familiar with lldb testing, but happy to take a look - any particular aspects you'd like me to consider?

[jankratochvil]

In D100299#2884171, @dblaikie wrote:

I'm not especilaly familiar with lldb testing, but happy to take a look - any particular aspects you'd like me to consider?

• split-lazy-load.test is arch-independent but when I use %clang I have to use some specific --target:

error: unknown target triple 'specify-a-target-or-use-a-_host-substitution', please use -triple or -arch

So I used Linux-X86 but that is sure not perfect.

• For split-optimized.s I would not need the assembly as one can build such file just with clang -gdwarf-5 -glldb -gsplit-dwarf=single -O3. But then I am concerned the clang output will change in the future possibly no longer really testing what it should (such as future clang may include DW_AT_APPLE_optimized even into the skeleton for example). So whether the is an agreement an assembly snapshot is appropriate in such case.

[dblaikie]

In D100299#2884234, @jankratochvil wrote:

In D100299#2884171, @dblaikie wrote:

I'm not especilaly familiar with lldb testing, but happy to take a look - any particular aspects you'd like me to consider?

• split-lazy-load.test is arch-independent but when I use %clang I have to use some specific --target:

error: unknown target triple 'specify-a-target-or-use-a-_host-substitution', please use -triple or -arch

How are other lldb tests written in this regard, and especially other tests for Split DWARF? I'm not sure how portable Split DWARF emission is with different object formats (like COFF and MachO) - so it may be that the test isn't portable? (checking how other tests for Split DWARF work might give some sense of how to write them to be as portable as is appropriate, etc)

So I used Linux-X86 but that is sure not perfect.

• For split-optimized.s I would not need the assembly as one can build such file just with clang -gdwarf-5 -glldb -gsplit-dwarf=single -O3. But then I am concerned the clang output will change in the future possibly no longer really testing what it should (such as future clang may include DW_AT_APPLE_optimized even into the skeleton for example). So whether the is an agreement an assembly snapshot is appropriate in such case.

Since the lldb tests sort of act as a convenient place for end-to-end debugging testing, I think (but I don't know, I'm not an lldb developer) the preference is towards source based tests - if there's properties that could throw things off significantly, you could add some validation that the properties are interesting. Such as using llvm-dwarfdump to confirm that DW_AT_APPLE_optimized is not present on the skeleton. (though, side question: if it'd be reasonable/useful to have that on the skeleton & that'd help address some of the issues this review is trying to address, we could do that? It wouldn't be expensive to put that on the skeleton if it really helps).

[jankratochvil]

In D100299#2884251, @dblaikie wrote:

How are other lldb tests written in this regard, and especially other tests for Split DWARF?

Sorry,there is %clangxx_host, I even remember it now.

Since the lldb tests sort of act as a convenient place for end-to-end debugging testing, I think (but I don't know, I'm not an lldb developer) the preference is towards source based tests - if there's properties that could throw things off significantly, you could add some validation that the properties are interesting. Such as using llvm-dwarfdump to confirm that DW_AT_APPLE_optimized is not present on the skeleton.

OK, done in: D106194

(though, side question: if it'd be reasonable/useful to have that on the skeleton & that'd help address some of the issues this review is trying to address, we could do that? It wouldn't be expensive to put that on the skeleton if it really helps).

That would violate DWARF-5 3.1.2 Skeleton Compilation Unit Entries (page 67 line 30). I do not think it is needed just that it could happen accidentally or not disabling this testcase. But it is protected now by that llvm-dwarfdump you suggested.

[dblaikie]

In D100299#2884603, @jankratochvil wrote:

In D100299#2884251, @dblaikie wrote:

How are other lldb tests written in this regard, and especially other tests for Split DWARF?

Sorry,there is %clangxx_host, I even remember it now.

Since the lldb tests sort of act as a convenient place for end-to-end debugging testing, I think (but I don't know, I'm not an lldb developer) the preference is towards source based tests - if there's properties that could throw things off significantly, you could add some validation that the properties are interesting. Such as using llvm-dwarfdump to confirm that DW_AT_APPLE_optimized is not present on the skeleton.

OK, done in: D106194

Looks plausible, with the previous caveat that I'm not especially familiar with lldb testing.

(though, side question: if it'd be reasonable/useful to have that on the skeleton & that'd help address some of the issues this review is trying to address, we could do that? It wouldn't be expensive to put that on the skeleton if it really helps).

That would violate DWARF-5 3.1.2 Skeleton Compilation Unit Entries (page 67 line 30). I do not think it is needed just that it could happen accidentally or not disabling this testcase. But it is protected now by that llvm-dwarfdump you suggested.

Yeah... but if there's good reason to put it there I wouldn't mind violating the spec/filing a DWARF feature request, etc.

What's the optimized property used for? This patch currently looks like it "lies" if the query is made too early (before something else has forced the DWO to be loaded), right? That seems a bit concerning to me (not giving a consistent view of the property - subtly changing the answer to the query based on other dwarf loading (that's like when gdb has index issues - and will fail to lookup a name until you happen to do something related to teh CU that name is in, then the lookup works... ). Should the query instead return something else indicating that the answer isn't known? (or assert that the query shouldn't be made until the DWO has been loaded?)

[jankratochvil]

In D100299#2885454, @dblaikie wrote:

What's the optimized property used for?

Just to print a warning.

This patch currently looks like it "lies" if the query is made too early (before something else has forced the DWO to be loaded), right?

Not in practice as the DWARFUnit::GetIsOptimized() will be called only for a function in CompileUnit which means GetNonSkeletonUnit() had to be loaded already. For the case there happens some other new caller of DWARFUnit::GetIsOptimized() it could be safer to add to DWARFUnit::GetIsOptimized() :

lldbassert(!m_dwo);

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

101

We know that m_addr_base is not unset therefore use the address (I have also suggested to preserve the original SetAddrBase prototype).

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

160

Setting empty addr_base is not useful, no need to complicate it.

[dblaikie]

In D100299#2885712, @jankratochvil wrote:

In D100299#2885454, @dblaikie wrote:

What's the optimized property used for?

Just to print a warning.

This patch currently looks like it "lies" if the query is made too early (before something else has forced the DWO to be loaded), right?

Not in practice as the DWARFUnit::GetIsOptimized() will be called only for a function in CompileUnit which means GetNonSkeletonUnit() had to be loaded already. For the case there happens some other new caller of DWARFUnit::GetIsOptimized() it could be safer to add to DWARFUnit::GetIsOptimized() :

lldbassert(!m_dwo);

Not sure I follow that second sentence - but if the first sentence is true, then could GetIsOptimized be changed so that this test (GetLazyIsOptimized() == eLazyBoolCalculate && GetUnitDIEPtrOnly()) is asserted (well, the inverse? Not sure) rather than conditional? (ie: There's an expectation that the value is always calculated by the time this is called, so if it's called without it being calculated, that means there's a bug in lldb, right?)

[jankratochvil]

In D100299#2885741, @dblaikie wrote:

could GetIsOptimized be changed so that this test (GetLazyIsOptimized() == eLazyBoolCalculate && GetUnitDIEPtrOnly()) is asserted (well, the inverse? Not sure) rather than conditional?

Not really as GetIsOptimized call with (GetLazyIsOptimized() == eLazyBoolCalculate && GetUnitDIEPtrOnly()) happens in the case of

• either non-split DWARF with missing DW_AT_APPLE_optimized
• or DWO parsing with missing DW_AT_APPLE_optimized

GetLazyIsOptimized() has to return eLazyBoolCalculate so that it can be called from SymbolFileDWARF::ParseCompileUnit also for skeleton parsing where it needs to delay the decision until DWO is loaded.

(ie: There's an expectation that the value is always calculated by the time this is called, so if it's called without it being calculated, that means there's a bug in lldb, right?)

There are two reasons why it may not be possible to calculate it:

• We are parsing skeleton but DW_AT_APPLE_optimized is in DWO which is not loaded yet.
• DW_AT_APPLE_optimized is missing (either in the non-split unit or in DWO itself).
• (ignoring here a third reason of corrupted unparseable DWARF)

In the former case we have to defer the decision until DWO is loaded. In the latter case we have to recognize eLazyBoolCalculate as it is eLazyBoolNo (the default assumption for the case missing DW_AT_APPLE_optimized).

In D100299#2885712, @jankratochvil wrote:

For the case there happens some other new caller of DWARFUnit::GetIsOptimized() it could be safer to add to DWARFUnit::GetIsOptimized() :

lldbassert(!m_dwo);

Not sure I follow that second sentence

I was proposing to make it safe against future changes of LLDB where someone could start to call DWARFUnit::GetIsOptimized() for a skeleton DWARFUnit before its CompileUnit gets created (and therefore its DWO would still not be loaded).

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

715–716

719

[dblaikie]

I'm confused. I thought in https://reviews.llvm.org/D100299#2885712 it was said that GetIsOptimized would not be called until the value had been loaded (if present in the DWARF). But then in the last comment it suggests it may be?

But also I'm confused why if the attribute isn't present in DWARF that the query would observe the "uninitialized/calculate" state - shouldn't the attribute not being present, once the attribute has been looked for, result in a known value rather than the uninitialized state? Or do you mean there's really 4 states: optimized, unoptimized, attribute not present, attribute not checked for yet/don't know if the attribute is present?

Perhaps we could use those 4 states then, and assert that the value isn't in the 4th state whenever GetIsOptimized is called? That way we can be sure that the unloaded state is never observed?

[jankratochvil]

Leaving the rewrite of the optimization flag getter up to @Eric, I could do it otherwise.

[Eric]

Thanks for your feedback. I was off for a long weekend but will finish fixing up this change tomorrow.

On the question of the property accessor, the difference between the two is that GetIsOptimized is always called on the non-skeleton unit, so it gives a final answer, whereas GetLazyIsOptimized is called by code intended not to trigger loading the non-skeleton unit, so it may not have the answer, and then the property accessor on the CompileUnit will trigger the code path to get it from the non-skeleton unit.

A side effect of this change as currently written is that if some compiler doesn't follow the spec and puts the DW_AT_APPLE_optimized tag (or the language for that matter) in the skeleton unit, not only will we use it but it will override the non-skeleton unit. I wanted to provide this information eagerly when possible but now I'm thinking it would be better to not do this and instead leave the accessors on DwarfUnit unchanged and initialize the compile unit without these, only computing them on demand.

The downside of making the language computed on demand is that the CompileUnit::Dump() method does not trigger on-demand computation and so lldb will actually print language = "unknown" if you run an image lookup command. I discovered early that switching these to be always computed on demand triggered test failures for this reason, so I made the change to get both of these properties eagerly when possible. However this is entirely unnecessary for the optimized flag as Dump doesn't print that. The remaining question is what we want the behavior to be for the language. I'm only changing DWARF5 behavior, and no tests currently do a dump on dwarf 5 symbols. The question is should I always compute on demand, resulting in the language being unknown until the user does something that causes a call to CompileUnit::GetLanguage() (like evaluating an expression), or do I try to make it eager when possible as in the current iteration of this change?

[dblaikie]

Sorry, I'm really not following well - this might just be too far out of my depth. I'm trying to distill my general concern to make it comprehensible/clear...

If this patch introduces a case where doing some relatively unrelated debugging activity (such as stepping into a function, etc) to cause some other operation to behave differently (going from language "unknown" to the correct language - to go from missing the "this thing might've been optimized, so will be harder to debug" to having that message) that would be a bad thing from a usability perspective. Whatever operations need to be done non-lazily to ensure that answers are consistent is probably worth doing.

(at the code level: a function that returns the same value for "this hasn't been loaded yet" as "this has been loaded, but the value wasn't present in the loaded data" seems really likely to cause this ^ problem - an early call gets the first answer, thinks it means "the value wasn't present" (& renders that to the user) and then later something causes the data to be loaded and it turns otu the value was present and now the user gets a different message when executing the same operation)

[Eric]

Updated and hopefully a little simpler now.

The optimized flag is always parsed on demand so there's no concern there and no need for the previous complication. Any call to CompileUnit::GetLanguage() will parse this on demand, but calls to ::Dump() cannot do this as it is a constant method. In my own testing I find that simply hitting a breakpoint is sufficient to get the language to be evaluated, so I don't think users will be seeing much language = "unknown" in practice.

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

715–716

Change undone

lldb/source/Symbol/CompileUnit.cpp

184–185

Removing, to be added in separate patch

[dblaikie]

In D100299#2900389, @Eric wrote:

Updated and hopefully a little simpler now.

The optimized flag is always parsed on demand so there's no concern there and no need for the previous complication. Any call to CompileUnit::GetLanguage() will parse this on demand, but calls to ::Dump() cannot do this as it is a constant method.

So dump always passes a the skeleton unit to "GetLanguage" or it already makes a dynamic choice based on whether or not the dwo has already been loaded?

I'd still be a bit concerned if the way "language" is rendered is the dump is indistinguishable between "dwo hasn't been loaded" and "there is no language specified in the full (split or non-split) unit" - while dump probably isn't the most important feature for end users, it may be important for lldb developers - if they get confused/mislead that the "language" is not present/can't be parsed, rather than the dwo hasn't been loaded, that might result in some frustration/waste of time. It'd be good/important to render those different states differently.

In my own testing I find that simply hitting a breakpoint is sufficient to get the language to be evaluated, so I don't think users will be seeing much language = "unknown" in practice.

[jankratochvil]

In D100299#2901372, @dblaikie wrote:

So dump always passes a the skeleton unit to "GetLanguage" or it already makes a dynamic choice based on whether or not the dwo has already been loaded?

GetLanguage has now a bug for -gsplit-dwarf as it will return eLanguageTypeUnknown if called on the skeleton - which could affect ManualDWARFIndex::IndexUnitImpl but then it is using LanguageType cu_language only for cu_language == eLanguageTypeObjC. Which is needed only on OSX and OSX does not have -gsplit-dwarf. GetLanguage should IMO force loading of the DWO.

I'd still be a bit concerned if the way "language" is rendered is the dump is indistinguishable between "dwo hasn't been loaded" and "there is no language specified in the full (split or non-split) unit"

Do you talk about CompileUnit::Dump? CompileUnit always has DWO already loaded.

(lldb) target modules dump symfile
...
Compile units:
0x9ef030: CompileUnit{0x00000000}, language = "c99", file = '/home/jkratoch/t/main.c'
                                               ^^^

There is also DWARFCompileUnit::Dump but that does not print the language.

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-lazy-dwo.cpp

6 ↗

(On Diff #361230)

Why have you removed %clangxx_host I was using in D106194? (I could use probably %clang_host instead.)
If it is x86_64-linux dependent then you need also:

// REQUIRES: target-x86_64, system-linux, native

But the x86 dependency is hopefully not needed.

lldb/test/Shell/SymbolFile/DWARF/x86/split-optimized.cpp

1 ↗

(On Diff #361230)

%clang_host?

[dblaikie]

In D100299#2904141, @jankratochvil wrote:

In D100299#2901372, @dblaikie wrote:

So dump always passes a the skeleton unit to "GetLanguage" or it already makes a dynamic choice based on whether or not the dwo has already been loaded?

GetLanguage has now a bug for -gsplit-dwarf as it will return eLanguageTypeUnknown if called on the skeleton - which could affect ManualDWARFIndex::IndexUnitImpl but then it is using LanguageType cu_language only for cu_language == eLanguageTypeObjC. Which is needed only on OSX and OSX does not have -gsplit-dwarf. GetLanguage should IMO force loading of the DWO.

Ah - yeah, I could see that particular thing either way (it gives a correct local answer, but probably not the answer someone wants). Yeah - maybe just assert(false) on getLanguage on a skeleton unit (or it should always load the DWO and delegate to it, as you say) - I'd be happy with either way.

I'd still be a bit concerned if the way "language" is rendered is the dump is indistinguishable between "dwo hasn't been loaded" and "there is no language specified in the full (split or non-split) unit"

Do you talk about CompileUnit::Dump? CompileUnit always has DWO already loaded.

(lldb) target modules dump symfile
...
Compile units:
0x9ef030: CompileUnit{0x00000000}, language = "c99", file = '/home/jkratoch/t/main.c'
                                               ^^^

There is also DWARFCompileUnit::Dump but that does not print the language.

I'm not sure which thing was being discussed. It was mentioned here: https://reviews.llvm.org/D100299#2895555 - so maybe that was confused/incorrect (or was correct at that point in the patch) and now it's addressed and as you say, loads the DWO and prints the language name correctly. That's fine by me.

[Eric]

So dump always passes a the skeleton unit to "GetLanguage" or it already makes a dynamic choice based on whether or not the dwo has already been loaded?

No, Dump always returns a cached value either provided to the CompileUnit constructor or calculated on a previous call to GetLanguage(). It will not trigger calculation even if the necessary information has already been loaded because then it would have to update the cached copy which is a non-const operation.

I'd still be a bit concerned if the way "language" is rendered is the dump is indistinguishable between "dwo hasn't been loaded" and "there is no language specified in the full (split or non-split) unit" - while dump probably isn't the most important feature for end users, it may be important for lldb developers - if they get confused/mislead that the "language" is not present/can't be parsed, rather than the dwo hasn't been loaded, that might result in some frustration/waste of time. It'd be good/important to render those different states differently.

I'm testing a fix for this; will upload shortly.

[jankratochvil]

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

715–716

This will not work for the need_non_skeleton case for DWO as one has to use dwarf_cu.GetNonSkeletonUnit().GetDWARFLanguageType() in such case.
Original code was using: dwarf_cu.GetNonSkeletonUnit().GetUnitDIEOnly().GetAttributeValueAsUnsigned(DW_AT_language, 0)

[Eric]

GetLanguage has now a bug for -gsplit-dwarf as it will return eLanguageTypeUnknown if called on the skeleton - which could affect ManualDWARFIndex::IndexUnitImpl but then it is using LanguageType cu_language only for cu_language == eLanguageTypeObjC. Which is needed only on OSX and OSX does not have -gsplit-dwarf. GetLanguage should IMO force loading of the DWO.

The behavior of GetLanguage should be unchanged. Could you explain what you think is different? Also what do you mean by "if called on the skeleton" -- this is a method on the CompileUnit, which can't be called on just the skeleton unit or just the non-skeleton unit.

Do you talk about CompileUnit::Dump? CompileUnit always has DWO already loaded.

This was true prior to this change but is no longer the case with this change.

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-lazy-dwo.cpp

6 ↗

(On Diff #361230)

I'll try changing it back, but I'm not sure what the difference is? Other tests in DWARF/x86 seem to just use %clang and I'm not clear on why this test would need to be different?

[jankratochvil]

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-lazy-dwo.cpp

6 ↗

(On Diff #361230)

• Those tests in DWARF/x86 do not do run.
• Those tests in DWARF/x86 are impossible to be used on different arch than x86_64 (as they are typically coded in x86_64 asm). Tests from this D100299 can run on any arch. When you develop LLDB on non-x86_64 arch (yes, some people incl. me do that) you want to have as rich testsuite as possible to catch regressions easier.

[Eric]

Now distinguishing between unknown language and not loaded.

[jankratochvil]

Could you split that <not loaded> change to an extra patch, please?

[Eric]

The "<not loaded>" message would never be seen without the changes in this patch, so I don't think it makes sense to do independently.

[kimanh]

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

53–54

nit: ExtractUnitDIEIfNeeded -> ExtractUnitDIENoDwoIfNeeded

[jankratochvil]

I tried this patch showing the language in more cases when DWO is already in memory: https://people.redhat.com/jkratoch/dwouseifloaded.patch
It would need some cleanup. But I find now questionable whether it is worth it as it affects only the debug dumps.

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

716–717

Variables are lowercase in LLDB, this is not LLVM.

750

This should be done inside InitializeCU - that is it needs to apply also for the optimized case.

[Eric]

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

716–717

Okay. I figured function style made more sense but I can see either way.

750

ParseSupportFiles takes care of path remapping already. (See line 244)

[jankratochvil]

I am fine with the patch except for the nitpicks.
@dblaikie not sure if you like more availability of the language? https://people.redhat.com/jkratoch/dwouseifloaded.patch

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

750

OK, thanks. There could be a comment for it as I find it far from obvious.

lldb/source/Symbol/CompileUnit.cpp

104

Missing newline after closing }.

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-lazy-dwo.cpp

1–2 ↗

(On Diff #362121)

This description was copy-pasted and not updated.

4 ↗

(On Diff #362121)

Due to the %clangxx_host this test is now arch-independent. Also the lld should not be needed. So this whole line can be deleted.

6 ↗

(On Diff #362121)

Is there a reason this testcase is .cpp and not .c and it is using %clangxx_host and not %clang?
One should remove -target x86_64-pc-linux as the test is now arch-independent.

10 ↗

(On Diff #362121)

You can use %clangxx_host %t1.o %t2.o -o %t then you need no lld dependency as lld is not available on some archs.
And it is generally dangerous/incompatible to run the linker directly, one should always use the driver (clang/clang++) even just for linking. It matters for this testcase compared to other testcases as it is using run.

lldb/test/Shell/SymbolFile/DWARF/x86/split-optimized.cpp

1 ↗

(On Diff #362121)

When there is the _host variant there should no longer be the -target x86_64-pc-linux as the test is arch-independent now.
Also the first line should be a description of the test.

[Eric]

Now eagerly evaluates the language if there is no dwo. Lazy evaluation only happens for split dwarf case.

[Eric]

Jan, I don't think there's any point in checking for the case when the dwo is already loaded as that wouldn't be triggered if the CompileUnit hasn't already been created. However I added a check for the case where there is no dwo because it wasn't compiled with -gsplit-dwarf. Note that the debug-types-address-ranges.s test case no longer requires modification in this version. Let me know if you have any further nitpicks for SymbolFileDWARF::ParseCompileUnit. Nothing else required changes since your last review. I'm also happy to bring back the previous version with your nitpicks fixed if you'd prefer.

[dblaikie]

In D100299#2908210, @jankratochvil wrote:

I am fine with the patch except for the nitpicks.
@dblaikie not sure if you like more availability of the language? https://people.redhat.com/jkratoch/dwouseifloaded.patch

Mostly I'm just concerned that there isn't a "trap" left where someone might call the API, get an answer that looks reasonable, but it is wrong or out of date.

so I guess order of concern:

If the same call can produce different results depending on whether some other operation has caused more parsing to happen - that's probably a problematic API that should be avoided.
-> If it can't be avoided, then it'd be good if that API returns a "indeterminate" Result to distinguish it from "the parsing happened and nothing was found"/"the parsing happened and the thing was found".

If the API is available on the split and full unit, and it always returns the same value in each case (ie: always returns the parsed result in the split unit, and it always returns "we looked and found nothing" on the skeleton unit) - that's /probably/ OK, at least it doesn't have the temporal inconsistency risk of the previous point - but maybe if the attempt to call on the skeleton unit were invalid/assert-failed, that might be better, since it's sort of not expected/meaningful to query the skeleton unit for the language.

Does that make sense?

(but this is all pretty out of my wheelhouse, so I'm happy to leave the details to you folks - if my concerns are understood, you can weigh/factor them in as you see fit)

[Eric]

The only changed behavior is CompileUnit::Dump(), which I've changed to distinguish between an uncalculated languange ("<not loaded>") and an unspecified one ("unknown"). No other API should behave differently, as GetLanguage() will trigger parsing of the non-skeleton unit, and no API would be parsing language information out of Dump() output. With my latest update there is also no effect if not using -gsplit-dwarf, and this change substantially benefits those using -gsplit-dwarf. In practice I don't see a compelling user story where this would be a regression.

[dblaikie]

In D100299#2912010, @Eric wrote:

The only changed behavior is CompileUnit::Dump(), which I've changed to distinguish between an uncalculated languange ("<not loaded>") and an unspecified one ("unknown"). No other API should behave differently, as GetLanguage() will trigger parsing of the non-skeleton unit, and no API would be parsing language information out of Dump() output. With my latest update there is also no effect if not using -gsplit-dwarf, and this change substantially benefits those using -gsplit-dwarf. In practice I don't see a compelling user story where this would be a regression.

That sounds all good to me - so consider my concerns addressed. (I'll leave it to folks more familiar with lldb for the final review/approval)

[Eric]

Jan, let me know if there's anything else I should change. Also, I believe I will need someone else to actually submit this for me.

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-lazy-dwo.cpp

4 ↗

(On Diff #362121)

Should I also move these tests up a folder since they are no longer x86 specific?

[jankratochvil]

In D100299#2911754, @dblaikie wrote:

Mostly I'm just concerned that there isn't a "trap" left where someone might call the API, get an answer that looks reasonable, but it is wrong or out of date.

With the <not loaded> it should not happen anywhere.

but maybe if the attempt to call on the skeleton unit were invalid/assert-failed, that might be better, since it's sort of not expected/meaningful to query the skeleton unit for the language.

I agree but that would be (another) hijack of this patch, than can be implemented separately/orthogonally.

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

709

IIUC you do not check GetDebugMapSymfile() as I did in my https://people.redhat.com/jkratoch/dwouseifloaded.patch (and which I did copy from SymbolFileDWARF::GetDwoSymbolFileForCompileUnit) as it is already checked here? I hope dwarf_cu.GetOffset() == 0 is always satisfied on OSX. Unfortunately I do not know much OSX and the testsuite recently fails a lot on my OSX.

767

Empty line before the comment.

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-lazy-dwo.c

10

As there could be otherwise a false PASS.

21

As there could be otherwise a false PASS.
But then it needs also settings set stop-line-count-before 0 otherwise it is a false FAIL.

[jankratochvil]

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-lazy-dwo.cpp

4 ↗

(On Diff #362121)

Yes, you are right, it should not be in x86/.

[Eric]

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

709

I'm not sure about that. Added the check.

[omjavaid]

This fails on 32 bit Arm
https://lab.llvm.org/buildbot/#/builders/17/builds/9595

[jankratochvil]

In D100299#2916203, @omjavaid wrote:

This fails on 32 bit Arm
https://lab.llvm.org/buildbot/#/builders/17/builds/9595

I have reverted it as it takes some time to build on arm32 to investigate it.

[Eric]

Would it make sense to turn the split-optimized test back into an x86 only test, or just leave it out of the change as it's not actually testing a code path that this changed?

[jankratochvil]

In D100299#2917250, @Eric wrote:

Would it make sense to turn the split-optimized test back into an x86 only test, or just leave it out of the change as it's not actually testing a code path that this changed?

The question is why it fails. I have no idea, do you? Unfortunately I haven't found a ready to use arm32 box, I even bricked armv7-test01.fedorainfracloud.org for it. I have started a local arm32 VM and I will try to build LLDB there over weekend and we can decide afterwards. Sometimes the exotic arches surprisingly discover an arch-unspecific bug (I do not think it is this case but who knows).

[Eric]

Is arm hardware necessary to test this, or can the test be modified to cross-compile to arm to see what is going on? Is there a way to determine what build target the test bot is using?

In any case the broken test doesn't exercise lldb at all so it could be separated from the patch.

[jankratochvil]

In D100299#2917467, @Eric wrote:

Is arm hardware necessary to test this,

In this case it is not as it does not require linking. Usually I find easier to run it natively than to setup all the cross-compilation libraries and include files. I agree it was my mistake as the cross-compilation is easier in this case.

or can the test be modified to cross-compile to arm to see what is going on?

In fact it is visible already from the build log and it is then obvious from source code. I did not see it first from the default shortened dump.

Is there a way to determine what build target the test bot is using?

Yes, armv8l-unknown-linux-gnueabihf.

In any case the broken test doesn't exercise lldb at all so it could be separated from the patch.

If the test did not exercise LLDB it should have been removed. But it does exercise LLDB.

I have added to lldb/test/Shell/SymbolFile/DWARF/split-optimized.c:

+// ObjectFileELF::ApplyRelocations does not implement arm32.
+// XFAIL: target-arm && linux-gnu

Hopefully it will satisfy the buildbot now.

[stella.stamenova]

In D100299#2917598, @jankratochvil wrote:

In D100299#2917467, @Eric wrote:

Is arm hardware necessary to test this,

In this case it is not as it does not require linking. Usually I find easier to run it natively than to setup all the cross-compilation libraries and include files. I agree it was my mistake as the cross-compilation is easier in this case.

or can the test be modified to cross-compile to arm to see what is going on?

In fact it is visible already from the build log and it is then obvious from source code. I did not see it first from the default shortened dump.

Is there a way to determine what build target the test bot is using?

Yes, armv8l-unknown-linux-gnueabihf.

In any case the broken test doesn't exercise lldb at all so it could be separated from the patch.

If the test did not exercise LLDB it should have been removed. But it does exercise LLDB.

I have added to lldb/test/Shell/SymbolFile/DWARF/split-optimized.c:

+// ObjectFileELF::ApplyRelocations does not implement arm32.
+// XFAIL: target-arm && linux-gnu

Hopefully it will satisfy the buildbot now.

This also fails on the Windows lldb bot:

https://lab.llvm.org/buildbot/#/builders/83/builds/8842

Perhaps something more than several xfails is needed? More specifically, I think it makese more sense to use something like requires or unsupported

[jankratochvil]

In D100299#2917768, @stella.stamenova wrote:

This also fails on the Windows lldb bot:

Sorry I did not check (probably it sends messages to Author and not Commiter). Added there:

// -gsplit-dwarf is supported only on Linux.
// REQUIRES: system-linux

I did not know -gsplit-dwarf is implemented only in clang/lib/Driver/ToolChains/Gnu.cpp. It is implemented also in clang/lib/Driver/ToolChains/MinGW.cpp but I could not get it working there (-target i686-w64-mingw32).

lldb/include/lldb/Symbol/CompileUnit.h

 //===-- CompileUnit.h -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_COMPILEUNIT_H
 #define LLDB_SYMBOL_COMPILEUNIT_H
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/ModuleChild.h"
 #include "lldb/Core/SourceLocationSpec.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SourceModule.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/UserID.h"
enum {
     flagsParsedImportedModules =
         (1u << 5), ///< Have we parsed the imported modules already?
     flagsParsedDebugMacros =
         (1u << 6) ///< Have we parsed the debug macros already?
   };
 
   CompileUnit(const CompileUnit &) = delete;
   const CompileUnit &operator=(const CompileUnit &) = delete;
+  const char *GetCachedLanguage() const;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_COMPILEUNIT_H

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

extract(SymbolFileDWARF &dwarf2Data, lldb::user_id_t uid,
           const lldb_private::DWARFDataExtractor &debug_info,
           DIERef::Section section, lldb::offset_t *offset_ptr);
   virtual ~DWARFUnit();
 
   bool IsDWOUnit() { return m_is_dwo; }
   uint64_t GetDWOId();
 
   void ExtractUnitDIEIfNeeded();
+  void ExtractUnitDIENoDwoIfNeeded();
   void ExtractDIEsIfNeeded();
 
   class ScopedExtractDIEs {
     DWARFUnit *m_cu;
   public:
     bool m_clear_dies = false;
     ScopedExtractDIEs(DWARFUnit &cu);
     ~ScopedExtractDIEs();
public:
   // Size of the CU data (without initial length and without header).
   size_t GetDebugInfoSize() const;
   // Size of the CU data incl. header but without initial length.
   uint32_t GetLength() const { return m_header.GetLength(); }
   uint16_t GetVersion() const { return m_header.GetVersion(); }
   const DWARFAbbreviationDeclarationSet *GetAbbreviations() const;
   dw_offset_t GetAbbrevOffset() const;
   uint8_t GetAddressByteSize() const { return m_header.GetAddressByteSize(); }
-  dw_addr_t GetAddrBase() const { return m_addr_base; }
+  dw_addr_t GetAddrBase() const { return m_addr_base ? *m_addr_base : 0; }
   dw_addr_t GetBaseAddress() const { return m_base_addr; }
   dw_offset_t GetLineTableOffset();
   dw_addr_t GetRangesBase() const { return m_ranges_base; }
   dw_addr_t GetStrOffsetsBase() const { return m_str_offsets_base; }
   void SetAddrBase(dw_addr_t addr_base);
   void SetLoclistsBase(dw_addr_t loclists_base);
   void SetRangesBase(dw_addr_t ranges_base);
   void SetStrOffsetsBase(dw_offset_t str_offsets_base);
   virtual void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) = 0;
 
   lldb::ByteOrder GetByteOrder() const;
 
   const DWARFDebugAranges &GetFunctionAranges();
protected:
 
   llvm::Error ExtractHeader(SymbolFileDWARF &dwarf,
                             const lldb_private::DWARFDataExtractor &data,
                             lldb::offset_t *offset_ptr);
 
   // Get the DWARF unit DWARF debug information entry. Parse the single DIE
   // if needed.
   const DWARFDebugInfoEntry *GetUnitDIEPtrOnly() {
-    ExtractUnitDIEIfNeeded();
+    ExtractUnitDIENoDwoIfNeeded();
     // m_first_die_mutex is not required as m_first_die is never cleared.
     if (!m_first_die)
       return NULL;
     return &m_first_die;
   }
 
   // Get all DWARF debug informration entries. Parse all DIEs if needed.
   const DWARFDebugInfoEntry *DIEPtr() {
protected:
   dw_addr_t m_base_addr = 0;
   DWARFProducer m_producer = eProducerInvalid;
   uint32_t m_producer_version_major = 0;
   uint32_t m_producer_version_minor = 0;
   uint32_t m_producer_version_update = 0;
   llvm::Optional<uint64_t> m_language_type;
   lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
   llvm::Optional<lldb_private::FileSpec> m_comp_dir;
   llvm::Optional<lldb_private::FileSpec> m_file_spec;
-  dw_addr_t m_addr_base = 0;     ///< Value of DW_AT_addr_base.
-  dw_addr_t m_loclists_base = 0; ///< Value of DW_AT_loclists_base.
-  dw_addr_t m_ranges_base = 0;   ///< Value of DW_AT_rnglists_base.
+  llvm::Optional<dw_addr_t> m_addr_base; ///< Value of DW_AT_addr_base.
+  dw_addr_t m_loclists_base = 0;         ///< Value of DW_AT_loclists_base.
+  dw_addr_t m_ranges_base = 0;           ///< Value of DW_AT_rnglists_base.
+  llvm::Optional<uint64_t> m_gnu_addr_base;
+  llvm::Optional<uint64_t> m_gnu_ranges_base;
 
   /// Value of DW_AT_stmt_list.
   dw_offset_t m_line_table_offset = DW_INVALID_OFFSET;
 
   dw_offset_t m_str_offsets_base = 0; // Value of DW_AT_str_offsets_base.
 
   llvm::Optional<llvm::DWARFDebugRnglistTable> m_rnglist_table;
   bool m_rnglist_table_done = false;
   llvm::Optional<llvm::DWARFListTableHeader> m_loclist_table_header;
 
   const DIERef::Section m_section;
   bool m_is_dwo;
+  bool m_has_parsed_non_skeleton_unit;
   /// Value of DW_AT_GNU_dwo_id (v4) or dwo_id from CU header (v5).
   uint64_t m_dwo_id;
 
 private:
   void ParseProducerInfo();
   void ExtractDIEsRWLocked();
   void ClearDIEsRWLocked();
 
   void AddUnitDIE(const DWARFDebugInfoEntry &cu_die);

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

 extern int g_verbose;
 
 DWARFUnit::DWARFUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid,
                      const DWARFUnitHeader &header,
                      const DWARFAbbreviationDeclarationSet &abbrevs,
                      DIERef::Section section, bool is_dwo)
     : UserID(uid), m_dwarf(dwarf), m_header(header), m_abbrevs(&abbrevs),
       m_cancel_scopes(false), m_section(section), m_is_dwo(is_dwo),
-      m_dwo_id(header.GetDWOId()) {}
+      m_has_parsed_non_skeleton_unit(false), m_dwo_id(header.GetDWOId()) {}
 
 DWARFUnit::~DWARFUnit() = default;
 
-// Parses first DIE of a compile unit.
-void DWARFUnit::ExtractUnitDIEIfNeeded() {
+// Parses first DIE of a compile unit, excluding DWO.
+void DWARFUnit::ExtractUnitDIENoDwoIfNeeded() {
   {
     llvm::sys::ScopedReader lock(m_first_die_mutex);
     if (m_first_die)
       return; // Already parsed
   }
   llvm::sys::ScopedWriter lock(m_first_die_mutex);
   if (m_first_die)
     return; // Already parsed
 
-  LLDB_SCOPED_TIMERF("%8.8x: DWARFUnit::ExtractUnitDIEIfNeeded()", GetOffset());
+  LLDB_SCOPED_TIMERF("%8.8x: DWARFUnit::ExtractUnitDIENoDwoIfNeeded()",
+                     GetOffset());
 
   // Set the offset to that of the first DIE and calculate the start of the
   // next compilation unit header.
   lldb::offset_t offset = GetFirstDIEOffset();
 
   // We are in our compile unit, parse starting at the offset we were told to
   // parse
   const DWARFDataExtractor &data = GetData();
   if (offset < GetNextUnitOffset() &&
       m_first_die.Extract(data, this, &offset)) {
     AddUnitDIE(m_first_die);
     return;
   }
 }
 
+// Parses first DIE of a compile unit including DWO.
+void DWARFUnit::ExtractUnitDIEIfNeeded() {
+  ExtractUnitDIENoDwoIfNeeded();
+
+  if (m_has_parsed_non_skeleton_unit)
+    return;
+
+  m_has_parsed_non_skeleton_unit = true;
+
+  std::shared_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
+      m_dwarf.GetDwoSymbolFileForCompileUnit(*this, m_first_die);
+  if (!dwo_symbol_file)
+    return;
+
+  DWARFUnit *dwo_cu = dwo_symbol_file->GetDWOCompileUnitForHash(m_dwo_id);
+
+  if (!dwo_cu)
+    return; // Can't fetch the compile unit from the dwo file.
+  dwo_cu->SetUserData(this);
+
+  DWARFBaseDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
+  if (!dwo_cu_die.IsValid())
+    return; // Can't fetch the compile unit DIE from the dwo file.
+
+  // Here for DWO CU we want to use the address base set in the skeleton unit
+  // (DW_AT_addr_base) if it is available and use the DW_AT_GNU_addr_base
+  // otherwise. We do that because pre-DWARF v5 could use the DW_AT_GNU_*
+  // attributes which were applicable to the DWO units. The corresponding
+  // DW_AT_* attributes standardized in DWARF v5 are also applicable to the
+  // main unit in contrast.
+  if (m_addr_base)
+    dwo_cu->SetAddrBase(*m_addr_base);
+  else if (m_gnu_addr_base)
+    dwo_cu->SetAddrBase(*m_gnu_addr_base);
+
+  if (GetVersion() <= 4 && m_gnu_ranges_base)
+    dwo_cu->SetRangesBase(*m_gnu_ranges_base);
+  else if (dwo_symbol_file->GetDWARFContext()
+               .getOrLoadRngListsData()
+               .GetByteSize() > 0)
+    dwo_cu->SetRangesBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32));
+
+  if (GetVersion() >= 5 &&
+      dwo_symbol_file->GetDWARFContext().getOrLoadLocListsData().GetByteSize() >
+          0)
+    dwo_cu->SetLoclistsBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32));
+
+  dwo_cu->SetBaseAddress(GetBaseAddress());
+
+  m_dwo = std::shared_ptr<DWARFUnit>(std::move(dwo_symbol_file), dwo_cu);
+}
+
 // Parses a compile unit and indexes its DIEs if it hasn't already been done.
 // It will leave this compile unit extracted forever.
 void DWARFUnit::ExtractDIEsIfNeeded() {
   m_cancel_scopes = true;
 
   {
     llvm::sys::ScopedReader lock(m_die_array_mutex);
     if (!m_die_array.empty())
if (GetVersion() >= 5) {
     // Skip padding.
     baseOffset += 2;
   }
 
   SetStrOffsetsBase(baseOffset);
 }
 
 uint64_t DWARFUnit::GetDWOId() {
-  ExtractUnitDIEIfNeeded();
+  ExtractUnitDIENoDwoIfNeeded();
   return m_dwo_id;
 }
 
 // m_die_array_mutex must be already held as read/write.
 void DWARFUnit::AddUnitDIE(const DWARFDebugInfoEntry &cu_die) {
-  llvm::Optional<uint64_t> addr_base, gnu_addr_base, gnu_ranges_base;
-
   DWARFAttributes attributes;
   size_t num_attributes = cu_die.GetAttributes(this, attributes);
 
   // Extract DW_AT_addr_base first, as other attributes may need it.
   for (size_t i = 0; i < num_attributes; ++i) {
     if (attributes.AttributeAtIndex(i) != DW_AT_addr_base)
       continue;
     DWARFFormValue form_value;
     if (attributes.ExtractFormValueAtIndex(i, form_value)) {
-      addr_base = form_value.Unsigned();
-      SetAddrBase(*addr_base);
+      SetAddrBase(form_value.Unsigned());
       break;
     }
   }
 
   for (size_t i = 0; i < num_attributes; ++i) {
     dw_attr_t attr = attributes.AttributeAtIndex(i);
     DWARFFormValue form_value;
     if (!attributes.ExtractFormValueAtIndex(i, form_value))
case DW_AT_entry_pc:
       // If the value was already set by DW_AT_low_pc, don't update it.
       if (m_base_addr == LLDB_INVALID_ADDRESS)
         SetBaseAddress(form_value.Address());
       break;
     case DW_AT_stmt_list:
       m_line_table_offset = form_value.Unsigned();
       break;
     case DW_AT_GNU_addr_base:
-      gnu_addr_base = form_value.Unsigned();
+      m_gnu_addr_base = form_value.Unsigned();
       break;
     case DW_AT_GNU_ranges_base:
-      gnu_ranges_base = form_value.Unsigned();
+      m_gnu_ranges_base = form_value.Unsigned();
       break;
     case DW_AT_GNU_dwo_id:
       m_dwo_id = form_value.Unsigned();
       break;
     }
   }
 
   if (m_is_dwo) {
+    m_has_parsed_non_skeleton_unit = true;
     SetDwoStrOffsetsBase();
     return;
   }
-
-  std::shared_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
-      m_dwarf.GetDwoSymbolFileForCompileUnit(*this, cu_die);
-  if (!dwo_symbol_file)
-    return;
-
-  DWARFUnit *dwo_cu = dwo_symbol_file->GetDWOCompileUnitForHash(m_dwo_id);
-
-  if (!dwo_cu)
-    return; // Can't fetch the compile unit from the dwo file.
-  dwo_cu->SetUserData(this);
-
-  DWARFBaseDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
-  if (!dwo_cu_die.IsValid())
-    return; // Can't fetch the compile unit DIE from the dwo file.
-
-  // Here for DWO CU we want to use the address base set in the skeleton unit
-  // (DW_AT_addr_base) if it is available and use the DW_AT_GNU_addr_base
-  // otherwise. We do that because pre-DWARF v5 could use the DW_AT_GNU_*
-  // attributes which were applicable to the DWO units. The corresponding
-  // DW_AT_* attributes standardized in DWARF v5 are also applicable to the main
-  // unit in contrast.
-  if (addr_base)
-    dwo_cu->SetAddrBase(*addr_base);
-  else if (gnu_addr_base)
-    dwo_cu->SetAddrBase(*gnu_addr_base);
-
-  if (GetVersion() <= 4 && gnu_ranges_base)
-    dwo_cu->SetRangesBase(*gnu_ranges_base);
-  else if (dwo_symbol_file->GetDWARFContext()
-               .getOrLoadRngListsData()
-               .GetByteSize() > 0)
-    dwo_cu->SetRangesBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32));
-
-  if (GetVersion() >= 5 &&
-      dwo_symbol_file->GetDWARFContext().getOrLoadLocListsData().GetByteSize() >
-          0)
-    dwo_cu->SetLoclistsBase(llvm::DWARFListTableHeader::getHeaderSize(DWARF32));
-  dwo_cu->SetBaseAddress(GetBaseAddress());
-
-  m_dwo = std::shared_ptr<DWARFUnit>(std::move(dwo_symbol_file), dwo_cu);
 }
 
 size_t DWARFUnit::GetDebugInfoSize() const {
   return GetLengthByteSize() + GetLength() - GetHeaderByteSize();
 }
 
 const DWARFAbbreviationDeclarationSet *DWARFUnit::GetAbbreviations() const {
   return m_abbrevs;
 }
 
 dw_offset_t DWARFUnit::GetAbbrevOffset() const {
   return m_abbrevs ? m_abbrevs->GetOffset() : DW_INVALID_OFFSET;
 }
 
 dw_offset_t DWARFUnit::GetLineTableOffset() {
-  ExtractUnitDIEIfNeeded();
+  ExtractUnitDIENoDwoIfNeeded();
   return m_line_table_offset;
 }
 
 void DWARFUnit::SetAddrBase(dw_addr_t addr_base) { m_addr_base = addr_base; }
 
 // Parse the rangelist table header, including the optional array of offsets
 // following it (DWARF v5 and later).
 template <typename ListTableType>
if (m_is_optimized == eLazyBoolCalculate) {
     const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
     if (die) {
       m_is_optimized = eLazyBoolNo;
       if (die->GetAttributeValueAsUnsigned(this, DW_AT_APPLE_optimized, 0) ==
           1) {
         m_is_optimized = eLazyBoolYes;
       }
     }
   }
   return m_is_optimized == eLazyBoolYes;
 }
 
 FileSpec::Style DWARFUnit::GetPathStyle() {
   if (!m_comp_dir)
     ComputeCompDirAndGuessPathStyle();
   return m_comp_dir->GetPathStyle();
 }
 
 const FileSpec &DWARFUnit::GetCompilationDirectory() {
   if (!m_comp_dir)
     ComputeCompDirAndGuessPathStyle();
   return *m_comp_dir;
 }
 

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

 #include <mutex>
 #include <unordered_map>
 #include <vector>
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/lldb-private.h"
size_t ParseBlocksRecursive(lldb_private::CompileUnit &comp_unit,
                               lldb::addr_t subprogram_low_pc, uint32_t depth);
 
   size_t ParseTypes(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
                     bool parse_siblings, bool parse_children);
 
   lldb::TypeSP ParseType(const lldb_private::SymbolContext &sc,
                          const DWARFDIE &die, bool *type_is_new);
 
+  bool ParseSupportFiles(DWARFUnit &dwarf_cu, const lldb::ModuleSP &module,
+                         lldb_private::FileSpecList &support_files);
+
   lldb_private::Type *ResolveTypeUID(const DWARFDIE &die,
                                      bool assert_not_being_parsed);
 
   lldb_private::Type *ResolveTypeUID(const DIERef &die_ref);
 
   lldb::VariableSP ParseVariableDIE(const lldb_private::SymbolContext &sc,
                                     const DWARFDIE &die,
                                     const lldb::addr_t func_low_pc);

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

static void MakeAbsoluteAndRemap(FileSpec &file_spec, DWARFUnit &dwarf_cu,
   // resolve the file.  This can be expensive e.g. when the source
   // files are NFS mounted.
   file_spec.MakeAbsolute(dwarf_cu.GetCompilationDirectory());
 
   if (auto remapped_file = module_sp->RemapSourceFile(file_spec.GetPath()))
     file_spec.SetFile(*remapped_file, FileSpec::Style::native);
 }
 
+/// Return the DW_AT_(GNU_)dwo_name.
+static const char *GetDWOName(DWARFCompileUnit &dwarf_cu,
+                              const DWARFDebugInfoEntry &cu_die) {
+  const char *dwo_name =
+      cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
+  if (!dwo_name)
+    dwo_name =
+        cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_dwo_name, nullptr);
+  return dwo_name;
+}
+
 lldb::CompUnitSP SymbolFileDWARF::ParseCompileUnit(DWARFCompileUnit &dwarf_cu) {
   CompUnitSP cu_sp;
   CompileUnit *comp_unit = (CompileUnit *)dwarf_cu.GetUserData();
   if (comp_unit) {
     // We already parsed this compile unit, had out a shared pointer to it
     cu_sp = comp_unit->shared_from_this();
   } else {
     if (dwarf_cu.GetOffset() == 0 && GetDebugMapSymfile()) {
       // Let the debug map create the compile unit
       cu_sp = m_debug_map_symfile->GetCompileUnit(this);
       dwarf_cu.SetUserData(cu_sp.get());
     } else {
       ModuleSP module_sp(m_objfile_sp->GetModule());
       if (module_sp) {
-        const DWARFBaseDIE cu_die =
-            dwarf_cu.GetNonSkeletonUnit().GetUnitDIEOnly();
-        if (cu_die) {
-          FileSpec cu_file_spec(cu_die.GetName(), dwarf_cu.GetPathStyle());
-          MakeAbsoluteAndRemap(cu_file_spec, dwarf_cu, module_sp);
-
-          LanguageType cu_language = SymbolFileDWARF::LanguageTypeFromDWARF(
-              cu_die.GetAttributeValueAsUnsigned(DW_AT_language, 0));
-
-          bool is_optimized = dwarf_cu.GetNonSkeletonUnit().GetIsOptimized();
+        auto initialize_cu = [&](const FileSpec &file_spec,
+                                 LanguageType cu_language) {
           BuildCuTranslationTable();
           cu_sp = std::make_shared<CompileUnit>(
-              module_sp, &dwarf_cu, cu_file_spec,
+              module_sp, &dwarf_cu, file_spec,
               *GetDWARFUnitIndex(dwarf_cu.GetID()), cu_language,
-              is_optimized ? eLazyBoolYes : eLazyBoolNo);
+              eLazyBoolCalculate);
 
           dwarf_cu.SetUserData(cu_sp.get());
 
           SetCompileUnitAtIndex(dwarf_cu.GetID(), cu_sp);
+        };
+
+        auto lazy_initialize_cu = [&]() {
+          // If the version is < 5, we can't do lazy initialization.
+          if (dwarf_cu.GetVersion() < 5)
+            return false;
+
+          // If there is no DWO, there is no reason to initialize
+          // lazily; we will do eager initialization in that case.
+          const DWARFBaseDIE cu_die = dwarf_cu.GetUnitDIEOnly();
+          if (!cu_die)
+            return false;
+          if (!GetDWOName(dwarf_cu, *cu_die.GetDIE()))
+            return false;
+
+          // With DWARFv5 we can assume that the first support
+          // file is also the name of the compile unit. This
+          // allows us to avoid loading the non-skeleton unit,
+          // which may be in a separate DWO file.
+          FileSpecList support_files;
+          if (!ParseSupportFiles(dwarf_cu, module_sp, support_files))
+            return false;
+          if (support_files.GetSize() == 0)
+            return false;
+
+          initialize_cu(support_files.GetFileSpecAtIndex(0),
+                        eLanguageTypeUnknown);
+          cu_sp->SetSupportFiles(std::move(support_files));
+          return true;
+        };
+
+        if (!lazy_initialize_cu()) {
+          // Eagerly initialize compile unit
+          const DWARFBaseDIE cu_die =
+              dwarf_cu.GetNonSkeletonUnit().GetUnitDIEOnly();
+          if (cu_die) {
+            LanguageType cu_language = SymbolFileDWARF::LanguageTypeFromDWARF(
+                dwarf_cu.GetDWARFLanguageType());
+
+            FileSpec cu_file_spec(cu_die.GetName(), dwarf_cu.GetPathStyle());
+            // Path needs to be remapped in this case. In the support files
+            // case ParseSupportFiles takes care of the remapping.
+            MakeAbsoluteAndRemap(cu_file_spec, dwarf_cu, module_sp);
+
+            initialize_cu(cu_file_spec, cu_language);
+          }
         }
       }
     }
   }
   return cu_sp;
 }
 
 void SymbolFileDWARF::BuildCuTranslationTable() {
bool SymbolFileDWARF::FixupAddress(Address &addr) {
   }
   // This is a normal DWARF file, no address fixups need to happen
   return true;
 }
 lldb::LanguageType SymbolFileDWARF::ParseLanguage(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
-    return GetLanguage(*dwarf_cu);
+    return GetLanguage(dwarf_cu->GetNonSkeletonUnit());
   else
     return eLanguageTypeUnknown;
 }
 
 XcodeSDK SymbolFileDWARF::ParseXcodeSDK(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (!dwarf_cu)

 
 bool SymbolFileDWARF::ParseSupportFiles(CompileUnit &comp_unit,
                                         FileSpecList &support_files) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (!dwarf_cu)
     return false;
 
-  dw_offset_t offset = dwarf_cu->GetLineTableOffset();
+  if (!ParseSupportFiles(*dwarf_cu, comp_unit.GetModule(), support_files))
+    return false;
+
+  comp_unit.SetSupportFiles(support_files);
+  return true;
+}
+
+bool SymbolFileDWARF::ParseSupportFiles(DWARFUnit &dwarf_cu,
+                                        const ModuleSP &module,
+                                        FileSpecList &support_files) {
+
+  dw_offset_t offset = dwarf_cu.GetLineTableOffset();
   if (offset == DW_INVALID_OFFSET)
     return false;
 
   llvm::DWARFDebugLine::Prologue prologue;
   if (!ParseLLVMLineTablePrologue(m_context, prologue, offset,
-                                  dwarf_cu->GetOffset()))
+                                  dwarf_cu.GetOffset()))
     return false;
 
-  comp_unit.SetSupportFiles(ParseSupportFilesFromPrologue(
-      comp_unit.GetModule(), prologue, dwarf_cu->GetPathStyle(),
-      dwarf_cu->GetCompilationDirectory().GetCString()));
+  support_files = ParseSupportFilesFromPrologue(
+      module, prologue, dwarf_cu.GetPathStyle(),
+      dwarf_cu.GetCompilationDirectory().GetCString());
 
   return true;
 }
 
 FileSpec SymbolFileDWARF::GetFile(DWARFUnit &unit, size_t file_idx) {
   if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit)) {
     if (CompileUnit *lldb_cu = GetCompUnitForDWARFCompUnit(*dwarf_cu))
       return lldb_cu->GetSupportFiles().GetFileSpecAtIndex(file_idx);
SymbolFileDWARF::GetTypeUnitSupportFiles(DWARFTypeUnit &tu) {
   }
   return list;
 }
 
 bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
-    return dwarf_cu->GetIsOptimized();
+    return dwarf_cu->GetNonSkeletonUnit().GetIsOptimized();
   return false;
 }
 
 bool SymbolFileDWARF::ParseImportedModules(
     const lldb_private::SymbolContext &sc,
     std::vector<SourceModule> &imported_modules) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   assert(sc.comp_unit);
SymbolFileDWARF *dwarf = *die_ref.dwo_num() == 0x3fffffff
                                        .GetUnitAtIndex(*die_ref.dwo_num())
                                        ->GetDwoSymbolFile();
     return dwarf->DebugInfo().GetDIE(die_ref);
   }
 
   return DebugInfo().GetDIE(die_ref);
 }
 
-/// Return the DW_AT_(GNU_)dwo_name.
-static const char *GetDWOName(DWARFCompileUnit &dwarf_cu,
-                              const DWARFDebugInfoEntry &cu_die) {
-  const char *dwo_name =
-      cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
-  if (!dwo_name)
-    dwo_name =
-        cu_die.GetAttributeValueAsString(&dwarf_cu, DW_AT_dwo_name, nullptr);
-  return dwo_name;
-}
-
 /// Return the DW_AT_(GNU_)dwo_id.
 /// FIXME: Technically 0 is a valid hash.
 static uint64_t GetDWOId(DWARFCompileUnit &dwarf_cu,
                          const DWARFDebugInfoEntry &cu_die) {
   uint64_t dwo_id =
       cu_die.GetAttributeValueAsUnsigned(&dwarf_cu, DW_AT_GNU_dwo_id, 0);
   if (!dwo_id)
     dwo_id = cu_die.GetAttributeValueAsUnsigned(&dwarf_cu, DW_AT_dwo_id, 0);

lldb/source/Symbol/CompileUnit.cpp

 //===-- CompileUnit.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/Timer.h"
 
 using namespace lldb;

 
 void CompileUnit::DumpSymbolContext(Stream *s) {
   GetModule()->DumpSymbolContext(s);
   s->Printf(", CompileUnit{0x%8.8" PRIx64 "}", GetID());
 }
 
 void CompileUnit::GetDescription(Stream *s,
                                  lldb::DescriptionLevel level) const {
-  const char *language = Language::GetNameForLanguageType(m_language);
+  const char *language = GetCachedLanguage();
   *s << "id = " << (const UserID &)*this << ", file = \""
      << this->GetPrimaryFile() << "\", language = \"" << language << '"';
 }
 
 void CompileUnit::ForeachFunction(
     llvm::function_ref<bool(const FunctionSP &)> lambda) const {
   std::vector<lldb::FunctionSP> sorted_functions;
   sorted_functions.reserve(m_functions_by_uid.size());
lldb::FunctionSP CompileUnit::FindFunction(
 
   for (auto &p : m_functions_by_uid) {
     if (matching_lambda(p.second))
       return p.second;
   }
   return {};
 }
 
+const char *CompileUnit::GetCachedLanguage() const {
+  if (m_flags.IsClear(flagsParsedLanguage))
+    return "<not loaded>";
+  return Language::GetNameForLanguageType(m_language);
+}
+
 // Dump the current contents of this object. No functions that cause on demand
 // parsing of functions, globals, statics are called, so this is a good
 // function to call to get an idea of the current contents of the CompileUnit
 // object.
 void CompileUnit::Dump(Stream *s, bool show_context) const {
-  const char *language = Language::GetNameForLanguageType(m_language);
+  const char *language = GetCachedLanguage();
 
   s->Printf("%p: ", static_cast<const void *>(this));
   s->Indent();
   *s << "CompileUnit" << static_cast<const UserID &>(*this) << ", language = \""
      << language << "\", file = '" << GetPrimaryFile() << "'\n";
 
   //  m_types.Dump(s);
 
else
     m_flags.Set(flagsParsedLineTable);
   m_line_table_up.reset(line_table);
 }
 
 void CompileUnit::SetSupportFiles(const FileSpecList &support_files) {
   m_support_files = support_files;
 }
 
 DebugMacros *CompileUnit::GetDebugMacros() {
   if (m_debug_macros_sp.get() == nullptr) {
     if (m_flags.IsClear(flagsParsedDebugMacros)) {
       m_flags.Set(flagsParsedDebugMacros);
       if (SymbolFile *symfile = GetModule()->GetSymbolFile())
         symfile->ParseDebugMacros(*this);
     }
   }
 
   return m_debug_macros_sp.get();

lldb/test/Shell/SymbolFile/DWARF/lit.local.cfg

-config.suffixes = ['.cpp', '.m', '.mm', '.s', '.test', '.ll']
+config.suffixes = ['.cpp', '.m', '.mm', '.s', '.test', '.ll', '.c']

lldb/test/Shell/SymbolFile/DWARF/x86/dwarf5-lazy-dwo.c

+// Test we load dwo information lazily.
+
+// RUN: %clang_host %s -fno-standalone-debug -g \
+// RUN:   -gdwarf-5 -gpubnames -gsplit-dwarf -c -o %t1.o -DONE
+// RUN: %clang_host %s -fno-standalone-debug -g \
+// RUN:   -gdwarf-5 -gpubnames -gsplit-dwarf -c -o %t2.o -DTWO
+// RUN: %clang_host %t1.o %t2.o -o %t
+// RUN: %lldb %t -o "log enable ll""db object" -o "b main" -o "run" -o "image lookup -n main -v" -b | FileCheck %s
+
+// CHECK: (lldb) b main
+// CHECK-NOT: 2.dwo,
+// CHECK: 1.dwo,
+// CHECK-NOT: 2.dwo,
+// CHECK: (lldb) run
+// CHECK-NOT: 2.dwo,
+// CHECK: stop reason = breakpoint
+// CHECK-NOT: 2.dwo,
+// CHECK: (lldb) image lookup
+// CHECK-NOT: 2.dwo,
+// CHECK: CompileUnit: id = {0x00000000}, file =
+// CHECK-SAME: language = "c99"
+
+#ifdef ONE
+int main() { return 0; }
+#else
+int x;
+#endif

lldb/test/Shell/SymbolFile/DWARF/x86/dwp.s

 # RUN: llvm-mc --filetype=obj --triple x86_64-pc-linux %s -o %t --defsym MAIN=0
 # RUN: llvm-mc --filetype=obj --triple x86_64-pc-linux %s -o %t.dwp --defsym DWP=0
 # RUN: %lldb %t -o "target variable A" -o "image lookup -v -n F1" -b | FileCheck %s
 # RUN: lldb-test symbols %t | FileCheck %s --check-prefix=SYMBOLS
 
 # CHECK-LABEL: target variable A
 # CHECK: (INT0) A = 0
 # CHECK: (INT1) A = 1
 # CHECK: (INT2) A = 2
 # CHECK: (INT3) A = 3
 
 # CHECK-LABEL: image lookup -v -n F1
-# CHECK: CompileUnit: id = {0x00000001}, file = "1.c", language = "unknown"
+# CHECK: CompileUnit: id = {0x00000001}, file = "1.c", language = "<not loaded>"
 # CHECK: Function: {{.*}}, name = "F1", range = [0x0000000000000001-0x0000000000000002)
 # CHECK: Variable: {{.*}}, name = "x", type = "int", location = DW_OP_reg1 RDX
 
 # SYMBOLS:      Compile units:
-# SYMBOLS-NEXT: CompileUnit{0x00000000}, language = "unknown", file = '0.c'
+# SYMBOLS-NEXT: CompileUnit{0x00000000}, language = "<not loaded>", file = '0.c'
 # SYMBOLS-NEXT:   Variable{{.*}}, name = "A", {{.*}}, location = DW_OP_GNU_addr_index 0x0
 # SYMBOLS-NEXT:   Function{{.*}}, demangled = F0
 # SYMBOLS-NEXT:   Block{{.*}}, ranges = [0x00000000-0x00000001)
 # SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location = 
 # SYMBOLS-NEXT:       DW_LLE_startx_length   (0x0000000000000001, 0x0000000000000001): DW_OP_reg0 RAX
 # SYMBOLS-EMPTY:
-# SYMBOLS-NEXT: CompileUnit{0x00000001}, language = "unknown", file = '1.c'
+# SYMBOLS-NEXT: CompileUnit{0x00000001}, language = "<not loaded>", file = '1.c'
 # SYMBOLS-NEXT:   Variable{{.*}}, name = "A", {{.*}}, location = DW_OP_GNU_addr_index 0x2
 # SYMBOLS-NEXT:   Function{{.*}}, demangled = F1
 # SYMBOLS-NEXT:   Block{{.*}}, ranges = [0x00000001-0x00000002)
 # SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location = 
 # SYMBOLS-NEXT:       DW_LLE_startx_length   (0x0000000000000003, 0x0000000000000001): DW_OP_reg1 RDX
 # SYMBOLS-EMPTY:
-# SYMBOLS-NEXT: CompileUnit{0x00000002}, language = "unknown", file = '2.c'
+# SYMBOLS-NEXT: CompileUnit{0x00000002}, language = "<not loaded>", file = '2.c'
 # SYMBOLS-NEXT:   Variable{{.*}}, name = "A", {{.*}}, location = DW_OP_GNU_addr_index 0x4
 # SYMBOLS-NEXT:   Function{{.*}}, demangled = F2
 # SYMBOLS-NEXT:   Block{{.*}}, ranges = [0x00000002-0x00000003)
 # SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location = 
 # SYMBOLS-NEXT:       DW_LLE_startx_length   (0x0000000000000005, 0x0000000000000001): DW_OP_reg2 RCX
 # SYMBOLS-EMPTY:
-# SYMBOLS-NEXT: CompileUnit{0x00000003}, language = "unknown", file = '3.c'
+# SYMBOLS-NEXT: CompileUnit{0x00000003}, language = "<not loaded>", file = '3.c'
 # SYMBOLS-NEXT:   Variable{{.*}}, name = "A", {{.*}}, location = DW_OP_GNU_addr_index 0x6
 # SYMBOLS-NEXT:   Function{{.*}}, demangled = F3
 # SYMBOLS-NEXT:   Block{{.*}}, ranges = [0x00000003-0x00000004)
 # SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location = 
 # SYMBOLS-NEXT:       DW_LLE_startx_length   (0x0000000000000007, 0x0000000000000001): DW_OP_reg3 RBX
 # SYMBOLS-EMPTY:
-# SYMBOLS-NEXT: CompileUnit{0x00000004}, language = "unknown", file = ''
+# SYMBOLS-NEXT: CompileUnit{0x00000004}, language = "<not loaded>", file = ''
 # SYMBOLS-EMPTY:
 
         .section        .debug_abbrev,"",@progbits
         .byte   1                       # Abbreviation Code
         .byte   17                      # DW_TAG_compile_unit
         .byte   0                       # DW_CHILDREN_no
         .ascii  "\260B"                 # DW_AT_GNU_dwo_name
         .byte   8                       # DW_FORM_string

lldb/test/Shell/SymbolFile/DWARF/x86/split-optimized.c

+// Test that optimized flag is properly included in DWARF.
+
+// RUN: %clang_host %s -fno-standalone-debug -glldb \
+// RUN:   -gdwarf-5 -gpubnames -gsplit-dwarf -O3 -c -o %t1.o
+
+// RUN: llvm-dwarfdump %t1.o | FileCheck %s --check-prefix DWARFDUMP_O
+// RUN: llvm-dwarfdump %t1.dwo | FileCheck %s --check-prefix DWARFDUMP_DWO
+// RUN: %lldb -b -o 'script lldb.SBDebugger.Create().CreateTarget("%t1.o").FindFunctions("main",lldb.eFunctionNameTypeAuto).GetContextAtIndex(0).GetFunction().GetIsOptimized()' | FileCheck %s
+
+// DWARFDUMP_O-NOT: DW_AT_APPLE_optimized
+//
+// DWARFDUMP_DWO: DW_TAG_compile_unit
+// DWARFDUMP_DWO-NOT: DW_TAG_
+// DWARFDUMP_DWO: DW_AT_APPLE_optimized (true)
+
+// CHECK: (lldb) script lldb.SBDebugger.Create()
+// CHECK-NEXT: True
+
+int main(void) { return 0; }