[BPF][DebugInfo] Use .BPF.ext for line info when DWARF is not available

[eddyz87]

Summary

"BTF" is a debug information format used by LLVM's BPF backend.
The format is much smaller in scope than DWARF, the following info is
available:

• full set of C types used in the binary file;
• types for global values;
• line number / line source code information .

BTF information is embedded in ELF as .BTF and .BTF.ext sections.
Detailed format description could be found as a part of Linux Source
tree, e.g. here: [1].

This commit modifies llvm-objdump utility to use line number
information provided by BTF if DWARF information is not available.
E.g., the goal is to make the following to print source code lines,
interleaved with disassembly:

$ clang --target=bpf -g test.c -o test.o
$ llvm-strip --strip-debug test.o
$ llvm-objdump -Sd test.o

test.o:	file format elf64-bpf

Disassembly of section .text:

<foo>:
; void foo(void) {
	r1 = 0x1
;   consume(1);
	call -0x1
	r1 = 0x2
;   consume(2);
	call -0x1
; }
	exit

A common production use case for BPF programs is to:

• compile separate object files using clang with -g -c flags;
• link these files as a final "static" binary using bpftool linker ([2]).

The bpftool linker discards most of the DWARF sections
(line information sections as well) but merges .BTF and .BTF.ext sections.
Hence, having llvm-objdump capable to print source code using .BTF.ext
is valuable.

The commit consists of the following modifications:

• llvm/lib/DebugInfo/BTF aka DebugInfoBTF component is added to host the code needed to process BTF (with assumption that BTF support would be added to some other tools as well, e.g. llvm-readelf):
  • DebugInfoBTF provides llvm::BTFParser class, that loads information from .BTF and .BTF.ext sections of a given object::ObjectFile instance and allows to query this information. Currently only line number information is loaded.
  • DebugInfoBTF also provides llvm::BTFContext class, which is an implementation of DIContext interface, used by llvm-objdump to query information about line numbers corresponding to specific instructions.

• Structure DILineInfo is modified with field LineSource.
  
  DIContext interface uses DILineInfo structure to communicate line number and source code information. Specifically, DILineInfo::Source field encodes full file source code, if available. BTF only stores source code for selected lines of the file, not a complete source file. Moreover, stored lines are not guaranteed to be sorted in a specific order.
  
  To avoid reconstruction of a file source code from a set of available lines, this commit adds LineSource field instead.

• Symbolize class is modified to use BTFContext instead of DWARFContext when DWARF sections are not available but BTF sections are present in the object file. (Symbolize is instantiated by llvm-objdump).

• Integration and unit tests.

Note, that DWARF has a notion of "instruction sequence".
DWARF implementation of DIContext::getLineInfoForAddress() provides
inexact responses if exact address information is not available but
address falls within "instruction sequence" with some known line
information (see DWARFDebugLine::LineTable::findRowInSeq()).

BTF does not provide instruction sequence groupings, thus
getLineInfoForAddress() queries only return exact matches.
This does not seem to be a big issue in practice, but output
of the llvm-objdump -Sd might differ slightly when BTF
is used instead of DWARF.

[1] https://www.kernel.org/doc/html/latest/bpf/btf.html
[2] https://github.com/libbpf/bpftool

Depends on https://reviews.llvm.org/D149501

[eddyz87]

Reorganized to report errors, added objdump test-case.

[eddyz87]

Reorganized to provide BTFParser class, added unit tests.

[yonghong-song]

The following is the immediate use case why this patch will help BPF community.
Currently bpftool implements static linking as lld does not support it. The static linking looks like below:

1. 1. Let us say we have three files t1.c, t2.c, t3.c, they call compiled with '-target bpf -O2 -mcpu=v3 -g -c' and generates t1.o, t2.0, t3.o
   2. To minimize runtime overhead, we would like to produce just one binary say t_final.o which contains a single BTF section and a single BTF.ext section, and this is bpf linking step implemented in bpftool.
2. The t_final.o is used by applicaiton (libbpf library) to extract necessary insn/relocation/btf etc. and process them and load them into the kernel.

The step 3 may be repeated many times (application restart, etc., repeated run e.g., for tracing app, etc.) so it is critical that bpf linking (bpftool) can generate a .o file which can be processed and loaded into kernel as faster as possible.

So the step 2 does the following with bpftool:

• merging all code sections with all .o files and do necessary relocation
• merging all .BTF/.BTF.ext sections into a single one, not that to save space, deduplication is done to minimize BTF size.
• remove dwarf sections as they are not cirtical to BPF program execution. Also, with bpf skeleton, t_final.o is presented as a blob of data and embedded as a special string constant and taking up application memory space. So removing dwarf data can save application memory usage as well.

The end result is that t_final.o does not have dwarf sections and only have .BTF/.BTF.ext sections. The BTF sections contains line number info and verifier uses such information to deplay verifier logs annotated with source code.
But llvm-objdump -S won't work any more. We would like it works with BTF to show source annotated asm code if dwarf is not available.

[eddyz87]

Unit test changed to use #pragma pack instead of attribute((packed)) to satisfy MSVC unit tests build.

[eddyz87]

Fix incorrect path substitution for interleaved-source-test.ll on windows.

[eddyz87]

Hi James, Fangrui,

Could you please take a look at this modification for llvm-objdump?
This change would be quite helpful for people developing BPF programs using CLANG.

[eddyz87]

Hi @jhenderson, @MaskRay,

Sorry to bother you, but could you please take a look at this revision?
I have other BPF related changes that depend on it...

[yonghong-song]

From BPF perspective, it looks good to me. The only thing I am not sure is in struct DILineInfo, std::optional<StringRef> LineSource; is added which sounds a little bit weird since 'Source' is there. But the 'LineSource' is used to differentiate from dwarf 'Source'. If this is not preferred, we could remove it and hide the LineSource info in BTFContext instead.

@MaskRay @jhenderson I really appreciate your opinions on this BTF addition to llvm-objdump. Thanks!

[eddyz87]

In D149058#4325770, @yonghong-song wrote:

From BPF perspective, it looks good to me. The only thing I am not sure is in struct DILineInfo, std::optional<StringRef> LineSource; is added which sounds a little bit weird since 'Source' is there. But the 'LineSource' is used to differentiate from dwarf 'Source'. If this is not preferred, we could remove it and hide the LineSource info in BTFContext instead.

Sorry, not sure I understand. The only way to preserve old interface for DILineInfo that I see is to collect all lines stored in .BTF.ext, sort those lines by file name, line number and create std::string instances with "fake" source code for each file (which is a bit wasteful from cpu/memory pov). Is that what you mean or am I missing something?

[yonghong-song]

Sorry, not sure I understand. The only way to preserve old interface for DILineInfo that I see is to collect all lines stored in .BTF.ext, sort those lines by file name, line number and create std::string instances with "fake" source code for each file (which is a bit wasteful from cpu/memory pov). Is that what you mean or am I missing something?

Okay, I see. I thought we could add 'LineSource' to BTFContext, but that will need to change the generic llvm-objdump interface (casting to BTFContext). Or we could reuse 'Source' by *constructing* similar-to-dwarf source from BTF as you mentioned above, but it is somehow a waste based on you explanation in the above.

There are different ways to solve this. I would like to hear @MaskRay and @jhenderson 's opinion.

