1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define ATRACE_TAG ATRACE_TAG_DALVIK
18
19#include "thread.h"
20
21#include <cutils/trace.h>
22#include <pthread.h>
23#include <signal.h>
24#include <sys/resource.h>
25#include <sys/time.h>
26
27#include <algorithm>
28#include <bitset>
29#include <cerrno>
30#include <iostream>
31#include <list>
32
33#include "arch/context.h"
34#include "base/mutex.h"
35#include "class_linker.h"
36#include "class_linker-inl.h"
37#include "cutils/atomic.h"
38#include "cutils/atomic-inline.h"
39#include "debugger.h"
40#include "dex_file-inl.h"
41#include "entrypoints/entrypoint_utils.h"
42#include "gc_map.h"
43#include "gc/accounting/card_table-inl.h"
44#include "gc/heap.h"
45#include "gc/space/space.h"
46#include "invoke_arg_array_builder.h"
47#include "jni_internal.h"
48#include "mirror/art_field-inl.h"
49#include "mirror/art_method-inl.h"
50#include "mirror/class-inl.h"
51#include "mirror/class_loader.h"
52#include "mirror/object_array-inl.h"
53#include "mirror/stack_trace_element.h"
54#include "monitor.h"
55#include "object_utils.h"
56#include "reflection.h"
57#include "runtime.h"
58#include "scoped_thread_state_change.h"
59#include "ScopedLocalRef.h"
60#include "ScopedUtfChars.h"
61#include "sirt_ref.h"
62#include "stack.h"
63#include "stack_indirect_reference_table.h"
64#include "thread-inl.h"
65#include "thread_list.h"
66#include "utils.h"
67#include "verifier/dex_gc_map.h"
68#include "verifier/method_verifier.h"
69#include "vmap_table.h"
70#include "well_known_classes.h"
71
72namespace art {
73
74bool Thread::is_started_ = false;
75pthread_key_t Thread::pthread_key_self_;
76ConditionVariable* Thread::resume_cond_ = NULL;
77
78static const char* kThreadNameDuringStartup = "<native thread without managed peer>";
79
80void Thread::InitCardTable() {
81  card_table_ = Runtime::Current()->GetHeap()->GetCardTable()->GetBiasedBegin();
82}
83
84#if !defined(__APPLE__)
85static void UnimplementedEntryPoint() {
86  UNIMPLEMENTED(FATAL);
87}
88#endif
89
90void InitEntryPoints(InterpreterEntryPoints* ipoints, JniEntryPoints* jpoints,
91                     PortableEntryPoints* ppoints, QuickEntryPoints* qpoints);
92
93void Thread::InitTlsEntryPoints() {
94#if !defined(__APPLE__)  // The Mac GCC is too old to accept this code.
95  // Insert a placeholder so we can easily tell if we call an unimplemented entry point.
96  uintptr_t* begin = reinterpret_cast<uintptr_t*>(&interpreter_entrypoints_);
97  uintptr_t* end = reinterpret_cast<uintptr_t*>(reinterpret_cast<uint8_t*>(begin) + sizeof(quick_entrypoints_));
98  for (uintptr_t* it = begin; it != end; ++it) {
99    *it = reinterpret_cast<uintptr_t>(UnimplementedEntryPoint);
100  }
101  begin = reinterpret_cast<uintptr_t*>(&interpreter_entrypoints_);
102  end = reinterpret_cast<uintptr_t*>(reinterpret_cast<uint8_t*>(begin) + sizeof(portable_entrypoints_));
103  for (uintptr_t* it = begin; it != end; ++it) {
104    *it = reinterpret_cast<uintptr_t>(UnimplementedEntryPoint);
105  }
106#endif
107  InitEntryPoints(&interpreter_entrypoints_, &jni_entrypoints_, &portable_entrypoints_,
108                  &quick_entrypoints_);
109}
110
111void Thread::SetDeoptimizationShadowFrame(ShadowFrame* sf) {
112  deoptimization_shadow_frame_ = sf;
113}
114
115void Thread::SetDeoptimizationReturnValue(const JValue& ret_val) {
116  deoptimization_return_value_.SetJ(ret_val.GetJ());
117}
118
119ShadowFrame* Thread::GetAndClearDeoptimizationShadowFrame(JValue* ret_val) {
120  ShadowFrame* sf = deoptimization_shadow_frame_;
121  deoptimization_shadow_frame_ = NULL;
122  ret_val->SetJ(deoptimization_return_value_.GetJ());
123  return sf;
124}
125
126void Thread::InitTid() {
127  tid_ = ::art::GetTid();
128}
129
130void Thread::InitAfterFork() {
131  // One thread (us) survived the fork, but we have a new tid so we need to
132  // update the value stashed in this Thread*.
133  InitTid();
134}
135
136void* Thread::CreateCallback(void* arg) {
137  Thread* self = reinterpret_cast<Thread*>(arg);
138  Runtime* runtime = Runtime::Current();
139  if (runtime == NULL) {
140    LOG(ERROR) << "Thread attaching to non-existent runtime: " << *self;
141    return NULL;
142  }
143  {
144    // TODO: pass self to MutexLock - requires self to equal Thread::Current(), which is only true
145    //       after self->Init().
146    MutexLock mu(NULL, *Locks::runtime_shutdown_lock_);
147    // Check that if we got here we cannot be shutting down (as shutdown should never have started
148    // while threads are being born).
149    CHECK(!runtime->IsShuttingDown());
150    self->Init(runtime->GetThreadList(), runtime->GetJavaVM());
151    Runtime::Current()->EndThreadBirth();
152  }
153  {
154    ScopedObjectAccess soa(self);
155
156    // Copy peer into self, deleting global reference when done.
157    CHECK(self->jpeer_ != NULL);
158    self->opeer_ = soa.Decode<mirror::Object*>(self->jpeer_);
159    self->GetJniEnv()->DeleteGlobalRef(self->jpeer_);
160    self->jpeer_ = NULL;
161
162    {
163      SirtRef<mirror::String> thread_name(self, self->GetThreadName(soa));
164      self->SetThreadName(thread_name->ToModifiedUtf8().c_str());
165    }
166    Dbg::PostThreadStart(self);
167
168    // Invoke the 'run' method of our java.lang.Thread.
169    mirror::Object* receiver = self->opeer_;
170    jmethodID mid = WellKnownClasses::java_lang_Thread_run;
171    mirror::ArtMethod* m =
172        receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
173    JValue result;
174    ArgArray arg_array(NULL, 0);
175    arg_array.Append(reinterpret_cast<uint32_t>(receiver));
176    m->Invoke(self, arg_array.GetArray(), arg_array.GetNumBytes(), &result, 'V');
177  }
178  // Detach and delete self.
179  Runtime::Current()->GetThreadList()->Unregister(self);
180
181  return NULL;
182}
183
184Thread* Thread::FromManagedThread(const ScopedObjectAccessUnchecked& soa,
185                                  mirror::Object* thread_peer) {
186  mirror::ArtField* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_nativePeer);
187  Thread* result = reinterpret_cast<Thread*>(static_cast<uintptr_t>(f->GetInt(thread_peer)));
188  // Sanity check that if we have a result it is either suspended or we hold the thread_list_lock_
189  // to stop it from going away.
190  if (kIsDebugBuild) {
191    MutexLock mu(soa.Self(), *Locks::thread_suspend_count_lock_);
192    if (result != NULL && !result->IsSuspended()) {
193      Locks::thread_list_lock_->AssertHeld(soa.Self());
194    }
195  }
196  return result;
197}
198
199Thread* Thread::FromManagedThread(const ScopedObjectAccessUnchecked& soa, jobject java_thread) {
200  return FromManagedThread(soa, soa.Decode<mirror::Object*>(java_thread));
201}
202
203static size_t FixStackSize(size_t stack_size) {
204  // A stack size of zero means "use the default".
205  if (stack_size == 0) {
206    stack_size = Runtime::Current()->GetDefaultStackSize();
207  }
208
209  // Dalvik used the bionic pthread default stack size for native threads,
210  // so include that here to support apps that expect large native stacks.
211  stack_size += 1 * MB;
212
213  // It's not possible to request a stack smaller than the system-defined PTHREAD_STACK_MIN.
214  if (stack_size < PTHREAD_STACK_MIN) {
215    stack_size = PTHREAD_STACK_MIN;
216  }
217
218  // It's likely that callers are trying to ensure they have at least a certain amount of
219  // stack space, so we should add our reserved space on top of what they requested, rather
220  // than implicitly take it away from them.
221  stack_size += Thread::kStackOverflowReservedBytes;
222
223  // Some systems require the stack size to be a multiple of the system page size, so round up.
224  stack_size = RoundUp(stack_size, kPageSize);
225
226  return stack_size;
227}
228
229void Thread::CreateNativeThread(JNIEnv* env, jobject java_peer, size_t stack_size, bool is_daemon) {
230  CHECK(java_peer != NULL);
231  Thread* self = static_cast<JNIEnvExt*>(env)->self;
232  Runtime* runtime = Runtime::Current();
233
234  // Atomically start the birth of the thread ensuring the runtime isn't shutting down.
235  bool thread_start_during_shutdown = false;
236  {
237    MutexLock mu(self, *Locks::runtime_shutdown_lock_);
238    if (runtime->IsShuttingDown()) {
239      thread_start_during_shutdown = true;
240    } else {
241      runtime->StartThreadBirth();
242    }
243  }
244  if (thread_start_during_shutdown) {
245    ScopedLocalRef<jclass> error_class(env, env->FindClass("java/lang/InternalError"));
246    env->ThrowNew(error_class.get(), "Thread starting during runtime shutdown");
247    return;
248  }
249
250  Thread* child_thread = new Thread(is_daemon);
251  // Use global JNI ref to hold peer live while child thread starts.
252  child_thread->jpeer_ = env->NewGlobalRef(java_peer);
253  stack_size = FixStackSize(stack_size);
254
255  // Thread.start is synchronized, so we know that nativePeer is 0, and know that we're not racing to
256  // assign it.
257  env->SetIntField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer,
258                   reinterpret_cast<jint>(child_thread));
259
260  pthread_t new_pthread;
261  pthread_attr_t attr;
262  CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
263  CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED), "PTHREAD_CREATE_DETACHED");
264  CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
265  int pthread_create_result = pthread_create(&new_pthread, &attr, Thread::CreateCallback, child_thread);
266  CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
267
268  if (pthread_create_result != 0) {
269    // pthread_create(3) failed, so clean up.
270    {
271      MutexLock mu(self, *Locks::runtime_shutdown_lock_);
272      runtime->EndThreadBirth();
273    }
274    // Manually delete the global reference since Thread::Init will not have been run.
275    env->DeleteGlobalRef(child_thread->jpeer_);
276    child_thread->jpeer_ = NULL;
277    delete child_thread;
278    child_thread = NULL;
279    // TODO: remove from thread group?
280    env->SetIntField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer, 0);
281    {
282      std::string msg(StringPrintf("pthread_create (%s stack) failed: %s",
283                                   PrettySize(stack_size).c_str(), strerror(pthread_create_result)));
284      ScopedObjectAccess soa(env);
285      soa.Self()->ThrowOutOfMemoryError(msg.c_str());
286    }
287  }
288}
289
290void Thread::Init(ThreadList* thread_list, JavaVMExt* java_vm) {
291  // This function does all the initialization that must be run by the native thread it applies to.
292  // (When we create a new thread from managed code, we allocate the Thread* in Thread::Create so
293  // we can handshake with the corresponding native thread when it's ready.) Check this native
294  // thread hasn't been through here already...
295  CHECK(Thread::Current() == NULL);
296  SetUpAlternateSignalStack();
297  InitCpu();
298  InitTlsEntryPoints();
299  InitCardTable();
300  InitTid();
301  // Set pthread_self_ ahead of pthread_setspecific, that makes Thread::Current function, this
302  // avoids pthread_self_ ever being invalid when discovered from Thread::Current().
303  pthread_self_ = pthread_self();
304  CHECK(is_started_);
305  CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, this), "attach self");
306  DCHECK_EQ(Thread::Current(), this);
307
308  thin_lock_id_ = thread_list->AllocThreadId(this);
309  InitStackHwm();
310
311  jni_env_ = new JNIEnvExt(this, java_vm);
312  thread_list->Register(this);
313}
314
315Thread* Thread::Attach(const char* thread_name, bool as_daemon, jobject thread_group,
316                       bool create_peer) {
317  Thread* self;
318  Runtime* runtime = Runtime::Current();
319  if (runtime == NULL) {
320    LOG(ERROR) << "Thread attaching to non-existent runtime: " << thread_name;
321    return NULL;
322  }
323  {
324    MutexLock mu(NULL, *Locks::runtime_shutdown_lock_);
325    if (runtime->IsShuttingDown()) {
326      LOG(ERROR) << "Thread attaching while runtime is shutting down: " << thread_name;
327      return NULL;
328    } else {
329      Runtime::Current()->StartThreadBirth();
330      self = new Thread(as_daemon);
331      self->Init(runtime->GetThreadList(), runtime->GetJavaVM());
332      Runtime::Current()->EndThreadBirth();
333    }
334  }
335
336  CHECK_NE(self->GetState(), kRunnable);
337  self->SetState(kNative);
338
339  // If we're the main thread, ClassLinker won't be created until after we're attached,
340  // so that thread needs a two-stage attach. Regular threads don't need this hack.
341  // In the compiler, all threads need this hack, because no-one's going to be getting
342  // a native peer!
343  if (create_peer) {
344    self->CreatePeer(thread_name, as_daemon, thread_group);
345  } else {
346    // These aren't necessary, but they improve diagnostics for unit tests & command-line tools.
347    if (thread_name != NULL) {
348      self->name_->assign(thread_name);
349      ::art::SetThreadName(thread_name);
350    }
351  }
352
353  return self;
354}
355
356void Thread::CreatePeer(const char* name, bool as_daemon, jobject thread_group) {
357  Runtime* runtime = Runtime::Current();
358  CHECK(runtime->IsStarted());
359  JNIEnv* env = jni_env_;
360
361  if (thread_group == NULL) {
362    thread_group = runtime->GetMainThreadGroup();
363  }
364  ScopedLocalRef<jobject> thread_name(env, env->NewStringUTF(name));
365  jint thread_priority = GetNativePriority();
366  jboolean thread_is_daemon = as_daemon;
367
368  ScopedLocalRef<jobject> peer(env, env->AllocObject(WellKnownClasses::java_lang_Thread));
369  if (peer.get() == NULL) {
370    CHECK(IsExceptionPending());
371    return;
372  }
373  {
374    ScopedObjectAccess soa(this);
375    opeer_ = soa.Decode<mirror::Object*>(peer.get());
376  }
377  env->CallNonvirtualVoidMethod(peer.get(),
378                                WellKnownClasses::java_lang_Thread,
379                                WellKnownClasses::java_lang_Thread_init,
380                                thread_group, thread_name.get(), thread_priority, thread_is_daemon);
381  AssertNoPendingException();
382
383  Thread* self = this;
384  DCHECK_EQ(self, Thread::Current());
385  jni_env_->SetIntField(peer.get(), WellKnownClasses::java_lang_Thread_nativePeer,
386                        reinterpret_cast<jint>(self));
387
388  ScopedObjectAccess soa(self);
389  SirtRef<mirror::String> peer_thread_name(soa.Self(), GetThreadName(soa));
390  if (peer_thread_name.get() == NULL) {
391    // The Thread constructor should have set the Thread.name to a
392    // non-null value. However, because we can run without code
393    // available (in the compiler, in tests), we manually assign the
394    // fields the constructor should have set.
395    soa.DecodeField(WellKnownClasses::java_lang_Thread_daemon)->
396        SetBoolean(opeer_, thread_is_daemon);
397    soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->
398        SetObject(opeer_, soa.Decode<mirror::Object*>(thread_group));
399    soa.DecodeField(WellKnownClasses::java_lang_Thread_name)->
400        SetObject(opeer_, soa.Decode<mirror::Object*>(thread_name.get()));
401    soa.DecodeField(WellKnownClasses::java_lang_Thread_priority)->
402        SetInt(opeer_, thread_priority);
403    peer_thread_name.reset(GetThreadName(soa));
404  }
405  // 'thread_name' may have been null, so don't trust 'peer_thread_name' to be non-null.
406  if (peer_thread_name.get() != NULL) {
407    SetThreadName(peer_thread_name->ToModifiedUtf8().c_str());
408  }
409}
410
411void Thread::SetThreadName(const char* name) {
412  name_->assign(name);
413  ::art::SetThreadName(name);
414  Dbg::DdmSendThreadNotification(this, CHUNK_TYPE("THNM"));
415}
416
417void Thread::InitStackHwm() {
418  void* stack_base;
419  size_t stack_size;
420  GetThreadStack(pthread_self_, stack_base, stack_size);
421
422  // TODO: include this in the thread dumps; potentially useful in SIGQUIT output?
423  VLOG(threads) << StringPrintf("Native stack is at %p (%s)", stack_base, PrettySize(stack_size).c_str());
424
425  stack_begin_ = reinterpret_cast<byte*>(stack_base);
426  stack_size_ = stack_size;
427
428  if (stack_size_ <= kStackOverflowReservedBytes) {
429    LOG(FATAL) << "Attempt to attach a thread with a too-small stack (" << stack_size_ << " bytes)";
430  }
431
432  // TODO: move this into the Linux GetThreadStack implementation.
433#if !defined(__APPLE__)
434  // If we're the main thread, check whether we were run with an unlimited stack. In that case,
435  // glibc will have reported a 2GB stack for our 32-bit process, and our stack overflow detection
436  // will be broken because we'll die long before we get close to 2GB.
437  bool is_main_thread = (::art::GetTid() == getpid());
438  if (is_main_thread) {
439    rlimit stack_limit;
440    if (getrlimit(RLIMIT_STACK, &stack_limit) == -1) {
441      PLOG(FATAL) << "getrlimit(RLIMIT_STACK) failed";
442    }
443    if (stack_limit.rlim_cur == RLIM_INFINITY) {
444      // Find the default stack size for new threads...
445      pthread_attr_t default_attributes;
446      size_t default_stack_size;
447      CHECK_PTHREAD_CALL(pthread_attr_init, (&default_attributes), "default stack size query");
448      CHECK_PTHREAD_CALL(pthread_attr_getstacksize, (&default_attributes, &default_stack_size),
449                         "default stack size query");
450      CHECK_PTHREAD_CALL(pthread_attr_destroy, (&default_attributes), "default stack size query");
451
452      // ...and use that as our limit.
453      size_t old_stack_size = stack_size_;
454      stack_size_ = default_stack_size;
455      stack_begin_ += (old_stack_size - stack_size_);
456      VLOG(threads) << "Limiting unlimited stack (reported as " << PrettySize(old_stack_size) << ")"
457                    << " to " << PrettySize(stack_size_)
458                    << " with base " << reinterpret_cast<void*>(stack_begin_);
459    }
460  }
461#endif
462
463  // Set stack_end_ to the bottom of the stack saving space of stack overflows
464  ResetDefaultStackEnd();
465
466  // Sanity check.
467  int stack_variable;
468  CHECK_GT(&stack_variable, reinterpret_cast<void*>(stack_end_));
469}
470
471void Thread::ShortDump(std::ostream& os) const {
472  os << "Thread[";
473  if (GetThinLockId() != 0) {
474    // If we're in kStarting, we won't have a thin lock id or tid yet.
475    os << GetThinLockId()
476             << ",tid=" << GetTid() << ',';
477  }
478  os << GetState()
479           << ",Thread*=" << this
480           << ",peer=" << opeer_
481           << ",\"" << *name_ << "\""
482           << "]";
483}
484
485void Thread::Dump(std::ostream& os) const {
486  DumpState(os);
487  DumpStack(os);
488}
489
490mirror::String* Thread::GetThreadName(const ScopedObjectAccessUnchecked& soa) const {
491  mirror::ArtField* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_name);
492  return (opeer_ != NULL) ? reinterpret_cast<mirror::String*>(f->GetObject(opeer_)) : NULL;
493}
494
495void Thread::GetThreadName(std::string& name) const {
496  name.assign(*name_);
497}
498
499uint64_t Thread::GetCpuMicroTime() const {
500#if defined(HAVE_POSIX_CLOCKS)
501  clockid_t cpu_clock_id;
502  pthread_getcpuclockid(pthread_self_, &cpu_clock_id);
503  timespec now;
504  clock_gettime(cpu_clock_id, &now);
505  return static_cast<uint64_t>(now.tv_sec) * 1000000LL + now.tv_nsec / 1000LL;
506#else
507  UNIMPLEMENTED(WARNING);
508  return -1;
509#endif
510}
511
512void Thread::AtomicSetFlag(ThreadFlag flag) {
513  android_atomic_or(flag, &state_and_flags_.as_int);
514}
515
516void Thread::AtomicClearFlag(ThreadFlag flag) {
517  android_atomic_and(-1 ^ flag, &state_and_flags_.as_int);
518}
519
520// Attempt to rectify locks so that we dump thread list with required locks before exiting.
521static void UnsafeLogFatalForSuspendCount(Thread* self, Thread* thread) NO_THREAD_SAFETY_ANALYSIS {
522  LOG(ERROR) << *thread << " suspend count already zero.";
523  Locks::thread_suspend_count_lock_->Unlock(self);
524  if (!Locks::mutator_lock_->IsSharedHeld(self)) {
525    Locks::mutator_lock_->SharedTryLock(self);
526    if (!Locks::mutator_lock_->IsSharedHeld(self)) {
527      LOG(WARNING) << "Dumping thread list without holding mutator_lock_";
528    }
529  }
530  if (!Locks::thread_list_lock_->IsExclusiveHeld(self)) {
531    Locks::thread_list_lock_->TryLock(self);
532    if (!Locks::thread_list_lock_->IsExclusiveHeld(self)) {
533      LOG(WARNING) << "Dumping thread list without holding thread_list_lock_";
534    }
535  }
536  std::ostringstream ss;
537  Runtime::Current()->GetThreadList()->DumpLocked(ss);
538  LOG(FATAL) << ss.str();
539}
540
541void Thread::ModifySuspendCount(Thread* self, int delta, bool for_debugger) {
542  DCHECK(delta == -1 || delta == +1 || delta == -debug_suspend_count_)
543      << delta << " " << debug_suspend_count_ << " " << this;
544  DCHECK_GE(suspend_count_, debug_suspend_count_) << this;
545  Locks::thread_suspend_count_lock_->AssertHeld(self);
546  if (this != self && !IsSuspended()) {
547    Locks::thread_list_lock_->AssertHeld(self);
548  }
549  if (UNLIKELY(delta < 0 && suspend_count_ <= 0)) {
550    UnsafeLogFatalForSuspendCount(self, this);
551    return;
552  }
553
554  suspend_count_ += delta;
555  if (for_debugger) {
556    debug_suspend_count_ += delta;
557  }
558
559  if (suspend_count_ == 0) {
560    AtomicClearFlag(kSuspendRequest);
561  } else {
562    AtomicSetFlag(kSuspendRequest);
563  }
564}
565
566void Thread::RunCheckpointFunction() {
567  CHECK(checkpoint_function_ != NULL);
568  ATRACE_BEGIN("Checkpoint function");
569  checkpoint_function_->Run(this);
570  ATRACE_END();
571}
572
573bool Thread::RequestCheckpoint(Closure* function) {
574  CHECK(!ReadFlag(kCheckpointRequest)) << "Already have a pending checkpoint request";
575  checkpoint_function_ = function;
576  union StateAndFlags old_state_and_flags = state_and_flags_;
577  // We must be runnable to request a checkpoint.
578  old_state_and_flags.as_struct.state = kRunnable;
579  union StateAndFlags new_state_and_flags = old_state_and_flags;
580  new_state_and_flags.as_struct.flags |= kCheckpointRequest;
581  int succeeded = android_atomic_cmpxchg(old_state_and_flags.as_int, new_state_and_flags.as_int,
582                                         &state_and_flags_.as_int);
583  return succeeded == 0;
584}
585
586void Thread::FullSuspendCheck() {
587  VLOG(threads) << this << " self-suspending";
588  ATRACE_BEGIN("Full suspend check");
589  // Make thread appear suspended to other threads, release mutator_lock_.
590  TransitionFromRunnableToSuspended(kSuspended);
591  // Transition back to runnable noting requests to suspend, re-acquire share on mutator_lock_.
592  TransitionFromSuspendedToRunnable();
593  ATRACE_END();
594  VLOG(threads) << this << " self-reviving";
595}
596
597Thread* Thread::SuspendForDebugger(jobject peer, bool request_suspension, bool* timed_out) {
598  static const useconds_t kTimeoutUs = 30 * 1000000;  // 30s.
599  useconds_t total_delay_us = 0;
600  useconds_t delay_us = 0;
601  bool did_suspend_request = false;
602  *timed_out = false;
603  while (true) {
604    Thread* thread;
605    {
606      ScopedObjectAccess soa(Thread::Current());
607      Thread* self = soa.Self();
608      MutexLock mu(self, *Locks::thread_list_lock_);
609      thread = Thread::FromManagedThread(soa, peer);
610      if (thread == NULL) {
611        JNIEnv* env = self->GetJniEnv();
612        ScopedLocalRef<jstring> scoped_name_string(env,
613                                                   (jstring)env->GetObjectField(peer,
614                                                              WellKnownClasses::java_lang_Thread_name));
615        ScopedUtfChars scoped_name_chars(env, scoped_name_string.get());
616        if (scoped_name_chars.c_str() == NULL) {
617            LOG(WARNING) << "No such thread for suspend: " << peer;
618            env->ExceptionClear();
619        } else {
620            LOG(WARNING) << "No such thread for suspend: " << peer << ":" << scoped_name_chars.c_str();
621        }
622
623        return NULL;
624      }
625      {
626        MutexLock mu(soa.Self(), *Locks::thread_suspend_count_lock_);
627        if (request_suspension) {
628          thread->ModifySuspendCount(soa.Self(), +1, true /* for_debugger */);
629          request_suspension = false;
630          did_suspend_request = true;
631        }
632        // IsSuspended on the current thread will fail as the current thread is changed into
633        // Runnable above. As the suspend count is now raised if this is the current thread
634        // it will self suspend on transition to Runnable, making it hard to work with. It's simpler
635        // to just explicitly handle the current thread in the callers to this code.
636        CHECK_NE(thread, soa.Self()) << "Attempt to suspend the current thread for the debugger";
637        // If thread is suspended (perhaps it was already not Runnable but didn't have a suspend
638        // count, or else we've waited and it has self suspended) or is the current thread, we're
639        // done.
640        if (thread->IsSuspended()) {
641          return thread;
642        }
643        if (total_delay_us >= kTimeoutUs) {
644          LOG(ERROR) << "Thread suspension timed out: " << peer;
645          if (did_suspend_request) {
646            thread->ModifySuspendCount(soa.Self(), -1, true /* for_debugger */);
647          }
648          *timed_out = true;
649          return NULL;
650        }
651      }
652      // Release locks and come out of runnable state.
653    }
654    for (int i = kLockLevelCount - 1; i >= 0; --i) {
655      BaseMutex* held_mutex = Thread::Current()->GetHeldMutex(static_cast<LockLevel>(i));
656      if (held_mutex != NULL) {
657        LOG(FATAL) << "Holding " << held_mutex->GetName()
658            << " while sleeping for thread suspension";
659      }
660    }
661    {
662      useconds_t new_delay_us = delay_us * 2;
663      CHECK_GE(new_delay_us, delay_us);
664      if (new_delay_us < 500000) {  // Don't allow sleeping to be more than 0.5s.
665        delay_us = new_delay_us;
666      }
667    }
668    if (delay_us == 0) {
669      sched_yield();
670      // Default to 1 milliseconds (note that this gets multiplied by 2 before the first sleep).
671      delay_us = 500;
672    } else {
673      usleep(delay_us);
674      total_delay_us += delay_us;
675    }
676  }
677}
678
679void Thread::DumpState(std::ostream& os, const Thread* thread, pid_t tid) {
680  std::string group_name;
681  int priority;
682  bool is_daemon = false;
683  Thread* self = Thread::Current();
684
685  if (self != NULL && thread != NULL && thread->opeer_ != NULL) {
686    ScopedObjectAccessUnchecked soa(self);
687    priority = soa.DecodeField(WellKnownClasses::java_lang_Thread_priority)->GetInt(thread->opeer_);
688    is_daemon = soa.DecodeField(WellKnownClasses::java_lang_Thread_daemon)->GetBoolean(thread->opeer_);
689
690    mirror::Object* thread_group =
691        soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(thread->opeer_);
692
693    if (thread_group != NULL) {
694      mirror::ArtField* group_name_field =
695          soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_name);
696      mirror::String* group_name_string =
697          reinterpret_cast<mirror::String*>(group_name_field->GetObject(thread_group));
698      group_name = (group_name_string != NULL) ? group_name_string->ToModifiedUtf8() : "<null>";
699    }
700  } else {
701    priority = GetNativePriority();
702  }
703
704  std::string scheduler_group_name(GetSchedulerGroupName(tid));
705  if (scheduler_group_name.empty()) {
706    scheduler_group_name = "default";
707  }
708
709  if (thread != NULL) {
710    os << '"' << *thread->name_ << '"';
711    if (is_daemon) {
712      os << " daemon";
713    }
714    os << " prio=" << priority
715       << " tid=" << thread->GetThinLockId()
716       << " " << thread->GetState();
717    if (thread->IsStillStarting()) {
718      os << " (still starting up)";
719    }
720    os << "\n";
721  } else {
722    os << '"' << ::art::GetThreadName(tid) << '"'
723       << " prio=" << priority
724       << " (not attached)\n";
725  }
726
727  if (thread != NULL) {
728    MutexLock mu(self, *Locks::thread_suspend_count_lock_);
729    os << "  | group=\"" << group_name << "\""
730       << " sCount=" << thread->suspend_count_
731       << " dsCount=" << thread->debug_suspend_count_
732       << " obj=" << reinterpret_cast<void*>(thread->opeer_)
733       << " self=" << reinterpret_cast<const void*>(thread) << "\n";
734  }
735
736  os << "  | sysTid=" << tid
737     << " nice=" << getpriority(PRIO_PROCESS, tid)
738     << " cgrp=" << scheduler_group_name;
739  if (thread != NULL) {
740    int policy;
741    sched_param sp;
742    CHECK_PTHREAD_CALL(pthread_getschedparam, (thread->pthread_self_, &policy, &sp), __FUNCTION__);
743    os << " sched=" << policy << "/" << sp.sched_priority
744       << " handle=" << reinterpret_cast<void*>(thread->pthread_self_);
745  }
746  os << "\n";
747
748  // Grab the scheduler stats for this thread.
749  std::string scheduler_stats;
750  if (ReadFileToString(StringPrintf("/proc/self/task/%d/schedstat", tid), &scheduler_stats)) {
751    scheduler_stats.resize(scheduler_stats.size() - 1);  // Lose the trailing '\n'.
752  } else {
753    scheduler_stats = "0 0 0";
754  }
755
756  char native_thread_state = '?';
757  int utime = 0;
758  int stime = 0;
759  int task_cpu = 0;
760  GetTaskStats(tid, native_thread_state, utime, stime, task_cpu);
761
762  os << "  | state=" << native_thread_state
763     << " schedstat=( " << scheduler_stats << " )"
764     << " utm=" << utime
765     << " stm=" << stime
766     << " core=" << task_cpu
767     << " HZ=" << sysconf(_SC_CLK_TCK) << "\n";
768  if (thread != NULL) {
769    os << "  | stack=" << reinterpret_cast<void*>(thread->stack_begin_) << "-" << reinterpret_cast<void*>(thread->stack_end_)
770       << " stackSize=" << PrettySize(thread->stack_size_) << "\n";
771  }
772}
773
774void Thread::DumpState(std::ostream& os) const {
775  Thread::DumpState(os, this, GetTid());
776}
777
778struct StackDumpVisitor : public StackVisitor {
779  StackDumpVisitor(std::ostream& os, Thread* thread, Context* context, bool can_allocate)
780      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
781      : StackVisitor(thread, context), os(os), thread(thread), can_allocate(can_allocate),
782        last_method(NULL), last_line_number(0), repetition_count(0), frame_count(0) {
783  }
784
785  virtual ~StackDumpVisitor() {
786    if (frame_count == 0) {
787      os << "  (no managed stack frames)\n";
788    }
789  }
790
791  bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
792    mirror::ArtMethod* m = GetMethod();
793    if (m->IsRuntimeMethod()) {
794      return true;
795    }
796    const int kMaxRepetition = 3;
797    mirror::Class* c = m->GetDeclaringClass();
798    const mirror::DexCache* dex_cache = c->GetDexCache();
799    int line_number = -1;
800    if (dex_cache != NULL) {  // be tolerant of bad input
801      const DexFile& dex_file = *dex_cache->GetDexFile();
802      line_number = dex_file.GetLineNumFromPC(m, GetDexPc());
803    }
804    if (line_number == last_line_number && last_method == m) {
805      repetition_count++;
806    } else {
807      if (repetition_count >= kMaxRepetition) {
808        os << "  ... repeated " << (repetition_count - kMaxRepetition) << " times\n";
809      }
810      repetition_count = 0;
811      last_line_number = line_number;
812      last_method = m;
813    }
814    if (repetition_count < kMaxRepetition) {
815      os << "  at " << PrettyMethod(m, false);
816      if (m->IsNative()) {
817        os << "(Native method)";
818      } else {
819        mh.ChangeMethod(m);
820        const char* source_file(mh.GetDeclaringClassSourceFile());
821        os << "(" << (source_file != NULL ? source_file : "unavailable")
822           << ":" << line_number << ")";
823      }
824      os << "\n";
825      if (frame_count == 0) {
826        Monitor::DescribeWait(os, thread);
827      }
828      if (can_allocate) {
829        Monitor::VisitLocks(this, DumpLockedObject, &os);
830      }
831    }
832
833    ++frame_count;
834    return true;
835  }
836
837  static void DumpLockedObject(mirror::Object* o, void* context)
838      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
839    std::ostream& os = *reinterpret_cast<std::ostream*>(context);
840    os << "  - locked <" << o << "> (a " << PrettyTypeOf(o) << ")\n";
841  }
842
843  std::ostream& os;
844  const Thread* thread;
845  const bool can_allocate;
846  MethodHelper mh;
847  mirror::ArtMethod* last_method;
848  int last_line_number;
849  int repetition_count;
850  int frame_count;
851};
852
853static bool ShouldShowNativeStack(const Thread* thread)
854    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
855  ThreadState state = thread->GetState();
856
857  // In native code somewhere in the VM (one of the kWaitingFor* states)? That's interesting.
858  if (state > kWaiting && state < kStarting) {
859    return true;
860  }
861
862  // In an Object.wait variant or Thread.sleep? That's not interesting.
863  if (state == kTimedWaiting || state == kSleeping || state == kWaiting) {
864    return false;
865  }
866
867  // In some other native method? That's interesting.
868  // We don't just check kNative because native methods will be in state kSuspended if they're
869  // calling back into the VM, or kBlocked if they're blocked on a monitor, or one of the
870  // thread-startup states if it's early enough in their life cycle (http://b/7432159).
871  mirror::ArtMethod* current_method = thread->GetCurrentMethod(NULL);
872  return current_method != NULL && current_method->IsNative();
873}
874
875void Thread::DumpStack(std::ostream& os) const {
876  // TODO: we call this code when dying but may not have suspended the thread ourself. The
877  //       IsSuspended check is therefore racy with the use for dumping (normally we inhibit
878  //       the race with the thread_suspend_count_lock_).
879  // No point dumping for an abort in debug builds where we'll hit the not suspended check in stack.
880  bool dump_for_abort = (gAborting > 0) && !kIsDebugBuild;
881  if (this == Thread::Current() || IsSuspended() || dump_for_abort) {
882    // If we're currently in native code, dump that stack before dumping the managed stack.
883    if (dump_for_abort || ShouldShowNativeStack(this)) {
884      DumpKernelStack(os, GetTid(), "  kernel: ", false);
885      DumpNativeStack(os, GetTid(), "  native: ", false);
886    }
887    UniquePtr<Context> context(Context::Create());
888    StackDumpVisitor dumper(os, const_cast<Thread*>(this), context.get(), !throwing_OutOfMemoryError_);
889    dumper.WalkStack();
890  } else {
891    os << "Not able to dump stack of thread that isn't suspended";
892  }
893}
894
895void Thread::ThreadExitCallback(void* arg) {
896  Thread* self = reinterpret_cast<Thread*>(arg);
897  if (self->thread_exit_check_count_ == 0) {
898    LOG(WARNING) << "Native thread exiting without having called DetachCurrentThread (maybe it's going to use a pthread_key_create destructor?): " << *self;
899    CHECK(is_started_);
900    CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, self), "reattach self");
901    self->thread_exit_check_count_ = 1;
902  } else {
903    LOG(FATAL) << "Native thread exited without calling DetachCurrentThread: " << *self;
904  }
905}
906
907void Thread::Startup() {
908  CHECK(!is_started_);
909  is_started_ = true;
910  {
911    // MutexLock to keep annotalysis happy.
912    //
913    // Note we use NULL for the thread because Thread::Current can
914    // return garbage since (is_started_ == true) and
915    // Thread::pthread_key_self_ is not yet initialized.
916    // This was seen on glibc.
917    MutexLock mu(NULL, *Locks::thread_suspend_count_lock_);
918    resume_cond_ = new ConditionVariable("Thread resumption condition variable",
919                                         *Locks::thread_suspend_count_lock_);
920  }
921
922  // Allocate a TLS slot.
923  CHECK_PTHREAD_CALL(pthread_key_create, (&Thread::pthread_key_self_, Thread::ThreadExitCallback), "self key");
924
925  // Double-check the TLS slot allocation.
926  if (pthread_getspecific(pthread_key_self_) != NULL) {
927    LOG(FATAL) << "Newly-created pthread TLS slot is not NULL";
928  }
929}
930
931void Thread::FinishStartup() {
932  Runtime* runtime = Runtime::Current();
933  CHECK(runtime->IsStarted());
934
935  // Finish attaching the main thread.
936  ScopedObjectAccess soa(Thread::Current());
937  Thread::Current()->CreatePeer("main", false, runtime->GetMainThreadGroup());
938
939  Runtime::Current()->GetClassLinker()->RunRootClinits();
940}
941
942void Thread::Shutdown() {
943  CHECK(is_started_);
944  is_started_ = false;
945  CHECK_PTHREAD_CALL(pthread_key_delete, (Thread::pthread_key_self_), "self key");
946  MutexLock mu(Thread::Current(), *Locks::thread_suspend_count_lock_);
947  if (resume_cond_ != NULL) {
948    delete resume_cond_;
949    resume_cond_ = NULL;
950  }
951}
952
953Thread::Thread(bool daemon)
954    : suspend_count_(0),
955      card_table_(NULL),
956      exception_(NULL),
957      stack_end_(NULL),
958      managed_stack_(),
959      jni_env_(NULL),
960      self_(NULL),
961      opeer_(NULL),
962      jpeer_(NULL),
963      stack_begin_(NULL),
964      stack_size_(0),
965      stack_trace_sample_(NULL),
966      trace_clock_base_(0),
967      thin_lock_id_(0),
968      tid_(0),
969      wait_mutex_(new Mutex("a thread wait mutex")),
970      wait_cond_(new ConditionVariable("a thread wait condition variable", *wait_mutex_)),
971      wait_monitor_(NULL),
972      interrupted_(false),
973      wait_next_(NULL),
974      monitor_enter_object_(NULL),
975      top_sirt_(NULL),
976      runtime_(NULL),
977      class_loader_override_(NULL),
978      long_jump_context_(NULL),
979      throwing_OutOfMemoryError_(false),
980      debug_suspend_count_(0),
981      debug_invoke_req_(new DebugInvokeReq),
982      deoptimization_shadow_frame_(NULL),
983      instrumentation_stack_(new std::deque<instrumentation::InstrumentationStackFrame>),
984      name_(new std::string(kThreadNameDuringStartup)),
985      daemon_(daemon),
986      pthread_self_(0),
987      no_thread_suspension_(0),
988      last_no_thread_suspension_cause_(NULL),
989      checkpoint_function_(0),
990      thread_exit_check_count_(0) {
991  CHECK_EQ((sizeof(Thread) % 4), 0U) << sizeof(Thread);
992  state_and_flags_.as_struct.flags = 0;
993  state_and_flags_.as_struct.state = kNative;
994  memset(&held_mutexes_[0], 0, sizeof(held_mutexes_));
995}
996
997bool Thread::IsStillStarting() const {
998  // You might think you can check whether the state is kStarting, but for much of thread startup,
999  // the thread is in kNative; it might also be in kVmWait.
1000  // You might think you can check whether the peer is NULL, but the peer is actually created and
1001  // assigned fairly early on, and needs to be.
1002  // It turns out that the last thing to change is the thread name; that's a good proxy for "has
1003  // this thread _ever_ entered kRunnable".
1004  return (jpeer_ == NULL && opeer_ == NULL) || (*name_ == kThreadNameDuringStartup);
1005}
1006
1007void Thread::AssertNoPendingException() const {
1008  if (UNLIKELY(IsExceptionPending())) {
1009    ScopedObjectAccess soa(Thread::Current());
1010    mirror::Throwable* exception = GetException(NULL);
1011    LOG(FATAL) << "No pending exception expected: " << exception->Dump();
1012  }
1013}
1014
1015static void MonitorExitVisitor(const mirror::Object* object, void* arg) NO_THREAD_SAFETY_ANALYSIS {
1016  Thread* self = reinterpret_cast<Thread*>(arg);
1017  mirror::Object* entered_monitor = const_cast<mirror::Object*>(object);
1018  if (self->HoldsLock(entered_monitor)) {
1019    LOG(WARNING) << "Calling MonitorExit on object "
1020                 << object << " (" << PrettyTypeOf(object) << ")"
1021                 << " left locked by native thread "
1022                 << *Thread::Current() << " which is detaching";
1023    entered_monitor->MonitorExit(self);
1024  }
1025}
1026
1027void Thread::Destroy() {
1028  Thread* self = this;
1029  DCHECK_EQ(self, Thread::Current());
1030
1031  if (opeer_ != NULL) {
1032    ScopedObjectAccess soa(self);
1033    // We may need to call user-supplied managed code, do this before final clean-up.
1034    HandleUncaughtExceptions(soa);
1035    RemoveFromThreadGroup(soa);
1036
1037    // this.nativePeer = 0;
1038    soa.DecodeField(WellKnownClasses::java_lang_Thread_nativePeer)->SetInt(opeer_, 0);
1039    Dbg::PostThreadDeath(self);
1040
1041    // Thread.join() is implemented as an Object.wait() on the Thread.lock object. Signal anyone
1042    // who is waiting.
1043    mirror::Object* lock =
1044        soa.DecodeField(WellKnownClasses::java_lang_Thread_lock)->GetObject(opeer_);
1045    // (This conditional is only needed for tests, where Thread.lock won't have been set.)
1046    if (lock != NULL) {
1047      ObjectLock locker(self, lock);
1048      locker.Notify();
1049    }
1050  }
1051
1052  // On thread detach, all monitors entered with JNI MonitorEnter are automatically exited.
1053  if (jni_env_ != NULL) {
1054    jni_env_->monitors.VisitRoots(MonitorExitVisitor, self);
1055  }
1056}
1057
1058Thread::~Thread() {
1059  if (jni_env_ != NULL && jpeer_ != NULL) {
1060    // If pthread_create fails we don't have a jni env here.
1061    jni_env_->DeleteGlobalRef(jpeer_);
1062    jpeer_ = NULL;
1063  }
1064  opeer_ = NULL;
1065
1066  delete jni_env_;
1067  jni_env_ = NULL;
1068
1069  CHECK_NE(GetState(), kRunnable);
1070  // We may be deleting a still born thread.
1071  SetStateUnsafe(kTerminated);
1072
1073  delete wait_cond_;
1074  delete wait_mutex_;
1075
1076  if (long_jump_context_ != NULL) {
1077    delete long_jump_context_;
1078  }
1079
1080  delete debug_invoke_req_;
1081  delete instrumentation_stack_;
1082  delete name_;
1083  delete stack_trace_sample_;
1084
1085  TearDownAlternateSignalStack();
1086}
1087
1088void Thread::HandleUncaughtExceptions(ScopedObjectAccess& soa) {
1089  if (!IsExceptionPending()) {
1090    return;
1091  }
1092  ScopedLocalRef<jobject> peer(jni_env_, soa.AddLocalReference<jobject>(opeer_));
1093  ScopedThreadStateChange tsc(this, kNative);
1094
1095  // Get and clear the exception.
1096  ScopedLocalRef<jthrowable> exception(jni_env_, jni_env_->ExceptionOccurred());
1097  jni_env_->ExceptionClear();
1098
1099  // If the thread has its own handler, use that.
1100  ScopedLocalRef<jobject> handler(jni_env_,
1101                                  jni_env_->GetObjectField(peer.get(),
1102                                                           WellKnownClasses::java_lang_Thread_uncaughtHandler));
1103  if (handler.get() == NULL) {
1104    // Otherwise use the thread group's default handler.
1105    handler.reset(jni_env_->GetObjectField(peer.get(), WellKnownClasses::java_lang_Thread_group));
1106  }
1107
1108  // Call the handler.
1109  jni_env_->CallVoidMethod(handler.get(),
1110                           WellKnownClasses::java_lang_Thread$UncaughtExceptionHandler_uncaughtException,
1111                           peer.get(), exception.get());
1112
1113  // If the handler threw, clear that exception too.
1114  jni_env_->ExceptionClear();
1115}
1116
1117void Thread::RemoveFromThreadGroup(ScopedObjectAccess& soa) {
1118  // this.group.removeThread(this);
1119  // group can be null if we're in the compiler or a test.
1120  mirror::Object* ogroup = soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(opeer_);
1121  if (ogroup != NULL) {
1122    ScopedLocalRef<jobject> group(soa.Env(), soa.AddLocalReference<jobject>(ogroup));
1123    ScopedLocalRef<jobject> peer(soa.Env(), soa.AddLocalReference<jobject>(opeer_));
1124    ScopedThreadStateChange tsc(soa.Self(), kNative);
1125    jni_env_->CallVoidMethod(group.get(), WellKnownClasses::java_lang_ThreadGroup_removeThread,
1126                             peer.get());
1127  }
1128}
1129
1130size_t Thread::NumSirtReferences() {
1131  size_t count = 0;
1132  for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
1133    count += cur->NumberOfReferences();
1134  }
1135  return count;
1136}
1137
1138bool Thread::SirtContains(jobject obj) const {
1139  mirror::Object** sirt_entry = reinterpret_cast<mirror::Object**>(obj);
1140  for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
1141    if (cur->Contains(sirt_entry)) {
1142      return true;
1143    }
1144  }
1145  // JNI code invoked from portable code uses shadow frames rather than the SIRT.
1146  return managed_stack_.ShadowFramesContain(sirt_entry);
1147}
1148
1149void Thread::SirtVisitRoots(RootVisitor* visitor, void* arg) {
1150  for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
1151    size_t num_refs = cur->NumberOfReferences();
1152    for (size_t j = 0; j < num_refs; j++) {
1153      mirror::Object* object = cur->GetReference(j);
1154      if (object != NULL) {
1155        visitor(object, arg);
1156      }
1157    }
1158  }
1159}
1160
1161mirror::Object* Thread::DecodeJObject(jobject obj) const {
1162  Locks::mutator_lock_->AssertSharedHeld(this);
1163  if (obj == NULL) {
1164    return NULL;
1165  }
1166  IndirectRef ref = reinterpret_cast<IndirectRef>(obj);
1167  IndirectRefKind kind = GetIndirectRefKind(ref);
1168  mirror::Object* result;
1169  // The "kinds" below are sorted by the frequency we expect to encounter them.
1170  if (kind == kLocal) {
1171    IndirectReferenceTable& locals = jni_env_->locals;
1172    result = const_cast<mirror::Object*>(locals.Get(ref));
1173  } else if (kind == kSirtOrInvalid) {
1174    // TODO: make stack indirect reference table lookup more efficient
1175    // Check if this is a local reference in the SIRT
1176    if (LIKELY(SirtContains(obj))) {
1177      result = *reinterpret_cast<mirror::Object**>(obj);  // Read from SIRT
1178    } else if (Runtime::Current()->GetJavaVM()->work_around_app_jni_bugs) {
1179      // Assume an invalid local reference is actually a direct pointer.
1180      result = reinterpret_cast<mirror::Object*>(obj);
1181    } else {
1182      result = kInvalidIndirectRefObject;
1183    }
1184  } else if (kind == kGlobal) {
1185    JavaVMExt* vm = Runtime::Current()->GetJavaVM();
1186    IndirectReferenceTable& globals = vm->globals;
1187    ReaderMutexLock mu(const_cast<Thread*>(this), vm->globals_lock);
1188    result = const_cast<mirror::Object*>(globals.Get(ref));
1189  } else {
1190    DCHECK_EQ(kind, kWeakGlobal);
1191    result = Runtime::Current()->GetJavaVM()->DecodeWeakGlobal(const_cast<Thread*>(this), ref);
1192    if (result == kClearedJniWeakGlobal) {
1193      // This is a special case where it's okay to return NULL.
1194      return NULL;
1195    }
1196  }
1197
1198  if (UNLIKELY(result == NULL)) {
1199    JniAbortF(NULL, "use of deleted %s %p", ToStr<IndirectRefKind>(kind).c_str(), obj);
1200  } else {
1201    if (kIsDebugBuild && (result != kInvalidIndirectRefObject)) {
1202      Runtime::Current()->GetHeap()->VerifyObject(result);
1203    }
1204  }
1205  return result;
1206}
1207
1208// Implements java.lang.Thread.interrupted.
1209bool Thread::Interrupted() {
1210  MutexLock mu(Thread::Current(), *wait_mutex_);
1211  bool interrupted = interrupted_;
1212  interrupted_ = false;
1213  return interrupted;
1214}
1215
1216// Implements java.lang.Thread.isInterrupted.
1217bool Thread::IsInterrupted() {
1218  MutexLock mu(Thread::Current(), *wait_mutex_);
1219  return interrupted_;
1220}
1221
1222void Thread::Interrupt() {
1223  Thread* self = Thread::Current();
1224  MutexLock mu(self, *wait_mutex_);
1225  if (interrupted_) {
1226    return;
1227  }
1228  interrupted_ = true;
1229  NotifyLocked(self);
1230}
1231
1232void Thread::Notify() {
1233  Thread* self = Thread::Current();
1234  MutexLock mu(self, *wait_mutex_);
1235  NotifyLocked(self);
1236}
1237
1238void Thread::NotifyLocked(Thread* self) {
1239  if (wait_monitor_ != NULL) {
1240    wait_cond_->Signal(self);
1241  }
1242}
1243
1244class CountStackDepthVisitor : public StackVisitor {
1245 public:
1246  explicit CountStackDepthVisitor(Thread* thread)
1247      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
1248      : StackVisitor(thread, NULL),
1249        depth_(0), skip_depth_(0), skipping_(true) {}
1250
1251  bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1252    // We want to skip frames up to and including the exception's constructor.
1253    // Note we also skip the frame if it doesn't have a method (namely the callee
1254    // save frame)
1255    mirror::ArtMethod* m = GetMethod();
1256    if (skipping_ && !m->IsRuntimeMethod() &&
1257        !mirror::Throwable::GetJavaLangThrowable()->IsAssignableFrom(m->GetDeclaringClass())) {
1258      skipping_ = false;
1259    }
1260    if (!skipping_) {
1261      if (!m->IsRuntimeMethod()) {  // Ignore runtime frames (in particular callee save).
1262        ++depth_;
1263      }
1264    } else {
1265      ++skip_depth_;
1266    }
1267    return true;
1268  }
1269
1270  int GetDepth() const {
1271    return depth_;
1272  }
1273
1274  int GetSkipDepth() const {
1275    return skip_depth_;
1276  }
1277
1278 private:
1279  uint32_t depth_;
1280  uint32_t skip_depth_;
1281  bool skipping_;
1282};
1283
1284class BuildInternalStackTraceVisitor : public StackVisitor {
1285 public:
1286  explicit BuildInternalStackTraceVisitor(Thread* self, Thread* thread, int skip_depth)
1287      : StackVisitor(thread, NULL), self_(self),
1288        skip_depth_(skip_depth), count_(0), dex_pc_trace_(NULL), method_trace_(NULL) {}
1289
1290  bool Init(int depth)
1291      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1292    // Allocate method trace with an extra slot that will hold the PC trace
1293    SirtRef<mirror::ObjectArray<mirror::Object> >
1294        method_trace(self_,
1295                     Runtime::Current()->GetClassLinker()->AllocObjectArray<mirror::Object>(self_,
1296                                                                                            depth + 1));
1297    if (method_trace.get() == NULL) {
1298      return false;
1299    }
1300    mirror::IntArray* dex_pc_trace = mirror::IntArray::Alloc(self_, depth);
1301    if (dex_pc_trace == NULL) {
1302      return false;
1303    }
1304    // Save PC trace in last element of method trace, also places it into the
1305    // object graph.
1306    method_trace->Set(depth, dex_pc_trace);
1307    // Set the Object*s and assert that no thread suspension is now possible.
1308    const char* last_no_suspend_cause =
1309        self_->StartAssertNoThreadSuspension("Building internal stack trace");
1310    CHECK(last_no_suspend_cause == NULL) << last_no_suspend_cause;
1311    method_trace_ = method_trace.get();
1312    dex_pc_trace_ = dex_pc_trace;
1313    return true;
1314  }
1315
1316  virtual ~BuildInternalStackTraceVisitor() {
1317    if (method_trace_ != NULL) {
1318      self_->EndAssertNoThreadSuspension(NULL);
1319    }
1320  }
1321
1322  bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1323    if (method_trace_ == NULL || dex_pc_trace_ == NULL) {
1324      return true;  // We're probably trying to fillInStackTrace for an OutOfMemoryError.
1325    }
1326    if (skip_depth_ > 0) {
1327      skip_depth_--;
1328      return true;
1329    }
1330    mirror::ArtMethod* m = GetMethod();
1331    if (m->IsRuntimeMethod()) {
1332      return true;  // Ignore runtime frames (in particular callee save).
1333    }
1334    method_trace_->Set(count_, m);
1335    dex_pc_trace_->Set(count_, GetDexPc());
1336    ++count_;
1337    return true;
1338  }
1339
1340  mirror::ObjectArray<mirror::Object>* GetInternalStackTrace() const {
1341    return method_trace_;
1342  }
1343
1344 private:
1345  Thread* const self_;
1346  // How many more frames to skip.
1347  int32_t skip_depth_;
1348  // Current position down stack trace.
1349  uint32_t count_;
1350  // Array of dex PC values.
1351  mirror::IntArray* dex_pc_trace_;
1352  // An array of the methods on the stack, the last entry is a reference to the PC trace.
1353  mirror::ObjectArray<mirror::Object>* method_trace_;
1354};
1355
1356jobject Thread::CreateInternalStackTrace(const ScopedObjectAccessUnchecked& soa) const {
1357  // Compute depth of stack
1358  CountStackDepthVisitor count_visitor(const_cast<Thread*>(this));
1359  count_visitor.WalkStack();
1360  int32_t depth = count_visitor.GetDepth();
1361  int32_t skip_depth = count_visitor.GetSkipDepth();
1362
1363  // Build internal stack trace.
1364  BuildInternalStackTraceVisitor build_trace_visitor(soa.Self(), const_cast<Thread*>(this),
1365                                                     skip_depth);
1366  if (!build_trace_visitor.Init(depth)) {
1367    return NULL;  // Allocation failed.
1368  }
1369  build_trace_visitor.WalkStack();
1370  mirror::ObjectArray<mirror::Object>* trace = build_trace_visitor.GetInternalStackTrace();
1371  if (kIsDebugBuild) {
1372    for (int32_t i = 0; i < trace->GetLength(); ++i) {
1373      CHECK(trace->Get(i) != NULL);
1374    }
1375  }
1376  return soa.AddLocalReference<jobjectArray>(trace);
1377}
1378
1379jobjectArray Thread::InternalStackTraceToStackTraceElementArray(JNIEnv* env, jobject internal,
1380    jobjectArray output_array, int* stack_depth) {
1381  // Transition into runnable state to work on Object*/Array*
1382  ScopedObjectAccess soa(env);
1383  // Decode the internal stack trace into the depth, method trace and PC trace
1384  mirror::ObjectArray<mirror::Object>* method_trace =
1385      soa.Decode<mirror::ObjectArray<mirror::Object>*>(internal);
1386  int32_t depth = method_trace->GetLength() - 1;
1387  mirror::IntArray* pc_trace = down_cast<mirror::IntArray*>(method_trace->Get(depth));
1388
1389  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1390
1391  jobjectArray result;
1392  mirror::ObjectArray<mirror::StackTraceElement>* java_traces;
1393  if (output_array != NULL) {
1394    // Reuse the array we were given.
1395    result = output_array;
1396    java_traces = soa.Decode<mirror::ObjectArray<mirror::StackTraceElement>*>(output_array);
1397    // ...adjusting the number of frames we'll write to not exceed the array length.
1398    depth = std::min(depth, java_traces->GetLength());
1399  } else {
1400    // Create java_trace array and place in local reference table
1401    java_traces = class_linker->AllocStackTraceElementArray(soa.Self(), depth);
1402    if (java_traces == NULL) {
1403      return NULL;
1404    }
1405    result = soa.AddLocalReference<jobjectArray>(java_traces);
1406  }
1407
1408  if (stack_depth != NULL) {
1409    *stack_depth = depth;
1410  }
1411
1412  MethodHelper mh;
1413  for (int32_t i = 0; i < depth; ++i) {
1414    // Prepare parameters for StackTraceElement(String cls, String method, String file, int line)
1415    mirror::ArtMethod* method = down_cast<mirror::ArtMethod*>(method_trace->Get(i));
1416    mh.ChangeMethod(method);
1417    uint32_t dex_pc = pc_trace->Get(i);
1418    int32_t line_number = mh.GetLineNumFromDexPC(dex_pc);
1419    // Allocate element, potentially triggering GC
1420    // TODO: reuse class_name_object via Class::name_?
1421    const char* descriptor = mh.GetDeclaringClassDescriptor();
1422    CHECK(descriptor != NULL);
1423    std::string class_name(PrettyDescriptor(descriptor));
1424    SirtRef<mirror::String> class_name_object(soa.Self(),
1425                                              mirror::String::AllocFromModifiedUtf8(soa.Self(),
1426                                                                                    class_name.c_str()));
1427    if (class_name_object.get() == NULL) {
1428      return NULL;
1429    }
1430    const char* method_name = mh.GetName();
1431    CHECK(method_name != NULL);
1432    SirtRef<mirror::String> method_name_object(soa.Self(),
1433                                               mirror::String::AllocFromModifiedUtf8(soa.Self(),
1434                                                                                     method_name));
1435    if (method_name_object.get() == NULL) {
1436      return NULL;
1437    }
1438    const char* source_file = mh.GetDeclaringClassSourceFile();
1439    SirtRef<mirror::String> source_name_object(soa.Self(), mirror::String::AllocFromModifiedUtf8(soa.Self(),
1440                                                                                                 source_file));
1441    mirror::StackTraceElement* obj = mirror::StackTraceElement::Alloc(soa.Self(),
1442                                                                      class_name_object.get(),
1443                                                                      method_name_object.get(),
1444                                                                      source_name_object.get(),
1445                                                                      line_number);
1446    if (obj == NULL) {
1447      return NULL;
1448    }
1449#ifdef MOVING_GARBAGE_COLLECTOR
1450    // Re-read after potential GC
1451    java_traces = Decode<ObjectArray<Object>*>(soa.Env(), result);
1452    method_trace = down_cast<ObjectArray<Object>*>(Decode<Object*>(soa.Env(), internal));
1453    pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
1454#endif
1455    java_traces->Set(i, obj);
1456  }
1457  return result;
1458}
1459
1460void Thread::ThrowNewExceptionF(const ThrowLocation& throw_location,
1461                                const char* exception_class_descriptor, const char* fmt, ...) {
1462  va_list args;
1463  va_start(args, fmt);
1464  ThrowNewExceptionV(throw_location, exception_class_descriptor,
1465                     fmt, args);
1466  va_end(args);
1467}
1468
1469void Thread::ThrowNewExceptionV(const ThrowLocation& throw_location,
1470                                const char* exception_class_descriptor,
1471                                const char* fmt, va_list ap) {
1472  std::string msg;
1473  StringAppendV(&msg, fmt, ap);
1474  ThrowNewException(throw_location, exception_class_descriptor, msg.c_str());
1475}
1476
1477void Thread::ThrowNewException(const ThrowLocation& throw_location, const char* exception_class_descriptor,
1478                               const char* msg) {
1479  AssertNoPendingException();  // Callers should either clear or call ThrowNewWrappedException.
1480  ThrowNewWrappedException(throw_location, exception_class_descriptor, msg);
1481}
1482
1483void Thread::ThrowNewWrappedException(const ThrowLocation& throw_location,
1484                                      const char* exception_class_descriptor,
1485                                      const char* msg) {
1486  DCHECK_EQ(this, Thread::Current());
1487  // Ensure we don't forget arguments over object allocation.
1488  SirtRef<mirror::Object> saved_throw_this(this, throw_location.GetThis());
1489  SirtRef<mirror::ArtMethod> saved_throw_method(this, throw_location.GetMethod());
1490  // Ignore the cause throw location. TODO: should we report this as a re-throw?
1491  SirtRef<mirror::Throwable> cause(this, GetException(NULL));
1492  ClearException();
1493  Runtime* runtime = Runtime::Current();
1494
1495  mirror::ClassLoader* cl = NULL;
1496  if (throw_location.GetMethod() != NULL) {
1497    cl = throw_location.GetMethod()->GetDeclaringClass()->GetClassLoader();
1498  }
1499  SirtRef<mirror::Class>
1500      exception_class(this, runtime->GetClassLinker()->FindClass(exception_class_descriptor, cl));
1501  if (UNLIKELY(exception_class.get() == NULL)) {
1502    CHECK(IsExceptionPending());
1503    LOG(ERROR) << "No exception class " << PrettyDescriptor(exception_class_descriptor);
1504    return;
1505  }
1506
1507  if (UNLIKELY(!runtime->GetClassLinker()->EnsureInitialized(exception_class.get(), true, true))) {
1508    DCHECK(IsExceptionPending());
1509    return;
1510  }
1511  DCHECK(!runtime->IsStarted() || exception_class->IsThrowableClass());
1512  SirtRef<mirror::Throwable> exception(this,
1513                                down_cast<mirror::Throwable*>(exception_class->AllocObject(this)));
1514
1515  // Choose an appropriate constructor and set up the arguments.
1516  const char* signature;
1517  SirtRef<mirror::String> msg_string(this, NULL);
1518  if (msg != NULL) {
1519    // Ensure we remember this and the method over the String allocation.
1520    msg_string.reset(mirror::String::AllocFromModifiedUtf8(this, msg));
1521    if (UNLIKELY(msg_string.get() == NULL)) {
1522      CHECK(IsExceptionPending());  // OOME.
1523      return;
1524    }
1525    if (cause.get() == NULL) {
1526      signature = "(Ljava/lang/String;)V";
1527    } else {
1528      signature = "(Ljava/lang/String;Ljava/lang/Throwable;)V";
1529    }
1530  } else {
1531    if (cause.get() == NULL) {
1532      signature = "()V";
1533    } else {
1534      signature = "(Ljava/lang/Throwable;)V";
1535    }
1536  }
1537  mirror::ArtMethod* exception_init_method =
1538      exception_class->FindDeclaredDirectMethod("<init>", signature);
1539
1540  CHECK(exception_init_method != NULL) << "No <init>" << signature << " in "
1541      << PrettyDescriptor(exception_class_descriptor);
1542
1543  if (UNLIKELY(!runtime->IsStarted())) {
1544    // Something is trying to throw an exception without a started runtime, which is the common
1545    // case in the compiler. We won't be able to invoke the constructor of the exception, so set
1546    // the exception fields directly.
1547    if (msg != NULL) {
1548      exception->SetDetailMessage(msg_string.get());
1549    }
1550    if (cause.get() != NULL) {
1551      exception->SetCause(cause.get());
1552    }
1553    ThrowLocation gc_safe_throw_location(saved_throw_this.get(), saved_throw_method.get(),
1554                                         throw_location.GetDexPc());
1555    SetException(gc_safe_throw_location, exception.get());
1556  } else {
1557    ArgArray args("VLL", 3);
1558    args.Append(reinterpret_cast<uint32_t>(exception.get()));
1559    if (msg != NULL) {
1560      args.Append(reinterpret_cast<uint32_t>(msg_string.get()));
1561    }
1562    if (cause.get() != NULL) {
1563      args.Append(reinterpret_cast<uint32_t>(cause.get()));
1564    }
1565    JValue result;
1566    exception_init_method->Invoke(this, args.GetArray(), args.GetNumBytes(), &result, 'V');
1567    if (LIKELY(!IsExceptionPending())) {
1568      ThrowLocation gc_safe_throw_location(saved_throw_this.get(), saved_throw_method.get(),
1569                                           throw_location.GetDexPc());
1570      SetException(gc_safe_throw_location, exception.get());
1571    }
1572  }
1573}
1574
1575void Thread::ThrowOutOfMemoryError(const char* msg) {
1576  LOG(ERROR) << StringPrintf("Throwing OutOfMemoryError \"%s\"%s",
1577      msg, (throwing_OutOfMemoryError_ ? " (recursive case)" : ""));
1578  ThrowLocation throw_location = GetCurrentLocationForThrow();
1579  if (!throwing_OutOfMemoryError_) {
1580    throwing_OutOfMemoryError_ = true;
1581    ThrowNewException(throw_location, "Ljava/lang/OutOfMemoryError;", msg);
1582    throwing_OutOfMemoryError_ = false;
1583  } else {
1584    Dump(LOG(ERROR));  // The pre-allocated OOME has no stack, so help out and log one.
1585    SetException(throw_location, Runtime::Current()->GetPreAllocatedOutOfMemoryError());
1586  }
1587}
1588
1589Thread* Thread::CurrentFromGdb() {
1590  return Thread::Current();
1591}
1592
1593void Thread::DumpFromGdb() const {
1594  std::ostringstream ss;
1595  Dump(ss);
1596  std::string str(ss.str());
1597  // log to stderr for debugging command line processes
1598  std::cerr << str;
1599#ifdef HAVE_ANDROID_OS
1600  // log to logcat for debugging frameworks processes
1601  LOG(INFO) << str;
1602#endif
1603}
1604
1605struct EntryPointInfo {
1606  uint32_t offset;
1607  const char* name;
1608};
1609#define INTERPRETER_ENTRY_POINT_INFO(x) { INTERPRETER_ENTRYPOINT_OFFSET(x).Uint32Value(), #x }
1610#define JNI_ENTRY_POINT_INFO(x)         { JNI_ENTRYPOINT_OFFSET(x).Uint32Value(), #x }
1611#define PORTABLE_ENTRY_POINT_INFO(x)    { PORTABLE_ENTRYPOINT_OFFSET(x).Uint32Value(), #x }
1612#define QUICK_ENTRY_POINT_INFO(x)       { QUICK_ENTRYPOINT_OFFSET(x).Uint32Value(), #x }
1613static const EntryPointInfo gThreadEntryPointInfo[] = {
1614  INTERPRETER_ENTRY_POINT_INFO(pInterpreterToInterpreterBridge),
1615  INTERPRETER_ENTRY_POINT_INFO(pInterpreterToCompiledCodeBridge),
1616  JNI_ENTRY_POINT_INFO(pDlsymLookup),
1617  PORTABLE_ENTRY_POINT_INFO(pPortableResolutionTrampoline),
1618  PORTABLE_ENTRY_POINT_INFO(pPortableToInterpreterBridge),
1619  QUICK_ENTRY_POINT_INFO(pAllocArray),
1620  QUICK_ENTRY_POINT_INFO(pAllocArrayWithAccessCheck),
1621  QUICK_ENTRY_POINT_INFO(pAllocObject),
1622  QUICK_ENTRY_POINT_INFO(pAllocObjectWithAccessCheck),
1623  QUICK_ENTRY_POINT_INFO(pCheckAndAllocArray),
1624  QUICK_ENTRY_POINT_INFO(pCheckAndAllocArrayWithAccessCheck),
1625  QUICK_ENTRY_POINT_INFO(pInstanceofNonTrivial),
1626  QUICK_ENTRY_POINT_INFO(pCanPutArrayElement),
1627  QUICK_ENTRY_POINT_INFO(pCheckCast),
1628  QUICK_ENTRY_POINT_INFO(pInitializeStaticStorage),
1629  QUICK_ENTRY_POINT_INFO(pInitializeTypeAndVerifyAccess),
1630  QUICK_ENTRY_POINT_INFO(pInitializeType),
1631  QUICK_ENTRY_POINT_INFO(pResolveString),
1632  QUICK_ENTRY_POINT_INFO(pSet32Instance),
1633  QUICK_ENTRY_POINT_INFO(pSet32Static),
1634  QUICK_ENTRY_POINT_INFO(pSet64Instance),
1635  QUICK_ENTRY_POINT_INFO(pSet64Static),
1636  QUICK_ENTRY_POINT_INFO(pSetObjInstance),
1637  QUICK_ENTRY_POINT_INFO(pSetObjStatic),
1638  QUICK_ENTRY_POINT_INFO(pGet32Instance),
1639  QUICK_ENTRY_POINT_INFO(pGet32Static),
1640  QUICK_ENTRY_POINT_INFO(pGet64Instance),
1641  QUICK_ENTRY_POINT_INFO(pGet64Static),
1642  QUICK_ENTRY_POINT_INFO(pGetObjInstance),
1643  QUICK_ENTRY_POINT_INFO(pGetObjStatic),
1644  QUICK_ENTRY_POINT_INFO(pHandleFillArrayData),
1645  QUICK_ENTRY_POINT_INFO(pJniMethodStart),
1646  QUICK_ENTRY_POINT_INFO(pJniMethodStartSynchronized),
1647  QUICK_ENTRY_POINT_INFO(pJniMethodEnd),
1648  QUICK_ENTRY_POINT_INFO(pJniMethodEndSynchronized),
1649  QUICK_ENTRY_POINT_INFO(pJniMethodEndWithReference),
1650  QUICK_ENTRY_POINT_INFO(pJniMethodEndWithReferenceSynchronized),
1651  QUICK_ENTRY_POINT_INFO(pLockObject),
1652  QUICK_ENTRY_POINT_INFO(pUnlockObject),
1653  QUICK_ENTRY_POINT_INFO(pCmpgDouble),
1654  QUICK_ENTRY_POINT_INFO(pCmpgFloat),
1655  QUICK_ENTRY_POINT_INFO(pCmplDouble),
1656  QUICK_ENTRY_POINT_INFO(pCmplFloat),
1657  QUICK_ENTRY_POINT_INFO(pFmod),
1658  QUICK_ENTRY_POINT_INFO(pSqrt),
1659  QUICK_ENTRY_POINT_INFO(pL2d),
1660  QUICK_ENTRY_POINT_INFO(pFmodf),
1661  QUICK_ENTRY_POINT_INFO(pL2f),
1662  QUICK_ENTRY_POINT_INFO(pD2iz),
1663  QUICK_ENTRY_POINT_INFO(pF2iz),
1664  QUICK_ENTRY_POINT_INFO(pIdivmod),
1665  QUICK_ENTRY_POINT_INFO(pD2l),
1666  QUICK_ENTRY_POINT_INFO(pF2l),
1667  QUICK_ENTRY_POINT_INFO(pLdiv),
1668  QUICK_ENTRY_POINT_INFO(pLdivmod),
1669  QUICK_ENTRY_POINT_INFO(pLmul),
1670  QUICK_ENTRY_POINT_INFO(pShlLong),
1671  QUICK_ENTRY_POINT_INFO(pShrLong),
1672  QUICK_ENTRY_POINT_INFO(pUshrLong),
1673  QUICK_ENTRY_POINT_INFO(pIndexOf),
1674  QUICK_ENTRY_POINT_INFO(pMemcmp16),
1675  QUICK_ENTRY_POINT_INFO(pStringCompareTo),
1676  QUICK_ENTRY_POINT_INFO(pMemcpy),
1677  QUICK_ENTRY_POINT_INFO(pQuickResolutionTrampoline),
1678  QUICK_ENTRY_POINT_INFO(pQuickToInterpreterBridge),
1679  QUICK_ENTRY_POINT_INFO(pInvokeDirectTrampolineWithAccessCheck),
1680  QUICK_ENTRY_POINT_INFO(pInvokeInterfaceTrampoline),
1681  QUICK_ENTRY_POINT_INFO(pInvokeInterfaceTrampolineWithAccessCheck),
1682  QUICK_ENTRY_POINT_INFO(pInvokeStaticTrampolineWithAccessCheck),
1683  QUICK_ENTRY_POINT_INFO(pInvokeSuperTrampolineWithAccessCheck),
1684  QUICK_ENTRY_POINT_INFO(pInvokeVirtualTrampolineWithAccessCheck),
1685  QUICK_ENTRY_POINT_INFO(pCheckSuspend),
1686  QUICK_ENTRY_POINT_INFO(pTestSuspend),
1687  QUICK_ENTRY_POINT_INFO(pDeliverException),
1688  QUICK_ENTRY_POINT_INFO(pThrowArrayBounds),
1689  QUICK_ENTRY_POINT_INFO(pThrowDivZero),
1690  QUICK_ENTRY_POINT_INFO(pThrowNoSuchMethod),
1691  QUICK_ENTRY_POINT_INFO(pThrowNullPointer),
1692  QUICK_ENTRY_POINT_INFO(pThrowStackOverflow),
1693};
1694#undef QUICK_ENTRY_POINT_INFO
1695
1696void Thread::DumpThreadOffset(std::ostream& os, uint32_t offset, size_t size_of_pointers) {
1697  CHECK_EQ(size_of_pointers, 4U);  // TODO: support 64-bit targets.
1698
1699#define DO_THREAD_OFFSET(x) \
1700    if (offset == static_cast<uint32_t>(OFFSETOF_VOLATILE_MEMBER(Thread, x))) { \
1701      os << # x; \
1702      return; \
1703    }
1704  DO_THREAD_OFFSET(state_and_flags_);
1705  DO_THREAD_OFFSET(card_table_);
1706  DO_THREAD_OFFSET(exception_);
1707  DO_THREAD_OFFSET(opeer_);
1708  DO_THREAD_OFFSET(jni_env_);
1709  DO_THREAD_OFFSET(self_);
1710  DO_THREAD_OFFSET(stack_end_);
1711  DO_THREAD_OFFSET(suspend_count_);
1712  DO_THREAD_OFFSET(thin_lock_id_);
1713  // DO_THREAD_OFFSET(top_of_managed_stack_);
1714  // DO_THREAD_OFFSET(top_of_managed_stack_pc_);
1715  DO_THREAD_OFFSET(top_sirt_);
1716#undef DO_THREAD_OFFSET
1717
1718  size_t entry_point_count = arraysize(gThreadEntryPointInfo);
1719  CHECK_EQ(entry_point_count * size_of_pointers,
1720           sizeof(InterpreterEntryPoints) + sizeof(JniEntryPoints) + sizeof(PortableEntryPoints) +
1721           sizeof(QuickEntryPoints));
1722  uint32_t expected_offset = OFFSETOF_MEMBER(Thread, interpreter_entrypoints_);
1723  for (size_t i = 0; i < entry_point_count; ++i) {
1724    CHECK_EQ(gThreadEntryPointInfo[i].offset, expected_offset) << gThreadEntryPointInfo[i].name;
1725    expected_offset += size_of_pointers;
1726    if (gThreadEntryPointInfo[i].offset == offset) {
1727      os << gThreadEntryPointInfo[i].name;
1728      return;
1729    }
1730  }
1731  os << offset;
1732}
1733
1734static const bool kDebugExceptionDelivery = false;
1735class CatchBlockStackVisitor : public StackVisitor {
1736 public:
1737  CatchBlockStackVisitor(Thread* self, const ThrowLocation& throw_location,
1738                         mirror::Throwable* exception, bool is_deoptimization)
1739      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
1740      : StackVisitor(self, self->GetLongJumpContext()),
1741        self_(self), exception_(exception), is_deoptimization_(is_deoptimization),
1742        to_find_(is_deoptimization ? NULL : exception->GetClass()), throw_location_(throw_location),
1743        handler_quick_frame_(NULL), handler_quick_frame_pc_(0), handler_dex_pc_(0),
1744        native_method_count_(0), clear_exception_(false),
1745        method_tracing_active_(is_deoptimization ||
1746                               Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled()),
1747        instrumentation_frames_to_pop_(0), top_shadow_frame_(NULL), prev_shadow_frame_(NULL) {
1748    // Exception not in root sets, can't allow GC.
1749    last_no_assert_suspension_cause_ = self->StartAssertNoThreadSuspension("Finding catch block");
1750  }
1751
1752  ~CatchBlockStackVisitor() {
1753    LOG(FATAL) << "UNREACHABLE";  // Expected to take long jump.
1754  }
1755
1756  bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1757    mirror::ArtMethod* method = GetMethod();
1758    if (method == NULL) {
1759      // This is the upcall, we remember the frame and last pc so that we may long jump to them.
1760      handler_quick_frame_pc_ = GetCurrentQuickFramePc();
1761      handler_quick_frame_ = GetCurrentQuickFrame();
1762      return false;  // End stack walk.
1763    } else {
1764      if (UNLIKELY(method_tracing_active_ &&
1765                   GetQuickInstrumentationExitPc() == GetReturnPc())) {
1766        // Keep count of the number of unwinds during instrumentation.
1767        instrumentation_frames_to_pop_++;
1768      }
1769      if (method->IsRuntimeMethod()) {
1770        // Ignore callee save method.
1771        DCHECK(method->IsCalleeSaveMethod());
1772        return true;
1773      } else if (is_deoptimization_) {
1774        return HandleDeoptimization(method);
1775      } else {
1776        return HandleTryItems(method);
1777      }
1778    }
1779  }
1780
1781  bool HandleTryItems(mirror::ArtMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1782    uint32_t dex_pc = DexFile::kDexNoIndex;
1783    if (method->IsNative()) {
1784      native_method_count_++;
1785    } else {
1786      dex_pc = GetDexPc();
1787    }
1788    if (dex_pc != DexFile::kDexNoIndex) {
1789      uint32_t found_dex_pc = method->FindCatchBlock(to_find_, dex_pc, &clear_exception_);
1790      if (found_dex_pc != DexFile::kDexNoIndex) {
1791        handler_dex_pc_ = found_dex_pc;
1792        handler_quick_frame_pc_ = method->ToNativePc(found_dex_pc);
1793        handler_quick_frame_ = GetCurrentQuickFrame();
1794        return false;  // End stack walk.
1795      }
1796    }
1797    return true;  // Continue stack walk.
1798  }
1799
1800  bool HandleDeoptimization(mirror::ArtMethod* m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1801    MethodHelper mh(m);
1802    const DexFile::CodeItem* code_item = mh.GetCodeItem();
1803    CHECK(code_item != NULL);
1804    uint16_t num_regs =  code_item->registers_size_;
1805    uint32_t dex_pc = GetDexPc();
1806    const Instruction* inst = Instruction::At(code_item->insns_ + dex_pc);
1807    uint32_t new_dex_pc = dex_pc + inst->SizeInCodeUnits();
1808    ShadowFrame* new_frame = ShadowFrame::Create(num_regs, NULL, m, new_dex_pc);
1809    verifier::MethodVerifier verifier(&mh.GetDexFile(), mh.GetDexCache(), mh.GetClassLoader(),
1810                                      &mh.GetClassDef(), code_item,
1811                                      m->GetDexMethodIndex(), m, m->GetAccessFlags(), false, true);
1812    verifier.Verify();
1813    std::vector<int32_t> kinds = verifier.DescribeVRegs(dex_pc);
1814    for (uint16_t reg = 0; reg < num_regs; reg++) {
1815      VRegKind kind = static_cast<VRegKind>(kinds.at(reg * 2));
1816      switch (kind) {
1817        case kUndefined:
1818          new_frame->SetVReg(reg, 0xEBADDE09);
1819          break;
1820        case kConstant:
1821          new_frame->SetVReg(reg, kinds.at((reg * 2) + 1));
1822          break;
1823        case kReferenceVReg:
1824          new_frame->SetVRegReference(reg,
1825                                      reinterpret_cast<mirror::Object*>(GetVReg(m, reg, kind)));
1826          break;
1827        default:
1828          new_frame->SetVReg(reg, GetVReg(m, reg, kind));
1829          break;
1830      }
1831    }
1832    if (prev_shadow_frame_ != NULL) {
1833      prev_shadow_frame_->SetLink(new_frame);
1834    } else {
1835      top_shadow_frame_ = new_frame;
1836    }
1837    prev_shadow_frame_ = new_frame;
1838    return true;
1839  }
1840
1841  void DoLongJump() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1842    mirror::ArtMethod* catch_method = *handler_quick_frame_;
1843    if (catch_method == NULL) {
1844      if (kDebugExceptionDelivery) {
1845        LOG(INFO) << "Handler is upcall";
1846      }
1847    } else {
1848      CHECK(!is_deoptimization_);
1849      if (kDebugExceptionDelivery) {
1850        const DexFile& dex_file = *catch_method->GetDeclaringClass()->GetDexCache()->GetDexFile();
1851        int line_number = dex_file.GetLineNumFromPC(catch_method, handler_dex_pc_);
1852        LOG(INFO) << "Handler: " << PrettyMethod(catch_method) << " (line: " << line_number << ")";
1853      }
1854    }
1855    if (clear_exception_) {
1856      // Exception was cleared as part of delivery.
1857      DCHECK(!self_->IsExceptionPending());
1858    } else {
1859      // Put exception back in root set with clear throw location.
1860      self_->SetException(ThrowLocation(), exception_);
1861    }
1862    self_->EndAssertNoThreadSuspension(last_no_assert_suspension_cause_);
1863    // Do instrumentation events after allowing thread suspension again.
1864    instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
1865    for (size_t i = 0; i < instrumentation_frames_to_pop_; ++i) {
1866      // We pop the instrumentation stack here so as not to corrupt it during the stack walk.
1867      if (i != instrumentation_frames_to_pop_ - 1 || self_->GetInstrumentationStack()->front().method_ != catch_method) {
1868        // Don't pop the instrumentation frame of the catch handler.
1869        instrumentation->PopMethodForUnwind(self_, is_deoptimization_);
1870      }
1871    }
1872    if (!is_deoptimization_) {
1873      instrumentation->ExceptionCaughtEvent(self_, throw_location_, catch_method, handler_dex_pc_,
1874                                            exception_);
1875    } else {
1876      // TODO: proper return value.
1877      self_->SetDeoptimizationShadowFrame(top_shadow_frame_);
1878    }
1879    // Place context back on thread so it will be available when we continue.
1880    self_->ReleaseLongJumpContext(context_);
1881    context_->SetSP(reinterpret_cast<uintptr_t>(handler_quick_frame_));
1882    CHECK_NE(handler_quick_frame_pc_, 0u);
1883    context_->SetPC(handler_quick_frame_pc_);
1884    context_->SmashCallerSaves();
1885    context_->DoLongJump();
1886  }
1887
1888 private:
1889  Thread* const self_;
1890  mirror::Throwable* const exception_;
1891  const bool is_deoptimization_;
1892  // The type of the exception catch block to find.
1893  mirror::Class* const to_find_;
1894  // Location of the throw.
1895  const ThrowLocation& throw_location_;
1896  // Quick frame with found handler or last frame if no handler found.
1897  mirror::ArtMethod** handler_quick_frame_;
1898  // PC to branch to for the handler.
1899  uintptr_t handler_quick_frame_pc_;
1900  // Associated dex PC.
1901  uint32_t handler_dex_pc_;
1902  // Number of native methods passed in crawl (equates to number of SIRTs to pop)
1903  uint32_t native_method_count_;
1904  // Should the exception be cleared as the catch block has no move-exception?
1905  bool clear_exception_;
1906  // Is method tracing active?
1907  const bool method_tracing_active_;
1908  // Support for nesting no thread suspension checks.
1909  const char* last_no_assert_suspension_cause_;
1910  // Number of frames to pop in long jump.
1911  size_t instrumentation_frames_to_pop_;
1912  ShadowFrame* top_shadow_frame_;
1913  ShadowFrame* prev_shadow_frame_;
1914};
1915
1916void Thread::QuickDeliverException() {
1917  // Get exception from thread.
1918  ThrowLocation throw_location;
1919  mirror::Throwable* exception = GetException(&throw_location);
1920  CHECK(exception != NULL);
1921  // Don't leave exception visible while we try to find the handler, which may cause class
1922  // resolution.
1923  ClearException();
1924  bool is_deoptimization = (exception == reinterpret_cast<mirror::Throwable*>(-1));
1925  if (kDebugExceptionDelivery) {
1926    if (!is_deoptimization) {
1927      mirror::String* msg = exception->GetDetailMessage();
1928      std::string str_msg(msg != NULL ? msg->ToModifiedUtf8() : "");
1929      DumpStack(LOG(INFO) << "Delivering exception: " << PrettyTypeOf(exception)
1930                << ": " << str_msg << "\n");
1931    } else {
1932      DumpStack(LOG(INFO) << "Deoptimizing: ");
1933    }
1934  }
1935  CatchBlockStackVisitor catch_finder(this, throw_location, exception, is_deoptimization);
1936  catch_finder.WalkStack(true);
1937  catch_finder.DoLongJump();
1938  LOG(FATAL) << "UNREACHABLE";
1939}
1940
1941Context* Thread::GetLongJumpContext() {
1942  Context* result = long_jump_context_;
1943  if (result == NULL) {
1944    result = Context::Create();
1945  } else {
1946    long_jump_context_ = NULL;  // Avoid context being shared.
1947    result->Reset();
1948  }
1949  return result;
1950}
1951
1952struct CurrentMethodVisitor : public StackVisitor {
1953  CurrentMethodVisitor(Thread* thread, Context* context)
1954      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
1955      : StackVisitor(thread, context), this_object_(NULL), method_(NULL), dex_pc_(0) {}
1956  virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
1957    mirror::ArtMethod* m = GetMethod();
1958    if (m->IsRuntimeMethod()) {
1959      // Continue if this is a runtime method.
1960      return true;
1961    }
1962    if (context_ != NULL) {
1963      this_object_ = GetThisObject();
1964    }
1965    method_ = m;
1966    dex_pc_ = GetDexPc();
1967    return false;
1968  }
1969  mirror::Object* this_object_;
1970  mirror::ArtMethod* method_;
1971  uint32_t dex_pc_;
1972};
1973
1974mirror::ArtMethod* Thread::GetCurrentMethod(uint32_t* dex_pc) const {
1975  CurrentMethodVisitor visitor(const_cast<Thread*>(this), NULL);
1976  visitor.WalkStack(false);
1977  if (dex_pc != NULL) {
1978    *dex_pc = visitor.dex_pc_;
1979  }
1980  return visitor.method_;
1981}
1982
1983ThrowLocation Thread::GetCurrentLocationForThrow() {
1984  Context* context = GetLongJumpContext();
1985  CurrentMethodVisitor visitor(this, context);
1986  visitor.WalkStack(false);
1987  ReleaseLongJumpContext(context);
1988  return ThrowLocation(visitor.this_object_, visitor.method_, visitor.dex_pc_);
1989}
1990
1991bool Thread::HoldsLock(mirror::Object* object) {
1992  if (object == NULL) {
1993    return false;
1994  }
1995  return object->GetThinLockId() == thin_lock_id_;
1996}
1997
1998// RootVisitor parameters are: (const Object* obj, size_t vreg, const StackVisitor* visitor).
1999template <typename RootVisitor>
2000class ReferenceMapVisitor : public StackVisitor {
2001 public:
2002  ReferenceMapVisitor(Thread* thread, Context* context, const RootVisitor& visitor)
2003      SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
2004      : StackVisitor(thread, context), visitor_(visitor) {}
2005
2006  bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
2007    if (false) {
2008      LOG(INFO) << "Visiting stack roots in " << PrettyMethod(GetMethod())
2009          << StringPrintf("@ PC:%04x", GetDexPc());
2010    }
2011    ShadowFrame* shadow_frame = GetCurrentShadowFrame();
2012    if (shadow_frame != NULL) {
2013      mirror::ArtMethod* m = shadow_frame->GetMethod();
2014      size_t num_regs = shadow_frame->NumberOfVRegs();
2015      if (m->IsNative() || shadow_frame->HasReferenceArray()) {
2016        // SIRT for JNI or References for interpreter.
2017        for (size_t reg = 0; reg < num_regs; ++reg) {
2018          mirror::Object* ref = shadow_frame->GetVRegReference(reg);
2019          if (ref != NULL) {
2020            visitor_(ref, reg, this);
2021          }
2022        }
2023      } else {
2024        // Java method.
2025        // Portable path use DexGcMap and store in Method.native_gc_map_.
2026        const uint8_t* gc_map = m->GetNativeGcMap();
2027        CHECK(gc_map != NULL) << PrettyMethod(m);
2028        uint32_t gc_map_length = static_cast<uint32_t>((gc_map[0] << 24) |
2029                                                       (gc_map[1] << 16) |
2030                                                       (gc_map[2] << 8) |
2031                                                       (gc_map[3] << 0));
2032        verifier::DexPcToReferenceMap dex_gc_map(gc_map + 4, gc_map_length);
2033        uint32_t dex_pc = GetDexPc();
2034        const uint8_t* reg_bitmap = dex_gc_map.FindBitMap(dex_pc);
2035        DCHECK(reg_bitmap != NULL);
2036        num_regs = std::min(dex_gc_map.RegWidth() * 8, num_regs);
2037        for (size_t reg = 0; reg < num_regs; ++reg) {
2038          if (TestBitmap(reg, reg_bitmap)) {
2039            mirror::Object* ref = shadow_frame->GetVRegReference(reg);
2040            if (ref != NULL) {
2041              visitor_(ref, reg, this);
2042            }
2043          }
2044        }
2045      }
2046    } else {
2047      mirror::ArtMethod* m = GetMethod();
2048      // Process register map (which native and runtime methods don't have)
2049      if (!m->IsNative() && !m->IsRuntimeMethod() && !m->IsProxyMethod()) {
2050        const uint8_t* native_gc_map = m->GetNativeGcMap();
2051        CHECK(native_gc_map != NULL) << PrettyMethod(m);
2052        mh_.ChangeMethod(m);
2053        const DexFile::CodeItem* code_item = mh_.GetCodeItem();
2054        DCHECK(code_item != NULL) << PrettyMethod(m);  // Can't be NULL or how would we compile its instructions?
2055        NativePcOffsetToReferenceMap map(native_gc_map);
2056        size_t num_regs = std::min(map.RegWidth() * 8,
2057                                   static_cast<size_t>(code_item->registers_size_));
2058        if (num_regs > 0) {
2059          const uint8_t* reg_bitmap = map.FindBitMap(GetNativePcOffset());
2060          DCHECK(reg_bitmap != NULL);
2061          const VmapTable vmap_table(m->GetVmapTable());
2062          uint32_t core_spills = m->GetCoreSpillMask();
2063          uint32_t fp_spills = m->GetFpSpillMask();
2064          size_t frame_size = m->GetFrameSizeInBytes();
2065          // For all dex registers in the bitmap
2066          mirror::ArtMethod** cur_quick_frame = GetCurrentQuickFrame();
2067          DCHECK(cur_quick_frame != NULL);
2068          for (size_t reg = 0; reg < num_regs; ++reg) {
2069            // Does this register hold a reference?
2070            if (TestBitmap(reg, reg_bitmap)) {
2071              uint32_t vmap_offset;
2072              mirror::Object* ref;
2073              if (vmap_table.IsInContext(reg, kReferenceVReg, &vmap_offset)) {
2074                uintptr_t val = GetGPR(vmap_table.ComputeRegister(core_spills, vmap_offset,
2075                                                                  kReferenceVReg));
2076                ref = reinterpret_cast<mirror::Object*>(val);
2077              } else {
2078                ref = reinterpret_cast<mirror::Object*>(GetVReg(cur_quick_frame, code_item,
2079                                                                core_spills, fp_spills, frame_size,
2080                                                                reg));
2081              }
2082
2083              if (ref != NULL) {
2084                visitor_(ref, reg, this);
2085              }
2086            }
2087          }
2088        }
2089      }
2090    }
2091    return true;
2092  }
2093
2094 private:
2095  static bool TestBitmap(int reg, const uint8_t* reg_vector) {
2096    return ((reg_vector[reg / 8] >> (reg % 8)) & 0x01) != 0;
2097  }
2098
2099  // Visitor for when we visit a root.
2100  const RootVisitor& visitor_;
2101
2102  // A method helper we keep around to avoid dex file/cache re-computations.
2103  MethodHelper mh_;
2104};
2105
2106class RootCallbackVisitor {
2107 public:
2108  RootCallbackVisitor(RootVisitor* visitor, void* arg) : visitor_(visitor), arg_(arg) {}
2109
2110  void operator()(const mirror::Object* obj, size_t, const StackVisitor*) const {
2111    visitor_(obj, arg_);
2112  }
2113
2114 private:
2115  RootVisitor* visitor_;
2116  void* arg_;
2117};
2118
2119class VerifyCallbackVisitor {
2120 public:
2121  VerifyCallbackVisitor(VerifyRootVisitor* visitor, void* arg)
2122      : visitor_(visitor),
2123        arg_(arg) {
2124  }
2125
2126  void operator()(const mirror::Object* obj, size_t vreg, const StackVisitor* visitor) const {
2127    visitor_(obj, arg_, vreg, visitor);
2128  }
2129
2130 private:
2131  VerifyRootVisitor* const visitor_;
2132  void* const arg_;
2133};
2134
2135struct VerifyRootWrapperArg {
2136  VerifyRootVisitor* visitor;
2137  void* arg;
2138};
2139
2140static void VerifyRootWrapperCallback(const mirror::Object* root, void* arg) {
2141  VerifyRootWrapperArg* wrapperArg = reinterpret_cast<VerifyRootWrapperArg*>(arg);
2142  wrapperArg->visitor(root, wrapperArg->arg, 0, NULL);
2143}
2144
2145void Thread::VerifyRoots(VerifyRootVisitor* visitor, void* arg) {
2146  // We need to map from a RootVisitor to VerifyRootVisitor, so pass in nulls for arguments we
2147  // don't have.
2148  VerifyRootWrapperArg wrapperArg;
2149  wrapperArg.arg = arg;
2150  wrapperArg.visitor = visitor;
2151
2152  if (opeer_ != NULL) {
2153    VerifyRootWrapperCallback(opeer_, &wrapperArg);
2154  }
2155  if (exception_ != NULL) {
2156    VerifyRootWrapperCallback(exception_, &wrapperArg);
2157  }
2158  throw_location_.VisitRoots(VerifyRootWrapperCallback, &wrapperArg);
2159  if (class_loader_override_ != NULL) {
2160    VerifyRootWrapperCallback(class_loader_override_, &wrapperArg);
2161  }
2162  jni_env_->locals.VisitRoots(VerifyRootWrapperCallback, &wrapperArg);
2163  jni_env_->monitors.VisitRoots(VerifyRootWrapperCallback, &wrapperArg);
2164
2165  SirtVisitRoots(VerifyRootWrapperCallback, &wrapperArg);
2166
2167  // Visit roots on this thread's stack
2168  Context* context = GetLongJumpContext();
2169  VerifyCallbackVisitor visitorToCallback(visitor, arg);
2170  ReferenceMapVisitor<VerifyCallbackVisitor> mapper(this, context, visitorToCallback);
2171  mapper.WalkStack();
2172  ReleaseLongJumpContext(context);
2173
2174  std::deque<instrumentation::InstrumentationStackFrame>* instrumentation_stack = GetInstrumentationStack();
2175  typedef std::deque<instrumentation::InstrumentationStackFrame>::const_iterator It;
2176  for (It it = instrumentation_stack->begin(), end = instrumentation_stack->end(); it != end; ++it) {
2177    mirror::Object* this_object = (*it).this_object_;
2178    if (this_object != NULL) {
2179      VerifyRootWrapperCallback(this_object, &wrapperArg);
2180    }
2181    mirror::ArtMethod* method = (*it).method_;
2182    VerifyRootWrapperCallback(method, &wrapperArg);
2183  }
2184}
2185
2186void Thread::VisitRoots(RootVisitor* visitor, void* arg) {
2187  if (opeer_ != NULL) {
2188    visitor(opeer_, arg);
2189  }
2190  if (exception_ != NULL) {
2191    visitor(exception_, arg);
2192  }
2193  throw_location_.VisitRoots(visitor, arg);
2194  if (class_loader_override_ != NULL) {
2195    visitor(class_loader_override_, arg);
2196  }
2197  jni_env_->locals.VisitRoots(visitor, arg);
2198  jni_env_->monitors.VisitRoots(visitor, arg);
2199
2200  SirtVisitRoots(visitor, arg);
2201
2202  // Visit roots on this thread's stack
2203  Context* context = GetLongJumpContext();
2204  RootCallbackVisitor visitorToCallback(visitor, arg);
2205  ReferenceMapVisitor<RootCallbackVisitor> mapper(this, context, visitorToCallback);
2206  mapper.WalkStack();
2207  ReleaseLongJumpContext(context);
2208
2209  for (const instrumentation::InstrumentationStackFrame& frame : *GetInstrumentationStack()) {
2210    mirror::Object* this_object = frame.this_object_;
2211    if (this_object != NULL) {
2212      visitor(this_object, arg);
2213    }
2214    mirror::ArtMethod* method = frame.method_;
2215    visitor(method, arg);
2216  }
2217}
2218
2219static void VerifyObject(const mirror::Object* root, void* arg) {
2220  gc::Heap* heap = reinterpret_cast<gc::Heap*>(arg);
2221  heap->VerifyObject(root);
2222}
2223
2224void Thread::VerifyStackImpl() {
2225  UniquePtr<Context> context(Context::Create());
2226  RootCallbackVisitor visitorToCallback(VerifyObject, Runtime::Current()->GetHeap());
2227  ReferenceMapVisitor<RootCallbackVisitor> mapper(this, context.get(), visitorToCallback);
2228  mapper.WalkStack();
2229}
2230
2231// Set the stack end to that to be used during a stack overflow
2232void Thread::SetStackEndForStackOverflow() {
2233  // During stack overflow we allow use of the full stack.
2234  if (stack_end_ == stack_begin_) {
2235    // However, we seem to have already extended to use the full stack.
2236    LOG(ERROR) << "Need to increase kStackOverflowReservedBytes (currently "
2237               << kStackOverflowReservedBytes << ")?";
2238    DumpStack(LOG(ERROR));
2239    LOG(FATAL) << "Recursive stack overflow.";
2240  }
2241
2242  stack_end_ = stack_begin_;
2243}
2244
2245std::ostream& operator<<(std::ostream& os, const Thread& thread) {
2246  thread.ShortDump(os);
2247  return os;
2248}
2249
2250}  // namespace art
2251