blob: 3a3eaf1f17b0b4e9cd4da17ddf649cf4cc8235bd [file] [log] [blame]
Shih-wei Liao2d831012011-09-28 22:06:53 -07001/*
2 * Copyright 2011 Google Inc. All Rights Reserved.
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#include "runtime_support.h"
18
Ian Rogerscaab8c42011-10-12 12:11:18 -070019#include "dex_cache.h"
Elliott Hughes6c8867d2011-10-03 16:34:05 -070020#include "dex_verifier.h"
Ian Rogerscaab8c42011-10-12 12:11:18 -070021#include "macros.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080022#include "object.h"
23#include "object_utils.h"
Ian Rogersdfcdf1a2011-10-10 17:50:35 -070024#include "reflection.h"
jeffhaoe343b762011-12-05 16:36:44 -080025#include "trace.h"
Ian Rogersdfcdf1a2011-10-10 17:50:35 -070026#include "ScopedLocalRef.h"
Elliott Hughes6c8867d2011-10-03 16:34:05 -070027
Shih-wei Liao2d831012011-09-28 22:06:53 -070028namespace art {
29
Ian Rogers4f0d07c2011-10-06 23:38:47 -070030// Place a special frame at the TOS that will save the callee saves for the given type
31static void FinishCalleeSaveFrameSetup(Thread* self, Method** sp, Runtime::CalleeSaveType type) {
Ian Rogersce9eca62011-10-07 17:11:03 -070032 // Be aware the store below may well stomp on an incoming argument
Ian Rogers4f0d07c2011-10-06 23:38:47 -070033 *sp = Runtime::Current()->GetCalleeSaveMethod(type);
34 self->SetTopOfStack(sp, 0);
35}
36
Shih-wei Liao2d831012011-09-28 22:06:53 -070037// Temporary debugging hook for compiler.
38extern void DebugMe(Method* method, uint32_t info) {
39 LOG(INFO) << "DebugMe";
40 if (method != NULL) {
41 LOG(INFO) << PrettyMethod(method);
42 }
43 LOG(INFO) << "Info: " << info;
44}
45
Brian Carlstrom6fd03fb2011-10-17 16:11:00 -070046extern "C" uint32_t artObjectInitFromCode(Object* o, Thread* self, Method** sp) {
47 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Ian Rogerscaab8c42011-10-12 12:11:18 -070048 Class* c = o->GetClass();
49 if (UNLIKELY(c->IsFinalizable())) {
Ian Rogers5d4bdc22011-11-02 22:15:43 -070050 Heap::AddFinalizerReference(self, o);
Ian Rogerscaab8c42011-10-12 12:11:18 -070051 }
52 /*
53 * NOTE: once debugger/profiler support is added, we'll need to check
54 * here and branch to actual compiled object.<init> to handle any
Ian Rogers0571d352011-11-03 19:51:38 -070055 * breakpoint/logging activities if either is active.
Ian Rogerscaab8c42011-10-12 12:11:18 -070056 */
Brian Carlstrom6fd03fb2011-10-17 16:11:00 -070057 return self->IsExceptionPending() ? -1 : 0;
Ian Rogerscaab8c42011-10-12 12:11:18 -070058}
59
Shih-wei Liao2d831012011-09-28 22:06:53 -070060// Return value helper for jobject return types
61extern Object* DecodeJObjectInThread(Thread* thread, jobject obj) {
Brian Carlstrom6f495f22011-10-10 15:05:03 -070062 if (thread->IsExceptionPending()) {
63 return NULL;
64 }
Shih-wei Liao2d831012011-09-28 22:06:53 -070065 return thread->DecodeJObject(obj);
66}
67
68extern void* FindNativeMethod(Thread* thread) {
69 DCHECK(Thread::Current() == thread);
70
71 Method* method = const_cast<Method*>(thread->GetCurrentMethod());
72 DCHECK(method != NULL);
73
74 // Lookup symbol address for method, on failure we'll return NULL with an
75 // exception set, otherwise we return the address of the method we found.
76 void* native_code = thread->GetJniEnv()->vm->FindCodeForNativeMethod(method);
77 if (native_code == NULL) {
78 DCHECK(thread->IsExceptionPending());
79 return NULL;
80 } else {
81 // Register so that future calls don't come here
82 method->RegisterNative(native_code);
83 return native_code;
84 }
85}
86
87// Called by generated call to throw an exception
88extern "C" void artDeliverExceptionFromCode(Throwable* exception, Thread* thread, Method** sp) {
89 /*
90 * exception may be NULL, in which case this routine should
91 * throw NPE. NOTE: this is a convenience for generated code,
92 * which previously did the null check inline and constructed
93 * and threw a NPE if NULL. This routine responsible for setting
94 * exception_ in thread and delivering the exception.
95 */
Ian Rogers4f0d07c2011-10-06 23:38:47 -070096 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
Shih-wei Liao2d831012011-09-28 22:06:53 -070097 if (exception == NULL) {
98 thread->ThrowNewException("Ljava/lang/NullPointerException;", "throw with null exception");
99 } else {
100 thread->SetException(exception);
101 }
102 thread->DeliverException();
103}
104
105// Deliver an exception that's pending on thread helping set up a callee save frame on the way
106extern "C" void artDeliverPendingExceptionFromCode(Thread* thread, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700107 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700108 thread->DeliverException();
109}
110
111// Called by generated call to throw a NPE exception
112extern "C" void artThrowNullPointerExceptionFromCode(Thread* thread, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700113 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700114 thread->ThrowNewException("Ljava/lang/NullPointerException;", NULL);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700115 thread->DeliverException();
116}
117
118// Called by generated call to throw an arithmetic divide by zero exception
119extern "C" void artThrowDivZeroFromCode(Thread* thread, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700120 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700121 thread->ThrowNewException("Ljava/lang/ArithmeticException;", "divide by zero");
122 thread->DeliverException();
123}
124
125// Called by generated call to throw an arithmetic divide by zero exception
126extern "C" void artThrowArrayBoundsFromCode(int index, int limit, Thread* thread, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700127 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
128 thread->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
129 "length=%d; index=%d", limit, index);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700130 thread->DeliverException();
131}
132
133// Called by the AbstractMethodError stub (not runtime support)
134extern void ThrowAbstractMethodErrorFromCode(Method* method, Thread* thread, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700135 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
136 thread->ThrowNewExceptionF("Ljava/lang/AbstractMethodError;",
137 "abstract method \"%s\"", PrettyMethod(method).c_str());
Shih-wei Liao2d831012011-09-28 22:06:53 -0700138 thread->DeliverException();
139}
140
141extern "C" void artThrowStackOverflowFromCode(Method* method, Thread* thread, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700142 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
jeffhaoe343b762011-12-05 16:36:44 -0800143 // Remove extra entry pushed onto second stack during method tracing
144 if (Trace::IsMethodTracingActive()) {
145 artTraceMethodUnwindFromCode(thread);
146 }
Shih-wei Liao2d831012011-09-28 22:06:53 -0700147 thread->SetStackEndForStackOverflow(); // Allow space on the stack for constructor to execute
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700148 thread->ThrowNewExceptionF("Ljava/lang/StackOverflowError;",
149 "stack size %zdkb; default stack size: %zdkb",
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700150 thread->GetStackSize() / KB, Runtime::Current()->GetDefaultStackSize() / KB);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700151 thread->ResetDefaultStackEnd(); // Return to default stack size
152 thread->DeliverException();
153}
154
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700155static std::string ClassNameFromIndex(Method* method, uint32_t ref,
Ian Rogersd81871c2011-10-03 13:57:23 -0700156 verifier::VerifyErrorRefType ref_type, bool access) {
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700157 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
158 const DexFile& dex_file = class_linker->FindDexFile(method->GetDeclaringClass()->GetDexCache());
159
160 uint16_t type_idx = 0;
Ian Rogersd81871c2011-10-03 13:57:23 -0700161 if (ref_type == verifier::VERIFY_ERROR_REF_FIELD) {
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700162 const DexFile::FieldId& id = dex_file.GetFieldId(ref);
163 type_idx = id.class_idx_;
Ian Rogersd81871c2011-10-03 13:57:23 -0700164 } else if (ref_type == verifier::VERIFY_ERROR_REF_METHOD) {
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700165 const DexFile::MethodId& id = dex_file.GetMethodId(ref);
166 type_idx = id.class_idx_;
Ian Rogersd81871c2011-10-03 13:57:23 -0700167 } else if (ref_type == verifier::VERIFY_ERROR_REF_CLASS) {
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700168 type_idx = ref;
169 } else {
170 CHECK(false) << static_cast<int>(ref_type);
171 }
172
Ian Rogers0571d352011-11-03 19:51:38 -0700173 std::string class_name(PrettyDescriptor(dex_file.StringByTypeIdx(type_idx)));
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700174 if (!access) {
175 return class_name;
176 }
177
178 std::string result;
179 result += "tried to access class ";
180 result += class_name;
181 result += " from class ";
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800182 result += PrettyDescriptor(method->GetDeclaringClass());
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700183 return result;
184}
185
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700186static std::string FieldNameFromIndex(const Method* method, uint32_t ref,
Ian Rogersd81871c2011-10-03 13:57:23 -0700187 verifier::VerifyErrorRefType ref_type, bool access) {
188 CHECK_EQ(static_cast<int>(ref_type), static_cast<int>(verifier::VERIFY_ERROR_REF_FIELD));
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700189
190 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
191 const DexFile& dex_file = class_linker->FindDexFile(method->GetDeclaringClass()->GetDexCache());
192
193 const DexFile::FieldId& id = dex_file.GetFieldId(ref);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700194 std::string class_name(PrettyDescriptor(dex_file.GetFieldDeclaringClassDescriptor(id)));
Ian Rogers0571d352011-11-03 19:51:38 -0700195 const char* field_name = dex_file.StringDataByIdx(id.name_idx_);
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700196 if (!access) {
197 return class_name + "." + field_name;
198 }
199
200 std::string result;
201 result += "tried to access field ";
202 result += class_name + "." + field_name;
203 result += " from class ";
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800204 result += PrettyDescriptor(method->GetDeclaringClass());
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700205 return result;
206}
207
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700208static std::string MethodNameFromIndex(const Method* method, uint32_t ref,
Ian Rogersd81871c2011-10-03 13:57:23 -0700209 verifier::VerifyErrorRefType ref_type, bool access) {
210 CHECK_EQ(static_cast<int>(ref_type), static_cast<int>(verifier::VERIFY_ERROR_REF_METHOD));
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700211
212 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
213 const DexFile& dex_file = class_linker->FindDexFile(method->GetDeclaringClass()->GetDexCache());
214
215 const DexFile::MethodId& id = dex_file.GetMethodId(ref);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700216 std::string class_name(PrettyDescriptor(dex_file.GetMethodDeclaringClassDescriptor(id)));
Ian Rogers0571d352011-11-03 19:51:38 -0700217 const char* method_name = dex_file.StringDataByIdx(id.name_idx_);
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700218 if (!access) {
219 return class_name + "." + method_name;
220 }
221
222 std::string result;
223 result += "tried to access method ";
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700224 result += class_name + "." + method_name + ":" +
Ian Rogers0571d352011-11-03 19:51:38 -0700225 dex_file.CreateMethodSignature(id.proto_idx_, NULL);
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700226 result += " from class ";
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800227 result += PrettyDescriptor(method->GetDeclaringClass());
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700228 return result;
229}
230
231extern "C" void artThrowVerificationErrorFromCode(int32_t kind, int32_t ref, Thread* self, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700232 FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
233 Frame frame = self->GetTopOfStack(); // We need the calling method as context to interpret 'ref'
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700234 frame.Next();
235 Method* method = frame.GetMethod();
236
Ian Rogersd81871c2011-10-03 13:57:23 -0700237 verifier::VerifyErrorRefType ref_type =
238 static_cast<verifier::VerifyErrorRefType>(kind >> verifier::kVerifyErrorRefTypeShift);
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700239
240 const char* exception_class = "Ljava/lang/VerifyError;";
241 std::string msg;
242
Ian Rogersd81871c2011-10-03 13:57:23 -0700243 switch (static_cast<verifier::VerifyError>(kind & ~(0xff << verifier::kVerifyErrorRefTypeShift))) {
244 case verifier::VERIFY_ERROR_NO_CLASS:
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700245 exception_class = "Ljava/lang/NoClassDefFoundError;";
246 msg = ClassNameFromIndex(method, ref, ref_type, false);
247 break;
Ian Rogersd81871c2011-10-03 13:57:23 -0700248 case verifier::VERIFY_ERROR_NO_FIELD:
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700249 exception_class = "Ljava/lang/NoSuchFieldError;";
250 msg = FieldNameFromIndex(method, ref, ref_type, false);
251 break;
Ian Rogersd81871c2011-10-03 13:57:23 -0700252 case verifier::VERIFY_ERROR_NO_METHOD:
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700253 exception_class = "Ljava/lang/NoSuchMethodError;";
254 msg = MethodNameFromIndex(method, ref, ref_type, false);
255 break;
Ian Rogersd81871c2011-10-03 13:57:23 -0700256 case verifier::VERIFY_ERROR_ACCESS_CLASS:
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700257 exception_class = "Ljava/lang/IllegalAccessError;";
258 msg = ClassNameFromIndex(method, ref, ref_type, true);
259 break;
Ian Rogersd81871c2011-10-03 13:57:23 -0700260 case verifier::VERIFY_ERROR_ACCESS_FIELD:
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700261 exception_class = "Ljava/lang/IllegalAccessError;";
262 msg = FieldNameFromIndex(method, ref, ref_type, true);
263 break;
Ian Rogersd81871c2011-10-03 13:57:23 -0700264 case verifier::VERIFY_ERROR_ACCESS_METHOD:
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700265 exception_class = "Ljava/lang/IllegalAccessError;";
266 msg = MethodNameFromIndex(method, ref, ref_type, true);
267 break;
Ian Rogersd81871c2011-10-03 13:57:23 -0700268 case verifier::VERIFY_ERROR_CLASS_CHANGE:
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700269 exception_class = "Ljava/lang/IncompatibleClassChangeError;";
270 msg = ClassNameFromIndex(method, ref, ref_type, false);
271 break;
Ian Rogersd81871c2011-10-03 13:57:23 -0700272 case verifier::VERIFY_ERROR_INSTANTIATION:
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700273 exception_class = "Ljava/lang/InstantiationError;";
274 msg = ClassNameFromIndex(method, ref, ref_type, false);
275 break;
Ian Rogersd81871c2011-10-03 13:57:23 -0700276 case verifier::VERIFY_ERROR_GENERIC:
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700277 // Generic VerifyError; use default exception, no message.
278 break;
Ian Rogersd81871c2011-10-03 13:57:23 -0700279 case verifier::VERIFY_ERROR_NONE:
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700280 CHECK(false);
281 break;
282 }
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700283 self->ThrowNewException(exception_class, msg.c_str());
284 self->DeliverException();
Shih-wei Liao2d831012011-09-28 22:06:53 -0700285}
286
287extern "C" void artThrowInternalErrorFromCode(int32_t errnum, Thread* thread, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700288 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700289 LOG(WARNING) << "TODO: internal error detail message. errnum=" << errnum;
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700290 thread->ThrowNewExceptionF("Ljava/lang/InternalError;", "errnum=%d", errnum);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700291 thread->DeliverException();
292}
293
294extern "C" void artThrowRuntimeExceptionFromCode(int32_t errnum, Thread* thread, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700295 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700296 LOG(WARNING) << "TODO: runtime exception detail message. errnum=" << errnum;
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700297 thread->ThrowNewExceptionF("Ljava/lang/RuntimeException;", "errnum=%d", errnum);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700298 thread->DeliverException();
299}
300
Elliott Hughese1410a22011-10-04 12:10:24 -0700301extern "C" void artThrowNoSuchMethodFromCode(int32_t method_idx, Thread* self, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700302 FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
303 Frame frame = self->GetTopOfStack(); // We need the calling method as context for the method_idx
Elliott Hughese1410a22011-10-04 12:10:24 -0700304 frame.Next();
305 Method* method = frame.GetMethod();
Elliott Hughese1410a22011-10-04 12:10:24 -0700306 self->ThrowNewException("Ljava/lang/NoSuchMethodError;",
Ian Rogersd81871c2011-10-03 13:57:23 -0700307 MethodNameFromIndex(method, method_idx, verifier::VERIFY_ERROR_REF_METHOD, false).c_str());
Elliott Hughese1410a22011-10-04 12:10:24 -0700308 self->DeliverException();
Shih-wei Liao2d831012011-09-28 22:06:53 -0700309}
310
311extern "C" void artThrowNegArraySizeFromCode(int32_t size, Thread* thread, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700312 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700313 LOG(WARNING) << "UNTESTED artThrowNegArraySizeFromCode";
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700314 thread->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", size);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700315 thread->DeliverException();
316}
317
Brian Carlstrom6a4be3a2011-10-20 16:34:03 -0700318void* UnresolvedDirectMethodTrampolineFromCode(int32_t method_idx, Method** sp, Thread* thread,
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700319 Runtime::TrampolineType type) {
Ian Rogersad25ac52011-10-04 19:13:33 -0700320 // TODO: this code is specific to ARM
321 // On entry the stack pointed by sp is:
322 // | argN | |
323 // | ... | |
324 // | arg4 | |
325 // | arg3 spill | | Caller's frame
326 // | arg2 spill | |
327 // | arg1 spill | |
328 // | Method* | ---
329 // | LR |
Brian Carlstrom6a4be3a2011-10-20 16:34:03 -0700330 // | ... | callee saves
Ian Rogersad25ac52011-10-04 19:13:33 -0700331 // | R3 | arg3
332 // | R2 | arg2
333 // | R1 | arg1
Brian Carlstrom6a4be3a2011-10-20 16:34:03 -0700334 // | R0 |
335 // | Method* | <- sp
336 uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp) + kPointerSize);
337 DCHECK_EQ(48U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
338 Method** caller_sp = reinterpret_cast<Method**>(reinterpret_cast<byte*>(sp) + 48);
339 uintptr_t caller_pc = regs[10];
340 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsAndArgs);
Ian Rogersad25ac52011-10-04 19:13:33 -0700341 // Start new JNI local reference state
342 JNIEnvExt* env = thread->GetJniEnv();
Ian Rogersdfcdf1a2011-10-10 17:50:35 -0700343 ScopedJniEnvLocalRefState env_state(env);
Ian Rogersad25ac52011-10-04 19:13:33 -0700344 // Discover shorty (avoid GCs)
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700345 ClassLinker* linker = Runtime::Current()->GetClassLinker();
Ian Rogersad25ac52011-10-04 19:13:33 -0700346 const char* shorty = linker->MethodShorty(method_idx, *caller_sp);
347 size_t shorty_len = strlen(shorty);
Ian Rogers14b1b242011-10-11 18:54:34 -0700348 size_t args_in_regs = 0;
349 for (size_t i = 1; i < shorty_len; i++) {
350 char c = shorty[i];
351 args_in_regs = args_in_regs + (c == 'J' || c == 'D' ? 2 : 1);
352 if (args_in_regs > 3) {
353 args_in_regs = 3;
354 break;
355 }
356 }
Ian Rogersea2a11d2011-10-11 16:48:51 -0700357 bool is_static;
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700358 if (type == Runtime::kUnknownMethod) {
Ian Rogersea2a11d2011-10-11 16:48:51 -0700359 Method* caller = *caller_sp;
Ian Rogersdf9a7822011-10-11 16:53:22 -0700360 // less two as return address may span into next dex instruction
361 uint32_t dex_pc = caller->ToDexPC(caller_pc - 2);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800362 const DexFile::CodeItem* code = MethodHelper(caller).GetCodeItem();
Ian Rogersd81871c2011-10-03 13:57:23 -0700363 CHECK_LT(dex_pc, code->insns_size_in_code_units_);
364 const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
Ian Rogersea2a11d2011-10-11 16:48:51 -0700365 Instruction::Code instr_code = instr->Opcode();
366 is_static = (instr_code == Instruction::INVOKE_STATIC) ||
367 (instr_code == Instruction::INVOKE_STATIC_RANGE);
368 DCHECK(is_static || (instr_code == Instruction::INVOKE_DIRECT) ||
369 (instr_code == Instruction::INVOKE_DIRECT_RANGE));
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700370 } else {
Ian Rogersea2a11d2011-10-11 16:48:51 -0700371 is_static = type == Runtime::kStaticMethod;
372 }
Ian Rogerscaab8c42011-10-12 12:11:18 -0700373 // Place into local references incoming arguments from the caller's register arguments
Ian Rogers14b1b242011-10-11 18:54:34 -0700374 size_t cur_arg = 1; // skip method_idx in R0, first arg is in R1
Ian Rogersea2a11d2011-10-11 16:48:51 -0700375 if (!is_static) {
376 Object* obj = reinterpret_cast<Object*>(regs[cur_arg]);
377 cur_arg++;
Ian Rogers14b1b242011-10-11 18:54:34 -0700378 if (args_in_regs < 3) {
379 // If we thought we had fewer than 3 arguments in registers, account for the receiver
380 args_in_regs++;
381 }
Ian Rogersea2a11d2011-10-11 16:48:51 -0700382 AddLocalReference<jobject>(env, obj);
383 }
Ian Rogers14b1b242011-10-11 18:54:34 -0700384 size_t shorty_index = 1; // skip return value
385 // Iterate while arguments and arguments in registers (less 1 from cur_arg which is offset to skip
386 // R0)
387 while ((cur_arg - 1) < args_in_regs && shorty_index < shorty_len) {
388 char c = shorty[shorty_index];
389 shorty_index++;
Ian Rogersea2a11d2011-10-11 16:48:51 -0700390 if (c == 'L') {
Ian Rogersad25ac52011-10-04 19:13:33 -0700391 Object* obj = reinterpret_cast<Object*>(regs[cur_arg]);
392 AddLocalReference<jobject>(env, obj);
393 }
Ian Rogersea2a11d2011-10-11 16:48:51 -0700394 cur_arg = cur_arg + (c == 'J' || c == 'D' ? 2 : 1);
395 }
Ian Rogerscaab8c42011-10-12 12:11:18 -0700396 // Place into local references incoming arguments from the caller's stack arguments
Brian Carlstrom6a4be3a2011-10-20 16:34:03 -0700397 cur_arg += 11; // skip LR, Method* and spills for R1 to R3 and callee saves
Ian Rogers14b1b242011-10-11 18:54:34 -0700398 while (shorty_index < shorty_len) {
399 char c = shorty[shorty_index];
400 shorty_index++;
Ian Rogersea2a11d2011-10-11 16:48:51 -0700401 if (c == 'L') {
Ian Rogers14b1b242011-10-11 18:54:34 -0700402 Object* obj = reinterpret_cast<Object*>(regs[cur_arg]);
Ian Rogersea2a11d2011-10-11 16:48:51 -0700403 AddLocalReference<jobject>(env, obj);
Ian Rogersad25ac52011-10-04 19:13:33 -0700404 }
Ian Rogersea2a11d2011-10-11 16:48:51 -0700405 cur_arg = cur_arg + (c == 'J' || c == 'D' ? 2 : 1);
Ian Rogersad25ac52011-10-04 19:13:33 -0700406 }
407 // Resolve method filling in dex cache
408 Method* called = linker->ResolveMethod(method_idx, *caller_sp, true);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700409 if (LIKELY(!thread->IsExceptionPending())) {
Brian Carlstromb2062cf2011-11-03 01:24:44 -0700410 // Update CodeAndDirectMethod table
411 Method* caller = *caller_sp;
412 DexCache* dex_cache = caller->GetDeclaringClass()->GetDexCache();
413 dex_cache->GetCodeAndDirectMethods()->SetResolvedDirectMethod(method_idx, called);
Ian Rogersad25ac52011-10-04 19:13:33 -0700414 // We got this far, ensure that the declaring class is initialized
415 linker->EnsureInitialized(called->GetDeclaringClass(), true);
416 }
Ian Rogersad25ac52011-10-04 19:13:33 -0700417 void* code;
Ian Rogerscaab8c42011-10-12 12:11:18 -0700418 if (UNLIKELY(thread->IsExceptionPending())) {
Brian Carlstromb2062cf2011-11-03 01:24:44 -0700419 // Something went wrong in ResolveMethod or EnsureInitialized,
420 // go into deliver exception with the pending exception in r0
Ian Rogersad25ac52011-10-04 19:13:33 -0700421 code = reinterpret_cast<void*>(art_deliver_exception_from_code);
Brian Carlstromb2062cf2011-11-03 01:24:44 -0700422 regs[0] = reinterpret_cast<uintptr_t>(thread->GetException());
Ian Rogersad25ac52011-10-04 19:13:33 -0700423 thread->ClearException();
424 } else {
425 // Expect class to at least be initializing
426 CHECK(called->GetDeclaringClass()->IsInitializing());
427 // Set up entry into main method
Brian Carlstromb2062cf2011-11-03 01:24:44 -0700428 regs[0] = reinterpret_cast<uintptr_t>(called);
Ian Rogersad25ac52011-10-04 19:13:33 -0700429 code = const_cast<void*>(called->GetCode());
430 }
431 return code;
432}
433
Ian Rogerscaab8c42011-10-12 12:11:18 -0700434// Fast path field resolution that can't throw exceptions
435static Field* FindFieldFast(uint32_t field_idx, const Method* referrer) {
436 Field* resolved_field = referrer->GetDexCacheResolvedFields()->Get(field_idx);
437 if (UNLIKELY(resolved_field == NULL)) {
438 return NULL;
439 }
440 Class* fields_class = resolved_field->GetDeclaringClass();
441 // Check class is initilaized or initializing
442 if (UNLIKELY(!fields_class->IsInitializing())) {
443 return NULL;
444 }
445 return resolved_field;
446}
447
448// Slow path field resolution and declaring class initialization
Ian Rogersce9eca62011-10-07 17:11:03 -0700449Field* FindFieldFromCode(uint32_t field_idx, const Method* referrer, bool is_static) {
450 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Ian Rogerscaab8c42011-10-12 12:11:18 -0700451 Field* resolved_field = class_linker->ResolveField(field_idx, referrer, is_static);
452 if (LIKELY(resolved_field != NULL)) {
453 Class* fields_class = resolved_field->GetDeclaringClass();
Ian Rogersce9eca62011-10-07 17:11:03 -0700454 // If the class is already initializing, we must be inside <clinit>, or
455 // we'd still be waiting for the lock.
Ian Rogerscaab8c42011-10-12 12:11:18 -0700456 if (fields_class->IsInitializing()) {
457 return resolved_field;
458 }
Elliott Hughes362f9bc2011-10-17 18:56:41 -0700459 if (Runtime::Current()->GetClassLinker()->EnsureInitialized(fields_class, true)) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700460 return resolved_field;
Ian Rogersce9eca62011-10-07 17:11:03 -0700461 }
462 }
463 DCHECK(Thread::Current()->IsExceptionPending()); // Throw exception and unwind
464 return NULL;
465}
466
467extern "C" Field* artFindInstanceFieldFromCode(uint32_t field_idx, const Method* referrer,
468 Thread* self, Method** sp) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700469 Field* resolved_field = FindFieldFast(field_idx, referrer);
470 if (UNLIKELY(resolved_field == NULL)) {
471 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
472 resolved_field = FindFieldFromCode(field_idx, referrer, false);
473 }
474 return resolved_field;
Ian Rogersce9eca62011-10-07 17:11:03 -0700475}
476
477extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx, const Method* referrer,
478 Thread* self, Method** sp) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700479 Field* field = FindFieldFast(field_idx, referrer);
480 if (LIKELY(field != NULL)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800481 FieldHelper fh(field);
482 if (LIKELY(fh.IsPrimitiveType() && fh.FieldSize() == sizeof(int32_t))) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700483 return field->Get32(NULL);
484 }
485 }
Ian Rogersce9eca62011-10-07 17:11:03 -0700486 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700487 field = FindFieldFromCode(field_idx, referrer, true);
Ian Rogersce9eca62011-10-07 17:11:03 -0700488 if (field != NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800489 FieldHelper fh(field);
490 if (!fh.IsPrimitiveType() || fh.FieldSize() != sizeof(int32_t)) {
Ian Rogersce9eca62011-10-07 17:11:03 -0700491 self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
492 "Attempted read of 32-bit primitive on field '%s'",
493 PrettyField(field, true).c_str());
494 } else {
495 return field->Get32(NULL);
496 }
497 }
498 return 0; // Will throw exception by checking with Thread::Current
499}
500
501extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx, const Method* referrer,
502 Thread* self, Method** sp) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700503 Field* field = FindFieldFast(field_idx, referrer);
504 if (LIKELY(field != NULL)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800505 FieldHelper fh(field);
506 if (LIKELY(fh.IsPrimitiveType() && fh.FieldSize() == sizeof(int64_t))) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700507 return field->Get64(NULL);
508 }
509 }
Ian Rogersce9eca62011-10-07 17:11:03 -0700510 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700511 field = FindFieldFromCode(field_idx, referrer, true);
Ian Rogersce9eca62011-10-07 17:11:03 -0700512 if (field != NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800513 FieldHelper fh(field);
514 if (!fh.IsPrimitiveType() || fh.FieldSize() != sizeof(int64_t)) {
Ian Rogersce9eca62011-10-07 17:11:03 -0700515 self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
516 "Attempted read of 64-bit primitive on field '%s'",
517 PrettyField(field, true).c_str());
518 } else {
519 return field->Get64(NULL);
520 }
521 }
522 return 0; // Will throw exception by checking with Thread::Current
523}
524
525extern "C" Object* artGetObjStaticFromCode(uint32_t field_idx, const Method* referrer,
526 Thread* self, Method** sp) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700527 Field* field = FindFieldFast(field_idx, referrer);
528 if (LIKELY(field != NULL)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800529 FieldHelper fh(field);
530 if (LIKELY(!fh.IsPrimitiveType())) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700531 return field->GetObj(NULL);
532 }
533 }
Ian Rogersce9eca62011-10-07 17:11:03 -0700534 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700535 field = FindFieldFromCode(field_idx, referrer, true);
Ian Rogersce9eca62011-10-07 17:11:03 -0700536 if (field != NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800537 FieldHelper fh(field);
538 if (fh.IsPrimitiveType()) {
Ian Rogersce9eca62011-10-07 17:11:03 -0700539 self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
540 "Attempted read of reference on primitive field '%s'",
541 PrettyField(field, true).c_str());
542 } else {
543 return field->GetObj(NULL);
544 }
545 }
546 return NULL; // Will throw exception by checking with Thread::Current
547}
548
549extern "C" int artSet32StaticFromCode(uint32_t field_idx, const Method* referrer,
550 uint32_t new_value, Thread* self, Method** sp) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700551 Field* field = FindFieldFast(field_idx, referrer);
552 if (LIKELY(field != NULL)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800553 FieldHelper fh(field);
554 if (LIKELY(fh.IsPrimitiveType() && fh.FieldSize() == sizeof(int32_t))) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700555 field->Set32(NULL, new_value);
556 return 0; // success
557 }
558 }
Ian Rogersce9eca62011-10-07 17:11:03 -0700559 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700560 field = FindFieldFromCode(field_idx, referrer, true);
Ian Rogersce9eca62011-10-07 17:11:03 -0700561 if (field != NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800562 FieldHelper fh(field);
563 if (!fh.IsPrimitiveType() || fh.FieldSize() != sizeof(int32_t)) {
Ian Rogersce9eca62011-10-07 17:11:03 -0700564 self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
565 "Attempted write of 32-bit primitive to field '%s'",
566 PrettyField(field, true).c_str());
567 } else {
568 field->Set32(NULL, new_value);
569 return 0; // success
570 }
571 }
572 return -1; // failure
573}
574
575extern "C" int artSet64StaticFromCode(uint32_t field_idx, const Method* referrer,
576 uint64_t new_value, Thread* self, Method** sp) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700577 Field* field = FindFieldFast(field_idx, referrer);
578 if (LIKELY(field != NULL)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800579 FieldHelper fh(field);
580 if (LIKELY(fh.IsPrimitiveType() && fh.FieldSize() == sizeof(int64_t))) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700581 field->Set64(NULL, new_value);
582 return 0; // success
583 }
584 }
585 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
586 field = FindFieldFromCode(field_idx, referrer, true);
587 if (LIKELY(field != NULL)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800588 FieldHelper fh(field);
589 if (UNLIKELY(!fh.IsPrimitiveType() || fh.FieldSize() != sizeof(int64_t))) {
Ian Rogersce9eca62011-10-07 17:11:03 -0700590 self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
591 "Attempted write of 64-bit primitive to field '%s'",
592 PrettyField(field, true).c_str());
593 } else {
594 field->Set64(NULL, new_value);
595 return 0; // success
596 }
597 }
598 return -1; // failure
599}
600
601extern "C" int artSetObjStaticFromCode(uint32_t field_idx, const Method* referrer,
602 Object* new_value, Thread* self, Method** sp) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700603 Field* field = FindFieldFast(field_idx, referrer);
604 if (LIKELY(field != NULL)) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800605 if (LIKELY(!FieldHelper(field).IsPrimitiveType())) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700606 field->SetObj(NULL, new_value);
607 return 0; // success
608 }
609 }
Ian Rogersce9eca62011-10-07 17:11:03 -0700610 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700611 field = FindFieldFromCode(field_idx, referrer, true);
Ian Rogersce9eca62011-10-07 17:11:03 -0700612 if (field != NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800613 if (FieldHelper(field).IsPrimitiveType()) {
Ian Rogersce9eca62011-10-07 17:11:03 -0700614 self->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
615 "Attempted write of reference to primitive field '%s'",
616 PrettyField(field, true).c_str());
617 } else {
618 field->SetObj(NULL, new_value);
619 return 0; // success
620 }
621 }
622 return -1; // failure
623}
624
Shih-wei Liao2d831012011-09-28 22:06:53 -0700625// Given the context of a calling Method, use its DexCache to resolve a type to a Class. If it
626// cannot be resolved, throw an error. If it can, use it to create an instance.
Ian Rogerscaab8c42011-10-12 12:11:18 -0700627extern "C" Object* artAllocObjectFromCode(uint32_t type_idx, Method* method,
628 Thread* self, Method** sp) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700629 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700630 Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700631 Runtime* runtime = Runtime::Current();
Ian Rogerscaab8c42011-10-12 12:11:18 -0700632 if (UNLIKELY(klass == NULL)) {
buzbee33a129c2011-10-06 16:53:20 -0700633 klass = runtime->GetClassLinker()->ResolveType(type_idx, method);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700634 if (klass == NULL) {
buzbee33a129c2011-10-06 16:53:20 -0700635 DCHECK(self->IsExceptionPending());
Shih-wei Liao2d831012011-09-28 22:06:53 -0700636 return NULL; // Failure
637 }
638 }
buzbee33a129c2011-10-06 16:53:20 -0700639 if (!runtime->GetClassLinker()->EnsureInitialized(klass, true)) {
640 DCHECK(self->IsExceptionPending());
Shih-wei Liao2d831012011-09-28 22:06:53 -0700641 return NULL; // Failure
642 }
643 return klass->AllocObject();
644}
645
Ian Rogers28ad40d2011-10-27 15:19:26 -0700646extern "C" Object* artAllocObjectFromCodeWithAccessCheck(uint32_t type_idx, Method* method,
647 Thread* self, Method** sp) {
648 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
649 Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
650 Runtime* runtime = Runtime::Current();
651 if (UNLIKELY(klass == NULL)) {
652 klass = runtime->GetClassLinker()->ResolveType(type_idx, method);
653 if (klass == NULL) {
654 DCHECK(self->IsExceptionPending());
655 return NULL; // Failure
656 }
657 }
658 Class* referrer = method->GetDeclaringClass();
659 if (UNLIKELY(!referrer->CanAccess(klass))) {
660 self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;", "illegal class access: '%s' -> '%s'",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800661 PrettyDescriptor(referrer).c_str(),
662 PrettyDescriptor(klass).c_str());
Ian Rogers28ad40d2011-10-27 15:19:26 -0700663 return NULL; // Failure
664 }
665 if (!runtime->GetClassLinker()->EnsureInitialized(klass, true)) {
666 DCHECK(self->IsExceptionPending());
667 return NULL; // Failure
668 }
669 return klass->AllocObject();
buzbeecc4540e2011-10-27 13:06:03 -0700670}
671
Ian Rogersce9eca62011-10-07 17:11:03 -0700672Array* CheckAndAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
673 Thread* self) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700674 if (UNLIKELY(component_count < 0)) {
Ian Rogersce9eca62011-10-07 17:11:03 -0700675 self->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", component_count);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700676 return NULL; // Failure
677 }
678 Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700679 if (UNLIKELY(klass == NULL)) { // Not in dex cache so try to resolve
Shih-wei Liao2d831012011-09-28 22:06:53 -0700680 klass = Runtime::Current()->GetClassLinker()->ResolveType(type_idx, method);
681 if (klass == NULL) { // Error
682 DCHECK(Thread::Current()->IsExceptionPending());
683 return NULL; // Failure
684 }
685 }
Ian Rogerscaab8c42011-10-12 12:11:18 -0700686 if (UNLIKELY(klass->IsPrimitive() && !klass->IsPrimitiveInt())) {
Shih-wei Liao2d831012011-09-28 22:06:53 -0700687 if (klass->IsPrimitiveLong() || klass->IsPrimitiveDouble()) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700688 Thread::Current()->ThrowNewExceptionF("Ljava/lang/RuntimeException;",
Shih-wei Liao2d831012011-09-28 22:06:53 -0700689 "Bad filled array request for type %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800690 PrettyDescriptor(klass).c_str());
Shih-wei Liao2d831012011-09-28 22:06:53 -0700691 } else {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700692 Thread::Current()->ThrowNewExceptionF("Ljava/lang/InternalError;",
Shih-wei Liao2d831012011-09-28 22:06:53 -0700693 "Found type %s; filled-new-array not implemented for anything but \'int\'",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800694 PrettyDescriptor(klass).c_str());
Shih-wei Liao2d831012011-09-28 22:06:53 -0700695 }
696 return NULL; // Failure
697 } else {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700698 DCHECK(klass->IsArrayClass()) << PrettyClass(klass);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700699 return Array::Alloc(klass, component_count);
700 }
701}
702
Ian Rogersce9eca62011-10-07 17:11:03 -0700703// Helper function to alloc array for OP_FILLED_NEW_ARRAY
704extern "C" Array* artCheckAndAllocArrayFromCode(uint32_t type_idx, Method* method,
705 int32_t component_count, Thread* self, Method** sp) {
706 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
707 return CheckAndAllocArrayFromCode(type_idx, method, component_count, self);
708}
709
Shih-wei Liao2d831012011-09-28 22:06:53 -0700710// Given the context of a calling Method, use its DexCache to resolve a type to an array Class. If
711// it cannot be resolved, throw an error. If it can, use it to create an array.
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700712extern "C" Array* artAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
713 Thread* self, Method** sp) {
714 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700715 if (UNLIKELY(component_count < 0)) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700716 Thread::Current()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d",
Shih-wei Liao2d831012011-09-28 22:06:53 -0700717 component_count);
718 return NULL; // Failure
719 }
720 Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700721 if (UNLIKELY(klass == NULL)) { // Not in dex cache so try to resolve
Shih-wei Liao2d831012011-09-28 22:06:53 -0700722 klass = Runtime::Current()->GetClassLinker()->ResolveType(type_idx, method);
723 if (klass == NULL) { // Error
724 DCHECK(Thread::Current()->IsExceptionPending());
725 return NULL; // Failure
726 }
727 CHECK(klass->IsArrayClass()) << PrettyClass(klass);
728 }
729 return Array::Alloc(klass, component_count);
730}
731
Ian Rogerscaab8c42011-10-12 12:11:18 -0700732// Assignable test for code, won't throw. Null and equality tests already performed
733uint32_t IsAssignableFromCode(const Class* klass, const Class* ref_class) {
734 DCHECK(klass != NULL);
735 DCHECK(ref_class != NULL);
736 return klass->IsAssignableFrom(ref_class) ? 1 : 0;
737}
738
Shih-wei Liao2d831012011-09-28 22:06:53 -0700739// Check whether it is safe to cast one class to the other, throw exception and return -1 on failure
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700740extern "C" int artCheckCastFromCode(const Class* a, const Class* b, Thread* self, Method** sp) {
Shih-wei Liao2d831012011-09-28 22:06:53 -0700741 DCHECK(a->IsClass()) << PrettyClass(a);
742 DCHECK(b->IsClass()) << PrettyClass(b);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700743 if (LIKELY(b->IsAssignableFrom(a))) {
Shih-wei Liao2d831012011-09-28 22:06:53 -0700744 return 0; // Success
745 } else {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700746 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700747 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ClassCastException;",
Shih-wei Liao2d831012011-09-28 22:06:53 -0700748 "%s cannot be cast to %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800749 PrettyDescriptor(a).c_str(),
750 PrettyDescriptor(b).c_str());
Shih-wei Liao2d831012011-09-28 22:06:53 -0700751 return -1; // Failure
752 }
753}
754
755// Tests whether 'element' can be assigned into an array of type 'array_class'.
756// Returns 0 on success and -1 if an exception is pending.
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700757extern "C" int artCanPutArrayElementFromCode(const Object* element, const Class* array_class,
758 Thread* self, Method** sp) {
Shih-wei Liao2d831012011-09-28 22:06:53 -0700759 DCHECK(array_class != NULL);
760 // element can't be NULL as we catch this is screened in runtime_support
761 Class* element_class = element->GetClass();
762 Class* component_type = array_class->GetComponentType();
Ian Rogerscaab8c42011-10-12 12:11:18 -0700763 if (LIKELY(component_type->IsAssignableFrom(element_class))) {
Shih-wei Liao2d831012011-09-28 22:06:53 -0700764 return 0; // Success
765 } else {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700766 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700767 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
Shih-wei Liao2d831012011-09-28 22:06:53 -0700768 "Cannot store an object of type %s in to an array of type %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800769 PrettyDescriptor(element_class).c_str(),
770 PrettyDescriptor(array_class).c_str());
Shih-wei Liao2d831012011-09-28 22:06:53 -0700771 return -1; // Failure
772 }
773}
774
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700775Class* InitializeStaticStorage(uint32_t type_idx, const Method* referrer, Thread* self) {
776 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
777 Class* klass = class_linker->ResolveType(type_idx, referrer);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700778 if (UNLIKELY(klass == NULL)) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700779 CHECK(self->IsExceptionPending());
780 return NULL; // Failure - Indicate to caller to deliver exception
781 }
Ian Rogersb093c6b2011-10-31 16:19:55 -0700782 DCHECK(referrer->GetDeclaringClass()->CanAccess(klass));
783 // If we are the <clinit> of this class, just return our storage.
784 //
785 // Do not set the DexCache InitializedStaticStorage, since that implies <clinit> has finished
786 // running.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800787 if (klass == referrer->GetDeclaringClass() && MethodHelper(referrer).IsClassInitializer()) {
Ian Rogersb093c6b2011-10-31 16:19:55 -0700788 return klass;
789 }
790 if (!class_linker->EnsureInitialized(klass, true)) {
791 CHECK(self->IsExceptionPending());
792 return NULL; // Failure - Indicate to caller to deliver exception
793 }
794 referrer->GetDexCacheInitializedStaticStorage()->Set(type_idx, klass);
795 return klass;
796}
797
798Class* InitializeStaticStorageAndVerifyAccess(uint32_t type_idx, const Method* referrer,
799 Thread* self) {
800 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
801 Class* klass = class_linker->ResolveType(type_idx, referrer);
802 if (UNLIKELY(klass == NULL)) {
803 CHECK(self->IsExceptionPending());
804 return NULL; // Failure - Indicate to caller to deliver exception
805 }
806 // Perform access check
807 if (UNLIKELY(!referrer->GetDeclaringClass()->CanAccess(klass))) {
808 self->ThrowNewExceptionF("Ljava/lang/IllegalAccessError;",
809 "Class %s is inaccessible to method %s",
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800810 PrettyDescriptor(klass).c_str(),
Ian Rogersb093c6b2011-10-31 16:19:55 -0700811 PrettyMethod(referrer, true).c_str());
812 }
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700813 // If we are the <clinit> of this class, just return our storage.
814 //
815 // Do not set the DexCache InitializedStaticStorage, since that implies <clinit> has finished
816 // running.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800817 if (klass == referrer->GetDeclaringClass() && MethodHelper(referrer).IsClassInitializer()) {
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700818 return klass;
819 }
820 if (!class_linker->EnsureInitialized(klass, true)) {
821 CHECK(self->IsExceptionPending());
822 return NULL; // Failure - Indicate to caller to deliver exception
823 }
824 referrer->GetDexCacheInitializedStaticStorage()->Set(type_idx, klass);
825 return klass;
Shih-wei Liao2d831012011-09-28 22:06:53 -0700826}
827
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700828extern "C" Class* artInitializeStaticStorageFromCode(uint32_t type_idx, const Method* referrer,
829 Thread* self, Method** sp) {
830 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
831 return InitializeStaticStorage(type_idx, referrer, self);
832}
833
Ian Rogers28ad40d2011-10-27 15:19:26 -0700834extern "C" Class* artInitializeTypeFromCode(uint32_t type_idx, const Method* referrer, Thread* self,
835 Method** sp) {
836 // Called when method->dex_cache_resolved_types_[] misses
837 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
838 return InitializeStaticStorage(type_idx, referrer, self);
839}
840
Ian Rogersb093c6b2011-10-31 16:19:55 -0700841extern "C" Class* artInitializeTypeAndVerifyAccessFromCode(uint32_t type_idx,
842 const Method* referrer, Thread* self,
843 Method** sp) {
844 // Called when caller isn't guaranteed to have access to a type and the dex cache may be
845 // unpopulated
846 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
847 return InitializeStaticStorageAndVerifyAccess(type_idx, referrer, self);
848}
849
Ian Rogers28ad40d2011-10-27 15:19:26 -0700850// TODO: placeholder. Helper function to resolve virtual method
851void ResolveMethodFromCode(Method* method, uint32_t method_idx) {
852 /*
853 * Slow-path handler on invoke virtual method path in which
854 * base method is unresolved at compile-time. Doesn't need to
855 * return anything - just either ensure that
856 * method->dex_cache_resolved_methods_(method_idx) != NULL or
857 * throw and unwind. The caller will restart call sequence
858 * from the beginning.
859 */
860}
861
Brian Carlstromaded5f72011-10-07 17:15:04 -0700862String* ResolveStringFromCode(const Method* referrer, uint32_t string_idx) {
863 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
864 return class_linker->ResolveString(string_idx, referrer);
865}
866
867extern "C" String* artResolveStringFromCode(Method* referrer, int32_t string_idx,
868 Thread* self, Method** sp) {
869 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
870 return ResolveStringFromCode(referrer, string_idx);
871}
872
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700873extern "C" int artUnlockObjectFromCode(Object* obj, Thread* self, Method** sp) {
874 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700875 DCHECK(obj != NULL); // Assumed to have been checked before entry
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700876 // MonitorExit may throw exception
877 return obj->MonitorExit(self) ? 0 /* Success */ : -1 /* Failure */;
878}
879
880extern "C" void artLockObjectFromCode(Object* obj, Thread* thread, Method** sp) {
881 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsOnly);
882 DCHECK(obj != NULL); // Assumed to have been checked before entry
883 obj->MonitorEnter(thread); // May block
Shih-wei Liao2d831012011-09-28 22:06:53 -0700884 DCHECK(thread->HoldsLock(obj));
885 // Only possible exception is NPE and is handled before entry
886 DCHECK(!thread->IsExceptionPending());
887}
888
Ian Rogers4a510d82011-10-09 14:30:24 -0700889void CheckSuspendFromCode(Thread* thread) {
890 // Called when thread->suspend_count_ != 0
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700891 Runtime::Current()->GetThreadList()->FullSuspendCheck(thread);
892}
893
Ian Rogers4a510d82011-10-09 14:30:24 -0700894extern "C" void artTestSuspendFromCode(Thread* thread, Method** sp) {
895 // Called when suspend count check value is 0 and thread->suspend_count_ != 0
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700896 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsOnly);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700897 Runtime::Current()->GetThreadList()->FullSuspendCheck(thread);
898}
899
900/*
901 * Fill the array with predefined constant values, throwing exceptions if the array is null or
902 * not of sufficient length.
903 *
904 * NOTE: When dealing with a raw dex file, the data to be copied uses
905 * little-endian ordering. Require that oat2dex do any required swapping
906 * so this routine can get by with a memcpy().
907 *
908 * Format of the data:
909 * ushort ident = 0x0300 magic value
910 * ushort width width of each element in the table
911 * uint size number of elements in the table
912 * ubyte data[size*width] table of data values (may contain a single-byte
913 * padding at the end)
914 */
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700915extern "C" int artHandleFillArrayDataFromCode(Array* array, const uint16_t* table,
916 Thread* self, Method** sp) {
917 FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700918 DCHECK_EQ(table[0], 0x0300);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700919 if (UNLIKELY(array == NULL)) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700920 Thread::Current()->ThrowNewExceptionF("Ljava/lang/NullPointerException;",
921 "null array in fill array");
Shih-wei Liao2d831012011-09-28 22:06:53 -0700922 return -1; // Error
923 }
924 DCHECK(array->IsArrayInstance() && !array->IsObjectArray());
925 uint32_t size = (uint32_t)table[2] | (((uint32_t)table[3]) << 16);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700926 if (UNLIKELY(static_cast<int32_t>(size) > array->GetLength())) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700927 Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
928 "failed array fill. length=%d; index=%d", array->GetLength(), size);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700929 return -1; // Error
930 }
931 uint16_t width = table[1];
932 uint32_t size_in_bytes = size * width;
933 memcpy((char*)array + Array::DataOffset().Int32Value(), (char*)&table[4], size_in_bytes);
934 return 0; // Success
935}
936
937// See comments in runtime_support_asm.S
938extern "C" uint64_t artFindInterfaceMethodInCacheFromCode(uint32_t method_idx,
Ian Rogerscaab8c42011-10-12 12:11:18 -0700939 Object* this_object,
940 Method* caller_method,
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700941 Thread* thread, Method** sp) {
Ian Rogerscaab8c42011-10-12 12:11:18 -0700942 Method* interface_method = caller_method->GetDexCacheResolvedMethods()->Get(method_idx);
943 Method* found_method = NULL; // The found method
944 if (LIKELY(interface_method != NULL && this_object != NULL)) {
Ian Rogersb04f69f2011-10-17 00:40:54 -0700945 found_method = this_object->GetClass()->FindVirtualMethodForInterface(interface_method, false);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700946 }
Ian Rogerscaab8c42011-10-12 12:11:18 -0700947 if (UNLIKELY(found_method == NULL)) {
948 FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsAndArgs);
949 if (this_object == NULL) {
950 thread->ThrowNewExceptionF("Ljava/lang/NullPointerException;",
951 "null receiver during interface dispatch");
952 return 0;
953 }
954 if (interface_method == NULL) {
955 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
956 interface_method = class_linker->ResolveMethod(method_idx, caller_method, false);
957 if (interface_method == NULL) {
958 // Could not resolve interface method. Throw error and unwind
959 CHECK(thread->IsExceptionPending());
960 return 0;
961 }
962 }
Ian Rogersb04f69f2011-10-17 00:40:54 -0700963 found_method = this_object->GetClass()->FindVirtualMethodForInterface(interface_method, true);
Ian Rogerscaab8c42011-10-12 12:11:18 -0700964 if (found_method == NULL) {
965 CHECK(thread->IsExceptionPending());
966 return 0;
967 }
Shih-wei Liao2d831012011-09-28 22:06:53 -0700968 }
Ian Rogerscaab8c42011-10-12 12:11:18 -0700969 const void* code = found_method->GetCode();
Shih-wei Liao2d831012011-09-28 22:06:53 -0700970
Ian Rogerscaab8c42011-10-12 12:11:18 -0700971 uint32_t method_uint = reinterpret_cast<uint32_t>(found_method);
Shih-wei Liao2d831012011-09-28 22:06:53 -0700972 uint64_t code_uint = reinterpret_cast<uint32_t>(code);
973 uint64_t result = ((code_uint << 32) | method_uint);
974 return result;
975}
976
Ian Rogers466bb252011-10-14 03:29:56 -0700977static void ThrowNewUndeclaredThrowableException(Thread* self, JNIEnv* env, Throwable* exception) {
978 ScopedLocalRef<jclass> jlr_UTE_class(env,
979 env->FindClass("java/lang/reflect/UndeclaredThrowableException"));
980 if (jlr_UTE_class.get() == NULL) {
981 LOG(ERROR) << "Couldn't throw new \"java/lang/reflect/UndeclaredThrowableException\"";
982 } else {
983 jmethodID jlre_UTE_constructor = env->GetMethodID(jlr_UTE_class.get(), "<init>",
984 "(Ljava/lang/Throwable;)V");
985 jthrowable jexception = AddLocalReference<jthrowable>(env, exception);
986 ScopedLocalRef<jthrowable> jlr_UTE(env,
987 reinterpret_cast<jthrowable>(env->NewObject(jlr_UTE_class.get(), jlre_UTE_constructor,
988 jexception)));
989 int rc = env->Throw(jlr_UTE.get());
990 if (rc != JNI_OK) {
991 LOG(ERROR) << "Couldn't throw new \"java/lang/reflect/UndeclaredThrowableException\"";
992 }
993 }
994 CHECK(self->IsExceptionPending());
995}
996
Ian Rogersdfcdf1a2011-10-10 17:50:35 -0700997// Handler for invocation on proxy methods. On entry a frame will exist for the proxy object method
998// which is responsible for recording callee save registers. We explicitly handlerize incoming
999// reference arguments (so they survive GC) and create a boxed argument array. Finally we invoke
1000// the invocation handler which is a field within the proxy object receiver.
1001extern "C" void artProxyInvokeHandler(Method* proxy_method, Object* receiver,
Ian Rogers466bb252011-10-14 03:29:56 -07001002 Thread* self, byte* stack_args) {
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001003 // Register the top of the managed stack
Ian Rogers466bb252011-10-14 03:29:56 -07001004 Method** proxy_sp = reinterpret_cast<Method**>(stack_args - 12);
1005 DCHECK_EQ(*proxy_sp, proxy_method);
1006 self->SetTopOfStack(proxy_sp, 0);
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001007 // TODO: ARM specific
1008 DCHECK_EQ(proxy_method->GetFrameSizeInBytes(), 48u);
1009 // Start new JNI local reference state
1010 JNIEnvExt* env = self->GetJniEnv();
1011 ScopedJniEnvLocalRefState env_state(env);
1012 // Create local ref. copies of proxy method and the receiver
1013 jobject rcvr_jobj = AddLocalReference<jobject>(env, receiver);
1014 jobject proxy_method_jobj = AddLocalReference<jobject>(env, proxy_method);
1015
Ian Rogers14b1b242011-10-11 18:54:34 -07001016 // Placing into local references incoming arguments from the caller's register arguments,
1017 // replacing original Object* with jobject
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001018 MethodHelper proxy_mh(proxy_method);
1019 const size_t num_params = proxy_mh.NumArgs();
Ian Rogers14b1b242011-10-11 18:54:34 -07001020 size_t args_in_regs = 0;
1021 for (size_t i = 1; i < num_params; i++) { // skip receiver
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001022 args_in_regs = args_in_regs + (proxy_mh.IsParamALongOrDouble(i) ? 2 : 1);
Ian Rogers14b1b242011-10-11 18:54:34 -07001023 if (args_in_regs > 2) {
1024 args_in_regs = 2;
1025 break;
1026 }
1027 }
1028 size_t cur_arg = 0; // current stack location to read
1029 size_t param_index = 1; // skip receiver
1030 while (cur_arg < args_in_regs && param_index < num_params) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001031 if (proxy_mh.IsParamAReference(param_index)) {
Ian Rogers14b1b242011-10-11 18:54:34 -07001032 Object* obj = *reinterpret_cast<Object**>(stack_args + (cur_arg * kPointerSize));
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001033 jobject jobj = AddLocalReference<jobject>(env, obj);
Ian Rogers14b1b242011-10-11 18:54:34 -07001034 *reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)) = jobj;
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001035 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001036 cur_arg = cur_arg + (proxy_mh.IsParamALongOrDouble(param_index) ? 2 : 1);
Ian Rogers14b1b242011-10-11 18:54:34 -07001037 param_index++;
1038 }
1039 // Placing into local references incoming arguments from the caller's stack arguments
Ian Rogers466bb252011-10-14 03:29:56 -07001040 cur_arg += 11; // skip callee saves, LR, Method* and out arg spills for R1 to R3
Ian Rogers14b1b242011-10-11 18:54:34 -07001041 while (param_index < num_params) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001042 if (proxy_mh.IsParamAReference(param_index)) {
Ian Rogers14b1b242011-10-11 18:54:34 -07001043 Object* obj = *reinterpret_cast<Object**>(stack_args + (cur_arg * kPointerSize));
1044 jobject jobj = AddLocalReference<jobject>(env, obj);
1045 *reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)) = jobj;
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001046 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001047 cur_arg = cur_arg + (proxy_mh.IsParamALongOrDouble(param_index) ? 2 : 1);
Ian Rogers14b1b242011-10-11 18:54:34 -07001048 param_index++;
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001049 }
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001050 // Set up arguments array and place in local IRT during boxing (which may allocate/GC)
1051 jvalue args_jobj[3];
1052 args_jobj[0].l = rcvr_jobj;
1053 args_jobj[1].l = proxy_method_jobj;
Ian Rogers466bb252011-10-14 03:29:56 -07001054 // Args array, if no arguments then NULL (don't include receiver in argument count)
1055 args_jobj[2].l = NULL;
1056 ObjectArray<Object>* args = NULL;
1057 if ((num_params - 1) > 0) {
1058 args = Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(num_params - 1);
Elliott Hughes362f9bc2011-10-17 18:56:41 -07001059 if (args == NULL) {
Ian Rogers466bb252011-10-14 03:29:56 -07001060 CHECK(self->IsExceptionPending());
1061 return;
1062 }
1063 args_jobj[2].l = AddLocalReference<jobjectArray>(env, args);
1064 }
1065 // Convert proxy method into expected interface method
1066 Method* interface_method = proxy_method->FindOverriddenMethod();
1067 CHECK(interface_method != NULL);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001068 CHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
Ian Rogers466bb252011-10-14 03:29:56 -07001069 args_jobj[1].l = AddLocalReference<jobject>(env, interface_method);
1070 LOG(INFO) << "Interface method is " << PrettyMethod(interface_method, true);
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001071 // Box arguments
Ian Rogers14b1b242011-10-11 18:54:34 -07001072 cur_arg = 0; // reset stack location to read to start
1073 // reset index, will index into param type array which doesn't include the receiver
1074 param_index = 0;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001075 ObjectArray<Class>* param_types = proxy_mh.GetParameterTypes();
Ian Rogers14b1b242011-10-11 18:54:34 -07001076 CHECK(param_types != NULL);
1077 // Check number of parameter types agrees with number from the Method - less 1 for the receiver.
1078 CHECK_EQ(static_cast<size_t>(param_types->GetLength()), num_params - 1);
1079 while (cur_arg < args_in_regs && param_index < (num_params - 1)) {
1080 Class* param_type = param_types->Get(param_index);
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001081 Object* obj;
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001082 if (!param_type->IsPrimitive()) {
Ian Rogers14b1b242011-10-11 18:54:34 -07001083 obj = self->DecodeJObject(*reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)));
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001084 } else {
Ian Rogers14b1b242011-10-11 18:54:34 -07001085 JValue val = *reinterpret_cast<JValue*>(stack_args + (cur_arg * kPointerSize));
1086 if (cur_arg == 1 && (param_type->IsPrimitiveLong() || param_type->IsPrimitiveDouble())) {
1087 // long/double split over regs and stack, mask in high half from stack arguments
Ian Rogers466bb252011-10-14 03:29:56 -07001088 uint64_t high_half = *reinterpret_cast<uint32_t*>(stack_args + (13 * kPointerSize));
Ian Rogerscaab8c42011-10-12 12:11:18 -07001089 val.j = (val.j & 0xffffffffULL) | (high_half << 32);
Ian Rogers14b1b242011-10-11 18:54:34 -07001090 }
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001091 BoxPrimitive(env, param_type->GetPrimitiveType(), val);
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001092 if (self->IsExceptionPending()) {
1093 return;
1094 }
1095 obj = val.l;
1096 }
Ian Rogers14b1b242011-10-11 18:54:34 -07001097 args->Set(param_index, obj);
1098 cur_arg = cur_arg + (param_type->IsPrimitiveLong() || param_type->IsPrimitiveDouble() ? 2 : 1);
1099 param_index++;
1100 }
1101 // Placing into local references incoming arguments from the caller's stack arguments
Ian Rogers466bb252011-10-14 03:29:56 -07001102 cur_arg += 11; // skip callee saves, LR, Method* and out arg spills for R1 to R3
1103 while (param_index < (num_params - 1)) {
Ian Rogers14b1b242011-10-11 18:54:34 -07001104 Class* param_type = param_types->Get(param_index);
1105 Object* obj;
1106 if (!param_type->IsPrimitive()) {
1107 obj = self->DecodeJObject(*reinterpret_cast<jobject*>(stack_args + (cur_arg * kPointerSize)));
1108 } else {
1109 JValue val = *reinterpret_cast<JValue*>(stack_args + (cur_arg * kPointerSize));
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001110 BoxPrimitive(env, param_type->GetPrimitiveType(), val);
Ian Rogers14b1b242011-10-11 18:54:34 -07001111 if (self->IsExceptionPending()) {
1112 return;
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001113 }
Ian Rogers14b1b242011-10-11 18:54:34 -07001114 obj = val.l;
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001115 }
Ian Rogers14b1b242011-10-11 18:54:34 -07001116 args->Set(param_index, obj);
1117 cur_arg = cur_arg + (param_type->IsPrimitiveLong() || param_type->IsPrimitiveDouble() ? 2 : 1);
1118 param_index++;
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001119 }
1120 // Get the InvocationHandler method and the field that holds it within the Proxy object
1121 static jmethodID inv_hand_invoke_mid = NULL;
1122 static jfieldID proxy_inv_hand_fid = NULL;
1123 if (proxy_inv_hand_fid == NULL) {
Ian Rogers466bb252011-10-14 03:29:56 -07001124 ScopedLocalRef<jclass> proxy(env, env->FindClass("java/lang/reflect/Proxy"));
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001125 proxy_inv_hand_fid = env->GetFieldID(proxy.get(), "h", "Ljava/lang/reflect/InvocationHandler;");
Ian Rogers466bb252011-10-14 03:29:56 -07001126 ScopedLocalRef<jclass> inv_hand_class(env, env->FindClass("java/lang/reflect/InvocationHandler"));
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001127 inv_hand_invoke_mid = env->GetMethodID(inv_hand_class.get(), "invoke",
1128 "(Ljava/lang/Object;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;");
1129 }
Ian Rogers466bb252011-10-14 03:29:56 -07001130 DCHECK(env->IsInstanceOf(rcvr_jobj, env->FindClass("java/lang/reflect/Proxy")));
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001131 jobject inv_hand = env->GetObjectField(rcvr_jobj, proxy_inv_hand_fid);
1132 // Call InvocationHandler.invoke
1133 jobject result = env->CallObjectMethodA(inv_hand, inv_hand_invoke_mid, args_jobj);
1134 // Place result in stack args
1135 if (!self->IsExceptionPending()) {
1136 Object* result_ref = self->DecodeJObject(result);
1137 if (result_ref != NULL) {
1138 JValue result_unboxed;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001139 UnboxPrimitive(env, result_ref, proxy_mh.GetReturnType(), result_unboxed);
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001140 *reinterpret_cast<JValue*>(stack_args) = result_unboxed;
1141 } else {
1142 *reinterpret_cast<jobject*>(stack_args) = NULL;
1143 }
Ian Rogers466bb252011-10-14 03:29:56 -07001144 } else {
1145 // In the case of checked exceptions that aren't declared, the exception must be wrapped by
1146 // a UndeclaredThrowableException.
1147 Throwable* exception = self->GetException();
1148 self->ClearException();
1149 if (!exception->IsCheckedException()) {
1150 self->SetException(exception);
1151 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001152 // TODO: get the correct intersection of exceptions as passed to the class linker's create
1153 // proxy code.
1154 UNIMPLEMENTED(FATAL);
1155 ObjectArray<Class>* declared_exceptions = NULL; // proxy_mh.GetExceptionTypes();
Ian Rogers466bb252011-10-14 03:29:56 -07001156 Class* exception_class = exception->GetClass();
1157 bool declares_exception = false;
1158 for (int i = 0; i < declared_exceptions->GetLength() && !declares_exception; i++) {
1159 Class* declared_exception = declared_exceptions->Get(i);
1160 declares_exception = declared_exception->IsAssignableFrom(exception_class);
1161 }
1162 if (declares_exception) {
1163 self->SetException(exception);
1164 } else {
1165 ThrowNewUndeclaredThrowableException(self, env, exception);
1166 }
1167 }
Ian Rogersdfcdf1a2011-10-10 17:50:35 -07001168 }
1169}
1170
jeffhaoe343b762011-12-05 16:36:44 -08001171extern "C" const void* artTraceMethodEntryFromCode(Method* method, Thread* self, uintptr_t lr) {
1172 LOG(INFO) << "Tracer - entering: " << PrettyMethod(method);
1173 TraceStackFrame trace_frame = TraceStackFrame(method, lr);
1174 self->PushTraceStackFrame(trace_frame);
1175
1176 return Trace::GetSavedCodeFromMap(method);
1177}
1178
1179extern "C" uintptr_t artTraceMethodExitFromCode() {
1180 TraceStackFrame trace_frame = Thread::Current()->PopTraceStackFrame();
1181 Method* method = trace_frame.method_;
1182 uintptr_t lr = trace_frame.return_pc_;
1183 LOG(INFO) << "Tracer - exiting: " << PrettyMethod(method);
1184
1185 return lr;
1186}
1187
1188uintptr_t artTraceMethodUnwindFromCode(Thread* self) {
1189 TraceStackFrame trace_frame = self->PopTraceStackFrame();
1190 Method* method = trace_frame.method_;
1191 uintptr_t lr = trace_frame.return_pc_;
1192 LOG(INFO) << "Tracer - unwinding: " << PrettyMethod(method);
1193
1194 return lr;
1195}
1196
Shih-wei Liao2d831012011-09-28 22:06:53 -07001197/*
1198 * Float/double conversion requires clamping to min and max of integer form. If
1199 * target doesn't support this normally, use these.
1200 */
1201int64_t D2L(double d) {
1202 static const double kMaxLong = (double)(int64_t)0x7fffffffffffffffULL;
1203 static const double kMinLong = (double)(int64_t)0x8000000000000000ULL;
1204 if (d >= kMaxLong)
1205 return (int64_t)0x7fffffffffffffffULL;
1206 else if (d <= kMinLong)
1207 return (int64_t)0x8000000000000000ULL;
1208 else if (d != d) // NaN case
1209 return 0;
1210 else
1211 return (int64_t)d;
1212}
1213
1214int64_t F2L(float f) {
1215 static const float kMaxLong = (float)(int64_t)0x7fffffffffffffffULL;
1216 static const float kMinLong = (float)(int64_t)0x8000000000000000ULL;
1217 if (f >= kMaxLong)
1218 return (int64_t)0x7fffffffffffffffULL;
1219 else if (f <= kMinLong)
1220 return (int64_t)0x8000000000000000ULL;
1221 else if (f != f) // NaN case
1222 return 0;
1223 else
1224 return (int64_t)f;
1225}
1226
1227} // namespace art