[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

34

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.

45

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

105

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

24

unused?

26

unused?

[nickdesaulniers]

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

91

size_t

[MaskRay]

Apologies for my slow response. Reading...

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

248

ditto below

[MaskRay]

llvm/lib/DebugInfo/BTF/BTFParser.cpp

30

const char BTF_SECTION_NAME[] = ".BTF"

48

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.

53

{}; => {}

56

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

81

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

87

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

251

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.

252

Error E

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

257

delete blank line

259

don't capitalize

260

delete blank line

277

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

135

Check whether the version is supported and add a test

176

Check whether the version is supported and add a test

211

make_unqiue

212

delete blank line

[MaskRay]

llvm/lib/DebugInfo/BTF/BTFParser.cpp

157

substr

delete blank line

215

delete blank line

218

delete blank line

221

delete blank line

226

delete blank line

288

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

56

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

81

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

288

• 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

91

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

25

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

103

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

45

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.

56

63

76

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

103

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

133

Make it explicit you discard the return value.

166

Make it explicit you discard the return value.

172

Make it explicit you discard the return value.

208

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

210

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

226

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

272

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

19

We normally place using namespace immediately below #include

27

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

54

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

22

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

[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/BTF.h

 
 /// Specifying one line info.
 struct BPFLineInfo {
   uint32_t InsnOffset;  ///< Byte offset in this section
   uint32_t FileNameOff; ///< File name index in the .BTF string table
   uint32_t LineOff;     ///< Line index in the .BTF string table
   uint32_t LineCol;     ///< Line num: line_col >> 10,
                         ///  col num: line_col & 0x3ff
+  uint32_t getLine() const { return LineCol >> 10; }
+  uint32_t getCol() const { return LineCol & 0x3ff; }
 };
 
 /// Specifying line info's in one section.
 struct SecLineInfo {
   uint32_t SecNameOff;  ///< Section name index in the .BTF string table
   uint32_t NumLineInfo; ///< Number of line info's in this section
 };
 

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

+//===- BTFContext.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
+//
+//===----------------------------------------------------------------------===//
+//
+// BTFContext interface is used by llvm-objdump tool to print source
+// code alongside disassembly.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_BTF_BTFCONTEXT_H
+#define LLVM_DEBUGINFO_BTF_BTFCONTEXT_H
+
+#include "llvm/DebugInfo/BTF/BTFParser.h"
+#include "llvm/DebugInfo/DIContext.h"
+
+namespace llvm {
+
+class BTFContext : public DIContext {
+  BTFParser BTF;
+
+public:
+  BTFContext() : DIContext(CK_BTF) {}
+
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts) override {
+    // This function is called from objdump when --dwarf=? option is set.
+    // BTF is no DWARF, so ignore this operation for now.
+  }
+
+  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,
+      std::function<void(Error)> ErrorHandler = WithColor::defaultErrorHandler);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_DEBUGINFO_BTF_BTFCONTEXT_H

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

+//===- BTFParser.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
+//
+//===----------------------------------------------------------------------===//
+//
+// BTFParser reads .BTF and .BTF.ext ELF sections generated by LLVM
+// BPF backend and provides introspection for the stored information.
+// Currently the following information is accessible:
+// - string table;
+// - instruction offset to line information mapping.
+//
+// See llvm/DebugInfo/BTF/BTF.h for some details about binary format
+// and links to Linux Kernel documentation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_DEBUGINFO_BTF_BTFPARSER_H
+#define LLVM_DEBUGINFO_BTF_BTFPARSER_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/DebugInfo/BTF/BTF.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/DataExtractor.h"
+
+namespace llvm {
+using object::ObjectFile;
+using object::SectionedAddress;
+using object::SectionRef;
+
+class BTFParser {
+  using BTFLinesVector = SmallVector<BTF::BPFLineInfo, 0>;
+
+  // In BTF strings are stored as a continuous memory region with
+  // individual strings separated by 0 bytes. Strings are identified
+  // by an offset in such region.
+  // The `StringsTable` points to this region in the parsed ObjectFile.
+  StringRef StringsTable;
+
+  // Maps ELF section number to instruction line number information.
+  // Each BTFLinesVector is sorted by `InsnOffset` to allow fast lookups.
+  DenseMap<uint64_t, BTFLinesVector> SectionLines;
+
+  struct ParseContext;
+  Error parseBTF(ParseContext &Ctx, SectionRef BTF);
+  Error parseBTFExt(ParseContext &Ctx, SectionRef BTFExt);
+  Error parseLineInfo(ParseContext &Ctx, DataExtractor &Extractor,
+                      uint64_t LineInfoStart, uint64_t LineInfoEnd);
+
+public:
+  // Looks-up a string in the .BTF section's string table.
+  // Offset is relative to string table start.
+  StringRef findString(uint32_t Offset) const;
+
+  // Search for line information for a specific address,
+  // address match is exact (contrary to DWARFContext).
+  // Return nullptr if no information found.
+  // If information is present, return a pointer to object
+  // owned by this class.
+  const BTF::BPFLineInfo *findLineInfo(SectionedAddress Address) const;
+
+  // Fills instance of BTFParser with information stored in .BTF and
+  // .BTF.ext sections of the `Obj`. If this instance was already
+  // filled, old data is discarded.
+  //
+  // If information cannot be parsed:
+  // - return an error describing the failure;
+  // - state of the BTFParser might be incomplete but is not invalid,
+  //   queries might be run against it, but some (or all) information
+  //   might be unavailable;
+  Error parse(const ObjectFile &Obj);
+
+  // Return true if `Obj` has .BTF and .BTF.ext sections.
+  static bool hasBTFSections(const ObjectFile &Obj);
+};
+
+} // namespace llvm
+
+#endif // LLVM_DEBUGINFO_BTF_BTFPARSER_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;
+  // Full source corresponding to `FileName`
   std::optional<StringRef> Source;
+  // Source code for this particular line
+  // (in case if `Source` is not available)
+  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

+//===- BTFContext.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 of the BTFContext interface, this is used by
+// llvm-objdump tool to print source code alongside disassembly.
+// In fact, currently it is a simple wrapper for BTFParser instance.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/BTF/BTFContext.h"
+
+#define DEBUG_TYPE "debug-info-btf-context"
+
+using namespace llvm;
+using object::ObjectFile;
+using object::SectionedAddress;
+
+DILineInfo BTFContext::getLineInfoForAddress(SectionedAddress Address,
+                                             DILineInfoSpecifier Specifier) {
+  const BTF::BPFLineInfo *LineInfo = BTF.findLineInfo(Address);
+  DILineInfo Result;
+  if (!LineInfo)
+    return 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) {
+  // BTF does not convey such information.
+  return {};
+}
+
+DILineInfoTable
+BTFContext::getLineInfoForAddressRange(SectionedAddress Address, uint64_t Size,
+                                       DILineInfoSpecifier Specifier) {
+  // This function is used only from llvm-rtdyld utility and a few
+  // JITEventListener implementations. Ignore it for now.
+  return {};
+}
+
+DIInliningInfo
+BTFContext::getInliningInfoForAddress(SectionedAddress Address,
+                                      DILineInfoSpecifier Specifier) {
+  // BTF does not convey such information
+  return {};
+}
+
+std::vector<DILocal> BTFContext::getLocalsForAddress(SectionedAddress Address) {
+  // BTF does not convey such information
+  return {};
+}
+
+std::unique_ptr<BTFContext>
+BTFContext::create(const ObjectFile &Obj,
+                   std::function<void(Error)> ErrorHandler) {
+  auto Ctx = std::make_unique<BTFContext>();
+  if (Error E = Ctx->BTF.parse(Obj))
+    ErrorHandler(std::move(E));
+  return Ctx;
+}

llvm/lib/DebugInfo/BTF/BTFParser.cpp

+//===- BTFParser.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
+//
+//===----------------------------------------------------------------------===//
+//
+// BTFParser reads/interprets .BTF and .BTF.ext ELF sections.
+// Refer to BTFParser.h for API description.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/DebugInfo/BTF/BTFParser.h"
+#include "llvm/Support/Errc.h"
+
+#define DEBUG_TYPE "debug-info-btf-parser"
+
+using namespace llvm;
+using object::ObjectFile;
+using object::SectionedAddress;
+using object::SectionRef;
+
+const char BTFSectionName[] = ".BTF";
+const char BTFExtSectionName[] = ".BTF.ext";
+
+// Utility class with API similar to raw_ostream but can be cast
+// to Error, e.g.:
+//
+// Error foo(...) {
+//   ...
+//   if (Error E = bar(...))
+//     return Err("error while foo(): ") << E;
+//   ...
+// }
+//
+namespace {
+class Err {
+  std::string Buffer;
+  raw_string_ostream Stream;
+
+public:
+  Err(const char *InitialMsg) : Buffer(InitialMsg), Stream(Buffer) {}
+  Err(const char *SectionName, DataExtractor::Cursor &C)
+      : Buffer(), Stream(Buffer) {
+    *this << "error while reading " << SectionName
+          << " section: " << C.takeError();
+  };
+
+  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);
+  }
+};
+} // anonymous namespace
+
+// ParseContext wraps information that is only necessary while parsing
+// ObjectFile and can be discarded once parsing is done.
+// Used by BTFParser::parse* auxiliary functions.
+struct BTFParser::ParseContext {
+  const ObjectFile &Obj;
+  // Map from ELF section name to SectionRef
+  DenseMap<StringRef, SectionRef> Sections;
+
+public:
+  ParseContext(const ObjectFile &Obj) : Obj(Obj) {}
+
+  Expected<DataExtractor> makeExtractor(SectionRef Sec) {
+    Expected<StringRef> Contents = Sec.getContents();
+    if (!Contents)
+      return Contents.takeError();
+    return DataExtractor(Contents.get(), Obj.isLittleEndian(),
+                         Obj.getBytesInAddress());
+  }
+
+  std::optional<SectionRef> findSection(StringRef Name) const {
+    auto It = Sections.find(Name);
+    if (It != Sections.end())
+      return It->second;
+    return std::nullopt;
+  }
+};
+
+Error BTFParser::parseBTF(ParseContext &Ctx, SectionRef BTF) {
+  Expected<DataExtractor> MaybeExtractor = Ctx.makeExtractor(BTF);
+  if (!MaybeExtractor)
+    return MaybeExtractor.takeError();
+
+  DataExtractor &Extractor = MaybeExtractor.get();
+  DataExtractor::Cursor C = DataExtractor::Cursor(0);
+  uint16_t Magic = Extractor.getU16(C);
+  if (!C)
+    return Err(".BTF", C);
+  if (Magic != BTF::MAGIC)
+    return Err("invalid .BTF magic: ").write_hex(Magic);
+  uint8_t Version = Extractor.getU8(C);
+  if (!C)
+    return Err(".BTF", C);
+  if (Version != 1)
+    return Err("unsupported .BTF version: ") << (unsigned)Version;
+  (void)Extractor.getU8(C); // flags
+  uint32_t HdrLen = Extractor.getU32(C);
+  if (!C)
+    return Err(".BTF", C);
+  if (HdrLen < 8)
+    return Err("unexpected .BTF header length: ") << HdrLen;
+  (void)Extractor.getU32(C); // type_off
+  (void)Extractor.getU32(C); // type_len
+  uint32_t StrOff = Extractor.getU32(C);
+  uint32_t StrLen = Extractor.getU32(C);
+  uint32_t StrStart = HdrLen + StrOff;
+  uint32_t StrEnd = StrStart + StrLen;
+  if (!C)
+    return Err(".BTF", C);
+  if (Extractor.getData().size() < StrEnd)
+    return Err("invalid .BTF section size, expecting at-least ")
+           << StrEnd << " bytes";
+
+  StringsTable = Extractor.getData().substr(StrStart, StrLen);
+  return Error::success();
+}
+
+Error BTFParser::parseBTFExt(ParseContext &Ctx, SectionRef BTFExt) {
+  Expected<DataExtractor> MaybeExtractor = Ctx.makeExtractor(BTFExt);
+  if (!MaybeExtractor)
+    return MaybeExtractor.takeError();
+
+  DataExtractor &Extractor = MaybeExtractor.get();
+  DataExtractor::Cursor C = DataExtractor::Cursor(0);
+  uint16_t Magic = Extractor.getU16(C);
+  if (!C)
+    return Err(".BTF.ext", C);
+  if (Magic != BTF::MAGIC)
+    return Err("invalid .BTF.ext magic: ").write_hex(Magic);
+  uint8_t Version = Extractor.getU8(C);
+  if (!C)
+    return Err(".BTF", C);
+  if (Version != 1)
+    return Err("unsupported .BTF.ext version: ") << (unsigned)Version;
+  (void)Extractor.getU8(C); // flags
+  uint32_t HdrLen = Extractor.getU32(C);
+  if (!C)
+    return Err(".BTF.ext", C);
+  if (HdrLen < 8)
+    return Err("unexpected .BTF.ext header length: ") << HdrLen;
+  (void)Extractor.getU32(C); // func_info_off
+  (void)Extractor.getU32(C); // func_info_len
+  uint32_t LineInfoOff = Extractor.getU32(C);
+  uint32_t LineInfoLen = Extractor.getU32(C);
+  if (!C)
+    return Err(".BTF.ext", C);
+  uint32_t LineInfoStart = HdrLen + LineInfoOff;
+  uint32_t LineInfoEnd = LineInfoStart + LineInfoLen;
+  if (Error E = parseLineInfo(Ctx, Extractor, LineInfoStart, LineInfoEnd))
+    return E;
+
+  return Error::success();
+}
+
+Error BTFParser::parseLineInfo(ParseContext &Ctx, DataExtractor &Extractor,
+                               uint64_t LineInfoStart, uint64_t LineInfoEnd) {
+  DataExtractor::Cursor C = DataExtractor::Cursor(LineInfoStart);
+  uint32_t RecSize = Extractor.getU32(C);
+  if (!C)
+    return Err(".BTF.ext", C);
+  if (RecSize < 16)
+    return Err("unexpected .BTF.ext line info record length: ") << RecSize;
+
+  while (C && C.tell() < LineInfoEnd) {
+    uint32_t SecNameOff = Extractor.getU32(C);
+    uint32_t NumInfo = Extractor.getU32(C);
+    StringRef SecName = findString(SecNameOff);
+    std::optional<SectionRef> Sec = Ctx.findSection(SecName);
+    if (!C)
+      return Err(".BTF.ext", C);
+    if (!Sec)
+      return Err("") << "can't find section '" << SecName
+                     << "' while parsing .BTF.ext line info";
+    BTFLinesVector &Lines = SectionLines[Sec->getIndex()];
+    for (uint32_t I = 0; C && I < NumInfo; ++I) {
+      uint64_t RecStart = C.tell();
+      uint32_t InsnOff = Extractor.getU32(C);
+      uint32_t FileNameOff = Extractor.getU32(C);
+      uint32_t LineOff = Extractor.getU32(C);
+      uint32_t LineCol = Extractor.getU32(C);
+      if (!C)
+        return Err(".BTF.ext", C);
+      Lines.push_back({InsnOff, FileNameOff, LineOff, LineCol});
+      C.seek(RecStart + RecSize);
+    }
+    llvm::stable_sort(Lines,
+                      [](const BTF::BPFLineInfo &L, const BTF::BPFLineInfo &R) {
+                        return L.InsnOffset < R.InsnOffset;
+                      });
+  }
+  if (!C)
+    return Err(".BTF.ext", C);
+
+  return Error::success();
+}
+
+Error BTFParser::parse(const ObjectFile &Obj) {
+  StringsTable = StringRef();
+  SectionLines.clear();
+
+  ParseContext Ctx(Obj);
+  std::optional<SectionRef> BTF;
+  std::optional<SectionRef> BTFExt;
+  for (SectionRef Sec : Obj.sections()) {
+    Expected<StringRef> MaybeName = Sec.getName();
+    if (!MaybeName)
+      return Err("error while reading section name: ") << MaybeName.takeError();
+    Ctx.Sections[*MaybeName] = Sec;
+    if (*MaybeName == BTFSectionName)
+      BTF = Sec;
+    if (*MaybeName == BTFExtSectionName)
+      BTFExt = Sec;
+  }
+  if (!BTF)
+    return Err("can't find .BTF section");
+  if (!BTFExt)
+    return Err("can't find .BTF.ext section");
+  if (Error E = parseBTF(Ctx, *BTF))
+    return E;
+  if (Error E = parseBTFExt(Ctx, *BTFExt))
+    return E;
+
+  return Error::success();
+}
+
+bool BTFParser::hasBTFSections(const ObjectFile &Obj) {
+  bool HasBTF = false;
+  bool HasBTFExt = false;
+  for (SectionRef Sec : Obj.sections()) {
+    Expected<StringRef> Name = Sec.getName();
+    if (Error E = Name.takeError()) {
+      logAllUnhandledErrors(std::move(E), errs());
+      continue;
+    }
+    HasBTF |= *Name == BTFSectionName;
+    HasBTFExt |= *Name == BTFExtSectionName;
+    if (HasBTF && HasBTFExt)
+      return true;
+  }
+  return false;
+}
+
+StringRef BTFParser::findString(uint32_t Offset) const {
+  return StringsTable.slice(Offset, StringsTable.find(0, Offset));
+}
+
+const BTF::BPFLineInfo *
+BTFParser::findLineInfo(SectionedAddress Address) const {
+  auto MaybeSecInfo = SectionLines.find(Address.SectionIndex);
+  if (MaybeSecInfo == SectionLines.end())
+    return nullptr;
+
+  const BTFLinesVector &SecInfo = MaybeSecInfo->second;
+  const uint64_t TargetOffset = Address.Address;
+  BTFLinesVector::const_iterator LineInfo =
+      llvm::partition_point(SecInfo, [=](const BTF::BPFLineInfo &Line) {
+        return Line.InsnOffset < TargetOffset;
+      });
+  if (LineInfo == SecInfo.end() || LineInfo->InsnOffset != Address.Address)
+    return nullptr;
+
+  return LineInfo;
+}

