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 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 17 | #ifndef ART_RUNTIME_MIRROR_DEX_CACHE_H_ |
| 18 | #define ART_RUNTIME_MIRROR_DEX_CACHE_H_ |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 19 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 20 | #include "array.h" |
Andreas Gampe | 58a5af8 | 2014-07-31 16:23:49 -0700 | [diff] [blame] | 21 | #include "art_field.h" |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 22 | #include "art_method.h" |
Andreas Gampe | 58a5af8 | 2014-07-31 16:23:49 -0700 | [diff] [blame] | 23 | #include "class.h" |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 24 | #include "object.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 25 | #include "object_array.h" |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 26 | |
| 27 | namespace art { |
| 28 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 29 | struct DexCacheOffsets; |
| 30 | class DexFile; |
| 31 | class ImageWriter; |
| 32 | union JValue; |
| 33 | |
| 34 | namespace mirror { |
| 35 | |
Mingyao Yang | 98d1cc8 | 2014-05-15 17:02:16 -0700 | [diff] [blame] | 36 | class String; |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 37 | |
Christina Wadsworth | 9210ce9 | 2016-08-19 13:28:19 -0700 | [diff] [blame] | 38 | struct PACKED(8) StringDexCachePair { |
Christina Wadsworth | bf44e0e | 2016-08-18 10:37:42 -0700 | [diff] [blame] | 39 | GcRoot<String> string_pointer; |
| 40 | uint32_t string_index; |
| 41 | // The array is initially [ {0,0}, {0,0}, {0,0} ... ] |
| 42 | // We maintain the invariant that once a dex cache entry is populated, |
| 43 | // the pointer is always non-0 |
| 44 | // Any given entry would thus be: |
| 45 | // {non-0, non-0} OR {0,0} |
| 46 | // |
| 47 | // It's generally sufficiently enough then to check if the |
| 48 | // lookup string index matches the stored string index (for a >0 string index) |
| 49 | // because if it's true the pointer is also non-null. |
| 50 | // |
| 51 | // For the 0th entry which is a special case, the value is either |
| 52 | // {0,0} (initial state) or {non-0, 0} which indicates |
| 53 | // that a valid string is stored at that index for a dex string id of 0. |
| 54 | // |
| 55 | // As an optimization, we want to avoid branching on the string pointer since |
| 56 | // it's always non-null if the string id branch succeeds (except for the 0th string id). |
| 57 | // Set the initial state for the 0th entry to be {0,1} which is guaranteed to fail |
| 58 | // the lookup string id == stored id branch. |
| 59 | static void Initialize(StringDexCacheType* strings) { |
Christina Wadsworth | bf44e0e | 2016-08-18 10:37:42 -0700 | [diff] [blame] | 60 | mirror::StringDexCachePair first_elem; |
| 61 | first_elem.string_pointer = GcRoot<String>(nullptr); |
| 62 | first_elem.string_index = 1; |
| 63 | strings[0].store(first_elem, std::memory_order_relaxed); |
| 64 | } |
| 65 | static GcRoot<String> LookupString(StringDexCacheType* dex_cache, |
| 66 | uint32_t string_idx, |
| 67 | uint32_t cache_size) { |
| 68 | StringDexCachePair index_string = dex_cache[string_idx % cache_size] |
| 69 | .load(std::memory_order_relaxed); |
| 70 | if (string_idx != index_string.string_index) return GcRoot<String>(nullptr); |
| 71 | DCHECK(!index_string.string_pointer.IsNull()); |
| 72 | return index_string.string_pointer; |
| 73 | } |
| 74 | }; |
| 75 | using StringDexCacheType = std::atomic<StringDexCachePair>; |
| 76 | |
| 77 | |
Mingyao Yang | 98d1cc8 | 2014-05-15 17:02:16 -0700 | [diff] [blame] | 78 | // C++ mirror of java.lang.DexCache. |
| 79 | class MANAGED DexCache FINAL : public Object { |
Brian Carlstrom | 83db772 | 2011-08-26 17:32:56 -0700 | [diff] [blame] | 80 | public: |
Mingyao Yang | 98d1cc8 | 2014-05-15 17:02:16 -0700 | [diff] [blame] | 81 | // Size of java.lang.DexCache.class. |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 82 | static uint32_t ClassSize(PointerSize pointer_size); |
Mingyao Yang | 98d1cc8 | 2014-05-15 17:02:16 -0700 | [diff] [blame] | 83 | |
Christina Wadsworth | bf44e0e | 2016-08-18 10:37:42 -0700 | [diff] [blame] | 84 | // Size of string dex cache. Needs to be a power of 2 for entrypoint assumptions to hold. |
| 85 | static constexpr size_t kDexCacheStringCacheSize = 1024; |
| 86 | static_assert(IsPowerOfTwo(kDexCacheStringCacheSize), |
| 87 | "String dex cache size is not a power of 2."); |
| 88 | |
| 89 | static constexpr size_t StaticStringSize() { |
| 90 | return kDexCacheStringCacheSize; |
| 91 | } |
| 92 | |
Mingyao Yang | 98d1cc8 | 2014-05-15 17:02:16 -0700 | [diff] [blame] | 93 | // Size of an instance of java.lang.DexCache not including referenced values. |
| 94 | static constexpr uint32_t InstanceSize() { |
| 95 | return sizeof(DexCache); |
| 96 | } |
| 97 | |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 98 | void Init(const DexFile* dex_file, |
| 99 | String* location, |
Christina Wadsworth | bf44e0e | 2016-08-18 10:37:42 -0700 | [diff] [blame] | 100 | StringDexCacheType* strings, |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 101 | uint32_t num_strings, |
| 102 | GcRoot<Class>* resolved_types, |
| 103 | uint32_t num_resolved_types, |
| 104 | ArtMethod** resolved_methods, |
| 105 | uint32_t num_resolved_methods, |
| 106 | ArtField** resolved_fields, |
| 107 | uint32_t num_resolved_fields, |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 108 | PointerSize pointer_size) REQUIRES_SHARED(Locks::mutator_lock_); |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 109 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 110 | void Fixup(ArtMethod* trampoline, PointerSize pointer_size) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 111 | REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | 1984651 | 2012-02-24 11:42:47 -0800 | [diff] [blame] | 112 | |
Mathieu Chartier | 60bc39c | 2016-01-27 18:37:48 -0800 | [diff] [blame] | 113 | template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier, typename Visitor> |
Christina Wadsworth | bf44e0e | 2016-08-18 10:37:42 -0700 | [diff] [blame] | 114 | void FixupStrings(StringDexCacheType* dest, const Visitor& visitor) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 115 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mathieu Chartier | 4b00d34 | 2015-11-13 10:42:08 -0800 | [diff] [blame] | 116 | |
Mathieu Chartier | 60bc39c | 2016-01-27 18:37:48 -0800 | [diff] [blame] | 117 | template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier, typename Visitor> |
Mathieu Chartier | 4b00d34 | 2015-11-13 10:42:08 -0800 | [diff] [blame] | 118 | void FixupResolvedTypes(GcRoot<mirror::Class>* dest, const Visitor& visitor) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 119 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mathieu Chartier | 4b00d34 | 2015-11-13 10:42:08 -0800 | [diff] [blame] | 120 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 121 | String* GetLocation() REQUIRES_SHARED(Locks::mutator_lock_) { |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 122 | return GetFieldObject<String>(OFFSET_OF_OBJECT_MEMBER(DexCache, location_)); |
Brian Carlstrom | a663ea5 | 2011-08-19 23:33:41 -0700 | [diff] [blame] | 123 | } |
| 124 | |
Andreas Gampe | dd9d055 | 2015-03-09 12:57:41 -0700 | [diff] [blame] | 125 | static MemberOffset DexOffset() { |
| 126 | return OFFSET_OF_OBJECT_MEMBER(DexCache, dex_); |
| 127 | } |
| 128 | |
buzbee | 5cd2180 | 2011-08-26 10:40:14 -0700 | [diff] [blame] | 129 | static MemberOffset StringsOffset() { |
Mathieu Chartier | 66f1925 | 2012-09-18 08:57:04 -0700 | [diff] [blame] | 130 | return OFFSET_OF_OBJECT_MEMBER(DexCache, strings_); |
buzbee | c5ef046 | 2011-08-25 18:44:49 -0700 | [diff] [blame] | 131 | } |
| 132 | |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 133 | static MemberOffset ResolvedTypesOffset() { |
| 134 | return OFFSET_OF_OBJECT_MEMBER(DexCache, resolved_types_); |
| 135 | } |
| 136 | |
Brian Carlstrom | 1caa2c2 | 2011-08-28 13:02:33 -0700 | [diff] [blame] | 137 | static MemberOffset ResolvedFieldsOffset() { |
Mathieu Chartier | 66f1925 | 2012-09-18 08:57:04 -0700 | [diff] [blame] | 138 | return OFFSET_OF_OBJECT_MEMBER(DexCache, resolved_fields_); |
buzbee | c5ef046 | 2011-08-25 18:44:49 -0700 | [diff] [blame] | 139 | } |
| 140 | |
Brian Carlstrom | 1caa2c2 | 2011-08-28 13:02:33 -0700 | [diff] [blame] | 141 | static MemberOffset ResolvedMethodsOffset() { |
Mathieu Chartier | 66f1925 | 2012-09-18 08:57:04 -0700 | [diff] [blame] | 142 | return OFFSET_OF_OBJECT_MEMBER(DexCache, resolved_methods_); |
buzbee | c5ef046 | 2011-08-25 18:44:49 -0700 | [diff] [blame] | 143 | } |
| 144 | |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 145 | static MemberOffset NumStringsOffset() { |
| 146 | return OFFSET_OF_OBJECT_MEMBER(DexCache, num_strings_); |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 147 | } |
| 148 | |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 149 | static MemberOffset NumResolvedTypesOffset() { |
| 150 | return OFFSET_OF_OBJECT_MEMBER(DexCache, num_resolved_types_); |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 151 | } |
| 152 | |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 153 | static MemberOffset NumResolvedFieldsOffset() { |
| 154 | return OFFSET_OF_OBJECT_MEMBER(DexCache, num_resolved_fields_); |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 155 | } |
| 156 | |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 157 | static MemberOffset NumResolvedMethodsOffset() { |
| 158 | return OFFSET_OF_OBJECT_MEMBER(DexCache, num_resolved_methods_); |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 159 | } |
| 160 | |
Christina Wadsworth | bf44e0e | 2016-08-18 10:37:42 -0700 | [diff] [blame] | 161 | mirror::String* GetResolvedString(uint32_t string_idx) ALWAYS_INLINE |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 162 | REQUIRES_SHARED(Locks::mutator_lock_); |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 163 | |
Christina Wadsworth | bf44e0e | 2016-08-18 10:37:42 -0700 | [diff] [blame] | 164 | void SetResolvedString(uint32_t string_idx, mirror::String* resolved) ALWAYS_INLINE |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 165 | REQUIRES_SHARED(Locks::mutator_lock_); |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 166 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 167 | Class* GetResolvedType(uint32_t type_idx) REQUIRES_SHARED(Locks::mutator_lock_); |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 168 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 169 | void SetResolvedType(uint32_t type_idx, Class* resolved) REQUIRES_SHARED(Locks::mutator_lock_); |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 170 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 171 | ALWAYS_INLINE ArtMethod* GetResolvedMethod(uint32_t method_idx, PointerSize ptr_size) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 172 | REQUIRES_SHARED(Locks::mutator_lock_); |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 173 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 174 | ALWAYS_INLINE void SetResolvedMethod(uint32_t method_idx, |
| 175 | ArtMethod* resolved, |
| 176 | PointerSize ptr_size) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 177 | REQUIRES_SHARED(Locks::mutator_lock_); |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 178 | |
Mathieu Chartier | c785344 | 2015-03-27 14:35:38 -0700 | [diff] [blame] | 179 | // Pointer sized variant, used for patching. |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 180 | ALWAYS_INLINE ArtField* GetResolvedField(uint32_t idx, PointerSize ptr_size) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 181 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 182 | |
| 183 | // Pointer sized variant, used for patching. |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 184 | ALWAYS_INLINE void SetResolvedField(uint32_t idx, ArtField* field, PointerSize ptr_size) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 185 | REQUIRES_SHARED(Locks::mutator_lock_); |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 186 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 187 | StringDexCacheType* GetStrings() ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_) { |
Christina Wadsworth | bf44e0e | 2016-08-18 10:37:42 -0700 | [diff] [blame] | 188 | return GetFieldPtr64<StringDexCacheType*>(StringsOffset()); |
Brian Carlstrom | 1caa2c2 | 2011-08-28 13:02:33 -0700 | [diff] [blame] | 189 | } |
Brian Carlstrom | 83db772 | 2011-08-26 17:32:56 -0700 | [diff] [blame] | 190 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 191 | void SetStrings(StringDexCacheType* strings) ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_) { |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 192 | SetFieldPtr<false>(StringsOffset(), strings); |
| 193 | } |
| 194 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 195 | GcRoot<Class>* GetResolvedTypes() ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_) { |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 196 | return GetFieldPtr<GcRoot<Class>*>(ResolvedTypesOffset()); |
Mathieu Chartier | 66f1925 | 2012-09-18 08:57:04 -0700 | [diff] [blame] | 197 | } |
| 198 | |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 199 | void SetResolvedTypes(GcRoot<Class>* resolved_types) |
| 200 | ALWAYS_INLINE |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 201 | REQUIRES_SHARED(Locks::mutator_lock_) { |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 202 | SetFieldPtr<false>(ResolvedTypesOffset(), resolved_types); |
| 203 | } |
| 204 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 205 | ArtMethod** GetResolvedMethods() ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_) { |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 206 | return GetFieldPtr<ArtMethod**>(ResolvedMethodsOffset()); |
Mathieu Chartier | 66f1925 | 2012-09-18 08:57:04 -0700 | [diff] [blame] | 207 | } |
| 208 | |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 209 | void SetResolvedMethods(ArtMethod** resolved_methods) |
| 210 | ALWAYS_INLINE |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 211 | REQUIRES_SHARED(Locks::mutator_lock_) { |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 212 | SetFieldPtr<false>(ResolvedMethodsOffset(), resolved_methods); |
| 213 | } |
| 214 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 215 | ArtField** GetResolvedFields() ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_) { |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 216 | return GetFieldPtr<ArtField**>(ResolvedFieldsOffset()); |
| 217 | } |
| 218 | |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 219 | void SetResolvedFields(ArtField** resolved_fields) |
| 220 | ALWAYS_INLINE |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 221 | REQUIRES_SHARED(Locks::mutator_lock_) { |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 222 | SetFieldPtr<false>(ResolvedFieldsOffset(), resolved_fields); |
| 223 | } |
| 224 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 225 | size_t NumStrings() REQUIRES_SHARED(Locks::mutator_lock_) { |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 226 | return GetField32(NumStringsOffset()); |
| 227 | } |
| 228 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 229 | size_t NumResolvedTypes() REQUIRES_SHARED(Locks::mutator_lock_) { |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 230 | return GetField32(NumResolvedTypesOffset()); |
| 231 | } |
| 232 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 233 | size_t NumResolvedMethods() REQUIRES_SHARED(Locks::mutator_lock_) { |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 234 | return GetField32(NumResolvedMethodsOffset()); |
| 235 | } |
| 236 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 237 | size_t NumResolvedFields() REQUIRES_SHARED(Locks::mutator_lock_) { |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 238 | return GetField32(NumResolvedFieldsOffset()); |
Mathieu Chartier | 66f1925 | 2012-09-18 08:57:04 -0700 | [diff] [blame] | 239 | } |
| 240 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 241 | const DexFile* GetDexFile() ALWAYS_INLINE REQUIRES_SHARED(Locks::mutator_lock_) { |
Ian Rogers | b0fa5dc | 2014-04-28 16:47:08 -0700 | [diff] [blame] | 242 | return GetFieldPtr<const DexFile*>(OFFSET_OF_OBJECT_MEMBER(DexCache, dex_file_)); |
Mathieu Chartier | 66f1925 | 2012-09-18 08:57:04 -0700 | [diff] [blame] | 243 | } |
| 244 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 245 | void SetDexFile(const DexFile* dex_file) REQUIRES_SHARED(Locks::mutator_lock_) { |
Mathieu Chartier | 7617216 | 2016-01-26 14:54:06 -0800 | [diff] [blame] | 246 | SetFieldPtr<false>(OFFSET_OF_OBJECT_MEMBER(DexCache, dex_file_), dex_file); |
Brian Carlstrom | 4b620ff | 2011-09-11 01:11:01 -0700 | [diff] [blame] | 247 | } |
Brian Carlstrom | c4fa2c0 | 2011-08-21 03:00:12 -0700 | [diff] [blame] | 248 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 249 | void SetLocation(mirror::String* location) REQUIRES_SHARED(Locks::mutator_lock_); |
Mathieu Chartier | 7617216 | 2016-01-26 14:54:06 -0800 | [diff] [blame] | 250 | |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 251 | // NOTE: Get/SetElementPtrSize() are intended for working with ArtMethod** and ArtField** |
| 252 | // provided by GetResolvedMethods/Fields() and ArtMethod::GetDexCacheResolvedMethods(), |
| 253 | // so they need to be public. |
| 254 | |
| 255 | template <typename PtrType> |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 256 | static PtrType GetElementPtrSize(PtrType* ptr_array, size_t idx, PointerSize ptr_size); |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 257 | |
| 258 | template <typename PtrType> |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 259 | static void SetElementPtrSize(PtrType* ptr_array, size_t idx, PtrType ptr, PointerSize ptr_size); |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 260 | |
Brian Carlstrom | c4fa2c0 | 2011-08-21 03:00:12 -0700 | [diff] [blame] | 261 | private: |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 262 | // Visit instance fields of the dex cache as well as its associated arrays. |
Mathieu Chartier | fbc3108 | 2016-01-24 11:59:56 -0800 | [diff] [blame] | 263 | template <bool kVisitNativeRoots, |
| 264 | VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags, |
| 265 | ReadBarrierOption kReadBarrierOption = kWithReadBarrier, |
| 266 | typename Visitor> |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 267 | void VisitReferences(mirror::Class* klass, const Visitor& visitor) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame^] | 268 | REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(Locks::heap_bitmap_lock_); |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 269 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 270 | HeapReference<Object> dex_; |
| 271 | HeapReference<String> location_; |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 272 | uint64_t dex_file_; // const DexFile* |
| 273 | uint64_t resolved_fields_; // ArtField*, array with num_resolved_fields_ elements. |
| 274 | uint64_t resolved_methods_; // ArtMethod*, array with num_resolved_methods_ elements. |
| 275 | uint64_t resolved_types_; // GcRoot<Class>*, array with num_resolved_types_ elements. |
Christina Wadsworth | bf44e0e | 2016-08-18 10:37:42 -0700 | [diff] [blame] | 276 | uint64_t strings_; // std::atomic<StringDexCachePair>*, |
| 277 | // array with num_strings_ elements. |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 278 | uint32_t num_resolved_fields_; // Number of elements in the resolved_fields_ array. |
| 279 | uint32_t num_resolved_methods_; // Number of elements in the resolved_methods_ array. |
| 280 | uint32_t num_resolved_types_; // Number of elements in the resolved_types_ array. |
| 281 | uint32_t num_strings_; // Number of elements in the strings_ array. |
Brian Carlstrom | 83db772 | 2011-08-26 17:32:56 -0700 | [diff] [blame] | 282 | |
Brian Carlstrom | 7934ac2 | 2013-07-26 10:54:15 -0700 | [diff] [blame] | 283 | friend struct art::DexCacheOffsets; // for verifying offset information |
Vladimir Marko | 05792b9 | 2015-08-03 11:56:49 +0100 | [diff] [blame] | 284 | friend class Object; // For VisitReferences |
Brian Carlstrom | c4fa2c0 | 2011-08-21 03:00:12 -0700 | [diff] [blame] | 285 | DISALLOW_IMPLICIT_CONSTRUCTORS(DexCache); |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 286 | }; |
| 287 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 288 | } // namespace mirror |
Brian Carlstrom | 7e49dca | 2011-07-22 18:07:34 -0700 | [diff] [blame] | 289 | } // namespace art |
| 290 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 291 | #endif // ART_RUNTIME_MIRROR_DEX_CACHE_H_ |