[lldb][ELF] Read symbols from .gnu_debugdata sect.

[kwk]

Summary

If the .symtab section is stripped from the binary it might be that
there's a .gnu_debugdata section which contains a smaller .symtab in
order to provide enough information to create a backtrace with function
names or to set and hit a breakpoint on a function name.

This change looks for a .gnu_debugdata section in the ELF object file.
The .gnu_debugdata section contains a xz-compressed ELF file with a
.symtab section inside. Symbols from that compressed .symtab section
are merged with the main object file's .dynsym symbols (if any).
In addition we always load the .dynsym even if there's a .symtab
section.

For example, the Fedora and RHEL operating systems strip their binaries
but keep a .gnu_debugdata section. While gdb already can read this
section, LLDB until this patch couldn't. To test this patch on a
Fedora or RHEL operating system, try to set a breakpoint on the "help"
symbol in the "zip" binary. Before this patch, only GDB can set this
breakpoint; now LLDB also can do so without installing extra debug
symbols:

lldb /usr/bin/zip -b -o "b help" -o "r" -o "bt" -- -h

The above line runs LLDB in batch mode and on the "/usr/bin/zip -h"
target:

(lldb) target create "/usr/bin/zip"
Current executable set to '/usr/bin/zip' (x86_64).
(lldb) settings set -- target.run-args  "-h"

Before the program starts, we set a breakpoint on the "help" symbol:

(lldb) b help
Breakpoint 1: where = zip`help, address = 0x00000000004093b0

Once the program is run and has hit the breakpoint we ask for a
backtrace:

(lldb) r
Process 10073 stopped
* thread #1, name = 'zip', stop reason = breakpoint 1.1
    frame #0: 0x00000000004093b0 zip`help
zip`help:
->  0x4093b0 <+0>:  pushq  %r12
    0x4093b2 <+2>:  movq   0x2af5f(%rip), %rsi       ;  + 4056
    0x4093b9 <+9>:  movl   $0x1, %edi
    0x4093be <+14>: xorl   %eax, %eax

Process 10073 launched: '/usr/bin/zip' (x86_64)
(lldb) bt
* thread #1, name = 'zip', stop reason = breakpoint 1.1
  * frame #0: 0x00000000004093b0 zip`help
    frame #1: 0x0000000000403970 zip`main + 3248
    frame #2: 0x00007ffff7d8bf33 libc.so.6`__libc_start_main + 243
    frame #3: 0x0000000000408cee zip`_start + 46

In order to support the .gnu_debugdata section, one has to have LZMA
development headers installed. The CMake section, that controls this
part looks for the LZMA headers and enables .gnu_debugdata support by
default if they are found; otherwise or if explicitly requested, the
minidebuginfo support is disabled.

GDB supports the "mini debuginfo" section .gnu_debugdata since v7.6
(2013).

[kwk]

lldb/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

77

Fixed in f509e547ab793068e8b822317b93060077623b74

llvm/CMakeLists.txt

53–361

Fixed in d4236447e75a882ab61bd369cb8253f2a908368f

[kwk]

• Moved and renamed m_gnu_debug_data_object_file

[kwk]

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

395

Fixed in 0427898acf4a292f9737a33059e985239cc0e640

[labath]

lldb/cmake/modules/LLDBConfig.cmake

337 ↗

