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 | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 16 | |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 17 | #include "dex_cache-inl.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 18 | |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 19 | #include "art_method-inl.h" |
Elliott Hughes | 07ed66b | 2012-12-12 18:34:25 -0800 | [diff] [blame] | 20 | #include "base/logging.h" |
Brian Carlstrom | 9ea1cb1 | 2011-08-24 23:18:18 -0700 | [diff] [blame] | 21 | #include "class_linker.h" |
Ian Rogers | 1d54e73 | 2013-05-02 21:10:01 -0700 | [diff] [blame] | 22 | #include "gc/accounting/card_table-inl.h" |
| 23 | #include "gc/heap.h" |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 24 | #include "globals.h" |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 25 | #include "linear_alloc.h" |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 26 | #include "object.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 27 | #include "object-inl.h" |
| 28 | #include "object_array-inl.h" |
| 29 | #include "runtime.h" |
| 30 | #include "string.h" |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 31 | #include "thread.h" |
| 32 | #include "utils/dex_cache_arrays_layout-inl.h" |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 33 | |
| 34 | namespace art { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 35 | namespace mirror { |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 36 | |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 37 | void DexCache::InitializeDexCache(Thread* self, |
| 38 | ObjPtr<mirror::DexCache> dex_cache, |
| 39 | ObjPtr<mirror::String> location, |
| 40 | const DexFile* dex_file, |
| 41 | LinearAlloc* linear_alloc, |
| 42 | PointerSize image_pointer_size) { |
| 43 | DCHECK(dex_file != nullptr); |
| 44 | ScopedAssertNoThreadSuspension sants(__FUNCTION__); |
| 45 | DexCacheArraysLayout layout(image_pointer_size, dex_file); |
| 46 | uint8_t* raw_arrays = nullptr; |
| 47 | |
| 48 | const OatDexFile* const oat_dex = dex_file->GetOatDexFile(); |
| 49 | if (oat_dex != nullptr && oat_dex->GetDexCacheArrays() != nullptr) { |
| 50 | raw_arrays = oat_dex->GetDexCacheArrays(); |
| 51 | } else if (dex_file->NumStringIds() != 0u || |
| 52 | dex_file->NumTypeIds() != 0u || |
| 53 | dex_file->NumMethodIds() != 0u || |
| 54 | dex_file->NumFieldIds() != 0u) { |
| 55 | // Zero-initialized. |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 56 | raw_arrays = reinterpret_cast<uint8_t*>(linear_alloc->Alloc(self, layout.Size())); |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 57 | } |
| 58 | |
| 59 | mirror::StringDexCacheType* strings = (dex_file->NumStringIds() == 0u) ? nullptr : |
| 60 | reinterpret_cast<mirror::StringDexCacheType*>(raw_arrays + layout.StringsOffset()); |
Vladimir Marko | 0b66d61 | 2017-03-13 14:50:04 +0000 | [diff] [blame] | 61 | GcRoot<mirror::Class>* types = (dex_file->NumTypeIds() == 0u) ? nullptr : |
| 62 | reinterpret_cast<GcRoot<mirror::Class>*>(raw_arrays + layout.TypesOffset()); |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 63 | ArtMethod** methods = (dex_file->NumMethodIds() == 0u) ? nullptr : |
| 64 | reinterpret_cast<ArtMethod**>(raw_arrays + layout.MethodsOffset()); |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 65 | ArtField** fields = (dex_file->NumFieldIds() == 0u) ? nullptr : |
| 66 | reinterpret_cast<ArtField**>(raw_arrays + layout.FieldsOffset()); |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 67 | |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 68 | size_t num_strings = mirror::DexCache::kDexCacheStringCacheSize; |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 69 | if (dex_file->NumStringIds() < num_strings) { |
| 70 | num_strings = dex_file->NumStringIds(); |
| 71 | } |
| 72 | |
| 73 | // Note that we allocate the method type dex caches regardless of this flag, |
| 74 | // and we make sure here that they're not used by the runtime. This is in the |
| 75 | // interest of simplicity and to avoid extensive compiler and layout class changes. |
| 76 | // |
| 77 | // If this needs to be mitigated in a production system running this code, |
| 78 | // DexCache::kDexCacheMethodTypeCacheSize can be set to zero. |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 79 | mirror::MethodTypeDexCacheType* method_types = nullptr; |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 80 | size_t num_method_types = 0; |
| 81 | |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 82 | if (dex_file->NumProtoIds() < mirror::DexCache::kDexCacheMethodTypeCacheSize) { |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 83 | num_method_types = dex_file->NumProtoIds(); |
| 84 | } else { |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 85 | num_method_types = mirror::DexCache::kDexCacheMethodTypeCacheSize; |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 86 | } |
| 87 | |
| 88 | if (num_method_types > 0) { |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 89 | method_types = reinterpret_cast<mirror::MethodTypeDexCacheType*>( |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 90 | raw_arrays + layout.MethodTypesOffset()); |
| 91 | } |
| 92 | |
Orion Hodson | c069a30 | 2017-01-18 09:23:12 +0000 | [diff] [blame] | 93 | GcRoot<mirror::CallSite>* call_sites = (dex_file->NumCallSiteIds() == 0) |
| 94 | ? nullptr |
| 95 | : reinterpret_cast<GcRoot<mirror::CallSite>*>(raw_arrays + layout.CallSitesOffset()); |
| 96 | |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 97 | DCHECK_ALIGNED(raw_arrays, alignof(mirror::StringDexCacheType)) << |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 98 | "Expected raw_arrays to align to StringDexCacheType."; |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 99 | DCHECK_ALIGNED(layout.StringsOffset(), alignof(mirror::StringDexCacheType)) << |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 100 | "Expected StringsOffset() to align to StringDexCacheType."; |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 101 | DCHECK_ALIGNED(strings, alignof(mirror::StringDexCacheType)) << |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 102 | "Expected strings to align to StringDexCacheType."; |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 103 | static_assert(alignof(mirror::StringDexCacheType) == 8u, |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 104 | "Expected StringDexCacheType to have align of 8."); |
| 105 | if (kIsDebugBuild) { |
| 106 | // Sanity check to make sure all the dex cache arrays are empty. b/28992179 |
| 107 | for (size_t i = 0; i < num_strings; ++i) { |
| 108 | CHECK_EQ(strings[i].load(std::memory_order_relaxed).index, 0u); |
| 109 | CHECK(strings[i].load(std::memory_order_relaxed).object.IsNull()); |
| 110 | } |
Vladimir Marko | 0b66d61 | 2017-03-13 14:50:04 +0000 | [diff] [blame] | 111 | for (size_t i = 0; i < dex_file->NumTypeIds(); ++i) { |
| 112 | CHECK(types[i].IsNull()); |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 113 | } |
| 114 | for (size_t i = 0; i < dex_file->NumMethodIds(); ++i) { |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 115 | CHECK(mirror::DexCache::GetElementPtrSize(methods, i, image_pointer_size) == nullptr); |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 116 | } |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 117 | for (size_t i = 0; i < dex_file->NumFieldIds(); ++i) { |
| 118 | CHECK(mirror::DexCache::GetElementPtrSize(fields, i, image_pointer_size) == nullptr); |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 119 | } |
| 120 | for (size_t i = 0; i < num_method_types; ++i) { |
| 121 | CHECK_EQ(method_types[i].load(std::memory_order_relaxed).index, 0u); |
| 122 | CHECK(method_types[i].load(std::memory_order_relaxed).object.IsNull()); |
| 123 | } |
Orion Hodson | c069a30 | 2017-01-18 09:23:12 +0000 | [diff] [blame] | 124 | for (size_t i = 0; i < dex_file->NumCallSiteIds(); ++i) { |
| 125 | CHECK(call_sites[i].IsNull()); |
| 126 | } |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 127 | } |
| 128 | if (strings != nullptr) { |
| 129 | mirror::StringDexCachePair::Initialize(strings); |
| 130 | } |
| 131 | if (method_types != nullptr) { |
| 132 | mirror::MethodTypeDexCachePair::Initialize(method_types); |
| 133 | } |
| 134 | dex_cache->Init(dex_file, |
| 135 | location, |
| 136 | strings, |
| 137 | num_strings, |
| 138 | types, |
Vladimir Marko | 0b66d61 | 2017-03-13 14:50:04 +0000 | [diff] [blame] | 139 | dex_file->NumTypeIds(), |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 140 | methods, |
| 141 | dex_file->NumMethodIds(), |
| 142 | fields, |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 143 | dex_file->NumFieldIds(), |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 144 | method_types, |
| 145 | num_method_types, |
Orion Hodson | c069a30 | 2017-01-18 09:23:12 +0000 | [diff] [blame] | 146 | call_sites, |
| 147 | dex_file->NumCallSiteIds(), |
Andreas Gampe | cc1b535 | 2016-12-01 16:58:38 -0800 | [diff] [blame] | 148 | image_pointer_size); |
| 149 | } |
| 150 | |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 151 | void DexCache::Init(const DexFile* dex_file, |
Mathieu Chartier | 28357fa | 2016-10-18 16:27:40 -0700 | [diff] [blame] | 152 | ObjPtr<String> location, |
Christina Wadsworth | bf44e0e | 2016-08-18 10:37:42 -0700 | [diff] [blame] | 153 | StringDexCacheType* strings, |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 154 | uint32_t num_strings, |
Vladimir Marko | 0b66d61 | 2017-03-13 14:50:04 +0000 | [diff] [blame] | 155 | GcRoot<Class>* resolved_types, |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 156 | uint32_t num_resolved_types, |
| 157 | ArtMethod** resolved_methods, |
| 158 | uint32_t num_resolved_methods, |
Vladimir Marko | 6374c58 | 2017-03-13 14:51:19 +0000 | [diff] [blame] | 159 | ArtField** resolved_fields, |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 160 | uint32_t num_resolved_fields, |
Narayan Kamath | 25352fc | 2016-08-03 12:46:58 +0100 | [diff] [blame] | 161 | MethodTypeDexCacheType* resolved_method_types, |
| 162 | uint32_t num_resolved_method_types, |
Orion Hodson | c069a30 | 2017-01-18 09:23:12 +0000 | [diff] [blame] | 163 | GcRoot<CallSite>* resolved_call_sites, |
| 164 | uint32_t num_resolved_call_sites, |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 165 | PointerSize pointer_size) { |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 166 | CHECK(dex_file != nullptr); |
| 167 | CHECK(location != nullptr); |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 168 | CHECK_EQ(num_strings != 0u, strings != nullptr); |
| 169 | CHECK_EQ(num_resolved_types != 0u, resolved_types != nullptr); |
| 170 | CHECK_EQ(num_resolved_methods != 0u, resolved_methods != nullptr); |
| 171 | CHECK_EQ(num_resolved_fields != 0u, resolved_fields != nullptr); |
Narayan Kamath | 25352fc | 2016-08-03 12:46:58 +0100 | [diff] [blame] | 172 | CHECK_EQ(num_resolved_method_types != 0u, resolved_method_types != nullptr); |
Orion Hodson | c069a30 | 2017-01-18 09:23:12 +0000 | [diff] [blame] | 173 | CHECK_EQ(num_resolved_call_sites != 0u, resolved_call_sites != nullptr); |
Mathieu Chartier | 66f1925 | 2012-09-18 08:57:04 -0700 | [diff] [blame] | 174 | |
Mathieu Chartier | c785344 | 2015-03-27 14:35:38 -0700 | [diff] [blame] | 175 | SetDexFile(dex_file); |
Mathieu Chartier | 7617216 | 2016-01-26 14:54:06 -0800 | [diff] [blame] | 176 | SetLocation(location); |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 177 | SetStrings(strings); |
| 178 | SetResolvedTypes(resolved_types); |
| 179 | SetResolvedMethods(resolved_methods); |
| 180 | SetResolvedFields(resolved_fields); |
Narayan Kamath | 25352fc | 2016-08-03 12:46:58 +0100 | [diff] [blame] | 181 | SetResolvedMethodTypes(resolved_method_types); |
Orion Hodson | c069a30 | 2017-01-18 09:23:12 +0000 | [diff] [blame] | 182 | SetResolvedCallSites(resolved_call_sites); |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 183 | SetField32<false>(NumStringsOffset(), num_strings); |
| 184 | SetField32<false>(NumResolvedTypesOffset(), num_resolved_types); |
| 185 | SetField32<false>(NumResolvedMethodsOffset(), num_resolved_methods); |
| 186 | SetField32<false>(NumResolvedFieldsOffset(), num_resolved_fields); |
Narayan Kamath | 25352fc | 2016-08-03 12:46:58 +0100 | [diff] [blame] | 187 | SetField32<false>(NumResolvedMethodTypesOffset(), num_resolved_method_types); |
Orion Hodson | c069a30 | 2017-01-18 09:23:12 +0000 | [diff] [blame] | 188 | SetField32<false>(NumResolvedCallSitesOffset(), num_resolved_call_sites); |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 189 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 190 | Runtime* const runtime = Runtime::Current(); |
Ian Rogers | 1984651 | 2012-02-24 11:42:47 -0800 | [diff] [blame] | 191 | if (runtime->HasResolutionMethod()) { |
| 192 | // Initialize the resolve methods array to contain trampolines for resolution. |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 193 | Fixup(runtime->GetResolutionMethod(), pointer_size); |
Ian Rogers | 1984651 | 2012-02-24 11:42:47 -0800 | [diff] [blame] | 194 | } |
| 195 | } |
| 196 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 197 | void DexCache::Fixup(ArtMethod* trampoline, PointerSize pointer_size) { |
Ian Rogers | 1984651 | 2012-02-24 11:42:47 -0800 | [diff] [blame] | 198 | // Fixup the resolve methods array to contain trampoline for resolution. |
Ian Rogers | 5ddb410 | 2014-01-07 08:58:46 -0800 | [diff] [blame] | 199 | CHECK(trampoline != nullptr); |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 200 | CHECK(trampoline->IsRuntimeMethod()); |
| 201 | auto* resolved_methods = GetResolvedMethods(); |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 202 | for (size_t i = 0, length = NumResolvedMethods(); i < length; i++) { |
| 203 | if (GetElementPtrSize<ArtMethod*>(resolved_methods, i, pointer_size) == nullptr) { |
| 204 | SetElementPtrSize(resolved_methods, i, trampoline, pointer_size); |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 205 | } |
| 206 | } |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 207 | } |
| 208 | |
Mathieu Chartier | 28357fa | 2016-10-18 16:27:40 -0700 | [diff] [blame] | 209 | void DexCache::SetLocation(ObjPtr<mirror::String> location) { |
Mathieu Chartier | 7617216 | 2016-01-26 14:54:06 -0800 | [diff] [blame] | 210 | SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(DexCache, location_), location); |
| 211 | } |
| 212 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 213 | } // namespace mirror |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 214 | } // namespace art |