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