Elliott Hughes | 2faa5f1 | 2012-01-30 14:42:07 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 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 | */ |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 16 | |
| 17 | #include "intern_table.h" |
| 18 | |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 19 | #include <memory> |
| 20 | |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 21 | #include "gc/space/image_space.h" |
| 22 | #include "mirror/dex_cache.h" |
| 23 | #include "mirror/object_array-inl.h" |
| 24 | #include "mirror/object-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 25 | #include "mirror/string.h" |
| 26 | #include "thread.h" |
Elliott Hughes | 814e403 | 2011-08-23 12:07:56 -0700 | [diff] [blame] | 27 | #include "utf.h" |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 28 | |
| 29 | namespace art { |
| 30 | |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 31 | InternTable::InternTable() |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 32 | : log_new_roots_(false), allow_new_interns_(true), |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 33 | new_intern_condition_("New intern condition", *Locks::intern_table_lock_) { |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 34 | } |
Elliott Hughes | de69d7f | 2011-08-18 16:49:37 -0700 | [diff] [blame] | 35 | |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 36 | size_t InternTable::Size() const { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 37 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 38 | return strong_interns_.size() + weak_interns_.size(); |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 39 | } |
| 40 | |
Hiroshi Yamauchi | a91a4bc | 2014-06-13 16:44:55 -0700 | [diff] [blame] | 41 | size_t InternTable::StrongSize() const { |
| 42 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
| 43 | return strong_interns_.size(); |
| 44 | } |
| 45 | |
| 46 | size_t InternTable::WeakSize() const { |
| 47 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
| 48 | return weak_interns_.size(); |
| 49 | } |
| 50 | |
Elliott Hughes | cac6cc7 | 2011-11-03 20:31:21 -0700 | [diff] [blame] | 51 | void InternTable::DumpForSigQuit(std::ostream& os) const { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 52 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Elliott Hughes | cac6cc7 | 2011-11-03 20:31:21 -0700 | [diff] [blame] | 53 | os << "Intern table: " << strong_interns_.size() << " strong; " |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 54 | << weak_interns_.size() << " weak\n"; |
Elliott Hughes | cac6cc7 | 2011-11-03 20:31:21 -0700 | [diff] [blame] | 55 | } |
| 56 | |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 57 | void InternTable::VisitRoots(RootCallback* callback, void* arg, VisitRootFlags flags) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 58 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 59 | if ((flags & kVisitRootFlagAllRoots) != 0) { |
Mathieu Chartier | b307052 | 2013-09-17 14:18:21 -0700 | [diff] [blame] | 60 | for (auto& strong_intern : strong_interns_) { |
Mathieu Chartier | 815873e | 2014-02-13 18:02:13 -0800 | [diff] [blame] | 61 | callback(reinterpret_cast<mirror::Object**>(&strong_intern.second), arg, 0, |
| 62 | kRootInternedString); |
Mathieu Chartier | b307052 | 2013-09-17 14:18:21 -0700 | [diff] [blame] | 63 | DCHECK(strong_intern.second != nullptr); |
Mathieu Chartier | c462198 | 2013-09-16 19:43:47 -0700 | [diff] [blame] | 64 | } |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 65 | } else if ((flags & kVisitRootFlagNewRoots) != 0) { |
| 66 | for (auto& pair : new_strong_intern_roots_) { |
| 67 | mirror::String* old_ref = pair.second; |
| 68 | callback(reinterpret_cast<mirror::Object**>(&pair.second), arg, 0, kRootInternedString); |
| 69 | if (UNLIKELY(pair.second != old_ref)) { |
| 70 | // Uh ohes, GC moved a root in the log. Need to search the strong interns and update the |
| 71 | // corresponding object. This is slow, but luckily for us, this may only happen with a |
| 72 | // concurrent moving GC. |
| 73 | for (auto it = strong_interns_.lower_bound(pair.first), end = strong_interns_.end(); |
| 74 | it != end && it->first == pair.first; ++it) { |
| 75 | // If the class stored matches the old class, update it to the new value. |
| 76 | if (old_ref == it->second) { |
| 77 | it->second = pair.second; |
| 78 | } |
| 79 | } |
| 80 | } |
| 81 | } |
| 82 | } |
| 83 | |
| 84 | if ((flags & kVisitRootFlagClearRootLog) != 0) { |
| 85 | new_strong_intern_roots_.clear(); |
| 86 | } |
| 87 | if ((flags & kVisitRootFlagStartLoggingNewRoots) != 0) { |
| 88 | log_new_roots_ = true; |
| 89 | } else if ((flags & kVisitRootFlagStopLoggingNewRoots) != 0) { |
| 90 | log_new_roots_ = false; |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 91 | } |
Mathieu Chartier | 423d2a3 | 2013-09-12 17:33:56 -0700 | [diff] [blame] | 92 | // Note: we deliberately don't visit the weak_interns_ table and the immutable image roots. |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 93 | } |
| 94 | |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 95 | mirror::String* InternTable::LookupStrong(mirror::String* s, int32_t hash_code) { |
Hiroshi Yamauchi | a91a4bc | 2014-06-13 16:44:55 -0700 | [diff] [blame] | 96 | return Lookup(&strong_interns_, s, hash_code); |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | mirror::String* InternTable::LookupWeak(mirror::String* s, int32_t hash_code) { |
| 100 | // Weak interns need a read barrier because they are weak roots. |
Hiroshi Yamauchi | a91a4bc | 2014-06-13 16:44:55 -0700 | [diff] [blame] | 101 | return Lookup(&weak_interns_, s, hash_code); |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 102 | } |
| 103 | |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 104 | mirror::String* InternTable::Lookup(Table* table, mirror::String* s, int32_t hash_code) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 105 | Locks::intern_table_lock_->AssertHeld(Thread::Current()); |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 106 | for (auto it = table->lower_bound(hash_code), end = table->end(); |
Vladimir Marko | 53dc70c | 2014-05-22 12:16:44 +0100 | [diff] [blame] | 107 | it != end && it->first == hash_code; ++it) { |
Hiroshi Yamauchi | a91a4bc | 2014-06-13 16:44:55 -0700 | [diff] [blame] | 108 | mirror::String* existing_string; |
| 109 | mirror::String** root = &it->second; |
| 110 | existing_string = ReadBarrier::BarrierForRoot<mirror::String, kWithReadBarrier>(root); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 111 | if (existing_string->Equals(s)) { |
| 112 | return existing_string; |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 113 | } |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 114 | } |
| 115 | return NULL; |
| 116 | } |
| 117 | |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 118 | mirror::String* InternTable::InsertStrong(mirror::String* s, int32_t hash_code) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 119 | Runtime* runtime = Runtime::Current(); |
| 120 | if (runtime->IsActiveTransaction()) { |
| 121 | runtime->RecordStrongStringInsertion(s, hash_code); |
| 122 | } |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 123 | if (log_new_roots_) { |
| 124 | new_strong_intern_roots_.push_back(std::make_pair(hash_code, s)); |
| 125 | } |
| 126 | strong_interns_.insert(std::make_pair(hash_code, s)); |
| 127 | return s; |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 128 | } |
| 129 | |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 130 | mirror::String* InternTable::InsertWeak(mirror::String* s, int32_t hash_code) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 131 | Runtime* runtime = Runtime::Current(); |
| 132 | if (runtime->IsActiveTransaction()) { |
| 133 | runtime->RecordWeakStringInsertion(s, hash_code); |
| 134 | } |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 135 | weak_interns_.insert(std::make_pair(hash_code, s)); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 136 | return s; |
| 137 | } |
| 138 | |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 139 | void InternTable::RemoveStrong(mirror::String* s, int32_t hash_code) { |
Hiroshi Yamauchi | a91a4bc | 2014-06-13 16:44:55 -0700 | [diff] [blame] | 140 | Remove(&strong_interns_, s, hash_code); |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 141 | } |
| 142 | |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 143 | void InternTable::RemoveWeak(mirror::String* s, int32_t hash_code) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 144 | Runtime* runtime = Runtime::Current(); |
| 145 | if (runtime->IsActiveTransaction()) { |
| 146 | runtime->RecordWeakStringRemoval(s, hash_code); |
| 147 | } |
Hiroshi Yamauchi | a91a4bc | 2014-06-13 16:44:55 -0700 | [diff] [blame] | 148 | Remove(&weak_interns_, s, hash_code); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 149 | } |
| 150 | |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 151 | void InternTable::Remove(Table* table, mirror::String* s, int32_t hash_code) { |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 152 | for (auto it = table->lower_bound(hash_code), end = table->end(); |
Vladimir Marko | 53dc70c | 2014-05-22 12:16:44 +0100 | [diff] [blame] | 153 | it != end && it->first == hash_code; ++it) { |
Hiroshi Yamauchi | a91a4bc | 2014-06-13 16:44:55 -0700 | [diff] [blame] | 154 | mirror::String* existing_string; |
| 155 | mirror::String** root = &it->second; |
| 156 | existing_string = ReadBarrier::BarrierForRoot<mirror::String, kWithReadBarrier>(root); |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 157 | if (existing_string == s) { |
| 158 | table->erase(it); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 159 | return; |
| 160 | } |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 161 | } |
| 162 | } |
| 163 | |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 164 | // Insert/remove methods used to undo changes made during an aborted transaction. |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 165 | mirror::String* InternTable::InsertStrongFromTransaction(mirror::String* s, int32_t hash_code) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 166 | DCHECK(!Runtime::Current()->IsActiveTransaction()); |
| 167 | return InsertStrong(s, hash_code); |
| 168 | } |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 169 | mirror::String* InternTable::InsertWeakFromTransaction(mirror::String* s, int32_t hash_code) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 170 | DCHECK(!Runtime::Current()->IsActiveTransaction()); |
| 171 | return InsertWeak(s, hash_code); |
| 172 | } |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 173 | void InternTable::RemoveStrongFromTransaction(mirror::String* s, int32_t hash_code) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 174 | DCHECK(!Runtime::Current()->IsActiveTransaction()); |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 175 | RemoveStrong(s, hash_code); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 176 | } |
Mathieu Chartier | 893263b | 2014-03-04 11:07:42 -0800 | [diff] [blame] | 177 | void InternTable::RemoveWeakFromTransaction(mirror::String* s, int32_t hash_code) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 178 | DCHECK(!Runtime::Current()->IsActiveTransaction()); |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 179 | RemoveWeak(s, hash_code); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 180 | } |
| 181 | |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 182 | static mirror::String* LookupStringFromImage(mirror::String* s) |
| 183 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
| 184 | gc::space::ImageSpace* image = Runtime::Current()->GetHeap()->GetImageSpace(); |
| 185 | if (image == NULL) { |
| 186 | return NULL; // No image present. |
| 187 | } |
| 188 | mirror::Object* root = image->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches); |
| 189 | mirror::ObjectArray<mirror::DexCache>* dex_caches = root->AsObjectArray<mirror::DexCache>(); |
| 190 | const std::string utf8 = s->ToModifiedUtf8(); |
| 191 | for (int32_t i = 0; i < dex_caches->GetLength(); ++i) { |
| 192 | mirror::DexCache* dex_cache = dex_caches->Get(i); |
| 193 | const DexFile* dex_file = dex_cache->GetDexFile(); |
| 194 | // Binary search the dex file for the string index. |
| 195 | const DexFile::StringId* string_id = dex_file->FindStringId(utf8.c_str()); |
| 196 | if (string_id != NULL) { |
| 197 | uint32_t string_idx = dex_file->GetIndexForStringId(*string_id); |
| 198 | mirror::String* image = dex_cache->GetResolvedString(string_idx); |
| 199 | if (image != NULL) { |
| 200 | return image; |
| 201 | } |
| 202 | } |
| 203 | } |
| 204 | return NULL; |
| 205 | } |
| 206 | |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 207 | void InternTable::AllowNewInterns() { |
| 208 | Thread* self = Thread::Current(); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 209 | MutexLock mu(self, *Locks::intern_table_lock_); |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 210 | allow_new_interns_ = true; |
| 211 | new_intern_condition_.Broadcast(self); |
| 212 | } |
| 213 | |
| 214 | void InternTable::DisallowNewInterns() { |
| 215 | Thread* self = Thread::Current(); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 216 | MutexLock mu(self, *Locks::intern_table_lock_); |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 217 | allow_new_interns_ = false; |
| 218 | } |
| 219 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 220 | mirror::String* InternTable::Insert(mirror::String* s, bool is_strong) { |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 221 | Thread* self = Thread::Current(); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 222 | MutexLock mu(self, *Locks::intern_table_lock_); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 223 | |
| 224 | DCHECK(s != NULL); |
| 225 | uint32_t hash_code = s->GetHashCode(); |
| 226 | |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 227 | while (UNLIKELY(!allow_new_interns_)) { |
| 228 | new_intern_condition_.WaitHoldingLocks(self); |
| 229 | } |
| 230 | |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 231 | if (is_strong) { |
jeffhao | b1c6f34 | 2012-03-20 17:57:26 -0700 | [diff] [blame] | 232 | // Check the strong table for a match. |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 233 | mirror::String* strong = LookupStrong(s, hash_code); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 234 | if (strong != NULL) { |
| 235 | return strong; |
| 236 | } |
| 237 | |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 238 | // Check the image for a match. |
| 239 | mirror::String* image = LookupStringFromImage(s); |
| 240 | if (image != NULL) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 241 | return InsertStrong(image, hash_code); |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 242 | } |
| 243 | |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 244 | // There is no match in the strong table, check the weak table. |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 245 | mirror::String* weak = LookupWeak(s, hash_code); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 246 | if (weak != NULL) { |
| 247 | // A match was found in the weak table. Promote to the strong table. |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 248 | RemoveWeak(weak, hash_code); |
| 249 | return InsertStrong(weak, hash_code); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 250 | } |
| 251 | |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 252 | // No match in the strong table or the weak table. Insert into the strong |
| 253 | // table. |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 254 | return InsertStrong(s, hash_code); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 255 | } |
| 256 | |
| 257 | // Check the strong table for a match. |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 258 | mirror::String* strong = LookupStrong(s, hash_code); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 259 | if (strong != NULL) { |
| 260 | return strong; |
| 261 | } |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 262 | // Check the image for a match. |
| 263 | mirror::String* image = LookupStringFromImage(s); |
jeffhao | b1c6f34 | 2012-03-20 17:57:26 -0700 | [diff] [blame] | 264 | if (image != NULL) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 265 | return InsertWeak(image, hash_code); |
jeffhao | b1c6f34 | 2012-03-20 17:57:26 -0700 | [diff] [blame] | 266 | } |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 267 | // Check the weak table for a match. |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 268 | mirror::String* weak = LookupWeak(s, hash_code); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 269 | if (weak != NULL) { |
| 270 | return weak; |
| 271 | } |
| 272 | // Insert into the weak table. |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 273 | return InsertWeak(s, hash_code); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 274 | } |
| 275 | |
Mathieu Chartier | ed0fc1d | 2014-03-21 14:09:35 -0700 | [diff] [blame] | 276 | mirror::String* InternTable::InternStrong(int32_t utf16_length, const char* utf8_data) { |
| 277 | DCHECK(utf8_data != nullptr); |
Ian Rogers | 7dfb28c | 2013-08-22 08:18:36 -0700 | [diff] [blame] | 278 | return InternStrong(mirror::String::AllocFromModifiedUtf8( |
| 279 | Thread::Current(), utf16_length, utf8_data)); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 280 | } |
| 281 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 282 | mirror::String* InternTable::InternStrong(const char* utf8_data) { |
Mathieu Chartier | ed0fc1d | 2014-03-21 14:09:35 -0700 | [diff] [blame] | 283 | DCHECK(utf8_data != nullptr); |
| 284 | return InternStrong(mirror::String::AllocFromModifiedUtf8(Thread::Current(), utf8_data)); |
Brian Carlstrom | c74255f | 2011-09-11 22:47:39 -0700 | [diff] [blame] | 285 | } |
| 286 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 287 | mirror::String* InternTable::InternStrong(mirror::String* s) { |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 288 | if (s == nullptr) { |
| 289 | return nullptr; |
Elliott Hughes | 37d4e6b | 2011-10-13 12:05:20 -0700 | [diff] [blame] | 290 | } |
Brian Carlstrom | c74255f | 2011-09-11 22:47:39 -0700 | [diff] [blame] | 291 | return Insert(s, true); |
| 292 | } |
| 293 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 294 | mirror::String* InternTable::InternWeak(mirror::String* s) { |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 295 | if (s == nullptr) { |
| 296 | return nullptr; |
Elliott Hughes | 37d4e6b | 2011-10-13 12:05:20 -0700 | [diff] [blame] | 297 | } |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 298 | return Insert(s, false); |
| 299 | } |
| 300 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 301 | bool InternTable::ContainsWeak(mirror::String* s) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 302 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 303 | const mirror::String* found = LookupWeak(s, s->GetHashCode()); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 304 | return found == s; |
| 305 | } |
| 306 | |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 307 | void InternTable::SweepInternTableWeaks(IsMarkedCallback* callback, void* arg) { |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 308 | MutexLock mu(Thread::Current(), *Locks::intern_table_lock_); |
Mathieu Chartier | 02e2511 | 2013-08-14 16:14:24 -0700 | [diff] [blame] | 309 | for (auto it = weak_interns_.begin(), end = weak_interns_.end(); it != end;) { |
Hiroshi Yamauchi | 1bd4872 | 2014-05-23 19:58:15 -0700 | [diff] [blame] | 310 | // This does not need a read barrier because this is called by GC. |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 311 | mirror::Object* object = it->second; |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 312 | mirror::Object* new_object = callback(object, arg); |
Mathieu Chartier | 6aa3df9 | 2013-09-17 15:17:28 -0700 | [diff] [blame] | 313 | if (new_object == nullptr) { |
| 314 | // TODO: use it = weak_interns_.erase(it) when we get a c++11 stl. |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 315 | weak_interns_.erase(it++); |
| 316 | } else { |
Mathieu Chartier | 6aa3df9 | 2013-09-17 15:17:28 -0700 | [diff] [blame] | 317 | it->second = down_cast<mirror::String*>(new_object); |
Elliott Hughes | cf4c6c4 | 2011-09-01 15:16:42 -0700 | [diff] [blame] | 318 | ++it; |
| 319 | } |
| 320 | } |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 321 | } |
| 322 | |
Brian Carlstrom | 7e93b50 | 2011-08-04 14:16:22 -0700 | [diff] [blame] | 323 | } // namespace art |