diff options
| author | David Srbecky <dsrbecky@google.com> | 2021-05-13 10:08:15 +0000 |
|---|---|---|
| committer | Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com> | 2021-05-13 10:08:15 +0000 |
| commit | 96809dad05354ef97798c30fa76551587a5e62ef (patch) | |
| tree | 5689c81858d587a016b3b6fe4cabcb0f81fee753 | |
| parent | 3387c8d256383069f78b05a4dd7c09ad3854a2d0 (diff) | |
| parent | 01372e33617b21f71b45dc843e6af0dd56df8a54 (diff) | |
| download | unwinding-96809dad05354ef97798c30fa76551587a5e62ef.tar.gz | |
MapInfo: Add get accessors for the fields am: 01372e3361
Original change: https://android-review.googlesource.com/c/platform/system/unwinding/+/1705381
Change-Id: I6ee73ed64ce57c263531574978b672e4bc436517
25 files changed, 546 insertions, 531 deletions
diff --git a/libbacktrace/UnwindStackMap.cpp b/libbacktrace/UnwindStackMap.cpp index 478f6a5..7c15ed7 100644 --- a/libbacktrace/UnwindStackMap.cpp +++ b/libbacktrace/UnwindStackMap.cpp @@ -71,13 +71,13 @@ bool UnwindStackMap::Build() { // Iterate through the maps and fill in the backtrace_map_t structure. for (const auto& map_info : *stack_maps_) { backtrace_map_t map; - map.start = map_info->start_; - map.end = map_info->end_; - map.offset = map_info->offset_; + map.start = map_info->start(); + map.end = map_info->end(); + map.offset = map_info->offset(); // Set to -1 so that it is demand loaded. map.load_bias = static_cast<uint64_t>(-1); - map.flags = map_info->flags_; - map.name = map_info->name_; + map.flags = map_info->flags(); + map.name = map_info->name(); maps_.push_back(map); } @@ -117,7 +117,7 @@ std::string UnwindStackMap::GetFunctionName(uint64_t pc, uint64_t* offset) { // Get the map for this unwindstack::MapInfo* map_info = maps->Find(pc); - if (map_info == nullptr || map_info->flags_ & PROT_DEVICE_MAP) { + if (map_info == nullptr || map_info->flags() & PROT_DEVICE_MAP) { return ""; } diff --git a/libunwindstack/DexFile.cpp b/libunwindstack/DexFile.cpp index a66e6fd..c3e53c7 100644 --- a/libunwindstack/DexFile.cpp +++ b/libunwindstack/DexFile.cpp @@ -48,20 +48,20 @@ static bool CheckDexSupport() { } std::shared_ptr<DexFile> DexFile::CreateFromDisk(uint64_t addr, uint64_t size, MapInfo* map) { - if (map == nullptr || map->name_.empty()) { + if (map == nullptr || map->name().empty()) { return nullptr; // MapInfo not backed by file. } - if (!(map->start_ <= addr && addr < map->end_)) { + if (!(map->start() <= addr && addr < map->end())) { return nullptr; // addr is not in MapInfo range. } - if (size > (map->end_ - addr)) { + if (size > (map->end() - addr)) { return nullptr; // size is past the MapInfo end. } - uint64_t offset_in_file = (addr - map->start_) + map->offset_; + uint64_t offset_in_file = (addr - map->start()) + map->offset(); // Fast-path: Check if the dex file was already mapped from disk. std::lock_guard<std::mutex> guard(g_lock); - MappedFileKey cache_key(map->name_, offset_in_file, size); + MappedFileKey cache_key(map->name(), offset_in_file, size); std::weak_ptr<DexFileApi>& cache_entry = g_mapped_dex_files[cache_key]; std::shared_ptr<DexFileApi> dex_api = cache_entry.lock(); if (dex_api != nullptr) { @@ -69,12 +69,12 @@ std::shared_ptr<DexFile> DexFile::CreateFromDisk(uint64_t addr, uint64_t size, M } // Load the file from disk and cache it. - std::unique_ptr<Memory> memory = Memory::CreateFileMemory(map->name_, offset_in_file, size); + std::unique_ptr<Memory> memory = Memory::CreateFileMemory(map->name(), offset_in_file, size); if (memory == nullptr) { return nullptr; // failed to map the file. } std::unique_ptr<art_api::dex::DexFile> dex; - art_api::dex::DexFile::Create(memory->GetPtr(), size, nullptr, map->name_.c_str(), &dex); + art_api::dex::DexFile::Create(memory->GetPtr(), size, nullptr, map->name().c_str(), &dex); if (dex == nullptr) { return nullptr; // invalid DEX file. } diff --git a/libunwindstack/Elf.cpp b/libunwindstack/Elf.cpp index 47373fd..4dec11e 100644 --- a/libunwindstack/Elf.cpp +++ b/libunwindstack/Elf.cpp @@ -102,7 +102,7 @@ std::string Elf::GetSoname() { } uint64_t Elf::GetRelPc(uint64_t pc, const MapInfo* map_info) { - return pc - map_info->start_ + load_bias_ + map_info->elf_offset_; + return pc - map_info->start() + load_bias_ + map_info->elf_offset(); } bool Elf::GetFunctionName(uint64_t addr, SharedString* name, uint64_t* func_offset) { @@ -376,24 +376,24 @@ void Elf::CacheAdd(MapInfo* info) { // where each reference the entire boot.odex, the cache will properly // use the same cached elf object. - if (info->offset_ == 0 || info->elf_offset_ != 0) { - (*cache_)[info->name_] = std::make_pair(info->elf_, true); + if (info->offset() == 0 || info->elf_offset() != 0) { + (*cache_)[info->name()] = std::make_pair(info->elf(), true); } - if (info->offset_ != 0) { + if (info->offset() != 0) { // The second element in the pair indicates whether elf_offset should // be set to offset when getting out of the cache. - std::string key = std::string(info->name_) + ':' + std::to_string(info->offset_); - (*cache_)[key] = std::make_pair(info->elf_, info->elf_offset_ != 0); + std::string key = std::string(info->name()) + ':' + std::to_string(info->offset()); + (*cache_)[key] = std::make_pair(info->elf(), info->elf_offset() != 0); } } bool Elf::CacheAfterCreateMemory(MapInfo* info) { - if (info->name_.empty() || info->offset_ == 0 || info->elf_offset_ == 0) { + if (info->name().empty() || info->offset() == 0 || info->elf_offset() == 0) { return false; } - auto entry = cache_->find(info->name_); + auto entry = cache_->find(info->name()); if (entry == cache_->end()) { return false; } @@ -402,21 +402,21 @@ bool Elf::CacheAfterCreateMemory(MapInfo* info) { // been cached. Add an entry at name:offset to get this directly out // of the cache next time. info->elf_ = entry->second.first; - std::string key = std::string(info->name_) + ':' + std::to_string(info->offset_); - (*cache_)[key] = std::make_pair(info->elf_, true); + std::string key = std::string(info->name()) + ':' + std::to_string(info->offset()); + (*cache_)[key] = std::make_pair(info->elf(), true); return true; } bool Elf::CacheGet(MapInfo* info) { - std::string name(info->name_); - if (info->offset_ != 0) { - name += ':' + std::to_string(info->offset_); + std::string name(info->name()); + if (info->offset() != 0) { + name += ':' + std::to_string(info->offset()); } auto entry = cache_->find(name); if (entry != cache_->end()) { info->elf_ = entry->second.first; if (entry->second.second) { - info->elf_offset_ = info->offset_; + info->elf_offset_ = info->offset(); } return true; } diff --git a/libunwindstack/Global.cpp b/libunwindstack/Global.cpp index 1b0b110..b8adc5c 100644 --- a/libunwindstack/Global.cpp +++ b/libunwindstack/Global.cpp @@ -77,21 +77,21 @@ void Global::FindAndReadVariable(Maps* maps, const char* var_str) { // f3000-f4000 2000 rw- /system/lib/libc.so MapInfo* map_zero = nullptr; for (const auto& info : *maps) { - if (info->offset_ != 0 && - (info->flags_ & (PROT_READ | PROT_WRITE)) == (PROT_READ | PROT_WRITE) && - map_zero != nullptr && Searchable(info->name_) && info->name_ == map_zero->name_) { + if (info->offset() != 0 && + (info->flags() & (PROT_READ | PROT_WRITE)) == (PROT_READ | PROT_WRITE) && + map_zero != nullptr && Searchable(info->name()) && info->name() == map_zero->name()) { Elf* elf = map_zero->GetElf(memory_, arch()); uint64_t ptr; if (elf->GetGlobalVariableOffset(variable, &ptr) && ptr != 0) { - uint64_t offset_end = info->offset_ + info->end_ - info->start_; - if (ptr >= info->offset_ && ptr < offset_end) { - ptr = info->start_ + ptr - info->offset_; + uint64_t offset_end = info->offset() + info->end() - info->start(); + if (ptr >= info->offset() && ptr < offset_end) { + ptr = info->start() + ptr - info->offset(); if (ReadVariableData(ptr)) { break; } } } - } else if (info->offset_ == 0 && !info->name_.empty()) { + } else if (info->offset() == 0 && !info->name().empty()) { map_zero = info.get(); } } diff --git a/libunwindstack/LocalUnwinder.cpp b/libunwindstack/LocalUnwinder.cpp index 02ce6b2..466dd68 100644 --- a/libunwindstack/LocalUnwinder.cpp +++ b/libunwindstack/LocalUnwinder.cpp @@ -107,7 +107,7 @@ bool LocalUnwinder::Unwind(std::vector<LocalFrameData>* frame_info, size_t max_f } // Skip any locations that are within this library. - if (num_frames != 0 || !ShouldSkipLibrary(map_info->name_)) { + if (num_frames != 0 || !ShouldSkipLibrary(map_info->name())) { // Add frame information. SharedString func_name; uint64_t func_offset; diff --git a/libunwindstack/MapInfo.cpp b/libunwindstack/MapInfo.cpp index 3be81f6..e25c788 100644 --- a/libunwindstack/MapInfo.cpp +++ b/libunwindstack/MapInfo.cpp @@ -37,11 +37,11 @@ namespace unwindstack { bool MapInfo::InitFileMemoryFromPreviousReadOnlyMap(MemoryFileAtOffset* memory) { // One last attempt, see if the previous map is read-only with the // same name and stretches across this map. - if (prev_real_map_ == nullptr || prev_real_map_->flags_ != PROT_READ) { + if (prev_real_map() == nullptr || prev_real_map()->flags() != PROT_READ) { return false; } - uint64_t map_size = end_ - prev_real_map_->end_; + uint64_t map_size = end() - prev_real_map_->end(); if (!memory->Init(name_, prev_real_map_->offset_, map_size)) { return false; } @@ -51,19 +51,19 @@ bool MapInfo::InitFileMemoryFromPreviousReadOnlyMap(MemoryFileAtOffset* memory) return false; } - if (!memory->Init(name_, prev_real_map_->offset_, max_size)) { + if (!memory->Init(name(), prev_real_map()->offset(), max_size)) { return false; } - elf_offset_ = offset_ - prev_real_map_->offset_; - elf_start_offset_ = prev_real_map_->offset_; + elf_offset_ = offset() - prev_real_map_->offset(); + elf_start_offset_ = prev_real_map_->offset(); return true; } Memory* MapInfo::GetFileMemory() { std::unique_ptr<MemoryFileAtOffset> memory(new MemoryFileAtOffset); - if (offset_ == 0) { - if (memory->Init(name_, 0)) { + if (offset() == 0) { + if (memory->Init(name(), 0)) { return memory.release(); } return nullptr; @@ -83,7 +83,7 @@ Memory* MapInfo::GetFileMemory() { // and reinit to that size. This is needed because the dynamic linker // only maps in a portion of the original elf, and never the symbol // file data. - uint64_t map_size = end_ - start_; + uint64_t map_size = end_ - start(); if (!memory->Init(name_, offset_, map_size)) { return nullptr; } @@ -91,9 +91,9 @@ Memory* MapInfo::GetFileMemory() { // Check if the start of this map is an embedded elf. uint64_t max_size = 0; if (Elf::GetInfo(memory.get(), &max_size)) { - elf_start_offset_ = offset_; + elf_start_offset_ = offset(); if (max_size > map_size) { - if (memory->Init(name_, offset_, max_size)) { + if (memory->Init(name(), offset(), max_size)) { return memory.release(); } // Try to reinit using the default map_size. @@ -107,14 +107,14 @@ Memory* MapInfo::GetFileMemory() { } // No elf at offset, try to init as if the whole file is an elf. - if (memory->Init(name_, 0) && Elf::IsValidElf(memory.get())) { - elf_offset_ = offset_; + if (memory->Init(name(), 0) && Elf::IsValidElf(memory.get())) { + elf_offset_ = offset(); // Need to check how to set the elf start offset. If this map is not // the r-x map of a r-- map, then use the real offset value. Otherwise, // use 0. - if (prev_real_map_ == nullptr || prev_real_map_->offset_ != 0 || - prev_real_map_->flags_ != PROT_READ || prev_real_map_->name_ != name_) { - elf_start_offset_ = offset_; + if (prev_real_map_ == nullptr || prev_real_map_->offset() != 0 || + prev_real_map_->flags() != PROT_READ || prev_real_map_->name() != name()) { + elf_start_offset_ = offset(); } return memory.release(); } @@ -134,19 +134,19 @@ Memory* MapInfo::GetFileMemory() { } Memory* MapInfo::CreateMemory(const std::shared_ptr<Memory>& process_memory) { - if (end_ <= start_) { + if (end() <= start()) { return nullptr; } elf_offset_ = 0; // Fail on device maps. - if (flags_ & MAPS_FLAGS_DEVICE_MAP) { + if (flags() & MAPS_FLAGS_DEVICE_MAP) { return nullptr; } // First try and use the file associated with the info. - if (!name_.empty()) { + if (!name().empty()) { Memory* memory = GetFileMemory(); if (memory != nullptr) { return memory; @@ -164,12 +164,12 @@ Memory* MapInfo::CreateMemory(const std::shared_ptr<Memory>& process_memory) { // map. In this case, there will be another read-only map that includes the // first part of the elf file. This is done if the linker rosegment // option is used. - std::unique_ptr<MemoryRange> memory(new MemoryRange(process_memory, start_, end_ - start_, 0)); + std::unique_ptr<MemoryRange> memory(new MemoryRange(process_memory, start(), end_ - start(), 0)); if (Elf::IsValidElf(memory.get())) { // Might need to peek at the next map to create a memory object that // includes that map too. - if (offset_ != 0 || name_.empty() || next_real_map_ == nullptr || - offset_ >= next_real_map_->offset_ || next_real_map_->name_ != name_) { + if (offset() != 0 || name_.empty() || next_real_map() == nullptr || + offset() >= next_real_map()->offset() || next_real_map()->name_ != name_) { return memory.release(); } @@ -178,10 +178,10 @@ Memory* MapInfo::CreateMemory(const std::shared_ptr<Memory>& process_memory) { // redo the work. If this happens, the elf for this map will eventually // be discarded. MemoryRanges* ranges = new MemoryRanges; - ranges->Insert(new MemoryRange(process_memory, start_, end_ - start_, 0)); - ranges->Insert(new MemoryRange(process_memory, next_real_map_->start_, - next_real_map_->end_ - next_real_map_->start_, - next_real_map_->offset_ - offset_)); + ranges->Insert(new MemoryRange(process_memory, start(), end() - start(), 0)); + ranges->Insert(new MemoryRange(process_memory, next_real_map()->start(), + next_real_map()->end() - next_real_map()->start(), + next_real_map()->offset() - offset())); return ranges; } @@ -190,22 +190,22 @@ Memory* MapInfo::CreateMemory(const std::shared_ptr<Memory>& process_memory) { // doesn't guarantee that this invariant will always be true. However, // if that changes, there is likely something else that will change and // break something. - if (offset_ == 0 || name_.empty() || prev_real_map_ == nullptr || - prev_real_map_->name_ != name_ || prev_real_map_->offset_ >= offset_) { + if (offset() == 0 || name_.empty() || prev_real_map_ == nullptr || + prev_real_map_->name_ != name_ || prev_real_map_->offset() >= offset()) { memory_backed_elf_ = false; return nullptr; } // Make sure that relative pc values are corrected properly. - elf_offset_ = offset_ - prev_real_map_->offset_; + elf_offset_ = offset() - prev_real_map_->offset(); // Use this as the elf start offset, otherwise, you always get offsets into // the r-x section, which is not quite the right information. - elf_start_offset_ = prev_real_map_->offset_; + elf_start_offset_ = prev_real_map_->offset(); MemoryRanges* ranges = new MemoryRanges; - ranges->Insert(new MemoryRange(process_memory, prev_real_map_->start_, - prev_real_map_->end_ - prev_real_map_->start_, 0)); - ranges->Insert(new MemoryRange(process_memory, start_, end_ - start_, elf_offset_)); + ranges->Insert(new MemoryRange(process_memory, prev_real_map()->start(), + prev_real_map()->end() - prev_real_map()->start(), 0)); + ranges->Insert(new MemoryRange(process_memory, start(), end() - start(), elf_offset_)); return ranges; } @@ -215,17 +215,17 @@ Elf* MapInfo::GetElf(const std::shared_ptr<Memory>& process_memory, ArchEnum exp // Make sure no other thread is trying to add the elf to this map. std::lock_guard<std::mutex> guard(mutex_); - if (elf_.get() != nullptr) { - return elf_.get(); + if (elf().get() != nullptr) { + return elf().get(); } bool locked = false; - if (Elf::CachingEnabled() && !name_.empty()) { + if (Elf::CachingEnabled() && !name().empty()) { Elf::CacheLock(); locked = true; if (Elf::CacheGet(this)) { Elf::CacheUnlock(); - return elf_.get(); + return elf().get(); } } @@ -234,16 +234,16 @@ Elf* MapInfo::GetElf(const std::shared_ptr<Memory>& process_memory, ArchEnum exp if (Elf::CacheAfterCreateMemory(this)) { delete memory; Elf::CacheUnlock(); - return elf_.get(); + return elf().get(); } } - elf_.reset(new Elf(memory)); + 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(); - if (elf_->valid() && expected_arch != elf_->arch()) { + elf()->Init(); + if (elf()->valid() && expected_arch != elf()->arch()) { // Make the elf invalid, mismatch between arch and expected arch. - elf_->Invalidate(); + elf()->Invalidate(); } if (locked) { @@ -252,40 +252,40 @@ Elf* MapInfo::GetElf(const std::shared_ptr<Memory>& process_memory, ArchEnum exp } } - if (!elf_->valid()) { - elf_start_offset_ = offset_; - } else if (prev_real_map_ != nullptr && elf_start_offset_ != offset_ && - prev_real_map_->offset_ == elf_start_offset_ && prev_real_map_->name_ == name_) { + if (!elf()->valid()) { + elf_start_offset_ = offset(); + } else if (prev_real_map_ != nullptr && elf_start_offset_ != offset() && + prev_real_map_->offset() == elf_start_offset_ && prev_real_map_->name_ == name_) { // If there is a read-only map then a read-execute map that represents the // same elf object, make sure the previous map is using the same elf // object if it hasn't already been set. std::lock_guard<std::mutex> guard(prev_real_map_->mutex_); - if (prev_real_map_->elf_.get() == nullptr) { - prev_real_map_->elf_ = elf_; - prev_real_map_->memory_backed_elf_ = memory_backed_elf_; + if (prev_real_map()->elf().get() == nullptr) { + prev_real_map_->elf_ = elf(); + prev_real_map()->memory_backed_elf_ = memory_backed_elf_; } else { // Discard this elf, and use the elf from the previous map instead. - elf_ = prev_real_map_->elf_; + elf_ = prev_real_map_->elf(); } } - return elf_.get(); + return elf().get(); } bool MapInfo::GetFunctionName(uint64_t addr, SharedString* name, uint64_t* func_offset) { { // Make sure no other thread is trying to update this elf object. std::lock_guard<std::mutex> guard(mutex_); - if (elf_ == nullptr) { + if (elf() == nullptr) { return false; } } // No longer need the lock, once the elf object is created, it is not deleted // until this object is deleted. - return elf_->GetFunctionName(addr, name, func_offset); + return elf()->GetFunctionName(addr, name, func_offset); } uint64_t MapInfo::GetLoadBias(const std::shared_ptr<Memory>& process_memory) { - int64_t cur_load_bias = load_bias_.load(); + int64_t cur_load_bias = load_bias().load(); if (cur_load_bias != INT64_MAX) { return cur_load_bias; } @@ -293,9 +293,9 @@ uint64_t MapInfo::GetLoadBias(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_); - if (elf_ != nullptr) { - if (elf_->valid()) { - cur_load_bias = elf_->GetLoadBias(); + if (elf() != nullptr) { + if (elf()->valid()) { + cur_load_bias = elf()->GetLoadBias(); load_bias_ = cur_load_bias; return cur_load_bias; } else { @@ -314,11 +314,11 @@ uint64_t MapInfo::GetLoadBias(const std::shared_ptr<Memory>& process_memory) { } MapInfo::~MapInfo() { - delete build_id_.load(); + delete build_id().load(); } SharedString MapInfo::GetBuildID() { - SharedString* id = build_id_.load(); + SharedString* id = build_id().load(); if (id != nullptr) { return *id; } @@ -330,7 +330,7 @@ SharedString MapInfo::GetBuildID() { // Now need to see if the elf object exists. // Make sure no other thread is trying to add the elf to this map. mutex_.lock(); - Elf* elf_obj = elf_.get(); + Elf* elf_obj = elf().get(); mutex_.unlock(); std::string result; if (elf_obj != nullptr) { diff --git a/libunwindstack/Maps.cpp b/libunwindstack/Maps.cpp index 2274c23..a1848b4 100644 --- a/libunwindstack/Maps.cpp +++ b/libunwindstack/Maps.cpp @@ -48,9 +48,9 @@ MapInfo* Maps::Find(uint64_t pc) { while (first < last) { size_t index = (first + last) / 2; const auto& cur = maps_[index]; - if (pc >= cur->start_ && pc < cur->end_) { + if (pc >= cur->start() && pc < cur->end()) { return cur.get(); - } else if (pc < cur->start_) { + } else if (pc < cur->start()) { last = index; } else { first = index + 1; @@ -84,7 +84,7 @@ void Maps::Add(uint64_t start, uint64_t end, uint64_t offset, uint64_t flags, MapInfo* prev_map = maps_.empty() ? nullptr : maps_.back().get(); MapInfo* prev_real_map = prev_map; while (prev_real_map != nullptr && prev_real_map->IsBlank()) { - prev_real_map = prev_real_map->prev_map_; + prev_real_map = prev_real_map->prev_map(); } auto map_info = @@ -96,7 +96,7 @@ void Maps::Add(uint64_t start, uint64_t end, uint64_t offset, uint64_t flags, void Maps::Sort() { std::sort(maps_.begin(), maps_.end(), [](const std::unique_ptr<MapInfo>& a, const std::unique_ptr<MapInfo>& b) { - return a->start_ < b->start_; + return a->start() < b->start(); }); // Set the prev_map values on the info objects. @@ -183,25 +183,25 @@ bool LocalUpdatableMaps::Reparse(/*out*/ bool* any_changed) { size_t num_deleted_new_entries = 0; for (size_t new_map_idx = last_map_idx; new_map_idx < maps_.size(); new_map_idx++) { auto& new_map_info = maps_[new_map_idx]; - uint64_t start = new_map_info->start_; - uint64_t end = new_map_info->end_; - uint64_t flags = new_map_info->flags_; - const std::string& name = new_map_info->name_; + uint64_t start = new_map_info->start(); + uint64_t end = new_map_info->end(); + uint64_t flags = new_map_info->flags(); + const std::string& name = new_map_info->name(); for (size_t old_map_idx = search_map_idx; old_map_idx < last_map_idx; old_map_idx++) { auto& info = maps_[old_map_idx]; - if (start == info->start_ && end == info->end_ && flags == info->flags_ && - name == info->name_) { + if (start == info->start() && end == info->end() && flags == info->flags() && + name == info->name()) { // No need to check search_map_idx = old_map_idx + 1; if (new_map_idx + 1 < maps_.size()) { maps_[new_map_idx + 1]->prev_map_ = info.get(); maps_[new_map_idx + 1]->prev_real_map_ = - info->IsBlank() ? info->prev_real_map_ : info.get(); + info->IsBlank() ? info->prev_real_map() : info.get(); } maps_[new_map_idx] = nullptr; num_deleted_new_entries++; break; - } else if (info->start_ > start) { + } else if (info->start() > start) { // Stop, there isn't going to be a match. search_map_idx = old_map_idx; break; diff --git a/libunwindstack/Unwinder.cpp b/libunwindstack/Unwinder.cpp index f655d9c..aae0fdb 100644 --- a/libunwindstack/Unwinder.cpp +++ b/libunwindstack/Unwinder.cpp @@ -62,19 +62,19 @@ void Unwinder::FillInDexFrame() { MapInfo* info = maps_->Find(dex_pc); if (info != nullptr) { - frame->map_start = info->start_; - frame->map_end = info->end_; + frame->map_start = info->start(); + frame->map_end = info->end(); // Since this is a dex file frame, the elf_start_offset is not set // by any of the normal code paths. Use the offset of the map since // that matches the actual offset. - frame->map_elf_start_offset = info->offset_; - frame->map_exact_offset = info->offset_; - frame->map_load_bias = info->load_bias_; - frame->map_flags = info->flags_; + frame->map_elf_start_offset = info->offset(); + frame->map_exact_offset = info->offset(); + frame->map_load_bias = info->load_bias(); + frame->map_flags = info->flags(); if (resolve_names_) { - frame->map_name = info->name_; + frame->map_name = info->name(); } - frame->rel_pc = dex_pc - info->start_; + frame->rel_pc = dex_pc - info->start(); } else { frame->rel_pc = dex_pc; warnings_ |= WARNING_DEX_PC_NOT_IN_MAP; @@ -110,8 +110,8 @@ FrameData* Unwinder::FillInFrame(MapInfo* map_info, Elf* elf, uint64_t rel_pc, } if (resolve_names_) { - frame->map_name = map_info->name_; - if (embedded_soname_ && map_info->elf_start_offset_ != 0 && !frame->map_name.empty()) { + frame->map_name = map_info->name(); + if (embedded_soname_ && map_info->elf_start_offset() != 0 && !frame->map_name.empty()) { std::string soname = elf->GetSoname(); if (!soname.empty()) { std::string map_with_soname; @@ -122,11 +122,11 @@ FrameData* Unwinder::FillInFrame(MapInfo* map_info, Elf* elf, uint64_t rel_pc, } } } - frame->map_elf_start_offset = map_info->elf_start_offset_; - frame->map_exact_offset = map_info->offset_; - frame->map_start = map_info->start_; - frame->map_end = map_info->end_; - frame->map_flags = map_info->flags_; + frame->map_elf_start_offset = map_info->elf_start_offset(); + frame->map_exact_offset = map_info->offset(); + frame->map_start = map_info->start(); + frame->map_end = map_info->end(); + frame->map_flags = map_info->flags(); frame->map_load_bias = elf->GetLoadBias(); return frame; } @@ -177,21 +177,21 @@ void Unwinder::Unwind(const std::vector<std::string>* initial_map_names_to_skip, last_error_.code = ERROR_INVALID_MAP; elf = nullptr; } else { - if (ShouldStop(map_suffixes_to_ignore, map_info->name_)) { + if (ShouldStop(map_suffixes_to_ignore, map_info->name())) { break; } elf = map_info->GetElf(process_memory_, arch_); // If this elf is memory backed, and there is a valid file, then set // an indicator that we couldn't open the file. - const std::string& map_name = map_info->name_; - if (!elf_from_memory_not_file_ && map_info->memory_backed_elf_ && !map_name.empty() && + const std::string& map_name = map_info->name(); + if (!elf_from_memory_not_file_ && map_info->memory_backed_elf() && !map_name.empty() && map_name[0] != '[' && !android::base::StartsWith(map_name, "/memfd:")) { elf_from_memory_not_file_ = true; } 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. - if (!(map_info->flags_ & MAPS_FLAGS_JIT_SYMFILE_MAP)) { + if (!(map_info->flags() & MAPS_FLAGS_JIT_SYMFILE_MAP)) { step_pc = rel_pc; } if (adjust_pc) { @@ -203,7 +203,7 @@ void Unwinder::Unwind(const std::vector<std::string>* initial_map_names_to_skip, // If the pc is in an invalid elf file, try and get an Elf object // using the jit debug information. - if (!elf->valid() && jit_debug_ != nullptr && (map_info->flags_ & PROT_EXEC)) { + if (!elf->valid() && jit_debug_ != nullptr && (map_info->flags() & PROT_EXEC)) { uint64_t adjusted_jit_pc = regs_->pc() - pc_adjustment; Elf* jit_elf = jit_debug_->Find(maps_, adjusted_jit_pc); if (jit_elf != nullptr) { @@ -217,7 +217,7 @@ void Unwinder::Unwind(const std::vector<std::string>* initial_map_names_to_skip, FrameData* frame = nullptr; if (map_info == nullptr || initial_map_names_to_skip == nullptr || std::find(initial_map_names_to_skip->begin(), initial_map_names_to_skip->end(), - basename(map_info->name_.c_str())) == initial_map_names_to_skip->end()) { + basename(map_info->name().c_str())) == initial_map_names_to_skip->end()) { if (regs_->dex_pc() != 0) { // Add a frame to represent the dex file. FillInDexFrame(); @@ -242,14 +242,14 @@ void Unwinder::Unwind(const std::vector<std::string>* initial_map_names_to_skip, bool in_device_map = false; bool finished = false; if (map_info != nullptr) { - if (map_info->flags_ & MAPS_FLAGS_DEVICE_MAP) { + if (map_info->flags() & MAPS_FLAGS_DEVICE_MAP) { // Do not stop here, fall through in case we are // in the speculative unwind path and need to remove // some of the speculative frames. in_device_map = true; } else { MapInfo* sp_info = maps_->Find(regs_->sp()); - if (sp_info != nullptr && sp_info->flags_ & MAPS_FLAGS_DEVICE_MAP) { + if (sp_info != nullptr && sp_info->flags() & MAPS_FLAGS_DEVICE_MAP) { // Do not stop here, fall through in case we are // in the speculative unwind path and need to remove // some of the speculative frames. @@ -473,12 +473,12 @@ FrameData Unwinder::BuildFrameFromPcOnly(uint64_t pc, ArchEnum arch, Maps* maps, // Copy all the things we need into the frame for symbolization. frame.rel_pc = relative_pc; frame.pc = pc - pc_adjustment; - frame.map_name = map_info->name_; - frame.map_elf_start_offset = map_info->elf_start_offset_; - frame.map_exact_offset = map_info->offset_; - frame.map_start = map_info->start_; - frame.map_end = map_info->end_; - frame.map_flags = map_info->flags_; + frame.map_name = map_info->name(); + frame.map_elf_start_offset = map_info->elf_start_offset(); + frame.map_exact_offset = map_info->offset(); + frame.map_start = map_info->start(); + frame.map_end = map_info->end(); + frame.map_flags = map_info->flags(); frame.map_load_bias = elf->GetLoadBias(); if (!resolve_names || diff --git a/libunwindstack/benchmarks/ElfBenchmark.cpp b/libunwindstack/benchmarks/ElfBenchmark.cpp index ec347b4..4a004dc 100644 --- a/libunwindstack/benchmarks/ElfBenchmark.cpp +++ b/libunwindstack/benchmarks/ElfBenchmark.cpp @@ -88,7 +88,7 @@ static void InitializeBuildId(benchmark::State& state, unwindstack::Maps& maps, // Find the libc.so share library and use that for benchmark purposes. *build_id_map_info = nullptr; for (auto& map_info : maps) { - if (map_info->offset_ == 0 && map_info->GetBuildID() != "") { + if (map_info->offset() == 0 && map_info->GetBuildID() != "") { *build_id_map_info = map_info.get(); break; } @@ -112,7 +112,7 @@ static void BM_elf_get_build_id_from_object(benchmark::State& state) { for (auto _ : state) { state.PauseTiming(); - unwindstack::SharedString* id = build_id_map_info->build_id_; + unwindstack::SharedString* id = build_id_map_info->build_id(); if (id != nullptr) { delete id; build_id_map_info->build_id_ = nullptr; @@ -130,7 +130,7 @@ static void BM_elf_get_build_id_from_file(benchmark::State& state) { for (auto _ : state) { state.PauseTiming(); - unwindstack::SharedString* id = build_id_map_info->build_id_; + unwindstack::SharedString* id = build_id_map_info->build_id(); if (id != nullptr) { delete id; build_id_map_info->build_id_ = nullptr; diff --git a/libunwindstack/include/unwindstack/MapInfo.h b/libunwindstack/include/unwindstack/MapInfo.h index c1f6683..026bda1 100644 --- a/libunwindstack/include/unwindstack/MapInfo.h +++ b/libunwindstack/include/unwindstack/MapInfo.h @@ -60,6 +60,21 @@ struct MapInfo { } ~MapInfo(); + inline uint64_t start() const { return start_; } + inline uint64_t end() const { return end_; } + inline uint64_t offset() const { return offset_; } + inline uint16_t flags() const { return flags_; } + inline SharedString& name() { return name_; } + inline std::shared_ptr<Elf>& elf() { return elf_; } + inline uint64_t elf_offset() const { return elf_offset_; } + inline uint64_t elf_start_offset() const { return elf_start_offset_; } + inline MapInfo* prev_map() const { return prev_map_; } + inline MapInfo* prev_real_map() const { return prev_real_map_; } + inline MapInfo* next_real_map() const { return next_real_map_; } + inline std::atomic_int64_t& load_bias() { return load_bias_; } + inline std::atomic<SharedString*>& build_id() { return build_id_; } + inline bool memory_backed_elf() const { return memory_backed_elf_; } + uint64_t start_ = 0; uint64_t end_ = 0; uint64_t offset_ = 0; diff --git a/libunwindstack/tests/DexFilesTest.cpp b/libunwindstack/tests/DexFilesTest.cpp index 2546cfe..cfb4a43 100644 --- a/libunwindstack/tests/DexFilesTest.cpp +++ b/libunwindstack/tests/DexFilesTest.cpp @@ -49,7 +49,7 @@ class DexFilesTest : public ::testing::Test { interface->FakeSetDataOffset(data_offset); interface->FakeSetDataVaddrStart(data_vaddr); interface->FakeSetDataVaddrEnd(data_vaddr + data_size); - map_info->elf_.reset(elf); + map_info->elf().reset(elf); } void Init(ArchEnum arch) { diff --git a/libunwindstack/tests/ElfCacheTest.cpp b/libunwindstack/tests/ElfCacheTest.cpp index 94ec356..65eef20 100644 --- a/libunwindstack/tests/ElfCacheTest.cpp +++ b/libunwindstack/tests/ElfCacheTest.cpp @@ -137,8 +137,8 @@ void ElfCacheTest::VerifyWithinSameMap(bool cache_enabled) { Elf* elf0_2 = info0_2.GetElf(memory_, ARCH_ARM); ASSERT_TRUE(elf0_2->valid()); EXPECT_EQ(ARCH_ARM, elf0_2->arch()); - EXPECT_EQ(0U, info0_1.elf_offset_); - EXPECT_EQ(0U, info0_2.elf_offset_); + EXPECT_EQ(0U, info0_1.elf_offset()); + EXPECT_EQ(0U, info0_2.elf_offset()); if (cache_enabled) { EXPECT_EQ(elf0_1, elf0_2); } else { @@ -151,8 +151,8 @@ void ElfCacheTest::VerifyWithinSameMap(bool cache_enabled) { Elf* elf100_2 = info100_2.GetElf(memory_, ARCH_X86); ASSERT_TRUE(elf100_2->valid()); EXPECT_EQ(ARCH_X86, elf100_2->arch()); - EXPECT_EQ(0U, info100_1.elf_offset_); - EXPECT_EQ(0U, info100_2.elf_offset_); + EXPECT_EQ(0U, info100_1.elf_offset()); + EXPECT_EQ(0U, info100_2.elf_offset()); if (cache_enabled) { EXPECT_EQ(elf100_1, elf100_2); } else { @@ -165,8 +165,8 @@ void ElfCacheTest::VerifyWithinSameMap(bool cache_enabled) { Elf* elf200_2 = info200_2.GetElf(memory_, ARCH_X86_64); ASSERT_TRUE(elf200_2->valid()); EXPECT_EQ(ARCH_X86_64, elf200_2->arch()); - EXPECT_EQ(0U, info200_1.elf_offset_); - EXPECT_EQ(0U, info200_2.elf_offset_); + EXPECT_EQ(0U, info200_1.elf_offset()); + EXPECT_EQ(0U, info200_2.elf_offset()); if (cache_enabled) { EXPECT_EQ(elf200_1, elf200_2); } else { @@ -179,8 +179,8 @@ void ElfCacheTest::VerifyWithinSameMap(bool cache_enabled) { Elf* elf300_2 = info300_2.GetElf(memory_, ARCH_ARM); ASSERT_TRUE(elf300_2->valid()); EXPECT_EQ(ARCH_ARM, elf300_2->arch()); - EXPECT_EQ(0x300U, info300_1.elf_offset_); - EXPECT_EQ(0x300U, info300_2.elf_offset_); + EXPECT_EQ(0x300U, info300_1.elf_offset()); + EXPECT_EQ(0x300U, info300_2.elf_offset()); if (cache_enabled) { EXPECT_EQ(elf300_1, elf300_2); EXPECT_EQ(elf0_1, elf300_1); @@ -227,8 +227,8 @@ void ElfCacheTest::VerifyWithinSameMapNeverReadAtZero(bool cache_enabled) { Elf* elf300_2 = info300_2.GetElf(memory_, ARCH_ARM); ASSERT_TRUE(elf300_2->valid()); EXPECT_EQ(ARCH_ARM, elf300_2->arch()); - EXPECT_EQ(0x300U, info300_1.elf_offset_); - EXPECT_EQ(0x300U, info300_2.elf_offset_); + EXPECT_EQ(0x300U, info300_1.elf_offset()); + EXPECT_EQ(0x300U, info300_2.elf_offset()); if (cache_enabled) { EXPECT_EQ(elf300_1, elf300_2); } else { @@ -241,8 +241,8 @@ void ElfCacheTest::VerifyWithinSameMapNeverReadAtZero(bool cache_enabled) { Elf* elf400_2 = info400_2.GetElf(memory_, ARCH_ARM); ASSERT_TRUE(elf400_2->valid()); EXPECT_EQ(ARCH_ARM, elf400_2->arch()); - EXPECT_EQ(0x400U, info400_1.elf_offset_); - EXPECT_EQ(0x400U, info400_2.elf_offset_); + EXPECT_EQ(0x400U, info400_1.elf_offset()); + EXPECT_EQ(0x400U, info400_2.elf_offset()); if (cache_enabled) { EXPECT_EQ(elf400_1, elf400_2); EXPECT_EQ(elf300_1, elf400_1); diff --git a/libunwindstack/tests/JitDebugTest.cpp b/libunwindstack/tests/JitDebugTest.cpp index b6e9f10..f829629 100644 --- a/libunwindstack/tests/JitDebugTest.cpp +++ b/libunwindstack/tests/JitDebugTest.cpp @@ -46,7 +46,7 @@ class JitDebugTest : public ::testing::Test { interface->FakeSetDataOffset(data_offset); interface->FakeSetDataVaddrStart(data_vaddr); interface->FakeSetDataVaddrEnd(data_vaddr + data_size); - map_info->elf_.reset(elf); + map_info->elf().reset(elf); } void Init(ArchEnum arch) { diff --git a/libunwindstack/tests/LocalUnwinderTest.cpp b/libunwindstack/tests/LocalUnwinderTest.cpp index 7579fb6..5658aa3 100644 --- a/libunwindstack/tests/LocalUnwinderTest.cpp +++ b/libunwindstack/tests/LocalUnwinderTest.cpp @@ -58,15 +58,15 @@ static std::string ErrorMsg(const std::vector<const char*>& function_names, unwind += android::base::StringPrintf("#%02zu pc 0x%" PRIx64 " rel_pc 0x%" PRIx64, i++, frame.pc, frame.rel_pc); if (frame.map_info != nullptr) { - if (!frame.map_info->name_.empty()) { + if (!frame.map_info->name().empty()) { unwind += " "; - unwind += frame.map_info->name_; + unwind += frame.map_info->name(); } else { - unwind += android::base::StringPrintf(" 0x%" PRIx64 "-0x%" PRIx64, frame.map_info->start_, - frame.map_info->end_); + unwind += android::base::StringPrintf(" 0x%" PRIx64 "-0x%" PRIx64, frame.map_info->start(), + frame.map_info->end()); } - if (frame.map_info->offset_ != 0) { - unwind += android::base::StringPrintf(" offset 0x%" PRIx64, frame.map_info->offset_); + if (frame.map_info->offset() != 0) { + unwind += android::base::StringPrintf(" offset 0x%" PRIx64, frame.map_info->offset()); } } if (!frame.function_name.empty()) { diff --git a/libunwindstack/tests/LocalUpdatableMapsTest.cpp b/libunwindstack/tests/LocalUpdatableMapsTest.cpp index 66246b9..07a3dba 100644 --- a/libunwindstack/tests/LocalUpdatableMapsTest.cpp +++ b/libunwindstack/tests/LocalUpdatableMapsTest.cpp @@ -58,19 +58,19 @@ class LocalUpdatableMapsTest : public ::testing::Test { MapInfo* map_info = maps_.Get(0); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x3000U, map_info->start_); - EXPECT_EQ(0x4000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); - EXPECT_TRUE(map_info->name_.empty()); + EXPECT_EQ(0x3000U, map_info->start()); + EXPECT_EQ(0x4000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); + EXPECT_TRUE(map_info->name().empty()); map_info = maps_.Get(1); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x8000U, map_info->start_); - EXPECT_EQ(0x9000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); - EXPECT_TRUE(map_info->name_.empty()); + EXPECT_EQ(0x8000U, map_info->start()); + EXPECT_EQ(0x9000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); + EXPECT_TRUE(map_info->name().empty()); } TestUpdatableMaps maps_; @@ -87,19 +87,19 @@ TEST_F(LocalUpdatableMapsTest, same_map) { MapInfo* map_info = maps_.Get(0); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x3000U, map_info->start_); - EXPECT_EQ(0x4000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); - EXPECT_TRUE(map_info->name_.empty()); + EXPECT_EQ(0x3000U, map_info->start()); + EXPECT_EQ(0x4000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); + EXPECT_TRUE(map_info->name().empty()); map_info = maps_.Get(1); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x8000U, map_info->start_); - EXPECT_EQ(0x9000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); - EXPECT_TRUE(map_info->name_.empty()); + EXPECT_EQ(0x8000U, map_info->start()); + EXPECT_EQ(0x9000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); + EXPECT_TRUE(map_info->name().empty()); } TEST_F(LocalUpdatableMapsTest, same_map_new_perms) { @@ -115,28 +115,28 @@ TEST_F(LocalUpdatableMapsTest, same_map_new_perms) { MapInfo* map_info = maps_.Get(0); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x3000U, map_info->start_); - EXPECT_EQ(0x4000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x3000U, map_info->start()); + EXPECT_EQ(0x4000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); map_info = maps_.Get(1); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x8000U, map_info->start_); - EXPECT_EQ(0x9000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x8000U, map_info->start()); + EXPECT_EQ(0x9000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); auto& saved_maps = maps_.TestGetSavedMaps(); ASSERT_EQ(1U, saved_maps.size()); map_info = saved_maps[0].get(); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x3000U, map_info->start_); - EXPECT_EQ(0x4000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x3000U, map_info->start()); + EXPECT_EQ(0x4000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); } @@ -153,28 +153,28 @@ TEST_F(LocalUpdatableMapsTest, same_map_new_name) { MapInfo* map_info = maps_.Get(0); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x3000U, map_info->start_); - EXPECT_EQ(0x4000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); - EXPECT_EQ("/fake/lib.so", map_info->name_); + EXPECT_EQ(0x3000U, map_info->start()); + EXPECT_EQ(0x4000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); + EXPECT_EQ("/fake/lib.so", map_info->name()); map_info = maps_.Get(1); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x8000U, map_info->start_); - EXPECT_EQ(0x9000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x8000U, map_info->start()); + EXPECT_EQ(0x9000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); auto& saved_maps = maps_.TestGetSavedMaps(); ASSERT_EQ(1U, saved_maps.size()); map_info = saved_maps[0].get(); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x3000U, map_info->start_); - EXPECT_EQ(0x4000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x3000U, map_info->start()); + EXPECT_EQ(0x4000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); } @@ -194,34 +194,34 @@ TEST_F(LocalUpdatableMapsTest, only_add_maps) { MapInfo* map_info = maps_.Get(0); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x1000U, map_info->start_); - EXPECT_EQ(0x2000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x1000U, map_info->start()); + EXPECT_EQ(0x2000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); map_info = maps_.Get(1); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x3000U, map_info->start_); - EXPECT_EQ(0x4000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x3000U, map_info->start()); + EXPECT_EQ(0x4000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); map_info = maps_.Get(2); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x8000U, map_info->start_); - EXPECT_EQ(0x9000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x8000U, map_info->start()); + EXPECT_EQ(0x9000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); map_info = maps_.Get(3); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0xa000U, map_info->start_); - EXPECT_EQ(0xf000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0xa000U, map_info->start()); + EXPECT_EQ(0xf000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); } @@ -238,36 +238,36 @@ TEST_F(LocalUpdatableMapsTest, all_new_maps) { MapInfo* map_info = maps_.Get(0); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x1000U, map_info->start_); - EXPECT_EQ(0x2000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x1000U, map_info->start()); + EXPECT_EQ(0x2000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); map_info = maps_.Get(1); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0xa000U, map_info->start_); - EXPECT_EQ(0xf000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0xa000U, map_info->start()); + EXPECT_EQ(0xf000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); auto& saved_maps = maps_.TestGetSavedMaps(); ASSERT_EQ(2U, saved_maps.size()); map_info = saved_maps[0].get(); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x3000U, map_info->start_); - EXPECT_EQ(0x4000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x3000U, map_info->start()); + EXPECT_EQ(0x4000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); map_info = saved_maps[1].get(); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x8000U, map_info->start_); - EXPECT_EQ(0x9000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x8000U, map_info->start()); + EXPECT_EQ(0x9000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); } @@ -285,12 +285,12 @@ TEST_F(LocalUpdatableMapsTest, add_map_prev_name_updated) { MapInfo* map_info = maps_.Get(2); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x9000U, map_info->start_); - EXPECT_EQ(0xA000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); + EXPECT_EQ(0x9000U, map_info->start()); + EXPECT_EQ(0xA000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); EXPECT_TRUE(map_info->name_.empty()); - EXPECT_EQ(maps_.Get(1), map_info->prev_map_); + EXPECT_EQ(maps_.Get(1), map_info->prev_map()); } TEST_F(LocalUpdatableMapsTest, add_map_prev_real_name_updated) { @@ -315,22 +315,22 @@ TEST_F(LocalUpdatableMapsTest, add_map_prev_real_name_updated) { MapInfo* map_info = maps_.Get(2); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x7000U, map_info->start_); - EXPECT_EQ(0x8000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); - EXPECT_EQ(maps_.Get(0), map_info->prev_real_map_); - EXPECT_EQ(maps_.Get(1), map_info->prev_map_); - EXPECT_EQ("/fake/lib1.so", map_info->name_); + EXPECT_EQ(0x7000U, map_info->start()); + EXPECT_EQ(0x8000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); + EXPECT_EQ(maps_.Get(0), map_info->prev_real_map()); + EXPECT_EQ(maps_.Get(1), map_info->prev_map()); + EXPECT_EQ("/fake/lib1.so", map_info->name()); map_info = maps_.Get(3); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x8000U, map_info->start_); - EXPECT_EQ(0x9000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); + EXPECT_EQ(0x8000U, map_info->start()); + EXPECT_EQ(0x9000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); EXPECT_TRUE(map_info->IsBlank()); - EXPECT_EQ(maps_.Get(2), map_info->prev_real_map_); - EXPECT_EQ(maps_.Get(2), map_info->prev_map_); + EXPECT_EQ(maps_.Get(2), map_info->prev_real_map()); + EXPECT_EQ(maps_.Get(2), map_info->prev_map()); EXPECT_TRUE(map_info->name_.empty()); ASSERT_TRUE( @@ -354,33 +354,33 @@ TEST_F(LocalUpdatableMapsTest, add_map_prev_real_name_updated) { map_info = maps_.Get(2); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x7000U, map_info->start_); - EXPECT_EQ(0x8000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); - EXPECT_EQ("/fake/lib1.so", map_info->name_); - EXPECT_EQ(maps_.Get(1), map_info->prev_map_); - EXPECT_EQ(maps_.Get(0), map_info->prev_real_map_); + EXPECT_EQ(0x7000U, map_info->start()); + EXPECT_EQ(0x8000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); + EXPECT_EQ("/fake/lib1.so", map_info->name()); + EXPECT_EQ(maps_.Get(1), map_info->prev_map()); + EXPECT_EQ(maps_.Get(0), map_info->prev_real_map()); map_info = maps_.Get(4); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0x9000U, map_info->start_); - EXPECT_EQ(0xA000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); - EXPECT_EQ("/fake/lib2.so", map_info->name_); - EXPECT_EQ(maps_.Get(3), map_info->prev_map_); - EXPECT_EQ(maps_.Get(2), map_info->prev_real_map_); + EXPECT_EQ(0x9000U, map_info->start()); + EXPECT_EQ(0xA000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); + EXPECT_EQ("/fake/lib2.so", map_info->name()); + EXPECT_EQ(maps_.Get(3), map_info->prev_map()); + EXPECT_EQ(maps_.Get(2), map_info->prev_real_map()); map_info = maps_.Get(5); ASSERT_TRUE(map_info != nullptr); - EXPECT_EQ(0xA000U, map_info->start_); - EXPECT_EQ(0xB000U, map_info->end_); - EXPECT_EQ(0U, map_info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags_); - EXPECT_EQ("/fake/lib3.so", map_info->name_); - EXPECT_EQ(maps_.Get(4), map_info->prev_map_); - EXPECT_EQ(maps_.Get(4), map_info->prev_real_map_); + EXPECT_EQ(0xA000U, map_info->start()); + EXPECT_EQ(0xB000U, map_info->end()); + EXPECT_EQ(0U, map_info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, map_info->flags()); + EXPECT_EQ("/fake/lib3.so", map_info->name()); + EXPECT_EQ(maps_.Get(4), map_info->prev_map()); + EXPECT_EQ(maps_.Get(4), map_info->prev_real_map()); } } // namespace unwindstack diff --git a/libunwindstack/tests/MapInfoCreateMemoryTest.cpp b/libunwindstack/tests/MapInfoCreateMemoryTest.cpp index f2c6dce..53b56a6 100644 --- a/libunwindstack/tests/MapInfoCreateMemoryTest.cpp +++ b/libunwindstack/tests/MapInfoCreateMemoryTest.cpp @@ -102,7 +102,7 @@ TEST_F(MapInfoCreateMemoryTest, end_le_start) { info.end_ = 0x101; memory.reset(info.CreateMemory(process_memory_)); ASSERT_TRUE(memory.get() != nullptr); - EXPECT_FALSE(info.memory_backed_elf_); + EXPECT_FALSE(info.memory_backed_elf()); } // Verify that if the offset is non-zero but there is no elf at the offset, @@ -112,9 +112,9 @@ TEST_F(MapInfoCreateMemoryTest, file_backed_non_zero_offset_full_file) { std::unique_ptr<Memory> memory(info.CreateMemory(process_memory_)); ASSERT_TRUE(memory.get() != nullptr); - EXPECT_FALSE(info.memory_backed_elf_); - ASSERT_EQ(0x100U, info.elf_offset_); - EXPECT_EQ(0x100U, info.elf_start_offset_); + EXPECT_FALSE(info.memory_backed_elf()); + ASSERT_EQ(0x100U, info.elf_offset()); + EXPECT_EQ(0x100U, info.elf_start_offset()); // Read the entire file. std::vector<uint8_t> buffer(1024); @@ -140,9 +140,9 @@ TEST_F(MapInfoCreateMemoryTest, file_backed_non_zero_offset_full_file) { info.memory_backed_elf_ = false; memory.reset(info.CreateMemory(process_memory_)); ASSERT_TRUE(memory.get() != nullptr); - EXPECT_FALSE(info.memory_backed_elf_); - ASSERT_EQ(0x100U, info.elf_offset_); - EXPECT_EQ(0x100U, info.elf_start_offset_); + EXPECT_FALSE(info.memory_backed_elf()); + ASSERT_EQ(0x100U, info.elf_offset()); + EXPECT_EQ(0x100U, info.elf_start_offset()); prev_info.offset_ = 0; info.elf_offset_ = 0; @@ -150,9 +150,9 @@ TEST_F(MapInfoCreateMemoryTest, file_backed_non_zero_offset_full_file) { info.memory_backed_elf_ = false; memory.reset(info.CreateMemory(process_memory_)); ASSERT_TRUE(memory.get() != nullptr); - EXPECT_FALSE(info.memory_backed_elf_); - ASSERT_EQ(0x100U, info.elf_offset_); - EXPECT_EQ(0x100U, info.elf_start_offset_); + EXPECT_FALSE(info.memory_backed_elf()); + ASSERT_EQ(0x100U, info.elf_offset()); + EXPECT_EQ(0x100U, info.elf_start_offset()); prev_info.flags_ = PROT_READ; info.elf_offset_ = 0; @@ -160,19 +160,19 @@ TEST_F(MapInfoCreateMemoryTest, file_backed_non_zero_offset_full_file) { info.memory_backed_elf_ = false; memory.reset(info.CreateMemory(process_memory_)); ASSERT_TRUE(memory.get() != nullptr); - EXPECT_FALSE(info.memory_backed_elf_); - ASSERT_EQ(0x100U, info.elf_offset_); - EXPECT_EQ(0x100U, info.elf_start_offset_); + EXPECT_FALSE(info.memory_backed_elf()); + ASSERT_EQ(0x100U, info.elf_offset()); + EXPECT_EQ(0x100U, info.elf_start_offset()); - prev_info.name_ = info.name_; + prev_info.name_ = info.name(); info.elf_offset_ = 0; info.elf_start_offset_ = 0; info.memory_backed_elf_ = false; memory.reset(info.CreateMemory(process_memory_)); ASSERT_TRUE(memory.get() != nullptr); EXPECT_FALSE(info.memory_backed_elf_); - ASSERT_EQ(0x100U, info.elf_offset_); - EXPECT_EQ(0U, info.elf_start_offset_); + ASSERT_EQ(0x100U, info.elf_offset()); + EXPECT_EQ(0U, info.elf_start_offset()); } // Verify that if the offset is non-zero and there is an elf at that @@ -183,8 +183,8 @@ TEST_F(MapInfoCreateMemoryTest, file_backed_non_zero_offset_partial_file) { std::unique_ptr<Memory> memory(info.CreateMemory(process_memory_)); ASSERT_TRUE(memory.get() != nullptr); EXPECT_FALSE(info.memory_backed_elf_); - ASSERT_EQ(0U, info.elf_offset_); - EXPECT_EQ(0x1000U, info.elf_start_offset_); + ASSERT_EQ(0U, info.elf_offset()); + EXPECT_EQ(0x1000U, info.elf_start_offset()); // Read the valid part of the file. std::vector<uint8_t> buffer(0x100); @@ -208,8 +208,8 @@ TEST_F(MapInfoCreateMemoryTest, file_backed_non_zero_offset_partial_file_whole_e std::unique_ptr<Memory> memory(info.CreateMemory(process_memory_)); ASSERT_TRUE(memory.get() != nullptr); EXPECT_FALSE(info.memory_backed_elf_); - ASSERT_EQ(0U, info.elf_offset_); - EXPECT_EQ(0x1000U, info.elf_start_offset_); + ASSERT_EQ(0U, info.elf_offset()); + EXPECT_EQ(0x1000U, info.elf_start_offset()); // Verify the memory is a valid elf. uint8_t e_ident[SELFMAG + 1]; @@ -226,8 +226,8 @@ TEST_F(MapInfoCreateMemoryTest, file_backed_non_zero_offset_partial_file_whole_e std::unique_ptr<Memory> memory(info.CreateMemory(process_memory_)); ASSERT_TRUE(memory.get() != nullptr); EXPECT_FALSE(info.memory_backed_elf_); - ASSERT_EQ(0U, info.elf_offset_); - EXPECT_EQ(0x2000U, info.elf_start_offset_); + ASSERT_EQ(0U, info.elf_offset()); + EXPECT_EQ(0x2000U, info.elf_start_offset()); // Verify the memory is a valid elf. uint8_t e_ident[SELFMAG + 1]; @@ -263,7 +263,7 @@ TEST_F(MapInfoCreateMemoryTest, process_memory) { for (size_t i = sizeof(ehdr); i < buffer.size(); i++) { buffer[i] = i % 256; } - memory_->SetMemory(info.start_, buffer.data(), buffer.size()); + memory_->SetMemory(info.start(), buffer.data(), buffer.size()); std::unique_ptr<Memory> memory(info.CreateMemory(process_memory_)); ASSERT_TRUE(memory.get() != nullptr); @@ -300,9 +300,9 @@ TEST_F(MapInfoCreateMemoryTest, valid_rosegment_zero_offset) { std::unique_ptr<Memory> mem(map_info->CreateMemory(process_memory_)); ASSERT_TRUE(mem.get() != nullptr); EXPECT_TRUE(map_info->memory_backed_elf_); - EXPECT_EQ(0x4000UL, map_info->elf_offset_); - EXPECT_EQ(0x4000UL, map_info->offset_); - EXPECT_EQ(0U, map_info->elf_start_offset_); + EXPECT_EQ(0x4000UL, map_info->elf_offset()); + EXPECT_EQ(0x4000UL, map_info->offset()); + EXPECT_EQ(0U, map_info->elf_start_offset()); // Verify that reading values from this memory works properly. std::vector<uint8_t> buffer(0x4000); @@ -347,9 +347,9 @@ TEST_F(MapInfoCreateMemoryTest, valid_rosegment_non_zero_offset) { std::unique_ptr<Memory> mem(map_info->CreateMemory(process_memory_)); ASSERT_TRUE(mem.get() != nullptr); EXPECT_TRUE(map_info->memory_backed_elf_); - EXPECT_EQ(0x1000UL, map_info->elf_offset_); - EXPECT_EQ(0xb000UL, map_info->offset_); - EXPECT_EQ(0xa000UL, map_info->elf_start_offset_); + EXPECT_EQ(0x1000UL, map_info->elf_offset()); + EXPECT_EQ(0xb000UL, map_info->offset()); + EXPECT_EQ(0xa000UL, map_info->elf_start_offset()); // Verify that reading values from this memory works properly. std::vector<uint8_t> buffer(0x4000); @@ -387,9 +387,9 @@ TEST_F(MapInfoCreateMemoryTest, rosegment_from_file) { ASSERT_TRUE(memory.get() != nullptr); EXPECT_FALSE(map_info->memory_backed_elf_); std::vector<uint8_t> buffer(0x100); - EXPECT_EQ(0x2000U, map_info->offset_); - EXPECT_EQ(0U, map_info->elf_offset_); - EXPECT_EQ(0U, map_info->elf_start_offset_); + EXPECT_EQ(0x2000U, map_info->offset()); + EXPECT_EQ(0U, map_info->elf_offset()); + EXPECT_EQ(0U, map_info->elf_start_offset()); ASSERT_TRUE(memory->ReadFully(0, buffer.data(), 0x100)); EXPECT_EQ(0xffU, buffer[0]); @@ -403,9 +403,9 @@ TEST_F(MapInfoCreateMemoryTest, rosegment_from_file) { map_info->memory_backed_elf_ = false; memory.reset(map_info->CreateMemory(process_memory_)); EXPECT_FALSE(map_info->memory_backed_elf_); - EXPECT_EQ(0x2000U, map_info->offset_); - EXPECT_EQ(0x1000U, map_info->elf_offset_); - EXPECT_EQ(0x1000U, map_info->elf_start_offset_); + EXPECT_EQ(0x2000U, map_info->offset()); + EXPECT_EQ(0x1000U, map_info->elf_offset()); + EXPECT_EQ(0x1000U, map_info->elf_start_offset()); Elf64_Ehdr ehdr_mem; ASSERT_TRUE(memory->ReadFully(0, &ehdr_mem, sizeof(ehdr_mem))); EXPECT_TRUE(memcmp(&ehdr, &ehdr_mem, sizeof(ehdr)) == 0); @@ -431,9 +431,9 @@ TEST_F(MapInfoCreateMemoryTest, valid_rosegment_offset_overflow) { std::unique_ptr<Memory> mem(map_info->CreateMemory(process_memory_)); ASSERT_TRUE(mem.get() != nullptr); EXPECT_TRUE(map_info->memory_backed_elf_); - EXPECT_EQ(0xfffffffffffff000UL, map_info->elf_offset_); - EXPECT_EQ(0xfffffffffffff000UL, map_info->offset_); - EXPECT_EQ(0U, map_info->elf_start_offset_); + EXPECT_EQ(0xfffffffffffff000UL, map_info->elf_offset()); + EXPECT_EQ(0xfffffffffffff000UL, map_info->offset()); + EXPECT_EQ(0U, map_info->elf_start_offset()); // Verify that reading values from this memory works properly. std::vector<uint8_t> buffer(0x2000); diff --git a/libunwindstack/tests/MapInfoGetBuildIDTest.cpp b/libunwindstack/tests/MapInfoGetBuildIDTest.cpp index 8724ed6..a88d120 100644 --- a/libunwindstack/tests/MapInfoGetBuildIDTest.cpp +++ b/libunwindstack/tests/MapInfoGetBuildIDTest.cpp @@ -74,7 +74,7 @@ TEST_F(MapInfoGetBuildIDTest, no_elf_and_no_valid_elf_in_memory) { } TEST_F(MapInfoGetBuildIDTest, from_elf) { - map_info_->elf_.reset(elf_container_.release()); + map_info_->elf().reset(elf_container_.release()); elf_interface_->FakeSetBuildID("FAKE_BUILD_ID"); EXPECT_EQ("FAKE_BUILD_ID", map_info_->GetBuildID()); @@ -82,7 +82,7 @@ TEST_F(MapInfoGetBuildIDTest, from_elf) { } TEST_F(MapInfoGetBuildIDTest, from_elf_no_sign_extension) { - map_info_->elf_.reset(elf_container_.release()); + map_info_->elf().reset(elf_container_.release()); std::string build_id = {static_cast<char>(0xfa), static_cast<char>(0xab), static_cast<char>(0x12), static_cast<char>(0x02)}; @@ -125,7 +125,7 @@ void MapInfoGetBuildIDTest::MultipleThreadTest(std::string expected_build_id) { } TEST_F(MapInfoGetBuildIDTest, multiple_thread_elf_exists) { - map_info_->elf_.reset(elf_container_.release()); + map_info_->elf().reset(elf_container_.release()); elf_interface_->FakeSetBuildID("FAKE_BUILD_ID"); MultipleThreadTest("FAKE_BUILD_ID"); diff --git a/libunwindstack/tests/MapInfoGetElfTest.cpp b/libunwindstack/tests/MapInfoGetElfTest.cpp index 018c57a..9ba01e0 100644 --- a/libunwindstack/tests/MapInfoGetElfTest.cpp +++ b/libunwindstack/tests/MapInfoGetElfTest.cpp @@ -92,7 +92,7 @@ TEST_F(MapInfoGetElfTest, valid32) { EXPECT_EQ(ELFCLASS32, elf->class_type()); // Now verify that an empty process memory returns an invalid elf object. - info.elf_.reset(); + info.elf().reset(); elf = info.GetElf(std::shared_ptr<Memory>(), ARCH_ARM); ASSERT_TRUE(elf != nullptr); ASSERT_FALSE(elf->valid()); @@ -167,14 +167,14 @@ TEST_F(MapInfoGetElfTest, end_le_start) { ASSERT_TRUE(elf != nullptr); ASSERT_FALSE(elf->valid()); - info.elf_.reset(); + info.elf().reset(); info.end_ = 0xfff; elf = info.GetElf(process_memory_, ARCH_ARM); ASSERT_TRUE(elf != nullptr); ASSERT_FALSE(elf->valid()); // Make sure this test is valid. - info.elf_.reset(); + info.elf().reset(); info.end_ = 0x2000; elf = info.GetElf(process_memory_, ARCH_ARM); ASSERT_TRUE(elf != nullptr); @@ -197,7 +197,7 @@ TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_full_file) { ASSERT_TRUE(elf != nullptr); ASSERT_TRUE(elf->valid()); ASSERT_TRUE(elf->memory() != nullptr); - ASSERT_EQ(0x100U, info.elf_offset_); + ASSERT_EQ(0x100U, info.elf_offset()); // Read the entire file. memset(buffer.data(), 0, buffer.size()); @@ -219,14 +219,14 @@ TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_partial_file) { memset(buffer.data(), 0, buffer.size()); Elf32_Ehdr ehdr; TestInitEhdr<Elf32_Ehdr>(&ehdr, ELFCLASS32, EM_ARM); - memcpy(&buffer[info.offset_], &ehdr, sizeof(ehdr)); + memcpy(&buffer[info.offset()], &ehdr, sizeof(ehdr)); ASSERT_TRUE(android::base::WriteFully(elf_.fd, buffer.data(), buffer.size())); Elf* elf = info.GetElf(process_memory_, ARCH_ARM); ASSERT_TRUE(elf != nullptr); ASSERT_TRUE(elf->valid()); ASSERT_TRUE(elf->memory() != nullptr); - ASSERT_EQ(0U, info.elf_offset_); + ASSERT_EQ(0U, info.elf_offset()); // Read the valid part of the file. ASSERT_TRUE(elf->memory()->ReadFully(0, buffer.data(), 0x1000)); @@ -252,14 +252,14 @@ TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_partial_file_whole_elf32) ehdr.e_shoff = 0x2000; ehdr.e_shentsize = sizeof(Elf32_Shdr) + 100; ehdr.e_shnum = 4; - memcpy(&buffer[info.offset_], &ehdr, sizeof(ehdr)); + memcpy(&buffer[info.offset()], &ehdr, sizeof(ehdr)); ASSERT_TRUE(android::base::WriteFully(elf_.fd, buffer.data(), buffer.size())); Elf* elf = info.GetElf(process_memory_, ARCH_ARM); ASSERT_TRUE(elf != nullptr); ASSERT_TRUE(elf->valid()); ASSERT_TRUE(elf->memory() != nullptr); - ASSERT_EQ(0U, info.elf_offset_); + ASSERT_EQ(0U, info.elf_offset()); // Verify the memory is a valid elf. memset(buffer.data(), 0, buffer.size()); @@ -280,14 +280,14 @@ TEST_F(MapInfoGetElfTest, file_backed_non_zero_offset_partial_file_whole_elf64) ehdr.e_shoff = 0x2000; ehdr.e_shentsize = sizeof(Elf64_Shdr) + 100; ehdr.e_shnum = 4; - memcpy(&buffer[info.offset_], &ehdr, sizeof(ehdr)); + memcpy(&buffer[info.offset()], &ehdr, sizeof(ehdr)); ASSERT_TRUE(android::base::WriteFully(elf_.fd, buffer.data(), buffer.size())); Elf* elf = info.GetElf(process_memory_, ARCH_ARM64); ASSERT_TRUE(elf != nullptr); ASSERT_TRUE(elf->valid()); ASSERT_TRUE(elf->memory() != nullptr); - ASSERT_EQ(0U, info.elf_offset_); + ASSERT_EQ(0U, info.elf_offset()); // Verify the memory is a valid elf. memset(buffer.data(), 0, buffer.size()); @@ -316,13 +316,13 @@ TEST_F(MapInfoGetElfTest, check_device_maps) { ASSERT_FALSE(elf->valid()); // Set the name to nothing to verify that it still fails. - info.elf_.reset(); + info.elf().reset(); info.name_ = ""; elf = info.GetElf(process_memory_, ARCH_X86_64); ASSERT_FALSE(elf->valid()); // Change the flags and verify the elf is valid now. - info.elf_.reset(); + info.elf().reset(); info.flags_ = PROT_READ; elf = info.GetElf(process_memory_, ARCH_X86_64); ASSERT_TRUE(elf->valid()); @@ -355,7 +355,7 @@ TEST_F(MapInfoGetElfTest, multiple_thread_get_elf) { }); threads.push_back(thread); } - ASSERT_TRUE(info.elf_ == nullptr); + ASSERT_TRUE(info.elf() == nullptr); // Set them all going and wait for the threads to finish. wait = false; @@ -365,7 +365,7 @@ TEST_F(MapInfoGetElfTest, multiple_thread_get_elf) { } // Now verify that all of the elf files are exactly the same and valid. - Elf* elf = info.elf_.get(); + Elf* elf = info.elf().get(); ASSERT_TRUE(elf != nullptr); EXPECT_TRUE(elf->valid()); for (size_t i = 0; i < kNumConcurrentThreads; i++) { diff --git a/libunwindstack/tests/MapInfoGetLoadBiasTest.cpp b/libunwindstack/tests/MapInfoGetLoadBiasTest.cpp index fa471cc..d60b600 100644 --- a/libunwindstack/tests/MapInfoGetLoadBiasTest.cpp +++ b/libunwindstack/tests/MapInfoGetLoadBiasTest.cpp @@ -69,7 +69,7 @@ TEST_F(MapInfoGetLoadBiasTest, no_elf_and_no_valid_elf_in_memory) { } TEST_F(MapInfoGetLoadBiasTest, load_bias_cached_from_elf) { - map_info_->elf_.reset(elf_container_.release()); + map_info_->elf().reset(elf_container_.release()); elf_->FakeSetLoadBias(0); EXPECT_EQ(0U, map_info_->GetLoadBias(process_memory_)); @@ -79,7 +79,7 @@ TEST_F(MapInfoGetLoadBiasTest, load_bias_cached_from_elf) { } TEST_F(MapInfoGetLoadBiasTest, elf_exists) { - map_info_->elf_.reset(elf_container_.release()); + map_info_->elf().reset(elf_container_.release()); elf_->FakeSetLoadBias(0); EXPECT_EQ(0U, map_info_->GetLoadBias(process_memory_)); @@ -122,7 +122,7 @@ void MapInfoGetLoadBiasTest::MultipleThreadTest(uint64_t expected_load_bias) { } TEST_F(MapInfoGetLoadBiasTest, multiple_thread_elf_exists) { - map_info_->elf_.reset(elf_container_.release()); + map_info_->elf().reset(elf_container_.release()); elf_->FakeSetLoadBias(0x1000); MultipleThreadTest(0x1000); @@ -148,13 +148,13 @@ static void InitElfData(MemoryFake* memory, uint64_t offset) { } TEST_F(MapInfoGetLoadBiasTest, elf_exists_in_memory) { - InitElfData(memory_, map_info_->start_); + InitElfData(memory_, map_info_->start()); EXPECT_EQ(0xe000U, map_info_->GetLoadBias(process_memory_)); } TEST_F(MapInfoGetLoadBiasTest, elf_exists_in_memory_cached) { - InitElfData(memory_, map_info_->start_); + InitElfData(memory_, map_info_->start()); EXPECT_EQ(0xe000U, map_info_->GetLoadBias(process_memory_)); @@ -163,7 +163,7 @@ TEST_F(MapInfoGetLoadBiasTest, elf_exists_in_memory_cached) { } TEST_F(MapInfoGetLoadBiasTest, multiple_thread_elf_exists_in_memory) { - InitElfData(memory_, map_info_->start_); + InitElfData(memory_, map_info_->start()); MultipleThreadTest(0xe000); } diff --git a/libunwindstack/tests/MapInfoTest.cpp b/libunwindstack/tests/MapInfoTest.cpp index 6ec28d8..b4c1010 100644 --- a/libunwindstack/tests/MapInfoTest.cpp +++ b/libunwindstack/tests/MapInfoTest.cpp @@ -29,15 +29,15 @@ TEST(MapInfoTest, maps_constructor_const_char) { MapInfo prev_map(nullptr, nullptr, 0, 0, 0, 0, ""); MapInfo map_info(&prev_map, &prev_map, 1, 2, 3, 4, "map"); - EXPECT_EQ(&prev_map, map_info.prev_map_); - EXPECT_EQ(1UL, map_info.start_); - EXPECT_EQ(2UL, map_info.end_); - EXPECT_EQ(3UL, map_info.offset_); - EXPECT_EQ(4UL, map_info.flags_); - EXPECT_EQ("map", map_info.name_); - EXPECT_EQ(INT64_MAX, map_info.load_bias_); - EXPECT_EQ(0UL, map_info.elf_offset_); - EXPECT_TRUE(map_info.elf_.get() == nullptr); + EXPECT_EQ(&prev_map, map_info.prev_map()); + EXPECT_EQ(1UL, map_info.start()); + EXPECT_EQ(2UL, map_info.end()); + EXPECT_EQ(3UL, map_info.offset()); + EXPECT_EQ(4UL, map_info.flags()); + EXPECT_EQ("map", map_info.name()); + EXPECT_EQ(INT64_MAX, map_info.load_bias()); + EXPECT_EQ(0UL, map_info.elf_offset()); + EXPECT_TRUE(map_info.elf().get() == nullptr); } TEST(MapInfoTest, maps_constructor_string) { @@ -45,15 +45,15 @@ TEST(MapInfoTest, maps_constructor_string) { MapInfo prev_map(nullptr, nullptr, 0, 0, 0, 0, ""); MapInfo map_info(&prev_map, &prev_map, 1, 2, 3, 4, name); - EXPECT_EQ(&prev_map, map_info.prev_map_); - EXPECT_EQ(1UL, map_info.start_); - EXPECT_EQ(2UL, map_info.end_); - EXPECT_EQ(3UL, map_info.offset_); - EXPECT_EQ(4UL, map_info.flags_); - EXPECT_EQ("string_map", map_info.name_); - EXPECT_EQ(INT64_MAX, map_info.load_bias_); - EXPECT_EQ(0UL, map_info.elf_offset_); - EXPECT_TRUE(map_info.elf_.get() == nullptr); + EXPECT_EQ(&prev_map, map_info.prev_map()); + EXPECT_EQ(1UL, map_info.start()); + EXPECT_EQ(2UL, map_info.end()); + EXPECT_EQ(3UL, map_info.offset()); + EXPECT_EQ(4UL, map_info.flags()); + EXPECT_EQ("string_map", map_info.name()); + EXPECT_EQ(INT64_MAX, map_info.load_bias()); + EXPECT_EQ(0UL, map_info.elf_offset()); + EXPECT_TRUE(map_info.elf().get() == nullptr); } TEST(MapInfoTest, get_function_name) { @@ -63,7 +63,7 @@ TEST(MapInfoTest, get_function_name) { interface->FakePushFunctionData(FunctionData("function", 1000)); MapInfo map_info(nullptr, nullptr, 1, 2, 3, 4, ""); - map_info.elf_.reset(elf); + map_info.elf().reset(elf); SharedString name; uint64_t offset; diff --git a/libunwindstack/tests/MapsTest.cpp b/libunwindstack/tests/MapsTest.cpp index af26c6d..1448149 100644 --- a/libunwindstack/tests/MapsTest.cpp +++ b/libunwindstack/tests/MapsTest.cpp @@ -34,12 +34,12 @@ static void VerifyLine(std::string line, MapInfo* info) { ASSERT_TRUE(maps.Parse()) << "Failed on: " + line; MapInfo* element = maps.Get(0); ASSERT_TRUE(element != nullptr) << "Failed on: " + line; - info->start_ = element->start_; - info->end_ = element->end_; - info->offset_ = element->offset_; - info->flags_ = element->flags_; - info->name_ = element->name_; - info->elf_offset_ = element->elf_offset_; + info->start_ = element->start(); + info->end_ = element->end(); + info->offset_ = element->offset(); + info->flags_ = element->flags(); + info->name_ = element->name(); + info->elf_offset_ = element->elf_offset(); } } @@ -52,13 +52,13 @@ TEST(MapsTest, map_add) { ASSERT_EQ(3U, maps.Total()); MapInfo* info = maps.Get(0); - ASSERT_EQ(0x1000U, info->start_); - ASSERT_EQ(0x2000U, info->end_); - ASSERT_EQ(0U, info->offset_); - ASSERT_EQ(PROT_READ, info->flags_); - ASSERT_EQ("fake_map", info->name_); - ASSERT_EQ(0U, info->elf_offset_); - ASSERT_EQ(0U, info->load_bias_.load()); + ASSERT_EQ(0x1000U, info->start()); + ASSERT_EQ(0x2000U, info->end()); + ASSERT_EQ(0U, info->offset()); + ASSERT_EQ(PROT_READ, info->flags()); + ASSERT_EQ("fake_map", info->name()); + ASSERT_EQ(0U, info->elf_offset()); + ASSERT_EQ(0U, info->load_bias().load()); } TEST(MapsTest, map_move) { @@ -72,38 +72,38 @@ TEST(MapsTest, map_move) { ASSERT_EQ(3U, maps2.Total()); MapInfo* info = maps2.Get(0); - ASSERT_EQ(0x1000U, info->start_); - ASSERT_EQ(0x2000U, info->end_); - ASSERT_EQ(0U, info->offset_); - ASSERT_EQ(PROT_READ, info->flags_); - ASSERT_EQ("fake_map", info->name_); - ASSERT_EQ(0U, info->elf_offset_); - ASSERT_EQ(0U, info->load_bias_.load()); + ASSERT_EQ(0x1000U, info->start()); + ASSERT_EQ(0x2000U, info->end()); + ASSERT_EQ(0U, info->offset()); + ASSERT_EQ(PROT_READ, info->flags()); + ASSERT_EQ("fake_map", info->name()); + ASSERT_EQ(0U, info->elf_offset()); + ASSERT_EQ(0U, info->load_bias().load()); } TEST(MapsTest, verify_parse_line) { MapInfo info(nullptr, nullptr, 0, 0, 0, 0, ""); VerifyLine("01-02 rwxp 03 04:05 06\n", &info); - EXPECT_EQ(1U, info.start_); - EXPECT_EQ(2U, info.end_); - EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info.flags_); - EXPECT_EQ(3U, info.offset_); - EXPECT_EQ("", info.name_); + EXPECT_EQ(1U, info.start()); + EXPECT_EQ(2U, info.end()); + EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info.flags()); + EXPECT_EQ(3U, info.offset()); + EXPECT_EQ("", info.name()); VerifyLine("0a-0b ---s 0c 0d:0e 06 /fake/name\n", &info); - EXPECT_EQ(0xaU, info.start_); - EXPECT_EQ(0xbU, info.end_); - EXPECT_EQ(0U, info.flags_); - EXPECT_EQ(0xcU, info.offset_); - EXPECT_EQ("/fake/name", info.name_); + EXPECT_EQ(0xaU, info.start()); + EXPECT_EQ(0xbU, info.end()); + EXPECT_EQ(0U, info.flags()); + EXPECT_EQ(0xcU, info.offset()); + EXPECT_EQ("/fake/name", info.name()); VerifyLine("01-02 rwxp 03 04:05 06 /fake/name/again\n", &info); - EXPECT_EQ(1U, info.start_); - EXPECT_EQ(2U, info.end_); - EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info.flags_); - EXPECT_EQ(3U, info.offset_); - EXPECT_EQ("/fake/name/again", info.name_); + EXPECT_EQ(1U, info.start()); + EXPECT_EQ(2U, info.end()); + EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info.flags()); + EXPECT_EQ(3U, info.offset()); + EXPECT_EQ("/fake/name/again", info.name()); VerifyLine("-00 rwxp 00 00:00 0\n", nullptr); VerifyLine("00- rwxp 00 00:00 0\n", nullptr); @@ -158,10 +158,10 @@ TEST(MapsTest, verify_large_values) { MapInfo info(nullptr, nullptr, 0, 0, 0, 0, ""); #if defined(__LP64__) VerifyLine("fabcdef012345678-f12345678abcdef8 rwxp f0b0d0f010305070 00:00 0\n", &info); - EXPECT_EQ(0xfabcdef012345678UL, info.start_); - EXPECT_EQ(0xf12345678abcdef8UL, info.end_); - EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info.flags_); - EXPECT_EQ(0xf0b0d0f010305070UL, info.offset_); + EXPECT_EQ(0xfabcdef012345678UL, info.start()); + EXPECT_EQ(0xf12345678abcdef8UL, info.end()); + EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info.flags()); + EXPECT_EQ(0xf0b0d0f010305070UL, info.offset()); #else VerifyLine("f2345678-fabcdef8 rwxp f0305070 00:00 0\n", &info); EXPECT_EQ(0xf2345678UL, info.start_); @@ -184,43 +184,43 @@ TEST(MapsTest, parse_permissions) { MapInfo* info = maps.Get(0); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(PROT_NONE, info->flags_); - EXPECT_EQ(0x1000U, info->start_); - EXPECT_EQ(0x2000U, info->end_); - EXPECT_EQ(0U, info->offset_); - EXPECT_EQ("", info->name_); + EXPECT_EQ(PROT_NONE, info->flags()); + EXPECT_EQ(0x1000U, info->start()); + EXPECT_EQ(0x2000U, info->end()); + EXPECT_EQ(0U, info->offset()); + EXPECT_EQ("", info->name()); info = maps.Get(1); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(PROT_READ, info->flags_); - EXPECT_EQ(0x2000U, info->start_); - EXPECT_EQ(0x3000U, info->end_); - EXPECT_EQ(0U, info->offset_); - EXPECT_EQ("", info->name_); + EXPECT_EQ(PROT_READ, info->flags()); + EXPECT_EQ(0x2000U, info->start()); + EXPECT_EQ(0x3000U, info->end()); + EXPECT_EQ(0U, info->offset()); + EXPECT_EQ("", info->name()); info = maps.Get(2); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(PROT_WRITE, info->flags_); - EXPECT_EQ(0x3000U, info->start_); - EXPECT_EQ(0x4000U, info->end_); - EXPECT_EQ(0U, info->offset_); - EXPECT_EQ("", info->name_); + EXPECT_EQ(PROT_WRITE, info->flags()); + EXPECT_EQ(0x3000U, info->start()); + EXPECT_EQ(0x4000U, info->end()); + EXPECT_EQ(0U, info->offset()); + EXPECT_EQ("", info->name()); info = maps.Get(3); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(PROT_EXEC, info->flags_); - EXPECT_EQ(0x4000U, info->start_); - EXPECT_EQ(0x5000U, info->end_); - EXPECT_EQ(0U, info->offset_); - EXPECT_EQ("", info->name_); + EXPECT_EQ(PROT_EXEC, info->flags()); + EXPECT_EQ(0x4000U, info->start()); + EXPECT_EQ(0x5000U, info->end()); + EXPECT_EQ(0U, info->offset()); + EXPECT_EQ("", info->name()); info = maps.Get(4); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info->flags_); - EXPECT_EQ(0x5000U, info->start_); - EXPECT_EQ(0x6000U, info->end_); - EXPECT_EQ(0U, info->offset_); - EXPECT_EQ("", info->name_); + EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info->flags()); + EXPECT_EQ(0x5000U, info->start()); + EXPECT_EQ(0x6000U, info->end()); + EXPECT_EQ(0U, info->offset()); + EXPECT_EQ("", info->name()); ASSERT_TRUE(maps.Get(5) == nullptr); } @@ -236,27 +236,27 @@ TEST(MapsTest, parse_name) { MapInfo* info = maps.Get(0); ASSERT_TRUE(info != nullptr); - EXPECT_EQ("", info->name_); - EXPECT_EQ(0x7b29b000U, info->start_); - EXPECT_EQ(0x7b29e000U, info->end_); - EXPECT_EQ(0U, info->offset_); - EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags_); + EXPECT_EQ("", info->name()); + EXPECT_EQ(0x7b29b000U, info->start()); + EXPECT_EQ(0x7b29e000U, info->end()); + EXPECT_EQ(0U, info->offset()); + EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags()); info = maps.Get(1); ASSERT_TRUE(info != nullptr); - EXPECT_EQ("/system/lib/fake.so", info->name_); - EXPECT_EQ(0x7b29e000U, info->start_); - EXPECT_EQ(0x7b29f000U, info->end_); - EXPECT_EQ(0U, info->offset_); - EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags_); + EXPECT_EQ("/system/lib/fake.so", info->name()); + EXPECT_EQ(0x7b29e000U, info->start()); + EXPECT_EQ(0x7b29f000U, info->end()); + EXPECT_EQ(0U, info->offset()); + EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags()); info = maps.Get(2); ASSERT_TRUE(info != nullptr); - EXPECT_EQ("", info->name_); - EXPECT_EQ(0x7b29f000U, info->start_); - EXPECT_EQ(0x7b2a0000U, info->end_); - EXPECT_EQ(0U, info->offset_); - EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags_); + EXPECT_EQ("", info->name()); + EXPECT_EQ(0x7b29f000U, info->start()); + EXPECT_EQ(0x7b2a0000U, info->end()); + EXPECT_EQ(0U, info->offset()); + EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags()); ASSERT_TRUE(maps.Get(3) == nullptr); } @@ -271,19 +271,19 @@ TEST(MapsTest, parse_offset) { MapInfo* info = maps.Get(0); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0U, info->offset_); - EXPECT_EQ(0xa000U, info->start_); - EXPECT_EQ(0xe000U, info->end_); - EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags_); - EXPECT_EQ("/system/lib/fake.so", info->name_); + EXPECT_EQ(0U, info->offset()); + EXPECT_EQ(0xa000U, info->start()); + EXPECT_EQ(0xe000U, info->end()); + EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags()); + EXPECT_EQ("/system/lib/fake.so", info->name()); info = maps.Get(1); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0xa12345U, info->offset_); - EXPECT_EQ(0xe000U, info->start_); - EXPECT_EQ(0xf000U, info->end_); - EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags_); - EXPECT_EQ("/system/lib/fake.so", info->name_); + EXPECT_EQ(0xa12345U, info->offset()); + EXPECT_EQ(0xe000U, info->start()); + EXPECT_EQ(0xf000U, info->end()); + EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags()); + EXPECT_EQ("/system/lib/fake.so", info->name()); ASSERT_TRUE(maps.Get(2) == nullptr); } @@ -297,11 +297,11 @@ TEST(MapsTest, iterate) { ASSERT_EQ(2U, maps.Total()); Maps::iterator it = maps.begin(); - EXPECT_EQ(0xa000U, (*it)->start_); - EXPECT_EQ(0xe000U, (*it)->end_); + EXPECT_EQ(0xa000U, (*it)->start()); + EXPECT_EQ(0xe000U, (*it)->end()); ++it; - EXPECT_EQ(0xe000U, (*it)->start_); - EXPECT_EQ(0xf000U, (*it)->end_); + EXPECT_EQ(0xe000U, (*it)->start()); + EXPECT_EQ(0xf000U, (*it)->end()); ++it; EXPECT_EQ(maps.end(), it); } @@ -315,10 +315,10 @@ TEST(MapsTest, const_iterate) { ASSERT_EQ(2U, maps.Total()); Maps::const_iterator it = maps.begin(); - EXPECT_EQ(0xa000U, (*it)->start_); + EXPECT_EQ(0xa000U, (*it)->start()); EXPECT_EQ(0xe000U, (*it)->end_); ++it; - EXPECT_EQ(0xe000U, (*it)->start_); + EXPECT_EQ(0xe000U, (*it)->start()); EXPECT_EQ(0xf000U, (*it)->end_); ++it; EXPECT_EQ(maps.end(), it); @@ -337,19 +337,19 @@ TEST(MapsTest, device) { MapInfo* info = maps.Get(0); ASSERT_TRUE(info != nullptr); EXPECT_TRUE(info->flags_ & 0x8000); - EXPECT_EQ("/dev/", info->name_); + EXPECT_EQ("/dev/", info->name()); info = maps.Get(1); EXPECT_TRUE(info->flags_ & 0x8000); - EXPECT_EQ("/dev/does_not_exist", info->name_); + EXPECT_EQ("/dev/does_not_exist", info->name()); info = maps.Get(2); EXPECT_FALSE(info->flags_ & 0x8000); - EXPECT_EQ("/dev/ashmem/does_not_exist", info->name_); + EXPECT_EQ("/dev/ashmem/does_not_exist", info->name()); info = maps.Get(3); EXPECT_FALSE(info->flags_ & 0x8000); - EXPECT_EQ("/devsomething/does_not_exist", info->name_); + EXPECT_EQ("/devsomething/does_not_exist", info->name()); } TEST(MapsTest, file_smoke) { @@ -369,27 +369,27 @@ TEST(MapsTest, file_smoke) { MapInfo* info = maps.Get(0); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0x7b29b000U, info->start_); - EXPECT_EQ(0x7b29e000U, info->end_); - EXPECT_EQ(0xa0000000U, info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags_); - EXPECT_EQ("/fake.so", info->name_); + EXPECT_EQ(0x7b29b000U, info->start()); + EXPECT_EQ(0x7b29e000U, info->end()); + EXPECT_EQ(0xa0000000U, info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags()); + EXPECT_EQ("/fake.so", info->name()); info = maps.Get(1); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0x7b2b0000U, info->start_); - EXPECT_EQ(0x7b2e0000U, info->end_); - EXPECT_EQ(0xb0000000U, info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags_); - EXPECT_EQ("/fake2.so", info->name_); + EXPECT_EQ(0x7b2b0000U, info->start()); + EXPECT_EQ(0x7b2e0000U, info->end()); + EXPECT_EQ(0xb0000000U, info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags()); + EXPECT_EQ("/fake2.so", info->name()); info = maps.Get(2); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0x7b2e0000U, info->start_); - EXPECT_EQ(0x7b2f0000U, info->end_); - EXPECT_EQ(0xc0000000U, info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags_); - EXPECT_EQ("/fake3.so", info->name_); + EXPECT_EQ(0x7b2e0000U, info->start()); + EXPECT_EQ(0x7b2f0000U, info->end()); + EXPECT_EQ(0xc0000000U, info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags()); + EXPECT_EQ("/fake3.so", info->name()); ASSERT_TRUE(maps.Get(3) == nullptr); } @@ -411,27 +411,27 @@ TEST(MapsTest, file_no_map_name) { MapInfo* info = maps.Get(0); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0x7b29b000U, info->start_); - EXPECT_EQ(0x7b29e000U, info->end_); - EXPECT_EQ(0xa0000000U, info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags_); - EXPECT_EQ("", info->name_); + EXPECT_EQ(0x7b29b000U, info->start()); + EXPECT_EQ(0x7b29e000U, info->end()); + EXPECT_EQ(0xa0000000U, info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags()); + EXPECT_EQ("", info->name()); info = maps.Get(1); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0x7b2b0000U, info->start_); - EXPECT_EQ(0x7b2e0000U, info->end_); - EXPECT_EQ(0xb0000000U, info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags_); - EXPECT_EQ("/fake2.so", info->name_); + EXPECT_EQ(0x7b2b0000U, info->start()); + EXPECT_EQ(0x7b2e0000U, info->end()); + EXPECT_EQ(0xb0000000U, info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags()); + EXPECT_EQ("/fake2.so", info->name()); info = maps.Get(2); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0x7b2e0000U, info->start_); - EXPECT_EQ(0x7b2f0000U, info->end_); - EXPECT_EQ(0xc0000000U, info->offset_); - EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags_); - EXPECT_EQ("", info->name_); + EXPECT_EQ(0x7b2e0000U, info->start()); + EXPECT_EQ(0x7b2f0000U, info->end()); + EXPECT_EQ(0xc0000000U, info->offset()); + EXPECT_EQ(PROT_READ | PROT_EXEC, info->flags()); + EXPECT_EQ("", info->name()); ASSERT_TRUE(maps.Get(3) == nullptr); } @@ -503,17 +503,17 @@ TEST(MapsTest, file_buffer_cross) { for (size_t i = 0; i < index; i++) { MapInfo* info = maps.Get(i); ASSERT_TRUE(info != nullptr) << "Failed verifying index " + std::to_string(i); - EXPECT_EQ(i * 4096, info->start_) << "Failed verifying index " + std::to_string(i); - EXPECT_EQ((i + 1) * 4096, info->end_) << "Failed verifying index " + std::to_string(i); - EXPECT_EQ(0U, info->offset_) << "Failed verifying index " + std::to_string(i); + EXPECT_EQ(i * 4096, info->start()) << "Failed verifying index " + std::to_string(i); + EXPECT_EQ((i + 1) * 4096, info->end()) << "Failed verifying index " + std::to_string(i); + EXPECT_EQ(0U, info->offset()) << "Failed verifying index " + std::to_string(i); if (overlap1_index != 0 && i == overlap1_index) { - EXPECT_EQ(overlap1_name, info->name_) + EXPECT_EQ(overlap1_name, info->name()) << "Failed verifying overlap1 name " + std::to_string(i); } else if (overlap2_index != 0 && i == overlap2_index) { - EXPECT_EQ(overlap2_name, info->name_) + EXPECT_EQ(overlap2_name, info->name()) << "Failed verifying overlap2 name " + std::to_string(i); } else { - EXPECT_EQ("", info->name_) << "Failed verifying index " + std::to_string(i); + EXPECT_EQ("", info->name()) << "Failed verifying index " + std::to_string(i); } } } @@ -552,10 +552,10 @@ TEST(MapsTest, large_file) { ASSERT_EQ(5000U, maps.Total()); for (size_t i = 0; i < 5000; i++) { MapInfo* info = maps.Get(i); - EXPECT_EQ(start + i * 4096, info->start_) << "Failed at map " + std::to_string(i); - EXPECT_EQ(start + (i + 1) * 4096, info->end_) << "Failed at map " + std::to_string(i); + EXPECT_EQ(start + i * 4096, info->start()) << "Failed at map " + std::to_string(i); + EXPECT_EQ(start + (i + 1) * 4096, info->end()) << "Failed at map " + std::to_string(i); std::string name = "/fake" + std::to_string(i) + ".so"; - EXPECT_EQ(name, info->name_) << "Failed at map " + std::to_string(i); + EXPECT_EQ(name, info->name()) << "Failed at map " + std::to_string(i); } } @@ -578,43 +578,43 @@ TEST(MapsTest, find) { MapInfo* info = maps.Find(0x1000); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0x1000U, info->start_); - EXPECT_EQ(0x2000U, info->end_); - EXPECT_EQ(0x10U, info->offset_); - EXPECT_EQ(PROT_READ, info->flags_); - EXPECT_EQ("/system/lib/fake1.so", info->name_); + EXPECT_EQ(0x1000U, info->start()); + EXPECT_EQ(0x2000U, info->end()); + EXPECT_EQ(0x10U, info->offset()); + EXPECT_EQ(PROT_READ, info->flags()); + EXPECT_EQ("/system/lib/fake1.so", info->name()); info = maps.Find(0x3020); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0x3000U, info->start_); - EXPECT_EQ(0x4000U, info->end_); - EXPECT_EQ(0x20U, info->offset_); - EXPECT_EQ(PROT_WRITE, info->flags_); - EXPECT_EQ("/system/lib/fake2.so", info->name_); + EXPECT_EQ(0x3000U, info->start()); + EXPECT_EQ(0x4000U, info->end()); + EXPECT_EQ(0x20U, info->offset()); + EXPECT_EQ(PROT_WRITE, info->flags()); + EXPECT_EQ("/system/lib/fake2.so", info->name()); info = maps.Find(0x6020); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0x6000U, info->start_); - EXPECT_EQ(0x8000U, info->end_); - EXPECT_EQ(0x30U, info->offset_); - EXPECT_EQ(PROT_EXEC, info->flags_); - EXPECT_EQ("/system/lib/fake3.so", info->name_); + EXPECT_EQ(0x6000U, info->start()); + EXPECT_EQ(0x8000U, info->end()); + EXPECT_EQ(0x30U, info->offset()); + EXPECT_EQ(PROT_EXEC, info->flags()); + EXPECT_EQ("/system/lib/fake3.so", info->name()); info = maps.Find(0xafff); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0xa000U, info->start_); - EXPECT_EQ(0xb000U, info->end_); - EXPECT_EQ(0x40U, info->offset_); - EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags_); - EXPECT_EQ("/system/lib/fake4.so", info->name_); + EXPECT_EQ(0xa000U, info->start()); + EXPECT_EQ(0xb000U, info->end()); + EXPECT_EQ(0x40U, info->offset()); + EXPECT_EQ(PROT_READ | PROT_WRITE, info->flags()); + EXPECT_EQ("/system/lib/fake4.so", info->name()); info = maps.Find(0xe500); ASSERT_TRUE(info != nullptr); - EXPECT_EQ(0xe000U, info->start_); - EXPECT_EQ(0xf000U, info->end_); - EXPECT_EQ(0x50U, info->offset_); - EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info->flags_); - EXPECT_EQ("/system/lib/fake5.so", info->name_); + EXPECT_EQ(0xe000U, info->start()); + EXPECT_EQ(0xf000U, info->end()); + EXPECT_EQ(0x50U, info->offset()); + EXPECT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info->flags()); + EXPECT_EQ("/system/lib/fake5.so", info->name()); } } // namespace unwindstack diff --git a/libunwindstack/tests/RegsTest.cpp b/libunwindstack/tests/RegsTest.cpp index 42b3882..1a9e153 100644 --- a/libunwindstack/tests/RegsTest.cpp +++ b/libunwindstack/tests/RegsTest.cpp @@ -171,7 +171,7 @@ TEST_F(RegsTest, rel_pc_arm) { TEST_F(RegsTest, elf_invalid) { MapInfo map_info(nullptr, nullptr, 0x1000, 0x2000, 0, 0, ""); Elf* invalid_elf = new Elf(nullptr); - map_info.elf_.reset(invalid_elf); + map_info.elf().reset(invalid_elf); EXPECT_EQ(0x500U, invalid_elf->GetRelPc(0x1500, &map_info)); EXPECT_EQ(2U, GetPcAdjustment(0x500U, invalid_elf, ARCH_ARM)); diff --git a/libunwindstack/tests/UnwinderTest.cpp b/libunwindstack/tests/UnwinderTest.cpp index aa3386c..ea429ab 100644 --- a/libunwindstack/tests/UnwinderTest.cpp +++ b/libunwindstack/tests/UnwinderTest.cpp @@ -52,7 +52,7 @@ class UnwinderTest : public ::testing::Test { maps_->Add(start, end, offset, flags, name, static_cast<uint64_t>(-1)); MapInfo* map_info = maps_->Find(start); if (elf != nullptr) { - map_info->elf_.reset(elf); + map_info->elf().reset(elf); } return map_info; } @@ -929,7 +929,7 @@ TEST_F(UnwinderTest, map_ignore_suffixes) { // Make sure the elf was not initialized. MapInfo* map_info = maps_->Find(0x53000); ASSERT_TRUE(map_info != nullptr); - EXPECT_TRUE(map_info->elf_ == nullptr); + EXPECT_TRUE(map_info->elf() == nullptr); auto* frame = &unwinder.frames()[0]; EXPECT_EQ(0U, frame->num); diff --git a/libunwindstack/tests/fuzz/UnwinderComponentCreator.cpp b/libunwindstack/tests/fuzz/UnwinderComponentCreator.cpp index 88d3168..51a9d8c 100644 --- a/libunwindstack/tests/fuzz/UnwinderComponentCreator.cpp +++ b/libunwindstack/tests/fuzz/UnwinderComponentCreator.cpp @@ -66,7 +66,7 @@ void ElfAddMapInfo(Maps* maps, uint64_t start, uint64_t end, uint64_t offset, ui maps->Add(start, end, offset, flags, name, static_cast<uint64_t>(-1)); if (elf != nullptr) { const auto& map_info = *--maps->end(); - map_info->elf_.reset(elf); + map_info->elf().reset(elf); } } diff --git a/libunwindstack/tools/unwind_for_offline.cpp b/libunwindstack/tools/unwind_for_offline.cpp index 689321b..49ab634 100644 --- a/libunwindstack/tools/unwind_for_offline.cpp +++ b/libunwindstack/tools/unwind_for_offline.cpp @@ -202,8 +202,8 @@ bool CopyElfFromFile(map_info_t* info, bool* file_copied) { map_info_t* FillInAndGetMapInfo(std::unordered_map<uint64_t, map_info_t>& maps_by_start, unwindstack::MapInfo* map_info) { - auto info = &maps_by_start[map_info->start_]; - info->start = map_info->start_; + auto info = &maps_by_start[map_info->start()]; + info->start = map_info->start(); info->end = map_info->end_; info->offset = map_info->offset_; info->name = map_info->name_; @@ -258,15 +258,15 @@ int SaveData(pid_t pid) { uint64_t sp_map_start = 0; unwindstack::MapInfo* map_info = maps->Find(sp); if (map_info != nullptr) { - stacks.emplace_back(std::make_pair(sp, map_info->end_)); - sp_map_start = map_info->start_; + stacks.emplace_back(std::make_pair(sp, map_info->end())); + sp_map_start = map_info->start(); } for (const auto& frame : unwinder.frames()) { map_info = maps->Find(frame.sp); - if (map_info != nullptr && sp_map_start != map_info->start_) { - stacks.emplace_back(std::make_pair(frame.sp, map_info->end_)); - sp_map_start = map_info->start_; + if (map_info != nullptr && sp_map_start != map_info->start()) { + stacks.emplace_back(std::make_pair(frame.sp, map_info->end())); + sp_map_start = map_info->start(); } if (maps_by_start.count(frame.map_start) == 0) { @@ -282,10 +282,10 @@ int SaveData(pid_t pid) { // If you are using a a linker that creates two maps (one read-only, one // read-executable), it's necessary to capture the previous map // information if needed. - unwindstack::MapInfo* prev_map = map_info->prev_map_; - if (prev_map != nullptr && map_info->offset_ != 0 && prev_map->offset_ == 0 && - prev_map->flags_ == PROT_READ && map_info->name_ == prev_map->name_ && - maps_by_start.count(prev_map->start_) == 0) { + unwindstack::MapInfo* prev_map = map_info->prev_map(); + if (prev_map != nullptr && map_info->offset() != 0 && prev_map->offset() == 0 && + prev_map->flags() == PROT_READ && map_info->name() == prev_map->name() && + maps_by_start.count(prev_map->start()) == 0) { info = FillInAndGetMapInfo(maps_by_start, prev_map); SaveMapInformation(unwinder.GetProcessMemory(), info, &file_copied); } |