1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/profiler/module_cache.h"
#include <algorithm>
#include <iterator>
#include <utility>
namespace base {
namespace {
// Supports heterogeneous comparisons on modules and addresses, for use in
// binary searching modules sorted by range for a contained address.
struct ModuleAddressCompare {
bool operator()(const std::unique_ptr<const ModuleCache::Module>& module,
uintptr_t address) const {
return module->GetBaseAddress() + module->GetSize() <= address;
}
bool operator()(
uintptr_t address,
const std::unique_ptr<const ModuleCache::Module>& module) const {
return address < module->GetBaseAddress();
}
};
} // namespace
ModuleCache::ModuleCache() = default;
ModuleCache::~ModuleCache() = default;
const ModuleCache::Module* ModuleCache::GetModuleForAddress(uintptr_t address) {
const auto non_native_module_loc = non_native_modules_.find(address);
if (non_native_module_loc != non_native_modules_.end())
return non_native_module_loc->get();
const auto native_module_loc = native_modules_.find(address);
if (native_module_loc != native_modules_.end())
return native_module_loc->get();
std::unique_ptr<const Module> new_module = CreateModuleForAddress(address);
if (!new_module)
return nullptr;
const auto loc = native_modules_.insert(std::move(new_module));
return loc.first->get();
}
std::vector<const ModuleCache::Module*> ModuleCache::GetModules() const {
std::vector<const Module*> result;
result.reserve(native_modules_.size());
for (const std::unique_ptr<const Module>& module : native_modules_)
result.push_back(module.get());
for (const std::unique_ptr<const Module>& module : non_native_modules_)
result.push_back(module.get());
return result;
}
void ModuleCache::UpdateNonNativeModules(
const std::vector<const Module*>& to_remove,
std::vector<std::unique_ptr<const Module>> to_add) {
// Insert the modules to remove into a set to support O(log(n)) lookup below.
flat_set<const Module*> to_remove_set(to_remove.begin(), to_remove.end());
// Reorder the modules to be removed to the last slots in the set, then move
// them to the inactive modules, then erase the moved-from modules from the
// set. The flat_set docs endorse using base::EraseIf() which performs the
// same operations -- exclusive of the moves -- so this is OK even though it
// might seem like we're messing with the internal set representation.
//
// remove_if is O(m*log(r)) where m is the number of current modules and r is
// the number of modules to remove. insert and erase are both O(r).
auto first_module_to_remove = std::remove_if(
non_native_modules_.begin(), non_native_modules_.end(),
[&to_remove_set](const std::unique_ptr<const Module>& module) {
return to_remove_set.find(module.get()) != to_remove_set.end();
});
// All modules requested to be removed should have been found.
DCHECK_EQ(static_cast<ptrdiff_t>(to_remove.size()),
std::distance(first_module_to_remove, non_native_modules_.end()));
inactive_non_native_modules_.insert(
inactive_non_native_modules_.end(),
std::make_move_iterator(first_module_to_remove),
std::make_move_iterator(non_native_modules_.end()));
non_native_modules_.erase(first_module_to_remove, non_native_modules_.end());
// Insert the modules to be added. This operation is O((m + a) + a*log(a))
// where m is the number of current modules and a is the number of modules to
// be added.
non_native_modules_.insert(std::make_move_iterator(to_add.begin()),
std::make_move_iterator(to_add.end()));
}
void ModuleCache::AddCustomNativeModule(std::unique_ptr<const Module> module) {
native_modules_.insert(std::move(module));
}
bool ModuleCache::ModuleAndAddressCompare::operator()(
const std::unique_ptr<const Module>& m1,
const std::unique_ptr<const Module>& m2) const {
return m1->GetBaseAddress() < m2->GetBaseAddress();
}
bool ModuleCache::ModuleAndAddressCompare::operator()(
const std::unique_ptr<const Module>& m1,
uintptr_t address) const {
return m1->GetBaseAddress() + m1->GetSize() <= address;
}
bool ModuleCache::ModuleAndAddressCompare::operator()(
uintptr_t address,
const std::unique_ptr<const Module>& m2) const {
return address < m2->GetBaseAddress();
}
} // namespace base
|
