blob: 51385f9b22669250ce812a1fdacffa88d5b79618 [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>
jeffhaoe343b762011-12-05 16:36:44 -080026#include <vector>
Carl Shapirob5573532011-07-12 18:22:59 -070027
Brian Carlstrom1f870082011-08-23 16:02:11 -070028#include "dex_file.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070029#include "globals.h"
Elliott Hughes69f5bc62011-08-24 09:26:14 -070030#include "jni_internal.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070031#include "logging.h"
32#include "macros.h"
Elliott Hughes8daa0922011-09-11 13:46:25 -070033#include "mutex.h"
Brian Carlstromb765be02011-08-17 23:54:10 -070034#include "mem_map.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070035#include "offsets.h"
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070036#include "runtime_stats.h"
Elliott Hughes68e76522011-10-05 13:22:16 -070037#include "stack.h"
jeffhaoe343b762011-12-05 16:36:44 -080038#include "trace.h"
Ian Rogersbdb03912011-09-14 00:55:44 -070039#include "UniquePtr.h"
Ian Rogersb033c752011-07-20 12:22:35 -070040
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070041namespace art {
42
Elliott Hughes69f5bc62011-08-24 09:26:14 -070043class Array;
Elliott Hughes37f7a402011-08-22 18:56:01 -070044class Class;
Brian Carlstrom1f870082011-08-23 16:02:11 -070045class ClassLinker;
Elliott Hughesedcc09c2011-08-21 18:47:05 -070046class ClassLoader;
Ian Rogersbdb03912011-09-14 00:55:44 -070047class Context;
Elliott Hughes475fc232011-10-25 15:00:35 -070048class DebugInvokeReq;
Brian Carlstroma40f9bc2011-07-26 21:26:07 -070049class Method;
Elliott Hughes8daa0922011-09-11 13:46:25 -070050class Monitor;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070051class Object;
Carl Shapirob5573532011-07-12 18:22:59 -070052class Runtime;
Elliott Hughes68e76522011-10-05 13:22:16 -070053class StackIndirectReferenceTable;
Shih-wei Liao55df06b2011-08-26 14:39:27 -070054class StackTraceElement;
buzbee1da522d2011-09-04 11:22:20 -070055class StaticStorageBase;
Brian Carlstrom40381fb2011-10-19 14:13:40 -070056class Thread;
57class ThreadList;
58class Throwable;
buzbee1da522d2011-09-04 11:22:20 -070059
Shih-wei Liao55df06b2011-08-26 14:39:27 -070060template<class T> class ObjectArray;
Shih-wei Liao44175362011-08-28 16:59:17 -070061template<class T> class PrimitiveArray;
62typedef PrimitiveArray<int32_t> IntArray;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070063
Elliott Hughes85d15452011-09-16 17:33:01 -070064class PACKED Thread {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070065 public:
Elliott Hughes8daa0922011-09-11 13:46:25 -070066 /* thread priorities, from java.lang.Thread */
67 enum Priority {
68 kMinPriority = 1,
69 kNormPriority = 5,
70 kMaxPriority = 10,
71 };
Carl Shapirob5573532011-07-12 18:22:59 -070072 enum State {
Elliott Hughes499c5132011-11-17 14:55:11 -080073 // These correspond to JDWP states (but needn't share the same values).
74 kTerminated = 0, // TS_ZOMBIE
75 kRunnable = 1, // TS_RUNNING
Elliott Hughes3ce4b262012-02-24 11:24:02 -080076 kTimedWaiting = 2, // TS_WAIT in Object.wait() with a timeout
Elliott Hughes499c5132011-11-17 14:55:11 -080077 kBlocked = 3, // TS_MONITOR on a monitor
78 kWaiting = 4, // TS_WAIT in Object.wait()
Elliott Hughes93e74e82011-09-13 11:07:03 -070079 // Non-JDWP states.
80 kInitializing = 5, // allocated, not yet running --- TODO: unnecessary?
81 kStarting = 6, // native thread started, not yet ready to run managed code
82 kNative = 7, // off in a JNI native method
83 kVmWait = 8, // waiting on a VM resource
84 kSuspended = 9, // suspended, usually by GC or debugger
Carl Shapirob5573532011-07-12 18:22:59 -070085 };
86
Ian Rogers932746a2011-09-22 18:57:50 -070087 // Space to throw a StackOverflowError in.
Brian Carlstromaded5f72011-10-07 17:15:04 -070088 static const size_t kStackOverflowReservedBytes = 4 * KB;
buzbeec143c552011-08-20 17:38:58 -070089
Brian Carlstrom72db0d72011-11-10 17:58:56 -080090 static const size_t kDefaultStackSize = 96 * KB;
Carl Shapiro61e019d2011-07-14 16:53:09 -070091
Shih-wei Liao9b576b42011-08-29 01:45:07 -070092 class StackVisitor {
93 public:
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070094 virtual ~StackVisitor() {}
Elliott Hughes530fa002012-03-12 11:44:49 -070095 // Return 'true' if we should continue to visit more frames, 'false' to stop.
96 virtual bool VisitFrame(const Frame& frame, uintptr_t pc) = 0;
Shih-wei Liao9b576b42011-08-29 01:45:07 -070097 };
98
Carl Shapiro61e019d2011-07-14 16:53:09 -070099 // Creates a new thread.
Elliott Hughesd369bb72011-09-12 14:41:14 -0700100 static void Create(Object* peer, size_t stack_size);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700101
102 // Creates a new thread from the calling thread.
Elliott Hughesdcc24742011-09-07 14:02:44 -0700103 static Thread* Attach(const Runtime* runtime, const char* name, bool as_daemon);
Carl Shapirob5573532011-07-12 18:22:59 -0700104
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700105 // Reset internal state of child thread after fork.
106 void InitAfterFork();
107
Carl Shapirob5573532011-07-12 18:22:59 -0700108 static Thread* Current() {
Carl Shapirod0e7e772011-07-15 14:31:01 -0700109 void* thread = pthread_getspecific(Thread::pthread_key_self_);
110 return reinterpret_cast<Thread*>(thread);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700111 }
112
Elliott Hughes761928d2011-11-16 18:33:03 -0800113 static Thread* FromManagedThread(Object* thread_peer);
Elliott Hughes01158d72011-09-19 19:47:10 -0700114 static Thread* FromManagedThread(JNIEnv* env, jobject thread);
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700115 static uint32_t LockOwnerFromThreadLock(Object* thread_lock);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700116
Elliott Hughes899e7892012-01-24 14:57:32 -0800117 // When full == true, dumps the detailed thread state and the thread stack (used for SIGQUIT).
118 // When full == false, dumps a one-line summary of thread state (used for operator<<).
119 void Dump(std::ostream& os, bool full = true) const;
Elliott Hughesa0957642011-09-02 14:27:33 -0700120
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700121 State GetState() const {
122 return state_;
123 }
124
Elliott Hughes8d768a92011-09-14 16:35:25 -0700125 State SetState(State new_state);
Elliott Hughesa4060e52012-03-02 16:51:35 -0800126 void SetStateWithoutSuspendCheck(State new_state);
Elliott Hughes8d768a92011-09-14 16:35:25 -0700127
Elliott Hughes038a8062011-09-18 14:12:41 -0700128 bool IsDaemon();
Elliott Hughes761928d2011-11-16 18:33:03 -0800129 bool IsSuspended();
Elliott Hughes038a8062011-09-18 14:12:41 -0700130
Elliott Hughes8d768a92011-09-14 16:35:25 -0700131 void WaitUntilSuspended();
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700132
Elliott Hughes5f791332011-09-15 17:45:30 -0700133 bool HoldsLock(Object*);
134
Elliott Hughes8daa0922011-09-11 13:46:25 -0700135 /*
136 * Changes the priority of this thread to match that of the java.lang.Thread object.
137 *
138 * We map a priority value from 1-10 to Linux "nice" values, where lower
139 * numbers indicate higher priority.
140 */
141 void SetNativePriority(int newPriority);
142
143 /*
144 * Returns the thread priority for the current thread by querying the system.
145 * This is useful when attaching a thread through JNI.
146 *
147 * Returns a value from 1 to 10 (compatible with java.lang.Thread values).
148 */
149 static int GetNativePriority();
150
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700151 bool CanAccessDirectReferences() const {
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700152#ifdef MOVING_GARBAGE_COLLECTOR
Elliott Hughesa59d1792011-09-04 18:42:35 -0700153 // TODO: when we have a moving collector, we'll need: return state_ == kRunnable;
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700154#endif
Elliott Hughesa59d1792011-09-04 18:42:35 -0700155 return true;
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700156 }
157
Elliott Hughesdcc24742011-09-07 14:02:44 -0700158 uint32_t GetThinLockId() const {
159 return thin_lock_id_;
Carl Shapirob5573532011-07-12 18:22:59 -0700160 }
161
Elliott Hughesd92bec42011-09-02 17:04:36 -0700162 pid_t GetTid() const {
163 return tid_;
164 }
Elliott Hughese27955c2011-08-26 15:21:24 -0700165
Elliott Hughesffb465f2012-03-01 18:46:05 -0800166 // Returns the java.lang.Thread's name, or NULL if this Thread* doesn't have a peer.
Elliott Hughes899e7892012-01-24 14:57:32 -0800167 String* GetThreadName() const;
168
Elliott Hughesffb465f2012-03-01 18:46:05 -0800169 // Sets 'name' to the java.lang.Thread's name. This requires no transition to managed code,
170 // allocation, or locking.
171 void GetThreadName(std::string& name) const;
172
Elliott Hughes899e7892012-01-24 14:57:32 -0800173 // Sets the thread's name.
174 void SetThreadName(const char* name);
Elliott Hughesfc861622011-10-17 17:57:47 -0700175
Elliott Hughesd369bb72011-09-12 14:41:14 -0700176 Object* GetPeer() const {
Elliott Hughes8daa0922011-09-11 13:46:25 -0700177 return peer_;
178 }
179
Elliott Hughesa2155262011-11-16 16:26:58 -0800180 Object* GetThreadGroup() const;
181
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700182 RuntimeStats* GetStats() {
183 return &stats_;
184 }
185
Elliott Hughesd07986f2011-12-06 18:27:45 -0800186 int GetSuspendCount() const {
187 return suspend_count_;
188 }
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700189
Elliott Hughesd07986f2011-12-06 18:27:45 -0800190 // Returns the current Method* and native PC (not dex PC) for this thread.
191 Method* GetCurrentMethod(uintptr_t* pc = NULL, Method*** sp = NULL) const;
jeffhao33dc7712011-11-09 17:54:24 -0800192
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700193 bool IsExceptionPending() const {
Elliott Hughesb20a5542011-08-12 18:03:12 -0700194 return exception_ != NULL;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700195 }
196
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700197 Throwable* GetException() const {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700198 DCHECK(CanAccessDirectReferences());
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700199 return exception_;
200 }
201
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700202 void SetException(Throwable* new_exception) {
203 DCHECK(CanAccessDirectReferences());
204 CHECK(new_exception != NULL);
205 // TODO: CHECK(exception_ == NULL);
206 exception_ = new_exception; // TODO
207 }
208
209 void ClearException() {
210 exception_ = NULL;
Elliott Hughesa0957642011-09-02 14:27:33 -0700211 }
212
Ian Rogersbdb03912011-09-14 00:55:44 -0700213 // Find catch block and perform long jump to appropriate exception handle
Ian Rogersff1ed472011-09-20 13:46:24 -0700214 void DeliverException();
Ian Rogersbdb03912011-09-14 00:55:44 -0700215
216 Context* GetLongJumpContext();
217
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -0700218 Frame GetTopOfStack() const {
219 return top_of_managed_stack_;
220 }
221
222 // TODO: this is here for testing, remove when we have exception unit tests
223 // that use the real stack
Ian Rogersbdb03912011-09-14 00:55:44 -0700224 void SetTopOfStack(void* stack, uintptr_t pc) {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700225 top_of_managed_stack_.SetSP(reinterpret_cast<Method**>(stack));
Ian Rogersbdb03912011-09-14 00:55:44 -0700226 top_of_managed_stack_pc_ = pc;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700227 }
228
Ian Rogersbdb03912011-09-14 00:55:44 -0700229 void SetTopOfStackPC(uintptr_t pc) {
230 top_of_managed_stack_pc_ = pc;
231 }
232
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700233 // 'msg' may be NULL.
234 void ThrowNewException(const char* exception_class_descriptor, const char* msg);
235
236 void ThrowNewExceptionF(const char* exception_class_descriptor, const char* fmt, ...)
Elliott Hughes362f9bc2011-10-17 18:56:41 -0700237 __attribute__((format(printf, 3, 4)));
Elliott Hughesa5b897e2011-08-16 11:33:06 -0700238
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700239 void ThrowNewExceptionV(const char* exception_class_descriptor, const char* fmt, va_list ap);
240
Elliott Hughes2ced6a52011-10-16 18:44:48 -0700241 // OutOfMemoryError is special, because we need to pre-allocate an instance.
242 void ThrowOutOfMemoryError(const char* msg);
Elliott Hughes418dfe72011-10-06 18:56:27 -0700243 void ThrowOutOfMemoryError(Class* c, size_t byte_count);
Elliott Hughes79082e32011-08-25 12:07:32 -0700244
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -0700245 Frame FindExceptionHandler(void* throw_pc, void** handler_pc);
246
247 void* FindExceptionHandlerInMethod(const Method* method,
248 void* throw_pc,
249 const DexFile& dex_file,
250 ClassLinker* class_linker);
buzbeec143c552011-08-20 17:38:58 -0700251
Elliott Hughesbe759c62011-09-08 19:38:21 -0700252 static void Startup();
Elliott Hughes038a8062011-09-18 14:12:41 -0700253 static void FinishStartup();
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700254 static void Shutdown();
Carl Shapirob5573532011-07-12 18:22:59 -0700255
Ian Rogersb033c752011-07-20 12:22:35 -0700256 // JNI methods
Elliott Hughes69f5bc62011-08-24 09:26:14 -0700257 JNIEnvExt* GetJniEnv() const {
Ian Rogersb033c752011-07-20 12:22:35 -0700258 return jni_env_;
259 }
260
Ian Rogers408f79a2011-08-23 18:22:33 -0700261 // Number of references allocated in SIRTs on this thread
262 size_t NumSirtReferences();
Ian Rogersa8cd9f42011-08-19 16:43:41 -0700263
Ian Rogers408f79a2011-08-23 18:22:33 -0700264 // Is the given obj in this thread's stack indirect reference table?
265 bool SirtContains(jobject obj);
266
Shih-wei Liao8dfc9d52011-09-28 18:06:15 -0700267 void SirtVisitRoots(Heap::RootVisitor* visitor, void* arg);
268
Ian Rogers408f79a2011-08-23 18:22:33 -0700269 // Convert a jobject into a Object*
270 Object* DecodeJObject(jobject obj);
Ian Rogersb033c752011-07-20 12:22:35 -0700271
Elliott Hughes8daa0922011-09-11 13:46:25 -0700272 // Implements java.lang.Thread.interrupted.
273 bool Interrupted() {
Elliott Hughes85d15452011-09-16 17:33:01 -0700274 MutexLock mu(*wait_mutex_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700275 bool interrupted = interrupted_;
276 interrupted_ = false;
277 return interrupted;
278 }
279
280 // Implements java.lang.Thread.isInterrupted.
281 bool IsInterrupted() {
Elliott Hughes85d15452011-09-16 17:33:01 -0700282 MutexLock mu(*wait_mutex_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700283 return interrupted_;
284 }
285
Elliott Hughes5f791332011-09-15 17:45:30 -0700286 void Interrupt() {
Elliott Hughes85d15452011-09-16 17:33:01 -0700287 MutexLock mu(*wait_mutex_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700288 if (interrupted_) {
289 return;
290 }
291 interrupted_ = true;
292 NotifyLocked();
293 }
294
295 void Notify() {
Elliott Hughes85d15452011-09-16 17:33:01 -0700296 MutexLock mu(*wait_mutex_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700297 NotifyLocked();
298 }
299
Ian Rogers6de08602011-08-19 14:52:39 -0700300 // Linked list recording transitions from native to managed code
Ian Rogersb04f69f2011-10-17 00:40:54 -0700301 void PushNativeToManagedRecord(NativeToManagedRecord* record);
302 void PopNativeToManagedRecord(const NativeToManagedRecord& record);
Ian Rogers6de08602011-08-19 14:52:39 -0700303
Brian Carlstrombffb1552011-08-25 12:23:53 -0700304 const ClassLoader* GetClassLoaderOverride() {
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700305 // TODO: need to place the class_loader_override_ in a handle
306 // DCHECK(CanAccessDirectReferences());
buzbeec143c552011-08-20 17:38:58 -0700307 return class_loader_override_;
308 }
309
Brian Carlstrombffb1552011-08-25 12:23:53 -0700310 void SetClassLoaderOverride(const ClassLoader* class_loader_override) {
buzbeec143c552011-08-20 17:38:58 -0700311 class_loader_override_ = class_loader_override;
312 }
313
Ian Rogersaaa20802011-09-11 21:47:37 -0700314 // Create the internal representation of a stack trace, that is more time
315 // and space efficient to compute than the StackTraceElement[]
Elliott Hughes01158d72011-09-19 19:47:10 -0700316 jobject CreateInternalStackTrace(JNIEnv* env) const;
Ian Rogersaaa20802011-09-11 21:47:37 -0700317
Elliott Hughes01158d72011-09-19 19:47:10 -0700318 // Convert an internal stack trace representation (returned by CreateInternalStackTrace) to a
319 // StackTraceElement[]. If output_array is NULL, a new array is created, otherwise as many
320 // frames as will fit are written into the given array. If stack_depth is non-NULL, it's updated
321 // with the number of valid frames in the returned array.
322 static jobjectArray InternalStackTraceToStackTraceElementArray(JNIEnv* env, jobject internal,
323 jobjectArray output_array = NULL, int* stack_depth = NULL);
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700324
Ian Rogersd6b1f612011-09-27 13:38:14 -0700325 void VisitRoots(Heap::RootVisitor* visitor, void* arg);
Elliott Hughes410c0c82011-09-01 17:58:25 -0700326
Elliott Hughesbe759c62011-09-08 19:38:21 -0700327 //
328 // Offsets of various members of native Thread class, used by compiled code.
329 //
330
331 static ThreadOffset SelfOffset() {
332 return ThreadOffset(OFFSETOF_MEMBER(Thread, self_));
333 }
334
335 static ThreadOffset ExceptionOffset() {
336 return ThreadOffset(OFFSETOF_MEMBER(Thread, exception_));
337 }
338
Elliott Hughes54e7df12011-09-16 11:47:04 -0700339 static ThreadOffset ThinLockIdOffset() {
Elliott Hughesbe759c62011-09-08 19:38:21 -0700340 return ThreadOffset(OFFSETOF_MEMBER(Thread, thin_lock_id_));
341 }
342
343 static ThreadOffset CardTableOffset() {
344 return ThreadOffset(OFFSETOF_MEMBER(Thread, card_table_));
345 }
346
347 static ThreadOffset SuspendCountOffset() {
348 return ThreadOffset(OFFSETOF_MEMBER(Thread, suspend_count_));
349 }
350
351 static ThreadOffset StateOffset() {
Elliott Hughes93e74e82011-09-13 11:07:03 -0700352 return ThreadOffset(OFFSETOF_VOLATILE_MEMBER(Thread, state_));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700353 }
354
Ian Rogers932746a2011-09-22 18:57:50 -0700355 // Size of stack less any space reserved for stack overflow
356 size_t GetStackSize() {
Ian Rogers30fab402012-01-23 15:43:46 -0800357 return stack_size_ - (stack_end_ - stack_begin_);
Ian Rogers932746a2011-09-22 18:57:50 -0700358 }
359
360 // Set the stack end to that to be used during a stack overflow
361 void SetStackEndForStackOverflow() {
362 // During stack overflow we allow use of the full stack
Ian Rogers30fab402012-01-23 15:43:46 -0800363 if (stack_end_ == stack_begin_) {
Elliott Hughes3b6baaa2011-10-14 19:13:56 -0700364 DumpStack(std::cerr);
365 LOG(FATAL) << "Need to increase kStackOverflowReservedBytes (currently "
366 << kStackOverflowReservedBytes << ")";
367 }
368
Ian Rogers30fab402012-01-23 15:43:46 -0800369 stack_end_ = stack_begin_;
Ian Rogers932746a2011-09-22 18:57:50 -0700370 }
371
372 // Set the stack end to that to be used during regular execution
373 void ResetDefaultStackEnd() {
374 // Our stacks grow down, so we want stack_end_ to be near there, but reserving enough room
375 // to throw a StackOverflowError.
Ian Rogers30fab402012-01-23 15:43:46 -0800376 stack_end_ = stack_begin_ + kStackOverflowReservedBytes;
Ian Rogers932746a2011-09-22 18:57:50 -0700377 }
378
Elliott Hughes449b4bd2011-09-09 12:01:38 -0700379 static ThreadOffset StackEndOffset() {
380 return ThreadOffset(OFFSETOF_MEMBER(Thread, stack_end_));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700381 }
382
383 static ThreadOffset JniEnvOffset() {
384 return ThreadOffset(OFFSETOF_MEMBER(Thread, jni_env_));
385 }
386
387 static ThreadOffset TopOfManagedStackOffset() {
388 return ThreadOffset(OFFSETOF_MEMBER(Thread, top_of_managed_stack_) +
389 OFFSETOF_MEMBER(Frame, sp_));
390 }
391
Ian Rogersbdb03912011-09-14 00:55:44 -0700392 static ThreadOffset TopOfManagedStackPcOffset() {
393 return ThreadOffset(OFFSETOF_MEMBER(Thread, top_of_managed_stack_pc_));
394 }
395
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700396 void PushSirt(StackIndirectReferenceTable* sirt);
397 StackIndirectReferenceTable* PopSirt();
398
Elliott Hughesbe759c62011-09-08 19:38:21 -0700399 static ThreadOffset TopSirtOffset() {
400 return ThreadOffset(OFFSETOF_MEMBER(Thread, top_sirt_));
401 }
402
Elliott Hughes530fa002012-03-12 11:44:49 -0700403 void WalkStack(StackVisitor* visitor, bool include_upcalls = false) const;
Shih-wei Liao9407c602011-09-16 10:36:43 -0700404
Elliott Hughes475fc232011-10-25 15:00:35 -0700405 DebugInvokeReq* GetInvokeReq() {
406 return debug_invoke_req_;
407 }
408
jeffhaoe343b762011-12-05 16:36:44 -0800409 bool IsTraceStackEmpty() const {
410 return trace_stack_->empty();
411 }
412
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800413 TraceStackFrame GetTraceStackFrame(uint32_t depth) const {
414 return trace_stack_->at(trace_stack_->size() - depth - 1);
415 }
416
jeffhaoe343b762011-12-05 16:36:44 -0800417 void PushTraceStackFrame(const TraceStackFrame& frame) {
418 trace_stack_->push_back(frame);
419 }
420
421 TraceStackFrame PopTraceStackFrame() {
422 TraceStackFrame frame = trace_stack_->back();
423 trace_stack_->pop_back();
424 return frame;
425 }
426
Elliott Hughesa4060e52012-03-02 16:51:35 -0800427 void CheckSafeToLockOrUnlock(MutexRank rank, bool is_locking);
428 void CheckSafeToWait(MutexRank rank);
Elliott Hughesffb465f2012-03-01 18:46:05 -0800429
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700430 private:
Elliott Hughesdcc24742011-09-07 14:02:44 -0700431 Thread();
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700432 ~Thread();
Elliott Hughes02b48d12011-09-07 17:15:51 -0700433 friend class ThreadList; // For ~Thread.
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700434
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700435 void CreatePeer(const char* name, bool as_daemon);
436 friend class Runtime; // For CreatePeer.
437
Elliott Hughesd92bec42011-09-02 17:04:36 -0700438 void DumpState(std::ostream& os) const;
439 void DumpStack(std::ostream& os) const;
Elliott Hughesffb465f2012-03-01 18:46:05 -0800440 void DumpNativeStack(std::ostream& os) const;
Elliott Hughesd92bec42011-09-02 17:04:36 -0700441
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700442 // Out-of-line conveniences for debugging in gdb.
Elliott Hughes498508c2011-10-17 14:58:22 -0700443 static Thread* CurrentFromGdb(); // Like Thread::Current.
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700444 void DumpFromGdb() const; // Like Thread::Dump(std::cerr).
445
Elliott Hughes93e74e82011-09-13 11:07:03 -0700446 void Attach(const Runtime* runtime);
447 static void* CreateCallback(void* arg);
448
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700449 void HandleUncaughtExceptions();
Brian Carlstrom4514d3c2011-10-21 17:01:31 -0700450 void RemoveFromThreadGroup();
Elliott Hughesaccd83d2011-10-17 14:25:58 -0700451
Ian Rogers5d76c432011-10-31 21:42:49 -0700452 void InitCardTable();
Ian Rogersb033c752011-07-20 12:22:35 -0700453 void InitCpu();
buzbee3ea4ec52011-08-22 17:37:19 -0700454 void InitFunctionPointers();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700455 void InitTid();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700456 void InitPthreadKeySelf();
Elliott Hughesbe759c62011-09-08 19:38:21 -0700457 void InitStackHwm();
458
Elliott Hughes5f791332011-09-15 17:45:30 -0700459 void NotifyLocked() {
460 if (wait_monitor_ != NULL) {
Elliott Hughes85d15452011-09-16 17:33:01 -0700461 wait_cond_->Signal();
Elliott Hughes5f791332011-09-15 17:45:30 -0700462 }
463 }
464
Elliott Hughesbe759c62011-09-08 19:38:21 -0700465 static void ThreadExitCallback(void* arg);
Ian Rogersb033c752011-07-20 12:22:35 -0700466
Elliott Hughesdcc24742011-09-07 14:02:44 -0700467 // Thin lock thread id. This is a small integer used by the thin lock implementation.
468 // This is not to be confused with the native thread's tid, nor is it the value returned
469 // by java.lang.Thread.getId --- this is a distinct value, used only for locking. One
470 // important difference between this id and the ids visible to managed code is that these
471 // ones get reused (to ensure that they fit in the number of bits available).
472 uint32_t thin_lock_id_;
Ian Rogersb033c752011-07-20 12:22:35 -0700473
Elliott Hughesd92bec42011-09-02 17:04:36 -0700474 // System thread id.
475 pid_t tid_;
476
Elliott Hughesdcc24742011-09-07 14:02:44 -0700477 // Our managed peer (an instance of java.lang.Thread).
Elliott Hughesd369bb72011-09-12 14:41:14 -0700478 Object* peer_;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700479
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700480 // The top_of_managed_stack_ and top_of_managed_stack_pc_ fields are accessed from
481 // compiled code, so we keep them early in the structure to (a) avoid having to keep
482 // fixing the assembler offsets and (b) improve the chances that these will still be aligned.
483
484 // Top of the managed stack, written out prior to the state transition from
Elliott Hughes68e76522011-10-05 13:22:16 -0700485 // kRunnable to kNative. Uses include giving the starting point for scanning
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700486 // a managed stack when a thread is in native code.
487 Frame top_of_managed_stack_;
488 // PC corresponding to the call out of the top_of_managed_stack_ frame
489 uintptr_t top_of_managed_stack_pc_;
490
Elliott Hughes8daa0922011-09-11 13:46:25 -0700491 // Guards the 'interrupted_' and 'wait_monitor_' members.
Elliott Hughes85d15452011-09-16 17:33:01 -0700492 mutable Mutex* wait_mutex_;
493 ConditionVariable* wait_cond_;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700494 // Pointer to the monitor lock we're currently waiting on (or NULL), guarded by wait_mutex_.
495 Monitor* wait_monitor_;
496 // Thread "interrupted" status; stays raised until queried or thrown, guarded by wait_mutex_.
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700497 uint32_t interrupted_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700498 // The next thread in the wait set this thread is part of.
499 Thread* wait_next_;
Elliott Hughes8e4aac52011-09-26 17:03:36 -0700500 // If we're blocked in MonitorEnter, this is the object we're trying to lock.
501 Object* monitor_enter_object_;
Elliott Hughes5f791332011-09-15 17:45:30 -0700502
503 friend class Monitor;
Elliott Hughesdcc24742011-09-07 14:02:44 -0700504
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700505 RuntimeStats stats_;
506
Ian Rogers5d76c432011-10-31 21:42:49 -0700507 // The biased card table, see CardTable for details
508 byte* card_table_;
buzbeec143c552011-08-20 17:38:58 -0700509
Elliott Hughes449b4bd2011-09-09 12:01:38 -0700510 // The end of this thread's stack. This is the lowest safely-addressable address on the stack.
511 // We leave extra space so there's room for the code that throws StackOverflowError.
512 byte* stack_end_;
Elliott Hughesbe759c62011-09-08 19:38:21 -0700513
Ian Rogers932746a2011-09-22 18:57:50 -0700514 // Size of the stack
515 size_t stack_size_;
516
517 // The "lowest addressable byte" of the stack
Ian Rogers30fab402012-01-23 15:43:46 -0800518 byte* stack_begin_;
Ian Rogers932746a2011-09-22 18:57:50 -0700519
Ian Rogers6de08602011-08-19 14:52:39 -0700520 // A linked list (of stack allocated records) recording transitions from
521 // native to managed code.
522 NativeToManagedRecord* native_to_managed_record_;
523
Ian Rogers408f79a2011-08-23 18:22:33 -0700524 // Top of linked list of stack indirect reference tables or NULL for none
525 StackIndirectReferenceTable* top_sirt_;
Ian Rogersb033c752011-07-20 12:22:35 -0700526
527 // Every thread may have an associated JNI environment
Elliott Hughes69f5bc62011-08-24 09:26:14 -0700528 JNIEnvExt* jni_env_;
Ian Rogersb033c752011-07-20 12:22:35 -0700529
Elliott Hughes93e74e82011-09-13 11:07:03 -0700530 volatile State state_;
Carl Shapirob5573532011-07-12 18:22:59 -0700531
Carl Shapiro69759ea2011-07-21 18:13:35 -0700532 // Initialized to "this". On certain architectures (such as x86) reading
533 // off of Thread::Current is easy but getting the address of Thread::Current
534 // is hard. This field can be read off of Thread::Current to give the address.
535 Thread* self_;
536
537 Runtime* runtime_;
538
539 // The pending exception or NULL.
Elliott Hughese5b0dc82011-08-23 09:59:02 -0700540 Throwable* exception_;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700541
Ian Rogers45a76cb2011-07-21 22:00:15 -0700542 // A non-zero value is used to tell the current thread to enter a safe point
543 // at the next poll.
544 int suspend_count_;
Elliott Hughes234ab152011-10-26 14:02:26 -0700545 // How much of 'suspend_count_' is by request of the debugger, used to set things right
546 // when the debugger detaches. Must be <= suspend_count_.
547 int debug_suspend_count_;
Ian Rogers45a76cb2011-07-21 22:00:15 -0700548
Elliott Hughesedcc09c2011-08-21 18:47:05 -0700549 // Needed to get the right ClassLoader in JNI_OnLoad, but also
550 // useful for testing.
Brian Carlstrombffb1552011-08-25 12:23:53 -0700551 const ClassLoader* class_loader_override_;
buzbeec143c552011-08-20 17:38:58 -0700552
Ian Rogersbdb03912011-09-14 00:55:44 -0700553 // Thread local, lazily allocated, long jump context. Used to deliver exceptions.
Elliott Hughes85d15452011-09-16 17:33:01 -0700554 Context* long_jump_context_;
Ian Rogersbdb03912011-09-14 00:55:44 -0700555
Elliott Hughes418dfe72011-10-06 18:56:27 -0700556 // A boolean telling us whether we're recursively throwing OOME.
Elliott Hughes726079d2011-10-07 18:43:44 -0700557 uint32_t throwing_OutOfMemoryError_;
558
559 Throwable* pre_allocated_OutOfMemoryError_;
Elliott Hughes418dfe72011-10-06 18:56:27 -0700560
Elliott Hughes475fc232011-10-25 15:00:35 -0700561 // JDWP invoke-during-breakpoint support.
562 DebugInvokeReq* debug_invoke_req_;
563
Carl Shapiro69759ea2011-07-21 18:13:35 -0700564 // TLS key used to retrieve the VM thread object.
Carl Shapirob5573532011-07-12 18:22:59 -0700565 static pthread_key_t pthread_key_self_;
566
jeffhaoe343b762011-12-05 16:36:44 -0800567 // Additional stack used by method tracer to store method and return pc values.
568 // Stored as a pointer since std::vector is not PACKED.
569 std::vector<TraceStackFrame>* trace_stack_;
570
Elliott Hughes899e7892012-01-24 14:57:32 -0800571 // A cached copy of the java.lang.Thread's name.
572 std::string* name_;
573
Elliott Hughesffb465f2012-03-01 18:46:05 -0800574 uint32_t held_mutexes_[kMaxMutexRank + 1];
575
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800576 public:
577 // Runtime support function pointers
578 void (*pDebugMe)(Method*, uint32_t);
579 void* (*pMemcpy)(void*, const void*, size_t);
580 uint64_t (*pShlLong)(uint64_t, uint32_t);
581 uint64_t (*pShrLong)(uint64_t, uint32_t);
582 uint64_t (*pUshrLong)(uint64_t, uint32_t);
583 float (*pI2f)(int);
584 int (*pF2iz)(float);
585 float (*pD2f)(double);
586 double (*pF2d)(float);
587 double (*pI2d)(int);
588 int (*pD2iz)(double);
589 float (*pL2f)(long);
590 double (*pL2d)(long);
591 long long (*pF2l)(float);
592 long long (*pD2l)(double);
593 float (*pFadd)(float, float);
594 float (*pFsub)(float, float);
595 float (*pFdiv)(float, float);
596 float (*pFmul)(float, float);
597 float (*pFmodf)(float, float);
598 double (*pDadd)(double, double);
599 double (*pDsub)(double, double);
600 double (*pDdiv)(double, double);
601 double (*pDmul)(double, double);
602 double (*pFmod)(double, double);
603 int (*pIdivmod)(int, int);
604 int (*pIdiv)(int, int);
605 long long (*pLmul)(long long, long long);
606 long long (*pLdivmod)(long long, long long);
607 void (*pCheckSuspendFromCode)(Thread*); // Stub that is called when the suspend count is non-zero
608 void (*pTestSuspendFromCode)(); // Stub that is periodically called to test the suspend count
609 void* (*pAllocObjectFromCode)(uint32_t, void*);
610 void* (*pAllocObjectFromCodeWithAccessCheck)(uint32_t, void*);
611 void* (*pAllocArrayFromCode)(uint32_t, void*, int32_t);
612 void* (*pAllocArrayFromCodeWithAccessCheck)(uint32_t, void*, int32_t);
613 void (*pCanPutArrayElementFromCode)(void*, void*);
614 void* (*pCheckAndAllocArrayFromCode)(uint32_t, void*, int32_t);
615 void* (*pCheckAndAllocArrayFromCodeWithAccessCheck)(uint32_t, void*, int32_t);
616 void (*pCheckCastFromCode)(void*, void*);
617 Object* (*pDecodeJObjectInThread)(Thread* thread, jobject obj);
618 void (*pDeliverException)(void*);
619 Method* (*pFindInterfaceMethodInCache)(Class*, uint32_t, const Method*, struct DvmDex*);
620 void* (*pFindNativeMethod)(Thread* thread);
621 int32_t (*pGet32Instance)(uint32_t, void*);
622 int64_t (*pGet64Instance)(uint32_t, void*);
623 void* (*pGetObjInstance)(uint32_t, void*);
624 int32_t (*pGet32Static)(uint32_t);
625 int64_t (*pGet64Static)(uint32_t);
626 void* (*pGetObjStatic)(uint32_t);
627 void (*pHandleFillArrayDataFromCode)(void*, void*);
628 void* (*pInitializeStaticStorage)(uint32_t, void*);
629 uint32_t (*pInstanceofNonTrivialFromCode)(const Class*, const Class*);
Ian Rogersc8b306f2012-02-17 21:34:44 -0800630 void (*pInvokeDirectTrampolineWithAccessCheck)(uint32_t, void*);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800631 void (*pInvokeInterfaceTrampoline)(uint32_t, void*);
632 void (*pInvokeInterfaceTrampolineWithAccessCheck)(uint32_t, void*);
Ian Rogersc8b306f2012-02-17 21:34:44 -0800633 void (*pInvokeStaticTrampolineWithAccessCheck)(uint32_t, void*);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800634 void (*pInvokeSuperTrampolineWithAccessCheck)(uint32_t, void*);
635 void (*pInvokeVirtualTrampolineWithAccessCheck)(uint32_t, void*);
636 void* (*pInitializeTypeFromCode)(uint32_t, void*);
637 void* (*pInitializeTypeAndVerifyAccessFromCode)(uint32_t, void*);
638 void (*pLockObjectFromCode)(void*);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800639 void* (*pResolveStringFromCode)(void*, uint32_t);
640 int (*pSet32Instance)(uint32_t, void*, int32_t); // field_idx, obj, src
641 int (*pSet64Instance)(uint32_t, void*, int64_t);
642 int (*pSetObjInstance)(uint32_t, void*, void*);
643 int (*pSet32Static)(uint32_t, int32_t);
644 int (*pSet64Static)(uint32_t, int64_t);
645 int (*pSetObjStatic)(uint32_t, void*);
646 void (*pThrowStackOverflowFromCode)(void*);
647 void (*pThrowNullPointerFromCode)();
648 void (*pThrowArrayBoundsFromCode)(int32_t, int32_t);
649 void (*pThrowDivZeroFromCode)();
650 void (*pThrowVerificationErrorFromCode)(int32_t, int32_t);
651 void (*pThrowNegArraySizeFromCode)(int32_t);
652 void (*pThrowNoSuchMethodFromCode)(int32_t);
653 void (*pThrowAbstractMethodErrorFromCode)(Method* method, Thread* thread, Method** sp);
654 void (*pUnlockObjectFromCode)(void*);
Ian Rogers19846512012-02-24 11:42:47 -0800655 const void* (*pUnresolvedDirectMethodTrampolineFromCode)(Method*, Method**, Thread*,
656 Runtime::TrampolineType);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800657 void (*pUpdateDebuggerFromCode)(void*, void*, int32_t, void*);
Bill Buzbee11f9d212012-03-03 20:03:18 -0800658 bool (*pCmplFloat)(float, float);
659 bool (*pCmpgFloat)(float, float);
660 bool (*pCmplDouble)(double, double);
661 bool (*pCmpgDouble)(double, double);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800662
663 private:
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700664 DISALLOW_COPY_AND_ASSIGN(Thread);
665};
Ian Rogersbdb03912011-09-14 00:55:44 -0700666
Elliott Hughes330304d2011-08-12 14:28:05 -0700667std::ostream& operator<<(std::ostream& os, const Thread& thread);
Ian Rogersb033c752011-07-20 12:22:35 -0700668std::ostream& operator<<(std::ostream& os, const Thread::State& state);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700669
Elliott Hughesad7c2a32011-08-31 11:58:10 -0700670class ScopedThreadStateChange {
671 public:
672 ScopedThreadStateChange(Thread* thread, Thread::State new_state) : thread_(thread) {
673 old_thread_state_ = thread_->SetState(new_state);
674 }
675
676 ~ScopedThreadStateChange() {
677 thread_->SetState(old_thread_state_);
678 }
679
680 private:
681 Thread* thread_;
682 Thread::State old_thread_state_;
683 DISALLOW_COPY_AND_ASSIGN(ScopedThreadStateChange);
684};
685
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700686} // namespace art
687
688#endif // ART_SRC_THREAD_H_