[jhenderson]

Sorry for not getting back to you: I'm in the midst of some fairly major work that means I only have minimal time for reviewing. I'll try to get back to you in the next week or two, if nobody else does. I've added @dblaikie, who has looked at symbolizer stuff and knows a lot about DWARF and the debug library interface.

[eddyz87]

In D149058#4331940, @jhenderson wrote:

Sorry for not getting back to you: I'm in the midst of some fairly major work that means I only have minimal time for reviewing. I'll try to get back to you in the next week or two, if nobody else does. I've added @dblaikie, who has looked at symbolizer stuff and knows a lot about DWARF and the debug library interface.

No problem, thank you for letting me know.
No rush from my side, just would be great to have this feature by LLVM 17 release.

[eddyz87]

Hi @jhenderson, @dblaikie,

Could you please take a look at this revision?

[jhenderson]

Sorry, having skimmed this again, I realistically don't think I'll ever get around to looking at this patch properly, as it's too complex for me to be able to understand in the small amounts of time I have available to review.

[yonghong-song]

Add @nickdesaulniers as the reviewer as well. @nickdesaulniers could you help take a look at the patch as well?

[nickdesaulniers]

yes; I'm traveling but will take a look later this week.

[nickdesaulniers]

Initial code review pass

llvm/include/llvm/DebugInfo/BTF/BTFParser.h

33 ↗

