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_MIRROR_ART_FIELD_INL_H_ 18 #define ART_RUNTIME_MIRROR_ART_FIELD_INL_H_ 19 20 #include "art_field.h" 21 22 #include "base/logging.h" 23 #include "dex_cache.h" 24 #include "gc/accounting/card_table-inl.h" 25 #include "jvalue.h" 26 #include "object-inl.h" 27 #include "primitive.h" 28 #include "scoped_thread_state_change.h" 29 #include "well_known_classes.h" 30 31 namespace art { 32 namespace mirror { 33 34 inline uint32_t ArtField::ClassSize() { 35 uint32_t vtable_entries = Object::kVTableLength + 6; 36 return Class::ComputeClassSize(true, vtable_entries, 0, 0, 0); 37 } 38 39 inline Class* ArtField::GetDeclaringClass() { 40 Class* result = GetFieldObject<Class>(OFFSET_OF_OBJECT_MEMBER(ArtField, declaring_class_)); 41 DCHECK(result != NULL); 42 DCHECK(result->IsLoaded() || result->IsErroneous()); 43 return result; 44 } 45 46 inline void ArtField::SetDeclaringClass(Class *new_declaring_class) { 47 SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(ArtField, declaring_class_), new_declaring_class); 48 } 49 50 inline uint32_t ArtField::GetAccessFlags() { 51 DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous()); 52 return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtField, access_flags_)); 53 } 54 55 inline MemberOffset ArtField::GetOffset() { 56 DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous()); 57 return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(ArtField, offset_))); 58 } 59 60 inline MemberOffset ArtField::GetOffsetDuringLinking() { 61 DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous()); 62 return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(ArtField, offset_))); 63 } 64 65 inline uint32_t ArtField::Get32(Object* object) { 66 DCHECK(object != nullptr) << PrettyField(this); 67 DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted()); 68 if (UNLIKELY(IsVolatile())) { 69 return object->GetField32Volatile(GetOffset()); 70 } 71 return object->GetField32(GetOffset()); 72 } 73 74 template<bool kTransactionActive> 75 inline void ArtField::Set32(Object* object, uint32_t new_value) { 76 DCHECK(object != nullptr) << PrettyField(this); 77 DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted()); 78 if (UNLIKELY(IsVolatile())) { 79 object->SetField32Volatile<kTransactionActive>(GetOffset(), new_value); 80 } else { 81 object->SetField32<kTransactionActive>(GetOffset(), new_value); 82 } 83 } 84 85 inline uint64_t ArtField::Get64(Object* object) { 86 DCHECK(object != NULL) << PrettyField(this); 87 DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted()); 88 if (UNLIKELY(IsVolatile())) { 89 return object->GetField64Volatile(GetOffset()); 90 } 91 return object->GetField64(GetOffset()); 92 } 93 94 template<bool kTransactionActive> 95 inline void ArtField::Set64(Object* object, uint64_t new_value) { 96 DCHECK(object != NULL) << PrettyField(this); 97 DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted()); 98 if (UNLIKELY(IsVolatile())) { 99 object->SetField64Volatile<kTransactionActive>(GetOffset(), new_value); 100 } else { 101 object->SetField64<kTransactionActive>(GetOffset(), new_value); 102 } 103 } 104 105 inline Object* ArtField::GetObj(Object* object) { 106 DCHECK(object != NULL) << PrettyField(this); 107 DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted()); 108 if (UNLIKELY(IsVolatile())) { 109 return object->GetFieldObjectVolatile<Object>(GetOffset()); 110 } 111 return object->GetFieldObject<Object>(GetOffset()); 112 } 113 114 template<bool kTransactionActive> 115 inline void ArtField::SetObj(Object* object, Object* new_value) { 116 DCHECK(object != NULL) << PrettyField(this); 117 DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted()); 118 if (UNLIKELY(IsVolatile())) { 119 object->SetFieldObjectVolatile<kTransactionActive>(GetOffset(), new_value); 120 } else { 121 object->SetFieldObject<kTransactionActive>(GetOffset(), new_value); 122 } 123 } 124 125 inline bool ArtField::GetBoolean(Object* object) { 126 DCHECK_EQ(Primitive::kPrimBoolean, GetTypeAsPrimitiveType()) << PrettyField(this); 127 return Get32(object); 128 } 129 130 template<bool kTransactionActive> 131 inline void ArtField::SetBoolean(Object* object, bool z) { 132 DCHECK_EQ(Primitive::kPrimBoolean, GetTypeAsPrimitiveType()) << PrettyField(this); 133 Set32<kTransactionActive>(object, z); 134 } 135 136 inline int8_t ArtField::GetByte(Object* object) { 137 DCHECK_EQ(Primitive::kPrimByte, GetTypeAsPrimitiveType()) << PrettyField(this); 138 return Get32(object); 139 } 140 141 template<bool kTransactionActive> 142 inline void ArtField::SetByte(Object* object, int8_t b) { 143 DCHECK_EQ(Primitive::kPrimByte, GetTypeAsPrimitiveType()) << PrettyField(this); 144 Set32<kTransactionActive>(object, b); 145 } 146 147 inline uint16_t ArtField::GetChar(Object* object) { 148 DCHECK_EQ(Primitive::kPrimChar, GetTypeAsPrimitiveType()) << PrettyField(this); 149 return Get32(object); 150 } 151 152 template<bool kTransactionActive> 153 inline void ArtField::SetChar(Object* object, uint16_t c) { 154 DCHECK_EQ(Primitive::kPrimChar, GetTypeAsPrimitiveType()) << PrettyField(this); 155 Set32<kTransactionActive>(object, c); 156 } 157 158 inline int16_t ArtField::GetShort(Object* object) { 159 DCHECK_EQ(Primitive::kPrimShort, GetTypeAsPrimitiveType()) << PrettyField(this); 160 return Get32(object); 161 } 162 163 template<bool kTransactionActive> 164 inline void ArtField::SetShort(Object* object, int16_t s) { 165 DCHECK_EQ(Primitive::kPrimShort, GetTypeAsPrimitiveType()) << PrettyField(this); 166 Set32<kTransactionActive>(object, s); 167 } 168 169 inline int32_t ArtField::GetInt(Object* object) { 170 if (kIsDebugBuild) { 171 Primitive::Type type = GetTypeAsPrimitiveType(); 172 CHECK(type == Primitive::kPrimInt || type == Primitive::kPrimFloat) << PrettyField(this); 173 } 174 return Get32(object); 175 } 176 177 template<bool kTransactionActive> 178 inline void ArtField::SetInt(Object* object, int32_t i) { 179 if (kIsDebugBuild) { 180 Primitive::Type type = GetTypeAsPrimitiveType(); 181 CHECK(type == Primitive::kPrimInt || type == Primitive::kPrimFloat) << PrettyField(this); 182 } 183 Set32<kTransactionActive>(object, i); 184 } 185 186 inline int64_t ArtField::GetLong(Object* object) { 187 if (kIsDebugBuild) { 188 Primitive::Type type = GetTypeAsPrimitiveType(); 189 CHECK(type == Primitive::kPrimLong || type == Primitive::kPrimDouble) << PrettyField(this); 190 } 191 return Get64(object); 192 } 193 194 template<bool kTransactionActive> 195 inline void ArtField::SetLong(Object* object, int64_t j) { 196 if (kIsDebugBuild) { 197 Primitive::Type type = GetTypeAsPrimitiveType(); 198 CHECK(type == Primitive::kPrimLong || type == Primitive::kPrimDouble) << PrettyField(this); 199 } 200 Set64<kTransactionActive>(object, j); 201 } 202 203 inline float ArtField::GetFloat(Object* object) { 204 DCHECK_EQ(Primitive::kPrimFloat, GetTypeAsPrimitiveType()) << PrettyField(this); 205 JValue bits; 206 bits.SetI(Get32(object)); 207 return bits.GetF(); 208 } 209 210 template<bool kTransactionActive> 211 inline void ArtField::SetFloat(Object* object, float f) { 212 DCHECK_EQ(Primitive::kPrimFloat, GetTypeAsPrimitiveType()) << PrettyField(this); 213 JValue bits; 214 bits.SetF(f); 215 Set32<kTransactionActive>(object, bits.GetI()); 216 } 217 218 inline double ArtField::GetDouble(Object* object) { 219 DCHECK_EQ(Primitive::kPrimDouble, GetTypeAsPrimitiveType()) << PrettyField(this); 220 JValue bits; 221 bits.SetJ(Get64(object)); 222 return bits.GetD(); 223 } 224 225 template<bool kTransactionActive> 226 inline void ArtField::SetDouble(Object* object, double d) { 227 DCHECK_EQ(Primitive::kPrimDouble, GetTypeAsPrimitiveType()) << PrettyField(this); 228 JValue bits; 229 bits.SetD(d); 230 Set64<kTransactionActive>(object, bits.GetJ()); 231 } 232 233 inline Object* ArtField::GetObject(Object* object) { 234 DCHECK_EQ(Primitive::kPrimNot, GetTypeAsPrimitiveType()) << PrettyField(this); 235 return GetObj(object); 236 } 237 238 template<bool kTransactionActive> 239 inline void ArtField::SetObject(Object* object, Object* l) { 240 DCHECK_EQ(Primitive::kPrimNot, GetTypeAsPrimitiveType()) << PrettyField(this); 241 SetObj<kTransactionActive>(object, l); 242 } 243 244 inline const char* ArtField::GetName() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 245 uint32_t field_index = GetDexFieldIndex(); 246 if (UNLIKELY(GetDeclaringClass()->IsProxyClass())) { 247 DCHECK(IsStatic()); 248 DCHECK_LT(field_index, 2U); 249 return field_index == 0 ? "interfaces" : "throws"; 250 } 251 const DexFile* dex_file = GetDexFile(); 252 return dex_file->GetFieldName(dex_file->GetFieldId(field_index)); 253 } 254 255 inline const char* ArtField::GetTypeDescriptor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 256 uint32_t field_index = GetDexFieldIndex(); 257 if (UNLIKELY(GetDeclaringClass()->IsProxyClass())) { 258 DCHECK(IsStatic()); 259 DCHECK_LT(field_index, 2U); 260 // 0 == Class[] interfaces; 1 == Class[][] throws; 261 return field_index == 0 ? "[Ljava/lang/Class;" : "[[Ljava/lang/Class;"; 262 } 263 const DexFile* dex_file = GetDexFile(); 264 const DexFile::FieldId& field_id = dex_file->GetFieldId(field_index); 265 return dex_file->GetFieldTypeDescriptor(field_id); 266 } 267 268 inline Primitive::Type ArtField::GetTypeAsPrimitiveType() 269 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 270 return Primitive::GetType(GetTypeDescriptor()[0]); 271 } 272 273 inline bool ArtField::IsPrimitiveType() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 274 return GetTypeAsPrimitiveType() != Primitive::kPrimNot; 275 } 276 277 inline size_t ArtField::FieldSize() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 278 return Primitive::FieldSize(GetTypeAsPrimitiveType()); 279 } 280 281 inline mirror::DexCache* ArtField::GetDexCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 282 return GetDeclaringClass()->GetDexCache(); 283 } 284 285 inline const DexFile* ArtField::GetDexFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 286 return GetDexCache()->GetDexFile(); 287 } 288 289 inline ArtField* ArtField::FromReflectedField(const ScopedObjectAccessAlreadyRunnable& soa, 290 jobject jlr_field) { 291 mirror::ArtField* f = soa.DecodeField(WellKnownClasses::java_lang_reflect_Field_artField); 292 mirror::ArtField* field = f->GetObject(soa.Decode<mirror::Object*>(jlr_field))->AsArtField(); 293 DCHECK(field != nullptr); 294 return field; 295 } 296 297 } // namespace mirror 298 } // namespace art 299 300 #endif // ART_RUNTIME_MIRROR_ART_FIELD_INL_H_ 301