[BPF][DebugInfo] Show CO-RE relocations in llvm-objdump

[eddyz87]

Summary

Extend llvm-objdump to show CO-RE relocations when -r option is
passed and object file has .BTF and .BTF.ext sections.

For example, the following C program:

#define __pai __attribute__((preserve_access_index))

struct foo { int i; int j;} __pai;
struct bar { struct foo f[7]; } __pai;
extern void sink(void *);

void root(struct bar *bar) {
  sink(&bar[2].f[3].j);
}

Should lead to the following objdump output:

$ clang --target=bpf -O2 -g t.c -c -o - | \
    llvm-objdump  --no-addresses --no-show-raw-insn -dr -

...
        r2 = 0x94
                CO-RE <byte_off> [2] struct bar::[2].f[3].j (2:0:3:1)
        r1 += r2
        call -0x1
                R_BPF_64_32     sink
        exit
...

More examples could be found in unit tests, see BTFParserTest.cpp.

To achieve this:

• Move CO-RE relocation kinds definitions from BPFCORE.h to BTF.h.
• Extend BTF.h with types derived from BTF::CommonType, e.g. BTF::IntType and BTF::StrutType, to allow dyn_cast() and access to type additional data.
• Extend BTFParser to load BTF type and relocation data.
• Modify llvm-objdump.cpp to create instance of BTFParser when disassembly of object file with BTF sections is processed and -r flag is supplied.

Additional information about CO-RE is available at [1].

[1] https://docs.kernel.org/bpf/llvm_reloc.html

Depends on D149058

[anakryiko]

Do you think it would be possible to keep output format close to libbpf's one? Here are few different CO-RE relocations as logged by libbpf, to give you an idea:

<byte_off> [6] struct task_struct.comm (0:115 @ offset 1944)
<field_exists> [586] struct bpf_testmod_test_read_ctx.buf (0:1 @ offset 8)
<enumval_value> [7] enum named_enum::NAMED_ENUM_VAL2 = 2
<enumval_value> [5] typedef anon_enum::ANON_ENUM_VAL1 = 16
<byte_off> [5] struct core_reloc_arrays.a[2] (0:0:2 @ offset 8)
<byte_off> [5] struct core_reloc_arrays.b[1][2][3] (0:1:1:2:3 @ offset 43)
<byte_off> [5] struct core_reloc_ptr_as_arr[2].a (2:0 @ offset 8)
<byte_off> [5] struct core_reloc_nesting.a.a.a (0:0:0:0 @ offset 0)
<byte_off> [5] struct core_reloc_nesting.b.b.b (0:1:0:0 @ offset 4)

Note how libbpf outputs almost C-like access syntax, and skips unnecessary [0] for initial array reference.

[eddyz87]

Rebase, update in line with fixes suggeested for D149058.

[eddyz87]

• styling fixes
• test case to check formatting
• adjust-vma option support

[eddyz87]

Hi @MaskRay, @yonghong-song,

Could you please take a look at this revision?
It adds support for CO-RE relocations printing in llvm-objdump.
While current implementation works, there are two aspects that might be sub-optimal:

• ELF relocations are not unified with BTF relocations and thus there are two functions: llvm-objdump.cpp:printRelocation(), llvm-objdump.cpp:printBTFRelocation();
• The BTFParser instance is not shared between LLVMSymbolizer (used for source line printing) and llvm-objdump.cpp:disassembleObject() (used for relocations printing).

Fixing both items might require some interface level changes that I opted not to do at the moment. Please let me know what you think.

[eddyz87]

Hi @MaskRay,

if you have a minute, could you please take a look?
I used this locally and it proved to be convenient for debugging (e.g. here).

[MaskRay]

In D150079#4538457, @eddyz87 wrote:

Hi @MaskRay,

if you have a minute, could you please take a look?
I used this locally and it proved to be convenient for debugging (e.g. here).

Sorry, I am on a trip and will be slow to respond.

[eddyz87]

Hi @MaskRay ,

If you have some time, could you please take a look?

[anakryiko]

FWIW, output format looks great, thanks!

[MaskRay]

In D150079#4604044, @eddyz87 wrote:

Hi @MaskRay ,

If you have some time, could you please take a look?

Sorry, was pretty busy handling a backlog of reviews and day work... Feel free to ping after a week https://llvm.org/docs/CodeReview.html#lgtm-how-a-patch-is-accepted

In a -DBUILD_SHARED_LIBS=on build, I get ld.lld: error: undefined symbol: llvm::BTFParser::parse(llvm::object::ObjectFile const&, llvm::BTFParser::ParseOptions const&). We need

--- i/llvm/tools/llvm-objdump/CMakeLists.txt
+++ w/llvm/tools/llvm-objdump/CMakeLists.txt
@@ -5,2 +5,3 @@ set(LLVM_LINK_COMPONENTS
   BinaryFormat
+  DebugInfoBTF
   DebugInfoDWARF

https://github.com/MaskRay/Config/wiki/LLVM#build-modes Personally, when I make CMake changes, I'll check both the default config and -DBUILD_SHARED_LIBS=on

[MaskRay]

llvm/test/tools/llvm-objdump/BPF/core-relo-formatting.s

1 ↗

(On Diff #540808)

We probably should change one of the files to test both -d and -dr, so that the effect of -r is clearer.

53 ↗

(On Diff #540808)

Use -NEXT: whenever applicable https://llvm.org/docs/CommandGuide/FileCheck.html#the-check-next-directive https://maskray.me/blog/2021-08-08-toolchain-testing#use-the-check-next-directive (I decided to add a section to this article so that I don't need to repeat the argument for future reviews:)

ditto throughout

llvm/tools/llvm-objdump/llvm-objdump.cpp

1471

BTF = std::make_unique<BTFParser>();

However, std::optional<BTFParser> BTF and BTF.emplace() is better as we avoid an unneeded dynamic allocation.

[MaskRay]

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

280

Macros in public headers should be used with caution as they may collide with downstream users.

308

These derived classes are only referenced in byteSize. This doesn't justify creating so many derived classes.

See that printMod you only use the kind value, not the derived classes.

385

Unneeded if we don't define these classes.

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

109

use member initializers, otherwise it's error-prone (without {} or = {}, we get uninitialized values).

123

avoid default argument. this doesn't

llvm/lib/DebugInfo/BTF/BTFParser.cpp

213

Use the OwningArrayRef(ArrayRef<T> Data) constructor to avoid a separate memcpy

221

[MaskRay]

llvm/lib/DebugInfo/BTF/BTFParser.cpp

352–400

@ast @yonghong-song BTF relocations seem undocumented on https://www.kernel.org/doc/html/latest/bpf/btf.html#btf-ext-section ?

689

typo: Splis

splits SpecStr by ':', parses numbers, and pushes them to RawSpec.

699

What if SpecStr is empty?

https://en.cppreference.com/w/cpp/string/basic_string_view/substr I think we may harden StringRef::substr to abort when pos > size in the future.

705

725

This is untested

728

761

Unlike Linux kernel, we don't keep a blank line after a variable declaration.
Group is immediately used so not having a blank line is arguably more readable.

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

349

This macro may collide with others (e.g. llvm/include/llvm/DebugInfo/LogicalView/Core/LVSupport.h). Use a static function

393

clear is more idiomatic

521

If we are unsure whether this works on a big-endian machine, we can ask someone to verify when this patch is about to land...

613

C++ prefers using

[MaskRay]

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

340

This and Enum*Type are used in BTFParser::symbolize. Keeping just these classes is fine but other classes are not needed.

Note: we can also utilize llvm/include/llvm/Support/TrailingObjects.h to access the trailing object, instead of DEFINE_TAIL_ARR

[eddyz87]

Fixes basing on feedback from @MaskRay.
Fix for incorrect BTF::CommonType::getVlen() mask.

[eddyz87]

In D150079#4608909, @MaskRay wrote:

Sorry, was pretty busy handling a backlog of reviews and day work... Feel free to ping after a week https://llvm.org/docs/CodeReview.html#lgtm-how-a-patch-is-accepted

Thanks a lot for taking a look.

In a -DBUILD_SHARED_LIBS=on build, I get ld.lld: error: undefined symbol: llvm::BTFParser::parse(llvm::object::ObjectFile const&, llvm::BTFParser::ParseOptions const&). We need

--- i/llvm/tools/llvm-objdump/CMakeLists.txt
+++ w/llvm/tools/llvm-objdump/CMakeLists.txt
@@ -5,2 +5,3 @@ set(LLVM_LINK_COMPONENTS
   BinaryFormat
+  DebugInfoBTF
   DebugInfoDWARF

Done

https://github.com/MaskRay/Config/wiki/LLVM#build-modes Personally, when I make CMake changes, I'll check both the default config and -DBUILD_SHARED_LIBS=on

Noted, thank you.

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

280

Removed CoreRelo.def, I reused it for printable names in the original revision but it is changed since then, so there is no need in this file.

308

Those are all types that have trailing items. I removed the types not used outside of byteSize and switched byteSize to use switch over kind (which is a bit less safe, imo).

As a final step for BTF support in objdump Yonghong wanted me to add support for printing BTF definitions like bpftool btf dump file does. The definitions in question would have been useful in that case. But I can add them back when necessary.

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

123

Replaced with overload.

llvm/lib/DebugInfo/BTF/BTFParser.cpp

213

Done, but it is kind-off ugly because StringRef encapsulates char and I use uint8_t for TypesBuffer:

TypesBuffer = OwningArrayRef<uint8_t>(
  ArrayRef<uint8_t>((const uint8_t *)RawData.data(), RawData.size()));

352–400

I will add necessary documentation.

699

Changed to exit loop if SpecStr is empty after consumeUnsignedInteger, added missing check that type relocation spec should be '0'.

725

Missed this one :-/

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

521

I'll try to check in the VM.

[yonghong-song]

llvm/lib/DebugInfo/BTF/BTFParser.cpp

352–400

@eddyz87 Let us add relocation documentation in https://github.com/torvalds/linux/blob/master/Documentation/bpf/llvm_reloc.rst
and add a reference in https://www.kernel.org/doc/html/latest/bpf/btf.html#btf-ext-section inst
Thanks!

[eddyz87]

llvm/lib/DebugInfo/BTF/BTFParser.cpp

352–400

Working on it, submitted patch here.

[MaskRay]

Seems good in shape! Wonder whether @jhenderson has some comments.

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

102

prefer constexpr uint32_t to enum, especially that these are bit masks.

llvm/lib/DebugInfo/BTF/BTFParser.cpp

215

Some using declarations such as big,little, seem unnecessary?

222

arrayRefFromStringRef

llvm/test/tools/llvm-objdump/BPF/core-relo-byte-offset.ll

7

For continuation lines we indent by 2.

[jhenderson]

I did a quick skim of comments and the like, but I don't really have the time to read up on BTF, so can't contirbute anything more meaningful really, sorry.

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

101

Nit.

279

Nit.

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

46–47

The "Mb" suffix is ambiguous/potentially incorrect. Is it meant to be megabits (I doubt it)?

Assuming it is intended to be binary megabytes (i.e. 1024*1024 bytes), consider using "MiB" (mebibytes).

107

Nit.

llvm/lib/DebugInfo/BTF/BTFParser.cpp

223

570

reclocKindName maybe? ("reloc" is a more common abbreviation for "relocation").

Same goes below at line 559 ("relo kind #") and at various other places (e.g. ReloKindGroup).

Neither of these apply if "relo" is an abbreviation used in the BTF spec or similar.

622–623

I'm a little nervous about referencing file paths in comments - I would expect them to fairly easily rot. Do you actually need to do that?

689

"splits" is duplicated.

704

llvm/test/tools/llvm-objdump/BPF/core-relo-byte-offset.ll

6–8

I have a personal preference to put the | at the end of the previous line. My reasoning is that by looking at any given line, you can tell if the command itself is continued (it ends with | \ or simply \), without needing to look at the next line, whilst the continuation lines are clearly continuations (due to being indented), and will either start with an executable name (indicating they are the start of a new command) or otherwise (indicating that they aren't).

Inline edit is to demonstrate - not a requirement if you object to the proposal.

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

556

std::numeric_limits::max<uint32_t>() might be clearer?

587–588

Similar can be done in various other places. There's also EXPECT variations and an ASSERT_THAT_EXPECTED for Expected types, and you can use FailedWithMessage() to check that the error failed with a specific error message too.

655

Nit (also below for other comments).

[eddyz87]

Stylistic changes according to feedback from @MaskRay and @jhenderson.

[eddyz87]

Hi @MaskRay, @jhenderson,

Thank you for the feedback, I think I covered all but one items.
The last remaining item is to verify that unit test is working on the bigendian system.
I'll update the revision once I check that.

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

46–47

Changed to MiB.

llvm/lib/DebugInfo/BTF/BTFParser.cpp

215

support::endian::system_endianness was unused, indeed. The big and little are used in the following declaration:

endianness Endianness = Ctx.Obj.isLittleEndian() ? little : big;

352–400

Documentation was merged to bpf tree: here and here.

570

Changed to reloc in identifiers and "relocation" in strings.

622–623

Removed.

689

Right, sorry about that.

llvm/test/tools/llvm-objdump/BPF/core-relo-byte-offset.ll

6–8

Updated to | \. I find the version with | at the new line a bit more aesthetically pleasing, but oh-well.

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

556

Documentation refers to value -1 (for unsigned field :) ), so I think it's better to keep -1 here to avoid confusion.

587–588

Thanks, replaced with local macro:

#define ASSERT_SUCCEEDED(E) ASSERT_THAT_ERROR((E), Succeeded())

I do use FailedWithMessage in macro EXPECT_PARSE_ERROR.

655

Added dots for comments that look like English sentences, did not add dots for comments that refer to type definitions.

[eddyz87]

Unit tests are passing on S390 under emulation w/o issues.

[jhenderson]

Only a couple of nits remaining from me.

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

56

Now I'm being really nit-picky - here and in the E struct below it should be capitalized "No" not "no".

556

Fair enough.

[eddyz87]

Missing dot at the end of the comment.

[eddyz87]

Hi @MaskRay,

Could you please take a look at this revision?
I think I addressed all feedback.

[MaskRay]

Sorry for the delay. LG!

Additional information about CO-RE is available at [1].
[1] https://nakryiko.com/posts/bpf-core-reference-guide/

Link to https://docs.kernel.org/bpf/llvm_reloc.html ? Thank you for https://git.kernel.org/linus/be4033d36070e44fba766a21ef2d0c24fa04c377 :)

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

101

nit: in this case we don't add parens

llvm/lib/DebugInfo/BTF/BTFContext.cpp

66–68

llvm/lib/DebugInfo/BTF/BTFParser.cpp

555

namespace { ... } per https://llvm.org/docs/CodingStandards.html#anonymous-namespaces

llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp

371

996

EXPECT_EQ as findString is non-fatail if failed

http://google.github.io/googletest/reference/assertions.html

1064

These find* calls can use EXPECT (nonfatal if failed)

[eddyz87]

Changes in accordance with @MaskRay feedback.

[eddyz87]

Hi @MaskRay, @jhenderson,

Thank you for all the feedback!
I've applied the latest suggestions and going to merge this revision once CI is done.

Link to https://docs.kernel.org/bpf/llvm_reloc.html ?

Commit message updated, thank you for the --verbatim tip.

llvm/lib/DebugInfo/BTF/BTFParser.cpp

555

Forgot about namespaces here, sorry. Surprisingly, to avoid compilation errors operator<< had to be moved inside the namespace as well.

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

 //===-- BTF.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
 //
 //===----------------------------------------------------------------------===//
 ///

 /// The section formats are also defined at
 ///    https://github.com/torvalds/linux/blob/master/include/uapi/linux/btf.h
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_BPF_BTF_H
 #define LLVM_LIB_TARGET_BPF_BTF_H
 
+#include "llvm/ADT/ArrayRef.h"
 #include <cstdint>
 
 namespace llvm {
 namespace BTF {
 
 enum : uint32_t { MAGIC = 0xeB9F, VERSION = 1 };
 
 /// Sizes in bytes of various things in the BTF format.
enum : uint32_t {
   MAX_VLEN = 0xffff ///< Max # of struct/union/enum members or func args
 };
 
 enum TypeKinds : uint8_t {
 #define HANDLE_BTF_KIND(ID, NAME) BTF_KIND_##NAME = ID,
 #include "BTF.def"
 };
 
+// Constants for CommonType::Info field
+enum : uint32_t { FWD_UNION_FLAG = (1u << 31), ENUM_SIGNED_FLAG = (1u << 31) };
+
 /// The BTF common type definition. Different kinds may have
 /// additional information after this structure data.
 struct CommonType {
   /// Type name offset in the string table.
   uint32_t NameOff;
 
   /// "Info" bits arrangement:
   /// Bits  0-15: vlen (e.g. # of struct's members)
   /// Bits 16-23: unused
-  /// Bits 24-27: kind (e.g. int, ptr, array...etc)
-  /// Bits 28-30: unused
+  /// Bits 24-28: kind (e.g. int, ptr, array...etc)
+  /// Bits 29-30: unused
   /// Bit     31: kind_flag, currently used by
   ///             struct, union and fwd
   uint32_t Info;
 
   /// "Size" is used by INT, ENUM, STRUCT and UNION.
   /// "Size" tells the size of the type it is describing.
   ///
   /// "Type" is used by PTR, TYPEDEF, VOLATILE, CONST, RESTRICT,
   /// FUNC, FUNC_PROTO, VAR, DECL_TAG and TYPE_TAG.
   /// "Type" is a type_id referring to another type.
   union {
     uint32_t Size;
     uint32_t Type;
   };
+
+  uint32_t getKind() const { return Info >> 24 & 0x1f; }
+  uint32_t getVlen() const { return Info & 0xff; }
 };
 
 // For some specific BTF_KIND, "struct CommonType" is immediately
 // followed by extra data.
 
 // BTF_KIND_INT is followed by a u32 and the following
 // is the 32 bits arrangement:
 // BTF_INT_ENCODING(VAL) : (((VAL) & 0x0f000000) >> 24)

 };
 
 /// Specifying offset relocation's in one section.
 struct SecFieldReloc {
   uint32_t SecNameOff;    ///< Section name index in the .BTF string table
   uint32_t NumFieldReloc; ///< Number of offset reloc's in this section
 };
 
+enum PatchableRelocKind : uint32_t {
+#define HANDLE_RELO_KIND(Val, Name) Name = Val,
+#include "CoreRelo.def"
+#undef HANDLE_RELO_KIND
+  MAX_FIELD_RELOC_KIND,
+};
+
+// Define a number of sub-types for CommonType, each with:
+// - An accessor for a relevant "tail" information (data fields that
+//   follow the CommonType record in binary format).
+// - A classof() definition based on CommonType::getKind() value to
+//   allow use with dyn_cast<>() function.
+
+// For CommonType sub-types that are followed by a single entry of
+// some type in the binary format.
+#define DEFINE_TAIL(Type, Accessor)                                            \
+  const Type &Accessor() const {                                               \
+    return *((const Type *)((const uint8_t *)this + sizeof(*this)));           \
+  }
+
+// For CommonType sub-types that are followed by CommonType::getVlen()
+// number of entries of some type in the binary format.
+#define DEFINE_TAIL_ARR(Type, Accessor)                                        \
+  ArrayRef<Type> Accessor() const {                                            \
+    return ArrayRef<Type>(                                                     \
+        (const Type *)((const uint8_t *)this + sizeof(*this)),                 \
+        this->getVlen());                                                      \
+  }
+
+struct IntType : CommonType {
+  DEFINE_TAIL(uint32_t, getBitsInfo)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_INT;
+  }
+};
+
+struct VarType : CommonType {
+  DEFINE_TAIL(uint32_t, getLinkage)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_VAR;
+  }
+};
+
+struct DeclTagType : CommonType {
+  DEFINE_TAIL(uint32_t, getComponentIdx)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_DECL_TAG;
+  }
+};
+
+struct ArrayType : CommonType {
+  DEFINE_TAIL(BTFArray, getArray)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_ARRAY;
+  }
+};
+
+struct StructType : CommonType {
+  DEFINE_TAIL_ARR(BTFMember, members)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_STRUCT || V->getKind() == BTF_KIND_UNION;
+  }
+};
+
+struct EnumType : CommonType {
+  DEFINE_TAIL_ARR(BTFEnum, values)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_ENUM;
+  }
+};
+
+struct Enum64Type : CommonType {
+  DEFINE_TAIL_ARR(BTFEnum64, values)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_ENUM64;
+  }
+};
+
+struct FuncProtoType : CommonType {
+  DEFINE_TAIL_ARR(BTFParam, params)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_FUNC_PROTO;
+  }
+};
+
+struct DataSecType : CommonType {
+  DEFINE_TAIL_ARR(BTFDataSec, vars)
+
+  static bool classof(const CommonType *V) {
+    return V->getKind() == BTF_KIND_DATASEC;
+  }
+};
+
+#undef DEFINE_TAIL
+#undef DEFINE_TAIL_ARR
+
 } // End namespace BTF.
 } // End namespace llvm.
 
 #endif

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

 //===- BTFParser.h --------------------------------------------------------===//
 //
 // 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.
