ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge "Always init gnu_debugdata interface if it exists."

Browse source
This commit is contained in:
Christopher Ferris 2018-10-24 00:38:51 +00:00 • committed by Gerrit Code Review
commit afd6e7712f
15 changed files with 58 additions and 122 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
libbacktrace/UnwindStackMap.cpp
View file

@ -106,7 +106,7 @@ std::string UnwindStackMap::GetFunctionName(uint64_t pc, uint64_t* offset) {
return "";
}
unwindstack::Elf* elf = map_info->GetElf(process_memory(), true);
unwindstack::Elf* elf = map_info->GetElf(process_memory());
std::string name;
uint64_t func_offset;

8
libunwindstack/Elf.cpp
View file

@ -40,7 +40,7 @@ bool Elf::cache_enabled_;
std::unordered_map<std::string, std::pair<std::shared_ptr<Elf>, bool>>* Elf::cache_;
std::mutex* Elf::cache_lock_;
bool Elf::Init(bool init_gnu_debugdata) {
bool Elf::Init() {
load_bias_ = 0;
if (!memory_) {
return false;
@ -54,11 +54,7 @@ bool Elf::Init(bool init_gnu_debugdata) {
valid_ = interface_->Init(&load_bias_);
if (valid_) {
interface_->InitHeaders(load_bias_);
if (init_gnu_debugdata) {
InitGnuDebugdata();
} else {
gnu_debugdata_interface_.reset(nullptr);
}
InitGnuDebugdata();
} else {
interface_.reset(nullptr);
}

2
libunwindstack/Global.cpp
View file

@ -46,7 +46,7 @@ uint64_t Global::GetVariableOffset(MapInfo* info, const std::string& variable) {
}
}
Elf* elf = info->GetElf(memory_, true);
Elf* elf = info->GetElf(memory_);
uint64_t ptr;
// Find first non-empty list (libraries might be loaded multiple times).
if (elf->GetGlobalVariable(variable, &ptr) && ptr != 0) {

2
libunwindstack/JitDebug.cpp
View file

@ -201,7 +201,7 @@ Elf* JitDebug::GetElf(Maps* maps, uint64_t pc) {
entry_addr_ = (this->*read_entry_func_)(&start, &size);
Elf* elf = new Elf(new MemoryRange(memory_, start, size, 0));
elf->Init(true);
elf->Init();
if (!elf->valid()) {
// The data is not formatted in a way we understand, do not attempt
// to process any other entries.

2
libunwindstack/LocalUnwinder.cpp
View file

@ -100,7 +100,7 @@ bool LocalUnwinder::Unwind(std::vector<LocalFrameData>* frame_info, size_t max_f
break;
}
Elf* elf = map_info->GetElf(process_memory_, true);
Elf* elf = map_info->GetElf(process_memory_);
uint64_t rel_pc = elf->GetRelPc(cur_pc, map_info);
uint64_t step_pc = rel_pc;
uint64_t pc_adjustment;

4
libunwindstack/MapInfo.cpp
View file

@ -146,7 +146,7 @@ Memory* MapInfo::CreateMemory(const std::shared_ptr<Memory>& process_memory) {
return nullptr;
}
Elf* MapInfo::GetElf(const std::shared_ptr<Memory>& process_memory, bool init_gnu_debugdata) {
Elf* MapInfo::GetElf(const std::shared_ptr<Memory>& process_memory) {
// Make sure no other thread is trying to add the elf to this map.
std::lock_guard<std::mutex> guard(mutex_);
@ -175,7 +175,7 @@ Elf* MapInfo::GetElf(const std::shared_ptr<Memory>& process_memory, bool init_gn
elf.reset(new Elf(memory));
// If the init fails, keep the elf around as an invalid object so we
// don't try to reinit the object.
elf->Init(init_gnu_debugdata);
elf->Init();
if (locked) {
Elf::CacheAdd(this);

2
libunwindstack/Unwinder.cpp
View file

@ -155,7 +155,7 @@ void Unwinder::Unwind(const std::vector<std::string>* initial_map_names_to_skip,
if (ShouldStop(map_suffixes_to_ignore, map_info->name)) {
break;
}
elf = map_info->GetElf(process_memory_, true);
elf = map_info->GetElf(process_memory_);
step_pc = regs_->pc();
rel_pc = elf->GetRelPc(step_pc, map_info);
// Everyone except elf data in gdb jit debug maps uses the relative pc.

2
libunwindstack/include/unwindstack/Elf.h
View file

@ -53,7 +53,7 @@ class Elf {
Elf(Memory* memory) : memory_(memory) {}
virtual ~Elf() = default;
bool Init(bool init_gnu_debugdata);
bool Init();
void InitGnuDebugdata();

2
libunwindstack/include/unwindstack/MapInfo.h
View file

@ -72,7 +72,7 @@ struct MapInfo {
std::atomic_uint64_t load_bias;
// This function guarantees it will never return nullptr.
Elf* GetElf(const std::shared_ptr<Memory>& process_memory, bool init_gnu_debugdata = false);
Elf* GetElf(const std::shared_ptr<Memory>& process_memory);
uint64_t GetLoadBias(const std::shared_ptr<Memory>& process_memory);

28
libunwindstack/tests/ElfCacheTest.cpp
View file

@ -82,9 +82,9 @@ void ElfCacheTest::VerifySameMap(bool cache_enabled) {
MapInfo info1(nullptr, start, end, 0, 0x5, tf.path);
MapInfo info2(nullptr, start, end, 0, 0x5, tf.path);
Elf* elf1 = info1.GetElf(memory_, true);
Elf* elf1 = info1.GetElf(memory_);
ASSERT_TRUE(elf1->valid());
Elf* elf2 = info2.GetElf(memory_, true);
Elf* elf2 = info2.GetElf(memory_);
ASSERT_TRUE(elf2->valid());
if (cache_enabled) {
@ -132,10 +132,10 @@ void ElfCacheTest::VerifyWithinSameMap(bool cache_enabled) {
MapInfo info300_1(nullptr, start, end, 0x300, 0x5, tf.path);
MapInfo info300_2(nullptr, start, end, 0x300, 0x5, tf.path);
Elf* elf0_1 = info0_1.GetElf(memory_, true);
Elf* elf0_1 = info0_1.GetElf(memory_);
ASSERT_TRUE(elf0_1->valid());
EXPECT_EQ(ARCH_ARM, elf0_1->arch());
Elf* elf0_2 = info0_2.GetElf(memory_, true);
Elf* elf0_2 = info0_2.GetElf(memory_);
ASSERT_TRUE(elf0_2->valid());
EXPECT_EQ(ARCH_ARM, elf0_2->arch());
EXPECT_EQ(0U, info0_1.elf_offset);
@ -146,10 +146,10 @@ void ElfCacheTest::VerifyWithinSameMap(bool cache_enabled) {
EXPECT_NE(elf0_1, elf0_2);
}
Elf* elf100_1 = info100_1.GetElf(memory_, true);
Elf* elf100_1 = info100_1.GetElf(memory_);
ASSERT_TRUE(elf100_1->valid());
EXPECT_EQ(ARCH_X86, elf100_1->arch());
Elf* elf100_2 = info100_2.GetElf(memory_, true);
Elf* elf100_2 = info100_2.GetElf(memory_);
ASSERT_TRUE(elf100_2->valid());
EXPECT_EQ(ARCH_X86, elf100_2->arch());
EXPECT_EQ(0U, info100_1.elf_offset);
@ -160,10 +160,10 @@ void ElfCacheTest::VerifyWithinSameMap(bool cache_enabled) {
EXPECT_NE(elf100_1, elf100_2);
}
Elf* elf200_1 = info200_1.GetElf(memory_, true);
Elf* elf200_1 = info200_1.GetElf(memory_);
ASSERT_TRUE(elf200_1->valid());
EXPECT_EQ(ARCH_X86_64, elf200_1->arch());
Elf* elf200_2 = info200_2.GetElf(memory_, true);
Elf* elf200_2 = info200_2.GetElf(memory_);
ASSERT_TRUE(elf200_2->valid());
EXPECT_EQ(ARCH_X86_64, elf200_2->arch());
EXPECT_EQ(0U, info200_1.elf_offset);
@ -174,10 +174,10 @@ void ElfCacheTest::VerifyWithinSameMap(bool cache_enabled) {
EXPECT_NE(elf200_1, elf200_2);
}
Elf* elf300_1 = info300_1.GetElf(memory_, true);
Elf* elf300_1 = info300_1.GetElf(memory_);
ASSERT_TRUE(elf300_1->valid());
EXPECT_EQ(ARCH_ARM, elf300_1->arch());
Elf* elf300_2 = info300_2.GetElf(memory_, true);
Elf* elf300_2 = info300_2.GetElf(memory_);
ASSERT_TRUE(elf300_2->valid());
EXPECT_EQ(ARCH_ARM, elf300_2->arch());
EXPECT_EQ(0x300U, info300_1.elf_offset);
@ -222,10 +222,10 @@ void ElfCacheTest::VerifyWithinSameMapNeverReadAtZero(bool cache_enabled) {
MapInfo info400_1(nullptr, start, end, 0x400, 0x5, tf.path);
MapInfo info400_2(nullptr, start, end, 0x400, 0x5, tf.path);
Elf* elf300_1 = info300_1.GetElf(memory_, true);
Elf* elf300_1 = info300_1.GetElf(memory_);
ASSERT_TRUE(elf300_1->valid());
EXPECT_EQ(ARCH_ARM, elf300_1->arch());
Elf* elf300_2 = info300_2.GetElf(memory_, true);
Elf* elf300_2 = info300_2.GetElf(memory_);
ASSERT_TRUE(elf300_2->valid());
EXPECT_EQ(ARCH_ARM, elf300_2->arch());
EXPECT_EQ(0x300U, info300_1.elf_offset);
@ -236,10 +236,10 @@ void ElfCacheTest::VerifyWithinSameMapNeverReadAtZero(bool cache_enabled) {
EXPECT_NE(elf300_1, elf300_2);
}
Elf* elf400_1 = info400_1.GetElf(memory_, true);
Elf* elf400_1 = info400_1.GetElf(memory_);
ASSERT_TRUE(elf400_1->valid());
EXPECT_EQ(ARCH_ARM, elf400_1->arch());
Elf* elf400_2 = info400_2.GetElf(memory_, true);
Elf* elf400_2 = info400_2.GetElf(memory_);
ASSERT_TRUE(elf400_2->valid());
EXPECT_EQ(ARCH_ARM, elf400_2->arch());
EXPECT_EQ(0x400U, info400_1.elf_offset);

52
libunwindstack/tests/ElfTest.cpp
View file

@ -110,7 +110,7 @@ class ElfTest : public ::testing::Test {
TEST_F(ElfTest, invalid_memory) {
Elf elf(memory_);
ASSERT_FALSE(elf.Init(false));
ASSERT_FALSE(elf.Init());
ASSERT_FALSE(elf.valid());
}
@ -122,7 +122,7 @@ TEST_F(ElfTest, elf_invalid) {
// Corrupt the ELF signature.
memory_->SetData32(0, 0x7f000000);
ASSERT_FALSE(elf.Init(false));
ASSERT_FALSE(elf.Init());
ASSERT_FALSE(elf.valid());
ASSERT_TRUE(elf.interface() == nullptr);
@ -142,7 +142,7 @@ TEST_F(ElfTest, elf32_invalid_machine) {
InitElf32(EM_PPC);
ResetLogs();
ASSERT_FALSE(elf.Init(false));
ASSERT_FALSE(elf.Init());
ASSERT_EQ("", GetFakeLogBuf());
ASSERT_EQ("4 unwind 32 bit elf that is neither arm nor x86 nor mips: e_machine = 20\n\n",
@ -155,7 +155,7 @@ TEST_F(ElfTest, elf64_invalid_machine) {
InitElf64(EM_PPC64);
ResetLogs();
ASSERT_FALSE(elf.Init(false));
ASSERT_FALSE(elf.Init());
ASSERT_EQ("", GetFakeLogBuf());
ASSERT_EQ("4 unwind 64 bit elf that is neither aarch64 nor x86_64 nor mips64: e_machine = 21\n\n",
@ -167,7 +167,7 @@ TEST_F(ElfTest, elf_arm) {
InitElf32(EM_ARM);
ASSERT_TRUE(elf.Init(false));
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_ARM), elf.machine_type());
ASSERT_EQ(ELFCLASS32, elf.class_type());
@ -179,7 +179,7 @@ TEST_F(ElfTest, elf_mips) {
InitElf32(EM_MIPS);
ASSERT_TRUE(elf.Init(false));
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_MIPS), elf.machine_type());
ASSERT_EQ(ELFCLASS32, elf.class_type());
@ -191,7 +191,7 @@ TEST_F(ElfTest, elf_x86) {
InitElf32(EM_386);
ASSERT_TRUE(elf.Init(false));
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_386), elf.machine_type());
ASSERT_EQ(ELFCLASS32, elf.class_type());
@ -203,7 +203,7 @@ TEST_F(ElfTest, elf_arm64) {
InitElf64(EM_AARCH64);
ASSERT_TRUE(elf.Init(false));
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_AARCH64), elf.machine_type());
ASSERT_EQ(ELFCLASS64, elf.class_type());
@ -215,7 +215,7 @@ TEST_F(ElfTest, elf_x86_64) {
InitElf64(EM_X86_64);
ASSERT_TRUE(elf.Init(false));
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_X86_64), elf.machine_type());
ASSERT_EQ(ELFCLASS64, elf.class_type());
@ -227,41 +227,13 @@ TEST_F(ElfTest, elf_mips64) {
InitElf64(EM_MIPS);
ASSERT_TRUE(elf.Init(false));
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.valid());
ASSERT_EQ(static_cast<uint32_t>(EM_MIPS), elf.machine_type());
ASSERT_EQ(ELFCLASS64, elf.class_type());
ASSERT_TRUE(elf.interface() != nullptr);
}
TEST_F(ElfTest, gnu_debugdata_init_fail32) {
TestInitGnuDebugdata<Elf32_Ehdr, Elf32_Shdr>(ELFCLASS32, EM_ARM, false,
[&](uint64_t offset, const void* ptr, size_t size) {
memory_->SetMemory(offset, ptr, size);
});
Elf elf(memory_);
ASSERT_TRUE(elf.Init(false));
ASSERT_TRUE(elf.interface() != nullptr);
ASSERT_TRUE(elf.gnu_debugdata_interface() == nullptr);
EXPECT_EQ(0x1acU, elf.interface()->gnu_debugdata_offset());
EXPECT_EQ(0x100U, elf.interface()->gnu_debugdata_size());
}
TEST_F(ElfTest, gnu_debugdata_init_fail64) {
TestInitGnuDebugdata<Elf64_Ehdr, Elf64_Shdr>(ELFCLASS64, EM_AARCH64, false,
[&](uint64_t offset, const void* ptr, size_t size) {
memory_->SetMemory(offset, ptr, size);
});
Elf elf(memory_);
ASSERT_TRUE(elf.Init(false));
ASSERT_TRUE(elf.interface() != nullptr);
ASSERT_TRUE(elf.gnu_debugdata_interface() == nullptr);
EXPECT_EQ(0x200U, elf.interface()->gnu_debugdata_offset());
EXPECT_EQ(0x100U, elf.interface()->gnu_debugdata_size());
}
TEST_F(ElfTest, gnu_debugdata_init32) {
TestInitGnuDebugdata<Elf32_Ehdr, Elf32_Shdr>(ELFCLASS32, EM_ARM, true,
[&](uint64_t offset, const void* ptr, size_t size) {
@ -269,7 +241,7 @@ TEST_F(ElfTest, gnu_debugdata_init32) {
});
Elf elf(memory_);
ASSERT_TRUE(elf.Init(true));
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.interface() != nullptr);
ASSERT_TRUE(elf.gnu_debugdata_interface() != nullptr);
EXPECT_EQ(0x1acU, elf.interface()->gnu_debugdata_offset());
@ -283,7 +255,7 @@ TEST_F(ElfTest, gnu_debugdata_init64) {
});
Elf elf(memory_);
ASSERT_TRUE(elf.Init(true));
ASSERT_TRUE(elf.Init());
ASSERT_TRUE(elf.interface() != nullptr);
ASSERT_TRUE(elf.gnu_debugdata_interface() != nullptr);
EXPECT_EQ(0x200U, elf.interface()->gnu_debugdata_offset());

68
libunwindstack/tests/MapInfoGetElfTest.cpp
View file

@ -72,7 +72,7 @@ TEST_F(MapInfoGetElfTest, invalid) {
MapInfo info(nullptr, 0x1000, 0x2000, 0, PROT_READ, "");
// The map is empty, but this should still create an invalid elf object.
Elf* elf = info.GetElf(process_memory_, false);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_FALSE(elf->valid());
}
@ -84,7 +84,7 @@ TEST_F(MapInfoGetElfTest, valid32) {
TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, EM_ARM);
memory_->SetMemory(0x3000, &ehdr, sizeof(ehdr));
Elf* elf = info.GetElf(process_memory_, false);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_TRUE(elf->valid());
EXPECT_EQ(static_cast<uint32_t>(EM_ARM), elf->machine_type());
@ -98,45 +98,13 @@ TEST_F(MapInfoGetElfTest, valid64) {
TestInitEhdr<Elf64_Ehdr>(&ehdr, ELFCLASS64, EM_AARCH64);
memory_->SetMemory(0x8000, &ehdr, sizeof(ehdr));
Elf* elf = info.GetElf(process_memory_, false);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_TRUE(elf->valid());
EXPECT_EQ(static_cast<uint32_t>(EM_AARCH64), elf->machine_type());
EXPECT_EQ(ELFCLASS64, elf->class_type());
}
TEST_F(MapInfoGetElfTest, gnu_debugdata_do_not_init32) {
MapInfo info(nullptr, 0x4000, 0x8000, 0, PROT_READ, "");
TestInitGnuDebugdata<Elf32_Ehdr, Elf32_Shdr>(ELFCLASS32, EM_ARM, false,
[&](uint64_t offset, const void* ptr, size_t size) {
memory_->SetMemory(0x4000 + offset, ptr, size);
});
Elf* elf = info.GetElf(process_memory_, false);
ASSERT_TRUE(elf != nullptr);
ASSERT_TRUE(elf->valid());
EXPECT_EQ(static_cast<uint32_t>(EM_ARM), elf->machine_type());
EXPECT_EQ(ELFCLASS32, elf->class_type());
EXPECT_TRUE(elf->gnu_debugdata_interface() == nullptr);
}
TEST_F(MapInfoGetElfTest, gnu_debugdata_do_not_init64) {
MapInfo info(nullptr, 0x6000, 0x8000, 0, PROT_READ, "");
TestInitGnuDebugdata<Elf64_Ehdr, Elf64_Shdr>(ELFCLASS64, EM_AARCH64, false,
[&](uint64_t offset, const void* ptr, size_t size) {
memory_->SetMemory(0x6000 + offset, ptr, size);
});
Elf* elf = info.GetElf(process_memory_, false);
ASSERT_TRUE(elf != nullptr);
ASSERT_TRUE(elf->valid());
EXPECT_EQ(static_cast<uint32_t>(EM_AARCH64), elf->machine_type());
EXPECT_EQ(ELFCLASS64, elf->class_type());
EXPECT_TRUE(elf->gnu_debugdata_interface() == nullptr);
}
TEST_F(MapInfoGetElfTest, gnu_debugdata_init32) {
MapInfo info(nullptr, 0x2000, 0x3000, 0, PROT_READ, "");
@ -145,7 +113,7 @@ TEST_F(MapInfoGetElfTest, gnu_debugdata_init32) {
memory_->SetMemory(0x2000 + offset, ptr, size);
});
Elf* elf = info.GetElf(process_memory_, true);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_TRUE(elf->valid());
EXPECT_EQ(static_cast<uint32_t>(EM_ARM), elf->machine_type());
@ -161,7 +129,7 @@ TEST_F(MapInfoGetElfTest, gnu_debugdata_init64) {
memory_->SetMemory(0x5000 + offset, ptr, size);
});
Elf* elf = info.GetElf(process_memory_, true);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_TRUE(elf->valid());
EXPECT_EQ(static_cast<uint32_t>(EM_AARCH64), elf->machine_type());
@ -176,20 +144,20 @@ TEST_F(MapInfoGetElfTest, end_le_start) {
TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, EM_ARM);
ASSERT_TRUE(android::base::WriteFully(elf_.fd, &ehdr, sizeof(ehdr)));
Elf* elf = info.GetElf(process_memory_, false);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_FALSE(elf->valid());
info.elf.reset();
info.end = 0xfff;
elf = info.GetElf(process_memory_, false);
elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_FALSE(elf->valid());
// Make sure this test is valid.
info.elf.reset();
info.end = 0x2000;
elf = info.GetElf(process_memory_, false);
elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_TRUE(elf->valid());
}
@ -206,7 +174,7 @@ TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_full_file) {
memcpy(buffer.data(), &ehdr, sizeof(ehdr));
ASSERT_TRUE(android::base::WriteFully(elf_.fd, buffer.data(), buffer.size()));
Elf* elf = info.GetElf(process_memory_, false);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_TRUE(elf->valid());
ASSERT_TRUE(elf->memory() != nullptr);
@ -235,7 +203,7 @@ TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_partial_file) {
memcpy(&buffer[info.offset], &ehdr, sizeof(ehdr));
ASSERT_TRUE(android::base::WriteFully(elf_.fd, buffer.data(), buffer.size()));
Elf* elf = info.GetElf(process_memory_, false);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_TRUE(elf->valid());
ASSERT_TRUE(elf->memory() != nullptr);
@ -268,7 +236,7 @@ TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_partial_file_whole_elf32)
memcpy(&buffer[info.offset], &ehdr, sizeof(ehdr));
ASSERT_TRUE(android::base::WriteFully(elf_.fd, buffer.data(), buffer.size()));
Elf* elf = info.GetElf(process_memory_, false);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_TRUE(elf->valid());
ASSERT_TRUE(elf->memory() != nullptr);
@ -296,7 +264,7 @@ TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_partial_file_whole_elf64)
memcpy(&buffer[info.offset], &ehdr, sizeof(ehdr));
ASSERT_TRUE(android::base::WriteFully(elf_.fd, buffer.data(), buffer.size()));
Elf* elf = info.GetElf(process_memory_, false);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_TRUE(elf->valid());
ASSERT_TRUE(elf->memory() != nullptr);
@ -322,13 +290,13 @@ TEST_F(MapInfoGetElfTest, process_memory_not_read_only) {
ehdr.e_shnum = 0;
memory_->SetMemory(0x9000, &ehdr, sizeof(ehdr));
Elf* elf = info.GetElf(process_memory_, false);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_FALSE(elf->valid());
info.elf.reset();
info.flags = PROT_READ;
elf = info.GetElf(process_memory_, false);
elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf->valid());
}
@ -345,20 +313,20 @@ TEST_F(MapInfoGetElfTest, check_device_maps) {
ehdr.e_shnum = 0;
memory_->SetMemory(0x7000, &ehdr, sizeof(ehdr));
Elf* elf = info.GetElf(process_memory_, false);
Elf* elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf != nullptr);
ASSERT_FALSE(elf->valid());
// Set the name to nothing to verify that it still fails.
info.elf.reset();
info.name = "";
elf = info.GetElf(process_memory_, false);
elf = info.GetElf(process_memory_);
ASSERT_FALSE(elf->valid());
// Change the flags and verify the elf is valid now.
info.elf.reset();
info.flags = PROT_READ;
elf = info.GetElf(process_memory_, false);
elf = info.GetElf(process_memory_);
ASSERT_TRUE(elf->valid());
}
@ -384,7 +352,7 @@ TEST_F(MapInfoGetElfTest, multiple_thread_get_elf) {
std::thread* thread = new std::thread([i, this, &wait, &info, &elf_in_threads]() {
while (wait)
;
Elf* elf = info.GetElf(process_memory_, false);
Elf* elf = info.GetElf(process_memory_);
elf_in_threads[i] = elf;
});
threads.push_back(thread);

2
libunwindstack/tools/unwind_info.cpp
View file

@ -113,7 +113,7 @@ int GetElfInfo(const char* file, uint64_t offset) {
}
Elf elf(memory);
if (!elf.Init(true) || !elf.valid()) {
if (!elf.Init() || !elf.valid()) {
printf("%s is not a valid elf file.\n", file);
return 1;
}

2
libunwindstack/tools/unwind_reg_info.cpp
View file

@ -173,7 +173,7 @@ int GetInfo(const char* file, uint64_t pc) {
}
Elf elf(memory);
if (!elf.Init(true) || !elf.valid()) {
if (!elf.Init() || !elf.valid()) {
printf("%s is not a valid elf file.\n", file);
return 1;
}

2
libunwindstack/tools/unwind_symbols.cpp
View file

@ -66,7 +66,7 @@ int main(int argc, char** argv) {
}
unwindstack::Elf elf(memory);
if (!elf.Init(true) || !elf.valid()) {
if (!elf.Init() || !elf.valid()) {
printf("%s is not a valid elf file.\n", argv[1]);
return 1;
}