Refactor runtime support.
Change-Id: Id7470a4105838150d5ceb73ab2c8c83e739660df
diff --git a/src/runtime_support.cc b/src/runtime_support.cc
index a55c55c..9072d58 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -1,5 +1,5 @@
/*
- * Copyright 2011 Google Inc. All Rights Reserved.
+ * Copyright 2012 Google Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,250 +16,98 @@
#include "runtime_support.h"
-#include "debugger.h"
-#include "dex_cache.h"
-#include "dex_verifier.h"
-#include "macros.h"
-#include "object.h"
-#include "object_utils.h"
-#include "reflection.h"
-#include "runtime_support_common.h"
-#include "trace.h"
-#include "ScopedLocalRef.h"
-
namespace art {
-// Place a special frame at the TOS that will save the callee saves for the given type
-static void FinishCalleeSaveFrameSetup(Thread* self, Method** sp, Runtime::CalleeSaveType type) {
- // Be aware the store below may well stomp on an incoming argument
- *sp = Runtime::Current()->GetCalleeSaveMethod(type);
- self->SetTopOfStack(sp, 0);
- self->VerifyStack();
+void ThrowNewIllegalAccessErrorClass(Thread* self,
+ Class* referrer,
+ Class* accessed) {
+ self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
+ "illegal class access: '%s' -> '%s'",
+ PrettyDescriptor(referrer).c_str(),
+ PrettyDescriptor(accessed).c_str());
}
-/*
- * Report location to debugger. Note: dex_pc is the current offset within
- * the method. However, because the offset alone cannot distinguish between
- * method entry and offset 0 within the method, we'll use an offset of -1
- * to denote method entry.
- */
-extern "C" void artUpdateDebuggerFromCode(int32_t dex_pc, Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
- Dbg::UpdateDebugger(dex_pc, self, sp);
+void ThrowNewIllegalAccessErrorClassForMethodDispatch(Thread* self,
+ Class* referrer,
+ Class* accessed,
+ const Method* caller,
+ const Method* called,
+ InvokeType type) {
+ std::ostringstream type_stream;
+ type_stream << type;
+ self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
+ "illegal class access ('%s' -> '%s')"
+ "in attempt to invoke %s method '%s' from '%s'",
+ PrettyDescriptor(referrer).c_str(),
+ PrettyDescriptor(accessed).c_str(),
+ type_stream.str().c_str(),
+ PrettyMethod(called).c_str(),
+ PrettyMethod(caller).c_str());
}
-// Temporary debugging hook for compiler.
-extern void DebugMe(Method* method, uint32_t info) {
- LOG(INFO) << "DebugMe";
- if (method != NULL) {
- LOG(INFO) << PrettyMethod(method);
- }
- LOG(INFO) << "Info: " << info;
+void ThrowNewIncompatibleClassChangeErrorClassForInterfaceDispatch(Thread* self,
+ const Method* referrer,
+ const Method* interface_method,
+ Object* this_object) {
+ self->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
+ "class '%s' does not implement interface '%s' in call to '%s' from '%s'",
+ PrettyDescriptor(this_object->GetClass()).c_str(),
+ PrettyDescriptor(interface_method->GetDeclaringClass()).c_str(),
+ PrettyMethod(interface_method).c_str(), PrettyMethod(referrer).c_str());
}
-// Return value helper for jobject return types
-extern Object* DecodeJObjectInThread(Thread* thread, jobject obj) {
- if (thread->IsExceptionPending()) {
- return NULL;
- }
- return thread->DecodeJObject(obj);
+void ThrowNewIllegalAccessErrorField(Thread* self,
+ Class* referrer,
+ Field* accessed) {
+ self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
+ "Field '%s' is inaccessible to class '%s'",
+ PrettyField(accessed, false).c_str(),
+ PrettyDescriptor(referrer).c_str());
}
-extern void* FindNativeMethod(Thread* self) {
- DCHECK(Thread::Current() == self);
-
- Method* method = const_cast<Method*>(self->GetCurrentMethod());
- DCHECK(method != NULL);
-
- // Lookup symbol address for method, on failure we'll return NULL with an
- // exception set, otherwise we return the address of the method we found.
- void* native_code = self->GetJniEnv()->vm->FindCodeForNativeMethod(method);
- if (native_code == NULL) {
- DCHECK(self->IsExceptionPending());
- return NULL;
- } else {
- // Register so that future calls don't come here
- method->RegisterNative(self, native_code);
- return native_code;
- }
+void ThrowNewIllegalAccessErrorFinalField(Thread* self,
+ const Method* referrer,
+ Field* accessed) {
+ self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
+ "Final field '%s' cannot be written to by method '%s'",
+ PrettyField(accessed, false).c_str(),
+ PrettyMethod(referrer).c_str());
}
-// Called by generated call to throw an exception
-extern "C" void artDeliverExceptionFromCode(Throwable* exception, Thread* thread, Method** sp) {
- /*
- * exception may be NULL, in which case this routine should
- * throw NPE. NOTE: this is a convenience for generated code,
- * which previously did the null check inline and constructed
- * and threw a NPE if NULL. This routine responsible for setting
- * exception_ in thread and delivering the exception.
- */
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
- if (exception == NULL) {
- thread->ThrowNewException("Ljava/lang/NullPointerException;", "throw with null exception");
- } else {
- thread->SetException(exception);
- }
- thread->DeliverException();
+void ThrowNewIllegalAccessErrorMethod(Thread* self,
+ Class* referrer,
+ Method* accessed) {
+ self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
+ "Method '%s' is inaccessible to class '%s'",
+ PrettyMethod(accessed).c_str(),
+ PrettyDescriptor(referrer).c_str());
}
-// Deliver an exception that's pending on thread helping set up a callee save frame on the way
-extern "C" void artDeliverPendingExceptionFromCode(Thread* thread, Method** sp) {
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
- thread->DeliverException();
+void ThrowNullPointerExceptionForFieldAccess(Thread* self,
+ Field* field,
+ bool is_read) {
+ self->ThrowNewExceptionF("Ljava/lang/NullPointerException;",
+ "Attempt to %s field '%s' on a null object reference",
+ is_read ? "read from" : "write to",
+ PrettyField(field, true).c_str());
}
-// Called by generated call to throw a NPE exception
-extern "C" void artThrowNullPointerExceptionFromCode(Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
- Frame fr = self->GetTopOfStack();
- uintptr_t throw_native_pc = fr.GetReturnPC();
- fr.Next();
- Method* throw_method = fr.GetMethod();
- uint32_t dex_pc = throw_method->ToDexPC(throw_native_pc - 2);
- const DexFile::CodeItem* code = MethodHelper(throw_method).GetCodeItem();
- CHECK_LT(dex_pc, code->insns_size_in_code_units_);
- const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
- DecodedInstruction dec_insn(instr);
- switch (instr->Opcode()) {
- case Instruction::INVOKE_DIRECT:
- case Instruction::INVOKE_DIRECT_RANGE:
- ThrowNullPointerExceptionForMethodAccess(self, throw_method, dec_insn.vB, kDirect);
- break;
- case Instruction::INVOKE_VIRTUAL:
- case Instruction::INVOKE_VIRTUAL_RANGE:
- ThrowNullPointerExceptionForMethodAccess(self, throw_method, dec_insn.vB, kVirtual);
- break;
- case Instruction::IGET:
- case Instruction::IGET_WIDE:
- case Instruction::IGET_OBJECT:
- case Instruction::IGET_BOOLEAN:
- case Instruction::IGET_BYTE:
- case Instruction::IGET_CHAR:
- case Instruction::IGET_SHORT: {
- Field* field =
- Runtime::Current()->GetClassLinker()->ResolveField(dec_insn.vC, throw_method, false);
- ThrowNullPointerExceptionForFieldAccess(self, field, true /* read */);
- break;
- }
- case Instruction::IPUT:
- case Instruction::IPUT_WIDE:
- case Instruction::IPUT_OBJECT:
- case Instruction::IPUT_BOOLEAN:
- case Instruction::IPUT_BYTE:
- case Instruction::IPUT_CHAR:
- case Instruction::IPUT_SHORT: {
- Field* field =
- Runtime::Current()->GetClassLinker()->ResolveField(dec_insn.vC, throw_method, false);
- ThrowNullPointerExceptionForFieldAccess(self, field, false /* write */);
- break;
- }
- case Instruction::AGET:
- case Instruction::AGET_WIDE:
- case Instruction::AGET_OBJECT:
- case Instruction::AGET_BOOLEAN:
- case Instruction::AGET_BYTE:
- case Instruction::AGET_CHAR:
- case Instruction::AGET_SHORT:
- self->ThrowNewException("Ljava/lang/NullPointerException;",
- "Attempt to read from null array");
- break;
- case Instruction::APUT:
- case Instruction::APUT_WIDE:
- case Instruction::APUT_OBJECT:
- case Instruction::APUT_BOOLEAN:
- case Instruction::APUT_BYTE:
- case Instruction::APUT_CHAR:
- case Instruction::APUT_SHORT:
- self->ThrowNewException("Ljava/lang/NullPointerException;",
- "Attempt to write to null array");
- break;
- default: {
- const DexFile& dex_file = Runtime::Current()->GetClassLinker()
- ->FindDexFile(throw_method->GetDeclaringClass()->GetDexCache());
- std::string message("Null pointer exception during instruction '");
- message += instr->DumpString(&dex_file);
- message += "'";
- self->ThrowNewException("Ljava/lang/NullPointerException;", message.c_str());
- break;
- }
- }
- self->DeliverException();
+void ThrowNullPointerExceptionForMethodAccess(Thread* self,
+ Method* caller,
+ uint32_t method_idx,
+ InvokeType type) {
+ const DexFile& dex_file =
+ Runtime::Current()->GetClassLinker()->FindDexFile(caller->GetDeclaringClass()->GetDexCache());
+ std::ostringstream type_stream;
+ type_stream << type;
+ self->ThrowNewExceptionF("Ljava/lang/NullPointerException;",
+ "Attempt to invoke %s method '%s' on a null object reference",
+ type_stream.str().c_str(),
+ PrettyMethod(method_idx, dex_file, true).c_str());
}
-// Called by generated call to throw an arithmetic divide by zero exception
-extern "C" void artThrowDivZeroFromCode(Thread* thread, Method** sp) {
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
- thread->ThrowNewException("Ljava/lang/ArithmeticException;", "divide by zero");
- thread->DeliverException();
-}
-
-// Called by generated call to throw an arithmetic divide by zero exception
-extern "C" void artThrowArrayBoundsFromCode(int index, int limit, Thread* thread, Method** sp) {
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
- thread->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
- "length=%d; index=%d", limit, index);
- thread->DeliverException();
-}
-
-// Called by the AbstractMethodError stub (not runtime support)
-extern void ThrowAbstractMethodErrorFromCode(Method* method, Thread* thread, Method** sp) {
-#if !defined(ART_USE_LLVM_COMPILER)
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
-#endif
- thread->ThrowNewExceptionF("Ljava/lang/AbstractMethodError;",
- "abstract method \"%s\"", PrettyMethod(method).c_str());
-#if !defined(ART_USE_LLVM_COMPILER)
- thread->DeliverException();
-#endif
-}
-
-extern "C" void artThrowStackOverflowFromCode(Method* /*method*/, Thread* thread, Method** sp) {
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
- // Remove extra entry pushed onto second stack during method tracing
- if (Runtime::Current()->IsMethodTracingActive()) {
- TraceMethodUnwindFromCode(thread);
- }
- thread->SetStackEndForStackOverflow(); // Allow space on the stack for constructor to execute
- thread->ThrowNewExceptionF("Ljava/lang/StackOverflowError;",
- "stack size %zdkb; default stack size: %zdkb",
- thread->GetStackSize() / KB, Runtime::Current()->GetDefaultStackSize() / KB);
- thread->ResetDefaultStackEnd(); // Return to default stack size
- thread->DeliverException();
-}
-
-static std::string ClassNameFromIndex(Method* method, uint32_t ref,
- verifier::VerifyErrorRefType ref_type, bool access) {
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- const DexFile& dex_file = class_linker->FindDexFile(method->GetDeclaringClass()->GetDexCache());
-
- uint16_t type_idx = 0;
- if (ref_type == verifier::VERIFY_ERROR_REF_FIELD) {
- const DexFile::FieldId& id = dex_file.GetFieldId(ref);
- type_idx = id.class_idx_;
- } else if (ref_type == verifier::VERIFY_ERROR_REF_METHOD) {
- const DexFile::MethodId& id = dex_file.GetMethodId(ref);
- type_idx = id.class_idx_;
- } else if (ref_type == verifier::VERIFY_ERROR_REF_CLASS) {
- type_idx = ref;
- } else {
- CHECK(false) << static_cast<int>(ref_type);
- }
-
- std::string class_name(PrettyDescriptor(dex_file.StringByTypeIdx(type_idx)));
- if (!access) {
- return class_name;
- }
-
- std::string result;
- result += "tried to access class ";
- result += class_name;
- result += " from class ";
- result += PrettyDescriptor(method->GetDeclaringClass());
- return result;
-}
-
-static std::string FieldNameFromIndex(const Method* method, uint32_t ref,
- verifier::VerifyErrorRefType ref_type, bool access) {
+std::string FieldNameFromIndex(const Method* method, uint32_t ref,
+ verifier::VerifyErrorRefType ref_type, bool access) {
CHECK_EQ(static_cast<int>(ref_type), static_cast<int>(verifier::VERIFY_ERROR_REF_FIELD));
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
@@ -280,8 +128,8 @@
return result;
}
-static std::string MethodNameFromIndex(const Method* method, uint32_t ref,
- verifier::VerifyErrorRefType ref_type, bool access) {
+std::string MethodNameFromIndex(const Method* method, uint32_t ref,
+ verifier::VerifyErrorRefType ref_type, bool access) {
CHECK_EQ(static_cast<int>(ref_type), static_cast<int>(verifier::VERIFY_ERROR_REF_METHOD));
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
@@ -303,1092 +151,228 @@
return result;
}
-extern "C" void artThrowVerificationErrorFromCode(int32_t kind, int32_t ref, Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
- Frame frame = self->GetTopOfStack(); // We need the calling method as context to interpret 'ref'
- frame.Next();
- Method* method = frame.GetMethod();
-
- verifier::VerifyErrorRefType ref_type =
- static_cast<verifier::VerifyErrorRefType>(kind >> verifier::kVerifyErrorRefTypeShift);
-
- const char* exception_class = "Ljava/lang/VerifyError;";
- std::string msg;
-
- switch (static_cast<verifier::VerifyError>(kind & ~(0xff << verifier::kVerifyErrorRefTypeShift))) {
- case verifier::VERIFY_ERROR_NO_CLASS:
- exception_class = "Ljava/lang/NoClassDefFoundError;";
- msg = ClassNameFromIndex(method, ref, ref_type, false);
- break;
- case verifier::VERIFY_ERROR_NO_FIELD:
- exception_class = "Ljava/lang/NoSuchFieldError;";
- msg = FieldNameFromIndex(method, ref, ref_type, false);
- break;
- case verifier::VERIFY_ERROR_NO_METHOD:
- exception_class = "Ljava/lang/NoSuchMethodError;";
- msg = MethodNameFromIndex(method, ref, ref_type, false);
- break;
- case verifier::VERIFY_ERROR_ACCESS_CLASS:
- exception_class = "Ljava/lang/IllegalAccessError;";
- msg = ClassNameFromIndex(method, ref, ref_type, true);
- break;
- case verifier::VERIFY_ERROR_ACCESS_FIELD:
- exception_class = "Ljava/lang/IllegalAccessError;";
- msg = FieldNameFromIndex(method, ref, ref_type, true);
- break;
- case verifier::VERIFY_ERROR_ACCESS_METHOD:
- exception_class = "Ljava/lang/IllegalAccessError;";
- msg = MethodNameFromIndex(method, ref, ref_type, true);
- break;
- case verifier::VERIFY_ERROR_CLASS_CHANGE:
- exception_class = "Ljava/lang/IncompatibleClassChangeError;";
- msg = ClassNameFromIndex(method, ref, ref_type, false);
- break;
- case verifier::VERIFY_ERROR_INSTANTIATION:
- exception_class = "Ljava/lang/InstantiationError;";
- msg = ClassNameFromIndex(method, ref, ref_type, false);
- break;
- case verifier::VERIFY_ERROR_BAD_CLASS_SOFT:
- case verifier::VERIFY_ERROR_BAD_CLASS_HARD:
- // Generic VerifyError; use default exception, no message.
- break;
- case verifier::VERIFY_ERROR_NONE:
- CHECK(false);
- break;
+// Helper function to allocate array for FILLED_NEW_ARRAY.
+Array* CheckAndAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
+ Thread* self, bool access_check) {
+ if (UNLIKELY(component_count < 0)) {
+ self->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", component_count);
+ return NULL; // Failure
}
- self->ThrowNewException(exception_class, msg.c_str());
- self->DeliverException();
-}
-
-extern "C" void artThrowInternalErrorFromCode(int32_t errnum, Thread* thread, Method** sp) {
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
- LOG(WARNING) << "TODO: internal error detail message. errnum=" << errnum;
- thread->ThrowNewExceptionF("Ljava/lang/InternalError;", "errnum=%d", errnum);
- thread->DeliverException();
-}
-
-extern "C" void artThrowRuntimeExceptionFromCode(int32_t errnum, Thread* thread, Method** sp) {
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
- LOG(WARNING) << "TODO: runtime exception detail message. errnum=" << errnum;
- thread->ThrowNewExceptionF("Ljava/lang/RuntimeException;", "errnum=%d", errnum);
- thread->DeliverException();
-}
-
-extern "C" void artThrowNoSuchMethodFromCode(int32_t method_idx, Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
- Frame frame = self->GetTopOfStack(); // We need the calling method as context for the method_idx
- frame.Next();
- Method* method = frame.GetMethod();
- self->ThrowNewException("Ljava/lang/NoSuchMethodError;",
- MethodNameFromIndex(method, method_idx, verifier::VERIFY_ERROR_REF_METHOD, false).c_str());
- self->DeliverException();
-}
-
-extern "C" void artThrowNegArraySizeFromCode(int32_t size, Thread* thread, Method** sp) {
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
- LOG(WARNING) << "UNTESTED artThrowNegArraySizeFromCode";
- thread->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", size);
- thread->DeliverException();
-}
-
-const void* UnresolvedDirectMethodTrampolineFromCode(Method* called, Method** sp, Thread* thread,
- Runtime::TrampolineType type) {
- // TODO: this code is specific to ARM
- // On entry the stack pointed by sp is:
- // | argN | |
- // | ... | |
- // | arg4 | |
- // | arg3 spill | | Caller's frame
- // | arg2 spill | |
- // | arg1 spill | |
- // | Method* | ---
- // | LR |
- // | ... | callee saves
- // | R3 | arg3
- // | R2 | arg2
- // | R1 | arg1
- // | R0 |
- // | Method* | <- sp
- uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp) + kPointerSize);
- DCHECK_EQ(48U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
- Method** caller_sp = reinterpret_cast<Method**>(reinterpret_cast<byte*>(sp) + 48);
- uintptr_t caller_pc = regs[10];
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsAndArgs);
- // Start new JNI local reference state
- JNIEnvExt* env = thread->GetJniEnv();
- ScopedJniEnvLocalRefState env_state(env);
-
- // Compute details about the called method (avoid GCs)
- ClassLinker* linker = Runtime::Current()->GetClassLinker();
- Method* caller = *caller_sp;
- bool is_static;
- bool is_virtual;
- uint32_t dex_method_idx;
- const char* shorty;
- uint32_t shorty_len;
- if (type == Runtime::kUnknownMethod) {
- DCHECK(called->IsRuntimeMethod());
- // less two as return address may span into next dex instruction
- uint32_t dex_pc = caller->ToDexPC(caller_pc - 2);
- const DexFile::CodeItem* code = MethodHelper(caller).GetCodeItem();
- CHECK_LT(dex_pc, code->insns_size_in_code_units_);
- const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
- Instruction::Code instr_code = instr->Opcode();
- is_static = (instr_code == Instruction::INVOKE_STATIC) ||
- (instr_code == Instruction::INVOKE_STATIC_RANGE);
- is_virtual = (instr_code == Instruction::INVOKE_VIRTUAL) ||
- (instr_code == Instruction::INVOKE_VIRTUAL_RANGE) ||
- (instr_code == Instruction::INVOKE_SUPER) ||
- (instr_code == Instruction::INVOKE_SUPER_RANGE);
- DCHECK(is_static || is_virtual || (instr_code == Instruction::INVOKE_DIRECT) ||
- (instr_code == Instruction::INVOKE_DIRECT_RANGE));
- DecodedInstruction dec_insn(instr);
- dex_method_idx = dec_insn.vB;
- shorty = linker->MethodShorty(dex_method_idx, caller, &shorty_len);
- } else {
- DCHECK(!called->IsRuntimeMethod());
- is_static = type == Runtime::kStaticMethod;
- is_virtual = false;
- dex_method_idx = called->GetDexMethodIndex();
- MethodHelper mh(called);
- shorty = mh.GetShorty();
- shorty_len = mh.GetShortyLength();
- }
- // Discover shorty (avoid GCs)
- size_t args_in_regs = 0;
- for (size_t i = 1; i < shorty_len; i++) {
- char c = shorty[i];
- args_in_regs = args_in_regs + (c == 'J' || c == 'D' ? 2 : 1);
- if (args_in_regs > 3) {
- args_in_regs = 3;
- break;
+ Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
+ if (UNLIKELY(klass == NULL)) { // Not in dex cache so try to resolve
+ klass = Runtime::Current()->GetClassLinker()->ResolveType(type_idx, method);
+ if (klass == NULL) { // Error
+ DCHECK(Thread::Current()->IsExceptionPending());
+ return NULL; // Failure
}
}
- // Place into local references incoming arguments from the caller's register arguments
- size_t cur_arg = 1; // skip method_idx in R0, first arg is in R1
- if (!is_static) {
- Object* obj = reinterpret_cast<Object*>(regs[cur_arg]);
- cur_arg++;
- if (args_in_regs < 3) {
- // If we thought we had fewer than 3 arguments in registers, account for the receiver
- args_in_regs++;
- }
- AddLocalReference<jobject>(env, obj);
- }
- size_t shorty_index = 1; // skip return value
- // Iterate while arguments and arguments in registers (less 1 from cur_arg which is offset to skip
- // R0)
- while ((cur_arg - 1) < args_in_regs && shorty_index < shorty_len) {
- char c = shorty[shorty_index];
- shorty_index++;
- if (c == 'L') {
- Object* obj = reinterpret_cast<Object*>(regs[cur_arg]);
- AddLocalReference<jobject>(env, obj);
- }
- cur_arg = cur_arg + (c == 'J' || c == 'D' ? 2 : 1);
- }
- // Place into local references incoming arguments from the caller's stack arguments
- cur_arg += 11; // skip LR, Method* and spills for R1 to R3 and callee saves
- while (shorty_index < shorty_len) {
- char c = shorty[shorty_index];
- shorty_index++;
- if (c == 'L') {
- Object* obj = reinterpret_cast<Object*>(regs[cur_arg]);
- AddLocalReference<jobject>(env, obj);
- }
- cur_arg = cur_arg + (c == 'J' || c == 'D' ? 2 : 1);
- }
- // Resolve method filling in dex cache
- if (type == Runtime::kUnknownMethod) {
- called = linker->ResolveMethod(dex_method_idx, caller, !is_virtual);
- }
- const void* code = NULL;
- if (LIKELY(!thread->IsExceptionPending())) {
- if (LIKELY(called->IsDirect() == !is_virtual)) {
- // Ensure that the called method's class is initialized.
- Class* called_class = called->GetDeclaringClass();
- linker->EnsureInitialized(called_class, true);
- if (LIKELY(called_class->IsInitialized())) {
- code = called->GetCode();
- } else if (called_class->IsInitializing()) {
- if (is_static) {
- // Class is still initializing, go to oat and grab code (trampoline must be left in place
- // until class is initialized to stop races between threads).
- code = linker->GetOatCodeFor(called);
- } else {
- // No trampoline for non-static methods.
- code = called->GetCode();
- }
- } else {
- DCHECK(called_class->IsErroneous());
- }
+ if (UNLIKELY(klass->IsPrimitive() && !klass->IsPrimitiveInt())) {
+ if (klass->IsPrimitiveLong() || klass->IsPrimitiveDouble()) {
+ Thread::Current()->ThrowNewExceptionF("Ljava/lang/RuntimeException;",
+ "Bad filled array request for type %s",
+ PrettyDescriptor(klass).c_str());
} else {
- // Direct method has been made virtual
- thread->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
- "Expected direct method but found virtual: %s",
- PrettyMethod(called, true).c_str());
+ Thread::Current()->ThrowNewExceptionF("Ljava/lang/InternalError;",
+ "Found type %s; filled-new-array not implemented for anything but \'int\'",
+ PrettyDescriptor(klass).c_str());
}
- }
- if (UNLIKELY(code == NULL)) {
- // Something went wrong in ResolveMethod or EnsureInitialized,
- // go into deliver exception with the pending exception in r0
- code = reinterpret_cast<void*>(art_deliver_exception_from_code);
- regs[0] = reinterpret_cast<uintptr_t>(thread->GetException());
- thread->ClearException();
+ return NULL; // Failure
} else {
- // Expect class to at least be initializing.
- DCHECK(called->GetDeclaringClass()->IsInitializing());
- // Don't want infinite recursion.
- DCHECK(code != Runtime::Current()->GetResolutionStubArray(Runtime::kUnknownMethod)->GetData());
- // Set up entry into main method
- regs[0] = reinterpret_cast<uintptr_t>(called);
- }
- return code;
-}
-
-static void WorkAroundJniBugsForJobject(intptr_t* arg_ptr) {
- intptr_t value = *arg_ptr;
- Object** value_as_jni_rep = reinterpret_cast<Object**>(value);
- Object* value_as_work_around_rep = value_as_jni_rep != NULL ? *value_as_jni_rep : NULL;
- CHECK(Runtime::Current()->GetHeap()->IsHeapAddress(value_as_work_around_rep)) << value_as_work_around_rep;
- *arg_ptr = reinterpret_cast<intptr_t>(value_as_work_around_rep);
-}
-
-extern "C" const void* artWorkAroundAppJniBugs(Thread* self, intptr_t* sp) {
- DCHECK(Thread::Current() == self);
- // TODO: this code is specific to ARM
- // On entry the stack pointed by sp is:
- // | arg3 | <- Calling JNI method's frame (and extra bit for out args)
- // | LR |
- // | R3 | arg2
- // | R2 | arg1
- // | R1 | jclass/jobject
- // | R0 | JNIEnv
- // | unused |
- // | unused |
- // | unused | <- sp
- Method* jni_method = self->GetTopOfStack().GetMethod();
- DCHECK(jni_method->IsNative()) << PrettyMethod(jni_method);
- intptr_t* arg_ptr = sp + 4; // pointer to r1 on stack
- // Fix up this/jclass argument
- WorkAroundJniBugsForJobject(arg_ptr);
- arg_ptr++;
- // Fix up jobject arguments
- MethodHelper mh(jni_method);
- int reg_num = 2; // Current register being processed, -1 for stack arguments.
- for (uint32_t i = 1; i < mh.GetShortyLength(); i++) {
- char shorty_char = mh.GetShorty()[i];
- if (shorty_char == 'L') {
- WorkAroundJniBugsForJobject(arg_ptr);
+ if (access_check) {
+ Class* referrer = method->GetDeclaringClass();
+ if (UNLIKELY(!referrer->CanAccess(klass))) {
+ ThrowNewIllegalAccessErrorClass(self, referrer, klass);
+ return NULL; // Failure
+ }
}
- if (shorty_char == 'J' || shorty_char == 'D') {
- if (reg_num == 2) {
- arg_ptr = sp + 8; // skip to out arguments
- reg_num = -1;
- } else if (reg_num == 3) {
- arg_ptr = sp + 10; // skip to out arguments plus 2 slots as long must be aligned
- reg_num = -1;
+ DCHECK(klass->IsArrayClass()) << PrettyClass(klass);
+ return Array::Alloc(klass, component_count);
+ }
+}
+
+// Slow path field resolution and declaring class initialization
+Field* FindFieldFromCode(uint32_t field_idx, const Method* referrer, Thread* self,
+ bool is_static, bool is_primitive, bool is_set, size_t expected_size) {
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ Field* resolved_field = class_linker->ResolveField(field_idx, referrer, is_static);
+ if (UNLIKELY(resolved_field == NULL)) {
+ DCHECK(self->IsExceptionPending()); // Throw exception and unwind
+ return NULL; // failure
+ } else {
+ Class* fields_class = resolved_field->GetDeclaringClass();
+ Class* referring_class = referrer->GetDeclaringClass();
+ if (UNLIKELY(!referring_class->CanAccess(fields_class))) {
+ ThrowNewIllegalAccessErrorClass(self, referring_class, fields_class);
+ return NULL; // failure
+ } else if (UNLIKELY(!referring_class->CanAccessMember(fields_class,
+ resolved_field->GetAccessFlags()))) {
+ ThrowNewIllegalAccessErrorField(self, referring_class, resolved_field);
+ return NULL; // failure
+ } else if (UNLIKELY(is_set && resolved_field->IsFinal() && (fields_class != referring_class))) {
+ ThrowNewIllegalAccessErrorFinalField(self, referrer, resolved_field);
+ return NULL; // failure
+ } else {
+ FieldHelper fh(resolved_field);
+ if (UNLIKELY(fh.IsPrimitiveType() != is_primitive ||
+ fh.FieldSize() != expected_size)) {
+ self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
+ "Attempted read of %zd-bit %s on field '%s'",
+ expected_size * (32 / sizeof(int32_t)),
+ is_primitive ? "primitive" : "non-primitive",
+ PrettyField(resolved_field, true).c_str());
+ return NULL; // failure
+ } else if (!is_static) {
+ // instance fields must be being accessed on an initialized class
+ return resolved_field;
} else {
- DCHECK(reg_num == -1);
- if ((reinterpret_cast<intptr_t>(arg_ptr) & 7) == 4) {
- arg_ptr += 3; // unaligned, pad and move through stack arguments
+ // If the class is already initializing, we must be inside <clinit>, or
+ // we'd still be waiting for the lock.
+ if (fields_class->IsInitializing()) {
+ return resolved_field;
+ } else if (Runtime::Current()->GetClassLinker()->EnsureInitialized(fields_class, true)) {
+ return resolved_field;
} else {
- arg_ptr += 2; // aligned, move through stack arguments
+ DCHECK(self->IsExceptionPending()); // Throw exception and unwind
+ return NULL; // failure
}
}
- } else {
- if (reg_num == 2) {
- arg_ptr++; // move through register arguments
- reg_num++;
- } else if (reg_num == 3) {
- arg_ptr = sp + 8; // skip to outgoing stack arguments
- reg_num = -1;
+ }
+ }
+}
+
+// Slow path method resolution
+Method* FindMethodFromCode(uint32_t method_idx, Object* this_object, const Method* referrer,
+ Thread* self, bool access_check, InvokeType type) {
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ bool is_direct = type == kStatic || type == kDirect;
+ Method* resolved_method = class_linker->ResolveMethod(method_idx, referrer, is_direct);
+ if (UNLIKELY(resolved_method == NULL)) {
+ DCHECK(self->IsExceptionPending()); // Throw exception and unwind
+ return NULL; // failure
+ } else {
+ if (!access_check) {
+ if (is_direct) {
+ return resolved_method;
+ } else if (type == kInterface) {
+ Method* interface_method =
+ this_object->GetClass()->FindVirtualMethodForInterface(resolved_method);
+ if (UNLIKELY(interface_method == NULL)) {
+ ThrowNewIncompatibleClassChangeErrorClassForInterfaceDispatch(self, referrer,
+ resolved_method,
+ this_object);
+ return NULL; // failure
+ } else {
+ return interface_method;
+ }
} else {
- DCHECK(reg_num == -1);
- arg_ptr++; // move through stack arguments
+ ObjectArray<Method>* vtable;
+ uint16_t vtable_index = resolved_method->GetMethodIndex();
+ if (type == kSuper) {
+ vtable = referrer->GetDeclaringClass()->GetSuperClass()->GetVTable();
+ } else {
+ vtable = this_object->GetClass()->GetVTable();
+ }
+ // TODO: eliminate bounds check?
+ return vtable->Get(vtable_index);
+ }
+ } else {
+ Class* methods_class = resolved_method->GetDeclaringClass();
+ Class* referring_class = referrer->GetDeclaringClass();
+ if (UNLIKELY(!referring_class->CanAccess(methods_class) ||
+ !referring_class->CanAccessMember(methods_class,
+ resolved_method->GetAccessFlags()))) {
+ // The referring class can't access the resolved method, this may occur as a result of a
+ // protected method being made public by implementing an interface that re-declares the
+ // method public. Resort to the dex file to determine the correct class for the access check
+ const DexFile& dex_file = class_linker->FindDexFile(referring_class->GetDexCache());
+ methods_class = class_linker->ResolveType(dex_file,
+ dex_file.GetMethodId(method_idx).class_idx_,
+ referring_class);
+ if (UNLIKELY(!referring_class->CanAccess(methods_class))) {
+ ThrowNewIllegalAccessErrorClassForMethodDispatch(self, referring_class, methods_class,
+ referrer, resolved_method, type);
+ return NULL; // failure
+ } else if (UNLIKELY(!referring_class->CanAccessMember(methods_class,
+ resolved_method->GetAccessFlags()))) {
+ ThrowNewIllegalAccessErrorMethod(self, referring_class, resolved_method);
+ return NULL; // failure
+ }
+ }
+ if (is_direct) {
+ return resolved_method;
+ } else if (type == kInterface) {
+ Method* interface_method =
+ this_object->GetClass()->FindVirtualMethodForInterface(resolved_method);
+ if (UNLIKELY(interface_method == NULL)) {
+ ThrowNewIncompatibleClassChangeErrorClassForInterfaceDispatch(self, referrer,
+ resolved_method,
+ this_object);
+ return NULL; // failure
+ } else {
+ return interface_method;
+ }
+ } else {
+ ObjectArray<Method>* vtable;
+ uint16_t vtable_index = resolved_method->GetMethodIndex();
+ if (type == kSuper) {
+ Class* super_class = referring_class->GetSuperClass();
+ if (LIKELY(super_class != NULL)) {
+ vtable = referring_class->GetSuperClass()->GetVTable();
+ } else {
+ vtable = NULL;
+ }
+ } else {
+ vtable = this_object->GetClass()->GetVTable();
+ }
+ if (LIKELY(vtable != NULL &&
+ vtable_index < static_cast<uint32_t>(vtable->GetLength()))) {
+ return vtable->GetWithoutChecks(vtable_index);
+ } else {
+ // Behavior to agree with that of the verifier
+ self->ThrowNewExceptionF("Ljava/lang/NoSuchMethodError;",
+ "attempt to invoke %s method '%s' from '%s'"
+ " using incorrect form of method dispatch",
+ (type == kSuper ? "super class" : "virtual"),
+ PrettyMethod(resolved_method).c_str(),
+ PrettyMethod(referrer).c_str());
+ return NULL; // failure
+ }
}
}
}
- // Load expected destination, see Method::RegisterNative
- const void* code = reinterpret_cast<const void*>(jni_method->GetGcMapRaw());
- if (UNLIKELY(code == NULL)) {
- code = Runtime::Current()->GetJniDlsymLookupStub()->GetData();
- jni_method->RegisterNative(self, code);
- }
- return code;
}
-
-extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx, const Method* referrer,
- Thread* self, Method** sp) {
- Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int32_t));
- if (LIKELY(field != NULL)) {
- return field->Get32(NULL);
- }
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, true, true, false, sizeof(int32_t));
- if (LIKELY(field != NULL)) {
- return field->Get32(NULL);
- }
- return 0; // Will throw exception by checking with Thread::Current
-}
-
-extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx, const Method* referrer,
- Thread* self, Method** sp) {
- Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int64_t));
- if (LIKELY(field != NULL)) {
- return field->Get64(NULL);
- }
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, true, true, false, sizeof(int64_t));
- if (LIKELY(field != NULL)) {
- return field->Get64(NULL);
- }
- return 0; // Will throw exception by checking with Thread::Current
-}
-
-extern "C" Object* artGetObjStaticFromCode(uint32_t field_idx, const Method* referrer,
- Thread* self, Method** sp) {
- Field* field = FindFieldFast(field_idx, referrer, false, false, sizeof(Object*));
- if (LIKELY(field != NULL)) {
- return field->GetObj(NULL);
- }
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, true, false, false, sizeof(Object*));
- if (LIKELY(field != NULL)) {
- return field->GetObj(NULL);
- }
- return NULL; // Will throw exception by checking with Thread::Current
-}
-
-extern "C" uint32_t artGet32InstanceFromCode(uint32_t field_idx, Object* obj,
- const Method* referrer, Thread* self, Method** sp) {
- Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int32_t));
- if (LIKELY(field != NULL && obj != NULL)) {
- return field->Get32(obj);
- }
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, false, true, false, sizeof(int32_t));
- if (LIKELY(field != NULL)) {
- if (UNLIKELY(obj == NULL)) {
- ThrowNullPointerExceptionForFieldAccess(self, field, true);
- } else {
- return field->Get32(obj);
- }
- }
- return 0; // Will throw exception by checking with Thread::Current
-}
-
-extern "C" uint64_t artGet64InstanceFromCode(uint32_t field_idx, Object* obj,
- const Method* referrer, Thread* self, Method** sp) {
- Field* field = FindFieldFast(field_idx, referrer, true, false, sizeof(int64_t));
- if (LIKELY(field != NULL && obj != NULL)) {
- return field->Get64(obj);
- }
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, false, true, false, sizeof(int64_t));
- if (LIKELY(field != NULL)) {
- if (UNLIKELY(obj == NULL)) {
- ThrowNullPointerExceptionForFieldAccess(self, field, true);
- } else {
- return field->Get64(obj);
- }
- }
- return 0; // Will throw exception by checking with Thread::Current
-}
-
-extern "C" Object* artGetObjInstanceFromCode(uint32_t field_idx, Object* obj,
- const Method* referrer, Thread* self, Method** sp) {
- Field* field = FindFieldFast(field_idx, referrer, false, false, sizeof(Object*));
- if (LIKELY(field != NULL && obj != NULL)) {
- return field->GetObj(obj);
- }
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, false, false, false, sizeof(Object*));
- if (LIKELY(field != NULL)) {
- if (UNLIKELY(obj == NULL)) {
- ThrowNullPointerExceptionForFieldAccess(self, field, true);
- } else {
- return field->GetObj(obj);
- }
- }
- return NULL; // Will throw exception by checking with Thread::Current
-}
-
-extern "C" int artSet32StaticFromCode(uint32_t field_idx, uint32_t new_value,
- const Method* referrer, Thread* self, Method** sp) {
- Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int32_t));
- if (LIKELY(field != NULL)) {
- field->Set32(NULL, new_value);
- return 0; // success
- }
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, true, true, true, sizeof(int32_t));
- if (LIKELY(field != NULL)) {
- field->Set32(NULL, new_value);
- return 0; // success
- }
- return -1; // failure
-}
-
-extern "C" int artSet64StaticFromCode(uint32_t field_idx, const Method* referrer,
- uint64_t new_value, Thread* self, Method** sp) {
- Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int64_t));
- if (LIKELY(field != NULL)) {
- field->Set64(NULL, new_value);
- return 0; // success
- }
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, true, true, true, sizeof(int64_t));
- if (LIKELY(field != NULL)) {
- field->Set64(NULL, new_value);
- return 0; // success
- }
- return -1; // failure
-}
-
-extern "C" int artSetObjStaticFromCode(uint32_t field_idx, Object* new_value,
- const Method* referrer, Thread* self, Method** sp) {
- Field* field = FindFieldFast(field_idx, referrer, false, true, sizeof(Object*));
- if (LIKELY(field != NULL)) {
- if (LIKELY(!FieldHelper(field).IsPrimitiveType())) {
- field->SetObj(NULL, new_value);
- return 0; // success
- }
- }
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, true, false, true, sizeof(Object*));
- if (LIKELY(field != NULL)) {
- field->SetObj(NULL, new_value);
- return 0; // success
- }
- return -1; // failure
-}
-
-extern "C" int artSet32InstanceFromCode(uint32_t field_idx, Object* obj, uint32_t new_value,
- const Method* referrer, Thread* self, Method** sp) {
- Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int32_t));
- if (LIKELY(field != NULL && obj != NULL)) {
- field->Set32(obj, new_value);
- return 0; // success
- }
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, false, true, true, sizeof(int32_t));
- if (LIKELY(field != NULL)) {
- if (UNLIKELY(obj == NULL)) {
- ThrowNullPointerExceptionForFieldAccess(self, field, false);
- } else {
- field->Set32(obj, new_value);
- return 0; // success
- }
- }
- return -1; // failure
-}
-
-extern "C" int artSet64InstanceFromCode(uint32_t field_idx, Object* obj, uint64_t new_value,
- Thread* self, Method** sp) {
- Method* callee_save = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsOnly);
- Method* referrer = sp[callee_save->GetFrameSizeInBytes() / sizeof(Method*)];
- Field* field = FindFieldFast(field_idx, referrer, true, true, sizeof(int64_t));
- if (LIKELY(field != NULL && obj != NULL)) {
- field->Set64(obj, new_value);
- return 0; // success
- }
- *sp = callee_save;
- self->SetTopOfStack(sp, 0);
- field = FindFieldFromCode(field_idx, referrer, self, false, true, true, sizeof(int64_t));
- if (LIKELY(field != NULL)) {
- if (UNLIKELY(obj == NULL)) {
- ThrowNullPointerExceptionForFieldAccess(self, field, false);
- } else {
- field->Set64(obj, new_value);
- return 0; // success
- }
- }
- return -1; // failure
-}
-
-extern "C" int artSetObjInstanceFromCode(uint32_t field_idx, Object* obj, Object* new_value,
- const Method* referrer, Thread* self, Method** sp) {
- Field* field = FindFieldFast(field_idx, referrer, false, true, sizeof(Object*));
- if (LIKELY(field != NULL && obj != NULL)) {
- field->SetObj(obj, new_value);
- return 0; // success
- }
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, false, false, true, sizeof(Object*));
- if (LIKELY(field != NULL)) {
- if (UNLIKELY(obj == NULL)) {
- ThrowNullPointerExceptionForFieldAccess(self, field, false);
- } else {
- field->SetObj(obj, new_value);
- return 0; // success
- }
- }
- return -1; // failure
-}
-
-extern "C" Object* artAllocObjectFromCode(uint32_t type_idx, Method* method,
- Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- return AllocObjectFromCode(type_idx, method, self, false);
-}
-
-extern "C" Object* artAllocObjectFromCodeWithAccessCheck(uint32_t type_idx, Method* method,
- Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- return AllocObjectFromCode(type_idx, method, self, true);
-}
-
-extern "C" Array* artAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
- Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- return AllocArrayFromCode(type_idx, method, component_count, self, false);
-}
-
-extern "C" Array* artAllocArrayFromCodeWithAccessCheck(uint32_t type_idx, Method* method,
- int32_t component_count,
- Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- return AllocArrayFromCode(type_idx, method, component_count, self, true);
-}
-
-extern "C" Array* artCheckAndAllocArrayFromCode(uint32_t type_idx, Method* method,
- int32_t component_count, Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- return CheckAndAllocArrayFromCode(type_idx, method, component_count, self, false);
-}
-
-extern "C" Array* artCheckAndAllocArrayFromCodeWithAccessCheck(uint32_t type_idx, Method* method,
- int32_t component_count,
- Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- return CheckAndAllocArrayFromCode(type_idx, method, component_count, self, true);
-}
-
-// Assignable test for code, won't throw. Null and equality tests already performed
-uint32_t IsAssignableFromCode(const Class* klass, const Class* ref_class) {
- DCHECK(klass != NULL);
- DCHECK(ref_class != NULL);
- return klass->IsAssignableFrom(ref_class) ? 1 : 0;
-}
-
-// Check whether it is safe to cast one class to the other, throw exception and return -1 on failure
-extern "C" int artCheckCastFromCode(const Class* a, const Class* b, Thread* self, Method** sp) {
- DCHECK(a->IsClass()) << PrettyClass(a);
- DCHECK(b->IsClass()) << PrettyClass(b);
- if (LIKELY(b->IsAssignableFrom(a))) {
- return 0; // Success
- } else {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- Thread::Current()->ThrowNewExceptionF("Ljava/lang/ClassCastException;",
- "%s cannot be cast to %s",
- PrettyDescriptor(a).c_str(),
- PrettyDescriptor(b).c_str());
- return -1; // Failure
- }
-}
-
-// Tests whether 'element' can be assigned into an array of type 'array_class'.
-// Returns 0 on success and -1 if an exception is pending.
-extern "C" int artCanPutArrayElementFromCode(const Object* element, const Class* array_class,
- Thread* self, Method** sp) {
- DCHECK(array_class != NULL);
- // element can't be NULL as we catch this is screened in runtime_support
- Class* element_class = element->GetClass();
- Class* component_type = array_class->GetComponentType();
- if (LIKELY(component_type->IsAssignableFrom(element_class))) {
- return 0; // Success
- } else {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
- "%s cannot be stored in an array of type %s",
- PrettyDescriptor(element_class).c_str(),
- PrettyDescriptor(array_class).c_str());
- return -1; // Failure
- }
-}
-
-extern "C" Class* artInitializeStaticStorageFromCode(uint32_t type_idx, const Method* referrer,
- Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- return ResolveVerifyAndClinit(type_idx, referrer, self, true, true);
-}
-
-extern "C" Class* artInitializeTypeFromCode(uint32_t type_idx, const Method* referrer, Thread* self,
- Method** sp) {
- // Called when method->dex_cache_resolved_types_[] misses
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- return ResolveVerifyAndClinit(type_idx, referrer, self, false, false);
-}
-
-extern "C" Class* artInitializeTypeAndVerifyAccessFromCode(uint32_t type_idx,
- const Method* referrer, Thread* self,
- Method** sp) {
- // Called when caller isn't guaranteed to have access to a type and the dex cache may be
- // unpopulated
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- return ResolveVerifyAndClinit(type_idx, referrer, self, false, true);
-}
-
-extern "C" String* artResolveStringFromCode(Method* referrer, int32_t string_idx,
- Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- return ResolveStringFromCode(referrer, string_idx);
-}
-
-extern "C" int artUnlockObjectFromCode(Object* obj, Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- DCHECK(obj != NULL); // Assumed to have been checked before entry
- // MonitorExit may throw exception
- return obj->MonitorExit(self) ? 0 /* Success */ : -1 /* Failure */;
-}
-
-extern "C" void artLockObjectFromCode(Object* obj, Thread* thread, Method** sp) {
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsOnly);
- DCHECK(obj != NULL); // Assumed to have been checked before entry
- obj->MonitorEnter(thread); // May block
- DCHECK(thread->HoldsLock(obj));
- // Only possible exception is NPE and is handled before entry
- DCHECK(!thread->IsExceptionPending());
-}
-
-void CheckSuspendFromCode(Thread* thread) {
- // Called when thread->suspend_count_ != 0
- Runtime::Current()->GetThreadList()->FullSuspendCheck(thread);
-}
-
-extern "C" void artTestSuspendFromCode(Thread* thread, Method** sp) {
- // Called when suspend count check value is 0 and thread->suspend_count_ != 0
- FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsOnly);
- Runtime::Current()->GetThreadList()->FullSuspendCheck(thread);
-}
-
-/*
- * Fill the array with predefined constant values, throwing exceptions if the array is null or
- * not of sufficient length.
- *
- * NOTE: When dealing with a raw dex file, the data to be copied uses
- * little-endian ordering. Require that oat2dex do any required swapping
- * so this routine can get by with a memcpy().
- *
- * Format of the data:
- * ushort ident = 0x0300 magic value
- * ushort width width of each element in the table
- * uint size number of elements in the table
- * ubyte data[size*width] table of data values (may contain a single-byte
- * padding at the end)
- */
-extern "C" int artHandleFillArrayDataFromCode(Array* array, const uint16_t* table,
- Thread* self, Method** sp) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- DCHECK_EQ(table[0], 0x0300);
- if (UNLIKELY(array == NULL)) {
- Thread::Current()->ThrowNewExceptionF("Ljava/lang/NullPointerException;",
- "null array in fill array");
- return -1; // Error
- }
- DCHECK(array->IsArrayInstance() && !array->IsObjectArray());
- uint32_t size = (uint32_t)table[2] | (((uint32_t)table[3]) << 16);
- if (UNLIKELY(static_cast<int32_t>(size) > array->GetLength())) {
- Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
- "failed array fill. length=%d; index=%d", array->GetLength(), size);
- return -1; // Error
- }
- uint16_t width = table[1];
- uint32_t size_in_bytes = size * width;
- memcpy((char*)array + Array::DataOffset(width).Int32Value(), (char*)&table[4], size_in_bytes);
- return 0; // Success
-}
-
-static uint64_t artInvokeCommon(uint32_t method_idx, Object* this_object, Method* caller_method,
- Thread* self, Method** sp, bool access_check, InvokeType type) {
- Method* method = FindMethodFast(method_idx, this_object, caller_method, access_check, type);
- if (UNLIKELY(method == NULL)) {
- FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
- if (UNLIKELY(this_object == NULL && type != kDirect && type != kStatic)) {
- ThrowNullPointerExceptionForMethodAccess(self, caller_method, method_idx, type);
- return 0; // failure
- }
- method = FindMethodFromCode(method_idx, this_object, caller_method, self, access_check, type);
- if (UNLIKELY(method == NULL)) {
- CHECK(self->IsExceptionPending());
- return 0; // failure
- }
- }
- DCHECK(!self->IsExceptionPending());
- const void* code = method->GetCode();
-
- // When we return, the caller will branch to this address, so it had better not be 0!
- CHECK(code != NULL) << PrettyMethod(method);
-
- uint32_t method_uint = reinterpret_cast<uint32_t>(method);
- uint64_t code_uint = reinterpret_cast<uint32_t>(code);
- uint64_t result = ((code_uint << 32) | method_uint);
- return result;
-}
-
-// See comments in runtime_support_asm.S
-extern "C" uint64_t artInvokeInterfaceTrampoline(uint32_t method_idx, Object* this_object,
- Method* caller_method, Thread* self,
- Method** sp) {
- return artInvokeCommon(method_idx, this_object, caller_method, self, sp, false, kInterface);
-}
-
-extern "C" uint64_t artInvokeInterfaceTrampolineWithAccessCheck(uint32_t method_idx,
- Object* this_object,
- Method* caller_method, Thread* self,
- Method** sp) {
- return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kInterface);
-}
-
-
-extern "C" uint64_t artInvokeDirectTrampolineWithAccessCheck(uint32_t method_idx,
- Object* this_object,
- Method* caller_method, Thread* self,
- Method** sp) {
- return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kDirect);
-}
-
-extern "C" uint64_t artInvokeStaticTrampolineWithAccessCheck(uint32_t method_idx,
- Object* this_object,
- Method* caller_method, Thread* self,
- Method** sp) {
- return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kStatic);
-}
-
-extern "C" uint64_t artInvokeSuperTrampolineWithAccessCheck(uint32_t method_idx,
- Object* this_object,
- Method* caller_method, Thread* self,
- Method** sp) {
- return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kSuper);
-}
-
-extern "C" uint64_t artInvokeVirtualTrampolineWithAccessCheck(uint32_t method_idx,
- Object* this_object,
- Method* caller_method, Thread* self,
- Method** sp) {
- return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kVirtual);
-}
-
-static void ThrowNewUndeclaredThrowableException(Thread* self, JNIEnv* env, Throwable* exception) {
- ScopedLocalRef<jclass> jlr_UTE_class(env,
- env->FindClass("java/lang/reflect/UndeclaredThrowableException"));
- if (jlr_UTE_class.get() == NULL) {
- LOG(ERROR) << "Couldn't throw new \"java/lang/reflect/UndeclaredThrowableException\"";
- } else {
- jmethodID jlre_UTE_constructor = env->GetMethodID(jlr_UTE_class.get(), "<init>",
- "(Ljava/lang/Throwable;)V");
- jthrowable jexception = AddLocalReference<jthrowable>(env, exception);
- ScopedLocalRef<jthrowable> jlr_UTE(env,
- reinterpret_cast<jthrowable>(env->NewObject(jlr_UTE_class.get(), jlre_UTE_constructor,
- jexception)));
- int rc = env->Throw(jlr_UTE.get());
- if (rc != JNI_OK) {
- LOG(ERROR) << "Couldn't throw new \"java/lang/reflect/UndeclaredThrowableException\"";
- }
- }
- CHECK(self->IsExceptionPending());
-}
-
-// Handler for invocation on proxy methods. On entry a frame will exist for the proxy object method
-// which is responsible for recording callee save registers. We explicitly handlerize incoming
-// reference arguments (so they survive GC) and create a boxed argument array. Finally we invoke
-// the invocation handler which is a field within the proxy object receiver.
-extern "C" void artProxyInvokeHandler(Method* proxy_method, Object* receiver,
- Thread* self, byte* stack_args) {
- // Register the top of the managed stack
- Method** proxy_sp = reinterpret_cast<Method**>(stack_args - 12);
- DCHECK_EQ(*proxy_sp, proxy_method);
- self->SetTopOfStack(proxy_sp, 0);
- // TODO: ARM specific
- DCHECK_EQ(proxy_method->GetFrameSizeInBytes(), 48u);
- // Start new JNI local reference state
- JNIEnvExt* env = self->GetJniEnv();
- ScopedJniEnvLocalRefState env_state(env);
- // Create local ref. copies of proxy method and the receiver
- jobject rcvr_jobj = AddLocalReference<jobject>(env, receiver);
- jobject proxy_method_jobj = AddLocalReference<jobject>(env, proxy_method);
-
- // Placing into local references incoming arguments from the caller's register arguments,
- // replacing original Object* with jobject
- MethodHelper proxy_mh(proxy_method);
- const size_t num_params = proxy_mh.NumArgs();
- size_t args_in_regs = 0;
- for (size_t i = 1; i < num_params; i++) { // skip receiver
- args_in_regs = args_in_regs + (proxy_mh.IsParamALongOrDouble(i) ? 2 : 1);
- if (args_in_regs > 2) {
- args_in_regs = 2;
- break;
- }
- }
- size_t cur_arg = 0; // current stack location to read
- size_t param_index = 1; // skip receiver
- while (cur_arg < args_in_regs && param_index < num_params) {
- if (proxy_mh.IsParamAReference(param_index)) {
- Object* obj = *reinterpret_cast<Object**>(stack_args + (cur_arg * kPointerSize));
- jobject jobj = AddLocalReference<jobject>(env, obj);
- *reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)) = jobj;
- }
- cur_arg = cur_arg + (proxy_mh.IsParamALongOrDouble(param_index) ? 2 : 1);
- param_index++;
- }
- // Placing into local references incoming arguments from the caller's stack arguments
- cur_arg += 11; // skip callee saves, LR, Method* and out arg spills for R1 to R3
- while (param_index < num_params) {
- if (proxy_mh.IsParamAReference(param_index)) {
- Object* obj = *reinterpret_cast<Object**>(stack_args + (cur_arg * kPointerSize));
- jobject jobj = AddLocalReference<jobject>(env, obj);
- *reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)) = jobj;
- }
- cur_arg = cur_arg + (proxy_mh.IsParamALongOrDouble(param_index) ? 2 : 1);
- param_index++;
- }
- // Set up arguments array and place in local IRT during boxing (which may allocate/GC)
- jvalue args_jobj[3];
- args_jobj[0].l = rcvr_jobj;
- args_jobj[1].l = proxy_method_jobj;
- // Args array, if no arguments then NULL (don't include receiver in argument count)
- args_jobj[2].l = NULL;
- ObjectArray<Object>* args = NULL;
- if ((num_params - 1) > 0) {
- args = Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(num_params - 1);
- if (args == NULL) {
- CHECK(self->IsExceptionPending());
- return;
- }
- args_jobj[2].l = AddLocalReference<jobjectArray>(env, args);
- }
- // Convert proxy method into expected interface method
- Method* interface_method = proxy_method->FindOverriddenMethod();
- DCHECK(interface_method != NULL);
- DCHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
- args_jobj[1].l = AddLocalReference<jobject>(env, interface_method);
- // Box arguments
- cur_arg = 0; // reset stack location to read to start
- // reset index, will index into param type array which doesn't include the receiver
- param_index = 0;
- ObjectArray<Class>* param_types = proxy_mh.GetParameterTypes();
- if (param_types == NULL) {
+Class* ResolveVerifyAndClinit(uint32_t type_idx, const Method* referrer, Thread* self,
+ bool can_run_clinit, bool verify_access) {
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ Class* klass = class_linker->ResolveType(type_idx, referrer);
+ if (UNLIKELY(klass == NULL)) {
CHECK(self->IsExceptionPending());
- return;
+ return NULL; // Failure - Indicate to caller to deliver exception
}
- // Check number of parameter types agrees with number from the Method - less 1 for the receiver.
- DCHECK_EQ(static_cast<size_t>(param_types->GetLength()), num_params - 1);
- while (cur_arg < args_in_regs && param_index < (num_params - 1)) {
- Class* param_type = param_types->Get(param_index);
- Object* obj;
- if (!param_type->IsPrimitive()) {
- obj = self->DecodeJObject(*reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)));
- } else {
- JValue val = *reinterpret_cast<JValue*>(stack_args + (cur_arg * kPointerSize));
- if (cur_arg == 1 && (param_type->IsPrimitiveLong() || param_type->IsPrimitiveDouble())) {
- // long/double split over regs and stack, mask in high half from stack arguments
- uint64_t high_half = *reinterpret_cast<uint32_t*>(stack_args + (13 * kPointerSize));
- val.j = (val.j & 0xffffffffULL) | (high_half << 32);
- }
- BoxPrimitive(param_type->GetPrimitiveType(), val);
- if (self->IsExceptionPending()) {
- return;
- }
- obj = val.l;
- }
- args->Set(param_index, obj);
- cur_arg = cur_arg + (param_type->IsPrimitiveLong() || param_type->IsPrimitiveDouble() ? 2 : 1);
- param_index++;
+ // Perform access check if necessary.
+ Class* referring_class = referrer->GetDeclaringClass();
+ if (verify_access && UNLIKELY(!referring_class->CanAccess(klass))) {
+ ThrowNewIllegalAccessErrorClass(self, referring_class, klass);
+ return NULL; // Failure - Indicate to caller to deliver exception
}
- // Placing into local references incoming arguments from the caller's stack arguments
- cur_arg += 11; // skip callee saves, LR, Method* and out arg spills for R1 to R3
- while (param_index < (num_params - 1)) {
- Class* param_type = param_types->Get(param_index);
- Object* obj;
- if (!param_type->IsPrimitive()) {
- obj = self->DecodeJObject(*reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)));
- } else {
- JValue val = *reinterpret_cast<JValue*>(stack_args + (cur_arg * kPointerSize));
- BoxPrimitive(param_type->GetPrimitiveType(), val);
- if (self->IsExceptionPending()) {
- return;
- }
- obj = val.l;
- }
- args->Set(param_index, obj);
- cur_arg = cur_arg + (param_type->IsPrimitiveLong() || param_type->IsPrimitiveDouble() ? 2 : 1);
- param_index++;
+ // If we're just implementing const-class, we shouldn't call <clinit>.
+ if (!can_run_clinit) {
+ return klass;
}
- // Get the InvocationHandler method and the field that holds it within the Proxy object
- static jmethodID inv_hand_invoke_mid = NULL;
- static jfieldID proxy_inv_hand_fid = NULL;
- if (proxy_inv_hand_fid == NULL) {
- ScopedLocalRef<jclass> proxy(env, env->FindClass("java/lang/reflect/Proxy"));
- proxy_inv_hand_fid = env->GetFieldID(proxy.get(), "h", "Ljava/lang/reflect/InvocationHandler;");
- ScopedLocalRef<jclass> inv_hand_class(env, env->FindClass("java/lang/reflect/InvocationHandler"));
- inv_hand_invoke_mid = env->GetMethodID(inv_hand_class.get(), "invoke",
- "(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;");
+ // If we are the <clinit> of this class, just return our storage.
+ //
+ // Do not set the DexCache InitializedStaticStorage, since that implies <clinit> has finished
+ // running.
+ if (klass == referring_class && MethodHelper(referrer).IsClassInitializer()) {
+ return klass;
}
- DCHECK(env->IsInstanceOf(rcvr_jobj, env->FindClass("java/lang/reflect/Proxy")));
- jobject inv_hand = env->GetObjectField(rcvr_jobj, proxy_inv_hand_fid);
- // Call InvocationHandler.invoke
- jobject result = env->CallObjectMethodA(inv_hand, inv_hand_invoke_mid, args_jobj);
- // Place result in stack args
- if (!self->IsExceptionPending()) {
- Object* result_ref = self->DecodeJObject(result);
- if (result_ref != NULL) {
- JValue result_unboxed;
- bool unboxed_okay = UnboxPrimitive(result_ref, proxy_mh.GetReturnType(), result_unboxed, "result");
- if (!unboxed_okay) {
- self->ClearException();
- self->ThrowNewExceptionF("Ljava/lang/ClassCastException;",
- "Couldn't convert result of type %s to %s",
- PrettyTypeOf(result_ref).c_str(),
- PrettyDescriptor(proxy_mh.GetReturnType()).c_str());
- return;
- }
- *reinterpret_cast<JValue*>(stack_args) = result_unboxed;
- } else {
- *reinterpret_cast<jobject*>(stack_args) = NULL;
- }
- } else {
- // In the case of checked exceptions that aren't declared, the exception must be wrapped by
- // a UndeclaredThrowableException.
- Throwable* exception = self->GetException();
- self->ClearException();
- if (!exception->IsCheckedException()) {
- self->SetException(exception);
- } else {
- SynthesizedProxyClass* proxy_class =
- down_cast<SynthesizedProxyClass*>(proxy_method->GetDeclaringClass());
- int throws_index = -1;
- size_t num_virt_methods = proxy_class->NumVirtualMethods();
- for (size_t i = 0; i < num_virt_methods; i++) {
- if (proxy_class->GetVirtualMethod(i) == proxy_method) {
- throws_index = i;
- break;
- }
- }
- CHECK_NE(throws_index, -1);
- ObjectArray<Class>* declared_exceptions = proxy_class->GetThrows()->Get(throws_index);
- Class* exception_class = exception->GetClass();
- bool declares_exception = false;
- for (int i = 0; i < declared_exceptions->GetLength() && !declares_exception; i++) {
- Class* declared_exception = declared_exceptions->Get(i);
- declares_exception = declared_exception->IsAssignableFrom(exception_class);
- }
- if (declares_exception) {
- self->SetException(exception);
- } else {
- ThrowNewUndeclaredThrowableException(self, env, exception);
- }
- }
+ if (!class_linker->EnsureInitialized(klass, true)) {
+ CHECK(self->IsExceptionPending());
+ return NULL; // Failure - Indicate to caller to deliver exception
}
-}
-
-extern "C" const void* artTraceMethodEntryFromCode(Method* method, Thread* self, uintptr_t lr) {
- Trace* tracer = Runtime::Current()->GetTracer();
- TraceStackFrame trace_frame = TraceStackFrame(method, lr);
- self->PushTraceStackFrame(trace_frame);
-
- tracer->LogMethodTraceEvent(self, method, Trace::kMethodTraceEnter);
-
- return tracer->GetSavedCodeFromMap(method);
-}
-
-extern "C" uintptr_t artTraceMethodExitFromCode() {
- Trace* tracer = Runtime::Current()->GetTracer();
- TraceStackFrame trace_frame = Thread::Current()->PopTraceStackFrame();
- Method* method = trace_frame.method_;
- uintptr_t lr = trace_frame.return_pc_;
-
- tracer->LogMethodTraceEvent(Thread::Current(), method, Trace::kMethodTraceExit);
-
- return lr;
-}
-
-uint32_t TraceMethodUnwindFromCode(Thread* self) {
- Trace* tracer = Runtime::Current()->GetTracer();
- TraceStackFrame trace_frame = self->PopTraceStackFrame();
- Method* method = trace_frame.method_;
- uint32_t lr = trace_frame.return_pc_;
-
- tracer->LogMethodTraceEvent(self, method, Trace::kMethodTraceUnwind);
-
- return lr;
-}
-
-int CmplFloat(float a, float b) {
- if (a == b) {
- return 0;
- } else if (a < b) {
- return -1;
- } else if (a > b) {
- return 1;
- }
- return -1;
-}
-
-int CmpgFloat(float a, float b) {
- if (a == b) {
- return 0;
- } else if (a < b) {
- return -1;
- } else if (a > b) {
- return 1;
- }
- return 1;
-}
-
-int CmpgDouble(double a, double b) {
- if (a == b) {
- return 0;
- } else if (a < b) {
- return -1;
- } else if (a > b) {
- return 1;
- }
- return 1;
-}
-
-int CmplDouble(double a, double b) {
- if (a == b) {
- return 0;
- } else if (a < b) {
- return -1;
- } else if (a > b) {
- return 1;
- }
- return -1;
-}
-
-/*
- * Float/double conversion requires clamping to min and max of integer form. If
- * target doesn't support this normally, use these.
- */
-int64_t D2L(double d) {
- static const double kMaxLong = (double) (int64_t) 0x7fffffffffffffffULL;
- static const double kMinLong = (double) (int64_t) 0x8000000000000000ULL;
- if (d >= kMaxLong) {
- return (int64_t) 0x7fffffffffffffffULL;
- } else if (d <= kMinLong) {
- return (int64_t) 0x8000000000000000ULL;
- } else if (d != d) { // NaN case
- return 0;
- } else {
- return (int64_t) d;
- }
-}
-
-int64_t F2L(float f) {
- static const float kMaxLong = (float) (int64_t) 0x7fffffffffffffffULL;
- static const float kMinLong = (float) (int64_t) 0x8000000000000000ULL;
- if (f >= kMaxLong) {
- return (int64_t) 0x7fffffffffffffffULL;
- } else if (f <= kMinLong) {
- return (int64_t) 0x8000000000000000ULL;
- } else if (f != f) { // NaN case
- return 0;
- } else {
- return (int64_t) f;
- }
+ referrer->GetDexCacheInitializedStaticStorage()->Set(type_idx, klass);
+ return klass;
}
} // namespace art