You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
377 lines
12 KiB
377 lines
12 KiB
/* |
|
* 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 <unwindstack/Regs.h> |
|
|
|
#include "ElfInterfaceArm.h" |
|
#include "Machine.h" |
|
|
|
#include "MemoryFake.h" |
|
|
|
namespace unwindstack { |
|
|
|
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]); |
|
} |
|
|
|
} // namespace unwindstack
|
|
|