runtime/mirror/art_method.cc - platform/art - Gitiles

 /*
  * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "art_method.h"

 #include "art_method-inl.h"
 #include "base/stringpiece.h"
 #include "class-inl.h"
 #include "dex_file-inl.h"
 #include "dex_instruction.h"
 #include "gc/accounting/card_table-inl.h"
 #include "interpreter/interpreter.h"
 #include "jni_internal.h"
 #include "mapping_table.h"
 #include "object-inl.h"
 #include "object_array.h"
 #include "object_array-inl.h"
 #include "string.h"
 #include "object_utils.h"

 namespace art {
 namespace mirror {

 extern "C" void art_portable_invoke_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*, char);
 extern "C" void art_quick_invoke_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*,
                                       const char*);
 #ifdef __x86_64__
 extern "C" void art_quick_invoke_static_stub(ArtMethod*, uint32_t*, uint32_t, Thread*, JValue*,
                                              const char*);
 #endif

 // TODO: get global references for these
 Class* ArtMethod::java_lang_reflect_ArtMethod_ = NULL;

 void ArtMethod::VisitRoots(RootCallback* callback, void* arg) {
   if (java_lang_reflect_ArtMethod_ != nullptr) {
     callback(reinterpret_cast<mirror::Object**>(&java_lang_reflect_ArtMethod_), arg, 0,
              kRootStickyClass);
   }
 }

 InvokeType ArtMethod::GetInvokeType() {
   // TODO: kSuper?
   if (GetDeclaringClass()->IsInterface()) {
     return kInterface;
   } else if (IsStatic()) {
     return kStatic;
   } else if (IsDirect()) {
     return kDirect;
   } else {
     return kVirtual;
   }
 }

 void ArtMethod::SetClass(Class* java_lang_reflect_ArtMethod) {
   CHECK(java_lang_reflect_ArtMethod_ == NULL);
   CHECK(java_lang_reflect_ArtMethod != NULL);
   java_lang_reflect_ArtMethod_ = java_lang_reflect_ArtMethod;
 }

 void ArtMethod::ResetClass() {
   CHECK(java_lang_reflect_ArtMethod_ != NULL);
   java_lang_reflect_ArtMethod_ = NULL;
 }

 void ArtMethod::SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings) {
   SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_strings_),
                         new_dex_cache_strings, false);
 }

 void ArtMethod::SetDexCacheResolvedMethods(ObjectArray<ArtMethod>* new_dex_cache_methods) {
   SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_methods_),
                         new_dex_cache_methods, false);
 }

 void ArtMethod::SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_classes) {
   SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_types_),
                         new_dex_cache_classes, false);
 }

 size_t ArtMethod::NumArgRegisters(const StringPiece& shorty) {
   CHECK_LE(1, shorty.length());
   uint32_t num_registers = 0;
   for (int i = 1; i < shorty.length(); ++i) {
     char ch = shorty[i];
     if (ch == 'D' || ch == 'J') {
       num_registers += 2;
     } else {
       num_registers += 1;
     }
   }
   return num_registers;
 }

 bool ArtMethod::IsProxyMethod() {
   return GetDeclaringClass()->IsProxyClass();
 }

 ArtMethod* ArtMethod::FindOverriddenMethod() {
   if (IsStatic()) {
     return NULL;
   }
   Class* declaring_class = GetDeclaringClass();
   Class* super_class = declaring_class->GetSuperClass();
   uint16_t method_index = GetMethodIndex();
   ObjectArray<ArtMethod>* super_class_vtable = super_class->GetVTable();
   ArtMethod* result = NULL;
   // Did this method override a super class method? If so load the result from the super class'
   // vtable
   if (super_class_vtable != NULL && method_index < super_class_vtable->GetLength()) {
     result = super_class_vtable->Get(method_index);
   } else {
     // Method didn't override superclass method so search interfaces
     if (IsProxyMethod()) {
       result = GetDexCacheResolvedMethods()->Get(GetDexMethodIndex());
       CHECK_EQ(result,
                Runtime::Current()->GetClassLinker()->FindMethodForProxy(GetDeclaringClass(), this));
     } else {
       MethodHelper mh(this);
       MethodHelper interface_mh;
       IfTable* iftable = GetDeclaringClass()->GetIfTable();
       for (size_t i = 0; i < iftable->Count() && result == NULL; i++) {
         Class* interface = iftable->GetInterface(i);
         for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
           ArtMethod* interface_method = interface->GetVirtualMethod(j);
           interface_mh.ChangeMethod(interface_method);
           if (mh.HasSameNameAndSignature(&interface_mh)) {
             result = interface_method;
             break;
           }
         }
       }
     }
   }
 #ifndef NDEBUG
   MethodHelper result_mh(result);
   DCHECK(result == NULL || MethodHelper(this).HasSameNameAndSignature(&result_mh));
 #endif
   return result;
 }

 uintptr_t ArtMethod::NativePcOffset(const uintptr_t pc) {
   const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
   return pc - reinterpret_cast<uintptr_t>(code);
 }

 uint32_t ArtMethod::ToDexPc(const uintptr_t pc, bool abort_on_failure) {
   if (IsPortableCompiled()) {
     // Portable doesn't use the machine pc, we just use dex pc instead.
     return static_cast<uint32_t>(pc);
   }
   MappingTable table(GetMappingTable());
   if (table.TotalSize() == 0) {
     DCHECK(IsNative() || IsCalleeSaveMethod() || IsProxyMethod()) << PrettyMethod(this);
     return DexFile::kDexNoIndex;   // Special no mapping case
   }
   const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
   uint32_t sought_offset = pc - reinterpret_cast<uintptr_t>(code);
   // Assume the caller wants a pc-to-dex mapping so check here first.
   typedef MappingTable::PcToDexIterator It;
   for (It cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
     if (cur.NativePcOffset() == sought_offset) {
       return cur.DexPc();
     }
   }
   // Now check dex-to-pc mappings.
   typedef MappingTable::DexToPcIterator It2;
   for (It2 cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
     if (cur.NativePcOffset() == sought_offset) {
       return cur.DexPc();
     }
   }
   if (abort_on_failure) {
       LOG(FATAL) << "Failed to find Dex offset for PC offset " << reinterpret_cast<void*>(sought_offset)
              << "(PC " << reinterpret_cast<void*>(pc) << ", code=" << code
              << ") in " << PrettyMethod(this);
   }
   return DexFile::kDexNoIndex;
 }

 uintptr_t ArtMethod::ToNativePc(const uint32_t dex_pc) {
   MappingTable table(GetMappingTable());
   if (table.TotalSize() == 0) {
     DCHECK_EQ(dex_pc, 0U);
     return 0;   // Special no mapping/pc == 0 case
   }
   // Assume the caller wants a dex-to-pc mapping so check here first.
   typedef MappingTable::DexToPcIterator It;
   for (It cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
     if (cur.DexPc() == dex_pc) {
       const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
       return reinterpret_cast<uintptr_t>(code) + cur.NativePcOffset();
     }
   }
   // Now check pc-to-dex mappings.
   typedef MappingTable::PcToDexIterator It2;
   for (It2 cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
     if (cur.DexPc() == dex_pc) {
       const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
       return reinterpret_cast<uintptr_t>(code) + cur.NativePcOffset();
     }
   }
   LOG(FATAL) << "Failed to find native offset for dex pc 0x" << std::hex << dex_pc
              << " in " << PrettyMethod(this);
   return 0;
 }

 uint32_t ArtMethod::FindCatchBlock(Class* exception_type, uint32_t dex_pc,
                                    bool* has_no_move_exception) {
   MethodHelper mh(this);
   const DexFile::CodeItem* code_item = mh.GetCodeItem();
   // Default to handler not found.
   uint32_t found_dex_pc = DexFile::kDexNoIndex;
   // Iterate over the catch handlers associated with dex_pc.
   for (CatchHandlerIterator it(*code_item, dex_pc); it.HasNext(); it.Next()) {
     uint16_t iter_type_idx = it.GetHandlerTypeIndex();
     // Catch all case
     if (iter_type_idx == DexFile::kDexNoIndex16) {
       found_dex_pc = it.GetHandlerAddress();
       break;
     }
     // Does this catch exception type apply?
     Class* iter_exception_type = mh.GetDexCacheResolvedType(iter_type_idx);
     if (iter_exception_type == NULL) {
       // The verifier should take care of resolving all exception classes early
       LOG(WARNING) << "Unresolved exception class when finding catch block: "
         << mh.GetTypeDescriptorFromTypeIdx(iter_type_idx);
     } else if (iter_exception_type->IsAssignableFrom(exception_type)) {
       found_dex_pc = it.GetHandlerAddress();
       break;
     }
   }
   if (found_dex_pc != DexFile::kDexNoIndex) {
     const Instruction* first_catch_instr =
         Instruction::At(&mh.GetCodeItem()->insns_[found_dex_pc]);
     *has_no_move_exception = (first_catch_instr->Opcode() != Instruction::MOVE_EXCEPTION);
   }
   return found_dex_pc;
 }

 void ArtMethod::Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result,
                        const char* shorty) {
   if (kIsDebugBuild) {
     self->AssertThreadSuspensionIsAllowable();
     CHECK_EQ(kRunnable, self->GetState());
     CHECK_STREQ(MethodHelper(this).GetShorty(), shorty);
   }

   // Push a transition back into managed code onto the linked list in thread.
   ManagedStack fragment;
   self->PushManagedStackFragment(&fragment);

   Runtime* runtime = Runtime::Current();
   // Call the invoke stub, passing everything as arguments.
   if (UNLIKELY(!runtime->IsStarted())) {
     LOG(INFO) << "Not invoking " << PrettyMethod(this) << " for a runtime that isn't started";
     if (result != NULL) {
       result->SetJ(0);
     }
   } else {
     const bool kLogInvocationStartAndReturn = false;
     bool have_quick_code = GetEntryPointFromQuickCompiledCode() != nullptr;
     bool have_portable_code = GetEntryPointFromPortableCompiledCode() != nullptr;
     if (LIKELY(have_quick_code || have_portable_code)) {
       if (kLogInvocationStartAndReturn) {
         LOG(INFO) << StringPrintf("Invoking '%s' %s code=%p", PrettyMethod(this).c_str(),
                                   have_quick_code ? "quick" : "portable",
                                   have_quick_code ? GetEntryPointFromQuickCompiledCode()
                                                   : GetEntryPointFromPortableCompiledCode());
       }
       if (!IsPortableCompiled()) {
 #ifdef __x86_64__
         if (!IsStatic()) {
           (*art_quick_invoke_stub)(this, args, args_size, self, result, shorty);
         } else {
           (*art_quick_invoke_static_stub)(this, args, args_size, self, result, shorty);
         }
 #else
         (*art_quick_invoke_stub)(this, args, args_size, self, result, shorty);
 #endif
       } else {
         (*art_portable_invoke_stub)(this, args, args_size, self, result, shorty[0]);
       }
       if (UNLIKELY(reinterpret_cast<intptr_t>(self->GetException(NULL)) == -1)) {
         // Unusual case where we were running LLVM generated code and an
         // exception was thrown to force the activations to be removed from the
         // stack. Continue execution in the interpreter.
         self->ClearException();
         ShadowFrame* shadow_frame = self->GetAndClearDeoptimizationShadowFrame(result);
         self->SetTopOfStack(NULL, 0);
         self->SetTopOfShadowStack(shadow_frame);
         interpreter::EnterInterpreterFromDeoptimize(self, shadow_frame, result);
       }
       if (kLogInvocationStartAndReturn) {
         LOG(INFO) << StringPrintf("Returned '%s' %s code=%p", PrettyMethod(this).c_str(),
                                   have_quick_code ? "quick" : "portable",
                                   have_quick_code ? GetEntryPointFromQuickCompiledCode()
                                                   : GetEntryPointFromPortableCompiledCode());
       }
     } else {
       LOG(INFO) << "Not invoking '" << PrettyMethod(this) << "' code=null";
       if (result != NULL) {
         result->SetJ(0);
       }
     }
   }

   // Pop transition.
   self->PopManagedStackFragment(fragment);
 }

 bool ArtMethod::IsRegistered() {
   void* native_method =
       GetFieldPtr<void*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_jni_), false);
   CHECK(native_method != nullptr);
   void* jni_stub = GetJniDlsymLookupStub();
   return native_method != jni_stub;
 }

 extern "C" void art_work_around_app_jni_bugs(JNIEnv*, jobject);
 void ArtMethod::RegisterNative(Thread* self, const void* native_method, bool is_fast) {
   DCHECK(Thread::Current() == self);
   CHECK(IsNative()) << PrettyMethod(this);
   CHECK(!IsFastNative()) << PrettyMethod(this);
   CHECK(native_method != NULL) << PrettyMethod(this);
   if (!self->GetJniEnv()->vm->work_around_app_jni_bugs) {
     if (is_fast) {
       SetAccessFlags(GetAccessFlags() | kAccFastNative);
     }
     SetNativeMethod(native_method);
   } else {
     // We've been asked to associate this method with the given native method but are working
     // around JNI bugs, that include not giving Object** SIRT references to native methods. Direct
     // the native method to runtime support and store the target somewhere runtime support will
     // find it.
 #if defined(__i386__) || defined(__x86_64__)
     UNIMPLEMENTED(FATAL);
 #else
     SetNativeMethod(reinterpret_cast<void*>(art_work_around_app_jni_bugs));
 #endif
     SetFieldPtr<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, gc_map_),
                        reinterpret_cast<const uint8_t*>(native_method), false);
   }
 }

 void ArtMethod::UnregisterNative(Thread* self) {
   CHECK(IsNative() && !IsFastNative()) << PrettyMethod(this);
   // restore stub to lookup native pointer via dlsym
   RegisterNative(self, GetJniDlsymLookupStub(), false);
 }

 }  // namespace mirror
 }  // namespace art
	/*
	* Copyright (C) 2011 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "art_method.h"

	#include "art_method-inl.h"
	#include "base/stringpiece.h"
	#include "class-inl.h"
	#include "dex_file-inl.h"
	#include "dex_instruction.h"
	#include "gc/accounting/card_table-inl.h"
	#include "interpreter/interpreter.h"
	#include "jni_internal.h"
	#include "mapping_table.h"
	#include "object-inl.h"
	#include "object_array.h"
	#include "object_array-inl.h"
	#include "string.h"
	#include "object_utils.h"

	namespace art {
	namespace mirror {

	extern "C" void art_portable_invoke_stub(ArtMethod, uint32_t, uint32_t, Thread, JValue, char);
	extern "C" void art_quick_invoke_stub(ArtMethod, uint32_t, uint32_t, Thread, JValue,
	const char*);
	#ifdef __x86_64__
	extern "C" void art_quick_invoke_static_stub(ArtMethod, uint32_t, uint32_t, Thread, JValue,
	const char*);
	#endif

	// TODO: get global references for these
	Class* ArtMethod::java_lang_reflect_ArtMethod_ = NULL;

	void ArtMethod::VisitRoots(RootCallback* callback, void* arg) {
	if (java_lang_reflect_ArtMethod_ != nullptr) {
	callback(reinterpret_cast<mirror::Object**>(&java_lang_reflect_ArtMethod_), arg, 0,
	kRootStickyClass);
	}
	}

	InvokeType ArtMethod::GetInvokeType() {
	// TODO: kSuper?
	if (GetDeclaringClass()->IsInterface()) {
	return kInterface;
	} else if (IsStatic()) {
	return kStatic;
	} else if (IsDirect()) {
	return kDirect;
	} else {
	return kVirtual;
	}
	}

	void ArtMethod::SetClass(Class* java_lang_reflect_ArtMethod) {
	CHECK(java_lang_reflect_ArtMethod_ == NULL);
	CHECK(java_lang_reflect_ArtMethod != NULL);
	java_lang_reflect_ArtMethod_ = java_lang_reflect_ArtMethod;
	}

	void ArtMethod::ResetClass() {
	CHECK(java_lang_reflect_ArtMethod_ != NULL);
	java_lang_reflect_ArtMethod_ = NULL;
	}

	void ArtMethod::SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings) {
	SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_strings_),
	new_dex_cache_strings, false);
	}

	void ArtMethod::SetDexCacheResolvedMethods(ObjectArray<ArtMethod>* new_dex_cache_methods) {
	SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_methods_),
	new_dex_cache_methods, false);
	}

	void ArtMethod::SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_classes) {
	SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, dex_cache_resolved_types_),
	new_dex_cache_classes, false);
	}

	size_t ArtMethod::NumArgRegisters(const StringPiece& shorty) {
	CHECK_LE(1, shorty.length());
	uint32_t num_registers = 0;
	for (int i = 1; i < shorty.length(); ++i) {
	char ch = shorty[i];
	if (ch == 'D' \|\| ch == 'J') {
	num_registers += 2;
	} else {
	num_registers += 1;
	}
	}
	return num_registers;
	}

	bool ArtMethod::IsProxyMethod() {
	return GetDeclaringClass()->IsProxyClass();
	}

	ArtMethod* ArtMethod::FindOverriddenMethod() {
	if (IsStatic()) {
	return NULL;
	}
	Class* declaring_class = GetDeclaringClass();
	Class* super_class = declaring_class->GetSuperClass();
	uint16_t method_index = GetMethodIndex();
	ObjectArray<ArtMethod>* super_class_vtable = super_class->GetVTable();
	ArtMethod* result = NULL;
	// Did this method override a super class method? If so load the result from the super class'
	// vtable
	if (super_class_vtable != NULL && method_index < super_class_vtable->GetLength()) {
	result = super_class_vtable->Get(method_index);
	} else {
	// Method didn't override superclass method so search interfaces
	if (IsProxyMethod()) {
	result = GetDexCacheResolvedMethods()->Get(GetDexMethodIndex());
	CHECK_EQ(result,
	Runtime::Current()->GetClassLinker()->FindMethodForProxy(GetDeclaringClass(), this));
	} else {
	MethodHelper mh(this);
	MethodHelper interface_mh;
	IfTable* iftable = GetDeclaringClass()->GetIfTable();
	for (size_t i = 0; i < iftable->Count() && result == NULL; i++) {
	Class* interface = iftable->GetInterface(i);
	for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
	ArtMethod* interface_method = interface->GetVirtualMethod(j);
	interface_mh.ChangeMethod(interface_method);
	if (mh.HasSameNameAndSignature(&interface_mh)) {
	result = interface_method;
	break;
	}
	}
	}
	}
	}
	#ifndef NDEBUG
	MethodHelper result_mh(result);
	DCHECK(result == NULL \|\| MethodHelper(this).HasSameNameAndSignature(&result_mh));
	#endif
	return result;
	}

	uintptr_t ArtMethod::NativePcOffset(const uintptr_t pc) {
	const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
	return pc - reinterpret_cast<uintptr_t>(code);
	}

	uint32_t ArtMethod::ToDexPc(const uintptr_t pc, bool abort_on_failure) {
	if (IsPortableCompiled()) {
	// Portable doesn't use the machine pc, we just use dex pc instead.
	return static_cast<uint32_t>(pc);
	}
	MappingTable table(GetMappingTable());
	if (table.TotalSize() == 0) {
	DCHECK(IsNative() \|\| IsCalleeSaveMethod() \|\| IsProxyMethod()) << PrettyMethod(this);
	return DexFile::kDexNoIndex; // Special no mapping case
	}
	const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
	uint32_t sought_offset = pc - reinterpret_cast<uintptr_t>(code);
	// Assume the caller wants a pc-to-dex mapping so check here first.
	typedef MappingTable::PcToDexIterator It;
	for (It cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
	if (cur.NativePcOffset() == sought_offset) {
	return cur.DexPc();
	}
	}
	// Now check dex-to-pc mappings.
	typedef MappingTable::DexToPcIterator It2;
	for (It2 cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
	if (cur.NativePcOffset() == sought_offset) {
	return cur.DexPc();
	}
	}
	if (abort_on_failure) {
	LOG(FATAL) << "Failed to find Dex offset for PC offset " << reinterpret_cast<void*>(sought_offset)
	<< "(PC " << reinterpret_cast<void*>(pc) << ", code=" << code
	<< ") in " << PrettyMethod(this);
	}
	return DexFile::kDexNoIndex;
	}

	uintptr_t ArtMethod::ToNativePc(const uint32_t dex_pc) {
	MappingTable table(GetMappingTable());
	if (table.TotalSize() == 0) {
	DCHECK_EQ(dex_pc, 0U);
	return 0; // Special no mapping/pc == 0 case
	}
	// Assume the caller wants a dex-to-pc mapping so check here first.
	typedef MappingTable::DexToPcIterator It;
	for (It cur = table.DexToPcBegin(), end = table.DexToPcEnd(); cur != end; ++cur) {
	if (cur.DexPc() == dex_pc) {
	const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
	return reinterpret_cast<uintptr_t>(code) + cur.NativePcOffset();
	}
	}
	// Now check pc-to-dex mappings.
	typedef MappingTable::PcToDexIterator It2;
	for (It2 cur = table.PcToDexBegin(), end = table.PcToDexEnd(); cur != end; ++cur) {
	if (cur.DexPc() == dex_pc) {
	const void* code = Runtime::Current()->GetInstrumentation()->GetQuickCodeFor(this);
	return reinterpret_cast<uintptr_t>(code) + cur.NativePcOffset();
	}
	}
	LOG(FATAL) << "Failed to find native offset for dex pc 0x" << std::hex << dex_pc
	<< " in " << PrettyMethod(this);
	return 0;
	}

	uint32_t ArtMethod::FindCatchBlock(Class* exception_type, uint32_t dex_pc,
	bool* has_no_move_exception) {
	MethodHelper mh(this);
	const DexFile::CodeItem* code_item = mh.GetCodeItem();
	// Default to handler not found.
	uint32_t found_dex_pc = DexFile::kDexNoIndex;
	// Iterate over the catch handlers associated with dex_pc.
	for (CatchHandlerIterator it(*code_item, dex_pc); it.HasNext(); it.Next()) {
	uint16_t iter_type_idx = it.GetHandlerTypeIndex();
	// Catch all case
	if (iter_type_idx == DexFile::kDexNoIndex16) {
	found_dex_pc = it.GetHandlerAddress();
	break;
	}
	// Does this catch exception type apply?
	Class* iter_exception_type = mh.GetDexCacheResolvedType(iter_type_idx);
	if (iter_exception_type == NULL) {
	// The verifier should take care of resolving all exception classes early
	LOG(WARNING) << "Unresolved exception class when finding catch block: "
	<< mh.GetTypeDescriptorFromTypeIdx(iter_type_idx);
	} else if (iter_exception_type->IsAssignableFrom(exception_type)) {
	found_dex_pc = it.GetHandlerAddress();
	break;
	}
	}
	if (found_dex_pc != DexFile::kDexNoIndex) {
	const Instruction* first_catch_instr =
	Instruction::At(&mh.GetCodeItem()->insns_[found_dex_pc]);
	*has_no_move_exception = (first_catch_instr->Opcode() != Instruction::MOVE_EXCEPTION);
	}
	return found_dex_pc;
	}

	void ArtMethod::Invoke(Thread* self, uint32_t* args, uint32_t args_size, JValue* result,
	const char* shorty) {
	if (kIsDebugBuild) {
	self->AssertThreadSuspensionIsAllowable();
	CHECK_EQ(kRunnable, self->GetState());
	CHECK_STREQ(MethodHelper(this).GetShorty(), shorty);
	}

	// Push a transition back into managed code onto the linked list in thread.
	ManagedStack fragment;
	self->PushManagedStackFragment(&fragment);

	Runtime* runtime = Runtime::Current();
	// Call the invoke stub, passing everything as arguments.
	if (UNLIKELY(!runtime->IsStarted())) {
	LOG(INFO) << "Not invoking " << PrettyMethod(this) << " for a runtime that isn't started";
	if (result != NULL) {
	result->SetJ(0);
	}
	} else {
	const bool kLogInvocationStartAndReturn = false;
	bool have_quick_code = GetEntryPointFromQuickCompiledCode() != nullptr;
	bool have_portable_code = GetEntryPointFromPortableCompiledCode() != nullptr;
	if (LIKELY(have_quick_code \|\| have_portable_code)) {
	if (kLogInvocationStartAndReturn) {
	LOG(INFO) << StringPrintf("Invoking '%s' %s code=%p", PrettyMethod(this).c_str(),
	have_quick_code ? "quick" : "portable",
	have_quick_code ? GetEntryPointFromQuickCompiledCode()
	: GetEntryPointFromPortableCompiledCode());
	}
	if (!IsPortableCompiled()) {
	#ifdef __x86_64__
	if (!IsStatic()) {
	(*art_quick_invoke_stub)(this, args, args_size, self, result, shorty);
	} else {
	(*art_quick_invoke_static_stub)(this, args, args_size, self, result, shorty);
	}
	#else
	(*art_quick_invoke_stub)(this, args, args_size, self, result, shorty);
	#endif
	} else {
	(*art_portable_invoke_stub)(this, args, args_size, self, result, shorty[0]);
	}
	if (UNLIKELY(reinterpret_cast<intptr_t>(self->GetException(NULL)) == -1)) {
	// Unusual case where we were running LLVM generated code and an
	// exception was thrown to force the activations to be removed from the
	// stack. Continue execution in the interpreter.
	self->ClearException();
	ShadowFrame* shadow_frame = self->GetAndClearDeoptimizationShadowFrame(result);
	self->SetTopOfStack(NULL, 0);
	self->SetTopOfShadowStack(shadow_frame);
	interpreter::EnterInterpreterFromDeoptimize(self, shadow_frame, result);
	}
	if (kLogInvocationStartAndReturn) {
	LOG(INFO) << StringPrintf("Returned '%s' %s code=%p", PrettyMethod(this).c_str(),
	have_quick_code ? "quick" : "portable",
	have_quick_code ? GetEntryPointFromQuickCompiledCode()
	: GetEntryPointFromPortableCompiledCode());
	}
	} else {
	LOG(INFO) << "Not invoking '" << PrettyMethod(this) << "' code=null";
	if (result != NULL) {
	result->SetJ(0);
	}
	}
	}

	// Pop transition.
	self->PopManagedStackFragment(fragment);
	}

	bool ArtMethod::IsRegistered() {
	void* native_method =
	GetFieldPtr<void*>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, entry_point_from_jni_), false);
	CHECK(native_method != nullptr);
	void* jni_stub = GetJniDlsymLookupStub();
	return native_method != jni_stub;
	}

	extern "C" void art_work_around_app_jni_bugs(JNIEnv*, jobject);
	void ArtMethod::RegisterNative(Thread* self, const void* native_method, bool is_fast) {
	DCHECK(Thread::Current() == self);
	CHECK(IsNative()) << PrettyMethod(this);
	CHECK(!IsFastNative()) << PrettyMethod(this);
	CHECK(native_method != NULL) << PrettyMethod(this);
	if (!self->GetJniEnv()->vm->work_around_app_jni_bugs) {
	if (is_fast) {
	SetAccessFlags(GetAccessFlags() \| kAccFastNative);
	}
	SetNativeMethod(native_method);
	} else {
	// We've been asked to associate this method with the given native method but are working
	// around JNI bugs, that include not giving Object** SIRT references to native methods. Direct
	// the native method to runtime support and store the target somewhere runtime support will
	// find it.
	#if defined(__i386__) \|\| defined(__x86_64__)
	UNIMPLEMENTED(FATAL);
	#else
	SetNativeMethod(reinterpret_cast<void*>(art_work_around_app_jni_bugs));
	#endif
	SetFieldPtr<false>(OFFSET_OF_OBJECT_MEMBER(ArtMethod, gc_map_),
	reinterpret_cast<const uint8_t*>(native_method), false);
	}
	}

	void ArtMethod::UnregisterNative(Thread* self) {
	CHECK(IsNative() && !IsFastNative()) << PrettyMethod(this);
	// restore stub to lookup native pointer via dlsym
	RegisterNative(self, GetJniDlsymLookupStub(), false);
	}

	} // namespace mirror
	} // namespace art