Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -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 | */ |
| 16 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 17 | #ifndef ART_RUNTIME_CLASS_LINKER_INL_H_ |
| 18 | #define ART_RUNTIME_CLASS_LINKER_INL_H_ |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 19 | |
| 20 | #include "class_linker.h" |
Mathieu Chartier | 52e4b43 | 2014-06-10 11:22:31 -0700 | [diff] [blame] | 21 | #include "gc/heap-inl.h" |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 22 | #include "mirror/art_field.h" |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 23 | #include "mirror/class_loader.h" |
Mathieu Chartier | bc56fc3 | 2014-06-03 15:37:03 -0700 | [diff] [blame] | 24 | #include "mirror/dex_cache-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 25 | #include "mirror/iftable.h" |
| 26 | #include "mirror/object_array.h" |
Ian Rogers | 9837939 | 2014-02-24 16:53:16 -0800 | [diff] [blame] | 27 | #include "object_utils.h" |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 28 | #include "handle_scope-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 29 | |
| 30 | namespace art { |
| 31 | |
Ian Rogers | 9837939 | 2014-02-24 16:53:16 -0800 | [diff] [blame] | 32 | inline bool ClassLinker::IsInBootClassPath(const char* descriptor) { |
| 33 | DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_); |
| 34 | return pair.second != nullptr; |
| 35 | } |
| 36 | |
| 37 | inline mirror::Class* ClassLinker::FindSystemClass(Thread* self, const char* descriptor) { |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 38 | return FindClass(self, descriptor, NullHandle<mirror::ClassLoader>()); |
Ian Rogers | 9837939 | 2014-02-24 16:53:16 -0800 | [diff] [blame] | 39 | } |
| 40 | |
Mathieu Chartier | b74cd29 | 2014-05-29 14:31:33 -0700 | [diff] [blame] | 41 | inline mirror::Class* ClassLinker::FindArrayClass(Thread* self, mirror::Class** element_class) { |
Ian Rogers | 9837939 | 2014-02-24 16:53:16 -0800 | [diff] [blame] | 42 | for (size_t i = 0; i < kFindArrayCacheSize; ++i) { |
Ian Rogers | a55cf41 | 2014-02-27 00:31:26 -0800 | [diff] [blame] | 43 | // Read the cached array class once to avoid races with other threads setting it. |
Hiroshi Yamauchi | e9e3e69 | 2014-06-24 14:31:37 -0700 | [diff] [blame] | 44 | mirror::Class* array_class = ReadBarrier::BarrierForRoot<mirror::Class, kWithReadBarrier>( |
| 45 | &find_array_class_cache_[i]); |
Mathieu Chartier | b74cd29 | 2014-05-29 14:31:33 -0700 | [diff] [blame] | 46 | if (array_class != nullptr && array_class->GetComponentType() == *element_class) { |
Ian Rogers | 9837939 | 2014-02-24 16:53:16 -0800 | [diff] [blame] | 47 | return array_class; |
| 48 | } |
| 49 | } |
Mathieu Chartier | b74cd29 | 2014-05-29 14:31:33 -0700 | [diff] [blame] | 50 | DCHECK(!(*element_class)->IsPrimitiveVoid()); |
| 51 | std::string descriptor = "[" + (*element_class)->GetDescriptor(); |
| 52 | StackHandleScope<2> hs(Thread::Current()); |
| 53 | Handle<mirror::ClassLoader> class_loader(hs.NewHandle((*element_class)->GetClassLoader())); |
| 54 | HandleWrapper<mirror::Class> h_element_class(hs.NewHandleWrapper(element_class)); |
Ian Rogers | 9837939 | 2014-02-24 16:53:16 -0800 | [diff] [blame] | 55 | mirror::Class* array_class = FindClass(self, descriptor.c_str(), class_loader); |
| 56 | // Benign races in storing array class and incrementing index. |
| 57 | size_t victim_index = find_array_class_cache_next_victim_; |
| 58 | find_array_class_cache_[victim_index] = array_class; |
| 59 | find_array_class_cache_next_victim_ = (victim_index + 1) % kFindArrayCacheSize; |
| 60 | return array_class; |
| 61 | } |
| 62 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 63 | inline mirror::String* ClassLinker::ResolveString(uint32_t string_idx, |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 64 | mirror::ArtMethod* referrer) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 65 | mirror::String* resolved_string = referrer->GetDexCacheStrings()->Get(string_idx); |
| 66 | if (UNLIKELY(resolved_string == NULL)) { |
| 67 | mirror::Class* declaring_class = referrer->GetDeclaringClass(); |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 68 | StackHandleScope<1> hs(Thread::Current()); |
| 69 | Handle<mirror::DexCache> dex_cache(hs.NewHandle(declaring_class->GetDexCache())); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 70 | const DexFile& dex_file = *dex_cache->GetDexFile(); |
| 71 | resolved_string = ResolveString(dex_file, string_idx, dex_cache); |
Ian Rogers | eebe03a | 2014-05-02 11:09:57 -0700 | [diff] [blame] | 72 | if (resolved_string != nullptr) { |
| 73 | DCHECK_EQ(dex_cache->GetResolvedString(string_idx), resolved_string); |
| 74 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 75 | } |
| 76 | return resolved_string; |
| 77 | } |
| 78 | |
| 79 | inline mirror::Class* ClassLinker::ResolveType(uint16_t type_idx, |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 80 | mirror::ArtMethod* referrer) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 81 | mirror::Class* resolved_type = referrer->GetDexCacheResolvedTypes()->Get(type_idx); |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 82 | if (UNLIKELY(resolved_type == nullptr)) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 83 | mirror::Class* declaring_class = referrer->GetDeclaringClass(); |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 84 | StackHandleScope<2> hs(Thread::Current()); |
| 85 | Handle<mirror::DexCache> dex_cache(hs.NewHandle(declaring_class->GetDexCache())); |
| 86 | Handle<mirror::ClassLoader> class_loader(hs.NewHandle(declaring_class->GetClassLoader())); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 87 | const DexFile& dex_file = *dex_cache->GetDexFile(); |
| 88 | resolved_type = ResolveType(dex_file, type_idx, dex_cache, class_loader); |
Ian Rogers | eebe03a | 2014-05-02 11:09:57 -0700 | [diff] [blame] | 89 | if (resolved_type != nullptr) { |
| 90 | DCHECK_EQ(dex_cache->GetResolvedType(type_idx), resolved_type); |
| 91 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 92 | } |
| 93 | return resolved_type; |
| 94 | } |
| 95 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 96 | inline mirror::Class* ClassLinker::ResolveType(uint16_t type_idx, mirror::ArtField* referrer) { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 97 | mirror::Class* declaring_class = referrer->GetDeclaringClass(); |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 98 | mirror::DexCache* dex_cache_ptr = declaring_class->GetDexCache(); |
| 99 | mirror::Class* resolved_type = dex_cache_ptr->GetResolvedType(type_idx); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 100 | if (UNLIKELY(resolved_type == NULL)) { |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 101 | StackHandleScope<2> hs(Thread::Current()); |
| 102 | Handle<mirror::DexCache> dex_cache(hs.NewHandle(dex_cache_ptr)); |
| 103 | Handle<mirror::ClassLoader> class_loader(hs.NewHandle(declaring_class->GetClassLoader())); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 104 | const DexFile& dex_file = *dex_cache->GetDexFile(); |
| 105 | resolved_type = ResolveType(dex_file, type_idx, dex_cache, class_loader); |
Ian Rogers | eebe03a | 2014-05-02 11:09:57 -0700 | [diff] [blame] | 106 | if (resolved_type != nullptr) { |
| 107 | DCHECK_EQ(dex_cache->GetResolvedType(type_idx), resolved_type); |
| 108 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 109 | } |
| 110 | return resolved_type; |
| 111 | } |
| 112 | |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 113 | inline mirror::ArtMethod* ClassLinker::GetResolvedMethod(uint32_t method_idx, |
| 114 | mirror::ArtMethod* referrer, |
| 115 | InvokeType type) { |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 116 | mirror::ArtMethod* resolved_method = |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 117 | referrer->GetDexCacheResolvedMethods()->Get(method_idx); |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 118 | if (resolved_method == nullptr || resolved_method->IsRuntimeMethod()) { |
| 119 | return nullptr; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 120 | } |
| 121 | return resolved_method; |
| 122 | } |
| 123 | |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 124 | inline mirror::ArtMethod* ClassLinker::ResolveMethod(Thread* self, uint32_t method_idx, |
| 125 | mirror::ArtMethod** referrer, |
| 126 | InvokeType type) { |
| 127 | mirror::ArtMethod* resolved_method = GetResolvedMethod(method_idx, *referrer, type); |
| 128 | if (LIKELY(resolved_method != nullptr)) { |
| 129 | return resolved_method; |
| 130 | } |
| 131 | mirror::Class* declaring_class = (*referrer)->GetDeclaringClass(); |
| 132 | StackHandleScope<3> hs(self); |
| 133 | Handle<mirror::DexCache> h_dex_cache(hs.NewHandle(declaring_class->GetDexCache())); |
| 134 | Handle<mirror::ClassLoader> h_class_loader(hs.NewHandle(declaring_class->GetClassLoader())); |
| 135 | HandleWrapper<mirror::ArtMethod> h_referrer(hs.NewHandleWrapper(referrer)); |
| 136 | const DexFile* dex_file = h_dex_cache->GetDexFile(); |
| 137 | resolved_method = ResolveMethod(*dex_file, method_idx, h_dex_cache, h_class_loader, h_referrer, |
| 138 | type); |
| 139 | if (resolved_method != nullptr) { |
| 140 | DCHECK_EQ(h_dex_cache->GetResolvedMethod(method_idx), resolved_method); |
| 141 | } |
| 142 | return resolved_method; |
| 143 | } |
| 144 | |
| 145 | inline mirror::ArtField* ClassLinker::GetResolvedField(uint32_t field_idx, |
| 146 | mirror::Class* field_declaring_class) { |
| 147 | return field_declaring_class->GetDexCache()->GetResolvedField(field_idx); |
| 148 | } |
| 149 | |
| 150 | inline mirror::ArtField* ClassLinker::ResolveField(uint32_t field_idx, mirror::ArtMethod* referrer, |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 151 | bool is_static) { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 152 | mirror::Class* declaring_class = referrer->GetDeclaringClass(); |
Mathieu Chartier | 0cd8135 | 2014-05-22 16:48:55 -0700 | [diff] [blame] | 153 | mirror::ArtField* resolved_field = GetResolvedField(field_idx, declaring_class); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 154 | if (UNLIKELY(resolved_field == NULL)) { |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 155 | StackHandleScope<2> hs(Thread::Current()); |
| 156 | Handle<mirror::DexCache> dex_cache(hs.NewHandle(declaring_class->GetDexCache())); |
| 157 | Handle<mirror::ClassLoader> class_loader(hs.NewHandle(declaring_class->GetClassLoader())); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 158 | const DexFile& dex_file = *dex_cache->GetDexFile(); |
| 159 | resolved_field = ResolveField(dex_file, field_idx, dex_cache, class_loader, is_static); |
Ian Rogers | eebe03a | 2014-05-02 11:09:57 -0700 | [diff] [blame] | 160 | if (resolved_field != nullptr) { |
| 161 | DCHECK_EQ(dex_cache->GetResolvedField(field_idx), resolved_field); |
| 162 | } |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 163 | } |
| 164 | return resolved_field; |
| 165 | } |
| 166 | |
| 167 | template <class T> |
| 168 | inline mirror::ObjectArray<T>* ClassLinker::AllocObjectArray(Thread* self, size_t length) { |
| 169 | return mirror::ObjectArray<T>::Alloc(self, GetClassRoot(kObjectArrayClass), length); |
| 170 | } |
| 171 | |
| 172 | inline mirror::ObjectArray<mirror::Class>* ClassLinker::AllocClassArray(Thread* self, |
| 173 | size_t length) { |
| 174 | return mirror::ObjectArray<mirror::Class>::Alloc(self, GetClassRoot(kClassArrayClass), length); |
| 175 | } |
| 176 | |
| 177 | inline mirror::ObjectArray<mirror::String>* ClassLinker::AllocStringArray(Thread* self, |
| 178 | size_t length) { |
| 179 | return mirror::ObjectArray<mirror::String>::Alloc(self, GetClassRoot(kJavaLangStringArrayClass), |
| 180 | length); |
| 181 | } |
| 182 | |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 183 | inline mirror::ObjectArray<mirror::ArtMethod>* ClassLinker::AllocArtMethodArray(Thread* self, |
| 184 | size_t length) { |
| 185 | return mirror::ObjectArray<mirror::ArtMethod>::Alloc(self, |
| 186 | GetClassRoot(kJavaLangReflectArtMethodArrayClass), length); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 187 | } |
| 188 | |
| 189 | inline mirror::IfTable* ClassLinker::AllocIfTable(Thread* self, size_t ifcount) { |
| 190 | return down_cast<mirror::IfTable*>( |
Mathieu Chartier | 52e4b43 | 2014-06-10 11:22:31 -0700 | [diff] [blame] | 191 | mirror::IfTable::Alloc(self, GetClassRoot(kObjectArrayClass), |
| 192 | ifcount * mirror::IfTable::kMax)); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 193 | } |
| 194 | |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 195 | inline mirror::ObjectArray<mirror::ArtField>* ClassLinker::AllocArtFieldArray(Thread* self, |
| 196 | size_t length) { |
Mathieu Chartier | 52e4b43 | 2014-06-10 11:22:31 -0700 | [diff] [blame] | 197 | gc::Heap* const heap = Runtime::Current()->GetHeap(); |
| 198 | // Can't have movable field arrays for mark compact since we need these arrays to always be valid |
| 199 | // so that we can do Object::VisitReferences in the case where the fields don't fit in the |
| 200 | // reference offsets word. |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 201 | return mirror::ObjectArray<mirror::ArtField>::Alloc( |
Mathieu Chartier | 52e4b43 | 2014-06-10 11:22:31 -0700 | [diff] [blame] | 202 | self, GetClassRoot(kJavaLangReflectArtFieldArrayClass), length, |
| 203 | kMoveFieldArrays ? heap->GetCurrentAllocator() : heap->GetCurrentNonMovingAllocator()); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 204 | } |
| 205 | |
| 206 | inline mirror::Class* ClassLinker::GetClassRoot(ClassRoot class_root) |
| 207 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { |
| 208 | DCHECK(class_roots_ != NULL); |
Hiroshi Yamauchi | e9e3e69 | 2014-06-24 14:31:37 -0700 | [diff] [blame] | 209 | mirror::ObjectArray<mirror::Class>* class_roots = |
| 210 | ReadBarrier::BarrierForRoot<mirror::ObjectArray<mirror::Class>, kWithReadBarrier>( |
| 211 | &class_roots_); |
| 212 | mirror::Class* klass = class_roots->Get(class_root); |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 213 | DCHECK(klass != NULL); |
| 214 | return klass; |
| 215 | } |
| 216 | |
Hiroshi Yamauchi | e9e3e69 | 2014-06-24 14:31:37 -0700 | [diff] [blame] | 217 | inline mirror::DexCache* ClassLinker::GetDexCache(size_t idx) { |
| 218 | dex_lock_.AssertSharedHeld(Thread::Current()); |
| 219 | DCHECK(idx < dex_caches_.size()); |
| 220 | return ReadBarrier::BarrierForRoot<mirror::DexCache, kWithReadBarrier>(&dex_caches_[idx]); |
| 221 | } |
| 222 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 223 | } // namespace art |
| 224 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 225 | #endif // ART_RUNTIME_CLASS_LINKER_INL_H_ |