llvm/lib/DebugInfo/BTF/CMakeLists.txt

+add_llvm_component_library(LLVMDebugInfoBTF
+  BTFParser.cpp
+  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) {
+  return Obj.makeTriple().isBPF() && !Obj.hasDebugInfo() &&
+         BTFParser::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);
+}
+
+void bar(void) {
+  consume(3);
+}
+
+__attribute__((section("a")))
+void buz(void) {
+  consume(4);
+}
+
+__attribute__((section("b")))
+void quux(void) {
+  consume(5);
+}

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 (little endian):
+;; - compile %t.o
+;; - check llvm-objdump output when both DWARF and BTF are present
+;; - strip debug info from %t.o
+;; - make sure that there are BTF but no DWARF sections in %t.o
+;; - check llvm-objdump output when only BTF is present
+
+; RUN: llc --mtriple bpfel %t.ll --filetype=obj -o %t
+; RUN: llvm-objdump --no-show-raw-insn -S %t | FileCheck %s
+; RUN: llvm-strip --strip-debug %t
+; RUN: llvm-objdump --section-headers %t \
+; RUN:   | FileCheck --implicit-check-not=.debug_ --check-prefix=SECTIONS %s
+; RUN: llvm-objdump --no-show-raw-insn -S %t | FileCheck %s
+
+;; Next, check bpfeb (big endian):
+
+; RUN: llc --mtriple bpfeb %t.ll --filetype=obj -o %t
+; RUN: llvm-strip --strip-debug %t
+; RUN: llvm-objdump --no-show-raw-insn -S %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.
+
+; SECTIONS: .BTF
+; SECTIONS: .BTF.ext
+
+;; Check inlined source code in disassembly:
+
+; CHECK:      Disassembly of section .text:
+; CHECK-EMPTY:
+; CHECK-NEXT: [[#%x,]] <foo>:
+; CHECK-NEXT: ;   consume(1);
+; CHECK-NEXT:        0: r1 = 0x1
+; CHECK-NEXT:        1: call -0x1
+; CHECK-NEXT: ;   consume(2);
+; CHECK-NEXT:        2: r1 = 0x2
+; CHECK-NEXT:        3: call -0x1
+; CHECK-NEXT: ; }
+; CHECK-NEXT:        4: exit
+; CHECK-EMPTY:
+; CHECK-NEXT: [[#%x,]] <bar>:
+; CHECK-NEXT: ;   consume(3);
+; CHECK-NEXT:        5: r1 = 0x3
+; CHECK-NEXT:        6: call -0x1
+; CHECK-NEXT: ; }
+; CHECK-NEXT:        7: exit
+; CHECK-EMPTY:
+; CHECK-NEXT: Disassembly of section a:
+; CHECK-EMPTY:
+; CHECK-NEXT: [[#%x,]] <buz>:
+; CHECK-NEXT: ;   consume(4);
+; CHECK-NEXT:        0: r1 = 0x4
+; CHECK-NEXT:        1: call -0x1
+; CHECK-NEXT: ; }
+; CHECK-NEXT:        2: exit
+; CHECK-EMPTY:
+; CHECK-NEXT: Disassembly of section b:
+; CHECK-EMPTY:
+; CHECK-NEXT: [[#%x,]] <quux>:
+; CHECK-NEXT: ;   consume(5);
+; CHECK-NEXT:        0: r1 = 0x5
+; CHECK-NEXT:        1: call -0x1
+; CHECK-NEXT: ; }
+; CHECK-NEXT:        2: exit
+
+; Function Attrs: noinline nounwind optnone
+define dso_local void @foo() #0 !dbg !7 {
+entry:
+  %call = call i32 @consume(i32 noundef 1), !dbg !11
+  %call1 = call i32 @consume(i32 noundef 2), !dbg !12
+  ret void, !dbg !13
+}
+
+declare dso_local i32 @consume(i32 noundef) #1
+
+; Function Attrs: noinline nounwind optnone
+define dso_local void @bar() #0 !dbg !14 {
+entry:
+  %call = call i32 @consume(i32 noundef 3), !dbg !15
+  ret void, !dbg !16
+}
+
+; Function Attrs: noinline nounwind optnone
+define dso_local void @buz() #0 section "a" !dbg !17 {
+entry:
+  %call = call i32 @consume(i32 noundef 4), !dbg !18
+  ret void, !dbg !19
+}
+
+; Function Attrs: noinline nounwind optnone
+define dso_local void @quux() #0 section "b" !dbg !20 {
+entry:
+  %call = call i32 @consume(i32 noundef 5), !dbg !21
+  ret void, !dbg !22
+}
+
+attributes #0 = { noinline nounwind optnone "frame-pointer"="all" "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_C11, file: !1, producer: "clang version 17.0.0 (/home/eddy/work/llvm-project/clang 81674c88f80fa7d9c55d4aee945f844b67f03267)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "SRC_COMPDIR", checksumkind: CSK_MD5, checksum: "292d67837b080844462efb2a6b004f09")
+!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 = !{!"clang version 17.0.0 (/home/eddy/work/llvm-project/clang 81674c88f80fa7d9c55d4aee945f844b67f03267)"}
+!7 = distinct !DISubprogram(name: "foo", scope: !8, file: !8, line: 3, type: !9, scopeLine: 3, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0)
+!8 = !DIFile(filename: "test.c", directory: "SRC_COMPDIR", checksumkind: CSK_MD5, checksum: "292d67837b080844462efb2a6b004f09")
+!9 = !DISubroutineType(types: !10)
+!10 = !{null}
+!11 = !DILocation(line: 4, column: 3, scope: !7)
+!12 = !DILocation(line: 5, column: 3, scope: !7)
+!13 = !DILocation(line: 6, column: 1, scope: !7)
+!14 = distinct !DISubprogram(name: "bar", scope: !8, file: !8, line: 8, type: !9, scopeLine: 8, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0)
+!15 = !DILocation(line: 9, column: 3, scope: !14)
+!16 = !DILocation(line: 10, column: 1, scope: !14)
+!17 = distinct !DISubprogram(name: "buz", scope: !8, file: !8, line: 13, type: !9, scopeLine: 13, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0)
+!18 = !DILocation(line: 14, column: 3, scope: !17)
+!19 = !DILocation(line: 15, column: 1, scope: !17)
+!20 = distinct !DISubprogram(name: "quux", scope: !8, file: !8, line: 18, type: !9, scopeLine: 18, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0)
+!21 = !DILocation(line: 19, column: 3, scope: !20)
+!22 = !DILocation(line: 20, column: 1, scope: !20)

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);
 
