art_method.h revision 4ef12f5b0e26c6016c87866f6a33da5ed8e98d74
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_METHOD_H_ 18#define ART_RUNTIME_MIRROR_ART_METHOD_H_ 19 20#include "dex_file.h" 21#include "gc_root.h" 22#include "invoke_type.h" 23#include "modifiers.h" 24#include "object.h" 25#include "object_callbacks.h" 26#include "quick/quick_method_frame_info.h" 27#include "read_barrier_option.h" 28 29namespace art { 30 31struct ArtMethodOffsets; 32struct ConstructorMethodOffsets; 33union JValue; 34class MethodHelper; 35class ScopedObjectAccessAlreadyRunnable; 36class StringPiece; 37class ShadowFrame; 38 39namespace mirror { 40 41typedef void (EntryPointFromInterpreter)(Thread* self, MethodHelper& mh, 42 const DexFile::CodeItem* code_item, ShadowFrame* shadow_frame, JValue* result); 43 44// C++ mirror of java.lang.reflect.ArtMethod. 45class MANAGED ArtMethod FINAL : public Object { 46 public: 47 // Size of java.lang.reflect.ArtMethod.class. 48 static uint32_t ClassSize(); 49 50 // Size of an instance of java.lang.reflect.ArtMethod not including its value array. 51 static constexpr uint32_t InstanceSize() { 52 return sizeof(ArtMethod); 53 } 54 55 static ArtMethod* FromReflectedMethod(const ScopedObjectAccessAlreadyRunnable& soa, 56 jobject jlr_method) 57 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 58 59 Class* GetDeclaringClass() ALWAYS_INLINE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 60 61 void SetDeclaringClass(Class *new_declaring_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 62 63 static MemberOffset DeclaringClassOffset() { 64 return MemberOffset(OFFSETOF_MEMBER(ArtMethod, declaring_class_)); 65 } 66 67 uint32_t GetAccessFlags() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 68 69 void SetAccessFlags(uint32_t new_access_flags) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 70 // Not called within a transaction. 71 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, access_flags_), new_access_flags); 72 } 73 74 // Approximate what kind of method call would be used for this method. 75 InvokeType GetInvokeType() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 76 77 // Returns true if the method is declared public. 78 bool IsPublic() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 79 return (GetAccessFlags() & kAccPublic) != 0; 80 } 81 82 // Returns true if the method is declared private. 83 bool IsPrivate() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 84 return (GetAccessFlags() & kAccPrivate) != 0; 85 } 86 87 // Returns true if the method is declared static. 88 bool IsStatic() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 89 return (GetAccessFlags() & kAccStatic) != 0; 90 } 91 92 // Returns true if the method is a constructor. 93 bool IsConstructor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 94 return (GetAccessFlags() & kAccConstructor) != 0; 95 } 96 97 // Returns true if the method is a class initializer. 98 bool IsClassInitializer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 99 return IsConstructor() && IsStatic(); 100 } 101 102 // Returns true if the method is static, private, or a constructor. 103 bool IsDirect() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 104 return IsDirect(GetAccessFlags()); 105 } 106 107 static bool IsDirect(uint32_t access_flags) { 108 return (access_flags & (kAccStatic | kAccPrivate | kAccConstructor)) != 0; 109 } 110 111 // Returns true if the method is declared synchronized. 112 bool IsSynchronized() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 113 uint32_t synchonized = kAccSynchronized | kAccDeclaredSynchronized; 114 return (GetAccessFlags() & synchonized) != 0; 115 } 116 117 bool IsFinal() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 118 return (GetAccessFlags() & kAccFinal) != 0; 119 } 120 121 bool IsMiranda() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 122 return (GetAccessFlags() & kAccMiranda) != 0; 123 } 124 125 bool IsNative() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 126 return (GetAccessFlags() & kAccNative) != 0; 127 } 128 129 bool IsFastNative() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 130 uint32_t mask = kAccFastNative | kAccNative; 131 return (GetAccessFlags() & mask) == mask; 132 } 133 134 bool IsAbstract() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 135 return (GetAccessFlags() & kAccAbstract) != 0; 136 } 137 138 bool IsSynthetic() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 139 return (GetAccessFlags() & kAccSynthetic) != 0; 140 } 141 142 bool IsProxyMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 143 144 bool IsPreverified() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 145 return (GetAccessFlags() & kAccPreverified) != 0; 146 } 147 148 void SetPreverified() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 149 DCHECK(!IsPreverified()); 150 SetAccessFlags(GetAccessFlags() | kAccPreverified); 151 } 152 153 bool IsPortableCompiled() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 154 return (GetAccessFlags() & kAccPortableCompiled) != 0; 155 } 156 157 void SetIsPortableCompiled() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 158 DCHECK(!IsPortableCompiled()); 159 SetAccessFlags(GetAccessFlags() | kAccPortableCompiled); 160 } 161 162 void ClearIsPortableCompiled() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 163 DCHECK(IsPortableCompiled()); 164 SetAccessFlags(GetAccessFlags() & ~kAccPortableCompiled); 165 } 166 167 bool CheckIncompatibleClassChange(InvokeType type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 168 169 uint16_t GetMethodIndex() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 170 171 size_t GetVtableIndex() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 172 return GetMethodIndex(); 173 } 174 175 void SetMethodIndex(uint16_t new_method_index) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 176 // Not called within a transaction. 177 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_), new_method_index); 178 } 179 180 static MemberOffset MethodIndexOffset() { 181 return OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_); 182 } 183 184 uint32_t GetCodeItemOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 185 return GetField32(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_code_item_offset_)); 186 } 187 188 void SetCodeItemOffset(uint32_t new_code_off) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 189 // Not called within a transaction. 190 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_code_item_offset_), new_code_off); 191 } 192 193 // Number of 32bit registers that would be required to hold all the arguments 194 static size_t NumArgRegisters(const StringPiece& shorty); 195 196 uint32_t GetDexMethodIndex() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 197 198 void SetDexMethodIndex(uint32_t new_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 199 // Not called within a transaction. 200 SetField32<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_method_index_), new_idx); 201 } 202 203 ObjectArray<String>* GetDexCacheStrings() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 204 void SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings) 205 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 206 207 static MemberOffset DexCacheStringsOffset() { 208 return OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_strings_); 209 } 210 211 static MemberOffset DexCacheResolvedMethodsOffset() { 212 return OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_methods_); 213 } 214 215 static MemberOffset DexCacheResolvedTypesOffset() { 216 return OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_types_); 217 } 218 219 ArtMethod* GetDexCacheResolvedMethod(uint16_t method_idx) 220 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 221 void SetDexCacheResolvedMethod(uint16_t method_idx, ArtMethod* new_method) 222 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 223 void SetDexCacheResolvedMethods(ObjectArray<ArtMethod>* new_dex_cache_methods) 224 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 225 bool HasDexCacheResolvedMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 226 bool HasSameDexCacheResolvedMethods(ArtMethod* other) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 227 bool HasSameDexCacheResolvedMethods(ObjectArray<ArtMethod>* other_cache) 228 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 229 230 template <bool kWithCheck = true> 231 Class* GetDexCacheResolvedType(uint32_t type_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 232 void SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_types) 233 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 234 bool HasDexCacheResolvedTypes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 235 bool HasSameDexCacheResolvedTypes(ArtMethod* other) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 236 bool HasSameDexCacheResolvedTypes(ObjectArray<Class>* other_cache) 237 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 238 239 // Find the method that this method overrides 240 ArtMethod* FindOverriddenMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 241 242 void Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result, const char* shorty) 243 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 244 245 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 246 EntryPointFromInterpreter* GetEntryPointFromInterpreter() 247 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 248 return GetFieldPtr<EntryPointFromInterpreter*, kVerifyFlags>( 249 OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_interpreter_)); 250 } 251 252 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 253 void SetEntryPointFromInterpreter(EntryPointFromInterpreter* entry_point_from_interpreter) 254 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 255 SetFieldPtr<false, true, kVerifyFlags>( 256 OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_interpreter_), 257 entry_point_from_interpreter); 258 } 259 260 static MemberOffset EntryPointFromPortableCompiledCodeOffset() { 261 return MemberOffset(OFFSETOF_MEMBER(ArtMethod, entry_point_from_portable_compiled_code_)); 262 } 263 264 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 265 const void* GetEntryPointFromPortableCompiledCode() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 266 return GetFieldPtr<const void*, kVerifyFlags>( 267 EntryPointFromPortableCompiledCodeOffset()); 268 } 269 270 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 271 void SetEntryPointFromPortableCompiledCode(const void* entry_point_from_portable_compiled_code) 272 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 273 SetFieldPtr<false, true, kVerifyFlags>( 274 EntryPointFromPortableCompiledCodeOffset(), entry_point_from_portable_compiled_code); 275 } 276 277 static MemberOffset EntryPointFromQuickCompiledCodeOffset() { 278 return MemberOffset(OFFSETOF_MEMBER(ArtMethod, entry_point_from_quick_compiled_code_)); 279 } 280 281 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 282 const void* GetEntryPointFromQuickCompiledCode() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 283 return GetFieldPtr<const void*, kVerifyFlags>(EntryPointFromQuickCompiledCodeOffset()); 284 } 285 286 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 287 void SetEntryPointFromQuickCompiledCode(const void* entry_point_from_quick_compiled_code) 288 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 289 SetFieldPtr<false, true, kVerifyFlags>( 290 EntryPointFromQuickCompiledCodeOffset(), entry_point_from_quick_compiled_code); 291 } 292 293 uint32_t GetCodeSize() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 294 295 bool IsWithinQuickCode(uintptr_t pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 296 uintptr_t code = reinterpret_cast<uintptr_t>(GetEntryPointFromQuickCompiledCode()); 297 if (code == 0) { 298 return pc == 0; 299 } 300 /* 301 * During a stack walk, a return PC may point past-the-end of the code 302 * in the case that the last instruction is a call that isn't expected to 303 * return. Thus, we check <= code + GetCodeSize(). 304 * 305 * NOTE: For Thumb both pc and code are offset by 1 indicating the Thumb state. 306 */ 307 return code <= pc && pc <= code + GetCodeSize(); 308 } 309 310 void AssertPcIsWithinQuickCode(uintptr_t pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 311 312 uint32_t GetQuickOatCodeOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 313 uint32_t GetPortableOatCodeOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 314 void SetQuickOatCodeOffset(uint32_t code_offset) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 315 void SetPortableOatCodeOffset(uint32_t code_offset) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 316 317 static const void* EntryPointToCodePointer(const void* entry_point) ALWAYS_INLINE { 318 uintptr_t code = reinterpret_cast<uintptr_t>(entry_point); 319 code &= ~0x1; // TODO: Make this Thumb2 specific. 320 return reinterpret_cast<const void*>(code); 321 } 322 323 // Actual entry point pointer to compiled oat code or nullptr. 324 const void* GetQuickOatEntryPoint() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 325 // Actual pointer to compiled oat code or nullptr. 326 const void* GetQuickOatCodePointer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 327 328 // Callers should wrap the uint8_t* in a MappingTable instance for convenient access. 329 const uint8_t* GetMappingTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 330 const uint8_t* GetMappingTable(const void* code_pointer) 331 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 332 333 // Callers should wrap the uint8_t* in a VmapTable instance for convenient access. 334 const uint8_t* GetVmapTable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 335 const uint8_t* GetVmapTable(const void* code_pointer) 336 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 337 338 const uint8_t* GetNativeGcMap() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 339 return GetFieldPtr<uint8_t*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, gc_map_)); 340 } 341 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 342 void SetNativeGcMap(const uint8_t* data) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 343 SetFieldPtr<false, true, kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, gc_map_), data); 344 } 345 346 // When building the oat need a convenient place to stuff the offset of the native GC map. 347 void SetOatNativeGcMapOffset(uint32_t gc_map_offset) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 348 uint32_t GetOatNativeGcMapOffset() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 349 350 template <bool kCheckFrameSize = true> 351 uint32_t GetFrameSizeInBytes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 352 uint32_t result = GetQuickFrameInfo().FrameSizeInBytes(); 353 if (kCheckFrameSize) { 354 DCHECK_LE(static_cast<size_t>(kStackAlignment), result); 355 } 356 return result; 357 } 358 359 QuickMethodFrameInfo GetQuickFrameInfo() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 360 QuickMethodFrameInfo GetQuickFrameInfo(const void* code_pointer) 361 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 362 363 size_t GetReturnPcOffsetInBytes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 364 return GetReturnPcOffsetInBytes(GetFrameSizeInBytes()); 365 } 366 367 size_t GetReturnPcOffsetInBytes(uint32_t frame_size_in_bytes) 368 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 369 DCHECK_EQ(frame_size_in_bytes, GetFrameSizeInBytes()); 370 return frame_size_in_bytes - kPointerSize; 371 } 372 373 size_t GetHandleScopeOffsetInBytes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 374 return kPointerSize; 375 } 376 377 void RegisterNative(Thread* self, const void* native_method, bool is_fast) 378 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 379 380 void UnregisterNative(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 381 382 static MemberOffset NativeMethodOffset() { 383 return OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_jni_); 384 } 385 386 const void* GetNativeMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 387 return GetFieldPtr<const void*>(NativeMethodOffset()); 388 } 389 390 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags> 391 void SetNativeMethod(const void*) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 392 393 static MemberOffset GetMethodIndexOffset() { 394 return OFFSET_OF_OBJECT_MEMBER(ArtMethod, method_index_); 395 } 396 397 // Is this a CalleSaveMethod or ResolutionMethod and therefore doesn't adhere to normal 398 // conventions for a method of managed code. Returns false for Proxy methods. 399 bool IsRuntimeMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 400 401 // Is this a hand crafted method used for something like describing callee saves? 402 bool IsCalleeSaveMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 403 404 bool IsResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 405 406 bool IsImtConflictMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 407 408 uintptr_t NativePcOffset(const uintptr_t pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 409 uintptr_t NativePcOffset(const uintptr_t pc, const void* quick_entry_point) 410 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 411 412 // Converts a native PC to a dex PC. 413 uint32_t ToDexPc(const uintptr_t pc, bool abort_on_failure = true) 414 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 415 416 // Converts a dex PC to a native PC. 417 uintptr_t ToNativePc(const uint32_t dex_pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 418 419 // Find the catch block for the given exception type and dex_pc. When a catch block is found, 420 // indicates whether the found catch block is responsible for clearing the exception or whether 421 // a move-exception instruction is present. 422 static uint32_t FindCatchBlock(Handle<ArtMethod> h_this, Handle<Class> exception_type, 423 uint32_t dex_pc, bool* has_no_move_exception) 424 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 425 426 static void SetClass(Class* java_lang_reflect_ArtMethod); 427 428 template<ReadBarrierOption kReadBarrierOption = kWithReadBarrier> 429 static Class* GetJavaLangReflectArtMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 430 431 static void ResetClass(); 432 433 static void VisitRoots(RootCallback* callback, void* arg) 434 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 435 436 const DexFile* GetDexFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 437 438 const char* GetDeclaringClassDescriptor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 439 440 const char* GetShorty() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 441 uint32_t unused_length; 442 return GetShorty(&unused_length); 443 } 444 445 const char* GetShorty(uint32_t* out_length) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 446 447 const Signature GetSignature() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 448 449 const char* GetName() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 450 451 const DexFile::CodeItem* GetCodeItem() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 452 453 bool IsResolvedTypeIdx(uint16_t type_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 454 455 int32_t GetLineNumFromDexPC(uint32_t dex_pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 456 457 const DexFile::ProtoId& GetPrototype() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 458 459 const DexFile::TypeList* GetParameterTypeList() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 460 461 const char* GetDeclaringClassSourceFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 462 463 uint16_t GetClassDefIndex() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 464 465 const DexFile::ClassDef& GetClassDef() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 466 467 const char* GetReturnTypeDescriptor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 468 469 const char* GetTypeDescriptorFromTypeIdx(uint16_t type_idx) 470 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 471 472 mirror::ClassLoader* GetClassLoader() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 473 474 mirror::DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 475 476 ArtMethod* GetInterfaceMethodIfProxy() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 477 478 protected: 479 // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses". 480 // The class we are a part of. 481 HeapReference<Class> declaring_class_; 482 483 // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access. 484 HeapReference<ObjectArray<ArtMethod>> dex_cache_resolved_methods_; 485 486 // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access. 487 HeapReference<ObjectArray<Class>> dex_cache_resolved_types_; 488 489 // Short cuts to declaring_class_->dex_cache_ member for fast compiled code access. 490 HeapReference<ObjectArray<String>> dex_cache_strings_; 491 492 // Method dispatch from the interpreter invokes this pointer which may cause a bridge into 493 // compiled code. 494 uint64_t entry_point_from_interpreter_; 495 496 // Pointer to JNI function registered to this method, or a function to resolve the JNI function. 497 uint64_t entry_point_from_jni_; 498 499 // Method dispatch from portable compiled code invokes this pointer which may cause bridging into 500 // quick compiled code or the interpreter. 501 uint64_t entry_point_from_portable_compiled_code_; 502 503 // Method dispatch from quick compiled code invokes this pointer which may cause bridging into 504 // portable compiled code or the interpreter. 505 uint64_t entry_point_from_quick_compiled_code_; 506 507 // Pointer to a data structure created by the compiler and used by the garbage collector to 508 // determine which registers hold live references to objects within the heap. Keyed by native PC 509 // offsets for the quick compiler and dex PCs for the portable. 510 uint64_t gc_map_; 511 512 // Access flags; low 16 bits are defined by spec. 513 uint32_t access_flags_; 514 515 /* Dex file fields. The defining dex file is available via declaring_class_->dex_cache_ */ 516 517 // Offset to the CodeItem. 518 uint32_t dex_code_item_offset_; 519 520 // Index into method_ids of the dex file associated with this method. 521 uint32_t dex_method_index_; 522 523 /* End of dex file fields. */ 524 525 // Entry within a dispatch table for this method. For static/direct methods the index is into 526 // the declaringClass.directMethods, for virtual methods the vtable and for interface methods the 527 // ifTable. 528 uint32_t method_index_; 529 530 static GcRoot<Class> java_lang_reflect_ArtMethod_; 531 532 private: 533 ObjectArray<ArtMethod>* GetDexCacheResolvedMethods() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 534 535 ObjectArray<Class>* GetDexCacheResolvedTypes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 536 537 friend struct art::ArtMethodOffsets; // for verifying offset information 538 DISALLOW_IMPLICIT_CONSTRUCTORS(ArtMethod); 539}; 540 541} // namespace mirror 542} // namespace art 543 544#endif // ART_RUNTIME_MIRROR_ART_METHOD_H_ 545