1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "class_table.h"
18
19 #include "mirror/class-inl.h"
20 #include "oat_file.h"
21
22 namespace art {
23
ClassTable()24 ClassTable::ClassTable() : lock_("Class loader classes", kClassLoaderClassesLock) {
25 Runtime* const runtime = Runtime::Current();
26 classes_.push_back(ClassSet(runtime->GetHashTableMinLoadFactor(),
27 runtime->GetHashTableMaxLoadFactor()));
28 }
29
FreezeSnapshot()30 void ClassTable::FreezeSnapshot() {
31 WriterMutexLock mu(Thread::Current(), lock_);
32 classes_.push_back(ClassSet());
33 }
34
Contains(ObjPtr<mirror::Class> klass)35 bool ClassTable::Contains(ObjPtr<mirror::Class> klass) {
36 ReaderMutexLock mu(Thread::Current(), lock_);
37 TableSlot slot(klass);
38 for (ClassSet& class_set : classes_) {
39 auto it = class_set.Find(slot);
40 if (it != class_set.end()) {
41 return it->Read() == klass;
42 }
43 }
44 return false;
45 }
46
LookupByDescriptor(ObjPtr<mirror::Class> klass)47 mirror::Class* ClassTable::LookupByDescriptor(ObjPtr<mirror::Class> klass) {
48 ReaderMutexLock mu(Thread::Current(), lock_);
49 TableSlot slot(klass);
50 for (ClassSet& class_set : classes_) {
51 auto it = class_set.Find(slot);
52 if (it != class_set.end()) {
53 return it->Read();
54 }
55 }
56 return nullptr;
57 }
58
59 // To take into account http://b/35845221
60 #pragma clang diagnostic push
61 #if __clang_major__ < 4
62 #pragma clang diagnostic ignored "-Wunreachable-code"
63 #endif
64
UpdateClass(const char * descriptor,mirror::Class * klass,size_t hash)65 mirror::Class* ClassTable::UpdateClass(const char* descriptor, mirror::Class* klass, size_t hash) {
66 WriterMutexLock mu(Thread::Current(), lock_);
67 // Should only be updating latest table.
68 DescriptorHashPair pair(descriptor, hash);
69 auto existing_it = classes_.back().FindWithHash(pair, hash);
70 if (kIsDebugBuild && existing_it == classes_.back().end()) {
71 for (const ClassSet& class_set : classes_) {
72 if (class_set.FindWithHash(pair, hash) != class_set.end()) {
73 LOG(FATAL) << "Updating class found in frozen table " << descriptor;
74 }
75 }
76 LOG(FATAL) << "Updating class not found " << descriptor;
77 }
78 mirror::Class* const existing = existing_it->Read();
79 CHECK_NE(existing, klass) << descriptor;
80 CHECK(!existing->IsResolved()) << descriptor;
81 CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusResolving) << descriptor;
82 CHECK(!klass->IsTemp()) << descriptor;
83 VerifyObject(klass);
84 // Update the element in the hash set with the new class. This is safe to do since the descriptor
85 // doesn't change.
86 *existing_it = TableSlot(klass, hash);
87 return existing;
88 }
89
90 #pragma clang diagnostic pop
91
CountDefiningLoaderClasses(ObjPtr<mirror::ClassLoader> defining_loader,const ClassSet & set) const92 size_t ClassTable::CountDefiningLoaderClasses(ObjPtr<mirror::ClassLoader> defining_loader,
93 const ClassSet& set) const {
94 size_t count = 0;
95 for (const TableSlot& root : set) {
96 if (root.Read()->GetClassLoader() == defining_loader) {
97 ++count;
98 }
99 }
100 return count;
101 }
102
NumZygoteClasses(ObjPtr<mirror::ClassLoader> defining_loader) const103 size_t ClassTable::NumZygoteClasses(ObjPtr<mirror::ClassLoader> defining_loader) const {
104 ReaderMutexLock mu(Thread::Current(), lock_);
105 size_t sum = 0;
106 for (size_t i = 0; i < classes_.size() - 1; ++i) {
107 sum += CountDefiningLoaderClasses(defining_loader, classes_[i]);
108 }
109 return sum;
110 }
111
NumNonZygoteClasses(ObjPtr<mirror::ClassLoader> defining_loader) const112 size_t ClassTable::NumNonZygoteClasses(ObjPtr<mirror::ClassLoader> defining_loader) const {
113 ReaderMutexLock mu(Thread::Current(), lock_);
114 return CountDefiningLoaderClasses(defining_loader, classes_.back());
115 }
116
NumReferencedZygoteClasses() const117 size_t ClassTable::NumReferencedZygoteClasses() const {
118 ReaderMutexLock mu(Thread::Current(), lock_);
119 size_t sum = 0;
120 for (size_t i = 0; i < classes_.size() - 1; ++i) {
121 sum += classes_[i].Size();
122 }
123 return sum;
124 }
125
NumReferencedNonZygoteClasses() const126 size_t ClassTable::NumReferencedNonZygoteClasses() const {
127 ReaderMutexLock mu(Thread::Current(), lock_);
128 return classes_.back().Size();
129 }
130
Lookup(const char * descriptor,size_t hash)131 mirror::Class* ClassTable::Lookup(const char* descriptor, size_t hash) {
132 DescriptorHashPair pair(descriptor, hash);
133 ReaderMutexLock mu(Thread::Current(), lock_);
134 for (ClassSet& class_set : classes_) {
135 auto it = class_set.FindWithHash(pair, hash);
136 if (it != class_set.end()) {
137 return it->Read();
138 }
139 }
140 return nullptr;
141 }
142
TryInsert(ObjPtr<mirror::Class> klass)143 ObjPtr<mirror::Class> ClassTable::TryInsert(ObjPtr<mirror::Class> klass) {
144 TableSlot slot(klass);
145 WriterMutexLock mu(Thread::Current(), lock_);
146 for (ClassSet& class_set : classes_) {
147 auto it = class_set.Find(slot);
148 if (it != class_set.end()) {
149 return it->Read();
150 }
151 }
152 classes_.back().Insert(slot);
153 return klass;
154 }
155
Insert(ObjPtr<mirror::Class> klass)156 void ClassTable::Insert(ObjPtr<mirror::Class> klass) {
157 const uint32_t hash = TableSlot::HashDescriptor(klass);
158 WriterMutexLock mu(Thread::Current(), lock_);
159 classes_.back().InsertWithHash(TableSlot(klass, hash), hash);
160 }
161
CopyWithoutLocks(const ClassTable & source_table)162 void ClassTable::CopyWithoutLocks(const ClassTable& source_table) {
163 if (kIsDebugBuild) {
164 for (ClassSet& class_set : classes_) {
165 CHECK(class_set.Empty());
166 }
167 }
168 for (const ClassSet& class_set : source_table.classes_) {
169 for (const TableSlot& slot : class_set) {
170 classes_.back().Insert(slot);
171 }
172 }
173 }
174
InsertWithoutLocks(ObjPtr<mirror::Class> klass)175 void ClassTable::InsertWithoutLocks(ObjPtr<mirror::Class> klass) {
176 const uint32_t hash = TableSlot::HashDescriptor(klass);
177 classes_.back().InsertWithHash(TableSlot(klass, hash), hash);
178 }
179
InsertWithHash(ObjPtr<mirror::Class> klass,size_t hash)180 void ClassTable::InsertWithHash(ObjPtr<mirror::Class> klass, size_t hash) {
181 WriterMutexLock mu(Thread::Current(), lock_);
182 classes_.back().InsertWithHash(TableSlot(klass, hash), hash);
183 }
184
Remove(const char * descriptor)185 bool ClassTable::Remove(const char* descriptor) {
186 DescriptorHashPair pair(descriptor, ComputeModifiedUtf8Hash(descriptor));
187 WriterMutexLock mu(Thread::Current(), lock_);
188 for (ClassSet& class_set : classes_) {
189 auto it = class_set.Find(pair);
190 if (it != class_set.end()) {
191 class_set.Erase(it);
192 return true;
193 }
194 }
195 return false;
196 }
197
operator ()(const TableSlot & slot) const198 uint32_t ClassTable::ClassDescriptorHashEquals::operator()(const TableSlot& slot)
199 const {
200 std::string temp;
201 return ComputeModifiedUtf8Hash(slot.Read()->GetDescriptor(&temp));
202 }
203
operator ()(const TableSlot & a,const TableSlot & b) const204 bool ClassTable::ClassDescriptorHashEquals::operator()(const TableSlot& a,
205 const TableSlot& b) const {
206 if (a.Hash() != b.Hash()) {
207 std::string temp;
208 DCHECK(!a.Read()->DescriptorEquals(b.Read()->GetDescriptor(&temp)));
209 return false;
210 }
211 std::string temp;
212 return a.Read()->DescriptorEquals(b.Read()->GetDescriptor(&temp));
213 }
214
operator ()(const TableSlot & a,const DescriptorHashPair & b) const215 bool ClassTable::ClassDescriptorHashEquals::operator()(const TableSlot& a,
216 const DescriptorHashPair& b) const {
217 if (!a.MaskedHashEquals(b.second)) {
218 DCHECK(!a.Read()->DescriptorEquals(b.first));
219 return false;
220 }
221 return a.Read()->DescriptorEquals(b.first);
222 }
223
operator ()(const DescriptorHashPair & pair) const224 uint32_t ClassTable::ClassDescriptorHashEquals::operator()(const DescriptorHashPair& pair) const {
225 return ComputeModifiedUtf8Hash(pair.first);
226 }
227
InsertStrongRoot(ObjPtr<mirror::Object> obj)228 bool ClassTable::InsertStrongRoot(ObjPtr<mirror::Object> obj) {
229 WriterMutexLock mu(Thread::Current(), lock_);
230 DCHECK(obj != nullptr);
231 for (GcRoot<mirror::Object>& root : strong_roots_) {
232 if (root.Read() == obj) {
233 return false;
234 }
235 }
236 strong_roots_.push_back(GcRoot<mirror::Object>(obj));
237 // If `obj` is a dex cache associated with a new oat file with GC roots, add it to oat_files_.
238 if (obj->IsDexCache()) {
239 const DexFile* dex_file = ObjPtr<mirror::DexCache>::DownCast(obj)->GetDexFile();
240 if (dex_file != nullptr && dex_file->GetOatDexFile() != nullptr) {
241 const OatFile* oat_file = dex_file->GetOatDexFile()->GetOatFile();
242 if (oat_file != nullptr && !oat_file->GetBssGcRoots().empty()) {
243 InsertOatFileLocked(oat_file); // Ignore return value.
244 }
245 }
246 }
247 return true;
248 }
249
InsertOatFile(const OatFile * oat_file)250 bool ClassTable::InsertOatFile(const OatFile* oat_file) {
251 WriterMutexLock mu(Thread::Current(), lock_);
252 return InsertOatFileLocked(oat_file);
253 }
254
InsertOatFileLocked(const OatFile * oat_file)255 bool ClassTable::InsertOatFileLocked(const OatFile* oat_file) {
256 if (ContainsElement(oat_files_, oat_file)) {
257 return false;
258 }
259 oat_files_.push_back(oat_file);
260 return true;
261 }
262
WriteToMemory(uint8_t * ptr) const263 size_t ClassTable::WriteToMemory(uint8_t* ptr) const {
264 ReaderMutexLock mu(Thread::Current(), lock_);
265 ClassSet combined;
266 // Combine all the class sets in case there are multiple, also adjusts load factor back to
267 // default in case classes were pruned.
268 for (const ClassSet& class_set : classes_) {
269 for (const TableSlot& root : class_set) {
270 combined.Insert(root);
271 }
272 }
273 const size_t ret = combined.WriteToMemory(ptr);
274 // Sanity check.
275 if (kIsDebugBuild && ptr != nullptr) {
276 size_t read_count;
277 ClassSet class_set(ptr, /*make copy*/false, &read_count);
278 class_set.Verify();
279 }
280 return ret;
281 }
282
ReadFromMemory(uint8_t * ptr)283 size_t ClassTable::ReadFromMemory(uint8_t* ptr) {
284 size_t read_count = 0;
285 AddClassSet(ClassSet(ptr, /*make copy*/false, &read_count));
286 return read_count;
287 }
288
AddClassSet(ClassSet && set)289 void ClassTable::AddClassSet(ClassSet&& set) {
290 WriterMutexLock mu(Thread::Current(), lock_);
291 classes_.insert(classes_.begin(), std::move(set));
292 }
293
ClearStrongRoots()294 void ClassTable::ClearStrongRoots() {
295 WriterMutexLock mu(Thread::Current(), lock_);
296 oat_files_.clear();
297 strong_roots_.clear();
298 }
299
TableSlot(ObjPtr<mirror::Class> klass)300 ClassTable::TableSlot::TableSlot(ObjPtr<mirror::Class> klass)
301 : TableSlot(klass, HashDescriptor(klass)) {}
302
HashDescriptor(ObjPtr<mirror::Class> klass)303 uint32_t ClassTable::TableSlot::HashDescriptor(ObjPtr<mirror::Class> klass) {
304 std::string temp;
305 return ComputeModifiedUtf8Hash(klass->GetDescriptor(&temp));
306 }
307
308 } // namespace art
309