Elf interface for new unwinder.
This cl includes the code to read arm unwind information from a shared
library.
Bug: 23762183
Test: Passes all unit tests. I can dump the arm unwind information
Test: for an arm shared library.
Change-Id: I43501ea2eab843b81de8bd5128401dd1971af8d3
diff --git a/libunwindstack/tests/ElfTest.cpp b/libunwindstack/tests/ElfTest.cpp
new file mode 100644
index 0000000..25fec8e
--- /dev/null
+++ b/libunwindstack/tests/ElfTest.cpp
@@ -0,0 +1,210 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#include "Elf.h"
+
+#include "MemoryFake.h"
+
+#if !defined(PT_ARM_EXIDX)
+#define PT_ARM_EXIDX 0x70000001
+#endif
+
+#if !defined(EM_AARCH64)
+#define EM_AARCH64 183
+#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;
+ }
+
+ void InitElf32(uint32_t type) {
+ Elf32_Ehdr ehdr;
+
+ InitEhdr<Elf32_Ehdr>(&ehdr);
+ ehdr.e_ident[EI_CLASS] = ELFCLASS32;
+
+ ehdr.e_type = ET_DYN;
+ ehdr.e_machine = type;
+ ehdr.e_version = EV_CURRENT;
+ 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 (type == 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 (type == 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 type) {
+ Elf64_Ehdr ehdr;
+
+ InitEhdr<Elf64_Ehdr>(&ehdr);
+ ehdr.e_ident[EI_CLASS] = ELFCLASS64;
+
+ ehdr.e_type = ET_DYN;
+ ehdr.e_machine = type;
+ ehdr.e_version = EV_CURRENT;
+ 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));
+ }
+
+ 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);
+}