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/ElfInterfaceArmTest.cpp b/libunwindstack/tests/ElfInterfaceArmTest.cpp
new file mode 100644
index 0000000..67c9a6b
--- /dev/null
+++ b/libunwindstack/tests/ElfInterfaceArmTest.cpp
@@ -0,0 +1,372 @@
+/*
+ * 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 <vector>
+
+#include "ElfInterfaceArm.h"
+#include "Machine.h"
+#include "Regs.h"
+
+#include "MemoryFake.h"
+
+class ElfInterfaceArmTest : public ::testing::Test {
+ protected:
+ void SetUp() override {
+ memory_.Clear();
+ process_memory_.Clear();
+ }
+
+ MemoryFake memory_;
+ MemoryFake process_memory_;
+};
+
+TEST_F(ElfInterfaceArmTest, GetPrel32Addr) {
+ ElfInterfaceArm interface(&memory_);
+ memory_.SetData32(0x1000, 0x230000);
+
+ uint32_t value;
+ ASSERT_TRUE(interface.GetPrel31Addr(0x1000, &value));
+ ASSERT_EQ(0x231000U, value);
+
+ memory_.SetData32(0x1000, 0x80001000);
+ ASSERT_TRUE(interface.GetPrel31Addr(0x1000, &value));
+ ASSERT_EQ(0x2000U, value);
+
+ memory_.SetData32(0x1000, 0x70001000);
+ ASSERT_TRUE(interface.GetPrel31Addr(0x1000, &value));
+ ASSERT_EQ(0xf0002000U, value);
+}
+
+TEST_F(ElfInterfaceArmTest, FindEntry_start_zero) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0);
+ interface.set_total_entries(10);
+
+ uint64_t entry_offset;
+ ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
+}
+
+TEST_F(ElfInterfaceArmTest, FindEntry_no_entries) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0x100);
+ interface.set_total_entries(0);
+
+ uint64_t entry_offset;
+ ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
+}
+
+TEST_F(ElfInterfaceArmTest, FindEntry_no_valid_memory) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0x100);
+ interface.set_total_entries(2);
+
+ uint64_t entry_offset;
+ ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
+}
+
+TEST_F(ElfInterfaceArmTest, FindEntry_ip_before_first) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0x1000);
+ interface.set_total_entries(1);
+ memory_.SetData32(0x1000, 0x6000);
+
+ uint64_t entry_offset;
+ ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
+}
+
+TEST_F(ElfInterfaceArmTest, FindEntry_single_entry_negative_value) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0x8000);
+ interface.set_total_entries(1);
+ memory_.SetData32(0x8000, 0x7fffff00);
+
+ uint64_t entry_offset;
+ ASSERT_TRUE(interface.FindEntry(0x7ff0, &entry_offset));
+ ASSERT_EQ(0x8000U, entry_offset);
+}
+
+TEST_F(ElfInterfaceArmTest, FindEntry_two_entries) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0x1000);
+ interface.set_total_entries(2);
+ memory_.SetData32(0x1000, 0x6000);
+ memory_.SetData32(0x1008, 0x7000);
+
+ uint64_t entry_offset;
+ ASSERT_TRUE(interface.FindEntry(0x7000, &entry_offset));
+ ASSERT_EQ(0x1000U, entry_offset);
+}
+
+
+TEST_F(ElfInterfaceArmTest, FindEntry_last_check_single_entry) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0x1000);
+ interface.set_total_entries(1);
+ memory_.SetData32(0x1000, 0x6000);
+
+ uint64_t entry_offset;
+ ASSERT_TRUE(interface.FindEntry(0x7000, &entry_offset));
+ ASSERT_EQ(0x1000U, entry_offset);
+
+ // To guarantee that we are using the cache on the second run,
+ // set the memory to a different value.
+ memory_.SetData32(0x1000, 0x8000);
+ ASSERT_TRUE(interface.FindEntry(0x7004, &entry_offset));
+ ASSERT_EQ(0x1000U, entry_offset);
+}
+
+TEST_F(ElfInterfaceArmTest, FindEntry_last_check_multiple_entries) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0x1000);
+ interface.set_total_entries(2);
+ memory_.SetData32(0x1000, 0x6000);
+ memory_.SetData32(0x1008, 0x8000);
+
+ uint64_t entry_offset;
+ ASSERT_TRUE(interface.FindEntry(0x9008, &entry_offset));
+ ASSERT_EQ(0x1008U, entry_offset);
+
+ // To guarantee that we are using the cache on the second run,
+ // set the memory to a different value.
+ memory_.SetData32(0x1000, 0x16000);
+ memory_.SetData32(0x1008, 0x18000);
+ ASSERT_TRUE(interface.FindEntry(0x9100, &entry_offset));
+ ASSERT_EQ(0x1008U, entry_offset);
+}
+
+TEST_F(ElfInterfaceArmTest, FindEntry_multiple_entries_even) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0x1000);
+ interface.set_total_entries(4);
+ memory_.SetData32(0x1000, 0x6000);
+ memory_.SetData32(0x1008, 0x7000);
+ memory_.SetData32(0x1010, 0x8000);
+ memory_.SetData32(0x1018, 0x9000);
+
+ uint64_t entry_offset;
+ ASSERT_TRUE(interface.FindEntry(0x9100, &entry_offset));
+ ASSERT_EQ(0x1010U, entry_offset);
+
+ // To guarantee that we are using the cache on the second run,
+ // set the memory to a different value.
+ memory_.SetData32(0x1000, 0x16000);
+ memory_.SetData32(0x1008, 0x17000);
+ memory_.SetData32(0x1010, 0x18000);
+ memory_.SetData32(0x1018, 0x19000);
+ ASSERT_TRUE(interface.FindEntry(0x9100, &entry_offset));
+ ASSERT_EQ(0x1010U, entry_offset);
+}
+
+TEST_F(ElfInterfaceArmTest, FindEntry_multiple_entries_odd) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0x1000);
+ interface.set_total_entries(5);
+ memory_.SetData32(0x1000, 0x5000);
+ memory_.SetData32(0x1008, 0x6000);
+ memory_.SetData32(0x1010, 0x7000);
+ memory_.SetData32(0x1018, 0x8000);
+ memory_.SetData32(0x1020, 0x9000);
+
+ uint64_t entry_offset;
+ ASSERT_TRUE(interface.FindEntry(0x8100, &entry_offset));
+ ASSERT_EQ(0x1010U, entry_offset);
+
+ // To guarantee that we are using the cache on the second run,
+ // set the memory to a different value.
+ memory_.SetData32(0x1000, 0x15000);
+ memory_.SetData32(0x1008, 0x16000);
+ memory_.SetData32(0x1010, 0x17000);
+ memory_.SetData32(0x1018, 0x18000);
+ memory_.SetData32(0x1020, 0x19000);
+ ASSERT_TRUE(interface.FindEntry(0x8100, &entry_offset));
+ ASSERT_EQ(0x1010U, entry_offset);
+}
+
+TEST_F(ElfInterfaceArmTest, iterate) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0x1000);
+ interface.set_total_entries(5);
+ memory_.SetData32(0x1000, 0x5000);
+ memory_.SetData32(0x1008, 0x6000);
+ memory_.SetData32(0x1010, 0x7000);
+ memory_.SetData32(0x1018, 0x8000);
+ memory_.SetData32(0x1020, 0x9000);
+
+ std::vector<uint32_t> entries;
+ for (auto addr : interface) {
+ entries.push_back(addr);
+ }
+ ASSERT_EQ(5U, entries.size());
+ ASSERT_EQ(0x6000U, entries[0]);
+ ASSERT_EQ(0x7008U, entries[1]);
+ ASSERT_EQ(0x8010U, entries[2]);
+ ASSERT_EQ(0x9018U, entries[3]);
+ ASSERT_EQ(0xa020U, entries[4]);
+
+ // Make sure the iterate cached the entries.
+ memory_.SetData32(0x1000, 0x11000);
+ memory_.SetData32(0x1008, 0x12000);
+ memory_.SetData32(0x1010, 0x13000);
+ memory_.SetData32(0x1018, 0x14000);
+ memory_.SetData32(0x1020, 0x15000);
+
+ entries.clear();
+ for (auto addr : interface) {
+ entries.push_back(addr);
+ }
+ ASSERT_EQ(5U, entries.size());
+ ASSERT_EQ(0x6000U, entries[0]);
+ ASSERT_EQ(0x7008U, entries[1]);
+ ASSERT_EQ(0x8010U, entries[2]);
+ ASSERT_EQ(0x9018U, entries[3]);
+ ASSERT_EQ(0xa020U, entries[4]);
+}
+
+TEST_F(ElfInterfaceArmTest, FindEntry_load_bias) {
+ ElfInterfaceArm interface(&memory_);
+ interface.set_start_offset(0x1000);
+ interface.set_total_entries(2);
+ memory_.SetData32(0x1000, 0x6000);
+ memory_.SetData32(0x1008, 0x8000);
+
+ uint64_t entry_offset;
+ interface.set_load_bias(0x2000);
+ ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
+ ASSERT_FALSE(interface.FindEntry(0x8000, &entry_offset));
+ ASSERT_FALSE(interface.FindEntry(0x8fff, &entry_offset));
+ ASSERT_TRUE(interface.FindEntry(0x9000, &entry_offset));
+ ASSERT_EQ(0x1000U, entry_offset);
+ ASSERT_TRUE(interface.FindEntry(0xb007, &entry_offset));
+ ASSERT_EQ(0x1000U, entry_offset);
+ ASSERT_TRUE(interface.FindEntry(0xb008, &entry_offset));
+ ASSERT_EQ(0x1008U, entry_offset);
+}
+
+TEST_F(ElfInterfaceArmTest, HandleType_not_arm_exidx) {
+ ElfInterfaceArm interface(&memory_);
+
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_NULL));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_LOAD));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_DYNAMIC));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_INTERP));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_NOTE));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_SHLIB));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_PHDR));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_TLS));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_LOOS));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_HIOS));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_LOPROC));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_HIPROC));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_GNU_EH_FRAME));
+ ASSERT_FALSE(interface.HandleType(0x1000, PT_GNU_STACK));
+}
+
+TEST_F(ElfInterfaceArmTest, HandleType_arm_exidx) {
+ ElfInterfaceArm interface(&memory_);
+
+ Elf32_Phdr phdr;
+ interface.set_start_offset(0x1000);
+ interface.set_total_entries(100);
+ phdr.p_vaddr = 0x2000;
+ phdr.p_memsz = 0xa00;
+
+ // Verify that if reads fail, we don't set the values but still get true.
+ ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001));
+ ASSERT_EQ(0x1000U, interface.start_offset());
+ ASSERT_EQ(100U, interface.total_entries());
+
+ // Verify that if the second read fails, we still don't set the values.
+ memory_.SetData32(
+ 0x1000 + reinterpret_cast<uint64_t>(&phdr.p_vaddr) - reinterpret_cast<uint64_t>(&phdr),
+ phdr.p_vaddr);
+ ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001));
+ ASSERT_EQ(0x1000U, interface.start_offset());
+ ASSERT_EQ(100U, interface.total_entries());
+
+ // Everything is correct and present.
+ memory_.SetData32(
+ 0x1000 + reinterpret_cast<uint64_t>(&phdr.p_memsz) - reinterpret_cast<uint64_t>(&phdr),
+ phdr.p_memsz);
+ ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001));
+ ASSERT_EQ(0x2000U, interface.start_offset());
+ ASSERT_EQ(320U, interface.total_entries());
+
+ // Non-zero load bias.
+ interface.set_load_bias(0x1000);
+ ASSERT_TRUE(interface.HandleType(0x1000, 0x70000001));
+ ASSERT_EQ(0x1000U, interface.start_offset());
+ ASSERT_EQ(320U, interface.total_entries());
+}
+
+TEST_F(ElfInterfaceArmTest, StepExidx) {
+ ElfInterfaceArm interface(&memory_);
+
+ // FindEntry fails.
+ ASSERT_FALSE(interface.StepExidx(0x7000, nullptr, nullptr));
+
+ // ExtractEntry should fail.
+ interface.set_start_offset(0x1000);
+ interface.set_total_entries(2);
+ memory_.SetData32(0x1000, 0x6000);
+ memory_.SetData32(0x1008, 0x8000);
+
+ RegsArm regs;
+ regs[ARM_REG_SP] = 0x1000;
+ regs[ARM_REG_LR] = 0x20000;
+ regs.set_sp(regs[ARM_REG_SP]);
+ regs.set_pc(0x1234);
+ ASSERT_FALSE(interface.StepExidx(0x7000, ®s, &process_memory_));
+
+ // Eval should fail.
+ memory_.SetData32(0x1004, 0x81000000);
+ ASSERT_FALSE(interface.StepExidx(0x7000, ®s, &process_memory_));
+
+ // Everything should pass.
+ memory_.SetData32(0x1004, 0x80b0b0b0);
+ ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_));
+ ASSERT_EQ(0x1000U, regs.sp());
+ ASSERT_EQ(0x1000U, regs[ARM_REG_SP]);
+ ASSERT_EQ(0x20000U, regs.pc());
+ ASSERT_EQ(0x20000U, regs[ARM_REG_PC]);
+}
+
+TEST_F(ElfInterfaceArmTest, StepExidx_pc_set) {
+ ElfInterfaceArm interface(&memory_);
+
+ interface.set_start_offset(0x1000);
+ interface.set_total_entries(2);
+ memory_.SetData32(0x1000, 0x6000);
+ memory_.SetData32(0x1004, 0x808800b0);
+ memory_.SetData32(0x1008, 0x8000);
+ process_memory_.SetData32(0x10000, 0x10);
+
+ RegsArm regs;
+ regs[ARM_REG_SP] = 0x10000;
+ regs[ARM_REG_LR] = 0x20000;
+ regs.set_sp(regs[ARM_REG_SP]);
+ regs.set_pc(0x1234);
+
+ // Everything should pass.
+ ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_));
+ ASSERT_EQ(0x10004U, regs.sp());
+ ASSERT_EQ(0x10004U, regs[ARM_REG_SP]);
+ ASSERT_EQ(0x10U, regs.pc());
+ ASSERT_EQ(0x10U, regs[ARM_REG_PC]);
+}