blob: 3892c236f372f66fb24e525a883704a4c2c06a2f [file] [log] [blame]
Elliott Hughes8d768a92011-09-14 16:35:25 -07001/*
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 */
Carl Shapirob5573532011-07-12 18:22:59 -070016
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070017#include "thread.h"
Carl Shapirob5573532011-07-12 18:22:59 -070018
Elliott Hughes8d768a92011-09-14 16:35:25 -070019#include <dynamic_annotations.h>
Ian Rogersb033c752011-07-20 12:22:35 -070020#include <pthread.h>
Elliott Hughes2acf36d2012-04-17 13:30:13 -070021#include <signal.h>
Ian Rogersb033c752011-07-20 12:22:35 -070022#include <sys/mman.h>
Brian Carlstromdbf05b72011-12-15 00:55:24 -080023#include <sys/resource.h>
24#include <sys/time.h>
Elliott Hughesa0957642011-09-02 14:27:33 -070025
Carl Shapirob5573532011-07-12 18:22:59 -070026#include <algorithm>
Elliott Hughesdcc24742011-09-07 14:02:44 -070027#include <bitset>
Elliott Hugheseb4f6142011-07-15 17:43:51 -070028#include <cerrno>
Elliott Hughesa0957642011-09-02 14:27:33 -070029#include <iostream>
Carl Shapirob5573532011-07-12 18:22:59 -070030#include <list>
Carl Shapirob5573532011-07-12 18:22:59 -070031
Elliott Hughes872d4ec2011-10-21 17:07:15 -070032#include "debugger.h"
Elliott Hughesa5b897e2011-08-16 11:33:06 -070033#include "class_linker.h"
Brian Carlstromdf143242011-10-10 18:05:34 -070034#include "class_loader.h"
Ian Rogers408f79a2011-08-23 18:22:33 -070035#include "heap.h"
Elliott Hughesc5f7c912011-08-18 14:00:42 -070036#include "jni_internal.h"
Elliott Hughes8e4aac52011-09-26 17:03:36 -070037#include "monitor.h"
Ian Rogers57b86d42012-03-27 16:05:41 -070038#include "oat/runtime/context.h"
Elliott Hughesa5b897e2011-08-16 11:33:06 -070039#include "object.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080040#include "object_utils.h"
Jesse Wilson9a6bae82011-11-14 14:57:30 -050041#include "reflection.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070042#include "runtime.h"
buzbee54330722011-08-23 16:46:55 -070043#include "runtime_support.h"
Elliott Hughes726079d2011-10-07 18:43:44 -070044#include "ScopedLocalRef.h"
Ian Rogersaaa20802011-09-11 21:47:37 -070045#include "scoped_jni_thread_state.h"
Logan Chienf7ad17e2012-03-15 03:10:03 +080046#include "shadow_frame.h"
Ian Rogers30fab402012-01-23 15:43:46 -080047#include "space.h"
Elliott Hughes68e76522011-10-05 13:22:16 -070048#include "stack.h"
49#include "stack_indirect_reference_table.h"
Elliott Hughes8daa0922011-09-11 13:46:25 -070050#include "thread_list.h"
Elliott Hughesa0957642011-09-02 14:27:33 -070051#include "utils.h"
Ian Rogers776ac1f2012-04-13 23:36:36 -070052#include "verifier/gc_map.h"
Carl Shapirob5573532011-07-12 18:22:59 -070053
54namespace art {
55
56pthread_key_t Thread::pthread_key_self_;
57
Elliott Hughes462c9442012-03-23 18:47:50 -070058static Class* gThreadGroup = NULL;
Elliott Hughes8e4aac52011-09-26 17:03:36 -070059static Class* gThreadLock = NULL;
Elliott Hughes038a8062011-09-18 14:12:41 -070060static Field* gThread_daemon = NULL;
61static Field* gThread_group = NULL;
62static Field* gThread_lock = NULL;
63static Field* gThread_name = NULL;
64static Field* gThread_priority = NULL;
Elliott Hughes29f27422011-09-18 16:02:18 -070065static Field* gThread_uncaughtHandler = NULL;
Elliott Hughes038a8062011-09-18 14:12:41 -070066static Field* gThread_vmData = NULL;
Elliott Hughes462c9442012-03-23 18:47:50 -070067static Field* gThreadGroup_mMain = NULL;
68static Field* gThreadGroup_mSystem = NULL;
Elliott Hughes038a8062011-09-18 14:12:41 -070069static Field* gThreadGroup_name = NULL;
Elliott Hughes8e4aac52011-09-26 17:03:36 -070070static Field* gThreadLock_thread = NULL;
Elliott Hughes038a8062011-09-18 14:12:41 -070071static Method* gThread_run = NULL;
Elliott Hughes29f27422011-09-18 16:02:18 -070072static Method* gThreadGroup_removeThread = NULL;
73static Method* gUncaughtExceptionHandler_uncaughtException = NULL;
Elliott Hughes038a8062011-09-18 14:12:41 -070074
Ian Rogers5d76c432011-10-31 21:42:49 -070075void Thread::InitCardTable() {
Elliott Hughesb3bd5f02012-03-08 21:05:27 -080076 card_table_ = Runtime::Current()->GetHeap()->GetCardTable()->GetBiasedBegin();
Ian Rogers5d76c432011-10-31 21:42:49 -070077}
78
Elliott Hughes99250ba2012-04-17 11:09:17 -070079#if !defined(__APPLE__)
Elliott Hughes3ea0f422012-04-16 17:01:43 -070080static void UnimplementedEntryPoint() {
81 UNIMPLEMENTED(FATAL);
82}
Elliott Hughes99250ba2012-04-17 11:09:17 -070083#endif
Elliott Hughes3ea0f422012-04-16 17:01:43 -070084
buzbee3ea4ec52011-08-22 17:37:19 -070085void Thread::InitFunctionPointers() {
Elliott Hughes99250ba2012-04-17 11:09:17 -070086#if !defined(__APPLE__) // The Mac GCC is too old to accept this code.
Elliott Hughes3ea0f422012-04-16 17:01:43 -070087 // Insert a placeholder so we can easily tell if we call an unimplemented entry point.
88 uintptr_t* begin = reinterpret_cast<uintptr_t*>(&entrypoints_);
89 uintptr_t* end = reinterpret_cast<uintptr_t*>(reinterpret_cast<uint8_t*>(begin) + sizeof(entrypoints_));
90 for (uintptr_t* it = begin; it != end; ++it) {
91 *it = reinterpret_cast<uintptr_t>(UnimplementedEntryPoint);
92 }
Elliott Hughes99250ba2012-04-17 11:09:17 -070093#endif
Ian Rogers57b86d42012-03-27 16:05:41 -070094 InitEntryPoints(&entrypoints_);
Elliott Hughesc0f09332012-03-26 13:27:06 -070095}
96
97void Thread::SetDebuggerUpdatesEnabled(bool enabled) {
98 LOG(INFO) << "Turning debugger updates " << (enabled ? "on" : "off") << " for " << *this;
Ian Rogers776ac1f2012-04-13 23:36:36 -070099#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogers57b86d42012-03-27 16:05:41 -0700100 ChangeDebuggerEntryPoint(&entrypoints_, enabled);
Ian Rogers776ac1f2012-04-13 23:36:36 -0700101#else
102 UNIMPLEMENTED(FATAL);
103#endif
buzbee3ea4ec52011-08-22 17:37:19 -0700104}
105
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700106void Thread::InitTid() {
107 tid_ = ::art::GetTid();
108}
109
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700110void Thread::InitAfterFork() {
111 InitTid();
Elliott Hughes3147a232011-10-12 15:55:07 -0700112#if defined(__BIONIC__)
113 // Work around a bionic bug.
114 struct bionic_pthread_internal_t {
115 void* next;
116 void** pref;
117 pthread_attr_t attr;
118 pid_t kernel_id;
119 // et cetera. we just need 'kernel_id' so we can stop here.
120 };
121 reinterpret_cast<bionic_pthread_internal_t*>(pthread_self())->kernel_id = tid_;
122#endif
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700123}
124
Brian Carlstrom78128a62011-09-15 17:21:19 -0700125void* Thread::CreateCallback(void* arg) {
Elliott Hughes93e74e82011-09-13 11:07:03 -0700126 Thread* self = reinterpret_cast<Thread*>(arg);
Elliott Hughes462c9442012-03-23 18:47:50 -0700127 self->Init();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700128
Elliott Hughes93e74e82011-09-13 11:07:03 -0700129 // Wait until it's safe to start running code. (There may have been a suspend-all
130 // in progress while we were starting up.)
Elliott Hughes462c9442012-03-23 18:47:50 -0700131 Runtime* runtime = Runtime::Current();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700132 runtime->GetThreadList()->WaitForGo();
133
Elliott Hughes47179f72011-10-27 16:44:39 -0700134 {
Elliott Hughes34e06962012-04-09 13:55:55 -0700135 CHECK_EQ(self->GetState(), kRunnable);
Elliott Hughes899e7892012-01-24 14:57:32 -0800136 SirtRef<String> thread_name(self->GetThreadName());
137 self->SetThreadName(thread_name->ToModifiedUtf8().c_str());
Elliott Hughes47179f72011-10-27 16:44:39 -0700138 }
139
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700140 Dbg::PostThreadStart(self);
Elliott Hughes93e74e82011-09-13 11:07:03 -0700141
142 // Invoke the 'run' method of our java.lang.Thread.
143 CHECK(self->peer_ != NULL);
144 Object* receiver = self->peer_;
Elliott Hughes038a8062011-09-18 14:12:41 -0700145 Method* m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(gThread_run);
Elliott Hughes93e74e82011-09-13 11:07:03 -0700146 m->Invoke(self, receiver, NULL, NULL);
147
148 // Detach.
149 runtime->GetThreadList()->Unregister();
150
Carl Shapirob5573532011-07-12 18:22:59 -0700151 return NULL;
152}
153
Elliott Hughesab7b9dc2012-03-27 13:16:29 -0700154static void SetVmData(Object* managed_thread, Thread* native_thread) {
Elliott Hughes038a8062011-09-18 14:12:41 -0700155 gThread_vmData->SetInt(managed_thread, reinterpret_cast<uintptr_t>(native_thread));
Elliott Hughes93e74e82011-09-13 11:07:03 -0700156}
157
Elliott Hughes761928d2011-11-16 18:33:03 -0800158Thread* Thread::FromManagedThread(Object* thread_peer) {
159 return reinterpret_cast<Thread*>(static_cast<uintptr_t>(gThread_vmData->GetInt(thread_peer)));
160}
161
Elliott Hughes01158d72011-09-19 19:47:10 -0700162Thread* Thread::FromManagedThread(JNIEnv* env, jobject java_thread) {
Elliott Hughes761928d2011-11-16 18:33:03 -0800163 return FromManagedThread(Decode<Object*>(env, java_thread));
Elliott Hughes01158d72011-09-19 19:47:10 -0700164}
165
Elliott Hughesab7b9dc2012-03-27 13:16:29 -0700166static size_t FixStackSize(size_t stack_size) {
Elliott Hughes7502e2a2011-10-02 13:24:37 -0700167 // A stack size of zero means "use the default".
Elliott Hughesd369bb72011-09-12 14:41:14 -0700168 if (stack_size == 0) {
169 stack_size = Runtime::Current()->GetDefaultStackSize();
170 }
Carl Shapiro61e019d2011-07-14 16:53:09 -0700171
Brian Carlstrom6414a972012-04-14 14:20:04 -0700172 // Dalvik used the bionic pthread default stack size for native threads,
173 // so include that here to support apps that expect large native stacks.
174 stack_size += 1 * MB;
175
176
Elliott Hughes7502e2a2011-10-02 13:24:37 -0700177 // It's not possible to request a stack smaller than the system-defined PTHREAD_STACK_MIN.
178 if (stack_size < PTHREAD_STACK_MIN) {
179 stack_size = PTHREAD_STACK_MIN;
180 }
181
182 // It's likely that callers are trying to ensure they have at least a certain amount of
183 // stack space, so we should add our reserved space on top of what they requested, rather
184 // than implicitly take it away from them.
185 stack_size += Thread::kStackOverflowReservedBytes;
186
187 // Some systems require the stack size to be a multiple of the system page size, so round up.
188 stack_size = RoundUp(stack_size, kPageSize);
189
190 return stack_size;
191}
192
Elliott Hughesd8af1592012-04-16 20:40:15 -0700193static void SigAltStack(stack_t* new_stack, stack_t* old_stack) {
194 if (sigaltstack(new_stack, old_stack) == -1) {
195 PLOG(FATAL) << "sigaltstack failed";
196 }
197}
198
199static void SetUpAlternateSignalStack() {
200 // Create and set an alternate signal stack.
201 stack_t ss;
202 ss.ss_sp = new uint8_t[SIGSTKSZ];
203 ss.ss_size = SIGSTKSZ;
204 ss.ss_flags = 0;
205 CHECK(ss.ss_sp != NULL);
206 SigAltStack(&ss, NULL);
207
208 // Double-check that it worked.
209 ss.ss_sp = NULL;
210 SigAltStack(NULL, &ss);
211 VLOG(threads) << "Alternate signal stack is " << PrettySize(ss.ss_size) << " at " << ss.ss_sp;
212}
213
214static void TearDownAlternateSignalStack() {
215 // Get the pointer so we can free the memory.
216 stack_t ss;
217 SigAltStack(NULL, &ss);
218 uint8_t* allocated_signal_stack = reinterpret_cast<uint8_t*>(ss.ss_sp);
219
220 // Tell the kernel to stop using it.
221 ss.ss_sp = NULL;
222 ss.ss_flags = SS_DISABLE;
223 ss.ss_size = 0;
224 SigAltStack(&ss, NULL);
225
226 // Free it.
227 delete[] allocated_signal_stack;
228}
229
Elliott Hughes7502e2a2011-10-02 13:24:37 -0700230void Thread::Create(Object* peer, size_t stack_size) {
231 CHECK(peer != NULL);
232
233 stack_size = FixStackSize(stack_size);
234
Elliott Hughes93e74e82011-09-13 11:07:03 -0700235 Thread* native_thread = new Thread;
236 native_thread->peer_ = peer;
237
238 // Thread.start is synchronized, so we know that vmData is 0,
239 // and know that we're not racing to assign it.
240 SetVmData(peer, native_thread);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700241
Elliott Hughes47179f72011-10-27 16:44:39 -0700242 {
Elliott Hughes34e06962012-04-09 13:55:55 -0700243 ScopedThreadStateChange tsc(Thread::Current(), kVmWait);
Elliott Hughes47179f72011-10-27 16:44:39 -0700244 pthread_t new_pthread;
245 pthread_attr_t attr;
246 CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
247 CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED), "PTHREAD_CREATE_DETACHED");
248 CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
249 CHECK_PTHREAD_CALL(pthread_create, (&new_pthread, &attr, Thread::CreateCallback, native_thread), "new thread");
250 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
251 }
Elliott Hughes93e74e82011-09-13 11:07:03 -0700252
253 // Let the child know when it's safe to start running.
254 Runtime::Current()->GetThreadList()->SignalGo(native_thread);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700255}
256
Elliott Hughes462c9442012-03-23 18:47:50 -0700257void Thread::Init() {
258 // This function does all the initialization that must be run by the native thread it applies to.
259 // (When we create a new thread from managed code, we allocate the Thread* in Thread::Create so
260 // we can handshake with the corresponding native thread when it's ready.) Check this native
261 // thread hasn't been through here already...
Elliott Hughescac6cc72011-11-03 20:31:21 -0700262 CHECK(Thread::Current() == NULL);
263
Elliott Hughesd8af1592012-04-16 20:40:15 -0700264 SetUpAlternateSignalStack();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700265 InitCpu();
266 InitFunctionPointers();
Ian Rogers5d76c432011-10-31 21:42:49 -0700267 InitCardTable();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700268
Elliott Hughes462c9442012-03-23 18:47:50 -0700269 Runtime* runtime = Runtime::Current();
270 CHECK(runtime != NULL);
271
272 thin_lock_id_ = runtime->GetThreadList()->AllocThreadId();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700273
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700274 InitTid();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700275 InitStackHwm();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700276
Elliott Hughes3147a232011-10-12 15:55:07 -0700277 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, this), "attach");
Elliott Hughesa5780da2011-07-17 11:39:39 -0700278
Elliott Hughes93e74e82011-09-13 11:07:03 -0700279 jni_env_ = new JNIEnvExt(this, runtime->GetJavaVM());
Elliott Hughes330304d2011-08-12 14:28:05 -0700280
Elliott Hughes7a3aeb42011-09-25 17:39:47 -0700281 runtime->GetThreadList()->Register();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700282}
283
Elliott Hughes462c9442012-03-23 18:47:50 -0700284Thread* Thread::Attach(const char* thread_name, bool as_daemon, Object* thread_group) {
Elliott Hughescac6cc72011-11-03 20:31:21 -0700285 Thread* self = new Thread;
Elliott Hughes462c9442012-03-23 18:47:50 -0700286 self->Init();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700287
Elliott Hughes34e06962012-04-09 13:55:55 -0700288 self->SetState(kNative);
Elliott Hughes93e74e82011-09-13 11:07:03 -0700289
Elliott Hughescac6cc72011-11-03 20:31:21 -0700290 // If we're the main thread, ClassLinker won't be created until after we're attached,
291 // so that thread needs a two-stage attach. Regular threads don't need this hack.
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800292 // In the compiler, all threads need this hack, because no-one's going to be getting
293 // a native peer!
294 if (self->thin_lock_id_ != ThreadList::kMainId && !Runtime::Current()->IsCompiler()) {
Elliott Hughes462c9442012-03-23 18:47:50 -0700295 self->CreatePeer(thread_name, as_daemon, thread_group);
Elliott Hughes06e3ad42012-02-07 14:51:57 -0800296 } else {
297 // These aren't necessary, but they improve diagnostics for unit tests & command-line tools.
Elliott Hughes22869a92012-03-27 14:08:24 -0700298 if (thread_name != NULL) {
299 self->name_->assign(thread_name);
300 ::art::SetThreadName(thread_name);
301 }
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700302 }
Elliott Hughescac6cc72011-11-03 20:31:21 -0700303
304 self->GetJniEnv()->locals.AssertEmpty();
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700305 return self;
306}
307
Elliott Hughes462c9442012-03-23 18:47:50 -0700308Object* Thread::GetMainThreadGroup() {
Ian Rogers0045a292012-03-31 21:08:41 -0700309 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(gThreadGroup, true, true)) {
Elliott Hughes462c9442012-03-23 18:47:50 -0700310 return NULL;
311 }
312 return gThreadGroup_mMain->GetObject(NULL);
Elliott Hughesd369bb72011-09-12 14:41:14 -0700313}
314
Elliott Hughes462c9442012-03-23 18:47:50 -0700315Object* Thread::GetSystemThreadGroup() {
Ian Rogers0045a292012-03-31 21:08:41 -0700316 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(gThreadGroup, true, true)) {
Elliott Hughes462c9442012-03-23 18:47:50 -0700317 return NULL;
318 }
319 return gThreadGroup_mSystem->GetObject(NULL);
320}
321
322void Thread::CreatePeer(const char* name, bool as_daemon, Object* thread_group) {
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500323 CHECK(Runtime::Current()->IsStarted());
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700324 JNIEnv* env = jni_env_;
325
Elliott Hughes462c9442012-03-23 18:47:50 -0700326 if (thread_group == NULL) {
327 thread_group = Thread::GetMainThreadGroup();
328 }
329 ScopedLocalRef<jobject> java_thread_group(env, AddLocalReference<jobject>(env, thread_group));
Elliott Hughes726079d2011-10-07 18:43:44 -0700330 ScopedLocalRef<jobject> thread_name(env, env->NewStringUTF(name));
Elliott Hughes8daa0922011-09-11 13:46:25 -0700331 jint thread_priority = GetNativePriority();
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700332 jboolean thread_is_daemon = as_daemon;
333
Elliott Hughes726079d2011-10-07 18:43:44 -0700334 ScopedLocalRef<jclass> c(env, env->FindClass("java/lang/Thread"));
Ian Rogers5d4bdc22011-11-02 22:15:43 -0700335 ScopedLocalRef<jobject> peer(env, env->AllocObject(c.get()));
Elliott Hughes726079d2011-10-07 18:43:44 -0700336 peer_ = DecodeJObject(peer.get());
Ian Rogers5d4bdc22011-11-02 22:15:43 -0700337 if (peer_ == NULL) {
338 CHECK(IsExceptionPending());
Ian Rogers5d4bdc22011-11-02 22:15:43 -0700339 return;
340 }
341 jmethodID mid = env->GetMethodID(c.get(), "<init>", "(Ljava/lang/ThreadGroup;Ljava/lang/String;IZ)V");
Elliott Hughes462c9442012-03-23 18:47:50 -0700342 env->CallNonvirtualVoidMethod(peer.get(), c.get(), mid, java_thread_group.get(), thread_name.get(), thread_priority, thread_is_daemon);
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500343 CHECK(!IsExceptionPending()) << " " << PrettyTypeOf(GetException());
Elliott Hughes7a3aeb42011-09-25 17:39:47 -0700344 SetVmData(peer_, Thread::Current());
Elliott Hughesd369bb72011-09-12 14:41:14 -0700345
Elliott Hughes899e7892012-01-24 14:57:32 -0800346 SirtRef<String> peer_thread_name(GetThreadName());
Brian Carlstrom00fae582011-10-28 01:16:28 -0700347 if (peer_thread_name.get() == NULL) {
348 // The Thread constructor should have set the Thread.name to a
349 // non-null value. However, because we can run without code
350 // available (in the compiler, in tests), we manually assign the
351 // fields the constructor should have set.
352 gThread_daemon->SetBoolean(peer_, thread_is_daemon);
Elliott Hughes462c9442012-03-23 18:47:50 -0700353 gThread_group->SetObject(peer_, thread_group);
Brian Carlstrom00fae582011-10-28 01:16:28 -0700354 gThread_name->SetObject(peer_, Decode<Object*>(env, thread_name.get()));
355 gThread_priority->SetInt(peer_, thread_priority);
Elliott Hughes899e7892012-01-24 14:57:32 -0800356 peer_thread_name.reset(GetThreadName());
Brian Carlstrom00fae582011-10-28 01:16:28 -0700357 }
358 // thread_name may have been null, so don't trust this to be non-null
359 if (peer_thread_name.get() != NULL) {
Elliott Hughes899e7892012-01-24 14:57:32 -0800360 SetThreadName(peer_thread_name->ToModifiedUtf8().c_str());
Brian Carlstrom00fae582011-10-28 01:16:28 -0700361 }
Elliott Hughes726079d2011-10-07 18:43:44 -0700362
363 // Pre-allocate an OutOfMemoryError for the double-OOME case.
364 ThrowNewException("Ljava/lang/OutOfMemoryError;",
365 "OutOfMemoryError thrown while trying to throw OutOfMemoryError; no stack available");
366 ScopedLocalRef<jthrowable> exception(env, env->ExceptionOccurred());
367 env->ExceptionClear();
368 pre_allocated_OutOfMemoryError_ = Decode<Throwable*>(env, exception.get());
Carl Shapiro61e019d2011-07-14 16:53:09 -0700369}
370
Elliott Hughes899e7892012-01-24 14:57:32 -0800371void Thread::SetThreadName(const char* name) {
372 name_->assign(name);
373 ::art::SetThreadName(name);
374 Dbg::DdmSendThreadNotification(this, CHUNK_TYPE("THNM"));
375}
376
Elliott Hughesbe759c62011-09-08 19:38:21 -0700377void Thread::InitStackHwm() {
Elliott Hughes215f3142012-01-19 00:22:47 -0800378#if defined(__APPLE__)
Elliott Hughes6cc332e2012-01-20 22:59:20 -0800379 // Only needed to run code. Try implementing this with pthread_get_stacksize_np and pthread_get_stackaddr_np.
380 UNIMPLEMENTED(WARNING);
Elliott Hughes215f3142012-01-19 00:22:47 -0800381#else
Elliott Hughesbe759c62011-09-08 19:38:21 -0700382 pthread_attr_t attributes;
Elliott Hughes3147a232011-10-12 15:55:07 -0700383 CHECK_PTHREAD_CALL(pthread_getattr_np, (pthread_self(), &attributes), __FUNCTION__);
Elliott Hughesbe759c62011-09-08 19:38:21 -0700384
Ian Rogers932746a2011-09-22 18:57:50 -0700385 void* temp_stack_base;
386 CHECK_PTHREAD_CALL(pthread_attr_getstack, (&attributes, &temp_stack_base, &stack_size_),
387 __FUNCTION__);
Ian Rogers30fab402012-01-23 15:43:46 -0800388 stack_begin_ = reinterpret_cast<byte*>(temp_stack_base);
Elliott Hughesbe759c62011-09-08 19:38:21 -0700389
Ian Rogers932746a2011-09-22 18:57:50 -0700390 if (stack_size_ <= kStackOverflowReservedBytes) {
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800391 LOG(FATAL) << "Attempt to attach a thread with a too-small stack (" << stack_size_ << " bytes)";
Elliott Hughesbe759c62011-09-08 19:38:21 -0700392 }
Elliott Hughes449b4bd2011-09-09 12:01:38 -0700393
Ian Rogers932746a2011-09-22 18:57:50 -0700394 // Set stack_end_ to the bottom of the stack saving space of stack overflows
395 ResetDefaultStackEnd();
Elliott Hughes449b4bd2011-09-09 12:01:38 -0700396
397 // Sanity check.
398 int stack_variable;
Elliott Hughes398f64b2012-03-26 18:05:48 -0700399 CHECK_GT(&stack_variable, reinterpret_cast<void*>(stack_end_));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700400
Elliott Hughes8d768a92011-09-14 16:35:25 -0700401 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attributes), __FUNCTION__);
Elliott Hughes215f3142012-01-19 00:22:47 -0800402#endif
Elliott Hughesbe759c62011-09-08 19:38:21 -0700403}
404
Elliott Hughes899e7892012-01-24 14:57:32 -0800405void Thread::Dump(std::ostream& os, bool full) const {
406 if (full) {
407 DumpState(os);
408 DumpStack(os);
409 } else {
410 os << "Thread[";
411 if (GetThinLockId() != 0) {
412 // If we're in kStarting, we won't have a thin lock id or tid yet.
413 os << GetThinLockId()
414 << ",tid=" << GetTid() << ',';
415 }
416 os << GetState()
417 << ",Thread*=" << this
Elliott Hughesffb465f2012-03-01 18:46:05 -0800418 << ",peer=" << peer_
Elliott Hughes899e7892012-01-24 14:57:32 -0800419 << ",\"" << *name_ << "\""
420 << "]";
Elliott Hughese0918552011-10-28 17:18:29 -0700421 }
Elliott Hughesa0957642011-09-02 14:27:33 -0700422}
423
Elliott Hughes899e7892012-01-24 14:57:32 -0800424String* Thread::GetThreadName() const {
Elliott Hughesfc861622011-10-17 17:57:47 -0700425 return (peer_ != NULL) ? reinterpret_cast<String*>(gThread_name->GetObject(peer_)) : NULL;
426}
427
Elliott Hughesffb465f2012-03-01 18:46:05 -0800428void Thread::GetThreadName(std::string& name) const {
429 name.assign(*name_);
430}
431
Elliott Hughesd92bec42011-09-02 17:04:36 -0700432void Thread::DumpState(std::ostream& os) const {
Elliott Hughesd369bb72011-09-12 14:41:14 -0700433 std::string group_name;
434 int priority;
435 bool is_daemon = false;
Elliott Hughesdcc24742011-09-07 14:02:44 -0700436
Elliott Hughesd369bb72011-09-12 14:41:14 -0700437 if (peer_ != NULL) {
Elliott Hughes038a8062011-09-18 14:12:41 -0700438 priority = gThread_priority->GetInt(peer_);
439 is_daemon = gThread_daemon->GetBoolean(peer_);
Elliott Hughesd369bb72011-09-12 14:41:14 -0700440
Elliott Hughesa2155262011-11-16 16:26:58 -0800441 Object* thread_group = GetThreadGroup();
Elliott Hughesd369bb72011-09-12 14:41:14 -0700442 if (thread_group != NULL) {
Elliott Hughes038a8062011-09-18 14:12:41 -0700443 String* group_name_string = reinterpret_cast<String*>(gThreadGroup_name->GetObject(thread_group));
Elliott Hughesd369bb72011-09-12 14:41:14 -0700444 group_name = (group_name_string != NULL) ? group_name_string->ToModifiedUtf8() : "<null>";
445 }
446 } else {
Elliott Hughesd369bb72011-09-12 14:41:14 -0700447 priority = GetNativePriority();
Elliott Hughesdcc24742011-09-07 14:02:44 -0700448 }
Elliott Hughesd92bec42011-09-02 17:04:36 -0700449
450 int policy;
451 sched_param sp;
Elliott Hughes3147a232011-10-12 15:55:07 -0700452 CHECK_PTHREAD_CALL(pthread_getschedparam, (pthread_self(), &policy, &sp), __FUNCTION__);
Elliott Hughesd92bec42011-09-02 17:04:36 -0700453
Elliott Hughes1bac54f2012-03-16 12:48:31 -0700454 std::string scheduler_group_name(GetSchedulerGroupName(GetTid()));
455 if (scheduler_group_name.empty()) {
456 scheduler_group_name = "default";
Elliott Hughesd92bec42011-09-02 17:04:36 -0700457 }
458
Elliott Hughes899e7892012-01-24 14:57:32 -0800459 os << '"' << *name_ << '"';
Elliott Hughesd369bb72011-09-12 14:41:14 -0700460 if (is_daemon) {
Elliott Hughesd92bec42011-09-02 17:04:36 -0700461 os << " daemon";
462 }
463 os << " prio=" << priority
Elliott Hughesdcc24742011-09-07 14:02:44 -0700464 << " tid=" << GetThinLockId()
Elliott Hughes93e74e82011-09-13 11:07:03 -0700465 << " " << GetState() << "\n";
Elliott Hughesd92bec42011-09-02 17:04:36 -0700466
Elliott Hughesd92bec42011-09-02 17:04:36 -0700467 os << " | group=\"" << group_name << "\""
Elliott Hughes8d768a92011-09-14 16:35:25 -0700468 << " sCount=" << suspend_count_
Elliott Hughes234ab152011-10-26 14:02:26 -0700469 << " dsCount=" << debug_suspend_count_
Elliott Hughesdcc24742011-09-07 14:02:44 -0700470 << " obj=" << reinterpret_cast<void*>(peer_)
Elliott Hughesd92bec42011-09-02 17:04:36 -0700471 << " self=" << reinterpret_cast<const void*>(this) << "\n";
472 os << " | sysTid=" << GetTid()
473 << " nice=" << getpriority(PRIO_PROCESS, GetTid())
474 << " sched=" << policy << "/" << sp.sched_priority
Elliott Hughes1bac54f2012-03-16 12:48:31 -0700475 << " cgrp=" << scheduler_group_name
Elliott Hughes3147a232011-10-12 15:55:07 -0700476 << " handle=" << pthread_self() << "\n";
Elliott Hughesd92bec42011-09-02 17:04:36 -0700477
478 // Grab the scheduler stats for this thread.
479 std::string scheduler_stats;
480 if (ReadFileToString(StringPrintf("/proc/self/task/%d/schedstat", GetTid()).c_str(), &scheduler_stats)) {
481 scheduler_stats.resize(scheduler_stats.size() - 1); // Lose the trailing '\n'.
482 } else {
483 scheduler_stats = "0 0 0";
484 }
485
486 int utime = 0;
487 int stime = 0;
488 int task_cpu = 0;
Elliott Hughesbfe487b2011-10-26 15:48:55 -0700489 GetTaskStats(GetTid(), utime, stime, task_cpu);
Elliott Hughesd92bec42011-09-02 17:04:36 -0700490
491 os << " | schedstat=( " << scheduler_stats << " )"
492 << " utm=" << utime
493 << " stm=" << stime
494 << " core=" << task_cpu
495 << " HZ=" << sysconf(_SC_CLK_TCK) << "\n";
496}
497
TDYa127ee0d3fb2012-04-01 14:55:33 -0700498#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogersb04f69f2011-10-17 00:40:54 -0700499void Thread::PushNativeToManagedRecord(NativeToManagedRecord* record) {
500 Method **sp = top_of_managed_stack_.GetSP();
501#ifndef NDEBUG
502 if (sp != NULL) {
503 Method* m = *sp;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800504 Runtime::Current()->GetHeap()->VerifyObject(m);
Ian Rogersb04f69f2011-10-17 00:40:54 -0700505 DCHECK((m == NULL) || m->IsMethod());
506 }
507#endif
508 record->last_top_of_managed_stack_ = reinterpret_cast<void*>(sp);
509 record->last_top_of_managed_stack_pc_ = top_of_managed_stack_pc_;
510 record->link_ = native_to_managed_record_;
511 native_to_managed_record_ = record;
512 top_of_managed_stack_.SetSP(NULL);
513}
TDYa127ee0d3fb2012-04-01 14:55:33 -0700514#else
515void Thread::PushNativeToManagedRecord(NativeToManagedRecord*) {
516 LOG(FATAL) << "Called non-LLVM method with LLVM";
517}
518#endif
Ian Rogersb04f69f2011-10-17 00:40:54 -0700519
TDYa127ee0d3fb2012-04-01 14:55:33 -0700520#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogersb04f69f2011-10-17 00:40:54 -0700521void Thread::PopNativeToManagedRecord(const NativeToManagedRecord& record) {
522 native_to_managed_record_ = record.link_;
523 top_of_managed_stack_.SetSP(reinterpret_cast<Method**>(record.last_top_of_managed_stack_));
524 top_of_managed_stack_pc_ = record.last_top_of_managed_stack_pc_;
525}
TDYa127ee0d3fb2012-04-01 14:55:33 -0700526#else
527void Thread::PopNativeToManagedRecord(const NativeToManagedRecord&) {
528 LOG(FATAL) << "Called non-LLVM method with LLVM";
529}
530#endif
Ian Rogersb04f69f2011-10-17 00:40:54 -0700531
Elliott Hughesd369bb72011-09-12 14:41:14 -0700532struct StackDumpVisitor : public Thread::StackVisitor {
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700533 StackDumpVisitor(std::ostream& os, const Thread* thread)
Ian Rogers28ad40d2011-10-27 15:19:26 -0700534 : last_method(NULL), last_line_number(0), repetition_count(0), os(os), thread(thread),
535 frame_count(0) {
Elliott Hughesd369bb72011-09-12 14:41:14 -0700536 }
537
Ian Rogersbdb03912011-09-14 00:55:44 -0700538 virtual ~StackDumpVisitor() {
Elliott Hughesd369bb72011-09-12 14:41:14 -0700539 }
540
Elliott Hughes530fa002012-03-12 11:44:49 -0700541 bool VisitFrame(const Frame& frame, uintptr_t pc) {
Ian Rogers90865722011-09-19 11:11:44 -0700542 if (!frame.HasMethod()) {
Elliott Hughes530fa002012-03-12 11:44:49 -0700543 return true;
Ian Rogers90865722011-09-19 11:11:44 -0700544 }
Ian Rogers28ad40d2011-10-27 15:19:26 -0700545 const int kMaxRepetition = 3;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700546 Method* m = frame.GetMethod();
TDYa127540a5b72012-04-03 18:56:08 -0700547#if !defined(ART_USE_LLVM_COMPILER)
Elliott Hughesd369bb72011-09-12 14:41:14 -0700548 Class* c = m->GetDeclaringClass();
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700549 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Ian Rogersb861dc02011-11-14 17:00:05 -0800550 const DexCache* dex_cache = c->GetDexCache();
551 int line_number = -1;
552 if (dex_cache != NULL) { // be tolerant of bad input
553 const DexFile& dex_file = class_linker->FindDexFile(dex_cache);
554 line_number = dex_file.GetLineNumFromPC(m, m->ToDexPC(pc));
555 }
TDYa127540a5b72012-04-03 18:56:08 -0700556#else
557 // Compiler_LLVM stores line_number in the ShadowFrame, and passes it to visitor.
558 int line_number = static_cast<int>(pc);
559#endif
Ian Rogers28ad40d2011-10-27 15:19:26 -0700560 if (line_number == last_line_number && last_method == m) {
561 repetition_count++;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700562 } else {
Ian Rogers28ad40d2011-10-27 15:19:26 -0700563 if (repetition_count >= kMaxRepetition) {
564 os << " ... repeated " << (repetition_count - kMaxRepetition) << " times\n";
565 }
566 repetition_count = 0;
567 last_line_number = line_number;
568 last_method = m;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700569 }
Ian Rogers28ad40d2011-10-27 15:19:26 -0700570 if (repetition_count < kMaxRepetition) {
571 os << " at " << PrettyMethod(m, false);
572 if (m->IsNative()) {
573 os << "(Native method)";
574 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800575 mh.ChangeMethod(m);
576 const char* source_file(mh.GetDeclaringClassSourceFile());
577 os << "(" << (source_file != NULL ? source_file : "unavailable")
Ian Rogers28ad40d2011-10-27 15:19:26 -0700578 << ":" << line_number << ")";
579 }
580 os << "\n";
581 }
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700582
583 if (frame_count++ == 0) {
584 Monitor::DescribeWait(os, thread);
585 }
Elliott Hughes530fa002012-03-12 11:44:49 -0700586 return true;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700587 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800588 MethodHelper mh;
Ian Rogers28ad40d2011-10-27 15:19:26 -0700589 Method* last_method;
590 int last_line_number;
591 int repetition_count;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700592 std::ostream& os;
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700593 const Thread* thread;
594 int frame_count;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700595};
596
Elliott Hughesd92bec42011-09-02 17:04:36 -0700597void Thread::DumpStack(std::ostream& os) const {
Elliott Hughesffb465f2012-03-01 18:46:05 -0800598 // If we're currently in native code, dump that stack before dumping the managed stack.
Elliott Hughes34e06962012-04-09 13:55:55 -0700599 if (GetState() == kNative || GetState() == kVmWait) {
Elliott Hughesffb465f2012-03-01 18:46:05 -0800600 DumpNativeStack(os);
601 }
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700602 StackDumpVisitor dumper(os, this);
Elliott Hughesd369bb72011-09-12 14:41:14 -0700603 WalkStack(&dumper);
Elliott Hughese27955c2011-08-26 15:21:24 -0700604}
605
Elliott Hughes34e06962012-04-09 13:55:55 -0700606void Thread::SetStateWithoutSuspendCheck(ThreadState new_state) {
Elliott Hughesa4060e52012-03-02 16:51:35 -0800607 volatile void* raw = reinterpret_cast<volatile void*>(&state_);
608 volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
609 android_atomic_release_store(new_state, addr);
610}
611
Elliott Hughes34e06962012-04-09 13:55:55 -0700612ThreadState Thread::SetState(ThreadState new_state) {
613 ThreadState old_state = state_;
Elliott Hughes8d768a92011-09-14 16:35:25 -0700614 if (old_state == new_state) {
615 return old_state;
616 }
617
618 volatile void* raw = reinterpret_cast<volatile void*>(&state_);
619 volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
620
Elliott Hughes34e06962012-04-09 13:55:55 -0700621 if (new_state == kRunnable) {
Elliott Hughes8d768a92011-09-14 16:35:25 -0700622 /*
Elliott Hughes34e06962012-04-09 13:55:55 -0700623 * Change our status to kRunnable. The transition requires
Elliott Hughes81ff3182012-03-23 20:35:56 -0700624 * that we check for pending suspension, because the runtime considers
Elliott Hughes8d768a92011-09-14 16:35:25 -0700625 * us to be "asleep" in all other states, and another thread could
626 * be performing a GC now.
627 *
628 * The order of operations is very significant here. One way to
629 * do this wrong is:
630 *
631 * GCing thread Our thread (in kNative)
632 * ------------ ----------------------
633 * check suspend count (== 0)
634 * SuspendAllThreads()
635 * grab suspend-count lock
636 * increment all suspend counts
637 * release suspend-count lock
638 * check thread state (== kNative)
639 * all are suspended, begin GC
640 * set state to kRunnable
641 * (continue executing)
642 *
643 * We can correct this by grabbing the suspend-count lock and
644 * performing both of our operations (check suspend count, set
645 * state) while holding it, now we need to grab a mutex on every
646 * transition to kRunnable.
647 *
648 * What we do instead is change the order of operations so that
649 * the transition to kRunnable happens first. If we then detect
650 * that the suspend count is nonzero, we switch to kSuspended.
651 *
652 * Appropriate compiler and memory barriers are required to ensure
653 * that the operations are observed in the expected order.
654 *
655 * This does create a small window of opportunity where a GC in
656 * progress could observe what appears to be a running thread (if
657 * it happens to look between when we set to kRunnable and when we
658 * switch to kSuspended). At worst this only affects assertions
659 * and thread logging. (We could work around it with some sort
660 * of intermediate "pre-running" state that is generally treated
661 * as equivalent to running, but that doesn't seem worthwhile.)
662 *
663 * We can also solve this by combining the "status" and "suspend
664 * count" fields into a single 32-bit value. This trades the
665 * store/load barrier on transition to kRunnable for an atomic RMW
666 * op on all transitions and all suspend count updates (also, all
667 * accesses to status or the thread count require bit-fiddling).
668 * It also eliminates the brief transition through kRunnable when
669 * the thread is supposed to be suspended. This is possibly faster
670 * on SMP and slightly more correct, but less convenient.
671 */
672 android_atomic_acquire_store(new_state, addr);
Elliott Hughes06e3ad42012-02-07 14:51:57 -0800673 ANNOTATE_IGNORE_READS_BEGIN();
674 int suspend_count = suspend_count_;
675 ANNOTATE_IGNORE_READS_END();
676 if (suspend_count != 0) {
Elliott Hughes8d768a92011-09-14 16:35:25 -0700677 Runtime::Current()->GetThreadList()->FullSuspendCheck(this);
678 }
679 } else {
680 /*
Elliott Hughes34e06962012-04-09 13:55:55 -0700681 * Not changing to kRunnable. No additional work required.
Elliott Hughes8d768a92011-09-14 16:35:25 -0700682 *
683 * We use a releasing store to ensure that, if we were runnable,
684 * any updates we previously made to objects on the managed heap
685 * will be observed before the state change.
686 */
687 android_atomic_release_store(new_state, addr);
688 }
689
690 return old_state;
691}
692
Elliott Hughes761928d2011-11-16 18:33:03 -0800693bool Thread::IsSuspended() {
Elliott Hughes06e3ad42012-02-07 14:51:57 -0800694 ANNOTATE_IGNORE_READS_BEGIN();
695 int suspend_count = suspend_count_;
696 ANNOTATE_IGNORE_READS_END();
Elliott Hughes34e06962012-04-09 13:55:55 -0700697 return suspend_count != 0 && GetState() != kRunnable;
Elliott Hughes761928d2011-11-16 18:33:03 -0800698}
699
Elliott Hughesff738062012-02-03 15:00:42 -0800700static void ReportThreadSuspendTimeout(Thread* waiting_thread) {
701 Runtime* runtime = Runtime::Current();
702 std::ostringstream ss;
Elliott Hughesffb465f2012-03-01 18:46:05 -0800703 ss << "Thread suspend timeout waiting for thread " << *waiting_thread << "\n";
Elliott Hughesff738062012-02-03 15:00:42 -0800704 runtime->DumpLockHolders(ss);
705 ss << "\n";
706 runtime->GetThreadList()->DumpLocked(ss);
707 LOG(FATAL) << ss.str();
708}
709
Elliott Hughes8d768a92011-09-14 16:35:25 -0700710void Thread::WaitUntilSuspended() {
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800711 static const useconds_t kTimeoutUs = 30 * 1000000; // 30s.
712
713 useconds_t total_delay = 0;
Elliott Hughes8d768a92011-09-14 16:35:25 -0700714 useconds_t delay = 0;
Elliott Hughes34e06962012-04-09 13:55:55 -0700715 while (GetState() == kRunnable) {
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800716 if (total_delay >= kTimeoutUs) {
Elliott Hughesff738062012-02-03 15:00:42 -0800717 ReportThreadSuspendTimeout(this);
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800718 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700719 useconds_t new_delay = delay * 2;
720 CHECK_GE(new_delay, delay);
721 delay = new_delay;
722 if (delay == 0) {
723 sched_yield();
724 delay = 10000;
725 } else {
726 usleep(delay);
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800727 total_delay += delay;
Elliott Hughes8d768a92011-09-14 16:35:25 -0700728 }
729 }
730}
731
Elliott Hughesbe759c62011-09-08 19:38:21 -0700732void Thread::ThreadExitCallback(void* arg) {
733 Thread* self = reinterpret_cast<Thread*>(arg);
734 LOG(FATAL) << "Native thread exited without calling DetachCurrentThread: " << *self;
Carl Shapirob5573532011-07-12 18:22:59 -0700735}
736
Elliott Hughesbe759c62011-09-08 19:38:21 -0700737void Thread::Startup() {
Carl Shapirob5573532011-07-12 18:22:59 -0700738 // Allocate a TLS slot.
Elliott Hughes8d768a92011-09-14 16:35:25 -0700739 CHECK_PTHREAD_CALL(pthread_key_create, (&Thread::pthread_key_self_, Thread::ThreadExitCallback), "self key");
Carl Shapirob5573532011-07-12 18:22:59 -0700740
741 // Double-check the TLS slot allocation.
742 if (pthread_getspecific(pthread_key_self_) != NULL) {
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800743 LOG(FATAL) << "Newly-created pthread TLS slot is not NULL";
Carl Shapirob5573532011-07-12 18:22:59 -0700744 }
Elliott Hughes038a8062011-09-18 14:12:41 -0700745}
Carl Shapirob5573532011-07-12 18:22:59 -0700746
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700747// TODO: make more accessible?
Elliott Hughesab7b9dc2012-03-27 13:16:29 -0700748static Class* FindClassOrDie(ClassLinker* class_linker, const char* descriptor) {
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700749 Class* c = class_linker->FindSystemClass(descriptor);
750 CHECK(c != NULL) << descriptor;
751 return c;
752}
753
754// TODO: make more accessible?
Elliott Hughesab7b9dc2012-03-27 13:16:29 -0700755static Field* FindFieldOrDie(Class* c, const char* name, const char* descriptor) {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700756 Field* f = c->FindDeclaredInstanceField(name, descriptor);
757 CHECK(f != NULL) << PrettyClass(c) << " " << name << " " << descriptor;
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700758 return f;
759}
760
761// TODO: make more accessible?
Elliott Hughesab7b9dc2012-03-27 13:16:29 -0700762static Method* FindMethodOrDie(Class* c, const char* name, const char* signature) {
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700763 Method* m = c->FindVirtualMethod(name, signature);
764 CHECK(m != NULL) << PrettyClass(c) << " " << name << " " << signature;
765 return m;
766}
767
Elliott Hughes462c9442012-03-23 18:47:50 -0700768// TODO: make more accessible?
Elliott Hughesab7b9dc2012-03-27 13:16:29 -0700769static Field* FindStaticFieldOrDie(Class* c, const char* name, const char* descriptor) {
Elliott Hughes462c9442012-03-23 18:47:50 -0700770 Field* f = c->FindDeclaredStaticField(name, descriptor);
771 CHECK(f != NULL) << PrettyClass(c) << " " << name << " " << descriptor;
772 return f;
773}
774
Elliott Hughes038a8062011-09-18 14:12:41 -0700775void Thread::FinishStartup() {
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500776 CHECK(Runtime::Current()->IsStarted());
Brian Carlstromb82b6872011-10-26 17:18:07 -0700777 Thread* self = Thread::Current();
778
779 // Need to be kRunnable for FindClass
Elliott Hughes34e06962012-04-09 13:55:55 -0700780 ScopedThreadStateChange tsc(self, kRunnable);
Brian Carlstromb82b6872011-10-26 17:18:07 -0700781
Elliott Hughes038a8062011-09-18 14:12:41 -0700782 // Now the ClassLinker is ready, we can find the various Class*, Field*, and Method*s we need.
783 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700784
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700785 Class* Thread_class = FindClassOrDie(class_linker, "Ljava/lang/Thread;");
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700786 Class* UncaughtExceptionHandler_class = FindClassOrDie(class_linker, "Ljava/lang/Thread$UncaughtExceptionHandler;");
Elliott Hughes462c9442012-03-23 18:47:50 -0700787 gThreadGroup = FindClassOrDie(class_linker, "Ljava/lang/ThreadGroup;");
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700788 gThreadLock = FindClassOrDie(class_linker, "Ljava/lang/ThreadLock;");
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700789
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700790 gThread_daemon = FindFieldOrDie(Thread_class, "daemon", "Z");
791 gThread_group = FindFieldOrDie(Thread_class, "group", "Ljava/lang/ThreadGroup;");
792 gThread_lock = FindFieldOrDie(Thread_class, "lock", "Ljava/lang/ThreadLock;");
793 gThread_name = FindFieldOrDie(Thread_class, "name", "Ljava/lang/String;");
794 gThread_priority = FindFieldOrDie(Thread_class, "priority", "I");
795 gThread_uncaughtHandler = FindFieldOrDie(Thread_class, "uncaughtHandler", "Ljava/lang/Thread$UncaughtExceptionHandler;");
796 gThread_vmData = FindFieldOrDie(Thread_class, "vmData", "I");
Elliott Hughes462c9442012-03-23 18:47:50 -0700797 gThreadGroup_name = FindFieldOrDie(gThreadGroup, "name", "Ljava/lang/String;");
798 gThreadGroup_mMain = FindStaticFieldOrDie(gThreadGroup, "mMain", "Ljava/lang/ThreadGroup;");
799 gThreadGroup_mSystem = FindStaticFieldOrDie(gThreadGroup, "mSystem", "Ljava/lang/ThreadGroup;");
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700800 gThreadLock_thread = FindFieldOrDie(gThreadLock, "thread", "Ljava/lang/Thread;");
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700801
802 gThread_run = FindMethodOrDie(Thread_class, "run", "()V");
Elliott Hughes462c9442012-03-23 18:47:50 -0700803 gThreadGroup_removeThread = FindMethodOrDie(gThreadGroup, "removeThread", "(Ljava/lang/Thread;)V");
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700804 gUncaughtExceptionHandler_uncaughtException = FindMethodOrDie(UncaughtExceptionHandler_class,
805 "uncaughtException", "(Ljava/lang/Thread;Ljava/lang/Throwable;)V");
Elliott Hughes01158d72011-09-19 19:47:10 -0700806
807 // Finish attaching the main thread.
Elliott Hughes462c9442012-03-23 18:47:50 -0700808 Thread::Current()->CreatePeer("main", false, Thread::GetMainThreadGroup());
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500809
810 InitBoxingMethods();
811 class_linker->RunRootClinits();
Carl Shapirob5573532011-07-12 18:22:59 -0700812}
813
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700814void Thread::Shutdown() {
Elliott Hughes8d768a92011-09-14 16:35:25 -0700815 CHECK_PTHREAD_CALL(pthread_key_delete, (Thread::pthread_key_self_), "self key");
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700816}
817
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700818uint32_t Thread::LockOwnerFromThreadLock(Object* thread_lock) {
819 if (thread_lock == NULL || thread_lock->GetClass() != gThreadLock) {
820 return ThreadList::kInvalidId;
821 }
822 Object* managed_thread = gThreadLock_thread->GetObject(thread_lock);
823 if (managed_thread == NULL) {
824 return ThreadList::kInvalidId;
825 }
826 uintptr_t vmData = static_cast<uintptr_t>(gThread_vmData->GetInt(managed_thread));
827 Thread* thread = reinterpret_cast<Thread*>(vmData);
828 if (thread == NULL) {
829 return ThreadList::kInvalidId;
830 }
831 return thread->GetThinLockId();
832}
833
Elliott Hughesdcc24742011-09-07 14:02:44 -0700834Thread::Thread()
Elliott Hughes47179f72011-10-27 16:44:39 -0700835 : thin_lock_id_(0),
836 tid_(0),
837 peer_(NULL),
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700838 top_of_managed_stack_(),
839 top_of_managed_stack_pc_(0),
Elliott Hughese62934d2012-04-09 11:24:29 -0700840 wait_mutex_(new Mutex("a thread wait mutex")),
841 wait_cond_(new ConditionVariable("a thread wait condition variable")),
Elliott Hughes8daa0922011-09-11 13:46:25 -0700842 wait_monitor_(NULL),
843 interrupted_(false),
Elliott Hughesdc33ad52011-09-16 19:46:51 -0700844 wait_next_(NULL),
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700845 monitor_enter_object_(NULL),
Elliott Hughesdc33ad52011-09-16 19:46:51 -0700846 card_table_(0),
Elliott Hughes8daa0922011-09-11 13:46:25 -0700847 stack_end_(NULL),
Elliott Hughesdcc24742011-09-07 14:02:44 -0700848 native_to_managed_record_(NULL),
849 top_sirt_(NULL),
Logan Chienf7ad17e2012-03-15 03:10:03 +0800850 top_shadow_frame_(NULL),
Elliott Hughesdcc24742011-09-07 14:02:44 -0700851 jni_env_(NULL),
Elliott Hughes34e06962012-04-09 13:55:55 -0700852 state_(kNative),
Elliott Hughesdc33ad52011-09-16 19:46:51 -0700853 self_(NULL),
854 runtime_(NULL),
Elliott Hughesdcc24742011-09-07 14:02:44 -0700855 exception_(NULL),
856 suspend_count_(0),
Elliott Hughes234ab152011-10-26 14:02:26 -0700857 debug_suspend_count_(0),
Elliott Hughes85d15452011-09-16 17:33:01 -0700858 class_loader_override_(NULL),
Elliott Hughes418dfe72011-10-06 18:56:27 -0700859 long_jump_context_(NULL),
Elliott Hughes726079d2011-10-07 18:43:44 -0700860 throwing_OutOfMemoryError_(false),
Elliott Hughes475fc232011-10-25 15:00:35 -0700861 pre_allocated_OutOfMemoryError_(NULL),
jeffhaoe343b762011-12-05 16:36:44 -0800862 debug_invoke_req_(new DebugInvokeReq),
Elliott Hughes899e7892012-01-24 14:57:32 -0800863 trace_stack_(new std::vector<TraceStackFrame>),
864 name_(new std::string("<native thread without managed peer>")) {
Elliott Hughesf5a7a472011-10-07 14:31:02 -0700865 CHECK_EQ((sizeof(Thread) % 4), 0U) << sizeof(Thread);
Elliott Hughesffb465f2012-03-01 18:46:05 -0800866 memset(&held_mutexes_[0], 0, sizeof(held_mutexes_));
Elliott Hughesdcc24742011-09-07 14:02:44 -0700867}
868
Elliott Hughesab7b9dc2012-03-27 13:16:29 -0700869static void MonitorExitVisitor(const Object* object, void*) {
Elliott Hughes02b48d12011-09-07 17:15:51 -0700870 Object* entered_monitor = const_cast<Object*>(object);
Elliott Hughesab7b9dc2012-03-27 13:16:29 -0700871 LOG(WARNING) << "Calling MonitorExit on object " << object << " (" << PrettyTypeOf(object) << ")"
872 << " left locked by native thread " << *Thread::Current() << " which is detaching";
Elliott Hughes5f791332011-09-15 17:45:30 -0700873 entered_monitor->MonitorExit(Thread::Current());
Elliott Hughes02b48d12011-09-07 17:15:51 -0700874}
875
Elliott Hughesc0f09332012-03-26 13:27:06 -0700876void Thread::Destroy() {
Elliott Hughes02b48d12011-09-07 17:15:51 -0700877 // On thread detach, all monitors entered with JNI MonitorEnter are automatically exited.
Elliott Hughes93e74e82011-09-13 11:07:03 -0700878 if (jni_env_ != NULL) {
879 jni_env_->monitors.VisitRoots(MonitorExitVisitor, NULL);
880 }
Elliott Hughes02b48d12011-09-07 17:15:51 -0700881
Elliott Hughes93e74e82011-09-13 11:07:03 -0700882 if (peer_ != NULL) {
Elliott Hughesc0f09332012-03-26 13:27:06 -0700883 Thread* self = this;
Elliott Hughes29f27422011-09-18 16:02:18 -0700884
Elliott Hughes534da072012-03-27 15:17:42 -0700885 // We may need to call user-supplied managed code.
Elliott Hughes34e06962012-04-09 13:55:55 -0700886 SetState(kRunnable);
Elliott Hughes534da072012-03-27 15:17:42 -0700887
888 HandleUncaughtExceptions();
889 RemoveFromThreadGroup();
890
Elliott Hughes29f27422011-09-18 16:02:18 -0700891 // this.vmData = 0;
Elliott Hughes93e74e82011-09-13 11:07:03 -0700892 SetVmData(peer_, NULL);
Elliott Hughes02b48d12011-09-07 17:15:51 -0700893
Elliott Hughesc0f09332012-03-26 13:27:06 -0700894 Dbg::PostThreadDeath(self);
Elliott Hughes02b48d12011-09-07 17:15:51 -0700895
Elliott Hughes29f27422011-09-18 16:02:18 -0700896 // Thread.join() is implemented as an Object.wait() on the Thread.lock
897 // object. Signal anyone who is waiting.
Elliott Hughes038a8062011-09-18 14:12:41 -0700898 Object* lock = gThread_lock->GetObject(peer_);
899 // (This conditional is only needed for tests, where Thread.lock won't have been set.)
Elliott Hughes5f791332011-09-15 17:45:30 -0700900 if (lock != NULL) {
901 lock->MonitorEnter(self);
902 lock->NotifyAll();
903 lock->MonitorExit(self);
904 }
905 }
Elliott Hughesc0f09332012-03-26 13:27:06 -0700906}
Elliott Hughes02b48d12011-09-07 17:15:51 -0700907
Elliott Hughesc0f09332012-03-26 13:27:06 -0700908Thread::~Thread() {
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700909 delete jni_env_;
Elliott Hughes02b48d12011-09-07 17:15:51 -0700910 jni_env_ = NULL;
911
Elliott Hughes34e06962012-04-09 13:55:55 -0700912 SetState(kTerminated);
Elliott Hughes85d15452011-09-16 17:33:01 -0700913
914 delete wait_cond_;
915 delete wait_mutex_;
916
Ian Rogers776ac1f2012-04-13 23:36:36 -0700917#if !defined(ART_USE_LLVM_COMPILER)
Elliott Hughes85d15452011-09-16 17:33:01 -0700918 delete long_jump_context_;
Ian Rogers776ac1f2012-04-13 23:36:36 -0700919#endif
Elliott Hughes475fc232011-10-25 15:00:35 -0700920
921 delete debug_invoke_req_;
jeffhaoe343b762011-12-05 16:36:44 -0800922 delete trace_stack_;
Elliott Hughes899e7892012-01-24 14:57:32 -0800923 delete name_;
Elliott Hughesd8af1592012-04-16 20:40:15 -0700924
925 TearDownAlternateSignalStack();
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700926}
927
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700928void Thread::HandleUncaughtExceptions() {
929 if (!IsExceptionPending()) {
930 return;
931 }
932
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700933 // Get and clear the exception.
934 Object* exception = GetException();
935 ClearException();
936
937 // If the thread has its own handler, use that.
938 Object* handler = gThread_uncaughtHandler->GetObject(peer_);
939 if (handler == NULL) {
940 // Otherwise use the thread group's default handler.
Elliott Hughesa2155262011-11-16 16:26:58 -0800941 handler = GetThreadGroup();
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700942 }
943
944 // Call the handler.
945 Method* m = handler->GetClass()->FindVirtualMethodForVirtualOrInterface(gUncaughtExceptionHandler_uncaughtException);
Elliott Hughes77405792012-03-15 15:22:12 -0700946 JValue args[2];
Elliott Hughesf24d3ce2012-04-11 17:43:37 -0700947 args[0].SetL(peer_);
948 args[1].SetL(exception);
Elliott Hughes77405792012-03-15 15:22:12 -0700949 m->Invoke(this, handler, args, NULL);
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700950
951 // If the handler threw, clear that exception too.
952 ClearException();
953}
954
Elliott Hughesa2155262011-11-16 16:26:58 -0800955Object* Thread::GetThreadGroup() const {
956 return gThread_group->GetObject(peer_);
957}
958
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700959void Thread::RemoveFromThreadGroup() {
960 // this.group.removeThread(this);
961 // group can be null if we're in the compiler or a test.
Elliott Hughesa2155262011-11-16 16:26:58 -0800962 Object* group = GetThreadGroup();
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700963 if (group != NULL) {
964 Method* m = group->GetClass()->FindVirtualMethodForVirtualOrInterface(gThreadGroup_removeThread);
Elliott Hughes77405792012-03-15 15:22:12 -0700965 JValue args[1];
Elliott Hughesf24d3ce2012-04-11 17:43:37 -0700966 args[0].SetL(peer_);
Elliott Hughes77405792012-03-15 15:22:12 -0700967 m->Invoke(this, group, args, NULL);
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700968 }
969}
970
Ian Rogers408f79a2011-08-23 18:22:33 -0700971size_t Thread::NumSirtReferences() {
Ian Rogersa8cd9f42011-08-19 16:43:41 -0700972 size_t count = 0;
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700973 for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
Ian Rogersa8cd9f42011-08-19 16:43:41 -0700974 count += cur->NumberOfReferences();
975 }
976 return count;
977}
978
TDYa12728f1a142012-03-15 21:51:52 -0700979size_t Thread::NumShadowFrameReferences() {
980 size_t count = 0;
981 for (ShadowFrame* cur = top_shadow_frame_; cur; cur = cur->GetLink()) {
982 count += cur->NumberOfReferences();
983 }
984 return count;
985}
986
Ian Rogers408f79a2011-08-23 18:22:33 -0700987bool Thread::SirtContains(jobject obj) {
988 Object** sirt_entry = reinterpret_cast<Object**>(obj);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700989 for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
990 if (cur->Contains(sirt_entry)) {
Ian Rogersa8cd9f42011-08-19 16:43:41 -0700991 return true;
992 }
993 }
994 return false;
995}
996
TDYa12728f1a142012-03-15 21:51:52 -0700997bool Thread::ShadowFrameContains(jobject obj) {
998 Object** shadow_frame_entry = reinterpret_cast<Object**>(obj);
999 for (ShadowFrame* cur = top_shadow_frame_; cur; cur = cur->GetLink()) {
1000 if (cur->Contains(shadow_frame_entry)) {
1001 return true;
1002 }
1003 }
1004 return false;
1005}
1006
1007bool Thread::StackReferencesContain(jobject obj) {
1008 return SirtContains(obj) || ShadowFrameContains(obj);
1009}
1010
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -07001011void Thread::SirtVisitRoots(Heap::RootVisitor* visitor, void* arg) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001012 for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -07001013 size_t num_refs = cur->NumberOfReferences();
1014 for (size_t j = 0; j < num_refs; j++) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001015 Object* object = cur->GetReference(j);
Brian Carlstrom5e73f9c2011-10-11 11:28:12 -07001016 if (object != NULL) {
1017 visitor(object, arg);
1018 }
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -07001019 }
1020 }
1021}
1022
Logan Chienf7ad17e2012-03-15 03:10:03 +08001023void Thread::ShadowFrameVisitRoots(Heap::RootVisitor* visitor, void* arg) {
1024 for (ShadowFrame* cur = top_shadow_frame_; cur; cur = cur->GetLink()) {
1025 size_t num_refs = cur->NumberOfReferences();
1026 for (size_t j = 0; j < num_refs; j++) {
1027 Object* object = cur->GetReference(j);
1028 if (object != NULL) {
1029 visitor(object, arg);
1030 }
1031 }
1032 }
1033}
1034
Ian Rogers408f79a2011-08-23 18:22:33 -07001035Object* Thread::DecodeJObject(jobject obj) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001036 DCHECK(CanAccessDirectReferences());
Ian Rogers408f79a2011-08-23 18:22:33 -07001037 if (obj == NULL) {
1038 return NULL;
1039 }
1040 IndirectRef ref = reinterpret_cast<IndirectRef>(obj);
1041 IndirectRefKind kind = GetIndirectRefKind(ref);
1042 Object* result;
1043 switch (kind) {
1044 case kLocal:
1045 {
Elliott Hughes69f5bc62011-08-24 09:26:14 -07001046 IndirectReferenceTable& locals = jni_env_->locals;
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001047 result = const_cast<Object*>(locals.Get(ref));
Ian Rogers408f79a2011-08-23 18:22:33 -07001048 break;
1049 }
1050 case kGlobal:
1051 {
1052 JavaVMExt* vm = Runtime::Current()->GetJavaVM();
1053 IndirectReferenceTable& globals = vm->globals;
1054 MutexLock mu(vm->globals_lock);
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001055 result = const_cast<Object*>(globals.Get(ref));
Ian Rogers408f79a2011-08-23 18:22:33 -07001056 break;
1057 }
1058 case kWeakGlobal:
1059 {
1060 JavaVMExt* vm = Runtime::Current()->GetJavaVM();
1061 IndirectReferenceTable& weak_globals = vm->weak_globals;
1062 MutexLock mu(vm->weak_globals_lock);
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001063 result = const_cast<Object*>(weak_globals.Get(ref));
Ian Rogers408f79a2011-08-23 18:22:33 -07001064 if (result == kClearedJniWeakGlobal) {
1065 // This is a special case where it's okay to return NULL.
1066 return NULL;
1067 }
1068 break;
1069 }
1070 case kSirtOrInvalid:
1071 default:
1072 // TODO: make stack indirect reference table lookup more efficient
1073 // Check if this is a local reference in the SIRT
TDYa12728f1a142012-03-15 21:51:52 -07001074 if (StackReferencesContain(obj)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001075 result = *reinterpret_cast<Object**>(obj); // Read from SIRT
Elliott Hughesc2dc62d2012-01-17 20:06:12 -08001076 } else if (Runtime::Current()->GetJavaVM()->work_around_app_jni_bugs) {
Ian Rogers408f79a2011-08-23 18:22:33 -07001077 // Assume an invalid local reference is actually a direct pointer.
1078 result = reinterpret_cast<Object*>(obj);
1079 } else {
Elliott Hughesa2501992011-08-26 19:39:54 -07001080 result = kInvalidIndirectRefObject;
Ian Rogers408f79a2011-08-23 18:22:33 -07001081 }
1082 }
1083
1084 if (result == NULL) {
Elliott Hughesa2501992011-08-26 19:39:54 -07001085 LOG(ERROR) << "JNI ERROR (app bug): use of deleted " << kind << ": " << obj;
1086 JniAbort(NULL);
1087 } else {
1088 if (result != kInvalidIndirectRefObject) {
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001089 Runtime::Current()->GetHeap()->VerifyObject(result);
Elliott Hughesa2501992011-08-26 19:39:54 -07001090 }
Ian Rogers408f79a2011-08-23 18:22:33 -07001091 }
Ian Rogers408f79a2011-08-23 18:22:33 -07001092 return result;
1093}
1094
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001095class CountStackDepthVisitor : public Thread::StackVisitor {
1096 public:
Elliott Hughes29f27422011-09-18 16:02:18 -07001097 CountStackDepthVisitor() : depth_(0), skip_depth_(0), skipping_(true) {}
Elliott Hughesd369bb72011-09-12 14:41:14 -07001098
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001099 bool VisitFrame(const Frame& frame, uintptr_t /*pc*/) {
Elliott Hughes29f27422011-09-18 16:02:18 -07001100 // We want to skip frames up to and including the exception's constructor.
Ian Rogers90865722011-09-19 11:11:44 -07001101 // Note we also skip the frame if it doesn't have a method (namely the callee
1102 // save frame)
Ian Rogers5167c972012-02-03 10:41:20 -08001103 if (skipping_ && frame.HasMethod() &&
1104 !Throwable::GetJavaLangThrowable()->IsAssignableFrom(frame.GetMethod()->GetDeclaringClass())) {
Elliott Hughes29f27422011-09-18 16:02:18 -07001105 skipping_ = false;
1106 }
1107 if (!skipping_) {
Ian Rogers6b0870d2011-12-15 19:38:12 -08001108 if (frame.HasMethod()) { // ignore callee save frames
1109 ++depth_;
1110 }
Elliott Hughes29f27422011-09-18 16:02:18 -07001111 } else {
1112 ++skip_depth_;
1113 }
Elliott Hughes530fa002012-03-12 11:44:49 -07001114 return true;
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001115 }
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001116
1117 int GetDepth() const {
Ian Rogersaaa20802011-09-11 21:47:37 -07001118 return depth_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001119 }
1120
Elliott Hughes29f27422011-09-18 16:02:18 -07001121 int GetSkipDepth() const {
1122 return skip_depth_;
1123 }
1124
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001125 private:
Ian Rogersaaa20802011-09-11 21:47:37 -07001126 uint32_t depth_;
Elliott Hughes29f27422011-09-18 16:02:18 -07001127 uint32_t skip_depth_;
1128 bool skipping_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001129};
1130
Ian Rogersaaa20802011-09-11 21:47:37 -07001131class BuildInternalStackTraceVisitor : public Thread::StackVisitor {
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001132 public:
Ian Rogers283ed0d2012-02-16 15:25:09 -08001133 explicit BuildInternalStackTraceVisitor(int skip_depth)
Elliott Hughes726079d2011-10-07 18:43:44 -07001134 : skip_depth_(skip_depth), count_(0), pc_trace_(NULL), method_trace_(NULL), local_ref_(NULL) {
Ian Rogers283ed0d2012-02-16 15:25:09 -08001135 }
1136
1137 bool Init(int depth, ScopedJniThreadState& ts) {
Ian Rogersaaa20802011-09-11 21:47:37 -07001138 // Allocate method trace with an extra slot that will hold the PC trace
Elliott Hughes01158d72011-09-19 19:47:10 -07001139 method_trace_ = Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(depth + 1);
Elliott Hughes726079d2011-10-07 18:43:44 -07001140 if (method_trace_ == NULL) {
Ian Rogers283ed0d2012-02-16 15:25:09 -08001141 return false;
Elliott Hughes726079d2011-10-07 18:43:44 -07001142 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001143 // Register a local reference as IntArray::Alloc may trigger GC
1144 local_ref_ = AddLocalReference<jobject>(ts.Env(), method_trace_);
1145 pc_trace_ = IntArray::Alloc(depth);
Elliott Hughes726079d2011-10-07 18:43:44 -07001146 if (pc_trace_ == NULL) {
Ian Rogers283ed0d2012-02-16 15:25:09 -08001147 return false;
Elliott Hughes726079d2011-10-07 18:43:44 -07001148 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001149#ifdef MOVING_GARBAGE_COLLECTOR
1150 // Re-read after potential GC
Brian Carlstrom26736442012-02-16 18:24:26 -08001151 method_trace_ = Decode<ObjectArray<Object>*>(ts.Env(), local_ref_);
Ian Rogersaaa20802011-09-11 21:47:37 -07001152#endif
1153 // Save PC trace in last element of method trace, also places it into the
1154 // object graph.
1155 method_trace_->Set(depth, pc_trace_);
Ian Rogers283ed0d2012-02-16 15:25:09 -08001156 return true;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001157 }
1158
Ian Rogersaaa20802011-09-11 21:47:37 -07001159 virtual ~BuildInternalStackTraceVisitor() {}
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001160
Elliott Hughes530fa002012-03-12 11:44:49 -07001161 bool VisitFrame(const Frame& frame, uintptr_t pc) {
Elliott Hughes726079d2011-10-07 18:43:44 -07001162 if (method_trace_ == NULL || pc_trace_ == NULL) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001163 return true; // We're probably trying to fillInStackTrace for an OutOfMemoryError.
Elliott Hughes726079d2011-10-07 18:43:44 -07001164 }
Elliott Hughes29f27422011-09-18 16:02:18 -07001165 if (skip_depth_ > 0) {
1166 skip_depth_--;
Elliott Hughes530fa002012-03-12 11:44:49 -07001167 return true;
Elliott Hughes29f27422011-09-18 16:02:18 -07001168 }
Ian Rogers6b0870d2011-12-15 19:38:12 -08001169 if (!frame.HasMethod()) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001170 return true; // ignore callee save frames
Ian Rogers6b0870d2011-12-15 19:38:12 -08001171 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001172 method_trace_->Set(count_, frame.GetMethod());
Ian Rogersbdb03912011-09-14 00:55:44 -07001173 pc_trace_->Set(count_, pc);
Ian Rogersaaa20802011-09-11 21:47:37 -07001174 ++count_;
Elliott Hughes530fa002012-03-12 11:44:49 -07001175 return true;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001176 }
1177
Ian Rogersaaa20802011-09-11 21:47:37 -07001178 jobject GetInternalStackTrace() const {
1179 return local_ref_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001180 }
1181
1182 private:
Elliott Hughes29f27422011-09-18 16:02:18 -07001183 // How many more frames to skip.
1184 int32_t skip_depth_;
Ian Rogersaaa20802011-09-11 21:47:37 -07001185 // Current position down stack trace
1186 uint32_t count_;
1187 // Array of return PC values
1188 IntArray* pc_trace_;
1189 // An array of the methods on the stack, the last entry is a reference to the
1190 // PC trace
1191 ObjectArray<Object>* method_trace_;
1192 // Local indirect reference table entry for method trace
1193 jobject local_ref_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001194};
1195
Ian Rogers776ac1f2012-04-13 23:36:36 -07001196#if !defined(ART_USE_LLVM_COMPILER)
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001197// TODO: remove this.
Elliott Hughesab7b9dc2012-03-27 13:16:29 -07001198static uintptr_t ManglePc(uintptr_t pc) {
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001199 // Move the PC back 2 bytes as a call will frequently terminate the
1200 // decoding of a particular instruction and we want to make sure we
1201 // get the Dex PC of the instruction with the call and not the
1202 // instruction following.
1203 if (pc > 0) { pc -= 2; }
1204 return pc;
1205}
Ian Rogers776ac1f2012-04-13 23:36:36 -07001206#endif
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001207
1208// TODO: remove this.
Elliott Hughesab7b9dc2012-03-27 13:16:29 -07001209static uintptr_t DemanglePc(uintptr_t pc) {
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001210 // Revert mangling for the case where we need the PC to return to the upcall
Ian Rogers9a8a8882012-03-08 02:30:55 -08001211 if (pc > 0) { pc += 2; }
1212 return pc;
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001213}
Ian Rogersf57c47c2011-10-06 00:06:17 -07001214
Logan Chienf7ad17e2012-03-15 03:10:03 +08001215void Thread::PushShadowFrame(ShadowFrame* frame) {
1216 frame->SetLink(top_shadow_frame_);
1217 top_shadow_frame_ = frame;
1218}
1219
1220ShadowFrame* Thread::PopShadowFrame() {
1221 CHECK(top_shadow_frame_ != NULL);
1222 ShadowFrame* frame = top_shadow_frame_;
1223 top_shadow_frame_ = frame->GetLink();
1224 return frame;
1225}
1226
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001227void Thread::PushSirt(StackIndirectReferenceTable* sirt) {
1228 sirt->SetLink(top_sirt_);
1229 top_sirt_ = sirt;
1230}
1231
1232StackIndirectReferenceTable* Thread::PopSirt() {
1233 CHECK(top_sirt_ != NULL);
1234 StackIndirectReferenceTable* sirt = top_sirt_;
1235 top_sirt_ = top_sirt_->GetLink();
1236 return sirt;
1237}
1238
TDYa1279b2ba2e2012-03-19 10:12:32 -07001239#if !defined(ART_USE_LLVM_COMPILER) // LLVM use ShadowFrame
1240
Elliott Hughes530fa002012-03-12 11:44:49 -07001241void Thread::WalkStack(StackVisitor* visitor, bool include_upcalls) const {
Elliott Hughesd369bb72011-09-12 14:41:14 -07001242 Frame frame = GetTopOfStack();
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001243 uintptr_t pc = ManglePc(top_of_managed_stack_pc_);
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001244 uint32_t trace_stack_depth = 0;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001245 // TODO: enable this CHECK after native_to_managed_record_ is initialized during startup.
1246 // CHECK(native_to_managed_record_ != NULL);
1247 NativeToManagedRecord* record = native_to_managed_record_;
Ian Rogers57b86d42012-03-27 16:05:41 -07001248 bool method_tracing_active = Runtime::Current()->IsMethodTracingActive();
Elliott Hughes530fa002012-03-12 11:44:49 -07001249 while (frame.GetSP() != NULL) {
1250 for ( ; frame.GetMethod() != NULL; frame.Next()) {
Brian Carlstromf8bbb842012-03-14 03:01:42 -07001251 frame.GetMethod()->AssertPcIsWithinCode(pc);
Elliott Hughes530fa002012-03-12 11:44:49 -07001252 bool should_continue = visitor->VisitFrame(frame, pc);
Ian Rogers57b86d42012-03-27 16:05:41 -07001253 if (UNLIKELY(!should_continue)) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001254 return;
1255 }
Ian Rogers57b86d42012-03-27 16:05:41 -07001256 uintptr_t return_pc = frame.GetReturnPC();
1257 if (LIKELY(!method_tracing_active)) {
1258 pc = ManglePc(return_pc);
1259 } else {
jeffhao0791adc2012-04-04 11:14:32 -07001260 // While profiling, the return pc is restored from the side stack, except when walking
1261 // the stack for an exception where the side stack will be unwound in VisitFrame.
1262 if (IsTraceExitPc(return_pc) && !include_upcalls) {
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001263 TraceStackFrame trace_frame = GetTraceStackFrame(trace_stack_depth++);
jeffhao26c0a1a2012-01-17 16:28:33 -08001264 CHECK(trace_frame.method_ == frame.GetMethod());
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001265 pc = ManglePc(trace_frame.return_pc_);
Ian Rogers57b86d42012-03-27 16:05:41 -07001266 } else {
1267 pc = ManglePc(return_pc);
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001268 }
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001269 }
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001270 }
Elliott Hughes530fa002012-03-12 11:44:49 -07001271 if (include_upcalls) {
1272 bool should_continue = visitor->VisitFrame(frame, pc);
1273 if (!should_continue) {
1274 return;
1275 }
1276 }
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001277 if (record == NULL) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001278 return;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001279 }
Ian Rogersbdb03912011-09-14 00:55:44 -07001280 // last_tos should return Frame instead of sp?
Ian Rogersff1ed472011-09-20 13:46:24 -07001281 frame.SetSP(reinterpret_cast<Method**>(record->last_top_of_managed_stack_));
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001282 pc = ManglePc(record->last_top_of_managed_stack_pc_);
Ian Rogersbdb03912011-09-14 00:55:44 -07001283 record = record->link_;
1284 }
1285}
1286
TDYa1279b2ba2e2012-03-19 10:12:32 -07001287#else // defined(ART_USE_LLVM_COMPILER) // LLVM uses ShadowFrame
1288
1289void Thread::WalkStack(StackVisitor* visitor, bool /*include_upcalls*/) const {
1290 for (ShadowFrame* cur = top_shadow_frame_; cur; cur = cur->GetLink()) {
1291 Frame frame;
1292 frame.SetSP(reinterpret_cast<Method**>(reinterpret_cast<byte*>(cur) +
1293 ShadowFrame::MethodOffset()));
Shih-wei Liao02f01fe2012-03-26 12:58:11 -07001294 bool should_continue = visitor->VisitFrame(frame, cur->GetLineNumber());
TDYa1279b2ba2e2012-03-19 10:12:32 -07001295 if (!should_continue) {
1296 return;
1297 }
1298 }
1299}
1300
1301/*
1302 * | |
1303 * | |
1304 * | |
1305 * | . |
1306 * | . |
1307 * | . |
1308 * | . |
1309 * | Method* |
1310 * | . |
1311 * | . | <-- top_shadow_frame_ (ShadowFrame*)
1312 * / +------------------------+
1313 * ->| . |
1314 * . | . |
1315 * . | . |
1316 * /+------------------------+
1317 * / | . |
1318 * / | . |
1319 * --- | | . |
1320 * | | | . |
1321 * | | Method* | <-- frame.GetSP() (Method**)
1322 * ShadowFrame \ | . |
1323 * | ->| . | <-- cur (ShadowFrame*)
1324 * --- /+------------------------+
1325 * / | . |
1326 * / | . |
1327 * --- | | . |
1328 * | cur->GetLink() | | . |
1329 * | | Method* |
1330 * ShadowFrame \ | . |
1331 * | ->| . |
1332 * --- +------------------------+
1333 * | . |
1334 * | . |
1335 * | . |
1336 * +========================+
1337 */
1338
1339#endif
1340
Elliott Hughes01158d72011-09-19 19:47:10 -07001341jobject Thread::CreateInternalStackTrace(JNIEnv* env) const {
Ian Rogersaaa20802011-09-11 21:47:37 -07001342 // Compute depth of stack
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001343 CountStackDepthVisitor count_visitor;
1344 WalkStack(&count_visitor);
1345 int32_t depth = count_visitor.GetDepth();
Elliott Hughes29f27422011-09-18 16:02:18 -07001346 int32_t skip_depth = count_visitor.GetSkipDepth();
Shih-wei Liao44175362011-08-28 16:59:17 -07001347
Ian Rogersaaa20802011-09-11 21:47:37 -07001348 // Transition into runnable state to work on Object*/Array*
Elliott Hughes01158d72011-09-19 19:47:10 -07001349 ScopedJniThreadState ts(env);
Ian Rogersaaa20802011-09-11 21:47:37 -07001350
1351 // Build internal stack trace
Ian Rogers77f74c12012-02-16 22:35:30 -08001352 BuildInternalStackTraceVisitor build_trace_visitor(skip_depth);
1353 if (!build_trace_visitor.Init(depth, ts)) {
Ian Rogers283ed0d2012-02-16 15:25:09 -08001354 return NULL; // Allocation failed
Ian Rogers283ed0d2012-02-16 15:25:09 -08001355 }
Brian Carlstrom26736442012-02-16 18:24:26 -08001356 WalkStack(&build_trace_visitor);
1357 return build_trace_visitor.GetInternalStackTrace();
Ian Rogersaaa20802011-09-11 21:47:37 -07001358}
1359
Elliott Hughes01158d72011-09-19 19:47:10 -07001360jobjectArray Thread::InternalStackTraceToStackTraceElementArray(JNIEnv* env, jobject internal,
1361 jobjectArray output_array, int* stack_depth) {
Ian Rogersaaa20802011-09-11 21:47:37 -07001362 // Transition into runnable state to work on Object*/Array*
1363 ScopedJniThreadState ts(env);
Ian Rogersaaa20802011-09-11 21:47:37 -07001364 // Decode the internal stack trace into the depth, method trace and PC trace
1365 ObjectArray<Object>* method_trace =
1366 down_cast<ObjectArray<Object>*>(Decode<Object*>(ts.Env(), internal));
Ian Rogers9074b992011-10-26 17:41:55 -07001367 int32_t depth = method_trace->GetLength() - 1;
Ian Rogersaaa20802011-09-11 21:47:37 -07001368 IntArray* pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
1369
1370 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1371
Elliott Hughes01158d72011-09-19 19:47:10 -07001372 jobjectArray result;
1373 ObjectArray<StackTraceElement>* java_traces;
1374 if (output_array != NULL) {
1375 // Reuse the array we were given.
1376 result = output_array;
1377 java_traces = reinterpret_cast<ObjectArray<StackTraceElement>*>(Decode<Array*>(env,
1378 output_array));
1379 // ...adjusting the number of frames we'll write to not exceed the array length.
1380 depth = std::min(depth, java_traces->GetLength());
1381 } else {
1382 // Create java_trace array and place in local reference table
1383 java_traces = class_linker->AllocStackTraceElementArray(depth);
Elliott Hughes30646832011-10-13 16:59:46 -07001384 if (java_traces == NULL) {
1385 return NULL;
1386 }
Elliott Hughes01158d72011-09-19 19:47:10 -07001387 result = AddLocalReference<jobjectArray>(ts.Env(), java_traces);
1388 }
1389
1390 if (stack_depth != NULL) {
1391 *stack_depth = depth;
1392 }
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001393
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001394 MethodHelper mh;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001395 for (int32_t i = 0; i < depth; ++i) {
Ian Rogersaaa20802011-09-11 21:47:37 -07001396 // Prepare parameters for StackTraceElement(String cls, String method, String file, int line)
1397 Method* method = down_cast<Method*>(method_trace->Get(i));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001398 mh.ChangeMethod(method);
Ian Rogersaaa20802011-09-11 21:47:37 -07001399 uint32_t native_pc = pc_trace->Get(i);
Shih-wei Liao02f01fe2012-03-26 12:58:11 -07001400#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001401 int32_t line_number = mh.GetLineNumFromNativePC(native_pc);
Shih-wei Liao02f01fe2012-03-26 12:58:11 -07001402#else
1403 int32_t line_number = native_pc; // LLVM stored line_number in the ShadowFrame
1404#endif
Ian Rogersaaa20802011-09-11 21:47:37 -07001405 // Allocate element, potentially triggering GC
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001406 // TODO: reuse class_name_object via Class::name_?
Ian Rogers48601312011-12-07 16:45:19 -08001407 const char* descriptor = mh.GetDeclaringClassDescriptor();
1408 CHECK(descriptor != NULL);
1409 std::string class_name(PrettyDescriptor(descriptor));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001410 SirtRef<String> class_name_object(String::AllocFromModifiedUtf8(class_name.c_str()));
1411 if (class_name_object.get() == NULL) {
1412 return NULL;
1413 }
Ian Rogers48601312011-12-07 16:45:19 -08001414 const char* method_name = mh.GetName();
1415 CHECK(method_name != NULL);
1416 SirtRef<String> method_name_object(String::AllocFromModifiedUtf8(method_name));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001417 if (method_name_object.get() == NULL) {
1418 return NULL;
1419 }
Ian Rogers48601312011-12-07 16:45:19 -08001420 const char* source_file = mh.GetDeclaringClassSourceFile();
1421 SirtRef<String> source_name_object(String::AllocFromModifiedUtf8(source_file));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001422 StackTraceElement* obj = StackTraceElement::Alloc(class_name_object.get(),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001423 method_name_object.get(),
1424 source_name_object.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001425 line_number);
Elliott Hughes30646832011-10-13 16:59:46 -07001426 if (obj == NULL) {
1427 return NULL;
1428 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001429#ifdef MOVING_GARBAGE_COLLECTOR
1430 // Re-read after potential GC
1431 java_traces = Decode<ObjectArray<Object>*>(ts.Env(), result);
1432 method_trace = down_cast<ObjectArray<Object>*>(Decode<Object*>(ts.Env(), internal));
1433 pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
1434#endif
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001435 java_traces->Set(i, obj);
1436 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001437 return result;
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001438}
1439
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001440void Thread::ThrowNewExceptionF(const char* exception_class_descriptor, const char* fmt, ...) {
Elliott Hughesa5b897e2011-08-16 11:33:06 -07001441 va_list args;
1442 va_start(args, fmt);
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001443 ThrowNewExceptionV(exception_class_descriptor, fmt, args);
Elliott Hughesa5b897e2011-08-16 11:33:06 -07001444 va_end(args);
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001445}
1446
1447void Thread::ThrowNewExceptionV(const char* exception_class_descriptor, const char* fmt, va_list ap) {
1448 std::string msg;
1449 StringAppendV(&msg, fmt, ap);
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001450 ThrowNewException(exception_class_descriptor, msg.c_str());
1451}
Elliott Hughes37f7a402011-08-22 18:56:01 -07001452
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001453void Thread::ThrowNewException(const char* exception_class_descriptor, const char* msg) {
Elliott Hughese5b0dc82011-08-23 09:59:02 -07001454 // Convert "Ljava/lang/Exception;" into JNI-style "java/lang/Exception".
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001455 CHECK_EQ('L', exception_class_descriptor[0]);
Elliott Hughese5b0dc82011-08-23 09:59:02 -07001456 std::string descriptor(exception_class_descriptor + 1);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001457 CHECK_EQ(';', descriptor[descriptor.length() - 1]);
Elliott Hughese5b0dc82011-08-23 09:59:02 -07001458 descriptor.erase(descriptor.length() - 1);
1459
1460 JNIEnv* env = GetJniEnv();
Elliott Hughes726079d2011-10-07 18:43:44 -07001461 ScopedLocalRef<jclass> exception_class(env, env->FindClass(descriptor.c_str()));
Elliott Hughes30646832011-10-13 16:59:46 -07001462 if (exception_class.get() == NULL) {
1463 LOG(ERROR) << "Couldn't throw new " << descriptor << " because JNI FindClass failed: "
1464 << PrettyTypeOf(GetException());
1465 CHECK(IsExceptionPending());
1466 return;
1467 }
Brian Carlstromebd1fd22011-12-07 15:46:26 -08001468 if (!Runtime::Current()->IsStarted()) {
1469 // Something is trying to throw an exception without a started
1470 // runtime, which is the common case in the compiler. We won't be
1471 // able to invoke the constructor of the exception, so use
1472 // AllocObject which will not invoke a constructor.
1473 ScopedLocalRef<jthrowable> exception(
1474 env, reinterpret_cast<jthrowable>(env->AllocObject(exception_class.get())));
1475 if (exception.get() != NULL) {
1476 ScopedJniThreadState ts(env);
1477 Throwable* t = reinterpret_cast<Throwable*>(ts.Self()->DecodeJObject(exception.get()));
Ian Rogers02fbef02012-01-31 22:15:33 -08001478 t->SetDetailMessage(String::AllocFromModifiedUtf8(msg));
Brian Carlstromebd1fd22011-12-07 15:46:26 -08001479 ts.Self()->SetException(t);
1480 } else {
1481 LOG(ERROR) << "Couldn't throw new " << descriptor << " because JNI AllocObject failed: "
1482 << PrettyTypeOf(GetException());
1483 CHECK(IsExceptionPending());
1484 }
1485 return;
1486 }
Elliott Hughes726079d2011-10-07 18:43:44 -07001487 int rc = env->ThrowNew(exception_class.get(), msg);
Elliott Hughes30646832011-10-13 16:59:46 -07001488 if (rc != JNI_OK) {
1489 LOG(ERROR) << "Couldn't throw new " << descriptor << " because JNI ThrowNew failed: "
1490 << PrettyTypeOf(GetException());
1491 CHECK(IsExceptionPending());
Elliott Hughes30646832011-10-13 16:59:46 -07001492 }
Elliott Hughesa5b897e2011-08-16 11:33:06 -07001493}
1494
Elliott Hughes2ced6a52011-10-16 18:44:48 -07001495void Thread::ThrowOutOfMemoryError(const char* msg) {
1496 LOG(ERROR) << StringPrintf("Throwing OutOfMemoryError \"%s\"%s",
1497 msg, (throwing_OutOfMemoryError_ ? " (recursive case)" : ""));
Elliott Hughes726079d2011-10-07 18:43:44 -07001498 if (!throwing_OutOfMemoryError_) {
1499 throwing_OutOfMemoryError_ = true;
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001500 ThrowNewException("Ljava/lang/OutOfMemoryError;", NULL);
Elliott Hughes418dfe72011-10-06 18:56:27 -07001501 } else {
Elliott Hughes726079d2011-10-07 18:43:44 -07001502 SetException(pre_allocated_OutOfMemoryError_);
Elliott Hughes418dfe72011-10-06 18:56:27 -07001503 }
Elliott Hughes726079d2011-10-07 18:43:44 -07001504 throwing_OutOfMemoryError_ = false;
Elliott Hughes79082e32011-08-25 12:07:32 -07001505}
1506
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001507
Elliott Hughes498508c2011-10-17 14:58:22 -07001508Thread* Thread::CurrentFromGdb() {
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001509 return Thread::Current();
1510}
1511
1512void Thread::DumpFromGdb() const {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001513 std::ostringstream ss;
1514 Dump(ss);
Elliott Hughes95572412011-12-13 18:14:20 -08001515 std::string str(ss.str());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001516 // log to stderr for debugging command line processes
1517 std::cerr << str;
1518#ifdef HAVE_ANDROID_OS
1519 // log to logcat for debugging frameworks processes
1520 LOG(INFO) << str;
1521#endif
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001522}
1523
Elliott Hughes28fa76d2012-04-09 17:31:46 -07001524void Thread::DumpThreadOffset(std::ostream& os, uint32_t offset, size_t size_of_pointers) {
1525 CHECK_EQ(size_of_pointers, 4U); // TODO: support 64-bit targets.
Elliott Hughes3d71d072012-04-10 18:28:35 -07001526#define DO_THREAD_OFFSET(x) if (offset == static_cast<uint32_t>(OFFSETOF_VOLATILE_MEMBER(Thread, x))) { os << # x; } else
Elliott Hughes28fa76d2012-04-09 17:31:46 -07001527#define DO_THREAD_ENTRY_POINT_OFFSET(x) if (offset == ENTRYPOINT_OFFSET(x)) { os << # x; } else
1528 DO_THREAD_OFFSET(card_table_)
1529 DO_THREAD_OFFSET(exception_)
1530 DO_THREAD_OFFSET(jni_env_)
1531 DO_THREAD_OFFSET(self_)
1532 DO_THREAD_OFFSET(stack_end_)
Elliott Hughes3d71d072012-04-10 18:28:35 -07001533 DO_THREAD_OFFSET(state_)
Elliott Hughes28fa76d2012-04-09 17:31:46 -07001534 DO_THREAD_OFFSET(suspend_count_)
1535 DO_THREAD_OFFSET(thin_lock_id_)
1536 DO_THREAD_OFFSET(top_of_managed_stack_)
1537 DO_THREAD_OFFSET(top_of_managed_stack_pc_)
1538 DO_THREAD_OFFSET(top_sirt_)
1539 DO_THREAD_ENTRY_POINT_OFFSET(pAllocArrayFromCode)
1540 DO_THREAD_ENTRY_POINT_OFFSET(pAllocArrayFromCodeWithAccessCheck)
1541 DO_THREAD_ENTRY_POINT_OFFSET(pAllocObjectFromCode)
1542 DO_THREAD_ENTRY_POINT_OFFSET(pAllocObjectFromCodeWithAccessCheck)
1543 DO_THREAD_ENTRY_POINT_OFFSET(pCheckAndAllocArrayFromCode)
1544 DO_THREAD_ENTRY_POINT_OFFSET(pCheckAndAllocArrayFromCodeWithAccessCheck)
1545 DO_THREAD_ENTRY_POINT_OFFSET(pInstanceofNonTrivialFromCode)
1546 DO_THREAD_ENTRY_POINT_OFFSET(pCanPutArrayElementFromCode)
1547 DO_THREAD_ENTRY_POINT_OFFSET(pCheckCastFromCode)
1548 DO_THREAD_ENTRY_POINT_OFFSET(pDebugMe)
1549 DO_THREAD_ENTRY_POINT_OFFSET(pUpdateDebuggerFromCode)
1550 DO_THREAD_ENTRY_POINT_OFFSET(pInitializeStaticStorage)
1551 DO_THREAD_ENTRY_POINT_OFFSET(pInitializeTypeAndVerifyAccessFromCode)
1552 DO_THREAD_ENTRY_POINT_OFFSET(pInitializeTypeFromCode)
1553 DO_THREAD_ENTRY_POINT_OFFSET(pResolveStringFromCode)
1554 DO_THREAD_ENTRY_POINT_OFFSET(pSet32Instance)
1555 DO_THREAD_ENTRY_POINT_OFFSET(pSet32Static)
1556 DO_THREAD_ENTRY_POINT_OFFSET(pSet64Instance)
1557 DO_THREAD_ENTRY_POINT_OFFSET(pSet64Static)
1558 DO_THREAD_ENTRY_POINT_OFFSET(pSetObjInstance)
1559 DO_THREAD_ENTRY_POINT_OFFSET(pSetObjStatic)
1560 DO_THREAD_ENTRY_POINT_OFFSET(pGet32Instance)
1561 DO_THREAD_ENTRY_POINT_OFFSET(pGet32Static)
1562 DO_THREAD_ENTRY_POINT_OFFSET(pGet64Instance)
1563 DO_THREAD_ENTRY_POINT_OFFSET(pGet64Static)
1564 DO_THREAD_ENTRY_POINT_OFFSET(pGetObjInstance)
1565 DO_THREAD_ENTRY_POINT_OFFSET(pGetObjStatic)
1566 DO_THREAD_ENTRY_POINT_OFFSET(pHandleFillArrayDataFromCode)
1567 DO_THREAD_ENTRY_POINT_OFFSET(pDecodeJObjectInThread)
1568 DO_THREAD_ENTRY_POINT_OFFSET(pFindNativeMethod)
1569 DO_THREAD_ENTRY_POINT_OFFSET(pLockObjectFromCode)
1570 DO_THREAD_ENTRY_POINT_OFFSET(pUnlockObjectFromCode)
1571 DO_THREAD_ENTRY_POINT_OFFSET(pCmpgDouble)
1572 DO_THREAD_ENTRY_POINT_OFFSET(pCmpgFloat)
1573 DO_THREAD_ENTRY_POINT_OFFSET(pCmplDouble)
1574 DO_THREAD_ENTRY_POINT_OFFSET(pCmplFloat)
1575 DO_THREAD_ENTRY_POINT_OFFSET(pDadd)
1576 DO_THREAD_ENTRY_POINT_OFFSET(pDdiv)
1577 DO_THREAD_ENTRY_POINT_OFFSET(pDmul)
1578 DO_THREAD_ENTRY_POINT_OFFSET(pDsub)
1579 DO_THREAD_ENTRY_POINT_OFFSET(pF2d)
1580 DO_THREAD_ENTRY_POINT_OFFSET(pFmod)
1581 DO_THREAD_ENTRY_POINT_OFFSET(pI2d)
1582 DO_THREAD_ENTRY_POINT_OFFSET(pL2d)
1583 DO_THREAD_ENTRY_POINT_OFFSET(pD2f)
1584 DO_THREAD_ENTRY_POINT_OFFSET(pFadd)
1585 DO_THREAD_ENTRY_POINT_OFFSET(pFdiv)
1586 DO_THREAD_ENTRY_POINT_OFFSET(pFmodf)
1587 DO_THREAD_ENTRY_POINT_OFFSET(pFmul)
1588 DO_THREAD_ENTRY_POINT_OFFSET(pFsub)
1589 DO_THREAD_ENTRY_POINT_OFFSET(pI2f)
1590 DO_THREAD_ENTRY_POINT_OFFSET(pL2f)
1591 DO_THREAD_ENTRY_POINT_OFFSET(pD2iz)
1592 DO_THREAD_ENTRY_POINT_OFFSET(pF2iz)
1593 DO_THREAD_ENTRY_POINT_OFFSET(pIdiv)
1594 DO_THREAD_ENTRY_POINT_OFFSET(pIdivmod)
1595 DO_THREAD_ENTRY_POINT_OFFSET(pD2l)
1596 DO_THREAD_ENTRY_POINT_OFFSET(pF2l)
1597 DO_THREAD_ENTRY_POINT_OFFSET(pLdiv)
1598 DO_THREAD_ENTRY_POINT_OFFSET(pLdivmod)
1599 DO_THREAD_ENTRY_POINT_OFFSET(pLmul)
1600 DO_THREAD_ENTRY_POINT_OFFSET(pShlLong)
1601 DO_THREAD_ENTRY_POINT_OFFSET(pShrLong)
1602 DO_THREAD_ENTRY_POINT_OFFSET(pUshrLong)
1603 DO_THREAD_ENTRY_POINT_OFFSET(pIndexOf)
1604 DO_THREAD_ENTRY_POINT_OFFSET(pMemcmp16)
1605 DO_THREAD_ENTRY_POINT_OFFSET(pStringCompareTo)
1606 DO_THREAD_ENTRY_POINT_OFFSET(pMemcpy)
1607 DO_THREAD_ENTRY_POINT_OFFSET(pFindInterfaceMethodInCache)
1608 DO_THREAD_ENTRY_POINT_OFFSET(pUnresolvedDirectMethodTrampolineFromCode)
1609 DO_THREAD_ENTRY_POINT_OFFSET(pInvokeDirectTrampolineWithAccessCheck)
1610 DO_THREAD_ENTRY_POINT_OFFSET(pInvokeInterfaceTrampoline)
1611 DO_THREAD_ENTRY_POINT_OFFSET(pInvokeInterfaceTrampolineWithAccessCheck)
1612 DO_THREAD_ENTRY_POINT_OFFSET(pInvokeStaticTrampolineWithAccessCheck)
1613 DO_THREAD_ENTRY_POINT_OFFSET(pInvokeSuperTrampolineWithAccessCheck)
1614 DO_THREAD_ENTRY_POINT_OFFSET(pInvokeVirtualTrampolineWithAccessCheck)
1615 DO_THREAD_ENTRY_POINT_OFFSET(pCheckSuspendFromCode)
1616 DO_THREAD_ENTRY_POINT_OFFSET(pTestSuspendFromCode)
1617 DO_THREAD_ENTRY_POINT_OFFSET(pDeliverException)
1618 DO_THREAD_ENTRY_POINT_OFFSET(pThrowAbstractMethodErrorFromCode)
1619 DO_THREAD_ENTRY_POINT_OFFSET(pThrowArrayBoundsFromCode)
1620 DO_THREAD_ENTRY_POINT_OFFSET(pThrowDivZeroFromCode)
1621 DO_THREAD_ENTRY_POINT_OFFSET(pThrowNoSuchMethodFromCode)
1622 DO_THREAD_ENTRY_POINT_OFFSET(pThrowNullPointerFromCode)
1623 DO_THREAD_ENTRY_POINT_OFFSET(pThrowStackOverflowFromCode)
1624 DO_THREAD_ENTRY_POINT_OFFSET(pThrowVerificationErrorFromCode)
1625 {
1626 os << offset;
1627 }
1628#undef DO_THREAD_OFFSET
1629#undef DO_THREAD_ENTRY_POINT_OFFSET
1630}
1631
Ian Rogersbdb03912011-09-14 00:55:44 -07001632class CatchBlockStackVisitor : public Thread::StackVisitor {
1633 public:
1634 CatchBlockStackVisitor(Class* to_find, Context* ljc)
Ian Rogers57b86d42012-03-27 16:05:41 -07001635 : to_find_(to_find), long_jump_context_(ljc), native_method_count_(0),
1636 method_tracing_active_(Runtime::Current()->IsMethodTracingActive()) {
Ian Rogers67375ac2011-09-14 00:55:44 -07001637#ifndef NDEBUG
1638 handler_pc_ = 0xEBADC0DE;
1639 handler_frame_.SetSP(reinterpret_cast<Method**>(0xEBADF00D));
1640#endif
1641 }
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001642
Elliott Hughes530fa002012-03-12 11:44:49 -07001643 bool VisitFrame(const Frame& fr, uintptr_t pc) {
1644 Method* method = fr.GetMethod();
1645 if (method == NULL) {
1646 // This is the upcall, we remember the frame and last_pc so that we may
1647 // long jump to them
1648 handler_pc_ = DemanglePc(pc);
1649 handler_frame_ = fr;
Ian Rogers57b86d42012-03-27 16:05:41 -07001650 return false; // End stack walk.
Elliott Hughes530fa002012-03-12 11:44:49 -07001651 }
1652 uint32_t dex_pc = DexFile::kDexNoIndex;
Ian Rogers57b86d42012-03-27 16:05:41 -07001653 if (method->IsRuntimeMethod()) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001654 // ignore callee save method
Ian Rogers57b86d42012-03-27 16:05:41 -07001655 DCHECK(method->IsCalleeSaveMethod());
Elliott Hughes530fa002012-03-12 11:44:49 -07001656 } else if (method->IsNative()) {
1657 native_method_count_++;
1658 } else {
jeffhao0791adc2012-04-04 11:14:32 -07001659 // Unwind stack when an exception occurs during method tracing
Ian Rogers57b86d42012-03-27 16:05:41 -07001660 if (UNLIKELY(method_tracing_active_)) {
Ian Rogers776ac1f2012-04-13 23:36:36 -07001661#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogers57b86d42012-03-27 16:05:41 -07001662 if (IsTraceExitPc(DemanglePc(pc))) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001663 pc = ManglePc(TraceMethodUnwindFromCode(Thread::Current()));
1664 }
Ian Rogers776ac1f2012-04-13 23:36:36 -07001665#else
1666 UNIMPLEMENTED(FATAL);
1667#endif
Ian Rogers67375ac2011-09-14 00:55:44 -07001668 }
Elliott Hughes530fa002012-03-12 11:44:49 -07001669 dex_pc = method->ToDexPC(pc);
1670 }
1671 if (dex_pc != DexFile::kDexNoIndex) {
1672 uint32_t found_dex_pc = method->FindCatchBlock(to_find_, dex_pc);
1673 if (found_dex_pc != DexFile::kDexNoIndex) {
1674 handler_pc_ = method->ToNativePC(found_dex_pc);
1675 handler_frame_ = fr;
Ian Rogers57b86d42012-03-27 16:05:41 -07001676 return false; // End stack walk.
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001677 }
1678 }
Ian Rogers776ac1f2012-04-13 23:36:36 -07001679#if !defined(ART_USE_LLVM_COMPILER)
Elliott Hughes530fa002012-03-12 11:44:49 -07001680 // Caller may be handler, fill in callee saves in context
1681 long_jump_context_->FillCalleeSaves(fr);
Ian Rogers776ac1f2012-04-13 23:36:36 -07001682#endif
Ian Rogers57b86d42012-03-27 16:05:41 -07001683 return true; // Continue stack walk.
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001684 }
Ian Rogersbdb03912011-09-14 00:55:44 -07001685
Ian Rogersbdb03912011-09-14 00:55:44 -07001686 // The type of the exception catch block to find
1687 Class* to_find_;
1688 // Frame with found handler or last frame if no handler found
1689 Frame handler_frame_;
Ian Rogers67375ac2011-09-14 00:55:44 -07001690 // PC to branch to for the handler
1691 uintptr_t handler_pc_;
Ian Rogersbdb03912011-09-14 00:55:44 -07001692 // Context that will be the target of the long jump
1693 Context* long_jump_context_;
Ian Rogers67375ac2011-09-14 00:55:44 -07001694 // Number of native methods passed in crawl (equates to number of SIRTs to pop)
1695 uint32_t native_method_count_;
Ian Rogers57b86d42012-03-27 16:05:41 -07001696 // Is method tracing active?
1697 const bool method_tracing_active_;
Ian Rogersbdb03912011-09-14 00:55:44 -07001698};
1699
Ian Rogersff1ed472011-09-20 13:46:24 -07001700void Thread::DeliverException() {
Ian Rogers776ac1f2012-04-13 23:36:36 -07001701#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogers28ad40d2011-10-27 15:19:26 -07001702 const bool kDebugExceptionDelivery = false;
Elliott Hughesd07986f2011-12-06 18:27:45 -08001703 Throwable* exception = GetException(); // Get exception from thread
Ian Rogersff1ed472011-09-20 13:46:24 -07001704 CHECK(exception != NULL);
Ian Rogers28ad40d2011-10-27 15:19:26 -07001705 // Don't leave exception visible while we try to find the handler, which may cause class
Elliott Hughesd07986f2011-12-06 18:27:45 -08001706 // resolution.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001707 ClearException();
1708 if (kDebugExceptionDelivery) {
Ian Rogersa32a6fd2012-02-06 20:18:44 -08001709 String* msg = exception->GetDetailMessage();
1710 std::string str_msg(msg != NULL ? msg->ToModifiedUtf8() : "");
1711 DumpStack(LOG(INFO) << "Delivering exception: " << PrettyTypeOf(exception)
1712 << ": " << str_msg << std::endl);
Ian Rogers28ad40d2011-10-27 15:19:26 -07001713 }
Ian Rogersbdb03912011-09-14 00:55:44 -07001714
1715 Context* long_jump_context = GetLongJumpContext();
1716 CatchBlockStackVisitor catch_finder(exception->GetClass(), long_jump_context);
Elliott Hughes530fa002012-03-12 11:44:49 -07001717 WalkStack(&catch_finder, true);
Ian Rogersbdb03912011-09-14 00:55:44 -07001718
Elliott Hughesd07986f2011-12-06 18:27:45 -08001719 Method** sp;
1720 uintptr_t throw_native_pc;
1721 Method* throw_method = GetCurrentMethod(&throw_native_pc, &sp);
1722 uintptr_t catch_native_pc = catch_finder.handler_pc_;
1723 Method* catch_method = catch_finder.handler_frame_.GetMethod();
1724 Dbg::PostException(sp, throw_method, throw_native_pc, catch_method, catch_native_pc, exception);
1725
Ian Rogers28ad40d2011-10-27 15:19:26 -07001726 if (kDebugExceptionDelivery) {
Elliott Hughesd07986f2011-12-06 18:27:45 -08001727 if (catch_method == NULL) {
Ian Rogers28ad40d2011-10-27 15:19:26 -07001728 LOG(INFO) << "Handler is upcall";
1729 } else {
1730 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1731 const DexFile& dex_file =
Elliott Hughesd07986f2011-12-06 18:27:45 -08001732 class_linker->FindDexFile(catch_method->GetDeclaringClass()->GetDexCache());
1733 int line_number = dex_file.GetLineNumFromPC(catch_method,
1734 catch_method->ToDexPC(catch_finder.handler_pc_));
1735 LOG(INFO) << "Handler: " << PrettyMethod(catch_method) << " (line: " << line_number << ")";
Ian Rogers28ad40d2011-10-27 15:19:26 -07001736 }
1737 }
1738 SetException(exception);
Ian Rogers9a8a8882012-03-08 02:30:55 -08001739 CHECK_NE(catch_native_pc, 0u);
Elliott Hughesd07986f2011-12-06 18:27:45 -08001740 long_jump_context->SetSP(reinterpret_cast<uintptr_t>(catch_finder.handler_frame_.GetSP()));
Ian Rogers9a8a8882012-03-08 02:30:55 -08001741 long_jump_context->SetPC(catch_native_pc);
Elliott Hughes9c750f92012-04-05 12:07:59 -07001742 long_jump_context->SmashCallerSaves();
Ian Rogersbdb03912011-09-14 00:55:44 -07001743 long_jump_context->DoLongJump();
Ian Rogers776ac1f2012-04-13 23:36:36 -07001744#endif
Ian Rogers9a8a8882012-03-08 02:30:55 -08001745 LOG(FATAL) << "UNREACHABLE";
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001746}
1747
Ian Rogersbdb03912011-09-14 00:55:44 -07001748Context* Thread::GetLongJumpContext() {
Elliott Hughes85d15452011-09-16 17:33:01 -07001749 Context* result = long_jump_context_;
Ian Rogers776ac1f2012-04-13 23:36:36 -07001750#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogersbdb03912011-09-14 00:55:44 -07001751 if (result == NULL) {
1752 result = Context::Create();
Elliott Hughes85d15452011-09-16 17:33:01 -07001753 long_jump_context_ = result;
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001754 }
Ian Rogers776ac1f2012-04-13 23:36:36 -07001755#endif
Ian Rogersbdb03912011-09-14 00:55:44 -07001756 return result;
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001757}
1758
TDYa127ee0d3fb2012-04-01 14:55:33 -07001759#if !defined(ART_USE_LLVM_COMPILER)
Elliott Hughesd07986f2011-12-06 18:27:45 -08001760Method* Thread::GetCurrentMethod(uintptr_t* pc, Method*** sp) const {
1761 Frame f = top_of_managed_stack_;
1762 Method* m = f.GetMethod();
Elliott Hughes8be2d402012-02-23 14:22:41 -08001763 uintptr_t native_pc = top_of_managed_stack_pc_;
1764
Elliott Hughes9fd66f52011-10-16 12:13:26 -07001765 // We use JNI internally for exception throwing, so it's possible to arrive
1766 // here via a "FromCode" function, in which case there's a synthetic
1767 // callee-save method at the top of the stack. These shouldn't be user-visible,
1768 // so if we find one, skip it and return the compiled method underneath.
jeffhao33dc7712011-11-09 17:54:24 -08001769 if (m != NULL && m->IsCalleeSaveMethod()) {
Elliott Hughes8be2d402012-02-23 14:22:41 -08001770 native_pc = f.GetReturnPC();
Elliott Hughes9fd66f52011-10-16 12:13:26 -07001771 f.Next();
1772 m = f.GetMethod();
1773 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08001774 if (pc != NULL) {
Elliott Hughes8be2d402012-02-23 14:22:41 -08001775 *pc = (m != NULL) ? ManglePc(native_pc) : 0;
jeffhao33dc7712011-11-09 17:54:24 -08001776 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08001777 if (sp != NULL) {
1778 *sp = f.GetSP();
1779 }
1780 return m;
jeffhao33dc7712011-11-09 17:54:24 -08001781}
TDYa127ee0d3fb2012-04-01 14:55:33 -07001782#else
1783Method* Thread::GetCurrentMethod(uintptr_t*, Method***) const {
1784 ShadowFrame* frame = top_shadow_frame_;
TDYa12720efe542012-04-03 17:40:49 -07001785 if (frame == NULL) {
1786 return NULL;
TDYa127ee0d3fb2012-04-01 14:55:33 -07001787 }
1788 return frame->GetMethod();
1789}
1790#endif
jeffhao33dc7712011-11-09 17:54:24 -08001791
Elliott Hughes5f791332011-09-15 17:45:30 -07001792bool Thread::HoldsLock(Object* object) {
1793 if (object == NULL) {
1794 return false;
1795 }
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07001796 return object->GetThinLockId() == thin_lock_id_;
Elliott Hughes5f791332011-09-15 17:45:30 -07001797}
1798
Elliott Hughes038a8062011-09-18 14:12:41 -07001799bool Thread::IsDaemon() {
1800 return gThread_daemon->GetBoolean(peer_);
1801}
1802
Ian Rogers776ac1f2012-04-13 23:36:36 -07001803#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogersd6b1f612011-09-27 13:38:14 -07001804class ReferenceMapVisitor : public Thread::StackVisitor {
1805 public:
1806 ReferenceMapVisitor(Context* context, Heap::RootVisitor* root_visitor, void* arg) :
1807 context_(context), root_visitor_(root_visitor), arg_(arg) {
1808 }
1809
Elliott Hughes530fa002012-03-12 11:44:49 -07001810 bool VisitFrame(const Frame& frame, uintptr_t pc) {
Ian Rogersd6b1f612011-09-27 13:38:14 -07001811 Method* m = frame.GetMethod();
Brian Carlstrom6a4be3a2011-10-20 16:34:03 -07001812 if (false) {
jeffhao25045522012-03-13 19:34:37 -07001813 LOG(INFO) << "Visiting stack roots in " << PrettyMethod(m)
Brian Carlstrom0dd7dda2011-10-25 15:47:53 -07001814 << StringPrintf("@ PC:%04x", m->ToDexPC(pc));
Brian Carlstrom6a4be3a2011-10-20 16:34:03 -07001815 }
Ian Rogersd6b1f612011-09-27 13:38:14 -07001816 // Process register map (which native and callee save methods don't have)
Ian Rogers3891c772011-12-06 15:38:28 -08001817 if (!m->IsNative() && !m->IsCalleeSaveMethod() && !m->IsProxyMethod()) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08001818 CHECK(m->GetGcMap() != NULL) << PrettyMethod(m);
1819 CHECK_NE(0U, m->GetGcMapLength()) << PrettyMethod(m);
1820 verifier::PcToReferenceMap map(m->GetGcMap(), m->GetGcMapLength());
Ian Rogersd81871c2011-10-03 13:57:23 -07001821 const uint8_t* reg_bitmap = map.FindBitMap(m->ToDexPC(pc));
Ian Rogersd6b1f612011-09-27 13:38:14 -07001822 CHECK(reg_bitmap != NULL);
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001823 const VmapTable vmap_table(m->GetVmapTableRaw());
Elliott Hughes11d1b0c2012-01-23 16:57:47 -08001824 const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001825 DCHECK(code_item != NULL); // can't be NULL or how would we compile its instructions?
1826 uint32_t core_spills = m->GetCoreSpillMask();
1827 uint32_t fp_spills = m->GetFpSpillMask();
1828 size_t frame_size = m->GetFrameSizeInBytes();
Brian Carlstrom0dd7dda2011-10-25 15:47:53 -07001829 // For all dex registers in the bitmap
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001830 size_t num_regs = std::min(map.RegWidth() * 8,
1831 static_cast<size_t>(code_item->registers_size_));
Brian Carlstrom0dd7dda2011-10-25 15:47:53 -07001832 for (size_t reg = 0; reg < num_regs; ++reg) {
Ian Rogersd6b1f612011-09-27 13:38:14 -07001833 // Does this register hold a reference?
1834 if (TestBitmap(reg, reg_bitmap)) {
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001835 uint32_t vmap_offset;
Ian Rogersd6b1f612011-09-27 13:38:14 -07001836 Object* ref;
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001837 if (vmap_table.IsInContext(reg, vmap_offset)) {
Ian Rogersd6b1f612011-09-27 13:38:14 -07001838 // Compute the register we need to load from the context
1839 uint32_t spill_mask = m->GetCoreSpillMask();
Brian Carlstrom0dd7dda2011-10-25 15:47:53 -07001840 CHECK_LT(vmap_offset, static_cast<uint32_t>(__builtin_popcount(spill_mask)));
Ian Rogersf57c47c2011-10-06 00:06:17 -07001841 uint32_t matches = 0;
1842 uint32_t spill_shifts = 0;
1843 while (matches != (vmap_offset + 1)) {
Brian Carlstrom0dd7dda2011-10-25 15:47:53 -07001844 DCHECK_NE(spill_mask, 0u);
Ian Rogersf57c47c2011-10-06 00:06:17 -07001845 matches += spill_mask & 1; // Add 1 if the low bit is set
1846 spill_mask >>= 1;
1847 spill_shifts++;
Ian Rogersd6b1f612011-09-27 13:38:14 -07001848 }
Ian Rogersf57c47c2011-10-06 00:06:17 -07001849 spill_shifts--; // wind back one as we want the last match
1850 ref = reinterpret_cast<Object*>(context_->GetGPR(spill_shifts));
Ian Rogersd6b1f612011-09-27 13:38:14 -07001851 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001852 ref = reinterpret_cast<Object*>(frame.GetVReg(code_item, core_spills, fp_spills,
1853 frame_size, reg));
Ian Rogersd6b1f612011-09-27 13:38:14 -07001854 }
Shih-wei Liao4f894e32011-09-27 21:33:19 -07001855 if (ref != NULL) {
1856 root_visitor_(ref, arg_);
1857 }
Ian Rogersd6b1f612011-09-27 13:38:14 -07001858 }
1859 }
1860 }
1861 context_->FillCalleeSaves(frame);
Elliott Hughes530fa002012-03-12 11:44:49 -07001862 return true;
Ian Rogersd6b1f612011-09-27 13:38:14 -07001863 }
1864
1865 private:
1866 bool TestBitmap(int reg, const uint8_t* reg_vector) {
1867 return ((reg_vector[reg / 8] >> (reg % 8)) & 0x01) != 0;
1868 }
1869
1870 // Context used to build up picture of callee saves
1871 Context* context_;
1872 // Call-back when we visit a root
1873 Heap::RootVisitor* root_visitor_;
1874 // Argument to call-back
1875 void* arg_;
1876};
Ian Rogers776ac1f2012-04-13 23:36:36 -07001877#endif
Ian Rogersd6b1f612011-09-27 13:38:14 -07001878
1879void Thread::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
Elliott Hughesd369bb72011-09-12 14:41:14 -07001880 if (exception_ != NULL) {
1881 visitor(exception_, arg);
1882 }
1883 if (peer_ != NULL) {
1884 visitor(peer_, arg);
1885 }
Elliott Hughes726079d2011-10-07 18:43:44 -07001886 if (pre_allocated_OutOfMemoryError_ != NULL) {
1887 visitor(pre_allocated_OutOfMemoryError_, arg);
1888 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001889 if (class_loader_override_ != NULL) {
1890 visitor(class_loader_override_, arg);
1891 }
Elliott Hughes410c0c82011-09-01 17:58:25 -07001892 jni_env_->locals.VisitRoots(visitor, arg);
1893 jni_env_->monitors.VisitRoots(visitor, arg);
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -07001894
1895 SirtVisitRoots(visitor, arg);
Logan Chienf7ad17e2012-03-15 03:10:03 +08001896 ShadowFrameVisitRoots(visitor, arg);
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -07001897
TDYa127540a5b72012-04-03 18:56:08 -07001898#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogersd6b1f612011-09-27 13:38:14 -07001899 // Cheat and steal the long jump context. Assume that we are not doing a GC during exception
1900 // delivery.
1901 Context* context = GetLongJumpContext();
1902 // Visit roots on this thread's stack
1903 ReferenceMapVisitor mapper(context, visitor, arg);
1904 WalkStack(&mapper);
TDYa127540a5b72012-04-03 18:56:08 -07001905#endif
Elliott Hughes410c0c82011-09-01 17:58:25 -07001906}
1907
jeffhao25045522012-03-13 19:34:37 -07001908#if VERIFY_OBJECT_ENABLED
Elliott Hughesab7b9dc2012-03-27 13:16:29 -07001909static void VerifyObject(const Object* obj, void*) {
jeffhao25045522012-03-13 19:34:37 -07001910 Runtime::Current()->GetHeap()->VerifyObject(obj);
1911}
1912
1913void Thread::VerifyStack() {
TDYa127540a5b72012-04-03 18:56:08 -07001914#if !defined(ART_USE_LLVM_COMPILER)
jeffhaoe66ac792012-03-19 16:08:46 -07001915 UniquePtr<Context> context(Context::Create());
1916 ReferenceMapVisitor mapper(context.get(), VerifyObject, NULL);
jeffhao25045522012-03-13 19:34:37 -07001917 WalkStack(&mapper);
TDYa127540a5b72012-04-03 18:56:08 -07001918#endif
jeffhao25045522012-03-13 19:34:37 -07001919}
1920#endif
1921
Elliott Hughes330304d2011-08-12 14:28:05 -07001922std::ostream& operator<<(std::ostream& os, const Thread& thread) {
Elliott Hughes899e7892012-01-24 14:57:32 -08001923 thread.Dump(os, false);
Elliott Hughes330304d2011-08-12 14:28:05 -07001924 return os;
1925}
1926
Elliott Hughesa4060e52012-03-02 16:51:35 -08001927void Thread::CheckSafeToLockOrUnlock(MutexRank rank, bool is_locking) {
Elliott Hughes17057b12012-04-03 10:22:39 -07001928 if (this == NULL) {
1929 CHECK(Runtime::Current()->IsShuttingDown());
1930 return;
1931 }
Elliott Hughesffb465f2012-03-01 18:46:05 -08001932 if (is_locking) {
1933 if (held_mutexes_[rank] == 0) {
1934 bool bad_mutexes_held = false;
1935 for (int i = kMaxMutexRank; i > rank; --i) {
1936 if (held_mutexes_[i] != 0) {
1937 LOG(ERROR) << "holding " << static_cast<MutexRank>(i) << " while " << (is_locking ? "locking" : "unlocking") << " " << rank;
1938 bad_mutexes_held = true;
1939 }
1940 }
Elliott Hughesb5db3bb2012-03-29 20:00:31 -07001941 CHECK(!bad_mutexes_held) << rank;
Elliott Hughesffb465f2012-03-01 18:46:05 -08001942 }
1943 ++held_mutexes_[rank];
1944 } else {
Elliott Hughesb5db3bb2012-03-29 20:00:31 -07001945 CHECK_GT(held_mutexes_[rank], 0U) << rank;
Elliott Hughesffb465f2012-03-01 18:46:05 -08001946 --held_mutexes_[rank];
1947 }
1948}
1949
Elliott Hughesa4060e52012-03-02 16:51:35 -08001950void Thread::CheckSafeToWait(MutexRank rank) {
Elliott Hughes17057b12012-04-03 10:22:39 -07001951 if (this == NULL) {
1952 CHECK(Runtime::Current()->IsShuttingDown());
1953 return;
1954 }
Elliott Hughesa4060e52012-03-02 16:51:35 -08001955 bool bad_mutexes_held = false;
1956 for (int i = kMaxMutexRank; i >= 0; --i) {
1957 if (i != rank && held_mutexes_[i] != 0) {
1958 LOG(ERROR) << "holding " << static_cast<MutexRank>(i) << " while doing condition variable wait on " << rank;
1959 bad_mutexes_held = true;
1960 }
1961 }
1962 if (held_mutexes_[rank] == 0) {
1963 LOG(ERROR) << "*not* holding " << rank << " while doing condition variable wait on it";
1964 bad_mutexes_held = true;
1965 }
1966 CHECK(!bad_mutexes_held);
1967}
1968
Elliott Hughes8daa0922011-09-11 13:46:25 -07001969} // namespace art