+  // Returns line source code corresponding to `LineInfo`.
+  // Returns empty string if source code cannot be found.
+  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;
+// Get the source line text for LineInfo:
+// - use LineInfo::LineSource if available;
+// - use LineCache if LineInfo::Source otherwise.
+StringRef SourcePrinter::getLine(const DILineInfo &LineInfo,
+                                 StringRef ObjectFilename) {
+  if (LineInfo.LineSource)
+    return LineInfo.LineSource.value();
 
   if (SourceCache.find(LineInfo.FileName) == SourceCache.end())
     if (!cacheSource(LineInfo))
-      return;
+      return {};
+
   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 {};
+
+        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 {};
+
+  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;
+
+  StringRef Line = getLine(LineInfo, ObjectFilename);
+  if (!Line.empty()) {
+    OS << Delimiter << Line;
     LVP.printBetweenInsts(OS, true);
   }
 }
 
 SourcePrinter::SourcePrinter(const object::ObjectFile *Obj,
                              StringRef DefaultArch)
     : Obj(Obj) {
   symbolize::LLVMSymbolizer::Options SymbolizerOpts;

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

+//===-- SourcePrinter.cpp -  source interleaving utilities ----------------===//
+//
+// 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/DebugInfo/BTF/BTFContext.h"
+#include "llvm/ObjectYAML/YAML.h"
+#include "llvm/ObjectYAML/yaml2obj.h"
+#include "llvm/Testing/Support/Error.h"
+
+using namespace llvm;
+using namespace object;
+
+#define LC(Line, Col) ((Line << 10u) | Col)
+
+const char BTFEndOfData[] =
+    "error while reading .BTF section: unexpected end of data";
+const char BTFExtEndOfData[] =
+    "error while reading .BTF.ext section: unexpected end of data";
+
+static raw_ostream &operator<<(raw_ostream &OS, const yaml::BinaryRef &Ref) {
+  Ref.writeAsHex(OS);
+  return OS;
+}
+
+template <typename T>
+static yaml::BinaryRef makeBinRef(const T *Ptr, size_t Size = sizeof(T)) {
+  return yaml::BinaryRef(ArrayRef<uint8_t>((const uint8_t *)Ptr, Size));
+}
+
+namespace {
+// This is a mockup for an ELF file containing .BTF and .BTF.ext sections.
+// Binary content of these sections corresponds to the value of
+// MockData1::BTF and MockData1::Ext fields.
+//
+// The yaml::yaml2ObjectFile() is used to generate actual ELF,
+// see MockData1::makeObj().
+//
+// The `BTF` and `Ext` fields are initialized with correct values
+// valid for a small example with a few sections, fields could be
+// modified before a call to `makeObj()` to test parser with invalid
+// input, etc.
+
+// 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
+    struct S {
+      char Foo[4] = "foo";
+      char Bar[4] = "bar";
+      char Buz[4] = "buz";
+      char Line1[11] = "first line";
+      char Line2[12] = "second line";
+      char File1[4] = "a.c";
+      char File2[4] = "b.c";
+    } Strings;
+
+    B() {
+      Header.Magic = BTF::MAGIC;
+      Header.Version = 1;
+      Header.HdrLen = sizeof(Header);
+      Header.StrOff = offsetof(B, Strings) - sizeof(Header);
+      Header.StrLen = sizeof(Strings);
+    }
+  } BTF;
+
+  struct E {
+    BTF::ExtHeader Header = {};
+    // no func info
+    struct {
+      uint32_t LineRecSize = sizeof(BTF::BPFLineInfo);
+      struct {
+        BTF::SecLineInfo Sec = {offsetof(B::S, Foo), 2};
+        BTF::BPFLineInfo Lines[2] = {
+            {16, offsetof(B::S, File1), offsetof(B::S, Line1), LC(7, 1)},
+            {32, offsetof(B::S, File1), offsetof(B::S, Line2), LC(14, 5)},
+        };
+      } Foo;
+      struct {
+        BTF::SecLineInfo Sec = {offsetof(B::S, Bar), 1};
+        BTF::BPFLineInfo Lines[1] = {
+            {0, offsetof(B::S, File2), offsetof(B::S, Line1), LC(42, 4)},
+        };
+      } Bar;
+    } Lines;
+
+    E() {
+      Header.Magic = BTF::MAGIC;
+      Header.Version = 1;
+      Header.HdrLen = sizeof(Header);
+      Header.LineInfoOff = offsetof(E, Lines) - sizeof(Header);
+      Header.LineInfoLen = sizeof(Lines);
+    }
+  } Ext;
+
+  int BTFSectionLen = sizeof(BTF);
+  int ExtSectionLen = sizeof(Ext);
+
+  SmallString<0> Storage;
+  std::unique_ptr<ObjectFile> Obj;
+
+  ObjectFile &makeObj() {
+    std::string Buffer;
+    raw_string_ostream Yaml(Buffer);
+    Yaml << R"(
+!ELF
+FileHeader:
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_BPF
+Sections:
+  - Name:     foo
+    Type:     SHT_PROGBITS
+    Size:     0x0
+  - Name:     bar
+    Type:     SHT_PROGBITS
+    Size:     0x0)";
+
+    if (BTFSectionLen >= 0)
+      Yaml << R"(
+  - Name:     .BTF
+    Type:     SHT_PROGBITS
+    Content: )"
+           << makeBinRef(&BTF, BTFSectionLen);
+
+    if (ExtSectionLen >= 0)
+      Yaml << R"(
+  - Name:     .BTF.ext
+    Type:     SHT_PROGBITS
+    Content: )"
+           << makeBinRef(&Ext, ExtSectionLen);
+
+    Obj = yaml::yaml2ObjectFile(Storage, Buffer,
+                                [](const Twine &Err) { errs() << Err; });
+    return *Obj.get();
+  }
+};
+#pragma pack(pop)
+
+TEST(BTFParserTest, simpleCorrectInput) {
+  BTFParser BTF;
+  MockData1 Mock;
+  Error Err = BTF.parse(Mock.makeObj());
+  EXPECT_FALSE(Err);
+
+  EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Foo)), "foo");
+  EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Bar)), "bar");
+  EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Line1)), "first line");
+  EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Line2)), "second line");
+  EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, File1)), "a.c");
+  EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, File2)), "b.c");
+
+  // Invalid offset
+  EXPECT_EQ(BTF.findString(sizeof(MockData1::B::S)), StringRef());
+
+  const BTF::BPFLineInfo *I1 = BTF.findLineInfo({16, 1});
+  EXPECT_TRUE(I1);
+  EXPECT_EQ(I1->getLine(), 7u);
+  EXPECT_EQ(I1->getCol(), 1u);
+  EXPECT_EQ(BTF.findString(I1->FileNameOff), "a.c");
+  EXPECT_EQ(BTF.findString(I1->LineOff), "first line");
+
+  const BTF::BPFLineInfo *I2 = BTF.findLineInfo({32, 1});
+  EXPECT_TRUE(I2);
+  EXPECT_EQ(I2->getLine(), 14u);
+  EXPECT_EQ(I2->getCol(), 5u);
+  EXPECT_EQ(BTF.findString(I2->FileNameOff), "a.c");
+  EXPECT_EQ(BTF.findString(I2->LineOff), "second line");
+
+  const BTF::BPFLineInfo *I3 = BTF.findLineInfo({0, 2});
+  EXPECT_TRUE(I3);
+  EXPECT_EQ(I3->getLine(), 42u);
+  EXPECT_EQ(I3->getCol(), 4u);
+  EXPECT_EQ(BTF.findString(I3->FileNameOff), "b.c");
+  EXPECT_EQ(BTF.findString(I3->LineOff), "first line");
+
+  // No info for insn address
+  EXPECT_FALSE(BTF.findLineInfo({24, 1}));
+  EXPECT_FALSE(BTF.findLineInfo({8, 2}));
+  // No info for section number
+  EXPECT_FALSE(BTF.findLineInfo({16, 3}));
+}
+
+TEST(BTFParserTest, badSectionNameOffset) {
+  BTFParser BTF;
+  MockData1 Mock;
+  // "foo" is section #1, corrupting it's name offset will make impossible
+  // to match section name with section index when BTF is parsed.
+  Mock.Ext.Lines.Foo.Sec.SecNameOff = 100500;
+  Error Err = BTF.parse(Mock.makeObj());
+  EXPECT_FALSE(Err);
+  // "foo" line info should be corrupted
+  EXPECT_FALSE(BTF.findLineInfo({16, 1}));
+  // "bar" line info should be ok
+  EXPECT_TRUE(BTF.findLineInfo({0, 2}));
+}
+
+// Keep this as macro to preserve line number info
+#define EXPECT_PARSE_ERROR(Mock, Message)                                      \
+  do {                                                                         \
+    BTFParser BTF;                                                             \
+    EXPECT_THAT_ERROR(BTF.parse((Mock).makeObj()),                             \
+                      FailedWithMessage(testing::HasSubstr(Message)));         \
+  } while (false)
+
+TEST(BTFParserTest, badBTFMagic) {
+  MockData1 Mock;
+  Mock.BTF.Header.Magic = 42;
+  EXPECT_PARSE_ERROR(Mock, "invalid .BTF magic: 2a");
+}
+
+TEST(BTFParserTest, badBTFVersion) {
+  MockData1 Mock;
+  Mock.BTF.Header.Version = 42;
+  EXPECT_PARSE_ERROR(Mock, "unsupported .BTF version: 42");
+}
+
+TEST(BTFParserTest, badBTFHdrLen) {
+  MockData1 Mock;
+  Mock.BTF.Header.HdrLen = 5;
+  EXPECT_PARSE_ERROR(Mock, "unexpected .BTF header length: 5");
+}
+
+TEST(BTFParserTest, badBTFSectionLen) {
+  MockData1 Mock1, Mock2;
+
+  // Cut-off string section by one byte
+  Mock1.BTFSectionLen =
+      offsetof(MockData1::B, Strings) + sizeof(MockData1::B::S) - 1;
+  EXPECT_PARSE_ERROR(Mock1, "invalid .BTF section size");
+
+  // Cut-off header
+  Mock2.BTFSectionLen = offsetof(BTF::Header, StrOff);
+  EXPECT_PARSE_ERROR(Mock2, BTFEndOfData);
+}
+
+TEST(BTFParserTest, badBTFExtMagic) {
+  MockData1 Mock;
+  Mock.Ext.Header.Magic = 42;
+  EXPECT_PARSE_ERROR(Mock, "invalid .BTF.ext magic: 2a");
+}
+
+TEST(BTFParserTest, badBTFExtVersion) {
+  MockData1 Mock;
+  Mock.Ext.Header.Version = 42;
+  EXPECT_PARSE_ERROR(Mock, "unsupported .BTF.ext version: 42");
+}
+
+TEST(BTFParserTest, badBTFExtHdrLen) {
+  MockData1 Mock1, Mock2;
+
+  Mock1.Ext.Header.HdrLen = 5;
+  EXPECT_PARSE_ERROR(Mock1, "unexpected .BTF.ext header length: 5");
+
+  Mock2.Ext.Header.HdrLen = sizeof(Mock2.Ext);
+  EXPECT_PARSE_ERROR(Mock2, BTFExtEndOfData);
+}
+
+TEST(BTFParserTest, badBTFExtSectionLen) {
+  MockData1 Mock1, Mock2, Mock3;
+
+  // Cut-off header before HdrLen
+  Mock1.ExtSectionLen = offsetof(BTF::ExtHeader, HdrLen);
+  EXPECT_PARSE_ERROR(Mock1, BTFExtEndOfData);
+
+  // Cut-off header before LineInfoLen
+  Mock2.ExtSectionLen = offsetof(BTF::ExtHeader, LineInfoLen);
+  EXPECT_PARSE_ERROR(Mock2, BTFExtEndOfData);
+
+  // Cut-off line-info section somewhere in the middle
+  Mock3.ExtSectionLen = offsetof(MockData1::E, Lines) + 4;
+  EXPECT_PARSE_ERROR(Mock3, BTFExtEndOfData);
+}
+
+TEST(BTFParserTest, badBTFExtLineInfoRecSize) {
+  MockData1 Mock1, Mock2;
+
+  Mock1.Ext.Lines.LineRecSize = 2;
+  EXPECT_PARSE_ERROR(Mock1, "unexpected .BTF.ext line info record length: 2");
+
+  Mock2.Ext.Lines.LineRecSize = sizeof(Mock2.Ext.Lines.Foo.Lines[0]) + 1;
+  EXPECT_PARSE_ERROR(Mock2, BTFExtEndOfData);
+}
+
+TEST(BTFParserTest, badBTFExtLineSectionName) {
+  MockData1 Mock1;
+
+  Mock1.Ext.Lines.Foo.Sec.SecNameOff = offsetof(MockData1::B::S, Buz);
+  EXPECT_PARSE_ERROR(
+      Mock1, "can't find section 'buz' while parsing .BTF.ext line info");
+}
+
+TEST(BTFParserTest, missingSections) {
+  MockData1 Mock1, Mock2, Mock3;
+
+  Mock1.BTFSectionLen = -1;
+  EXPECT_PARSE_ERROR(Mock1, "can't find .BTF section");
+  EXPECT_FALSE(BTFParser::hasBTFSections(Mock1.makeObj()));
+
+  Mock2.ExtSectionLen = -1;
+  EXPECT_PARSE_ERROR(Mock2, "can't find .BTF.ext section");
+  EXPECT_FALSE(BTFParser::hasBTFSections(Mock2.makeObj()));
+
+  EXPECT_TRUE(BTFParser::hasBTFSections(Mock3.makeObj()));
+}
+
+// Check that BTFParser instance is reset when BTFParser::parse() is
+// called several times.
+TEST(BTFParserTest, parserReset) {
+  BTFParser BTF;
+  MockData1 Mock1, Mock2;
+
+  EXPECT_FALSE(BTF.parse(Mock1.makeObj()));
+  EXPECT_TRUE(BTF.findLineInfo({16, 1}));
+  EXPECT_TRUE(BTF.findLineInfo({0, 2}));
+
+  // Break the reference to "bar" section name, thus making
+  // information about "bar" line numbers unavailable.
+  Mock2.Ext.Lines.Bar.Sec.SecNameOff = 100500;
+
+  EXPECT_FALSE(BTF.parse(Mock2.makeObj()));
+  EXPECT_TRUE(BTF.findLineInfo({16, 1}));
+  // Make sure that "bar" no longer available (its index is 2).
+  EXPECT_FALSE(BTF.findLineInfo({0, 2}));
+}
+
+TEST(BTFParserTest, btfContext) {
+  MockData1 Mock;
+  BTFParser BTF;
+  std::unique_ptr<BTFContext> Ctx = BTFContext::create(Mock.makeObj());
+
+  DILineInfo I1 = Ctx->getLineInfoForAddress({16, 1});
+  EXPECT_EQ(I1.Line, 7u);
+  EXPECT_EQ(I1.Column, 1u);
+  EXPECT_EQ(I1.FileName, "a.c");
+  EXPECT_EQ(I1.LineSource, "first line");
+
+  DILineInfo I2 = Ctx->getLineInfoForAddress({24, 1});
+  EXPECT_EQ(I2.Line, 0u);
+  EXPECT_EQ(I2.Column, 0u);
+  EXPECT_EQ(I2.FileName, DILineInfo::BadString);
+  EXPECT_EQ(I2.LineSource, std::nullopt);
+}
+
+} // namespace

llvm/unittests/DebugInfo/BTF/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  ${LLVM_TARGETS_TO_BUILD}
+  DebugInfoBTF
+  ObjectYAML
+  )
+
+add_llvm_unittest(DebugInfoBTFTests
+  BTFParserTest.cpp
+  )
+
+target_link_libraries(DebugInfoBTFTests PRIVATE LLVMTestingSupport)
+
+set_property(TARGET DebugInfoBTFTests PROPERTY FOLDER "Tests/UnitTests/DebugInfoTests")

llvm/unittests/DebugInfo/CMakeLists.txt

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