1 /* 2 * Copyright (C) 2015 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_MIRROR_FIELD_H_ 18 #define ART_RUNTIME_MIRROR_FIELD_H_ 19 20 #include "accessible_object.h" 21 #include "base/enums.h" 22 #include "gc_root.h" 23 #include "obj_ptr.h" 24 #include "object.h" 25 #include "object_callbacks.h" 26 #include "read_barrier_option.h" 27 28 namespace art { 29 30 class ArtField; 31 struct FieldOffsets; 32 33 namespace mirror { 34 35 class Class; 36 class String; 37 38 // C++ mirror of java.lang.reflect.Field. 39 class MANAGED Field : public AccessibleObject { 40 public: StaticClass()41 static mirror::Class* StaticClass() REQUIRES_SHARED(Locks::mutator_lock_) { 42 return static_class_.Read(); 43 } 44 ArrayClass()45 static mirror::Class* ArrayClass() REQUIRES_SHARED(Locks::mutator_lock_) { 46 return array_class_.Read(); 47 } 48 GetDexFieldIndex()49 ALWAYS_INLINE uint32_t GetDexFieldIndex() REQUIRES_SHARED(Locks::mutator_lock_) { 50 return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, dex_field_index_)); 51 } 52 GetDeclaringClass()53 mirror::Class* GetDeclaringClass() REQUIRES_SHARED(Locks::mutator_lock_) { 54 return GetFieldObject<Class>(OFFSET_OF_OBJECT_MEMBER(Field, declaring_class_)); 55 } 56 GetAccessFlags()57 uint32_t GetAccessFlags() REQUIRES_SHARED(Locks::mutator_lock_) { 58 return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, access_flags_)); 59 } 60 IsStatic()61 bool IsStatic() REQUIRES_SHARED(Locks::mutator_lock_) { 62 return (GetAccessFlags() & kAccStatic) != 0; 63 } 64 IsFinal()65 bool IsFinal() REQUIRES_SHARED(Locks::mutator_lock_) { 66 return (GetAccessFlags() & kAccFinal) != 0; 67 } 68 IsVolatile()69 bool IsVolatile() REQUIRES_SHARED(Locks::mutator_lock_) { 70 return (GetAccessFlags() & kAccVolatile) != 0; 71 } 72 GetTypeAsPrimitiveType()73 ALWAYS_INLINE Primitive::Type GetTypeAsPrimitiveType() 74 REQUIRES_SHARED(Locks::mutator_lock_) { 75 return GetType()->GetPrimitiveType(); 76 } 77 GetType()78 mirror::Class* GetType() REQUIRES_SHARED(Locks::mutator_lock_) { 79 return GetFieldObject<mirror::Class>(OFFSET_OF_OBJECT_MEMBER(Field, type_)); 80 } 81 GetOffset()82 int32_t GetOffset() REQUIRES_SHARED(Locks::mutator_lock_) { 83 return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_)); 84 } 85 86 static void SetClass(ObjPtr<Class> klass) REQUIRES_SHARED(Locks::mutator_lock_); 87 static void ResetClass() REQUIRES_SHARED(Locks::mutator_lock_); 88 89 static void SetArrayClass(ObjPtr<Class> klass) REQUIRES_SHARED(Locks::mutator_lock_); 90 static void ResetArrayClass() REQUIRES_SHARED(Locks::mutator_lock_); 91 92 static void VisitRoots(RootVisitor* visitor) REQUIRES_SHARED(Locks::mutator_lock_); 93 94 // Slow, try to use only for PrettyField and such. 95 ArtField* GetArtField() REQUIRES_SHARED(Locks::mutator_lock_); 96 97 template <PointerSize kPointerSize, bool kTransactionActive = false> 98 static mirror::Field* CreateFromArtField(Thread* self, ArtField* field, 99 bool force_resolve) 100 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); 101 102 private: 103 // Padding required for matching alignment with the Java peer. 104 uint8_t padding_[2]; 105 106 HeapReference<mirror::Class> declaring_class_; 107 HeapReference<mirror::Class> type_; 108 int32_t access_flags_; 109 int32_t dex_field_index_; 110 int32_t offset_; 111 112 template<bool kTransactionActive> 113 void SetDeclaringClass(ObjPtr<mirror::Class> c) REQUIRES_SHARED(Locks::mutator_lock_); 114 115 template<bool kTransactionActive> 116 void SetType(ObjPtr<mirror::Class> type) REQUIRES_SHARED(Locks::mutator_lock_); 117 118 template<bool kTransactionActive> SetAccessFlags(uint32_t flags)119 void SetAccessFlags(uint32_t flags) REQUIRES_SHARED(Locks::mutator_lock_) { 120 SetField32<kTransactionActive>(OFFSET_OF_OBJECT_MEMBER(Field, access_flags_), flags); 121 } 122 123 template<bool kTransactionActive> SetDexFieldIndex(uint32_t idx)124 void SetDexFieldIndex(uint32_t idx) REQUIRES_SHARED(Locks::mutator_lock_) { 125 SetField32<kTransactionActive>(OFFSET_OF_OBJECT_MEMBER(Field, dex_field_index_), idx); 126 } 127 128 template<bool kTransactionActive> SetOffset(uint32_t offset)129 void SetOffset(uint32_t offset) REQUIRES_SHARED(Locks::mutator_lock_) { 130 SetField32<kTransactionActive>(OFFSET_OF_OBJECT_MEMBER(Field, offset_), offset); 131 } 132 133 static GcRoot<Class> static_class_; // java.lang.reflect.Field.class. 134 static GcRoot<Class> array_class_; // array of java.lang.reflect.Field. 135 136 friend struct art::FieldOffsets; // for verifying offset information 137 DISALLOW_IMPLICIT_CONSTRUCTORS(Field); 138 }; 139 140 } // namespace mirror 141 } // namespace art 142 143 #endif // ART_RUNTIME_MIRROR_FIELD_H_ 144