blob: 2f3ce6a7ff1dda5de24ace72411c1588cded91be [file] [log] [blame]
Elliott Hughes8d768a92011-09-14 16:35:25 -07001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Carl Shapirob5573532011-07-12 18:22:59 -070016
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070017#include "thread.h"
Carl Shapirob5573532011-07-12 18:22:59 -070018
Elliott Hughes8d768a92011-09-14 16:35:25 -070019#include <dynamic_annotations.h>
Ian Rogersb033c752011-07-20 12:22:35 -070020#include <pthread.h>
21#include <sys/mman.h>
Brian Carlstromdbf05b72011-12-15 00:55:24 -080022#include <sys/resource.h>
23#include <sys/time.h>
Elliott Hughesa0957642011-09-02 14:27:33 -070024
Carl Shapirob5573532011-07-12 18:22:59 -070025#include <algorithm>
Elliott Hughesdcc24742011-09-07 14:02:44 -070026#include <bitset>
Elliott Hugheseb4f6142011-07-15 17:43:51 -070027#include <cerrno>
Elliott Hughesa0957642011-09-02 14:27:33 -070028#include <iostream>
Carl Shapirob5573532011-07-12 18:22:59 -070029#include <list>
Carl Shapirob5573532011-07-12 18:22:59 -070030
Elliott Hughes872d4ec2011-10-21 17:07:15 -070031#include "debugger.h"
Elliott Hughesa5b897e2011-08-16 11:33:06 -070032#include "class_linker.h"
Brian Carlstromdf143242011-10-10 18:05:34 -070033#include "class_loader.h"
Ian Rogersbdb03912011-09-14 00:55:44 -070034#include "context.h"
Ian Rogersd6b1f612011-09-27 13:38:14 -070035#include "dex_verifier.h"
Ian Rogers408f79a2011-08-23 18:22:33 -070036#include "heap.h"
Elliott Hughesc5f7c912011-08-18 14:00:42 -070037#include "jni_internal.h"
Elliott Hughes8e4aac52011-09-26 17:03:36 -070038#include "monitor.h"
Elliott Hughesa5b897e2011-08-16 11:33:06 -070039#include "object.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080040#include "object_utils.h"
Jesse Wilson9a6bae82011-11-14 14:57:30 -050041#include "reflection.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070042#include "runtime.h"
buzbee54330722011-08-23 16:46:55 -070043#include "runtime_support.h"
Elliott Hughes726079d2011-10-07 18:43:44 -070044#include "ScopedLocalRef.h"
Ian Rogersaaa20802011-09-11 21:47:37 -070045#include "scoped_jni_thread_state.h"
Ian Rogers30fab402012-01-23 15:43:46 -080046#include "space.h"
Elliott Hughes68e76522011-10-05 13:22:16 -070047#include "stack.h"
48#include "stack_indirect_reference_table.h"
Elliott Hughes8daa0922011-09-11 13:46:25 -070049#include "thread_list.h"
Elliott Hughesa0957642011-09-02 14:27:33 -070050#include "utils.h"
Carl Shapirob5573532011-07-12 18:22:59 -070051
52namespace art {
53
54pthread_key_t Thread::pthread_key_self_;
55
Elliott Hughes8e4aac52011-09-26 17:03:36 -070056static Class* gThreadLock = NULL;
Elliott Hughes038a8062011-09-18 14:12:41 -070057static Field* gThread_daemon = NULL;
58static Field* gThread_group = NULL;
59static Field* gThread_lock = NULL;
60static Field* gThread_name = NULL;
61static Field* gThread_priority = NULL;
Elliott Hughes29f27422011-09-18 16:02:18 -070062static Field* gThread_uncaughtHandler = NULL;
Elliott Hughes038a8062011-09-18 14:12:41 -070063static Field* gThread_vmData = NULL;
64static Field* gThreadGroup_name = NULL;
Elliott Hughes8e4aac52011-09-26 17:03:36 -070065static Field* gThreadLock_thread = NULL;
Elliott Hughes038a8062011-09-18 14:12:41 -070066static Method* gThread_run = NULL;
Elliott Hughes29f27422011-09-18 16:02:18 -070067static Method* gThreadGroup_removeThread = NULL;
68static Method* gUncaughtExceptionHandler_uncaughtException = NULL;
Elliott Hughes038a8062011-09-18 14:12:41 -070069
Ian Rogers5d76c432011-10-31 21:42:49 -070070void Thread::InitCardTable() {
Ian Rogers30fab402012-01-23 15:43:46 -080071 card_table_ = Heap::GetCardTable()->GetBiasedBegin();
Ian Rogers5d76c432011-10-31 21:42:49 -070072}
73
buzbee3ea4ec52011-08-22 17:37:19 -070074void Thread::InitFunctionPointers() {
Bill Buzbee11f9d212012-03-03 20:03:18 -080075#if defined(__mips)
76 pShlLong = art_shl_long;
77 pShrLong = art_shr_long;
78 pUshrLong = art_ushr_long;
79 pI2f = __floatsisf;
80 pF2iz = __fixsfi;
81 pD2f = __truncdfsf2;
82 pF2d = __extendsfdfs;
83 pD2iz = __fixdfsi;
84 pL2f = __floatdisf;
85 pL2d = __floatdidf;
86 pFadd = __addsf3;
87 pFsub = __subsf3;
88 pFdiv = divsf3;
89 pFmul = __mulsf3;
90 pFmodf = fmodf;
91 pDadd = __adddf3;
92 pDsub = __subdf3;
93 pDdiv = __divdf3;
94 pDmul = muldf3;
95 pFmod = fmod;
96 pCmplFloat = art_cmpl_float;
97 pCmpgFloat = arg_cmpl_float;
98 pCmplDouble = art_cmpl_double;
99 pCmpgDouble = arg_cmpl_double;
100#endif
buzbee54330722011-08-23 16:46:55 -0700101#if defined(__arm__)
102 pShlLong = art_shl_long;
103 pShrLong = art_shr_long;
104 pUshrLong = art_ushr_long;
buzbee7b1b86d2011-08-26 18:59:10 -0700105 pIdiv = __aeabi_idiv;
106 pIdivmod = __aeabi_idivmod;
107 pI2f = __aeabi_i2f;
108 pF2iz = __aeabi_f2iz;
109 pD2f = __aeabi_d2f;
110 pF2d = __aeabi_f2d;
111 pD2iz = __aeabi_d2iz;
112 pL2f = __aeabi_l2f;
113 pL2d = __aeabi_l2d;
114 pFadd = __aeabi_fadd;
115 pFsub = __aeabi_fsub;
116 pFdiv = __aeabi_fdiv;
117 pFmul = __aeabi_fmul;
118 pFmodf = fmodf;
119 pDadd = __aeabi_dadd;
120 pDsub = __aeabi_dsub;
121 pDdiv = __aeabi_ddiv;
122 pDmul = __aeabi_dmul;
123 pFmod = fmod;
buzbee7b1b86d2011-08-26 18:59:10 -0700124 pLdivmod = __aeabi_ldivmod;
buzbee439c4fa2011-08-27 15:59:07 -0700125 pLmul = __aeabi_lmul;
Elliott Hughesb408de72011-10-04 14:35:05 -0700126 pAllocArrayFromCode = art_alloc_array_from_code;
Ian Rogers0eb7d7e2012-01-31 21:12:32 -0800127 pAllocArrayFromCodeWithAccessCheck = art_alloc_array_from_code_with_access_check;
Brian Carlstrom6fd03fb2011-10-17 16:11:00 -0700128 pAllocObjectFromCode = art_alloc_object_from_code;
Ian Rogers28ad40d2011-10-27 15:19:26 -0700129 pAllocObjectFromCodeWithAccessCheck = art_alloc_object_from_code_with_access_check;
Ian Rogerse51a5112011-09-23 14:16:35 -0700130 pCanPutArrayElementFromCode = art_can_put_array_element_from_code;
Elliott Hughesb408de72011-10-04 14:35:05 -0700131 pCheckAndAllocArrayFromCode = art_check_and_alloc_array_from_code;
Ian Rogers0eb7d7e2012-01-31 21:12:32 -0800132 pCheckAndAllocArrayFromCodeWithAccessCheck = art_check_and_alloc_array_from_code_with_access_check;
Ian Rogersff1ed472011-09-20 13:46:24 -0700133 pCheckCastFromCode = art_check_cast_from_code;
Ian Rogers1bddec32012-02-04 12:27:34 -0800134 pGet32Instance = art_get32_instance_from_code;
135 pGet64Instance = art_get64_instance_from_code;
136 pGetObjInstance = art_get_obj_instance_from_code;
Ian Rogersce9eca62011-10-07 17:11:03 -0700137 pGet32Static = art_get32_static_from_code;
138 pGet64Static = art_get64_static_from_code;
139 pGetObjStatic = art_get_obj_static_from_code;
Ian Rogersff1ed472011-09-20 13:46:24 -0700140 pHandleFillArrayDataFromCode = art_handle_fill_data_from_code;
Ian Rogerscbba6ac2011-09-22 16:28:37 -0700141 pInitializeStaticStorage = art_initialize_static_storage_from_code;
Ian Rogers28ad40d2011-10-27 15:19:26 -0700142 pInitializeTypeFromCode = art_initialize_type_from_code;
Ian Rogersb093c6b2011-10-31 16:19:55 -0700143 pInitializeTypeAndVerifyAccessFromCode = art_initialize_type_and_verify_access_from_code;
Ian Rogersc8b306f2012-02-17 21:34:44 -0800144 pInvokeDirectTrampolineWithAccessCheck = art_invoke_direct_trampoline_with_access_check;
buzbee4a3164f2011-09-03 11:25:10 -0700145 pInvokeInterfaceTrampoline = art_invoke_interface_trampoline;
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800146 pInvokeInterfaceTrampolineWithAccessCheck = art_invoke_interface_trampoline_with_access_check;
Ian Rogersc8b306f2012-02-17 21:34:44 -0800147 pInvokeStaticTrampolineWithAccessCheck = art_invoke_static_trampoline_with_access_check;
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800148 pInvokeSuperTrampolineWithAccessCheck = art_invoke_super_trampoline_with_access_check;
149 pInvokeVirtualTrampolineWithAccessCheck = art_invoke_virtual_trampoline_with_access_check;
Brian Carlstrom6fd03fb2011-10-17 16:11:00 -0700150 pLockObjectFromCode = art_lock_object_from_code;
Brian Carlstrom6fd03fb2011-10-17 16:11:00 -0700151 pResolveStringFromCode = art_resolve_string_from_code;
Ian Rogers1bddec32012-02-04 12:27:34 -0800152 pSet32Instance = art_set32_instance_from_code;
153 pSet64Instance = art_set64_instance_from_code;
154 pSetObjInstance = art_set_obj_instance_from_code;
Ian Rogersce9eca62011-10-07 17:11:03 -0700155 pSet32Static = art_set32_static_from_code;
156 pSet64Static = art_set64_static_from_code;
157 pSetObjStatic = art_set_obj_static_from_code;
Brian Carlstrom6fd03fb2011-10-17 16:11:00 -0700158 pTestSuspendFromCode = art_test_suspend;
Ian Rogersff1ed472011-09-20 13:46:24 -0700159 pThrowArrayBoundsFromCode = art_throw_array_bounds_from_code;
160 pThrowDivZeroFromCode = art_throw_div_zero_from_code;
Ian Rogersc0c8dc82011-09-24 18:15:59 -0700161 pThrowNegArraySizeFromCode = art_throw_neg_array_size_from_code;
162 pThrowNoSuchMethodFromCode = art_throw_no_such_method_from_code;
Ian Rogersff1ed472011-09-20 13:46:24 -0700163 pThrowNullPointerFromCode = art_throw_null_pointer_exception_from_code;
Ian Rogers932746a2011-09-22 18:57:50 -0700164 pThrowStackOverflowFromCode = art_throw_stack_overflow_from_code;
Ian Rogersc0c8dc82011-09-24 18:15:59 -0700165 pThrowVerificationErrorFromCode = art_throw_verification_error_from_code;
Ian Rogersff1ed472011-09-20 13:46:24 -0700166 pUnlockObjectFromCode = art_unlock_object_from_code;
buzbee44b412b2012-02-04 08:50:53 -0800167 pUpdateDebuggerFromCode = NULL; // To enable, set to art_update_debugger
Ian Rogers67375ac2011-09-14 00:55:44 -0700168#endif
buzbeec396efc2011-09-11 09:36:41 -0700169 pF2l = F2L;
170 pD2l = D2L;
buzbee3ea4ec52011-08-22 17:37:19 -0700171 pMemcpy = memcpy;
Ian Rogers4a510d82011-10-09 14:30:24 -0700172 pCheckSuspendFromCode = CheckSuspendFromCode;
buzbee4a3164f2011-09-03 11:25:10 -0700173 pDebugMe = DebugMe;
Ian Rogers4a510d82011-10-09 14:30:24 -0700174 pDecodeJObjectInThread = DecodeJObjectInThread;
175 pDeliverException = art_deliver_exception_from_code;
176 pFindNativeMethod = FindNativeMethod;
Ian Rogerscaab8c42011-10-12 12:11:18 -0700177 pInstanceofNonTrivialFromCode = IsAssignableFromCode;
Ian Rogers4a510d82011-10-09 14:30:24 -0700178 pThrowAbstractMethodErrorFromCode = ThrowAbstractMethodErrorFromCode;
179 pUnresolvedDirectMethodTrampolineFromCode = UnresolvedDirectMethodTrampolineFromCode;
buzbee3ea4ec52011-08-22 17:37:19 -0700180}
181
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700182void Thread::InitTid() {
183 tid_ = ::art::GetTid();
184}
185
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700186void Thread::InitAfterFork() {
187 InitTid();
Elliott Hughes3147a232011-10-12 15:55:07 -0700188#if defined(__BIONIC__)
189 // Work around a bionic bug.
190 struct bionic_pthread_internal_t {
191 void* next;
192 void** pref;
193 pthread_attr_t attr;
194 pid_t kernel_id;
195 // et cetera. we just need 'kernel_id' so we can stop here.
196 };
197 reinterpret_cast<bionic_pthread_internal_t*>(pthread_self())->kernel_id = tid_;
198#endif
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700199}
200
Brian Carlstrom78128a62011-09-15 17:21:19 -0700201void* Thread::CreateCallback(void* arg) {
Elliott Hughes93e74e82011-09-13 11:07:03 -0700202 Thread* self = reinterpret_cast<Thread*>(arg);
203 Runtime* runtime = Runtime::Current();
204
205 self->Attach(runtime);
206
Elliott Hughes93e74e82011-09-13 11:07:03 -0700207 // Wait until it's safe to start running code. (There may have been a suspend-all
208 // in progress while we were starting up.)
209 runtime->GetThreadList()->WaitForGo();
210
Elliott Hughes47179f72011-10-27 16:44:39 -0700211 {
212 CHECK_EQ(self->GetState(), Thread::kRunnable);
Elliott Hughes899e7892012-01-24 14:57:32 -0800213 SirtRef<String> thread_name(self->GetThreadName());
214 self->SetThreadName(thread_name->ToModifiedUtf8().c_str());
Elliott Hughes47179f72011-10-27 16:44:39 -0700215 }
216
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700217 Dbg::PostThreadStart(self);
Elliott Hughes93e74e82011-09-13 11:07:03 -0700218
219 // Invoke the 'run' method of our java.lang.Thread.
220 CHECK(self->peer_ != NULL);
221 Object* receiver = self->peer_;
Elliott Hughes038a8062011-09-18 14:12:41 -0700222 Method* m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(gThread_run);
Elliott Hughes93e74e82011-09-13 11:07:03 -0700223 m->Invoke(self, receiver, NULL, NULL);
224
225 // Detach.
226 runtime->GetThreadList()->Unregister();
227
Carl Shapirob5573532011-07-12 18:22:59 -0700228 return NULL;
229}
230
Elliott Hughes93e74e82011-09-13 11:07:03 -0700231void SetVmData(Object* managed_thread, Thread* native_thread) {
Elliott Hughes038a8062011-09-18 14:12:41 -0700232 gThread_vmData->SetInt(managed_thread, reinterpret_cast<uintptr_t>(native_thread));
Elliott Hughes93e74e82011-09-13 11:07:03 -0700233}
234
Elliott Hughes761928d2011-11-16 18:33:03 -0800235Thread* Thread::FromManagedThread(Object* thread_peer) {
236 return reinterpret_cast<Thread*>(static_cast<uintptr_t>(gThread_vmData->GetInt(thread_peer)));
237}
238
Elliott Hughes01158d72011-09-19 19:47:10 -0700239Thread* Thread::FromManagedThread(JNIEnv* env, jobject java_thread) {
Elliott Hughes761928d2011-11-16 18:33:03 -0800240 return FromManagedThread(Decode<Object*>(env, java_thread));
Elliott Hughes01158d72011-09-19 19:47:10 -0700241}
242
Elliott Hughes7502e2a2011-10-02 13:24:37 -0700243size_t FixStackSize(size_t stack_size) {
244 // A stack size of zero means "use the default".
Elliott Hughesd369bb72011-09-12 14:41:14 -0700245 if (stack_size == 0) {
246 stack_size = Runtime::Current()->GetDefaultStackSize();
247 }
Carl Shapiro61e019d2011-07-14 16:53:09 -0700248
Elliott Hughes7502e2a2011-10-02 13:24:37 -0700249 // It's not possible to request a stack smaller than the system-defined PTHREAD_STACK_MIN.
250 if (stack_size < PTHREAD_STACK_MIN) {
251 stack_size = PTHREAD_STACK_MIN;
252 }
253
254 // It's likely that callers are trying to ensure they have at least a certain amount of
255 // stack space, so we should add our reserved space on top of what they requested, rather
256 // than implicitly take it away from them.
257 stack_size += Thread::kStackOverflowReservedBytes;
258
259 // Some systems require the stack size to be a multiple of the system page size, so round up.
260 stack_size = RoundUp(stack_size, kPageSize);
261
262 return stack_size;
263}
264
265void Thread::Create(Object* peer, size_t stack_size) {
266 CHECK(peer != NULL);
267
268 stack_size = FixStackSize(stack_size);
269
Elliott Hughes93e74e82011-09-13 11:07:03 -0700270 Thread* native_thread = new Thread;
271 native_thread->peer_ = peer;
272
273 // Thread.start is synchronized, so we know that vmData is 0,
274 // and know that we're not racing to assign it.
275 SetVmData(peer, native_thread);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700276
Elliott Hughes47179f72011-10-27 16:44:39 -0700277 {
278 ScopedThreadStateChange tsc(Thread::Current(), Thread::kVmWait);
279 pthread_t new_pthread;
280 pthread_attr_t attr;
281 CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
282 CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED), "PTHREAD_CREATE_DETACHED");
283 CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
284 CHECK_PTHREAD_CALL(pthread_create, (&new_pthread, &attr, Thread::CreateCallback, native_thread), "new thread");
285 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
286 }
Elliott Hughes93e74e82011-09-13 11:07:03 -0700287
288 // Let the child know when it's safe to start running.
289 Runtime::Current()->GetThreadList()->SignalGo(native_thread);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700290}
291
Elliott Hughes93e74e82011-09-13 11:07:03 -0700292void Thread::Attach(const Runtime* runtime) {
Elliott Hughescac6cc72011-11-03 20:31:21 -0700293 CHECK(Thread::Current() == NULL);
294
Elliott Hughes93e74e82011-09-13 11:07:03 -0700295 InitCpu();
296 InitFunctionPointers();
Ian Rogers5d76c432011-10-31 21:42:49 -0700297 InitCardTable();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700298
Elliott Hughes93e74e82011-09-13 11:07:03 -0700299 thin_lock_id_ = Runtime::Current()->GetThreadList()->AllocThreadId();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700300
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700301 InitTid();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700302 InitStackHwm();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700303
Elliott Hughes3147a232011-10-12 15:55:07 -0700304 CHECK_PTHREAD_CALL(pthread_setspecific, (Thread::pthread_key_self_, this), "attach");
Elliott Hughesa5780da2011-07-17 11:39:39 -0700305
Elliott Hughes93e74e82011-09-13 11:07:03 -0700306 jni_env_ = new JNIEnvExt(this, runtime->GetJavaVM());
Elliott Hughes330304d2011-08-12 14:28:05 -0700307
Elliott Hughes7a3aeb42011-09-25 17:39:47 -0700308 runtime->GetThreadList()->Register();
Elliott Hughes93e74e82011-09-13 11:07:03 -0700309}
310
311Thread* Thread::Attach(const Runtime* runtime, const char* name, bool as_daemon) {
Elliott Hughescac6cc72011-11-03 20:31:21 -0700312 Thread* self = new Thread;
313 self->Attach(runtime);
Elliott Hughes93e74e82011-09-13 11:07:03 -0700314
Elliott Hughescac6cc72011-11-03 20:31:21 -0700315 self->SetState(Thread::kNative);
Elliott Hughes93e74e82011-09-13 11:07:03 -0700316
Elliott Hughescac6cc72011-11-03 20:31:21 -0700317 // If we're the main thread, ClassLinker won't be created until after we're attached,
318 // so that thread needs a two-stage attach. Regular threads don't need this hack.
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800319 // In the compiler, all threads need this hack, because no-one's going to be getting
320 // a native peer!
321 if (self->thin_lock_id_ != ThreadList::kMainId && !Runtime::Current()->IsCompiler()) {
Elliott Hughescac6cc72011-11-03 20:31:21 -0700322 self->CreatePeer(name, as_daemon);
Elliott Hughes06e3ad42012-02-07 14:51:57 -0800323 } else {
324 // These aren't necessary, but they improve diagnostics for unit tests & command-line tools.
325 self->name_->assign(name);
326 ::art::SetThreadName(name);
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700327 }
Elliott Hughescac6cc72011-11-03 20:31:21 -0700328
329 self->GetJniEnv()->locals.AssertEmpty();
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700330 return self;
331}
332
Elliott Hughesd369bb72011-09-12 14:41:14 -0700333jobject GetWellKnownThreadGroup(JNIEnv* env, const char* field_name) {
Elliott Hughes726079d2011-10-07 18:43:44 -0700334 ScopedLocalRef<jclass> thread_group_class(env, env->FindClass("java/lang/ThreadGroup"));
335 jfieldID fid = env->GetStaticFieldID(thread_group_class.get(), field_name, "Ljava/lang/ThreadGroup;");
336 return env->GetStaticObjectField(thread_group_class.get(), fid);
Elliott Hughesd369bb72011-09-12 14:41:14 -0700337}
338
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700339void Thread::CreatePeer(const char* name, bool as_daemon) {
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500340 CHECK(Runtime::Current()->IsStarted());
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700341 JNIEnv* env = jni_env_;
342
Elliott Hughesd369bb72011-09-12 14:41:14 -0700343 const char* field_name = (GetThinLockId() == ThreadList::kMainId) ? "mMain" : "mSystem";
Elliott Hughes726079d2011-10-07 18:43:44 -0700344 ScopedLocalRef<jobject> thread_group(env, GetWellKnownThreadGroup(env, field_name));
345 ScopedLocalRef<jobject> thread_name(env, env->NewStringUTF(name));
Elliott Hughes8daa0922011-09-11 13:46:25 -0700346 jint thread_priority = GetNativePriority();
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700347 jboolean thread_is_daemon = as_daemon;
348
Elliott Hughes726079d2011-10-07 18:43:44 -0700349 ScopedLocalRef<jclass> c(env, env->FindClass("java/lang/Thread"));
Ian Rogers5d4bdc22011-11-02 22:15:43 -0700350 ScopedLocalRef<jobject> peer(env, env->AllocObject(c.get()));
Elliott Hughes726079d2011-10-07 18:43:44 -0700351 peer_ = DecodeJObject(peer.get());
Ian Rogers5d4bdc22011-11-02 22:15:43 -0700352 if (peer_ == NULL) {
353 CHECK(IsExceptionPending());
Ian Rogers5d4bdc22011-11-02 22:15:43 -0700354 return;
355 }
356 jmethodID mid = env->GetMethodID(c.get(), "<init>", "(Ljava/lang/ThreadGroup;Ljava/lang/String;IZ)V");
357 env->CallNonvirtualVoidMethod(peer.get(), c.get(), mid, thread_group.get(), thread_name.get(), thread_priority, thread_is_daemon);
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500358 CHECK(!IsExceptionPending()) << " " << PrettyTypeOf(GetException());
Elliott Hughes7a3aeb42011-09-25 17:39:47 -0700359 SetVmData(peer_, Thread::Current());
Elliott Hughesd369bb72011-09-12 14:41:14 -0700360
Elliott Hughes899e7892012-01-24 14:57:32 -0800361 SirtRef<String> peer_thread_name(GetThreadName());
Brian Carlstrom00fae582011-10-28 01:16:28 -0700362 if (peer_thread_name.get() == NULL) {
363 // The Thread constructor should have set the Thread.name to a
364 // non-null value. However, because we can run without code
365 // available (in the compiler, in tests), we manually assign the
366 // fields the constructor should have set.
367 gThread_daemon->SetBoolean(peer_, thread_is_daemon);
368 gThread_group->SetObject(peer_, Decode<Object*>(env, thread_group.get()));
369 gThread_name->SetObject(peer_, Decode<Object*>(env, thread_name.get()));
370 gThread_priority->SetInt(peer_, thread_priority);
Elliott Hughes899e7892012-01-24 14:57:32 -0800371 peer_thread_name.reset(GetThreadName());
Brian Carlstrom00fae582011-10-28 01:16:28 -0700372 }
373 // thread_name may have been null, so don't trust this to be non-null
374 if (peer_thread_name.get() != NULL) {
Elliott Hughes899e7892012-01-24 14:57:32 -0800375 SetThreadName(peer_thread_name->ToModifiedUtf8().c_str());
Brian Carlstrom00fae582011-10-28 01:16:28 -0700376 }
Elliott Hughes726079d2011-10-07 18:43:44 -0700377
378 // Pre-allocate an OutOfMemoryError for the double-OOME case.
379 ThrowNewException("Ljava/lang/OutOfMemoryError;",
380 "OutOfMemoryError thrown while trying to throw OutOfMemoryError; no stack available");
381 ScopedLocalRef<jthrowable> exception(env, env->ExceptionOccurred());
382 env->ExceptionClear();
383 pre_allocated_OutOfMemoryError_ = Decode<Throwable*>(env, exception.get());
Carl Shapiro61e019d2011-07-14 16:53:09 -0700384}
385
Elliott Hughes899e7892012-01-24 14:57:32 -0800386void Thread::SetThreadName(const char* name) {
387 name_->assign(name);
388 ::art::SetThreadName(name);
389 Dbg::DdmSendThreadNotification(this, CHUNK_TYPE("THNM"));
390}
391
Elliott Hughesbe759c62011-09-08 19:38:21 -0700392void Thread::InitStackHwm() {
Elliott Hughes215f3142012-01-19 00:22:47 -0800393#if defined(__APPLE__)
Elliott Hughes6cc332e2012-01-20 22:59:20 -0800394 // Only needed to run code. Try implementing this with pthread_get_stacksize_np and pthread_get_stackaddr_np.
395 UNIMPLEMENTED(WARNING);
Elliott Hughes215f3142012-01-19 00:22:47 -0800396#else
Elliott Hughesbe759c62011-09-08 19:38:21 -0700397 pthread_attr_t attributes;
Elliott Hughes3147a232011-10-12 15:55:07 -0700398 CHECK_PTHREAD_CALL(pthread_getattr_np, (pthread_self(), &attributes), __FUNCTION__);
Elliott Hughesbe759c62011-09-08 19:38:21 -0700399
Ian Rogers932746a2011-09-22 18:57:50 -0700400 void* temp_stack_base;
401 CHECK_PTHREAD_CALL(pthread_attr_getstack, (&attributes, &temp_stack_base, &stack_size_),
402 __FUNCTION__);
Ian Rogers30fab402012-01-23 15:43:46 -0800403 stack_begin_ = reinterpret_cast<byte*>(temp_stack_base);
Elliott Hughesbe759c62011-09-08 19:38:21 -0700404
Ian Rogers932746a2011-09-22 18:57:50 -0700405 if (stack_size_ <= kStackOverflowReservedBytes) {
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800406 LOG(FATAL) << "Attempt to attach a thread with a too-small stack (" << stack_size_ << " bytes)";
Elliott Hughesbe759c62011-09-08 19:38:21 -0700407 }
Elliott Hughes449b4bd2011-09-09 12:01:38 -0700408
Ian Rogers932746a2011-09-22 18:57:50 -0700409 // Set stack_end_ to the bottom of the stack saving space of stack overflows
410 ResetDefaultStackEnd();
Elliott Hughes449b4bd2011-09-09 12:01:38 -0700411
412 // Sanity check.
413 int stack_variable;
414 CHECK_GT(&stack_variable, (void*) stack_end_);
Elliott Hughesbe759c62011-09-08 19:38:21 -0700415
Elliott Hughes8d768a92011-09-14 16:35:25 -0700416 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attributes), __FUNCTION__);
Elliott Hughes215f3142012-01-19 00:22:47 -0800417#endif
Elliott Hughesbe759c62011-09-08 19:38:21 -0700418}
419
Elliott Hughes899e7892012-01-24 14:57:32 -0800420void Thread::Dump(std::ostream& os, bool full) const {
421 if (full) {
422 DumpState(os);
423 DumpStack(os);
424 } else {
425 os << "Thread[";
426 if (GetThinLockId() != 0) {
427 // If we're in kStarting, we won't have a thin lock id or tid yet.
428 os << GetThinLockId()
429 << ",tid=" << GetTid() << ',';
430 }
431 os << GetState()
432 << ",Thread*=" << this
Elliott Hughesffb465f2012-03-01 18:46:05 -0800433 << ",peer=" << peer_
Elliott Hughes899e7892012-01-24 14:57:32 -0800434 << ",\"" << *name_ << "\""
435 << "]";
Elliott Hughese0918552011-10-28 17:18:29 -0700436 }
Elliott Hughesa0957642011-09-02 14:27:33 -0700437}
438
Elliott Hughesd92bec42011-09-02 17:04:36 -0700439std::string GetSchedulerGroup(pid_t tid) {
440 // /proc/<pid>/group looks like this:
441 // 2:devices:/
442 // 1:cpuacct,cpu:/
443 // We want the third field from the line whose second field contains the "cpu" token.
444 std::string cgroup_file;
445 if (!ReadFileToString("/proc/self/cgroup", &cgroup_file)) {
446 return "";
447 }
448 std::vector<std::string> cgroup_lines;
449 Split(cgroup_file, '\n', cgroup_lines);
450 for (size_t i = 0; i < cgroup_lines.size(); ++i) {
451 std::vector<std::string> cgroup_fields;
452 Split(cgroup_lines[i], ':', cgroup_fields);
453 std::vector<std::string> cgroups;
454 Split(cgroup_fields[1], ',', cgroups);
455 for (size_t i = 0; i < cgroups.size(); ++i) {
456 if (cgroups[i] == "cpu") {
457 return cgroup_fields[2].substr(1); // Skip the leading slash.
458 }
459 }
460 }
461 return "";
462}
463
Elliott Hughes899e7892012-01-24 14:57:32 -0800464String* Thread::GetThreadName() const {
Elliott Hughesfc861622011-10-17 17:57:47 -0700465 return (peer_ != NULL) ? reinterpret_cast<String*>(gThread_name->GetObject(peer_)) : NULL;
466}
467
Elliott Hughesffb465f2012-03-01 18:46:05 -0800468void Thread::GetThreadName(std::string& name) const {
469 name.assign(*name_);
470}
471
Elliott Hughesd92bec42011-09-02 17:04:36 -0700472void Thread::DumpState(std::ostream& os) const {
Elliott Hughesd369bb72011-09-12 14:41:14 -0700473 std::string group_name;
474 int priority;
475 bool is_daemon = false;
Elliott Hughesdcc24742011-09-07 14:02:44 -0700476
Elliott Hughesd369bb72011-09-12 14:41:14 -0700477 if (peer_ != NULL) {
Elliott Hughes038a8062011-09-18 14:12:41 -0700478 priority = gThread_priority->GetInt(peer_);
479 is_daemon = gThread_daemon->GetBoolean(peer_);
Elliott Hughesd369bb72011-09-12 14:41:14 -0700480
Elliott Hughesa2155262011-11-16 16:26:58 -0800481 Object* thread_group = GetThreadGroup();
Elliott Hughesd369bb72011-09-12 14:41:14 -0700482 if (thread_group != NULL) {
Elliott Hughes038a8062011-09-18 14:12:41 -0700483 String* group_name_string = reinterpret_cast<String*>(gThreadGroup_name->GetObject(thread_group));
Elliott Hughesd369bb72011-09-12 14:41:14 -0700484 group_name = (group_name_string != NULL) ? group_name_string->ToModifiedUtf8() : "<null>";
485 }
486 } else {
Elliott Hughesd369bb72011-09-12 14:41:14 -0700487 priority = GetNativePriority();
Elliott Hughesdcc24742011-09-07 14:02:44 -0700488 }
Elliott Hughesd92bec42011-09-02 17:04:36 -0700489
490 int policy;
491 sched_param sp;
Elliott Hughes3147a232011-10-12 15:55:07 -0700492 CHECK_PTHREAD_CALL(pthread_getschedparam, (pthread_self(), &policy, &sp), __FUNCTION__);
Elliott Hughesd92bec42011-09-02 17:04:36 -0700493
494 std::string scheduler_group(GetSchedulerGroup(GetTid()));
495 if (scheduler_group.empty()) {
496 scheduler_group = "default";
497 }
498
Elliott Hughes899e7892012-01-24 14:57:32 -0800499 os << '"' << *name_ << '"';
Elliott Hughesd369bb72011-09-12 14:41:14 -0700500 if (is_daemon) {
Elliott Hughesd92bec42011-09-02 17:04:36 -0700501 os << " daemon";
502 }
503 os << " prio=" << priority
Elliott Hughesdcc24742011-09-07 14:02:44 -0700504 << " tid=" << GetThinLockId()
Elliott Hughes93e74e82011-09-13 11:07:03 -0700505 << " " << GetState() << "\n";
Elliott Hughesd92bec42011-09-02 17:04:36 -0700506
Elliott Hughesd92bec42011-09-02 17:04:36 -0700507 os << " | group=\"" << group_name << "\""
Elliott Hughes8d768a92011-09-14 16:35:25 -0700508 << " sCount=" << suspend_count_
Elliott Hughes234ab152011-10-26 14:02:26 -0700509 << " dsCount=" << debug_suspend_count_
Elliott Hughesdcc24742011-09-07 14:02:44 -0700510 << " obj=" << reinterpret_cast<void*>(peer_)
Elliott Hughesd92bec42011-09-02 17:04:36 -0700511 << " self=" << reinterpret_cast<const void*>(this) << "\n";
512 os << " | sysTid=" << GetTid()
513 << " nice=" << getpriority(PRIO_PROCESS, GetTid())
514 << " sched=" << policy << "/" << sp.sched_priority
515 << " cgrp=" << scheduler_group
Elliott Hughes3147a232011-10-12 15:55:07 -0700516 << " handle=" << pthread_self() << "\n";
Elliott Hughesd92bec42011-09-02 17:04:36 -0700517
518 // Grab the scheduler stats for this thread.
519 std::string scheduler_stats;
520 if (ReadFileToString(StringPrintf("/proc/self/task/%d/schedstat", GetTid()).c_str(), &scheduler_stats)) {
521 scheduler_stats.resize(scheduler_stats.size() - 1); // Lose the trailing '\n'.
522 } else {
523 scheduler_stats = "0 0 0";
524 }
525
526 int utime = 0;
527 int stime = 0;
528 int task_cpu = 0;
Elliott Hughesbfe487b2011-10-26 15:48:55 -0700529 GetTaskStats(GetTid(), utime, stime, task_cpu);
Elliott Hughesd92bec42011-09-02 17:04:36 -0700530
531 os << " | schedstat=( " << scheduler_stats << " )"
532 << " utm=" << utime
533 << " stm=" << stime
534 << " core=" << task_cpu
535 << " HZ=" << sysconf(_SC_CLK_TCK) << "\n";
536}
537
Ian Rogersb04f69f2011-10-17 00:40:54 -0700538void Thread::PushNativeToManagedRecord(NativeToManagedRecord* record) {
539 Method **sp = top_of_managed_stack_.GetSP();
540#ifndef NDEBUG
541 if (sp != NULL) {
542 Method* m = *sp;
543 Heap::VerifyObject(m);
544 DCHECK((m == NULL) || m->IsMethod());
545 }
546#endif
547 record->last_top_of_managed_stack_ = reinterpret_cast<void*>(sp);
548 record->last_top_of_managed_stack_pc_ = top_of_managed_stack_pc_;
549 record->link_ = native_to_managed_record_;
550 native_to_managed_record_ = record;
551 top_of_managed_stack_.SetSP(NULL);
552}
553
554void Thread::PopNativeToManagedRecord(const NativeToManagedRecord& record) {
555 native_to_managed_record_ = record.link_;
556 top_of_managed_stack_.SetSP(reinterpret_cast<Method**>(record.last_top_of_managed_stack_));
557 top_of_managed_stack_pc_ = record.last_top_of_managed_stack_pc_;
558}
559
Elliott Hughesd369bb72011-09-12 14:41:14 -0700560struct StackDumpVisitor : public Thread::StackVisitor {
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700561 StackDumpVisitor(std::ostream& os, const Thread* thread)
Ian Rogers28ad40d2011-10-27 15:19:26 -0700562 : last_method(NULL), last_line_number(0), repetition_count(0), os(os), thread(thread),
563 frame_count(0) {
Elliott Hughesd369bb72011-09-12 14:41:14 -0700564 }
565
Ian Rogersbdb03912011-09-14 00:55:44 -0700566 virtual ~StackDumpVisitor() {
Elliott Hughesd369bb72011-09-12 14:41:14 -0700567 }
568
Ian Rogersbdb03912011-09-14 00:55:44 -0700569 void VisitFrame(const Frame& frame, uintptr_t pc) {
Ian Rogers90865722011-09-19 11:11:44 -0700570 if (!frame.HasMethod()) {
571 return;
572 }
Ian Rogers28ad40d2011-10-27 15:19:26 -0700573 const int kMaxRepetition = 3;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700574 Method* m = frame.GetMethod();
575 Class* c = m->GetDeclaringClass();
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700576 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Ian Rogersb861dc02011-11-14 17:00:05 -0800577 const DexCache* dex_cache = c->GetDexCache();
578 int line_number = -1;
579 if (dex_cache != NULL) { // be tolerant of bad input
580 const DexFile& dex_file = class_linker->FindDexFile(dex_cache);
581 line_number = dex_file.GetLineNumFromPC(m, m->ToDexPC(pc));
582 }
Ian Rogers28ad40d2011-10-27 15:19:26 -0700583 if (line_number == last_line_number && last_method == m) {
584 repetition_count++;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700585 } else {
Ian Rogers28ad40d2011-10-27 15:19:26 -0700586 if (repetition_count >= kMaxRepetition) {
587 os << " ... repeated " << (repetition_count - kMaxRepetition) << " times\n";
588 }
589 repetition_count = 0;
590 last_line_number = line_number;
591 last_method = m;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700592 }
Ian Rogers28ad40d2011-10-27 15:19:26 -0700593 if (repetition_count < kMaxRepetition) {
594 os << " at " << PrettyMethod(m, false);
595 if (m->IsNative()) {
596 os << "(Native method)";
597 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800598 mh.ChangeMethod(m);
599 const char* source_file(mh.GetDeclaringClassSourceFile());
600 os << "(" << (source_file != NULL ? source_file : "unavailable")
Ian Rogers28ad40d2011-10-27 15:19:26 -0700601 << ":" << line_number << ")";
602 }
603 os << "\n";
604 }
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700605
606 if (frame_count++ == 0) {
607 Monitor::DescribeWait(os, thread);
608 }
Elliott Hughesd369bb72011-09-12 14:41:14 -0700609 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800610 MethodHelper mh;
Ian Rogers28ad40d2011-10-27 15:19:26 -0700611 Method* last_method;
612 int last_line_number;
613 int repetition_count;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700614 std::ostream& os;
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700615 const Thread* thread;
616 int frame_count;
Elliott Hughesd369bb72011-09-12 14:41:14 -0700617};
618
Elliott Hughesd92bec42011-09-02 17:04:36 -0700619void Thread::DumpStack(std::ostream& os) const {
Elliott Hughesffb465f2012-03-01 18:46:05 -0800620 // If we're currently in native code, dump that stack before dumping the managed stack.
621 if (GetState() == Thread::kNative || GetState() == Thread::kVmWait) {
622 DumpNativeStack(os);
623 }
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700624 StackDumpVisitor dumper(os, this);
Elliott Hughesd369bb72011-09-12 14:41:14 -0700625 WalkStack(&dumper);
Elliott Hughese27955c2011-08-26 15:21:24 -0700626}
627
Elliott Hughesa4060e52012-03-02 16:51:35 -0800628void Thread::SetStateWithoutSuspendCheck(Thread::State new_state) {
629 volatile void* raw = reinterpret_cast<volatile void*>(&state_);
630 volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
631 android_atomic_release_store(new_state, addr);
632}
633
Elliott Hughes8d768a92011-09-14 16:35:25 -0700634Thread::State Thread::SetState(Thread::State new_state) {
635 Thread::State old_state = state_;
636 if (old_state == new_state) {
637 return old_state;
638 }
639
640 volatile void* raw = reinterpret_cast<volatile void*>(&state_);
641 volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
642
643 if (new_state == Thread::kRunnable) {
644 /*
645 * Change our status to Thread::kRunnable. The transition requires
646 * that we check for pending suspension, because the VM considers
647 * us to be "asleep" in all other states, and another thread could
648 * be performing a GC now.
649 *
650 * The order of operations is very significant here. One way to
651 * do this wrong is:
652 *
653 * GCing thread Our thread (in kNative)
654 * ------------ ----------------------
655 * check suspend count (== 0)
656 * SuspendAllThreads()
657 * grab suspend-count lock
658 * increment all suspend counts
659 * release suspend-count lock
660 * check thread state (== kNative)
661 * all are suspended, begin GC
662 * set state to kRunnable
663 * (continue executing)
664 *
665 * We can correct this by grabbing the suspend-count lock and
666 * performing both of our operations (check suspend count, set
667 * state) while holding it, now we need to grab a mutex on every
668 * transition to kRunnable.
669 *
670 * What we do instead is change the order of operations so that
671 * the transition to kRunnable happens first. If we then detect
672 * that the suspend count is nonzero, we switch to kSuspended.
673 *
674 * Appropriate compiler and memory barriers are required to ensure
675 * that the operations are observed in the expected order.
676 *
677 * This does create a small window of opportunity where a GC in
678 * progress could observe what appears to be a running thread (if
679 * it happens to look between when we set to kRunnable and when we
680 * switch to kSuspended). At worst this only affects assertions
681 * and thread logging. (We could work around it with some sort
682 * of intermediate "pre-running" state that is generally treated
683 * as equivalent to running, but that doesn't seem worthwhile.)
684 *
685 * We can also solve this by combining the "status" and "suspend
686 * count" fields into a single 32-bit value. This trades the
687 * store/load barrier on transition to kRunnable for an atomic RMW
688 * op on all transitions and all suspend count updates (also, all
689 * accesses to status or the thread count require bit-fiddling).
690 * It also eliminates the brief transition through kRunnable when
691 * the thread is supposed to be suspended. This is possibly faster
692 * on SMP and slightly more correct, but less convenient.
693 */
694 android_atomic_acquire_store(new_state, addr);
Elliott Hughes06e3ad42012-02-07 14:51:57 -0800695 ANNOTATE_IGNORE_READS_BEGIN();
696 int suspend_count = suspend_count_;
697 ANNOTATE_IGNORE_READS_END();
698 if (suspend_count != 0) {
Elliott Hughes8d768a92011-09-14 16:35:25 -0700699 Runtime::Current()->GetThreadList()->FullSuspendCheck(this);
700 }
701 } else {
702 /*
703 * Not changing to Thread::kRunnable. No additional work required.
704 *
705 * We use a releasing store to ensure that, if we were runnable,
706 * any updates we previously made to objects on the managed heap
707 * will be observed before the state change.
708 */
709 android_atomic_release_store(new_state, addr);
710 }
711
712 return old_state;
713}
714
Elliott Hughes761928d2011-11-16 18:33:03 -0800715bool Thread::IsSuspended() {
Elliott Hughes06e3ad42012-02-07 14:51:57 -0800716 ANNOTATE_IGNORE_READS_BEGIN();
717 int suspend_count = suspend_count_;
718 ANNOTATE_IGNORE_READS_END();
719 return suspend_count != 0 && GetState() != Thread::kRunnable;
Elliott Hughes761928d2011-11-16 18:33:03 -0800720}
721
Elliott Hughesff738062012-02-03 15:00:42 -0800722static void ReportThreadSuspendTimeout(Thread* waiting_thread) {
723 Runtime* runtime = Runtime::Current();
724 std::ostringstream ss;
Elliott Hughesffb465f2012-03-01 18:46:05 -0800725 ss << "Thread suspend timeout waiting for thread " << *waiting_thread << "\n";
Elliott Hughesff738062012-02-03 15:00:42 -0800726 runtime->DumpLockHolders(ss);
727 ss << "\n";
728 runtime->GetThreadList()->DumpLocked(ss);
729 LOG(FATAL) << ss.str();
730}
731
Elliott Hughes8d768a92011-09-14 16:35:25 -0700732void Thread::WaitUntilSuspended() {
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800733 static const useconds_t kTimeoutUs = 30 * 1000000; // 30s.
734
735 useconds_t total_delay = 0;
Elliott Hughes8d768a92011-09-14 16:35:25 -0700736 useconds_t delay = 0;
737 while (GetState() == Thread::kRunnable) {
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800738 if (total_delay >= kTimeoutUs) {
Elliott Hughesff738062012-02-03 15:00:42 -0800739 ReportThreadSuspendTimeout(this);
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800740 }
Elliott Hughes8d768a92011-09-14 16:35:25 -0700741 useconds_t new_delay = delay * 2;
742 CHECK_GE(new_delay, delay);
743 delay = new_delay;
744 if (delay == 0) {
745 sched_yield();
746 delay = 10000;
747 } else {
748 usleep(delay);
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800749 total_delay += delay;
Elliott Hughes8d768a92011-09-14 16:35:25 -0700750 }
751 }
752}
753
Elliott Hughesbe759c62011-09-08 19:38:21 -0700754void Thread::ThreadExitCallback(void* arg) {
755 Thread* self = reinterpret_cast<Thread*>(arg);
756 LOG(FATAL) << "Native thread exited without calling DetachCurrentThread: " << *self;
Carl Shapirob5573532011-07-12 18:22:59 -0700757}
758
Elliott Hughesbe759c62011-09-08 19:38:21 -0700759void Thread::Startup() {
Carl Shapirob5573532011-07-12 18:22:59 -0700760 // Allocate a TLS slot.
Elliott Hughes8d768a92011-09-14 16:35:25 -0700761 CHECK_PTHREAD_CALL(pthread_key_create, (&Thread::pthread_key_self_, Thread::ThreadExitCallback), "self key");
Carl Shapirob5573532011-07-12 18:22:59 -0700762
763 // Double-check the TLS slot allocation.
764 if (pthread_getspecific(pthread_key_self_) != NULL) {
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800765 LOG(FATAL) << "Newly-created pthread TLS slot is not NULL";
Carl Shapirob5573532011-07-12 18:22:59 -0700766 }
Elliott Hughes038a8062011-09-18 14:12:41 -0700767}
Carl Shapirob5573532011-07-12 18:22:59 -0700768
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700769// TODO: make more accessible?
770Class* FindPrimitiveClassOrDie(ClassLinker* class_linker, char descriptor) {
771 Class* c = class_linker->FindPrimitiveClass(descriptor);
772 CHECK(c != NULL) << descriptor;
773 return c;
774}
775
776// TODO: make more accessible?
777Class* FindClassOrDie(ClassLinker* class_linker, const char* descriptor) {
778 Class* c = class_linker->FindSystemClass(descriptor);
779 CHECK(c != NULL) << descriptor;
780 return c;
781}
782
783// TODO: make more accessible?
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700784Field* FindFieldOrDie(Class* c, const char* name, const char* descriptor) {
785 Field* f = c->FindDeclaredInstanceField(name, descriptor);
786 CHECK(f != NULL) << PrettyClass(c) << " " << name << " " << descriptor;
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700787 return f;
788}
789
790// TODO: make more accessible?
791Method* FindMethodOrDie(Class* c, const char* name, const char* signature) {
792 Method* m = c->FindVirtualMethod(name, signature);
793 CHECK(m != NULL) << PrettyClass(c) << " " << name << " " << signature;
794 return m;
795}
796
Elliott Hughes038a8062011-09-18 14:12:41 -0700797void Thread::FinishStartup() {
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500798 CHECK(Runtime::Current()->IsStarted());
Brian Carlstromb82b6872011-10-26 17:18:07 -0700799 Thread* self = Thread::Current();
800
801 // Need to be kRunnable for FindClass
802 ScopedThreadStateChange tsc(self, Thread::kRunnable);
803
Elliott Hughes038a8062011-09-18 14:12:41 -0700804 // Now the ClassLinker is ready, we can find the various Class*, Field*, and Method*s we need.
805 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700806
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700807 Class* Thread_class = FindClassOrDie(class_linker, "Ljava/lang/Thread;");
808 Class* ThreadGroup_class = FindClassOrDie(class_linker, "Ljava/lang/ThreadGroup;");
809 Class* UncaughtExceptionHandler_class = FindClassOrDie(class_linker, "Ljava/lang/Thread$UncaughtExceptionHandler;");
810 gThreadLock = FindClassOrDie(class_linker, "Ljava/lang/ThreadLock;");
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700811
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700812 gThread_daemon = FindFieldOrDie(Thread_class, "daemon", "Z");
813 gThread_group = FindFieldOrDie(Thread_class, "group", "Ljava/lang/ThreadGroup;");
814 gThread_lock = FindFieldOrDie(Thread_class, "lock", "Ljava/lang/ThreadLock;");
815 gThread_name = FindFieldOrDie(Thread_class, "name", "Ljava/lang/String;");
816 gThread_priority = FindFieldOrDie(Thread_class, "priority", "I");
817 gThread_uncaughtHandler = FindFieldOrDie(Thread_class, "uncaughtHandler", "Ljava/lang/Thread$UncaughtExceptionHandler;");
818 gThread_vmData = FindFieldOrDie(Thread_class, "vmData", "I");
819 gThreadGroup_name = FindFieldOrDie(ThreadGroup_class, "name", "Ljava/lang/String;");
820 gThreadLock_thread = FindFieldOrDie(gThreadLock, "thread", "Ljava/lang/Thread;");
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700821
822 gThread_run = FindMethodOrDie(Thread_class, "run", "()V");
823 gThreadGroup_removeThread = FindMethodOrDie(ThreadGroup_class, "removeThread", "(Ljava/lang/Thread;)V");
824 gUncaughtExceptionHandler_uncaughtException = FindMethodOrDie(UncaughtExceptionHandler_class,
825 "uncaughtException", "(Ljava/lang/Thread;Ljava/lang/Throwable;)V");
Elliott Hughes01158d72011-09-19 19:47:10 -0700826
827 // Finish attaching the main thread.
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500828 Thread::Current()->CreatePeer("main", false);
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500829
830 InitBoxingMethods();
831 class_linker->RunRootClinits();
Carl Shapirob5573532011-07-12 18:22:59 -0700832}
833
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700834void Thread::Shutdown() {
Elliott Hughes8d768a92011-09-14 16:35:25 -0700835 CHECK_PTHREAD_CALL(pthread_key_delete, (Thread::pthread_key_self_), "self key");
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700836}
837
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700838uint32_t Thread::LockOwnerFromThreadLock(Object* thread_lock) {
839 if (thread_lock == NULL || thread_lock->GetClass() != gThreadLock) {
840 return ThreadList::kInvalidId;
841 }
842 Object* managed_thread = gThreadLock_thread->GetObject(thread_lock);
843 if (managed_thread == NULL) {
844 return ThreadList::kInvalidId;
845 }
846 uintptr_t vmData = static_cast<uintptr_t>(gThread_vmData->GetInt(managed_thread));
847 Thread* thread = reinterpret_cast<Thread*>(vmData);
848 if (thread == NULL) {
849 return ThreadList::kInvalidId;
850 }
851 return thread->GetThinLockId();
852}
853
Elliott Hughesdcc24742011-09-07 14:02:44 -0700854Thread::Thread()
Elliott Hughes47179f72011-10-27 16:44:39 -0700855 : thin_lock_id_(0),
856 tid_(0),
857 peer_(NULL),
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700858 top_of_managed_stack_(),
859 top_of_managed_stack_pc_(0),
Elliott Hughes85d15452011-09-16 17:33:01 -0700860 wait_mutex_(new Mutex("Thread wait mutex")),
861 wait_cond_(new ConditionVariable("Thread wait condition variable")),
Elliott Hughes8daa0922011-09-11 13:46:25 -0700862 wait_monitor_(NULL),
863 interrupted_(false),
Elliott Hughesdc33ad52011-09-16 19:46:51 -0700864 wait_next_(NULL),
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700865 monitor_enter_object_(NULL),
Elliott Hughesdc33ad52011-09-16 19:46:51 -0700866 card_table_(0),
Elliott Hughes8daa0922011-09-11 13:46:25 -0700867 stack_end_(NULL),
Elliott Hughesdcc24742011-09-07 14:02:44 -0700868 native_to_managed_record_(NULL),
869 top_sirt_(NULL),
870 jni_env_(NULL),
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700871 state_(Thread::kNative),
Elliott Hughesdc33ad52011-09-16 19:46:51 -0700872 self_(NULL),
873 runtime_(NULL),
Elliott Hughesdcc24742011-09-07 14:02:44 -0700874 exception_(NULL),
875 suspend_count_(0),
Elliott Hughes234ab152011-10-26 14:02:26 -0700876 debug_suspend_count_(0),
Elliott Hughes85d15452011-09-16 17:33:01 -0700877 class_loader_override_(NULL),
Elliott Hughes418dfe72011-10-06 18:56:27 -0700878 long_jump_context_(NULL),
Elliott Hughes726079d2011-10-07 18:43:44 -0700879 throwing_OutOfMemoryError_(false),
Elliott Hughes475fc232011-10-25 15:00:35 -0700880 pre_allocated_OutOfMemoryError_(NULL),
jeffhaoe343b762011-12-05 16:36:44 -0800881 debug_invoke_req_(new DebugInvokeReq),
Elliott Hughes899e7892012-01-24 14:57:32 -0800882 trace_stack_(new std::vector<TraceStackFrame>),
883 name_(new std::string("<native thread without managed peer>")) {
Elliott Hughesf5a7a472011-10-07 14:31:02 -0700884 CHECK_EQ((sizeof(Thread) % 4), 0U) << sizeof(Thread);
Elliott Hughesffb465f2012-03-01 18:46:05 -0800885 memset(&held_mutexes_[0], 0, sizeof(held_mutexes_));
Elliott Hughesdcc24742011-09-07 14:02:44 -0700886}
887
Elliott Hughes02b48d12011-09-07 17:15:51 -0700888void MonitorExitVisitor(const Object* object, void*) {
889 Object* entered_monitor = const_cast<Object*>(object);
Elliott Hughes5f791332011-09-15 17:45:30 -0700890 entered_monitor->MonitorExit(Thread::Current());
Elliott Hughes02b48d12011-09-07 17:15:51 -0700891}
892
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700893Thread::~Thread() {
Elliott Hughes02b48d12011-09-07 17:15:51 -0700894 // On thread detach, all monitors entered with JNI MonitorEnter are automatically exited.
Elliott Hughes93e74e82011-09-13 11:07:03 -0700895 if (jni_env_ != NULL) {
896 jni_env_->monitors.VisitRoots(MonitorExitVisitor, NULL);
897 }
Elliott Hughes02b48d12011-09-07 17:15:51 -0700898
Elliott Hughes93e74e82011-09-13 11:07:03 -0700899 if (peer_ != NULL) {
Elliott Hughes29f27422011-09-18 16:02:18 -0700900
901 // this.vmData = 0;
Elliott Hughes93e74e82011-09-13 11:07:03 -0700902 SetVmData(peer_, NULL);
Elliott Hughes02b48d12011-09-07 17:15:51 -0700903
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700904 Dbg::PostThreadDeath(this);
Elliott Hughes02b48d12011-09-07 17:15:51 -0700905
Elliott Hughes29f27422011-09-18 16:02:18 -0700906 // Thread.join() is implemented as an Object.wait() on the Thread.lock
907 // object. Signal anyone who is waiting.
Elliott Hughes5f791332011-09-15 17:45:30 -0700908 Thread* self = Thread::Current();
Elliott Hughes038a8062011-09-18 14:12:41 -0700909 Object* lock = gThread_lock->GetObject(peer_);
910 // (This conditional is only needed for tests, where Thread.lock won't have been set.)
Elliott Hughes5f791332011-09-15 17:45:30 -0700911 if (lock != NULL) {
912 lock->MonitorEnter(self);
913 lock->NotifyAll();
914 lock->MonitorExit(self);
915 }
916 }
Elliott Hughes02b48d12011-09-07 17:15:51 -0700917
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700918 delete jni_env_;
Elliott Hughes02b48d12011-09-07 17:15:51 -0700919 jni_env_ = NULL;
920
921 SetState(Thread::kTerminated);
Elliott Hughes85d15452011-09-16 17:33:01 -0700922
923 delete wait_cond_;
924 delete wait_mutex_;
925
926 delete long_jump_context_;
Elliott Hughes475fc232011-10-25 15:00:35 -0700927
928 delete debug_invoke_req_;
jeffhaoe343b762011-12-05 16:36:44 -0800929 delete trace_stack_;
Elliott Hughes899e7892012-01-24 14:57:32 -0800930 delete name_;
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700931}
932
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700933void Thread::HandleUncaughtExceptions() {
934 if (!IsExceptionPending()) {
935 return;
936 }
937
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700938 // Get and clear the exception.
939 Object* exception = GetException();
940 ClearException();
941
942 // If the thread has its own handler, use that.
943 Object* handler = gThread_uncaughtHandler->GetObject(peer_);
944 if (handler == NULL) {
945 // Otherwise use the thread group's default handler.
Elliott Hughesa2155262011-11-16 16:26:58 -0800946 handler = GetThreadGroup();
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700947 }
948
949 // Call the handler.
950 Method* m = handler->GetClass()->FindVirtualMethodForVirtualOrInterface(gUncaughtExceptionHandler_uncaughtException);
951 Object* args[2];
952 args[0] = peer_;
953 args[1] = exception;
954 m->Invoke(this, handler, reinterpret_cast<byte*>(&args), NULL);
955
956 // If the handler threw, clear that exception too.
957 ClearException();
958}
959
Elliott Hughesa2155262011-11-16 16:26:58 -0800960Object* Thread::GetThreadGroup() const {
961 return gThread_group->GetObject(peer_);
962}
963
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700964void Thread::RemoveFromThreadGroup() {
965 // this.group.removeThread(this);
966 // group can be null if we're in the compiler or a test.
Elliott Hughesa2155262011-11-16 16:26:58 -0800967 Object* group = GetThreadGroup();
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700968 if (group != NULL) {
969 Method* m = group->GetClass()->FindVirtualMethodForVirtualOrInterface(gThreadGroup_removeThread);
970 Object* args = peer_;
971 m->Invoke(this, group, reinterpret_cast<byte*>(&args), NULL);
972 }
973}
974
Ian Rogers408f79a2011-08-23 18:22:33 -0700975size_t Thread::NumSirtReferences() {
Ian Rogersa8cd9f42011-08-19 16:43:41 -0700976 size_t count = 0;
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700977 for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
Ian Rogersa8cd9f42011-08-19 16:43:41 -0700978 count += cur->NumberOfReferences();
979 }
980 return count;
981}
982
Ian Rogers408f79a2011-08-23 18:22:33 -0700983bool Thread::SirtContains(jobject obj) {
984 Object** sirt_entry = reinterpret_cast<Object**>(obj);
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700985 for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
986 if (cur->Contains(sirt_entry)) {
Ian Rogersa8cd9f42011-08-19 16:43:41 -0700987 return true;
988 }
989 }
990 return false;
991}
992
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -0700993void Thread::SirtVisitRoots(Heap::RootVisitor* visitor, void* arg) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700994 for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -0700995 size_t num_refs = cur->NumberOfReferences();
996 for (size_t j = 0; j < num_refs; j++) {
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700997 Object* object = cur->GetReference(j);
Brian Carlstrom5e73f9c2011-10-11 11:28:12 -0700998 if (object != NULL) {
999 visitor(object, arg);
1000 }
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -07001001 }
1002 }
1003}
1004
Ian Rogers408f79a2011-08-23 18:22:33 -07001005Object* Thread::DecodeJObject(jobject obj) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001006 DCHECK(CanAccessDirectReferences());
Ian Rogers408f79a2011-08-23 18:22:33 -07001007 if (obj == NULL) {
1008 return NULL;
1009 }
1010 IndirectRef ref = reinterpret_cast<IndirectRef>(obj);
1011 IndirectRefKind kind = GetIndirectRefKind(ref);
1012 Object* result;
1013 switch (kind) {
1014 case kLocal:
1015 {
Elliott Hughes69f5bc62011-08-24 09:26:14 -07001016 IndirectReferenceTable& locals = jni_env_->locals;
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001017 result = const_cast<Object*>(locals.Get(ref));
Ian Rogers408f79a2011-08-23 18:22:33 -07001018 break;
1019 }
1020 case kGlobal:
1021 {
1022 JavaVMExt* vm = Runtime::Current()->GetJavaVM();
1023 IndirectReferenceTable& globals = vm->globals;
1024 MutexLock mu(vm->globals_lock);
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001025 result = const_cast<Object*>(globals.Get(ref));
Ian Rogers408f79a2011-08-23 18:22:33 -07001026 break;
1027 }
1028 case kWeakGlobal:
1029 {
1030 JavaVMExt* vm = Runtime::Current()->GetJavaVM();
1031 IndirectReferenceTable& weak_globals = vm->weak_globals;
1032 MutexLock mu(vm->weak_globals_lock);
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001033 result = const_cast<Object*>(weak_globals.Get(ref));
Ian Rogers408f79a2011-08-23 18:22:33 -07001034 if (result == kClearedJniWeakGlobal) {
1035 // This is a special case where it's okay to return NULL.
1036 return NULL;
1037 }
1038 break;
1039 }
1040 case kSirtOrInvalid:
1041 default:
1042 // TODO: make stack indirect reference table lookup more efficient
1043 // Check if this is a local reference in the SIRT
1044 if (SirtContains(obj)) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001045 result = *reinterpret_cast<Object**>(obj); // Read from SIRT
Elliott Hughesc2dc62d2012-01-17 20:06:12 -08001046 } else if (Runtime::Current()->GetJavaVM()->work_around_app_jni_bugs) {
Ian Rogers408f79a2011-08-23 18:22:33 -07001047 // Assume an invalid local reference is actually a direct pointer.
1048 result = reinterpret_cast<Object*>(obj);
1049 } else {
Elliott Hughesa2501992011-08-26 19:39:54 -07001050 result = kInvalidIndirectRefObject;
Ian Rogers408f79a2011-08-23 18:22:33 -07001051 }
1052 }
1053
1054 if (result == NULL) {
Elliott Hughesa2501992011-08-26 19:39:54 -07001055 LOG(ERROR) << "JNI ERROR (app bug): use of deleted " << kind << ": " << obj;
1056 JniAbort(NULL);
1057 } else {
1058 if (result != kInvalidIndirectRefObject) {
1059 Heap::VerifyObject(result);
1060 }
Ian Rogers408f79a2011-08-23 18:22:33 -07001061 }
Ian Rogers408f79a2011-08-23 18:22:33 -07001062 return result;
1063}
1064
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001065class CountStackDepthVisitor : public Thread::StackVisitor {
1066 public:
Elliott Hughes29f27422011-09-18 16:02:18 -07001067 CountStackDepthVisitor() : depth_(0), skip_depth_(0), skipping_(true) {}
Elliott Hughesd369bb72011-09-12 14:41:14 -07001068
Elliott Hughes29f27422011-09-18 16:02:18 -07001069 virtual void VisitFrame(const Frame& frame, uintptr_t pc) {
1070 // We want to skip frames up to and including the exception's constructor.
Ian Rogers90865722011-09-19 11:11:44 -07001071 // Note we also skip the frame if it doesn't have a method (namely the callee
1072 // save frame)
Ian Rogers5167c972012-02-03 10:41:20 -08001073 if (skipping_ && frame.HasMethod() &&
1074 !Throwable::GetJavaLangThrowable()->IsAssignableFrom(frame.GetMethod()->GetDeclaringClass())) {
Elliott Hughes29f27422011-09-18 16:02:18 -07001075 skipping_ = false;
1076 }
1077 if (!skipping_) {
Ian Rogers6b0870d2011-12-15 19:38:12 -08001078 if (frame.HasMethod()) { // ignore callee save frames
1079 ++depth_;
1080 }
Elliott Hughes29f27422011-09-18 16:02:18 -07001081 } else {
1082 ++skip_depth_;
1083 }
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001084 }
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001085
1086 int GetDepth() const {
Ian Rogersaaa20802011-09-11 21:47:37 -07001087 return depth_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001088 }
1089
Elliott Hughes29f27422011-09-18 16:02:18 -07001090 int GetSkipDepth() const {
1091 return skip_depth_;
1092 }
1093
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001094 private:
Ian Rogersaaa20802011-09-11 21:47:37 -07001095 uint32_t depth_;
Elliott Hughes29f27422011-09-18 16:02:18 -07001096 uint32_t skip_depth_;
1097 bool skipping_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001098};
1099
Ian Rogersaaa20802011-09-11 21:47:37 -07001100class BuildInternalStackTraceVisitor : public Thread::StackVisitor {
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001101 public:
Ian Rogers283ed0d2012-02-16 15:25:09 -08001102 explicit BuildInternalStackTraceVisitor(int skip_depth)
Elliott Hughes726079d2011-10-07 18:43:44 -07001103 : skip_depth_(skip_depth), count_(0), pc_trace_(NULL), method_trace_(NULL), local_ref_(NULL) {
Ian Rogers283ed0d2012-02-16 15:25:09 -08001104 }
1105
1106 bool Init(int depth, ScopedJniThreadState& ts) {
Ian Rogersaaa20802011-09-11 21:47:37 -07001107 // Allocate method trace with an extra slot that will hold the PC trace
Elliott Hughes01158d72011-09-19 19:47:10 -07001108 method_trace_ = Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(depth + 1);
Elliott Hughes726079d2011-10-07 18:43:44 -07001109 if (method_trace_ == NULL) {
Ian Rogers283ed0d2012-02-16 15:25:09 -08001110 return false;
Elliott Hughes726079d2011-10-07 18:43:44 -07001111 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001112 // Register a local reference as IntArray::Alloc may trigger GC
1113 local_ref_ = AddLocalReference<jobject>(ts.Env(), method_trace_);
1114 pc_trace_ = IntArray::Alloc(depth);
Elliott Hughes726079d2011-10-07 18:43:44 -07001115 if (pc_trace_ == NULL) {
Ian Rogers283ed0d2012-02-16 15:25:09 -08001116 return false;
Elliott Hughes726079d2011-10-07 18:43:44 -07001117 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001118#ifdef MOVING_GARBAGE_COLLECTOR
1119 // Re-read after potential GC
Brian Carlstrom26736442012-02-16 18:24:26 -08001120 method_trace_ = Decode<ObjectArray<Object>*>(ts.Env(), local_ref_);
Ian Rogersaaa20802011-09-11 21:47:37 -07001121#endif
1122 // Save PC trace in last element of method trace, also places it into the
1123 // object graph.
1124 method_trace_->Set(depth, pc_trace_);
Ian Rogers283ed0d2012-02-16 15:25:09 -08001125 return true;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001126 }
1127
Ian Rogersaaa20802011-09-11 21:47:37 -07001128 virtual ~BuildInternalStackTraceVisitor() {}
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001129
Ian Rogersbdb03912011-09-14 00:55:44 -07001130 virtual void VisitFrame(const Frame& frame, uintptr_t pc) {
Elliott Hughes726079d2011-10-07 18:43:44 -07001131 if (method_trace_ == NULL || pc_trace_ == NULL) {
1132 return; // We're probably trying to fillInStackTrace for an OutOfMemoryError.
1133 }
Elliott Hughes29f27422011-09-18 16:02:18 -07001134 if (skip_depth_ > 0) {
1135 skip_depth_--;
1136 return;
1137 }
Ian Rogers6b0870d2011-12-15 19:38:12 -08001138 if (!frame.HasMethod()) {
1139 return; // ignore callee save frames
1140 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001141 method_trace_->Set(count_, frame.GetMethod());
Ian Rogersbdb03912011-09-14 00:55:44 -07001142 pc_trace_->Set(count_, pc);
Ian Rogersaaa20802011-09-11 21:47:37 -07001143 ++count_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001144 }
1145
Ian Rogersaaa20802011-09-11 21:47:37 -07001146 jobject GetInternalStackTrace() const {
1147 return local_ref_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001148 }
1149
1150 private:
Elliott Hughes29f27422011-09-18 16:02:18 -07001151 // How many more frames to skip.
1152 int32_t skip_depth_;
Ian Rogersaaa20802011-09-11 21:47:37 -07001153 // Current position down stack trace
1154 uint32_t count_;
1155 // Array of return PC values
1156 IntArray* pc_trace_;
1157 // An array of the methods on the stack, the last entry is a reference to the
1158 // PC trace
1159 ObjectArray<Object>* method_trace_;
1160 // Local indirect reference table entry for method trace
1161 jobject local_ref_;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001162};
1163
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001164// TODO: remove this.
1165uintptr_t ManglePc(uintptr_t pc) {
1166 // Move the PC back 2 bytes as a call will frequently terminate the
1167 // decoding of a particular instruction and we want to make sure we
1168 // get the Dex PC of the instruction with the call and not the
1169 // instruction following.
1170 if (pc > 0) { pc -= 2; }
1171 return pc;
1172}
1173
1174// TODO: remove this.
1175uintptr_t DemanglePc(uintptr_t pc) {
1176 // Revert mangling for the case where we need the PC to return to the upcall
1177 return pc + 2;
1178}
Ian Rogersf57c47c2011-10-06 00:06:17 -07001179
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001180void Thread::PushSirt(StackIndirectReferenceTable* sirt) {
1181 sirt->SetLink(top_sirt_);
1182 top_sirt_ = sirt;
1183}
1184
1185StackIndirectReferenceTable* Thread::PopSirt() {
1186 CHECK(top_sirt_ != NULL);
1187 StackIndirectReferenceTable* sirt = top_sirt_;
1188 top_sirt_ = top_sirt_->GetLink();
1189 return sirt;
1190}
1191
Ian Rogersaaa20802011-09-11 21:47:37 -07001192void Thread::WalkStack(StackVisitor* visitor) const {
Elliott Hughesd369bb72011-09-12 14:41:14 -07001193 Frame frame = GetTopOfStack();
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001194 uintptr_t pc = ManglePc(top_of_managed_stack_pc_);
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001195#if defined(__arm__)
1196 uint32_t trace_stack_depth = 0;
1197#endif
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001198 // TODO: enable this CHECK after native_to_managed_record_ is initialized during startup.
1199 // CHECK(native_to_managed_record_ != NULL);
1200 NativeToManagedRecord* record = native_to_managed_record_;
1201
Ian Rogersbdb03912011-09-14 00:55:44 -07001202 while (frame.GetSP() != 0) {
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001203 for ( ; frame.GetMethod() != 0; frame.Next()) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001204 // DCHECK(frame.GetMethod()->IsWithinCode(pc)); // TODO: restore IsWithinCode
Shih-wei Liao3ddac992011-10-07 00:48:09 -07001205 visitor->VisitFrame(frame, pc);
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001206 pc = ManglePc(frame.GetReturnPC());
jeffhao2692b572011-12-16 15:42:28 -08001207 if (Runtime::Current()->IsMethodTracingActive()) {
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001208#if defined(__arm__)
1209 uintptr_t trace_exit = reinterpret_cast<uintptr_t>(art_trace_exit_from_code);
1210 if (ManglePc(trace_exit) == pc) {
1211 TraceStackFrame trace_frame = GetTraceStackFrame(trace_stack_depth++);
jeffhao26c0a1a2012-01-17 16:28:33 -08001212 CHECK(trace_frame.method_ == frame.GetMethod());
jeffhaoa9ef3fd2011-12-13 18:33:43 -08001213 pc = ManglePc(trace_frame.return_pc_);
1214 }
1215#endif
1216 }
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001217 }
1218 if (record == NULL) {
1219 break;
1220 }
Ian Rogersbdb03912011-09-14 00:55:44 -07001221 // last_tos should return Frame instead of sp?
Ian Rogersff1ed472011-09-20 13:46:24 -07001222 frame.SetSP(reinterpret_cast<Method**>(record->last_top_of_managed_stack_));
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001223 pc = ManglePc(record->last_top_of_managed_stack_pc_);
Ian Rogersbdb03912011-09-14 00:55:44 -07001224 record = record->link_;
1225 }
1226}
1227
Ian Rogers67375ac2011-09-14 00:55:44 -07001228void Thread::WalkStackUntilUpCall(StackVisitor* visitor, bool include_upcall) const {
Ian Rogersbdb03912011-09-14 00:55:44 -07001229 Frame frame = GetTopOfStack();
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001230 uintptr_t pc = ManglePc(top_of_managed_stack_pc_);
Ian Rogersbdb03912011-09-14 00:55:44 -07001231
1232 if (frame.GetSP() != 0) {
1233 for ( ; frame.GetMethod() != 0; frame.Next()) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001234 // DCHECK(frame.GetMethod()->IsWithinCode(pc)); // TODO: restore IsWithinCode
Shih-wei Liao3ddac992011-10-07 00:48:09 -07001235 visitor->VisitFrame(frame, pc);
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001236 pc = ManglePc(frame.GetReturnPC());
Ian Rogersbdb03912011-09-14 00:55:44 -07001237 }
Ian Rogers67375ac2011-09-14 00:55:44 -07001238 if (include_upcall) {
1239 visitor->VisitFrame(frame, pc);
1240 }
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001241 }
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001242}
1243
Elliott Hughes01158d72011-09-19 19:47:10 -07001244jobject Thread::CreateInternalStackTrace(JNIEnv* env) const {
Ian Rogersaaa20802011-09-11 21:47:37 -07001245 // Compute depth of stack
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001246 CountStackDepthVisitor count_visitor;
1247 WalkStack(&count_visitor);
1248 int32_t depth = count_visitor.GetDepth();
Elliott Hughes29f27422011-09-18 16:02:18 -07001249 int32_t skip_depth = count_visitor.GetSkipDepth();
Shih-wei Liao44175362011-08-28 16:59:17 -07001250
Ian Rogersaaa20802011-09-11 21:47:37 -07001251 // Transition into runnable state to work on Object*/Array*
Elliott Hughes01158d72011-09-19 19:47:10 -07001252 ScopedJniThreadState ts(env);
Ian Rogersaaa20802011-09-11 21:47:37 -07001253
1254 // Build internal stack trace
Ian Rogers77f74c12012-02-16 22:35:30 -08001255 BuildInternalStackTraceVisitor build_trace_visitor(skip_depth);
1256 if (!build_trace_visitor.Init(depth, ts)) {
Ian Rogers283ed0d2012-02-16 15:25:09 -08001257 return NULL; // Allocation failed
Ian Rogers283ed0d2012-02-16 15:25:09 -08001258 }
Brian Carlstrom26736442012-02-16 18:24:26 -08001259 WalkStack(&build_trace_visitor);
1260 return build_trace_visitor.GetInternalStackTrace();
Ian Rogersaaa20802011-09-11 21:47:37 -07001261}
1262
Elliott Hughes01158d72011-09-19 19:47:10 -07001263jobjectArray Thread::InternalStackTraceToStackTraceElementArray(JNIEnv* env, jobject internal,
1264 jobjectArray output_array, int* stack_depth) {
Ian Rogersaaa20802011-09-11 21:47:37 -07001265 // Transition into runnable state to work on Object*/Array*
1266 ScopedJniThreadState ts(env);
Ian Rogersaaa20802011-09-11 21:47:37 -07001267 // Decode the internal stack trace into the depth, method trace and PC trace
1268 ObjectArray<Object>* method_trace =
1269 down_cast<ObjectArray<Object>*>(Decode<Object*>(ts.Env(), internal));
Ian Rogers9074b992011-10-26 17:41:55 -07001270 int32_t depth = method_trace->GetLength() - 1;
Ian Rogersaaa20802011-09-11 21:47:37 -07001271 IntArray* pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
1272
1273 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1274
Elliott Hughes01158d72011-09-19 19:47:10 -07001275 jobjectArray result;
1276 ObjectArray<StackTraceElement>* java_traces;
1277 if (output_array != NULL) {
1278 // Reuse the array we were given.
1279 result = output_array;
1280 java_traces = reinterpret_cast<ObjectArray<StackTraceElement>*>(Decode<Array*>(env,
1281 output_array));
1282 // ...adjusting the number of frames we'll write to not exceed the array length.
1283 depth = std::min(depth, java_traces->GetLength());
1284 } else {
1285 // Create java_trace array and place in local reference table
1286 java_traces = class_linker->AllocStackTraceElementArray(depth);
Elliott Hughes30646832011-10-13 16:59:46 -07001287 if (java_traces == NULL) {
1288 return NULL;
1289 }
Elliott Hughes01158d72011-09-19 19:47:10 -07001290 result = AddLocalReference<jobjectArray>(ts.Env(), java_traces);
1291 }
1292
1293 if (stack_depth != NULL) {
1294 *stack_depth = depth;
1295 }
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001296
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001297 MethodHelper mh;
Shih-wei Liao9b576b42011-08-29 01:45:07 -07001298 for (int32_t i = 0; i < depth; ++i) {
Ian Rogersaaa20802011-09-11 21:47:37 -07001299 // Prepare parameters for StackTraceElement(String cls, String method, String file, int line)
1300 Method* method = down_cast<Method*>(method_trace->Get(i));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001301 mh.ChangeMethod(method);
Ian Rogersaaa20802011-09-11 21:47:37 -07001302 uint32_t native_pc = pc_trace->Get(i);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001303 int32_t line_number = mh.GetLineNumFromNativePC(native_pc);
Ian Rogersaaa20802011-09-11 21:47:37 -07001304 // Allocate element, potentially triggering GC
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001305 // TODO: reuse class_name_object via Class::name_?
Ian Rogers48601312011-12-07 16:45:19 -08001306 const char* descriptor = mh.GetDeclaringClassDescriptor();
1307 CHECK(descriptor != NULL);
1308 std::string class_name(PrettyDescriptor(descriptor));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001309 SirtRef<String> class_name_object(String::AllocFromModifiedUtf8(class_name.c_str()));
1310 if (class_name_object.get() == NULL) {
1311 return NULL;
1312 }
Ian Rogers48601312011-12-07 16:45:19 -08001313 const char* method_name = mh.GetName();
1314 CHECK(method_name != NULL);
1315 SirtRef<String> method_name_object(String::AllocFromModifiedUtf8(method_name));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001316 if (method_name_object.get() == NULL) {
1317 return NULL;
1318 }
Ian Rogers48601312011-12-07 16:45:19 -08001319 const char* source_file = mh.GetDeclaringClassSourceFile();
1320 SirtRef<String> source_name_object(String::AllocFromModifiedUtf8(source_file));
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001321 StackTraceElement* obj = StackTraceElement::Alloc(class_name_object.get(),
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001322 method_name_object.get(),
1323 source_name_object.get(),
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001324 line_number);
Elliott Hughes30646832011-10-13 16:59:46 -07001325 if (obj == NULL) {
1326 return NULL;
1327 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001328#ifdef MOVING_GARBAGE_COLLECTOR
1329 // Re-read after potential GC
1330 java_traces = Decode<ObjectArray<Object>*>(ts.Env(), result);
1331 method_trace = down_cast<ObjectArray<Object>*>(Decode<Object*>(ts.Env(), internal));
1332 pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
1333#endif
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001334 java_traces->Set(i, obj);
1335 }
Ian Rogersaaa20802011-09-11 21:47:37 -07001336 return result;
Shih-wei Liao55df06b2011-08-26 14:39:27 -07001337}
1338
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001339void Thread::ThrowNewExceptionF(const char* exception_class_descriptor, const char* fmt, ...) {
Elliott Hughesa5b897e2011-08-16 11:33:06 -07001340 va_list args;
1341 va_start(args, fmt);
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001342 ThrowNewExceptionV(exception_class_descriptor, fmt, args);
Elliott Hughesa5b897e2011-08-16 11:33:06 -07001343 va_end(args);
Elliott Hughes4a2b4172011-09-20 17:08:25 -07001344}
1345
1346void Thread::ThrowNewExceptionV(const char* exception_class_descriptor, const char* fmt, va_list ap) {
1347 std::string msg;
1348 StringAppendV(&msg, fmt, ap);
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001349 ThrowNewException(exception_class_descriptor, msg.c_str());
1350}
Elliott Hughes37f7a402011-08-22 18:56:01 -07001351
Elliott Hughes5cb5ad22011-10-02 12:13:39 -07001352void Thread::ThrowNewException(const char* exception_class_descriptor, const char* msg) {
Elliott Hughese5b0dc82011-08-23 09:59:02 -07001353 // Convert "Ljava/lang/Exception;" into JNI-style "java/lang/Exception".
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001354 CHECK_EQ('L', exception_class_descriptor[0]);
Elliott Hughese5b0dc82011-08-23 09:59:02 -07001355 std::string descriptor(exception_class_descriptor + 1);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -07001356 CHECK_EQ(';', descriptor[descriptor.length() - 1]);
Elliott Hughese5b0dc82011-08-23 09:59:02 -07001357 descriptor.erase(descriptor.length() - 1);
1358
1359 JNIEnv* env = GetJniEnv();
Elliott Hughes726079d2011-10-07 18:43:44 -07001360 ScopedLocalRef<jclass> exception_class(env, env->FindClass(descriptor.c_str()));
Elliott Hughes30646832011-10-13 16:59:46 -07001361 if (exception_class.get() == NULL) {
1362 LOG(ERROR) << "Couldn't throw new " << descriptor << " because JNI FindClass failed: "
1363 << PrettyTypeOf(GetException());
1364 CHECK(IsExceptionPending());
1365 return;
1366 }
Brian Carlstromebd1fd22011-12-07 15:46:26 -08001367 if (!Runtime::Current()->IsStarted()) {
1368 // Something is trying to throw an exception without a started
1369 // runtime, which is the common case in the compiler. We won't be
1370 // able to invoke the constructor of the exception, so use
1371 // AllocObject which will not invoke a constructor.
1372 ScopedLocalRef<jthrowable> exception(
1373 env, reinterpret_cast<jthrowable>(env->AllocObject(exception_class.get())));
1374 if (exception.get() != NULL) {
1375 ScopedJniThreadState ts(env);
1376 Throwable* t = reinterpret_cast<Throwable*>(ts.Self()->DecodeJObject(exception.get()));
Ian Rogers02fbef02012-01-31 22:15:33 -08001377 t->SetDetailMessage(String::AllocFromModifiedUtf8(msg));
Brian Carlstromebd1fd22011-12-07 15:46:26 -08001378 ts.Self()->SetException(t);
1379 } else {
1380 LOG(ERROR) << "Couldn't throw new " << descriptor << " because JNI AllocObject failed: "
1381 << PrettyTypeOf(GetException());
1382 CHECK(IsExceptionPending());
1383 }
1384 return;
1385 }
Elliott Hughes726079d2011-10-07 18:43:44 -07001386 int rc = env->ThrowNew(exception_class.get(), msg);
Elliott Hughes30646832011-10-13 16:59:46 -07001387 if (rc != JNI_OK) {
1388 LOG(ERROR) << "Couldn't throw new " << descriptor << " because JNI ThrowNew failed: "
1389 << PrettyTypeOf(GetException());
1390 CHECK(IsExceptionPending());
Elliott Hughes30646832011-10-13 16:59:46 -07001391 }
Elliott Hughesa5b897e2011-08-16 11:33:06 -07001392}
1393
Elliott Hughes418dfe72011-10-06 18:56:27 -07001394void Thread::ThrowOutOfMemoryError(Class* c, size_t byte_count) {
Elliott Hughes2ced6a52011-10-16 18:44:48 -07001395 std::string msg(StringPrintf("Failed to allocate a %zd-byte %s", byte_count,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001396 PrettyDescriptor(c).c_str()));
Elliott Hughes2ced6a52011-10-16 18:44:48 -07001397 ThrowOutOfMemoryError(msg.c_str());
1398}
1399
1400void Thread::ThrowOutOfMemoryError(const char* msg) {
1401 LOG(ERROR) << StringPrintf("Throwing OutOfMemoryError \"%s\"%s",
1402 msg, (throwing_OutOfMemoryError_ ? " (recursive case)" : ""));
Elliott Hughes726079d2011-10-07 18:43:44 -07001403 if (!throwing_OutOfMemoryError_) {
1404 throwing_OutOfMemoryError_ = true;
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001405 ThrowNewException("Ljava/lang/OutOfMemoryError;", NULL);
Elliott Hughes418dfe72011-10-06 18:56:27 -07001406 } else {
Elliott Hughes726079d2011-10-07 18:43:44 -07001407 SetException(pre_allocated_OutOfMemoryError_);
Elliott Hughes418dfe72011-10-06 18:56:27 -07001408 }
Elliott Hughes726079d2011-10-07 18:43:44 -07001409 throwing_OutOfMemoryError_ = false;
Elliott Hughes79082e32011-08-25 12:07:32 -07001410}
1411
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001412
Elliott Hughes498508c2011-10-17 14:58:22 -07001413Thread* Thread::CurrentFromGdb() {
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001414 return Thread::Current();
1415}
1416
1417void Thread::DumpFromGdb() const {
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001418 std::ostringstream ss;
1419 Dump(ss);
Elliott Hughes95572412011-12-13 18:14:20 -08001420 std::string str(ss.str());
Brian Carlstrom6b4ef022011-10-23 14:59:04 -07001421 // log to stderr for debugging command line processes
1422 std::cerr << str;
1423#ifdef HAVE_ANDROID_OS
1424 // log to logcat for debugging frameworks processes
1425 LOG(INFO) << str;
1426#endif
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001427}
1428
Ian Rogersbdb03912011-09-14 00:55:44 -07001429class CatchBlockStackVisitor : public Thread::StackVisitor {
1430 public:
1431 CatchBlockStackVisitor(Class* to_find, Context* ljc)
Ian Rogers67375ac2011-09-14 00:55:44 -07001432 : found_(false), to_find_(to_find), long_jump_context_(ljc), native_method_count_(0) {
1433#ifndef NDEBUG
1434 handler_pc_ = 0xEBADC0DE;
1435 handler_frame_.SetSP(reinterpret_cast<Method**>(0xEBADF00D));
1436#endif
1437 }
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001438
Ian Rogersbdb03912011-09-14 00:55:44 -07001439 virtual void VisitFrame(const Frame& fr, uintptr_t pc) {
1440 if (!found_) {
Ian Rogersbdb03912011-09-14 00:55:44 -07001441 Method* method = fr.GetMethod();
Ian Rogers67375ac2011-09-14 00:55:44 -07001442 if (method == NULL) {
1443 // This is the upcall, we remember the frame and last_pc so that we may
1444 // long jump to them
Elliott Hughesa43cb5e2011-10-07 11:37:59 -07001445 handler_pc_ = DemanglePc(pc);
Ian Rogers67375ac2011-09-14 00:55:44 -07001446 handler_frame_ = fr;
1447 return;
Ian Rogersbdb03912011-09-14 00:55:44 -07001448 }
Ian Rogers67375ac2011-09-14 00:55:44 -07001449 uint32_t dex_pc = DexFile::kDexNoIndex;
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001450 if (method->IsCalleeSaveMethod()) {
Ian Rogers90865722011-09-19 11:11:44 -07001451 // ignore callee save method
1452 } else if (method->IsNative()) {
1453 native_method_count_++;
1454 } else {
jeffhaoe343b762011-12-05 16:36:44 -08001455 // Unwind stack during method tracing
jeffhao2692b572011-12-16 15:42:28 -08001456 if (Runtime::Current()->IsMethodTracingActive()) {
jeffhaoe343b762011-12-05 16:36:44 -08001457#if defined(__arm__)
1458 uintptr_t trace_exit = reinterpret_cast<uintptr_t>(art_trace_exit_from_code);
1459 if (ManglePc(trace_exit) == pc) {
1460 pc = ManglePc(artTraceMethodUnwindFromCode(Thread::Current()));
1461 }
1462#else
1463 UNIMPLEMENTED(WARNING);
1464#endif
1465 }
Ian Rogers90865722011-09-19 11:11:44 -07001466 dex_pc = method->ToDexPC(pc);
Ian Rogers67375ac2011-09-14 00:55:44 -07001467 }
Ian Rogersbdb03912011-09-14 00:55:44 -07001468 if (dex_pc != DexFile::kDexNoIndex) {
1469 uint32_t found_dex_pc = method->FindCatchBlock(to_find_, dex_pc);
1470 if (found_dex_pc != DexFile::kDexNoIndex) {
1471 found_ = true;
Ian Rogers67375ac2011-09-14 00:55:44 -07001472 handler_pc_ = method->ToNativePC(found_dex_pc);
1473 handler_frame_ = fr;
Ian Rogersbdb03912011-09-14 00:55:44 -07001474 }
1475 }
1476 if (!found_) {
1477 // Caller may be handler, fill in callee saves in context
1478 long_jump_context_->FillCalleeSaves(fr);
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001479 }
1480 }
1481 }
Ian Rogersbdb03912011-09-14 00:55:44 -07001482
1483 // Did we find a catch block yet?
1484 bool found_;
1485 // The type of the exception catch block to find
1486 Class* to_find_;
1487 // Frame with found handler or last frame if no handler found
1488 Frame handler_frame_;
Ian Rogers67375ac2011-09-14 00:55:44 -07001489 // PC to branch to for the handler
1490 uintptr_t handler_pc_;
Ian Rogersbdb03912011-09-14 00:55:44 -07001491 // Context that will be the target of the long jump
1492 Context* long_jump_context_;
Ian Rogers67375ac2011-09-14 00:55:44 -07001493 // Number of native methods passed in crawl (equates to number of SIRTs to pop)
1494 uint32_t native_method_count_;
Ian Rogersbdb03912011-09-14 00:55:44 -07001495};
1496
Ian Rogersff1ed472011-09-20 13:46:24 -07001497void Thread::DeliverException() {
Ian Rogers28ad40d2011-10-27 15:19:26 -07001498 const bool kDebugExceptionDelivery = false;
Elliott Hughesd07986f2011-12-06 18:27:45 -08001499 Throwable* exception = GetException(); // Get exception from thread
Ian Rogersff1ed472011-09-20 13:46:24 -07001500 CHECK(exception != NULL);
Ian Rogers28ad40d2011-10-27 15:19:26 -07001501 // Don't leave exception visible while we try to find the handler, which may cause class
Elliott Hughesd07986f2011-12-06 18:27:45 -08001502 // resolution.
Ian Rogers28ad40d2011-10-27 15:19:26 -07001503 ClearException();
1504 if (kDebugExceptionDelivery) {
Ian Rogersa32a6fd2012-02-06 20:18:44 -08001505 String* msg = exception->GetDetailMessage();
1506 std::string str_msg(msg != NULL ? msg->ToModifiedUtf8() : "");
1507 DumpStack(LOG(INFO) << "Delivering exception: " << PrettyTypeOf(exception)
1508 << ": " << str_msg << std::endl);
Ian Rogers28ad40d2011-10-27 15:19:26 -07001509 }
Ian Rogersbdb03912011-09-14 00:55:44 -07001510
1511 Context* long_jump_context = GetLongJumpContext();
1512 CatchBlockStackVisitor catch_finder(exception->GetClass(), long_jump_context);
Ian Rogers67375ac2011-09-14 00:55:44 -07001513 WalkStackUntilUpCall(&catch_finder, true);
Ian Rogersbdb03912011-09-14 00:55:44 -07001514
Elliott Hughesd07986f2011-12-06 18:27:45 -08001515 Method** sp;
1516 uintptr_t throw_native_pc;
1517 Method* throw_method = GetCurrentMethod(&throw_native_pc, &sp);
1518 uintptr_t catch_native_pc = catch_finder.handler_pc_;
1519 Method* catch_method = catch_finder.handler_frame_.GetMethod();
1520 Dbg::PostException(sp, throw_method, throw_native_pc, catch_method, catch_native_pc, exception);
1521
Ian Rogers28ad40d2011-10-27 15:19:26 -07001522 if (kDebugExceptionDelivery) {
Elliott Hughesd07986f2011-12-06 18:27:45 -08001523 if (catch_method == NULL) {
Ian Rogers28ad40d2011-10-27 15:19:26 -07001524 LOG(INFO) << "Handler is upcall";
1525 } else {
1526 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1527 const DexFile& dex_file =
Elliott Hughesd07986f2011-12-06 18:27:45 -08001528 class_linker->FindDexFile(catch_method->GetDeclaringClass()->GetDexCache());
1529 int line_number = dex_file.GetLineNumFromPC(catch_method,
1530 catch_method->ToDexPC(catch_finder.handler_pc_));
1531 LOG(INFO) << "Handler: " << PrettyMethod(catch_method) << " (line: " << line_number << ")";
Ian Rogers28ad40d2011-10-27 15:19:26 -07001532 }
1533 }
1534 SetException(exception);
Elliott Hughesd07986f2011-12-06 18:27:45 -08001535 long_jump_context->SetSP(reinterpret_cast<uintptr_t>(catch_finder.handler_frame_.GetSP()));
Ian Rogers67375ac2011-09-14 00:55:44 -07001536 long_jump_context->SetPC(catch_finder.handler_pc_);
Ian Rogersbdb03912011-09-14 00:55:44 -07001537 long_jump_context->DoLongJump();
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001538}
1539
Ian Rogersbdb03912011-09-14 00:55:44 -07001540Context* Thread::GetLongJumpContext() {
Elliott Hughes85d15452011-09-16 17:33:01 -07001541 Context* result = long_jump_context_;
Ian Rogersbdb03912011-09-14 00:55:44 -07001542 if (result == NULL) {
1543 result = Context::Create();
Elliott Hughes85d15452011-09-16 17:33:01 -07001544 long_jump_context_ = result;
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001545 }
Ian Rogersbdb03912011-09-14 00:55:44 -07001546 return result;
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -07001547}
1548
Elliott Hughesd07986f2011-12-06 18:27:45 -08001549Method* Thread::GetCurrentMethod(uintptr_t* pc, Method*** sp) const {
1550 Frame f = top_of_managed_stack_;
1551 Method* m = f.GetMethod();
Elliott Hughes8be2d402012-02-23 14:22:41 -08001552 uintptr_t native_pc = top_of_managed_stack_pc_;
1553
Elliott Hughes9fd66f52011-10-16 12:13:26 -07001554 // We use JNI internally for exception throwing, so it's possible to arrive
1555 // here via a "FromCode" function, in which case there's a synthetic
1556 // callee-save method at the top of the stack. These shouldn't be user-visible,
1557 // so if we find one, skip it and return the compiled method underneath.
jeffhao33dc7712011-11-09 17:54:24 -08001558 if (m != NULL && m->IsCalleeSaveMethod()) {
Elliott Hughes8be2d402012-02-23 14:22:41 -08001559 native_pc = f.GetReturnPC();
Elliott Hughes9fd66f52011-10-16 12:13:26 -07001560 f.Next();
1561 m = f.GetMethod();
1562 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08001563 if (pc != NULL) {
Elliott Hughes8be2d402012-02-23 14:22:41 -08001564 *pc = (m != NULL) ? ManglePc(native_pc) : 0;
jeffhao33dc7712011-11-09 17:54:24 -08001565 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08001566 if (sp != NULL) {
1567 *sp = f.GetSP();
1568 }
1569 return m;
jeffhao33dc7712011-11-09 17:54:24 -08001570}
1571
Elliott Hughes5f791332011-09-15 17:45:30 -07001572bool Thread::HoldsLock(Object* object) {
1573 if (object == NULL) {
1574 return false;
1575 }
Brian Carlstrom24a3c2e2011-10-17 18:07:52 -07001576 return object->GetThinLockId() == thin_lock_id_;
Elliott Hughes5f791332011-09-15 17:45:30 -07001577}
1578
Elliott Hughes038a8062011-09-18 14:12:41 -07001579bool Thread::IsDaemon() {
1580 return gThread_daemon->GetBoolean(peer_);
1581}
1582
Ian Rogersd6b1f612011-09-27 13:38:14 -07001583class ReferenceMapVisitor : public Thread::StackVisitor {
1584 public:
1585 ReferenceMapVisitor(Context* context, Heap::RootVisitor* root_visitor, void* arg) :
1586 context_(context), root_visitor_(root_visitor), arg_(arg) {
1587 }
1588
1589 void VisitFrame(const Frame& frame, uintptr_t pc) {
1590 Method* m = frame.GetMethod();
Brian Carlstrom6a4be3a2011-10-20 16:34:03 -07001591 if (false) {
1592 LOG(INFO) << "Visiting stack roots in " << PrettyMethod(m, false)
Brian Carlstrom0dd7dda2011-10-25 15:47:53 -07001593 << StringPrintf("@ PC:%04x", m->ToDexPC(pc));
Brian Carlstrom6a4be3a2011-10-20 16:34:03 -07001594 }
Ian Rogersd6b1f612011-09-27 13:38:14 -07001595 // Process register map (which native and callee save methods don't have)
Ian Rogers3891c772011-12-06 15:38:28 -08001596 if (!m->IsNative() && !m->IsCalleeSaveMethod() && !m->IsProxyMethod()) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08001597 CHECK(m->GetGcMap() != NULL) << PrettyMethod(m);
1598 CHECK_NE(0U, m->GetGcMapLength()) << PrettyMethod(m);
1599 verifier::PcToReferenceMap map(m->GetGcMap(), m->GetGcMapLength());
Ian Rogersd81871c2011-10-03 13:57:23 -07001600 const uint8_t* reg_bitmap = map.FindBitMap(m->ToDexPC(pc));
Ian Rogersd6b1f612011-09-27 13:38:14 -07001601 CHECK(reg_bitmap != NULL);
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001602 const VmapTable vmap_table(m->GetVmapTableRaw());
Elliott Hughes11d1b0c2012-01-23 16:57:47 -08001603 const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001604 DCHECK(code_item != NULL); // can't be NULL or how would we compile its instructions?
1605 uint32_t core_spills = m->GetCoreSpillMask();
1606 uint32_t fp_spills = m->GetFpSpillMask();
1607 size_t frame_size = m->GetFrameSizeInBytes();
Brian Carlstrom0dd7dda2011-10-25 15:47:53 -07001608 // For all dex registers in the bitmap
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001609 size_t num_regs = std::min(map.RegWidth() * 8,
1610 static_cast<size_t>(code_item->registers_size_));
Brian Carlstrom0dd7dda2011-10-25 15:47:53 -07001611 for (size_t reg = 0; reg < num_regs; ++reg) {
Ian Rogersd6b1f612011-09-27 13:38:14 -07001612 // Does this register hold a reference?
1613 if (TestBitmap(reg, reg_bitmap)) {
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001614 uint32_t vmap_offset;
Ian Rogersd6b1f612011-09-27 13:38:14 -07001615 Object* ref;
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001616 if (vmap_table.IsInContext(reg, vmap_offset)) {
Ian Rogersd6b1f612011-09-27 13:38:14 -07001617 // Compute the register we need to load from the context
1618 uint32_t spill_mask = m->GetCoreSpillMask();
Brian Carlstrom0dd7dda2011-10-25 15:47:53 -07001619 CHECK_LT(vmap_offset, static_cast<uint32_t>(__builtin_popcount(spill_mask)));
Ian Rogersf57c47c2011-10-06 00:06:17 -07001620 uint32_t matches = 0;
1621 uint32_t spill_shifts = 0;
1622 while (matches != (vmap_offset + 1)) {
Brian Carlstrom0dd7dda2011-10-25 15:47:53 -07001623 DCHECK_NE(spill_mask, 0u);
Ian Rogersf57c47c2011-10-06 00:06:17 -07001624 matches += spill_mask & 1; // Add 1 if the low bit is set
1625 spill_mask >>= 1;
1626 spill_shifts++;
Ian Rogersd6b1f612011-09-27 13:38:14 -07001627 }
Ian Rogersf57c47c2011-10-06 00:06:17 -07001628 spill_shifts--; // wind back one as we want the last match
1629 ref = reinterpret_cast<Object*>(context_->GetGPR(spill_shifts));
Ian Rogersd6b1f612011-09-27 13:38:14 -07001630 } else {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001631 ref = reinterpret_cast<Object*>(frame.GetVReg(code_item, core_spills, fp_spills,
1632 frame_size, reg));
Ian Rogersd6b1f612011-09-27 13:38:14 -07001633 }
Shih-wei Liao4f894e32011-09-27 21:33:19 -07001634 if (ref != NULL) {
1635 root_visitor_(ref, arg_);
1636 }
Ian Rogersd6b1f612011-09-27 13:38:14 -07001637 }
1638 }
1639 }
1640 context_->FillCalleeSaves(frame);
1641 }
1642
1643 private:
1644 bool TestBitmap(int reg, const uint8_t* reg_vector) {
1645 return ((reg_vector[reg / 8] >> (reg % 8)) & 0x01) != 0;
1646 }
1647
1648 // Context used to build up picture of callee saves
1649 Context* context_;
1650 // Call-back when we visit a root
1651 Heap::RootVisitor* root_visitor_;
1652 // Argument to call-back
1653 void* arg_;
1654};
1655
1656void Thread::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
Elliott Hughesd369bb72011-09-12 14:41:14 -07001657 if (exception_ != NULL) {
1658 visitor(exception_, arg);
1659 }
1660 if (peer_ != NULL) {
1661 visitor(peer_, arg);
1662 }
Elliott Hughes726079d2011-10-07 18:43:44 -07001663 if (pre_allocated_OutOfMemoryError_ != NULL) {
1664 visitor(pre_allocated_OutOfMemoryError_, arg);
1665 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -07001666 if (class_loader_override_ != NULL) {
1667 visitor(class_loader_override_, arg);
1668 }
Elliott Hughes410c0c82011-09-01 17:58:25 -07001669 jni_env_->locals.VisitRoots(visitor, arg);
1670 jni_env_->monitors.VisitRoots(visitor, arg);
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -07001671
1672 SirtVisitRoots(visitor, arg);
1673
Ian Rogersd6b1f612011-09-27 13:38:14 -07001674 // Cheat and steal the long jump context. Assume that we are not doing a GC during exception
1675 // delivery.
1676 Context* context = GetLongJumpContext();
1677 // Visit roots on this thread's stack
1678 ReferenceMapVisitor mapper(context, visitor, arg);
1679 WalkStack(&mapper);
Elliott Hughes410c0c82011-09-01 17:58:25 -07001680}
1681
Ian Rogersb033c752011-07-20 12:22:35 -07001682static const char* kStateNames[] = {
Elliott Hughes93e74e82011-09-13 11:07:03 -07001683 "Terminated",
Ian Rogersb033c752011-07-20 12:22:35 -07001684 "Runnable",
Elliott Hughes93e74e82011-09-13 11:07:03 -07001685 "TimedWaiting",
Ian Rogersb033c752011-07-20 12:22:35 -07001686 "Blocked",
1687 "Waiting",
Elliott Hughes93e74e82011-09-13 11:07:03 -07001688 "Initializing",
1689 "Starting",
Ian Rogersb033c752011-07-20 12:22:35 -07001690 "Native",
Elliott Hughes93e74e82011-09-13 11:07:03 -07001691 "VmWait",
1692 "Suspended",
Ian Rogersb033c752011-07-20 12:22:35 -07001693};
1694std::ostream& operator<<(std::ostream& os, const Thread::State& state) {
Elliott Hughes8e4aac52011-09-26 17:03:36 -07001695 int32_t int_state = static_cast<int32_t>(state);
Elliott Hughes93e74e82011-09-13 11:07:03 -07001696 if (state >= Thread::kTerminated && state <= Thread::kSuspended) {
1697 os << kStateNames[int_state];
Ian Rogersb033c752011-07-20 12:22:35 -07001698 } else {
Elliott Hughes93e74e82011-09-13 11:07:03 -07001699 os << "State[" << int_state << "]";
Ian Rogersb033c752011-07-20 12:22:35 -07001700 }
1701 return os;
1702}
1703
Elliott Hughes330304d2011-08-12 14:28:05 -07001704std::ostream& operator<<(std::ostream& os, const Thread& thread) {
Elliott Hughes899e7892012-01-24 14:57:32 -08001705 thread.Dump(os, false);
Elliott Hughes330304d2011-08-12 14:28:05 -07001706 return os;
1707}
1708
Elliott Hughesa4060e52012-03-02 16:51:35 -08001709void Thread::CheckSafeToLockOrUnlock(MutexRank rank, bool is_locking) {
Elliott Hughesffb465f2012-03-01 18:46:05 -08001710 if (is_locking) {
1711 if (held_mutexes_[rank] == 0) {
1712 bool bad_mutexes_held = false;
1713 for (int i = kMaxMutexRank; i > rank; --i) {
1714 if (held_mutexes_[i] != 0) {
1715 LOG(ERROR) << "holding " << static_cast<MutexRank>(i) << " while " << (is_locking ? "locking" : "unlocking") << " " << rank;
1716 bad_mutexes_held = true;
1717 }
1718 }
1719 CHECK(!bad_mutexes_held);
1720 }
1721 ++held_mutexes_[rank];
1722 } else {
1723 CHECK_GT(held_mutexes_[rank], 0U);
1724 --held_mutexes_[rank];
1725 }
1726}
1727
Elliott Hughesa4060e52012-03-02 16:51:35 -08001728void Thread::CheckSafeToWait(MutexRank rank) {
1729 bool bad_mutexes_held = false;
1730 for (int i = kMaxMutexRank; i >= 0; --i) {
1731 if (i != rank && held_mutexes_[i] != 0) {
1732 LOG(ERROR) << "holding " << static_cast<MutexRank>(i) << " while doing condition variable wait on " << rank;
1733 bad_mutexes_held = true;
1734 }
1735 }
1736 if (held_mutexes_[rank] == 0) {
1737 LOG(ERROR) << "*not* holding " << rank << " while doing condition variable wait on it";
1738 bad_mutexes_held = true;
1739 }
1740 CHECK(!bad_mutexes_held);
1741}
1742
Elliott Hughes8daa0922011-09-11 13:46:25 -07001743} // namespace art