werunplugged/unplugged-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
06ee9615ad
unplugged-system/external/cronet/base/profiler/chrome_unwinder_android_unittest.cc

1644 lines
58 KiB
C++
Raw Blame History

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/profiler/chrome_unwinder_android.h"
#include "base/memory/aligned_memory.h"
#include "base/profiler/chrome_unwind_info_android.h"
#include "base/profiler/stack_sampling_profiler_test_util.h"
#include "base/ranges/algorithm.h"
#include "base/test/gtest_util.h"
#include "build/build_config.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace base {
TEST(ChromeAndroidUnwindInstructionTest,
TestSmallStackPointerIncrementMinValue) {
RegisterContext thread_context = {};
const uint8_t instruction = 0b00000000;
const uint8_t* current_instruction = &instruction;
thread_context.arm_sp = 0x10000000;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(0x10000004ul, thread_context.arm_sp);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestSmallStackPointerIncrementMidValue) {
// xxxxxx = 4; vsp = vsp + (4 << 2) + 4 = vsp + 16 + 4 = vsp + 0x14.
RegisterContext thread_context = {};
const uint8_t instruction = 0b00000100;
const uint8_t* current_instruction = &instruction;
thread_context.arm_sp = 0x10000000;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(0x10000014ul, thread_context.arm_sp);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestSmallStackPointerIncrementMaxValue) {
RegisterContext thread_context = {};
const uint8_t instruction = 0b00111111;
const uint8_t* current_instruction = &instruction;
thread_context.arm_sp = 0x10000000;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(0x10000100ul, thread_context.arm_sp);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestSmallStackPointerIncrementOverflow) {
RegisterContext thread_context = {};
const uint8_t instruction = 0b00111111;
const uint8_t* current_instruction = &instruction;
thread_context.arm_sp = 0xffffffff;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kAborted);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(0xffffffff, thread_context.arm_sp);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestSmallStackPointerDecrementMinValue) {
RegisterContext thread_context = {};
const uint8_t instruction = 0b01000000;
const uint8_t* current_instruction = &instruction;
thread_context.arm_sp = 0x10000000;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(0x0ffffffcul, thread_context.arm_sp);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestSmallStackPointerDecrementMidValue) {
// xxxxxx = 4; vsp = vsp - (4 << 2) - 4 = vsp - 16 - 4 = vsp - 0x14.
RegisterContext thread_context = {};
const uint8_t instruction = 0b01000100;
const uint8_t* current_instruction = &instruction;
thread_context.arm_sp = 0x10000000;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(0x0fffffecul, thread_context.arm_sp);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestSmallStackPointerDecrementMaxValue) {
RegisterContext thread_context = {};
const uint8_t instruction = 0b01111111;
const uint8_t* current_instruction = &instruction;
thread_context.arm_sp = 0x10000000;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(0x0fffff00ul, thread_context.arm_sp);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestSmallStackPointerDecrementUnderflow) {
RegisterContext thread_context = {};
const uint8_t instruction = 0b01111111;
const uint8_t* current_instruction = &instruction;
thread_context.arm_sp = 0x00000000;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kAborted);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(0x0ul, thread_context.arm_sp);
}
using ChromeAndroidUnwindSetStackPointerFromRegisterValueTest =
::testing::TestWithParam<uint8_t>;
INSTANTIATE_TEST_SUITE_P(
All,
ChromeAndroidUnwindSetStackPointerFromRegisterValueTest,
// The function should set all registers except
// - callee saved registers (r0, r1, r2, r3)
// - sp (r13)
// - pc (r15)
::testing::Values(4, 5, 6, 7, 8, 9, 10, 11, 12, 14));
TEST_P(ChromeAndroidUnwindSetStackPointerFromRegisterValueTest,
TestSetStackPointerFromRegisterValue) {
const uint8_t register_index = GetParam();
RegisterContext thread_context = {};
thread_context.arm_r0 = 100;
thread_context.arm_r1 = 101;
thread_context.arm_r2 = 102;
thread_context.arm_r3 = 103;
thread_context.arm_r4 = 104;
thread_context.arm_r5 = 105;
thread_context.arm_r6 = 106;
thread_context.arm_r7 = 107;
thread_context.arm_r8 = 108;
thread_context.arm_r9 = 109;
thread_context.arm_r10 = 110;
thread_context.arm_fp = 111; // r11
thread_context.arm_ip = 112; // r12
thread_context.arm_lr = 114; // r14
const uint8_t instruction = 0b10010000 + register_index;
const uint8_t* current_instruction = &instruction;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(100ul + register_index, thread_context.arm_sp);
}
TEST(ChromeAndroidUnwindInstructionTest, TestCompleteWithNoPriorPCUpdate) {
RegisterContext thread_context = {};
thread_context.arm_lr = 114; // r14
thread_context.arm_pc = 115; // r15
const uint8_t instruction = 0b10110000;
const uint8_t* current_instruction = &instruction;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kCompleted);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(114ul, thread_context.arm_pc);
}
TEST(ChromeAndroidUnwindInstructionTest, TestCompleteWithPriorPCUpdate) {
RegisterContext thread_context = {};
thread_context.arm_lr = 114; // r14
thread_context.arm_pc = 115; // r15
const uint8_t instruction = 0b10110000;
const uint8_t* current_instruction = &instruction;
bool pc_was_updated = true;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kCompleted);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(115ul, thread_context.arm_pc);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestPopDiscontinuousRegistersIncludingPC) {
RegisterContext thread_context = {};
thread_context.arm_r0 = 100;
thread_context.arm_r1 = 101;
thread_context.arm_r2 = 102;
thread_context.arm_r3 = 103;
thread_context.arm_r4 = 104;
thread_context.arm_r5 = 105;
thread_context.arm_r6 = 106;
thread_context.arm_r7 = 107;
thread_context.arm_r8 = 108;
thread_context.arm_r9 = 109;
thread_context.arm_r10 = 110;
thread_context.arm_fp = 111;
thread_context.arm_ip = 112;
thread_context.arm_lr = 113;
thread_context.arm_pc = 114;
// Pop up to 12 integer registers under masks {r15-r12}, {r11-r4}.
const uintptr_t stack[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
thread_context.arm_sp = reinterpret_cast<uintptr_t>(&stack[0]);
// Pop r15, r12, r8, r4.
const uint8_t instruction[] = {0b10001001, 0b00010001};
const uint8_t* current_instruction = instruction;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_TRUE(pc_was_updated);
ASSERT_EQ(current_instruction, instruction + 2);
EXPECT_EQ(reinterpret_cast<uintptr_t>(&stack[0] + 4), thread_context.arm_sp);
EXPECT_EQ(100ul, thread_context.arm_r0);
EXPECT_EQ(101ul, thread_context.arm_r1);
EXPECT_EQ(102ul, thread_context.arm_r2);
EXPECT_EQ(103ul, thread_context.arm_r3);
EXPECT_EQ(1ul, thread_context.arm_r4);
EXPECT_EQ(105ul, thread_context.arm_r5);
EXPECT_EQ(106ul, thread_context.arm_r6);
EXPECT_EQ(107ul, thread_context.arm_r7);
EXPECT_EQ(2ul, thread_context.arm_r8);
EXPECT_EQ(109ul, thread_context.arm_r9);
EXPECT_EQ(110ul, thread_context.arm_r10);
EXPECT_EQ(111ul, thread_context.arm_fp);
EXPECT_EQ(3ul, thread_context.arm_ip);
EXPECT_EQ(113ul, thread_context.arm_lr);
EXPECT_EQ(4ul, thread_context.arm_pc);
}
TEST(ChromeAndroidUnwindInstructionTest, TestPopDiscontinuousRegisters) {
RegisterContext thread_context = {};
thread_context.arm_r0 = 100;
thread_context.arm_r1 = 101;
thread_context.arm_r2 = 102;
thread_context.arm_r3 = 103;
thread_context.arm_r4 = 104;
thread_context.arm_r5 = 105;
thread_context.arm_r6 = 106;
thread_context.arm_r7 = 107;
thread_context.arm_r8 = 108;
thread_context.arm_r9 = 109;
thread_context.arm_r10 = 110;
thread_context.arm_fp = 111;
thread_context.arm_ip = 112;
thread_context.arm_lr = 113;
thread_context.arm_pc = 114;
// Pop up to 12 integer registers under masks {r15-r12}, {r11-r4}.
const uintptr_t stack[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
thread_context.arm_sp = reinterpret_cast<uintptr_t>(&stack[0]);
// Pop r12, r8, r4.
const uint8_t instruction[] = {0b10000001, 0b00010001};
const uint8_t* current_instruction = instruction;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, instruction + 2);
EXPECT_EQ(reinterpret_cast<uintptr_t>(&stack[0] + 3), thread_context.arm_sp);
EXPECT_EQ(100ul, thread_context.arm_r0);
EXPECT_EQ(101ul, thread_context.arm_r1);
EXPECT_EQ(102ul, thread_context.arm_r2);
EXPECT_EQ(103ul, thread_context.arm_r3);
EXPECT_EQ(1ul, thread_context.arm_r4);
EXPECT_EQ(105ul, thread_context.arm_r5);
EXPECT_EQ(106ul, thread_context.arm_r6);
EXPECT_EQ(107ul, thread_context.arm_r7);
EXPECT_EQ(2ul, thread_context.arm_r8);
EXPECT_EQ(109ul, thread_context.arm_r9);
EXPECT_EQ(110ul, thread_context.arm_r10);
EXPECT_EQ(111ul, thread_context.arm_fp);
EXPECT_EQ(3ul, thread_context.arm_ip);
EXPECT_EQ(113ul, thread_context.arm_lr);
EXPECT_EQ(114ul, thread_context.arm_pc);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestPopDiscontinuousRegistersOverflow) {
RegisterContext thread_context = {};
thread_context.arm_r0 = 100;
thread_context.arm_r1 = 101;
thread_context.arm_r2 = 102;
thread_context.arm_r3 = 103;
thread_context.arm_r4 = 104;
thread_context.arm_r5 = 105;
thread_context.arm_r6 = 106;
thread_context.arm_r7 = 107;
thread_context.arm_r8 = 108;
thread_context.arm_r9 = 109;
thread_context.arm_r10 = 110;
thread_context.arm_fp = 111;
thread_context.arm_ip = 112;
thread_context.arm_lr = 113;
thread_context.arm_pc = 114;
// Pop up to 12 integer registers under masks {r15-r12}, {r11-r4}.
thread_context.arm_sp = 0xffffffff;
// Pop r15, r12, r8, r4.
const uint8_t instruction[] = {0b10001001, 0b00010001};
const uint8_t* current_instruction = instruction;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kAborted);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, instruction + 2);
EXPECT_EQ(0xffffffff, thread_context.arm_sp);
EXPECT_EQ(100ul, thread_context.arm_r0);
EXPECT_EQ(101ul, thread_context.arm_r1);
EXPECT_EQ(102ul, thread_context.arm_r2);
EXPECT_EQ(103ul, thread_context.arm_r3);
EXPECT_EQ(104ul, thread_context.arm_r4);
EXPECT_EQ(105ul, thread_context.arm_r5);
EXPECT_EQ(106ul, thread_context.arm_r6);
EXPECT_EQ(107ul, thread_context.arm_r7);
EXPECT_EQ(108ul, thread_context.arm_r8);
EXPECT_EQ(109ul, thread_context.arm_r9);
EXPECT_EQ(110ul, thread_context.arm_r10);
EXPECT_EQ(111ul, thread_context.arm_fp);
EXPECT_EQ(112ul, thread_context.arm_ip);
EXPECT_EQ(113ul, thread_context.arm_lr);
EXPECT_EQ(114ul, thread_context.arm_pc);
}
TEST(ChromeAndroidUnwindInstructionTest, TestRefuseToUnwind) {
RegisterContext thread_context = {};
const uint8_t instruction[] = {0b10000000, 0b0};
const uint8_t* current_instruction = instruction;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kAborted);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, instruction + 2);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestPopRegistersIncludingR14MinRegisters) {
RegisterContext thread_context = {};
thread_context.arm_r0 = 100;
thread_context.arm_r1 = 101;
thread_context.arm_r2 = 102;
thread_context.arm_r3 = 103;
thread_context.arm_r4 = 104;
thread_context.arm_r5 = 105;
thread_context.arm_r6 = 106;
thread_context.arm_r7 = 107;
thread_context.arm_r8 = 108;
thread_context.arm_r9 = 109;
thread_context.arm_r10 = 110;
thread_context.arm_fp = 111;
thread_context.arm_ip = 112;
thread_context.arm_lr = 113;
// Popping r4 - r[4 + nnn], r14, at most 9 registers.
// r14 = lr
const uintptr_t stack[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
thread_context.arm_sp = reinterpret_cast<uintptr_t>(&stack[0]);
const uint8_t instruction = 0b10101000;
const uint8_t* current_instruction = &instruction;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(reinterpret_cast<uintptr_t>(&stack[0] + 2), thread_context.arm_sp);
EXPECT_EQ(100ul, thread_context.arm_r0);
EXPECT_EQ(101ul, thread_context.arm_r1);
EXPECT_EQ(102ul, thread_context.arm_r2);
EXPECT_EQ(103ul, thread_context.arm_r3);
EXPECT_EQ(1ul, thread_context.arm_r4);
EXPECT_EQ(105ul, thread_context.arm_r5);
EXPECT_EQ(106ul, thread_context.arm_r6);
EXPECT_EQ(107ul, thread_context.arm_r7);
EXPECT_EQ(108ul, thread_context.arm_r8);
EXPECT_EQ(109ul, thread_context.arm_r9);
EXPECT_EQ(110ul, thread_context.arm_r10);
EXPECT_EQ(111ul, thread_context.arm_fp);
EXPECT_EQ(112ul, thread_context.arm_ip);
EXPECT_EQ(2ul, thread_context.arm_lr);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestPopRegistersIncludingR14MidRegisters) {
RegisterContext thread_context = {};
thread_context.arm_r0 = 100;
thread_context.arm_r1 = 101;
thread_context.arm_r2 = 102;
thread_context.arm_r3 = 103;
thread_context.arm_r4 = 104;
thread_context.arm_r5 = 105;
thread_context.arm_r6 = 106;
thread_context.arm_r7 = 107;
thread_context.arm_r8 = 108;
thread_context.arm_r9 = 109;
thread_context.arm_r10 = 110;
thread_context.arm_fp = 111;
thread_context.arm_ip = 112;
thread_context.arm_lr = 113;
// Popping r4 - r[4 + nnn], r14, at most 9 registers.
// r14 = lr
const uintptr_t stack[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
thread_context.arm_sp = reinterpret_cast<uintptr_t>(&stack[0]);
const uint8_t instruction = 0b10101100; // Pop r4-r8, r14.
const uint8_t* current_instruction = &instruction;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(reinterpret_cast<uintptr_t>(&stack[0] + 6), thread_context.arm_sp);
EXPECT_EQ(100ul, thread_context.arm_r0);
EXPECT_EQ(101ul, thread_context.arm_r1);
EXPECT_EQ(102ul, thread_context.arm_r2);
EXPECT_EQ(103ul, thread_context.arm_r3);
EXPECT_EQ(1ul, thread_context.arm_r4);
EXPECT_EQ(2ul, thread_context.arm_r5);
EXPECT_EQ(3ul, thread_context.arm_r6);
EXPECT_EQ(4ul, thread_context.arm_r7);
EXPECT_EQ(5ul, thread_context.arm_r8);
EXPECT_EQ(109ul, thread_context.arm_r9);
EXPECT_EQ(110ul, thread_context.arm_r10);
EXPECT_EQ(111ul, thread_context.arm_fp);
EXPECT_EQ(112ul, thread_context.arm_ip);
EXPECT_EQ(6ul, thread_context.arm_lr);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestPopRegistersIncludingR14MaxRegisters) {
RegisterContext thread_context = {};
thread_context.arm_r0 = 100;
thread_context.arm_r1 = 101;
thread_context.arm_r2 = 102;
thread_context.arm_r3 = 103;
thread_context.arm_r4 = 104;
thread_context.arm_r5 = 105;
thread_context.arm_r6 = 106;
thread_context.arm_r7 = 107;
thread_context.arm_r8 = 108;
thread_context.arm_r9 = 109;
thread_context.arm_r10 = 110;
thread_context.arm_fp = 111;
thread_context.arm_ip = 112;
thread_context.arm_lr = 113;
// Popping r4 - r[4 + nnn], r14, at most 9 registers.
// r14 = lr
const uintptr_t stack[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
thread_context.arm_sp = reinterpret_cast<uintptr_t>(&stack[0]);
const uint8_t instruction = 0b10101111; // Pop r4 - r11, r14.
const uint8_t* current_instruction = &instruction;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(reinterpret_cast<uintptr_t>(&stack[0] + 9), thread_context.arm_sp);
EXPECT_EQ(100ul, thread_context.arm_r0);
EXPECT_EQ(101ul, thread_context.arm_r1);
EXPECT_EQ(102ul, thread_context.arm_r2);
EXPECT_EQ(103ul, thread_context.arm_r3);
EXPECT_EQ(1ul, thread_context.arm_r4);
EXPECT_EQ(2ul, thread_context.arm_r5);
EXPECT_EQ(3ul, thread_context.arm_r6);
EXPECT_EQ(4ul, thread_context.arm_r7);
EXPECT_EQ(5ul, thread_context.arm_r8);
EXPECT_EQ(6ul, thread_context.arm_r9);
EXPECT_EQ(7ul, thread_context.arm_r10);
EXPECT_EQ(8ul, thread_context.arm_fp);
EXPECT_EQ(112ul, thread_context.arm_ip);
EXPECT_EQ(9ul, thread_context.arm_lr);
}
TEST(ChromeAndroidUnwindInstructionTest, TestPopRegistersIncludingR14Overflow) {
RegisterContext thread_context = {};
thread_context.arm_r0 = 100;
thread_context.arm_r1 = 101;
thread_context.arm_r2 = 102;
thread_context.arm_r3 = 103;
thread_context.arm_r4 = 104;
thread_context.arm_r5 = 105;
thread_context.arm_r6 = 106;
thread_context.arm_r7 = 107;
thread_context.arm_r8 = 108;
thread_context.arm_r9 = 109;
thread_context.arm_r10 = 110;
thread_context.arm_fp = 111;
thread_context.arm_ip = 112;
thread_context.arm_lr = 113;
// Popping r4 - r[4 + nnn], r14, at most 9 registers.
// r14 = lr
thread_context.arm_sp = 0xffffffff;
const uint8_t instruction = 0b10101111; // Pop r4 - r11, r14.
const uint8_t* current_instruction = &instruction;
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kAborted);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, &instruction + 1);
EXPECT_EQ(0xffffffff, thread_context.arm_sp);
EXPECT_EQ(100ul, thread_context.arm_r0);
EXPECT_EQ(101ul, thread_context.arm_r1);
EXPECT_EQ(102ul, thread_context.arm_r2);
EXPECT_EQ(103ul, thread_context.arm_r3);
EXPECT_EQ(104ul, thread_context.arm_r4);
EXPECT_EQ(105ul, thread_context.arm_r5);
EXPECT_EQ(106ul, thread_context.arm_r6);
EXPECT_EQ(107ul, thread_context.arm_r7);
EXPECT_EQ(108ul, thread_context.arm_r8);
EXPECT_EQ(109ul, thread_context.arm_r9);
EXPECT_EQ(110ul, thread_context.arm_r10);
EXPECT_EQ(111ul, thread_context.arm_fp);
EXPECT_EQ(112ul, thread_context.arm_ip);
EXPECT_EQ(113ul, thread_context.arm_lr);
}
TEST(ChromeAndroidUnwindInstructionTest, TestBigStackPointerIncrementMinValue) {
RegisterContext thread_context = {};
thread_context.arm_sp = 0x10000000;
const uint8_t increment_0[] = {
0b10110010,
0b00000000,
};
const uint8_t* current_instruction = &increment_0[0];
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, increment_0 + sizeof(increment_0));
// vsp + 0x204 + (0 << 2)
// = vsp + 0x204
EXPECT_EQ(0x10000204ul, thread_context.arm_sp);
}
TEST(ChromeAndroidUnwindInstructionTest, TestBigStackPointerIncrementMidValue) {
RegisterContext thread_context = {};
thread_context.arm_sp = 0x10000000;
const uint8_t increment_4[] = {
0b10110010,
0b00000100,
};
const uint8_t* current_instruction = &increment_4[0];
// vsp + 0x204 + (4 << 2)
// = vsp + 0x204 + 0x10
// = vsp + 0x214
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, increment_4 + sizeof(increment_4));
EXPECT_EQ(0x10000214ul, thread_context.arm_sp);
}
TEST(ChromeAndroidUnwindInstructionTest,
TestBigStackPointerIncrementLargeValue) {
RegisterContext thread_context = {};
thread_context.arm_sp = 0x10000000;
const uint8_t increment_128[] = {
0b10110010,
0b10000000,
0b00000001,
};
const uint8_t* current_instruction = &increment_128[0];
// vsp + 0x204 + (128 << 2)
// = vsp + 0x204 + 512
// = vsp + 0x204 + 0x200
// = vsp + 0x404
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kInstructionPending);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction, increment_128 + sizeof(increment_128));
EXPECT_EQ(0x10000404ul, thread_context.arm_sp);
}
TEST(ChromeAndroidUnwindInstructionTest, TestBigStackPointerIncrementOverflow) {
RegisterContext thread_context = {};
thread_context.arm_sp = 0xffffffff;
const uint8_t increment_overflow[] = {
0b10110010,
0b10000000,
0b00000001,
}; // ULEB128 = 128
const uint8_t* current_instruction = &increment_overflow[0];
bool pc_was_updated = false;
ASSERT_EQ(ExecuteUnwindInstruction(current_instruction, pc_was_updated,
&thread_context),
UnwindInstructionResult::kAborted);
EXPECT_FALSE(pc_was_updated);
ASSERT_EQ(current_instruction,
increment_overflow + sizeof(increment_overflow));
EXPECT_EQ(0xfffffffful, thread_context.arm_sp);
}
TEST(ChromeUnwinderAndroidTest,
TestFunctionOffsetTableLookupExactMatchingOffset) {
const uint8_t function_offset_table[] = {
// Function 1: [(130, 2), (128, 3), (0, 4)]
// offset = 130
0b10000010,
0b00000001,
// unwind index = 2
0b00000010,
// offset = 128
0b10000000,
0b00000001,
// unwind index = 3
0b00000011,
// offset = 0
0b00000000,
// unwind index = 4
0b00000100,
};
EXPECT_EQ(3ul, GetFirstUnwindInstructionIndexFromFunctionOffsetTableEntry(
&function_offset_table[0],
/* instruction_offset_from_function_start */ 128));
}
TEST(ChromeUnwinderAndroidTest,
TestFunctionOffsetTableLookupNonExactMatchingOffset) {
const uint8_t function_offset_table[] = {
// Function 1: [(130, 2), (128, 3), (0, 4)]
// offset = 130
0b10000010,
0b00000001,
// unwind index = 2
0b00000010,
// offset = 128
0b10000000,
0b00000001,
// unwind index = 3
0b00000011,
// offset = 0
0b00000000,
// unwind index = 4
0b00000100,
};
EXPECT_EQ(3ul, GetFirstUnwindInstructionIndexFromFunctionOffsetTableEntry(
&function_offset_table[0],
/* instruction_offset_from_function_start */ 129));
}
TEST(ChromeUnwinderAndroidTest, TestFunctionOffsetTableLookupZeroOffset) {
const uint8_t function_offset_table[] = {
// Function 1: [(130, 2), (128, 3), (0, 4)]
// offset = 130
0b10000010,
0b00000001,
// unwind index = 2
0b00000010,
// offset = 128
0b10000000,
0b00000001,
// unwind index = 3
0b00000011,
// offset = 0
0b00000000,
// unwind index = 4
0b00000100,
};
EXPECT_EQ(4ul, GetFirstUnwindInstructionIndexFromFunctionOffsetTableEntry(
&function_offset_table[0],
/* instruction_offset_from_function_start */ 0));
}
TEST(ChromeUnwinderAndroidTest, TestAddressTableLookupEntryInPage) {
const uint32_t page_start_instructions[] = {0, 2};
const FunctionTableEntry function_offset_table_indices[] = {
// Page 0
{
/* function_start_address_page_instruction_offset */ 0,
/* function_offset_table_byte_index */ 20,
},
{
/* function_start_address_page_instruction_offset */ 4,
/* function_offset_table_byte_index */ 40,
},
// Page 1
{
/* function_start_address_page_instruction_offset */ 6,
/* function_offset_table_byte_index */ 70,
},
};
{
const uint32_t page_number = 0;
const uint32_t page_instruction_offset = 4;
const auto entry_found = GetFunctionTableIndexFromInstructionOffset(
page_start_instructions, function_offset_table_indices,
/* instruction_offset */ (page_instruction_offset << 1) +
(page_number << 17));
ASSERT_NE(absl::nullopt, entry_found);
EXPECT_EQ(0, entry_found->instruction_offset_from_function_start);
EXPECT_EQ(40ul, entry_found->function_offset_table_byte_index);
}
{
const uint32_t page_number = 0;
const uint32_t page_instruction_offset = 50;
const auto entry_found = GetFunctionTableIndexFromInstructionOffset(
page_start_instructions, function_offset_table_indices,
/* instruction_offset */ (page_instruction_offset << 1) +
(page_number << 17));
ASSERT_NE(absl::nullopt, entry_found);
EXPECT_EQ(46, entry_found->instruction_offset_from_function_start);
EXPECT_EQ(40ul, entry_found->function_offset_table_byte_index);
}
// Lookup last instruction in last function.
{
const uint32_t page_number = 1;
const uint32_t page_instruction_offset = 0xffff;
const auto entry_found = GetFunctionTableIndexFromInstructionOffset(
page_start_instructions, function_offset_table_indices,
/* instruction_offset */ (page_instruction_offset << 1) +
(page_number << 17));
ASSERT_NE(absl::nullopt, entry_found);
// 0xffff - 6 = 0xfff9.
EXPECT_EQ(0xfff9, entry_found->instruction_offset_from_function_start);
EXPECT_EQ(70ul, entry_found->function_offset_table_byte_index);
}
}
TEST(ChromeUnwinderAndroidTest, TestAddressTableLookupEmptyPage) {
const uint32_t page_start_instructions[] = {0, 1, 1};
const FunctionTableEntry function_offset_table_indices[] = {
// Page 0
{
/* function_start_address_page_instruction_offset */ 0,
/* function_offset_table_byte_index */ 20,
},
// Page 1 is empty
// Page 2
{
/* function_start_address_page_instruction_offset */ 6,
/* function_offset_table_byte_index */ 70,
},
};
const uint32_t page_number = 1;
const uint32_t page_instruction_offset = 4;
const auto entry_found = GetFunctionTableIndexFromInstructionOffset(
page_start_instructions, function_offset_table_indices,
/* instruction_offset */ (page_instruction_offset << 1) +
(page_number << 17));
ASSERT_NE(absl::nullopt, entry_found);
EXPECT_EQ(0x10004, entry_found->instruction_offset_from_function_start);
EXPECT_EQ(20ul, entry_found->function_offset_table_byte_index);
}
TEST(ChromeUnwinderAndroidTest, TestAddressTableLookupInvalidIntructionOffset) {
const uint32_t page_start_instructions[] = {0, 1};
const FunctionTableEntry function_offset_table_indices[] = {
// Page 0
// This function spans from page 0 offset 0 to page 1 offset 5.
{
/* function_start_address_page_instruction_offset */ 0,
/* function_offset_table_byte_index */ 20,
},
// Page 1
{
/* function_start_address_page_instruction_offset */ 6,
/* function_offset_table_byte_index */ 70,
},
};
// Instruction offset lies after last page on page table.
{
const uint32_t page_number = 50;
const uint32_t page_instruction_offset = 6;
const auto entry_found = GetFunctionTableIndexFromInstructionOffset(
page_start_instructions, function_offset_table_indices,
/* instruction_offset */ (page_instruction_offset << 1) +
(page_number << 17));
ASSERT_EQ(absl::nullopt, entry_found);
}
{
const uint32_t page_number = 2;
const uint32_t page_instruction_offset = 0;
const auto entry_found = GetFunctionTableIndexFromInstructionOffset(
page_start_instructions, function_offset_table_indices,
/* instruction_offset */ (page_instruction_offset << 1) +
(page_number << 17));
ASSERT_EQ(absl::nullopt, entry_found);
}
}
TEST(ChromeUnwinderAndroidTest,
TestAddressTableLookupOnSecondPageOfFunctionSpanningPageBoundary) {
const uint32_t page_start_instructions[] = {0, 1, 2};
const FunctionTableEntry function_offset_table_indices[] = {
// Page 0
{
/* function_start_address_page_instruction_offset */ 0,
/* function_offset_table_byte_index */ 20,
},
// Page 1
{
/* function_start_address_page_instruction_offset */ 6,
/* function_offset_table_byte_index */ 70,
},
// Page 2
{
/* function_start_address_page_instruction_offset */ 10,
/* function_offset_table_byte_index */ 80,
}};
const uint32_t page_number = 1;
const uint32_t page_instruction_offset = 4;
const auto entry_found = GetFunctionTableIndexFromInstructionOffset(
page_start_instructions, function_offset_table_indices,
/* instruction_offset */ (page_instruction_offset << 1) +
(page_number << 17));
ASSERT_NE(absl::nullopt, entry_found);
EXPECT_EQ(0x10004, entry_found->instruction_offset_from_function_start);
EXPECT_EQ(20ul, entry_found->function_offset_table_byte_index);
}
TEST(ChromeUnwinderAndroidTest,
TestAddressTableLookupWithinFunctionSpanningMultiplePages) {
const uint32_t page_start_instructions[] = {0, 1, 1, 1};
const FunctionTableEntry function_offset_table_indices[] = {
// Page 0
// This function spans from page 0 offset 0 to page 3 offset 5.
{
/* function_start_address_page_instruction_offset */ 0,
/* function_offset_table_byte_index */ 20,
},
// Page 1 is empty
// Page 2 is empty
// Page 3
{
/* function_start_address_page_instruction_offset */ 6,
/* function_offset_table_byte_index */ 70,
},
};
{
const uint32_t page_number = 0;
const uint32_t page_instruction_offset = 4;
const auto entry_found = GetFunctionTableIndexFromInstructionOffset(
page_start_instructions, function_offset_table_indices,
/* instruction_offset */ (page_instruction_offset << 1) +
(page_number << 17));
ASSERT_NE(absl::nullopt, entry_found);
EXPECT_EQ(0x4, entry_found->instruction_offset_from_function_start);
EXPECT_EQ(20ul, entry_found->function_offset_table_byte_index);
}
{
const uint32_t page_number = 1;
const uint32_t page_instruction_offset = 4;
const auto entry_found = GetFunctionTableIndexFromInstructionOffset(
page_start_instructions, function_offset_table_indices,
/* instruction_offset */ (page_instruction_offset << 1) +
(page_number << 17));
ASSERT_NE(absl::nullopt, entry_found);
EXPECT_EQ(0x10004, entry_found->instruction_offset_from_function_start);
EXPECT_EQ(20ul, entry_found->function_offset_table_byte_index);
}
{
const uint32_t page_number = 2;
const uint32_t page_instruction_offset = 4;
const auto entry_found = GetFunctionTableIndexFromInstructionOffset(
page_start_instructions, function_offset_table_indices,
/* instruction_offset */ (page_instruction_offset << 1) +
(page_number << 17));
ASSERT_NE(absl::nullopt, entry_found);
EXPECT_EQ(0x20004, entry_found->instruction_offset_from_function_start);
EXPECT_EQ(20ul, entry_found->function_offset_table_byte_index);
}
{
const uint32_t page_number = 3;
const uint32_t page_instruction_offset = 4;
const auto entry_found = GetFunctionTableIndexFromInstructionOffset(
page_start_instructions, function_offset_table_indices,
/* instruction_offset */ (page_instruction_offset << 1) +
(page_number << 17));
ASSERT_NE(absl::nullopt, entry_found);
EXPECT_EQ(0x30004, entry_found->instruction_offset_from_function_start);
EXPECT_EQ(20ul, entry_found->function_offset_table_byte_index);
}
}
// Utility function to add a single native module during test setup. Returns
// a pointer to the provided module.
const ModuleCache::Module* AddNativeModule(
ModuleCache* cache,
std::unique_ptr<const ModuleCache::Module> module) {
const ModuleCache::Module* module_ptr = module.get();
cache->AddCustomNativeModule(std::move(module));
return module_ptr;
}
TEST(ChromeUnwinderAndroidTest, CanUnwindFrom) {
const uint32_t page_table[] = {0};
const FunctionTableEntry function_table[] = {{0, 0}};
const uint8_t function_offset_table[] = {0};
const uint8_t unwind_instruction_table[] = {0};
auto dummy_unwind_info = ChromeUnwindInfoAndroid{
make_span(unwind_instruction_table, 1ul),
make_span(function_offset_table, 1ul),
make_span(function_table, 1ul),
make_span(page_table, 1ul),
};
auto chrome_module = std::make_unique<TestModule>(0x1000, 0x500);
auto non_chrome_module = std::make_unique<TestModule>(0x2000, 0x500);
ModuleCache module_cache;
ChromeUnwinderAndroid unwinder(dummy_unwind_info,
chrome_module->GetBaseAddress(),
/* text_section_start_address */
chrome_module->GetBaseAddress() + 4);
unwinder.Initialize(&module_cache);
EXPECT_TRUE(unwinder.CanUnwindFrom({0x1100, chrome_module.get()}));
EXPECT_TRUE(unwinder.CanUnwindFrom({0x1000, chrome_module.get()}));
EXPECT_FALSE(unwinder.CanUnwindFrom({0x2100, non_chrome_module.get()}));
EXPECT_FALSE(unwinder.CanUnwindFrom({0x400, nullptr}));
}
namespace {
void ExpectFramesEq(const std::vector<Frame>& expected,
const std::vector<Frame>& actual) {
EXPECT_EQ(actual.size(), expected.size());
if (actual.size() != expected.size())
return;
for (size_t i = 0; i < actual.size(); i++) {
EXPECT_EQ(expected[i].module, actual[i].module);
EXPECT_EQ(expected[i].instruction_pointer, actual[i].instruction_pointer);
}
}
class AlignedStackMemory {
public:
AlignedStackMemory(std::initializer_list<uintptr_t> values)
: size_(values.size()),
stack_memory_(static_cast<uintptr_t*>(
AlignedAlloc(size_ * sizeof(uintptr_t), 2 * sizeof(uintptr_t)))) {
DCHECK_EQ(size_ % 2, 0u);
ranges::copy(values, stack_memory_.get());
}
uintptr_t stack_start_address() const {
return reinterpret_cast<uintptr_t>(stack_memory_.get());
}
uintptr_t stack_end_address() const {
return reinterpret_cast<uintptr_t>(stack_memory_.get() + size_);
}
private:
const uintptr_t size_;
const std::unique_ptr<uintptr_t, AlignedFreeDeleter> stack_memory_;
};
} // namespace
TEST(ChromeUnwinderAndroidTest, TryUnwind) {
const uint32_t page_table[] = {0, 2};
const size_t number_of_pages = std::size(page_table);
const size_t page_size = 1 << 17;
const FunctionTableEntry function_table[] = {
// Page 0.
{0, 0}, // Function 0.
{0x10, 4}, // Function 1. The function to unwind 2 times.
// Page 1.
{0x5, 8}, // Function 2.
{0x20, 12}, // Function 3.
};
const uint8_t function_offset_table[] = {
// Function 0.
0x2,
0,
0x0,
1,
// Function 1.
0x7f,
0,
0x0,
1,
// Function 2.
0x78,
0,
0x0,
1,
// Function 3.
0x2,
0,
0x0,
1,
};
const uint8_t unwind_instruction_table[] = {
// Offset 0: Pop r4, r14 from stack top.
// Need to pop 2 registers to keep SP aligned.
0b10101000,
// Offset 1: COMPLETE.
0b10110000,
};
auto unwind_info = ChromeUnwindInfoAndroid{
make_span(unwind_instruction_table, std::size(unwind_instruction_table)),
make_span(function_offset_table, std::size(function_offset_table)),
make_span(function_table, std::size(function_table)),
make_span(page_table, std::size(page_table)),
};
ModuleCache module_cache;
const ModuleCache::Module* chrome_module = AddNativeModule(
&module_cache, std::make_unique<TestModule>(
0x1000, number_of_pages * page_size, "ChromeModule"));
uintptr_t text_section_start_address = 0x1100;
ChromeUnwinderAndroid unwinder(unwind_info, chrome_module->GetBaseAddress(),
text_section_start_address);
unwinder.Initialize(&module_cache);
// Both first_pc and second_pc lie in Function 1's address range.
uintptr_t first_pc = text_section_start_address + 0x20;
uintptr_t second_pc = text_section_start_address + page_size + 0x4;
// third_pc lies outside chrome_module's address range.
uintptr_t third_pc = text_section_start_address + 3 * page_size;
AlignedStackMemory stack_memory = {
0x0,
third_pc,
0xFFFF,
0xFFFF,
};
std::vector<Frame> unwound_frames = {{first_pc, chrome_module}};
RegisterContext context;
RegisterContextInstructionPointer(&context) = first_pc;
RegisterContextStackPointer(&context) = stack_memory.stack_start_address();
context.arm_lr = second_pc;
EXPECT_EQ(UnwindResult::kUnrecognizedFrame,
unwinder.TryUnwind(&context, stack_memory.stack_end_address(),
&unwound_frames));
ExpectFramesEq(std::vector<Frame>({{first_pc, chrome_module},
{second_pc, chrome_module},
{third_pc, nullptr}}),
unwound_frames);
}
TEST(ChromeUnwinderAndroidTest, TryUnwindInfiniteLoopSingleFrame) {
const uint32_t page_table[] = {0, 2};
const size_t number_of_pages = std::size(page_table);
const size_t page_size = 1 << 17;
const FunctionTableEntry function_table[] = {
// Page 0.
{0x0, 0}, // Refuse to unwind filler function.
{0x10, 2}, // Function 0. The function to unwind.
// Page 1.
{0x5, 0}, // Refuse to unwind filler function.
};
const uint8_t function_offset_table[] = {
// Refuse to unwind filler function.
0x0,
0,
// Function 0.
0x0,
2,
};
const uint8_t unwind_instruction_table[] = {
// Offset 0: REFUSE_TO_UNWIND.
0b10000000,
0b00000000,
// Offset 2: COMPLETE.
0b10110000,
};
auto unwind_info = ChromeUnwindInfoAndroid{
make_span(unwind_instruction_table, std::size(unwind_instruction_table)),
make_span(function_offset_table, std::size(function_offset_table)),
make_span(function_table, std::size(function_table)),
make_span(page_table, std::size(page_table)),
};
ModuleCache module_cache;
const ModuleCache::Module* chrome_module = AddNativeModule(
&module_cache, std::make_unique<TestModule>(
0x1000, number_of_pages * page_size, "ChromeModule"));
uintptr_t text_section_start_address = 0x1100;
ChromeUnwinderAndroid unwinder(unwind_info, chrome_module->GetBaseAddress(),
text_section_start_address);
unwinder.Initialize(&module_cache);
uintptr_t pc = text_section_start_address + 0x20;
AlignedStackMemory stack_memory = {
0xFFFF,
0xFFFF,
};
std::vector<Frame> unwound_frames = {{pc, chrome_module}};
RegisterContext context;
RegisterContextInstructionPointer(&context) = pc;
RegisterContextStackPointer(&context) = stack_memory.stack_start_address();
// Set lr = pc so that both sp and pc stays the same after first round of
// unwind.
context.arm_lr = pc;
EXPECT_EQ(UnwindResult::kAborted,
unwinder.TryUnwind(&context, stack_memory.stack_end_address(),
&unwound_frames));
ExpectFramesEq(std::vector<Frame>({{pc, chrome_module}}), unwound_frames);
}
TEST(ChromeUnwinderAndroidTest, TryUnwindInfiniteLoopMultipleFrames) {
// This test aims to produce a scenario, where after the unwind of a number
// of frames, the sp and pc get to their original state before the unwind.
// Function 1 (pc1, sp1):
// - set pc = lr(pc2)
// Function 2 (pc2, sp1):
// - pop r14(pc2), r15(pc1) off stack
// - vsp = r4 (reset vsp to frame initial vsp)
const uint32_t page_table[] = {0, 3};
const size_t number_of_pages = std::size(page_table);
const size_t page_size = 1 << 17;
const FunctionTableEntry function_table[] = {
// Page 0.
{0x0, 0}, // Refuse to unwind filler function.
{0x10, 2}, // Function 1. The function to unwind.
{0x100, 2}, // Function 2. The function to unwind.
// Page 1.
{0x5, 0}, // Refuse to unwind filler function.
};
const uint8_t function_offset_table[] = {
// Refuse to unwind filler function.
0x0,
0,
// Function 0.
0x0,
2,
// Function 1.
0x2,
3,
0x1,
5,
0x0,
6,
};
const uint8_t unwind_instruction_table[] = {
// Offset 0: REFUSE_TO_UNWIND.
0b10000000,
0b00000000,
// Offset 2: COMPLETE.
0b10110000,
// Offset 3: POP r14, r15 off the stack.
0b10001100,
0b00000000,
// Offset 5: vsp = r4.
0b10010100,
// Offset 6: COMPLETE.
0b10110000,
};
auto unwind_info = ChromeUnwindInfoAndroid{
make_span(unwind_instruction_table, std::size(unwind_instruction_table)),
make_span(function_offset_table, std::size(function_offset_table)),
make_span(function_table, std::size(function_table)),
make_span(page_table, std::size(page_table)),
};
ModuleCache module_cache;
const ModuleCache::Module* chrome_module = AddNativeModule(
&module_cache, std::make_unique<TestModule>(
0x1000, number_of_pages * page_size, "ChromeModule"));
uintptr_t text_section_start_address = 0x1100;
ChromeUnwinderAndroid unwinder(unwind_info, chrome_module->GetBaseAddress(),
text_section_start_address);
unwinder.Initialize(&module_cache);
uintptr_t first_pc = text_section_start_address + 0x20; // Function 1.
uintptr_t second_pc = text_section_start_address + 0x110; // Function 2.
AlignedStackMemory stack_memory = {
second_pc,
first_pc,
0xFFFF,
0xFFFF,
};
std::vector<Frame> unwound_frames = {{first_pc, chrome_module}};
RegisterContext context;
RegisterContextInstructionPointer(&context) = first_pc;
RegisterContextStackPointer(&context) = stack_memory.stack_start_address();
context.arm_lr = second_pc;
context.arm_r4 = stack_memory.stack_start_address();
EXPECT_EQ(UnwindResult::kAborted,
unwinder.TryUnwind(&context, stack_memory.stack_end_address(),
&unwound_frames));
ExpectFramesEq(std::vector<Frame>(
{{first_pc, chrome_module}, {second_pc, chrome_module}}),
unwound_frames);
}
TEST(ChromeUnwinderAndroidTest, TryUnwindUnalignedSPFrameUnwind) {
// SP should be 2-uintptr_t aligned before/after each frame unwind.
const uint32_t page_table[] = {0, 2};
const size_t number_of_pages = std::size(page_table);
const size_t page_size = 1 << 17;
const FunctionTableEntry function_table[] = {
// Page 0.
{0x0, 0}, // Refuse to unwind filler function.
{0x10, 2}, // Function 0. The function to unwind.
// Page 1.
{0x5, 0}, // Refuse to unwind filler function.
};
const uint8_t function_offset_table[] = {
// Refuse to unwind filler function.
0x0,
0,
// Function 0.
0x0,
2,
};
const uint8_t unwind_instruction_table[] = {
// Offset 0: REFUSE_TO_UNWIND.
0b10000000,
0b00000000,
// Offset 2: COMPLETE.
0b10110000,
};
auto unwind_info = ChromeUnwindInfoAndroid{
make_span(unwind_instruction_table, std::size(unwind_instruction_table)),
make_span(function_offset_table, std::size(function_offset_table)),
make_span(function_table, std::size(function_table)),
make_span(page_table, std::size(page_table)),
};
ModuleCache module_cache;
const ModuleCache::Module* chrome_module = AddNativeModule(
&module_cache, std::make_unique<TestModule>(
0x1000, number_of_pages * page_size, "ChromeModule"));
uintptr_t text_section_start_address = 0x1100;
ChromeUnwinderAndroid unwinder(unwind_info, chrome_module->GetBaseAddress(),
text_section_start_address);
unwinder.Initialize(&module_cache);
uintptr_t pc = text_section_start_address + 0x20;
AlignedStackMemory stack_memory = {
0xFFFF,
0xFFFF,
};
std::vector<Frame> unwound_frames = {{pc, chrome_module}};
RegisterContext context;
RegisterContextInstructionPointer(&context) = pc;
// Make stack memory not aligned to 2 * sizeof(uintptr_t);
RegisterContextStackPointer(&context) =
stack_memory.stack_start_address() + sizeof(uintptr_t);
// The address is outside chrome module, which will result the unwind to
// stop with result kUnrecognizedFrame if SP alignment issue was not detected.
context.arm_lr =
text_section_start_address + (number_of_pages + 1) * page_size;
EXPECT_EQ(UnwindResult::kAborted,
unwinder.TryUnwind(&context, stack_memory.stack_end_address(),
&unwound_frames));
ExpectFramesEq(std::vector<Frame>({{pc, chrome_module}}), unwound_frames);
}
TEST(ChromeUnwinderAndroidTest, TryUnwindUnalignedSPInstructionUnwind) {
// SP should be uintptr_t aligned before/after each unwind instruction
// execution.
const uint32_t page_table[] = {0, 2};
const size_t number_of_pages = std::size(page_table);
const size_t page_size = 1 << 17;
const FunctionTableEntry function_table[] = {
// Page 0.
{0x0, 0}, // Refuse to unwind filler function.
{0x10, 2}, // Function 0. The function to unwind.
// Page 1.
{0x5, 0}, // Refuse to unwind filler function.
};
const uint8_t function_offset_table[] = {
// Refuse to unwind filler function.
0x0,
0,
// Function 0.
0x0,
2,
};
const uint8_t unwind_instruction_table[] = {
// Offset 0: REFUSE_TO_UNWIND.
0b10000000, 0b00000000,
// Offset 2:
0b10010100, // vsp = r4, where r4 = stack + (sizeof(uintptr_t) / 2)
0b10110000, // COMPLETE.
};
auto unwind_info = ChromeUnwindInfoAndroid{
make_span(unwind_instruction_table, std::size(unwind_instruction_table)),
make_span(function_offset_table, std::size(function_offset_table)),
make_span(function_table, std::size(function_table)),
make_span(page_table, std::size(page_table)),
};
ModuleCache module_cache;
const ModuleCache::Module* chrome_module = AddNativeModule(
&module_cache, std::make_unique<TestModule>(
0x1000, number_of_pages * page_size, "ChromeModule"));
uintptr_t text_section_start_address = 0x1100;
ChromeUnwinderAndroid unwinder(unwind_info, chrome_module->GetBaseAddress(),
text_section_start_address);
unwinder.Initialize(&module_cache);
uintptr_t pc = text_section_start_address + 0x20;
AlignedStackMemory stack_memory = {
0xFFFF,
0xFFFF,
};
std::vector<Frame> unwound_frames = {{pc, chrome_module}};
RegisterContext context;
RegisterContextInstructionPointer(&context) = pc;
RegisterContextStackPointer(&context) = stack_memory.stack_start_address();
// The address is outside chrome module, which will result the unwind to
// stop with result kUnrecognizedFrame if SP alignment issue was not detected.
context.arm_lr =
text_section_start_address + (number_of_pages + 1) * page_size;
context.arm_r4 = stack_memory.stack_start_address() + sizeof(uintptr_t) / 2;
EXPECT_EQ(UnwindResult::kAborted,
unwinder.TryUnwind(&context, stack_memory.stack_end_address(),
&unwound_frames));
ExpectFramesEq(std::vector<Frame>({{pc, chrome_module}}), unwound_frames);
}
TEST(ChromeUnwinderAndroidTest, TryUnwindSPOverflow) {
const uint32_t page_table[] = {0, 2};
const size_t number_of_pages = std::size(page_table);
const size_t page_size = 1 << 17;
const FunctionTableEntry function_table[] = {
// Page 0.
{0x0, 0}, // Refuse to unwind filler function.
{0x10, 2}, // Function 0. The function to unwind.
// Page 1.
{0x5, 0}, // Refuse to unwind filler function.
};
const uint8_t function_offset_table[] = {
// Refuse to unwind filler function.
0x0,
0,
// Function 0.
0x0,
2,
};
const uint8_t unwind_instruction_table[] = {
// Offset 0: REFUSE_TO_UNWIND.
0b10000000, 0b00000000,
// Offset 2.
0b10010100, // vsp = r4.
0b10101000, // Pop r4, r14.
0b10110000, // COMPLETE.
};
auto unwind_info = ChromeUnwindInfoAndroid{
make_span(unwind_instruction_table, std::size(unwind_instruction_table)),
make_span(function_offset_table, std::size(function_offset_table)),
make_span(function_table, std::size(function_table)),
make_span(page_table, std::size(page_table)),
};
ModuleCache module_cache;
const ModuleCache::Module* chrome_module = AddNativeModule(
&module_cache, std::make_unique<TestModule>(
0x1000, number_of_pages * page_size, "ChromeModule"));
uintptr_t text_section_start_address = 0x1100;
ChromeUnwinderAndroid unwinder(unwind_info, chrome_module->GetBaseAddress(),
text_section_start_address);
unwinder.Initialize(&module_cache);
uintptr_t pc = text_section_start_address + 0x20;
AlignedStackMemory stack_memory = {
0xFFFF,
0xFFFF,
};
std::vector<Frame> unwound_frames = {{pc, chrome_module}};
RegisterContext context;
RegisterContextInstructionPointer(&context) = pc;
RegisterContextStackPointer(&context) = stack_memory.stack_start_address();
// Setting vsp = 0xffffffff should cause SP overflow.
context.arm_r4 = 0xffffffff;
// The address is outside chrome module, which will result the unwind to
// stop with result kUnrecognizedFrame if the unwinder did not abort for other
// reasons.
context.arm_lr =
text_section_start_address + (number_of_pages + 1) * page_size;
EXPECT_EQ(UnwindResult::kAborted,
unwinder.TryUnwind(&context, stack_memory.stack_end_address(),
&unwound_frames));
ExpectFramesEq(std::vector<Frame>({{pc, chrome_module}}), unwound_frames);
}
TEST(ChromeUnwinderAndroidTest, TryUnwindNullSP) {
const uint32_t page_table[] = {0, 2};
const size_t number_of_pages = std::size(page_table);
const size_t page_size = 1 << 17;
const FunctionTableEntry function_table[] = {
// Page 0.
{0x0, 0}, // Refuse to unwind filler function.
{0x10, 2}, // Function 0. The function to unwind.
// Page 1.
{0x5, 0}, // Refuse to unwind filler function.
};
const uint8_t function_offset_table[] = {
// Refuse to unwind filler function.
0x0,
0,
// Function 0.
0x0,
2,
};
const uint8_t unwind_instruction_table[] = {
// Offset 0: REFUSE_TO_UNWIND.
0b10000000, 0b00000000,
// Offset 2.
0b10010100, // vsp = r4.
0b10101000, // Pop r4, r14.
0b10110000, // COMPLETE.
};
auto unwind_info = ChromeUnwindInfoAndroid{
make_span(unwind_instruction_table, std::size(unwind_instruction_table)),
make_span(function_offset_table, std::size(function_offset_table)),
make_span(function_table, std::size(function_table)),
make_span(page_table, std::size(page_table)),
};
ModuleCache module_cache;
const ModuleCache::Module* chrome_module = AddNativeModule(
&module_cache, std::make_unique<TestModule>(
0x1000, number_of_pages * page_size, "ChromeModule"));
uintptr_t text_section_start_address = 0x1100;
ChromeUnwinderAndroid unwinder(unwind_info, chrome_module->GetBaseAddress(),
text_section_start_address);
unwinder.Initialize(&module_cache);
uintptr_t pc = text_section_start_address + 0x20;
AlignedStackMemory stack_memory = {
0xFFFF,
0xFFFF,
};
std::vector<Frame> unwound_frames = {{pc, chrome_module}};
RegisterContext context;
RegisterContextInstructionPointer(&context) = pc;
RegisterContextStackPointer(&context) = stack_memory.stack_start_address();
// Setting vsp = 0x0 should cause the unwinder to abort.
context.arm_r4 = 0x0;
// The address is outside chrome module, which will result the unwind to
// stop with result kUnrecognizedFrame if the unwinder did not abort for other
// reasons.
context.arm_lr =
text_section_start_address + (number_of_pages + 1) * page_size;
EXPECT_EQ(UnwindResult::kAborted,
unwinder.TryUnwind(&context, stack_memory.stack_end_address(),
&unwound_frames));
ExpectFramesEq(std::vector<Frame>({{pc, chrome_module}}), unwound_frames);
}
TEST(ChromeUnwinderAndroidTest, TryUnwindInvalidSPOperation) {
// This test aims to verify that for each unwind instruction executed, it is
// always true that sp > frame initial sp.
const uint32_t page_table[] = {0, 2};
const size_t number_of_pages = std::size(page_table);
const size_t page_size = 1 << 17;
const FunctionTableEntry function_table[] = {
// Page 0.
{0x0, 0}, // Refuse to unwind filler function.
{0x10, 2}, // Function 0. The function to unwind.
// Page 1.
{0x5, 0}, // Refuse to unwind filler function.
};
const uint8_t function_offset_table[] = {
// Refuse to unwind filler function.
0x0,
0,
// Function 0.
0x0,
2,
};
const uint8_t unwind_instruction_table[] = {
// Offset 0: REFUSE_TO_UNWIND.
0b10000000, 0b00000000,
// Offset 2.
0b10010100, // vsp = r4 (r4 < frame initial sp).
0b10010101, // vsp = r5 (r5 > frame initial sp).
0b10110000, // COMPLETE.
};
auto unwind_info = ChromeUnwindInfoAndroid{
make_span(unwind_instruction_table, std::size(unwind_instruction_table)),
make_span(function_offset_table, std::size(function_offset_table)),
make_span(function_table, std::size(function_table)),
make_span(page_table, std::size(page_table)),
};
ModuleCache module_cache;
const ModuleCache::Module* chrome_module = AddNativeModule(
&module_cache, std::make_unique<TestModule>(
0x1000, number_of_pages * page_size, "ChromeModule"));
uintptr_t text_section_start_address = 0x1100;
ChromeUnwinderAndroid unwinder(unwind_info, chrome_module->GetBaseAddress(),
text_section_start_address);
unwinder.Initialize(&module_cache);
uintptr_t pc = text_section_start_address + 0x20;
AlignedStackMemory stack_memory = {
0xFFFF,
0xFFFF,
};
std::vector<Frame> unwound_frames = {{pc, chrome_module}};
RegisterContext context;
RegisterContextInstructionPointer(&context) = pc;
RegisterContextStackPointer(&context) = stack_memory.stack_start_address();
context.arm_r4 = stack_memory.stack_start_address() - 2 * sizeof(uintptr_t);
context.arm_r5 = stack_memory.stack_start_address() + 2 * sizeof(uintptr_t);
// The address is outside chrome module, which will result the unwind to
// stop with result kUnrecognizedFrame if the unwinder did not abort for other
// reasons.
context.arm_lr =
text_section_start_address + (number_of_pages + 1) * page_size;
EXPECT_EQ(UnwindResult::kAborted,
unwinder.TryUnwind(&context, stack_memory.stack_end_address(),
&unwound_frames));
ExpectFramesEq(std::vector<Frame>({{pc, chrome_module}}), unwound_frames);
}
} // namespace base
Reference in New Issue View Git Blame Copy Permalink