libunwindstack/tests/ElfTest.cpp - android_system_core - Gitiles

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <elf.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include <gtest/gtest.h>

 #include "Elf.h"

 #include "MemoryFake.h"

 #if !defined(PT_ARM_EXIDX)
 #define PT_ARM_EXIDX 0x70000001
 #endif

 class ElfTest : public ::testing::Test {
  protected:
   void SetUp() override {
     memory_ = new MemoryFake;
   }

   template <typename Ehdr>
   void InitEhdr(Ehdr* ehdr) {
     memset(ehdr, 0, sizeof(Ehdr));
     memcpy(&ehdr->e_ident[0], ELFMAG, SELFMAG);
     ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
     ehdr->e_ident[EI_VERSION] = EV_CURRENT;
     ehdr->e_ident[EI_OSABI] = ELFOSABI_SYSV;

     ehdr->e_type = ET_DYN;
     ehdr->e_version = EV_CURRENT;
   }

   void InitElf32(uint32_t machine) {
     Elf32_Ehdr ehdr;

     InitEhdr<Elf32_Ehdr>(&ehdr);
     ehdr.e_ident[EI_CLASS] = ELFCLASS32;

     ehdr.e_machine = machine;
     ehdr.e_entry = 0;
     ehdr.e_phoff = 0x100;
     ehdr.e_shoff = 0;
     ehdr.e_flags = 0;
     ehdr.e_ehsize = sizeof(ehdr);
     ehdr.e_phentsize = sizeof(Elf32_Phdr);
     ehdr.e_phnum = 1;
     ehdr.e_shentsize = sizeof(Elf32_Shdr);
     ehdr.e_shnum = 0;
     ehdr.e_shstrndx = 0;
     if (machine == EM_ARM) {
       ehdr.e_flags = 0x5000200;
       ehdr.e_phnum = 2;
     }
     memory_->SetMemory(0, &ehdr, sizeof(ehdr));

     Elf32_Phdr phdr;
     memset(&phdr, 0, sizeof(phdr));
     phdr.p_type = PT_LOAD;
     phdr.p_offset = 0;
     phdr.p_vaddr = 0;
     phdr.p_paddr = 0;
     phdr.p_filesz = 0x10000;
     phdr.p_memsz = 0x10000;
     phdr.p_flags = PF_R | PF_X;
     phdr.p_align = 0x1000;
     memory_->SetMemory(0x100, &phdr, sizeof(phdr));

     if (machine == EM_ARM) {
       memset(&phdr, 0, sizeof(phdr));
       phdr.p_type = PT_ARM_EXIDX;
       phdr.p_offset = 0x30000;
       phdr.p_vaddr = 0x30000;
       phdr.p_paddr = 0x30000;
       phdr.p_filesz = 16;
       phdr.p_memsz = 16;
       phdr.p_flags = PF_R;
       phdr.p_align = 0x4;
       memory_->SetMemory(0x100 + sizeof(phdr), &phdr, sizeof(phdr));
     }
   }

   void InitElf64(uint32_t machine) {
     Elf64_Ehdr ehdr;

     InitEhdr<Elf64_Ehdr>(&ehdr);
     ehdr.e_ident[EI_CLASS] = ELFCLASS64;

     ehdr.e_machine = machine;
     ehdr.e_entry = 0;
     ehdr.e_phoff = 0x100;
     ehdr.e_shoff = 0;
     ehdr.e_flags = 0x5000200;
     ehdr.e_ehsize = sizeof(ehdr);
     ehdr.e_phentsize = sizeof(Elf64_Phdr);
     ehdr.e_phnum = 1;
     ehdr.e_shentsize = sizeof(Elf64_Shdr);
     ehdr.e_shnum = 0;
     ehdr.e_shstrndx = 0;
     memory_->SetMemory(0, &ehdr, sizeof(ehdr));

     Elf64_Phdr phdr;
     memset(&phdr, 0, sizeof(phdr));
     phdr.p_type = PT_LOAD;
     phdr.p_offset = 0;
     phdr.p_vaddr = 0;
     phdr.p_paddr = 0;
     phdr.p_filesz = 0x10000;
     phdr.p_memsz = 0x10000;
     phdr.p_flags = PF_R | PF_X;
     phdr.p_align = 0x1000;
     memory_->SetMemory(0x100, &phdr, sizeof(phdr));
   }

   template <typename Ehdr, typename Shdr>
   void GnuDebugdataInitFail(Ehdr* ehdr);

   template <typename Ehdr, typename Shdr>
   void GnuDebugdataInit(Ehdr* ehdr);

   MemoryFake* memory_;
 };

 TEST_F(ElfTest, invalid_memory) {
   Elf elf(memory_);

   ASSERT_FALSE(elf.Init());
   ASSERT_FALSE(elf.valid());
 }

 TEST_F(ElfTest, elf_invalid) {
   Elf elf(memory_);

   InitElf32(EM_386);

   // Corrupt the ELF signature.
   memory_->SetData32(0, 0x7f000000);

   ASSERT_FALSE(elf.Init());
   ASSERT_FALSE(elf.valid());
   ASSERT_TRUE(elf.interface() == nullptr);

   std::string name;
   ASSERT_FALSE(elf.GetSoname(&name));

   uint64_t func_offset;
   ASSERT_FALSE(elf.GetFunctionName(0, &name, &func_offset));

   ASSERT_FALSE(elf.Step(0, nullptr, nullptr));
 }

 TEST_F(ElfTest, elf_arm) {
   Elf elf(memory_);

   InitElf32(EM_ARM);

   ASSERT_TRUE(elf.Init());
   ASSERT_TRUE(elf.valid());
   ASSERT_EQ(static_cast<uint32_t>(EM_ARM), elf.machine_type());
   ASSERT_EQ(ELFCLASS32, elf.class_type());
   ASSERT_TRUE(elf.interface() != nullptr);
 }

 TEST_F(ElfTest, elf_x86) {
   Elf elf(memory_);

   InitElf32(EM_386);

   ASSERT_TRUE(elf.Init());
   ASSERT_TRUE(elf.valid());
   ASSERT_EQ(static_cast<uint32_t>(EM_386), elf.machine_type());
   ASSERT_EQ(ELFCLASS32, elf.class_type());
   ASSERT_TRUE(elf.interface() != nullptr);
 }

 TEST_F(ElfTest, elf_arm64) {
   Elf elf(memory_);

   InitElf64(EM_AARCH64);

   ASSERT_TRUE(elf.Init());
   ASSERT_TRUE(elf.valid());
   ASSERT_EQ(static_cast<uint32_t>(EM_AARCH64), elf.machine_type());
   ASSERT_EQ(ELFCLASS64, elf.class_type());
   ASSERT_TRUE(elf.interface() != nullptr);
 }

 TEST_F(ElfTest, elf_x86_64) {
   Elf elf(memory_);

   InitElf64(EM_X86_64);

   ASSERT_TRUE(elf.Init());
   ASSERT_TRUE(elf.valid());
   ASSERT_EQ(static_cast<uint32_t>(EM_X86_64), elf.machine_type());
   ASSERT_EQ(ELFCLASS64, elf.class_type());
   ASSERT_TRUE(elf.interface() != nullptr);
 }

 template <typename Ehdr, typename Shdr>
 void ElfTest::GnuDebugdataInitFail(Ehdr* ehdr) {
   Elf elf(memory_);

   uint64_t offset = 0x2000;

   ehdr->e_shoff = offset;
   ehdr->e_shnum = 3;
   ehdr->e_shentsize = sizeof(Shdr);
   ehdr->e_shstrndx = 2;
   memory_->SetMemory(0, ehdr, sizeof(*ehdr));

   Shdr shdr;
   memset(&shdr, 0, sizeof(shdr));
   shdr.sh_type = SHT_NULL;
   memory_->SetMemory(offset, &shdr, sizeof(shdr));
   offset += ehdr->e_shentsize;

   memset(&shdr, 0, sizeof(shdr));
   shdr.sh_type = SHT_PROGBITS;
   shdr.sh_name = 0x100;
   shdr.sh_addr = 0x5000;
   shdr.sh_offset = 0x5000;
   shdr.sh_entsize = 0x100;
   shdr.sh_size = 0x800;
   memory_->SetMemory(offset, &shdr, sizeof(shdr));
   offset += ehdr->e_shentsize;

   memset(&shdr, 0, sizeof(shdr));
   shdr.sh_type = SHT_STRTAB;
   shdr.sh_name = 0x200000;
   shdr.sh_offset = 0xf000;
   shdr.sh_size = 0x1000;
   memory_->SetMemory(offset, &shdr, sizeof(shdr));
   offset += ehdr->e_shentsize;

   memory_->SetMemory(0xf100, ".gnu_debugdata", sizeof(".gnu_debugdata"));

   ASSERT_TRUE(elf.Init());
   ASSERT_TRUE(elf.interface() != nullptr);
   ASSERT_TRUE(elf.gnu_debugdata_interface() == nullptr);
   EXPECT_EQ(0x5000U, elf.interface()->gnu_debugdata_offset());
   EXPECT_EQ(0x800U, elf.interface()->gnu_debugdata_size());

   elf.InitGnuDebugdata();
 }

 TEST_F(ElfTest, gnu_debugdata_init_fail32) {
   Elf32_Ehdr ehdr;
   InitEhdr<Elf32_Ehdr>(&ehdr);
   ehdr.e_ident[EI_CLASS] = ELFCLASS32;
   ehdr.e_machine = EM_ARM;

   GnuDebugdataInitFail<Elf32_Ehdr, Elf32_Shdr>(&ehdr);
 }

 TEST_F(ElfTest, gnu_debugdata_init_fail64) {
   Elf64_Ehdr ehdr;
   InitEhdr<Elf64_Ehdr>(&ehdr);
   ehdr.e_ident[EI_CLASS] = ELFCLASS64;
   ehdr.e_machine = EM_AARCH64;

   GnuDebugdataInitFail<Elf64_Ehdr, Elf64_Shdr>(&ehdr);
 }

 template <typename Ehdr, typename Shdr>
 void ElfTest::GnuDebugdataInit(Ehdr* ehdr) {
   Elf elf(memory_);

   uint64_t offset = 0x2000;

   ehdr->e_shoff = offset;
   ehdr->e_shnum = 3;
   ehdr->e_shentsize = sizeof(Shdr);
   ehdr->e_shstrndx = 2;
   memory_->SetMemory(0, ehdr, sizeof(*ehdr));

   Shdr shdr;
   memset(&shdr, 0, sizeof(shdr));
   shdr.sh_type = SHT_NULL;
   memory_->SetMemory(offset, &shdr, sizeof(shdr));
   offset += ehdr->e_shentsize;

   uint64_t gnu_offset = offset;
   offset += ehdr->e_shentsize;

   memset(&shdr, 0, sizeof(shdr));
   shdr.sh_type = SHT_STRTAB;
   shdr.sh_name = 0x200000;
   shdr.sh_offset = 0xf000;
   shdr.sh_size = 0x1000;
   memory_->SetMemory(offset, &shdr, sizeof(shdr));
   offset += ehdr->e_shentsize;

   memory_->SetMemory(0xf100, ".gnu_debugdata", sizeof(".gnu_debugdata"));

   // Read in the compressed elf data and put it in our fake memory.
   std::string name("tests/");
   if (sizeof(Ehdr) == sizeof(Elf32_Ehdr)) {
     name += "elf32.xz";
   } else {
     name += "elf64.xz";
   }
   int fd = TEMP_FAILURE_RETRY(open(name.c_str(), O_RDONLY));
   ASSERT_NE(-1, fd) << "Cannot open " + name;
   // Assumes the file is less than 1024 bytes.
   std::vector<uint8_t> buf(1024);
   ssize_t bytes = TEMP_FAILURE_RETRY(read(fd, buf.data(), buf.size()));
   ASSERT_GT(bytes, 0);
   // Make sure the file isn't too big.
   ASSERT_NE(static_cast<size_t>(bytes), buf.size())
       << "File " + name + " is too big, increase buffer size.";
   close(fd);
   buf.resize(bytes);
   memory_->SetMemory(0x5000, buf);

   memset(&shdr, 0, sizeof(shdr));
   shdr.sh_type = SHT_PROGBITS;
   shdr.sh_name = 0x100;
   shdr.sh_addr = 0x5000;
   shdr.sh_offset = 0x5000;
   shdr.sh_size = bytes;
   memory_->SetMemory(gnu_offset, &shdr, sizeof(shdr));

   ASSERT_TRUE(elf.Init());
   ASSERT_TRUE(elf.interface() != nullptr);
   ASSERT_TRUE(elf.gnu_debugdata_interface() == nullptr);
   EXPECT_EQ(0x5000U, elf.interface()->gnu_debugdata_offset());

   elf.InitGnuDebugdata();
   ASSERT_TRUE(elf.gnu_debugdata_interface() != nullptr);
 }

 TEST_F(ElfTest, gnu_debugdata_init32) {
   Elf32_Ehdr ehdr;
   InitEhdr<Elf32_Ehdr>(&ehdr);
   ehdr.e_ident[EI_CLASS] = ELFCLASS32;
   ehdr.e_machine = EM_ARM;

   GnuDebugdataInit<Elf32_Ehdr, Elf32_Shdr>(&ehdr);
 }

 TEST_F(ElfTest, gnu_debugdata_init64) {
   Elf64_Ehdr ehdr;
   InitEhdr<Elf64_Ehdr>(&ehdr);
   ehdr.e_ident[EI_CLASS] = ELFCLASS64;
   ehdr.e_machine = EM_AARCH64;

   GnuDebugdataInit<Elf64_Ehdr, Elf64_Shdr>(&ehdr);
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <elf.h>
	#include <fcntl.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include <gtest/gtest.h>

	#include "Elf.h"

	#include "MemoryFake.h"

	#if !defined(PT_ARM_EXIDX)
	#define PT_ARM_EXIDX 0x70000001
	#endif

	class ElfTest : public ::testing::Test {
	protected:
	void SetUp() override {
	memory_ = new MemoryFake;
	}

	template <typename Ehdr>
	void InitEhdr(Ehdr* ehdr) {
	memset(ehdr, 0, sizeof(Ehdr));
	memcpy(&ehdr->e_ident[0], ELFMAG, SELFMAG);
	ehdr->e_ident[EI_DATA] = ELFDATA2LSB;
	ehdr->e_ident[EI_VERSION] = EV_CURRENT;
	ehdr->e_ident[EI_OSABI] = ELFOSABI_SYSV;

	ehdr->e_type = ET_DYN;
	ehdr->e_version = EV_CURRENT;
	}

	void InitElf32(uint32_t machine) {
	Elf32_Ehdr ehdr;

	InitEhdr<Elf32_Ehdr>(&ehdr);
	ehdr.e_ident[EI_CLASS] = ELFCLASS32;

	ehdr.e_machine = machine;
	ehdr.e_entry = 0;
	ehdr.e_phoff = 0x100;
	ehdr.e_shoff = 0;
	ehdr.e_flags = 0;
	ehdr.e_ehsize = sizeof(ehdr);
	ehdr.e_phentsize = sizeof(Elf32_Phdr);
	ehdr.e_phnum = 1;
	ehdr.e_shentsize = sizeof(Elf32_Shdr);
	ehdr.e_shnum = 0;
	ehdr.e_shstrndx = 0;
	if (machine == EM_ARM) {
	ehdr.e_flags = 0x5000200;
	ehdr.e_phnum = 2;
	}
	memory_->SetMemory(0, &ehdr, sizeof(ehdr));

	Elf32_Phdr phdr;
	memset(&phdr, 0, sizeof(phdr));
	phdr.p_type = PT_LOAD;
	phdr.p_offset = 0;
	phdr.p_vaddr = 0;
	phdr.p_paddr = 0;
	phdr.p_filesz = 0x10000;
	phdr.p_memsz = 0x10000;
	phdr.p_flags = PF_R \| PF_X;
	phdr.p_align = 0x1000;
	memory_->SetMemory(0x100, &phdr, sizeof(phdr));

	if (machine == EM_ARM) {
	memset(&phdr, 0, sizeof(phdr));
	phdr.p_type = PT_ARM_EXIDX;
	phdr.p_offset = 0x30000;
	phdr.p_vaddr = 0x30000;
	phdr.p_paddr = 0x30000;
	phdr.p_filesz = 16;
	phdr.p_memsz = 16;
	phdr.p_flags = PF_R;
	phdr.p_align = 0x4;
	memory_->SetMemory(0x100 + sizeof(phdr), &phdr, sizeof(phdr));
	}
	}

	void InitElf64(uint32_t machine) {
	Elf64_Ehdr ehdr;

	InitEhdr<Elf64_Ehdr>(&ehdr);
	ehdr.e_ident[EI_CLASS] = ELFCLASS64;

	ehdr.e_machine = machine;
	ehdr.e_entry = 0;
	ehdr.e_phoff = 0x100;
	ehdr.e_shoff = 0;
	ehdr.e_flags = 0x5000200;
	ehdr.e_ehsize = sizeof(ehdr);
	ehdr.e_phentsize = sizeof(Elf64_Phdr);
	ehdr.e_phnum = 1;
	ehdr.e_shentsize = sizeof(Elf64_Shdr);
	ehdr.e_shnum = 0;
	ehdr.e_shstrndx = 0;
	memory_->SetMemory(0, &ehdr, sizeof(ehdr));

	Elf64_Phdr phdr;
	memset(&phdr, 0, sizeof(phdr));
	phdr.p_type = PT_LOAD;
	phdr.p_offset = 0;
	phdr.p_vaddr = 0;
	phdr.p_paddr = 0;
	phdr.p_filesz = 0x10000;
	phdr.p_memsz = 0x10000;
	phdr.p_flags = PF_R \| PF_X;
	phdr.p_align = 0x1000;
	memory_->SetMemory(0x100, &phdr, sizeof(phdr));
	}

	template <typename Ehdr, typename Shdr>
	void GnuDebugdataInitFail(Ehdr* ehdr);

	template <typename Ehdr, typename Shdr>
	void GnuDebugdataInit(Ehdr* ehdr);

	MemoryFake* memory_;
	};

	TEST_F(ElfTest, invalid_memory) {
	Elf elf(memory_);

	ASSERT_FALSE(elf.Init());
	ASSERT_FALSE(elf.valid());
	}

	TEST_F(ElfTest, elf_invalid) {
	Elf elf(memory_);

	InitElf32(EM_386);

	// Corrupt the ELF signature.
	memory_->SetData32(0, 0x7f000000);

	ASSERT_FALSE(elf.Init());
	ASSERT_FALSE(elf.valid());
	ASSERT_TRUE(elf.interface() == nullptr);

	std::string name;
	ASSERT_FALSE(elf.GetSoname(&name));

	uint64_t func_offset;
	ASSERT_FALSE(elf.GetFunctionName(0, &name, &func_offset));

	ASSERT_FALSE(elf.Step(0, nullptr, nullptr));
	}

	TEST_F(ElfTest, elf_arm) {
	Elf elf(memory_);

	InitElf32(EM_ARM);

	ASSERT_TRUE(elf.Init());
	ASSERT_TRUE(elf.valid());
	ASSERT_EQ(static_cast<uint32_t>(EM_ARM), elf.machine_type());
	ASSERT_EQ(ELFCLASS32, elf.class_type());
	ASSERT_TRUE(elf.interface() != nullptr);
	}

	TEST_F(ElfTest, elf_x86) {
	Elf elf(memory_);

	InitElf32(EM_386);

	ASSERT_TRUE(elf.Init());
	ASSERT_TRUE(elf.valid());
	ASSERT_EQ(static_cast<uint32_t>(EM_386), elf.machine_type());
	ASSERT_EQ(ELFCLASS32, elf.class_type());
	ASSERT_TRUE(elf.interface() != nullptr);
	}

	TEST_F(ElfTest, elf_arm64) {
	Elf elf(memory_);

	InitElf64(EM_AARCH64);

	ASSERT_TRUE(elf.Init());
	ASSERT_TRUE(elf.valid());
	ASSERT_EQ(static_cast<uint32_t>(EM_AARCH64), elf.machine_type());
	ASSERT_EQ(ELFCLASS64, elf.class_type());
	ASSERT_TRUE(elf.interface() != nullptr);
	}

	TEST_F(ElfTest, elf_x86_64) {
	Elf elf(memory_);

	InitElf64(EM_X86_64);

	ASSERT_TRUE(elf.Init());
	ASSERT_TRUE(elf.valid());
	ASSERT_EQ(static_cast<uint32_t>(EM_X86_64), elf.machine_type());
	ASSERT_EQ(ELFCLASS64, elf.class_type());
	ASSERT_TRUE(elf.interface() != nullptr);
	}

	template <typename Ehdr, typename Shdr>
	void ElfTest::GnuDebugdataInitFail(Ehdr* ehdr) {
	Elf elf(memory_);

	uint64_t offset = 0x2000;

	ehdr->e_shoff = offset;
	ehdr->e_shnum = 3;
	ehdr->e_shentsize = sizeof(Shdr);
	ehdr->e_shstrndx = 2;
	memory_->SetMemory(0, ehdr, sizeof(*ehdr));

	Shdr shdr;
	memset(&shdr, 0, sizeof(shdr));
	shdr.sh_type = SHT_NULL;
	memory_->SetMemory(offset, &shdr, sizeof(shdr));
	offset += ehdr->e_shentsize;

	memset(&shdr, 0, sizeof(shdr));
	shdr.sh_type = SHT_PROGBITS;
	shdr.sh_name = 0x100;
	shdr.sh_addr = 0x5000;
	shdr.sh_offset = 0x5000;
	shdr.sh_entsize = 0x100;
	shdr.sh_size = 0x800;
	memory_->SetMemory(offset, &shdr, sizeof(shdr));
	offset += ehdr->e_shentsize;

	memset(&shdr, 0, sizeof(shdr));
	shdr.sh_type = SHT_STRTAB;
	shdr.sh_name = 0x200000;
	shdr.sh_offset = 0xf000;
	shdr.sh_size = 0x1000;
	memory_->SetMemory(offset, &shdr, sizeof(shdr));
	offset += ehdr->e_shentsize;

	memory_->SetMemory(0xf100, ".gnu_debugdata", sizeof(".gnu_debugdata"));

	ASSERT_TRUE(elf.Init());
	ASSERT_TRUE(elf.interface() != nullptr);
	ASSERT_TRUE(elf.gnu_debugdata_interface() == nullptr);
	EXPECT_EQ(0x5000U, elf.interface()->gnu_debugdata_offset());
	EXPECT_EQ(0x800U, elf.interface()->gnu_debugdata_size());

	elf.InitGnuDebugdata();
	}

	TEST_F(ElfTest, gnu_debugdata_init_fail32) {
	Elf32_Ehdr ehdr;
	InitEhdr<Elf32_Ehdr>(&ehdr);
	ehdr.e_ident[EI_CLASS] = ELFCLASS32;
	ehdr.e_machine = EM_ARM;

	GnuDebugdataInitFail<Elf32_Ehdr, Elf32_Shdr>(&ehdr);
	}

	TEST_F(ElfTest, gnu_debugdata_init_fail64) {
	Elf64_Ehdr ehdr;
	InitEhdr<Elf64_Ehdr>(&ehdr);
	ehdr.e_ident[EI_CLASS] = ELFCLASS64;
	ehdr.e_machine = EM_AARCH64;

	GnuDebugdataInitFail<Elf64_Ehdr, Elf64_Shdr>(&ehdr);
	}

	template <typename Ehdr, typename Shdr>
	void ElfTest::GnuDebugdataInit(Ehdr* ehdr) {
	Elf elf(memory_);

	uint64_t offset = 0x2000;

	ehdr->e_shoff = offset;
	ehdr->e_shnum = 3;
	ehdr->e_shentsize = sizeof(Shdr);
	ehdr->e_shstrndx = 2;
	memory_->SetMemory(0, ehdr, sizeof(*ehdr));

	Shdr shdr;
	memset(&shdr, 0, sizeof(shdr));
	shdr.sh_type = SHT_NULL;
	memory_->SetMemory(offset, &shdr, sizeof(shdr));
	offset += ehdr->e_shentsize;

	uint64_t gnu_offset = offset;
	offset += ehdr->e_shentsize;

	memset(&shdr, 0, sizeof(shdr));
	shdr.sh_type = SHT_STRTAB;
	shdr.sh_name = 0x200000;
	shdr.sh_offset = 0xf000;
	shdr.sh_size = 0x1000;
	memory_->SetMemory(offset, &shdr, sizeof(shdr));
	offset += ehdr->e_shentsize;

	memory_->SetMemory(0xf100, ".gnu_debugdata", sizeof(".gnu_debugdata"));

	// Read in the compressed elf data and put it in our fake memory.
	std::string name("tests/");
	if (sizeof(Ehdr) == sizeof(Elf32_Ehdr)) {
	name += "elf32.xz";
	} else {
	name += "elf64.xz";
	}
	int fd = TEMP_FAILURE_RETRY(open(name.c_str(), O_RDONLY));
	ASSERT_NE(-1, fd) << "Cannot open " + name;
	// Assumes the file is less than 1024 bytes.
	std::vector<uint8_t> buf(1024);
	ssize_t bytes = TEMP_FAILURE_RETRY(read(fd, buf.data(), buf.size()));
	ASSERT_GT(bytes, 0);
	// Make sure the file isn't too big.
	ASSERT_NE(static_cast<size_t>(bytes), buf.size())
	<< "File " + name + " is too big, increase buffer size.";
	close(fd);
	buf.resize(bytes);
	memory_->SetMemory(0x5000, buf);

	memset(&shdr, 0, sizeof(shdr));
	shdr.sh_type = SHT_PROGBITS;
	shdr.sh_name = 0x100;
	shdr.sh_addr = 0x5000;
	shdr.sh_offset = 0x5000;
	shdr.sh_size = bytes;
	memory_->SetMemory(gnu_offset, &shdr, sizeof(shdr));

	ASSERT_TRUE(elf.Init());
	ASSERT_TRUE(elf.interface() != nullptr);
	ASSERT_TRUE(elf.gnu_debugdata_interface() == nullptr);
	EXPECT_EQ(0x5000U, elf.interface()->gnu_debugdata_offset());

	elf.InitGnuDebugdata();
	ASSERT_TRUE(elf.gnu_debugdata_interface() != nullptr);
	}

	TEST_F(ElfTest, gnu_debugdata_init32) {
	Elf32_Ehdr ehdr;
	InitEhdr<Elf32_Ehdr>(&ehdr);
	ehdr.e_ident[EI_CLASS] = ELFCLASS32;
	ehdr.e_machine = EM_ARM;

	GnuDebugdataInit<Elf32_Ehdr, Elf32_Shdr>(&ehdr);
	}

	TEST_F(ElfTest, gnu_debugdata_init64) {
	Elf64_Ehdr ehdr;
	InitEhdr<Elf64_Ehdr>(&ehdr);
	ehdr.e_ident[EI_CLASS] = ELFCLASS64;
	ehdr.e_machine = EM_AARCH64;

	GnuDebugdataInit<Elf64_Ehdr, Elf64_Shdr>(&ehdr);
	}