7e21eba5b7
Bug: 135528735 Test: All unit tests pass. Change-Id: I1f3dc6fe381ec557b6b7bc5cb1c58d210efa63da
779 lines
26 KiB
C++
779 lines
26 KiB
C++
/*
|
|
* 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 <stdint.h>
|
|
|
|
#include <memory>
|
|
#include <type_traits>
|
|
#include <unordered_map>
|
|
|
|
#include <android-base/stringprintf.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <unwindstack/DwarfLocation.h>
|
|
#include <unwindstack/DwarfMemory.h>
|
|
#include <unwindstack/DwarfStructs.h>
|
|
#include <unwindstack/Log.h>
|
|
|
|
#include "DwarfCfa.h"
|
|
|
|
#include "LogFake.h"
|
|
#include "MemoryFake.h"
|
|
|
|
namespace unwindstack {
|
|
|
|
template <typename TypeParam>
|
|
class DwarfCfaLogTest : public ::testing::Test {
|
|
protected:
|
|
void SetUp() override {
|
|
ResetLogs();
|
|
memory_.Clear();
|
|
|
|
dmem_.reset(new DwarfMemory(&memory_));
|
|
|
|
cie_.cfa_instructions_offset = 0x1000;
|
|
cie_.cfa_instructions_end = 0x1030;
|
|
// These two values should be different to distinguish between
|
|
// operations that deal with code versus data.
|
|
cie_.code_alignment_factor = 4;
|
|
cie_.data_alignment_factor = 8;
|
|
|
|
fde_.cfa_instructions_offset = 0x2000;
|
|
fde_.cfa_instructions_end = 0x2030;
|
|
fde_.pc_start = 0x2000;
|
|
fde_.pc_end = 0x2000;
|
|
fde_.pc_end = 0x10000;
|
|
fde_.cie = &cie_;
|
|
cfa_.reset(new DwarfCfa<TypeParam>(dmem_.get(), &fde_));
|
|
}
|
|
|
|
MemoryFake memory_;
|
|
std::unique_ptr<DwarfMemory> dmem_;
|
|
std::unique_ptr<DwarfCfa<TypeParam>> cfa_;
|
|
DwarfCie cie_;
|
|
DwarfFde fde_;
|
|
};
|
|
TYPED_TEST_SUITE_P(DwarfCfaLogTest);
|
|
|
|
// NOTE: All class variable references have to be prefaced with this->.
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_illegal) {
|
|
for (uint8_t i = 0x17; i < 0x3f; i++) {
|
|
if (i == 0x2e || i == 0x2f) {
|
|
// Skip gnu extension ops.
|
|
continue;
|
|
}
|
|
this->memory_.SetMemory(0x2000, std::vector<uint8_t>{i});
|
|
|
|
ResetLogs();
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x2000, 0x2001));
|
|
std::string expected = "4 unwind Illegal\n";
|
|
expected += android::base::StringPrintf("4 unwind Raw Data: 0x%02x\n", i);
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_nop) {
|
|
this->memory_.SetMemory(0x2000, std::vector<uint8_t>{0x00});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x2000, 0x2001));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_nop\n"
|
|
"4 unwind Raw Data: 0x00\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_offset) {
|
|
this->memory_.SetMemory(0x2000, std::vector<uint8_t>{0x83, 0x04});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x2000, 0x2002));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_offset register(3) 4\n"
|
|
"4 unwind Raw Data: 0x83 0x04\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x2100, std::vector<uint8_t>{0x83, 0x84, 0x01});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x2100, 0x2103));
|
|
expected =
|
|
"4 unwind DW_CFA_offset register(3) 132\n"
|
|
"4 unwind Raw Data: 0x83 0x84 0x01\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_offset_extended) {
|
|
this->memory_.SetMemory(0x500, std::vector<uint8_t>{0x05, 0x03, 0x02});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x500, 0x503));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_offset_extended register(3) 2\n"
|
|
"4 unwind Raw Data: 0x05 0x03 0x02\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x1500, std::vector<uint8_t>{0x05, 0x81, 0x01, 0x82, 0x12});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x1500, 0x1505));
|
|
expected =
|
|
"4 unwind DW_CFA_offset_extended register(129) 2306\n"
|
|
"4 unwind Raw Data: 0x05 0x81 0x01 0x82 0x12\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_offset_extended_sf) {
|
|
this->memory_.SetMemory(0x500, std::vector<uint8_t>{0x11, 0x05, 0x10});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x500, 0x503));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_offset_extended_sf register(5) 16\n"
|
|
"4 unwind Raw Data: 0x11 0x05 0x10\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
// Check a negative value for the offset.
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x1500, std::vector<uint8_t>{0x11, 0x86, 0x01, 0xff, 0x7f});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x1500, 0x1505));
|
|
expected =
|
|
"4 unwind DW_CFA_offset_extended_sf register(134) -1\n"
|
|
"4 unwind Raw Data: 0x11 0x86 0x01 0xff 0x7f\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_restore) {
|
|
this->memory_.SetMemory(0x2000, std::vector<uint8_t>{0xc2});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x2000, 0x2001));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_restore register(2)\n"
|
|
"4 unwind Raw Data: 0xc2\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x3000, std::vector<uint8_t>{0x82, 0x04, 0xc2});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x3000, 0x3003));
|
|
expected =
|
|
"4 unwind DW_CFA_offset register(2) 4\n"
|
|
"4 unwind Raw Data: 0x82 0x04\n"
|
|
"4 unwind DW_CFA_restore register(2)\n"
|
|
"4 unwind Raw Data: 0xc2\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_restore_extended) {
|
|
this->memory_.SetMemory(0x4000, std::vector<uint8_t>{0x06, 0x08});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x4000, 0x4002));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_restore_extended register(8)\n"
|
|
"4 unwind Raw Data: 0x06 0x08\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x5000, std::vector<uint8_t>{0x05, 0x82, 0x02, 0x04, 0x06, 0x82, 0x02});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x5000, 0x5007));
|
|
expected =
|
|
"4 unwind DW_CFA_offset_extended register(258) 4\n"
|
|
"4 unwind Raw Data: 0x05 0x82 0x02 0x04\n"
|
|
"4 unwind DW_CFA_restore_extended register(258)\n"
|
|
"4 unwind Raw Data: 0x06 0x82 0x02\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_set_loc) {
|
|
uint8_t buffer[1 + sizeof(TypeParam)];
|
|
buffer[0] = 0x1;
|
|
TypeParam address;
|
|
std::string raw_data("Raw Data: 0x01 ");
|
|
std::string address_str;
|
|
if (std::is_same<TypeParam, uint32_t>::value) {
|
|
address = 0x81234578U;
|
|
address_str = "0x81234578";
|
|
raw_data += "0x78 0x45 0x23 0x81";
|
|
} else {
|
|
address = 0x8123456712345678ULL;
|
|
address_str = "0x8123456712345678";
|
|
raw_data += "0x78 0x56 0x34 0x12 0x67 0x45 0x23 0x81";
|
|
}
|
|
memcpy(&buffer[1], &address, sizeof(address));
|
|
|
|
this->memory_.SetMemory(0x50, buffer, sizeof(buffer));
|
|
ResetLogs();
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x50, 0x51 + sizeof(TypeParam)));
|
|
std::string expected = "4 unwind DW_CFA_set_loc " + address_str + "\n";
|
|
expected += "4 unwind " + raw_data + "\n";
|
|
expected += "4 unwind \n";
|
|
expected += "4 unwind PC " + address_str + "\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
// Check for a set going back.
|
|
ResetLogs();
|
|
this->fde_.pc_start = address + 0x10;
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x50, 0x51 + sizeof(TypeParam)));
|
|
expected = "4 unwind DW_CFA_set_loc " + address_str + "\n";
|
|
expected += "4 unwind " + raw_data + "\n";
|
|
expected += "4 unwind \n";
|
|
expected += "4 unwind PC " + address_str + "\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_advance_loc) {
|
|
this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x44});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x200, 0x201));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_advance_loc 4\n"
|
|
"4 unwind Raw Data: 0x44\n"
|
|
"4 unwind \n"
|
|
"4 unwind PC 0x2010\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_advance_loc1) {
|
|
this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x02, 0x04});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x200, 0x202));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_advance_loc1 4\n"
|
|
"4 unwind Raw Data: 0x02 0x04\n"
|
|
"4 unwind \n"
|
|
"4 unwind PC 0x2004\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_advance_loc2) {
|
|
this->memory_.SetMemory(0x600, std::vector<uint8_t>{0x03, 0x04, 0x03});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x600, 0x603));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_advance_loc2 772\n"
|
|
"4 unwind Raw Data: 0x03 0x04 0x03\n"
|
|
"4 unwind \n"
|
|
"4 unwind PC 0x2304\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_advance_loc4) {
|
|
this->memory_.SetMemory(0x500, std::vector<uint8_t>{0x04, 0x04, 0x03, 0x02, 0x01});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x500, 0x505));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_advance_loc4 16909060\n"
|
|
"4 unwind Raw Data: 0x04 0x04 0x03 0x02 0x01\n"
|
|
"4 unwind \n"
|
|
"4 unwind PC 0x1022304\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_undefined) {
|
|
this->memory_.SetMemory(0xa00, std::vector<uint8_t>{0x07, 0x09});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0xa00, 0xa02));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_undefined register(9)\n"
|
|
"4 unwind Raw Data: 0x07 0x09\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
dwarf_loc_regs_t cie_loc_regs;
|
|
this->memory_.SetMemory(0x1a00, std::vector<uint8_t>{0x07, 0x81, 0x01});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x1a00, 0x1a03));
|
|
expected =
|
|
"4 unwind DW_CFA_undefined register(129)\n"
|
|
"4 unwind Raw Data: 0x07 0x81 0x01\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_same) {
|
|
this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x08, 0x7f});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x102));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_same_value register(127)\n"
|
|
"4 unwind Raw Data: 0x08 0x7f\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x2100, std::vector<uint8_t>{0x08, 0xff, 0x01});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x2100, 0x2103));
|
|
expected =
|
|
"4 unwind DW_CFA_same_value register(255)\n"
|
|
"4 unwind Raw Data: 0x08 0xff 0x01\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_register) {
|
|
this->memory_.SetMemory(0x300, std::vector<uint8_t>{0x09, 0x02, 0x01});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x300, 0x303));
|
|
std::string expected =
|
|
"4 unwind DW_CFA_register register(2) register(1)\n"
|
|
"4 unwind Raw Data: 0x09 0x02 0x01\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x4300, std::vector<uint8_t>{0x09, 0xff, 0x01, 0xff, 0x03});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x4300, 0x4305));
|
|
expected =
|
|
"4 unwind DW_CFA_register register(255) register(511)\n"
|
|
"4 unwind Raw Data: 0x09 0xff 0x01 0xff 0x03\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_state) {
|
|
this->memory_.SetMemory(0x300, std::vector<uint8_t>{0x0a});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x300, 0x301));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_remember_state\n"
|
|
"4 unwind Raw Data: 0x0a\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x4300, std::vector<uint8_t>{0x0b});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x4300, 0x4301));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_restore_state\n"
|
|
"4 unwind Raw Data: 0x0b\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_state_cfa_offset_restore) {
|
|
this->memory_.SetMemory(0x3000, std::vector<uint8_t>{0x0a, 0x0e, 0x40, 0x0b});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x3000, 0x3004));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_remember_state\n"
|
|
"4 unwind Raw Data: 0x0a\n"
|
|
"4 unwind DW_CFA_def_cfa_offset 64\n"
|
|
"4 unwind Raw Data: 0x0e 0x40\n"
|
|
"4 unwind DW_CFA_restore_state\n"
|
|
"4 unwind Raw Data: 0x0b\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa) {
|
|
this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x0c, 0x7f, 0x74});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x103));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_def_cfa register(127) 116\n"
|
|
"4 unwind Raw Data: 0x0c 0x7f 0x74\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x0c, 0xff, 0x02, 0xf4, 0x04});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x200, 0x205));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_def_cfa register(383) 628\n"
|
|
"4 unwind Raw Data: 0x0c 0xff 0x02 0xf4 0x04\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa_sf) {
|
|
this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x12, 0x30, 0x25});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x103));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_def_cfa_sf register(48) 37\n"
|
|
"4 unwind Raw Data: 0x12 0x30 0x25\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
// Test a negative value.
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x12, 0xa3, 0x01, 0xfa, 0x7f});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x200, 0x205));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_def_cfa_sf register(163) -6\n"
|
|
"4 unwind Raw Data: 0x12 0xa3 0x01 0xfa 0x7f\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa_register) {
|
|
this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x0d, 0x72});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x102));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_def_cfa_register register(114)\n"
|
|
"4 unwind Raw Data: 0x0d 0x72\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x0d, 0xf9, 0x20});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x200, 0x203));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_def_cfa_register register(4217)\n"
|
|
"4 unwind Raw Data: 0x0d 0xf9 0x20\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa_offset) {
|
|
this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x0e, 0x59});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x102));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_def_cfa_offset 89\n"
|
|
"4 unwind Raw Data: 0x0e 0x59\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x102));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_def_cfa_offset 89\n"
|
|
"4 unwind Raw Data: 0x0e 0x59\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x0e, 0xd4, 0x0a});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x200, 0x203));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_def_cfa_offset 1364\n"
|
|
"4 unwind Raw Data: 0x0e 0xd4 0x0a\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa_offset_sf) {
|
|
this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x13, 0x23});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x102));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_def_cfa_offset_sf 35\n"
|
|
"4 unwind Raw Data: 0x13 0x23\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x102));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_def_cfa_offset_sf 35\n"
|
|
"4 unwind Raw Data: 0x13 0x23\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
// Negative offset.
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x200, std::vector<uint8_t>{0x13, 0xf6, 0x7f});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x200, 0x203));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_def_cfa_offset_sf -10\n"
|
|
"4 unwind Raw Data: 0x13 0xf6 0x7f\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_def_cfa_expression) {
|
|
this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x0f, 0x04, 0x01, 0x02, 0x04, 0x05});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x106));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_def_cfa_expression 4\n"
|
|
"4 unwind Raw Data: 0x0f 0x04 0x01 0x02 0x04 0x05\n"
|
|
"4 unwind Illegal\n"
|
|
"4 unwind Raw Data: 0x01\n"
|
|
"4 unwind Illegal\n"
|
|
"4 unwind Raw Data: 0x02\n"
|
|
"4 unwind Illegal\n"
|
|
"4 unwind Raw Data: 0x04\n"
|
|
"4 unwind Illegal\n"
|
|
"4 unwind Raw Data: 0x05\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
std::vector<uint8_t> ops{0x0f, 0x81, 0x01};
|
|
expected = "4 unwind Raw Data: 0x0f 0x81 0x01";
|
|
std::string op_string;
|
|
for (uint8_t i = 3; i < 132; i++) {
|
|
ops.push_back(0x05);
|
|
op_string +=
|
|
"4 unwind Illegal\n"
|
|
"4 unwind Raw Data: 0x05\n";
|
|
expected += " 0x05";
|
|
if (((i + 1) % 10) == 0) {
|
|
expected += "\n4 unwind Raw Data:";
|
|
}
|
|
}
|
|
expected += '\n';
|
|
this->memory_.SetMemory(0x200, ops);
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x200, 0x284));
|
|
|
|
expected = "4 unwind DW_CFA_def_cfa_expression 129\n" + expected;
|
|
ASSERT_EQ(expected + op_string, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_expression) {
|
|
this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x10, 0x04, 0x02, 0xc0, 0xc1});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x105));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_expression register(4) 2\n"
|
|
"4 unwind Raw Data: 0x10 0x04 0x02 0xc0 0xc1\n"
|
|
"4 unwind Illegal\n"
|
|
"4 unwind Raw Data: 0xc0\n"
|
|
"4 unwind Illegal\n"
|
|
"4 unwind Raw Data: 0xc1\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
std::vector<uint8_t> ops{0x10, 0xff, 0x01, 0x82, 0x01};
|
|
expected = "4 unwind Raw Data: 0x10 0xff 0x01 0x82 0x01";
|
|
std::string op_string;
|
|
for (uint8_t i = 5; i < 135; i++) {
|
|
ops.push_back(0xa0 + (i - 5) % 96);
|
|
op_string += "4 unwind Illegal\n";
|
|
op_string += android::base::StringPrintf("4 unwind Raw Data: 0x%02x\n", ops.back());
|
|
expected += android::base::StringPrintf(" 0x%02x", ops.back());
|
|
if (((i + 1) % 10) == 0) {
|
|
expected += "\n4 unwind Raw Data:";
|
|
}
|
|
}
|
|
expected = "4 unwind DW_CFA_expression register(255) 130\n" + expected + "\n";
|
|
|
|
this->memory_.SetMemory(0x200, ops);
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x200, 0x287));
|
|
|
|
ASSERT_EQ(expected + op_string, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_val_offset) {
|
|
this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x14, 0x45, 0x54});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x103));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_val_offset register(69) 84\n"
|
|
"4 unwind Raw Data: 0x14 0x45 0x54\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x400, std::vector<uint8_t>{0x14, 0xa2, 0x02, 0xb4, 0x05});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x400, 0x405));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_val_offset register(290) 692\n"
|
|
"4 unwind Raw Data: 0x14 0xa2 0x02 0xb4 0x05\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_val_offset_sf) {
|
|
this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x15, 0x56, 0x12});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x103));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_val_offset_sf register(86) 18\n"
|
|
"4 unwind Raw Data: 0x15 0x56 0x12\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
// Negative value.
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0xa00, std::vector<uint8_t>{0x15, 0xff, 0x01, 0xc0, 0x7f});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0xa00, 0xa05));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_val_offset_sf register(255) -64\n"
|
|
"4 unwind Raw Data: 0x15 0xff 0x01 0xc0 0x7f\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_val_expression) {
|
|
this->memory_.SetMemory(0x100, std::vector<uint8_t>{0x16, 0x05, 0x02, 0xb0, 0xb1});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x100, 0x105));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_val_expression register(5) 2\n"
|
|
"4 unwind Raw Data: 0x16 0x05 0x02 0xb0 0xb1\n"
|
|
"4 unwind Illegal\n"
|
|
"4 unwind Raw Data: 0xb0\n"
|
|
"4 unwind Illegal\n"
|
|
"4 unwind Raw Data: 0xb1\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
std::vector<uint8_t> ops{0x16, 0x83, 0x10, 0xa8, 0x01};
|
|
expected = "4 unwind Raw Data: 0x16 0x83 0x10 0xa8 0x01";
|
|
std::string op_string;
|
|
for (uint8_t i = 0; i < 168; i++) {
|
|
ops.push_back(0xa0 + (i % 96));
|
|
op_string += "4 unwind Illegal\n";
|
|
op_string += android::base::StringPrintf("4 unwind Raw Data: 0x%02x\n", ops.back());
|
|
expected += android::base::StringPrintf(" 0x%02x", ops.back());
|
|
if (((i + 6) % 10) == 0) {
|
|
expected += "\n4 unwind Raw Data:";
|
|
}
|
|
}
|
|
expected = "4 unwind DW_CFA_val_expression register(2051) 168\n" + expected + "\n";
|
|
|
|
this->memory_.SetMemory(0xa00, ops);
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0xa00, 0xaad));
|
|
|
|
ASSERT_EQ(expected + op_string, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_gnu_args_size) {
|
|
this->memory_.SetMemory(0x2000, std::vector<uint8_t>{0x2e, 0x04});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x2000, 0x2002));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_GNU_args_size 4\n"
|
|
"4 unwind Raw Data: 0x2e 0x04\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x5000, std::vector<uint8_t>{0x2e, 0xa4, 0x80, 0x04});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x5000, 0x5004));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_GNU_args_size 65572\n"
|
|
"4 unwind Raw Data: 0x2e 0xa4 0x80 0x04\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_gnu_negative_offset_extended) {
|
|
this->memory_.SetMemory(0x500, std::vector<uint8_t>{0x2f, 0x08, 0x10});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x500, 0x503));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_GNU_negative_offset_extended register(8) 16\n"
|
|
"4 unwind Raw Data: 0x2f 0x08 0x10\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
|
|
ResetLogs();
|
|
this->memory_.SetMemory(0x1500, std::vector<uint8_t>{0x2f, 0x81, 0x02, 0xff, 0x01});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x1500, 0x1505));
|
|
|
|
expected =
|
|
"4 unwind DW_CFA_GNU_negative_offset_extended register(257) 255\n"
|
|
"4 unwind Raw Data: 0x2f 0x81 0x02 0xff 0x01\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
TYPED_TEST_P(DwarfCfaLogTest, cfa_register_override) {
|
|
this->memory_.SetMemory(0x300, std::vector<uint8_t>{0x09, 0x02, 0x01, 0x09, 0x02, 0x04});
|
|
|
|
ASSERT_TRUE(this->cfa_->Log(0, this->fde_.pc_start, 0x300, 0x306));
|
|
|
|
std::string expected =
|
|
"4 unwind DW_CFA_register register(2) register(1)\n"
|
|
"4 unwind Raw Data: 0x09 0x02 0x01\n"
|
|
"4 unwind DW_CFA_register register(2) register(4)\n"
|
|
"4 unwind Raw Data: 0x09 0x02 0x04\n";
|
|
ASSERT_EQ(expected, GetFakeLogPrint());
|
|
ASSERT_EQ("", GetFakeLogBuf());
|
|
}
|
|
|
|
REGISTER_TYPED_TEST_SUITE_P(DwarfCfaLogTest, cfa_illegal, cfa_nop, cfa_offset, cfa_offset_extended,
|
|
cfa_offset_extended_sf, cfa_restore, cfa_restore_extended, cfa_set_loc,
|
|
cfa_advance_loc, cfa_advance_loc1, cfa_advance_loc2, cfa_advance_loc4,
|
|
cfa_undefined, cfa_same, cfa_register, cfa_state,
|
|
cfa_state_cfa_offset_restore, cfa_def_cfa, cfa_def_cfa_sf,
|
|
cfa_def_cfa_register, cfa_def_cfa_offset, cfa_def_cfa_offset_sf,
|
|
cfa_def_cfa_expression, cfa_expression, cfa_val_offset,
|
|
cfa_val_offset_sf, cfa_val_expression, cfa_gnu_args_size,
|
|
cfa_gnu_negative_offset_extended, cfa_register_override);
|
|
|
|
typedef ::testing::Types<uint32_t, uint64_t> DwarfCfaLogTestTypes;
|
|
INSTANTIATE_TYPED_TEST_SUITE_P(, DwarfCfaLogTest, DwarfCfaLogTestTypes);
|
|
|
|
} // namespace unwindstack
|