blob: 9c7a63d3ba7d497e5666e567d0d48b3750fb76a1 [file] [log] [blame]
Ian Rogersdf20fe02011-07-20 20:34:16 -07001// Copyright 2011 Google Inc. All Rights Reserved.
2
Brian Carlstrom578bbdc2011-07-21 14:07:47 -07003#include "jni_internal.h"
Carl Shapiro2ed144c2011-07-26 16:52:08 -07004
Elliott Hughes0af55432011-08-17 18:37:28 -07005#include <dlfcn.h>
Carl Shapiro9b9ba282011-08-14 15:30:39 -07006#include <sys/mman.h>
Elliott Hughes79082e32011-08-25 12:07:32 -07007
8#include <cstdarg>
9#include <map>
Elliott Hughes0af55432011-08-17 18:37:28 -070010#include <utility>
11#include <vector>
Carl Shapiro2ed144c2011-07-26 16:52:08 -070012
Elliott Hughes72025e52011-08-23 17:50:30 -070013#include "ScopedLocalRef.h"
Elliott Hughes90a33692011-08-30 13:27:07 -070014#include "UniquePtr.h"
Elliott Hughes18c07532011-08-18 15:50:51 -070015#include "assembler.h"
Elliott Hughes40ef99e2011-08-11 17:44:34 -070016#include "class_linker.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070017#include "class_loader.h"
Carl Shapiroea4dca82011-08-01 13:45:38 -070018#include "jni.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070019#include "logging.h"
Carl Shapiro9b9ba282011-08-14 15:30:39 -070020#include "object.h"
Carl Shapiro2ed144c2011-07-26 16:52:08 -070021#include "runtime.h"
Elliott Hughesc5bfa8f2011-08-30 14:32:49 -070022#include "scoped_jni_thread_state.h"
Elliott Hughesc31664f2011-09-29 15:58:28 -070023#include "stl_util.h"
Carl Shapirofc322c72011-07-27 00:20:01 -070024#include "stringpiece.h"
Carl Shapiro2ed144c2011-07-26 16:52:08 -070025#include "thread.h"
Ian Rogersdf20fe02011-07-20 20:34:16 -070026
27namespace art {
28
Elliott Hughesc5f7c912011-08-18 14:00:42 -070029/*
30 * Add a local reference for an object to the current stack frame. When
31 * the native function returns, the reference will be discarded.
32 *
33 * We need to allow the same reference to be added multiple times.
34 *
35 * This will be called on otherwise unreferenced objects. We cannot do
36 * GC allocations here, and it's best if we don't grab a mutex.
37 *
38 * Returns the local reference (currently just the same pointer that was
39 * passed in), or NULL on failure.
40 */
Elliott Hughes8a26c5c2011-08-15 18:35:43 -070041template<typename T>
Elliott Hughescf4c6c42011-09-01 15:16:42 -070042T AddLocalReference(JNIEnv* public_env, const Object* const_obj) {
43 // The jobject type hierarchy has no notion of const, so it's not worth carrying through.
44 Object* obj = const_cast<Object*>(const_obj);
45
Elliott Hughesc5f7c912011-08-18 14:00:42 -070046 if (obj == NULL) {
47 return NULL;
48 }
49
Elliott Hughesbf86d042011-08-31 17:53:14 -070050 JNIEnvExt* env = reinterpret_cast<JNIEnvExt*>(public_env);
51 IndirectReferenceTable& locals = env->locals;
Elliott Hughesc5f7c912011-08-18 14:00:42 -070052
Ian Rogers5a7a74a2011-09-26 16:32:29 -070053 uint32_t cookie = env->local_ref_cookie;
Elliott Hughesc5f7c912011-08-18 14:00:42 -070054 IndirectRef ref = locals.Add(cookie, obj);
55 if (ref == NULL) {
56 // TODO: just change Add's DCHECK to CHECK and lose this?
57 locals.Dump();
58 LOG(FATAL) << "Failed adding to JNI local reference table "
59 << "(has " << locals.Capacity() << " entries)";
60 // TODO: dvmDumpThread(dvmThreadSelf(), false);
61 }
62
63#if 0 // TODO: fix this to understand PushLocalFrame, so we can turn it on.
Elliott Hughesbf86d042011-08-31 17:53:14 -070064 if (env->check_jni) {
Elliott Hughesc5f7c912011-08-18 14:00:42 -070065 size_t entry_count = locals.Capacity();
66 if (entry_count > 16) {
Elliott Hughesc5f7c912011-08-18 14:00:42 -070067 LOG(WARNING) << "Warning: more than 16 JNI local references: "
Elliott Hughes54e7df12011-09-16 11:47:04 -070068 << entry_count << " (most recent was a " << PrettyTypeOf(obj) << ")";
Elliott Hughesc5f7c912011-08-18 14:00:42 -070069 locals.Dump();
70 // TODO: dvmDumpThread(dvmThreadSelf(), false);
71 // dvmAbort();
72 }
73 }
74#endif
75
Elliott Hughesbf86d042011-08-31 17:53:14 -070076 if (env->work_around_app_jni_bugs) {
Elliott Hughesc5f7c912011-08-18 14:00:42 -070077 // Hand out direct pointers to support broken old apps.
78 return reinterpret_cast<T>(obj);
79 }
80
81 return reinterpret_cast<T>(ref);
82}
83
Elliott Hughesbf86d042011-08-31 17:53:14 -070084// For external use.
85template<typename T>
86T Decode(JNIEnv* public_env, jobject obj) {
87 JNIEnvExt* env = reinterpret_cast<JNIEnvExt*>(public_env);
88 return reinterpret_cast<T>(env->self->DecodeJObject(obj));
89}
90// Explicit instantiations.
Elliott Hughes7ede61e2011-09-14 18:18:06 -070091template Array* Decode<Array*>(JNIEnv*, jobject);
Elliott Hughesbf86d042011-08-31 17:53:14 -070092template Class* Decode<Class*>(JNIEnv*, jobject);
93template ClassLoader* Decode<ClassLoader*>(JNIEnv*, jobject);
94template Object* Decode<Object*>(JNIEnv*, jobject);
Elliott Hughes418d20f2011-09-22 14:00:39 -070095template ObjectArray<Class>* Decode<ObjectArray<Class>*>(JNIEnv*, jobject);
96template ObjectArray<Object>* Decode<ObjectArray<Object>*>(JNIEnv*, jobject);
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -070097template ObjectArray<StackTraceElement>* Decode<ObjectArray<StackTraceElement>*>(JNIEnv*, jobject);
Jesse Wilson95caa792011-10-12 18:14:17 -040098template ObjectArray<Method>* Decode<ObjectArray<Method>*>(JNIEnv*, jobject);
Elliott Hughes726079d2011-10-07 18:43:44 -070099template String* Decode<String*>(JNIEnv*, jobject);
100template Throwable* Decode<Throwable*>(JNIEnv*, jobject);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700101
102namespace {
103
Elliott Hughescdf53122011-08-19 15:46:09 -0700104jweak AddWeakGlobalReference(ScopedJniThreadState& ts, Object* obj) {
105 if (obj == NULL) {
106 return NULL;
107 }
Elliott Hughes75770752011-08-24 17:52:38 -0700108 JavaVMExt* vm = ts.Vm();
Elliott Hughescdf53122011-08-19 15:46:09 -0700109 IndirectReferenceTable& weak_globals = vm->weak_globals;
110 MutexLock mu(vm->weak_globals_lock);
111 IndirectRef ref = weak_globals.Add(IRT_FIRST_SEGMENT, obj);
112 return reinterpret_cast<jweak>(ref);
113}
114
Elliott Hughesbf86d042011-08-31 17:53:14 -0700115// For internal use.
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700116template<typename T>
117T Decode(ScopedJniThreadState& ts, jobject obj) {
Ian Rogers408f79a2011-08-23 18:22:33 -0700118 return reinterpret_cast<T>(ts.Self()->DecodeJObject(obj));
Elliott Hughes8a26c5c2011-08-15 18:35:43 -0700119}
120
Elliott Hughes418d20f2011-09-22 14:00:39 -0700121byte* CreateArgArray(JNIEnv* public_env, Method* method, va_list ap) {
122 JNIEnvExt* env = reinterpret_cast<JNIEnvExt*>(public_env);
Carl Shapiro9b9ba282011-08-14 15:30:39 -0700123 size_t num_bytes = method->NumArgArrayBytes();
Elliott Hughes90a33692011-08-30 13:27:07 -0700124 UniquePtr<byte[]> arg_array(new byte[num_bytes]);
Brian Carlstromc74255f2011-09-11 22:47:39 -0700125 const String* shorty = method->GetShorty();
Brian Carlstrom2ed67392011-09-09 14:53:28 -0700126 for (int i = 1, offset = 0; i < shorty->GetLength(); ++i) {
127 switch (shorty->CharAt(i)) {
Carl Shapiro9b9ba282011-08-14 15:30:39 -0700128 case 'Z':
129 case 'B':
130 case 'C':
131 case 'S':
132 case 'I':
133 *reinterpret_cast<int32_t*>(&arg_array[offset]) = va_arg(ap, jint);
134 offset += 4;
135 break;
136 case 'F':
137 *reinterpret_cast<float*>(&arg_array[offset]) = va_arg(ap, jdouble);
138 offset += 4;
139 break;
140 case 'L': {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700141 Object* obj = Decode<Object*>(env, va_arg(ap, jobject));
Carl Shapiro9b9ba282011-08-14 15:30:39 -0700142 *reinterpret_cast<Object**>(&arg_array[offset]) = obj;
143 offset += sizeof(Object*);
144 break;
145 }
146 case 'D':
147 *reinterpret_cast<double*>(&arg_array[offset]) = va_arg(ap, jdouble);
148 offset += 8;
149 break;
150 case 'J':
151 *reinterpret_cast<int64_t*>(&arg_array[offset]) = va_arg(ap, jlong);
152 offset += 8;
153 break;
154 }
155 }
156 return arg_array.release();
157}
158
Elliott Hughes418d20f2011-09-22 14:00:39 -0700159byte* CreateArgArray(JNIEnv* public_env, Method* method, jvalue* args) {
160 JNIEnvExt* env = reinterpret_cast<JNIEnvExt*>(public_env);
Carl Shapiro9b9ba282011-08-14 15:30:39 -0700161 size_t num_bytes = method->NumArgArrayBytes();
Elliott Hughes90a33692011-08-30 13:27:07 -0700162 UniquePtr<byte[]> arg_array(new byte[num_bytes]);
Brian Carlstromc74255f2011-09-11 22:47:39 -0700163 const String* shorty = method->GetShorty();
Brian Carlstrom2ed67392011-09-09 14:53:28 -0700164 for (int i = 1, offset = 0; i < shorty->GetLength(); ++i) {
165 switch (shorty->CharAt(i)) {
Carl Shapiro9b9ba282011-08-14 15:30:39 -0700166 case 'Z':
167 case 'B':
168 case 'C':
169 case 'S':
170 case 'I':
171 *reinterpret_cast<uint32_t*>(&arg_array[offset]) = args[i - 1].i;
172 offset += 4;
173 break;
174 case 'F':
175 *reinterpret_cast<float*>(&arg_array[offset]) = args[i - 1].f;
176 offset += 4;
177 break;
178 case 'L': {
Elliott Hughes418d20f2011-09-22 14:00:39 -0700179 Object* obj = Decode<Object*>(env, args[i - 1].l);
Carl Shapiro9b9ba282011-08-14 15:30:39 -0700180 *reinterpret_cast<Object**>(&arg_array[offset]) = obj;
181 offset += sizeof(Object*);
182 break;
183 }
184 case 'D':
185 *reinterpret_cast<double*>(&arg_array[offset]) = args[i - 1].d;
186 offset += 8;
187 break;
188 case 'J':
189 *reinterpret_cast<uint64_t*>(&arg_array[offset]) = args[i - 1].j;
190 offset += 8;
191 break;
192 }
193 }
194 return arg_array.release();
195}
196
Elliott Hughes418d20f2011-09-22 14:00:39 -0700197JValue InvokeWithArgArray(JNIEnv* public_env, Object* receiver, Method* method, byte* args) {
198 JNIEnvExt* env = reinterpret_cast<JNIEnvExt*>(public_env);
Carl Shapiro9b9ba282011-08-14 15:30:39 -0700199 JValue result;
Elliott Hughes418d20f2011-09-22 14:00:39 -0700200 method->Invoke(env->self, receiver, args, &result);
Carl Shapiro9b9ba282011-08-14 15:30:39 -0700201 return result;
202}
203
Elliott Hughes418d20f2011-09-22 14:00:39 -0700204JValue InvokeWithVarArgs(JNIEnv* public_env, jobject obj, jmethodID mid, va_list args) {
205 JNIEnvExt* env = reinterpret_cast<JNIEnvExt*>(public_env);
206 Object* receiver = Decode<Object*>(env, obj);
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -0700207 Method* method = DecodeMethod(mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700208 UniquePtr<byte[]> arg_array(CreateArgArray(env, method, args));
209 return InvokeWithArgArray(env, receiver, method, arg_array.get());
Elliott Hughes72025e52011-08-23 17:50:30 -0700210}
211
Elliott Hughes75770752011-08-24 17:52:38 -0700212Method* FindVirtualMethod(Object* receiver, Method* method) {
Brian Carlstrom30b94452011-08-25 21:35:26 -0700213 return receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(method);
Elliott Hughes72025e52011-08-23 17:50:30 -0700214}
215
Elliott Hughes418d20f2011-09-22 14:00:39 -0700216JValue InvokeVirtualOrInterfaceWithJValues(JNIEnv* public_env, jobject obj, jmethodID mid, jvalue* args) {
217 JNIEnvExt* env = reinterpret_cast<JNIEnvExt*>(public_env);
218 Object* receiver = Decode<Object*>(env, obj);
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -0700219 Method* method = FindVirtualMethod(receiver, DecodeMethod(mid));
Elliott Hughes418d20f2011-09-22 14:00:39 -0700220 UniquePtr<byte[]> arg_array(CreateArgArray(env, method, args));
221 return InvokeWithArgArray(env, receiver, method, arg_array.get());
Elliott Hughes72025e52011-08-23 17:50:30 -0700222}
223
Elliott Hughes418d20f2011-09-22 14:00:39 -0700224JValue InvokeVirtualOrInterfaceWithVarArgs(JNIEnv* public_env, jobject obj, jmethodID mid, va_list args) {
225 JNIEnvExt* env = reinterpret_cast<JNIEnvExt*>(public_env);
226 Object* receiver = Decode<Object*>(env, obj);
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -0700227 Method* method = FindVirtualMethod(receiver, DecodeMethod(mid));
Elliott Hughes418d20f2011-09-22 14:00:39 -0700228 UniquePtr<byte[]> arg_array(CreateArgArray(env, method, args));
229 return InvokeWithArgArray(env, receiver, method, arg_array.get());
Carl Shapiroea4dca82011-08-01 13:45:38 -0700230}
231
Elliott Hughes6b436852011-08-12 10:16:44 -0700232// Section 12.3.2 of the JNI spec describes JNI class descriptors. They're
233// separated with slashes but aren't wrapped with "L;" like regular descriptors
234// (i.e. "a/b/C" rather than "La/b/C;"). Arrays of reference types are an
235// exception; there the "L;" must be present ("[La/b/C;"). Historically we've
236// supported names with dots too (such as "a.b.C").
237std::string NormalizeJniClassDescriptor(const char* name) {
238 std::string result;
239 // Add the missing "L;" if necessary.
240 if (name[0] == '[') {
241 result = name;
242 } else {
243 result += 'L';
244 result += name;
245 result += ';';
246 }
247 // Rewrite '.' as '/' for backwards compatibility.
Elliott Hughesa5b897e2011-08-16 11:33:06 -0700248 if (result.find('.') != std::string::npos) {
249 LOG(WARNING) << "Call to JNI FindClass with dots in name: "
250 << "\"" << name << "\"";
251 std::replace(result.begin(), result.end(), '.', '/');
Elliott Hughes6b436852011-08-12 10:16:44 -0700252 }
253 return result;
254}
255
Elliott Hughes14134a12011-09-30 16:55:51 -0700256void ThrowNoSuchMethodError(ScopedJniThreadState& ts, Class* c, const char* name, const char* sig, const char* kind) {
257 std::string class_descriptor(c->GetDescriptor()->ToModifiedUtf8());
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700258 ts.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchMethodError;",
Elliott Hughes14134a12011-09-30 16:55:51 -0700259 "no %s method \"%s.%s%s\"", kind, class_descriptor.c_str(), name, sig);
260}
261
Elliott Hughescdf53122011-08-19 15:46:09 -0700262jmethodID FindMethodID(ScopedJniThreadState& ts, jclass jni_class, const char* name, const char* sig, bool is_static) {
263 Class* c = Decode<Class*>(ts, jni_class);
Brian Carlstrom25c33252011-09-18 15:58:35 -0700264 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true)) {
Elliott Hughesf4c21c92011-08-19 17:31:31 -0700265 return NULL;
Carl Shapiro83ab4f32011-08-15 20:21:39 -0700266 }
Elliott Hughescdf53122011-08-19 15:46:09 -0700267
268 Method* method = NULL;
269 if (is_static) {
270 method = c->FindDirectMethod(name, sig);
Ian Rogers4dd71f12011-08-16 14:16:02 -0700271 } else {
Elliott Hughescdf53122011-08-19 15:46:09 -0700272 method = c->FindVirtualMethod(name, sig);
273 if (method == NULL) {
274 // No virtual method matching the signature. Search declared
275 // private methods and constructors.
276 method = c->FindDeclaredDirectMethod(name, sig);
Ian Rogers4dd71f12011-08-16 14:16:02 -0700277 }
Carl Shapiro83ab4f32011-08-15 20:21:39 -0700278 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700279
Elliott Hughescdf53122011-08-19 15:46:09 -0700280 if (method == NULL || method->IsStatic() != is_static) {
Elliott Hughes14134a12011-09-30 16:55:51 -0700281 ThrowNoSuchMethodError(ts, c, name, sig, is_static ? "static" : "non-static");
Elliott Hughescdf53122011-08-19 15:46:09 -0700282 return NULL;
283 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700284
Elliott Hughes418d20f2011-09-22 14:00:39 -0700285 method->InitJavaFields();
286
Brian Carlstromf91c8c32011-09-21 17:30:34 -0700287 return EncodeMethod(method);
Carl Shapiroea4dca82011-08-01 13:45:38 -0700288}
289
Elliott Hughescdf53122011-08-19 15:46:09 -0700290jfieldID FindFieldID(ScopedJniThreadState& ts, jclass jni_class, const char* name, const char* sig, bool is_static) {
291 Class* c = Decode<Class*>(ts, jni_class);
Brian Carlstrom25c33252011-09-18 15:58:35 -0700292 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true)) {
Elliott Hughesf4c21c92011-08-19 17:31:31 -0700293 return NULL;
Carl Shapiro83ab4f32011-08-15 20:21:39 -0700294 }
Elliott Hughescdf53122011-08-19 15:46:09 -0700295
296 Field* field = NULL;
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700297 Class* field_type;
298 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
299 if (sig[1] != '\0') {
300 // TODO: need to get the appropriate ClassLoader.
301 const ClassLoader* cl = ts.Self()->GetClassLoaderOverride();
302 field_type = class_linker->FindClass(sig, cl);
Ian Rogers4dd71f12011-08-16 14:16:02 -0700303 } else {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700304 field_type = class_linker->FindPrimitiveClass(*sig);
Carl Shapiro9b9ba282011-08-14 15:30:39 -0700305 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700306 if (field_type == NULL) {
307 // Failed to find type from the signature of the field.
Ian Rogersb17d08b2011-09-02 16:16:49 -0700308 DCHECK(ts.Self()->IsExceptionPending());
309 ts.Self()->ClearException();
310 std::string class_descriptor(c->GetDescriptor()->ToModifiedUtf8());
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700311 ts.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
Ian Rogersb17d08b2011-09-02 16:16:49 -0700312 "no type \"%s\" found and so no field \"%s\" could be found in class "
313 "\"%s\" or its superclasses", sig, name, class_descriptor.c_str());
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700314 return NULL;
315 }
316 if (is_static) {
317 field = c->FindStaticField(name, field_type);
318 } else {
319 field = c->FindInstanceField(name, field_type);
320 }
Elliott Hughescdf53122011-08-19 15:46:09 -0700321 if (field == NULL) {
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700322 std::string class_descriptor(c->GetDescriptor()->ToModifiedUtf8());
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700323 ts.Self()->ThrowNewExceptionF("Ljava/lang/NoSuchFieldError;",
Elliott Hughescdf53122011-08-19 15:46:09 -0700324 "no \"%s\" field \"%s\" in class \"%s\" or its superclasses", sig,
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700325 name, class_descriptor.c_str());
Elliott Hughes8a26c5c2011-08-15 18:35:43 -0700326 return NULL;
327 }
Elliott Hughes80609252011-09-23 17:24:51 -0700328 field->InitJavaFields();
Brian Carlstromf91c8c32011-09-21 17:30:34 -0700329 return EncodeField(field);
Carl Shapiroea4dca82011-08-01 13:45:38 -0700330}
331
Elliott Hughes75770752011-08-24 17:52:38 -0700332void PinPrimitiveArray(ScopedJniThreadState& ts, const Array* array) {
333 JavaVMExt* vm = ts.Vm();
334 MutexLock mu(vm->pins_lock);
335 vm->pin_table.Add(array);
336}
337
338void UnpinPrimitiveArray(ScopedJniThreadState& ts, const Array* array) {
339 JavaVMExt* vm = ts.Vm();
340 MutexLock mu(vm->pins_lock);
341 vm->pin_table.Remove(array);
342}
343
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700344template<typename JniT, typename ArtT>
345JniT NewPrimitiveArray(ScopedJniThreadState& ts, jsize length) {
346 CHECK_GE(length, 0); // TODO: ReportJniError
347 ArtT* result = ArtT::Alloc(length);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700348 return AddLocalReference<JniT>(ts.Env(), result);
Elliott Hughesd8ddfd52011-08-15 14:32:53 -0700349}
350
Elliott Hughes75770752011-08-24 17:52:38 -0700351template <typename ArrayT, typename CArrayT, typename ArtArrayT>
352CArrayT GetPrimitiveArray(ScopedJniThreadState& ts, ArrayT java_array, jboolean* is_copy) {
353 ArtArrayT* array = Decode<ArtArrayT*>(ts, java_array);
354 PinPrimitiveArray(ts, array);
355 if (is_copy != NULL) {
356 *is_copy = JNI_FALSE;
357 }
358 return array->GetData();
359}
360
361template <typename ArrayT>
362void ReleasePrimitiveArray(ScopedJniThreadState& ts, ArrayT java_array, jint mode) {
363 if (mode != JNI_COMMIT) {
364 Array* array = Decode<Array*>(ts, java_array);
365 UnpinPrimitiveArray(ts, array);
366 }
367}
368
Elliott Hughes814e4032011-08-23 12:07:56 -0700369void ThrowAIOOBE(ScopedJniThreadState& ts, Array* array, jsize start, jsize length, const char* identifier) {
Elliott Hughes54e7df12011-09-16 11:47:04 -0700370 std::string type(PrettyTypeOf(array));
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700371 ts.Self()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
Elliott Hughes814e4032011-08-23 12:07:56 -0700372 "%s offset=%d length=%d %s.length=%d",
373 type.c_str(), start, length, identifier, array->GetLength());
374}
Elliott Hughesb465ab02011-08-24 11:21:21 -0700375void ThrowSIOOBE(ScopedJniThreadState& ts, jsize start, jsize length, jsize array_length) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700376 ts.Self()->ThrowNewExceptionF("Ljava/lang/StringIndexOutOfBoundsException;",
Elliott Hughesb465ab02011-08-24 11:21:21 -0700377 "offset=%d length=%d string.length()=%d", start, length, array_length);
378}
Elliott Hughes814e4032011-08-23 12:07:56 -0700379
380template <typename JavaArrayT, typename JavaT, typename ArrayT>
Elliott Hughes75770752011-08-24 17:52:38 -0700381void GetPrimitiveArrayRegion(ScopedJniThreadState& ts, JavaArrayT java_array, jsize start, jsize length, JavaT* buf) {
Elliott Hughes814e4032011-08-23 12:07:56 -0700382 ArrayT* array = Decode<ArrayT*>(ts, java_array);
383 if (start < 0 || length < 0 || start + length > array->GetLength()) {
384 ThrowAIOOBE(ts, array, start, length, "src");
385 } else {
386 JavaT* data = array->GetData();
387 memcpy(buf, data + start, length * sizeof(JavaT));
388 }
389}
390
391template <typename JavaArrayT, typename JavaT, typename ArrayT>
Elliott Hughes75770752011-08-24 17:52:38 -0700392void SetPrimitiveArrayRegion(ScopedJniThreadState& ts, JavaArrayT java_array, jsize start, jsize length, const JavaT* buf) {
Elliott Hughes814e4032011-08-23 12:07:56 -0700393 ArrayT* array = Decode<ArrayT*>(ts, java_array);
394 if (start < 0 || length < 0 || start + length > array->GetLength()) {
395 ThrowAIOOBE(ts, array, start, length, "dst");
396 } else {
397 JavaT* data = array->GetData();
398 memcpy(data + start, buf, length * sizeof(JavaT));
399 }
400}
401
Elliott Hughes75770752011-08-24 17:52:38 -0700402jclass InitDirectByteBufferClass(JNIEnv* env) {
Elliott Hughesb465ab02011-08-24 11:21:21 -0700403 ScopedLocalRef<jclass> buffer_class(env, env->FindClass("java/nio/ReadWriteDirectByteBuffer"));
404 CHECK(buffer_class.get() != NULL);
405 return reinterpret_cast<jclass>(env->NewGlobalRef(buffer_class.get()));
406}
407
Elliott Hughes75770752011-08-24 17:52:38 -0700408jclass GetDirectByteBufferClass(JNIEnv* env) {
Elliott Hughesb465ab02011-08-24 11:21:21 -0700409 static jclass buffer_class = InitDirectByteBufferClass(env);
410 return buffer_class;
411}
412
Elliott Hughes75770752011-08-24 17:52:38 -0700413jint JII_AttachCurrentThread(JavaVM* vm, JNIEnv** p_env, void* thr_args, bool as_daemon) {
414 if (vm == NULL || p_env == NULL) {
415 return JNI_ERR;
416 }
417
418 JavaVMAttachArgs* in_args = static_cast<JavaVMAttachArgs*>(thr_args);
419 JavaVMAttachArgs args;
420 if (thr_args == NULL) {
421 // Allow the v1.1 calling convention.
422 args.version = JNI_VERSION_1_2;
423 args.name = NULL;
424 args.group = NULL; // TODO: get "main" thread group
425 } else {
426 args.version = in_args->version;
427 args.name = in_args->name;
428 if (in_args->group != NULL) {
429 UNIMPLEMENTED(WARNING) << "thr_args->group != NULL";
430 args.group = NULL; // TODO: decode in_args->group
431 } else {
432 args.group = NULL; // TODO: get "main" thread group
433 }
434 }
435 CHECK_GE(args.version, JNI_VERSION_1_2);
436
437 Runtime* runtime = reinterpret_cast<JavaVMExt*>(vm)->runtime;
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700438 runtime->AttachCurrentThread(args.name, as_daemon);
439 *p_env = Thread::Current()->GetJniEnv();
Elliott Hughesd92bec42011-09-02 17:04:36 -0700440 return JNI_OK;
Elliott Hughes75770752011-08-24 17:52:38 -0700441}
442
Elliott Hughes79082e32011-08-25 12:07:32 -0700443class SharedLibrary {
444 public:
445 SharedLibrary(const std::string& path, void* handle, Object* class_loader)
446 : path_(path),
447 handle_(handle),
Shih-wei Liao31384c52011-09-06 15:27:45 -0700448 class_loader_(class_loader),
Elliott Hughes8daa0922011-09-11 13:46:25 -0700449 jni_on_load_lock_("JNI_OnLoad lock"),
Elliott Hughes5f791332011-09-15 17:45:30 -0700450 jni_on_load_cond_("JNI_OnLoad"),
Elliott Hughesdcc24742011-09-07 14:02:44 -0700451 jni_on_load_thread_id_(Thread::Current()->GetThinLockId()),
Elliott Hughes79082e32011-08-25 12:07:32 -0700452 jni_on_load_result_(kPending) {
Elliott Hughes79082e32011-08-25 12:07:32 -0700453 }
454
Elliott Hughes79082e32011-08-25 12:07:32 -0700455 Object* GetClassLoader() {
456 return class_loader_;
457 }
458
459 std::string GetPath() {
460 return path_;
461 }
462
463 /*
464 * Check the result of an earlier call to JNI_OnLoad on this library. If
465 * the call has not yet finished in another thread, wait for it.
466 */
467 bool CheckOnLoadResult(JavaVMExt* vm) {
468 Thread* self = Thread::Current();
Elliott Hughesdcc24742011-09-07 14:02:44 -0700469 if (jni_on_load_thread_id_ == self->GetThinLockId()) {
Elliott Hughes79082e32011-08-25 12:07:32 -0700470 // Check this so we don't end up waiting for ourselves. We need
471 // to return "true" so the caller can continue.
472 LOG(INFO) << *self << " recursive attempt to load library "
473 << "\"" << path_ << "\"";
474 return true;
475 }
476
477 MutexLock mu(jni_on_load_lock_);
478 while (jni_on_load_result_ == kPending) {
479 if (vm->verbose_jni) {
480 LOG(INFO) << "[" << *self << " waiting for \"" << path_ << "\" "
481 << "JNI_OnLoad...]";
482 }
Elliott Hughes93e74e82011-09-13 11:07:03 -0700483 ScopedThreadStateChange tsc(self, Thread::kVmWait);
Elliott Hughes5f791332011-09-15 17:45:30 -0700484 jni_on_load_cond_.Wait(jni_on_load_lock_);
Elliott Hughes79082e32011-08-25 12:07:32 -0700485 }
486
487 bool okay = (jni_on_load_result_ == kOkay);
488 if (vm->verbose_jni) {
489 LOG(INFO) << "[Earlier JNI_OnLoad for \"" << path_ << "\" "
490 << (okay ? "succeeded" : "failed") << "]";
491 }
492 return okay;
493 }
494
495 void SetResult(bool result) {
496 jni_on_load_result_ = result ? kOkay : kFailed;
Elliott Hughesdcc24742011-09-07 14:02:44 -0700497 jni_on_load_thread_id_ = 0;
Elliott Hughes79082e32011-08-25 12:07:32 -0700498
499 // Broadcast a wakeup to anybody sleeping on the condition variable.
500 MutexLock mu(jni_on_load_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700501 jni_on_load_cond_.Broadcast();
Elliott Hughes79082e32011-08-25 12:07:32 -0700502 }
503
504 void* FindSymbol(const std::string& symbol_name) {
505 return dlsym(handle_, symbol_name.c_str());
506 }
507
508 private:
509 enum JNI_OnLoadState {
510 kPending,
511 kFailed,
512 kOkay,
513 };
514
515 // Path to library "/system/lib/libjni.so".
516 std::string path_;
517
518 // The void* returned by dlopen(3).
519 void* handle_;
520
521 // The ClassLoader this library is associated with.
522 Object* class_loader_;
523
524 // Guards remaining items.
Elliott Hughes8daa0922011-09-11 13:46:25 -0700525 Mutex jni_on_load_lock_;
Elliott Hughes79082e32011-08-25 12:07:32 -0700526 // Wait for JNI_OnLoad in other thread.
Elliott Hughes5f791332011-09-15 17:45:30 -0700527 ConditionVariable jni_on_load_cond_;
Elliott Hughes79082e32011-08-25 12:07:32 -0700528 // Recursive invocation guard.
Elliott Hughesdcc24742011-09-07 14:02:44 -0700529 uint32_t jni_on_load_thread_id_;
Elliott Hughes79082e32011-08-25 12:07:32 -0700530 // Result of earlier JNI_OnLoad call.
531 JNI_OnLoadState jni_on_load_result_;
532};
533
Elliott Hughescdf53122011-08-19 15:46:09 -0700534} // namespace
Carl Shapiroea4dca82011-08-01 13:45:38 -0700535
Elliott Hughes79082e32011-08-25 12:07:32 -0700536// This exists mainly to keep implementation details out of the header file.
537class Libraries {
538 public:
539 Libraries() {
540 }
541
542 ~Libraries() {
Elliott Hughesc31664f2011-09-29 15:58:28 -0700543 STLDeleteValues(&libraries_);
Elliott Hughes79082e32011-08-25 12:07:32 -0700544 }
545
546 SharedLibrary* Get(const std::string& path) {
547 return libraries_[path];
548 }
549
550 void Put(const std::string& path, SharedLibrary* library) {
551 libraries_[path] = library;
552 }
553
554 // See section 11.3 "Linking Native Methods" of the JNI spec.
Brian Carlstrom16192862011-09-12 17:50:06 -0700555 void* FindNativeMethod(const Method* m, std::string& detail) {
Elliott Hughes79082e32011-08-25 12:07:32 -0700556 std::string jni_short_name(JniShortName(m));
557 std::string jni_long_name(JniLongName(m));
Elliott Hughes4b093bf2011-08-25 13:34:29 -0700558 const ClassLoader* declaring_class_loader = m->GetDeclaringClass()->GetClassLoader();
Elliott Hughes79082e32011-08-25 12:07:32 -0700559 for (It it = libraries_.begin(); it != libraries_.end(); ++it) {
560 SharedLibrary* library = it->second;
561 if (library->GetClassLoader() != declaring_class_loader) {
562 // We only search libraries loaded by the appropriate ClassLoader.
563 continue;
564 }
565 // Try the short name then the long name...
566 void* fn = library->FindSymbol(jni_short_name);
567 if (fn == NULL) {
568 fn = library->FindSymbol(jni_long_name);
569 }
570 if (fn != NULL) {
571 if (Runtime::Current()->GetJavaVM()->verbose_jni) {
Elliott Hughesa2501992011-08-26 19:39:54 -0700572 LOG(INFO) << "[Found native code for " << PrettyMethod(m)
Elliott Hughes79082e32011-08-25 12:07:32 -0700573 << " in \"" << library->GetPath() << "\"]";
574 }
575 return fn;
576 }
577 }
Elliott Hughes79082e32011-08-25 12:07:32 -0700578 detail += "No implementation found for ";
Elliott Hughesa2501992011-08-26 19:39:54 -0700579 detail += PrettyMethod(m);
Brian Carlstrom92827a52011-10-10 15:50:01 -0700580 detail += " (tried " + jni_short_name + " and " + jni_long_name + ")";
Elliott Hughes79082e32011-08-25 12:07:32 -0700581 LOG(ERROR) << detail;
Elliott Hughes79082e32011-08-25 12:07:32 -0700582 return NULL;
583 }
584
585 private:
586 typedef std::map<std::string, SharedLibrary*>::iterator It; // TODO: C++0x auto
587
588 std::map<std::string, SharedLibrary*> libraries_;
589};
590
Elliott Hughes418d20f2011-09-22 14:00:39 -0700591JValue InvokeWithJValues(JNIEnv* public_env, jobject obj, jmethodID mid, jvalue* args) {
592 JNIEnvExt* env = reinterpret_cast<JNIEnvExt*>(public_env);
593 Object* receiver = Decode<Object*>(env, obj);
594 Method* method = DecodeMethod(mid);
595 UniquePtr<byte[]> arg_array(CreateArgArray(env, method, args));
596 return InvokeWithArgArray(env, receiver, method, arg_array.get());
597}
598
Elliott Hughescdf53122011-08-19 15:46:09 -0700599class JNI {
600 public:
Carl Shapiroea4dca82011-08-01 13:45:38 -0700601
Elliott Hughescdf53122011-08-19 15:46:09 -0700602 static jint GetVersion(JNIEnv* env) {
603 ScopedJniThreadState ts(env);
604 return JNI_VERSION_1_6;
605 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700606
Elliott Hughescdf53122011-08-19 15:46:09 -0700607 static jclass DefineClass(JNIEnv* env, const char*, jobject, const jbyte*, jsize) {
608 ScopedJniThreadState ts(env);
609 LOG(WARNING) << "JNI DefineClass is not supported";
Elliott Hughesf2682d52011-08-15 16:37:04 -0700610 return NULL;
611 }
612
Elliott Hughescdf53122011-08-19 15:46:09 -0700613 static jclass FindClass(JNIEnv* env, const char* name) {
614 ScopedJniThreadState ts(env);
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700615 Runtime* runtime = Runtime::Current();
616 ClassLinker* class_linker = runtime->GetClassLinker();
Elliott Hughescdf53122011-08-19 15:46:09 -0700617 std::string descriptor(NormalizeJniClassDescriptor(name));
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700618 Class* c = NULL;
619 if (runtime->IsStarted()) {
620 // TODO: need to get the appropriate ClassLoader.
621 const ClassLoader* cl = ts.Self()->GetClassLoaderOverride();
622 c = class_linker->FindClass(descriptor, cl);
623 } else {
624 c = class_linker->FindSystemClass(descriptor);
625 }
Elliott Hughesbf86d042011-08-31 17:53:14 -0700626 return AddLocalReference<jclass>(env, c);
Ian Rogers4dd71f12011-08-16 14:16:02 -0700627 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700628
Elliott Hughescdf53122011-08-19 15:46:09 -0700629 static jmethodID FromReflectedMethod(JNIEnv* env, jobject java_method) {
630 ScopedJniThreadState ts(env);
631 Method* method = Decode<Method*>(ts, java_method);
Brian Carlstromf91c8c32011-09-21 17:30:34 -0700632 return EncodeMethod(method);
Elliott Hughesf2682d52011-08-15 16:37:04 -0700633 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700634
Elliott Hughescdf53122011-08-19 15:46:09 -0700635 static jfieldID FromReflectedField(JNIEnv* env, jobject java_field) {
636 ScopedJniThreadState ts(env);
637 Field* field = Decode<Field*>(ts, java_field);
Brian Carlstromf91c8c32011-09-21 17:30:34 -0700638 return EncodeField(field);
Elliott Hughescdf53122011-08-19 15:46:09 -0700639 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700640
Elliott Hughescdf53122011-08-19 15:46:09 -0700641 static jobject ToReflectedMethod(JNIEnv* env, jclass, jmethodID mid, jboolean) {
642 ScopedJniThreadState ts(env);
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -0700643 Method* method = DecodeMethod(mid);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700644 return AddLocalReference<jobject>(env, method);
Elliott Hughescdf53122011-08-19 15:46:09 -0700645 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700646
Elliott Hughescdf53122011-08-19 15:46:09 -0700647 static jobject ToReflectedField(JNIEnv* env, jclass, jfieldID fid, jboolean) {
648 ScopedJniThreadState ts(env);
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -0700649 Field* field = DecodeField(fid);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700650 return AddLocalReference<jobject>(env, field);
Elliott Hughescdf53122011-08-19 15:46:09 -0700651 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700652
Elliott Hughes37f7a402011-08-22 18:56:01 -0700653 static jclass GetObjectClass(JNIEnv* env, jobject java_object) {
654 ScopedJniThreadState ts(env);
655 Object* o = Decode<Object*>(ts, java_object);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700656 return AddLocalReference<jclass>(env, o->GetClass());
Elliott Hughes37f7a402011-08-22 18:56:01 -0700657 }
658
Elliott Hughes885c3bd2011-08-22 16:59:20 -0700659 static jclass GetSuperclass(JNIEnv* env, jclass java_class) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700660 ScopedJniThreadState ts(env);
Elliott Hughes885c3bd2011-08-22 16:59:20 -0700661 Class* c = Decode<Class*>(ts, java_class);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700662 return AddLocalReference<jclass>(env, c->GetSuperClass());
Elliott Hughescdf53122011-08-19 15:46:09 -0700663 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700664
Elliott Hughes37f7a402011-08-22 18:56:01 -0700665 static jboolean IsAssignableFrom(JNIEnv* env, jclass java_class1, jclass java_class2) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700666 ScopedJniThreadState ts(env);
Elliott Hughes37f7a402011-08-22 18:56:01 -0700667 Class* c1 = Decode<Class*>(ts, java_class1);
668 Class* c2 = Decode<Class*>(ts, java_class2);
669 return c1->IsAssignableFrom(c2) ? JNI_TRUE : JNI_FALSE;
Elliott Hughescdf53122011-08-19 15:46:09 -0700670 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700671
Elliott Hughes37f7a402011-08-22 18:56:01 -0700672 static jboolean IsInstanceOf(JNIEnv* env, jobject jobj, jclass clazz) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700673 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -0700674 CHECK_NE(static_cast<jclass>(NULL), clazz); // TODO: ReportJniError
Elliott Hughes37f7a402011-08-22 18:56:01 -0700675 if (jobj == NULL) {
Brian Carlstrom5d40f182011-09-26 22:29:18 -0700676 // Note: JNI is different from regular Java instanceof in this respect
Elliott Hughes37f7a402011-08-22 18:56:01 -0700677 return JNI_TRUE;
678 } else {
679 Object* obj = Decode<Object*>(ts, jobj);
680 Class* klass = Decode<Class*>(ts, clazz);
Brian Carlstrom5d40f182011-09-26 22:29:18 -0700681 return obj->InstanceOf(klass) ? JNI_TRUE : JNI_FALSE;
Elliott Hughes37f7a402011-08-22 18:56:01 -0700682 }
Elliott Hughescdf53122011-08-19 15:46:09 -0700683 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700684
Elliott Hughes37f7a402011-08-22 18:56:01 -0700685 static jint Throw(JNIEnv* env, jthrowable java_exception) {
686 ScopedJniThreadState ts(env);
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700687 Throwable* exception = Decode<Throwable*>(ts, java_exception);
Elliott Hughes37f7a402011-08-22 18:56:01 -0700688 if (exception == NULL) {
689 return JNI_ERR;
690 }
691 ts.Self()->SetException(exception);
692 return JNI_OK;
693 }
694
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700695 static jint ThrowNew(JNIEnv* env, jclass c, const char* msg) {
Elliott Hughes37f7a402011-08-22 18:56:01 -0700696 ScopedJniThreadState ts(env);
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700697 // TODO: check for a pending exception to decide what constructor to call.
698 jmethodID mid = env->GetMethodID(c, "<init>", "(Ljava/lang/String;)V");
699 if (mid == NULL) {
700 return JNI_ERR;
701 }
Elliott Hughes72025e52011-08-23 17:50:30 -0700702 ScopedLocalRef<jstring> s(env, env->NewStringUTF(msg));
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700703 if (msg != NULL && s.get() == NULL) {
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700704 return JNI_ERR;
705 }
706
707 jvalue args[1];
Elliott Hughes72025e52011-08-23 17:50:30 -0700708 args[0].l = s.get();
709 ScopedLocalRef<jthrowable> exception(env, reinterpret_cast<jthrowable>(env->NewObjectA(c, mid, args)));
710 if (exception.get() == NULL) {
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700711 return JNI_ERR;
712 }
713
Elliott Hughes72025e52011-08-23 17:50:30 -0700714 ts.Self()->SetException(Decode<Throwable*>(ts, exception.get()));
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700715
Elliott Hughes37f7a402011-08-22 18:56:01 -0700716 return JNI_OK;
717 }
718
719 static jboolean ExceptionCheck(JNIEnv* env) {
720 ScopedJniThreadState ts(env);
721 return ts.Self()->IsExceptionPending() ? JNI_TRUE : JNI_FALSE;
722 }
723
724 static void ExceptionClear(JNIEnv* env) {
725 ScopedJniThreadState ts(env);
726 ts.Self()->ClearException();
727 }
728
729 static void ExceptionDescribe(JNIEnv* env) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700730 ScopedJniThreadState ts(env);
Elliott Hughes72025e52011-08-23 17:50:30 -0700731
732 Thread* self = ts.Self();
733 Throwable* original_exception = self->GetException();
734 self->ClearException();
735
Elliott Hughesbf86d042011-08-31 17:53:14 -0700736 ScopedLocalRef<jthrowable> exception(env, AddLocalReference<jthrowable>(env, original_exception));
Elliott Hughes72025e52011-08-23 17:50:30 -0700737 ScopedLocalRef<jclass> exception_class(env, env->GetObjectClass(exception.get()));
738 jmethodID mid = env->GetMethodID(exception_class.get(), "printStackTrace", "()V");
739 if (mid == NULL) {
740 LOG(WARNING) << "JNI WARNING: no printStackTrace()V in "
Elliott Hughes54e7df12011-09-16 11:47:04 -0700741 << PrettyTypeOf(original_exception);
Elliott Hughes72025e52011-08-23 17:50:30 -0700742 } else {
743 env->CallVoidMethod(exception.get(), mid);
744 if (self->IsExceptionPending()) {
Elliott Hughes54e7df12011-09-16 11:47:04 -0700745 LOG(WARNING) << "JNI WARNING: " << PrettyTypeOf(self->GetException())
Elliott Hughes72025e52011-08-23 17:50:30 -0700746 << " thrown while calling printStackTrace";
747 self->ClearException();
748 }
749 }
750
751 self->SetException(original_exception);
Elliott Hughescdf53122011-08-19 15:46:09 -0700752 }
Carl Shapiroea4dca82011-08-01 13:45:38 -0700753
Elliott Hughescdf53122011-08-19 15:46:09 -0700754 static jthrowable ExceptionOccurred(JNIEnv* env) {
755 ScopedJniThreadState ts(env);
756 Object* exception = ts.Self()->GetException();
757 if (exception == NULL) {
758 return NULL;
759 } else {
760 // TODO: if adding a local reference failing causes the VM to abort
761 // then the following check will never occur.
Elliott Hughesbf86d042011-08-31 17:53:14 -0700762 jthrowable localException = AddLocalReference<jthrowable>(env, exception);
Elliott Hughescdf53122011-08-19 15:46:09 -0700763 if (localException == NULL) {
764 // We were unable to add a new local reference, and threw a new
765 // exception. We can't return "exception", because it's not a
766 // local reference. So we have to return NULL, indicating that
767 // there was no exception, even though it's pretty much raining
768 // exceptions in here.
769 LOG(WARNING) << "JNI WARNING: addLocal/exception combo";
770 }
771 return localException;
772 }
773 }
774
Elliott Hughescdf53122011-08-19 15:46:09 -0700775 static void FatalError(JNIEnv* env, const char* msg) {
776 ScopedJniThreadState ts(env);
777 LOG(FATAL) << "JNI FatalError called: " << msg;
778 }
779
780 static jint PushLocalFrame(JNIEnv* env, jint cap) {
781 ScopedJniThreadState ts(env);
782 UNIMPLEMENTED(WARNING) << "ignoring PushLocalFrame(" << cap << ")";
783 return JNI_OK;
784 }
785
786 static jobject PopLocalFrame(JNIEnv* env, jobject res) {
787 ScopedJniThreadState ts(env);
788 UNIMPLEMENTED(WARNING) << "ignoring PopLocalFrame " << res;
789 return res;
790 }
791
Elliott Hughes72025e52011-08-23 17:50:30 -0700792 static jint EnsureLocalCapacity(JNIEnv* env, jint cap) {
793 ScopedJniThreadState ts(env);
794 UNIMPLEMENTED(WARNING) << "ignoring EnsureLocalCapacity(" << cap << ")";
795 return 0;
796 }
797
Elliott Hughescdf53122011-08-19 15:46:09 -0700798 static jobject NewGlobalRef(JNIEnv* env, jobject obj) {
799 ScopedJniThreadState ts(env);
800 if (obj == NULL) {
801 return NULL;
802 }
803
Elliott Hughes75770752011-08-24 17:52:38 -0700804 JavaVMExt* vm = ts.Vm();
Elliott Hughescdf53122011-08-19 15:46:09 -0700805 IndirectReferenceTable& globals = vm->globals;
806 MutexLock mu(vm->globals_lock);
807 IndirectRef ref = globals.Add(IRT_FIRST_SEGMENT, Decode<Object*>(ts, obj));
808 return reinterpret_cast<jobject>(ref);
809 }
810
811 static void DeleteGlobalRef(JNIEnv* env, jobject obj) {
812 ScopedJniThreadState ts(env);
813 if (obj == NULL) {
814 return;
815 }
816
Elliott Hughes75770752011-08-24 17:52:38 -0700817 JavaVMExt* vm = ts.Vm();
Elliott Hughescdf53122011-08-19 15:46:09 -0700818 IndirectReferenceTable& globals = vm->globals;
819 MutexLock mu(vm->globals_lock);
820
821 if (!globals.Remove(IRT_FIRST_SEGMENT, obj)) {
822 LOG(WARNING) << "JNI WARNING: DeleteGlobalRef(" << obj << ") "
823 << "failed to find entry";
824 }
825 }
826
827 static jweak NewWeakGlobalRef(JNIEnv* env, jobject obj) {
828 ScopedJniThreadState ts(env);
829 return AddWeakGlobalReference(ts, Decode<Object*>(ts, obj));
830 }
831
832 static void DeleteWeakGlobalRef(JNIEnv* env, jweak obj) {
833 ScopedJniThreadState ts(env);
834 if (obj == NULL) {
835 return;
836 }
837
Elliott Hughes75770752011-08-24 17:52:38 -0700838 JavaVMExt* vm = ts.Vm();
Elliott Hughescdf53122011-08-19 15:46:09 -0700839 IndirectReferenceTable& weak_globals = vm->weak_globals;
840 MutexLock mu(vm->weak_globals_lock);
841
842 if (!weak_globals.Remove(IRT_FIRST_SEGMENT, obj)) {
843 LOG(WARNING) << "JNI WARNING: DeleteWeakGlobalRef(" << obj << ") "
844 << "failed to find entry";
845 }
846 }
847
848 static jobject NewLocalRef(JNIEnv* env, jobject obj) {
849 ScopedJniThreadState ts(env);
850 if (obj == NULL) {
851 return NULL;
852 }
853
854 IndirectReferenceTable& locals = ts.Env()->locals;
855
Ian Rogers5a7a74a2011-09-26 16:32:29 -0700856 uint32_t cookie = ts.Env()->local_ref_cookie;
Elliott Hughescdf53122011-08-19 15:46:09 -0700857 IndirectRef ref = locals.Add(cookie, Decode<Object*>(ts, obj));
858 return reinterpret_cast<jobject>(ref);
859 }
860
861 static void DeleteLocalRef(JNIEnv* env, jobject obj) {
862 ScopedJniThreadState ts(env);
863 if (obj == NULL) {
864 return;
865 }
866
867 IndirectReferenceTable& locals = ts.Env()->locals;
868
Ian Rogers5a7a74a2011-09-26 16:32:29 -0700869 uint32_t cookie = ts.Env()->local_ref_cookie;
Elliott Hughescdf53122011-08-19 15:46:09 -0700870 if (!locals.Remove(cookie, obj)) {
871 // Attempting to delete a local reference that is not in the
872 // topmost local reference frame is a no-op. DeleteLocalRef returns
873 // void and doesn't throw any exceptions, but we should probably
874 // complain about it so the user will notice that things aren't
875 // going quite the way they expect.
876 LOG(WARNING) << "JNI WARNING: DeleteLocalRef(" << obj << ") "
877 << "failed to find entry";
878 }
879 }
880
881 static jboolean IsSameObject(JNIEnv* env, jobject obj1, jobject obj2) {
882 ScopedJniThreadState ts(env);
883 return (Decode<Object*>(ts, obj1) == Decode<Object*>(ts, obj2))
884 ? JNI_TRUE : JNI_FALSE;
885 }
886
Elliott Hughes885c3bd2011-08-22 16:59:20 -0700887 static jobject AllocObject(JNIEnv* env, jclass java_class) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700888 ScopedJniThreadState ts(env);
Elliott Hughes885c3bd2011-08-22 16:59:20 -0700889 Class* c = Decode<Class*>(ts, java_class);
Brian Carlstrom25c33252011-09-18 15:58:35 -0700890 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true)) {
Elliott Hughes885c3bd2011-08-22 16:59:20 -0700891 return NULL;
892 }
Elliott Hughesbf86d042011-08-31 17:53:14 -0700893 return AddLocalReference<jobject>(env, c->AllocObject());
Elliott Hughescdf53122011-08-19 15:46:09 -0700894 }
895
Elliott Hughes72025e52011-08-23 17:50:30 -0700896 static jobject NewObject(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700897 ScopedJniThreadState ts(env);
898 va_list args;
Elliott Hughes72025e52011-08-23 17:50:30 -0700899 va_start(args, mid);
900 jobject result = NewObjectV(env, clazz, mid, args);
Elliott Hughescdf53122011-08-19 15:46:09 -0700901 va_end(args);
902 return result;
903 }
904
Elliott Hughes72025e52011-08-23 17:50:30 -0700905 static jobject NewObjectV(JNIEnv* env, jclass java_class, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700906 ScopedJniThreadState ts(env);
Elliott Hughes885c3bd2011-08-22 16:59:20 -0700907 Class* c = Decode<Class*>(ts, java_class);
Brian Carlstrom25c33252011-09-18 15:58:35 -0700908 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true)) {
Elliott Hughes885c3bd2011-08-22 16:59:20 -0700909 return NULL;
910 }
Brian Carlstrom1f870082011-08-23 16:02:11 -0700911 Object* result = c->AllocObject();
Elliott Hughesbf86d042011-08-31 17:53:14 -0700912 jobject local_result = AddLocalReference<jobject>(env, result);
Elliott Hughes72025e52011-08-23 17:50:30 -0700913 CallNonvirtualVoidMethodV(env, local_result, java_class, mid, args);
Elliott Hughescdf53122011-08-19 15:46:09 -0700914 return local_result;
915 }
916
Elliott Hughes72025e52011-08-23 17:50:30 -0700917 static jobject NewObjectA(JNIEnv* env, jclass java_class, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700918 ScopedJniThreadState ts(env);
Elliott Hughes885c3bd2011-08-22 16:59:20 -0700919 Class* c = Decode<Class*>(ts, java_class);
Brian Carlstrom25c33252011-09-18 15:58:35 -0700920 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true)) {
Elliott Hughes885c3bd2011-08-22 16:59:20 -0700921 return NULL;
922 }
Brian Carlstrom1f870082011-08-23 16:02:11 -0700923 Object* result = c->AllocObject();
Elliott Hughesbf86d042011-08-31 17:53:14 -0700924 jobject local_result = AddLocalReference<jobjectArray>(env, result);
Elliott Hughes72025e52011-08-23 17:50:30 -0700925 CallNonvirtualVoidMethodA(env, local_result, java_class, mid, args);
Elliott Hughescdf53122011-08-19 15:46:09 -0700926 return local_result;
927 }
928
Elliott Hughescdf53122011-08-19 15:46:09 -0700929 static jmethodID GetMethodID(JNIEnv* env, jclass c, const char* name, const char* sig) {
930 ScopedJniThreadState ts(env);
931 return FindMethodID(ts, c, name, sig, false);
932 }
933
934 static jmethodID GetStaticMethodID(JNIEnv* env, jclass c, const char* name, const char* sig) {
935 ScopedJniThreadState ts(env);
936 return FindMethodID(ts, c, name, sig, true);
937 }
938
Elliott Hughes72025e52011-08-23 17:50:30 -0700939 static jobject CallObjectMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700940 ScopedJniThreadState ts(env);
Elliott Hughes72025e52011-08-23 17:50:30 -0700941 va_list ap;
942 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700943 JValue result = InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, ap);
Elliott Hughes72025e52011-08-23 17:50:30 -0700944 va_end(ap);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700945 return AddLocalReference<jobject>(env, result.l);
Elliott Hughescdf53122011-08-19 15:46:09 -0700946 }
947
Elliott Hughes72025e52011-08-23 17:50:30 -0700948 static jobject CallObjectMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700949 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700950 JValue result = InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, args);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700951 return AddLocalReference<jobject>(env, result.l);
Elliott Hughescdf53122011-08-19 15:46:09 -0700952 }
953
Elliott Hughes72025e52011-08-23 17:50:30 -0700954 static jobject CallObjectMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700955 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700956 JValue result = InvokeVirtualOrInterfaceWithJValues(env, obj, mid, args);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700957 return AddLocalReference<jobject>(env, result.l);
Elliott Hughescdf53122011-08-19 15:46:09 -0700958 }
959
Elliott Hughes72025e52011-08-23 17:50:30 -0700960 static jboolean CallBooleanMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700961 ScopedJniThreadState ts(env);
Elliott Hughes72025e52011-08-23 17:50:30 -0700962 va_list ap;
963 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700964 JValue result = InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, ap);
Elliott Hughes72025e52011-08-23 17:50:30 -0700965 va_end(ap);
966 return result.z;
Elliott Hughescdf53122011-08-19 15:46:09 -0700967 }
968
Elliott Hughes72025e52011-08-23 17:50:30 -0700969 static jboolean CallBooleanMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700970 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700971 return InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, args).z;
Elliott Hughescdf53122011-08-19 15:46:09 -0700972 }
973
Elliott Hughes72025e52011-08-23 17:50:30 -0700974 static jboolean CallBooleanMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700975 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700976 return InvokeVirtualOrInterfaceWithJValues(env, obj, mid, args).z;
Elliott Hughescdf53122011-08-19 15:46:09 -0700977 }
978
Elliott Hughes72025e52011-08-23 17:50:30 -0700979 static jbyte CallByteMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700980 ScopedJniThreadState ts(env);
Elliott Hughes72025e52011-08-23 17:50:30 -0700981 va_list ap;
982 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700983 JValue result = InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, ap);
Elliott Hughes72025e52011-08-23 17:50:30 -0700984 va_end(ap);
985 return result.b;
Elliott Hughescdf53122011-08-19 15:46:09 -0700986 }
987
Elliott Hughes72025e52011-08-23 17:50:30 -0700988 static jbyte CallByteMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700989 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700990 return InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, args).b;
Elliott Hughescdf53122011-08-19 15:46:09 -0700991 }
992
Elliott Hughes72025e52011-08-23 17:50:30 -0700993 static jbyte CallByteMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700994 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -0700995 return InvokeVirtualOrInterfaceWithJValues(env, obj, mid, args).b;
Elliott Hughescdf53122011-08-19 15:46:09 -0700996 }
997
Elliott Hughes72025e52011-08-23 17:50:30 -0700998 static jchar CallCharMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -0700999 ScopedJniThreadState ts(env);
Elliott Hughes72025e52011-08-23 17:50:30 -07001000 va_list ap;
1001 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001002 JValue result = InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, ap);
Elliott Hughes72025e52011-08-23 17:50:30 -07001003 va_end(ap);
1004 return result.c;
Elliott Hughescdf53122011-08-19 15:46:09 -07001005 }
1006
Elliott Hughes72025e52011-08-23 17:50:30 -07001007 static jchar CallCharMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001008 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001009 return InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, args).c;
Elliott Hughescdf53122011-08-19 15:46:09 -07001010 }
1011
Elliott Hughes72025e52011-08-23 17:50:30 -07001012 static jchar CallCharMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001013 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001014 return InvokeVirtualOrInterfaceWithJValues(env, obj, mid, args).c;
Elliott Hughescdf53122011-08-19 15:46:09 -07001015 }
1016
Elliott Hughes72025e52011-08-23 17:50:30 -07001017 static jdouble CallDoubleMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001018 ScopedJniThreadState ts(env);
Elliott Hughes72025e52011-08-23 17:50:30 -07001019 va_list ap;
1020 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001021 JValue result = InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, ap);
Elliott Hughes72025e52011-08-23 17:50:30 -07001022 va_end(ap);
1023 return result.d;
Elliott Hughescdf53122011-08-19 15:46:09 -07001024 }
1025
Elliott Hughes72025e52011-08-23 17:50:30 -07001026 static jdouble CallDoubleMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001027 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001028 return InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, args).d;
Elliott Hughescdf53122011-08-19 15:46:09 -07001029 }
1030
Elliott Hughes72025e52011-08-23 17:50:30 -07001031 static jdouble CallDoubleMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001032 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001033 return InvokeVirtualOrInterfaceWithJValues(env, obj, mid, args).d;
Elliott Hughescdf53122011-08-19 15:46:09 -07001034 }
1035
Elliott Hughes72025e52011-08-23 17:50:30 -07001036 static jfloat CallFloatMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001037 ScopedJniThreadState ts(env);
Elliott Hughes72025e52011-08-23 17:50:30 -07001038 va_list ap;
1039 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001040 JValue result = InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, ap);
Elliott Hughes72025e52011-08-23 17:50:30 -07001041 va_end(ap);
1042 return result.f;
Elliott Hughescdf53122011-08-19 15:46:09 -07001043 }
1044
Elliott Hughes72025e52011-08-23 17:50:30 -07001045 static jfloat CallFloatMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001046 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001047 return InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, args).f;
Elliott Hughescdf53122011-08-19 15:46:09 -07001048 }
1049
Elliott Hughes72025e52011-08-23 17:50:30 -07001050 static jfloat CallFloatMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001051 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001052 return InvokeVirtualOrInterfaceWithJValues(env, obj, mid, args).f;
Elliott Hughescdf53122011-08-19 15:46:09 -07001053 }
1054
Elliott Hughes72025e52011-08-23 17:50:30 -07001055 static jint CallIntMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001056 ScopedJniThreadState ts(env);
Elliott Hughes72025e52011-08-23 17:50:30 -07001057 va_list ap;
1058 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001059 JValue result = InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, ap);
Elliott Hughes72025e52011-08-23 17:50:30 -07001060 va_end(ap);
1061 return result.i;
Elliott Hughescdf53122011-08-19 15:46:09 -07001062 }
1063
Elliott Hughes72025e52011-08-23 17:50:30 -07001064 static jint CallIntMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001065 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001066 return InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, args).i;
Elliott Hughescdf53122011-08-19 15:46:09 -07001067 }
1068
Elliott Hughes72025e52011-08-23 17:50:30 -07001069 static jint CallIntMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001070 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001071 return InvokeVirtualOrInterfaceWithJValues(env, obj, mid, args).i;
Elliott Hughescdf53122011-08-19 15:46:09 -07001072 }
1073
Elliott Hughes72025e52011-08-23 17:50:30 -07001074 static jlong CallLongMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001075 ScopedJniThreadState ts(env);
Elliott Hughes72025e52011-08-23 17:50:30 -07001076 va_list ap;
1077 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001078 JValue result = InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, ap);
Elliott Hughes72025e52011-08-23 17:50:30 -07001079 va_end(ap);
1080 return result.j;
Elliott Hughescdf53122011-08-19 15:46:09 -07001081 }
1082
Elliott Hughes72025e52011-08-23 17:50:30 -07001083 static jlong CallLongMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001084 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001085 return InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, args).j;
Elliott Hughescdf53122011-08-19 15:46:09 -07001086 }
1087
Elliott Hughes72025e52011-08-23 17:50:30 -07001088 static jlong CallLongMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001089 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001090 return InvokeVirtualOrInterfaceWithJValues(env, obj, mid, args).j;
Elliott Hughescdf53122011-08-19 15:46:09 -07001091 }
1092
Elliott Hughes72025e52011-08-23 17:50:30 -07001093 static jshort CallShortMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001094 ScopedJniThreadState ts(env);
Elliott Hughes72025e52011-08-23 17:50:30 -07001095 va_list ap;
1096 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001097 JValue result = InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, ap);
Elliott Hughes72025e52011-08-23 17:50:30 -07001098 va_end(ap);
1099 return result.s;
Elliott Hughescdf53122011-08-19 15:46:09 -07001100 }
1101
Elliott Hughes72025e52011-08-23 17:50:30 -07001102 static jshort CallShortMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001103 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001104 return InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, args).s;
Elliott Hughescdf53122011-08-19 15:46:09 -07001105 }
1106
Elliott Hughes72025e52011-08-23 17:50:30 -07001107 static jshort CallShortMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001108 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001109 return InvokeVirtualOrInterfaceWithJValues(env, obj, mid, args).s;
Elliott Hughescdf53122011-08-19 15:46:09 -07001110 }
1111
Elliott Hughes72025e52011-08-23 17:50:30 -07001112 static void CallVoidMethod(JNIEnv* env, jobject obj, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001113 ScopedJniThreadState ts(env);
Elliott Hughes72025e52011-08-23 17:50:30 -07001114 va_list ap;
1115 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001116 JValue result = InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, ap);
Elliott Hughes72025e52011-08-23 17:50:30 -07001117 va_end(ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001118 }
1119
Elliott Hughes72025e52011-08-23 17:50:30 -07001120 static void CallVoidMethodV(JNIEnv* env, jobject obj, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001121 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001122 InvokeVirtualOrInterfaceWithVarArgs(env, obj, mid, args);
Elliott Hughescdf53122011-08-19 15:46:09 -07001123 }
1124
Elliott Hughes72025e52011-08-23 17:50:30 -07001125 static void CallVoidMethodA(JNIEnv* env, jobject obj, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001126 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001127 InvokeVirtualOrInterfaceWithJValues(env, obj, mid, args);
Elliott Hughescdf53122011-08-19 15:46:09 -07001128 }
1129
1130 static jobject CallNonvirtualObjectMethod(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001131 jobject obj, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001132 ScopedJniThreadState ts(env);
1133 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001134 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001135 JValue result = InvokeWithVarArgs(env, obj, mid, ap);
Elliott Hughesbf86d042011-08-31 17:53:14 -07001136 jobject local_result = AddLocalReference<jobject>(env, result.l);
Elliott Hughescdf53122011-08-19 15:46:09 -07001137 va_end(ap);
1138 return local_result;
1139 }
1140
1141 static jobject CallNonvirtualObjectMethodV(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001142 jobject obj, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001143 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001144 JValue result = InvokeWithVarArgs(env, obj, mid, args);
Elliott Hughesbf86d042011-08-31 17:53:14 -07001145 return AddLocalReference<jobject>(env, result.l);
Elliott Hughescdf53122011-08-19 15:46:09 -07001146 }
1147
1148 static jobject CallNonvirtualObjectMethodA(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001149 jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001150 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001151 JValue result = InvokeWithJValues(env, obj, mid, args);
Elliott Hughesbf86d042011-08-31 17:53:14 -07001152 return AddLocalReference<jobject>(env, result.l);
Elliott Hughescdf53122011-08-19 15:46:09 -07001153 }
1154
1155 static jboolean CallNonvirtualBooleanMethod(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001156 jobject obj, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001157 ScopedJniThreadState ts(env);
1158 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001159 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001160 JValue result = InvokeWithVarArgs(env, obj, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001161 va_end(ap);
1162 return result.z;
1163 }
1164
1165 static jboolean CallNonvirtualBooleanMethodV(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001166 jobject obj, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001167 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001168 return InvokeWithVarArgs(env, obj, mid, args).z;
Elliott Hughescdf53122011-08-19 15:46:09 -07001169 }
1170
1171 static jboolean CallNonvirtualBooleanMethodA(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001172 jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001173 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001174 return InvokeWithJValues(env, obj, mid, args).z;
Elliott Hughescdf53122011-08-19 15:46:09 -07001175 }
1176
1177 static jbyte CallNonvirtualByteMethod(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001178 jobject obj, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001179 ScopedJniThreadState ts(env);
1180 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001181 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001182 JValue result = InvokeWithVarArgs(env, obj, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001183 va_end(ap);
1184 return result.b;
1185 }
1186
1187 static jbyte CallNonvirtualByteMethodV(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001188 jobject obj, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001189 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001190 return InvokeWithVarArgs(env, obj, mid, args).b;
Elliott Hughescdf53122011-08-19 15:46:09 -07001191 }
1192
1193 static jbyte CallNonvirtualByteMethodA(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001194 jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001195 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001196 return InvokeWithJValues(env, obj, mid, args).b;
Elliott Hughescdf53122011-08-19 15:46:09 -07001197 }
1198
1199 static jchar CallNonvirtualCharMethod(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001200 jobject obj, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001201 ScopedJniThreadState ts(env);
1202 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001203 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001204 JValue result = InvokeWithVarArgs(env, obj, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001205 va_end(ap);
1206 return result.c;
1207 }
1208
1209 static jchar CallNonvirtualCharMethodV(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001210 jobject obj, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001211 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001212 return InvokeWithVarArgs(env, obj, mid, args).c;
Elliott Hughescdf53122011-08-19 15:46:09 -07001213 }
1214
1215 static jchar CallNonvirtualCharMethodA(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001216 jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001217 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001218 return InvokeWithJValues(env, obj, mid, args).c;
Elliott Hughescdf53122011-08-19 15:46:09 -07001219 }
1220
1221 static jshort CallNonvirtualShortMethod(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001222 jobject obj, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001223 ScopedJniThreadState ts(env);
1224 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001225 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001226 JValue result = InvokeWithVarArgs(env, obj, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001227 va_end(ap);
1228 return result.s;
1229 }
1230
1231 static jshort CallNonvirtualShortMethodV(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001232 jobject obj, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001233 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001234 return InvokeWithVarArgs(env, obj, mid, args).s;
Elliott Hughescdf53122011-08-19 15:46:09 -07001235 }
1236
1237 static jshort CallNonvirtualShortMethodA(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001238 jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001239 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001240 return InvokeWithJValues(env, obj, mid, args).s;
Elliott Hughescdf53122011-08-19 15:46:09 -07001241 }
1242
Elliott Hughes418d20f2011-09-22 14:00:39 -07001243 static jint CallNonvirtualIntMethod(JNIEnv* env, jobject obj, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001244 ScopedJniThreadState ts(env);
1245 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001246 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001247 JValue result = InvokeWithVarArgs(env, obj, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001248 va_end(ap);
1249 return result.i;
1250 }
1251
1252 static jint CallNonvirtualIntMethodV(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001253 jobject obj, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001254 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001255 return InvokeWithVarArgs(env, obj, mid, args).i;
Elliott Hughescdf53122011-08-19 15:46:09 -07001256 }
1257
1258 static jint CallNonvirtualIntMethodA(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001259 jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001260 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001261 return InvokeWithJValues(env, obj, mid, args).i;
Elliott Hughescdf53122011-08-19 15:46:09 -07001262 }
1263
1264 static jlong CallNonvirtualLongMethod(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001265 jobject obj, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001266 ScopedJniThreadState ts(env);
1267 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001268 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001269 JValue result = InvokeWithVarArgs(env, obj, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001270 va_end(ap);
1271 return result.j;
1272 }
1273
1274 static jlong CallNonvirtualLongMethodV(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001275 jobject obj, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001276 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001277 return InvokeWithVarArgs(env, obj, mid, args).j;
Elliott Hughescdf53122011-08-19 15:46:09 -07001278 }
1279
1280 static jlong CallNonvirtualLongMethodA(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001281 jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001282 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001283 return InvokeWithJValues(env, obj, mid, args).j;
Elliott Hughescdf53122011-08-19 15:46:09 -07001284 }
1285
1286 static jfloat CallNonvirtualFloatMethod(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001287 jobject obj, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001288 ScopedJniThreadState ts(env);
1289 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001290 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001291 JValue result = InvokeWithVarArgs(env, obj, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001292 va_end(ap);
1293 return result.f;
1294 }
1295
1296 static jfloat CallNonvirtualFloatMethodV(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001297 jobject obj, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001298 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001299 return InvokeWithVarArgs(env, obj, mid, args).f;
Elliott Hughescdf53122011-08-19 15:46:09 -07001300 }
1301
1302 static jfloat CallNonvirtualFloatMethodA(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001303 jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001304 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001305 return InvokeWithJValues(env, obj, mid, args).f;
Elliott Hughescdf53122011-08-19 15:46:09 -07001306 }
1307
1308 static jdouble CallNonvirtualDoubleMethod(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001309 jobject obj, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001310 ScopedJniThreadState ts(env);
1311 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001312 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001313 JValue result = InvokeWithVarArgs(env, obj, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001314 va_end(ap);
1315 return result.d;
1316 }
1317
1318 static jdouble CallNonvirtualDoubleMethodV(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001319 jobject obj, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001320 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001321 return InvokeWithVarArgs(env, obj, mid, args).d;
Elliott Hughescdf53122011-08-19 15:46:09 -07001322 }
1323
1324 static jdouble CallNonvirtualDoubleMethodA(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001325 jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001326 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001327 return InvokeWithJValues(env, obj, mid, args).d;
Elliott Hughescdf53122011-08-19 15:46:09 -07001328 }
1329
1330 static void CallNonvirtualVoidMethod(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001331 jobject obj, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001332 ScopedJniThreadState ts(env);
1333 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001334 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001335 InvokeWithVarArgs(env, obj, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001336 va_end(ap);
1337 }
1338
1339 static void CallNonvirtualVoidMethodV(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001340 jobject obj, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001341 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001342 InvokeWithVarArgs(env, obj, mid, args);
Elliott Hughescdf53122011-08-19 15:46:09 -07001343 }
1344
1345 static void CallNonvirtualVoidMethodA(JNIEnv* env,
Elliott Hughes72025e52011-08-23 17:50:30 -07001346 jobject obj, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001347 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001348 InvokeWithJValues(env, obj, mid, args);
Elliott Hughescdf53122011-08-19 15:46:09 -07001349 }
1350
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -07001351 static jfieldID GetFieldID(JNIEnv* env, jclass c, const char* name, const char* sig) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001352 ScopedJniThreadState ts(env);
1353 return FindFieldID(ts, c, name, sig, false);
1354 }
Carl Shapiroea4dca82011-08-01 13:45:38 -07001355
1356
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -07001357 static jfieldID GetStaticFieldID(JNIEnv* env, jclass c, const char* name, const char* sig) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001358 ScopedJniThreadState ts(env);
1359 return FindFieldID(ts, c, name, sig, true);
1360 }
Carl Shapiroea4dca82011-08-01 13:45:38 -07001361
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001362 static jobject GetObjectField(JNIEnv* env, jobject obj, jfieldID fid) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001363 ScopedJniThreadState ts(env);
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001364 Object* o = Decode<Object*>(ts, obj);
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -07001365 Field* f = DecodeField(fid);
Elliott Hughesbf86d042011-08-31 17:53:14 -07001366 return AddLocalReference<jobject>(env, f->GetObject(o));
Elliott Hughescdf53122011-08-19 15:46:09 -07001367 }
Carl Shapiroea4dca82011-08-01 13:45:38 -07001368
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001369 static jobject GetStaticObjectField(JNIEnv* env, jclass, jfieldID fid) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001370 ScopedJniThreadState ts(env);
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -07001371 Field* f = DecodeField(fid);
Elliott Hughesbf86d042011-08-31 17:53:14 -07001372 return AddLocalReference<jobject>(env, f->GetObject(NULL));
Elliott Hughescdf53122011-08-19 15:46:09 -07001373 }
1374
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001375 static void SetObjectField(JNIEnv* env, jobject java_object, jfieldID fid, jobject java_value) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001376 ScopedJniThreadState ts(env);
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001377 Object* o = Decode<Object*>(ts, java_object);
1378 Object* v = Decode<Object*>(ts, java_value);
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -07001379 Field* f = DecodeField(fid);
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001380 f->SetObject(o, v);
Elliott Hughescdf53122011-08-19 15:46:09 -07001381 }
1382
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001383 static void SetStaticObjectField(JNIEnv* env, jclass, jfieldID fid, jobject java_value) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001384 ScopedJniThreadState ts(env);
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001385 Object* v = Decode<Object*>(ts, java_value);
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -07001386 Field* f = DecodeField(fid);
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001387 f->SetObject(NULL, v);
Elliott Hughescdf53122011-08-19 15:46:09 -07001388 }
1389
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001390#define GET_PRIMITIVE_FIELD(fn, instance) \
1391 ScopedJniThreadState ts(env); \
1392 Object* o = Decode<Object*>(ts, instance); \
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -07001393 Field* f = DecodeField(fid); \
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001394 return f->fn(o)
1395
1396#define SET_PRIMITIVE_FIELD(fn, instance, value) \
1397 ScopedJniThreadState ts(env); \
1398 Object* o = Decode<Object*>(ts, instance); \
Elliott Hughes5ee7a8b2011-09-13 16:40:07 -07001399 Field* f = DecodeField(fid); \
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001400 f->fn(o, value)
1401
1402 static jboolean GetBooleanField(JNIEnv* env, jobject obj, jfieldID fid) {
1403 GET_PRIMITIVE_FIELD(GetBoolean, obj);
Elliott Hughescdf53122011-08-19 15:46:09 -07001404 }
1405
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001406 static jbyte GetByteField(JNIEnv* env, jobject obj, jfieldID fid) {
1407 GET_PRIMITIVE_FIELD(GetByte, obj);
Elliott Hughescdf53122011-08-19 15:46:09 -07001408 }
1409
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001410 static jchar GetCharField(JNIEnv* env, jobject obj, jfieldID fid) {
1411 GET_PRIMITIVE_FIELD(GetChar, obj);
Elliott Hughescdf53122011-08-19 15:46:09 -07001412 }
1413
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001414 static jshort GetShortField(JNIEnv* env, jobject obj, jfieldID fid) {
1415 GET_PRIMITIVE_FIELD(GetShort, obj);
Elliott Hughescdf53122011-08-19 15:46:09 -07001416 }
1417
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001418 static jint GetIntField(JNIEnv* env, jobject obj, jfieldID fid) {
1419 GET_PRIMITIVE_FIELD(GetInt, obj);
Elliott Hughescdf53122011-08-19 15:46:09 -07001420 }
1421
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001422 static jlong GetLongField(JNIEnv* env, jobject obj, jfieldID fid) {
1423 GET_PRIMITIVE_FIELD(GetLong, obj);
Elliott Hughescdf53122011-08-19 15:46:09 -07001424 }
1425
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001426 static jfloat GetFloatField(JNIEnv* env, jobject obj, jfieldID fid) {
1427 GET_PRIMITIVE_FIELD(GetFloat, obj);
Elliott Hughescdf53122011-08-19 15:46:09 -07001428 }
1429
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001430 static jdouble GetDoubleField(JNIEnv* env, jobject obj, jfieldID fid) {
1431 GET_PRIMITIVE_FIELD(GetDouble, obj);
Elliott Hughescdf53122011-08-19 15:46:09 -07001432 }
1433
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001434 static jboolean GetStaticBooleanField(JNIEnv* env, jclass clazz, jfieldID fid) {
1435 GET_PRIMITIVE_FIELD(GetBoolean, NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -07001436 }
1437
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001438 static jbyte GetStaticByteField(JNIEnv* env, jclass clazz, jfieldID fid) {
1439 GET_PRIMITIVE_FIELD(GetByte, NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -07001440 }
1441
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001442 static jchar GetStaticCharField(JNIEnv* env, jclass clazz, jfieldID fid) {
1443 GET_PRIMITIVE_FIELD(GetChar, NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -07001444 }
1445
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001446 static jshort GetStaticShortField(JNIEnv* env, jclass clazz, jfieldID fid) {
1447 GET_PRIMITIVE_FIELD(GetShort, NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -07001448 }
1449
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001450 static jint GetStaticIntField(JNIEnv* env, jclass clazz, jfieldID fid) {
1451 GET_PRIMITIVE_FIELD(GetInt, NULL);
Elliott Hughescdf53122011-08-19 15:46:09 -07001452 }
1453
Elliott Hughes885c3bd2011-08-22 16:59:20 -07001454 static jlong GetStaticLongField(JNIEnv* env, jclass clazz, jfieldID fid) {
1455 GET_PRIMITIVE_FIELD(GetLong, NULL);
1456 }
1457
1458 static jfloat GetStaticFloatField(JNIEnv* env, jclass clazz, jfieldID fid) {
1459 GET_PRIMITIVE_FIELD(GetFloat, NULL);
1460 }
1461
1462 static jdouble GetStaticDoubleField(JNIEnv* env, jclass clazz, jfieldID fid) {
1463 GET_PRIMITIVE_FIELD(GetDouble, NULL);
1464 }
1465
1466 static void SetBooleanField(JNIEnv* env, jobject obj, jfieldID fid, jboolean v) {
1467 SET_PRIMITIVE_FIELD(SetBoolean, obj, v);
1468 }
1469
1470 static void SetByteField(JNIEnv* env, jobject obj, jfieldID fid, jbyte v) {
1471 SET_PRIMITIVE_FIELD(SetByte, obj, v);
1472 }
1473
1474 static void SetCharField(JNIEnv* env, jobject obj, jfieldID fid, jchar v) {
1475 SET_PRIMITIVE_FIELD(SetChar, obj, v);
1476 }
1477
1478 static void SetFloatField(JNIEnv* env, jobject obj, jfieldID fid, jfloat v) {
1479 SET_PRIMITIVE_FIELD(SetFloat, obj, v);
1480 }
1481
1482 static void SetDoubleField(JNIEnv* env, jobject obj, jfieldID fid, jdouble v) {
1483 SET_PRIMITIVE_FIELD(SetDouble, obj, v);
1484 }
1485
1486 static void SetIntField(JNIEnv* env, jobject obj, jfieldID fid, jint v) {
1487 SET_PRIMITIVE_FIELD(SetInt, obj, v);
1488 }
1489
1490 static void SetLongField(JNIEnv* env, jobject obj, jfieldID fid, jlong v) {
1491 SET_PRIMITIVE_FIELD(SetLong, obj, v);
1492 }
1493
1494 static void SetShortField(JNIEnv* env, jobject obj, jfieldID fid, jshort v) {
1495 SET_PRIMITIVE_FIELD(SetShort, obj, v);
1496 }
1497
1498 static void SetStaticBooleanField(JNIEnv* env, jclass, jfieldID fid, jboolean v) {
1499 SET_PRIMITIVE_FIELD(SetBoolean, NULL, v);
1500 }
1501
1502 static void SetStaticByteField(JNIEnv* env, jclass, jfieldID fid, jbyte v) {
1503 SET_PRIMITIVE_FIELD(SetByte, NULL, v);
1504 }
1505
1506 static void SetStaticCharField(JNIEnv* env, jclass, jfieldID fid, jchar v) {
1507 SET_PRIMITIVE_FIELD(SetChar, NULL, v);
1508 }
1509
1510 static void SetStaticFloatField(JNIEnv* env, jclass, jfieldID fid, jfloat v) {
1511 SET_PRIMITIVE_FIELD(SetFloat, NULL, v);
1512 }
1513
1514 static void SetStaticDoubleField(JNIEnv* env, jclass, jfieldID fid, jdouble v) {
1515 SET_PRIMITIVE_FIELD(SetDouble, NULL, v);
1516 }
1517
1518 static void SetStaticIntField(JNIEnv* env, jclass, jfieldID fid, jint v) {
1519 SET_PRIMITIVE_FIELD(SetInt, NULL, v);
1520 }
1521
1522 static void SetStaticLongField(JNIEnv* env, jclass, jfieldID fid, jlong v) {
1523 SET_PRIMITIVE_FIELD(SetLong, NULL, v);
1524 }
1525
1526 static void SetStaticShortField(JNIEnv* env, jclass, jfieldID fid, jshort v) {
1527 SET_PRIMITIVE_FIELD(SetShort, NULL, v);
Elliott Hughescdf53122011-08-19 15:46:09 -07001528 }
1529
Elliott Hughes418d20f2011-09-22 14:00:39 -07001530 static jobject CallStaticObjectMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001531 ScopedJniThreadState ts(env);
1532 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001533 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001534 JValue result = InvokeWithVarArgs(env, NULL, mid, ap);
Elliott Hughesbf86d042011-08-31 17:53:14 -07001535 jobject local_result = AddLocalReference<jobject>(env, result.l);
Elliott Hughescdf53122011-08-19 15:46:09 -07001536 va_end(ap);
1537 return local_result;
1538 }
1539
Elliott Hughes418d20f2011-09-22 14:00:39 -07001540 static jobject CallStaticObjectMethodV(JNIEnv* env, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001541 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001542 JValue result = InvokeWithVarArgs(env, NULL, mid, args);
Elliott Hughesbf86d042011-08-31 17:53:14 -07001543 return AddLocalReference<jobject>(env, result.l);
Elliott Hughescdf53122011-08-19 15:46:09 -07001544 }
1545
Elliott Hughes418d20f2011-09-22 14:00:39 -07001546 static jobject CallStaticObjectMethodA(JNIEnv* env, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001547 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001548 JValue result = InvokeWithJValues(env, NULL, mid, args);
Elliott Hughesbf86d042011-08-31 17:53:14 -07001549 return AddLocalReference<jobject>(env, result.l);
Elliott Hughescdf53122011-08-19 15:46:09 -07001550 }
1551
Elliott Hughes418d20f2011-09-22 14:00:39 -07001552 static jboolean CallStaticBooleanMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001553 ScopedJniThreadState ts(env);
1554 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001555 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001556 JValue result = InvokeWithVarArgs(env, NULL, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001557 va_end(ap);
1558 return result.z;
1559 }
1560
Elliott Hughes418d20f2011-09-22 14:00:39 -07001561 static jboolean CallStaticBooleanMethodV(JNIEnv* env, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001562 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001563 return InvokeWithVarArgs(env, NULL, mid, args).z;
Elliott Hughescdf53122011-08-19 15:46:09 -07001564 }
1565
Elliott Hughes418d20f2011-09-22 14:00:39 -07001566 static jboolean CallStaticBooleanMethodA(JNIEnv* env, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001567 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001568 return InvokeWithJValues(env, NULL, mid, args).z;
Elliott Hughescdf53122011-08-19 15:46:09 -07001569 }
1570
Elliott Hughes72025e52011-08-23 17:50:30 -07001571 static jbyte CallStaticByteMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001572 ScopedJniThreadState ts(env);
1573 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001574 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001575 JValue result = InvokeWithVarArgs(env, NULL, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001576 va_end(ap);
1577 return result.b;
1578 }
1579
Elliott Hughes418d20f2011-09-22 14:00:39 -07001580 static jbyte CallStaticByteMethodV(JNIEnv* env, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001581 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001582 return InvokeWithVarArgs(env, NULL, mid, args).b;
Elliott Hughescdf53122011-08-19 15:46:09 -07001583 }
1584
Elliott Hughes418d20f2011-09-22 14:00:39 -07001585 static jbyte CallStaticByteMethodA(JNIEnv* env, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001586 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001587 return InvokeWithJValues(env, NULL, mid, args).b;
Elliott Hughescdf53122011-08-19 15:46:09 -07001588 }
1589
Elliott Hughes72025e52011-08-23 17:50:30 -07001590 static jchar CallStaticCharMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001591 ScopedJniThreadState ts(env);
1592 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001593 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001594 JValue result = InvokeWithVarArgs(env, NULL, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001595 va_end(ap);
1596 return result.c;
1597 }
1598
Elliott Hughes418d20f2011-09-22 14:00:39 -07001599 static jchar CallStaticCharMethodV(JNIEnv* env, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001600 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001601 return InvokeWithVarArgs(env, NULL, mid, args).c;
Elliott Hughescdf53122011-08-19 15:46:09 -07001602 }
1603
Elliott Hughes418d20f2011-09-22 14:00:39 -07001604 static jchar CallStaticCharMethodA(JNIEnv* env, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001605 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001606 return InvokeWithJValues(env, NULL, mid, args).c;
Elliott Hughescdf53122011-08-19 15:46:09 -07001607 }
1608
Elliott Hughes72025e52011-08-23 17:50:30 -07001609 static jshort CallStaticShortMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001610 ScopedJniThreadState ts(env);
1611 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001612 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001613 JValue result = InvokeWithVarArgs(env, NULL, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001614 va_end(ap);
1615 return result.s;
1616 }
1617
Elliott Hughes418d20f2011-09-22 14:00:39 -07001618 static jshort CallStaticShortMethodV(JNIEnv* env, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001619 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001620 return InvokeWithVarArgs(env, NULL, mid, args).s;
Elliott Hughescdf53122011-08-19 15:46:09 -07001621 }
1622
Elliott Hughes418d20f2011-09-22 14:00:39 -07001623 static jshort CallStaticShortMethodA(JNIEnv* env, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001624 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001625 return InvokeWithJValues(env, NULL, mid, args).s;
Elliott Hughescdf53122011-08-19 15:46:09 -07001626 }
1627
Elliott Hughes72025e52011-08-23 17:50:30 -07001628 static jint CallStaticIntMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001629 ScopedJniThreadState ts(env);
1630 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001631 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001632 JValue result = InvokeWithVarArgs(env, NULL, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001633 va_end(ap);
1634 return result.i;
1635 }
1636
Elliott Hughes418d20f2011-09-22 14:00:39 -07001637 static jint CallStaticIntMethodV(JNIEnv* env, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001638 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001639 return InvokeWithVarArgs(env, NULL, mid, args).i;
Elliott Hughescdf53122011-08-19 15:46:09 -07001640 }
1641
Elliott Hughes418d20f2011-09-22 14:00:39 -07001642 static jint CallStaticIntMethodA(JNIEnv* env, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001643 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001644 return InvokeWithJValues(env, NULL, mid, args).i;
Elliott Hughescdf53122011-08-19 15:46:09 -07001645 }
1646
Elliott Hughes72025e52011-08-23 17:50:30 -07001647 static jlong CallStaticLongMethod(JNIEnv* env, jclass clazz, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001648 ScopedJniThreadState ts(env);
1649 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001650 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001651 JValue result = InvokeWithVarArgs(env, NULL, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001652 va_end(ap);
1653 return result.j;
1654 }
1655
Elliott Hughes418d20f2011-09-22 14:00:39 -07001656 static jlong CallStaticLongMethodV(JNIEnv* env, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001657 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001658 return InvokeWithVarArgs(env, NULL, mid, args).j;
Elliott Hughescdf53122011-08-19 15:46:09 -07001659 }
1660
Elliott Hughes418d20f2011-09-22 14:00:39 -07001661 static jlong CallStaticLongMethodA(JNIEnv* env, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001662 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001663 return InvokeWithJValues(env, NULL, mid, args).j;
Elliott Hughescdf53122011-08-19 15:46:09 -07001664 }
1665
Elliott Hughes72025e52011-08-23 17:50:30 -07001666 static jfloat CallStaticFloatMethod(JNIEnv* env, jclass cls, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001667 ScopedJniThreadState ts(env);
1668 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001669 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001670 JValue result = InvokeWithVarArgs(env, NULL, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001671 va_end(ap);
1672 return result.f;
1673 }
1674
Elliott Hughes418d20f2011-09-22 14:00:39 -07001675 static jfloat CallStaticFloatMethodV(JNIEnv* env, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001676 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001677 return InvokeWithVarArgs(env, NULL, mid, args).f;
Elliott Hughescdf53122011-08-19 15:46:09 -07001678 }
1679
Elliott Hughes418d20f2011-09-22 14:00:39 -07001680 static jfloat CallStaticFloatMethodA(JNIEnv* env, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001681 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001682 return InvokeWithJValues(env, NULL, mid, args).f;
Elliott Hughescdf53122011-08-19 15:46:09 -07001683 }
1684
Elliott Hughes72025e52011-08-23 17:50:30 -07001685 static jdouble CallStaticDoubleMethod(JNIEnv* env, jclass cls, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001686 ScopedJniThreadState ts(env);
1687 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001688 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001689 JValue result = InvokeWithVarArgs(env, NULL, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001690 va_end(ap);
1691 return result.d;
1692 }
1693
Elliott Hughes418d20f2011-09-22 14:00:39 -07001694 static jdouble CallStaticDoubleMethodV(JNIEnv* env, jclass clazz, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001695 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001696 return InvokeWithVarArgs(env, NULL, mid, args).d;
Elliott Hughescdf53122011-08-19 15:46:09 -07001697 }
1698
Elliott Hughes418d20f2011-09-22 14:00:39 -07001699 static jdouble CallStaticDoubleMethodA(JNIEnv* env, jclass clazz, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001700 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001701 return InvokeWithJValues(env, NULL, mid, args).d;
Elliott Hughescdf53122011-08-19 15:46:09 -07001702 }
1703
Elliott Hughes72025e52011-08-23 17:50:30 -07001704 static void CallStaticVoidMethod(JNIEnv* env, jclass cls, jmethodID mid, ...) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001705 ScopedJniThreadState ts(env);
1706 va_list ap;
Elliott Hughes72025e52011-08-23 17:50:30 -07001707 va_start(ap, mid);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001708 InvokeWithVarArgs(env, NULL, mid, ap);
Elliott Hughescdf53122011-08-19 15:46:09 -07001709 va_end(ap);
1710 }
1711
Elliott Hughes418d20f2011-09-22 14:00:39 -07001712 static void CallStaticVoidMethodV(JNIEnv* env, jclass cls, jmethodID mid, va_list args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001713 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001714 InvokeWithVarArgs(env, NULL, mid, args);
Elliott Hughescdf53122011-08-19 15:46:09 -07001715 }
1716
Elliott Hughes418d20f2011-09-22 14:00:39 -07001717 static void CallStaticVoidMethodA(JNIEnv* env, jclass cls, jmethodID mid, jvalue* args) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001718 ScopedJniThreadState ts(env);
Elliott Hughes418d20f2011-09-22 14:00:39 -07001719 InvokeWithJValues(env, NULL, mid, args);
Elliott Hughescdf53122011-08-19 15:46:09 -07001720 }
1721
Elliott Hughes814e4032011-08-23 12:07:56 -07001722 static jstring NewString(JNIEnv* env, const jchar* chars, jsize char_count) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001723 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07001724 if (chars == NULL && char_count == 0) {
1725 return NULL;
1726 }
1727 String* result = String::AllocFromUtf16(char_count, chars);
Elliott Hughesbf86d042011-08-31 17:53:14 -07001728 return AddLocalReference<jstring>(env, result);
Elliott Hughescdf53122011-08-19 15:46:09 -07001729 }
1730
1731 static jstring NewStringUTF(JNIEnv* env, const char* utf) {
1732 ScopedJniThreadState ts(env);
1733 if (utf == NULL) {
1734 return NULL;
1735 }
1736 String* result = String::AllocFromModifiedUtf8(utf);
Elliott Hughesbf86d042011-08-31 17:53:14 -07001737 return AddLocalReference<jstring>(env, result);
Elliott Hughescdf53122011-08-19 15:46:09 -07001738 }
1739
Elliott Hughes814e4032011-08-23 12:07:56 -07001740 static jsize GetStringLength(JNIEnv* env, jstring java_string) {
1741 ScopedJniThreadState ts(env);
1742 return Decode<String*>(ts, java_string)->GetLength();
1743 }
1744
1745 static jsize GetStringUTFLength(JNIEnv* env, jstring java_string) {
1746 ScopedJniThreadState ts(env);
1747 return Decode<String*>(ts, java_string)->GetUtfLength();
1748 }
1749
Elliott Hughesb465ab02011-08-24 11:21:21 -07001750 static void GetStringRegion(JNIEnv* env, jstring java_string, jsize start, jsize length, jchar* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001751 ScopedJniThreadState ts(env);
Elliott Hughesb465ab02011-08-24 11:21:21 -07001752 String* s = Decode<String*>(ts, java_string);
1753 if (start < 0 || length < 0 || start + length > s->GetLength()) {
1754 ThrowSIOOBE(ts, start, length, s->GetLength());
1755 } else {
1756 const jchar* chars = s->GetCharArray()->GetData() + s->GetOffset();
1757 memcpy(buf, chars + start, length * sizeof(jchar));
1758 }
Elliott Hughes814e4032011-08-23 12:07:56 -07001759 }
1760
Elliott Hughesb465ab02011-08-24 11:21:21 -07001761 static void GetStringUTFRegion(JNIEnv* env, jstring java_string, jsize start, jsize length, char* buf) {
Elliott Hughes814e4032011-08-23 12:07:56 -07001762 ScopedJniThreadState ts(env);
Elliott Hughesb465ab02011-08-24 11:21:21 -07001763 String* s = Decode<String*>(ts, java_string);
1764 if (start < 0 || length < 0 || start + length > s->GetLength()) {
1765 ThrowSIOOBE(ts, start, length, s->GetLength());
1766 } else {
1767 const jchar* chars = s->GetCharArray()->GetData() + s->GetOffset();
1768 ConvertUtf16ToModifiedUtf8(buf, chars + start, length);
1769 }
Elliott Hughes814e4032011-08-23 12:07:56 -07001770 }
1771
Elliott Hughes75770752011-08-24 17:52:38 -07001772 static const jchar* GetStringChars(JNIEnv* env, jstring java_string, jboolean* is_copy) {
Elliott Hughes814e4032011-08-23 12:07:56 -07001773 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001774 String* s = Decode<String*>(ts, java_string);
1775 const CharArray* chars = s->GetCharArray();
1776 PinPrimitiveArray(ts, chars);
1777 if (is_copy != NULL) {
1778 *is_copy = JNI_FALSE;
1779 }
1780 return chars->GetData() + s->GetOffset();
Elliott Hughes814e4032011-08-23 12:07:56 -07001781 }
1782
Elliott Hughes75770752011-08-24 17:52:38 -07001783 static void ReleaseStringChars(JNIEnv* env, jstring java_string, const jchar* chars) {
Elliott Hughes814e4032011-08-23 12:07:56 -07001784 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001785 UnpinPrimitiveArray(ts, Decode<String*>(ts, java_string)->GetCharArray());
Elliott Hughescdf53122011-08-19 15:46:09 -07001786 }
1787
Elliott Hughes75770752011-08-24 17:52:38 -07001788 static const jchar* GetStringCritical(JNIEnv* env, jstring java_string, jboolean* is_copy) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001789 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001790 return GetStringChars(env, java_string, is_copy);
Elliott Hughescdf53122011-08-19 15:46:09 -07001791 }
1792
Elliott Hughes75770752011-08-24 17:52:38 -07001793 static void ReleaseStringCritical(JNIEnv* env, jstring java_string, const jchar* chars) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001794 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001795 return ReleaseStringChars(env, java_string, chars);
Elliott Hughescdf53122011-08-19 15:46:09 -07001796 }
1797
Elliott Hughes75770752011-08-24 17:52:38 -07001798 static const char* GetStringUTFChars(JNIEnv* env, jstring java_string, jboolean* is_copy) {
Elliott Hughesb465ab02011-08-24 11:21:21 -07001799 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001800 if (java_string == NULL) {
1801 return NULL;
1802 }
1803 if (is_copy != NULL) {
1804 *is_copy = JNI_TRUE;
1805 }
1806 String* s = Decode<String*>(ts, java_string);
1807 size_t byte_count = s->GetUtfLength();
1808 char* bytes = new char[byte_count + 1];
Elliott Hughes418dfe72011-10-06 18:56:27 -07001809 CHECK(bytes != NULL); // bionic aborts anyway.
Elliott Hughes75770752011-08-24 17:52:38 -07001810 const uint16_t* chars = s->GetCharArray()->GetData() + s->GetOffset();
1811 ConvertUtf16ToModifiedUtf8(bytes, chars, s->GetLength());
1812 bytes[byte_count] = '\0';
1813 return bytes;
Elliott Hughesb465ab02011-08-24 11:21:21 -07001814 }
1815
Elliott Hughes75770752011-08-24 17:52:38 -07001816 static void ReleaseStringUTFChars(JNIEnv* env, jstring, const char* chars) {
Elliott Hughesb465ab02011-08-24 11:21:21 -07001817 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001818 delete[] chars;
Elliott Hughesb465ab02011-08-24 11:21:21 -07001819 }
1820
Elliott Hughesbd935992011-08-22 11:59:34 -07001821 static jsize GetArrayLength(JNIEnv* env, jarray java_array) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001822 ScopedJniThreadState ts(env);
Elliott Hughesbd935992011-08-22 11:59:34 -07001823 Object* obj = Decode<Object*>(ts, java_array);
Brian Carlstromb63ec392011-08-27 17:38:27 -07001824 CHECK(obj->IsArrayInstance()); // TODO: ReportJniError
Elliott Hughesbd935992011-08-22 11:59:34 -07001825 Array* array = obj->AsArray();
1826 return array->GetLength();
Elliott Hughescdf53122011-08-19 15:46:09 -07001827 }
1828
Elliott Hughes814e4032011-08-23 12:07:56 -07001829 static jobject GetObjectArrayElement(JNIEnv* env, jobjectArray java_array, jsize index) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001830 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07001831 ObjectArray<Object>* array = Decode<ObjectArray<Object>*>(ts, java_array);
Elliott Hughesbf86d042011-08-31 17:53:14 -07001832 return AddLocalReference<jobject>(env, array->Get(index));
Elliott Hughescdf53122011-08-19 15:46:09 -07001833 }
1834
1835 static void SetObjectArrayElement(JNIEnv* env,
1836 jobjectArray java_array, jsize index, jobject java_value) {
1837 ScopedJniThreadState ts(env);
1838 ObjectArray<Object>* array = Decode<ObjectArray<Object>*>(ts, java_array);
1839 Object* value = Decode<Object*>(ts, java_value);
1840 array->Set(index, value);
1841 }
1842
1843 static jbooleanArray NewBooleanArray(JNIEnv* env, jsize length) {
1844 ScopedJniThreadState ts(env);
1845 return NewPrimitiveArray<jbooleanArray, BooleanArray>(ts, length);
1846 }
1847
1848 static jbyteArray NewByteArray(JNIEnv* env, jsize length) {
1849 ScopedJniThreadState ts(env);
1850 return NewPrimitiveArray<jbyteArray, ByteArray>(ts, length);
1851 }
1852
1853 static jcharArray NewCharArray(JNIEnv* env, jsize length) {
1854 ScopedJniThreadState ts(env);
1855 return NewPrimitiveArray<jcharArray, CharArray>(ts, length);
1856 }
1857
1858 static jdoubleArray NewDoubleArray(JNIEnv* env, jsize length) {
1859 ScopedJniThreadState ts(env);
1860 return NewPrimitiveArray<jdoubleArray, DoubleArray>(ts, length);
1861 }
1862
1863 static jfloatArray NewFloatArray(JNIEnv* env, jsize length) {
1864 ScopedJniThreadState ts(env);
1865 return NewPrimitiveArray<jfloatArray, FloatArray>(ts, length);
1866 }
1867
1868 static jintArray NewIntArray(JNIEnv* env, jsize length) {
1869 ScopedJniThreadState ts(env);
1870 return NewPrimitiveArray<jintArray, IntArray>(ts, length);
1871 }
1872
1873 static jlongArray NewLongArray(JNIEnv* env, jsize length) {
1874 ScopedJniThreadState ts(env);
1875 return NewPrimitiveArray<jlongArray, LongArray>(ts, length);
1876 }
1877
1878 static jobjectArray NewObjectArray(JNIEnv* env, jsize length, jclass element_jclass, jobject initial_element) {
1879 ScopedJniThreadState ts(env);
1880 CHECK_GE(length, 0); // TODO: ReportJniError
1881
1882 // Compute the array class corresponding to the given element class.
1883 Class* element_class = Decode<Class*>(ts, element_jclass);
1884 std::string descriptor;
1885 descriptor += "[";
Brian Carlstrom9cff8e12011-08-18 16:47:29 -07001886 descriptor += element_class->GetDescriptor()->ToModifiedUtf8();
Elliott Hughescdf53122011-08-19 15:46:09 -07001887
1888 // Find the class.
Elliott Hughes75770752011-08-24 17:52:38 -07001889 ScopedLocalRef<jclass> java_array_class(env, FindClass(env, descriptor.c_str()));
1890 if (java_array_class.get() == NULL) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001891 return NULL;
1892 }
1893
Elliott Hughes75770752011-08-24 17:52:38 -07001894 // Allocate and initialize if necessary.
1895 Class* array_class = Decode<Class*>(ts, java_array_class.get());
Elliott Hughescdf53122011-08-19 15:46:09 -07001896 ObjectArray<Object>* result = ObjectArray<Object>::Alloc(array_class, length);
Elliott Hughes75770752011-08-24 17:52:38 -07001897 if (initial_element != NULL) {
1898 Object* initial_object = Decode<Object*>(ts, initial_element);
1899 for (jsize i = 0; i < length; ++i) {
1900 result->Set(i, initial_object);
1901 }
1902 }
Elliott Hughesbf86d042011-08-31 17:53:14 -07001903 return AddLocalReference<jobjectArray>(env, result);
Elliott Hughescdf53122011-08-19 15:46:09 -07001904 }
1905
1906 static jshortArray NewShortArray(JNIEnv* env, jsize length) {
1907 ScopedJniThreadState ts(env);
1908 return NewPrimitiveArray<jshortArray, ShortArray>(ts, length);
1909 }
1910
Elliott Hughes75770752011-08-24 17:52:38 -07001911 static void* GetPrimitiveArrayCritical(JNIEnv* env, jarray array, jboolean* is_copy) {
Elliott Hughesb465ab02011-08-24 11:21:21 -07001912 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001913 return GetPrimitiveArray<jarray, jbyte*, ByteArray>(ts, array, is_copy);
Elliott Hughesb465ab02011-08-24 11:21:21 -07001914 }
1915
Elliott Hughes75770752011-08-24 17:52:38 -07001916 static void ReleasePrimitiveArrayCritical(JNIEnv* env, jarray array, void* data, jint mode) {
Elliott Hughesb465ab02011-08-24 11:21:21 -07001917 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001918 ReleasePrimitiveArray(ts, array, mode);
Elliott Hughesb465ab02011-08-24 11:21:21 -07001919 }
1920
Elliott Hughes75770752011-08-24 17:52:38 -07001921 static jboolean* GetBooleanArrayElements(JNIEnv* env, jbooleanArray array, jboolean* is_copy) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001922 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001923 return GetPrimitiveArray<jbooleanArray, jboolean*, BooleanArray>(ts, array, is_copy);
Elliott Hughescdf53122011-08-19 15:46:09 -07001924 }
1925
Elliott Hughes75770752011-08-24 17:52:38 -07001926 static jbyte* GetByteArrayElements(JNIEnv* env, jbyteArray array, jboolean* is_copy) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001927 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001928 return GetPrimitiveArray<jbyteArray, jbyte*, ByteArray>(ts, array, is_copy);
Elliott Hughescdf53122011-08-19 15:46:09 -07001929 }
1930
Elliott Hughes75770752011-08-24 17:52:38 -07001931 static jchar* GetCharArrayElements(JNIEnv* env, jcharArray array, jboolean* is_copy) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001932 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001933 return GetPrimitiveArray<jcharArray, jchar*, CharArray>(ts, array, is_copy);
Elliott Hughescdf53122011-08-19 15:46:09 -07001934 }
1935
Elliott Hughes75770752011-08-24 17:52:38 -07001936 static jdouble* GetDoubleArrayElements(JNIEnv* env, jdoubleArray array, jboolean* is_copy) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001937 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001938 return GetPrimitiveArray<jdoubleArray, jdouble*, DoubleArray>(ts, array, is_copy);
Elliott Hughescdf53122011-08-19 15:46:09 -07001939 }
1940
Elliott Hughes75770752011-08-24 17:52:38 -07001941 static jfloat* GetFloatArrayElements(JNIEnv* env, jfloatArray array, jboolean* is_copy) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001942 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001943 return GetPrimitiveArray<jfloatArray, jfloat*, FloatArray>(ts, array, is_copy);
Elliott Hughescdf53122011-08-19 15:46:09 -07001944 }
1945
Elliott Hughes75770752011-08-24 17:52:38 -07001946 static jint* GetIntArrayElements(JNIEnv* env, jintArray array, jboolean* is_copy) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001947 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001948 return GetPrimitiveArray<jintArray, jint*, IntArray>(ts, array, is_copy);
Elliott Hughescdf53122011-08-19 15:46:09 -07001949 }
1950
Elliott Hughes75770752011-08-24 17:52:38 -07001951 static jlong* GetLongArrayElements(JNIEnv* env, jlongArray array, jboolean* is_copy) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001952 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001953 return GetPrimitiveArray<jlongArray, jlong*, LongArray>(ts, array, is_copy);
Elliott Hughescdf53122011-08-19 15:46:09 -07001954 }
1955
Elliott Hughes75770752011-08-24 17:52:38 -07001956 static jshort* GetShortArrayElements(JNIEnv* env, jshortArray array, jboolean* is_copy) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001957 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001958 return GetPrimitiveArray<jshortArray, jshort*, ShortArray>(ts, array, is_copy);
Elliott Hughescdf53122011-08-19 15:46:09 -07001959 }
1960
Elliott Hughes75770752011-08-24 17:52:38 -07001961 static void ReleaseBooleanArrayElements(JNIEnv* env, jbooleanArray array, jboolean* data, jint mode) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001962 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001963 ReleasePrimitiveArray(ts, array, mode);
Elliott Hughescdf53122011-08-19 15:46:09 -07001964 }
1965
Elliott Hughes75770752011-08-24 17:52:38 -07001966 static void ReleaseByteArrayElements(JNIEnv* env, jbyteArray array, jbyte* data, jint mode) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001967 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001968 ReleasePrimitiveArray(ts, array, mode);
Elliott Hughescdf53122011-08-19 15:46:09 -07001969 }
1970
Elliott Hughes75770752011-08-24 17:52:38 -07001971 static void ReleaseCharArrayElements(JNIEnv* env, jcharArray array, jchar* data, jint mode) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001972 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001973 ReleasePrimitiveArray(ts, array, mode);
Elliott Hughescdf53122011-08-19 15:46:09 -07001974 }
1975
Elliott Hughes75770752011-08-24 17:52:38 -07001976 static void ReleaseDoubleArrayElements(JNIEnv* env, jdoubleArray array, jdouble* data, jint mode) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001977 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001978 ReleasePrimitiveArray(ts, array, mode);
Elliott Hughescdf53122011-08-19 15:46:09 -07001979 }
1980
Elliott Hughes75770752011-08-24 17:52:38 -07001981 static void ReleaseFloatArrayElements(JNIEnv* env, jfloatArray array, jfloat* data, jint mode) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001982 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001983 ReleasePrimitiveArray(ts, array, mode);
Elliott Hughescdf53122011-08-19 15:46:09 -07001984 }
1985
Elliott Hughes75770752011-08-24 17:52:38 -07001986 static void ReleaseIntArrayElements(JNIEnv* env, jintArray array, jint* data, jint mode) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001987 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001988 ReleasePrimitiveArray(ts, array, mode);
Elliott Hughescdf53122011-08-19 15:46:09 -07001989 }
1990
Elliott Hughes75770752011-08-24 17:52:38 -07001991 static void ReleaseLongArrayElements(JNIEnv* env, jlongArray array, jlong* data, jint mode) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001992 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001993 ReleasePrimitiveArray(ts, array, mode);
Elliott Hughescdf53122011-08-19 15:46:09 -07001994 }
1995
Elliott Hughes75770752011-08-24 17:52:38 -07001996 static void ReleaseShortArrayElements(JNIEnv* env, jshortArray array, jshort* data, jint mode) {
Elliott Hughescdf53122011-08-19 15:46:09 -07001997 ScopedJniThreadState ts(env);
Elliott Hughes75770752011-08-24 17:52:38 -07001998 ReleasePrimitiveArray(ts, array, mode);
Elliott Hughescdf53122011-08-19 15:46:09 -07001999 }
2000
Elliott Hughes814e4032011-08-23 12:07:56 -07002001 static void GetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize length, jboolean* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002002 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002003 GetPrimitiveArrayRegion<jbooleanArray, jboolean, BooleanArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002004 }
2005
Elliott Hughes814e4032011-08-23 12:07:56 -07002006 static void GetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize length, jbyte* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002007 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002008 GetPrimitiveArrayRegion<jbyteArray, jbyte, ByteArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002009 }
2010
Elliott Hughes814e4032011-08-23 12:07:56 -07002011 static void GetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize length, jchar* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002012 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002013 GetPrimitiveArrayRegion<jcharArray, jchar, CharArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002014 }
2015
Elliott Hughes814e4032011-08-23 12:07:56 -07002016 static void GetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize length, jdouble* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002017 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002018 GetPrimitiveArrayRegion<jdoubleArray, jdouble, DoubleArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002019 }
2020
Elliott Hughes814e4032011-08-23 12:07:56 -07002021 static void GetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize length, jfloat* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002022 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002023 GetPrimitiveArrayRegion<jfloatArray, jfloat, FloatArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002024 }
2025
Elliott Hughes814e4032011-08-23 12:07:56 -07002026 static void GetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize length, jint* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002027 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002028 GetPrimitiveArrayRegion<jintArray, jint, IntArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002029 }
2030
Elliott Hughes814e4032011-08-23 12:07:56 -07002031 static void GetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize length, jlong* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002032 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002033 GetPrimitiveArrayRegion<jlongArray, jlong, LongArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002034 }
2035
Elliott Hughes814e4032011-08-23 12:07:56 -07002036 static void GetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize length, jshort* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002037 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002038 GetPrimitiveArrayRegion<jshortArray, jshort, ShortArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002039 }
2040
Elliott Hughes814e4032011-08-23 12:07:56 -07002041 static void SetBooleanArrayRegion(JNIEnv* env, jbooleanArray array, jsize start, jsize length, const jboolean* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002042 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002043 SetPrimitiveArrayRegion<jbooleanArray, jboolean, BooleanArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002044 }
2045
Elliott Hughes814e4032011-08-23 12:07:56 -07002046 static void SetByteArrayRegion(JNIEnv* env, jbyteArray array, jsize start, jsize length, const jbyte* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002047 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002048 SetPrimitiveArrayRegion<jbyteArray, jbyte, ByteArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002049 }
2050
Elliott Hughes814e4032011-08-23 12:07:56 -07002051 static void SetCharArrayRegion(JNIEnv* env, jcharArray array, jsize start, jsize length, const jchar* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002052 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002053 SetPrimitiveArrayRegion<jcharArray, jchar, CharArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002054 }
2055
Elliott Hughes814e4032011-08-23 12:07:56 -07002056 static void SetDoubleArrayRegion(JNIEnv* env, jdoubleArray array, jsize start, jsize length, const jdouble* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002057 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002058 SetPrimitiveArrayRegion<jdoubleArray, jdouble, DoubleArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002059 }
2060
Elliott Hughes814e4032011-08-23 12:07:56 -07002061 static void SetFloatArrayRegion(JNIEnv* env, jfloatArray array, jsize start, jsize length, const jfloat* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002062 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002063 SetPrimitiveArrayRegion<jfloatArray, jfloat, FloatArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002064 }
2065
Elliott Hughes814e4032011-08-23 12:07:56 -07002066 static void SetIntArrayRegion(JNIEnv* env, jintArray array, jsize start, jsize length, const jint* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002067 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002068 SetPrimitiveArrayRegion<jintArray, jint, IntArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002069 }
2070
Elliott Hughes814e4032011-08-23 12:07:56 -07002071 static void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize length, const jlong* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002072 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002073 SetPrimitiveArrayRegion<jlongArray, jlong, LongArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002074 }
2075
Elliott Hughes814e4032011-08-23 12:07:56 -07002076 static void SetShortArrayRegion(JNIEnv* env, jshortArray array, jsize start, jsize length, const jshort* buf) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002077 ScopedJniThreadState ts(env);
Elliott Hughes814e4032011-08-23 12:07:56 -07002078 SetPrimitiveArrayRegion<jshortArray, jshort, ShortArray>(ts, array, start, length, buf);
Elliott Hughescdf53122011-08-19 15:46:09 -07002079 }
2080
Elliott Hughes5174fe62011-08-23 15:12:35 -07002081 static jint RegisterNatives(JNIEnv* env, jclass java_class, const JNINativeMethod* methods, jint method_count) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002082 ScopedJniThreadState ts(env);
Elliott Hughes5174fe62011-08-23 15:12:35 -07002083 Class* c = Decode<Class*>(ts, java_class);
2084
Elliott Hughes5174fe62011-08-23 15:12:35 -07002085 for (int i = 0; i < method_count; i++) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002086 const char* name = methods[i].name;
2087 const char* sig = methods[i].signature;
2088
2089 if (*sig == '!') {
2090 // TODO: fast jni. it's too noisy to log all these.
2091 ++sig;
2092 }
2093
Elliott Hughes5174fe62011-08-23 15:12:35 -07002094 Method* m = c->FindDirectMethod(name, sig);
2095 if (m == NULL) {
2096 m = c->FindVirtualMethod(name, sig);
Elliott Hughescdf53122011-08-19 15:46:09 -07002097 }
Elliott Hughes5174fe62011-08-23 15:12:35 -07002098 if (m == NULL) {
Elliott Hughes14134a12011-09-30 16:55:51 -07002099 ThrowNoSuchMethodError(ts, c, name, sig, "static or non-static");
Elliott Hughescdf53122011-08-19 15:46:09 -07002100 return JNI_ERR;
Elliott Hughes5174fe62011-08-23 15:12:35 -07002101 } else if (!m->IsNative()) {
Elliott Hughes14134a12011-09-30 16:55:51 -07002102 ThrowNoSuchMethodError(ts, c, name, sig, "native");
Elliott Hughescdf53122011-08-19 15:46:09 -07002103 return JNI_ERR;
2104 }
Elliott Hughes5174fe62011-08-23 15:12:35 -07002105
Elliott Hughes75770752011-08-24 17:52:38 -07002106 if (ts.Vm()->verbose_jni) {
Elliott Hughesa2501992011-08-26 19:39:54 -07002107 LOG(INFO) << "[Registering JNI native method " << PrettyMethod(m) << "]";
Elliott Hughes5174fe62011-08-23 15:12:35 -07002108 }
2109
2110 m->RegisterNative(methods[i].fnPtr);
Elliott Hughescdf53122011-08-19 15:46:09 -07002111 }
2112 return JNI_OK;
2113 }
2114
Elliott Hughes5174fe62011-08-23 15:12:35 -07002115 static jint UnregisterNatives(JNIEnv* env, jclass java_class) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002116 ScopedJniThreadState ts(env);
Elliott Hughes5174fe62011-08-23 15:12:35 -07002117 Class* c = Decode<Class*>(ts, java_class);
2118
Elliott Hughes75770752011-08-24 17:52:38 -07002119 if (ts.Vm()->verbose_jni) {
Elliott Hughes54e7df12011-09-16 11:47:04 -07002120 LOG(INFO) << "[Unregistering JNI native methods for " << PrettyClass(c) << "]";
Elliott Hughes5174fe62011-08-23 15:12:35 -07002121 }
2122
2123 for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
2124 Method* m = c->GetDirectMethod(i);
2125 if (m->IsNative()) {
2126 m->UnregisterNative();
2127 }
2128 }
2129 for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
2130 Method* m = c->GetVirtualMethod(i);
2131 if (m->IsNative()) {
2132 m->UnregisterNative();
2133 }
2134 }
2135
2136 return JNI_OK;
Elliott Hughescdf53122011-08-19 15:46:09 -07002137 }
2138
Elliott Hughes72025e52011-08-23 17:50:30 -07002139 static jint MonitorEnter(JNIEnv* env, jobject java_object) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002140 ScopedJniThreadState ts(env);
Elliott Hughes5f791332011-09-15 17:45:30 -07002141 Decode<Object*>(ts, java_object)->MonitorEnter(ts.Self());
Elliott Hughes72025e52011-08-23 17:50:30 -07002142 return ts.Self()->IsExceptionPending() ? JNI_ERR : JNI_OK;
Elliott Hughescdf53122011-08-19 15:46:09 -07002143 }
2144
Elliott Hughes72025e52011-08-23 17:50:30 -07002145 static jint MonitorExit(JNIEnv* env, jobject java_object) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002146 ScopedJniThreadState ts(env);
Elliott Hughes5f791332011-09-15 17:45:30 -07002147 Decode<Object*>(ts, java_object)->MonitorExit(ts.Self());
Elliott Hughes72025e52011-08-23 17:50:30 -07002148 return ts.Self()->IsExceptionPending() ? JNI_ERR : JNI_OK;
Elliott Hughescdf53122011-08-19 15:46:09 -07002149 }
2150
2151 static jint GetJavaVM(JNIEnv* env, JavaVM** vm) {
2152 ScopedJniThreadState ts(env);
2153 Runtime* runtime = Runtime::Current();
2154 if (runtime != NULL) {
Elliott Hughes69f5bc62011-08-24 09:26:14 -07002155 *vm = runtime->GetJavaVM();
Elliott Hughescdf53122011-08-19 15:46:09 -07002156 } else {
2157 *vm = NULL;
2158 }
2159 return (*vm != NULL) ? JNI_OK : JNI_ERR;
2160 }
2161
Elliott Hughescdf53122011-08-19 15:46:09 -07002162 static jobject NewDirectByteBuffer(JNIEnv* env, void* address, jlong capacity) {
2163 ScopedJniThreadState ts(env);
Elliott Hughesb465ab02011-08-24 11:21:21 -07002164
2165 // The address may not be NULL, and the capacity must be > 0.
Elliott Hughes75770752011-08-24 17:52:38 -07002166 CHECK(address != NULL); // TODO: ReportJniError
2167 CHECK_GT(capacity, 0); // TODO: ReportJniError
Elliott Hughesb465ab02011-08-24 11:21:21 -07002168
2169 jclass buffer_class = GetDirectByteBufferClass(env);
2170 jmethodID mid = env->GetMethodID(buffer_class, "<init>", "(II)V");
2171 if (mid == NULL) {
2172 return NULL;
2173 }
2174
2175 // At the moment, the Java side is limited to 32 bits.
2176 CHECK_LE(reinterpret_cast<uintptr_t>(address), 0xffffffff);
2177 CHECK_LE(capacity, 0xffffffff);
2178 jint address_arg = reinterpret_cast<jint>(address);
2179 jint capacity_arg = static_cast<jint>(capacity);
2180
2181 jobject result = env->NewObject(buffer_class, mid, address_arg, capacity_arg);
2182 return ts.Self()->IsExceptionPending() ? NULL : result;
Elliott Hughescdf53122011-08-19 15:46:09 -07002183 }
2184
Elliott Hughesb465ab02011-08-24 11:21:21 -07002185 static void* GetDirectBufferAddress(JNIEnv* env, jobject java_buffer) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002186 ScopedJniThreadState ts(env);
Elliott Hughesb465ab02011-08-24 11:21:21 -07002187 static jfieldID fid = env->GetFieldID(GetDirectByteBufferClass(env), "effectiveDirectAddress", "I");
2188 return reinterpret_cast<void*>(env->GetIntField(java_buffer, fid));
Elliott Hughescdf53122011-08-19 15:46:09 -07002189 }
2190
Elliott Hughesb465ab02011-08-24 11:21:21 -07002191 static jlong GetDirectBufferCapacity(JNIEnv* env, jobject java_buffer) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002192 ScopedJniThreadState ts(env);
Elliott Hughesb465ab02011-08-24 11:21:21 -07002193 static jfieldID fid = env->GetFieldID(GetDirectByteBufferClass(env), "capacity", "I");
2194 return static_cast<jlong>(env->GetIntField(java_buffer, fid));
Elliott Hughescdf53122011-08-19 15:46:09 -07002195 }
2196
Elliott Hughesb465ab02011-08-24 11:21:21 -07002197 static jobjectRefType GetObjectRefType(JNIEnv* env, jobject java_object) {
Elliott Hughescdf53122011-08-19 15:46:09 -07002198 ScopedJniThreadState ts(env);
Elliott Hughesb465ab02011-08-24 11:21:21 -07002199
Elliott Hughes75770752011-08-24 17:52:38 -07002200 CHECK(java_object != NULL); // TODO: ReportJniError
Elliott Hughesb465ab02011-08-24 11:21:21 -07002201
2202 // Do we definitely know what kind of reference this is?
2203 IndirectRef ref = reinterpret_cast<IndirectRef>(java_object);
2204 IndirectRefKind kind = GetIndirectRefKind(ref);
2205 switch (kind) {
2206 case kLocal:
2207 return JNILocalRefType;
2208 case kGlobal:
2209 return JNIGlobalRefType;
2210 case kWeakGlobal:
2211 return JNIWeakGlobalRefType;
2212 case kSirtOrInvalid:
2213 // Is it in a stack IRT?
2214 if (ts.Self()->SirtContains(java_object)) {
2215 return JNILocalRefType;
2216 }
2217
Elliott Hughesc5bfa8f2011-08-30 14:32:49 -07002218 if (!ts.Env()->work_around_app_jni_bugs) {
2219 return JNIInvalidRefType;
2220 }
2221
Elliott Hughesb465ab02011-08-24 11:21:21 -07002222 // If we're handing out direct pointers, check whether it's a direct pointer
2223 // to a local reference.
Elliott Hughesc5bfa8f2011-08-30 14:32:49 -07002224 if (Decode<Object*>(ts, java_object) == reinterpret_cast<Object*>(java_object)) {
Elliott Hughesb465ab02011-08-24 11:21:21 -07002225 if (ts.Env()->locals.Contains(java_object)) {
2226 return JNILocalRefType;
2227 }
2228 }
2229
2230 return JNIInvalidRefType;
2231 }
Elliott Hughescdf53122011-08-19 15:46:09 -07002232 }
2233};
Carl Shapiroea4dca82011-08-01 13:45:38 -07002234
Elliott Hughesa2501992011-08-26 19:39:54 -07002235const JNINativeInterface gNativeInterface = {
Carl Shapiroea4dca82011-08-01 13:45:38 -07002236 NULL, // reserved0.
2237 NULL, // reserved1.
2238 NULL, // reserved2.
2239 NULL, // reserved3.
Elliott Hughescdf53122011-08-19 15:46:09 -07002240 JNI::GetVersion,
2241 JNI::DefineClass,
2242 JNI::FindClass,
2243 JNI::FromReflectedMethod,
2244 JNI::FromReflectedField,
2245 JNI::ToReflectedMethod,
2246 JNI::GetSuperclass,
2247 JNI::IsAssignableFrom,
2248 JNI::ToReflectedField,
2249 JNI::Throw,
2250 JNI::ThrowNew,
2251 JNI::ExceptionOccurred,
2252 JNI::ExceptionDescribe,
2253 JNI::ExceptionClear,
2254 JNI::FatalError,
2255 JNI::PushLocalFrame,
2256 JNI::PopLocalFrame,
2257 JNI::NewGlobalRef,
2258 JNI::DeleteGlobalRef,
2259 JNI::DeleteLocalRef,
2260 JNI::IsSameObject,
2261 JNI::NewLocalRef,
2262 JNI::EnsureLocalCapacity,
2263 JNI::AllocObject,
2264 JNI::NewObject,
2265 JNI::NewObjectV,
2266 JNI::NewObjectA,
2267 JNI::GetObjectClass,
2268 JNI::IsInstanceOf,
2269 JNI::GetMethodID,
2270 JNI::CallObjectMethod,
2271 JNI::CallObjectMethodV,
2272 JNI::CallObjectMethodA,
2273 JNI::CallBooleanMethod,
2274 JNI::CallBooleanMethodV,
2275 JNI::CallBooleanMethodA,
2276 JNI::CallByteMethod,
2277 JNI::CallByteMethodV,
2278 JNI::CallByteMethodA,
2279 JNI::CallCharMethod,
2280 JNI::CallCharMethodV,
2281 JNI::CallCharMethodA,
2282 JNI::CallShortMethod,
2283 JNI::CallShortMethodV,
2284 JNI::CallShortMethodA,
2285 JNI::CallIntMethod,
2286 JNI::CallIntMethodV,
2287 JNI::CallIntMethodA,
2288 JNI::CallLongMethod,
2289 JNI::CallLongMethodV,
2290 JNI::CallLongMethodA,
2291 JNI::CallFloatMethod,
2292 JNI::CallFloatMethodV,
2293 JNI::CallFloatMethodA,
2294 JNI::CallDoubleMethod,
2295 JNI::CallDoubleMethodV,
2296 JNI::CallDoubleMethodA,
2297 JNI::CallVoidMethod,
2298 JNI::CallVoidMethodV,
2299 JNI::CallVoidMethodA,
2300 JNI::CallNonvirtualObjectMethod,
2301 JNI::CallNonvirtualObjectMethodV,
2302 JNI::CallNonvirtualObjectMethodA,
2303 JNI::CallNonvirtualBooleanMethod,
2304 JNI::CallNonvirtualBooleanMethodV,
2305 JNI::CallNonvirtualBooleanMethodA,
2306 JNI::CallNonvirtualByteMethod,
2307 JNI::CallNonvirtualByteMethodV,
2308 JNI::CallNonvirtualByteMethodA,
2309 JNI::CallNonvirtualCharMethod,
2310 JNI::CallNonvirtualCharMethodV,
2311 JNI::CallNonvirtualCharMethodA,
2312 JNI::CallNonvirtualShortMethod,
2313 JNI::CallNonvirtualShortMethodV,
2314 JNI::CallNonvirtualShortMethodA,
2315 JNI::CallNonvirtualIntMethod,
2316 JNI::CallNonvirtualIntMethodV,
2317 JNI::CallNonvirtualIntMethodA,
2318 JNI::CallNonvirtualLongMethod,
2319 JNI::CallNonvirtualLongMethodV,
2320 JNI::CallNonvirtualLongMethodA,
2321 JNI::CallNonvirtualFloatMethod,
2322 JNI::CallNonvirtualFloatMethodV,
2323 JNI::CallNonvirtualFloatMethodA,
2324 JNI::CallNonvirtualDoubleMethod,
2325 JNI::CallNonvirtualDoubleMethodV,
2326 JNI::CallNonvirtualDoubleMethodA,
2327 JNI::CallNonvirtualVoidMethod,
2328 JNI::CallNonvirtualVoidMethodV,
2329 JNI::CallNonvirtualVoidMethodA,
2330 JNI::GetFieldID,
2331 JNI::GetObjectField,
2332 JNI::GetBooleanField,
2333 JNI::GetByteField,
2334 JNI::GetCharField,
2335 JNI::GetShortField,
2336 JNI::GetIntField,
2337 JNI::GetLongField,
2338 JNI::GetFloatField,
2339 JNI::GetDoubleField,
2340 JNI::SetObjectField,
2341 JNI::SetBooleanField,
2342 JNI::SetByteField,
2343 JNI::SetCharField,
2344 JNI::SetShortField,
2345 JNI::SetIntField,
2346 JNI::SetLongField,
2347 JNI::SetFloatField,
2348 JNI::SetDoubleField,
2349 JNI::GetStaticMethodID,
2350 JNI::CallStaticObjectMethod,
2351 JNI::CallStaticObjectMethodV,
2352 JNI::CallStaticObjectMethodA,
2353 JNI::CallStaticBooleanMethod,
2354 JNI::CallStaticBooleanMethodV,
2355 JNI::CallStaticBooleanMethodA,
2356 JNI::CallStaticByteMethod,
2357 JNI::CallStaticByteMethodV,
2358 JNI::CallStaticByteMethodA,
2359 JNI::CallStaticCharMethod,
2360 JNI::CallStaticCharMethodV,
2361 JNI::CallStaticCharMethodA,
2362 JNI::CallStaticShortMethod,
2363 JNI::CallStaticShortMethodV,
2364 JNI::CallStaticShortMethodA,
2365 JNI::CallStaticIntMethod,
2366 JNI::CallStaticIntMethodV,
2367 JNI::CallStaticIntMethodA,
2368 JNI::CallStaticLongMethod,
2369 JNI::CallStaticLongMethodV,
2370 JNI::CallStaticLongMethodA,
2371 JNI::CallStaticFloatMethod,
2372 JNI::CallStaticFloatMethodV,
2373 JNI::CallStaticFloatMethodA,
2374 JNI::CallStaticDoubleMethod,
2375 JNI::CallStaticDoubleMethodV,
2376 JNI::CallStaticDoubleMethodA,
2377 JNI::CallStaticVoidMethod,
2378 JNI::CallStaticVoidMethodV,
2379 JNI::CallStaticVoidMethodA,
2380 JNI::GetStaticFieldID,
2381 JNI::GetStaticObjectField,
2382 JNI::GetStaticBooleanField,
2383 JNI::GetStaticByteField,
2384 JNI::GetStaticCharField,
2385 JNI::GetStaticShortField,
2386 JNI::GetStaticIntField,
2387 JNI::GetStaticLongField,
2388 JNI::GetStaticFloatField,
2389 JNI::GetStaticDoubleField,
2390 JNI::SetStaticObjectField,
2391 JNI::SetStaticBooleanField,
2392 JNI::SetStaticByteField,
2393 JNI::SetStaticCharField,
2394 JNI::SetStaticShortField,
2395 JNI::SetStaticIntField,
2396 JNI::SetStaticLongField,
2397 JNI::SetStaticFloatField,
2398 JNI::SetStaticDoubleField,
2399 JNI::NewString,
2400 JNI::GetStringLength,
2401 JNI::GetStringChars,
2402 JNI::ReleaseStringChars,
2403 JNI::NewStringUTF,
2404 JNI::GetStringUTFLength,
2405 JNI::GetStringUTFChars,
2406 JNI::ReleaseStringUTFChars,
2407 JNI::GetArrayLength,
2408 JNI::NewObjectArray,
2409 JNI::GetObjectArrayElement,
2410 JNI::SetObjectArrayElement,
2411 JNI::NewBooleanArray,
2412 JNI::NewByteArray,
2413 JNI::NewCharArray,
2414 JNI::NewShortArray,
2415 JNI::NewIntArray,
2416 JNI::NewLongArray,
2417 JNI::NewFloatArray,
2418 JNI::NewDoubleArray,
2419 JNI::GetBooleanArrayElements,
2420 JNI::GetByteArrayElements,
2421 JNI::GetCharArrayElements,
2422 JNI::GetShortArrayElements,
2423 JNI::GetIntArrayElements,
2424 JNI::GetLongArrayElements,
2425 JNI::GetFloatArrayElements,
2426 JNI::GetDoubleArrayElements,
2427 JNI::ReleaseBooleanArrayElements,
2428 JNI::ReleaseByteArrayElements,
2429 JNI::ReleaseCharArrayElements,
2430 JNI::ReleaseShortArrayElements,
2431 JNI::ReleaseIntArrayElements,
2432 JNI::ReleaseLongArrayElements,
2433 JNI::ReleaseFloatArrayElements,
2434 JNI::ReleaseDoubleArrayElements,
2435 JNI::GetBooleanArrayRegion,
2436 JNI::GetByteArrayRegion,
2437 JNI::GetCharArrayRegion,
2438 JNI::GetShortArrayRegion,
2439 JNI::GetIntArrayRegion,
2440 JNI::GetLongArrayRegion,
2441 JNI::GetFloatArrayRegion,
2442 JNI::GetDoubleArrayRegion,
2443 JNI::SetBooleanArrayRegion,
2444 JNI::SetByteArrayRegion,
2445 JNI::SetCharArrayRegion,
2446 JNI::SetShortArrayRegion,
2447 JNI::SetIntArrayRegion,
2448 JNI::SetLongArrayRegion,
2449 JNI::SetFloatArrayRegion,
2450 JNI::SetDoubleArrayRegion,
2451 JNI::RegisterNatives,
2452 JNI::UnregisterNatives,
2453 JNI::MonitorEnter,
2454 JNI::MonitorExit,
2455 JNI::GetJavaVM,
2456 JNI::GetStringRegion,
2457 JNI::GetStringUTFRegion,
2458 JNI::GetPrimitiveArrayCritical,
2459 JNI::ReleasePrimitiveArrayCritical,
2460 JNI::GetStringCritical,
2461 JNI::ReleaseStringCritical,
2462 JNI::NewWeakGlobalRef,
2463 JNI::DeleteWeakGlobalRef,
2464 JNI::ExceptionCheck,
2465 JNI::NewDirectByteBuffer,
2466 JNI::GetDirectBufferAddress,
2467 JNI::GetDirectBufferCapacity,
2468 JNI::GetObjectRefType,
Carl Shapiroea4dca82011-08-01 13:45:38 -07002469};
2470
Elliott Hughes6c1a3942011-08-17 15:00:06 -07002471static const size_t kMonitorsInitial = 32; // Arbitrary.
2472static const size_t kMonitorsMax = 4096; // Arbitrary sanity check.
2473
2474static const size_t kLocalsInitial = 64; // Arbitrary.
2475static const size_t kLocalsMax = 512; // Arbitrary sanity check.
Elliott Hughesbbd76712011-08-17 10:25:24 -07002476
Elliott Hughes75770752011-08-24 17:52:38 -07002477JNIEnvExt::JNIEnvExt(Thread* self, JavaVMExt* vm)
Elliott Hughes69f5bc62011-08-24 09:26:14 -07002478 : self(self),
Elliott Hughes75770752011-08-24 17:52:38 -07002479 vm(vm),
Ian Rogers5a7a74a2011-09-26 16:32:29 -07002480 local_ref_cookie(IRT_FIRST_SEGMENT),
2481 locals(kLocalsInitial, kLocalsMax, kLocal),
Elliott Hughes75770752011-08-24 17:52:38 -07002482 check_jni(vm->check_jni),
Elliott Hughesc5bfa8f2011-08-30 14:32:49 -07002483 work_around_app_jni_bugs(vm->work_around_app_jni_bugs),
Elliott Hughesbbd76712011-08-17 10:25:24 -07002484 critical(false),
Ian Rogers5a7a74a2011-09-26 16:32:29 -07002485 monitors("monitors", kMonitorsInitial, kMonitorsMax) {
Elliott Hughesa2501992011-08-26 19:39:54 -07002486 functions = unchecked_functions = &gNativeInterface;
2487 if (check_jni) {
2488 functions = GetCheckJniNativeInterface();
2489 }
Ian Rogers5a7a74a2011-09-26 16:32:29 -07002490 // The JniEnv local reference values must be at a consistent offset or else cross-compilation
2491 // errors will ensue.
2492 CHECK_EQ(JNIEnvExt::LocalRefCookieOffset().Int32Value(), 12);
2493 CHECK_EQ(JNIEnvExt::SegmentStateOffset().Int32Value(), 16);
Elliott Hughes40ef99e2011-08-11 17:44:34 -07002494}
2495
Elliott Hughesc1674ed2011-08-25 18:09:09 -07002496JNIEnvExt::~JNIEnvExt() {
2497}
2498
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07002499void JNIEnvExt::DumpReferenceTables() {
2500 locals.Dump();
2501 monitors.Dump();
2502}
2503
Carl Shapiroea4dca82011-08-01 13:45:38 -07002504// JNI Invocation interface.
2505
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002506extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, void** p_env, void* vm_args) {
2507 const JavaVMInitArgs* args = static_cast<JavaVMInitArgs*>(vm_args);
2508 if (args->version < JNI_VERSION_1_2) {
2509 return JNI_EVERSION;
2510 }
2511 Runtime::Options options;
2512 for (int i = 0; i < args->nOptions; ++i) {
2513 JavaVMOption* option = &args->options[i];
Carl Shapirofc322c72011-07-27 00:20:01 -07002514 options.push_back(std::make_pair(StringPiece(option->optionString),
2515 option->extraInfo));
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002516 }
2517 bool ignore_unrecognized = args->ignoreUnrecognized;
Elliott Hughesf2682d52011-08-15 16:37:04 -07002518 Runtime* runtime = Runtime::Create(options, ignore_unrecognized);
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002519 if (runtime == NULL) {
2520 return JNI_ERR;
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002521 }
Brian Carlstrom69b15fb2011-09-03 12:25:21 -07002522 runtime->Start();
2523 *p_env = Thread::Current()->GetJniEnv();
2524 *p_vm = runtime->GetJavaVM();
2525 return JNI_OK;
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002526}
2527
Elliott Hughesf2682d52011-08-15 16:37:04 -07002528extern "C" jint JNI_GetCreatedJavaVMs(JavaVM** vms, jsize, jsize* vm_count) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002529 Runtime* runtime = Runtime::Current();
2530 if (runtime == NULL) {
Elliott Hughesf2682d52011-08-15 16:37:04 -07002531 *vm_count = 0;
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002532 } else {
Elliott Hughesf2682d52011-08-15 16:37:04 -07002533 *vm_count = 1;
Elliott Hughes69f5bc62011-08-24 09:26:14 -07002534 vms[0] = runtime->GetJavaVM();
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002535 }
2536 return JNI_OK;
2537}
2538
2539// Historically unsupported.
2540extern "C" jint JNI_GetDefaultJavaVMInitArgs(void* vm_args) {
2541 return JNI_ERR;
2542}
2543
Elliott Hughescdf53122011-08-19 15:46:09 -07002544class JII {
2545 public:
2546 static jint DestroyJavaVM(JavaVM* vm) {
2547 if (vm == NULL) {
2548 return JNI_ERR;
2549 } else {
2550 JavaVMExt* raw_vm = reinterpret_cast<JavaVMExt*>(vm);
2551 delete raw_vm->runtime;
2552 return JNI_OK;
2553 }
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002554 }
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002555
Elliott Hughescdf53122011-08-19 15:46:09 -07002556 static jint AttachCurrentThread(JavaVM* vm, JNIEnv** p_env, void* thr_args) {
Elliott Hughes75770752011-08-24 17:52:38 -07002557 return JII_AttachCurrentThread(vm, p_env, thr_args, false);
Elliott Hughescdf53122011-08-19 15:46:09 -07002558 }
2559
2560 static jint AttachCurrentThreadAsDaemon(JavaVM* vm, JNIEnv** p_env, void* thr_args) {
Elliott Hughes75770752011-08-24 17:52:38 -07002561 return JII_AttachCurrentThread(vm, p_env, thr_args, true);
Elliott Hughescdf53122011-08-19 15:46:09 -07002562 }
2563
2564 static jint DetachCurrentThread(JavaVM* vm) {
2565 if (vm == NULL) {
2566 return JNI_ERR;
2567 } else {
2568 JavaVMExt* raw_vm = reinterpret_cast<JavaVMExt*>(vm);
2569 Runtime* runtime = raw_vm->runtime;
2570 runtime->DetachCurrentThread();
2571 return JNI_OK;
2572 }
2573 }
2574
2575 static jint GetEnv(JavaVM* vm, void** env, jint version) {
2576 if (version < JNI_VERSION_1_1 || version > JNI_VERSION_1_6) {
2577 return JNI_EVERSION;
2578 }
2579 if (vm == NULL || env == NULL) {
2580 return JNI_ERR;
2581 }
2582 Thread* thread = Thread::Current();
2583 if (thread == NULL) {
2584 *env = NULL;
2585 return JNI_EDETACHED;
2586 }
2587 *env = thread->GetJniEnv();
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002588 return JNI_OK;
2589 }
Elliott Hughescdf53122011-08-19 15:46:09 -07002590};
Carl Shapiro2ed144c2011-07-26 16:52:08 -07002591
Elliott Hughesa2501992011-08-26 19:39:54 -07002592const JNIInvokeInterface gInvokeInterface = {
Carl Shapiroea4dca82011-08-01 13:45:38 -07002593 NULL, // reserved0
2594 NULL, // reserved1
2595 NULL, // reserved2
Elliott Hughescdf53122011-08-19 15:46:09 -07002596 JII::DestroyJavaVM,
2597 JII::AttachCurrentThread,
2598 JII::DetachCurrentThread,
2599 JII::GetEnv,
2600 JII::AttachCurrentThreadAsDaemon
Carl Shapiroea4dca82011-08-01 13:45:38 -07002601};
2602
Elliott Hughesbbd76712011-08-17 10:25:24 -07002603static const size_t kPinTableInitialSize = 16;
2604static const size_t kPinTableMaxSize = 1024;
2605
Elliott Hughes6c1a3942011-08-17 15:00:06 -07002606static const size_t kGlobalsInitial = 512; // Arbitrary.
2607static const size_t kGlobalsMax = 51200; // Arbitrary sanity check.
2608
2609static const size_t kWeakGlobalsInitial = 16; // Arbitrary.
2610static const size_t kWeakGlobalsMax = 51200; // Arbitrary sanity check.
2611
Elliott Hughesa0957642011-09-02 14:27:33 -07002612JavaVMExt::JavaVMExt(Runtime* runtime, Runtime::ParsedOptions* options)
Elliott Hughes69f5bc62011-08-24 09:26:14 -07002613 : runtime(runtime),
Elliott Hughesa2501992011-08-26 19:39:54 -07002614 check_jni_abort_hook(NULL),
Elliott Hughesa0957642011-09-02 14:27:33 -07002615 check_jni(options->check_jni_),
Elliott Hughesc5bfa8f2011-08-30 14:32:49 -07002616 force_copy(false), // TODO: add a way to enable this
Elliott Hughesa0957642011-09-02 14:27:33 -07002617 verbose_jni(options->IsVerbose("jni")),
2618 log_third_party_jni(options->IsVerbose("third-party-jni")),
2619 trace(options->jni_trace_),
Elliott Hughesc5bfa8f2011-08-30 14:32:49 -07002620 work_around_app_jni_bugs(false), // TODO: add a way to enable this
Elliott Hughes8daa0922011-09-11 13:46:25 -07002621 pins_lock("JNI pin table lock"),
Elliott Hughes6c1a3942011-08-17 15:00:06 -07002622 pin_table("pin table", kPinTableInitialSize, kPinTableMaxSize),
Elliott Hughes8daa0922011-09-11 13:46:25 -07002623 globals_lock("JNI global reference table lock"),
Elliott Hughes6c1a3942011-08-17 15:00:06 -07002624 globals(kGlobalsInitial, kGlobalsMax, kGlobal),
Elliott Hughes8daa0922011-09-11 13:46:25 -07002625 weak_globals_lock("JNI weak global reference table lock"),
Elliott Hughes79082e32011-08-25 12:07:32 -07002626 weak_globals(kWeakGlobalsInitial, kWeakGlobalsMax, kWeakGlobal),
Elliott Hughes8daa0922011-09-11 13:46:25 -07002627 libraries_lock("JNI shared libraries map lock"),
Elliott Hughes79082e32011-08-25 12:07:32 -07002628 libraries(new Libraries) {
Elliott Hughesa2501992011-08-26 19:39:54 -07002629 functions = unchecked_functions = &gInvokeInterface;
2630 if (check_jni) {
2631 functions = GetCheckJniInvokeInterface();
2632 }
Elliott Hughesf2682d52011-08-15 16:37:04 -07002633}
2634
Elliott Hughesde69d7f2011-08-18 16:49:37 -07002635JavaVMExt::~JavaVMExt() {
Elliott Hughes79082e32011-08-25 12:07:32 -07002636 delete libraries;
Elliott Hughesde69d7f2011-08-18 16:49:37 -07002637}
2638
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07002639void JavaVMExt::DumpReferenceTables() {
2640 {
2641 MutexLock mu(globals_lock);
2642 globals.Dump();
2643 }
2644 {
2645 MutexLock mu(weak_globals_lock);
2646 weak_globals.Dump();
2647 }
2648 {
2649 MutexLock mu(pins_lock);
2650 pin_table.Dump();
2651 }
2652}
2653
Elliott Hughes75770752011-08-24 17:52:38 -07002654bool JavaVMExt::LoadNativeLibrary(const std::string& path, ClassLoader* class_loader, std::string& detail) {
2655 detail.clear();
Elliott Hughescdf53122011-08-19 15:46:09 -07002656
2657 // See if we've already loaded this library. If we have, and the class loader
2658 // matches, return successfully without doing anything.
Elliott Hughes75770752011-08-24 17:52:38 -07002659 // TODO: for better results we should canonicalize the pathname (or even compare
2660 // inodes). This implementation is fine if everybody is using System.loadLibrary.
Elliott Hughes79082e32011-08-25 12:07:32 -07002661 SharedLibrary* library;
2662 {
2663 // TODO: move the locking (and more of this logic) into Libraries.
2664 MutexLock mu(libraries_lock);
2665 library = libraries->Get(path);
2666 }
Elliott Hughescdf53122011-08-19 15:46:09 -07002667 if (library != NULL) {
2668 if (library->GetClassLoader() != class_loader) {
Elliott Hughes75770752011-08-24 17:52:38 -07002669 // The library will be associated with class_loader. The JNI
2670 // spec says we can't load the same library into more than one
2671 // class loader.
2672 StringAppendF(&detail, "Shared library \"%s\" already opened by "
2673 "ClassLoader %p; can't open in ClassLoader %p",
2674 path.c_str(), library->GetClassLoader(), class_loader);
2675 LOG(WARNING) << detail;
Elliott Hughescdf53122011-08-19 15:46:09 -07002676 return false;
2677 }
2678 if (verbose_jni) {
2679 LOG(INFO) << "[Shared library \"" << path << "\" already loaded in "
2680 << "ClassLoader " << class_loader << "]";
2681 }
2682 if (!library->CheckOnLoadResult(this)) {
Elliott Hughes75770752011-08-24 17:52:38 -07002683 StringAppendF(&detail, "JNI_OnLoad failed on a previous attempt "
2684 "to load \"%s\"", path.c_str());
Elliott Hughescdf53122011-08-19 15:46:09 -07002685 return false;
2686 }
2687 return true;
2688 }
2689
2690 // Open the shared library. Because we're using a full path, the system
2691 // doesn't have to search through LD_LIBRARY_PATH. (It may do so to
2692 // resolve this library's dependencies though.)
2693
2694 // Failures here are expected when java.library.path has several entries
2695 // and we have to hunt for the lib.
2696
2697 // The current version of the dynamic linker prints detailed information
2698 // about dlopen() failures. Some things to check if the message is
2699 // cryptic:
2700 // - make sure the library exists on the device
2701 // - verify that the right path is being opened (the debug log message
2702 // above can help with that)
2703 // - check to see if the library is valid (e.g. not zero bytes long)
2704 // - check config/prelink-linux-arm.map to ensure that the library
2705 // is listed and is not being overrun by the previous entry (if
2706 // loading suddenly stops working on a prelinked library, this is
2707 // a good one to check)
2708 // - write a trivial app that calls sleep() then dlopen(), attach
2709 // to it with "strace -p <pid>" while it sleeps, and watch for
2710 // attempts to open nonexistent dependent shared libs
2711
2712 // TODO: automate some of these checks!
2713
2714 // This can execute slowly for a large library on a busy system, so we
Elliott Hughes93e74e82011-09-13 11:07:03 -07002715 // want to switch from kRunnable to kVmWait while it executes. This allows
Elliott Hughescdf53122011-08-19 15:46:09 -07002716 // the GC to ignore us.
2717 Thread* self = Thread::Current();
Elliott Hughesad7c2a32011-08-31 11:58:10 -07002718 void* handle = NULL;
2719 {
Elliott Hughes93e74e82011-09-13 11:07:03 -07002720 ScopedThreadStateChange tsc(self, Thread::kVmWait);
Elliott Hughesad7c2a32011-08-31 11:58:10 -07002721 handle = dlopen(path.c_str(), RTLD_LAZY);
2722 }
Elliott Hughescdf53122011-08-19 15:46:09 -07002723
2724 if (verbose_jni) {
2725 LOG(INFO) << "[Call to dlopen(\"" << path << "\") returned " << handle << "]";
2726 }
2727
2728 if (handle == NULL) {
Elliott Hughes75770752011-08-24 17:52:38 -07002729 detail = dlerror();
Elliott Hughescdf53122011-08-19 15:46:09 -07002730 return false;
2731 }
2732
2733 // Create a new entry.
Elliott Hughescdf53122011-08-19 15:46:09 -07002734 {
Elliott Hughes79082e32011-08-25 12:07:32 -07002735 // TODO: move the locking (and more of this logic) into Libraries.
2736 MutexLock mu(libraries_lock);
2737 library = libraries->Get(path);
2738 if (library != NULL) {
2739 LOG(INFO) << "WOW: we lost a race to add shared library: "
2740 << "\"" << path << "\" ClassLoader=" << class_loader;
2741 return library->CheckOnLoadResult(this);
Elliott Hughescdf53122011-08-19 15:46:09 -07002742 }
Elliott Hughes79082e32011-08-25 12:07:32 -07002743 library = new SharedLibrary(path, handle, class_loader);
2744 libraries->Put(path, library);
Elliott Hughescdf53122011-08-19 15:46:09 -07002745 }
Elliott Hughes79082e32011-08-25 12:07:32 -07002746
2747 if (verbose_jni) {
2748 LOG(INFO) << "[Added shared library \"" << path << "\" for ClassLoader " << class_loader << "]";
2749 }
2750
2751 bool result = true;
2752 void* sym = dlsym(handle, "JNI_OnLoad");
2753 if (sym == NULL) {
2754 if (verbose_jni) {
2755 LOG(INFO) << "[No JNI_OnLoad found in \"" << path << "\"]";
2756 }
2757 } else {
2758 // Call JNI_OnLoad. We have to override the current class
2759 // loader, which will always be "null" since the stuff at the
2760 // top of the stack is around Runtime.loadLibrary(). (See
2761 // the comments in the JNI FindClass function.)
2762 typedef int (*JNI_OnLoadFn)(JavaVM*, void*);
2763 JNI_OnLoadFn jni_on_load = reinterpret_cast<JNI_OnLoadFn>(sym);
Brian Carlstrombffb1552011-08-25 12:23:53 -07002764 const ClassLoader* old_class_loader = self->GetClassLoaderOverride();
Elliott Hughes79082e32011-08-25 12:07:32 -07002765 self->SetClassLoaderOverride(class_loader);
2766
Elliott Hughesad7c2a32011-08-31 11:58:10 -07002767 int version = 0;
2768 {
2769 ScopedThreadStateChange tsc(self, Thread::kNative);
2770 if (verbose_jni) {
2771 LOG(INFO) << "[Calling JNI_OnLoad in \"" << path << "\"]";
2772 }
2773 version = (*jni_on_load)(this, NULL);
Elliott Hughes79082e32011-08-25 12:07:32 -07002774 }
Elliott Hughes79082e32011-08-25 12:07:32 -07002775
Brian Carlstromaded5f72011-10-07 17:15:04 -07002776 self->SetClassLoaderOverride(old_class_loader);
Elliott Hughes79082e32011-08-25 12:07:32 -07002777
2778 if (version != JNI_VERSION_1_2 &&
2779 version != JNI_VERSION_1_4 &&
2780 version != JNI_VERSION_1_6) {
2781 LOG(WARNING) << "JNI_OnLoad in \"" << path << "\" returned "
2782 << "bad version: " << version;
2783 // It's unwise to call dlclose() here, but we can mark it
2784 // as bad and ensure that future load attempts will fail.
2785 // We don't know how far JNI_OnLoad got, so there could
2786 // be some partially-initialized stuff accessible through
2787 // newly-registered native method calls. We could try to
2788 // unregister them, but that doesn't seem worthwhile.
2789 result = false;
2790 } else {
2791 if (verbose_jni) {
2792 LOG(INFO) << "[Returned " << (result ? "successfully" : "failure")
2793 << " from JNI_OnLoad in \"" << path << "\"]";
2794 }
2795 }
2796 }
2797
2798 library->SetResult(result);
2799 return result;
2800}
2801
2802void* JavaVMExt::FindCodeForNativeMethod(Method* m) {
2803 CHECK(m->IsNative());
2804
2805 Class* c = m->GetDeclaringClass();
2806
2807 // If this is a static method, it could be called before the class
2808 // has been initialized.
2809 if (m->IsStatic()) {
Brian Carlstrom25c33252011-09-18 15:58:35 -07002810 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(c, true)) {
Elliott Hughes79082e32011-08-25 12:07:32 -07002811 return NULL;
2812 }
2813 } else {
Elliott Hughes2a20cfd2011-09-23 19:30:41 -07002814 CHECK(c->GetStatus() >= Class::kStatusInitializing) << c->GetStatus() << " " << PrettyMethod(m);
Elliott Hughes79082e32011-08-25 12:07:32 -07002815 }
2816
Brian Carlstrom16192862011-09-12 17:50:06 -07002817 std::string detail;
2818 void* native_method;
2819 {
2820 MutexLock mu(libraries_lock);
2821 native_method = libraries->FindNativeMethod(m, detail);
2822 }
2823 // throwing can cause libraries_lock to be reacquired
2824 if (native_method == NULL) {
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07002825 Thread::Current()->ThrowNewException("Ljava/lang/UnsatisfiedLinkError;", detail.c_str());
Brian Carlstrom16192862011-09-12 17:50:06 -07002826 }
2827 return native_method;
Elliott Hughescdf53122011-08-19 15:46:09 -07002828}
2829
Elliott Hughes410c0c82011-09-01 17:58:25 -07002830void JavaVMExt::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
2831 {
2832 MutexLock mu(globals_lock);
2833 globals.VisitRoots(visitor, arg);
2834 }
2835 {
2836 MutexLock mu(pins_lock);
2837 pin_table.VisitRoots(visitor, arg);
2838 }
2839 // The weak_globals table is visited by the GC itself (because it mutates the table).
2840}
2841
Ian Rogersdf20fe02011-07-20 20:34:16 -07002842} // namespace art
Elliott Hughesb465ab02011-08-24 11:21:21 -07002843
2844std::ostream& operator<<(std::ostream& os, const jobjectRefType& rhs) {
2845 switch (rhs) {
2846 case JNIInvalidRefType:
2847 os << "JNIInvalidRefType";
2848 return os;
2849 case JNILocalRefType:
2850 os << "JNILocalRefType";
2851 return os;
2852 case JNIGlobalRefType:
2853 os << "JNIGlobalRefType";
2854 return os;
2855 case JNIWeakGlobalRefType:
2856 os << "JNIWeakGlobalRefType";
2857 return os;
2858 }
2859}