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_ART_FIELD_H_ 18 #define ART_RUNTIME_ART_FIELD_H_ 19 20 #include "dex/modifiers.h" 21 #include "dex/primitive.h" 22 #include "gc_root.h" 23 #include "obj_ptr.h" 24 #include "offsets.h" 25 #include "read_barrier_option.h" 26 27 namespace art { 28 29 class DexFile; 30 class ScopedObjectAccessAlreadyRunnable; 31 32 namespace mirror { 33 class Class; 34 class ClassLoader; 35 class DexCache; 36 class Object; 37 class String; 38 } // namespace mirror 39 40 class ArtField final { 41 public: 42 template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 43 ObjPtr<mirror::Class> GetDeclaringClass() REQUIRES_SHARED(Locks::mutator_lock_); 44 45 ObjPtr<mirror::ClassLoader> GetClassLoader() REQUIRES_SHARED(Locks::mutator_lock_); 46 47 void SetDeclaringClass(ObjPtr<mirror::Class> new_declaring_class) 48 REQUIRES_SHARED(Locks::mutator_lock_); 49 GetDeclaringClassAddressWithoutBarrier()50 mirror::CompressedReference<mirror::Object>* GetDeclaringClassAddressWithoutBarrier() { 51 return declaring_class_.AddressWithoutBarrier(); 52 } 53 GetAccessFlags()54 uint32_t GetAccessFlags() { 55 return access_flags_; 56 } 57 SetAccessFlags(uint32_t new_access_flags)58 void SetAccessFlags(uint32_t new_access_flags) { 59 // Not called within a transaction. 60 access_flags_ = new_access_flags; 61 } 62 IsPublic()63 bool IsPublic() { 64 return (GetAccessFlags() & kAccPublic) != 0; 65 } 66 IsStatic()67 bool IsStatic() { 68 return (GetAccessFlags() & kAccStatic) != 0; 69 } 70 IsFinal()71 bool IsFinal() { 72 return (GetAccessFlags() & kAccFinal) != 0; 73 } 74 IsPrivate()75 bool IsPrivate() { 76 return (GetAccessFlags() & kAccPrivate) != 0; 77 } 78 GetDexFieldIndex()79 uint32_t GetDexFieldIndex() { 80 return field_dex_idx_; 81 } 82 SetDexFieldIndex(uint32_t new_idx)83 void SetDexFieldIndex(uint32_t new_idx) { 84 // Not called within a transaction. 85 field_dex_idx_ = new_idx; 86 } 87 88 // Offset to field within an Object. GetOffset()89 MemberOffset GetOffset() { 90 return MemberOffset(offset_); 91 } 92 OffsetOffset()93 static constexpr MemberOffset OffsetOffset() { 94 return MemberOffset(OFFSETOF_MEMBER(ArtField, offset_)); 95 } 96 DeclaringClassOffset()97 static constexpr MemberOffset DeclaringClassOffset() { 98 return MemberOffset(OFFSETOF_MEMBER(ArtField, declaring_class_)); 99 } 100 101 MemberOffset GetOffsetDuringLinking() REQUIRES_SHARED(Locks::mutator_lock_); 102 103 void SetOffset(MemberOffset num_bytes) REQUIRES_SHARED(Locks::mutator_lock_); 104 105 // field access, null object for static fields 106 uint8_t GetBoolean(ObjPtr<mirror::Object> object) REQUIRES_SHARED(Locks::mutator_lock_); 107 108 template<bool kTransactionActive> 109 void SetBoolean(ObjPtr<mirror::Object> object, uint8_t z) REQUIRES_SHARED(Locks::mutator_lock_); 110 111 int8_t GetByte(ObjPtr<mirror::Object> object) REQUIRES_SHARED(Locks::mutator_lock_); 112 113 template<bool kTransactionActive> 114 void SetByte(ObjPtr<mirror::Object> object, int8_t b) REQUIRES_SHARED(Locks::mutator_lock_); 115 116 uint16_t GetChar(ObjPtr<mirror::Object> object) REQUIRES_SHARED(Locks::mutator_lock_); 117 118 template<bool kTransactionActive> 119 void SetChar(ObjPtr<mirror::Object> object, uint16_t c) REQUIRES_SHARED(Locks::mutator_lock_); 120 121 int16_t GetShort(ObjPtr<mirror::Object> object) REQUIRES_SHARED(Locks::mutator_lock_); 122 123 template<bool kTransactionActive> 124 void SetShort(ObjPtr<mirror::Object> object, int16_t s) REQUIRES_SHARED(Locks::mutator_lock_); 125 126 int32_t GetInt(ObjPtr<mirror::Object> object) REQUIRES_SHARED(Locks::mutator_lock_); 127 128 template<bool kTransactionActive> 129 void SetInt(ObjPtr<mirror::Object> object, int32_t i) REQUIRES_SHARED(Locks::mutator_lock_); 130 131 int64_t GetLong(ObjPtr<mirror::Object> object) REQUIRES_SHARED(Locks::mutator_lock_); 132 133 template<bool kTransactionActive> 134 void SetLong(ObjPtr<mirror::Object> object, int64_t j) REQUIRES_SHARED(Locks::mutator_lock_); 135 136 float GetFloat(ObjPtr<mirror::Object> object) REQUIRES_SHARED(Locks::mutator_lock_); 137 138 template<bool kTransactionActive> 139 void SetFloat(ObjPtr<mirror::Object> object, float f) REQUIRES_SHARED(Locks::mutator_lock_); 140 141 double GetDouble(ObjPtr<mirror::Object> object) REQUIRES_SHARED(Locks::mutator_lock_); 142 143 template<bool kTransactionActive> 144 void SetDouble(ObjPtr<mirror::Object> object, double d) REQUIRES_SHARED(Locks::mutator_lock_); 145 146 template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 147 ObjPtr<mirror::Object> GetObject(ObjPtr<mirror::Object> object) 148 REQUIRES_SHARED(Locks::mutator_lock_); 149 150 template<bool kTransactionActive> 151 void SetObject(ObjPtr<mirror::Object> object, ObjPtr<mirror::Object> l) 152 REQUIRES_SHARED(Locks::mutator_lock_); 153 154 // Raw field accesses. 155 uint32_t Get32(ObjPtr<mirror::Object> object) REQUIRES_SHARED(Locks::mutator_lock_); 156 157 template<bool kTransactionActive> 158 void Set32(ObjPtr<mirror::Object> object, uint32_t new_value) 159 REQUIRES_SHARED(Locks::mutator_lock_); 160 161 uint64_t Get64(ObjPtr<mirror::Object> object) REQUIRES_SHARED(Locks::mutator_lock_); 162 163 template<bool kTransactionActive> 164 void Set64(ObjPtr<mirror::Object> object, uint64_t new_value) 165 REQUIRES_SHARED(Locks::mutator_lock_); 166 167 template<class MirrorType = mirror::Object, 168 ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 169 ObjPtr<MirrorType> GetObj(ObjPtr<mirror::Object> object) 170 REQUIRES_SHARED(Locks::mutator_lock_); 171 172 template<bool kTransactionActive> 173 void SetObj(ObjPtr<mirror::Object> object, ObjPtr<mirror::Object> new_value) 174 REQUIRES_SHARED(Locks::mutator_lock_); 175 176 // NO_THREAD_SAFETY_ANALYSIS since we don't know what the callback requires. 177 template<typename RootVisitorType> VisitRoots(RootVisitorType & visitor)178 ALWAYS_INLINE inline void VisitRoots(RootVisitorType& visitor) NO_THREAD_SAFETY_ANALYSIS { 179 visitor.VisitRoot(declaring_class_.AddressWithoutBarrier()); 180 } 181 IsVolatile()182 bool IsVolatile() { 183 return (GetAccessFlags() & kAccVolatile) != 0; 184 } 185 186 // Returns an instance field with this offset in the given class or null if not found. 187 // If kExactOffset is true then we only find the matching offset, not the field containing the 188 // offset. 189 template <bool kExactOffset = true> 190 static ArtField* FindInstanceFieldWithOffset(ObjPtr<mirror::Class> klass, uint32_t field_offset) 191 REQUIRES_SHARED(Locks::mutator_lock_); 192 193 // Returns a static field with this offset in the given class or null if not found. 194 // If kExactOffset is true then we only find the matching offset, not the field containing the 195 // offset. 196 template <bool kExactOffset = true> 197 static ArtField* FindStaticFieldWithOffset(ObjPtr<mirror::Class> klass, uint32_t field_offset) 198 REQUIRES_SHARED(Locks::mutator_lock_); 199 200 const char* GetName() REQUIRES_SHARED(Locks::mutator_lock_); 201 202 // Resolves / returns the name from the dex cache. 203 ObjPtr<mirror::String> ResolveNameString() REQUIRES_SHARED(Locks::mutator_lock_); 204 205 const char* GetTypeDescriptor() REQUIRES_SHARED(Locks::mutator_lock_); 206 207 Primitive::Type GetTypeAsPrimitiveType() REQUIRES_SHARED(Locks::mutator_lock_); 208 209 bool IsPrimitiveType() REQUIRES_SHARED(Locks::mutator_lock_); 210 211 ObjPtr<mirror::Class> LookupResolvedType() REQUIRES_SHARED(Locks::mutator_lock_); 212 ObjPtr<mirror::Class> ResolveType() REQUIRES_SHARED(Locks::mutator_lock_); 213 214 size_t FieldSize() REQUIRES_SHARED(Locks::mutator_lock_); 215 216 template <ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 217 ObjPtr<mirror::DexCache> GetDexCache() REQUIRES_SHARED(Locks::mutator_lock_); 218 219 const DexFile* GetDexFile() REQUIRES_SHARED(Locks::mutator_lock_); 220 DeclaringClassRoot()221 GcRoot<mirror::Class>& DeclaringClassRoot() { 222 return declaring_class_; 223 } 224 225 // Returns a human-readable signature. Something like "a.b.C.f" or 226 // "int a.b.C.f" (depending on the value of 'with_type'). 227 static std::string PrettyField(ArtField* f, bool with_type = true) 228 REQUIRES_SHARED(Locks::mutator_lock_); 229 std::string PrettyField(bool with_type = true) 230 REQUIRES_SHARED(Locks::mutator_lock_); 231 232 // Returns true if a set-* instruction in the given method is allowable. 233 ALWAYS_INLINE inline bool CanBeChangedBy(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_); 234 235 private: 236 bool IsProxyField() REQUIRES_SHARED(Locks::mutator_lock_); 237 238 ObjPtr<mirror::Class> ProxyFindSystemClass(const char* descriptor) 239 REQUIRES_SHARED(Locks::mutator_lock_); 240 241 GcRoot<mirror::Class> declaring_class_; 242 243 uint32_t access_flags_ = 0; 244 245 // Dex cache index of field id 246 uint32_t field_dex_idx_ = 0; 247 248 // Offset of field within an instance or in the Class' static fields 249 uint32_t offset_ = 0; 250 }; 251 252 } // namespace art 253 254 #endif // ART_RUNTIME_ART_FIELD_H_ 255