src/llvm-project/llvm/unittests/DebugInfo/BTF/BTFParserTest.cpp - toolchain/rustc - Git at Google

 //===-- SourcePrinter.cpp -  source interleaving utilities ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #include "llvm/DebugInfo/BTF/BTFContext.h"
 #include "llvm/ObjectYAML/YAML.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/SwapByteOrder.h"
 #include "llvm/Testing/Support/Error.h"

 using namespace llvm;
 using namespace llvm::object;

 #define LC(Line, Col) ((Line << 10u) | Col)

 const char BTFEndOfData[] =
     "error while reading .BTF section: unexpected end of data";
 const char BTFExtEndOfData[] =
     "error while reading .BTF.ext section: unexpected end of data";

 static raw_ostream &operator<<(raw_ostream &OS, const yaml::BinaryRef &Ref) {
   Ref.writeAsHex(OS);
   return OS;
 }

 template <typename T>
 static yaml::BinaryRef makeBinRef(const T *Ptr, size_t Size = sizeof(T)) {
   return yaml::BinaryRef(ArrayRef<uint8_t>((const uint8_t *)Ptr, Size));
 }

 namespace {
 // This is a mockup for an ELF file containing .BTF and .BTF.ext sections.
 // Binary content of these sections corresponds to the value of
 // MockData1::BTF and MockData1::Ext fields.
 //
 // The yaml::yaml2ObjectFile() is used to generate actual ELF,
 // see MockData1::makeObj().
 //
 // The `BTF` and `Ext` fields are initialized with correct values
 // valid for a small example with a few sections, fields could be
 // modified before a call to `makeObj()` to test parser with invalid
 // input, etc.

 struct MockData1 {
 // Use "pragma pack" to model .BTF & .BTF.ext sections content using
 // 'struct' objects. This pragma is supported by CLANG, GCC & MSVC,
 // which matters for LLVM CI.
 #pragma pack(push, 1)
   struct B {
     BTF::Header Header = {};
     // no types
     struct S {
       char Foo[4] = "foo";
       char Bar[4] = "bar";
       char Buz[4] = "buz";
       char Line1[11] = "first line";
       char Line2[12] = "second line";
       char File1[4] = "a.c";
       char File2[4] = "b.c";
     } Strings;

     B() {
       Header.Magic = BTF::MAGIC;
       Header.Version = 1;
       Header.HdrLen = sizeof(Header);
       Header.StrOff = offsetof(B, Strings) - sizeof(Header);
       Header.StrLen = sizeof(Strings);
     }
   } BTF;

   struct E {
     BTF::ExtHeader Header = {};
     // no func info
     struct {
       uint32_t LineRecSize = sizeof(BTF::BPFLineInfo);
       struct {
         BTF::SecLineInfo Sec = {offsetof(B::S, Foo), 2};
         BTF::BPFLineInfo Lines[2] = {
             {16, offsetof(B::S, File1), offsetof(B::S, Line1), LC(7, 1)},
             {32, offsetof(B::S, File1), offsetof(B::S, Line2), LC(14, 5)},
         };
       } Foo;
       struct {
         BTF::SecLineInfo Sec = {offsetof(B::S, Bar), 1};
         BTF::BPFLineInfo Lines[1] = {
             {0, offsetof(B::S, File2), offsetof(B::S, Line1), LC(42, 4)},
         };
       } Bar;
     } Lines;

     E() {
       Header.Magic = BTF::MAGIC;
       Header.Version = 1;
       Header.HdrLen = sizeof(Header);
       Header.LineInfoOff = offsetof(E, Lines) - sizeof(Header);
       Header.LineInfoLen = sizeof(Lines);
     }
   } Ext;
 #pragma pack(pop)

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

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

   ObjectFile &makeObj() {
     std::string Buffer;
     raw_string_ostream Yaml(Buffer);
     Yaml << R"(
 !ELF
 FileHeader:
   Class:    ELFCLASS64)";
     if (sys::IsBigEndianHost)
       Yaml << "\n  Data:     ELFDATA2MSB";
     else
       Yaml << "\n  Data:     ELFDATA2LSB";
     Yaml << R"(
   Type:     ET_REL
   Machine:  EM_BPF
 Sections:
   - Name:     foo
     Type:     SHT_PROGBITS
     Size:     0x0
   - Name:     bar
     Type:     SHT_PROGBITS
     Size:     0x0)";

     if (BTFSectionLen >= 0)
       Yaml << R"(
   - Name:     .BTF
     Type:     SHT_PROGBITS
     Content: )"
            << makeBinRef(&BTF, BTFSectionLen);

     if (ExtSectionLen >= 0)
       Yaml << R"(
   - Name:     .BTF.ext
     Type:     SHT_PROGBITS
     Content: )"
            << makeBinRef(&Ext, ExtSectionLen);

     Obj = yaml::yaml2ObjectFile(Storage, Buffer,
                                 [](const Twine &Err) { errs() << Err; });
     return *Obj.get();
   }
 };

 TEST(BTFParserTest, simpleCorrectInput) {
   BTFParser BTF;
   MockData1 Mock;
   Error Err = BTF.parse(Mock.makeObj());
   EXPECT_FALSE(Err);

   EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Foo)), "foo");
   EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Bar)), "bar");
   EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Line1)), "first line");
   EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Line2)), "second line");
   EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, File1)), "a.c");
   EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, File2)), "b.c");

   // Invalid offset
   EXPECT_EQ(BTF.findString(sizeof(MockData1::B::S)), StringRef());

   const BTF::BPFLineInfo *I1 = BTF.findLineInfo({16, 1});
   ASSERT_TRUE(I1);
   EXPECT_EQ(I1->getLine(), 7u);
   EXPECT_EQ(I1->getCol(), 1u);
   EXPECT_EQ(BTF.findString(I1->FileNameOff), "a.c");
   EXPECT_EQ(BTF.findString(I1->LineOff), "first line");

   const BTF::BPFLineInfo *I2 = BTF.findLineInfo({32, 1});
   ASSERT_TRUE(I2);
   EXPECT_EQ(I2->getLine(), 14u);
   EXPECT_EQ(I2->getCol(), 5u);
   EXPECT_EQ(BTF.findString(I2->FileNameOff), "a.c");
   EXPECT_EQ(BTF.findString(I2->LineOff), "second line");

   const BTF::BPFLineInfo *I3 = BTF.findLineInfo({0, 2});
   ASSERT_TRUE(I3);
   EXPECT_EQ(I3->getLine(), 42u);
   EXPECT_EQ(I3->getCol(), 4u);
   EXPECT_EQ(BTF.findString(I3->FileNameOff), "b.c");
   EXPECT_EQ(BTF.findString(I3->LineOff), "first line");

   // No info for insn address
   EXPECT_FALSE(BTF.findLineInfo({24, 1}));
   EXPECT_FALSE(BTF.findLineInfo({8, 2}));
   // No info for section number
   EXPECT_FALSE(BTF.findLineInfo({16, 3}));
 }

 TEST(BTFParserTest, badSectionNameOffset) {
   BTFParser BTF;
   MockData1 Mock;
   // "foo" is section #1, corrupting it's name offset will make impossible
   // to match section name with section index when BTF is parsed.
   Mock.Ext.Lines.Foo.Sec.SecNameOff = 100500;
   Error Err = BTF.parse(Mock.makeObj());
   EXPECT_FALSE(Err);
   // "foo" line info should be corrupted
   EXPECT_FALSE(BTF.findLineInfo({16, 1}));
   // "bar" line info should be ok
   EXPECT_TRUE(BTF.findLineInfo({0, 2}));
 }

 // Keep this as macro to preserve line number info
 #define EXPECT_PARSE_ERROR(Mock, Message)                                      \
   do {                                                                         \
     BTFParser BTF;                                                             \
     EXPECT_THAT_ERROR(BTF.parse((Mock).makeObj()),                             \
                       FailedWithMessage(testing::HasSubstr(Message)));         \
   } while (false)

 TEST(BTFParserTest, badBTFMagic) {
   MockData1 Mock;
   Mock.BTF.Header.Magic = 42;
   EXPECT_PARSE_ERROR(Mock, "invalid .BTF magic: 2a");
 }

 TEST(BTFParserTest, badBTFVersion) {
   MockData1 Mock;
   Mock.BTF.Header.Version = 42;
   EXPECT_PARSE_ERROR(Mock, "unsupported .BTF version: 42");
 }

 TEST(BTFParserTest, badBTFHdrLen) {
   MockData1 Mock;
   Mock.BTF.Header.HdrLen = 5;
   EXPECT_PARSE_ERROR(Mock, "unexpected .BTF header length: 5");
 }

 TEST(BTFParserTest, badBTFSectionLen) {
   MockData1 Mock1, Mock2;

   // Cut-off string section by one byte
   Mock1.BTFSectionLen =
       offsetof(MockData1::B, Strings) + sizeof(MockData1::B::S) - 1;
   EXPECT_PARSE_ERROR(Mock1, "invalid .BTF section size");

   // Cut-off header
   Mock2.BTFSectionLen = offsetof(BTF::Header, StrOff);
   EXPECT_PARSE_ERROR(Mock2, BTFEndOfData);
 }

 TEST(BTFParserTest, badBTFExtMagic) {
   MockData1 Mock;
   Mock.Ext.Header.Magic = 42;
   EXPECT_PARSE_ERROR(Mock, "invalid .BTF.ext magic: 2a");
 }

 TEST(BTFParserTest, badBTFExtVersion) {
   MockData1 Mock;
   Mock.Ext.Header.Version = 42;
   EXPECT_PARSE_ERROR(Mock, "unsupported .BTF.ext version: 42");
 }

 TEST(BTFParserTest, badBTFExtHdrLen) {
   MockData1 Mock1, Mock2;

   Mock1.Ext.Header.HdrLen = 5;
   EXPECT_PARSE_ERROR(Mock1, "unexpected .BTF.ext header length: 5");

   Mock2.Ext.Header.HdrLen = sizeof(Mock2.Ext);
   EXPECT_PARSE_ERROR(Mock2, BTFExtEndOfData);
 }

 TEST(BTFParserTest, badBTFExtSectionLen) {
   MockData1 Mock1, Mock2, Mock3;

   // Cut-off header before HdrLen
   Mock1.ExtSectionLen = offsetof(BTF::ExtHeader, HdrLen);
   EXPECT_PARSE_ERROR(Mock1, BTFExtEndOfData);

   // Cut-off header before LineInfoLen
   Mock2.ExtSectionLen = offsetof(BTF::ExtHeader, LineInfoLen);
   EXPECT_PARSE_ERROR(Mock2, BTFExtEndOfData);

   // Cut-off line-info section somewhere in the middle
   Mock3.ExtSectionLen = offsetof(MockData1::E, Lines) + 4;
   EXPECT_PARSE_ERROR(Mock3, BTFExtEndOfData);
 }

 TEST(BTFParserTest, badBTFExtLineInfoRecSize) {
   MockData1 Mock1, Mock2;

   Mock1.Ext.Lines.LineRecSize = 2;
   EXPECT_PARSE_ERROR(Mock1, "unexpected .BTF.ext line info record length: 2");

   Mock2.Ext.Lines.LineRecSize = sizeof(Mock2.Ext.Lines.Foo.Lines[0]) + 1;
   EXPECT_PARSE_ERROR(Mock2, BTFExtEndOfData);
 }

 TEST(BTFParserTest, badBTFExtLineSectionName) {
   MockData1 Mock1;

   Mock1.Ext.Lines.Foo.Sec.SecNameOff = offsetof(MockData1::B::S, Buz);
   EXPECT_PARSE_ERROR(
       Mock1, "can't find section 'buz' while parsing .BTF.ext line info");
 }

 TEST(BTFParserTest, missingSections) {
   MockData1 Mock1, Mock2, Mock3;

   Mock1.BTFSectionLen = -1;
   EXPECT_PARSE_ERROR(Mock1, "can't find .BTF section");
   EXPECT_FALSE(BTFParser::hasBTFSections(Mock1.makeObj()));

   Mock2.ExtSectionLen = -1;
   EXPECT_PARSE_ERROR(Mock2, "can't find .BTF.ext section");
   EXPECT_FALSE(BTFParser::hasBTFSections(Mock2.makeObj()));

   EXPECT_TRUE(BTFParser::hasBTFSections(Mock3.makeObj()));
 }

 // Check that BTFParser instance is reset when BTFParser::parse() is
 // called several times.
 TEST(BTFParserTest, parserReset) {
   BTFParser BTF;
   MockData1 Mock1, Mock2;

   EXPECT_FALSE(BTF.parse(Mock1.makeObj()));
   EXPECT_TRUE(BTF.findLineInfo({16, 1}));
   EXPECT_TRUE(BTF.findLineInfo({0, 2}));

   // Break the reference to "bar" section name, thus making
   // information about "bar" line numbers unavailable.
   Mock2.Ext.Lines.Bar.Sec.SecNameOff = 100500;

   EXPECT_FALSE(BTF.parse(Mock2.makeObj()));
   EXPECT_TRUE(BTF.findLineInfo({16, 1}));
   // Make sure that "bar" no longer available (its index is 2).
   EXPECT_FALSE(BTF.findLineInfo({0, 2}));
 }

 TEST(BTFParserTest, btfContext) {
   MockData1 Mock;
   BTFParser BTF;
   std::unique_ptr<BTFContext> Ctx = BTFContext::create(Mock.makeObj());

   DILineInfo I1 = Ctx->getLineInfoForAddress({16, 1});
   EXPECT_EQ(I1.Line, 7u);
   EXPECT_EQ(I1.Column, 1u);
   EXPECT_EQ(I1.FileName, "a.c");
   EXPECT_EQ(I1.LineSource, "first line");

   DILineInfo I2 = Ctx->getLineInfoForAddress({24, 1});
   EXPECT_EQ(I2.Line, 0u);
   EXPECT_EQ(I2.Column, 0u);
   EXPECT_EQ(I2.FileName, DILineInfo::BadString);
   EXPECT_EQ(I2.LineSource, std::nullopt);
 }

 } // namespace
	//===-- SourcePrinter.cpp - source interleaving utilities ----------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#include "llvm/DebugInfo/BTF/BTFContext.h"
	#include "llvm/ObjectYAML/YAML.h"
	#include "llvm/ObjectYAML/yaml2obj.h"
	#include "llvm/Support/SwapByteOrder.h"
	#include "llvm/Testing/Support/Error.h"

	using namespace llvm;
	using namespace llvm::object;

	#define LC(Line, Col) ((Line << 10u) \| Col)

	const char BTFEndOfData[] =
	"error while reading .BTF section: unexpected end of data";
	const char BTFExtEndOfData[] =
	"error while reading .BTF.ext section: unexpected end of data";

	static raw_ostream &operator<<(raw_ostream &OS, const yaml::BinaryRef &Ref) {
	Ref.writeAsHex(OS);
	return OS;
	}

	template <typename T>
	static yaml::BinaryRef makeBinRef(const T *Ptr, size_t Size = sizeof(T)) {
	return yaml::BinaryRef(ArrayRef<uint8_t>((const uint8_t *)Ptr, Size));
	}

	namespace {
	// This is a mockup for an ELF file containing .BTF and .BTF.ext sections.
	// Binary content of these sections corresponds to the value of
	// MockData1::BTF and MockData1::Ext fields.
	//
	// The yaml::yaml2ObjectFile() is used to generate actual ELF,
	// see MockData1::makeObj().
	//
	// The `BTF` and `Ext` fields are initialized with correct values
	// valid for a small example with a few sections, fields could be
	// modified before a call to `makeObj()` to test parser with invalid
	// input, etc.

	struct MockData1 {
	// Use "pragma pack" to model .BTF & .BTF.ext sections content using
	// 'struct' objects. This pragma is supported by CLANG, GCC & MSVC,
	// which matters for LLVM CI.
	#pragma pack(push, 1)
	struct B {
	BTF::Header Header = {};
	// no types
	struct S {
	char Foo[4] = "foo";
	char Bar[4] = "bar";
	char Buz[4] = "buz";
	char Line1[11] = "first line";
	char Line2[12] = "second line";
	char File1[4] = "a.c";
	char File2[4] = "b.c";
	} Strings;

	B() {
	Header.Magic = BTF::MAGIC;
	Header.Version = 1;
	Header.HdrLen = sizeof(Header);
	Header.StrOff = offsetof(B, Strings) - sizeof(Header);
	Header.StrLen = sizeof(Strings);
	}
	} BTF;

	struct E {
	BTF::ExtHeader Header = {};
	// no func info
	struct {
	uint32_t LineRecSize = sizeof(BTF::BPFLineInfo);
	struct {
	BTF::SecLineInfo Sec = {offsetof(B::S, Foo), 2};
	BTF::BPFLineInfo Lines[2] = {
	{16, offsetof(B::S, File1), offsetof(B::S, Line1), LC(7, 1)},
	{32, offsetof(B::S, File1), offsetof(B::S, Line2), LC(14, 5)},
	};
	} Foo;
	struct {
	BTF::SecLineInfo Sec = {offsetof(B::S, Bar), 1};
	BTF::BPFLineInfo Lines[1] = {
	{0, offsetof(B::S, File2), offsetof(B::S, Line1), LC(42, 4)},
	};
	} Bar;
	} Lines;

	E() {
	Header.Magic = BTF::MAGIC;
	Header.Version = 1;
	Header.HdrLen = sizeof(Header);
	Header.LineInfoOff = offsetof(E, Lines) - sizeof(Header);
	Header.LineInfoLen = sizeof(Lines);
	}
	} Ext;
	#pragma pack(pop)

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

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

	ObjectFile &makeObj() {
	std::string Buffer;
	raw_string_ostream Yaml(Buffer);
	Yaml << R"(
	!ELF
	FileHeader:
	Class: ELFCLASS64)";
	if (sys::IsBigEndianHost)
	Yaml << "\n Data: ELFDATA2MSB";
	else
	Yaml << "\n Data: ELFDATA2LSB";
	Yaml << R"(
	Type: ET_REL
	Machine: EM_BPF
	Sections:
	- Name: foo
	Type: SHT_PROGBITS
	Size: 0x0
	- Name: bar
	Type: SHT_PROGBITS
	Size: 0x0)";

	if (BTFSectionLen >= 0)
	Yaml << R"(
	- Name: .BTF
	Type: SHT_PROGBITS
	Content: )"
	<< makeBinRef(&BTF, BTFSectionLen);

	if (ExtSectionLen >= 0)
	Yaml << R"(
	- Name: .BTF.ext
	Type: SHT_PROGBITS
	Content: )"
	<< makeBinRef(&Ext, ExtSectionLen);

	Obj = yaml::yaml2ObjectFile(Storage, Buffer,
	[](const Twine &Err) { errs() << Err; });
	return *Obj.get();
	}
	};

	TEST(BTFParserTest, simpleCorrectInput) {
	BTFParser BTF;
	MockData1 Mock;
	Error Err = BTF.parse(Mock.makeObj());
	EXPECT_FALSE(Err);

	EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Foo)), "foo");
	EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Bar)), "bar");
	EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Line1)), "first line");
	EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, Line2)), "second line");
	EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, File1)), "a.c");
	EXPECT_EQ(BTF.findString(offsetof(MockData1::B::S, File2)), "b.c");

	// Invalid offset
	EXPECT_EQ(BTF.findString(sizeof(MockData1::B::S)), StringRef());

	const BTF::BPFLineInfo *I1 = BTF.findLineInfo({16, 1});
	ASSERT_TRUE(I1);
	EXPECT_EQ(I1->getLine(), 7u);
	EXPECT_EQ(I1->getCol(), 1u);
	EXPECT_EQ(BTF.findString(I1->FileNameOff), "a.c");
	EXPECT_EQ(BTF.findString(I1->LineOff), "first line");

	const BTF::BPFLineInfo *I2 = BTF.findLineInfo({32, 1});
	ASSERT_TRUE(I2);
	EXPECT_EQ(I2->getLine(), 14u);
	EXPECT_EQ(I2->getCol(), 5u);
	EXPECT_EQ(BTF.findString(I2->FileNameOff), "a.c");
	EXPECT_EQ(BTF.findString(I2->LineOff), "second line");

	const BTF::BPFLineInfo *I3 = BTF.findLineInfo({0, 2});
	ASSERT_TRUE(I3);
	EXPECT_EQ(I3->getLine(), 42u);
	EXPECT_EQ(I3->getCol(), 4u);
	EXPECT_EQ(BTF.findString(I3->FileNameOff), "b.c");
	EXPECT_EQ(BTF.findString(I3->LineOff), "first line");

	// No info for insn address
	EXPECT_FALSE(BTF.findLineInfo({24, 1}));
	EXPECT_FALSE(BTF.findLineInfo({8, 2}));
	// No info for section number
	EXPECT_FALSE(BTF.findLineInfo({16, 3}));
	}

	TEST(BTFParserTest, badSectionNameOffset) {
	BTFParser BTF;
	MockData1 Mock;
	// "foo" is section #1, corrupting it's name offset will make impossible
	// to match section name with section index when BTF is parsed.
	Mock.Ext.Lines.Foo.Sec.SecNameOff = 100500;
	Error Err = BTF.parse(Mock.makeObj());
	EXPECT_FALSE(Err);
	// "foo" line info should be corrupted
	EXPECT_FALSE(BTF.findLineInfo({16, 1}));
	// "bar" line info should be ok
	EXPECT_TRUE(BTF.findLineInfo({0, 2}));
	}

	// Keep this as macro to preserve line number info
	#define EXPECT_PARSE_ERROR(Mock, Message) \
	do { \
	BTFParser BTF; \
	EXPECT_THAT_ERROR(BTF.parse((Mock).makeObj()), \
	FailedWithMessage(testing::HasSubstr(Message))); \
	} while (false)

	TEST(BTFParserTest, badBTFMagic) {
	MockData1 Mock;
	Mock.BTF.Header.Magic = 42;
	EXPECT_PARSE_ERROR(Mock, "invalid .BTF magic: 2a");
	}

	TEST(BTFParserTest, badBTFVersion) {
	MockData1 Mock;
	Mock.BTF.Header.Version = 42;
	EXPECT_PARSE_ERROR(Mock, "unsupported .BTF version: 42");
	}

	TEST(BTFParserTest, badBTFHdrLen) {
	MockData1 Mock;
	Mock.BTF.Header.HdrLen = 5;
	EXPECT_PARSE_ERROR(Mock, "unexpected .BTF header length: 5");
	}

	TEST(BTFParserTest, badBTFSectionLen) {
	MockData1 Mock1, Mock2;

	// Cut-off string section by one byte
	Mock1.BTFSectionLen =
	offsetof(MockData1::B, Strings) + sizeof(MockData1::B::S) - 1;
	EXPECT_PARSE_ERROR(Mock1, "invalid .BTF section size");

	// Cut-off header
	Mock2.BTFSectionLen = offsetof(BTF::Header, StrOff);
	EXPECT_PARSE_ERROR(Mock2, BTFEndOfData);
	}

	TEST(BTFParserTest, badBTFExtMagic) {
	MockData1 Mock;
	Mock.Ext.Header.Magic = 42;
	EXPECT_PARSE_ERROR(Mock, "invalid .BTF.ext magic: 2a");
	}

	TEST(BTFParserTest, badBTFExtVersion) {
	MockData1 Mock;
	Mock.Ext.Header.Version = 42;
	EXPECT_PARSE_ERROR(Mock, "unsupported .BTF.ext version: 42");
	}

	TEST(BTFParserTest, badBTFExtHdrLen) {
	MockData1 Mock1, Mock2;

	Mock1.Ext.Header.HdrLen = 5;
	EXPECT_PARSE_ERROR(Mock1, "unexpected .BTF.ext header length: 5");

	Mock2.Ext.Header.HdrLen = sizeof(Mock2.Ext);
	EXPECT_PARSE_ERROR(Mock2, BTFExtEndOfData);
	}

	TEST(BTFParserTest, badBTFExtSectionLen) {
	MockData1 Mock1, Mock2, Mock3;

	// Cut-off header before HdrLen
	Mock1.ExtSectionLen = offsetof(BTF::ExtHeader, HdrLen);
	EXPECT_PARSE_ERROR(Mock1, BTFExtEndOfData);

	// Cut-off header before LineInfoLen
	Mock2.ExtSectionLen = offsetof(BTF::ExtHeader, LineInfoLen);
	EXPECT_PARSE_ERROR(Mock2, BTFExtEndOfData);

	// Cut-off line-info section somewhere in the middle
	Mock3.ExtSectionLen = offsetof(MockData1::E, Lines) + 4;
	EXPECT_PARSE_ERROR(Mock3, BTFExtEndOfData);
	}

	TEST(BTFParserTest, badBTFExtLineInfoRecSize) {
	MockData1 Mock1, Mock2;

	Mock1.Ext.Lines.LineRecSize = 2;
	EXPECT_PARSE_ERROR(Mock1, "unexpected .BTF.ext line info record length: 2");

	Mock2.Ext.Lines.LineRecSize = sizeof(Mock2.Ext.Lines.Foo.Lines[0]) + 1;
	EXPECT_PARSE_ERROR(Mock2, BTFExtEndOfData);
	}

	TEST(BTFParserTest, badBTFExtLineSectionName) {
	MockData1 Mock1;

	Mock1.Ext.Lines.Foo.Sec.SecNameOff = offsetof(MockData1::B::S, Buz);
	EXPECT_PARSE_ERROR(
	Mock1, "can't find section 'buz' while parsing .BTF.ext line info");
	}

	TEST(BTFParserTest, missingSections) {
	MockData1 Mock1, Mock2, Mock3;

	Mock1.BTFSectionLen = -1;
	EXPECT_PARSE_ERROR(Mock1, "can't find .BTF section");
	EXPECT_FALSE(BTFParser::hasBTFSections(Mock1.makeObj()));

	Mock2.ExtSectionLen = -1;
	EXPECT_PARSE_ERROR(Mock2, "can't find .BTF.ext section");
	EXPECT_FALSE(BTFParser::hasBTFSections(Mock2.makeObj()));

	EXPECT_TRUE(BTFParser::hasBTFSections(Mock3.makeObj()));
	}

	// Check that BTFParser instance is reset when BTFParser::parse() is
	// called several times.
	TEST(BTFParserTest, parserReset) {
	BTFParser BTF;
	MockData1 Mock1, Mock2;

	EXPECT_FALSE(BTF.parse(Mock1.makeObj()));
	EXPECT_TRUE(BTF.findLineInfo({16, 1}));
	EXPECT_TRUE(BTF.findLineInfo({0, 2}));

	// Break the reference to "bar" section name, thus making
	// information about "bar" line numbers unavailable.
	Mock2.Ext.Lines.Bar.Sec.SecNameOff = 100500;

	EXPECT_FALSE(BTF.parse(Mock2.makeObj()));
	EXPECT_TRUE(BTF.findLineInfo({16, 1}));
	// Make sure that "bar" no longer available (its index is 2).
	EXPECT_FALSE(BTF.findLineInfo({0, 2}));
	}

	TEST(BTFParserTest, btfContext) {
	MockData1 Mock;
	BTFParser BTF;
	std::unique_ptr<BTFContext> Ctx = BTFContext::create(Mock.makeObj());

	DILineInfo I1 = Ctx->getLineInfoForAddress({16, 1});
	EXPECT_EQ(I1.Line, 7u);
	EXPECT_EQ(I1.Column, 1u);
	EXPECT_EQ(I1.FileName, "a.c");
	EXPECT_EQ(I1.LineSource, "first line");

	DILineInfo I2 = Ctx->getLineInfoForAddress({24, 1});
	EXPECT_EQ(I2.Line, 0u);
	EXPECT_EQ(I2.Column, 0u);
	EXPECT_EQ(I2.FileName, DILineInfo::BadString);
	EXPECT_EQ(I2.LineSource, std::nullopt);
	}

	} // namespace