(On Diff #518581)

IIRC, I think you can move this using statement into the class definition to scope its use within the class? Otherwise using in headers makes me nervous.

44 ↗

(On Diff #518581)

why std::map over something like llvm::DenseMap?
https://llvm.org/docs/ProgrammersManual.html#llvm-adt-densemap-h

llvm/lib/DebugInfo/BTF/BTFContext.cpp

31–34

dump is super common for most classes in LLVM when debugging. If you're not going to provide a meaningful definition, I think you can do so in the header file. Same for the constructor above.

38

plz no auto

40–42

pretty sure this will prevent NVRO. Just declare Result first, then always return it.

52

here you can return {};

60

here you can return {};

67–69

here you can return {};

72

probably here you can return {};

79

plz no auto here

llvm/lib/DebugInfo/BTF/BTFParser.cpp

104 ↗

(On Diff #518581)

plz no auto here

plz review https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable and update the remainder of this patch where appropriate.

llvm/tools/llvm-objdump/SourcePrinter.h

154–155

How about returning just a StringRef; in the case of failure, return a StringRef that is empty, such as a default constructed StringRef.

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

23 ↗

(On Diff #518581)

unused?

25 ↗

(On Diff #518581)

unused?

[nickdesaulniers]

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

90 ↗

(On Diff #518581)

size_t

[MaskRay]

Apologies for my slow response. Reading...

llvm/include/llvm/DebugInfo/BTF/BTF.h

248 ↗

(On Diff #518581)

ditto below

[MaskRay]

llvm/lib/DebugInfo/BTF/BTFParser.cpp

29 ↗

(On Diff #518581)

const char BTF_SECTION_NAME[] = ".BTF"

47 ↗

(On Diff #518581)

See https://llvm.org/docs/CodingStandards.html#anonymous-namespaces

This dangerously leaves a globally named Err which may collide with user programs if they link in LLVM.

52 ↗

(On Diff #518581)

{}; => {}

55 ↗

(On Diff #518581)

don't capitalize. see https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

80 ↗

(On Diff #518581)

The "The section name to SectionRef mapping" should be attached to Sections, not the class.

86 ↗

(On Diff #518581)

map is slow. Here we don't need a stable iteration order. Use DenseMap<StringRef, SectionRef>

250 ↗

(On Diff #518581)

Nit: delete blank line.

This is not the Linux kernel community. Generally we don't add a blank line after a variable declaration. IMHO it often unnecessarily increases the number of lines without improving readability.

You may want to fix this elsewhere in the patch.

251 ↗

(On Diff #518581)

Error E

https://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable "Don’t “almost always” use auto"

256 ↗

(On Diff #518581)

delete blank line

258 ↗

(On Diff #518581)

don't capitalize

259 ↗

(On Diff #518581)

delete blank line

276 ↗

(On Diff #518581)

In LLVM_ENABLE_ABI_BREAKING_CHECKS mode, in case of an error, this Expected return value will crash.

[MaskRay]

llvm/lib/DebugInfo/BTF/BTFContext.cpp

78

make_unqiue

llvm/lib/DebugInfo/BTF/BTFParser.cpp

134 ↗

(On Diff #518581)

Check whether the version is supported and add a test

175 ↗

(On Diff #518581)

Check whether the version is supported and add a test

210 ↗

(On Diff #518581)

make_unqiue

211 ↗

(On Diff #518581)

delete blank line

[MaskRay]

llvm/lib/DebugInfo/BTF/BTFParser.cpp

156 ↗

(On Diff #518581)

substr

delete blank line

214 ↗

(On Diff #518581)

delete blank line

217 ↗

(On Diff #518581)

delete blank line

220 ↗

(On Diff #518581)

delete blank line

225 ↗

(On Diff #518581)

delete blank line

287 ↗

(On Diff #518581)

substr

llvm/test/tools/llvm-objdump/BPF/interleaved-source-test.ll

3

We don't generally add ^;$ lines. Having these lines actually makes { } jumping with Vim difficult...

4

Some test directories, including llvm-objdump, prefer ;; for non-RUN-non-CHECK comments. This makes comments stand out (may be highlit in some editors).

15

interleaved-source-test.ll tests a BPF program with only BTF, but there is no test testing the behavior when both DWARF and BTF are present. We probably should dump the output of the original %t and the stripped %t into two text files, and check that the two text files are identical.

17

Testing the addresses below, at least for one function, will be useful.

17

You can simplify -Sd to -S as -S implies -d

28

Use --target=bpf.

I have sent https://lore.kernel.org/bpf/[e-mail]/T/#u to replace -target bpf with --target=bpf and hopefully influenced new BPF users to migrate away from the deprecated -target

36

This doesn't check that .debug_info is not above .BTF.

FileCheck %s --implicit-check-not=.debug_ may be useful.

[eddyz87]

• styling fixes according to reviewer's comments
• added checks for .BTF and .BTF.ext versions

[eddyz87]

Hi @nickdesaulniers , @MaskRay ,

Thank you for taking a look at this revision.
I've added requested changes, and put inline comments for a few points I don't agree with.
Could you please take a second look?

P.S.
A silly question, who has to check the "Done" box for sub-discussions, author or reviewer?

llvm/lib/DebugInfo/BTF/BTFContext.cpp

78

I defined BTFContext constructor as private and clang disallows me to call private constructor here:

unique_ptr.h:1065:34: error: calling a private constructor of class 'llvm::BTFContext'
    { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

If you strictly disprove usage of unique_ptr() I can make the constructor public.

llvm/lib/DebugInfo/BTF/BTFParser.cpp

55 ↗

(On Diff #518581)

Done under assumption that you refer to the error message, removed capitalization from all error messages.

80 ↗

(On Diff #518581)

The purpose of the comment was to explain the purpose of this class existence.
I changed comment to focus on the class itself.

287 ↗

(On Diff #518581)

• substr(size_t Start, size_t N) -> substring from [Start, Start + N)
• slice(size_t Start, size_t End) -> substring from [Start, End)

Call to StringsTable.find(0, Offset) returns the end position for string starting at Offset. Why is substr() better in this context?

llvm/test/tools/llvm-objdump/BPF/interleaved-source-test.ll

15

I've added llvm-objdump ... %t | FileCheck %s step before DWARF information stripping, so objdump output is verified for both DWARF-BTF and BTF-only versions of the object file.

llvm/tools/llvm-objdump/SourcePrinter.h

154–155

This is probably fine and no tests fail if I do such change.
However, it implies that SourcePrinter::printSources() can never print an empty line.
The original SourcePrinter::printSources() does not have such property, idk if this is important.
I included this change but I think std::optional is better because it highlights that return value is not mandatory and makes the "absent" value indicator self-explanatory.

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

90 ↗

(On Diff #518581)

This is a part of the packed structure with predefined layout, the u32 value is expected in this position.

Note: structure MockData1 is used as a blob to be parsed by BTF parser in the tests below, its layout has to match BTF binary encoding.

[eddyz87]

Fix for a memory handling issue in unit tests:
Storage parameter passed to yaml::yaml2ObjectFile() has to be alive while resulting ObjectFile is used.
This updates the mock data class to own both object file and storage buffer.

[eddyz87]

Hi @nickdesaulniers , @MaskRay ,

Could you please take a look at my replies / fixes?
It would be really great if this could be sorted out before LLVM 17 release...

[nickdesaulniers]

In D149058#4460285, @eddyz87 wrote:

Could you please take a second look?

Sorry for the delays; I've been on vacation a lot lately!

A silly question, who has to check the "Done" box for sub-discussions, author or reviewer?

Anyone can, but generally a reviewer makes a comment/request, then the author of the patch marks them done as they are addressed, which denotes that the requested points have been addressed.

llvm/lib/DebugInfo/BTF/BTFContext.cpp

78

right, std::make_unique requires the constructor to be private, unfortunately. I think the code LGTM as is.

[MaskRay]

Sorry for the slow response... Weekly ping is fine if you receive no response. I am reading through this again...

For the summary:

$ clang -target bpf -g test.c -o test.o

Switch to clang --target=bpf as -target has been deprecated since Clang 3.4.
Tip: use arc diff --head=HEAD 'HEAD^' --verbatim to update the diff as well as rewriting the summary with your local commit message.

A silly question, who has to check the "Done" box for sub-discussions, author or reviewer?

Tip. The differential author can click "Done" without clicking "Submit". When arc diff 'HEAD^' or (to update the summary) arc diff --head=HEAD 'HEAD^' --verbatim uploads a new patch, the "Done" states will be sumited.
However, if you make replies to the inline comments, you need to explicitly click "Submit".

llvm/lib/DebugInfo/BTF/BTFParser.cpp

24 ↗

(On Diff #537549)

const variables in namespace are automatically internal linkage. static is not needed.

102 ↗

(On Diff #537549)

return Sections.lookup(Name);

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

623

Use llvm::Triple::isBPF

llvm/test/tools/llvm-objdump/BPF/interleaved-source-test.ll

41

;; Check inlined source code in disassembly:

45

We can use [[#%x,]], but the convention is probably to just use ; CHECK-NEXT: <foo>:.

[MaskRay]

Thank you for the update. The code looks good, i've only got a few nits and test suggestions.

llvm/include/llvm/DebugInfo/BTF/BTFContext.h

2

See https://llvm.org/docs/CodingStandards.html#file-headers

This needs a C++ marker. Ditto elsewhere

llvm/include/llvm/DebugInfo/BTF/BTFParser.h

44 ↗

(On Diff #537549)

We can remove the unique_ptr indirection: DenseMap<uint64_t, BTFLinesVector> SectionLines;

If you change BTFLinesVector to use SmallVector<xxx, 0>, it will be even smaller.

55 ↗

(On Diff #537549)

62 ↗

(On Diff #537549)

75 ↗

(On Diff #537549)

llvm/lib/DebugInfo/BTF/BTFContext.cpp

54

66

Make the constructor public so that make_unique can be used.

78

Make the constructor public so that make_unique can be used.

DWARFContext has a public constructor as well.

llvm/lib/DebugInfo/BTF/BTFParser.cpp

225 ↗

(On Diff #518581)

I think init (a simple method) can be inlined into parse, then we may even avoid the two Ctx.findSection(BTF...Name); calls as we can check the section name in the section iteration loop.

In addition, the new code will be more similar to hasBTFSections

102 ↗

(On Diff #537549)

Sorry, lookup cannot be used. The existing code is correct.

132 ↗

(On Diff #537549)

Make it explicit you discard the return value.

165 ↗

(On Diff #537549)

Make it explicit you discard the return value.

171 ↗

(On Diff #537549)

Make it explicit you discard the return value.

207 ↗

(On Diff #537549)

If C has errored, we probably should not invoke Lines->push_back({InsnOff, FileNameOff, LineOff, LineCol});

209 ↗

(On Diff #537549)

llvm::stable_sort(*Lines, ...) to make the behavior deterministic no matter what std::sort implementations are unused.
See https://libcxx.llvm.org/DesignDocs/UnspecifiedBehaviorRandomization.html

271 ↗

(On Diff #537549)

When lower_bound is used with a custom predicate, it's usually better to use https://en.cppreference.com/w/cpp/algorithm/partition_point instead

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

18 ↗

(On Diff #537549)

We normally place using namespace immediately below #include

26 ↗

(On Diff #537549)

Use static instead of an anonymous namespace. See https://llvm.org/docs/CodingStandards.html#anonymous-namespaces

53 ↗

(On Diff #537549)

Consider starting the anonymous namespace here, including all TEST( below.

[eddyz87]

• changes according to comments from @MaskRay;
• added new error condition: non-existing section name specified in the .BTF.ext line info table;
• unit tests: changed parseError function EXPECT_PARSE_ERROR macro to preserve line info when error is reported.

[eddyz87]

Hi @MaskRay , @nickdesaulniers,

Thanks a lot for reviewing the patch!

llvm/test/tools/llvm-objdump/BPF/interleaved-source-test.ll

45

You asked to check function address in the disassembly, so I added regex to match the address. Changed to [[#%x,]] in the new version.

[MaskRay]

Thank!

llvm/include/llvm/DebugInfo/BTF/BTFContext.h

23

llvm/test/tools/llvm-objdump/BPF/interleaved-source-test.ll

45

Ah, sounds good. This makes it clear that there is an address.

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

15 ↗

(On Diff #539169)

[eddyz87]

Changes requested by @MaskRay in the last review round.

[nickdesaulniers]

Seems to be causing a build breakage. @eddyz87 PTAL and revert if you can't fix forward quickly.
https://lab.llvm.org/buildbot/#/builders/231/builds/13875

[nickdesaulniers]

In D149058#4494358, @nickdesaulniers wrote:

Seems to be causing a build breakage. @eddyz87 PTAL and revert if you can't fix forward quickly.
https://lab.llvm.org/buildbot/#/builders/231/builds/13875

Specifically, it seems that the tests fail for big endian architectures.

[MaskRay]

In D149058#4494363, @nickdesaulniers wrote:

In D149058#4494358, @nickdesaulniers wrote:

Seems to be causing a build breakage. @eddyz87 PTAL and revert if you can't fix forward quickly.
https://lab.llvm.org/buildbot/#/builders/231/builds/13875

Specifically, it seems that the tests fail for big endian architectures.

8130166b92d513acabec3962cd91baa54b5f095a should hopefully fix the unittest for big-endian targets.
The big-endian functionality is correct, though, just the unittest needs more care.

[eddyz87]

Hi @MaskRay,

Sorry, I was away from the PC. Thank you for committing the fix, I will update the unit test to execute in both big and little endian.
However, it looks like there is one more issue, as reported here for address sanitizer:

[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from BTFParserTest
[ RUN      ] BTFParserTest.simpleCorrectInput
/b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp:141:33: runtime error: upcast of misaligned address 0x7facce60411f for type 'llvm::SmallString<0>', which requires 8 byte alignment
0x7facce60411f: note: pointer points here
 64 00 00 00 37  41 60 ce ac 7f 00 00 00  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  00 00 00
             ^ 
SUMMARY: UndefinedBehaviorSanitizer: undefined-behavior /b/sanitizer-x86_64-linux-fast/build/llvm-project/llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp:141:33 in

Probably because of the attribute "packed" used for too many things:

c++
#pragma pack(push, 1)
struct MockData1 {
  struct B {
    ...
  } BTF;
  struct E {
    ...
  } Ext;

  int BTFSectionLen = sizeof(BTF);
  int ExtSectionLen = sizeof(Ext);

  SmallString<0> Storage;
  std::unique_ptr<ObjectFile> Obj;

}
#pragma pack(pop)

Look like access to unaligned pointers in Storage/Obj causes error on S390.
If so, #pragma directives should be pushed invards to apply only to B and ``E.

I'm not sure what is the best course of action here:

• revert commit and try to test locally (not sure if I can reproduce in on x86, might try QEMU)
• push another fix and hope for the best

Do you have any suggestions?

By the way, I have committer rights, so I can handle this cleanup.

[MaskRay]

The test has good test coverage for the regular code path, but the error code paths need the unittest.
In the worst situation we can remove the unittest and figure out how to make it portable to more configurations, but there is likely no value to revert the functionality part and cause churn to the repository.

[eddyz87]

In D149058#4495293, @MaskRay wrote:

The test has good test coverage for the regular code path, but the error code paths need the unittest.

Actually, I think there are test cases for each error message parser can currently produce...

I want to push the patch below to the main branch.
I tested it locally and -Wunaligned-access does catch the issue with Obj and Storage.
What do you think?

diff --git a/llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp b/llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp
index 097d6205adec..041933deb4ec 100644
--- a/llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp
+++ b/llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp
@@ -44,11 +44,11 @@ namespace {
 // modified before a call to `makeObj()` to test parser with invalid
 // input, etc.
 
+struct MockData1 {
 // Use "pragma pack" to model .BTF & .BTF.ext sections content using
 // 'struct' objects. This pragma is supported by CLANG, GCC & MSVC,
 // which matters for LLVM CI.
 #pragma pack(push, 1)
-struct MockData1 {
   struct B {
     BTF::Header Header = {};
     // no types
@@ -99,6 +99,7 @@ struct MockData1 {
       Header.LineInfoLen = sizeof(Lines);
     }
   } Ext;
+#pragma pack(pop)
 
   int BTFSectionLen = sizeof(BTF);
   int ExtSectionLen = sizeof(Ext);
@@ -143,7 +144,6 @@ Sections:
     return *Obj.get();
   }
 };
-#pragma pack(pop)
 
 TEST(BTFParserTest, simpleCorrectInput) {
   BTFParser BTF;
diff --git a/llvm/unittests/DebugInfo/BTF/CMakeLists.txt b/llvm/unittests/DebugInfo/BTF/CMakeLists.txt
index b425e46b9f0c..8cd4b793a741 100644
--- a/llvm/unittests/DebugInfo/BTF/CMakeLists.txt
+++ b/llvm/unittests/DebugInfo/BTF/CMakeLists.txt
@@ -10,4 +10,11 @@ add_llvm_unittest(DebugInfoBTFTests
 
 target_link_libraries(DebugInfoBTFTests PRIVATE LLVMTestingSupport)
 
+# Packed structures are used in the test. Asan/UBsan can catch
+# unaligned access errors, but such builds take significant time.
+# Use clang's -Wunaligned-access to get a heads-up.
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  set_source_files_properties(BTFParserTest.cpp PROPERTIES COMPILE_FLAGS -Wunaligned-access)
+endif()
+
 set_property(TARGET DebugInfoBTFTests PROPERTY FOLDER "Tests/UnitTests/DebugInfoTests")

[glandium]

llvm/include/llvm/DebugInfo/BTF/BTFContext.h

39

Our builds are failing here:

In file included from /builds/worker/fetches/llvm-project/llvm/lib/DebugInfo/BTF/BTFContext.cpp:15:
/builds/worker/fetches/llvm-project/llvm/include/llvm/DebugInfo/BTF/BTFContext.h:38:63: error: only virtual member functions can be marked 'override'
  getLineInfoForDataAddress(object::SectionedAddress Address) override;
                                                              ^~~~~~~~

(compiling with clang 13)

[glandium]

llvm/include/llvm/DebugInfo/BTF/BTFContext.h

39

Forget it, it's self-inflicted, we have a patch that reverts cead4eceb01b935fae07bf4a7e91911b344d2fec

[MaskRay]

In D149058#4495477, @eddyz87 wrote:

In D149058#4495293, @MaskRay wrote:

The test has good test coverage for the regular code path, but the error code paths need the unittest.

Actually, I think there are test cases for each error message parser can currently produce...

I want to push the patch below to the main branch.
I tested it locally and -Wunaligned-access does catch the issue with Obj and Storage.
What do you think?

diff --git a/llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp b/llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp
index 097d6205adec..041933deb4ec 100644
--- a/llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp
+++ b/llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp
@@ -44,11 +44,11 @@ namespace {
 // modified before a call to `makeObj()` to test parser with invalid
 // input, etc.
 
+struct MockData1 {
 // Use "pragma pack" to model .BTF & .BTF.ext sections content using
 // 'struct' objects. This pragma is supported by CLANG, GCC & MSVC,
 // which matters for LLVM CI.
 #pragma pack(push, 1)
-struct MockData1 {
   struct B {
     BTF::Header Header = {};
     // no types
@@ -99,6 +99,7 @@ struct MockData1 {
       Header.LineInfoLen = sizeof(Lines);
     }
   } Ext;
+#pragma pack(pop)
 
   int BTFSectionLen = sizeof(BTF);
   int ExtSectionLen = sizeof(Ext);
@@ -143,7 +144,6 @@ Sections:
     return *Obj.get();
   }
 };
-#pragma pack(pop)
 
 TEST(BTFParserTest, simpleCorrectInput) {
   BTFParser BTF;
diff --git a/llvm/unittests/DebugInfo/BTF/CMakeLists.txt b/llvm/unittests/DebugInfo/BTF/CMakeLists.txt
index b425e46b9f0c..8cd4b793a741 100644
--- a/llvm/unittests/DebugInfo/BTF/CMakeLists.txt
+++ b/llvm/unittests/DebugInfo/BTF/CMakeLists.txt
@@ -10,4 +10,11 @@ add_llvm_unittest(DebugInfoBTFTests
 
 target_link_libraries(DebugInfoBTFTests PRIVATE LLVMTestingSupport)
 
+# Packed structures are used in the test. Asan/UBsan can catch
+# unaligned access errors, but such builds take significant time.
+# Use clang's -Wunaligned-access to get a heads-up.
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  set_source_files_properties(BTFParserTest.cpp PROPERTIES COMPILE_FLAGS -Wunaligned-access)
+endif()
+
 set_property(TARGET DebugInfoBTFTests PROPERTY FOLDER "Tests/UnitTests/DebugInfoTests")

llvm-project is conservative on library/unittest specific cflags. If this #pragma shuffling fixes the issue (-fsanitize=alignment implied by -fsanitize=undefined), push just this part.
-fsanitize=alignment is unrelated to asan.

[eddyz87]

I opened D155176 with packed attribute shuffling, will commit after pre-merge checks are complete for it.
(Want to make sure that the change does not cause issues with MSVC).

llvm/include/llvm/DebugInfo/BTF/BTFContext.h

+#ifndef LLVM_DEBUGINFO_BPF_BPFCONTEXT_H
+#define LLVM_DEBUGINFO_BPF_BPFCONTEXT_H
+
+#include "llvm/DebugInfo/DIContext.h"
+#include <memory>
+
+namespace llvm {
+
+class BTFContext : public DIContext {
+  struct Impl;
+  std::unique_ptr<Impl> Impl;
+
+public:
+  BTFContext(struct Impl *Impl);
+  ~BTFContext();
+
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts) override;
+
+  bool verify(raw_ostream &OS, DIDumpOptions DumpOpts = {}) override;
+
+  DILineInfo getLineInfoForAddress(
+      object::SectionedAddress Address,
+      DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
+
+  DILineInfo
+  getLineInfoForDataAddress(object::SectionedAddress Address) override;
+
+  DILineInfoTable getLineInfoForAddressRange(
+      object::SectionedAddress Address, uint64_t Size,
+      DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
+
+  DIInliningInfo getInliningInfoForAddress(
+      object::SectionedAddress Address,
+      DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
+
+  std::vector<DILocal>
+  getLocalsForAddress(object::SectionedAddress Address) override;
+
+  static std::unique_ptr<BTFContext> create(const object::ObjectFile &Obj);
+  static bool hasBTFSections(const object::ObjectFile &Obj);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_BPF_BPFCONTEXT_H

llvm/include/llvm/DebugInfo/DIContext.h

struct DILineInfo {
   // DILineInfo contains "<invalid>" for function/filename it cannot fetch.
   static constexpr const char *const BadString = "<invalid>";
   // Use "??" instead of "<invalid>" to make our output closer to addr2line.
   static constexpr const char *const Addr2LineBadString = "??";
   std::string FileName;
   std::string FunctionName;
   std::string StartFileName;
   std::optional<StringRef> Source;
+  std::optional<StringRef> LineSource;
   uint32_t Line = 0;
   uint32_t Column = 0;
   uint32_t StartLine = 0;
   std::optional<uint64_t> StartAddress;
 
   // DWARF-specific.
   uint32_t Discriminator = 0;
 
struct DIDumpOptions {
 
   std::function<void(Error)> RecoverableErrorHandler =
       WithColor::defaultErrorHandler;
   std::function<void(Error)> WarningHandler = WithColor::defaultWarningHandler;
 };
 
 class DIContext {
 public:
-  enum DIContextKind { CK_DWARF, CK_PDB };
+  enum DIContextKind { CK_DWARF, CK_PDB, CK_BTF };
 
   DIContext(DIContextKind K) : Kind(K) {}
   virtual ~DIContext() = default;
 
   DIContextKind getKind() const { return Kind; }
 
   virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts) = 0;
 

llvm/lib/DebugInfo/BTF/BTFContext.cpp

+#include "llvm/DebugInfo/BTF/BTFContext.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/DIContext.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/DataExtractor.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
+#include <algorithm>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <optional>
+
+using namespace llvm;
+using object::ObjectFile;
+using object::SectionedAddress;
+using object::SectionRef;
+
+#define DEBUG_TYPE "debug-info-bpf"
+
+#define EBPF_MAGIC 0xEB9F
+#define BTF_SECTION_NAME ".BTF"
+#define BTF_EXT_SECTION_NAME ".BTF.ext"
+
+class Err {
+  std::string Buffer;
+  raw_string_ostream Stream;
+
+public:
+  Err(const char *InitialMsg) : Buffer(InitialMsg), Stream(Buffer){};
+
+  template <typename T> Err &operator<<(T Val) {
+    Stream << Val;
+    return *this;
+  }
+
+  Err &write_hex(unsigned long long Val) {
+    Stream.write_hex(Val);
+    return *this;
+  }
+
+  Err &operator<<(Error Val) {
+    handleAllErrors(std::move(Val),
+                    [=](ErrorInfoBase &Info) { Stream << Info.message(); });
+    return *this;
+  }
+
+  operator Error() const {
+    return make_error<StringError>(Buffer, errc::invalid_argument);
+  }
+
+  template <typename T> operator Expected<T>() const { return (Error) * this; }
+};
+
+struct BTFLineInfo {
+  // Offset of instruction from beginning of a section (in bytes)
+  uint32_t InsnAddress;
+  // Offsets in strings table (in bytes)
+  uint32_t FileNameOff;
+  uint32_t LineOff;
+  // Combined line and column number information
+  uint32_t LineCol;
+
+  uint32_t getLine() { return LineCol >> 10; }
+  uint32_t getCol() { return LineCol & 0x3ff; }
+};
+
+// The vector is sorted by InsnOff for fast lookups
+using BTFLinesVector = std::vector<BTFLineInfo>;
+
+struct BTFInfo {
+  StringRef StringsTable;
+  std::map<uint64_t, std::unique_ptr<BTFLinesVector>> SectionLines;
+
+  StringRef findString(uint32_t Offset) {
+    return StringsTable.slice(Offset, StringsTable.find(0, Offset));
+  }
+};
+
+class ParseContext {
+  const ObjectFile &Obj;
+  std::map<StringRef, SectionRef> Sections;
+
+public:
+  ParseContext(const ObjectFile &Obj) : Obj(Obj) {}
+
+  Error init() {
+    for (SectionRef Sec : Obj.sections()) {
+      Expected<StringRef> MaybeName = Sec.getName();
+      if (!MaybeName)
+        return MaybeName.takeError();
+
+      Sections[*MaybeName] = Sec;
+    }
+
+    return Error::success();
+  }
+
+  Expected<DataExtractor> makeExtractor(SectionRef Sec) {
+    auto Contents = Sec.getContents();
+    if (!Contents)
+      return Contents.takeError();
+
+    return DataExtractor(Contents.get(), Obj.isLittleEndian(),
+                         Obj.getBytesInAddress());
+  }
+
+  std::optional<SectionRef> findSection(StringRef Name) {
+    auto It = Sections.find(Name);
+    if (It != Sections.end())
+      return It->second;
+    return std::nullopt;
+  }
+};
+
+static Error parseBTF(ParseContext &Ctx, SectionRef BTF, BTFInfo &Info) {
+  auto MaybeExtractor = Ctx.makeExtractor(BTF);
+  if (!MaybeExtractor)
+    return MaybeExtractor.takeError();
+
+  auto Extractor = MaybeExtractor.get();
+  DataExtractor::Cursor C = DataExtractor::Cursor(0);
+
+  auto Magic = Extractor.getU16(C);
+  if (Magic != EBPF_MAGIC)
+    return Err("Invalid .BTF.ext magic: ").write_hex(Magic);
+
+  Extractor.getU8(C); // version
+  Extractor.getU8(C); // flags
+  auto HdrLen = Extractor.getU32(C);
+  if (HdrLen < 8)
+    return Err("Unexpected .BTF header length: ") << HdrLen;
+
+  Extractor.getU32(C); // type_off
+  Extractor.getU32(C); // type_len
+  auto StrOff = Extractor.getU32(C);
+  auto StrLen = Extractor.getU32(C);
+  auto StrStart = HdrLen + StrOff;
+
+  if (!C)
+    return C.takeError();
+
+  Info.StringsTable = Extractor.getData().slice(StrStart, StrStart + StrLen);
+
+  return Error::success();
+}
+
+static Error parseLineInfo(ParseContext &Ctx, DataExtractor &Extractor,
+                           uint64_t LineInfoStart, uint64_t LineInfoEnd,
+                           BTFInfo &Info) {
+  DataExtractor::Cursor C = DataExtractor::Cursor(LineInfoStart);
+  auto RecSize = Extractor.getU32(C);
+  if (RecSize < 16)
+    return Err("Unexpected .BTF.ext line info record length: ") << RecSize;
+
+  while (C && C.tell() < LineInfoEnd) {
+    std::unique_ptr<BTFLinesVector> Lines(new BTFLinesVector());
+
+    auto SecNameOff = Extractor.getU32(C);
+    auto NumInfo = Extractor.getU32(C);
+
+    auto SecName = Info.findString(SecNameOff);
+    auto Sec = Ctx.findSection(SecName);
+
+    for (uint32_t I = 0; C && I < NumInfo; ++I) {
+      auto RecStart = C.tell();
+
+      auto InsnOff = Extractor.getU32(C);
+      auto FileNameOff = Extractor.getU32(C);
+      auto LineOff = Extractor.getU32(C);
+      auto LineCol = Extractor.getU32(C);
+
+      Lines->push_back({InsnOff, FileNameOff, LineOff, LineCol});
+
+      C.seek(RecStart + RecSize);
+    }
+
+    std::sort(Lines->begin(), Lines->end(),
+              [](const BTFLineInfo &L, const BTFLineInfo &R) {
+                return L.InsnAddress < R.InsnAddress;
+              });
+
+    if (Sec)
+      Info.SectionLines[Sec->getIndex()] = std::move(Lines);
+  }
+
+  if (!C)
+    return Err("Error while reading .BTF.ext line info ") << C.takeError();
+
+  return Error::success();
+}
+
+static Error parseBTFExt(ParseContext &Ctx, SectionRef BTFExt, BTFInfo &Info) {
+  auto MaybeExtractor = Ctx.makeExtractor(BTFExt);
+  if (!MaybeExtractor)
+    return MaybeExtractor.takeError();
+
+  auto Extractor = MaybeExtractor.get();
+  DataExtractor::Cursor C = DataExtractor::Cursor(0);
+
+  auto Magic = Extractor.getU16(C);
+  if (Magic != EBPF_MAGIC)
+    return Err("Invalid .BTF.ext magic: ").write_hex(Magic);
+
+  Extractor.getU8(C); // version
+  Extractor.getU8(C); // flags
+  auto HdrLen = Extractor.getU32(C);
+  if (HdrLen < 8)
+    return Err("Unexpected .BTF.ext header length: ") << HdrLen;
+
+  Extractor.getU32(C); // func_info_off
+  Extractor.getU32(C); // func_info_len
+  auto LineInfoOff = Extractor.getU32(C);
+  auto LineInfoLen = Extractor.getU32(C);
+
+  if (!C)
+    return Err("Error while reading .BTF.ext header ") << C.takeError();
+
+  auto LineInfoStart = HdrLen + LineInfoOff;
+  auto LineInfoEnd = LineInfoStart + LineInfoLen;
+
+  if (auto E = parseLineInfo(Ctx, Extractor, LineInfoStart, LineInfoEnd, Info))
+    return E;
+
+  return Error::success();
+}
+
+static Error parseBTFSections(const ObjectFile &Obj, BTFInfo &Info) {
+  ParseContext Ctx(Obj);
+
+  if (auto E = Ctx.init())
+    return E;
+
+  auto BTF = Ctx.findSection(BTF_SECTION_NAME);
+  auto BTFExt = Ctx.findSection(BTF_EXT_SECTION_NAME);
+
+  if (!BTF)
+    return Err("Can't find .BTF section");
+
+  if (!BTFExt)
+    return Err("Can't find .BTF.ext section");
+
+  if (auto E = parseBTF(Ctx, *BTF, Info))
+    return E;
+
+  if (auto E = parseBTFExt(Ctx, *BTFExt, Info))
+    return E;
+
+  return Error::success();
+}
+
+struct llvm::BTFContext::Impl {
+  BTFInfo BTF;
+};
+
+BTFContext::BTFContext(struct Impl *Impl) : DIContext(CK_BTF), Impl(Impl) {}
+
+BTFContext::~BTFContext() {}
+
+void BTFContext::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
+  // TODO
+}
+
+bool BTFContext::verify(raw_ostream &OS, DIDumpOptions DumpOpts) {
+  // TODO
+  return true;
+}
+
+DILineInfo BTFContext::getLineInfoForAddress(SectionedAddress Address,
+                                             DILineInfoSpecifier Specifier) {
+  BTFInfo &BTF = Impl->BTF;
+  auto MaybeSecInfo = BTF.SectionLines.find(Address.SectionIndex);
+  if (MaybeSecInfo == BTF.SectionLines.end()) {
+    LLVM_DEBUG(llvm::dbgs() << "No sec info for " << Address << "\n");
+    return {};
+  }
+
+  auto &SecInfo = MaybeSecInfo->second;
+  auto LineInfo = std::lower_bound(
+      SecInfo->begin(), SecInfo->end(), Address.Address,
+      [](BTFLineInfo &Line, uint64_t Addr) { return Line.InsnAddress < Addr; });
+  if (LineInfo == SecInfo->end() || LineInfo->InsnAddress != Address.Address) {
+    LLVM_DEBUG(llvm::dbgs() << "No line info for " << Address << "\n");
+    return {};
+  }
+
+  DILineInfo Result;
+  Result.LineSource = BTF.findString(LineInfo->LineOff);
+  Result.FileName = BTF.findString(LineInfo->FileNameOff);
+  Result.Line = LineInfo->getLine();
+  Result.Column = LineInfo->getCol();
+  return Result;
+}
+
+DILineInfo BTFContext::getLineInfoForDataAddress(SectionedAddress Address) {
+  return DILineInfo();
+}
+
+DILineInfoTable
+BTFContext::getLineInfoForAddressRange(SectionedAddress Address, uint64_t Size,
+                                       DILineInfoSpecifier Specifier) {
+  return DILineInfoTable();
+}
+
+DIInliningInfo
+BTFContext::getInliningInfoForAddress(SectionedAddress Address,
+                                      DILineInfoSpecifier Specifier) {
+  return DIInliningInfo();
+}
+
+std::vector<DILocal> BTFContext::getLocalsForAddress(SectionedAddress Address) {
+  return std::vector<DILocal>();
+}
+
+std::unique_ptr<BTFContext> BTFContext::create(const ObjectFile &Obj) {
+  auto Result = std::make_unique<BTFContext>(new struct BTFContext::Impl());
+  if (auto E = parseBTFSections(Obj, Result->Impl->BTF))
+    WithColor::defaultErrorHandler(std::move(E));
+  return Result;
+}
+
+bool BTFContext::hasBTFSections(const ObjectFile &Obj) {
+  bool HasBTF = false;
+  bool HasBTFExt = false;
+  for (auto Sec : Obj.sections()) {
+    if (auto Name = Sec.getName()) {
+      HasBTF |= *Name == BTF_SECTION_NAME;
+      HasBTFExt |= *Name == BTF_EXT_SECTION_NAME;
+      if (HasBTF && HasBTFExt)
+        return true;
+    }
+  }
+  return false;
+}

llvm/lib/DebugInfo/BTF/CMakeLists.txt

+add_llvm_component_library(LLVMDebugInfoBTF
+  BTFContext.cpp
+  ADDITIONAL_HEADER_DIRS
+  "${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/BTF"
+
+  LINK_COMPONENTS
+  Support
+  )

llvm/lib/DebugInfo/CMakeLists.txt

 add_subdirectory(DWARF)
 add_subdirectory(GSYM)
 add_subdirectory(LogicalView)
 add_subdirectory(MSF)
 add_subdirectory(CodeView)
 add_subdirectory(PDB)
 add_subdirectory(Symbolize)
+add_subdirectory(BTF)

llvm/lib/DebugInfo/Symbolize/CMakeLists.txt

 add_llvm_component_library(LLVMSymbolize
   DIPrinter.cpp
   Markup.cpp
   MarkupFilter.cpp
   SymbolizableObjectFile.cpp
   Symbolize.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/Symbolize
 
   LINK_COMPONENTS
   DebugInfoDWARF
   DebugInfoPDB
+  DebugInfoBTF
   Object
   Support
   Demangle
   TargetParser
   )

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

 //===-- LLVMSymbolize.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
 //
 //===----------------------------------------------------------------------===//
 //
 // Implementation for LLVM symbolization library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/DebugInfo/BTF/BTFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/DebugInfo/PDB/PDBContext.h"
 #include "llvm/DebugInfo/Symbolize/SymbolizableObjectFile.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Object/BuildID.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/ELFObjectFile.h"
if (ModuleOrErr) {
     auto I = Modules.find(ModuleName);
     BinaryForPath.find(BinaryName)->second.pushEvictor([this, I]() {
       Modules.erase(I);
     });
   }
   return ModuleOrErr;
 }
 
+// For BPF programs .BTF.ext section contains line numbers information,
+// use it if regular DWARF is not available (e.g. for stripped binary).
+static bool useBTFContext(const ObjectFile &Obj) {
+  auto Arch = Obj.getArch();
+  if (Arch != Triple::ArchType::bpfel && Arch != Triple::ArchType::bpfeb)
+    return false;
+
+  if (Obj.hasDebugInfo())
+    return false;
+
+  return BTFContext::hasBTFSections(Obj);
+}
+
 Expected<SymbolizableModule *>
 LLVMSymbolizer::getOrCreateModuleInfo(const ObjectFile &Obj) {
   StringRef ObjName = Obj.getFileName();
   auto I = Modules.find(ObjName);
   if (I != Modules.end())
     return I->second.get();
 
-  std::unique_ptr<DIContext> Context = DWARFContext::create(Obj);
+  std::unique_ptr<DIContext> Context;
+  if (useBTFContext(Obj))
+    Context = BTFContext::create(Obj);
+  else
+    Context = DWARFContext::create(Obj);
   // FIXME: handle COFF object with PDB info to use PDBContext
   return createModuleInfo(&Obj, std::move(Context), ObjName);
 }
 
 Expected<SymbolizableModule *>
 LLVMSymbolizer::getOrCreateModuleInfo(ArrayRef<uint8_t> BuildID) {
   std::string Path;
   if (!getOrFindDebugBinary(BuildID, Path)) {

llvm/test/tools/llvm-objdump/BPF/Inputs/test.c

+extern int consume(int);
+
+void foo(void) {
+  consume(1);
+  consume(2);
+}
+
+__attribute__((section("a")))
+void bar(void) {
+  consume(3);
+}
+
+__attribute__((section("b")))
+void buz(void) {
+  consume(4);
+}

llvm/test/tools/llvm-objdump/BPF/interleaved-source-test.ll

+; REQUIRES: bpf-registered-target
+;
+; Verify that llvm-objdump can use .BTF.ext to extract line number
+; information in disassembly when DWARF is not available.
+;
+; The 'sed' part is needed because llc would look for source file in
+; order to embed line info when BPF is compiled.
+;
+; RUN: sed -e "s,SRC_COMPDIR,%p/Inputs,g" %s > %t.ll
+;
+; First, check bpfel:
+;
+; RUN: llc --mtriple bpfel %t.ll --filetype=obj -o %t
+; RUN: llvm-strip --strip-debug %t
+; RUN: llvm-objdump --section-headers %t | FileCheck --check-prefix=SECTIONS %s
+; RUN: llvm-objdump --no-addresses --no-show-raw-insn -Sd %t | FileCheck %s
+;
+; Next, check bpfeb:
+;
+; RUN: llc --mtriple bpfeb %t.ll --filetype=obj -o %t
+; RUN: llvm-strip --strip-debug %t
+; RUN: llvm-objdump --section-headers %t | FileCheck --check-prefix=SECTIONS %s
+; RUN: llvm-objdump -Sd %t | FileCheck %s
+;
+; Test case adapted from output of the following command:
+;
+;  clang -g -target bpf -emit-llvm -S ./Inputs/test.c
+;
+; DIFile::directory is changed to SRC_COMPDIR.
+;
+
+; Make sure that BTF is present and DWARF is stripped:
+;
+; SECTIONS: .BTF
+; SECTIONS: .BTF.ext
+; SECTIONS-NOT: .debug_line
+; SECTIONS-NOT: .debug_line_str
+
+; Check source code in disassembly:
+;
+; CHECK:      Disassembly of section .text:
+; CHECK-EMPTY:
+; CHECK-NEXT: <foo>:
+; CHECK-NEXT: ;   consume(1);
+; CHECK-NEXT:        r1 = 0x1
+; CHECK-NEXT:        call -0x1
+; CHECK-NEXT: ;   consume(2);
+; CHECK-NEXT:        r1 = 0x2
+; CHECK-NEXT:        call -0x1
+; CHECK-NEXT: ; }
+; CHECK-NEXT:        exit
+; CHECK-EMPTY:
+; CHECK-NEXT: Disassembly of section a:
+; CHECK-EMPTY:
+; CHECK-NEXT: <bar>:
+; CHECK-NEXT: ;   consume(3);
+; CHECK-NEXT:        r1 = 0x3
+; CHECK-NEXT:        call -0x1
+; CHECK-NEXT: ; }
+; CHECK-NEXT:        exit
+; CHECK-EMPTY:
+; CHECK-NEXT: Disassembly of section b:
+; CHECK-EMPTY:
+; CHECK-NEXT: <buz>:
+; CHECK-NEXT: ;   consume(4);
+; CHECK-NEXT:        r1 = 0x4
+; CHECK-NEXT:        call -0x1
+; CHECK-NEXT: ; }
+; CHECK-NEXT:        exit
+
+; Function Attrs: noinline nounwind optnone
+define dso_local void @foo() #0 !dbg !7 {
+  %1 = call i32 @consume(i32 noundef 1), !dbg !12
+  %2 = call i32 @consume(i32 noundef 2), !dbg !13
+  ret void, !dbg !14
+}
+
+declare dso_local i32 @consume(i32 noundef) #1
+
+; Function Attrs: noinline nounwind optnone
+define dso_local void @bar() #0 section "a" !dbg !15 {
+  %1 = call i32 @consume(i32 noundef 3), !dbg !16
+  ret void, !dbg !17
+}
+
+; Function Attrs: noinline nounwind optnone
+define dso_local void @buz() #0 section "b" !dbg !18 {
+  %1 = call i32 @consume(i32 noundef 4), !dbg !19
+  ret void, !dbg !20
+}
+
+attributes #0 = { noinline nounwind optnone "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #1 = { "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "Ubuntu clang version 14.0.0-1ubuntu1", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "/home/eddy/work/llvm-project/llvm/test/tools/llvm-objdump/BPF/Inputs/test.c", directory: "/home/eddy", checksumkind: CSK_MD5, checksum: "73d9dbf2a4ebbbb25f026b623953473b")
+!2 = !{i32 7, !"Dwarf Version", i32 5}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = !{i32 1, !"wchar_size", i32 4}
+!5 = !{i32 7, !"frame-pointer", i32 2}
+!6 = !{!"Ubuntu clang version 14.0.0-1ubuntu1"}
+!7 = distinct !DISubprogram(name: "foo", scope: !8, file: !8, line: 3, type: !9, scopeLine: 3, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !11)
+!8 = !DIFile(filename: "test.c", directory: "SRC_COMPDIR", checksumkind: CSK_MD5, checksum: "73d9dbf2a4ebbbb25f026b623953473b")
+!9 = !DISubroutineType(types: !10)
+!10 = !{null}
+!11 = !{}
+!12 = !DILocation(line: 4, column: 3, scope: !7)
+!13 = !DILocation(line: 5, column: 3, scope: !7)
+!14 = !DILocation(line: 6, column: 1, scope: !7)
+!15 = distinct !DISubprogram(name: "bar", scope: !8, file: !8, line: 9, type: !9, scopeLine: 9, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !11)
+!16 = !DILocation(line: 10, column: 3, scope: !15)
+!17 = !DILocation(line: 11, column: 1, scope: !15)
+!18 = distinct !DISubprogram(name: "buz", scope: !8, file: !8, line: 14, type: !9, scopeLine: 14, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !11)
+!19 = !DILocation(line: 15, column: 3, scope: !18)
+!20 = !DILocation(line: 16, column: 1, scope: !18)

llvm/tools/llvm-objdump/SourcePrinter.h

private:
 
   void printLines(formatted_raw_ostream &OS, const DILineInfo &LineInfo,
                   StringRef Delimiter, LiveVariablePrinter &LVP);
 
   void printSources(formatted_raw_ostream &OS, const DILineInfo &LineInfo,
                     StringRef ObjectFilename, StringRef Delimiter,
                     LiveVariablePrinter &LVP);
 
+  std::optional<StringRef> getLine(const DILineInfo &LineInfo,
+                                   StringRef ObjectFilename);
+
 public:
   SourcePrinter() = default;
   SourcePrinter(const object::ObjectFile *Obj, StringRef DefaultArch);
   virtual ~SourcePrinter() = default;
   virtual void printSourceLine(formatted_raw_ostream &OS,
                                object::SectionedAddress Address,
                                StringRef ObjectFilename,
                                LiveVariablePrinter &LVP,
                                StringRef Delimiter = "; ");
 };
 
 } // namespace objdump
 } // namespace llvm
 
 #endif

llvm/tools/llvm-objdump/SourcePrinter.cpp

void SourcePrinter::printLines(formatted_raw_ostream &OS,
   if (LineInfo.FileName != DILineInfo::BadString && LineInfo.Line != 0 &&
       (OldLineInfo.Line != LineInfo.Line ||
        OldLineInfo.FileName != LineInfo.FileName || PrintFunctionName)) {
     OS << Delimiter << LineInfo.FileName << ":" << LineInfo.Line;
     LVP.printBetweenInsts(OS, true);
   }
 }
 
-void SourcePrinter::printSources(formatted_raw_ostream &OS,
-                                 const DILineInfo &LineInfo,
-                                 StringRef ObjectFilename, StringRef Delimiter,
-                                 LiveVariablePrinter &LVP) {
-  if (LineInfo.FileName == DILineInfo::BadString || LineInfo.Line == 0 ||
-      (OldLineInfo.Line == LineInfo.Line &&
-       OldLineInfo.FileName == LineInfo.FileName))
-    return;
+std::optional<StringRef> SourcePrinter::getLine(const DILineInfo &LineInfo,
+                                                StringRef ObjectFilename) {
+  if (LineInfo.LineSource)
+    return LineInfo.LineSource;
 
   if (SourceCache.find(LineInfo.FileName) == SourceCache.end())
     if (!cacheSource(LineInfo))
-      return;
+      return std::nullopt;
+
   auto LineBuffer = LineCache.find(LineInfo.FileName);
-  if (LineBuffer != LineCache.end()) {
-    if (LineInfo.Line > LineBuffer->second.size()) {
-      reportWarning(
-          formatv(
-              "debug info line number {0} exceeds the number of lines in {1}",
+  if (LineBuffer == LineCache.end())
+    return std::nullopt;
+
+        formatv("debug info line number {0} exceeds the number of lines in {1}",
                 LineInfo.Line, LineInfo.FileName),
-          ObjectFilename);
-      return;
-    }
-    // Vector begins at 0, line numbers are non-zero
-    OS << Delimiter << LineBuffer->second[LineInfo.Line - 1];
+    return std::nullopt;
+
+  return LineBuffer->second[LineInfo.Line - 1];
+}
+
+void SourcePrinter::printSources(formatted_raw_ostream &OS,
+                                 const DILineInfo &LineInfo,
+                                 StringRef ObjectFilename, StringRef Delimiter,
+                                 LiveVariablePrinter &LVP) {
+  if (LineInfo.FileName == DILineInfo::BadString || LineInfo.Line == 0 ||
+      (OldLineInfo.Line == LineInfo.Line &&
+       OldLineInfo.FileName == LineInfo.FileName))
+    return;
+
+  if (auto Line = getLine(LineInfo, ObjectFilename)) {
+    OS << Delimiter << Line;
     LVP.printBetweenInsts(OS, true);
   }
 }
 
 SourcePrinter::SourcePrinter(const object::ObjectFile *Obj,
                              StringRef DefaultArch)
     : Obj(Obj) {
   symbolize::LLVMSymbolizer::Options SymbolizerOpts;