blob: d7bbe6475a91724cddb6c445e5a554a4e509f18d [file] [log] [blame]
Shih-wei Liao2d831012011-09-28 22:06:53 -07001/*
Elliott Hughes0f3c5532012-03-30 14:51:51 -07002 * Copyright (C) 2012 The Android Open Source Project
Shih-wei Liao2d831012011-09-28 22:06:53 -07003 *
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
Ian Rogers7655f292013-07-29 11:07:13 -070017#include "entrypoints/entrypoint_utils.h"
Shih-wei Liao2d831012011-09-28 22:06:53 -070018
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080019#include "class_linker-inl.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070020#include "dex_file-inl.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070021#include "gc/accounting/card_table-inl.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070022#include "mirror/art_field-inl.h"
23#include "mirror/art_method-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080024#include "mirror/class-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080025#include "mirror/object-inl.h"
Dragos Sbirleabd136a22013-08-13 18:07:04 -070026#include "object_utils.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080027#include "mirror/object_array-inl.h"
28#include "mirror/proxy.h"
Ian Rogersaf6e67a2013-01-16 08:38:37 -080029#include "reflection.h"
30#include "scoped_thread_state_change.h"
TDYa1275bb86012012-04-11 05:57:28 -070031#include "ScopedLocalRef.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070032#include "well_known_classes.h"
TDYa1275bb86012012-04-11 05:57:28 -070033
jeffhao41005dd2012-05-09 17:58:52 -070034namespace art {
35
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070036static inline bool CheckFilledNewArrayAlloc(uint32_t type_idx, mirror::ArtMethod* referrer,
37 int32_t component_count, Thread* self,
38 bool access_check, mirror::Class** klass_ptr)
39 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers57b86d42012-03-27 16:05:41 -070040 if (UNLIKELY(component_count < 0)) {
Ian Rogers62d6c772013-02-27 08:32:07 -080041 ThrowNegativeArraySizeException(component_count);
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070042 return false; // Failure
Elliott Hughes6c8867d2011-10-03 16:34:05 -070043 }
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070044 mirror::Class* klass = referrer->GetDexCacheResolvedTypes()->GetWithoutChecks(type_idx);
Ian Rogers57b86d42012-03-27 16:05:41 -070045 if (UNLIKELY(klass == NULL)) { // Not in dex cache so try to resolve
Ian Rogers62d6c772013-02-27 08:32:07 -080046 klass = Runtime::Current()->GetClassLinker()->ResolveType(type_idx, referrer);
Ian Rogers57b86d42012-03-27 16:05:41 -070047 if (klass == NULL) { // Error
Ian Rogers50b35e22012-10-04 10:09:15 -070048 DCHECK(self->IsExceptionPending());
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070049 return false; // Failure
Ian Rogers19846512012-02-24 11:42:47 -080050 }
Ian Rogersea2a11d2011-10-11 16:48:51 -070051 }
Ian Rogers57b86d42012-03-27 16:05:41 -070052 if (UNLIKELY(klass->IsPrimitive() && !klass->IsPrimitiveInt())) {
53 if (klass->IsPrimitiveLong() || klass->IsPrimitiveDouble()) {
Ian Rogers62d6c772013-02-27 08:32:07 -080054 ThrowRuntimeException("Bad filled array request for type %s",
55 PrettyDescriptor(klass).c_str());
Ian Rogers573db4a2011-12-13 15:30:50 -080056 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -080057 ThrowLocation throw_location = self->GetCurrentLocationForThrow();
58 DCHECK(throw_location.GetMethod() == referrer);
59 self->ThrowNewExceptionF(throw_location, "Ljava/lang/InternalError;",
Ian Rogers50b35e22012-10-04 10:09:15 -070060 "Found type %s; filled-new-array not implemented for anything but \'int\'",
61 PrettyDescriptor(klass).c_str());
Ian Rogers573db4a2011-12-13 15:30:50 -080062 }
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070063 return false; // Failure
Ian Rogers57b86d42012-03-27 16:05:41 -070064 }
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070065 if (access_check) {
66 mirror::Class* referrer_klass = referrer->GetDeclaringClass();
67 if (UNLIKELY(!referrer_klass->CanAccess(klass))) {
68 ThrowIllegalAccessErrorClass(referrer_klass, klass);
69 return false; // Failure
70 }
71 }
72 DCHECK(klass->IsArrayClass()) << PrettyClass(klass);
73 *klass_ptr = klass;
74 return true;
75}
76
77// Helper function to allocate array for FILLED_NEW_ARRAY.
78mirror::Array* CheckAndAllocArrayFromCode(uint32_t type_idx, mirror::ArtMethod* referrer,
79 int32_t component_count, Thread* self,
80 bool access_check) {
81 mirror::Class* klass;
82 if (UNLIKELY(!CheckFilledNewArrayAlloc(type_idx, referrer, component_count, self, access_check, &klass))) {
83 return NULL;
84 }
Mathieu Chartier590fee92013-09-13 13:46:47 -070085 return mirror::Array::Alloc<kMovingCollector, false>(self, klass, component_count);
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -070086}
87
88// Helper function to allocate array for FILLED_NEW_ARRAY.
89mirror::Array* CheckAndAllocArrayFromCodeInstrumented(uint32_t type_idx, mirror::ArtMethod* referrer,
90 int32_t component_count, Thread* self,
91 bool access_check) {
92 mirror::Class* klass;
93 if (UNLIKELY(!CheckFilledNewArrayAlloc(type_idx, referrer, component_count, self, access_check, &klass))) {
94 return NULL;
95 }
Mathieu Chartier590fee92013-09-13 13:46:47 -070096 return mirror::Array::Alloc<kMovingCollector, true>(self, klass, component_count);
Ian Rogers57b86d42012-03-27 16:05:41 -070097}
98
jeffhaod7521322012-11-21 15:38:24 -080099void ThrowStackOverflowError(Thread* self) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700100 if (self->IsHandlingStackOverflow()) {
101 LOG(ERROR) << "Recursive stack overflow.";
102 // We don't fail here because SetStackEndForStackOverflow will print better diagnostics.
103 }
Ian Rogers62d6c772013-02-27 08:32:07 -0800104
105 if (Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled()) {
106 // Remove extra entry pushed onto second stack during method tracing.
107 Runtime::Current()->GetInstrumentation()->PopMethodForUnwind(self, false);
jeffhaod7521322012-11-21 15:38:24 -0800108 }
Ian Rogers62d6c772013-02-27 08:32:07 -0800109
jeffhaod7521322012-11-21 15:38:24 -0800110 self->SetStackEndForStackOverflow(); // Allow space on the stack for constructor to execute.
111 JNIEnvExt* env = self->GetJniEnv();
112 std::string msg("stack size ");
113 msg += PrettySize(self->GetStackSize());
114 // Use low-level JNI routine and pre-baked error class to avoid class linking operations that
115 // would consume more stack.
116 int rc = ::art::ThrowNewException(env, WellKnownClasses::java_lang_StackOverflowError,
117 msg.c_str(), NULL);
118 if (rc != JNI_OK) {
119 // TODO: ThrowNewException failed presumably because of an OOME, we continue to throw the OOME
120 // or die in the CHECK below. We may want to throw a pre-baked StackOverflowError
121 // instead.
122 LOG(ERROR) << "Couldn't throw new StackOverflowError because JNI ThrowNew failed.";
123 CHECK(self->IsExceptionPending());
124 }
125 self->ResetDefaultStackEnd(); // Return to default stack size.
126}
127
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800128JValue InvokeProxyInvocationHandler(ScopedObjectAccessUnchecked& soa, const char* shorty,
129 jobject rcvr_jobj, jobject interface_method_jobj,
130 std::vector<jvalue>& args) {
131 DCHECK(soa.Env()->IsInstanceOf(rcvr_jobj, WellKnownClasses::java_lang_reflect_Proxy));
132
133 // Build argument array possibly triggering GC.
134 soa.Self()->AssertThreadSuspensionIsAllowable();
135 jobjectArray args_jobj = NULL;
136 const JValue zero;
137 if (args.size() > 0) {
138 args_jobj = soa.Env()->NewObjectArray(args.size(), WellKnownClasses::java_lang_Object, NULL);
139 if (args_jobj == NULL) {
140 CHECK(soa.Self()->IsExceptionPending());
141 return zero;
142 }
143 for (size_t i = 0; i < args.size(); ++i) {
144 if (shorty[i + 1] == 'L') {
145 jobject val = args.at(i).l;
146 soa.Env()->SetObjectArrayElement(args_jobj, i, val);
147 } else {
148 JValue jv;
149 jv.SetJ(args.at(i).j);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800150 mirror::Object* val = BoxPrimitive(Primitive::GetType(shorty[i + 1]), jv);
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800151 if (val == NULL) {
152 CHECK(soa.Self()->IsExceptionPending());
153 return zero;
154 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800155 soa.Decode<mirror::ObjectArray<mirror::Object>* >(args_jobj)->Set(i, val);
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800156 }
157 }
158 }
159
Brian Carlstromea46f952013-07-30 01:26:50 -0700160 // Call Proxy.invoke(Proxy proxy, ArtMethod method, Object[] args).
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800161 jvalue invocation_args[3];
162 invocation_args[0].l = rcvr_jobj;
163 invocation_args[1].l = interface_method_jobj;
164 invocation_args[2].l = args_jobj;
165 jobject result =
Brian Carlstromea46f952013-07-30 01:26:50 -0700166 soa.Env()->CallStaticObjectMethodA(WellKnownClasses::java_lang_reflect_Proxy,
167 WellKnownClasses::java_lang_reflect_Proxy_invoke,
168 invocation_args);
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800169
170 // Unbox result and handle error conditions.
Ian Rogers62d6c772013-02-27 08:32:07 -0800171 if (LIKELY(!soa.Self()->IsExceptionPending())) {
172 if (shorty[0] == 'V' || (shorty[0] == 'L' && result == NULL)) {
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800173 // Do nothing.
174 return zero;
175 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800176 mirror::Object* result_ref = soa.Decode<mirror::Object*>(result);
Ian Rogers62d6c772013-02-27 08:32:07 -0800177 mirror::Object* rcvr = soa.Decode<mirror::Object*>(rcvr_jobj);
Brian Carlstromea46f952013-07-30 01:26:50 -0700178 mirror::ArtMethod* interface_method =
179 soa.Decode<mirror::ArtMethod*>(interface_method_jobj);
Ian Rogers62d6c772013-02-27 08:32:07 -0800180 mirror::Class* result_type = MethodHelper(interface_method).GetReturnType();
Brian Carlstromea46f952013-07-30 01:26:50 -0700181 mirror::ArtMethod* proxy_method;
Ian Rogers62d6c772013-02-27 08:32:07 -0800182 if (interface_method->GetDeclaringClass()->IsInterface()) {
183 proxy_method = rcvr->GetClass()->FindVirtualMethodForInterface(interface_method);
184 } else {
185 // Proxy dispatch to a method defined in Object.
186 DCHECK(interface_method->GetDeclaringClass()->IsObjectClass());
187 proxy_method = interface_method;
188 }
189 ThrowLocation throw_location(rcvr, proxy_method, -1);
190 JValue result_unboxed;
191 if (!UnboxPrimitiveForResult(throw_location, result_ref, result_type, result_unboxed)) {
Ian Rogers530f71c2013-02-22 23:29:00 -0800192 DCHECK(soa.Self()->IsExceptionPending());
Ian Rogers62d6c772013-02-27 08:32:07 -0800193 return zero;
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800194 }
195 return result_unboxed;
196 }
197 } else {
198 // In the case of checked exceptions that aren't declared, the exception must be wrapped by
199 // a UndeclaredThrowableException.
Ian Rogers62d6c772013-02-27 08:32:07 -0800200 mirror::Throwable* exception = soa.Self()->GetException(NULL);
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800201 if (exception->IsCheckedException()) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800202 mirror::Object* rcvr = soa.Decode<mirror::Object*>(rcvr_jobj);
203 mirror::SynthesizedProxyClass* proxy_class =
204 down_cast<mirror::SynthesizedProxyClass*>(rcvr->GetClass());
Brian Carlstromea46f952013-07-30 01:26:50 -0700205 mirror::ArtMethod* interface_method =
206 soa.Decode<mirror::ArtMethod*>(interface_method_jobj);
207 mirror::ArtMethod* proxy_method =
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800208 rcvr->GetClass()->FindVirtualMethodForInterface(interface_method);
209 int throws_index = -1;
210 size_t num_virt_methods = proxy_class->NumVirtualMethods();
211 for (size_t i = 0; i < num_virt_methods; i++) {
212 if (proxy_class->GetVirtualMethod(i) == proxy_method) {
213 throws_index = i;
214 break;
215 }
216 }
217 CHECK_NE(throws_index, -1);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800218 mirror::ObjectArray<mirror::Class>* declared_exceptions = proxy_class->GetThrows()->Get(throws_index);
219 mirror::Class* exception_class = exception->GetClass();
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800220 bool declares_exception = false;
221 for (int i = 0; i < declared_exceptions->GetLength() && !declares_exception; i++) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800222 mirror::Class* declared_exception = declared_exceptions->Get(i);
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800223 declares_exception = declared_exception->IsAssignableFrom(exception_class);
224 }
225 if (!declares_exception) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800226 ThrowLocation throw_location(rcvr, proxy_method, -1);
227 soa.Self()->ThrowNewWrappedException(throw_location,
228 "Ljava/lang/reflect/UndeclaredThrowableException;",
Ian Rogersaf6e67a2013-01-16 08:38:37 -0800229 NULL);
230 }
231 }
232 return zero;
233 }
234}
Shih-wei Liao2d831012011-09-28 22:06:53 -0700235} // namespace art