+// - instruction offset to line information mapping;
+// - types table;
+// - CO-RE relocations table.
 //
 // 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 = std::vector<BTF::BPFLineInfo>;
+  using BTFRelocVector = std::vector<BTF::BPFFieldReloc>;
 
   // 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;
 
+  // A copy of types table from the object file but using native byte
+  // order. Should not be too big in practice, e.g. for ~250Mb vmlinux
+  // image it is ~4Mb.
+  OwningArrayRef<uint8_t> TypesBuffer;
+
   // Maps ELF section number to instruction line number information.
   // Each BTFLinesVector is sorted by `InsnOffset` to allow fast lookups.
   DenseMap<uint64_t, std::unique_ptr<BTFLinesVector>> SectionLines;
 
+  // Maps ELF section number to CO-RE relocation information.
+  // Each BTFRelocVector is sorted by `InsnOffset` to allow fast lookups.
+  DenseMap<uint64_t, std::unique_ptr<BTFRelocVector>> SectionRelocs;
+
+  // Vector of pointers to all known types, index in this vector
+  // equals to logical type BTF id.
+  // Pointers point to memory owned by `TypesBuffer`
+  // (except pointer at index 0, which is statically allocated).
+  std::vector<const BTF::CommonType *> Types;
+
   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);
+  Error parseRelocInfo(ParseContext &Ctx, DataExtractor &Extractor,
+                       uint64_t RelocInfoStart, uint64_t RelocInfoEnd);
+  Error parseTypesInfo(ParseContext &Ctx, uint64_t TypesInfoStart,
+                       StringRef RawData);
 
 public:
   // Looks-up a string in the .BTF section's string table.
   // Offset is relative to string table start.
   StringRef findString(uint32_t Offset);
 
   // 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.
   BTF::BPFLineInfo *findLineInfo(SectionedAddress Address);
 
+  // Search for CO-RE relocation information for a specific address.
+  // Return nullptr if no information found.
+  // If information is present, return a pointer to object
+  // owned by this class.
+  BTF::BPFFieldReloc *findFieldReloc(SectionedAddress Address);
+
+  // Return a human readable representation of the CO-RE relocation
+  // record, this is for display purpose only.
+  // See implementation for details.
+  std::string symbolize(BTF::BPFFieldReloc *Reloc);
+
+  // Lookup BTF type definition with a specific index.
+  // Return nullptr if no information found.
+  // If information is present, return a pointer to object
+  // owned by this class.
+  const BTF::CommonType *findType(uint32_t Id);
+
+  // Return total number of known BTF types.
+  size_t typesCount() { return Types.size(); }
+
+  // Allow to selectively load BTF information
+  struct ParseOptions {
+    bool LoadLines;
+    bool LoadTypes;
+    bool LoadRelocs;
+  };
+
   // 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);
+  Error parse(const ObjectFile &Obj,
+              const ParseOptions &Opts = {true, true, true});
 
   // Returns 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/BTF/CoreRelo.def

+HANDLE_RELO_KIND(0, FIELD_BYTE_OFFSET)
+HANDLE_RELO_KIND(1, FIELD_BYTE_SIZE)
+HANDLE_RELO_KIND(2, FIELD_EXISTENCE)
+HANDLE_RELO_KIND(3, FIELD_SIGNEDNESS)
+HANDLE_RELO_KIND(4, FIELD_LSHIFT_U64)
+HANDLE_RELO_KIND(5, FIELD_RSHIFT_U64)
+HANDLE_RELO_KIND(6, BTF_TYPE_ID_LOCAL)
+HANDLE_RELO_KIND(7, BTF_TYPE_ID_REMOTE)
+HANDLE_RELO_KIND(8, TYPE_EXISTENCE)
+HANDLE_RELO_KIND(9, TYPE_SIZE)
+HANDLE_RELO_KIND(10, ENUM_VALUE_EXISTENCE)
+HANDLE_RELO_KIND(11, ENUM_VALUE)
+HANDLE_RELO_KIND(12, TYPE_MATCH)

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
 //
 //===----------------------------------------------------------------------===//
 //
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::unique_ptr<BTFContext>(new BTFContext());
-  if (Error E = Ctx->BTF.parse(Obj))
+  BTFParser::ParseOptions Opts = {};
+  Opts.LoadLines = true;
+  if (Error E = Ctx->BTF.parse(Obj, Opts))
     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
 //
 //===----------------------------------------------------------------------===//
 //

 };
 } // 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;
+  const ParseOptions &Opts;
   // Map from ELF section name to SectionRef
   DenseMap<StringRef, SectionRef> Sections;
 
 public:
