blob: dca983fb00bd6daec4f8d17870600edaaf2b636d [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 Shapiro0e5d75d2011-07-06 18:28:37 -070016
17#ifndef ART_SRC_THREAD_H_
18#define ART_SRC_THREAD_H_
19
Carl Shapirob5573532011-07-12 18:22:59 -070020#include <pthread.h>
Elliott Hughesa0957642011-09-02 14:27:33 -070021
Elliott Hughes02b48d12011-09-07 17:15:51 -070022#include <bitset>
Elliott Hughesa0957642011-09-02 14:27:33 -070023#include <iosfwd>
Ian Rogersb033c752011-07-20 12:22:35 -070024#include <list>
Elliott Hughes8daa0922011-09-11 13:46:25 -070025#include <string>
Carl Shapirob5573532011-07-12 18:22:59 -070026
Brian Carlstrom1f870082011-08-23 16:02:11 -070027#include "dex_file.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070028#include "globals.h"
Elliott Hughes69f5bc62011-08-24 09:26:14 -070029#include "jni_internal.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070030#include "logging.h"
31#include "macros.h"
Elliott Hughes8daa0922011-09-11 13:46:25 -070032#include "mutex.h"
Brian Carlstromb765be02011-08-17 23:54:10 -070033#include "mem_map.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070034#include "offsets.h"
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070035#include "runtime_stats.h"
Elliott Hughes68e76522011-10-05 13:22:16 -070036#include "stack.h"
Ian Rogersbdb03912011-09-14 00:55:44 -070037#include "UniquePtr.h"
Ian Rogersb033c752011-07-20 12:22:35 -070038
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070039namespace art {
40
Elliott Hughes69f5bc62011-08-24 09:26:14 -070041class Array;
Elliott Hughes37f7a402011-08-22 18:56:01 -070042class Class;
Brian Carlstrom1f870082011-08-23 16:02:11 -070043class ClassLinker;
Elliott Hughesedcc09c2011-08-21 18:47:05 -070044class ClassLoader;
Ian Rogersbdb03912011-09-14 00:55:44 -070045class Context;
Elliott Hughes475fc232011-10-25 15:00:35 -070046class DebugInvokeReq;
Brian Carlstroma40f9bc2011-07-26 21:26:07 -070047class Method;
Elliott Hughes8daa0922011-09-11 13:46:25 -070048class Monitor;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070049class Object;
Carl Shapirob5573532011-07-12 18:22:59 -070050class Runtime;
Elliott Hughes68e76522011-10-05 13:22:16 -070051class StackIndirectReferenceTable;
Shih-wei Liao55df06b2011-08-26 14:39:27 -070052class StackTraceElement;
buzbee1da522d2011-09-04 11:22:20 -070053class StaticStorageBase;
Brian Carlstrom40381fb2011-10-19 14:13:40 -070054class Thread;
55class ThreadList;
56class Throwable;
buzbee1da522d2011-09-04 11:22:20 -070057
Shih-wei Liao55df06b2011-08-26 14:39:27 -070058template<class T> class ObjectArray;
Shih-wei Liao44175362011-08-28 16:59:17 -070059template<class T> class PrimitiveArray;
60typedef PrimitiveArray<int32_t> IntArray;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070061
Elliott Hughes85d15452011-09-16 17:33:01 -070062class PACKED Thread {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070063 public:
Elliott Hughes8daa0922011-09-11 13:46:25 -070064 /* thread priorities, from java.lang.Thread */
65 enum Priority {
66 kMinPriority = 1,
67 kNormPriority = 5,
68 kMaxPriority = 10,
69 };
Carl Shapirob5573532011-07-12 18:22:59 -070070 enum State {
Elliott Hughes93e74e82011-09-13 11:07:03 -070071 // These match up with JDWP values.
72 kTerminated = 0, // TERMINATED
73 kRunnable = 1, // RUNNABLE or running now
74 kTimedWaiting = 2, // TIMED_WAITING in Object.wait()
75 kBlocked = 3, // BLOCKED on a monitor
76 kWaiting = 4, // WAITING in Object.wait()
77 // Non-JDWP states.
78 kInitializing = 5, // allocated, not yet running --- TODO: unnecessary?
79 kStarting = 6, // native thread started, not yet ready to run managed code
80 kNative = 7, // off in a JNI native method
81 kVmWait = 8, // waiting on a VM resource
82 kSuspended = 9, // suspended, usually by GC or debugger
Carl Shapirob5573532011-07-12 18:22:59 -070083 };
84
Ian Rogers932746a2011-09-22 18:57:50 -070085 // Space to throw a StackOverflowError in.
Brian Carlstromaded5f72011-10-07 17:15:04 -070086 static const size_t kStackOverflowReservedBytes = 4 * KB;
buzbeec143c552011-08-20 17:38:58 -070087
Brian Carlstrom72db0d72011-11-10 17:58:56 -080088 static const size_t kDefaultStackSize = 96 * KB;
Carl Shapiro61e019d2011-07-14 16:53:09 -070089
buzbeec143c552011-08-20 17:38:58 -070090 // Runtime support function pointers
buzbee4a3164f2011-09-03 11:25:10 -070091 void (*pDebugMe)(Method*, uint32_t);
buzbeec143c552011-08-20 17:38:58 -070092 void* (*pMemcpy)(void*, const void*, size_t);
buzbee54330722011-08-23 16:46:55 -070093 uint64_t (*pShlLong)(uint64_t, uint32_t);
94 uint64_t (*pShrLong)(uint64_t, uint32_t);
95 uint64_t (*pUshrLong)(uint64_t, uint32_t);
buzbeec143c552011-08-20 17:38:58 -070096 float (*pI2f)(int);
97 int (*pF2iz)(float);
98 float (*pD2f)(double);
99 double (*pF2d)(float);
100 double (*pI2d)(int);
101 int (*pD2iz)(double);
102 float (*pL2f)(long);
103 double (*pL2d)(long);
buzbee1b4c8592011-08-31 10:43:51 -0700104 long long (*pF2l)(float);
105 long long (*pD2l)(double);
buzbeec143c552011-08-20 17:38:58 -0700106 float (*pFadd)(float, float);
107 float (*pFsub)(float, float);
108 float (*pFdiv)(float, float);
109 float (*pFmul)(float, float);
110 float (*pFmodf)(float, float);
111 double (*pDadd)(double, double);
112 double (*pDsub)(double, double);
113 double (*pDdiv)(double, double);
114 double (*pDmul)(double, double);
115 double (*pFmod)(double, double);
116 int (*pIdivmod)(int, int);
117 int (*pIdiv)(int, int);
buzbee439c4fa2011-08-27 15:59:07 -0700118 long long (*pLmul)(long long, long long);
buzbeec143c552011-08-20 17:38:58 -0700119 long long (*pLdivmod)(long long, long long);
Ian Rogers4a510d82011-10-09 14:30:24 -0700120 void (*pCheckSuspendFromCode)(Thread*); // Stub that is called when the suspend count is non-zero
121 void (*pTestSuspendFromCode)(); // Stub that is periodically called to test the suspend count
Ian Rogers21d9e832011-09-23 17:05:09 -0700122 void* (*pAllocObjectFromCode)(uint32_t, void*);
Ian Rogers28ad40d2011-10-27 15:19:26 -0700123 void* (*pAllocObjectFromCodeWithAccessCheck)(uint32_t, void*);
Elliott Hughesb408de72011-10-04 14:35:05 -0700124 void* (*pAllocArrayFromCode)(uint32_t, void*, int32_t);
Ian Rogerse51a5112011-09-23 14:16:35 -0700125 void (*pCanPutArrayElementFromCode)(void*, void*);
Ian Rogersce9eca62011-10-07 17:11:03 -0700126 void* (*pCheckAndAllocArrayFromCode)(uint32_t, void*, int32_t);
Elliott Hughes362f9bc2011-10-17 18:56:41 -0700127 void (*pCheckCastFromCode)(void*, void*);
Ian Rogersce9eca62011-10-07 17:11:03 -0700128 Object* (*pDecodeJObjectInThread)(Thread* thread, jobject obj);
129 void (*pDeliverException)(void*);
130 void* (*pFindInstanceFieldFromCode)(uint32_t, void*);
131 Method* (*pFindInterfaceMethodInCache)(Class*, uint32_t, const Method*, struct DvmDex*);
132 void* (*pFindNativeMethod)(Thread* thread);
133 int32_t (*pGet32Static)(uint32_t, void*);
134 int64_t (*pGet64Static)(uint32_t, void*);
135 void* (*pGetObjStatic)(uint32_t, void*);
136 void (*pHandleFillArrayDataFromCode)(void*, void*);
137 void* (*pInitializeStaticStorage)(uint32_t, void*);
Elliott Hughes362f9bc2011-10-17 18:56:41 -0700138 uint32_t (*pInstanceofNonTrivialFromCode)(const Class*, const Class*);
Ian Rogersce9eca62011-10-07 17:11:03 -0700139 void (*pInvokeInterfaceTrampoline)(uint32_t, void*);
Ian Rogers28ad40d2011-10-27 15:19:26 -0700140 void* (*pInitializeTypeFromCode)(uint32_t, void*);
Ian Rogersb093c6b2011-10-31 16:19:55 -0700141 void* (*pInitializeTypeAndVerifyAccessFromCode)(uint32_t, void*);
Ian Rogersce9eca62011-10-07 17:11:03 -0700142 void (*pLockObjectFromCode)(void*);
Brian Carlstrom6fd03fb2011-10-17 16:11:00 -0700143 void (*pObjectInit)(void*);
Ian Rogersce9eca62011-10-07 17:11:03 -0700144 void (*pResolveMethodFromCode)(Method*, uint32_t);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700145 void* (*pResolveStringFromCode)(void*, uint32_t);
Ian Rogersce9eca62011-10-07 17:11:03 -0700146 int (*pSet32Static)(uint32_t, void*, int32_t);
147 int (*pSet64Static)(uint32_t, void*, int64_t);
148 int (*pSetObjStatic)(uint32_t, void*, void*);
Ian Rogers932746a2011-09-22 18:57:50 -0700149 void (*pThrowStackOverflowFromCode)(void*);
buzbee5ade1d22011-09-09 14:44:52 -0700150 void (*pThrowNullPointerFromCode)();
151 void (*pThrowArrayBoundsFromCode)(int32_t, int32_t);
152 void (*pThrowDivZeroFromCode)();
153 void (*pThrowVerificationErrorFromCode)(int32_t, int32_t);
154 void (*pThrowNegArraySizeFromCode)(int32_t);
buzbee5ade1d22011-09-09 14:44:52 -0700155 void (*pThrowNoSuchMethodFromCode)(int32_t);
Ian Rogersff1ed472011-09-20 13:46:24 -0700156 void (*pThrowAbstractMethodErrorFromCode)(Method* method, Thread* thread, Method** sp);
Ian Rogersce9eca62011-10-07 17:11:03 -0700157 void (*pUnlockObjectFromCode)(void*);
Brian Carlstrom6a4be3a2011-10-20 16:34:03 -0700158 void* (*pUnresolvedDirectMethodTrampolineFromCode)(int32_t, Method**, Thread*,
Ian Rogersce9eca62011-10-07 17:11:03 -0700159 Runtime::TrampolineType);
buzbeec143c552011-08-20 17:38:58 -0700160
Shih-wei Liao9b576b42011-08-29 01:45:07 -0700161 class StackVisitor {
162 public:
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700163 virtual ~StackVisitor() {}
Ian Rogersbdb03912011-09-14 00:55:44 -0700164 virtual void VisitFrame(const Frame& frame, uintptr_t pc) = 0;
Shih-wei Liao9b576b42011-08-29 01:45:07 -0700165 };
166
Carl Shapiro61e019d2011-07-14 16:53:09 -0700167 // Creates a new thread.
Elliott Hughesd369bb72011-09-12 14:41:14 -0700168 static void Create(Object* peer, size_t stack_size);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700169
170 // Creates a new thread from the calling thread.
Elliott Hughesdcc24742011-09-07 14:02:44 -0700171 static Thread* Attach(const Runtime* runtime, const char* name, bool as_daemon);
Carl Shapirob5573532011-07-12 18:22:59 -0700172
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700173 // Reset internal state of child thread after fork.
174 void InitAfterFork();
175
Carl Shapirob5573532011-07-12 18:22:59 -0700176 static Thread* Current() {
Carl Shapirod0e7e772011-07-15 14:31:01 -0700177 void* thread = pthread_getspecific(Thread::pthread_key_self_);
178 return reinterpret_cast<Thread*>(thread);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700179 }
180
Elliott Hughes761928d2011-11-16 18:33:03 -0800181 static Thread* FromManagedThread(Object* thread_peer);
Elliott Hughes01158d72011-09-19 19:47:10 -0700182 static Thread* FromManagedThread(JNIEnv* env, jobject thread);
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700183 static uint32_t LockOwnerFromThreadLock(Object* thread_lock);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700184
Elliott Hughese0918552011-10-28 17:18:29 -0700185 void Dump(std::ostream& os, bool dump_pending_exception = false) const;
Elliott Hughesa0957642011-09-02 14:27:33 -0700186
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700187 State GetState() const {
188 return state_;
189 }
190
Elliott Hughes8d768a92011-09-14 16:35:25 -0700191 State SetState(State new_state);
192
Elliott Hughes038a8062011-09-18 14:12:41 -0700193 bool IsDaemon();
Elliott Hughes761928d2011-11-16 18:33:03 -0800194 bool IsSuspended();
Elliott Hughes038a8062011-09-18 14:12:41 -0700195
Elliott Hughes8d768a92011-09-14 16:35:25 -0700196 void WaitUntilSuspended();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700197
Elliott Hughes5f791332011-09-15 17:45:30 -0700198 bool HoldsLock(Object*);
199
Elliott Hughes8daa0922011-09-11 13:46:25 -0700200 /*
201 * Changes the priority of this thread to match that of the java.lang.Thread object.
202 *
203 * We map a priority value from 1-10 to Linux "nice" values, where lower
204 * numbers indicate higher priority.
205 */
206 void SetNativePriority(int newPriority);
207
208 /*
209 * Returns the thread priority for the current thread by querying the system.
210 * This is useful when attaching a thread through JNI.
211 *
212 * Returns a value from 1 to 10 (compatible with java.lang.Thread values).
213 */
214 static int GetNativePriority();
215
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700216 bool CanAccessDirectReferences() const {
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700217#ifdef MOVING_GARBAGE_COLLECTOR
Elliott Hughesa59d1792011-09-04 18:42:35 -0700218 // TODO: when we have a moving collector, we'll need: return state_ == kRunnable;
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700219#endif
Elliott Hughesa59d1792011-09-04 18:42:35 -0700220 return true;
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700221 }
222
Elliott Hughesdcc24742011-09-07 14:02:44 -0700223 uint32_t GetThinLockId() const {
224 return thin_lock_id_;
Carl Shapirob5573532011-07-12 18:22:59 -0700225 }
226
Elliott Hughesd92bec42011-09-02 17:04:36 -0700227 pid_t GetTid() const {
228 return tid_;
229 }
Elliott Hughese27955c2011-08-26 15:21:24 -0700230
Elliott Hughesfc861622011-10-17 17:57:47 -0700231 // Returns the java.lang.Thread's name, or NULL.
232 String* GetName() const;
233
Elliott Hughesd369bb72011-09-12 14:41:14 -0700234 Object* GetPeer() const {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700235 return peer_;
236 }
237
Elliott Hughesa2155262011-11-16 16:26:58 -0800238 Object* GetThreadGroup() const;
239
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700240 RuntimeStats* GetStats() {
241 return &stats_;
242 }
243
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700244 // Returns the Method* for the current method.
245 // This is used by the JNI implementation for logging and diagnostic purposes.
Elliott Hughes9fd66f52011-10-16 12:13:26 -0700246 const Method* GetCurrentMethod() const;
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700247
jeffhao33dc7712011-11-09 17:54:24 -0800248 uint32_t GetCurrentReturnPc() const;
249
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700250 bool IsExceptionPending() const {
Elliott Hughesb20a5542011-08-12 18:03:12 -0700251 return exception_ != NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700252 }
253
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700254 Throwable* GetException() const {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700255 DCHECK(CanAccessDirectReferences());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700256 return exception_;
257 }
258
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700259 void SetException(Throwable* new_exception) {
260 DCHECK(CanAccessDirectReferences());
261 CHECK(new_exception != NULL);
262 // TODO: CHECK(exception_ == NULL);
263 exception_ = new_exception; // TODO
264 }
265
266 void ClearException() {
267 exception_ = NULL;
Elliott Hughesa0957642011-09-02 14:27:33 -0700268 }
269
Ian Rogersbdb03912011-09-14 00:55:44 -0700270 // Find catch block and perform long jump to appropriate exception handle
Ian Rogersff1ed472011-09-20 13:46:24 -0700271 void DeliverException();
Ian Rogersbdb03912011-09-14 00:55:44 -0700272
273 Context* GetLongJumpContext();
274
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -0700275 Frame GetTopOfStack() const {
276 return top_of_managed_stack_;
277 }
278
279 // TODO: this is here for testing, remove when we have exception unit tests
280 // that use the real stack
Ian Rogersbdb03912011-09-14 00:55:44 -0700281 void SetTopOfStack(void* stack, uintptr_t pc) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700282 top_of_managed_stack_.SetSP(reinterpret_cast<Method**>(stack));
Ian Rogersbdb03912011-09-14 00:55:44 -0700283 top_of_managed_stack_pc_ = pc;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700284 }
285
Ian Rogersbdb03912011-09-14 00:55:44 -0700286 void SetTopOfStackPC(uintptr_t pc) {
287 top_of_managed_stack_pc_ = pc;
288 }
289
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700290 // 'msg' may be NULL.
291 void ThrowNewException(const char* exception_class_descriptor, const char* msg);
292
293 void ThrowNewExceptionF(const char* exception_class_descriptor, const char* fmt, ...)
Elliott Hughes362f9bc2011-10-17 18:56:41 -0700294 __attribute__((format(printf, 3, 4)));
Elliott Hughesa5b897e2011-08-16 11:33:06 -0700295
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700296 void ThrowNewExceptionV(const char* exception_class_descriptor, const char* fmt, va_list ap);
297
Elliott Hughes2ced6a52011-10-16 18:44:48 -0700298 // OutOfMemoryError is special, because we need to pre-allocate an instance.
299 void ThrowOutOfMemoryError(const char* msg);
Elliott Hughes418dfe72011-10-06 18:56:27 -0700300 void ThrowOutOfMemoryError(Class* c, size_t byte_count);
Elliott Hughes79082e32011-08-25 12:07:32 -0700301
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -0700302 Frame FindExceptionHandler(void* throw_pc, void** handler_pc);
303
304 void* FindExceptionHandlerInMethod(const Method* method,
305 void* throw_pc,
306 const DexFile& dex_file,
307 ClassLinker* class_linker);
buzbeec143c552011-08-20 17:38:58 -0700308
Carl Shapirob5573532011-07-12 18:22:59 -0700309 void SetName(const char* name);
310
Elliott Hughesbe759c62011-09-08 19:38:21 -0700311 static void Startup();
Elliott Hughes038a8062011-09-18 14:12:41 -0700312 static void FinishStartup();
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700313 static void Shutdown();
Carl Shapirob5573532011-07-12 18:22:59 -0700314
Ian Rogersb033c752011-07-20 12:22:35 -0700315 // JNI methods
Elliott Hughes69f5bc62011-08-24 09:26:14 -0700316 JNIEnvExt* GetJniEnv() const {
Ian Rogersb033c752011-07-20 12:22:35 -0700317 return jni_env_;
318 }
319
Ian Rogers408f79a2011-08-23 18:22:33 -0700320 // Number of references allocated in SIRTs on this thread
321 size_t NumSirtReferences();
Ian Rogersa8cd9f42011-08-19 16:43:41 -0700322
Ian Rogers408f79a2011-08-23 18:22:33 -0700323 // Is the given obj in this thread's stack indirect reference table?
324 bool SirtContains(jobject obj);
325
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -0700326 void SirtVisitRoots(Heap::RootVisitor* visitor, void* arg);
327
Ian Rogers408f79a2011-08-23 18:22:33 -0700328 // Convert a jobject into a Object*
329 Object* DecodeJObject(jobject obj);
Ian Rogersb033c752011-07-20 12:22:35 -0700330
Elliott Hughes8daa0922011-09-11 13:46:25 -0700331 // Implements java.lang.Thread.interrupted.
332 bool Interrupted() {
Elliott Hughes85d15452011-09-16 17:33:01 -0700333 MutexLock mu(*wait_mutex_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700334 bool interrupted = interrupted_;
335 interrupted_ = false;
336 return interrupted;
337 }
338
339 // Implements java.lang.Thread.isInterrupted.
340 bool IsInterrupted() {
Elliott Hughes85d15452011-09-16 17:33:01 -0700341 MutexLock mu(*wait_mutex_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700342 return interrupted_;
343 }
344
Elliott Hughes5f791332011-09-15 17:45:30 -0700345 void Interrupt() {
Elliott Hughes85d15452011-09-16 17:33:01 -0700346 MutexLock mu(*wait_mutex_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700347 if (interrupted_) {
348 return;
349 }
350 interrupted_ = true;
351 NotifyLocked();
352 }
353
354 void Notify() {
Elliott Hughes85d15452011-09-16 17:33:01 -0700355 MutexLock mu(*wait_mutex_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700356 NotifyLocked();
357 }
358
Ian Rogers6de08602011-08-19 14:52:39 -0700359 // Linked list recording transitions from native to managed code
Ian Rogersb04f69f2011-10-17 00:40:54 -0700360 void PushNativeToManagedRecord(NativeToManagedRecord* record);
361 void PopNativeToManagedRecord(const NativeToManagedRecord& record);
Ian Rogers6de08602011-08-19 14:52:39 -0700362
Brian Carlstrombffb1552011-08-25 12:23:53 -0700363 const ClassLoader* GetClassLoaderOverride() {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700364 // TODO: need to place the class_loader_override_ in a handle
365 // DCHECK(CanAccessDirectReferences());
buzbeec143c552011-08-20 17:38:58 -0700366 return class_loader_override_;
367 }
368
Brian Carlstrombffb1552011-08-25 12:23:53 -0700369 void SetClassLoaderOverride(const ClassLoader* class_loader_override) {
buzbeec143c552011-08-20 17:38:58 -0700370 class_loader_override_ = class_loader_override;
371 }
372
Ian Rogersaaa20802011-09-11 21:47:37 -0700373 // Create the internal representation of a stack trace, that is more time
374 // and space efficient to compute than the StackTraceElement[]
Elliott Hughes01158d72011-09-19 19:47:10 -0700375 jobject CreateInternalStackTrace(JNIEnv* env) const;
Ian Rogersaaa20802011-09-11 21:47:37 -0700376
Elliott Hughes01158d72011-09-19 19:47:10 -0700377 // Convert an internal stack trace representation (returned by CreateInternalStackTrace) to a
378 // StackTraceElement[]. If output_array is NULL, a new array is created, otherwise as many
379 // frames as will fit are written into the given array. If stack_depth is non-NULL, it's updated
380 // with the number of valid frames in the returned array.
381 static jobjectArray InternalStackTraceToStackTraceElementArray(JNIEnv* env, jobject internal,
382 jobjectArray output_array = NULL, int* stack_depth = NULL);
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700383
Ian Rogersd6b1f612011-09-27 13:38:14 -0700384 void VisitRoots(Heap::RootVisitor* visitor, void* arg);
Elliott Hughes410c0c82011-09-01 17:58:25 -0700385
Elliott Hughesbe759c62011-09-08 19:38:21 -0700386 //
387 // Offsets of various members of native Thread class, used by compiled code.
388 //
389
390 static ThreadOffset SelfOffset() {
391 return ThreadOffset(OFFSETOF_MEMBER(Thread, self_));
392 }
393
394 static ThreadOffset ExceptionOffset() {
395 return ThreadOffset(OFFSETOF_MEMBER(Thread, exception_));
396 }
397
Elliott Hughes54e7df12011-09-16 11:47:04 -0700398 static ThreadOffset ThinLockIdOffset() {
Elliott Hughesbe759c62011-09-08 19:38:21 -0700399 return ThreadOffset(OFFSETOF_MEMBER(Thread, thin_lock_id_));
400 }
401
402 static ThreadOffset CardTableOffset() {
403 return ThreadOffset(OFFSETOF_MEMBER(Thread, card_table_));
404 }
405
406 static ThreadOffset SuspendCountOffset() {
407 return ThreadOffset(OFFSETOF_MEMBER(Thread, suspend_count_));
408 }
409
410 static ThreadOffset StateOffset() {
Elliott Hughes93e74e82011-09-13 11:07:03 -0700411 return ThreadOffset(OFFSETOF_VOLATILE_MEMBER(Thread, state_));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700412 }
413
Ian Rogers932746a2011-09-22 18:57:50 -0700414 // Size of stack less any space reserved for stack overflow
415 size_t GetStackSize() {
416 return stack_size_ - (stack_end_ - stack_base_);
417 }
418
419 // Set the stack end to that to be used during a stack overflow
420 void SetStackEndForStackOverflow() {
421 // During stack overflow we allow use of the full stack
Elliott Hughes3b6baaa2011-10-14 19:13:56 -0700422 if (stack_end_ == stack_base_) {
423 DumpStack(std::cerr);
424 LOG(FATAL) << "Need to increase kStackOverflowReservedBytes (currently "
425 << kStackOverflowReservedBytes << ")";
426 }
427
Ian Rogers932746a2011-09-22 18:57:50 -0700428 stack_end_ = stack_base_;
429 }
430
431 // Set the stack end to that to be used during regular execution
432 void ResetDefaultStackEnd() {
433 // Our stacks grow down, so we want stack_end_ to be near there, but reserving enough room
434 // to throw a StackOverflowError.
435 stack_end_ = stack_base_ + kStackOverflowReservedBytes;
436 }
437
Elliott Hughes449b4bd2011-09-09 12:01:38 -0700438 static ThreadOffset StackEndOffset() {
439 return ThreadOffset(OFFSETOF_MEMBER(Thread, stack_end_));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700440 }
441
442 static ThreadOffset JniEnvOffset() {
443 return ThreadOffset(OFFSETOF_MEMBER(Thread, jni_env_));
444 }
445
446 static ThreadOffset TopOfManagedStackOffset() {
447 return ThreadOffset(OFFSETOF_MEMBER(Thread, top_of_managed_stack_) +
448 OFFSETOF_MEMBER(Frame, sp_));
449 }
450
Ian Rogersbdb03912011-09-14 00:55:44 -0700451 static ThreadOffset TopOfManagedStackPcOffset() {
452 return ThreadOffset(OFFSETOF_MEMBER(Thread, top_of_managed_stack_pc_));
453 }
454
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700455 void PushSirt(StackIndirectReferenceTable* sirt);
456 StackIndirectReferenceTable* PopSirt();
457
Elliott Hughesbe759c62011-09-08 19:38:21 -0700458 static ThreadOffset TopSirtOffset() {
459 return ThreadOffset(OFFSETOF_MEMBER(Thread, top_sirt_));
460 }
461
Shih-wei Liao9407c602011-09-16 10:36:43 -0700462 void WalkStack(StackVisitor* visitor) const;
463
Elliott Hughes475fc232011-10-25 15:00:35 -0700464 DebugInvokeReq* GetInvokeReq() {
465 return debug_invoke_req_;
466 }
467
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700468 private:
Elliott Hughesdcc24742011-09-07 14:02:44 -0700469 Thread();
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700470 ~Thread();
Elliott Hughes02b48d12011-09-07 17:15:51 -0700471 friend class ThreadList; // For ~Thread.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700472
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700473 void CreatePeer(const char* name, bool as_daemon);
474 friend class Runtime; // For CreatePeer.
475
Elliott Hughesd92bec42011-09-02 17:04:36 -0700476 void DumpState(std::ostream& os) const;
477 void DumpStack(std::ostream& os) const;
478
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700479 // Out-of-line conveniences for debugging in gdb.
Elliott Hughes498508c2011-10-17 14:58:22 -0700480 static Thread* CurrentFromGdb(); // Like Thread::Current.
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700481 void DumpFromGdb() const; // Like Thread::Dump(std::cerr).
482
Elliott Hughes93e74e82011-09-13 11:07:03 -0700483 void Attach(const Runtime* runtime);
484 static void* CreateCallback(void* arg);
485
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700486 void HandleUncaughtExceptions();
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700487 void RemoveFromThreadGroup();
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700488
Ian Rogers5d76c432011-10-31 21:42:49 -0700489 void InitCardTable();
Ian Rogersb033c752011-07-20 12:22:35 -0700490 void InitCpu();
buzbee3ea4ec52011-08-22 17:37:19 -0700491 void InitFunctionPointers();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700492 void InitTid();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700493 void InitPthreadKeySelf();
Elliott Hughesbe759c62011-09-08 19:38:21 -0700494 void InitStackHwm();
495
Elliott Hughes5f791332011-09-15 17:45:30 -0700496 void NotifyLocked() {
497 if (wait_monitor_ != NULL) {
Elliott Hughes85d15452011-09-16 17:33:01 -0700498 wait_cond_->Signal();
Elliott Hughes5f791332011-09-15 17:45:30 -0700499 }
500 }
501
Elliott Hughesbe759c62011-09-08 19:38:21 -0700502 static void ThreadExitCallback(void* arg);
Ian Rogersb033c752011-07-20 12:22:35 -0700503
Ian Rogers67375ac2011-09-14 00:55:44 -0700504 void WalkStackUntilUpCall(StackVisitor* visitor, bool include_upcall) const;
Ian Rogersbdb03912011-09-14 00:55:44 -0700505
Elliott Hughesdcc24742011-09-07 14:02:44 -0700506 // Thin lock thread id. This is a small integer used by the thin lock implementation.
507 // This is not to be confused with the native thread's tid, nor is it the value returned
508 // by java.lang.Thread.getId --- this is a distinct value, used only for locking. One
509 // important difference between this id and the ids visible to managed code is that these
510 // ones get reused (to ensure that they fit in the number of bits available).
511 uint32_t thin_lock_id_;
Ian Rogersb033c752011-07-20 12:22:35 -0700512
Elliott Hughesd92bec42011-09-02 17:04:36 -0700513 // System thread id.
514 pid_t tid_;
515
Elliott Hughesdcc24742011-09-07 14:02:44 -0700516 // Our managed peer (an instance of java.lang.Thread).
Elliott Hughesd369bb72011-09-12 14:41:14 -0700517 Object* peer_;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700518
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700519 // The top_of_managed_stack_ and top_of_managed_stack_pc_ fields are accessed from
520 // compiled code, so we keep them early in the structure to (a) avoid having to keep
521 // fixing the assembler offsets and (b) improve the chances that these will still be aligned.
522
523 // Top of the managed stack, written out prior to the state transition from
Elliott Hughes68e76522011-10-05 13:22:16 -0700524 // kRunnable to kNative. Uses include giving the starting point for scanning
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700525 // a managed stack when a thread is in native code.
526 Frame top_of_managed_stack_;
527 // PC corresponding to the call out of the top_of_managed_stack_ frame
528 uintptr_t top_of_managed_stack_pc_;
529
Elliott Hughes8daa0922011-09-11 13:46:25 -0700530 // Guards the 'interrupted_' and 'wait_monitor_' members.
Elliott Hughes85d15452011-09-16 17:33:01 -0700531 mutable Mutex* wait_mutex_;
532 ConditionVariable* wait_cond_;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700533 // Pointer to the monitor lock we're currently waiting on (or NULL), guarded by wait_mutex_.
534 Monitor* wait_monitor_;
535 // Thread "interrupted" status; stays raised until queried or thrown, guarded by wait_mutex_.
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700536 uint32_t interrupted_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700537 // The next thread in the wait set this thread is part of.
538 Thread* wait_next_;
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700539 // If we're blocked in MonitorEnter, this is the object we're trying to lock.
540 Object* monitor_enter_object_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700541
542 friend class Monitor;
Elliott Hughesdcc24742011-09-07 14:02:44 -0700543
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700544 RuntimeStats stats_;
545
Ian Rogers5d76c432011-10-31 21:42:49 -0700546 // The biased card table, see CardTable for details
547 byte* card_table_;
buzbeec143c552011-08-20 17:38:58 -0700548
Elliott Hughes449b4bd2011-09-09 12:01:38 -0700549 // The end of this thread's stack. This is the lowest safely-addressable address on the stack.
550 // We leave extra space so there's room for the code that throws StackOverflowError.
551 byte* stack_end_;
Elliott Hughesbe759c62011-09-08 19:38:21 -0700552
Ian Rogers932746a2011-09-22 18:57:50 -0700553 // Size of the stack
554 size_t stack_size_;
555
556 // The "lowest addressable byte" of the stack
557 byte* stack_base_;
558
Ian Rogers6de08602011-08-19 14:52:39 -0700559 // A linked list (of stack allocated records) recording transitions from
560 // native to managed code.
561 NativeToManagedRecord* native_to_managed_record_;
562
Ian Rogers408f79a2011-08-23 18:22:33 -0700563 // Top of linked list of stack indirect reference tables or NULL for none
564 StackIndirectReferenceTable* top_sirt_;
Ian Rogersb033c752011-07-20 12:22:35 -0700565
566 // Every thread may have an associated JNI environment
Elliott Hughes69f5bc62011-08-24 09:26:14 -0700567 JNIEnvExt* jni_env_;
Ian Rogersb033c752011-07-20 12:22:35 -0700568
Elliott Hughes93e74e82011-09-13 11:07:03 -0700569 volatile State state_;
Carl Shapirob5573532011-07-12 18:22:59 -0700570
Carl Shapiro69759ea2011-07-21 18:13:35 -0700571 // Initialized to "this". On certain architectures (such as x86) reading
572 // off of Thread::Current is easy but getting the address of Thread::Current
573 // is hard. This field can be read off of Thread::Current to give the address.
574 Thread* self_;
575
576 Runtime* runtime_;
577
578 // The pending exception or NULL.
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700579 Throwable* exception_;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700580
Ian Rogers45a76cb2011-07-21 22:00:15 -0700581 // A non-zero value is used to tell the current thread to enter a safe point
582 // at the next poll.
583 int suspend_count_;
Elliott Hughes234ab152011-10-26 14:02:26 -0700584 // How much of 'suspend_count_' is by request of the debugger, used to set things right
585 // when the debugger detaches. Must be <= suspend_count_.
586 int debug_suspend_count_;
Ian Rogers45a76cb2011-07-21 22:00:15 -0700587
Elliott Hughesedcc09c2011-08-21 18:47:05 -0700588 // Needed to get the right ClassLoader in JNI_OnLoad, but also
589 // useful for testing.
Brian Carlstrombffb1552011-08-25 12:23:53 -0700590 const ClassLoader* class_loader_override_;
buzbeec143c552011-08-20 17:38:58 -0700591
Ian Rogersbdb03912011-09-14 00:55:44 -0700592 // Thread local, lazily allocated, long jump context. Used to deliver exceptions.
Elliott Hughes85d15452011-09-16 17:33:01 -0700593 Context* long_jump_context_;
Ian Rogersbdb03912011-09-14 00:55:44 -0700594
Elliott Hughes418dfe72011-10-06 18:56:27 -0700595 // A boolean telling us whether we're recursively throwing OOME.
Elliott Hughes726079d2011-10-07 18:43:44 -0700596 uint32_t throwing_OutOfMemoryError_;
597
598 Throwable* pre_allocated_OutOfMemoryError_;
Elliott Hughes418dfe72011-10-06 18:56:27 -0700599
Elliott Hughes475fc232011-10-25 15:00:35 -0700600 // JDWP invoke-during-breakpoint support.
601 DebugInvokeReq* debug_invoke_req_;
602
Carl Shapiro69759ea2011-07-21 18:13:35 -0700603 // TLS key used to retrieve the VM thread object.
Carl Shapirob5573532011-07-12 18:22:59 -0700604 static pthread_key_t pthread_key_self_;
605
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700606 DISALLOW_COPY_AND_ASSIGN(Thread);
607};
Ian Rogersbdb03912011-09-14 00:55:44 -0700608
Elliott Hughes330304d2011-08-12 14:28:05 -0700609std::ostream& operator<<(std::ostream& os, const Thread& thread);
Ian Rogersb033c752011-07-20 12:22:35 -0700610std::ostream& operator<<(std::ostream& os, const Thread::State& state);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700611
Elliott Hughesad7c2a32011-08-31 11:58:10 -0700612class ScopedThreadStateChange {
613 public:
614 ScopedThreadStateChange(Thread* thread, Thread::State new_state) : thread_(thread) {
615 old_thread_state_ = thread_->SetState(new_state);
616 }
617
618 ~ScopedThreadStateChange() {
619 thread_->SetState(old_thread_state_);
620 }
621
622 private:
623 Thread* thread_;
624 Thread::State old_thread_state_;
625 DISALLOW_COPY_AND_ASSIGN(ScopedThreadStateChange);
626};
627
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700628} // namespace art
629
630#endif // ART_SRC_THREAD_H_