blob: 3bae0af0e58bd1389ab6d11568ada4b1415991fa [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>
Brian Carlstromdbf05b72011-12-15 00:55:24 -080022#include <sys/resource.h>
23#include <sys/time.h>
Elliott Hughesa0957642011-09-02 14:27:33 -070024
Carl Shapirob5573532011-07-12 18:22:59 -070025#include <algorithm>
Elliott Hughesdcc24742011-09-07 14:02:44 -070026#include <bitset>
Elliott Hugheseb4f6142011-07-15 17:43:51 -070027#include <cerrno>
Elliott Hughesa0957642011-09-02 14:27:33 -070028#include <iostream>
Carl Shapirob5573532011-07-12 18:22:59 -070029#include <list>
Carl Shapirob5573532011-07-12 18:22:59 -070030
Elliott Hughesa5b897e2011-08-16 11:33:06 -070031#include "class_linker.h"
Brian Carlstromdf143242011-10-10 18:05:34 -070032#include "class_loader.h"
Elliott Hughes46e251b2012-05-22 15:10:45 -070033#include "debugger.h"
Ian Rogers408f79a2011-08-23 18:22:33 -070034#include "heap.h"
Elliott Hughesc5f7c912011-08-18 14:00:42 -070035#include "jni_internal.h"
Elliott Hughes8e4aac52011-09-26 17:03:36 -070036#include "monitor.h"
Ian Rogers57b86d42012-03-27 16:05:41 -070037#include "oat/runtime/context.h"
Elliott Hughesa5b897e2011-08-16 11:33:06 -070038#include "object.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080039#include "object_utils.h"
Jesse Wilson9a6bae82011-11-14 14:57:30 -050040#include "reflection.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070041#include "runtime.h"
buzbee54330722011-08-23 16:46:55 -070042#include "runtime_support.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070043#include "scoped_thread_state_change.h"
Elliott Hughes46e251b2012-05-22 15:10:45 -070044#include "ScopedLocalRef.h"
Ian Rogers30fab402012-01-23 15:43:46 -080045#include "space.h"
Elliott Hughes68e76522011-10-05 13:22:16 -070046#include "stack.h"
47#include "stack_indirect_reference_table.h"
Elliott Hughes8daa0922011-09-11 13:46:25 -070048#include "thread_list.h"
Elliott Hughesa0957642011-09-02 14:27:33 -070049#include "utils.h"
Ian Rogers776ac1f2012-04-13 23:36:36 -070050#include "verifier/gc_map.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070051#include "well_known_classes.h"
Carl Shapirob5573532011-07-12 18:22:59 -070052
53namespace art {
54
55pthread_key_t Thread::pthread_key_self_;
Ian Rogers00f7d0e2012-07-19 15:28:27 -070056ConditionVariable* Thread::resume_cond_;
Carl Shapirob5573532011-07-12 18:22:59 -070057
Elliott Hughes7dc51662012-05-16 14:48:43 -070058static const char* kThreadNameDuringStartup = "<native thread without managed peer>";
59
Ian Rogers5d76c432011-10-31 21:42:49 -070060void Thread::InitCardTable() {
Elliott Hughesb3bd5f02012-03-08 21:05:27 -080061 card_table_ = Runtime::Current()->GetHeap()->GetCardTable()->GetBiasedBegin();
Ian Rogers5d76c432011-10-31 21:42:49 -070062}
63
Elliott Hughes99250ba2012-04-17 11:09:17 -070064#if !defined(__APPLE__)
Elliott Hughes3ea0f422012-04-16 17:01:43 -070065static void UnimplementedEntryPoint() {
66 UNIMPLEMENTED(FATAL);
67}
Elliott Hughes99250ba2012-04-17 11:09:17 -070068#endif
Elliott Hughes3ea0f422012-04-16 17:01:43 -070069
buzbee3ea4ec52011-08-22 17:37:19 -070070void Thread::InitFunctionPointers() {
Elliott Hughes99250ba2012-04-17 11:09:17 -070071#if !defined(__APPLE__) // The Mac GCC is too old to accept this code.
Elliott Hughes3ea0f422012-04-16 17:01:43 -070072 // Insert a placeholder so we can easily tell if we call an unimplemented entry point.
73 uintptr_t* begin = reinterpret_cast<uintptr_t*>(&entrypoints_);
74 uintptr_t* end = reinterpret_cast<uintptr_t*>(reinterpret_cast<uint8_t*>(begin) + sizeof(entrypoints_));
75 for (uintptr_t* it = begin; it != end; ++it) {
76 *it = reinterpret_cast<uintptr_t>(UnimplementedEntryPoint);
77 }
Elliott Hughes99250ba2012-04-17 11:09:17 -070078#endif
Ian Rogers57b86d42012-03-27 16:05:41 -070079 InitEntryPoints(&entrypoints_);
Elliott Hughesc0f09332012-03-26 13:27:06 -070080}
81
82void Thread::SetDebuggerUpdatesEnabled(bool enabled) {
83 LOG(INFO) << "Turning debugger updates " << (enabled ? "on" : "off") << " for " << *this;
Ian Rogers776ac1f2012-04-13 23:36:36 -070084#if !defined(ART_USE_LLVM_COMPILER)
Ian Rogers57b86d42012-03-27 16:05:41 -070085 ChangeDebuggerEntryPoint(&entrypoints_, enabled);
Ian Rogers776ac1f2012-04-13 23:36:36 -070086#else
87 UNIMPLEMENTED(FATAL);
88#endif
buzbee3ea4ec52011-08-22 17:37:19 -070089}
90
Brian Carlstromcaabb1b2011-10-11 18:09:13 -070091void Thread::InitTid() {
92 tid_ = ::art::GetTid();
93}
94
Brian Carlstromcaabb1b2011-10-11 18:09:13 -070095void Thread::InitAfterFork() {
Elliott Hughes8029cbe2012-05-22 09:13:08 -070096 // One thread (us) survived the fork, but we have a new tid so we need to
97 // update the value stashed in this Thread*.
Brian Carlstromcaabb1b2011-10-11 18:09:13 -070098 InitTid();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -070099}
100
Brian Carlstrom78128a62011-09-15 17:21:19 -0700101void* Thread::CreateCallback(void* arg) {
Elliott Hughes93e74e82011-09-13 11:07:03 -0700102 Thread* self = reinterpret_cast<Thread*>(arg);
Elliott Hughes462c9442012-03-23 18:47:50 -0700103 self->Init();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700104
Elliott Hughes47179f72011-10-27 16:44:39 -0700105 {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700106 ScopedObjectAccess soa(self);
Ian Rogers365c1022012-06-22 15:05:28 -0700107 {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700108 SirtRef<String> thread_name(self->GetThreadName(soa));
Ian Rogers365c1022012-06-22 15:05:28 -0700109 self->SetThreadName(thread_name->ToModifiedUtf8().c_str());
110 }
111
112 Dbg::PostThreadStart(self);
113
114 // Invoke the 'run' method of our java.lang.Thread.
115 CHECK(self->peer_ != NULL);
116 Object* receiver = self->peer_;
117 jmethodID mid = WellKnownClasses::java_lang_Thread_run;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700118 Method* m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
Ian Rogers365c1022012-06-22 15:05:28 -0700119 m->Invoke(self, receiver, NULL, NULL);
Elliott Hughes47179f72011-10-27 16:44:39 -0700120 }
121
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700122 // Detach and delete self.
123 Runtime::Current()->GetThreadList()->Unregister(self);
Elliott Hughes93e74e82011-09-13 11:07:03 -0700124
Carl Shapirob5573532011-07-12 18:22:59 -0700125 return NULL;
126}
127
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700128static void SetVmData(const ScopedObjectAccess& soa, Object* managed_thread,
129 Thread* native_thread)
130 SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
131 Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_vmData);
Elliott Hughesaf8d15a2012-05-29 09:12:18 -0700132 f->SetInt(managed_thread, reinterpret_cast<uintptr_t>(native_thread));
Elliott Hughes93e74e82011-09-13 11:07:03 -0700133}
134
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700135Thread* Thread::FromManagedThread(const ScopedObjectAccessUnchecked& soa, Object* thread_peer) {
136 Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_vmData);
137 Thread* result = reinterpret_cast<Thread*>(static_cast<uintptr_t>(f->GetInt(thread_peer)));
138 // Sanity check that if we have a result it is either suspended or we hold the thread_list_lock_
139 // to stop it from going away.
140 MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
141 if (result != NULL && !result->IsSuspended()) {
142 GlobalSynchronization::thread_list_lock_->AssertHeld();
143 }
144 return result;
Elliott Hughes761928d2011-11-16 18:33:03 -0800145}
146
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700147Thread* Thread::FromManagedThread(const ScopedObjectAccessUnchecked& soa, jobject java_thread) {
148 return FromManagedThread(soa, soa.Decode<Object*>(java_thread));
Elliott Hughes01158d72011-09-19 19:47:10 -0700149}
150
Elliott Hughesab7b9dc2012-03-27 13:16:29 -0700151static size_t FixStackSize(size_t stack_size) {
Elliott Hughes7502e2a2011-10-02 13:24:37 -0700152 // A stack size of zero means "use the default".
Elliott Hughesd369bb72011-09-12 14:41:14 -0700153 if (stack_size == 0) {
154 stack_size = Runtime::Current()->GetDefaultStackSize();
155 }
Carl Shapiro61e019d2011-07-14 16:53:09 -0700156
Brian Carlstrom6414a972012-04-14 14:20:04 -0700157 // Dalvik used the bionic pthread default stack size for native threads,
158 // so include that here to support apps that expect large native stacks.
159 stack_size += 1 * MB;
160
Elliott Hughes7502e2a2011-10-02 13:24:37 -0700161 // It's not possible to request a stack smaller than the system-defined PTHREAD_STACK_MIN.
162 if (stack_size < PTHREAD_STACK_MIN) {
163 stack_size = PTHREAD_STACK_MIN;
164 }
165
166 // It's likely that callers are trying to ensure they have at least a certain amount of
167 // stack space, so we should add our reserved space on top of what they requested, rather
168 // than implicitly take it away from them.
169 stack_size += Thread::kStackOverflowReservedBytes;
170
171 // Some systems require the stack size to be a multiple of the system page size, so round up.
172 stack_size = RoundUp(stack_size, kPageSize);
173
174 return stack_size;
175}
176
Elliott Hughesd8af1592012-04-16 20:40:15 -0700177static void SigAltStack(stack_t* new_stack, stack_t* old_stack) {
178 if (sigaltstack(new_stack, old_stack) == -1) {
179 PLOG(FATAL) << "sigaltstack failed";
180 }
181}
182
183static void SetUpAlternateSignalStack() {
184 // Create and set an alternate signal stack.
185 stack_t ss;
186 ss.ss_sp = new uint8_t[SIGSTKSZ];
187 ss.ss_size = SIGSTKSZ;
188 ss.ss_flags = 0;
189 CHECK(ss.ss_sp != NULL);
190 SigAltStack(&ss, NULL);
191
192 // Double-check that it worked.
193 ss.ss_sp = NULL;
194 SigAltStack(NULL, &ss);
195 VLOG(threads) << "Alternate signal stack is " << PrettySize(ss.ss_size) << " at " << ss.ss_sp;
196}
197
198static void TearDownAlternateSignalStack() {
199 // Get the pointer so we can free the memory.
200 stack_t ss;
201 SigAltStack(NULL, &ss);
202 uint8_t* allocated_signal_stack = reinterpret_cast<uint8_t*>(ss.ss_sp);
203
204 // Tell the kernel to stop using it.
205 ss.ss_sp = NULL;
206 ss.ss_flags = SS_DISABLE;
Elliott Hughes4c5231d2012-04-18 16:54:31 -0700207 ss.ss_size = SIGSTKSZ; // Avoid ENOMEM failure with Mac OS' buggy libc.
Elliott Hughesd8af1592012-04-16 20:40:15 -0700208 SigAltStack(&ss, NULL);
209
210 // Free it.
211 delete[] allocated_signal_stack;
212}
213
Ian Rogers52673ff2012-06-27 23:25:34 -0700214void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool daemon) {
215 Thread* native_thread = new Thread(daemon);
Elliott Hughes47179f72011-10-27 16:44:39 -0700216 {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700217 ScopedObjectAccess soa(env);
218 Object* peer = soa.Decode<Object*>(java_peer);
Ian Rogers365c1022012-06-22 15:05:28 -0700219 CHECK(peer != NULL);
220 native_thread->peer_ = peer;
221
222 stack_size = FixStackSize(stack_size);
223
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700224 // Thread.start is synchronized, so we know that vmData is 0, and know that we're not racing to
225 // assign it.
226 SetVmData(soa, peer, native_thread);
Elliott Hughes47179f72011-10-27 16:44:39 -0700227 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700228
229 pthread_t new_pthread;
230 pthread_attr_t attr;
231 CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
232 CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED), "PTHREAD_CREATE_DETACHED");
233 CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
234 int pthread_create_result = pthread_create(&new_pthread, &attr, Thread::CreateCallback, native_thread);
235 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
236
237 if (UNLIKELY(pthread_create_result != 0)) {
238 // pthread_create(3) failed, so clean up.
239 ScopedObjectAccess soa(env);
240 Object* peer = soa.Decode<Object*>(java_peer);
241 SetVmData(soa, peer, 0);
242 delete native_thread;
243
244 std::string msg(StringPrintf("pthread_create (%s stack) failed: %s",
245 PrettySize(stack_size).c_str(), strerror(pthread_create_result)));
246 Thread::Current()->ThrowOutOfMemoryError(msg.c_str());
247 return;
248 }
Carl Shapiro61e019d2011-07-14 16:53:09 -0700249}
250
Elliott Hughes462c9442012-03-23 18:47:50 -0700251void Thread::Init() {
252 // This function does all the initialization that must be run by the native thread it applies to.
253 // (When we create a new thread from managed code, we allocate the Thread* in Thread::Create so
254 // we can handshake with the corresponding native thread when it's ready.) Check this native
255 // thread hasn't been through here already...
Elliott Hughescac6cc72011-11-03 20:31:21 -0700256 CHECK(Thread::Current() == NULL);
257
Elliott Hughesd8af1592012-04-16 20:40:15 -0700258 SetUpAlternateSignalStack();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700259 InitCpu();
260 InitFunctionPointers();
Ian Rogers5d76c432011-10-31 21:42:49 -0700261 InitCardTable();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700262
Elliott Hughes462c9442012-03-23 18:47:50 -0700263 Runtime* runtime = Runtime::Current();
264 CHECK(runtime != NULL);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700265 if (runtime->IsShuttingDown()) {
266 UNIMPLEMENTED(WARNING) << "Thread attaching whilst runtime is shutting down";
267 }
Elliott Hughes462c9442012-03-23 18:47:50 -0700268 thin_lock_id_ = runtime->GetThreadList()->AllocThreadId();
Elliott Hughes0d39c122012-06-06 16:41:17 -0700269 pthread_self_ = pthread_self();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700270
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700271 InitTid();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700272 InitStackHwm();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700273
Elliott Hughes6a607ad2012-07-13 20:40:00 -0700274 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, this), "attach self");
Elliott Hughesa5780da2011-07-17 11:39:39 -0700275
Elliott Hughes93e74e82011-09-13 11:07:03 -0700276 jni_env_ = new JNIEnvExt(this, runtime->GetJavaVM());
Elliott Hughes330304d2011-08-12 14:28:05 -0700277
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700278 runtime->GetThreadList()->Register(this);
Elliott Hughes93e74e82011-09-13 11:07:03 -0700279}
280
Ian Rogers365c1022012-06-22 15:05:28 -0700281Thread* Thread::Attach(const char* thread_name, bool as_daemon, jobject thread_group) {
Ian Rogers52673ff2012-06-27 23:25:34 -0700282 Thread* self = new Thread(as_daemon);
Elliott Hughes462c9442012-03-23 18:47:50 -0700283 self->Init();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700284
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700285 {
286 MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
287 CHECK_NE(self->GetState(), kRunnable);
288 self->SetState(kNative);
289 }
Elliott Hughes93e74e82011-09-13 11:07:03 -0700290
Elliott Hughescac6cc72011-11-03 20:31:21 -0700291 // If we're the main thread, ClassLinker won't be created until after we're attached,
292 // so that thread needs a two-stage attach. Regular threads don't need this hack.
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800293 // In the compiler, all threads need this hack, because no-one's going to be getting
294 // a native peer!
295 if (self->thin_lock_id_ != ThreadList::kMainId && !Runtime::Current()->IsCompiler()) {
Elliott Hughes462c9442012-03-23 18:47:50 -0700296 self->CreatePeer(thread_name, as_daemon, thread_group);
Elliott Hughes06e3ad42012-02-07 14:51:57 -0800297 } else {
298 // These aren't necessary, but they improve diagnostics for unit tests & command-line tools.
Elliott Hughes22869a92012-03-27 14:08:24 -0700299 if (thread_name != NULL) {
300 self->name_->assign(thread_name);
301 ::art::SetThreadName(thread_name);
302 }
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700303 }
Elliott Hughescac6cc72011-11-03 20:31:21 -0700304
305 self->GetJniEnv()->locals.AssertEmpty();
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700306 return self;
307}
308
Ian Rogers365c1022012-06-22 15:05:28 -0700309void Thread::CreatePeer(const char* name, bool as_daemon, jobject thread_group) {
310 Runtime* runtime = Runtime::Current();
311 CHECK(runtime->IsStarted());
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700312 JNIEnv* env = jni_env_;
313
Elliott Hughes462c9442012-03-23 18:47:50 -0700314 if (thread_group == NULL) {
Ian Rogers365c1022012-06-22 15:05:28 -0700315 thread_group = runtime->GetMainThreadGroup();
Elliott Hughes462c9442012-03-23 18:47:50 -0700316 }
Elliott Hughes726079d2011-10-07 18:43:44 -0700317 ScopedLocalRef<jobject> thread_name(env, env->NewStringUTF(name));
Elliott Hughes8daa0922011-09-11 13:46:25 -0700318 jint thread_priority = GetNativePriority();
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700319 jboolean thread_is_daemon = as_daemon;
320
Elliott Hugheseac76672012-05-24 21:56:51 -0700321 ScopedLocalRef<jobject> peer(env, env->AllocObject(WellKnownClasses::java_lang_Thread));
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700322 {
323 ScopedObjectAccess soa(env);
324 peer_ = DecodeJObject(peer.get());
325 if (peer_ == NULL) {
326 CHECK(IsExceptionPending());
327 return;
328 }
Ian Rogers5d4bdc22011-11-02 22:15:43 -0700329 }
Elliott Hugheseac76672012-05-24 21:56:51 -0700330 env->CallNonvirtualVoidMethod(peer.get(),
331 WellKnownClasses::java_lang_Thread,
332 WellKnownClasses::java_lang_Thread_init,
Ian Rogers365c1022012-06-22 15:05:28 -0700333 thread_group, thread_name.get(), thread_priority, thread_is_daemon);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700334 AssertNoPendingException();
Elliott Hughesd369bb72011-09-12 14:41:14 -0700335
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700336 ScopedObjectAccess soa(this);
337 SetVmData(soa, peer_, Thread::Current());
338 SirtRef<String> peer_thread_name(GetThreadName(soa));
Brian Carlstrom00fae582011-10-28 01:16:28 -0700339 if (peer_thread_name.get() == NULL) {
340 // The Thread constructor should have set the Thread.name to a
341 // non-null value. However, because we can run without code
342 // available (in the compiler, in tests), we manually assign the
343 // fields the constructor should have set.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700344 soa.DecodeField(WellKnownClasses::java_lang_Thread_daemon)->SetBoolean(peer_, thread_is_daemon);
345 soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->SetObject(peer_, soa.Decode<Object*>(thread_group));
346 soa.DecodeField(WellKnownClasses::java_lang_Thread_name)->SetObject(peer_, soa.Decode<Object*>(thread_name.get()));
347 soa.DecodeField(WellKnownClasses::java_lang_Thread_priority)->SetInt(peer_, thread_priority);
348 peer_thread_name.reset(GetThreadName(soa));
Brian Carlstrom00fae582011-10-28 01:16:28 -0700349 }
Elliott Hughes225f5a12012-06-11 11:23:48 -0700350 // 'thread_name' may have been null, so don't trust 'peer_thread_name' to be non-null.
Brian Carlstrom00fae582011-10-28 01:16:28 -0700351 if (peer_thread_name.get() != NULL) {
Elliott Hughes899e7892012-01-24 14:57:32 -0800352 SetThreadName(peer_thread_name->ToModifiedUtf8().c_str());
Brian Carlstrom00fae582011-10-28 01:16:28 -0700353 }
Carl Shapiro61e019d2011-07-14 16:53:09 -0700354}
355
Elliott Hughes899e7892012-01-24 14:57:32 -0800356void Thread::SetThreadName(const char* name) {
357 name_->assign(name);
358 ::art::SetThreadName(name);
359 Dbg::DdmSendThreadNotification(this, CHUNK_TYPE("THNM"));
360}
361
Elliott Hughesbe759c62011-09-08 19:38:21 -0700362void Thread::InitStackHwm() {
Elliott Hughese1884192012-04-23 12:38:15 -0700363 void* stack_base;
364 size_t stack_size;
365 GetThreadStack(stack_base, stack_size);
Elliott Hughes36ecb782012-04-17 16:55:45 -0700366
367 // TODO: include this in the thread dumps; potentially useful in SIGQUIT output?
Elliott Hughese1884192012-04-23 12:38:15 -0700368 VLOG(threads) << StringPrintf("Native stack is at %p (%s)", stack_base, PrettySize(stack_size).c_str());
369
370 stack_begin_ = reinterpret_cast<byte*>(stack_base);
371 stack_size_ = stack_size;
Elliott Hughes36ecb782012-04-17 16:55:45 -0700372
Ian Rogers932746a2011-09-22 18:57:50 -0700373 if (stack_size_ <= kStackOverflowReservedBytes) {
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800374 LOG(FATAL) << "Attempt to attach a thread with a too-small stack (" << stack_size_ << " bytes)";
Elliott Hughesbe759c62011-09-08 19:38:21 -0700375 }
Elliott Hughes449b4bd2011-09-09 12:01:38 -0700376
Elliott Hughese1884192012-04-23 12:38:15 -0700377 // TODO: move this into the Linux GetThreadStack implementation.
378#if !defined(__APPLE__)
Elliott Hughes36ecb782012-04-17 16:55:45 -0700379 // If we're the main thread, check whether we were run with an unlimited stack. In that case,
380 // glibc will have reported a 2GB stack for our 32-bit process, and our stack overflow detection
381 // will be broken because we'll die long before we get close to 2GB.
382 if (thin_lock_id_ == 1) {
383 rlimit stack_limit;
384 if (getrlimit(RLIMIT_STACK, &stack_limit) == -1) {
385 PLOG(FATAL) << "getrlimit(RLIMIT_STACK) failed";
386 }
387 if (stack_limit.rlim_cur == RLIM_INFINITY) {
388 // Find the default stack size for new threads...
389 pthread_attr_t default_attributes;
390 size_t default_stack_size;
391 CHECK_PTHREAD_CALL(pthread_attr_init, (&default_attributes), "default stack size query");
392 CHECK_PTHREAD_CALL(pthread_attr_getstacksize, (&default_attributes, &default_stack_size),
393 "default stack size query");
394 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&default_attributes), "default stack size query");
395
396 // ...and use that as our limit.
397 size_t old_stack_size = stack_size_;
398 stack_size_ = default_stack_size;
399 stack_begin_ += (old_stack_size - stack_size_);
Elliott Hughesfaf4ba02012-05-02 16:12:19 -0700400 VLOG(threads) << "Limiting unlimited stack (reported as " << PrettySize(old_stack_size) << ")"
401 << " to " << PrettySize(stack_size_)
402 << " with base " << reinterpret_cast<void*>(stack_begin_);
Elliott Hughes36ecb782012-04-17 16:55:45 -0700403 }
404 }
Elliott Hughese1884192012-04-23 12:38:15 -0700405#endif
Elliott Hughes36ecb782012-04-17 16:55:45 -0700406
Ian Rogers932746a2011-09-22 18:57:50 -0700407 // Set stack_end_ to the bottom of the stack saving space of stack overflows
408 ResetDefaultStackEnd();
Elliott Hughes449b4bd2011-09-09 12:01:38 -0700409
410 // Sanity check.
411 int stack_variable;
Elliott Hughes398f64b2012-03-26 18:05:48 -0700412 CHECK_GT(&stack_variable, reinterpret_cast<void*>(stack_end_));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700413}
414
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700415void Thread::ShortDump(std::ostream& os) const {
416 os << "Thread[";
417 if (GetThinLockId() != 0) {
418 // If we're in kStarting, we won't have a thin lock id or tid yet.
419 os << GetThinLockId()
420 << ",tid=" << GetTid() << ',';
Elliott Hughese0918552011-10-28 17:18:29 -0700421 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700422 os << GetStateUnsafe()
423 << ",Thread*=" << this
424 << ",peer=" << peer_
425 << ",\"" << *name_ << "\""
426 << "]";
Elliott Hughesa0957642011-09-02 14:27:33 -0700427}
428
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700429void Thread::Dump(std::ostream& os) const {
430 DumpState(os);
431 DumpStack(os);
432}
433
434String* Thread::GetThreadName(const ScopedObjectAccessUnchecked& soa) const {
435 Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_name);
Elliott Hughesaf8d15a2012-05-29 09:12:18 -0700436 return (peer_ != NULL) ? reinterpret_cast<String*>(f->GetObject(peer_)) : NULL;
Elliott Hughesfc861622011-10-17 17:57:47 -0700437}
438
Elliott Hughesffb465f2012-03-01 18:46:05 -0800439void Thread::GetThreadName(std::string& name) const {
440 name.assign(*name_);
441}
442
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700443// Attempt to rectify locks so that we dump thread list with required locks before exiting.
444static void UnsafeLogFatalForSuspendCount(Thread* self) NO_THREAD_SAFETY_ANALYSIS {
445 GlobalSynchronization::thread_suspend_count_lock_->Unlock();
446 GlobalSynchronization::mutator_lock_->SharedTryLock();
447 if (!GlobalSynchronization::mutator_lock_->IsSharedHeld()) {
448 LOG(WARNING) << "Dumping thread list without holding mutator_lock_";
449 }
450 GlobalSynchronization::thread_list_lock_->TryLock();
451 if (!GlobalSynchronization::thread_list_lock_->IsExclusiveHeld()) {
452 LOG(WARNING) << "Dumping thread list without holding thread_list_lock_";
453 }
454 std::ostringstream ss;
455 Runtime::Current()->GetThreadList()->DumpLocked(ss);
456 LOG(FATAL) << self << " suspend count already zero.\n" << ss.str();
457}
458
459void Thread::ModifySuspendCount(int delta, bool for_debugger) {
460 DCHECK(delta == -1 || delta == +1 || delta == -debug_suspend_count_)
461 << delta << " " << debug_suspend_count_ << " " << this;
462 DCHECK_GE(suspend_count_, debug_suspend_count_) << this;
463 GlobalSynchronization::thread_suspend_count_lock_->AssertHeld();
464
465 if (delta == -1 && suspend_count_ <= 0) {
466 // This is expected if you attach a thread during a GC.
467 if (UNLIKELY(!IsStillStarting())) {
468 UnsafeLogFatalForSuspendCount(this);
469 }
470 return;
471 }
472 suspend_count_ += delta;
473 if (for_debugger) {
474 debug_suspend_count_ += delta;
475 }
476}
477
478void Thread::FullSuspendCheck() {
479 VLOG(threads) << this << " self-suspending";
480 // Make thread appear suspended to other threads, release mutator_lock_.
481 TransitionFromRunnableToSuspended(kSuspended);
482 // Transition back to runnable noting requests to suspend, re-acquire share on mutator_lock_.
483 TransitionFromSuspendedToRunnable();
484 VLOG(threads) << this << " self-reviving";
485}
486
487void Thread::TransitionFromRunnableToSuspended(ThreadState new_state) {
488 AssertThreadSuspensionIsAllowable();
489 CHECK_NE(new_state, kRunnable);
490 CHECK_EQ(this, Thread::Current());
491 {
492 MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
493 CHECK_EQ(GetState(), kRunnable);
494 SetState(new_state);
495 }
496 // Release share on mutator_lock_.
497 GlobalSynchronization::mutator_lock_->SharedUnlock();
498}
499
500ThreadState Thread::TransitionFromSuspendedToRunnable() {
501 bool done = false;
502 ThreadState old_state;
503 do {
504 {
505 // Wait while our suspend count is non-zero.
506 MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
507 old_state = GetState();
508 CHECK_NE(old_state, kRunnable);
509 GlobalSynchronization::mutator_lock_->AssertNotHeld(); // Otherwise we starve GC..
510 while (GetSuspendCount() != 0) {
511 // Re-check when Thread::resume_cond_ is notified.
512 Thread::resume_cond_->Wait(*GlobalSynchronization::thread_suspend_count_lock_);
513 }
514 }
515 // Re-acquire shared mutator_lock_ access.
516 GlobalSynchronization::mutator_lock_->SharedLock();
517 // Holding the mutator_lock_, synchronize with any thread trying to raise the suspend count
518 // and change state to Runnable if no suspend is pending.
519 MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
520 if (GetSuspendCount() == 0) {
521 SetState(kRunnable);
522 done = true;
523 } else {
524 // Release shared mutator_lock_ access and try again.
525 GlobalSynchronization::mutator_lock_->SharedUnlock();
526 }
527 } while (!done);
528 return old_state;
529}
530
531Thread* Thread::SuspendForDebugger(jobject peer, bool request_suspension, bool* timeout) {
532 static const useconds_t kTimeoutUs = 30 * 1000000; // 30s.
533 useconds_t total_delay_us = 0;
534 useconds_t delay_us = 0;
535 bool did_suspend_request = false;
536 *timeout = false;
537 while (true) {
538 Thread* thread;
539 {
540 ScopedObjectAccess soa(Thread::Current());
541 MutexLock mu(*GlobalSynchronization::thread_list_lock_);
542 thread = Thread::FromManagedThread(soa, peer);
543 if (thread == NULL) {
544 LOG(WARNING) << "No such thread for suspend: " << peer;
545 return NULL;
546 }
547 {
548 MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
549 if (request_suspension) {
550 thread->ModifySuspendCount(+1, true /* for_debugger */);
551 request_suspension = false;
552 did_suspend_request = true;
553 }
554 // IsSuspended on the current thread will fail as the current thread is changed into
555 // Runnable above. As the suspend count is now raised if this is the current thread
556 // it will self suspend on transition to Runnable, making it hard to work with. Its simpler
557 // to just explicitly handle the current thread in the callers to this code.
558 CHECK_NE(thread, soa.Self()) << "Attempt to suspend for debugger the current thread";
559 // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
560 // count, or else we've waited and it has self suspended) or is the current thread, we're
561 // done.
562 if (thread->IsSuspended()) {
563 return thread;
564 }
565 if (total_delay_us >= kTimeoutUs) {
566 LOG(ERROR) << "Thread suspension timed out: " << peer;
567 if (did_suspend_request) {
568 thread->ModifySuspendCount(-1, true /* for_debugger */);
569 }
570 *timeout = true;
571 return NULL;
572 }
573 }
574 // Release locks and come out of runnable state.
575 }
576 for (int i = kMaxMutexLevel; i >= 0; --i) {
577 BaseMutex* held_mutex = Thread::Current()->GetHeldMutex(static_cast<MutexLevel>(i));
578 if (held_mutex != NULL) {
579 LOG(FATAL) << "Holding " << held_mutex->GetName()
580 << " while sleeping for thread suspension";
581 }
582 }
583 {
584 useconds_t new_delay_us = delay_us * 2;
585 CHECK_GE(new_delay_us, delay_us);
586 if (new_delay_us < 500000) { // Don't allow sleeping to be more than 0.5s.
587 delay_us = new_delay_us;
588 }
589 }
590 if (delay_us == 0) {
591 sched_yield();
592 // Default to 1 milliseconds (note that this gets multiplied by 2 before the first sleep).
593 delay_us = 500;
594 } else {
595 usleep(delay_us);
596 total_delay_us += delay_us;
597 }
598 }
599}
600
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700601void Thread::DumpState(std::ostream& os, const Thread* thread, pid_t tid) {
Elliott Hughesd369bb72011-09-12 14:41:14 -0700602 std::string group_name;
603 int priority;
604 bool is_daemon = false;
Elliott Hughesdcc24742011-09-07 14:02:44 -0700605
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700606 if (thread != NULL && thread->peer_ != NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700607 ScopedObjectAccess soa(Thread::Current());
608 priority = soa.DecodeField(WellKnownClasses::java_lang_Thread_priority)->GetInt(thread->peer_);
609 is_daemon = soa.DecodeField(WellKnownClasses::java_lang_Thread_daemon)->GetBoolean(thread->peer_);
Elliott Hughesd369bb72011-09-12 14:41:14 -0700610
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700611 Object* thread_group = thread->GetThreadGroup(soa);
Elliott Hughesd369bb72011-09-12 14:41:14 -0700612 if (thread_group != NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700613 Field* group_name_field = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_name);
Elliott Hughesaf8d15a2012-05-29 09:12:18 -0700614 String* group_name_string = reinterpret_cast<String*>(group_name_field->GetObject(thread_group));
Elliott Hughesd369bb72011-09-12 14:41:14 -0700615 group_name = (group_name_string != NULL) ? group_name_string->ToModifiedUtf8() : "<null>";
616 }
617 } else {
Elliott Hughesd369bb72011-09-12 14:41:14 -0700618 priority = GetNativePriority();
Elliott Hughesdcc24742011-09-07 14:02:44 -0700619 }
Elliott Hughesd92bec42011-09-02 17:04:36 -0700620
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700621 std::string scheduler_group_name(GetSchedulerGroupName(tid));
Elliott Hughes1bac54f2012-03-16 12:48:31 -0700622 if (scheduler_group_name.empty()) {
623 scheduler_group_name = "default";
Elliott Hughesd92bec42011-09-02 17:04:36 -0700624 }
625
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700626 if (thread != NULL) {
627 os << '"' << *thread->name_ << '"';
628 if (is_daemon) {
629 os << " daemon";
630 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700631 MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700632 os << " prio=" << priority
633 << " tid=" << thread->GetThinLockId()
634 << " " << thread->GetState() << "\n";
635 } else {
Elliott Hughes289be852012-06-12 13:57:20 -0700636 os << '"' << ::art::GetThreadName(tid) << '"'
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700637 << " prio=" << priority
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700638 << " (not attached)\n";
Elliott Hughesd92bec42011-09-02 17:04:36 -0700639 }
Elliott Hughesd92bec42011-09-02 17:04:36 -0700640
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700641 if (thread != NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700642 MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700643 os << " | group=\"" << group_name << "\""
644 << " sCount=" << thread->suspend_count_
645 << " dsCount=" << thread->debug_suspend_count_
646 << " obj=" << reinterpret_cast<void*>(thread->peer_)
647 << " self=" << reinterpret_cast<const void*>(thread) << "\n";
648 }
Elliott Hughes0d39c122012-06-06 16:41:17 -0700649
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700650 os << " | sysTid=" << tid
651 << " nice=" << getpriority(PRIO_PROCESS, tid)
Elliott Hughes0d39c122012-06-06 16:41:17 -0700652 << " cgrp=" << scheduler_group_name;
653 if (thread != NULL) {
654 int policy;
655 sched_param sp;
656 CHECK_PTHREAD_CALL(pthread_getschedparam, (thread->pthread_self_, &policy, &sp), __FUNCTION__);
657 os << " sched=" << policy << "/" << sp.sched_priority
658 << " handle=" << reinterpret_cast<void*>(thread->pthread_self_);
659 }
660 os << "\n";
Elliott Hughesd92bec42011-09-02 17:04:36 -0700661
662 // Grab the scheduler stats for this thread.
663 std::string scheduler_stats;
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700664 if (ReadFileToString(StringPrintf("/proc/self/task/%d/schedstat", tid), &scheduler_stats)) {
Elliott Hughesd92bec42011-09-02 17:04:36 -0700665 scheduler_stats.resize(scheduler_stats.size() - 1); // Lose the trailing '\n'.
666 } else {
667 scheduler_stats = "0 0 0";
668 }
669
670 int utime = 0;
671 int stime = 0;
672 int task_cpu = 0;
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700673 GetTaskStats(tid, utime, stime, task_cpu);
Elliott Hughesd92bec42011-09-02 17:04:36 -0700674
675 os << " | schedstat=( " << scheduler_stats << " )"
676 << " utm=" << utime
677 << " stm=" << stime
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700678 << " core=" << task_cpu
679 << " HZ=" << sysconf(_SC_CLK_TCK) << "\n";
680 if (thread != NULL) {
681 os << " | stack=" << reinterpret_cast<void*>(thread->stack_begin_) << "-" << reinterpret_cast<void*>(thread->stack_end_)
682 << " stackSize=" << PrettySize(thread->stack_size_) << "\n";
683 }
684}
685
686void Thread::DumpState(std::ostream& os) const {
687 Thread::DumpState(os, this, GetTid());
Elliott Hughesd92bec42011-09-02 17:04:36 -0700688}
689
Ian Rogers0399dde2012-06-06 17:09:28 -0700690struct StackDumpVisitor : public StackVisitor {
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700691 StackDumpVisitor(std::ostream& os, const Thread* thread, Context* context, bool can_allocate)
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700692 SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700693 : StackVisitor(thread->GetManagedStack(), thread->GetTraceStack(), context),
694 os(os), thread(thread), can_allocate(can_allocate),
695 last_method(NULL), last_line_number(0), repetition_count(0), frame_count(0) {
Elliott Hughesd369bb72011-09-12 14:41:14 -0700696 }
697
Ian Rogersbdb03912011-09-14 00:55:44 -0700698 virtual ~StackDumpVisitor() {
Elliott Hughese85d2e92012-05-01 14:02:10 -0700699 if (frame_count == 0) {
700 os << " (no managed stack frames)\n";
701 }
Elliott Hughesd369bb72011-09-12 14:41:14 -0700702 }
703
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700704 bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -0700705 Method* m = GetMethod();
706 if (m->IsRuntimeMethod()) {
Elliott Hughes530fa002012-03-12 11:44:49 -0700707 return true;
Ian Rogers90865722011-09-19 11:11:44 -0700708 }
Ian Rogers28ad40d2011-10-27 15:19:26 -0700709 const int kMaxRepetition = 3;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700710 Class* c = m->GetDeclaringClass();
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700711 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Ian Rogersb861dc02011-11-14 17:00:05 -0800712 const DexCache* dex_cache = c->GetDexCache();
713 int line_number = -1;
714 if (dex_cache != NULL) { // be tolerant of bad input
715 const DexFile& dex_file = class_linker->FindDexFile(dex_cache);
Ian Rogers0399dde2012-06-06 17:09:28 -0700716 line_number = dex_file.GetLineNumFromPC(m, GetDexPc());
Ian Rogersb861dc02011-11-14 17:00:05 -0800717 }
Ian Rogers28ad40d2011-10-27 15:19:26 -0700718 if (line_number == last_line_number && last_method == m) {
719 repetition_count++;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700720 } else {
Ian Rogers28ad40d2011-10-27 15:19:26 -0700721 if (repetition_count >= kMaxRepetition) {
722 os << " ... repeated " << (repetition_count - kMaxRepetition) << " times\n";
723 }
724 repetition_count = 0;
725 last_line_number = line_number;
726 last_method = m;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700727 }
Ian Rogers28ad40d2011-10-27 15:19:26 -0700728 if (repetition_count < kMaxRepetition) {
729 os << " at " << PrettyMethod(m, false);
730 if (m->IsNative()) {
731 os << "(Native method)";
732 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800733 mh.ChangeMethod(m);
734 const char* source_file(mh.GetDeclaringClassSourceFile());
735 os << "(" << (source_file != NULL ? source_file : "unavailable")
Ian Rogers28ad40d2011-10-27 15:19:26 -0700736 << ":" << line_number << ")";
737 }
738 os << "\n";
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700739 if (frame_count == 0) {
740 Monitor::DescribeWait(os, thread);
741 }
742 if (can_allocate) {
743 Monitor::DescribeLocks(os, this);
744 }
Ian Rogers28ad40d2011-10-27 15:19:26 -0700745 }
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700746
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700747 ++frame_count;
Elliott Hughes530fa002012-03-12 11:44:49 -0700748 return true;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700749 }
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700750 std::ostream& os;
751 const Thread* thread;
752 bool can_allocate;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800753 MethodHelper mh;
Ian Rogers28ad40d2011-10-27 15:19:26 -0700754 Method* last_method;
755 int last_line_number;
756 int repetition_count;
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700757 int frame_count;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700758};
759
Elliott Hughesd92bec42011-09-02 17:04:36 -0700760void Thread::DumpStack(std::ostream& os) const {
Elliott Hughesffb465f2012-03-01 18:46:05 -0800761 // If we're currently in native code, dump that stack before dumping the managed stack.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700762 ThreadState state;
763 {
764 MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
765 state = GetState();
766 }
767 if (state == kNative) {
Elliott Hughes46e251b2012-05-22 15:10:45 -0700768 DumpKernelStack(os, GetTid(), " kernel: ", false);
769 DumpNativeStack(os, GetTid(), " native: ", false);
Elliott Hughesffb465f2012-03-01 18:46:05 -0800770 }
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700771 UniquePtr<Context> context(Context::Create());
772 StackDumpVisitor dumper(os, this, context.get(), !throwing_OutOfMemoryError_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700773 dumper.WalkStack();
Elliott Hughese27955c2011-08-26 15:21:24 -0700774}
775
Elliott Hughesbe759c62011-09-08 19:38:21 -0700776void Thread::ThreadExitCallback(void* arg) {
777 Thread* self = reinterpret_cast<Thread*>(arg);
Elliott Hughes6a607ad2012-07-13 20:40:00 -0700778 if (self->thread_exit_check_count_ == 0) {
779 LOG(WARNING) << "Native thread exiting without having called DetachCurrentThread (maybe it's going to use a pthread_key_create destructor?): " << *self;
780 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, self), "reattach self");
781 self->thread_exit_check_count_ = 1;
782 } else {
783 LOG(FATAL) << "Native thread exited without calling DetachCurrentThread: " << *self;
784 }
Carl Shapirob5573532011-07-12 18:22:59 -0700785}
786
Elliott Hughesbe759c62011-09-08 19:38:21 -0700787void Thread::Startup() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700788 {
789 MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_); // Keep GCC happy.
790 resume_cond_ = new ConditionVariable("Thread resumption condition variable");
791 }
792
Carl Shapirob5573532011-07-12 18:22:59 -0700793 // Allocate a TLS slot.
Elliott Hughes8d768a92011-09-14 16:35:25 -0700794 CHECK_PTHREAD_CALL(pthread_key_create, (&Thread::pthread_key_self_, Thread::ThreadExitCallback), "self key");
Carl Shapirob5573532011-07-12 18:22:59 -0700795
796 // Double-check the TLS slot allocation.
797 if (pthread_getspecific(pthread_key_self_) != NULL) {
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800798 LOG(FATAL) << "Newly-created pthread TLS slot is not NULL";
Carl Shapirob5573532011-07-12 18:22:59 -0700799 }
Elliott Hughes038a8062011-09-18 14:12:41 -0700800}
Carl Shapirob5573532011-07-12 18:22:59 -0700801
Elliott Hughes038a8062011-09-18 14:12:41 -0700802void Thread::FinishStartup() {
Ian Rogers365c1022012-06-22 15:05:28 -0700803 Runtime* runtime = Runtime::Current();
804 CHECK(runtime->IsStarted());
Brian Carlstromb82b6872011-10-26 17:18:07 -0700805
Elliott Hughes01158d72011-09-19 19:47:10 -0700806 // Finish attaching the main thread.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700807 ScopedObjectAccess soa(Thread::Current());
Ian Rogers365c1022012-06-22 15:05:28 -0700808 Thread::Current()->CreatePeer("main", false, runtime->GetMainThreadGroup());
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500809
Elliott Hughesaf8d15a2012-05-29 09:12:18 -0700810 Runtime::Current()->GetClassLinker()->RunRootClinits();
Carl Shapirob5573532011-07-12 18:22:59 -0700811}
812
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700813void Thread::Shutdown() {
Elliott Hughes8d768a92011-09-14 16:35:25 -0700814 CHECK_PTHREAD_CALL(pthread_key_delete, (Thread::pthread_key_self_), "self key");
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700815}
816
Ian Rogers52673ff2012-06-27 23:25:34 -0700817Thread::Thread(bool daemon)
Ian Rogers0399dde2012-06-06 17:09:28 -0700818 : suspend_count_(0),
819 card_table_(NULL),
820 exception_(NULL),
821 stack_end_(NULL),
822 managed_stack_(),
823 jni_env_(NULL),
824 self_(NULL),
825 state_(kNative),
Elliott Hughes47179f72011-10-27 16:44:39 -0700826 peer_(NULL),
Ian Rogers0399dde2012-06-06 17:09:28 -0700827 stack_begin_(NULL),
828 stack_size_(0),
829 thin_lock_id_(0),
830 tid_(0),
Elliott Hughese62934d2012-04-09 11:24:29 -0700831 wait_mutex_(new Mutex("a thread wait mutex")),
832 wait_cond_(new ConditionVariable("a thread wait condition variable")),
Elliott Hughes8daa0922011-09-11 13:46:25 -0700833 wait_monitor_(NULL),
834 interrupted_(false),
Elliott Hughesdc33ad52011-09-16 19:46:51 -0700835 wait_next_(NULL),
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700836 monitor_enter_object_(NULL),
Elliott Hughesdcc24742011-09-07 14:02:44 -0700837 top_sirt_(NULL),
Elliott Hughesdc33ad52011-09-16 19:46:51 -0700838 runtime_(NULL),
Elliott Hughes85d15452011-09-16 17:33:01 -0700839 class_loader_override_(NULL),
Elliott Hughes418dfe72011-10-06 18:56:27 -0700840 long_jump_context_(NULL),
Elliott Hughes726079d2011-10-07 18:43:44 -0700841 throwing_OutOfMemoryError_(false),
Ian Rogers0399dde2012-06-06 17:09:28 -0700842 debug_suspend_count_(0),
jeffhaoe343b762011-12-05 16:36:44 -0800843 debug_invoke_req_(new DebugInvokeReq),
Elliott Hughes899e7892012-01-24 14:57:32 -0800844 trace_stack_(new std::vector<TraceStackFrame>),
Ian Rogers0399dde2012-06-06 17:09:28 -0700845 name_(new std::string(kThreadNameDuringStartup)),
Ian Rogers52673ff2012-06-27 23:25:34 -0700846 daemon_(daemon),
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700847 pthread_self_(0),
Ian Rogers52673ff2012-06-27 23:25:34 -0700848 no_thread_suspension_(0),
Elliott Hughes6a607ad2012-07-13 20:40:00 -0700849 last_no_thread_suspension_cause_(NULL),
850 thread_exit_check_count_(0) {
Elliott Hughesf5a7a472011-10-07 14:31:02 -0700851 CHECK_EQ((sizeof(Thread) % 4), 0U) << sizeof(Thread);
Elliott Hughesffb465f2012-03-01 18:46:05 -0800852 memset(&held_mutexes_[0], 0, sizeof(held_mutexes_));
Elliott Hughesdcc24742011-09-07 14:02:44 -0700853}
854
Elliott Hughes7dc51662012-05-16 14:48:43 -0700855bool Thread::IsStillStarting() const {
856 // You might think you can check whether the state is kStarting, but for much of thread startup,
857 // the thread might also be in kVmWait.
858 // You might think you can check whether the peer is NULL, but the peer is actually created and
859 // assigned fairly early on, and needs to be.
860 // It turns out that the last thing to change is the thread name; that's a good proxy for "has
861 // this thread _ever_ entered kRunnable".
862 return (*name_ == kThreadNameDuringStartup);
863}
864
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700865void Thread::AssertNoPendingException() const {
866 if (UNLIKELY(IsExceptionPending())) {
867 ScopedObjectAccess soa(Thread::Current());
868 Throwable* exception = GetException();
869 LOG(FATAL) << "No pending exception expected: " << exception->Dump();
870 }
871}
872
873static void MonitorExitVisitor(const Object* object, void* arg) NO_THREAD_SAFETY_ANALYSIS {
874 Thread* self = reinterpret_cast<Thread*>(arg);
Elliott Hughes02b48d12011-09-07 17:15:51 -0700875 Object* entered_monitor = const_cast<Object*>(object);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700876 if (self->HoldsLock(entered_monitor)) {
877 LOG(WARNING) << "Calling MonitorExit on object "
878 << object << " (" << PrettyTypeOf(object) << ")"
879 << " left locked by native thread "
880 << *Thread::Current() << " which is detaching";
881 entered_monitor->MonitorExit(self);
882 }
Elliott Hughes02b48d12011-09-07 17:15:51 -0700883}
884
Elliott Hughesc0f09332012-03-26 13:27:06 -0700885void Thread::Destroy() {
Elliott Hughes02b48d12011-09-07 17:15:51 -0700886 // On thread detach, all monitors entered with JNI MonitorEnter are automatically exited.
Elliott Hughes93e74e82011-09-13 11:07:03 -0700887 if (jni_env_ != NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700888 jni_env_->monitors.VisitRoots(MonitorExitVisitor, Thread::Current());
Elliott Hughes93e74e82011-09-13 11:07:03 -0700889 }
Elliott Hughes02b48d12011-09-07 17:15:51 -0700890
Elliott Hughes93e74e82011-09-13 11:07:03 -0700891 if (peer_ != NULL) {
Elliott Hughesc0f09332012-03-26 13:27:06 -0700892 Thread* self = this;
Elliott Hughes29f27422011-09-18 16:02:18 -0700893
Elliott Hughes534da072012-03-27 15:17:42 -0700894 // We may need to call user-supplied managed code.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700895 ScopedObjectAccess soa(this);
Elliott Hughes534da072012-03-27 15:17:42 -0700896
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700897 HandleUncaughtExceptions(soa);
898 RemoveFromThreadGroup(soa);
Elliott Hughes534da072012-03-27 15:17:42 -0700899
Elliott Hughes29f27422011-09-18 16:02:18 -0700900 // this.vmData = 0;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700901 SetVmData(soa, peer_, NULL);
Elliott Hughes02b48d12011-09-07 17:15:51 -0700902
Elliott Hughesc0f09332012-03-26 13:27:06 -0700903 Dbg::PostThreadDeath(self);
Elliott Hughes02b48d12011-09-07 17:15:51 -0700904
Elliott Hughes29f27422011-09-18 16:02:18 -0700905 // Thread.join() is implemented as an Object.wait() on the Thread.lock
906 // object. Signal anyone who is waiting.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700907 Object* lock = soa.DecodeField(WellKnownClasses::java_lang_Thread_lock)->GetObject(peer_);
Elliott Hughes038a8062011-09-18 14:12:41 -0700908 // (This conditional is only needed for tests, where Thread.lock won't have been set.)
Elliott Hughes5f791332011-09-15 17:45:30 -0700909 if (lock != NULL) {
910 lock->MonitorEnter(self);
911 lock->NotifyAll();
912 lock->MonitorExit(self);
913 }
914 }
Elliott Hughesc0f09332012-03-26 13:27:06 -0700915}
Elliott Hughes02b48d12011-09-07 17:15:51 -0700916
Elliott Hughesc0f09332012-03-26 13:27:06 -0700917Thread::~Thread() {
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700918 delete jni_env_;
Elliott Hughes02b48d12011-09-07 17:15:51 -0700919 jni_env_ = NULL;
920
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700921 {
922 MutexLock mu(*GlobalSynchronization::thread_suspend_count_lock_);
923 CHECK_NE(GetState(), kRunnable);
924 SetState(kTerminated);
925 }
Elliott Hughes85d15452011-09-16 17:33:01 -0700926
927 delete wait_cond_;
928 delete wait_mutex_;
929
Ian Rogers776ac1f2012-04-13 23:36:36 -0700930#if !defined(ART_USE_LLVM_COMPILER)
Elliott Hughes85d15452011-09-16 17:33:01 -0700931 delete long_jump_context_;
Ian Rogers776ac1f2012-04-13 23:36:36 -0700932#endif
Elliott Hughes475fc232011-10-25 15:00:35 -0700933
934 delete debug_invoke_req_;
jeffhaoe343b762011-12-05 16:36:44 -0800935 delete trace_stack_;
Elliott Hughes899e7892012-01-24 14:57:32 -0800936 delete name_;
Elliott Hughesd8af1592012-04-16 20:40:15 -0700937
938 TearDownAlternateSignalStack();
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700939}
940
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700941void Thread::HandleUncaughtExceptions(const ScopedObjectAccess& soa) {
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700942 if (!IsExceptionPending()) {
943 return;
944 }
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700945 // Get and clear the exception.
946 Object* exception = GetException();
947 ClearException();
948
949 // If the thread has its own handler, use that.
Ian Rogers365c1022012-06-22 15:05:28 -0700950 Object* handler =
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700951 soa.DecodeField(WellKnownClasses::java_lang_Thread_uncaughtHandler)->GetObject(peer_);
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700952 if (handler == NULL) {
953 // Otherwise use the thread group's default handler.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700954 handler = GetThreadGroup(soa);
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700955 }
956
957 // Call the handler.
Elliott Hughesaf8d15a2012-05-29 09:12:18 -0700958 jmethodID mid = WellKnownClasses::java_lang_Thread$UncaughtExceptionHandler_uncaughtException;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700959 Method* m = handler->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
Elliott Hughes77405792012-03-15 15:22:12 -0700960 JValue args[2];
Elliott Hughesf24d3ce2012-04-11 17:43:37 -0700961 args[0].SetL(peer_);
962 args[1].SetL(exception);
Elliott Hughes77405792012-03-15 15:22:12 -0700963 m->Invoke(this, handler, args, NULL);
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700964
965 // If the handler threw, clear that exception too.
966 ClearException();
967}
968
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700969Object* Thread::GetThreadGroup(const ScopedObjectAccessUnchecked& soa) const {
970 return soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(peer_);
Elliott Hughesa2155262011-11-16 16:26:58 -0800971}
972
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700973void Thread::RemoveFromThreadGroup(const ScopedObjectAccess& soa) {
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700974 // this.group.removeThread(this);
975 // group can be null if we're in the compiler or a test.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700976 Object* group = GetThreadGroup(soa);
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700977 if (group != NULL) {
Elliott Hughesaf8d15a2012-05-29 09:12:18 -0700978 jmethodID mid = WellKnownClasses::java_lang_ThreadGroup_removeThread;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700979 Method* m = group->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
Elliott Hughes77405792012-03-15 15:22:12 -0700980 JValue args[1];
Elliott Hughesf24d3ce2012-04-11 17:43:37 -0700981 args[0].SetL(peer_);
Elliott Hughes77405792012-03-15 15:22:12 -0700982 m->Invoke(this, group, args, NULL);
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700983 }
984}
985
Ian Rogers408f79a2011-08-23 18:22:33 -0700986size_t Thread::NumSirtReferences() {
Ian Rogersa8cd9f42011-08-19 16:43:41 -0700987 size_t count = 0;
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700988 for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
Ian Rogersa8cd9f42011-08-19 16:43:41 -0700989 count += cur->NumberOfReferences();
990 }
991 return count;
992}
993
Ian Rogers408f79a2011-08-23 18:22:33 -0700994bool Thread::SirtContains(jobject obj) {
995 Object** sirt_entry = reinterpret_cast<Object**>(obj);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700996 for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
997 if (cur->Contains(sirt_entry)) {
Ian Rogersa8cd9f42011-08-19 16:43:41 -0700998 return true;
999 }
1000 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001001 // JNI code invoked from portable code uses shadow frames rather than the SIRT.
1002 return managed_stack_.ShadowFramesContain(sirt_entry);
TDYa12728f1a142012-03-15 21:51:52 -07001003}
1004
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -07001005void Thread::SirtVisitRoots(Heap::RootVisitor* visitor, void* arg) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001006 for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -07001007 size_t num_refs = cur->NumberOfReferences();
1008 for (size_t j = 0; j < num_refs; j++) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001009 Object* object = cur->GetReference(j);
Brian Carlstrom5e73f9c2011-10-11 11:28:12 -07001010 if (object != NULL) {
1011 visitor(object, arg);
1012 }
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -07001013 }
1014 }
1015}
1016
Ian Rogers408f79a2011-08-23 18:22:33 -07001017Object* Thread::DecodeJObject(jobject obj) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001018 DCHECK(CanAccessDirectReferences());
Ian Rogers408f79a2011-08-23 18:22:33 -07001019 if (obj == NULL) {
1020 return NULL;
1021 }
1022 IndirectRef ref = reinterpret_cast<IndirectRef>(obj);
1023 IndirectRefKind kind = GetIndirectRefKind(ref);
1024 Object* result;
1025 switch (kind) {
1026 case kLocal:
1027 {
Elliott Hughes69f5bc62011-08-24 09:26:14 -07001028 IndirectReferenceTable& locals = jni_env_->locals;
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001029 result = const_cast<Object*>(locals.Get(ref));
Ian Rogers408f79a2011-08-23 18:22:33 -07001030 break;
1031 }
1032 case kGlobal:
1033 {
1034 JavaVMExt* vm = Runtime::Current()->GetJavaVM();
1035 IndirectReferenceTable& globals = vm->globals;
1036 MutexLock mu(vm->globals_lock);
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001037 result = const_cast<Object*>(globals.Get(ref));
Ian Rogers408f79a2011-08-23 18:22:33 -07001038 break;
1039 }
1040 case kWeakGlobal:
1041 {
1042 JavaVMExt* vm = Runtime::Current()->GetJavaVM();
1043 IndirectReferenceTable& weak_globals = vm->weak_globals;
1044 MutexLock mu(vm->weak_globals_lock);
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001045 result = const_cast<Object*>(weak_globals.Get(ref));
Ian Rogers408f79a2011-08-23 18:22:33 -07001046 if (result == kClearedJniWeakGlobal) {
1047 // This is a special case where it's okay to return NULL.
1048 return NULL;
1049 }
1050 break;
1051 }
1052 case kSirtOrInvalid:
1053 default:
1054 // TODO: make stack indirect reference table lookup more efficient
1055 // Check if this is a local reference in the SIRT
Ian Rogers0399dde2012-06-06 17:09:28 -07001056 if (SirtContains(obj)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001057 result = *reinterpret_cast<Object**>(obj); // Read from SIRT
Elliott Hughesc2dc62d2012-01-17 20:06:12 -08001058 } else if (Runtime::Current()->GetJavaVM()->work_around_app_jni_bugs) {
Ian Rogers408f79a2011-08-23 18:22:33 -07001059 // Assume an invalid local reference is actually a direct pointer.
1060 result = reinterpret_cast<Object*>(obj);
1061 } else {
Elliott Hughesa2501992011-08-26 19:39:54 -07001062 result = kInvalidIndirectRefObject;
Ian Rogers408f79a2011-08-23 18:22:33 -07001063 }
1064 }
1065
1066 if (result == NULL) {
Elliott Hughes3f6635a2012-06-19 13:37:49 -07001067 JniAbortF(NULL, "use of deleted %s %p", ToStr<IndirectRefKind>(kind).c_str(), obj);
Elliott Hughesa2501992011-08-26 19:39:54 -07001068 } else {
1069 if (result != kInvalidIndirectRefObject) {
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08001070 Runtime::Current()->GetHeap()->VerifyObject(result);
Elliott Hughesa2501992011-08-26 19:39:54 -07001071 }
Ian Rogers408f79a2011-08-23 18:22:33 -07001072 }
Ian Rogers408f79a2011-08-23 18:22:33 -07001073 return result;
1074}
1075
Ian Rogers0399dde2012-06-06 17:09:28 -07001076class CountStackDepthVisitor : public StackVisitor {
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001077 public:
Ian Rogers0399dde2012-06-06 17:09:28 -07001078 CountStackDepthVisitor(const ManagedStack* stack,
Ian Rogersca190662012-06-26 15:45:57 -07001079 const std::vector<TraceStackFrame>* trace_stack)
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001080 SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001081 : StackVisitor(stack, trace_stack, NULL),
1082 depth_(0), skip_depth_(0), skipping_(true) {}
Elliott Hughesd369bb72011-09-12 14:41:14 -07001083
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001084 bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
Elliott Hughes29f27422011-09-18 16:02:18 -07001085 // We want to skip frames up to and including the exception's constructor.
Ian Rogers90865722011-09-19 11:11:44 -07001086 // Note we also skip the frame if it doesn't have a method (namely the callee
1087 // save frame)
Ian Rogers0399dde2012-06-06 17:09:28 -07001088 Method* m = GetMethod();
1089 if (skipping_ && !m->IsRuntimeMethod() &&
1090 !Throwable::GetJavaLangThrowable()->IsAssignableFrom(m->GetDeclaringClass())) {
Elliott Hughes29f27422011-09-18 16:02:18 -07001091 skipping_ = false;
1092 }
1093 if (!skipping_) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001094 if (!m->IsRuntimeMethod()) { // Ignore runtime frames (in particular callee save).
Ian Rogers6b0870d2011-12-15 19:38:12 -08001095 ++depth_;
1096 }
Elliott Hughes29f27422011-09-18 16:02:18 -07001097 } else {
1098 ++skip_depth_;
1099 }
Elliott Hughes530fa002012-03-12 11:44:49 -07001100 return true;
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001101 }
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001102
1103 int GetDepth() const {
Ian Rogersaaa20802011-09-11 21:47:37 -07001104 return depth_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001105 }
1106
Elliott Hughes29f27422011-09-18 16:02:18 -07001107 int GetSkipDepth() const {
1108 return skip_depth_;
1109 }
1110
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001111 private:
Ian Rogersaaa20802011-09-11 21:47:37 -07001112 uint32_t depth_;
Elliott Hughes29f27422011-09-18 16:02:18 -07001113 uint32_t skip_depth_;
1114 bool skipping_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001115};
1116
Ian Rogers0399dde2012-06-06 17:09:28 -07001117class BuildInternalStackTraceVisitor : public StackVisitor {
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001118 public:
Ian Rogers0399dde2012-06-06 17:09:28 -07001119 explicit BuildInternalStackTraceVisitor(const ManagedStack* stack,
1120 const std::vector<TraceStackFrame>* trace_stack,
Ian Rogersca190662012-06-26 15:45:57 -07001121 int skip_depth)
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001122 : StackVisitor(stack, trace_stack, NULL),
1123 skip_depth_(skip_depth), count_(0), dex_pc_trace_(NULL), method_trace_(NULL) {}
Ian Rogers283ed0d2012-02-16 15:25:09 -08001124
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001125 bool Init(int depth, const ScopedObjectAccess& soa)
1126 SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
Ian Rogersaaa20802011-09-11 21:47:37 -07001127 // Allocate method trace with an extra slot that will hold the PC trace
Ian Rogers0399dde2012-06-06 17:09:28 -07001128 SirtRef<ObjectArray<Object> >
1129 method_trace(Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(depth + 1));
1130 if (method_trace.get() == NULL) {
Ian Rogers283ed0d2012-02-16 15:25:09 -08001131 return false;
Elliott Hughes726079d2011-10-07 18:43:44 -07001132 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001133 IntArray* dex_pc_trace = IntArray::Alloc(depth);
1134 if (dex_pc_trace == NULL) {
Ian Rogers283ed0d2012-02-16 15:25:09 -08001135 return false;
Elliott Hughes726079d2011-10-07 18:43:44 -07001136 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001137 // Save PC trace in last element of method trace, also places it into the
1138 // object graph.
Ian Rogers0399dde2012-06-06 17:09:28 -07001139 method_trace->Set(depth, dex_pc_trace);
1140 // Set the Object*s and assert that no thread suspension is now possible.
Ian Rogers52673ff2012-06-27 23:25:34 -07001141 const char* last_no_suspend_cause =
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001142 soa.Self()->StartAssertNoThreadSuspension("Building internal stack trace");
Ian Rogers52673ff2012-06-27 23:25:34 -07001143 CHECK(last_no_suspend_cause == NULL) << last_no_suspend_cause;
Ian Rogers0399dde2012-06-06 17:09:28 -07001144 method_trace_ = method_trace.get();
1145 dex_pc_trace_ = dex_pc_trace;
Ian Rogers283ed0d2012-02-16 15:25:09 -08001146 return true;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001147 }
1148
Ian Rogers0399dde2012-06-06 17:09:28 -07001149 virtual ~BuildInternalStackTraceVisitor() {
Ian Rogers52673ff2012-06-27 23:25:34 -07001150 if (method_trace_ != NULL) {
1151 Thread::Current()->EndAssertNoThreadSuspension(NULL);
1152 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001153 }
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001154
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001155 bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001156 if (method_trace_ == NULL || dex_pc_trace_ == NULL) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001157 return true; // We're probably trying to fillInStackTrace for an OutOfMemoryError.
Elliott Hughes726079d2011-10-07 18:43:44 -07001158 }
Elliott Hughes29f27422011-09-18 16:02:18 -07001159 if (skip_depth_ > 0) {
1160 skip_depth_--;
Elliott Hughes530fa002012-03-12 11:44:49 -07001161 return true;
Elliott Hughes29f27422011-09-18 16:02:18 -07001162 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001163 Method* m = GetMethod();
1164 if (m->IsRuntimeMethod()) {
1165 return true; // Ignore runtime frames (in particular callee save).
Ian Rogers6b0870d2011-12-15 19:38:12 -08001166 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001167 method_trace_->Set(count_, m);
1168 dex_pc_trace_->Set(count_, GetDexPc());
Ian Rogersaaa20802011-09-11 21:47:37 -07001169 ++count_;
Elliott Hughes530fa002012-03-12 11:44:49 -07001170 return true;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001171 }
1172
Ian Rogers0399dde2012-06-06 17:09:28 -07001173 ObjectArray<Object>* GetInternalStackTrace() const {
1174 return method_trace_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001175 }
1176
1177 private:
Elliott Hughes29f27422011-09-18 16:02:18 -07001178 // How many more frames to skip.
1179 int32_t skip_depth_;
Ian Rogers0399dde2012-06-06 17:09:28 -07001180 // Current position down stack trace.
Ian Rogersaaa20802011-09-11 21:47:37 -07001181 uint32_t count_;
Ian Rogers0399dde2012-06-06 17:09:28 -07001182 // Array of dex PC values.
1183 IntArray* dex_pc_trace_;
1184 // An array of the methods on the stack, the last entry is a reference to the PC trace.
Ian Rogersaaa20802011-09-11 21:47:37 -07001185 ObjectArray<Object>* method_trace_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001186};
1187
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001188void Thread::PushSirt(StackIndirectReferenceTable* sirt) {
1189 sirt->SetLink(top_sirt_);
1190 top_sirt_ = sirt;
1191}
1192
1193StackIndirectReferenceTable* Thread::PopSirt() {
1194 CHECK(top_sirt_ != NULL);
1195 StackIndirectReferenceTable* sirt = top_sirt_;
1196 top_sirt_ = top_sirt_->GetLink();
1197 return sirt;
1198}
1199
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001200jobject Thread::CreateInternalStackTrace(const ScopedObjectAccess& soa) const {
Ian Rogersaaa20802011-09-11 21:47:37 -07001201 // Compute depth of stack
Ian Rogers0399dde2012-06-06 17:09:28 -07001202 CountStackDepthVisitor count_visitor(GetManagedStack(), GetTraceStack());
1203 count_visitor.WalkStack();
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001204 int32_t depth = count_visitor.GetDepth();
Elliott Hughes29f27422011-09-18 16:02:18 -07001205 int32_t skip_depth = count_visitor.GetSkipDepth();
Shih-wei Liao44175362011-08-28 16:59:17 -07001206
Ian Rogersaaa20802011-09-11 21:47:37 -07001207 // Build internal stack trace
Ian Rogers0399dde2012-06-06 17:09:28 -07001208 BuildInternalStackTraceVisitor build_trace_visitor(GetManagedStack(), GetTraceStack(),
1209 skip_depth);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001210 if (!build_trace_visitor.Init(depth, soa)) {
Ian Rogers283ed0d2012-02-16 15:25:09 -08001211 return NULL; // Allocation failed
Ian Rogers283ed0d2012-02-16 15:25:09 -08001212 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001213 build_trace_visitor.WalkStack();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001214 return soa.AddLocalReference<jobjectArray>(build_trace_visitor.GetInternalStackTrace());
Ian Rogersaaa20802011-09-11 21:47:37 -07001215}
1216
Elliott Hughes01158d72011-09-19 19:47:10 -07001217jobjectArray Thread::InternalStackTraceToStackTraceElementArray(JNIEnv* env, jobject internal,
1218 jobjectArray output_array, int* stack_depth) {
Ian Rogersaaa20802011-09-11 21:47:37 -07001219 // Transition into runnable state to work on Object*/Array*
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001220 ScopedObjectAccess soa(env);
Ian Rogersaaa20802011-09-11 21:47:37 -07001221 // Decode the internal stack trace into the depth, method trace and PC trace
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001222 ObjectArray<Object>* method_trace = soa.Decode<ObjectArray<Object>*>(internal);
Ian Rogers9074b992011-10-26 17:41:55 -07001223 int32_t depth = method_trace->GetLength() - 1;
Ian Rogersaaa20802011-09-11 21:47:37 -07001224 IntArray* pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
1225
1226 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1227
Elliott Hughes01158d72011-09-19 19:47:10 -07001228 jobjectArray result;
1229 ObjectArray<StackTraceElement>* java_traces;
1230 if (output_array != NULL) {
1231 // Reuse the array we were given.
1232 result = output_array;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001233 java_traces = soa.Decode<ObjectArray<StackTraceElement>*>(output_array);
Elliott Hughes01158d72011-09-19 19:47:10 -07001234 // ...adjusting the number of frames we'll write to not exceed the array length.
1235 depth = std::min(depth, java_traces->GetLength());
1236 } else {
1237 // Create java_trace array and place in local reference table
1238 java_traces = class_linker->AllocStackTraceElementArray(depth);
Elliott Hughes30646832011-10-13 16:59:46 -07001239 if (java_traces == NULL) {
1240 return NULL;
1241 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001242 result = soa.AddLocalReference<jobjectArray>(java_traces);
Elliott Hughes01158d72011-09-19 19:47:10 -07001243 }
1244
1245 if (stack_depth != NULL) {
1246 *stack_depth = depth;
1247 }
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001248
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001249 MethodHelper mh;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001250 for (int32_t i = 0; i < depth; ++i) {
Ian Rogersaaa20802011-09-11 21:47:37 -07001251 // Prepare parameters for StackTraceElement(String cls, String method, String file, int line)
1252 Method* method = down_cast<Method*>(method_trace->Get(i));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001253 mh.ChangeMethod(method);
Ian Rogers0399dde2012-06-06 17:09:28 -07001254 uint32_t dex_pc = pc_trace->Get(i);
1255 int32_t line_number = mh.GetLineNumFromDexPC(dex_pc);
Ian Rogersaaa20802011-09-11 21:47:37 -07001256 // Allocate element, potentially triggering GC
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001257 // TODO: reuse class_name_object via Class::name_?
Ian Rogers48601312011-12-07 16:45:19 -08001258 const char* descriptor = mh.GetDeclaringClassDescriptor();
1259 CHECK(descriptor != NULL);
1260 std::string class_name(PrettyDescriptor(descriptor));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001261 SirtRef<String> class_name_object(String::AllocFromModifiedUtf8(class_name.c_str()));
1262 if (class_name_object.get() == NULL) {
1263 return NULL;
1264 }
Ian Rogers48601312011-12-07 16:45:19 -08001265 const char* method_name = mh.GetName();
1266 CHECK(method_name != NULL);
1267 SirtRef<String> method_name_object(String::AllocFromModifiedUtf8(method_name));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001268 if (method_name_object.get() == NULL) {
1269 return NULL;
1270 }
Ian Rogers48601312011-12-07 16:45:19 -08001271 const char* source_file = mh.GetDeclaringClassSourceFile();
1272 SirtRef<String> source_name_object(String::AllocFromModifiedUtf8(source_file));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001273 StackTraceElement* obj = StackTraceElement::Alloc(class_name_object.get(),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001274 method_name_object.get(),
1275 source_name_object.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001276 line_number);
Elliott Hughes30646832011-10-13 16:59:46 -07001277 if (obj == NULL) {
1278 return NULL;
1279 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001280#ifdef MOVING_GARBAGE_COLLECTOR
1281 // Re-read after potential GC
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001282 java_traces = Decode<ObjectArray<Object>*>(soa.Env(), result);
1283 method_trace = down_cast<ObjectArray<Object>*>(Decode<Object*>(soa.Env(), internal));
Ian Rogersaaa20802011-09-11 21:47:37 -07001284 pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
1285#endif
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001286 java_traces->Set(i, obj);
1287 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001288 return result;
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001289}
1290
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001291void Thread::ThrowNewExceptionF(const char* exception_class_descriptor, const char* fmt, ...) {
Elliott Hughesa5b897e2011-08-16 11:33:06 -07001292 va_list args;
1293 va_start(args, fmt);
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001294 ThrowNewExceptionV(exception_class_descriptor, fmt, args);
Elliott Hughesa5b897e2011-08-16 11:33:06 -07001295 va_end(args);
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001296}
1297
1298void Thread::ThrowNewExceptionV(const char* exception_class_descriptor, const char* fmt, va_list ap) {
1299 std::string msg;
1300 StringAppendV(&msg, fmt, ap);
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001301 ThrowNewException(exception_class_descriptor, msg.c_str());
1302}
Elliott Hughes37f7a402011-08-22 18:56:01 -07001303
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001304void Thread::ThrowNewException(const char* exception_class_descriptor, const char* msg) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001305 AssertNoPendingException(); // Callers should either clear or call ThrowNewWrappedException.
Elliott Hughesa4f94742012-05-29 16:28:38 -07001306 ThrowNewWrappedException(exception_class_descriptor, msg);
1307}
1308
1309void Thread::ThrowNewWrappedException(const char* exception_class_descriptor, const char* msg) {
Elliott Hughese5b0dc82011-08-23 09:59:02 -07001310 // Convert "Ljava/lang/Exception;" into JNI-style "java/lang/Exception".
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001311 CHECK_EQ('L', exception_class_descriptor[0]);
Elliott Hughese5b0dc82011-08-23 09:59:02 -07001312 std::string descriptor(exception_class_descriptor + 1);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001313 CHECK_EQ(';', descriptor[descriptor.length() - 1]);
Elliott Hughese5b0dc82011-08-23 09:59:02 -07001314 descriptor.erase(descriptor.length() - 1);
1315
1316 JNIEnv* env = GetJniEnv();
Elliott Hughesa4f94742012-05-29 16:28:38 -07001317 jobject cause = env->ExceptionOccurred();
1318 env->ExceptionClear();
1319
Elliott Hughes726079d2011-10-07 18:43:44 -07001320 ScopedLocalRef<jclass> exception_class(env, env->FindClass(descriptor.c_str()));
Elliott Hughes30646832011-10-13 16:59:46 -07001321 if (exception_class.get() == NULL) {
1322 LOG(ERROR) << "Couldn't throw new " << descriptor << " because JNI FindClass failed: "
1323 << PrettyTypeOf(GetException());
1324 CHECK(IsExceptionPending());
1325 return;
1326 }
Brian Carlstromebd1fd22011-12-07 15:46:26 -08001327 if (!Runtime::Current()->IsStarted()) {
1328 // Something is trying to throw an exception without a started
1329 // runtime, which is the common case in the compiler. We won't be
1330 // able to invoke the constructor of the exception, so use
1331 // AllocObject which will not invoke a constructor.
1332 ScopedLocalRef<jthrowable> exception(
1333 env, reinterpret_cast<jthrowable>(env->AllocObject(exception_class.get())));
1334 if (exception.get() != NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001335 ScopedObjectAccessUnchecked soa(env);
1336 Throwable* t = reinterpret_cast<Throwable*>(soa.Self()->DecodeJObject(exception.get()));
Ian Rogers02fbef02012-01-31 22:15:33 -08001337 t->SetDetailMessage(String::AllocFromModifiedUtf8(msg));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001338 soa.Self()->SetException(t);
Brian Carlstromebd1fd22011-12-07 15:46:26 -08001339 } else {
1340 LOG(ERROR) << "Couldn't throw new " << descriptor << " because JNI AllocObject failed: "
1341 << PrettyTypeOf(GetException());
1342 CHECK(IsExceptionPending());
1343 }
1344 return;
1345 }
Elliott Hughesa4f94742012-05-29 16:28:38 -07001346 int rc = ::art::ThrowNewException(env, exception_class.get(), msg, cause);
Elliott Hughes30646832011-10-13 16:59:46 -07001347 if (rc != JNI_OK) {
1348 LOG(ERROR) << "Couldn't throw new " << descriptor << " because JNI ThrowNew failed: "
1349 << PrettyTypeOf(GetException());
1350 CHECK(IsExceptionPending());
Elliott Hughes30646832011-10-13 16:59:46 -07001351 }
Elliott Hughesa5b897e2011-08-16 11:33:06 -07001352}
1353
Elliott Hughes2ced6a52011-10-16 18:44:48 -07001354void Thread::ThrowOutOfMemoryError(const char* msg) {
1355 LOG(ERROR) << StringPrintf("Throwing OutOfMemoryError \"%s\"%s",
1356 msg, (throwing_OutOfMemoryError_ ? " (recursive case)" : ""));
Elliott Hughes726079d2011-10-07 18:43:44 -07001357 if (!throwing_OutOfMemoryError_) {
1358 throwing_OutOfMemoryError_ = true;
Elliott Hughes57aba862012-06-20 14:00:47 -07001359 ThrowNewException("Ljava/lang/OutOfMemoryError;", msg);
Elliott Hughes418dfe72011-10-06 18:56:27 -07001360 } else {
Elliott Hughes225f5a12012-06-11 11:23:48 -07001361 Dump(LOG(ERROR)); // The pre-allocated OOME has no stack, so help out and log one.
1362 SetException(Runtime::Current()->GetPreAllocatedOutOfMemoryError());
Elliott Hughes418dfe72011-10-06 18:56:27 -07001363 }
Elliott Hughes726079d2011-10-07 18:43:44 -07001364 throwing_OutOfMemoryError_ = false;
Elliott Hughes79082e32011-08-25 12:07:32 -07001365}
1366
Elliott Hughes498508c2011-10-17 14:58:22 -07001367Thread* Thread::CurrentFromGdb() {
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001368 return Thread::Current();
1369}
1370
1371void Thread::DumpFromGdb() const {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001372 std::ostringstream ss;
1373 Dump(ss);
Elliott Hughes95572412011-12-13 18:14:20 -08001374 std::string str(ss.str());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001375 // log to stderr for debugging command line processes
1376 std::cerr << str;
1377#ifdef HAVE_ANDROID_OS
1378 // log to logcat for debugging frameworks processes
1379 LOG(INFO) << str;
1380#endif
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001381}
1382
Elliott Hughes98e20172012-04-24 15:38:13 -07001383struct EntryPointInfo {
1384 uint32_t offset;
1385 const char* name;
1386};
1387#define ENTRY_POINT_INFO(x) { ENTRYPOINT_OFFSET(x), #x }
1388static const EntryPointInfo gThreadEntryPointInfo[] = {
1389 ENTRY_POINT_INFO(pAllocArrayFromCode),
1390 ENTRY_POINT_INFO(pAllocArrayFromCodeWithAccessCheck),
1391 ENTRY_POINT_INFO(pAllocObjectFromCode),
1392 ENTRY_POINT_INFO(pAllocObjectFromCodeWithAccessCheck),
1393 ENTRY_POINT_INFO(pCheckAndAllocArrayFromCode),
1394 ENTRY_POINT_INFO(pCheckAndAllocArrayFromCodeWithAccessCheck),
1395 ENTRY_POINT_INFO(pInstanceofNonTrivialFromCode),
1396 ENTRY_POINT_INFO(pCanPutArrayElementFromCode),
1397 ENTRY_POINT_INFO(pCheckCastFromCode),
1398 ENTRY_POINT_INFO(pDebugMe),
1399 ENTRY_POINT_INFO(pUpdateDebuggerFromCode),
1400 ENTRY_POINT_INFO(pInitializeStaticStorage),
1401 ENTRY_POINT_INFO(pInitializeTypeAndVerifyAccessFromCode),
1402 ENTRY_POINT_INFO(pInitializeTypeFromCode),
1403 ENTRY_POINT_INFO(pResolveStringFromCode),
1404 ENTRY_POINT_INFO(pSet32Instance),
1405 ENTRY_POINT_INFO(pSet32Static),
1406 ENTRY_POINT_INFO(pSet64Instance),
1407 ENTRY_POINT_INFO(pSet64Static),
1408 ENTRY_POINT_INFO(pSetObjInstance),
1409 ENTRY_POINT_INFO(pSetObjStatic),
1410 ENTRY_POINT_INFO(pGet32Instance),
1411 ENTRY_POINT_INFO(pGet32Static),
1412 ENTRY_POINT_INFO(pGet64Instance),
1413 ENTRY_POINT_INFO(pGet64Static),
1414 ENTRY_POINT_INFO(pGetObjInstance),
1415 ENTRY_POINT_INFO(pGetObjStatic),
1416 ENTRY_POINT_INFO(pHandleFillArrayDataFromCode),
Elliott Hughes98e20172012-04-24 15:38:13 -07001417 ENTRY_POINT_INFO(pFindNativeMethod),
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001418 ENTRY_POINT_INFO(pJniMethodStart),
1419 ENTRY_POINT_INFO(pJniMethodStartSynchronized),
1420 ENTRY_POINT_INFO(pJniMethodEnd),
1421 ENTRY_POINT_INFO(pJniMethodEndSynchronized),
1422 ENTRY_POINT_INFO(pJniMethodEndWithReference),
1423 ENTRY_POINT_INFO(pJniMethodEndWithReferenceSynchronized),
Elliott Hughes98e20172012-04-24 15:38:13 -07001424 ENTRY_POINT_INFO(pLockObjectFromCode),
1425 ENTRY_POINT_INFO(pUnlockObjectFromCode),
1426 ENTRY_POINT_INFO(pCmpgDouble),
1427 ENTRY_POINT_INFO(pCmpgFloat),
1428 ENTRY_POINT_INFO(pCmplDouble),
1429 ENTRY_POINT_INFO(pCmplFloat),
1430 ENTRY_POINT_INFO(pDadd),
1431 ENTRY_POINT_INFO(pDdiv),
1432 ENTRY_POINT_INFO(pDmul),
1433 ENTRY_POINT_INFO(pDsub),
1434 ENTRY_POINT_INFO(pF2d),
1435 ENTRY_POINT_INFO(pFmod),
1436 ENTRY_POINT_INFO(pI2d),
1437 ENTRY_POINT_INFO(pL2d),
1438 ENTRY_POINT_INFO(pD2f),
1439 ENTRY_POINT_INFO(pFadd),
1440 ENTRY_POINT_INFO(pFdiv),
1441 ENTRY_POINT_INFO(pFmodf),
1442 ENTRY_POINT_INFO(pFmul),
1443 ENTRY_POINT_INFO(pFsub),
1444 ENTRY_POINT_INFO(pI2f),
1445 ENTRY_POINT_INFO(pL2f),
1446 ENTRY_POINT_INFO(pD2iz),
1447 ENTRY_POINT_INFO(pF2iz),
1448 ENTRY_POINT_INFO(pIdivmod),
1449 ENTRY_POINT_INFO(pD2l),
1450 ENTRY_POINT_INFO(pF2l),
1451 ENTRY_POINT_INFO(pLdiv),
1452 ENTRY_POINT_INFO(pLdivmod),
1453 ENTRY_POINT_INFO(pLmul),
1454 ENTRY_POINT_INFO(pShlLong),
1455 ENTRY_POINT_INFO(pShrLong),
1456 ENTRY_POINT_INFO(pUshrLong),
1457 ENTRY_POINT_INFO(pIndexOf),
1458 ENTRY_POINT_INFO(pMemcmp16),
1459 ENTRY_POINT_INFO(pStringCompareTo),
1460 ENTRY_POINT_INFO(pMemcpy),
1461 ENTRY_POINT_INFO(pUnresolvedDirectMethodTrampolineFromCode),
1462 ENTRY_POINT_INFO(pInvokeDirectTrampolineWithAccessCheck),
1463 ENTRY_POINT_INFO(pInvokeInterfaceTrampoline),
1464 ENTRY_POINT_INFO(pInvokeInterfaceTrampolineWithAccessCheck),
1465 ENTRY_POINT_INFO(pInvokeStaticTrampolineWithAccessCheck),
1466 ENTRY_POINT_INFO(pInvokeSuperTrampolineWithAccessCheck),
1467 ENTRY_POINT_INFO(pInvokeVirtualTrampolineWithAccessCheck),
1468 ENTRY_POINT_INFO(pCheckSuspendFromCode),
1469 ENTRY_POINT_INFO(pTestSuspendFromCode),
1470 ENTRY_POINT_INFO(pDeliverException),
1471 ENTRY_POINT_INFO(pThrowAbstractMethodErrorFromCode),
1472 ENTRY_POINT_INFO(pThrowArrayBoundsFromCode),
1473 ENTRY_POINT_INFO(pThrowDivZeroFromCode),
1474 ENTRY_POINT_INFO(pThrowNoSuchMethodFromCode),
1475 ENTRY_POINT_INFO(pThrowNullPointerFromCode),
1476 ENTRY_POINT_INFO(pThrowStackOverflowFromCode),
1477 ENTRY_POINT_INFO(pThrowVerificationErrorFromCode),
1478};
1479#undef ENTRY_POINT_INFO
1480
Elliott Hughes28fa76d2012-04-09 17:31:46 -07001481void Thread::DumpThreadOffset(std::ostream& os, uint32_t offset, size_t size_of_pointers) {
1482 CHECK_EQ(size_of_pointers, 4U); // TODO: support 64-bit targets.
Elliott Hughes98e20172012-04-24 15:38:13 -07001483
1484#define DO_THREAD_OFFSET(x) if (offset == static_cast<uint32_t>(OFFSETOF_VOLATILE_MEMBER(Thread, x))) { os << # x; return; }
1485 DO_THREAD_OFFSET(card_table_);
1486 DO_THREAD_OFFSET(exception_);
1487 DO_THREAD_OFFSET(jni_env_);
1488 DO_THREAD_OFFSET(self_);
1489 DO_THREAD_OFFSET(stack_end_);
1490 DO_THREAD_OFFSET(state_);
1491 DO_THREAD_OFFSET(suspend_count_);
1492 DO_THREAD_OFFSET(thin_lock_id_);
Ian Rogers0399dde2012-06-06 17:09:28 -07001493 //DO_THREAD_OFFSET(top_of_managed_stack_);
1494 //DO_THREAD_OFFSET(top_of_managed_stack_pc_);
Elliott Hughes98e20172012-04-24 15:38:13 -07001495 DO_THREAD_OFFSET(top_sirt_);
Elliott Hughes28fa76d2012-04-09 17:31:46 -07001496#undef DO_THREAD_OFFSET
Elliott Hughes98e20172012-04-24 15:38:13 -07001497
1498 size_t entry_point_count = arraysize(gThreadEntryPointInfo);
1499 CHECK_EQ(entry_point_count * size_of_pointers, sizeof(EntryPoints));
1500 uint32_t expected_offset = OFFSETOF_MEMBER(Thread, entrypoints_);
1501 for (size_t i = 0; i < entry_point_count; ++i) {
1502 CHECK_EQ(gThreadEntryPointInfo[i].offset, expected_offset);
1503 expected_offset += size_of_pointers;
1504 if (gThreadEntryPointInfo[i].offset == offset) {
1505 os << gThreadEntryPointInfo[i].name;
1506 return;
1507 }
1508 }
1509 os << offset;
Elliott Hughes28fa76d2012-04-09 17:31:46 -07001510}
1511
Ian Rogers0399dde2012-06-06 17:09:28 -07001512static const bool kDebugExceptionDelivery = false;
1513class CatchBlockStackVisitor : public StackVisitor {
Ian Rogersbdb03912011-09-14 00:55:44 -07001514 public:
Ian Rogers0399dde2012-06-06 17:09:28 -07001515 CatchBlockStackVisitor(Thread* self, Throwable* exception)
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001516 SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
Ian Rogers0399dde2012-06-06 17:09:28 -07001517 : StackVisitor(self->GetManagedStack(), self->GetTraceStack(), self->GetLongJumpContext()),
1518 self_(self), exception_(exception), to_find_(exception->GetClass()), throw_method_(NULL),
1519 throw_frame_id_(0), throw_dex_pc_(0), handler_quick_frame_(NULL),
1520 handler_quick_frame_pc_(0), handler_dex_pc_(0), native_method_count_(0),
Ian Rogers57b86d42012-03-27 16:05:41 -07001521 method_tracing_active_(Runtime::Current()->IsMethodTracingActive()) {
Ian Rogers52673ff2012-06-27 23:25:34 -07001522 // Exception not in root sets, can't allow GC.
1523 last_no_assert_suspension_cause_ = self->StartAssertNoThreadSuspension("Finding catch block");
1524 }
1525
1526 ~CatchBlockStackVisitor() {
1527 LOG(FATAL) << "UNREACHABLE"; // Expected to take long jump.
Ian Rogers67375ac2011-09-14 00:55:44 -07001528 }
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001529
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001530 bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
1531 SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001532 Method* method = GetMethod();
Elliott Hughes530fa002012-03-12 11:44:49 -07001533 if (method == NULL) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001534 // This is the upcall, we remember the frame and last pc so that we may long jump to them.
1535 handler_quick_frame_pc_ = GetCurrentQuickFramePc();
1536 handler_quick_frame_ = GetCurrentQuickFrame();
Ian Rogers57b86d42012-03-27 16:05:41 -07001537 return false; // End stack walk.
Elliott Hughes530fa002012-03-12 11:44:49 -07001538 }
1539 uint32_t dex_pc = DexFile::kDexNoIndex;
Ian Rogers57b86d42012-03-27 16:05:41 -07001540 if (method->IsRuntimeMethod()) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001541 // ignore callee save method
Ian Rogers57b86d42012-03-27 16:05:41 -07001542 DCHECK(method->IsCalleeSaveMethod());
Elliott Hughes530fa002012-03-12 11:44:49 -07001543 } else {
Ian Rogers0399dde2012-06-06 17:09:28 -07001544 if (throw_method_ == NULL) {
1545 throw_method_ = method;
1546 throw_frame_id_ = GetFrameId();
1547 throw_dex_pc_ = GetDexPc();
Ian Rogers67375ac2011-09-14 00:55:44 -07001548 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001549 if (method->IsNative()) {
1550 native_method_count_++;
1551 } else {
1552 // Unwind stack when an exception occurs during method tracing
1553 if (UNLIKELY(method_tracing_active_ && IsTraceExitPc(GetCurrentQuickFramePc()))) {
1554 uintptr_t pc = AdjustQuickFramePcForDexPcComputation(TraceMethodUnwindFromCode(Thread::Current()));
1555 dex_pc = method->ToDexPC(pc);
1556 } else {
1557 dex_pc = GetDexPc();
1558 }
1559 }
Elliott Hughes530fa002012-03-12 11:44:49 -07001560 }
1561 if (dex_pc != DexFile::kDexNoIndex) {
1562 uint32_t found_dex_pc = method->FindCatchBlock(to_find_, dex_pc);
1563 if (found_dex_pc != DexFile::kDexNoIndex) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001564 handler_dex_pc_ = found_dex_pc;
1565 handler_quick_frame_pc_ = method->ToNativePC(found_dex_pc);
1566 handler_quick_frame_ = GetCurrentQuickFrame();
Ian Rogers57b86d42012-03-27 16:05:41 -07001567 return false; // End stack walk.
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001568 }
1569 }
Ian Rogers57b86d42012-03-27 16:05:41 -07001570 return true; // Continue stack walk.
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001571 }
Ian Rogersbdb03912011-09-14 00:55:44 -07001572
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001573 void DoLongJump() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001574 Method* catch_method = *handler_quick_frame_;
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001575 Dbg::PostException(self_, throw_frame_id_, throw_method_, throw_dex_pc_,
Ian Rogers0399dde2012-06-06 17:09:28 -07001576 catch_method, handler_dex_pc_, exception_);
1577 if (kDebugExceptionDelivery) {
1578 if (catch_method == NULL) {
1579 LOG(INFO) << "Handler is upcall";
1580 } else {
1581 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1582 const DexFile& dex_file =
1583 class_linker->FindDexFile(catch_method->GetDeclaringClass()->GetDexCache());
1584 int line_number = dex_file.GetLineNumFromPC(catch_method, handler_dex_pc_);
1585 LOG(INFO) << "Handler: " << PrettyMethod(catch_method) << " (line: " << line_number << ")";
1586 }
1587 }
Ian Rogers52673ff2012-06-27 23:25:34 -07001588 self_->SetException(exception_); // Exception back in root set.
1589 self_->EndAssertNoThreadSuspension(last_no_assert_suspension_cause_);
Ian Rogers0399dde2012-06-06 17:09:28 -07001590 // Place context back on thread so it will be available when we continue.
1591 self_->ReleaseLongJumpContext(context_);
1592 context_->SetSP(reinterpret_cast<uintptr_t>(handler_quick_frame_));
1593 CHECK_NE(handler_quick_frame_pc_, 0u);
1594 context_->SetPC(handler_quick_frame_pc_);
1595 context_->SmashCallerSaves();
1596 context_->DoLongJump();
1597 }
1598
1599 private:
1600 Thread* self_;
1601 Throwable* exception_;
1602 // The type of the exception catch block to find.
Ian Rogersbdb03912011-09-14 00:55:44 -07001603 Class* to_find_;
Ian Rogers0399dde2012-06-06 17:09:28 -07001604 Method* throw_method_;
1605 JDWP::FrameId throw_frame_id_;
1606 uint32_t throw_dex_pc_;
1607 // Quick frame with found handler or last frame if no handler found.
1608 Method** handler_quick_frame_;
1609 // PC to branch to for the handler.
1610 uintptr_t handler_quick_frame_pc_;
1611 // Associated dex PC.
1612 uint32_t handler_dex_pc_;
Ian Rogers67375ac2011-09-14 00:55:44 -07001613 // Number of native methods passed in crawl (equates to number of SIRTs to pop)
1614 uint32_t native_method_count_;
Ian Rogers57b86d42012-03-27 16:05:41 -07001615 // Is method tracing active?
1616 const bool method_tracing_active_;
Ian Rogers52673ff2012-06-27 23:25:34 -07001617 // Support for nesting no thread suspension checks.
1618 const char* last_no_assert_suspension_cause_;
Ian Rogersbdb03912011-09-14 00:55:44 -07001619};
1620
Ian Rogersff1ed472011-09-20 13:46:24 -07001621void Thread::DeliverException() {
Elliott Hughesd07986f2011-12-06 18:27:45 -08001622 Throwable* exception = GetException(); // Get exception from thread
Ian Rogersff1ed472011-09-20 13:46:24 -07001623 CHECK(exception != NULL);
Ian Rogers28ad40d2011-10-27 15:19:26 -07001624 // Don't leave exception visible while we try to find the handler, which may cause class
Elliott Hughesd07986f2011-12-06 18:27:45 -08001625 // resolution.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001626 ClearException();
1627 if (kDebugExceptionDelivery) {
Ian Rogersa32a6fd2012-02-06 20:18:44 -08001628 String* msg = exception->GetDetailMessage();
1629 std::string str_msg(msg != NULL ? msg->ToModifiedUtf8() : "");
1630 DumpStack(LOG(INFO) << "Delivering exception: " << PrettyTypeOf(exception)
Elliott Hughesc073b072012-05-24 19:29:17 -07001631 << ": " << str_msg << "\n");
Ian Rogers28ad40d2011-10-27 15:19:26 -07001632 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001633 CatchBlockStackVisitor catch_finder(this, exception);
1634 catch_finder.WalkStack(true);
1635 catch_finder.DoLongJump();
Ian Rogers9a8a8882012-03-08 02:30:55 -08001636 LOG(FATAL) << "UNREACHABLE";
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001637}
1638
Ian Rogersbdb03912011-09-14 00:55:44 -07001639Context* Thread::GetLongJumpContext() {
Elliott Hughes85d15452011-09-16 17:33:01 -07001640 Context* result = long_jump_context_;
Ian Rogersbdb03912011-09-14 00:55:44 -07001641 if (result == NULL) {
1642 result = Context::Create();
Ian Rogers0399dde2012-06-06 17:09:28 -07001643 } else {
1644 long_jump_context_ = NULL; // Avoid context being shared.
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001645 }
Ian Rogersbdb03912011-09-14 00:55:44 -07001646 return result;
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001647}
1648
Ian Rogers0399dde2012-06-06 17:09:28 -07001649Method* Thread::GetCurrentMethod(uint32_t* dex_pc, size_t* frame_id) const {
1650 struct CurrentMethodVisitor : public StackVisitor {
1651 CurrentMethodVisitor(const ManagedStack* stack,
Ian Rogersca190662012-06-26 15:45:57 -07001652 const std::vector<TraceStackFrame>* trace_stack)
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001653 SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001654 : StackVisitor(stack, trace_stack, NULL), method_(NULL), dex_pc_(0), frame_id_(0) {}
Elliott Hughes8be2d402012-02-23 14:22:41 -08001655
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001656 virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001657 Method* m = GetMethod();
1658 if (m->IsRuntimeMethod()) {
1659 // Continue if this is a runtime method.
1660 return true;
1661 }
1662 method_ = m;
1663 dex_pc_ = GetDexPc();
1664 frame_id_ = GetFrameId();
1665 return false;
1666 }
1667 Method* method_;
1668 uint32_t dex_pc_;
1669 size_t frame_id_;
1670 };
1671
1672 CurrentMethodVisitor visitor(GetManagedStack(), GetTraceStack());
1673 visitor.WalkStack(false);
1674 if (dex_pc != NULL) {
1675 *dex_pc = visitor.dex_pc_;
Elliott Hughes9fd66f52011-10-16 12:13:26 -07001676 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001677 if (frame_id != NULL) {
1678 *frame_id = visitor.frame_id_;
jeffhao33dc7712011-11-09 17:54:24 -08001679 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001680 return visitor.method_;
jeffhao33dc7712011-11-09 17:54:24 -08001681}
1682
Elliott Hughes5f791332011-09-15 17:45:30 -07001683bool Thread::HoldsLock(Object* object) {
1684 if (object == NULL) {
1685 return false;
1686 }
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07001687 return object->GetThinLockId() == thin_lock_id_;
Elliott Hughes5f791332011-09-15 17:45:30 -07001688}
1689
Ian Rogers0399dde2012-06-06 17:09:28 -07001690class ReferenceMapVisitor : public StackVisitor {
Ian Rogersd6b1f612011-09-27 13:38:14 -07001691 public:
Ian Rogers0399dde2012-06-06 17:09:28 -07001692 ReferenceMapVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
Ian Rogersca190662012-06-26 15:45:57 -07001693 Context* context, Heap::RootVisitor* root_visitor, void* arg)
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001694 SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_)
Ian Rogersca190662012-06-26 15:45:57 -07001695 : StackVisitor(stack, trace_stack, context), root_visitor_(root_visitor), arg_(arg) {}
Ian Rogersd6b1f612011-09-27 13:38:14 -07001696
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001697 bool VisitFrame() SHARED_LOCKS_REQUIRED(GlobalSynchronization::mutator_lock_) {
Brian Carlstrom6a4be3a2011-10-20 16:34:03 -07001698 if (false) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001699 LOG(INFO) << "Visiting stack roots in " << PrettyMethod(GetMethod())
1700 << StringPrintf("@ PC:%04x", GetDexPc());
Brian Carlstrom6a4be3a2011-10-20 16:34:03 -07001701 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001702 ShadowFrame* shadow_frame = GetCurrentShadowFrame();
1703 if (shadow_frame != NULL) {
1704 shadow_frame->VisitRoots(root_visitor_, arg_);
1705 } else {
1706 Method* m = GetMethod();
1707 // Process register map (which native and runtime methods don't have)
Ian Rogers640495b2012-06-22 15:15:47 -07001708 if (!m->IsNative() && !m->IsRuntimeMethod() && !m->IsProxyMethod()) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001709 const uint8_t* gc_map = m->GetGcMap();
1710 CHECK(gc_map != NULL) << PrettyMethod(m);
1711 uint32_t gc_map_length = m->GetGcMapLength();
1712 CHECK_NE(0U, gc_map_length) << PrettyMethod(m);
1713 verifier::PcToReferenceMap map(gc_map, gc_map_length);
1714 const uint8_t* reg_bitmap = map.FindBitMap(GetDexPc());
1715 CHECK(reg_bitmap != NULL);
1716 const VmapTable vmap_table(m->GetVmapTableRaw());
1717 const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
Elliott Hughescaf76542012-06-28 16:08:22 -07001718 DCHECK(code_item != NULL) << PrettyMethod(m); // Can't be NULL or how would we compile its instructions?
Ian Rogers0399dde2012-06-06 17:09:28 -07001719 uint32_t core_spills = m->GetCoreSpillMask();
1720 uint32_t fp_spills = m->GetFpSpillMask();
1721 size_t frame_size = m->GetFrameSizeInBytes();
1722 // For all dex registers in the bitmap
1723 size_t num_regs = std::min(map.RegWidth() * 8,
1724 static_cast<size_t>(code_item->registers_size_));
Ian Rogers0ec569a2012-07-01 16:43:46 -07001725 Method** cur_quick_frame = GetCurrentQuickFrame();
1726 DCHECK(cur_quick_frame != NULL);
Ian Rogers0399dde2012-06-06 17:09:28 -07001727 for (size_t reg = 0; reg < num_regs; ++reg) {
1728 // Does this register hold a reference?
1729 if (TestBitmap(reg, reg_bitmap)) {
1730 uint32_t vmap_offset;
1731 Object* ref;
1732 if (vmap_table.IsInContext(reg, vmap_offset)) {
1733 // Compute the register we need to load from the context
1734 uint32_t spill_mask = core_spills;
1735 CHECK_LT(vmap_offset, static_cast<uint32_t>(__builtin_popcount(spill_mask)));
1736 uint32_t matches = 0;
1737 uint32_t spill_shifts = 0;
1738 while (matches != (vmap_offset + 1)) {
1739 DCHECK_NE(spill_mask, 0u);
1740 matches += spill_mask & 1; // Add 1 if the low bit is set
1741 spill_mask >>= 1;
1742 spill_shifts++;
1743 }
1744 spill_shifts--; // wind back one as we want the last match
1745 ref = reinterpret_cast<Object*>(GetGPR(spill_shifts));
1746 } else {
Ian Rogers0ec569a2012-07-01 16:43:46 -07001747 ref = reinterpret_cast<Object*>(GetVReg(cur_quick_frame, code_item, core_spills,
1748 fp_spills, frame_size, reg));
Ian Rogersd6b1f612011-09-27 13:38:14 -07001749 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001750 if (ref != NULL) {
1751 root_visitor_(ref, arg_);
1752 }
Shih-wei Liao4f894e32011-09-27 21:33:19 -07001753 }
Ian Rogersd6b1f612011-09-27 13:38:14 -07001754 }
1755 }
1756 }
Elliott Hughes530fa002012-03-12 11:44:49 -07001757 return true;
Ian Rogersd6b1f612011-09-27 13:38:14 -07001758 }
1759
1760 private:
1761 bool TestBitmap(int reg, const uint8_t* reg_vector) {
1762 return ((reg_vector[reg / 8] >> (reg % 8)) & 0x01) != 0;
1763 }
1764
Ian Rogersd6b1f612011-09-27 13:38:14 -07001765 // Call-back when we visit a root
1766 Heap::RootVisitor* root_visitor_;
1767 // Argument to call-back
1768 void* arg_;
1769};
1770
1771void Thread::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
Elliott Hughesd369bb72011-09-12 14:41:14 -07001772 if (exception_ != NULL) {
1773 visitor(exception_, arg);
1774 }
1775 if (peer_ != NULL) {
1776 visitor(peer_, arg);
1777 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001778 if (class_loader_override_ != NULL) {
1779 visitor(class_loader_override_, arg);
1780 }
Elliott Hughes410c0c82011-09-01 17:58:25 -07001781 jni_env_->locals.VisitRoots(visitor, arg);
1782 jni_env_->monitors.VisitRoots(visitor, arg);
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -07001783
1784 SirtVisitRoots(visitor, arg);
1785
Ian Rogersd6b1f612011-09-27 13:38:14 -07001786 // Visit roots on this thread's stack
Ian Rogers0399dde2012-06-06 17:09:28 -07001787 Context* context = GetLongJumpContext();
1788 ReferenceMapVisitor mapper(GetManagedStack(), GetTraceStack(), context, visitor, arg);
1789 mapper.WalkStack();
1790 ReleaseLongJumpContext(context);
Elliott Hughes410c0c82011-09-01 17:58:25 -07001791}
1792
jeffhao25045522012-03-13 19:34:37 -07001793#if VERIFY_OBJECT_ENABLED
Ian Rogers0399dde2012-06-06 17:09:28 -07001794static void VerifyObject(const Object* obj, void* arg) {
1795 Heap* heap = reinterpret_cast<Heap*>(arg);
1796 heap->VerifyObject(obj);
jeffhao25045522012-03-13 19:34:37 -07001797}
1798
1799void Thread::VerifyStack() {
jeffhaoe66ac792012-03-19 16:08:46 -07001800 UniquePtr<Context> context(Context::Create());
Ian Rogers67054b52012-06-26 16:02:10 -07001801 ReferenceMapVisitor mapper(GetManagedStack(), GetTraceStack(), context.get(), VerifyObject,
Ian Rogers0399dde2012-06-06 17:09:28 -07001802 Runtime::Current()->GetHeap());
1803 mapper.WalkStack();
jeffhao25045522012-03-13 19:34:37 -07001804}
1805#endif
1806
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001807// Set the stack end to that to be used during a stack overflow
1808void Thread::SetStackEndForStackOverflow() {
1809 // During stack overflow we allow use of the full stack
1810 if (stack_end_ == stack_begin_) {
1811 DumpStack(std::cerr);
1812 LOG(FATAL) << "Need to increase kStackOverflowReservedBytes (currently "
1813 << kStackOverflowReservedBytes << ")";
1814 }
1815
1816 stack_end_ = stack_begin_;
1817}
1818
Elliott Hughes330304d2011-08-12 14:28:05 -07001819std::ostream& operator<<(std::ostream& os, const Thread& thread) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001820 thread.ShortDump(os);
Elliott Hughes330304d2011-08-12 14:28:05 -07001821 return os;
1822}
1823
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001824#ifndef NDEBUG
1825void Thread::AssertThreadSuspensionIsAllowable(bool check_locks) const {
1826 CHECK_EQ(0u, no_thread_suspension_) << last_no_thread_suspension_cause_;
1827 if (check_locks) {
1828 bool bad_mutexes_held = false;
1829 for (int i = kMaxMutexLevel; i >= 0; --i) {
1830 // We expect no locks except the mutator_lock_.
1831 if (i != kMutatorLock) {
1832 BaseMutex* held_mutex = GetHeldMutex(static_cast<MutexLevel>(i));
1833 if (held_mutex != NULL) {
1834 LOG(ERROR) << "holding \"" << held_mutex->GetName()
1835 << "\" at point where thread suspension is expected";
Elliott Hughesffb465f2012-03-01 18:46:05 -08001836 bad_mutexes_held = true;
1837 }
1838 }
Elliott Hughesffb465f2012-03-01 18:46:05 -08001839 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001840 CHECK(!bad_mutexes_held);
Elliott Hughesffb465f2012-03-01 18:46:05 -08001841 }
1842}
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001843#endif
Elliott Hughesa4060e52012-03-02 16:51:35 -08001844
Elliott Hughes8daa0922011-09-11 13:46:25 -07001845} // namespace art