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.
423 lines
13 KiB
423 lines
13 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/MachineArm.h>
|
|
#include <unwindstack/RegsArm.h>
|
|
|
|
#include "ElfInterfaceArm.h"
|
|
|
|
#include "ElfFake.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) {
|
|
ElfInterfaceArmFake 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) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
interface.FakeSetStartOffset(0);
|
|
interface.FakeSetTotalEntries(10);
|
|
|
|
uint64_t entry_offset;
|
|
ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
|
|
}
|
|
|
|
TEST_F(ElfInterfaceArmTest, FindEntry_no_entries) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
interface.FakeSetStartOffset(0x100);
|
|
interface.FakeSetTotalEntries(0);
|
|
|
|
uint64_t entry_offset;
|
|
ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
|
|
}
|
|
|
|
TEST_F(ElfInterfaceArmTest, FindEntry_no_valid_memory) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
interface.FakeSetStartOffset(0x100);
|
|
interface.FakeSetTotalEntries(2);
|
|
|
|
uint64_t entry_offset;
|
|
ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
|
|
}
|
|
|
|
TEST_F(ElfInterfaceArmTest, FindEntry_ip_before_first) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(1);
|
|
memory_.SetData32(0x1000, 0x6000);
|
|
|
|
uint64_t entry_offset;
|
|
ASSERT_FALSE(interface.FindEntry(0x1000, &entry_offset));
|
|
}
|
|
|
|
TEST_F(ElfInterfaceArmTest, FindEntry_single_entry_negative_value) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
interface.FakeSetStartOffset(0x8000);
|
|
interface.FakeSetTotalEntries(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) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(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) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(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) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(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) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(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) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(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) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(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, HandleUnknownType_arm_exidx) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(100);
|
|
|
|
// Verify that if the type is not the one we want, we don't set the values.
|
|
interface.HandleUnknownType(0x70000000, 0x2000, 320);
|
|
ASSERT_EQ(0x1000U, interface.start_offset());
|
|
ASSERT_EQ(100U, interface.total_entries());
|
|
|
|
// Everything is correct and present.
|
|
interface.HandleUnknownType(0x70000001, 0x2000, 320);
|
|
ASSERT_EQ(0x2000U, interface.start_offset());
|
|
ASSERT_EQ(40U, interface.total_entries());
|
|
}
|
|
|
|
TEST_F(ElfInterfaceArmTest, StepExidx) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
|
|
// FindEntry fails.
|
|
bool finished;
|
|
ASSERT_FALSE(interface.StepExidx(0x7000, nullptr, nullptr, &finished));
|
|
EXPECT_EQ(ERROR_UNWIND_INFO, interface.LastErrorCode());
|
|
|
|
// ExtractEntry should fail.
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(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_, &finished));
|
|
EXPECT_EQ(ERROR_MEMORY_INVALID, interface.LastErrorCode());
|
|
EXPECT_EQ(0x1004U, interface.LastErrorAddress());
|
|
|
|
// Eval should fail.
|
|
memory_.SetData32(0x1004, 0x81000000);
|
|
ASSERT_FALSE(interface.StepExidx(0x7000, ®s, &process_memory_, &finished));
|
|
EXPECT_EQ(ERROR_UNWIND_INFO, interface.LastErrorCode());
|
|
|
|
// Everything should pass.
|
|
memory_.SetData32(0x1004, 0x80b0b0b0);
|
|
ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_, &finished));
|
|
EXPECT_EQ(ERROR_UNWIND_INFO, interface.LastErrorCode());
|
|
ASSERT_FALSE(finished);
|
|
ASSERT_EQ(0x1000U, regs.sp());
|
|
ASSERT_EQ(0x1000U, regs[ARM_REG_SP]);
|
|
ASSERT_EQ(0x20000U, regs.pc());
|
|
ASSERT_EQ(0x20000U, regs[ARM_REG_PC]);
|
|
|
|
// Load bias is non-zero.
|
|
interface.set_load_bias(0x1000);
|
|
ASSERT_TRUE(interface.StepExidx(0x8000, ®s, &process_memory_, &finished));
|
|
EXPECT_EQ(ERROR_UNWIND_INFO, interface.LastErrorCode());
|
|
|
|
// Pc too small.
|
|
interface.set_load_bias(0x9000);
|
|
ASSERT_FALSE(interface.StepExidx(0x8000, ®s, &process_memory_, &finished));
|
|
EXPECT_EQ(ERROR_UNWIND_INFO, interface.LastErrorCode());
|
|
}
|
|
|
|
TEST_F(ElfInterfaceArmTest, StepExidx_pc_set) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(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.
|
|
bool finished;
|
|
ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_, &finished));
|
|
EXPECT_EQ(ERROR_NONE, interface.LastErrorCode());
|
|
ASSERT_FALSE(finished);
|
|
ASSERT_EQ(0x10004U, regs.sp());
|
|
ASSERT_EQ(0x10004U, regs[ARM_REG_SP]);
|
|
ASSERT_EQ(0x10U, regs.pc());
|
|
ASSERT_EQ(0x10U, regs[ARM_REG_PC]);
|
|
}
|
|
|
|
TEST_F(ElfInterfaceArmTest, StepExidx_cant_unwind) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(1);
|
|
memory_.SetData32(0x1000, 0x6000);
|
|
memory_.SetData32(0x1004, 1);
|
|
|
|
RegsArm regs;
|
|
regs[ARM_REG_SP] = 0x10000;
|
|
regs[ARM_REG_LR] = 0x20000;
|
|
regs.set_sp(regs[ARM_REG_SP]);
|
|
regs.set_pc(0x1234);
|
|
|
|
bool finished;
|
|
ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_, &finished));
|
|
EXPECT_EQ(ERROR_NONE, interface.LastErrorCode());
|
|
ASSERT_TRUE(finished);
|
|
ASSERT_EQ(0x10000U, regs.sp());
|
|
ASSERT_EQ(0x10000U, regs[ARM_REG_SP]);
|
|
ASSERT_EQ(0x1234U, regs.pc());
|
|
}
|
|
|
|
TEST_F(ElfInterfaceArmTest, StepExidx_refuse_unwind) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(1);
|
|
memory_.SetData32(0x1000, 0x6000);
|
|
memory_.SetData32(0x1004, 0x808000b0);
|
|
|
|
RegsArm regs;
|
|
regs[ARM_REG_SP] = 0x10000;
|
|
regs[ARM_REG_LR] = 0x20000;
|
|
regs.set_sp(regs[ARM_REG_SP]);
|
|
regs.set_pc(0x1234);
|
|
|
|
bool finished;
|
|
ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_, &finished));
|
|
EXPECT_EQ(ERROR_NONE, interface.LastErrorCode());
|
|
ASSERT_TRUE(finished);
|
|
ASSERT_EQ(0x10000U, regs.sp());
|
|
ASSERT_EQ(0x10000U, regs[ARM_REG_SP]);
|
|
ASSERT_EQ(0x1234U, regs.pc());
|
|
}
|
|
|
|
TEST_F(ElfInterfaceArmTest, StepExidx_pc_zero) {
|
|
ElfInterfaceArmFake interface(&memory_);
|
|
|
|
interface.FakeSetStartOffset(0x1000);
|
|
interface.FakeSetTotalEntries(1);
|
|
memory_.SetData32(0x1000, 0x6000);
|
|
// Set the pc using a pop r15 command.
|
|
memory_.SetData32(0x1004, 0x808800b0);
|
|
|
|
// pc value of zero.
|
|
process_memory_.SetData32(0x10000, 0);
|
|
|
|
RegsArm regs;
|
|
regs[ARM_REG_SP] = 0x10000;
|
|
regs[ARM_REG_LR] = 0x20000;
|
|
regs.set_sp(regs[ARM_REG_SP]);
|
|
regs.set_pc(0x1234);
|
|
|
|
bool finished;
|
|
ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_, &finished));
|
|
EXPECT_EQ(ERROR_NONE, interface.LastErrorCode());
|
|
ASSERT_TRUE(finished);
|
|
ASSERT_EQ(0U, regs.pc());
|
|
|
|
// Now set the pc from the lr register (pop r14).
|
|
memory_.SetData32(0x1004, 0x808400b0);
|
|
|
|
regs[ARM_REG_SP] = 0x10000;
|
|
regs[ARM_REG_LR] = 0x20000;
|
|
regs.set_sp(regs[ARM_REG_SP]);
|
|
regs.set_pc(0x1234);
|
|
|
|
ASSERT_TRUE(interface.StepExidx(0x7000, ®s, &process_memory_, &finished));
|
|
EXPECT_EQ(ERROR_NONE, interface.LastErrorCode());
|
|
ASSERT_TRUE(finished);
|
|
ASSERT_EQ(0U, regs.pc());
|
|
}
|
|
|
|
} // namespace unwindstack
|