(On Diff #218300)

This looks like a really useful macro. I'll be sure to remember it.

338 ↗

(On Diff #218300)

It doesn't look like this is used anywhere.

341 ↗

(On Diff #218300)

Please put this into Config.h.cmake. I know a lot of code in this file does not do that, but that's because we didn't have a Config.h back then.

344 ↗

(On Diff #218300)

Is this code actually reachable? My understanding is that LLDB_ENABLE_LZMA should be automatically false if LIBLZMA_FOUND is not true...

lldb/source/Host/common/LZMA.cpp

82–83

printf format string here.

92

This is a valid printf string, but I am not sure if you intended it to come out like {lzma error: LZMA_MEMLIMIT_ERROR}

93

Calling .data() on a StringRef and expecting to get a c string is ill-advised. convertLZMACodeToString is a local static function, you could just make it return a const char *...

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

1978

No, I think you should just delete this bit of code completely (as the containing object file will call SetModulesArchitecture on its own).

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

157–164

This doesn't need to be public now, right?

lldb/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

70

Using a unique_ptr is not a bad idea, but as right now this patch does not need to touch this file, it shouldn't be done as a part of this patch. Feel free to submit the unique_ptr thingy as a separate patch. No need to go through the review process...

lldb/test/CMakeLists.txt

119–121

I'd just make this unconditional, and add the tools to the big lldb-test-deps block.

[labath]

lldb/cmake/modules/LLDBConfig.cmake

341 ↗

(On Diff #218300)

(Among other things, this helps with incremental rebuilds, as only the files which include Config.h need to be recompiled)

[kwk]

• Remove left-over variable in CMake
• Move LLDB_ENABLE_LZMA into Config.h.cmake
• Remove unused code
• Change signature of lldb_private::lzma::uncompress
• Fixup
• Fixup
• When using the ObjectFile's own GetArchitecture(), no debug symbols are found
• Make GetGnuDebugDataObjectFile private
• Cleanup
• moved llvm-nm llvm-strip as test dependencies

[kwk]

@labath I did go over a lot of your comments. Thank you for helping me in becoming in a better contributor. I'm still not done with the python/make -> lit test transition but the rest is mostly covered.

lldb/cmake/modules/LLDBConfig.cmake

337 ↗

(On Diff #218300)

Make sure to include include(CMakeDependentOption)

338 ↗

(On Diff #218300)

Right, that was a left-over. Removed in 7dc045e67bb.

341 ↗

(On Diff #218300)

Addressed in a6277c07451

344 ↗

(On Diff #218300)

The logic is as follows:

LLDB_ENABLE_LZMA is ON if LIBLZMA_FOUND is ON.

Until now I though that can always go ahead and manually toggle on the option LLDB_ENABLE_LZMA by hand. And if you do this when LZMA is not available, then you get the fatal error. But as I understand [1] after reading it more than once, I think you're right: "This macro presents an option to the user only if a set of other conditions are true."

Let me verify this with a small example... yes, you're right. Even if you specify cmake . -DLLVM_ENABLE_LZMA it will not enable the option. Awesome! Fixed in 156f0af8c29980139ff1a2a8e51a768050564898

[1]: https://cmake.org/cmake/help/v3.0/module/CMakeDependentOption.html

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

1978

Let me try if it works how you suggested it. No, it doesn't work as no breakpoint from the embedded .gnu_debugdata section will be hit anymore. This section was inspired by ObjectFileELF::CreateInstance as you suggested to look at once.

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

157–164

Right, now that it is only called from CreateSections, it can be made private again. Fixed in bb1f3f0b5bd.

lldb/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

70

It wasn't an idea but a necessity back when the whole minidebuginfo stuff was here. It still is a left-over that I have remove this change.

lldb/test/CMakeLists.txt

119–121

Done 1d731e225a243bb2afb66eb1f06cd010ee094208

[labath]

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

1978

I'd be very surprised if this makes a difference as calling SetModulesArchitecture just invokes Module::SetArchitecture, which is actually a no-op if the module architecture has already been set.

However, I see now that SetArchitecture also acts as a check, which ensures that the architecture of the (nested) object file is compatible with the module architecture. This bit sounds like a useful check against someone accidentally (however unlikely) embedding a different object file into the gnu_debugdata section, so I guess we can keep that.

[kwk]

• add lit test for minidebuginfo
• Fixup
• test
• Fiddle with the lit test
• Fix binary in lit test
• Working lit test - still need to only run it when minidebuginfo is available (LZMA)
• Make FileCheck less verbose
• Only run minidebuginfo lit test when lzma is available
• fix mylib.so not found problem
• Removed old python based minidebuginfo test
• Remove changes that were only necessary for the old python based test for minidebuginfo

[kwk]

• remove not needed <vector> include

[kwk]

squashed and rebased on top of master

[labath]

I think we're getting pretty close. I have a couple of extra comments inline, but they're all pretty minor, I hope. I'd just like to add some more tests, per our discussion on the IRC, and I have some doubts about what exactly is the test you've written actually testing, which I'd like to clarify...

lldb/CMakeLists.txt

101 ↗

(On Diff #218618)

It looks like you're already adding these in lldb/lit/CMakeLists.txt. Does it need to be in both?

lldb/include/lldb/Host/LZMA.h

25–26

Now that the vector is auto-resized, do you think it's still useful to expose the getUncompressedSize function as public api? If yes, then please change it to return Expected<uint64_t>. (returning Expected would be nice even for a private api, but there it's less important...)

lldb/lit/Breakpoint/Inputs/minidebuginfo-lib.h

1 ↗

(On Diff #218623)

Hmm... so, what is the exact scenario you want to test here? This function will end up in the dynsym section of the main executable, but it will be an *undefined* symbol there. Undefined symbols are ignored in the gnu_debugdata logic. The symbol will be *defined* in the dynsym section of the shared library, but you're not debugdata-ing that one.

While this scenario might be interesting to test, I am not sure if that's the one you actually intended...

PS: If you want to create a file with both dynsym, and non-dynsym defined symbols, you don't have to resort to using shared libraries to achieve that. A suitable combination of -rdynamic and visibility("hidden") will achieve that too. For example the following line:

clang -x c - <<<'__attribute__((visibility("hidden"))) int in_symtab() { return 42; } int in_dynsym() { return 47; } int main() { return in_symtab()+in_dynsym(); }' -rdynamic

will generate a file where the in_symtab function will only be present in the symtab, and in_dynsym will be in the dynsym section (until you apply the debug-data magic, it will be in the symtab too)...

lldb/lit/Breakpoint/minidebuginfo.test

32 ↗

(On Diff #218623)

Shouldn't this be %t.keep_symbols? Typo ?

lldb/lit/lit.cfg.py

102 ↗

(On Diff #218623)

you should apply llvm_canonicalize_cmake_booleans to the value of LLDB_ENABLE_LZMA at the cmake level. Otherwise, this will blow up if someone types -DLLDB_ENABLE_LZMA=On

lldb/source/Host/common/LZMA.cpp

73–83

too much auto

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

1886

You don't need the temporary ArrayRef. You can just pass data.GetData() directly..

[kwk]

• Fixup
• Test for minidebuginfo image dump symtab
• Fixed test for corrupted xz blob
• Fix test
• Added test that runs when no LZMA is configured

[kwk]

• Fixup
• Test for minidebuginfo image dump symtab
• Fixed test for corrupted xz blob
• Fix test
• Added test that runs when no LZMA is configured

[kwk]

• Better names for minidebuginfo files

[kwk]

• Better names for minidebuginfo files

[kwk]

• Fix spelling error

[labath]

Thank you for adding the tests, and for adding the xz detection to lit in particular. We're getting _reaally_ close now. I have a bunch more comments, including highlighting some you seems to have missed from earlier, but they are all just about polishing. The only somewhat larger comment is about the minidebuginfo-set-and-hit-breakpoint.test test. I'd like to understand what exactly is the scenario you are intending to test there, because I have a feeling it's not testing what you want it to test...

lldb/CMakeLists.txt

101 ↗

(On Diff #218618)

What about this?

lldb/include/lldb/Host/LZMA.h

25–26

What about this?

lldb/lit/Breakpoint/minidebuginfo-corrupt-xz.yaml

1 ↗

(On Diff #219038)

These tests should go to lit/Modules/ELF, as they have nothing to do with breakpoints, and everything to do with ELF files. The minidebuginfo-set-and-hit-breakpoint.test might stay here as it actually does deal with breakpoints, but it would also make sense to put it next to the ELF tests. I'll leave it up to you to decide where to place that one.

13 ↗

(On Diff #219038)

You shouldn't need an explicit -x in these tests as %lldb adds --no-use-colors already.

lldb/lit/Breakpoint/minidebuginfo-find-symbols.yaml

15 ↗

(On Diff #219038)

Could you add a symbol or two to the dynsym section of the outer file? I'd like to test that we get symbols from .dynsym *and* .symtab sections.

lldb/lit/Breakpoint/minidebuginfo-no-lzma.yaml

22 ↗

(On Diff #219038)

Nit: You most likely don't need such a gigantic blob to test this bit of functionality, as you can't read the data anyway...

lldb/lit/Breakpoint/minidebuginfo-set-and-hit-breakpoint.test

50 ↗

(On Diff #219038)

Instead of messing with the environment, it might be better to just set the rpath (-Wl,-rpath) of the executable appropriately (but I would still like to know what you're exactly trying to test with that extra shared library).

lldb/lit/lit.cfg.py

102 ↗

(On Diff #218623)

What about this?

lldb/source/Host/common/LZMA.cpp

73–83

What about this? (I think both of the autos here are unnecessary).

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

1850

I didn't notice this before, but you shouln't be calling module->GetSectionList() here. The unified_section_list you got as an argument *is* the module's section list.

1886

What about this?

[labath]

lldb/lit/Breakpoint/minidebuginfo-corrupt-xz.yaml

13 ↗

(On Diff #219038)

Actually, I take this back. It seems %lldb does not pass this automatically. I am not sure why, but since colors aren't a problem you here, you probably don't have to explicitly disable them anyway...

[kwk]

• Removed not needed test dependencies
• Changed return type of lzma::getUncompressedSize
• Moved minidebuginfo to subtree that deals with ELF
• Apply review comments

[kwk]

I've tackled the easy comments now and will come back to the more detailed ones as well. I'm not ignoring them.

lldb/CMakeLists.txt

101 ↗

(On Diff #218618)

You're right. one place is enough.

[kwk]

lldb/include/lldb/Host/LZMA.h

25–26

I've changed the syntax as you suggested. I kept the function there because I find it easier to maintain this way.

lldb/lit/Breakpoint/minidebuginfo-corrupt-xz.yaml

1 ↗

(On Diff #219038)

I've move all to lit/Modules/ELF.

13 ↗

(On Diff #219038)

I use -x and not -X. See lldb --help:

-x Alias for --no-lldbinit
-X Alias for --no-use-color

lldb/lit/Breakpoint/minidebuginfo-no-lzma.yaml

22 ↗

(On Diff #219038)

I kept it the same for the like the other files so you can text-diff it to find out that only one byte was modified. I thought this is a neat idea in order to actually error out upon decompression and not on file header for example. That being said what do you think about adding tests for the different errors that can occur during the whole inspection (e.g. in getUncompressedSize).

lldb/source/Host/common/LZMA.cpp

82–83

All done now.

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

1850

Done.

1886

Sorry for missing this. Done now.

[labath]

lldb/include/lldb/Host/LZMA.h

25–26

Ok. I am fine with that.

lldb/lit/Breakpoint/minidebuginfo-corrupt-xz.yaml

13 ↗

(On Diff #219038)

Ah, my bad. In that case you definitely *can* remove it because %lldb does add --no-lldbinit.

lldb/lit/Breakpoint/minidebuginfo-no-lzma.yaml

22 ↗

(On Diff #219038)

Ok. That's fine with me.
I am definitely not *against* adding more tests. :) I am not going to ask you to put more in because this patch already has more tests than most lldb patches, but I you want to do that, then by all means, go ahead. Things like these would be probably better off as a (c++) unit test, as they're really testing the details of the lzma handling code. The elf code doesn't really care about these details -- it just wants to know whether the decompression was successful or not.

[kwk]

labath, please see my answer to your question and maybe help me out why you think I don't test what I want to test.

lldb/lit/Breakpoint/minidebuginfo-set-and-hit-breakpoint.test

50 ↗

(On Diff #219038)

labath, I'd like to test the following scenario: Set a breakpoint on a symbol (multiplyByThree) in the .dynsym section and one on a symbol (multiplyByFour) from the .symtab that's embedded within the .gnu_debugdata section. I have no clue how to get those symbols without using a shared lib. Do you?

[kwk]

lldb/lit/Breakpoint/minidebuginfo-set-and-hit-breakpoint.test

50 ↗

(On Diff #219038)

I found a better and simpler way thanks to the help from @jankratochvil . Will implement it soon.

[MaskRay]

lldb/source/Host/common/LZMA.cpp

125

empty

130

if (auto err = ...)

return err;

137

is more common

139

stray inpos = 0;

[kwk]

• Remove -x from %lldb because that expands to the command which already includes it
• Improve and fix the minidebuginfo-set-and-hit-breakpoint.test

[kwk]

@labath I have greatly improved the set and hit breakpoint test. Thank you again @jankratochvil for bringing my attention to -Wl,--dynamic-list. That helped to put one symbol in .dynsym explicitly. I will see if I can utilize that knowledge to separate out the patch this comment of yours @labath :

Let's put this bit into a separate patch. As I said over IRC, I view this bit as functionally independent of the debugdata stuff (it's definitely independent in it's current form, as it will kick in for non-debugdata files too, which I think is fine).

[kwk]

Rebased on master to include changes from D67390

[kwk]

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

2728–2749

Done in D67390.

[labath]

This looks great now. Thank you for your patience. Just make sure to deal with the breakages from the other patch first. If the fix is non trivial, or if it's going to take a while, then please revert to unbreak the bots.

lldb/lit/Modules/ELF/minidebuginfo-corrupt-xz.yaml

1 ↗

(On Diff #219680)

system-linux shouldn't be required here. One of the reasons I wanted to have these tests is that they can run on any system, not just on linux.

lldb/lit/Modules/ELF/minidebuginfo-find-symbols.yaml

1 ↗

(On Diff #219680)

No system-linux

lldb/lit/Modules/ELF/minidebuginfo-no-lzma.yaml

1 ↗

(On Diff #219680)

no system-linux

lldb/source/Host/common/LZMA.cpp

130

I have a feeling this pattern is actually more common in lldb. I tend to use this one, but I am fine with either.

[kwk]

• Addressed review comments

[kwk]

This comment was removed by kwk.

lldb/source/Host/common/LZMA.cpp

130

So what now? I had getCompressedSize return an error before and changed it upon request to expected. I can live with both but like the expected thing a bit better in terms of: this goes in and this comes out mentality.

[kwk]

lldb/lit/Modules/ELF/minidebuginfo-corrupt-xz.yaml

1 ↗

(On Diff #219680)

@labath what about the other file minidebuginfo-set-and-hit-breakpoint.test. Remove system-linux from there as well?

[labath]

lldb/lit/Modules/ELF/minidebuginfo-corrupt-xz.yaml

1 ↗

(On Diff #219680)

You need to restrict that test somehow, because it only has a chance for working on elf platforms (as you're compiling binaries for the host and running them). It probably *should* work on all elf platforms, but we currently don't have a good way of expressing that and we're just restricting to system-linux currently.

If you feel adventurous you can try introducing a system-elf feature (or something), and then changing this test (and possibly others) to use that instead, but please do that as a separate patch.

lldb/source/Host/common/LZMA.cpp

130

My interpretation of @MaskRay's comment was that he wanted you do write something like

if (auto err = uncompressedSize.takeError())
  return err;

That is orthogonal to what type is returned by getCompressedSize, and is indeed a more common pattern in at least some parts of llvm. I am personally fine with both.

[kwk]

• Change logic and comment for when .dynsym is parsed
• Use different pattern for error checking
• use less auto
• Remove required system-linux test feature from LZMA tests

[kwk]

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

2728–2749

We agreed to not have this other patch. See D67390#1691424.

[kwk]

Tests did pass so this change is ready for review @labath @jankratochvil .

[jankratochvil]

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

1854

I miss here comparing that the sections inside .gnu_debugdata file match sections in the outer file:

jankratochvil: "hm.... I was under the impression that section number should remain the same in regular and split debug files" - maybe you are right but then we could just also compare the two section tables and if they differ then reject whole .gnu_debugdata.  And then we do not have to compare section names but it is enough to compare section indexes.
labath: "right but then we could just also compare the two section tables and if they differ then reject whole .gnu_debugdata."
labath: I would like that ^

Also I do not see here handling .strtab, why does it work without moving also .strtab?

[labath]

Ok, let's try this once more. I took another look at the patch, and I have some more tiny comments, but nothing too major.

I'm sorry this took so long. When the topic of parsing both symbol sections came up, I was happy that it was implemented in a way that applies outside of minidebuginfo too, because it seemed like it could be a useful source of additional information. However, that turned into a huge rabbit hole, which isn't really relevant for the thing you're trying to accomplish. If we've managed to come this far without needing to consult both symbol tables, I think we'll manage to wait a couple years longer.

lldb/lit/Modules/ELF/minidebuginfo-no-lzma.yaml

4 ↗

(On Diff #222845)

s/a. /a ./

lldb/source/Host/common/LZMA.cpp

2

Fix header.

70–73

This is redundant, as you're comparing the size against LZMA_STREAM_HEADER_SIZE anyway.

85

Maybe InputBuffer.take_back(LZMA_STREAM_HEADER_SIZE).data() ?

105–106

same here.

126–129

This is redundant, as getUncompressedSize checks that anyway.

138

= UINT64_MAX;. This looks too much like a function declaration, and is not consistent with the code below.

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

1854

I'd leave that out for now. This is similar stuff to what is already being done in SymbolVendorELF, which should also probably check for section matches, and would be best handled together.

The reason that this works without moving .strtab is because the parsing is still done within the context of the owning object file. This whole section merging business is a pretty big mess, and in dire need of some TLC, but @kwk is not making that worse, so I wouldn't want to deal with that here...

2738

You can add that this is because minidebuginfo normally removes the symtab symbols which have their matching dynsym counterparts.

[kwk]

• Fix typo: s/a. /a ./
• Fix comment header
• Remove redundant input buffer check
• Remove another redundant input buffer check
• Change variable initialization to assign
• added comment about minidebuginfo

[kwk]

@labath I've addressed all you comments. Thank you for answering @jankratochvil's question as well. If this patch is good to go now, please give a thumbs up.

lldb/source/Host/common/LZMA.cpp

85

take_back:

Return a copy of *this with only the last \p N elements.

I mean LZMA_STREAM_HEADER_SIZE is only 12 but do we really need it?

105–106

Same answer here.

[kwk]

@labath ah, I've just seen that you did accept the revision already. Will merge it then after running tests once more.

[kwk]

Rebased onto current master

[kwk]

@labath as much as I would love to merge this patch I get errors from these tests that I didn't see before. They only appear after rebasing onto master:

Failing Tests (4):
    lldb-Suite :: commands/process/attach/TestProcessAttach.py
    lldb-Suite :: python_api/hello_world/TestHelloWorld.py
    lldb-Suite :: tools/lldb-server/libraries-svr4/TestGdbRemoteLibrariesSvr4Support.py
    lldb-Suite :: tools/lldb-vscode/attach/TestVSCode_attach.py

I also get the same errors on current master .(revision 8815be04ec1f333564591d9593735f22efa9bee5) without my patch applied. But before I merrge my patch I'd like to see master in a better shape, no?

[jankratochvil]

In D66791#1696340, @kwk wrote:

lldb-Suite :: commands/process/attach/TestProcessAttach.py
lldb-Suite :: tools/lldb-vscode/attach/TestVSCode_attach.py

These are by: D68289

lldb-Suite :: python_api/hello_world/TestHelloWorld.py
lldb-Suite :: tools/lldb-server/libraries-svr4/TestGdbRemoteLibrariesSvr4Support.py

The Fedora buildbot shows different two ones:

lldb-Suite :: commands/gui/basic/TestGuiBasic.py
lldb-Suite :: python_api/hello_world/TestHelloWorld.py

Although I do not have those reproducible on my local Fedora 30 host.

[kwk]

rebased

[kwk]

Closed by 2c082b48274fcba62bf9b3acb63075aedcc7a976.

[labath]

lldb/source/Host/common/LZMA.cpp

85

Yeah, that documentation is somewhat misleading. If you look at the implementation you'll see that there's no copying involved (ArrayRefs never copy anything -- that's their whole point of existence). So, I still think that this is better/more readable with take_back.

lldb/include/lldb/Host/LZMA.h

+//===-- LZMA.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 liblldb_Host_LZMA_h_
+#define liblldb_Host_LZMA_h_
+
+#include <vector>
+
+namespace llvm {
+class Error;
+} // End of namespace llvm
+
+namespace lldb_private {
+
+namespace lzma {
+  
+bool isAvailable();
+
+llvm::Error getUncompressedSize(const uint8_t *compressedBuffer,
+                                uint64_t compressedBufferSize,
+                                uint64_t &uncompressedSize);
+
+llvm::Error uncompress(const uint8_t *compressedBuffer,
+                       uint64_t compressedBufferSize, uint8_t *uncompressedData,
+                       uint64_t uncompressedSize);
+
+} // End of namespace lzma
+
+} // End of namespace lldb_private
+
+#endif // liblldb_Host_LZMA_h_

lldb/packages/Python/lldbsuite/test/decorators.py

 def skipIfXmlSupportMissing(func):
     config = lldb.SBDebugger.GetBuildConfiguration()
     xml = config.GetValueForKey("xml")
 
     fail_value = True # More likely to notice if something goes wrong
     have_xml = xml.GetValueForKey("value").GetBooleanValue(fail_value)
     return unittest2.skipIf(not have_xml, "requires xml support")(func)
 
+def skipIfLzmaSupportMissing(func):
+    config = lldb.SBDebugger.GetBuildConfiguration()
+    lzma = config.GetValueForKey("lzma")
+
+    fail_value = True # More likely to notice if something goes wrong
+    have_lzma = lzma.GetValueForKey("value").GetBooleanValue(fail_value)
+    return unittest2.skipIf(not have_lzma, "requires lzma support")(func)
+
 def skipIfLLVMTargetMissing(target):
     config = lldb.SBDebugger.GetBuildConfiguration()
     targets = config.GetValueForKey("targets").GetValueForKey("value")
     found = False
     for i in range(targets.GetSize()):
         if targets.GetItemAtIndex(i).GetStringValue(99) == target:
             found = True
             break

lldb/packages/Python/lldbsuite/test/linux/minidebuginfo/Makefile

+LEVEL = ../../make
+C_SOURCES := main.c
+
+all: clean binary
+
+.PHONY: binary
+binary: a.out
+  $(RM) -r $@
+  cp a.out binary
+  
+  # The following section is adapted from GDB's official documentation:
+  # http://sourceware.org/gdb/current/onlinedocs/gdb/MiniDebugInfo.html#MiniDebugInfo
+  
+  # Extract the dynamic symbols from the main binary, there is no need
+  # to also have these in the normal symbol table.
+  $(LLVMNM) -D binary --format=posix --defined-only \
+    | awk '{ print $$1 }' | sort > dynsyms
+  
+  # Extract all the text (i.e. function) symbols from the debuginfo.
+  # (Note that we actually also accept "D" symbols, for the benefit
+  # of platforms like PowerPC64 that use function descriptors.)
+  $(LLVMNM) binary --format=posix --defined-only \
+    | awk '{ if ($$2 == "T" || $$2 == "t" || $$2 == "D") print $$1 }' \
+    | sort > funcsyms
+  
+  # Keep all the function symbols not already in the dynamic symbol
+  # table.
+  comm -13 dynsyms funcsyms > keep_symbols
+  
+  # Separate full debug info into debug binary.
+  $(OBJCOPY) --only-keep-debug binary debug
+  
+  # Copy the full debuginfo, keeping only a minimal set of symbols and
+  # removing some unnecessary sections.
+  $(OBJCOPY) -S --remove-section .gdb_index --remove-section .comment \
+    --keep-symbols=keep_symbols debug mini_debuginfo
+  
+  # Drop the full debug info from the original binary.
+  $(LLVMSTRIP) --strip-all -R .comment binary
+  
+  # Inject the compressed data into the .gnu_debugdata section of the
+  # original binary.
+  xz --keep mini_debuginfo
+  $(OBJCOPY) --add-section .gnu_debugdata=mini_debuginfo.xz binary
+  
+clean::
+  $(RM) -r mini_debuginfo \
+    mini_debuginfo.xz \
+    binary \
+    debug \
+    keep_symbols \
+    funcsyms \
+    dynsyms
+
+include $(LEVEL)/Makefile.rules

lldb/packages/Python/lldbsuite/test/linux/minidebuginfo/TestMiniDebugInfo.py

+""" Testing debugging of a binary with "mini debuginfo" in .gnu_debugdata section. """
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestMinidebugInfo(TestBase):
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        TestBase.setUp(self)
+
+    @no_debug_info_test  # Prevent the genaration of the dwarf version of this test
+    @add_test_categories(["dwo"])
+    @skipUnlessPlatform(["linux"])
+    @skipIfLzmaSupportMissing
+    def test_mini_debug_info(self):
+        """Test that we can set and hit a breakpoint on a symbol from .gnu_debugdata."""
+
+        self.build()
+        exe = self.getBuildArtifact("binary")
+    
+        self.target = self.dbg.CreateTarget(exe)
+        self.assertTrue(self.target, VALID_TARGET)
+
+        main_bp = self.target.BreakpointCreateByName("multiplyByThree", "binary")
+        self.assertTrue(main_bp, VALID_BREAKPOINT)
+
+        self.process = self.target.LaunchSimple(
+            None, None, self.get_process_working_directory())
+        self.assertTrue(self.process, PROCESS_IS_VALID)
+
+        # The stop reason of the thread should be breakpoint.
+        self.assertTrue(self.process.GetState() == lldb.eStateStopped,
+                        STOPPED_DUE_TO_BREAKPOINT)
+

lldb/packages/Python/lldbsuite/test/linux/minidebuginfo/main.c

+int multiplyByThree(int num) { return num * 3; }
+
+int main(int argc, char *argv[]) {
+  (void)argv;
+  return multiplyByThree(argc);
+}

lldb/packages/Python/lldbsuite/test/make/Makefile.rules

ifneq "$(OS)" "Darwin"
 
     ifeq "$(notdir $(CC))" "$(CC)"
         replace_cc_with = $(call replace_with,$(1),$(CC),$(CLANG_OR_GCC))
     else
         replace_cc_with = $(join $(dir $(CC)),$(call replace_with,$(1),$(notdir $(CC)),$(CLANG_OR_GCC)))
     endif
 
     OBJCOPY ?= $(call replace_cc_with,objcopy)
+    LLVMNM ?= $(call replace_cc_with,llvm-nm)
+    LLVMSTRIP ?= $(call replace_cc_with,llvm-strip)
     ARCHIVER ?= $(call replace_cc_with,ar)
     override AR = $(ARCHIVER)
 endif
 
 ifdef PIE
   LDFLAGS += -pie
 endif
 

lldb/source/API/SBDebugger.cpp

 #include "lldb/API/SBTypeSynthetic.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Host/XML.h"
+#include "lldb/Host/LZMA.h"
 #include "lldb/Initialization/SystemLifetimeManager.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupPlatform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/State.h"

 SBStructuredData SBDebugger::GetBuildConfiguration() {
   LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger,
                                     GetBuildConfiguration);
 
   auto config_up = std::make_unique<StructuredData::Dictionary>();
   AddBoolConfigEntry(
       *config_up, "xml", XMLDocument::XMLEnabled(),
       "A boolean value that indicates if XML support is enabled in LLDB");
+  AddBoolConfigEntry(
+      *config_up, "lzma", lldb_private::lzma::isAvailable(),
+      "A boolean value that indicates if LZMA support is enabled in LLDB");
   AddLLVMTargets(*config_up);
 
   SBStructuredData data;
   data.m_impl_up->SetObjectSP(std::move(config_up));
   return LLDB_RECORD_RESULT(data);
 }
 
 bool SBDebugger::StateIsRunningState(StateType state) {

lldb/source/Host/CMakeLists.txt

add_host_subdirectory(common
   common/FileSystem.cpp
   common/GetOptInc.cpp
   common/Host.cpp
   common/HostInfoBase.cpp
   common/HostNativeThreadBase.cpp
   common/HostProcess.cpp
   common/HostThread.cpp
   common/LockFileBase.cpp
+  common/LZMA.cpp
   common/MainLoop.cpp
   common/MonitoringProcessLauncher.cpp
   common/NativeProcessProtocol.cpp
   common/NativeRegisterContext.cpp
   common/NativeThreadProtocol.cpp
   common/NativeWatchpointList.cpp
   common/OptionParser.cpp
   common/PipeBase.cpp
else ()
   endif()
 endif ()
 if (HAVE_LIBDL)
   list(APPEND EXTRA_LIBS ${CMAKE_DL_LIBS})
 endif()
 if (NOT LLDB_DISABLE_LIBEDIT)
   list(APPEND EXTRA_LIBS ${libedit_LIBRARIES})
 endif()
+if (LLVM_ENABLE_LZMA)
+  list(APPEND EXTRA_LIBS ${LIBLZMA_LIBRARIES})
+endif()
 
 if (NOT LLDB_DISABLE_LIBEDIT)
   list(APPEND LLDB_LIBEDIT_LIBS ${libedit_LIBRARIES})
   if (LLVM_BUILD_STATIC)
     list(APPEND LLDB_SYSTEM_LIBS gpm)
   endif()
 endif()
 

lldb/source/Host/common/LZMA.cpp

+//===--- Compression.cpp - Compression implementation ---------------------===//
+//
+// 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 "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
+
+#ifdef LLVM_ENABLE_LZMA
+#include <lzma.h>
+#endif // LLVM_ENABLE_LZMA
+
+namespace lldb_private {
+
+namespace lzma {
+
+#ifndef LLVM_ENABLE_LZMA
+bool isAvailable() { return false; }
+llvm::Error getUncompressedSize(const uint8_t *compressedBuffer,
+                                uint64_t compressedBufferSize,
+                                uint64_t &uncompressedSize) {
+  llvm_unreachable("lzma::getUncompressedSize is unavailable");
+}
+
+llvm::Error uncompress(const uint8_t *compressedBuffer,
+                       uint64_t compressedBufferSize, uint8_t *uncompressedData,
+                       uint64_t uncompressedSize) {
+  llvm_unreachable("lzma::uncompress is unavailable");
+}
+
+#else  // LLVM_ENABLE_LZMA
+
+bool isAvailable() { return true; }
+
+static llvm::StringRef convertLZMACodeToString(lzma_ret Code) {
+  switch (Code) {
+  case LZMA_STREAM_END:
+    return "lzma error: LZMA_STREAM_END";
+  case LZMA_NO_CHECK:
+    return "lzma error: LZMA_NO_CHECK";
+  case LZMA_UNSUPPORTED_CHECK:
+    return "lzma error: LZMA_UNSUPPORTED_CHECK";
+  case LZMA_GET_CHECK:
+    return "lzma error: LZMA_GET_CHECK";
+  case LZMA_MEM_ERROR:
+    return "lzma error: LZMA_MEM_ERROR";
+  case LZMA_MEMLIMIT_ERROR:
+    return "lzma error: LZMA_MEMLIMIT_ERROR";
+  case LZMA_FORMAT_ERROR:
+    return "lzma error: LZMA_FORMAT_ERROR";
+  case LZMA_OPTIONS_ERROR:
+    return "lzma error: LZMA_OPTIONS_ERROR";
+  case LZMA_DATA_ERROR:
+    return "lzma error: LZMA_DATA_ERROR";
+  case LZMA_BUF_ERROR:
+    return "lzma error: LZMA_BUF_ERROR";
+  case LZMA_PROG_ERROR:
+    return "lzma error: LZMA_PROG_ERROR";
+  default:
+    llvm_unreachable("unknown or unexpected lzma status code");
+  }
+}
+
+llvm::Error getUncompressedSize(const uint8_t *compressedBuffer,
+                                uint64_t compressedBufferSize,
+                                uint64_t &uncompressedSize) {
+  if (!compressedBuffer || compressedBufferSize == 0) {
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        "address (%p) or size (%lu) of xz-compressed blob cannot be 0",
+        compressedBuffer, compressedBufferSize);
+  }
+
+  auto opts = lzma_stream_flags{};
+  if (compressedBufferSize < LZMA_STREAM_HEADER_SIZE) {
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        "size of xz-compressed blob ({0} bytes) is smaller than the "
+        "LZMA_STREAM_HEADER_SIZE ({1} bytes)",
+        compressedBufferSize, LZMA_STREAM_HEADER_SIZE);
+  }
+
+  // Decode xz footer.
+  auto xzerr = lzma_stream_footer_decode(
+      &opts, compressedBuffer + compressedBufferSize - LZMA_STREAM_HEADER_SIZE);
+  if (xzerr != LZMA_OK) {
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "lzma_stream_footer_decode()={%s}",
+                                   convertLZMACodeToString(xzerr).data());
+  }
+  if (compressedBufferSize < (opts.backward_size + LZMA_STREAM_HEADER_SIZE)) {
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        "xz-compressed buffer size ({%lu} bytes) too small (required at "
+        "least {%lu} bytes) ",
+        compressedBufferSize, (opts.backward_size + LZMA_STREAM_HEADER_SIZE));
+  }
+
+  // Decode xz index.
+  lzma_index *xzindex;
+  uint64_t memlimit(UINT64_MAX);
+  size_t inpos = 0;
+  xzerr =
+      lzma_index_buffer_decode(&xzindex, &memlimit, nullptr,
+                               compressedBuffer + compressedBufferSize -
+                                   LZMA_STREAM_HEADER_SIZE - opts.backward_size,
+                               &inpos, compressedBufferSize);
+  if (xzerr != LZMA_OK) {
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "lzma_index_buffer_decode()={%s}",
+                                   convertLZMACodeToString(xzerr).data());
+  }
+
+  // Get size of uncompressed file to construct an in-memory buffer of the
+  // same size on the calling end (if needed).
+  uncompressedSize = lzma_index_uncompressed_size(xzindex);
+
+  // Deallocate xz index as it is no longer needed.
+  lzma_index_end(xzindex, nullptr);
+
+  return llvm::Error::success();
+}
+
+llvm::Error uncompress(const uint8_t *compressedBuffer,
+                       uint64_t compressedBufferSize, uint8_t *uncompressedData,
+                       uint64_t uncompressedSize) {
+  if (!compressedBuffer || compressedBufferSize == 0) {
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        "address (%p) or size (%lu) of xz-compressed blob cannot be 0",
+        compressedBuffer, compressedBufferSize);
+  }
+
+  // Decompress xz buffer to buffer.
+  uint64_t memlimit(UINT64_MAX);
+  size_t inpos = 0;
+  inpos = 0;
+  size_t outpos = 0;
+  auto xzerr = lzma_stream_buffer_decode(
+      &memlimit, 0, nullptr, compressedBuffer, &inpos, compressedBufferSize,
+      uncompressedData, &outpos, uncompressedSize);
+  if (xzerr != LZMA_OK) {
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "lzma_stream_buffer_decode()={%s}",
+                                   convertLZMACodeToString(xzerr).data());
+  }
+
+  return llvm::Error::success();
+}
+#endif // LLVM_ENABLE_LZMA
+
+} // end of namespace lzma
+} // namespace lldb_private

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h

public:
   llvm::ArrayRef<elf::ELFProgramHeader> ProgramHeaders();
   lldb_private::DataExtractor GetSegmentData(const elf::ELFProgramHeader &H);
 
   llvm::StringRef
   StripLinkerSymbolAnnotations(llvm::StringRef symbol_name) const override;
 
   void RelocateSection(lldb_private::Section *section) override;
 
+  /// Takes the .gnu_debugdata and returns the decompressed object file that is
+  /// stored within that section.
+  ///
+  /// \returns either the decompressed object file stored within the
+  /// .gnu_debugdata section or \c nullptr if an error occured or if there's no
+  /// section with that name.
+  std::shared_ptr<ObjectFileELF> GetGnuDebugDataObjectFile();
+
 protected:
 
   std::vector<LoadableData>
   GetLoadableData(lldb_private::Target &target) override;
 
 private:
   ObjectFileELF(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
                 lldb::offset_t data_offset, const lldb_private::FileSpec *file,
private:
   unsigned PLTRelocationType();
 
   static lldb_private::Status
   RefineModuleDetailsFromNote(lldb_private::DataExtractor &data,
                               lldb_private::ArchSpec &arch_spec,
                               lldb_private::UUID &uuid);
 
   bool AnySegmentHasPhysicalAddress();
+
+  std::shared_ptr<ObjectFileELF> m_gnuDebugDataObjectFile;
 };
 
 #endif // liblldb_ObjectFileELF_h_

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

 #include <unordered_map>
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/FileSystem.h"
+#include "lldb/Host/LZMA.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RangeMap.h"
(InfoOr->Segment ? InfoOr->Segment->GetChildren() : *m_sections_up)
         .AddSection(section_sp);
     provider.AddSection(std::move(*InfoOr), std::move(section_sp));
   }
 
   // For eTypeDebugInfo files, the Symbol Vendor will take care of updating the
   // unified section list.
   if (GetType() != eTypeDebugInfo)
     unified_section_list = *m_sections_up;
+  
+  // If there's a .gnu_debugdata section, we'll try to read the .symtab that's
+  // embedded in there and replace the one in the original object file (if any).
+  // If there's none in the orignal object file, we add it to it.
+  SectionList *module_section_list = GetModule()->GetSectionList();
+  if (auto gdd_obj_file = GetGnuDebugDataObjectFile()) {
+    if (auto gdd_objfile_section_list = gdd_obj_file->GetSectionList()) {
+      if (SectionSP symtab_section_sp =
+              gdd_objfile_section_list->FindSectionByType(
+                  eSectionTypeELFSymbolTable, true)) {
+        SectionSP module_section_sp = module_section_list->FindSectionByType(
+            eSectionTypeELFSymbolTable, true);
+        if (module_section_sp)
+          module_section_list->ReplaceSection(module_section_sp->GetID(),
+                                              symtab_section_sp);
+        else
+          module_section_list->AddSection(symtab_section_sp);
+      }
+    }
+  }  
+}
+
+std::shared_ptr<ObjectFileELF> ObjectFileELF::GetGnuDebugDataObjectFile() {
+  if (m_gnuDebugDataObjectFile != nullptr)
+    return m_gnuDebugDataObjectFile;
+
+  SectionSP section =
+      GetSectionList()->FindSectionByName(ConstString(".gnu_debugdata"));
+  if (!section)
+    return nullptr;
+
+  if (!lldb_private::lzma::isAvailable()) {
+    GetModule()->ReportWarning(
+        "No LZMA support found for reading .gnu_debugdata section");
+    return nullptr;
+  }
+
+  // Determine size of uncompressed data
+  DataExtractor data;
+  section->GetSectionData(data);
+  uint64_t uncompressedSize = 0;
+  auto err = lldb_private::lzma::getUncompressedSize(data.GetDataStart(), data.GetByteSize(), uncompressedSize);
+  if (err) {
+    GetModule()->ReportWarning(
+        "Failed to get size of uncompressed LZMA buffer from section %s: %s",
+        section->GetName().AsCString(), Status(std::move(err)).AsCString());
+    return nullptr;
+  }
+  
+  // Uncompress into large enough buffer
+  std::vector<uint8_t> uncompressedData(uncompressedSize);
+  err =
+      lldb_private::lzma::uncompress(data.GetDataStart(), data.GetByteSize(),
+                                     uncompressedData.data(), uncompressedSize);
+  if (err) {
+    GetModule()->ReportWarning(
+        "An error occured while decompression the section %s: %s",
+        section->GetName().AsCString(), Status(std::move(err)).AsCString());
+    return nullptr;
+  }
+
+  // Construct ObjectFileELF object from decompressed buffer
+  DataBufferSP gdd_data_buf(
+      new DataBufferHeap(uncompressedData.data(), uncompressedData.size()));
+  auto fspec = GetFileSpec().CopyByAppendingPathComponent(
+      llvm::StringRef("gnu_debugdata"));
+  m_gnuDebugDataObjectFile.reset(new ObjectFileELF(
+      GetModule(), gdd_data_buf, 0, &fspec, 0, gdd_data_buf->GetByteSize()));
+
+  // This line is essential; otherwise a breakpoint can be set but not hit.
+  m_gnuDebugDataObjectFile->SetType(ObjectFile::eTypeDebugInfo);
+
+  ArchSpec spec = m_gnuDebugDataObjectFile->GetArchitecture();
+  if (spec && m_gnuDebugDataObjectFile->SetModulesArchitecture(spec))
+    return m_gnuDebugDataObjectFile;
+  
+  return nullptr;
 }
 
 // Find the arm/aarch64 mapping symbol character in the given symbol name.
 // Mapping symbols have the form of "$<char>[.<any>]*". Additionally we
 // recognize cases when the mapping symbol prefixed by an arbitrary string
 // because if a symbol prefix added to each symbol in the object file with
 // objcopy then the mapping symbols are also prefixed.
 static char FindArmAarch64MappingSymbol(const char *symbol_name) {
   if (!symbol_name)
     return '\0';
 
   const char *dollar_pos = ::strchr(symbol_name, '$');
   if (!dollar_pos || dollar_pos[1] == '\0')
     return '\0';
 
   if (dollar_pos[2] == '\0' || dollar_pos[2] == '.')
     return dollar_pos[1];
   return '\0';
 }
 
 #define STO_MIPS_ISA (3 << 6)
 #define STO_MICROMIPS (2 << 6)
 #define IS_MICROMIPS(ST_OTHER) (((ST_OTHER)&STO_MIPS_ISA) == STO_MICROMIPS)
 
 // private
 unsigned ObjectFileELF::ParseSymbols(Symtab *symtab, user_id_t start_id,
                                      SectionList *section_list,
                                      const size_t num_symbols,
                                      const DataExtractor &symtab_data,
                                      const DataExtractor &strtab_data) {
   ELFSymbol symbol;
   lldb::offset_t offset = 0;
 
   static ConstString text_section_name(".text");
   static ConstString init_section_name(".init");
   static ConstString fini_section_name(".fini");
   static ConstString ctors_section_name(".ctors");
   static ConstString dtors_section_name(".dtors");
 
   static ConstString data_section_name(".data");
   static ConstString rodata_section_name(".rodata");
   static ConstString rodata1_section_name(".rodata1");
   static ConstString data2_section_name(".data1");
   static ConstString bss_section_name(".bss");
   static ConstString opd_section_name(".opd"); // For ppc64
 
   // On Android the oatdata and the oatexec symbols in the oat and odex files
   // covers the full .text section what causes issues with displaying unusable
   // symbol name to the user and very slow unwinding speed because the
   // instruction emulation based unwind plans try to emulate all instructions
   // in these symbols. Don't add these symbols to the symbol list as they have
   // no use for the debugger and they are causing a lot of trouble. Filtering
   // can't be restricted to Android because this special object file don't
   // contain the note section specifying the environment to Android but the
   // custom extension and file name makes it highly unlikely that this will
   // collide with anything else.
   ConstString file_extension = m_file.GetFileNameExtension();
   bool skip_oatdata_oatexec =
       file_extension == ".oat" || file_extension == ".odex";
 
   ArchSpec arch = GetArchitecture();
   ModuleSP module_sp(GetModule());
   SectionList *module_section_list =
       module_sp ? module_sp->GetSectionList() : nullptr;
if (m_symtab_up == nullptr) {
     uint64_t symbol_id = 0;
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
     // Sharable objects and dynamic executables usually have 2 distinct symbol
     // tables, one named ".symtab", and the other ".dynsym". The dynsym is a
     // smaller version of the symtab that only contains global symbols. The
     // information found in the dynsym is therefore also found in the symtab,
     // while the reverse is not necessarily true.
     Section *symtab =
         section_list->FindSectionByType(eSectionTypeELFSymbolTable, true).get();
-    if (!symtab) {
-      // The symtab section is non-allocable and can be stripped, so if it
-      // doesn't exist then use the dynsym section which should always be
-      // there.
-      symtab =
-          section_list->FindSectionByType(eSectionTypeELFDynamicSymbols, true)
-              .get();
-    }
     if (symtab) {
       m_symtab_up.reset(new Symtab(symtab->GetObjectFile()));
       symbol_id += ParseSymbolTable(m_symtab_up.get(), symbol_id, symtab);
     }
 
+    // The symtab section is non-allocable and can be stripped. If both, .symtab
+    // and .dynsym exist, we load both. And if only .dymsym exists, we load it
+    // alone.
+    auto dynsym =
+        section_list->FindSectionByType(eSectionTypeELFDynamicSymbols, true)
+            .get();
+    if (dynsym) {
+      if (!m_symtab_up) {
+        auto sec = symtab ? symtab : dynsym;
+        m_symtab_up.reset(new Symtab(sec->GetObjectFile()));
+      }
+      symbol_id += ParseSymbolTable(m_symtab_up.get(), symbol_id, dynsym);
+    }
+
     // DT_JMPREL
     //      If present, this entry's d_ptr member holds the address of
     //      relocation
     //      entries associated solely with the procedure linkage table.
     //      Separating
     //      these relocation entries lets the dynamic linker ignore them during
     //      process initialization, if lazy binding is enabled. If this entry is
     //      present, the related entries of types DT_PLTRELSZ and DT_PLTREL must
     //      also be present.

lldb/source/Plugins/SymbolVendor/ELF/SymbolVendorELF.cpp

 // CreateInstance
 //
 // Platforms can register a callback to use when creating symbol vendors to
 // allow for complex debug information file setups, and to also allow for
 // finding separate debug information files.
 SymbolVendor *
 SymbolVendorELF::CreateInstance(const lldb::ModuleSP &module_sp,
                                 lldb_private::Stream *feedback_strm) {
   if (!module_sp)
     return nullptr;
 
   ObjectFileELF *obj_file =
       llvm::dyn_cast_or_null<ObjectFileELF>(module_sp->GetObjectFile());
   if (!obj_file)
     return nullptr;
 
+  std::unique_ptr<SymbolVendorELF> symbol_vendor(
+      new SymbolVendorELF(module_sp));
+  SectionList *module_section_list = module_sp->GetSectionList();
+
   lldb_private::UUID uuid = obj_file->GetUUID();
   if (!uuid)
     return nullptr;
 
   // If the main object file already contains debug info, then we are done.
   if (obj_file->GetSectionList()->FindSectionByType(
           lldb::eSectionTypeDWARFDebugInfo, true))
     return nullptr;
 
   // If the module specified a filespec, use that.
   FileSpec fspec = module_sp->GetSymbolFileFileSpec();
   // Otherwise, try gnu_debuglink, if one exists.
SymbolVendorELF::CreateInstance(const lldb::ModuleSP &module_sp,
   if (!dsym_objfile_sp)
     return nullptr;
 
   // This objfile is for debugging purposes. Sadly, ObjectFileELF won't
   // be able to figure this out consistently as the symbol file may not
   // have stripped the code sections, etc.
   dsym_objfile_sp->SetType(ObjectFile::eTypeDebugInfo);
 
-  SymbolVendorELF *symbol_vendor = new SymbolVendorELF(module_sp);
-
   // Get the module unified section list and add our debug sections to
   // that.
-  SectionList *module_section_list = module_sp->GetSectionList();
+  module_section_list = module_sp->GetSectionList();
   SectionList *objfile_section_list = dsym_objfile_sp->GetSectionList();
 
   static const SectionType g_sections[] = {
       eSectionTypeDWARFDebugAbbrev,   eSectionTypeDWARFDebugAddr,
       eSectionTypeDWARFDebugAranges,  eSectionTypeDWARFDebugCuIndex,
       eSectionTypeDWARFDebugFrame,    eSectionTypeDWARFDebugInfo,
       eSectionTypeDWARFDebugLine,     eSectionTypeDWARFDebugLoc,
       eSectionTypeDWARFDebugMacInfo,  eSectionTypeDWARFDebugPubNames,
if (SectionSP section_sp =
         module_section_list->ReplaceSection(module_section_sp->GetID(),
                                             section_sp);
       else
         module_section_list->AddSection(section_sp);
     }
   }
 
   symbol_vendor->AddSymbolFileRepresentation(dsym_objfile_sp);
-  return symbol_vendor;
+
+  return symbol_vendor.release();
 }
 
 // PluginInterface protocol
 ConstString SymbolVendorELF::GetPluginName() { return GetPluginNameStatic(); }
 
 uint32_t SymbolVendorELF::GetPluginVersion() { return 1; }

lldb/test/CMakeLists.txt

elseif(TARGET lldb-server)
     message(STATUS "LLDB Tests use just-built lldb-server: ${lldb_server_path}")
     list(APPEND LLDB_TEST_COMMON_ARGS --server ${lldb_server_path})
     add_dependencies(lldb-test-deps lldb-server)
   else()
     message(WARNING "LLDB Tests enabled, but no server available")
   endif()
 endif()
 
+if (LLVM_ENABLE_LZMA)
+  add_dependencies(lldb-test-deps llvm-nm llvm-strip)
+endif()
+
 set(LLDB_DOTEST_ARGS ${LLDB_TEST_COMMON_ARGS};${LLDB_TEST_USER_ARGS})
 set_property(GLOBAL PROPERTY LLDB_DOTEST_ARGS_PROPERTY ${LLDB_DOTEST_ARGS})
 
 # If tests crash cause LLDB to crash, or things are otherwise unstable, or if machine-parsable
 # output is desired (i.e. in continuous integration contexts) check-lldb-single is a better target.
 add_custom_target(check-lldb)
 add_dependencies(check-lldb lldb-test-deps)
 set_target_properties(check-lldb PROPERTIES FOLDER "lldb misc")

llvm/CMakeLists.txt

if (CMAKE_GENERATOR STREQUAL "Xcode" AND NOT CMAKE_OSX_ARCHITECTURES)
   # explicitly specify an architecture setting with the Xcode generator.
   set(CMAKE_OSX_ARCHITECTURES "x86_64")
 endif()
 
 project(LLVM
   VERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR}.${LLVM_VERSION_PATCH}
   LANGUAGES C CXX ASM)
 
+include(CMakeDependentOption)
+
 if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
   message(STATUS "No build type selected, default to Debug")
   set(CMAKE_BUILD_TYPE "Debug" CACHE STRING "Build type (default Debug)" FORCE)
 endif()
 
 # Side-by-side subprojects layout: automatically set the
 # LLVM_EXTERNAL_${project}_SOURCE_DIR using LLVM_ALL_PROJECTS
 # This allows an easy way of setting up a build directory for llvm and another
 # one for llvm+clang+... using the same sources.
 set(LLVM_ALL_PROJECTS "clang;clang-tools-extra;compiler-rt;debuginfo-tests;libclc;libcxx;libcxxabi;libunwind;lld;lldb;llgo;openmp;parallel-libs;polly;pstl")
 set(LLVM_ENABLE_PROJECTS "" CACHE STRING
   "Semicolon-separated list of projects to build (${LLVM_ALL_PROJECTS}), or \"all\".")
 if( LLVM_ENABLE_PROJECTS STREQUAL "all" )
   set( LLVM_ENABLE_PROJECTS ${LLVM_ALL_PROJECTS})
 endif()
 
 # LLVM_ENABLE_PROJECTS_USED is `ON` if the user has ever used the
 # `LLVM_ENABLE_PROJECTS` CMake cache variable.  This exists for
 # several reasons:
 #
 # * As an indicator that the `LLVM_ENABLE_PROJECTS` list is now the single
 # source of truth for which projects to build. This means we will ignore user
 # supplied `LLVM_TOOL_<project>_BUILD` CMake cache variables and overwrite
 # them.
 #
 # * The case where the user previously had `LLVM_ENABLE_PROJECTS` set to a
 # non-empty list but now the user wishes to disable building all other projects
 # by setting `LLVM_ENABLE_PROJECTS` to an empty string. In that case we still
 # need to set the `LLVM_TOOL_${upper_proj}_BUILD` variables so that we disable
 # building all the projects that were previously enabled.
 set(LLVM_ENABLE_PROJECTS_USED OFF CACHE BOOL "")
 mark_as_advanced(LLVM_ENABLE_PROJECTS_USED)
 
 if (LLVM_ENABLE_PROJECTS_USED OR NOT LLVM_ENABLE_PROJECTS STREQUAL "")
   set(LLVM_ENABLE_PROJECTS_USED ON CACHE BOOL "" FORCE)
   foreach(proj ${LLVM_ALL_PROJECTS} ${LLVM_EXTERNAL_PROJECTS})
     string(TOUPPER "${proj}" upper_proj)
     string(REGEX REPLACE "-" "_" upper_proj ${upper_proj})
     if ("${proj}" IN_LIST LLVM_ENABLE_PROJECTS)
       message(STATUS "${proj} project is enabled")
       set(SHOULD_ENABLE_PROJECT TRUE)
       set(PROJ_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../${proj}")
       if(NOT EXISTS "${PROJ_DIR}" OR NOT IS_DIRECTORY "${PROJ_DIR}")
         message(FATAL_ERROR "LLVM_ENABLE_PROJECTS requests ${proj} but directory not found: ${PROJ_DIR}")
       endif()
       if( LLVM_EXTERNAL_${upper_proj}_SOURCE_DIR STREQUAL "" )
         set(LLVM_EXTERNAL_${upper_proj}_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../${proj}" CACHE PATH "" FORCE)
       else()
         set(LLVM_EXTERNAL_${upper_proj}_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../${proj}" CACHE PATH "")
       endif()
     elseif ("${proj}" IN_LIST LLVM_EXTERNAL_PROJECTS)
       message(STATUS "${proj} project is enabled")
       set(SHOULD_ENABLE_PROJECT TRUE)
     else()
       message(STATUS "${proj} project is disabled")
       set(SHOULD_ENABLE_PROJECT FALSE)
     endif()
     # Force `LLVM_TOOL_${upper_proj}_BUILD` variables to have values that
     # corresponds with `LLVM_ENABLE_PROJECTS`. This prevents the user setting
     # `LLVM_TOOL_${upper_proj}_BUILD` variables externally. At some point
     # we should deprecate allowing users to set these variables by turning them
     # into normal CMake variables rather than cache variables.
     set(LLVM_TOOL_${upper_proj}_BUILD
       ${SHOULD_ENABLE_PROJECT}
       CACHE
       BOOL "Whether to build ${upper_proj} as part of LLVM" FORCE
     )
   endforeach()
 endif()
 unset(SHOULD_ENABLE_PROJECT)
 
 # Build llvm with ccache if the package is present
 set(LLVM_CCACHE_BUILD OFF CACHE BOOL "Set to ON for a ccache enabled build")
 if(LLVM_CCACHE_BUILD)
   find_program(CCACHE_PROGRAM ccache)
   if(CCACHE_PROGRAM)
       set(LLVM_CCACHE_MAXSIZE "" CACHE STRING "Size of ccache")
       set(LLVM_CCACHE_DIR "" CACHE STRING "Directory to keep ccached data")
       set(LLVM_CCACHE_PARAMS "CCACHE_CPP2=yes CCACHE_HASHDIR=yes"
           CACHE STRING "Parameters to pass through to ccache")
 
       set(CCACHE_PROGRAM "${LLVM_CCACHE_PARAMS} ${CCACHE_PROGRAM}")
       if (LLVM_CCACHE_MAXSIZE)
         set(CCACHE_PROGRAM "CCACHE_MAXSIZE=${LLVM_CCACHE_MAXSIZE} ${CCACHE_PROGRAM}")
       endif()
       if (LLVM_CCACHE_DIR)
         set(CCACHE_PROGRAM "CCACHE_DIR=${LLVM_CCACHE_DIR} ${CCACHE_PROGRAM}")
       endif()
       set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_PROGRAM})
   else()
     message(FATAL_ERROR "Unable to find the program ccache. Set LLVM_CCACHE_BUILD to OFF")
   endif()
 endif()
 
 option(LLVM_DEPENDENCY_DEBUGGING "Dependency debugging mode to verify correctly expressed library dependencies (Darwin only)" OFF)
 
 # Some features of the LLVM build may be disallowed when dependency debugging is
 # enabled. In particular you cannot use ccache because we want to force compile
 # operations to always happen.
 if(LLVM_DEPENDENCY_DEBUGGING)
   if(NOT CMAKE_HOST_APPLE)
     message(FATAL_ERROR "Dependency debugging is only currently supported on Darwin hosts.")
   endif()
   if(LLVM_CCACHE_BUILD)
     message(FATAL_ERROR "Cannot enable dependency debugging while using ccache.")
   endif()
 endif()
 
 option(LLVM_ENABLE_DAGISEL_COV "Debug: Prints tablegen patterns that were used for selecting" OFF)
 option(LLVM_ENABLE_GISEL_COV "Enable collection of GlobalISel rule coverage" OFF)
 if(LLVM_ENABLE_GISEL_COV)
   set(LLVM_GISEL_COV_PREFIX "${CMAKE_BINARY_DIR}/gisel-coverage-" CACHE STRING "Provide a filename prefix to collect the GlobalISel rule coverage")
 endif()
 
 # Add path for custom modules
 set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules"
   )
 
 # Generate a CompilationDatabase (compile_commands.json file) for our build,
 # for use by clang_complete, YouCompleteMe, etc.
 set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
 
 option(LLVM_INSTALL_BINUTILS_SYMLINKS
   "Install symlinks from the binutils tool names to the corresponding LLVM tools." OFF)
 
 option(LLVM_INSTALL_CCTOOLS_SYMLINKS
   "Install symlinks from the cctools tool names to the corresponding LLVM tools." OFF)
 
 option(LLVM_INSTALL_UTILS "Include utility binaries in the 'install' target." OFF)
 
 option(LLVM_INSTALL_TOOLCHAIN_ONLY "Only include toolchain files in the 'install' target." OFF)
 
 # Unfortunatly Clang is too eager to search directories for module maps, which can cause the
 # installed version of the maps to be found when building LLVM from source. Therefore we turn off
 # the installation by default. See llvm.org/PR31905.
 option(LLVM_INSTALL_MODULEMAPS "Install the modulemap files in the 'install' target." OFF)
 
 option(LLVM_USE_FOLDERS "Enable solution folders in Visual Studio. Disable for Express versions." ON)
 if ( LLVM_USE_FOLDERS )
   set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 endif()
 
 include(VersionFromVCS)
 
 option(LLVM_APPEND_VC_REV
   "Embed the version control system revision in LLVM" ON)
 
 set(PACKAGE_NAME LLVM)
 set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
 set(PACKAGE_BUGREPORT "https://bugs.llvm.org/")
 
 set(BUG_REPORT_URL "${PACKAGE_BUGREPORT}" CACHE STRING
   "Default URL where bug reports are to be submitted.")
 
 # Configure CPack.
 set(CPACK_PACKAGE_INSTALL_DIRECTORY "LLVM")
 set(CPACK_PACKAGE_VENDOR "LLVM")
 set(CPACK_PACKAGE_VERSION_MAJOR ${LLVM_VERSION_MAJOR})
 set(CPACK_PACKAGE_VERSION_MINOR ${LLVM_VERSION_MINOR})
 set(CPACK_PACKAGE_VERSION_PATCH ${LLVM_VERSION_PATCH})
 set(CPACK_PACKAGE_VERSION ${PACKAGE_VERSION})
 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.TXT")
 set(CPACK_NSIS_COMPRESSOR "/SOLID lzma \r\n SetCompressorDictSize 32")
 if(WIN32 AND NOT UNIX)
   set(CPACK_PACKAGE_INSTALL_REGISTRY_KEY "LLVM")
   set(CPACK_PACKAGE_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\cmake\\\\nsis_logo.bmp")
   set(CPACK_NSIS_MUI_ICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\cmake\\\\nsis_icon.ico")
   set(CPACK_NSIS_MUI_UNIICON "${CMAKE_CURRENT_SOURCE_DIR}\\\\cmake\\\\nsis_icon.ico")
   set(CPACK_NSIS_MODIFY_PATH "ON")
   set(CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL "ON")
   if( CMAKE_CL_64 )
     set(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES64")
   endif()
 endif()
 include(CPack)
 
 # Sanity check our source directory to make sure that we are not trying to
 # generate an in-source build (unless on MSVC_IDE, where it is ok), and to make
 # sure that we don't have any stray generated files lying around in the tree
 # (which would end up getting picked up by header search, instead of the correct
 # versions).
 if( CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE )
   message(FATAL_ERROR "In-source builds are not allowed.
 Please create a directory and run cmake from there, passing the path
 to this source directory as the last argument.
 This process created the file `CMakeCache.txt' and the directory `CMakeFiles'.
 Please delete them.")
 endif()
 
 string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 
 if (CMAKE_BUILD_TYPE AND
     NOT uppercase_CMAKE_BUILD_TYPE MATCHES "^(DEBUG|RELEASE|RELWITHDEBINFO|MINSIZEREL)$")
   message(FATAL_ERROR "Invalid value for CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
 endif()
 
 set(LLVM_LIBDIR_SUFFIX "" CACHE STRING "Define suffix of library directory name (32/64)" )
 
 set(LLVM_TOOLS_INSTALL_DIR "bin" CACHE STRING "Path for binary subdirectory (defaults to 'bin')")
 mark_as_advanced(LLVM_TOOLS_INSTALL_DIR)
 
 set(LLVM_UTILS_INSTALL_DIR "${LLVM_TOOLS_INSTALL_DIR}" CACHE STRING
     "Path to install LLVM utilities (enabled by LLVM_INSTALL_UTILS=ON) (defaults to LLVM_TOOLS_INSTALL_DIR)")
 mark_as_advanced(LLVM_UTILS_INSTALL_DIR)
 
 # They are used as destination of target generators.
 set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/bin)
 set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib${LLVM_LIBDIR_SUFFIX})
 if(WIN32 OR CYGWIN)
   # DLL platform -- put DLLs into bin.
   set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_RUNTIME_OUTPUT_INTDIR})
 else()
   set(LLVM_SHLIB_OUTPUT_INTDIR ${LLVM_LIBRARY_OUTPUT_INTDIR})
 endif()
 
 # Each of them corresponds to llvm-config's.
 set(LLVM_TOOLS_BINARY_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR}) # --bindir
 set(LLVM_LIBRARY_DIR      ${LLVM_LIBRARY_OUTPUT_INTDIR}) # --libdir
 set(LLVM_MAIN_SRC_DIR     ${CMAKE_CURRENT_SOURCE_DIR}  ) # --src-root
 set(LLVM_MAIN_INCLUDE_DIR ${LLVM_MAIN_SRC_DIR}/include ) # --includedir
 set(LLVM_BINARY_DIR       ${CMAKE_CURRENT_BINARY_DIR}  ) # --prefix
 
 # Note: LLVM_CMAKE_PATH does not include generated files
 set(LLVM_CMAKE_PATH ${LLVM_MAIN_SRC_DIR}/cmake/modules)
 set(LLVM_EXAMPLES_BINARY_DIR ${LLVM_BINARY_DIR}/examples)
 set(LLVM_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/include)
 
 # List of all targets to be built by default:
 set(LLVM_ALL_TARGETS
   AArch64
   AMDGPU
   ARM
   BPF
   Hexagon
   Lanai
   Mips
   MSP430
   NVPTX
   PowerPC
   RISCV
   Sparc
   SystemZ
   WebAssembly
   X86
   XCore
   )
 
 # List of targets with JIT support:
 set(LLVM_TARGETS_WITH_JIT X86 PowerPC AArch64 ARM Mips SystemZ)
 
 set(LLVM_TARGETS_TO_BUILD "all"
     CACHE STRING "Semicolon-separated list of targets to build, or \"all\".")
 
 set(LLVM_EXPERIMENTAL_TARGETS_TO_BUILD ""
   CACHE STRING "Semicolon-separated list of experimental targets to build.")
 
 option(BUILD_SHARED_LIBS
   "Build all libraries as shared libraries instead of static" OFF)
 
 option(LLVM_ENABLE_BACKTRACES "Enable embedding backtraces on crash." ON)
 if(LLVM_ENABLE_BACKTRACES)
   set(ENABLE_BACKTRACES 1)
 endif()
 
 option(LLVM_ENABLE_UNWIND_TABLES "Emit unwind tables for the libraries" ON)
 
 option(LLVM_ENABLE_CRASH_OVERRIDES "Enable crash overrides." ON)
 if(LLVM_ENABLE_CRASH_OVERRIDES)
   set(ENABLE_CRASH_OVERRIDES 1)
 endif()
 
 option(LLVM_ENABLE_CRASH_DUMPS "Turn on memory dumps on crashes. Currently only implemented on Windows." OFF)
 
 option(LLVM_ENABLE_FFI "Use libffi to call external functions from the interpreter" OFF)
 set(FFI_LIBRARY_DIR "" CACHE PATH "Additional directory, where CMake should search for libffi.so")
 set(FFI_INCLUDE_DIR "" CACHE PATH "Additional directory, where CMake should search for ffi.h or ffi/ffi.h")
 
 set(LLVM_TARGET_ARCH "host"
   CACHE STRING "Set target to use for LLVM JIT or use \"host\" for automatic detection.")
 
 option(LLVM_ENABLE_TERMINFO "Use terminfo database if available." ON)
 
 set(LLVM_ENABLE_LIBXML2 "ON" CACHE STRING "Use libxml2 if available. Can be ON, OFF, or FORCE_ON")
 
 option(LLVM_ENABLE_LIBEDIT "Use libedit if available." ON)
 
 option(LLVM_ENABLE_LIBPFM "Use libpfm for performance counters if available." ON)
 
 option(LLVM_ENABLE_THREADS "Use threads if available." ON)
 
 option(LLVM_ENABLE_ZLIB "Use zlib for compression/decompression if available." ON)
 
+find_package(LibLZMA)
+cmake_dependent_option(LLVM_ENABLE_LZMA "Support LZMA compression" ON "LIBLZMA_FOUND" OFF)
+set(LLVM_LIBLZMA_LIBRARIES)
+if (LLVM_ENABLE_LZMA)
+  if (LIBLZMA_FOUND)
+  add_definitions(-DLLVM_ENABLE_LZMA)
+    include_directories(${LIBLZMA_INCLUDE_DIRS})
+  else()
+    message(FATAL_ERROR "LZMA devel package is required when LLVM_ENABLE_LZMA is On.")
+  endif()
+endif()
+
 set(LLVM_Z3_INSTALL_DIR "" CACHE STRING "Install directory of the Z3 solver.")
 
 find_package(Z3 4.7.1)
 
 if (LLVM_Z3_INSTALL_DIR)
   if (NOT Z3_FOUND)
     message(FATAL_ERROR "Z3 >= 4.7.1 has not been found in LLVM_Z3_INSTALL_DIR: ${LLVM_Z3_INSTALL_DIR}.")
   endif()