Elliott Hughes | 2faa5f1 | 2012-01-30 14:42:07 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 16 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 17 | #ifndef ART_RUNTIME_JNI_INTERNAL_H_ |
| 18 | #define ART_RUNTIME_JNI_INTERNAL_H_ |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 19 | |
| 20 | #include "jni.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 21 | |
Elliott Hughes | 7616005 | 2012-12-12 16:31:20 -0800 | [diff] [blame] | 22 | #include "base/macros.h" |
Elliott Hughes | 76b6167 | 2012-12-12 17:47:30 -0800 | [diff] [blame] | 23 | #include "base/mutex.h" |
Elliott Hughes | 6c1a394 | 2011-08-17 15:00:06 -0700 | [diff] [blame] | 24 | #include "indirect_reference_table.h" |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 25 | #include "object_callbacks.h" |
Elliott Hughes | bbd7671 | 2011-08-17 10:25:24 -0700 | [diff] [blame] | 26 | #include "reference_table.h" |
Elliott Hughes | a095764 | 2011-09-02 14:27:33 -0700 | [diff] [blame] | 27 | #include "runtime.h" |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 28 | |
Elliott Hughes | ae80b49 | 2012-04-24 10:43:17 -0700 | [diff] [blame] | 29 | #include <iosfwd> |
Elliott Hughes | 0af5543 | 2011-08-17 18:37:28 -0700 | [diff] [blame] | 30 | #include <string> |
| 31 | |
Elliott Hughes | eac7667 | 2012-05-24 21:56:51 -0700 | [diff] [blame] | 32 | #ifndef NATIVE_METHOD |
| 33 | #define NATIVE_METHOD(className, functionName, signature) \ |
| 34 | { #functionName, signature, reinterpret_cast<void*>(className ## _ ## functionName) } |
| 35 | #endif |
| 36 | #define REGISTER_NATIVE_METHODS(jni_class_name) \ |
| 37 | RegisterNativeMethods(env, jni_class_name, gMethods, arraysize(gMethods)) |
| 38 | |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 39 | namespace art { |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 40 | namespace mirror { |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 41 | class ArtField; |
| 42 | class ArtMethod; |
| 43 | class ClassLoader; |
| 44 | } // namespace mirror |
Elliott Hughes | 418d20f | 2011-09-22 14:00:39 -0700 | [diff] [blame] | 45 | union JValue; |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 46 | class Libraries; |
Brian Carlstrom | 491ca9e | 2014-03-02 18:24:38 -0800 | [diff] [blame] | 47 | class ParsedOptions; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 48 | class ScopedObjectAccess; |
Mathieu Chartier | c645f1d | 2014-03-06 18:11:53 -0800 | [diff] [blame] | 49 | template<class T> class SirtRef; |
Elliott Hughes | 18c0753 | 2011-08-18 15:50:51 -0700 | [diff] [blame] | 50 | class Thread; |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 51 | |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 52 | void JniAbortF(const char* jni_function_name, const char* fmt, ...) |
| 53 | __attribute__((__format__(__printf__, 2, 3))); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 54 | void RegisterNativeMethods(JNIEnv* env, const char* jni_class_name, const JNINativeMethod* methods, |
Ian Rogers | abd7be9 | 2013-08-15 10:26:54 -0700 | [diff] [blame] | 55 | jint method_count); |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 56 | |
Elliott Hughes | a4f9474 | 2012-05-29 16:28:38 -0700 | [diff] [blame] | 57 | int ThrowNewException(JNIEnv* env, jclass exception_class, const char* msg, jobject cause); |
| 58 | |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 59 | class JavaVMExt : public JavaVM { |
| 60 | public: |
Brian Carlstrom | 491ca9e | 2014-03-02 18:24:38 -0800 | [diff] [blame] | 61 | JavaVMExt(Runtime* runtime, ParsedOptions* options); |
Elliott Hughes | de69d7f | 2011-08-18 16:49:37 -0700 | [diff] [blame] | 62 | ~JavaVMExt(); |
Elliott Hughes | 0af5543 | 2011-08-17 18:37:28 -0700 | [diff] [blame] | 63 | |
Elliott Hughes | 7577075 | 2011-08-24 17:52:38 -0700 | [diff] [blame] | 64 | /** |
| 65 | * Loads the given shared library. 'path' is an absolute pathname. |
Elliott Hughes | 0af5543 | 2011-08-17 18:37:28 -0700 | [diff] [blame] | 66 | * |
Elliott Hughes | 7577075 | 2011-08-24 17:52:38 -0700 | [diff] [blame] | 67 | * Returns 'true' on success. On failure, sets 'detail' to a |
| 68 | * human-readable description of the error. |
Elliott Hughes | 0af5543 | 2011-08-17 18:37:28 -0700 | [diff] [blame] | 69 | */ |
Mathieu Chartier | 055d46c | 2014-02-06 11:22:17 -0800 | [diff] [blame] | 70 | bool LoadNativeLibrary(const std::string& path, const SirtRef<mirror::ClassLoader>& class_loader, |
Ian Rogers | 1eb512d | 2013-10-18 15:42:20 -0700 | [diff] [blame] | 71 | std::string* detail) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 72 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Elliott Hughes | bbd7671 | 2011-08-17 10:25:24 -0700 | [diff] [blame] | 73 | |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 74 | /** |
| 75 | * Returns a pointer to the code for the native method 'm', found |
| 76 | * using dlsym(3) on every native library that's been loaded so far. |
| 77 | */ |
Brian Carlstrom | ea46f95 | 2013-07-30 01:26:50 -0700 | [diff] [blame] | 78 | void* FindCodeForNativeMethod(mirror::ArtMethod* m) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 79 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 80 | |
Elliott Hughes | ae80b49 | 2012-04-24 10:43:17 -0700 | [diff] [blame] | 81 | void DumpForSigQuit(std::ostream& os); |
| 82 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 83 | void DumpReferenceTables(std::ostream& os) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 84 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 85 | |
Elliott Hughes | 88c5c35 | 2012-03-15 18:49:48 -0700 | [diff] [blame] | 86 | void SetCheckJniEnabled(bool enabled); |
Elliott Hughes | 4ffd313 | 2011-10-24 12:06:42 -0700 | [diff] [blame] | 87 | |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 88 | void VisitRoots(RootCallback* callback, void* arg); |
Elliott Hughes | 410c0c8 | 2011-09-01 17:58:25 -0700 | [diff] [blame] | 89 | |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 90 | void DisallowNewWeakGlobals() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 91 | void AllowNewWeakGlobals() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 92 | jweak AddWeakGlobalReference(Thread* self, mirror::Object* obj) |
| 93 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 94 | void DeleteWeakGlobalRef(Thread* self, jweak obj) |
| 95 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 96 | void SweepJniWeakGlobals(IsMarkedCallback* callback, void* arg); |
Mathieu Chartier | c645f1d | 2014-03-06 18:11:53 -0800 | [diff] [blame] | 97 | mirror::Object* DecodeWeakGlobal(Thread* self, IndirectRef ref) |
| 98 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 99 | |
Elliott Hughes | f2682d5 | 2011-08-15 16:37:04 -0700 | [diff] [blame] | 100 | Runtime* runtime; |
Elliott Hughes | bbd7671 | 2011-08-17 10:25:24 -0700 | [diff] [blame] | 101 | |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 102 | // Used for testing. By default, we'll LOG(FATAL) the reason. |
Elliott Hughes | b264f08 | 2012-04-06 17:10:10 -0700 | [diff] [blame] | 103 | void (*check_jni_abort_hook)(void* data, const std::string& reason); |
| 104 | void* check_jni_abort_hook_data; |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 105 | |
Elliott Hughes | a095764 | 2011-09-02 14:27:33 -0700 | [diff] [blame] | 106 | // Extra checking. |
Elliott Hughes | 515a5bc | 2011-08-17 11:08:34 -0700 | [diff] [blame] | 107 | bool check_jni; |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 108 | bool force_copy; |
Elliott Hughes | 515a5bc | 2011-08-17 11:08:34 -0700 | [diff] [blame] | 109 | |
Elliott Hughes | a095764 | 2011-09-02 14:27:33 -0700 | [diff] [blame] | 110 | // Extra diagnostics. |
Elliott Hughes | a095764 | 2011-09-02 14:27:33 -0700 | [diff] [blame] | 111 | std::string trace; |
| 112 | |
Elliott Hughes | bbd7671 | 2011-08-17 10:25:24 -0700 | [diff] [blame] | 113 | // Used to hold references to pinned primitive arrays. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 114 | Mutex pins_lock DEFAULT_MUTEX_ACQUIRED_AFTER; |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 115 | ReferenceTable pin_table GUARDED_BY(pins_lock); |
Elliott Hughes | 6c1a394 | 2011-08-17 15:00:06 -0700 | [diff] [blame] | 116 | |
| 117 | // JNI global references. |
Ian Rogers | b8a0b94 | 2013-08-20 18:09:52 -0700 | [diff] [blame] | 118 | ReaderWriterMutex globals_lock DEFAULT_MUTEX_ACQUIRED_AFTER; |
Mathieu Chartier | c56057e | 2014-05-04 13:18:58 -0700 | [diff] [blame] | 119 | // Not guarded by globals_lock since we sometimes use SynchronizedGet in Thread::DecodeJObject. |
| 120 | IndirectReferenceTable globals; |
Elliott Hughes | 6c1a394 | 2011-08-17 15:00:06 -0700 | [diff] [blame] | 121 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 122 | Mutex libraries_lock DEFAULT_MUTEX_ACQUIRED_AFTER; |
Elliott Hughes | f834936 | 2012-06-18 15:00:06 -0700 | [diff] [blame] | 123 | Libraries* libraries GUARDED_BY(libraries_lock); |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 124 | |
| 125 | // Used by -Xcheck:jni. |
| 126 | const JNIInvokeInterface* unchecked_functions; |
Mathieu Chartier | c11d9b8 | 2013-09-19 10:01:59 -0700 | [diff] [blame] | 127 | |
| 128 | private: |
| 129 | // TODO: Make the other members of this class also private. |
| 130 | // JNI weak global references. |
| 131 | Mutex weak_globals_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
| 132 | IndirectReferenceTable weak_globals_ GUARDED_BY(weak_globals_lock_); |
| 133 | bool allow_new_weak_globals_ GUARDED_BY(weak_globals_lock_); |
| 134 | ConditionVariable weak_globals_add_condition_ GUARDED_BY(weak_globals_lock_); |
Elliott Hughes | f2682d5 | 2011-08-15 16:37:04 -0700 | [diff] [blame] | 135 | }; |
| 136 | |
Elliott Hughes | 69f5bc6 | 2011-08-24 09:26:14 -0700 | [diff] [blame] | 137 | struct JNIEnvExt : public JNIEnv { |
Elliott Hughes | 7577075 | 2011-08-24 17:52:38 -0700 | [diff] [blame] | 138 | JNIEnvExt(Thread* self, JavaVMExt* vm); |
Elliott Hughes | c1674ed | 2011-08-25 18:09:09 -0700 | [diff] [blame] | 139 | ~JNIEnvExt(); |
Elliott Hughes | bbd7671 | 2011-08-17 10:25:24 -0700 | [diff] [blame] | 140 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 141 | void DumpReferenceTables(std::ostream& os) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 142 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 143 | |
Elliott Hughes | 88c5c35 | 2012-03-15 18:49:48 -0700 | [diff] [blame] | 144 | void SetCheckJniEnabled(bool enabled); |
Elliott Hughes | 4ffd313 | 2011-10-24 12:06:42 -0700 | [diff] [blame] | 145 | |
Elliott Hughes | 2ced6a5 | 2011-10-16 18:44:48 -0700 | [diff] [blame] | 146 | void PushFrame(int capacity); |
| 147 | void PopFrame(); |
| 148 | |
Ian Rogers | 53b8b09 | 2014-03-13 23:45:53 -0700 | [diff] [blame] | 149 | template<typename T> |
Ian Rogers | 987560f | 2014-04-22 11:42:59 -0700 | [diff] [blame] | 150 | T AddLocalReference(mirror::Object* obj) |
Ian Rogers | 53b8b09 | 2014-03-13 23:45:53 -0700 | [diff] [blame] | 151 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 152 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 153 | static Offset SegmentStateOffset(); |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 154 | |
Ian Rogers | 5a7a74a | 2011-09-26 16:32:29 -0700 | [diff] [blame] | 155 | static Offset LocalRefCookieOffset() { |
| 156 | return Offset(OFFSETOF_MEMBER(JNIEnvExt, local_ref_cookie)); |
| 157 | } |
| 158 | |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 159 | static Offset SelfOffset() { |
| 160 | return Offset(OFFSETOF_MEMBER(JNIEnvExt, self)); |
| 161 | } |
| 162 | |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 163 | jobject NewLocalRef(mirror::Object* obj) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 164 | void DeleteLocalRef(jobject obj) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
| 165 | |
Elliott Hughes | 85d1545 | 2011-09-16 17:33:01 -0700 | [diff] [blame] | 166 | Thread* const self; |
Elliott Hughes | 7577075 | 2011-08-24 17:52:38 -0700 | [diff] [blame] | 167 | JavaVMExt* vm; |
Carl Shapiro | ea4dca8 | 2011-08-01 13:45:38 -0700 | [diff] [blame] | 168 | |
Elliott Hughes | 2ced6a5 | 2011-10-16 18:44:48 -0700 | [diff] [blame] | 169 | // Cookie used when using the local indirect reference table. |
Ian Rogers | 5a7a74a | 2011-09-26 16:32:29 -0700 | [diff] [blame] | 170 | uint32_t local_ref_cookie; |
| 171 | |
| 172 | // JNI local references. |
| 173 | IndirectReferenceTable locals; |
| 174 | |
Elliott Hughes | 2ced6a5 | 2011-10-16 18:44:48 -0700 | [diff] [blame] | 175 | // Stack of cookies corresponding to PushLocalFrame/PopLocalFrame calls. |
| 176 | // TODO: to avoid leaks (and bugs), we need to clear this vector on entry (or return) |
| 177 | // to a native method. |
| 178 | std::vector<uint32_t> stacked_local_ref_cookies; |
| 179 | |
Elliott Hughes | c5bfa8f | 2011-08-30 14:32:49 -0700 | [diff] [blame] | 180 | // Frequently-accessed fields cached from JavaVM. |
Elliott Hughes | 515a5bc | 2011-08-17 11:08:34 -0700 | [diff] [blame] | 181 | bool check_jni; |
| 182 | |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 183 | // How many nested "critical" JNI calls are we in? |
| 184 | int critical; |
Carl Shapiro | 2ed144c | 2011-07-26 16:52:08 -0700 | [diff] [blame] | 185 | |
Elliott Hughes | bbd7671 | 2011-08-17 10:25:24 -0700 | [diff] [blame] | 186 | // Entered JNI monitors, for bulk exit on thread detach. |
Elliott Hughes | 02b48d1 | 2011-09-07 17:15:51 -0700 | [diff] [blame] | 187 | ReferenceTable monitors; |
Elliott Hughes | 6c1a394 | 2011-08-17 15:00:06 -0700 | [diff] [blame] | 188 | |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 189 | // Used by -Xcheck:jni. |
| 190 | const JNINativeInterface* unchecked_functions; |
Carl Shapiro | ea4dca8 | 2011-08-01 13:45:38 -0700 | [diff] [blame] | 191 | }; |
| 192 | |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 193 | const JNINativeInterface* GetCheckJniNativeInterface(); |
| 194 | const JNIInvokeInterface* GetCheckJniInvokeInterface(); |
| 195 | |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 196 | // Used to save and restore the JNIEnvExt state when not going through code created by the JNI |
| 197 | // compiler |
| 198 | class ScopedJniEnvLocalRefState { |
| 199 | public: |
Elliott Hughes | a51a3dd | 2011-10-17 15:19:26 -0700 | [diff] [blame] | 200 | explicit ScopedJniEnvLocalRefState(JNIEnvExt* env) : env_(env) { |
Ian Rogers | dfcdf1a | 2011-10-10 17:50:35 -0700 | [diff] [blame] | 201 | saved_local_ref_cookie_ = env->local_ref_cookie; |
| 202 | env->local_ref_cookie = env->locals.GetSegmentState(); |
| 203 | } |
| 204 | |
| 205 | ~ScopedJniEnvLocalRefState() { |
| 206 | env_->locals.SetSegmentState(env_->local_ref_cookie); |
| 207 | env_->local_ref_cookie = saved_local_ref_cookie_; |
| 208 | } |
| 209 | |
| 210 | private: |
| 211 | JNIEnvExt* env_; |
| 212 | uint32_t saved_local_ref_cookie_; |
| 213 | DISALLOW_COPY_AND_ASSIGN(ScopedJniEnvLocalRefState); |
| 214 | }; |
| 215 | |
Ian Rogers | 53b8b09 | 2014-03-13 23:45:53 -0700 | [diff] [blame] | 216 | template<typename T> |
Ian Rogers | 987560f | 2014-04-22 11:42:59 -0700 | [diff] [blame] | 217 | inline T JNIEnvExt::AddLocalReference(mirror::Object* obj) { |
Ian Rogers | 53b8b09 | 2014-03-13 23:45:53 -0700 | [diff] [blame] | 218 | IndirectRef ref = locals.Add(local_ref_cookie, obj); |
| 219 | |
| 220 | // TODO: fix this to understand PushLocalFrame, so we can turn it on. |
| 221 | if (false) { |
| 222 | if (check_jni) { |
| 223 | size_t entry_count = locals.Capacity(); |
| 224 | if (entry_count > 16) { |
| 225 | locals.Dump(LOG(WARNING) << "Warning: more than 16 JNI local references: " |
| 226 | << entry_count << " (most recent was a " << PrettyTypeOf(obj) << ")\n"); |
| 227 | // TODO: LOG(FATAL) in a later release? |
| 228 | } |
| 229 | } |
| 230 | } |
| 231 | |
Ian Rogers | 53b8b09 | 2014-03-13 23:45:53 -0700 | [diff] [blame] | 232 | return reinterpret_cast<T>(ref); |
| 233 | } |
| 234 | |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 235 | } // namespace art |
Carl Shapiro | ea4dca8 | 2011-08-01 13:45:38 -0700 | [diff] [blame] | 236 | |
Elliott Hughes | b465ab0 | 2011-08-24 11:21:21 -0700 | [diff] [blame] | 237 | std::ostream& operator<<(std::ostream& os, const jobjectRefType& rhs); |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 238 | #endif // ART_RUNTIME_JNI_INTERNAL_H_ |