-  ParseContext(const ObjectFile &Obj) : Obj(Obj) {}
+  ParseContext(const ObjectFile &Obj, const ParseOptions &Opts)
+      : Obj(Obj), Opts(Opts) {}
 
   Error init() {
     for (SectionRef Sec : Obj.sections()) {
       Expected<StringRef> MaybeName = Sec.getName();
       if (!MaybeName)
         return MaybeName.takeError();
       Sections[*MaybeName] = Sec;
     }
Error BTFParser::parseBTF(ParseContext &Ctx, SectionRef BTF) {
   if (Version != 1)
     return Err("unsupported .BTF version: ") << (unsigned)Version;
   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;
-  Extractor.getU32(C); // type_off
-  Extractor.getU32(C); // type_len
+  uint32_t TypeOff = Extractor.getU32(C);
+  uint32_t TypeLen = Extractor.getU32(C);
   uint32_t StrOff = Extractor.getU32(C);
   uint32_t StrLen = Extractor.getU32(C);
   uint32_t StrStart = HdrLen + StrOff;
   uint32_t StrEnd = StrStart + StrLen;
+  uint32_t TypesInfoStart = HdrLen + TypeOff;
+  uint32_t TypesInfoEnd = TypesInfoStart + TypeLen;
+  uint32_t BytesExpected = std::max(StrEnd, TypesInfoEnd);
   if (!C)
     return Err(".BTF", C);
-  if (Extractor.getData().size() < StrEnd)
+  if (Extractor.getData().size() < BytesExpected)
     return Err("invalid .BTF section size, expecting at-least ")
-           << StrEnd << " bytes";
+           << BytesExpected << " bytes";
+
+  StringsTable = Extractor.getData().slice(StrStart, StrEnd);
+
+  if (TypeLen > 0 && Ctx.Opts.LoadTypes) {
+    StringRef RawData = Extractor.getData().slice(TypesInfoStart, TypesInfoEnd);
+    if (Error E = parseTypesInfo(Ctx, TypesInfoStart, RawData))
+      return E;
+  }
+
+  return Error::success();
+}
+
+// These classes can be used for direct memory mappings,
+// add standard layout assertions just in case.
+static_assert(std::is_standard_layout<BTF::CommonType>());
+static_assert(std::is_standard_layout<BTF::IntType>());
+static_assert(std::is_standard_layout<BTF::VarType>());
+static_assert(std::is_standard_layout<BTF::DeclTagType>());
+static_assert(std::is_standard_layout<BTF::ArrayType>());
+static_assert(std::is_standard_layout<BTF::StructType>());
+static_assert(std::is_standard_layout<BTF::EnumType>());
+static_assert(std::is_standard_layout<BTF::Enum64Type>());
+static_assert(std::is_standard_layout<BTF::FuncProtoType>());
+static_assert(std::is_standard_layout<BTF::DataSecType>());
+
+template <typename T> static size_t byteSize(ArrayRef<T> A) {
+  return A.size() * sizeof(T);
+}
+
+// Compute record size for each BTF::CommonType sub-type
+// (including entries in the tail position).
+static size_t byteSize(BTF::CommonType *Type) {
+  size_t Size = sizeof(BTF::CommonType);
+
+  if (auto *T = dyn_cast<BTF::IntType>(Type))
+    Size += sizeof(T->getBitsInfo());
+  else if (auto *T = dyn_cast<BTF::ArrayType>(Type))
+    Size += sizeof(T->getArray());
+  else if (auto *T = dyn_cast<BTF::VarType>(Type))
+    Size += sizeof(T->getLinkage());
+  else if (auto *T = dyn_cast<BTF::DeclTagType>(Type))
+    Size += sizeof(T->getComponentIdx());
+  else if (auto *T = dyn_cast<BTF::StructType>(Type))
+    Size += byteSize(T->members());
+  else if (auto *T = dyn_cast<BTF::EnumType>(Type))
+    Size += byteSize(T->values());
+  else if (auto *T = dyn_cast<BTF::Enum64Type>(Type))
+    Size += byteSize(T->values());
+  else if (auto *T = dyn_cast<BTF::FuncProtoType>(Type))
+    Size += byteSize(T->params());
+  else if (auto *T = dyn_cast<BTF::DataSecType>(Type))
+    Size += byteSize(T->vars());
+
+  return Size;
+}
+
+// Guard value for voids, simplifies code a bit, but NameOff is not
+// actually valid.
+const static BTF::CommonType VoidTypeInst = {0, BTF::BTF_KIND_UNKN << 24, {0}};
+
+// Type information "parsing" is very primitive:
+// - The `RawData` is copied to a buffer owned by `BTFParser` instance.
+// - The buffer is treated as an array of `uint32_t` values, each value
+//   is swapped to use native endianness. This is possible, because
+//   according to BTF spec all buffer elements are structures comprised
+//   of `uint32_t` fields.
+// - `BTFParser::Types` vector is filled with pointers to buffer
+//   elements, using `byteSize()` function to slice the buffer at type
+//   record boundaries.
+// - If at some point a type definition with incorrect size (logical size
+//   exceeding buffer boundaries) is reached it is not added to the
+//   `BTFParser::Types` vector and the process stops.
+Error BTFParser::parseTypesInfo(ParseContext &Ctx, uint64_t TypesInfoStart,
+                                StringRef RawData) {
+  using support::big;
+  using support::endianness;
+  using support::little;
+  using support::endian::byte_swap;
+  using support::endian::system_endianness;
+
+  TypesBuffer = OwningArrayRef<uint8_t>(RawData.size());
+  std::memcpy(TypesBuffer.data(), RawData.data(), RawData.size());
+
+  endianness Endianness = Ctx.Obj.isLittleEndian() ? little : big;
+  uint32_t *TypesBuffer32 = (uint32_t *)TypesBuffer.data();
+  for (uint64_t I = 0; I < TypesBuffer.size() / 4; ++I)
+    TypesBuffer32[I] = byte_swap(TypesBuffer32[I], Endianness);
+
+  // void
+  Types.push_back(&VoidTypeInst);
+
+  uint64_t Pos = 0;
+  while (Pos < RawData.size()) {
+    uint64_t BytesLeft = RawData.size() - Pos;
+    uint64_t Offset = TypesInfoStart + Pos;
+    BTF::CommonType *Type = (BTF::CommonType *)&TypesBuffer[Pos];
+    if (BytesLeft < sizeof(*Type))
+      return Err("incomplete type definition in .BTF section:")
+             << " offset " << Offset << ", index " << Types.size();
+
+    uint64_t Size = byteSize(Type);
+    if (BytesLeft < Size)
+      return Err("incomplete type definition in .BTF section:")
+             << " offset=" << Offset << ", index=" << Types.size()
+             << ", vlen=" << Type->getVlen();
+
+    LLVM_DEBUG({
+      llvm::dbgs() << "Adding type " << Types.size() << " "
+                   << findString(Type->NameOff) << ", record size " << Size
+                   << "\n";
+    });
+    Types.push_back(Type);
+    Pos += Size;
+  }
 
-  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();
 
Error BTFParser::parseBTFExt(ParseContext &Ctx, SectionRef BTFExt) {
   if (!C)
     return Err(".BTF.ext", C);
   if (HdrLen < 8)
     return Err("unexpected .BTF.ext header length: ") << HdrLen;
   Extractor.getU32(C); // func_info_off
   Extractor.getU32(C); // func_info_len
   uint32_t LineInfoOff = Extractor.getU32(C);
   uint32_t LineInfoLen = Extractor.getU32(C);
+  uint32_t RelocInfoOff = Extractor.getU32(C);
+  uint32_t RelocInfoLen = Extractor.getU32(C);
   if (!C)
     return Err(".BTF.ext", C);
+
+  if (LineInfoLen > 0 && Ctx.Opts.LoadLines) {
     uint32_t LineInfoStart = HdrLen + LineInfoOff;
     uint32_t LineInfoEnd = LineInfoStart + LineInfoLen;
     if (Error E = parseLineInfo(Ctx, Extractor, LineInfoStart, LineInfoEnd))
       return E;
+  }
+
+  if (RelocInfoLen > 0 && Ctx.Opts.LoadRelocs) {
+    uint32_t RelocInfoStart = HdrLen + RelocInfoOff;
+    uint32_t RelocInfoEnd = RelocInfoStart + RelocInfoLen;
+    if (Error E = parseRelocInfo(Ctx, Extractor, RelocInfoStart, RelocInfoEnd))
+      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 (Sec)
       SectionLines[Sec->getIndex()] = std::move(Lines);
   }
   if (!C)
     return Err(".BTF.ext", C);
 
   return Error::success();
 }
 
-Error BTFParser::parse(const ObjectFile &Obj) {
+Error BTFParser::parseRelocInfo(ParseContext &Ctx, DataExtractor &Extractor,
+                                uint64_t RelocInfoStart,
+                                uint64_t RelocInfoEnd) {
+  DataExtractor::Cursor C = DataExtractor::Cursor(RelocInfoStart);
+  uint32_t RecSize = Extractor.getU32(C);
+  if (!C)
+    return Err(".BTF.ext", C);
+  if (RecSize < 16)
+    return Err("unexpected .BTF.ext field reloc info record length: ")
+           << RecSize;
+
+  while (C && C.tell() < RelocInfoEnd) {
+    std::unique_ptr<BTFRelocVector> Relocs(new BTFRelocVector());
+
+    uint32_t SecNameOff = Extractor.getU32(C);
+    uint32_t NumInfo = Extractor.getU32(C);
+
+    StringRef SecName = findString(SecNameOff);
+    std::optional<SectionRef> Sec = Ctx.findSection(SecName);
+
+    for (uint32_t I = 0; C && I < NumInfo; ++I) {
+      uint64_t RecStart = C.tell();
+
+      uint32_t InsnOff = Extractor.getU32(C);
+      uint32_t TypeID = Extractor.getU32(C);
+      uint32_t OffsetNameOff = Extractor.getU32(C);
+      uint32_t RelocKind = Extractor.getU32(C);
+
+      Relocs->push_back({InsnOff, TypeID, OffsetNameOff, RelocKind});
+
+      C.seek(RecStart + RecSize);
+    }
+
+    std::sort(Relocs->begin(), Relocs->end(),
+              [](const BTF::BPFFieldReloc &L, const BTF::BPFFieldReloc &R) {
+                return L.InsnOffset < R.InsnOffset;
+              });
+
+    if (Sec)
+      SectionRelocs[Sec->getIndex()] = std::move(Relocs);
+  }
+
+  if (!C)
+    return Err(".BTF.ext", C);
+
+  return Error::success();
+}
+
+Error BTFParser::parse(const ObjectFile &Obj, const ParseOptions &Opts) {
   StringsTable = StringRef();
   SectionLines.clear();
-  ParseContext Ctx(Obj);
+  SectionRelocs.clear();
+  Types.clear();
+  TypesBuffer = OwningArrayRef<uint8_t>();
+
+  ParseContext Ctx(Obj, Opts);
   if (Error E = Ctx.init())
     return E;
 
   std::optional<SectionRef> BTF = Ctx.findSection(BTFSectionName);
   std::optional<SectionRef> BTFExt = Ctx.findSection(BTFExtSectionName);
   if (!BTF)
     return Err("can't find .BTF section");
   if (!BTFExt)
bool BTFParser::hasBTFSections(const ObjectFile &Obj) {
   }
   return false;
 }
 
 StringRef BTFParser::findString(uint32_t Offset) {
   return StringsTable.slice(Offset, StringsTable.find(0, Offset));
 }
 
-BTF::BPFLineInfo *BTFParser::findLineInfo(SectionedAddress Address) {
-  auto MaybeSecInfo = SectionLines.find(Address.SectionIndex);
-  if (MaybeSecInfo == SectionLines.end())
+template <typename T>
+static T *findInfo(DenseMap<uint64_t, std::unique_ptr<std::vector<T>>> &SecMap,
+                   SectionedAddress Address) {
+  auto MaybeSecInfo = SecMap.find(Address.SectionIndex);
+  if (MaybeSecInfo == SecMap.end())
     return nullptr;
 
-  std::unique_ptr<BTFLinesVector> &SecInfo = MaybeSecInfo->second;
-  auto LineInfo =
+  std::unique_ptr<std::vector<T>> &SecInfo = MaybeSecInfo->second;
+  auto MaybeInfo =
       std::lower_bound(SecInfo->begin(), SecInfo->end(), Address.Address,
-                       [](const BTF::BPFLineInfo &Line, uint64_t Addr) {
-                         return Line.InsnOffset < Addr;
+                       [](const T &Info, uint64_t Addr) {
+                         return Info.InsnOffset < Addr;
                        });
-  if (LineInfo == SecInfo->end() || LineInfo->InsnOffset != Address.Address)
-    return nullptr;
+  if (MaybeInfo == SecInfo->end() || MaybeInfo->InsnOffset != Address.Address)
+    return nullptr;
+
+  return &*MaybeInfo;
+}
+
+BTF::BPFLineInfo *BTFParser::findLineInfo(SectionedAddress Address) {
+  return findInfo(SectionLines, Address);
+}
+
+BTF::BPFFieldReloc *BTFParser::findFieldReloc(SectionedAddress Address) {
+  return findInfo(SectionRelocs, Address);
+}
+
+const BTF::CommonType *BTFParser::findType(uint32_t Id) {
+  if (Id < Types.size())
+    return Types[Id];
+}
+
+enum ReloKindGroup {
+  RKG_FIELD,
+  RKG_TYPE,
+  RKG_ENUMVAL,
+  RKG_UNKNOWN,
+};
+
+static ReloKindGroup reloKindGroup(const BTF::BPFFieldReloc *Reloc) {
+  switch (Reloc->RelocKind) {
+  case BTF::FIELD_BYTE_OFFSET:
+  case BTF::FIELD_BYTE_SIZE:
+  case BTF::FIELD_EXISTENCE:
+  case BTF::FIELD_SIGNEDNESS:
+  case BTF::FIELD_LSHIFT_U64:
+  case BTF::FIELD_RSHIFT_U64:
+    return RKG_FIELD;
+  case BTF::BTF_TYPE_ID_LOCAL:
+  case BTF::BTF_TYPE_ID_REMOTE:
+  case BTF::TYPE_EXISTENCE:
+  case BTF::TYPE_MATCH:
+  case BTF::TYPE_SIZE:
+    return RKG_TYPE;
+  case BTF::ENUM_VALUE_EXISTENCE:
+  case BTF::ENUM_VALUE:
+    return RKG_ENUMVAL;
+  default:
+    return RKG_UNKNOWN;
+  }
+}
+
+static bool isMod(const BTF::CommonType *Type) {
+  switch (Type->getKind()) {
+  case BTF::BTF_KIND_VOLATILE:
+  case BTF::BTF_KIND_CONST:
+  case BTF::BTF_KIND_RESTRICT:
+  case BTF::BTF_KIND_TYPE_TAG:
+    return true;
+  default:
+    return false;
+  }
+}
+
+static bool printMod(BTFParser &BTF, const BTF::CommonType *Type,
+                     raw_ostream &Stream) {
+  switch (Type->getKind()) {
+  case BTF::BTF_KIND_CONST:
+    Stream << " const";
+    break;
+  case BTF::BTF_KIND_VOLATILE:
+    Stream << " volatile";
+    break;
+  case BTF::BTF_KIND_RESTRICT:
+    Stream << " restrict";
+    break;
+  case BTF::BTF_KIND_TYPE_TAG:
+    Stream << " type_tag(\"" << BTF.findString(Type->NameOff) << "\")";
+    break;
+  default:
+    return false;
+  }
+  return true;
+}
+
+static const BTF::CommonType *skipModsAndTypedefs(BTFParser &BTF,
+                                                  const BTF::CommonType *Type) {
+  while (isMod(Type) || Type->getKind() == BTF::BTF_KIND_TYPEDEF) {
+    auto *Base = BTF.findType(Type->Type);
+    if (!Base)
+      break;
+    Type = Base;
+  }
+  return Type;
+}
+
+struct StrOrAnon {
+  BTFParser &BTF;
+  uint32_t Offset;
+  uint32_t Idx;
+};
+
+static raw_ostream &operator<<(raw_ostream &Stream, const StrOrAnon &S) {
+  StringRef Str = S.BTF.findString(S.Offset);
+  if (Str.empty())
+    Stream << "<anon " << S.Idx << ">";
+  else
+    Stream << Str;
+  return Stream;
+}
+
+static void reloKindName(uint32_t X, raw_ostream &Out) {
+  Out << "<";
+  switch (X) {
+  default:
+    Out << "relo kind #" << X;
+    break;
+  case BTF::FIELD_BYTE_OFFSET:
+    Out << "byte_off";
+    break;
+  case BTF::FIELD_BYTE_SIZE:
+    Out << "byte_sz";
+    break;
+  case BTF::FIELD_EXISTENCE:
+    Out << "field_exists";
+    break;
+  case BTF::FIELD_SIGNEDNESS:
+    Out << "signed";
+    break;
+  case BTF::FIELD_LSHIFT_U64:
+    Out << "lshift_u64";
+    break;
+  case BTF::FIELD_RSHIFT_U64:
+    Out << "rshift_u64";
+    break;
+  case BTF::BTF_TYPE_ID_LOCAL:
+    Out << "local_type_id";
+    break;
+  case BTF::BTF_TYPE_ID_REMOTE:
+    Out << "target_type_id";
+    break;
+  case BTF::TYPE_EXISTENCE:
+    Out << "type_exists";
+    break;
+  case BTF::TYPE_MATCH:
+    Out << "type_matches";
+    break;
+  case BTF::TYPE_SIZE:
+    Out << "type_size";
+    break;
+  case BTF::ENUM_VALUE_EXISTENCE:
+    Out << "enumval_exists";
+    break;
+  case BTF::ENUM_VALUE:
+    Out << "enumval_value";
+    break;
+  }
+  Out << ">";
+}
+
+// Produces a human readable description of a CO-RE relocation.
+// Such relocations are generated by BPF backend, specifically by code
+// from the following files:
+// - llvm/lib/Target/BPF/BPFAbstractMemberAccess.cpp
+// - llvm/lib/Target/BPF/BTFDebug.cpp
+// And than processed by libbpf's BPF program loader [1].
+//
+// Each relocation record has the following information:
+// - Relocation kind;
+// - BTF type ID;
+// - Access string offset in string table.
+//
+// There are different kinds of relocations, these kinds could be split
+// in three groups:
+// - load-time information about types (size, existence),
+//   `BTFParser::symbolize()` output for such relocations uses the template:
+//
+//     <relocation-kind> [<id>] <type-name>
+//
+//   For example:
+//   - "<type_exists> [7] struct foo"
+//   - "<type_size> [7] struct foo"
+//
+// - load-time information about enums (literal existence, literal value),
+//   `BTFParser::symbolize()` output for such relocations uses the template:
+//
+//     <relocation-kind> [<id>] <type-name>::<literal-name> = <original-value>
+//
+//   For example:
+//   - "<enumval_exists> [5] enum foo::U = 1"
+//   - "<enumval_value> [5] enum foo::V = 2"
+//
+// - load-time information about fields (e.g. field offset),
+//   `BTFParser::symbolize()` output for such relocations uses the template:
+//
+//     <relocation-kind> [<id>] <type-name>::[N].<field-1-name>...<field-M-name>
+//
+//   For example:
+//   - "<byte_off> [8] struct bar::[7].v (7:1)"
+//   - "<field_exists> [8] struct bar::v (0:1)"
+//
+// If relocation description is not valid output follows the following pattern:
+//
+//     <relocation-kind> <type-id>::<unprocessedaccess-string> <<error-msg>>
+//
+// For example:
+//
+// - "<type_sz> [42] '' <unknown type id: 42>"
+// - "<byte_off> [4] '0:' <field spec too short>"
+//
+// Additional examples could be found in unit tests, see
+// llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp.
+//
+// [1] https://www.kernel.org/doc/html/latest/bpf/libbpf/index.html
+std::string BTFParser::symbolize(BTF::BPFFieldReloc *Reloc) {
+  std::string Result;
+  raw_string_ostream Stream(Result);
+  StringRef FullSpecStr = findString(Reloc->OffsetNameOff);
+  SmallVector<uint32_t, 8> RawSpec;
+
+  auto Fail = [&](auto Msg) {
+    Result.resize(0);
+    reloKindName(Reloc->RelocKind, Stream);
+    Stream << " [" << Reloc->TypeID << "] '" << FullSpecStr << "'"
+           << " <" << Msg << ">";
+    return Result;
+  };
+
+  // Relocation access string follows pattern [0-9]+(:[0-9]+)*,
+  // e.g.: 12:22:3. Code below Splis the `SpecStr` by ':',
+  // parses numbers and pushes those to `RawSpec`.
+  StringRef SpecStr = FullSpecStr;
+  while (SpecStr.size()) {
+    unsigned long long Val;
+    if (consumeUnsignedInteger(SpecStr, 10, Val))
+      return Fail("spec string is not a number");
+
+    RawSpec.push_back(Val);
+
+    if (SpecStr.size() && SpecStr[0] != ':')
+      return Fail(format("unexpected spec string delimiter: '%c'", SpecStr[0]));
+
+    SpecStr = SpecStr.substr(1);
+  }
+
+  // Print relocation kind to `Stream`
+  reloKindName(Reloc->RelocKind, Stream);
+
+  uint32_t CurId = Reloc->TypeID;
+  const BTF::CommonType *Type = findType(CurId);
+  if (!Type)
+    return Fail(format("unknown type id: %d", CurId));
+
+  Stream << " [" << CurId << "]";
+
+  // `Type` might have modifiers, e.g. for type 'const int' the `Type`
+  // would refer to BTF type of kind BTF_KIND_CONST.
+  // Print all these modifiers to `Stream`.
+  for (uint32_t ChainLen = 0; printMod(*this, Type, Stream); ++ChainLen) {
+    if (ChainLen >= 32)
+      return Fail("modifiers chain is too long");
+
+    CurId = Type->Type;
+    const BTF::CommonType *NextType = findType(CurId);
+    if (!NextType)
+      return Fail(format("unknown type id: %d in modifiers chain", CurId));
+    Type = NextType;
+  }
+  // Print the type name to `Stream`
+  if (CurId == 0) {
+    Stream << " void";
+  } else {
+    switch (Type->getKind()) {
+    case BTF::BTF_KIND_TYPEDEF:
+      Stream << " typedef";
+      break;
+    case BTF::BTF_KIND_STRUCT:
+      Stream << " struct";
+      break;
+    case BTF::BTF_KIND_UNION:
+      Stream << " union";
+      break;
+    case BTF::BTF_KIND_ENUM:
+      Stream << " enum";
+      break;
+    case BTF::BTF_KIND_ENUM64:
+      Stream << " enum";
+      break;
+    case BTF::BTF_KIND_FWD:
+      if (Type->Info & BTF::FWD_UNION_FLAG)
+        Stream << " fwd union";
+      else
+        Stream << " fwd struct";
+      break;
+    default:
+      break;
+    }
+    Stream << " " << StrOrAnon({*this, Type->NameOff, CurId});
+  }
+
+  ReloKindGroup Group = reloKindGroup(Reloc);
+
+  // Type-based relocations don't use access string.
+  if (Group == RKG_TYPE)
+    return Result;
+
+  Stream << "::";
+
+  // For enum-based relocations access string is a single number,
+  // corresponding to the enum literal sequential number.
+  // E.g. for `enum E { U, V }`, relocation requesting value of `V`
+  // would look as follows:
+  // - kind: BTF::ENUM_VALUE
+  // - BTF id: id for `E`
+  // - access string: "1"
+  if (Group == RKG_ENUMVAL) {
+    Type = skipModsAndTypedefs(*this, Type);
+
+    if (RawSpec.size() != 1)
+      return Fail("unexpected enumval relo spec size");
+
+    uint32_t NameOff;
+    uint64_t Val;
+    uint32_t Idx = RawSpec[0];
+    if (auto *T = dyn_cast<BTF::EnumType>(Type)) {
+      if (T->values().size() <= Idx)
+        return Fail(format("bad value index: %d", Idx));
+      const BTF::BTFEnum &E = T->values()[Idx];
+      NameOff = E.NameOff;
+      Val = E.Val;
+    } else if (auto *T = dyn_cast<BTF::Enum64Type>(Type)) {
+      if (T->values().size() <= Idx)
+        return Fail(format("bad value index: %d", Idx));
+      const BTF::BTFEnum64 &E = T->values()[Idx];
+      NameOff = E.NameOff;
+      Val = (uint64_t)E.Val_Hi32 << 32u | E.Val_Lo32;
+    } else {
+      return Fail(
+          format("unexpected type kind for enum relo: %d", Type->getKind()));
+    }
+
+    Stream << StrOrAnon({*this, NameOff, Idx});
+    if (Type->Info & BTF::ENUM_SIGNED_FLAG)
+      Stream << " = " << (int64_t)Val;
+    else
+      Stream << " = " << (uint64_t)Val;
+    return Result;
+  }
+
+  // For type-based relocations access string is an array of numbers,
+  // which resemble index parameters for `getelementptr` LLVM IR instruction.
+  // E.g. for the following types:
+  //
+  //   struct foo {
+  //     int a;
+  //     int b;
+  //   };
+  //   struct bar {
+  //     int u;
+  //     struct foo v[7];
+  //   };
+  //
+  // Relocation requesting `offsetof(struct bar, v[2].b)` will have
+  // the following access string: 0:1:2:1
+  //                              ^ ^ ^ ^
+  //                              | | | |
+  //                  initial index | | field 'b' is a field #1
+  //                                | | (counting from 0)
+  //                                | array index #2
+  //           field 'v' is a field #1
+  //              (counting from 0)
+  if (Group == RKG_FIELD) {
+    if (RawSpec.size() < 1)
+      return Fail("field spec too short");
+
+    if (RawSpec[0] != 0)
+      Stream << "[" << RawSpec[0] << "]";
+    for (uint32_t I = 1; I < RawSpec.size(); ++I) {
+      Type = skipModsAndTypedefs(*this, Type);
+      uint32_t Idx = RawSpec[I];
+
+      if (auto *T = dyn_cast<BTF::StructType>(Type)) {
+        if (T->getVlen() <= Idx)
+          return Fail(
+              format("member index %d for spec sub-string %d is out of range",
+                     Idx, I));
+
+        const BTF::BTFMember &Member = T->members()[Idx];
+        if (I != 1 || RawSpec[0] != 0)
+          Stream << ".";
+        Stream << StrOrAnon({*this, Member.NameOff, Idx});
+        Type = findType(Member.Type);
+        if (!Type)
+          return Fail(format("unknown member type id %d for spec sub-string %d",
+                             Member.Type, I));
+      } else if (auto *T = dyn_cast<BTF::ArrayType>(Type)) {
+        Stream << "[" << Idx << "]";
+        Type = findType(T->getArray().ElemType);
+        if (!Type)
+          return Fail(
+              format("unknown element type id %d for spec sub-string %d",
+                     T->getArray().ElemType, I));
+      } else {
+        return Fail(format("unexpected type kind %d for spec sub-string %d",
+                           Type->getKind(), I));
+      }
+    }
+
+    Stream << " (" << FullSpecStr << ")";
+    return Result;
+  }
 
-  return &*LineInfo;
+  return Fail(format("unknown relo kind: %d", Reloc->RelocKind));
 }

llvm/lib/Target/BPF/BPFAbstractMemberAccess.cpp

 //===------ BPFAbstractMemberAccess.cpp - Abstracting Member Accesses -----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //

 // on the target host where the member_access may or may not be available
 //
 //===----------------------------------------------------------------------===//
 
 #include "BPF.h"
 #include "BPFCORE.h"
 #include "BPFTargetMachine.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/BTF/BTF.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicsBPF.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Type.h"
if (GV->getName().startswith("llvm.preserve.struct.access.index")) {
     CInfo.RecordAlignment = DL->getABITypeAlign(getBaseElementType(Call));
     return true;
   }
   if (GV->getName().startswith("llvm.bpf.preserve.field.info")) {
     CInfo.Kind = BPFPreserveFieldInfoAI;
     CInfo.Metadata = nullptr;
     // Check validity of info_kind as clang did not check this.
     uint64_t InfoKind = getConstant(Call->getArgOperand(1));
-    if (InfoKind >= BPFCoreSharedInfo::MAX_FIELD_RELOC_KIND)
+    if (InfoKind >= BTF::MAX_FIELD_RELOC_KIND)
       report_fatal_error("Incorrect info_kind for llvm.bpf.preserve.field.info intrinsic");
     CInfo.AccessIndex = InfoKind;
     return true;
   }
   if (GV->getName().startswith("llvm.bpf.preserve.type.info")) {
     CInfo.Kind = BPFPreserveFieldInfoAI;
     CInfo.Metadata = Call->getMetadata(LLVMContext::MD_preserve_access_index);
     if (!CInfo.Metadata)
       report_fatal_error("Missing metadata for llvm.preserve.type.info intrinsic");
     uint64_t Flag = getConstant(Call->getArgOperand(1));
     if (Flag >= BPFCoreSharedInfo::MAX_PRESERVE_TYPE_INFO_FLAG)
       report_fatal_error("Incorrect flag for llvm.bpf.preserve.type.info intrinsic");
     if (Flag == BPFCoreSharedInfo::PRESERVE_TYPE_INFO_EXISTENCE)
-      CInfo.AccessIndex = BPFCoreSharedInfo::TYPE_EXISTENCE;
+      CInfo.AccessIndex = BTF::TYPE_EXISTENCE;
     else if (Flag == BPFCoreSharedInfo::PRESERVE_TYPE_INFO_MATCH)
-      CInfo.AccessIndex = BPFCoreSharedInfo::TYPE_MATCH;
+      CInfo.AccessIndex = BTF::TYPE_MATCH;
     else
-      CInfo.AccessIndex = BPFCoreSharedInfo::TYPE_SIZE;
+      CInfo.AccessIndex = BTF::TYPE_SIZE;
     return true;
   }
   if (GV->getName().startswith("llvm.bpf.preserve.enum.value")) {
     CInfo.Kind = BPFPreserveFieldInfoAI;
     CInfo.Metadata = Call->getMetadata(LLVMContext::MD_preserve_access_index);
     if (!CInfo.Metadata)
       report_fatal_error("Missing metadata for llvm.preserve.enum.value intrinsic");
     uint64_t Flag = getConstant(Call->getArgOperand(2));
     if (Flag >= BPFCoreSharedInfo::MAX_PRESERVE_ENUM_VALUE_FLAG)
       report_fatal_error("Incorrect flag for llvm.bpf.preserve.enum.value intrinsic");
     if (Flag == BPFCoreSharedInfo::PRESERVE_ENUM_VALUE_EXISTENCE)
-      CInfo.AccessIndex = BPFCoreSharedInfo::ENUM_VALUE_EXISTENCE;
+      CInfo.AccessIndex = BTF::ENUM_VALUE_EXISTENCE;
     else
-      CInfo.AccessIndex = BPFCoreSharedInfo::ENUM_VALUE;
+      CInfo.AccessIndex = BTF::ENUM_VALUE;
     return true;
   }
 
   return false;
 }
 
 void BPFAbstractMemberAccess::replaceWithGEP(std::vector<CallInst *> &CallList,
                                              uint32_t DimensionIndex,
void BPFAbstractMemberAccess::GetStorageBitRange(DIDerivedType *MemberTy,
   EndBitOffset = StartBitOffset + AlignBits;
 }
 
 uint32_t BPFAbstractMemberAccess::GetFieldInfo(uint32_t InfoKind,
                                                DICompositeType *CTy,
                                                uint32_t AccessIndex,
                                                uint32_t PatchImm,
                                                MaybeAlign RecordAlignment) {
-  if (InfoKind == BPFCoreSharedInfo::FIELD_EXISTENCE)
-      return 1;
+  if (InfoKind == BTF::FIELD_EXISTENCE)
 
   uint32_t Tag = CTy->getTag();
-  if (InfoKind == BPFCoreSharedInfo::FIELD_BYTE_OFFSET) {
+  if (InfoKind == BTF::FIELD_BYTE_OFFSET) {
     if (Tag == dwarf::DW_TAG_array_type) {
       auto *EltTy = stripQualifiers(CTy->getBaseType());
       PatchImm += AccessIndex * calcArraySize(CTy, 1) *
                   (EltTy->getSizeInBits() >> 3);
     } else if (Tag == dwarf::DW_TAG_structure_type) {
       auto *MemberTy = cast<DIDerivedType>(CTy->getElements()[AccessIndex]);
       if (!MemberTy->isBitField()) {
         PatchImm += MemberTy->getOffsetInBits() >> 3;
       } else {
         unsigned SBitOffset, NextSBitOffset;
         GetStorageBitRange(MemberTy, *RecordAlignment, SBitOffset,
                            NextSBitOffset);
         PatchImm += SBitOffset >> 3;
       }
     }
     return PatchImm;
   }
 
-  if (InfoKind == BPFCoreSharedInfo::FIELD_BYTE_SIZE) {
+  if (InfoKind == BTF::FIELD_BYTE_SIZE) {
     if (Tag == dwarf::DW_TAG_array_type) {
       auto *EltTy = stripQualifiers(CTy->getBaseType());
       return calcArraySize(CTy, 1) * (EltTy->getSizeInBits() >> 3);
     } else {
       auto *MemberTy = cast<DIDerivedType>(CTy->getElements()[AccessIndex]);
       uint32_t SizeInBits = MemberTy->getSizeInBits();
       if (!MemberTy->isBitField())
         return SizeInBits >> 3;
 
       unsigned SBitOffset, NextSBitOffset;
       GetStorageBitRange(MemberTy, *RecordAlignment, SBitOffset,
                          NextSBitOffset);
       SizeInBits = NextSBitOffset - SBitOffset;
       if (SizeInBits & (SizeInBits - 1))
         report_fatal_error("Unsupported field expression for llvm.bpf.preserve.field.info");
       return SizeInBits >> 3;
     }
   }
 
-  if (InfoKind == BPFCoreSharedInfo::FIELD_SIGNEDNESS) {
+  if (InfoKind == BTF::FIELD_SIGNEDNESS) {
     const DIType *BaseTy;
     if (Tag == dwarf::DW_TAG_array_type) {
       // Signedness only checked when final array elements are accessed.
       if (CTy->getElements().size() != 1)
         report_fatal_error("Invalid array expression for llvm.bpf.preserve.field.info");
       BaseTy = stripQualifiers(CTy->getBaseType());
     } else {
       auto *MemberTy = cast<DIDerivedType>(CTy->getElements()[AccessIndex]);
while (!BTy) {
         report_fatal_error("Invalid field expression for llvm.bpf.preserve.field.info");
       BaseTy = stripQualifiers(CompTy->getBaseType());
       BTy = dyn_cast<DIBasicType>(BaseTy);
     }
     uint32_t Encoding = BTy->getEncoding();
     return (Encoding == dwarf::DW_ATE_signed || Encoding == dwarf::DW_ATE_signed_char);
   }
 
-  if (InfoKind == BPFCoreSharedInfo::FIELD_LSHIFT_U64) {
+  if (InfoKind == BTF::FIELD_LSHIFT_U64) {
     // The value is loaded into a value with FIELD_BYTE_SIZE size,
     // and then zero or sign extended to U64.
     // FIELD_LSHIFT_U64 and FIELD_RSHIFT_U64 are operations
     // to extract the original value.
     const Triple &Triple = TM->getTargetTriple();
     DIDerivedType *MemberTy = nullptr;
     bool IsBitField = false;
     uint32_t SizeInBits;
if (InfoKind == BTF::FIELD_LSHIFT_U64) {
 
     unsigned OffsetInBits = MemberTy->getOffsetInBits();
     if (Triple.getArch() == Triple::bpfel)
       return SBitOffset + 64 - OffsetInBits - SizeInBits;
     else
       return OffsetInBits + 64 - NextSBitOffset;
   }
 
-  if (InfoKind == BPFCoreSharedInfo::FIELD_RSHIFT_U64) {
+  if (InfoKind == BTF::FIELD_RSHIFT_U64) {
     DIDerivedType *MemberTy = nullptr;
     bool IsBitField = false;
     uint32_t SizeInBits;
     if (Tag == dwarf::DW_TAG_array_type) {
       auto *EltTy = stripQualifiers(CTy->getBaseType());
       SizeInBits = calcArraySize(CTy, 1) * EltTy->getSizeInBits();
     } else {
       MemberTy = cast<DIDerivedType>(CTy->getElements()[AccessIndex]);
Value *BPFAbstractMemberAccess::computeBaseAndAccessKey(CallInst *Call,
   // We only want to get type name from typedef, structure or union.
   // If user wants a relocation like
   //    int *p; ... __builtin_preserve_access_index(&p[4]) ...
   // or
   //    int a[10][20]; ... __builtin_preserve_access_index(&a[2][3]) ...
   // we will skip them.
   uint32_t FirstIndex = 0;
   uint32_t PatchImm = 0; // AccessOffset or the requested field info
-  uint32_t InfoKind = BPFCoreSharedInfo::FIELD_BYTE_OFFSET;
+  uint32_t InfoKind = BTF::FIELD_BYTE_OFFSET;
   while (CallStack.size()) {
     auto StackElem = CallStack.top();
     Call = StackElem.first;
     CInfo = StackElem.second;
 
     if (!Base)
       Base = CInfo.Base;
 
Value *BPFAbstractMemberAccess::computeBaseAndAccessKey(CallInst *Call,
   // and access key construction.
   while (CallStack.size()) {
     auto StackElem = CallStack.top();
     CInfo = StackElem.second;
     CallStack.pop();
 
     if (CInfo.Kind == BPFPreserveFieldInfoAI) {
       InfoKind = CInfo.AccessIndex;
-      if (InfoKind == BPFCoreSharedInfo::FIELD_EXISTENCE)
+      if (InfoKind == BTF::FIELD_EXISTENCE)
         PatchImm = 1;
       break;
     }
 
     // If the next Call (the top of the stack) is a BPFPreserveFieldInfoAI,
     // the action will be extracting field info.
     if (CallStack.size()) {
       auto StackElem2 = CallStack.top();
MDNode *BPFAbstractMemberAccess::computeAccessKey(CallInst *Call,
                                                   CallInfo &CInfo,
                                                   std::string &AccessKey,
                                                   bool &IsInt32Ret) {
   DIType *Ty = stripQualifiers(cast<DIType>(CInfo.Metadata), false);
   assert(!Ty->getName().empty());
 
   int64_t PatchImm;
   std::string AccessStr("0");
-  if (CInfo.AccessIndex == BPFCoreSharedInfo::TYPE_EXISTENCE ||
-      CInfo.AccessIndex == BPFCoreSharedInfo::TYPE_MATCH) {
+  if (CInfo.AccessIndex == BTF::TYPE_EXISTENCE ||
+      CInfo.AccessIndex == BTF::TYPE_MATCH) {
     PatchImm = 1;
-  } else if (CInfo.AccessIndex == BPFCoreSharedInfo::TYPE_SIZE) {
+  } else if (CInfo.AccessIndex == BTF::TYPE_SIZE) {
     // typedef debuginfo type has size 0, get the eventual base type.
     DIType *BaseTy = stripQualifiers(Ty, true);
     PatchImm = BaseTy->getSizeInBits() / 8;
   } else {
     // ENUM_VALUE_EXISTENCE and ENUM_VALUE
     IsInt32Ret = false;
 
     // The argument could be a global variable or a getelementptr with base to
for (const auto Element : CTy->getElements()) {
       const auto *Enum = cast<DIEnumerator>(Element);
       if (Enum->getName() == EnumeratorStr) {
         AccessStr = std::to_string(EnumIndex);
         break;
       }
       EnumIndex++;
     }
 
-    if (CInfo.AccessIndex == BPFCoreSharedInfo::ENUM_VALUE) {
+    if (CInfo.AccessIndex == BTF::ENUM_VALUE) {
       StringRef EValueStr = ValueStr.substr(Separator + 1);
       PatchImm = std::stoll(std::string(EValueStr));
     } else {
       PatchImm = 1;
     }
   }
 
   AccessKey = "llvm." + Ty->getName().str() + ":" +

llvm/lib/Target/BPF/BPFCORE.h

 //===- BPFCORE.h - Common info for Compile-Once Run-EveryWhere  -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_TARGET_BPF_BPFCORE_H
 #define LLVM_LIB_TARGET_BPF_BPFCORE_H
 
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 
 class BasicBlock;
 class Instruction;
 class Module;
 
 class BPFCoreSharedInfo {
 public:
-  enum PatchableRelocKind : uint32_t {
-    FIELD_BYTE_OFFSET = 0,
-    FIELD_BYTE_SIZE,
-    FIELD_EXISTENCE,
-    FIELD_SIGNEDNESS,
-    FIELD_LSHIFT_U64,
-    FIELD_RSHIFT_U64,
-    BTF_TYPE_ID_LOCAL,
-    BTF_TYPE_ID_REMOTE,
-    TYPE_EXISTENCE,
-    TYPE_SIZE,
-    ENUM_VALUE_EXISTENCE,
-    ENUM_VALUE,
-    TYPE_MATCH,
-
-    MAX_FIELD_RELOC_KIND,
-  };
-
   enum BTFTypeIdFlag : uint32_t {
     BTF_TYPE_ID_LOCAL_RELOC = 0,
     BTF_TYPE_ID_REMOTE_RELOC,
 
     MAX_BTF_TYPE_ID_FLAG,
   };
 
   enum PreserveTypeInfo : uint32_t {

llvm/lib/Target/BPF/BPFPreserveDIType.cpp

 //===----------- BPFPreserveDIType.cpp - Preserve DebugInfo Types ---------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Preserve Debuginfo types encoded in __builtin_btf_type_id() metadata.
 //
 //===----------------------------------------------------------------------===//
 
 #include "BPF.h"
 #include "BPFCORE.h"
 #include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/DebugInfo/BTF/BTF.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/User.h"
for (auto *Call : PreserveDITypeCalls) {
 
     if (FlagValue >= BPFCoreSharedInfo::MAX_BTF_TYPE_ID_FLAG)
       report_fatal_error("Incorrect flag for llvm.bpf.btf.type.id intrinsic");
 
     MDNode *MD = Call->getMetadata(LLVMContext::MD_preserve_access_index);
 
     uint32_t Reloc;
     if (FlagValue == BPFCoreSharedInfo::BTF_TYPE_ID_LOCAL_RELOC) {
-      Reloc = BPFCoreSharedInfo::BTF_TYPE_ID_LOCAL;
+      Reloc = BTF::BTF_TYPE_ID_LOCAL;
     } else {
-      Reloc = BPFCoreSharedInfo::BTF_TYPE_ID_REMOTE;
+      Reloc = BTF::BTF_TYPE_ID_REMOTE;
       DIType *Ty = cast<DIType>(MD);
       while (auto *DTy = dyn_cast<DIDerivedType>(Ty)) {
         unsigned Tag = DTy->getTag();
         if (Tag != dwarf::DW_TAG_const_type &&
             Tag != dwarf::DW_TAG_volatile_type)
           break;
         Ty = DTy->getBaseType();
       }

llvm/lib/Target/BPF/BTFDebug.cpp

 //===- BTFDebug.cpp - BTF Generator ---------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
if (MO.isGlobal()) {
         if (GVar->hasAttribute(BPFCoreSharedInfo::AmaAttr) ||
             GVar->hasAttribute(BPFCoreSharedInfo::TypeIdAttr)) {
           Imm = PatchImms[GVar].first;
           Reloc = PatchImms[GVar].second;
         } else {
           return false;
         }
 
-        if (Reloc == BPFCoreSharedInfo::ENUM_VALUE_EXISTENCE ||
-            Reloc == BPFCoreSharedInfo::ENUM_VALUE ||
-            Reloc == BPFCoreSharedInfo::BTF_TYPE_ID_LOCAL ||
-            Reloc == BPFCoreSharedInfo::BTF_TYPE_ID_REMOTE)
+        if (Reloc == BTF::ENUM_VALUE_EXISTENCE || Reloc == BTF::ENUM_VALUE ||
+            Reloc == BTF::BTF_TYPE_ID_LOCAL || Reloc == BTF::BTF_TYPE_ID_REMOTE)
           OutMI.setOpcode(BPF::LD_imm64);
         else
           OutMI.setOpcode(BPF::MOV_ri);
         OutMI.addOperand(MCOperand::createReg(MI->getOperand(0).getReg()));
         OutMI.addOperand(MCOperand::createImm(Imm));
         return true;
       }
     }

llvm/test/tools/llvm-objdump/BPF/core-relo-byte-offset.ll

+; REQUIRES: bpf-registered-target
+
+;; Verify that llvm-objdump can use .BTF.ext to show CO-RE relocation data.
+
+; RUN: llc --mtriple bpfel %s --filetype=obj -o - \
+; RUN:  | llvm-objdump --no-addresses --no-show-raw-insn -dr - \
+; RUN:  | FileCheck %s
+
+; RUN: llc --mtriple bpfeb %s --filetype=obj -o - \
+; RUN:  | llvm-objdump --no-addresses --no-show-raw-insn -dr - \
+; RUN:  | FileCheck %s
+
+;; Input generated from the following C code:
+;;
+;;  #define __pai __attribute__((preserve_access_index))
+;;
+;;  struct buz {
+;;    int a;
+;;    int b;
+;;  } __pai;
+;;
+;;  struct foo {
+;;    int :4;
+;;    int i;
+;;    struct buz k[10];
+;;  } __pai;
+;;
+;;  struct bar {
+;;    struct foo f;
+;;  } __pai;
+;;
+;;  void * volatile g;
+;;
+;;  void root(void) {
+;;    struct bar *bar = (void *)0;
+;;    g = &bar->f;
+;;    g = &bar->f.i;
+;;    g = &bar->f.k;
+;;    g = &bar->f.k[7].a;
+;;    g = &bar->f.k[7].b;
+;;    g = &bar[1].f.k[7].b;
+;;  }
+;;
+;; Using the following command:
+;;
+;;  clang -target bpf -g -O2 -emit-llvm -S t.c
+
+; CHECK: CO-RE relo: <byte_off> [[[#]]] struct bar::f
+; CHECK: CO-RE relo: <byte_off> [[[#]]] struct bar::f.i
+; CHECK: CO-RE relo: <byte_off> [[[#]]] struct bar::f.k
+; CHECK: CO-RE relo: <byte_off> [[[#]]] struct bar::f.k[7].a
+; CHECK: CO-RE relo: <byte_off> [[[#]]] struct bar::f.k[7].b
+; CHECK: CO-RE relo: <byte_off> [[[#]]] struct bar::[1].f.k[7].b
+
+@g = dso_local global ptr null, align 8, !dbg !0
+@"llvm.bar:0:0$0:0" = external global i64, !llvm.preserve.access.index !14 #0
+@"llvm.bar:0:8$0:0:1" = external global i64, !llvm.preserve.access.index !14 #0
+@"llvm.bar:0:4$0:0:0" = external global i64, !llvm.preserve.access.index !14 #0
+@"llvm.bar:0:64$0:0:1:7:0" = external global i64, !llvm.preserve.access.index !14 #0
+@"llvm.bar:0:68$0:0:1:7:1" = external global i64, !llvm.preserve.access.index !14 #0
+@"llvm.bar:0:156$1:0:1:7:1" = external global i64, !llvm.preserve.access.index !14 #0
+
+; Function Attrs: nofree nounwind memory(readwrite, argmem: none)
+define dso_local void @root() local_unnamed_addr #1 !dbg !29 {
+entry:
+  call void @llvm.dbg.value(metadata ptr null, metadata !33, metadata !DIExpression()), !dbg !34
+  %0 = load i64, ptr @"llvm.bar:0:0$0:0", align 8
+  %1 = getelementptr i8, ptr null, i64 %0
+  %2 = tail call ptr @llvm.bpf.passthrough.p0.p0(i32 0, ptr %1)
+  store volatile ptr %2, ptr @g, align 8, !dbg !35, !tbaa !36
+  %3 = load i64, ptr @"llvm.bar:0:4$0:0:0", align 8
+  %4 = getelementptr i8, ptr null, i64 %3
+  %5 = tail call ptr @llvm.bpf.passthrough.p0.p0(i32 2, ptr %4)
+  store volatile ptr %5, ptr @g, align 8, !dbg !40, !tbaa !36
+  %6 = load i64, ptr @"llvm.bar:0:8$0:0:1", align 8
+  %7 = getelementptr i8, ptr null, i64 %6
+  %8 = tail call ptr @llvm.bpf.passthrough.p0.p0(i32 1, ptr %7)
+  store volatile ptr %8, ptr @g, align 8, !dbg !41, !tbaa !36
+  %9 = load i64, ptr @"llvm.bar:0:64$0:0:1:7:0", align 8
+  %10 = getelementptr i8, ptr null, i64 %9
+  %11 = tail call ptr @llvm.bpf.passthrough.p0.p0(i32 3, ptr %10)
+  store volatile ptr %11, ptr @g, align 8, !dbg !42, !tbaa !36
+  %12 = load i64, ptr @"llvm.bar:0:68$0:0:1:7:1", align 8
+  %13 = getelementptr i8, ptr null, i64 %12
+  %14 = tail call ptr @llvm.bpf.passthrough.p0.p0(i32 4, ptr %13)
+  store volatile ptr %14, ptr @g, align 8, !dbg !43, !tbaa !36
+  %15 = load i64, ptr @"llvm.bar:0:156$1:0:1:7:1", align 8
+  %16 = getelementptr i8, ptr null, i64 %15
+  %17 = tail call ptr @llvm.bpf.passthrough.p0.p0(i32 5, ptr %16)
+  store volatile ptr %17, ptr @g, align 8, !dbg !44, !tbaa !36
+  ret void, !dbg !45
+}
+
+; Function Attrs: nofree nosync nounwind memory(none)
+declare ptr @llvm.bpf.passthrough.p0.p0(i32, ptr) #2
+
+; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
+declare void @llvm.dbg.value(metadata, metadata, metadata) #3
+
+attributes #0 = { "btf_ama" }
+attributes #1 = { nofree nounwind memory(readwrite, argmem: none) "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #2 = { nofree nosync nounwind memory(none) }
+attributes #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!24, !25, !26, !27}
+!llvm.ident = !{!28}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 18, type: !22, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C11, file: !3, producer: "clang version 17.0.0 (/home/eddy/work/llvm-project/clang 2f8c5c0afd1d79a771dd74c8fb1e5bbae6d04eb7)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, retainedTypes: !4, globals: !21, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "t.c", directory: "/home/eddy/work/tmp", checksumkind: CSK_MD5, checksum: "f7c638151153f385e69bef98e88c80ef")
+!4 = !{!5, !13}
+!5 = !DICompositeType(tag: DW_TAG_array_type, baseType: !6, size: 640, elements: !11)
+!6 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "buz", file: !3, line: 3, size: 64, elements: !7)
+!7 = !{!8, !10}
+!8 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !6, file: !3, line: 4, baseType: !9, size: 32)
+!9 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!10 = !DIDerivedType(tag: DW_TAG_member, name: "b", scope: !6, file: !3, line: 5, baseType: !9, size: 32, offset: 32)
+!11 = !{!12}
+!12 = !DISubrange(count: 10)
+!13 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !14, size: 64)
+!14 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "bar", file: !3, line: 14, size: 704, elements: !15)
+!15 = !{!16}
+!16 = !DIDerivedType(tag: DW_TAG_member, name: "f", scope: !14, file: !3, line: 15, baseType: !17, size: 704)
+!17 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "foo", file: !3, line: 8, size: 704, elements: !18)
+!18 = !{!19, !20}
+!19 = !DIDerivedType(tag: DW_TAG_member, name: "i", scope: !17, file: !3, line: 10, baseType: !9, size: 32, offset: 32)
+!20 = !DIDerivedType(tag: DW_TAG_member, name: "k", scope: !17, file: !3, line: 11, baseType: !5, size: 640, offset: 64)
+!21 = !{!0}
+!22 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !23)
+!23 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: null, size: 64)
+!24 = !{i32 7, !"Dwarf Version", i32 5}
+!25 = !{i32 2, !"Debug Info Version", i32 3}
+!26 = !{i32 1, !"wchar_size", i32 4}
+!27 = !{i32 7, !"frame-pointer", i32 2}
+!28 = !{!"clang version 17.0.0 (/home/eddy/work/llvm-project/clang 2f8c5c0afd1d79a771dd74c8fb1e5bbae6d04eb7)"}
+!29 = distinct !DISubprogram(name: "root", scope: !3, file: !3, line: 20, type: !30, scopeLine: 20, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !32)
+!30 = !DISubroutineType(types: !31)
+!31 = !{null}
+!32 = !{!33}
+!33 = !DILocalVariable(name: "bar", scope: !29, file: !3, line: 21, type: !13)
+!34 = !DILocation(line: 0, scope: !29)
+!35 = !DILocation(line: 22, column: 5, scope: !29)
+!36 = !{!37, !37, i64 0}
+!37 = !{!"any pointer", !38, i64 0}
+!38 = !{!"omnipotent char", !39, i64 0}
+!39 = !{!"Simple C/C++ TBAA"}
+!40 = !DILocation(line: 23, column: 5, scope: !29)
+!41 = !DILocation(line: 24, column: 5, scope: !29)
+!42 = !DILocation(line: 25, column: 5, scope: !29)
+!43 = !DILocation(line: 26, column: 5, scope: !29)
+!44 = !DILocation(line: 27, column: 5, scope: !29)
+!45 = !DILocation(line: 28, column: 1, scope: !29)

llvm/test/tools/llvm-objdump/BPF/core-relo-enum-value.ll

+; REQUIRES: bpf-registered-target
+
+;; Verify that llvm-objdump can use .BTF.ext to show CO-RE relocation data.
+
+; RUN: llc --mtriple bpfel %s --filetype=obj -o - \
+; RUN:  | llvm-objdump --no-addresses --no-show-raw-insn -dr - \
+; RUN:  | FileCheck %s
+
+; RUN: llc --mtriple bpfeb %s --filetype=obj -o - \
+; RUN:  | llvm-objdump --no-addresses --no-show-raw-insn -dr - \
+; RUN:  | FileCheck %s
+
+;; Input generated from the following C code:
+;;
+;;  #define __pai __attribute__((preserve_access_index))
+;;
+;;  enum bar { U, V };
+;;  volatile unsigned long g;
+;;  void root(void) {
+;;    g = __builtin_preserve_enum_value(*(enum bar *)U, 0);
+;;    g = __builtin_preserve_enum_value(*(enum bar *)V, 1);
+;;  }
+;;
+;; Using the following command:
+;;
+;;  clang -target bpf -g -O2 -emit-llvm -S t.c
+
+; CHECK: CO-RE relo: <enumval_exists> [[[#]]] enum bar::U = 0
+; CHECK: CO-RE relo: <enumval_value> [[[#]]] enum bar::V = 1
+
+@g = dso_local global i64 0, align 8, !dbg !0
+@"llvm.bar:11:1$1" = external global i64, !llvm.preserve.access.index !5 #0
+@"llvm.bar:10:1$0" = external global i64, !llvm.preserve.access.index !5 #0
+
+; Function Attrs: nofree nounwind memory(readwrite, argmem: none)
+define dso_local void @root() local_unnamed_addr #1 !dbg !18 {
+entry:
+  %0 = load i64, ptr @"llvm.bar:10:1$0", align 8
+  %1 = tail call i64 @llvm.bpf.passthrough.i64.i64(i32 1, i64 %0)
+  store volatile i64 %1, ptr @g, align 8, !dbg !22, !tbaa !23
+  %2 = load i64, ptr @"llvm.bar:11:1$1", align 8
+  %3 = tail call i64 @llvm.bpf.passthrough.i64.i64(i32 0, i64 %2)
+  store volatile i64 %3, ptr @g, align 8, !dbg !27, !tbaa !23
+  ret void, !dbg !28
+}
+
+; Function Attrs: nofree nosync nounwind memory(none)
+declare i64 @llvm.bpf.passthrough.i64.i64(i32, i64) #2
+
+attributes #0 = { "btf_ama" }
+attributes #1 = { nofree nounwind memory(readwrite, argmem: none) "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #2 = { nofree nosync nounwind memory(none) }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!13, !14, !15, !16}
+!llvm.ident = !{!17}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 4, type: !11, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C11, file: !3, producer: "clang version 17.0.0 (/home/eddy/work/llvm-project/clang 2f8c5c0afd1d79a771dd74c8fb1e5bbae6d04eb7)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !10, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "t.c", directory: "/home/eddy/work/tmp", checksumkind: CSK_MD5, checksum: "5423aa9ef48cb61e948b5c2bd75fd1df")
+!4 = !{!5}
+!5 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "bar", file: !3, line: 3, baseType: !6, size: 32, elements: !7)
+!6 = !DIBasicType(name: "unsigned int", size: 32, encoding: DW_ATE_unsigned)
+!7 = !{!8, !9}
+!8 = !DIEnumerator(name: "U", value: 0)
+!9 = !DIEnumerator(name: "V", value: 1)
+!10 = !{!0}
+!11 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !12)
+!12 = !DIBasicType(name: "unsigned long", size: 64, encoding: DW_ATE_unsigned)
+!13 = !{i32 7, !"Dwarf Version", i32 5}
+!14 = !{i32 2, !"Debug Info Version", i32 3}
+!15 = !{i32 1, !"wchar_size", i32 4}
+!16 = !{i32 7, !"frame-pointer", i32 2}
+!17 = !{!"clang version 17.0.0 (/home/eddy/work/llvm-project/clang 2f8c5c0afd1d79a771dd74c8fb1e5bbae6d04eb7)"}
+!18 = distinct !DISubprogram(name: "root", scope: !3, file: !3, line: 5, type: !19, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !21)
+!19 = !DISubroutineType(types: !20)
+!20 = !{null}
+!21 = !{}
+!22 = !DILocation(line: 6, column: 5, scope: !18)
+!23 = !{!24, !24, i64 0}
+!24 = !{!"long", !25, i64 0}
+!25 = !{!"omnipotent char", !26, i64 0}
+!26 = !{!"Simple C/C++ TBAA"}
+!27 = !DILocation(line: 7, column: 5, scope: !18)
+!28 = !DILocation(line: 8, column: 1, scope: !18)

llvm/test/tools/llvm-objdump/BPF/core-relo-field-info.ll

+; REQUIRES: bpf-registered-target
+
+;; Verify that llvm-objdump can use .BTF.ext to show CO-RE relocation data.
+
+; RUN: llc --mtriple bpfel %s --filetype=obj -o - \
+; RUN:  | llvm-objdump --no-addresses --no-show-raw-insn -dr - \
+; RUN:  | FileCheck %s
+
+; RUN: llc --mtriple bpfeb %s --filetype=obj -o - \
+; RUN:  | llvm-objdump --no-addresses --no-show-raw-insn -dr - \
+; RUN:  | FileCheck %s
+
+;; Input generated from the following C code:
+;;
+;;  #define __pai __attribute__((preserve_access_index))
+;;
+;;  struct bar { int a; } __pai;
+;;  volatile unsigned long g;
+;;  void root(void) {
+;;    struct bar *bar = (void *)0;
+;;    g = __builtin_preserve_field_info(bar->a, 1);
+;;    g = __builtin_preserve_field_info(bar->a, 2);
+;;    g = __builtin_preserve_field_info(bar->a, 3);
+;;    g = __builtin_preserve_field_info(bar->a, 4);
+;;    g = __builtin_preserve_field_info(bar->a, 5);
+;;  }
+;;
+;; Using the following command:
+;;
+;;  clang -target bpf -g -O2 -emit-llvm -S t.c
+
+; CHECK: CO-RE relo: <byte_sz> [[[#]]] struct bar::a
+; CHECK: CO-RE relo: <field_exists> [[[#]]] struct bar::a
+; CHECK: CO-RE relo: <signed> [[[#]]] struct bar::a
+; CHECK: CO-RE relo: <lshift_u64> [[[#]]] struct bar::a
+; CHECK: CO-RE relo: <rshift_u64> [[[#]]] struct bar::a
+
+@g = dso_local global i64 0, align 8, !dbg !0
+@"llvm.bar:1:4$0:0" = external global i32, !llvm.preserve.access.index !7 #0
+@"llvm.bar:2:1$0:0" = external global i32, !llvm.preserve.access.index !7 #0
+@"llvm.bar:3:1$0:0" = external global i32, !llvm.preserve.access.index !7 #0
+@"llvm.bar:4:32$0:0" = external global i32, !llvm.preserve.access.index !7 #0
+@"llvm.bar:5:32$0:0" = external global i32, !llvm.preserve.access.index !7 #0
+
+; Function Attrs: nofree nounwind memory(readwrite, argmem: none)
+define dso_local void @root() local_unnamed_addr #1 !dbg !16 {
+entry:
+  call void @llvm.dbg.value(metadata ptr null, metadata !20, metadata !DIExpression()), !dbg !22
+  %0 = load i32, ptr @"llvm.bar:1:4$0:0", align 4
+  %1 = tail call i32 @llvm.bpf.passthrough.i32.i32(i32 0, i32 %0)
+  %conv = zext i32 %1 to i64, !dbg !23
+  store volatile i64 %conv, ptr @g, align 8, !dbg !24, !tbaa !25
+  %2 = load i32, ptr @"llvm.bar:2:1$0:0", align 4
+  %3 = tail call i32 @llvm.bpf.passthrough.i32.i32(i32 1, i32 %2)
+  %conv1 = zext i32 %3 to i64, !dbg !29
+  store volatile i64 %conv1, ptr @g, align 8, !dbg !30, !tbaa !25
+  %4 = load i32, ptr @"llvm.bar:3:1$0:0", align 4
+  %5 = tail call i32 @llvm.bpf.passthrough.i32.i32(i32 2, i32 %4)
+  %conv2 = zext i32 %5 to i64, !dbg !31
+  store volatile i64 %conv2, ptr @g, align 8, !dbg !32, !tbaa !25
+  %6 = load i32, ptr @"llvm.bar:4:32$0:0", align 4
+  %7 = tail call i32 @llvm.bpf.passthrough.i32.i32(i32 3, i32 %6)
+  %conv3 = zext i32 %7 to i64, !dbg !33
+  store volatile i64 %conv3, ptr @g, align 8, !dbg !34, !tbaa !25
+  %8 = load i32, ptr @"llvm.bar:5:32$0:0", align 4
+  %9 = tail call i32 @llvm.bpf.passthrough.i32.i32(i32 4, i32 %8)
+  %conv4 = zext i32 %9 to i64, !dbg !35
+  store volatile i64 %conv4, ptr @g, align 8, !dbg !36, !tbaa !25
+  ret void, !dbg !37
+}
+
+; Function Attrs: nofree nosync nounwind memory(none)
+declare i32 @llvm.bpf.passthrough.i32.i32(i32, i32) #2
+
+; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
+declare void @llvm.dbg.value(metadata, metadata, metadata) #3
+
+attributes #0 = { "btf_ama" }
+attributes #1 = { nofree nounwind memory(readwrite, argmem: none) "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #2 = { nofree nosync nounwind memory(none) }
+attributes #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!11, !12, !13, !14}
+!llvm.ident = !{!15}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 4, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C11, file: !3, producer: "clang version 17.0.0 (/home/eddy/work/llvm-project/clang 2f8c5c0afd1d79a771dd74c8fb1e5bbae6d04eb7)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "t.c", directory: "/home/eddy/work/tmp", checksumkind: CSK_MD5, checksum: "ff78616039301f51cd56ee6ea1377b86")
+!4 = !{!0}
+!5 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !6)
+!6 = !DIBasicType(name: "unsigned long", size: 64, encoding: DW_ATE_unsigned)
+!7 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "bar", file: !3, line: 3, size: 32, elements: !8)
+!8 = !{!9}
+!9 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !7, file: !3, line: 3, baseType: !10, size: 32)
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !{i32 7, !"Dwarf Version", i32 5}
+!12 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = !{i32 1, !"wchar_size", i32 4}
+!14 = !{i32 7, !"frame-pointer", i32 2}
+!15 = !{!"clang version 17.0.0 (/home/eddy/work/llvm-project/clang 2f8c5c0afd1d79a771dd74c8fb1e5bbae6d04eb7)"}
+!16 = distinct !DISubprogram(name: "root", scope: !3, file: !3, line: 5, type: !17, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !19)
+!17 = !DISubroutineType(types: !18)
+!18 = !{null}
+!19 = !{!20}
+!20 = !DILocalVariable(name: "bar", scope: !16, file: !3, line: 6, type: !21)
+!21 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!22 = !DILocation(line: 0, scope: !16)
+!23 = !DILocation(line: 7, column: 7, scope: !16)
+!24 = !DILocation(line: 7, column: 5, scope: !16)
+!25 = !{!26, !26, i64 0}
+!26 = !{!"long", !27, i64 0}
+!27 = !{!"omnipotent char", !28, i64 0}
+!28 = !{!"Simple C/C++ TBAA"}
+!29 = !DILocation(line: 8, column: 7, scope: !16)
+!30 = !DILocation(line: 8, column: 5, scope: !16)
+!31 = !DILocation(line: 9, column: 7, scope: !16)
+!32 = !DILocation(line: 9, column: 5, scope: !16)
+!33 = !DILocation(line: 10, column: 7, scope: !16)
+!34 = !DILocation(line: 10, column: 5, scope: !16)
+!35 = !DILocation(line: 11, column: 7, scope: !16)
+!36 = !DILocation(line: 11, column: 5, scope: !16)
+!37 = !DILocation(line: 12, column: 1, scope: !16)

llvm/test/tools/llvm-objdump/BPF/core-relo-type-id.ll

+; REQUIRES: bpf-registered-target
+
+;; Verify that llvm-objdump can use .BTF.ext to show CO-RE relocation data.
+
+; RUN: llc --mtriple bpfel %s --filetype=obj -o - \
+; RUN:  | llvm-objdump --no-addresses --no-show-raw-insn -dr - \
+; RUN:  | FileCheck %s
+
+; RUN: llc --mtriple bpfeb %s --filetype=obj -o - \
+; RUN:  | llvm-objdump --no-addresses --no-show-raw-insn -dr - \
+; RUN:  | FileCheck %s
+
+;; Input generated from the following C code:
+;;
+;;  #define __pai __attribute__((preserve_access_index))
+;;
+;;  struct bar { } __pai;
+;;  volatile unsigned long g;
+;;  void root(void) {
+;;    struct bar *bar = (void *)0;
+;;    g = __builtin_btf_type_id(*bar, 0);
+;;    g = __builtin_btf_type_id(*bar, 1);
+;;  }
+;;
+;; Using the following command:
+;;
+;;  clang -target bpf -g -O2 -emit-llvm -S t.c
+
+; CHECK: CO-RE relo: <local_type_id> [[[#]]] struct bar
+; CHECK: CO-RE relo: <target_type_id> [[[#]]] struct bar
+
+@g = dso_local global i64 0, align 8, !dbg !0
+@"llvm.btf_type_id.0$6" = external global i64, !llvm.preserve.access.index !7 #0
+@"llvm.btf_type_id.1$7" = external global i64, !llvm.preserve.access.index !7 #0
+
+; Function Attrs: nofree nounwind memory(readwrite, argmem: none)
+define dso_local void @root() local_unnamed_addr #1 !dbg !14 {
+entry:
+  call void @llvm.dbg.value(metadata ptr null, metadata !18, metadata !DIExpression()), !dbg !20
+  %0 = load i64, ptr @"llvm.btf_type_id.0$6", align 8
+  %1 = tail call i64 @llvm.bpf.passthrough.i64.i64(i32 0, i64 %0)
+  store volatile i64 %1, ptr @g, align 8, !dbg !21, !tbaa !22
+  %2 = load i64, ptr @"llvm.btf_type_id.1$7", align 8
+  %3 = tail call i64 @llvm.bpf.passthrough.i64.i64(i32 1, i64 %2)
+  store volatile i64 %3, ptr @g, align 8, !dbg !26, !tbaa !22
+  ret void, !dbg !27
+}
+
+; Function Attrs: nofree nosync nounwind memory(none)
+declare i64 @llvm.bpf.passthrough.i64.i64(i32, i64) #2
+
+; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
+declare void @llvm.dbg.value(metadata, metadata, metadata) #3
+
+attributes #0 = { "btf_type_id" }
+attributes #1 = { nofree nounwind memory(readwrite, argmem: none) "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #2 = { nofree nosync nounwind memory(none) }
+attributes #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!9, !10, !11, !12}
+!llvm.ident = !{!13}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 4, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C11, file: !3, producer: "clang version 17.0.0 (/home/eddy/work/llvm-project/clang 2f8c5c0afd1d79a771dd74c8fb1e5bbae6d04eb7)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "t.c", directory: "/home/eddy/work/tmp", checksumkind: CSK_MD5, checksum: "29efc9dba44aaba9e4b0c389bb8694ea")
+!4 = !{!0}
+!5 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !6)
+!6 = !DIBasicType(name: "unsigned long", size: 64, encoding: DW_ATE_unsigned)
+!7 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "bar", file: !3, line: 3, elements: !8)
+!8 = !{}
+!9 = !{i32 7, !"Dwarf Version", i32 5}
+!10 = !{i32 2, !"Debug Info Version", i32 3}
+!11 = !{i32 1, !"wchar_size", i32 4}
+!12 = !{i32 7, !"frame-pointer", i32 2}
+!13 = !{!"clang version 17.0.0 (/home/eddy/work/llvm-project/clang 2f8c5c0afd1d79a771dd74c8fb1e5bbae6d04eb7)"}
+!14 = distinct !DISubprogram(name: "root", scope: !3, file: !3, line: 5, type: !15, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !17)
+!15 = !DISubroutineType(types: !16)
+!16 = !{null}
+!17 = !{!18}
+!18 = !DILocalVariable(name: "bar", scope: !14, file: !3, line: 6, type: !19)
+!19 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!20 = !DILocation(line: 0, scope: !14)
+!21 = !DILocation(line: 7, column: 5, scope: !14)
+!22 = !{!23, !23, i64 0}
+!23 = !{!"long", !24, i64 0}
+!24 = !{!"omnipotent char", !25, i64 0}
+!25 = !{!"Simple C/C++ TBAA"}
+!26 = !DILocation(line: 8, column: 5, scope: !14)
+!27 = !DILocation(line: 9, column: 1, scope: !14)

llvm/test/tools/llvm-objdump/BPF/core-relo-type-info.ll

+; REQUIRES: bpf-registered-target
+
+;; Verify that llvm-objdump can use .BTF.ext to show CO-RE relocation data.
+
+; RUN: llc --mtriple bpfel %s --filetype=obj -o - \
+; RUN:  | llvm-objdump --no-addresses --no-show-raw-insn -dr - \
+; RUN:  | FileCheck %s
+
+; RUN: llc --mtriple bpfeb %s --filetype=obj -o - \
+; RUN:  | llvm-objdump --no-addresses --no-show-raw-insn -dr - \
+; RUN:  | FileCheck %s
+
+;; Input generated from the following C code:
+;;
+;;  #define __pai __attribute__((preserve_access_index))
+;;
+;;  struct bar { } __pai;
+;;  volatile unsigned long g;
+;;  void root(void) {
+;;    struct bar *bar = (void *)0;
+;;    g = __builtin_preserve_type_info(*bar, 0);
+;;    g = __builtin_preserve_type_info(*bar, 1);
+;;    g = __builtin_preserve_type_info(*bar, 2);
+;;  }
+;;
+;; Using the following command:
+;;
+;;  clang -target bpf -g -O2 -emit-llvm -S t.c
+
+; CHECK: CO-RE relo: <type_exists> [[[#]]] struct bar
+; CHECK: CO-RE relo: <type_size> [[[#]]] struct bar
+; CHECK: CO-RE relo: <type_matches> [[[#]]] struct bar
+
+@g = dso_local global i64 0, align 8, !dbg !0
+@"llvm.bar:8:1$0" = external global i32, !llvm.preserve.access.index !7 #0
+@"llvm.bar:9:0$0" = external global i32, !llvm.preserve.access.index !7 #0
+@"llvm.bar:12:1$0" = external global i32, !llvm.preserve.access.index !7 #0
+
+; Function Attrs: nofree nounwind memory(readwrite, argmem: none)
+define dso_local void @root() local_unnamed_addr #1 !dbg !14 {
+entry:
+  call void @llvm.dbg.value(metadata ptr null, metadata !18, metadata !DIExpression()), !dbg !20
+  %0 = load i32, ptr @"llvm.bar:8:1$0", align 4
+  %1 = tail call i32 @llvm.bpf.passthrough.i32.i32(i32 0, i32 %0)
+  %conv = zext i32 %1 to i64, !dbg !21
+  store volatile i64 %conv, ptr @g, align 8, !dbg !22, !tbaa !23
+  %2 = load i32, ptr @"llvm.bar:9:0$0", align 4
+  %3 = tail call i32 @llvm.bpf.passthrough.i32.i32(i32 1, i32 %2)
+  %conv1 = zext i32 %3 to i64, !dbg !27
+  store volatile i64 %conv1, ptr @g, align 8, !dbg !28, !tbaa !23
+  %4 = load i32, ptr @"llvm.bar:12:1$0", align 4
+  %5 = tail call i32 @llvm.bpf.passthrough.i32.i32(i32 2, i32 %4)
+  %conv2 = zext i32 %5 to i64, !dbg !29
+  store volatile i64 %conv2, ptr @g, align 8, !dbg !30, !tbaa !23
+  ret void, !dbg !31
+}
+
+; Function Attrs: nofree nosync nounwind memory(none)
+declare i32 @llvm.bpf.passthrough.i32.i32(i32, i32) #2
+
+; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
+declare void @llvm.dbg.value(metadata, metadata, metadata) #3
+
+attributes #0 = { "btf_ama" }
+attributes #1 = { nofree nounwind memory(readwrite, argmem: none) "frame-pointer"="all" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+attributes #2 = { nofree nosync nounwind memory(none) }
+attributes #3 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!9, !10, !11, !12}
+!llvm.ident = !{!13}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "g", scope: !2, file: !3, line: 4, type: !5, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C11, file: !3, producer: "clang version 17.0.0 (/home/eddy/work/llvm-project/clang 2f8c5c0afd1d79a771dd74c8fb1e5bbae6d04eb7)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, globals: !4, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "t.c", directory: "/home/eddy/work/tmp", checksumkind: CSK_MD5, checksum: "5bf218e82301e866fa302fd927913bcf")
+!4 = !{!0}
+!5 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !6)
+!6 = !DIBasicType(name: "unsigned long", size: 64, encoding: DW_ATE_unsigned)
+!7 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "bar", file: !3, line: 3, elements: !8)
+!8 = !{}
+!9 = !{i32 7, !"Dwarf Version", i32 5}
+!10 = !{i32 2, !"Debug Info Version", i32 3}
+!11 = !{i32 1, !"wchar_size", i32 4}
+!12 = !{i32 7, !"frame-pointer", i32 2}
+!13 = !{!"clang version 17.0.0 (/home/eddy/work/llvm-project/clang 2f8c5c0afd1d79a771dd74c8fb1e5bbae6d04eb7)"}
+!14 = distinct !DISubprogram(name: "root", scope: !3, file: !3, line: 5, type: !15, scopeLine: 5, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !17)
+!15 = !DISubroutineType(types: !16)
+!16 = !{null}
+!17 = !{!18}
+!18 = !DILocalVariable(name: "bar", scope: !14, file: !3, line: 6, type: !19)
+!19 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!20 = !DILocation(line: 0, scope: !14)
+!21 = !DILocation(line: 7, column: 7, scope: !14)
+!22 = !DILocation(line: 7, column: 5, scope: !14)
+!23 = !{!24, !24, i64 0}
+!24 = !{!"long", !25, i64 0}
+!25 = !{!"omnipotent char", !26, i64 0}
+!26 = !{!"Simple C/C++ TBAA"}
+!27 = !DILocation(line: 8, column: 7, scope: !14)
+!28 = !DILocation(line: 8, column: 5, scope: !14)
+!29 = !DILocation(line: 9, column: 7, scope: !14)
+!30 = !DILocation(line: 9, column: 5, scope: !14)
+!31 = !DILocation(line: 10, column: 1, scope: !14)

llvm/tools/llvm-objdump/llvm-objdump.cpp

 //===-- llvm-objdump.cpp - Object file dumping utility for llvm -----------===//
 //
 // 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 "XCOFFDump.h"
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/DebugInfo/BTF/BTFParser.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/Debuginfod/BuildIDFetcher.h"
 #include "llvm/Debuginfod/Debuginfod.h"
 #include "llvm/Debuginfod/HTTPClient.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/MC/MCAsmInfo.h"
if (!Comments.empty()) {
       FOS << MAI.getCommentString() << ' ' << Comment;
     }
     LVP.printAfterInst(FOS);
     FOS << '\n';
   } while (!Comments.empty());
   FOS.flush();
 }
 
+static void emitBTFReloc(formatted_raw_ostream &FOS, llvm::BTFParser &BTF,
+                         object::SectionedAddress Address,
+                         LiveVariablePrinter &LVP) {
+  llvm::BTF::BPFFieldReloc *Reloc = BTF.findFieldReloc(Address);
+  if (!Reloc)
+    return;
+
+  FOS << (LeadingAddr ? "\t\t" : "\t");
+  FOS << "CO-RE relo: " << BTF.symbolize(Reloc);
+  LVP.printAfterInst(FOS);
+  FOS << '\n';
+  FOS.flush();
+}
+
 static void createFakeELFSections(ObjectFile &Obj) {
   assert(Obj.isELF());
   if (auto *Elf32LEObj = dyn_cast<ELF32LEObjectFile>(&Obj))
     Elf32LEObj->createFakeSections();
   else if (auto *Elf64LEObj = dyn_cast<ELF64LEObjectFile>(&Obj))
     Elf64LEObj->createFakeSections();
   else if (auto *Elf32BEObj = dyn_cast<ELF32BEObjectFile>(&Obj))
     Elf32BEObj->createFakeSections();
auto ReadBBAddrMap = [&](std::optional<unsigned> SectionIndex =
     }
   };
 
   // For non-relocatable objects, Read all LLVM_BB_ADDR_MAP sections into a
   // single mapping, since they don't have any conflicts.
   if (SymbolizeOperands && !Obj.isRelocatableObject())
     ReadBBAddrMap();
 
+  std::unique_ptr<llvm::BTFParser> BTF;
+  if (InlineRelocs && BTFParser::hasBTFSections(Obj)) {
+    BTF.reset(new llvm::BTFParser());
+    BTFParser::ParseOptions Opts = {};
+    Opts.LoadTypes = true;
+    Opts.LoadRelocs = true;
+    if (Error E = BTF->parse(Obj, Opts))
+      WithColor::defaultErrorHandler(std::move(E));
+  }
+
   for (const SectionRef &Section : ToolSectionFilter(Obj)) {
     if (FilterSections.empty() && !DisassembleAll &&
         (!Section.isText() || Section.isVirtual()))
       continue;
 
     uint64_t SectionAddr = Section.getAddress();
     uint64_t SectSize = Section.getSize();
     if (!SectSize)
for (size_t SI = 0, SE = Symbols.size(); SI != SE;) {
           }
         }
 
         assert(Ctx.getAsmInfo());
         emitPostInstructionInfo(FOS, *Ctx.getAsmInfo(), *STI,
                                 CommentStream.str(), LVP);
         Comments.clear();
 
+        if (BTF)
+          emitBTFReloc(FOS, *BTF, {Index, Section.getIndex()}, LVP);
+
         // Hexagon does this in pretty printer
         if (Obj.getArch() != Triple::hexagon) {
           // Print relocation for instruction and data.
           while (RelCur != RelEnd) {
             uint64_t Offset = RelCur->getOffset() - RelAdjustment;
             // If this relocation is hidden, skip it.
             if (getHidden(*RelCur) || SectionAddr + Offset < StartAddress) {
               ++RelCur;

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
 //
 //===----------------------------------------------------------------------===//
 

 // 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 Line1[11] = "first line";
       char Line2[12] = "second line";
       char File1[4] = "a.c";
       char File2[4] = "b.c";
     } Strings;
TEST(BTFParserTest, badSectionNameOffset) {
   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}));
 }
 
-static void parseError(MockData1 &Mock, const char *Message) {
+static void parseError(ObjectFile &Obj, const char *Message) {
   BTFParser BTF;
-  EXPECT_THAT_ERROR(BTF.parse(Mock.makeObj()),
+  EXPECT_THAT_ERROR(BTF.parse(Obj),
                     FailedWithMessage(testing::HasSubstr(Message)));
 }
 
+static void parseError(MockData1 &Mock, const char *Message) {
+  parseError(Mock.makeObj(), Message);
+}
+
 TEST(BTFParserTest, badBTFMagic) {
   MockData1 Mock;
   Mock.BTF.Header.Magic = 42;
   parseError(Mock, "invalid .BTF magic: 2a");
 }
 
 TEST(BTFParserTest, badBTFVersion) {
   MockData1 Mock;
TEST(BTFParserTest, btfContext) {
 
   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);
 }
 
+#define KIND(Kind) ((Kind) << 24)
+
+template <typename T> static void append(std::string &S, const T &What) {
+  S.append((const char *)&What, sizeof(What));
+}
+
+class MockData2 {
+  SmallString<0> ObjStorage;
+  std::unique_ptr<ObjectFile> Obj;
+  std::string Types;
+  std::string Strings;
+  std::string Relocs;
+  std::string Lines;
+  unsigned TotalTypes;
+  int LastRelocSecIdx;
+  unsigned NumRelocs;
+  int LastLineSecIdx;
+  unsigned NumLines;
+
+public:
+  MockData2() { reset(); }
+
+  unsigned totalTypes() { return TotalTypes; }
+
+  uint32_t addString(StringRef S) {
+    uint32_t Off = Strings.size();
+    Strings.append(S.data(), S.size());
+    Strings.append("\0", 1);
+    return Off;
+  };
+
+  uint32_t addType(const BTF::CommonType &Tp) {
+    append(Types, Tp);
+    return ++TotalTypes;
+  }
+
+  template <typename T> void addTail(const T &Tp) { append(Types, Tp); }
+
+  void resetTypes() {
+    Types.resize(0);
+    TotalTypes = 0;
+  }
+
+  void reset() {
+    ObjStorage.resize(0);
+    Types.resize(0);
+    Strings.resize(0);
+    Relocs.resize(0);
+    Lines.resize(0);
+    TotalTypes = 0;
+    LastRelocSecIdx = -1;
+    NumRelocs = 0;
+    LastLineSecIdx = -1;
+    NumLines = 0;
+  }
+
+  void finishRelocSec() {
+    if (LastRelocSecIdx == -1)
+      return;
+
+    BTF::SecFieldReloc *SecInfo =
+        (BTF::SecFieldReloc *)&Relocs[LastRelocSecIdx];
+    SecInfo->NumFieldReloc = NumRelocs;
+    LastRelocSecIdx = -1;
+    NumRelocs = 0;
+  }
+
+  void finishLineSec() {
+    if (LastLineSecIdx == -1)
+      return;
+
+    BTF::SecLineInfo *SecInfo = (BTF::SecLineInfo *)&Lines[LastLineSecIdx];
+    SecInfo->NumLineInfo = NumLines;
+    NumLines = 0;
+    LastLineSecIdx = -1;
+  }
+
+  void addRelocSec(const BTF::SecFieldReloc &R) {
+    finishRelocSec();
+    LastRelocSecIdx = Relocs.size();
+    append(Relocs, R);
+  }
+
+  void addReloc(const BTF::BPFFieldReloc &R) {
+    append(Relocs, R);
+    ++NumRelocs;
+  }
+
+  void addLinesSec(const BTF::SecLineInfo &R) {
+    finishLineSec();
+    LastLineSecIdx = Lines.size();
+    append(Lines, R);
+  }
+
+  void addLine(const BTF::BPFLineInfo &R) {
+    append(Lines, R);
+    ++NumLines;
+  }
+
+  ObjectFile &makeObj() {
+    finishRelocSec();
+    finishLineSec();
+
+    BTF::Header BTFHeader = {};
+    BTFHeader.Magic = BTF::MAGIC;
+    BTFHeader.Version = 1;
+    BTFHeader.HdrLen = sizeof(BTFHeader);
+    BTFHeader.StrOff = 0;
+    BTFHeader.StrLen = Strings.size();
+    BTFHeader.TypeOff = Strings.size();
+    BTFHeader.TypeLen = Types.size();
+
+    std::string BTFSec;
+    append(BTFSec, BTFHeader);
+    BTFSec.append(Strings);
+    BTFSec.append(Types);
+
+    BTF::ExtHeader ExtHeader = {};
+    ExtHeader.Magic = BTF::MAGIC;
+    ExtHeader.Version = 1;
+    ExtHeader.HdrLen = sizeof(ExtHeader);
+    ExtHeader.FieldRelocOff = 0;
+    ExtHeader.FieldRelocLen = Relocs.size() + sizeof(uint32_t);
+    ExtHeader.LineInfoOff = ExtHeader.FieldRelocLen;
+    ExtHeader.LineInfoLen = Lines.size() + sizeof(uint32_t);
+
+    std::string ExtSec;
+    append(ExtSec, ExtHeader);
+    append(ExtSec, (uint32_t)sizeof(BTF::BPFFieldReloc));
+    ExtSec.append(Relocs);
+    append(ExtSec, (uint32_t)sizeof(BTF::BPFLineInfo));
+    ExtSec.append(Lines);
+
+    std::string YamlBuffer;
+    raw_string_ostream Yaml(YamlBuffer);
+    Yaml << R"(
+!ELF
+FileHeader:
+  Class:    ELFCLASS64
+  Data:     ELFDATA2LSB
+  Type:     ET_REL
+  Machine:  EM_BPF
+Sections:
+  - Name:     foo
+    Type:     SHT_PROGBITS
+    Size:     0x80
+  - Name:     bar
+    Type:     SHT_PROGBITS
+    Size:     0x80
+  - Name:     .BTF
+    Type:     SHT_PROGBITS
+    Content: )"
+         << makeBinRef(BTFSec.data(), BTFSec.size());
+    Yaml << R"(
+  - Name:     .BTF.ext
+    Type:     SHT_PROGBITS
+    Content: )"
+         << makeBinRef(ExtSec.data(), ExtSec.size());
+
+    Obj = yaml::yaml2ObjectFile(ObjStorage, YamlBuffer,
+                                [](const Twine &Err) { errs() << Err; });
+    return *Obj.get();
+  }
+};
+
+TEST(BTFParserTest, allTypeKinds) {
+  MockData2 D;
+
+  // won't work on big-endian machine?
+  D.addType({D.addString("1"), KIND(BTF::BTF_KIND_INT), {4}});
+  D.addTail((uint32_t)0);
+  D.addType({D.addString("2"), KIND(BTF::BTF_KIND_PTR), {1}});
+  D.addType({D.addString("3"), KIND(BTF::BTF_KIND_ARRAY), {0}});
+  D.addTail(BTF::BTFArray({1, 1, 2}));
+  D.addType({D.addString("4"), KIND(BTF::BTF_KIND_STRUCT) | 2, {8}});
+  D.addTail(BTF::BTFMember({D.addString("a"), 1, 0}));
+  D.addTail(BTF::BTFMember({D.addString("b"), 1, 0}));
+  D.addType({D.addString("5"), KIND(BTF::BTF_KIND_UNION) | 3, {8}});
+  D.addTail(BTF::BTFMember({D.addString("a"), 1, 0}));
+  D.addTail(BTF::BTFMember({D.addString("b"), 1, 0}));
+  D.addTail(BTF::BTFMember({D.addString("c"), 1, 0}));
+  D.addType({D.addString("6"), KIND(BTF::BTF_KIND_ENUM) | 2, {4}});
+  D.addTail(BTF::BTFEnum({D.addString("U"), 1}));
+  D.addTail(BTF::BTFEnum({D.addString("V"), 2}));
+  D.addType({D.addString("7"), KIND(BTF::BTF_KIND_ENUM64) | 1, {4}});
+  D.addTail(BTF::BTFEnum64({D.addString("W"), 0, 1}));
+  D.addType(
+      {D.addString("8"), BTF::FWD_UNION_FLAG | KIND(BTF::BTF_KIND_FWD), {0}});
+  D.addType({D.addString("9"), KIND(BTF::BTF_KIND_TYPEDEF), {1}});
+  D.addType({D.addString("10"), KIND(BTF::BTF_KIND_VOLATILE), {1}});
+  D.addType({D.addString("11"), KIND(BTF::BTF_KIND_CONST), {1}});
+  D.addType({D.addString("12"), KIND(BTF::BTF_KIND_RESTRICT), {1}});
+  D.addType({D.addString("13"), KIND(BTF::BTF_KIND_FUNC_PROTO) | 1, {1}});
+  D.addTail(BTF::BTFParam({D.addString("P"), 2}));
+  D.addType({D.addString("14"), KIND(BTF::BTF_KIND_FUNC), {13}});
+  D.addType({D.addString("15"), KIND(BTF::BTF_KIND_VAR), {2}});
+  D.addTail((uint32_t)0);
+  D.addType({D.addString("16"), KIND(BTF::BTF_KIND_DATASEC) | 3, {0}});
+  D.addTail(BTF::BTFDataSec({1, 0, 4}));
+  D.addTail(BTF::BTFDataSec({1, 4, 4}));
+  D.addTail(BTF::BTFDataSec({1, 8, 4}));
+  D.addType({D.addString("17"), KIND(BTF::BTF_KIND_FLOAT), {4}});
+  D.addType({D.addString("18"), KIND(BTF::BTF_KIND_DECL_TAG), {0}});
+  D.addTail((uint32_t)-1);
+  D.addType({D.addString("19"), KIND(BTF::BTF_KIND_TYPE_TAG), {0}});
+
+  BTFParser BTF;
+  Error Err = BTF.parse(D.makeObj());
+  EXPECT_FALSE(Err);
+
+  EXPECT_EQ(D.totalTypes() + 1 /* +1 for void */, BTF.typesCount());
+  for (unsigned Id = 1; Id < D.totalTypes() + 1; ++Id) {
+    const BTF::CommonType *Tp = BTF.findType(Id);
+    ASSERT_TRUE(Tp);
+    std::string IdBuf;
+    raw_string_ostream IdBufStream(IdBuf);
+    IdBufStream << Id;
+    EXPECT_EQ(BTF.findString(Tp->NameOff), IdBuf);
+  }
+}
+
+TEST(BTFParserTest, incompleteTypes) {
+  MockData2 D;
+  auto IncompleteType = [&](const BTF::CommonType &Tp) {
+    D.resetTypes();
+    D.addType(Tp);
+    parseError(D.makeObj(), "incomplete type definition in .BTF section");
+  };
+
+  // All kinds that need tail
+  IncompleteType({D.addString("a"), KIND(BTF::BTF_KIND_INT), {4}});
+  IncompleteType({D.addString("b"), KIND(BTF::BTF_KIND_ARRAY), {0}});
+  IncompleteType({D.addString("c"), KIND(BTF::BTF_KIND_VAR), {0}});
+  IncompleteType({D.addString("d"), KIND(BTF::BTF_KIND_DECL_TAG), {0}});
+
+  // All kinds with vlen
+  IncompleteType({D.addString("a"), KIND(BTF::BTF_KIND_STRUCT) | 2, {8}});
+  IncompleteType({D.addString("b"), KIND(BTF::BTF_KIND_UNION) | 3, {8}});
+  IncompleteType({D.addString("c"), KIND(BTF::BTF_KIND_ENUM) | 2, {4}});
+  IncompleteType({D.addString("d"), KIND(BTF::BTF_KIND_ENUM64) | 1, {4}});
+  IncompleteType({D.addString("e"), KIND(BTF::BTF_KIND_FUNC_PROTO) | 1, {1}});
+  IncompleteType({D.addString("f"), KIND(BTF::BTF_KIND_DATASEC) | 3, {0}});
+
+  // An unexpected tail
+  D.resetTypes();
+  D.addTail((uint32_t)0);
+  parseError(D.makeObj(), "incomplete type definition in .BTF section");
+}
+
+// Use macro to preserve line number in error message
+#define SYMBOLIZE(SecAddr, Expected)                                           \
+  do {                                                                         \
+    BTF::BPFFieldReloc *R = BTF.findFieldReloc((SecAddr));                     \
+    ASSERT_TRUE(R);                                                            \
+    EXPECT_EQ(BTF.symbolize(R), (Expected));                                   \
+  } while (false)
+
+// Shorter name for initializers below
+typedef SectionedAddress SA;
+
+TEST(BTFParserTest, typeRelocs) {
+  MockData2 D;
+  uint32_t EmptyString = D.addString("");
+  // id 1: struct foo {}
+  // id 2: union bar;
+  // id 3: struct buz;
+  D.addType({D.addString("foo"), KIND(BTF::BTF_KIND_STRUCT), {0}});
+  D.addType(
+      {D.addString("bar"), KIND(BTF::BTF_KIND_FWD) | BTF::FWD_UNION_FLAG, {0}});
+  D.addType({D.addString("buz"), KIND(BTF::BTF_KIND_FWD), {0}});
+  D.addRelocSec({D.addString("foo"), 7});
+  // List of all possible correct type relocations for type id #1
+  D.addReloc({0, 1, EmptyString, BTF::BTF_TYPE_ID_LOCAL});
+  D.addReloc({8, 1, EmptyString, BTF::BTF_TYPE_ID_REMOTE});
+  D.addReloc({16, 1, EmptyString, BTF::TYPE_EXISTENCE});
+  D.addReloc({24, 1, EmptyString, BTF::TYPE_MATCH});
+  D.addReloc({32, 1, EmptyString, BTF::TYPE_SIZE});
+  // Forward declarations
+  D.addReloc({40, 2, EmptyString, BTF::TYPE_SIZE});
+  D.addReloc({48, 3, EmptyString, BTF::TYPE_SIZE});
+  // Incorrect type relocation: bad type id
+  D.addReloc({56, 42, EmptyString, BTF::TYPE_SIZE});
+
+  BTFParser BTF;
+  Error E = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E);
+
+  SYMBOLIZE(SA({0, 1}), "<local_type_id> [1] struct foo");
+  SYMBOLIZE(SA({8, 1}), "<target_type_id> [1] struct foo");
+  SYMBOLIZE(SA({16, 1}), "<type_exists> [1] struct foo");
+  SYMBOLIZE(SA({24, 1}), "<type_matches> [1] struct foo");
+  SYMBOLIZE(SA({32, 1}), "<type_size> [1] struct foo");
+  SYMBOLIZE(SA({40, 1}), "<type_size> [2] fwd union bar");
+  SYMBOLIZE(SA({48, 1}), "<type_size> [3] fwd struct buz");
+  SYMBOLIZE(SA({56, 1}), "<type_size> [42] '' <unknown type id: 42>");
+}
+
+TEST(BTFParserTest, enumRelocs) {
+  MockData2 D;
+  // id 1: enum { U, V }
+  D.addType({D.addString("foo"), KIND(BTF::BTF_KIND_ENUM) | 2, {4}});
+  D.addTail(BTF::BTFEnum({D.addString("U"), 1}));
+  D.addTail(BTF::BTFEnum({D.addString("V"), 2}));
+  // id 2: int
+  D.addType({D.addString("int"), KIND(BTF::BTF_KIND_INT), {4}});
+  D.addTail((uint32_t)0);
+  // id 3: enum: uint64_t { A, B }
+  D.addType({D.addString("bar"), KIND(BTF::BTF_KIND_ENUM64) | 2, {8}});
+  D.addTail(BTF::BTFEnum64({D.addString("A"), 1, 0}));
+  D.addTail(BTF::BTFEnum64({D.addString("B"), 2, 0}));
+
+  D.addRelocSec({D.addString("foo"), 5});
+  // An ok relocation accessing value #1: U
+  D.addReloc({0, 1, D.addString("0"), BTF::ENUM_VALUE_EXISTENCE});
+  // An ok relocation accessing value #2: V
+  D.addReloc({8, 1, D.addString("1"), BTF::ENUM_VALUE});
+  // Incorrect relocation: too many elements in string "1:0"
+  D.addReloc({16, 1, D.addString("1:0"), BTF::ENUM_VALUE});
+  // Incorrect relocation: type id "2" is not an enum
+  D.addReloc({24, 2, D.addString("1"), BTF::ENUM_VALUE});
+  // Incorrect relocation: value #42 does not exist for enum "foo"
+  D.addReloc({32, 1, D.addString("42"), BTF::ENUM_VALUE});
+  // An ok relocation accessing value #1: A
+  D.addReloc({40, 3, D.addString("0"), BTF::ENUM_VALUE_EXISTENCE});
+  // An ok relocation accessing value #2: B
+  D.addReloc({48, 3, D.addString("1"), BTF::ENUM_VALUE});
+
+  BTFParser BTF;
+  Error E = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E);
+
+  SYMBOLIZE(SA({0, 1}), "<enumval_exists> [1] enum foo::U = 1");
+  SYMBOLIZE(SA({8, 1}), "<enumval_value> [1] enum foo::V = 2");
+  SYMBOLIZE(SA({16, 1}),
+            "<enumval_value> [1] '1:0' <unexpected enumval relo spec size>");
+  SYMBOLIZE(SA({24, 1}),
+            "<enumval_value> [2] '1' <unexpected type kind for enum relo: 1>");
+  SYMBOLIZE(SA({32, 1}), "<enumval_value> [1] '42' <bad value index: 42>");
+  SYMBOLIZE(SA({40, 1}), "<enumval_exists> [3] enum bar::A = 1");
+  SYMBOLIZE(SA({48, 1}), "<enumval_value> [3] enum bar::B = 2");
+}
+
+TEST(BTFParserTest, enumRelocsMods) {
+  MockData2 D;
+  // id 1: enum { U, V }
+  D.addType({D.addString("foo"), KIND(BTF::BTF_KIND_ENUM) | 2, {4}});
+  D.addTail(BTF::BTFEnum({D.addString("U"), 1}));
+  D.addTail(BTF::BTFEnum({D.addString("V"), 2}));
+  // id 2: typedef enum foo a;
+  D.addType({D.addString("a"), KIND(BTF::BTF_KIND_TYPEDEF), {1}});
+  // id 3: const enum foo
+  D.addType({D.addString(""), KIND(BTF::BTF_KIND_CONST), {1}});
+
+  D.addRelocSec({D.addString("foo"), 0});
+  D.addReloc({0, 2, D.addString("0"), BTF::ENUM_VALUE});
+  D.addReloc({8, 3, D.addString("1"), BTF::ENUM_VALUE});
+
+  BTFParser BTF;
+  Error E = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E);
+
+  SYMBOLIZE(SA({0, 1}), "<enumval_value> [2] typedef a::U = 1");
+  SYMBOLIZE(SA({8, 1}), "<enumval_value> [3] const enum foo::V = 2");
+}
+
+TEST(BTFParserTest, fieldRelocs) {
+  MockData2 D;
+  // id 1: int
+  D.addType({D.addString("int"), KIND(BTF::BTF_KIND_INT), {4}});
+  D.addTail((uint32_t)0);
+  // id 2: struct foo { int a; int b; }
+  D.addType({D.addString("foo"), KIND(BTF::BTF_KIND_STRUCT) | 2, {8}});
+  D.addTail(BTF::BTFMember({D.addString("a"), 1, 0}));
+  D.addTail(BTF::BTFMember({D.addString("b"), 1, 0}));
+  // id 3: array of struct foo
+  D.addType({D.addString(""), KIND(BTF::BTF_KIND_ARRAY), {0}});
+  D.addTail(BTF::BTFArray({2, 1, 2}));
+  // id 4: struct bar { struct foo u[2]; int v; }
+  D.addType({D.addString("bar"), KIND(BTF::BTF_KIND_STRUCT) | 2, {8}});
+  D.addTail(BTF::BTFMember({D.addString("u"), 3, 0}));
+  D.addTail(BTF::BTFMember({D.addString("v"), 1, 0}));
+  // id 5: array with bad element type id
+  D.addType({D.addString(""), KIND(BTF::BTF_KIND_ARRAY), {0}});
+  D.addTail(BTF::BTFArray({42, 1, 2}));
+  // id 6: struct buz { <bad type> u[2]; <bad type> v; }
+  D.addType({D.addString("bar"), KIND(BTF::BTF_KIND_STRUCT) | 2, {8}});
+  D.addTail(BTF::BTFMember({D.addString("u"), 5, 0}));
+  D.addTail(BTF::BTFMember({D.addString("v"), 42, 0}));
+
+  D.addRelocSec({D.addString("foo"), 0 /* patched automatically */});
+  // All field relocations kinds for struct bar::v
+  D.addReloc({0, 4, D.addString("0:1"), BTF::FIELD_BYTE_OFFSET});
+  D.addReloc({8, 4, D.addString("0:1"), BTF::FIELD_BYTE_SIZE});
+  D.addReloc({16, 4, D.addString("0:1"), BTF::FIELD_EXISTENCE});
+  D.addReloc({24, 4, D.addString("0:1"), BTF::FIELD_SIGNEDNESS});
+  D.addReloc({32, 4, D.addString("0:1"), BTF::FIELD_LSHIFT_U64});
+  D.addReloc({40, 4, D.addString("0:1"), BTF::FIELD_RSHIFT_U64});
+  // Non-zero first idx
+  D.addReloc({48, 4, D.addString("7:1"), BTF::FIELD_BYTE_OFFSET});
+  // Access through array and struct: struct bar::u[1].a
+  D.addReloc({56, 4, D.addString("0:0:1:0"), BTF::FIELD_BYTE_OFFSET});
+  // Access through array and struct: struct bar::u[1].b
+  D.addReloc({64, 4, D.addString("0:0:1:1"), BTF::FIELD_BYTE_OFFSET});
+  // Incorrect relocation: empty access string
+  D.addReloc({72, 4, D.addString(""), BTF::FIELD_BYTE_OFFSET});
+  // Incorrect relocation: member index out of range (only two members in bar)
+  D.addReloc({80, 4, D.addString("0:2"), BTF::FIELD_BYTE_OFFSET});
+  // Incorrect relocation: unknown element type id (buz::u[0] access)
+  D.addReloc({88, 6, D.addString("0:0:0"), BTF::FIELD_BYTE_OFFSET});
+  // Incorrect relocation: unknown member type id (buz::v access)
+  D.addReloc({96, 6, D.addString("0:1:0"), BTF::FIELD_BYTE_OFFSET});
+  // Incorrect relocation: non structural type in the middle of access string
+  //   struct bar::v.<something>
+  D.addReloc({104, 4, D.addString("0:1:0"), BTF::FIELD_BYTE_OFFSET});
+
+  BTFParser BTF;
+  Error E = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E);
+
+  SYMBOLIZE(SA({0, 1}), "<byte_off> [4] struct bar::v (0:1)");
+  SYMBOLIZE(SA({8, 1}), "<byte_sz> [4] struct bar::v (0:1)");
+  SYMBOLIZE(SA({16, 1}), "<field_exists> [4] struct bar::v (0:1)");
+  SYMBOLIZE(SA({24, 1}), "<signed> [4] struct bar::v (0:1)");
+  SYMBOLIZE(SA({32, 1}), "<lshift_u64> [4] struct bar::v (0:1)");
+  SYMBOLIZE(SA({40, 1}), "<rshift_u64> [4] struct bar::v (0:1)");
+  SYMBOLIZE(SA({48, 1}), "<byte_off> [4] struct bar::[7].v (7:1)");
+  SYMBOLIZE(SA({56, 1}), "<byte_off> [4] struct bar::u[1].a (0:0:1:0)");
+  SYMBOLIZE(SA({64, 1}), "<byte_off> [4] struct bar::u[1].b (0:0:1:1)");
+  SYMBOLIZE(SA({72, 1}), "<byte_off> [4] '' <field spec too short>");
+  SYMBOLIZE(SA({80, 1}),
+            "<byte_off> [4] '0:2' "
+            "<member index 2 for spec sub-string 1 is out of range>");
+  SYMBOLIZE(SA({88, 1}), "<byte_off> [6] '0:0:0' "
+                         "<unknown element type id 42 for spec sub-string 2>");
+  SYMBOLIZE(SA({96, 1}), "<byte_off> [6] '0:1:0' "
+                         "<unknown member type id 42 for spec sub-string 1>");
+  SYMBOLIZE(SA({104, 1}), "<byte_off> [4] '0:1:0' "
+                          "<unexpected type kind 1 for spec sub-string 2>");
+}
+
+TEST(BTFParserTest, fieldRelocsMods) {
+  MockData2 D;
+  // struct foo {
+  //   int u;
+  // }
+  // typedef struct foo bar;
+  // struct buz {
+  //   const bar v;
+  // }
+  // typedef buz quux;
+  // const volatile restrict quux <some-var>;
+  uint32_t Int = D.addType({D.addString("int"), KIND(BTF::BTF_KIND_INT), {4}});
+  D.addTail((uint32_t)0);
+  uint32_t Foo =
+      D.addType({D.addString("foo"), KIND(BTF::BTF_KIND_STRUCT) | 1, {4}});
+  D.addTail(BTF::BTFMember({D.addString("u"), Int, 0}));
+  uint32_t Bar =
+      D.addType({D.addString("bar"), KIND(BTF::BTF_KIND_TYPEDEF), {Foo}});
+  uint32_t CBar =
+      D.addType({D.addString("bar"), KIND(BTF::BTF_KIND_CONST), {Bar}});
+  uint32_t Buz =
+      D.addType({D.addString("buz"), KIND(BTF::BTF_KIND_STRUCT) | 1, {4}});
+  D.addTail(BTF::BTFMember({D.addString("v"), CBar, 0}));
+  uint32_t Quux =
+      D.addType({D.addString("quux"), KIND(BTF::BTF_KIND_TYPEDEF), {Buz}});
+  uint32_t RQuux =
+      D.addType({D.addString(""), KIND(BTF::BTF_KIND_RESTRICT), {Quux}});
+  uint32_t VRQuux =
+      D.addType({D.addString(""), KIND(BTF::BTF_KIND_VOLATILE), {RQuux}});
+  uint32_t CVRQuux =
+      D.addType({D.addString(""), KIND(BTF::BTF_KIND_CONST), {VRQuux}});
+
+  D.addRelocSec({D.addString("foo"), 0});
+  D.addReloc({0, Bar, D.addString("0:0"), BTF::FIELD_BYTE_OFFSET});
+  D.addReloc({8, CVRQuux, D.addString("0:0:0"), BTF::FIELD_BYTE_OFFSET});
+
+  BTFParser BTF;
+  Error E = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E);
+
+  // Should show modifiers / name of typedef
+  SYMBOLIZE(SA({0, 1}), "<byte_off> [3] typedef bar::u (0:0)");
+  SYMBOLIZE(SA({8, 1}),
+            "<byte_off> [9] const volatile restrict typedef quux::v.u (0:0:0)");
+}
+
+TEST(BTFParserTest, relocTypeTagAndVoid) {
+  MockData2 D;
+  // __attribute__((type_tag("tag"))) void
+  uint32_t Tag =
+      D.addType({D.addString("tag"), KIND(BTF::BTF_KIND_TYPE_TAG), {0}});
+
+  D.addRelocSec({D.addString("foo"), 0});
+  D.addReloc({0, Tag, D.addString(""), BTF::TYPE_EXISTENCE});
+  D.addReloc({8, 0 /* void */, D.addString(""), BTF::TYPE_EXISTENCE});
+
+  BTFParser BTF;
+  Error E = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E);
+
+  SYMBOLIZE(SA({0, 1}), "<type_exists> [1] type_tag(\"tag\") void");
+  SYMBOLIZE(SA({8, 1}), "<type_exists> [0] void");
+}
+
+TEST(BTFParserTest, longRelocModifiersCycle) {
+  MockData2 D;
+
+  D.addType({D.addString(""), KIND(BTF::BTF_KIND_CONST), {1 /* ourselves */}});
+  D.addRelocSec({D.addString("foo"), 0});
+  D.addReloc({0, 1, D.addString(""), BTF::TYPE_EXISTENCE});
+
+  BTFParser BTF;
+  Error E = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E);
+
+  SYMBOLIZE(SA({0, 1}), "<type_exists> [1] '' <modifiers chain is too long>");
+}
+
+TEST(BTFParserTest, relocAnonFieldsAndTypes) {
+  MockData2 D;
+
+  // struct {
+  //   int :32;
+  // } v;
+  uint32_t Int = D.addType({D.addString("int"), KIND(BTF::BTF_KIND_INT), {4}});
+  D.addTail((uint32_t)0);
+  uint32_t Anon =
+      D.addType({D.addString(""), KIND(BTF::BTF_KIND_STRUCT) | 1, {4}});
+  D.addTail(BTF::BTFMember({D.addString(""), Int, 0}));
+
+  D.addRelocSec({D.addString("foo"), 0});
+  D.addReloc({0, Anon, D.addString(""), BTF::TYPE_EXISTENCE});
+  D.addReloc({8, Anon, D.addString("0:0"), BTF::FIELD_BYTE_OFFSET});
+
+  BTFParser BTF;
+  Error E = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E);
+
+  SYMBOLIZE(SA({0, 1}), "<type_exists> [2] struct <anon 2>");
+  SYMBOLIZE(SA({8, 1}), "<byte_off> [2] struct <anon 2>::<anon 0> (0:0)");
+}
+
+TEST(BTFParserTest, miscBadRelos) {
+  MockData2 D;
+
+  uint32_t S = D.addType({D.addString("S"), KIND(BTF::BTF_KIND_STRUCT), {0}});
+
+  D.addRelocSec({D.addString("foo"), 0});
+  D.addReloc({0, 0, D.addString(""), 777});
+  D.addReloc({8, S, D.addString("abc"), BTF::FIELD_BYTE_OFFSET});
+  D.addReloc({16, S, D.addString("0#"), BTF::FIELD_BYTE_OFFSET});
+
+  BTFParser BTF;
+  Error E = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E);
+
+  SYMBOLIZE(SA({0, 1}), "<relo kind #777> [0] '' <unknown relo kind: 777>");
+  SYMBOLIZE(SA({8, 1}), "<byte_off> [1] 'abc' <spec string is not a number>");
+  SYMBOLIZE(SA({16, 1}),
+            "<byte_off> [1] '0#' <unexpected spec string delimiter: '#'>");
+}
+
+TEST(BTFParserTest, relocsMultipleSections) {
+  MockData2 D;
+
+  uint32_t S = D.addType({D.addString("S"), KIND(BTF::BTF_KIND_STRUCT), {0}});
+  uint32_t T = D.addType({D.addString("T"), KIND(BTF::BTF_KIND_STRUCT), {0}});
+
+  D.addRelocSec({D.addString("foo"), 0});
+  D.addReloc({0, S, D.addString(""), BTF::TYPE_EXISTENCE});
+  D.addReloc({8, S, D.addString(""), BTF::TYPE_EXISTENCE});
+
+  D.addRelocSec({D.addString("bar"), 0});
+  D.addReloc({8, T, D.addString(""), BTF::TYPE_EXISTENCE});
+  D.addReloc({16, T, D.addString(""), BTF::TYPE_EXISTENCE});
+
+  BTFParser BTF;
+  Error E = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E);
+
+  EXPECT_TRUE(BTF.findFieldReloc({0, 1}));
+  EXPECT_TRUE(BTF.findFieldReloc({8, 1}));
+  EXPECT_FALSE(BTF.findFieldReloc({16, 1}));
+
+  EXPECT_FALSE(BTF.findFieldReloc({0, 2}));
+  EXPECT_TRUE(BTF.findFieldReloc({8, 2}));
+  EXPECT_TRUE(BTF.findFieldReloc({16, 2}));
+
+  EXPECT_FALSE(BTF.findFieldReloc({0, 3}));
+  EXPECT_FALSE(BTF.findFieldReloc({8, 3}));
+  EXPECT_FALSE(BTF.findFieldReloc({16, 3}));
+
+  auto AssertReloType = [&](const SectionedAddress &A, const char *Name) {
+    BTF::BPFFieldReloc *Relo = BTF.findFieldReloc(A);
+    ASSERT_TRUE(Relo);
+    const BTF::CommonType *Type = BTF.findType(Relo->TypeID);
+    ASSERT_TRUE(Type);
+    ASSERT_EQ(BTF.findString(Type->NameOff), Name);
+  };
+
+  AssertReloType({8, 1}, "S");
+  AssertReloType({8, 2}, "T");
+}
+
+TEST(BTFParserTest, parserResetReloAndTypes) {
+  BTFParser BTF;
+  MockData2 D;
+
+  // First time: two types, two relos
+  D.addType({D.addString("foo"), KIND(BTF::BTF_KIND_STRUCT), {0}});
+  D.addType({D.addString("bar"), KIND(BTF::BTF_KIND_STRUCT), {0}});
+  D.addRelocSec({D.addString("foo"), 0});
+  D.addReloc({0, 1, D.addString(""), BTF::TYPE_EXISTENCE});
+  D.addReloc({8, 2, D.addString(""), BTF::TYPE_EXISTENCE});
+
+  Error E1 = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E1);
+
+  ASSERT_TRUE(BTF.findType(1));
+  EXPECT_EQ(BTF.findString(BTF.findType(1)->NameOff), "foo");
+  EXPECT_TRUE(BTF.findType(2));
+  EXPECT_TRUE(BTF.findFieldReloc({0, 1}));
+  EXPECT_TRUE(BTF.findFieldReloc({8, 1}));
+
+  // Second time: one type, one relo
+  D.reset();
+  D.addType({D.addString("buz"), KIND(BTF::BTF_KIND_STRUCT), {0}});
+  D.addRelocSec({D.addString("foo"), 0});
+  D.addReloc({0, 1, D.addString(""), BTF::TYPE_EXISTENCE});
+
+  Error E2 = BTF.parse(D.makeObj());
+  EXPECT_FALSE(E2);
+
+  ASSERT_TRUE(BTF.findType(1));
+  EXPECT_EQ(BTF.findString(BTF.findType(1)->NameOff), "buz");
+  EXPECT_FALSE(BTF.findType(2));
+  EXPECT_TRUE(BTF.findFieldReloc({0, 1}));
+  EXPECT_FALSE(BTF.findFieldReloc({8, 1}));
+}
+
+TEST(BTFParserTest, selectiveLoad) {
+  BTFParser BTF1, BTF2, BTF3;
+  MockData2 D;
+
+  D.addType({D.addString("foo"), KIND(BTF::BTF_KIND_STRUCT), {0}});
+  D.addRelocSec({D.addString("foo"), 0});
+  D.addReloc({0, 1, D.addString(""), BTF::TYPE_EXISTENCE});
+  D.addLinesSec({D.addString("foo"), 0});
+  D.addLine({0, D.addString("file.c"), D.addString("some line"), LC(2, 3)});
+
+  BTFParser::ParseOptions Opts;
+
+  ObjectFile &Obj1 = D.makeObj();
+  Opts = {};
+  Opts.LoadLines = true;
+  Error E1 = BTF1.parse(Obj1, Opts);
+  ASSERT_FALSE(E1);
+
+  Opts = {};
+  Opts.LoadTypes = true;
+  Error E2 = BTF2.parse(Obj1, Opts);
+  ASSERT_FALSE(E2);
+
+  Opts = {};
+  Opts.LoadRelocs = true;
+  Error E3 = BTF3.parse(Obj1, Opts);
+  ASSERT_FALSE(E3);
+
+  ASSERT_TRUE(BTF1.findLineInfo({0, 1}));
+  ASSERT_FALSE(BTF2.findLineInfo({0, 1}));
+  ASSERT_FALSE(BTF3.findLineInfo({0, 1}));
+
+  ASSERT_FALSE(BTF1.findType(1));
+  ASSERT_TRUE(BTF2.findType(1));
+  ASSERT_FALSE(BTF3.findType(1));
+
+  ASSERT_FALSE(BTF1.findFieldReloc({0, 1}));
+  ASSERT_FALSE(BTF2.findFieldReloc({0, 1}));
+  ASSERT_TRUE(BTF3.findFieldReloc({0, 1}));
+}
+
 } // namespace