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 17 #ifndef ART_RUNTIME_CLASS_LINKER_INL_H_ 18 #define ART_RUNTIME_CLASS_LINKER_INL_H_ 19 20 #include "art_field.h" 21 #include "class_linker.h" 22 #include "gc_root-inl.h" 23 #include "gc/heap-inl.h" 24 #include "mirror/class_loader.h" 25 #include "mirror/dex_cache-inl.h" 26 #include "mirror/iftable.h" 27 #include "mirror/object_array.h" 28 #include "handle_scope-inl.h" 29 30 namespace art { 31 32 inline mirror::Class* ClassLinker::FindSystemClass(Thread* self, const char* descriptor) { 33 return FindClass(self, descriptor, NullHandle<mirror::ClassLoader>()); 34 } 35 36 inline mirror::Class* ClassLinker::FindArrayClass(Thread* self, mirror::Class** element_class) { 37 for (size_t i = 0; i < kFindArrayCacheSize; ++i) { 38 // Read the cached array class once to avoid races with other threads setting it. 39 mirror::Class* array_class = find_array_class_cache_[i].Read(); 40 if (array_class != nullptr && array_class->GetComponentType() == *element_class) { 41 return array_class; 42 } 43 } 44 DCHECK(!(*element_class)->IsPrimitiveVoid()); 45 std::string descriptor = "["; 46 std::string temp; 47 descriptor += (*element_class)->GetDescriptor(&temp); 48 StackHandleScope<2> hs(Thread::Current()); 49 Handle<mirror::ClassLoader> class_loader(hs.NewHandle((*element_class)->GetClassLoader())); 50 HandleWrapper<mirror::Class> h_element_class(hs.NewHandleWrapper(element_class)); 51 mirror::Class* array_class = FindClass(self, descriptor.c_str(), class_loader); 52 // Benign races in storing array class and incrementing index. 53 size_t victim_index = find_array_class_cache_next_victim_; 54 find_array_class_cache_[victim_index] = GcRoot<mirror::Class>(array_class); 55 find_array_class_cache_next_victim_ = (victim_index + 1) % kFindArrayCacheSize; 56 return array_class; 57 } 58 59 inline mirror::String* ClassLinker::ResolveString(uint32_t string_idx, 60 ArtMethod* referrer) { 61 mirror::Class* declaring_class = referrer->GetDeclaringClass(); 62 mirror::String* resolved_string = declaring_class->GetDexCacheStrings()->Get(string_idx); 63 if (UNLIKELY(resolved_string == nullptr)) { 64 StackHandleScope<1> hs(Thread::Current()); 65 Handle<mirror::DexCache> dex_cache(hs.NewHandle(declaring_class->GetDexCache())); 66 const DexFile& dex_file = *dex_cache->GetDexFile(); 67 resolved_string = ResolveString(dex_file, string_idx, dex_cache); 68 if (resolved_string != nullptr) { 69 DCHECK_EQ(dex_cache->GetResolvedString(string_idx), resolved_string); 70 } 71 } 72 return resolved_string; 73 } 74 75 inline mirror::Class* ClassLinker::ResolveType(uint16_t type_idx, 76 ArtMethod* referrer) { 77 mirror::Class* resolved_type = referrer->GetDexCacheResolvedType(type_idx); 78 if (UNLIKELY(resolved_type == nullptr)) { 79 mirror::Class* declaring_class = referrer->GetDeclaringClass(); 80 StackHandleScope<2> hs(Thread::Current()); 81 Handle<mirror::DexCache> dex_cache(hs.NewHandle(declaring_class->GetDexCache())); 82 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(declaring_class->GetClassLoader())); 83 const DexFile& dex_file = *dex_cache->GetDexFile(); 84 resolved_type = ResolveType(dex_file, type_idx, dex_cache, class_loader); 85 // Note: We cannot check here to see whether we added the type to the cache. The type 86 // might be an erroneous class, which results in it being hidden from us. 87 } 88 return resolved_type; 89 } 90 91 inline mirror::Class* ClassLinker::ResolveType(uint16_t type_idx, ArtField* referrer) { 92 mirror::Class* declaring_class = referrer->GetDeclaringClass(); 93 mirror::DexCache* dex_cache_ptr = declaring_class->GetDexCache(); 94 mirror::Class* resolved_type = dex_cache_ptr->GetResolvedType(type_idx); 95 if (UNLIKELY(resolved_type == nullptr)) { 96 StackHandleScope<2> hs(Thread::Current()); 97 Handle<mirror::DexCache> dex_cache(hs.NewHandle(dex_cache_ptr)); 98 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(declaring_class->GetClassLoader())); 99 const DexFile& dex_file = *dex_cache->GetDexFile(); 100 resolved_type = ResolveType(dex_file, type_idx, dex_cache, class_loader); 101 // Note: We cannot check here to see whether we added the type to the cache. The type 102 // might be an erroneous class, which results in it being hidden from us. 103 } 104 return resolved_type; 105 } 106 107 inline ArtMethod* ClassLinker::GetResolvedMethod(uint32_t method_idx, ArtMethod* referrer) { 108 ArtMethod* resolved_method = referrer->GetDexCacheResolvedMethod( 109 method_idx, image_pointer_size_); 110 if (resolved_method == nullptr || resolved_method->IsRuntimeMethod()) { 111 return nullptr; 112 } 113 return resolved_method; 114 } 115 116 inline ArtMethod* ClassLinker::ResolveMethod(Thread* self, uint32_t method_idx, 117 ArtMethod* referrer, InvokeType type) { 118 ArtMethod* resolved_method = GetResolvedMethod(method_idx, referrer); 119 if (UNLIKELY(resolved_method == nullptr)) { 120 mirror::Class* declaring_class = referrer->GetDeclaringClass(); 121 StackHandleScope<2> hs(self); 122 Handle<mirror::DexCache> h_dex_cache(hs.NewHandle(declaring_class->GetDexCache())); 123 Handle<mirror::ClassLoader> h_class_loader(hs.NewHandle(declaring_class->GetClassLoader())); 124 const DexFile* dex_file = h_dex_cache->GetDexFile(); 125 resolved_method = ResolveMethod(*dex_file, method_idx, h_dex_cache, h_class_loader, referrer, 126 type); 127 } 128 // Note: We cannot check here to see whether we added the method to the cache. It 129 // might be an erroneous class, which results in it being hidden from us. 130 return resolved_method; 131 } 132 133 inline ArtField* ClassLinker::GetResolvedField(uint32_t field_idx, mirror::DexCache* dex_cache) { 134 return dex_cache->GetResolvedField(field_idx, image_pointer_size_); 135 } 136 137 inline ArtField* ClassLinker::GetResolvedField( 138 uint32_t field_idx, mirror::Class* field_declaring_class) { 139 return GetResolvedField(field_idx, field_declaring_class->GetDexCache()); 140 } 141 142 inline ArtField* ClassLinker::ResolveField(uint32_t field_idx, ArtMethod* referrer, 143 bool is_static) { 144 mirror::Class* declaring_class = referrer->GetDeclaringClass(); 145 ArtField* resolved_field = GetResolvedField(field_idx, declaring_class); 146 if (UNLIKELY(resolved_field == nullptr)) { 147 StackHandleScope<2> hs(Thread::Current()); 148 Handle<mirror::DexCache> dex_cache(hs.NewHandle(declaring_class->GetDexCache())); 149 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(declaring_class->GetClassLoader())); 150 const DexFile& dex_file = *dex_cache->GetDexFile(); 151 resolved_field = ResolveField(dex_file, field_idx, dex_cache, class_loader, is_static); 152 // Note: We cannot check here to see whether we added the field to the cache. The type 153 // might be an erroneous class, which results in it being hidden from us. 154 } 155 return resolved_field; 156 } 157 158 inline mirror::Object* ClassLinker::AllocObject(Thread* self) { 159 return GetClassRoot(kJavaLangObject)->Alloc<true, false>(self, 160 Runtime::Current()->GetHeap()->GetCurrentAllocator()); 161 } 162 163 template <class T> 164 inline mirror::ObjectArray<T>* ClassLinker::AllocObjectArray(Thread* self, size_t length) { 165 return mirror::ObjectArray<T>::Alloc(self, GetClassRoot(kObjectArrayClass), length); 166 } 167 168 inline mirror::ObjectArray<mirror::Class>* ClassLinker::AllocClassArray(Thread* self, 169 size_t length) { 170 return mirror::ObjectArray<mirror::Class>::Alloc(self, GetClassRoot(kClassArrayClass), length); 171 } 172 173 inline mirror::ObjectArray<mirror::String>* ClassLinker::AllocStringArray(Thread* self, 174 size_t length) { 175 return mirror::ObjectArray<mirror::String>::Alloc(self, GetClassRoot(kJavaLangStringArrayClass), 176 length); 177 } 178 179 inline mirror::IfTable* ClassLinker::AllocIfTable(Thread* self, size_t ifcount) { 180 return down_cast<mirror::IfTable*>( 181 mirror::IfTable::Alloc(self, GetClassRoot(kObjectArrayClass), 182 ifcount * mirror::IfTable::kMax)); 183 } 184 185 inline mirror::Class* ClassLinker::GetClassRoot(ClassRoot class_root) 186 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 187 DCHECK(!class_roots_.IsNull()); 188 mirror::ObjectArray<mirror::Class>* class_roots = class_roots_.Read(); 189 mirror::Class* klass = class_roots->Get(class_root); 190 DCHECK(klass != nullptr); 191 return klass; 192 } 193 194 inline mirror::DexCache* ClassLinker::GetDexCache(size_t idx) { 195 dex_lock_.AssertSharedHeld(Thread::Current()); 196 DCHECK(idx < dex_caches_.size()); 197 return dex_caches_[idx].Read(); 198 } 199 200 } // namespace art 201 202 #endif // ART_RUNTIME_CLASS_LINKER_INL_H_ 203
