blob: 138c143d34e6786e16a4b5a47224166209a0e6bf [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
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_THREAD_H_
18#define ART_RUNTIME_THREAD_H_
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070019
Elliott Hughes02b48d12011-09-07 17:15:51 -070020#include <bitset>
Ian Rogers306057f2012-11-26 12:45:53 -080021#include <deque>
Elliott Hughesa0957642011-09-02 14:27:33 -070022#include <iosfwd>
Ian Rogersb033c752011-07-20 12:22:35 -070023#include <list>
Ian Rogers700a4022014-05-19 16:49:03 -070024#include <memory>
Dave Allison8ce6b902014-08-26 11:07:58 -070025#include <setjmp.h>
Elliott Hughes8daa0922011-09-11 13:46:25 -070026#include <string>
Carl Shapirob5573532011-07-12 18:22:59 -070027
Mingyao Yang4dcfc432015-04-21 16:55:22 -070028#include "arch/context.h"
Ian Rogersd582fa42014-11-05 23:46:43 -080029#include "arch/instruction_set.h"
Ian Rogersb8e087e2014-07-09 21:12:06 -070030#include "atomic.h"
Elliott Hughes76160052012-12-12 16:31:20 -080031#include "base/macros.h"
Ian Rogers719d1a32014-03-06 12:13:39 -080032#include "base/mutex.h"
Ian Rogers848871b2013-08-05 10:56:33 -070033#include "entrypoints/jni/jni_entrypoints.h"
Ian Rogers7655f292013-07-29 11:07:13 -070034#include "entrypoints/quick/quick_entrypoints.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070035#include "globals.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070036#include "handle_scope.h"
Elliott Hughes956af0f2014-12-11 14:34:28 -080037#include "instrumentation.h"
Ian Rogers306057f2012-11-26 12:45:53 -080038#include "jvalue.h"
Mathieu Chartier83c8ee02014-01-28 14:50:23 -080039#include "object_callbacks.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070040#include "offsets.h"
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070041#include "runtime_stats.h"
Elliott Hughes68e76522011-10-05 13:22:16 -070042#include "stack.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080043#include "thread_state.h"
Ian Rogersb033c752011-07-20 12:22:35 -070044
Christopher Ferris6cff48f2014-01-26 21:36:13 -080045class BacktraceMap;
46
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070047namespace art {
48
Mathieu Chartier15d34022014-02-26 17:16:38 -080049namespace gc {
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -070050namespace accounting {
51 template<class T> class AtomicStack;
52} // namespace accounting
Mathieu Chartier15d34022014-02-26 17:16:38 -080053namespace collector {
Mingyao Yang98d1cc82014-05-15 17:02:16 -070054 class SemiSpace;
Mathieu Chartier15d34022014-02-26 17:16:38 -080055} // namespace collector
56} // namespace gc
57
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080058namespace mirror {
Ian Rogers848871b2013-08-05 10:56:33 -070059 class Array;
60 class Class;
61 class ClassLoader;
62 class Object;
63 template<class T> class ObjectArray;
64 template<class T> class PrimitiveArray;
65 typedef PrimitiveArray<int32_t> IntArray;
66 class StackTraceElement;
Vladimir Marko80afd022015-05-19 18:08:00 +010067 class String;
Ian Rogers848871b2013-08-05 10:56:33 -070068 class Throwable;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080069} // namespace mirror
Mathieu Chartier12d625f2015-03-13 11:33:37 -070070
71namespace verifier {
72class MethodVerifier;
73} // namespace verifier
74
Mathieu Chartiere401d142015-04-22 13:56:20 -070075class ArtMethod;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080076class BaseMutex;
77class ClassLinker;
Ian Rogers7a22fa62013-01-23 12:16:16 -080078class Closure;
Ian Rogersbdb03912011-09-14 00:55:44 -070079class Context;
Ian Rogers1b09b092012-08-20 15:35:52 -070080struct DebugInvokeReq;
Sebastien Hertz07474662015-08-25 15:12:33 +000081class DeoptimizationContextRecord;
Ian Rogers81d425b2012-09-27 16:03:43 -070082class DexFile;
Mingyao Yang99170c62015-07-06 11:10:37 -070083class FrameIdToShadowFrame;
Ian Rogersb48b9eb2014-02-28 16:20:21 -080084class JavaVMExt;
Ian Rogers81d425b2012-09-27 16:03:43 -070085struct JNIEnvExt;
Elliott Hughes8daa0922011-09-11 13:46:25 -070086class Monitor;
Carl Shapirob5573532011-07-12 18:22:59 -070087class Runtime;
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -070088class ScopedObjectAccessAlreadyRunnable;
Logan Chienf7ad17e2012-03-15 03:10:03 +080089class ShadowFrame;
Sebastien Hertz597c4f02015-01-26 17:37:14 +010090class SingleStepControl;
Sebastien Hertzf7958692015-06-09 14:09:14 +020091class StackedShadowFrameRecord;
Brian Carlstrom40381fb2011-10-19 14:13:40 -070092class Thread;
93class ThreadList;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070094
Elliott Hughes34e06962012-04-09 13:55:55 -070095// Thread priorities. These must match the Thread.MIN_PRIORITY,
96// Thread.NORM_PRIORITY, and Thread.MAX_PRIORITY constants.
97enum ThreadPriority {
98 kMinThreadPriority = 1,
99 kNormThreadPriority = 5,
100 kMaxThreadPriority = 10,
101};
102
Ian Rogers474b6da2012-09-25 00:20:38 -0700103enum ThreadFlag {
Ian Rogers50ffee22012-11-20 11:47:44 -0800104 kSuspendRequest = 1, // If set implies that suspend_count_ > 0 and the Thread should enter the
105 // safepoint handler.
Yu Lieac44242015-06-29 10:50:03 +0800106 kCheckpointRequest = 2, // Request that the thread do some checkpoint work and then continue.
107 kActiveSuspendBarrier = 4 // Register that at least 1 suspend barrier needs to be passed.
Ian Rogers474b6da2012-09-25 00:20:38 -0700108};
109
Sebastien Hertzf7958692015-06-09 14:09:14 +0200110enum class StackedShadowFrameType {
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700111 kShadowFrameUnderConstruction,
Andreas Gampe639bdd12015-06-03 11:22:45 -0700112 kDeoptimizationShadowFrame,
113 kSingleFrameDeoptimizationShadowFrame
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700114};
115
Ian Rogerse63db272014-07-15 15:36:11 -0700116static constexpr size_t kNumRosAllocThreadLocalSizeBrackets = 34;
117
Dave Allison648d7112014-07-25 16:15:27 -0700118// Thread's stack layout for implicit stack overflow checks:
119//
120// +---------------------+ <- highest address of stack memory
121// | |
122// . . <- SP
123// | |
124// | |
125// +---------------------+ <- stack_end
126// | |
127// | Gap |
128// | |
129// +---------------------+ <- stack_begin
130// | |
131// | Protected region |
132// | |
133// +---------------------+ <- lowest address of stack memory
134//
135// The stack always grows down in memory. At the lowest address is a region of memory
136// that is set mprotect(PROT_NONE). Any attempt to read/write to this region will
137// result in a segmentation fault signal. At any point, the thread's SP will be somewhere
138// between the stack_end and the highest address in stack memory. An implicit stack
139// overflow check is a read of memory at a certain offset below the current SP (4K typically).
140// If the thread's SP is below the stack_end address this will be a read into the protected
141// region. If the SP is above the stack_end address, the thread is guaranteed to have
142// at least 4K of space. Because stack overflow checks are only performed in generated code,
143// if the thread makes a call out to a native function (through JNI), that native function
144// might only have 4K of memory (if the SP is adjacent to stack_end).
145
Ian Rogersdd7624d2014-03-14 17:43:00 -0700146class Thread {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700147 public:
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700148 static const size_t kStackOverflowImplicitCheckSize;
Dave Allisonf9439142014-03-27 15:10:22 -0700149
Elliott Hughes462c9442012-03-23 18:47:50 -0700150 // Creates a new native thread corresponding to the given managed peer.
151 // Used to implement Thread.start.
Ian Rogers52673ff2012-06-27 23:25:34 -0700152 static void CreateNativeThread(JNIEnv* env, jobject peer, size_t stack_size, bool daemon);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700153
Elliott Hughes462c9442012-03-23 18:47:50 -0700154 // Attaches the calling native thread to the runtime, returning the new native peer.
155 // Used to implement JNI AttachCurrentThread and AttachCurrentThreadAsDaemon calls.
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800156 static Thread* Attach(const char* thread_name, bool as_daemon, jobject thread_group,
157 bool create_peer);
Carl Shapirob5573532011-07-12 18:22:59 -0700158
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700159 // Reset internal state of child thread after fork.
160 void InitAfterFork();
161
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700162 // Get the currently executing thread, frequently referred to as 'self'. This call has reasonably
163 // high cost and so we favor passing self around when possible.
164 // TODO: mark as PURE so the compiler may coalesce and remove?
Ian Rogers02ed4c02013-09-06 13:10:04 -0700165 static Thread* Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700166
Ian Rogers7b078e82014-09-10 14:44:24 -0700167 // On a runnable thread, check for pending thread suspension request and handle if pending.
Mathieu Chartier90443472015-07-16 20:32:27 -0700168 void AllowThreadSuspension() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers7b078e82014-09-10 14:44:24 -0700169
170 // Process pending thread suspension request and handle if pending.
Mathieu Chartier90443472015-07-16 20:32:27 -0700171 void CheckSuspend() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers7b078e82014-09-10 14:44:24 -0700172
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700173 static Thread* FromManagedThread(const ScopedObjectAccessAlreadyRunnable& ts,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800174 mirror::Object* thread_peer)
Mathieu Chartier90443472015-07-16 20:32:27 -0700175 REQUIRES(Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
176 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700177 static Thread* FromManagedThread(const ScopedObjectAccessAlreadyRunnable& ts, jobject thread)
Mathieu Chartier90443472015-07-16 20:32:27 -0700178 REQUIRES(Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
179 SHARED_REQUIRES(Locks::mutator_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700180
Elliott Hughes28fa76d2012-04-09 17:31:46 -0700181 // Translates 172 to pAllocArrayFromCode and so on.
Ian Rogersdd7624d2014-03-14 17:43:00 -0700182 template<size_t size_of_pointers>
183 static void DumpThreadOffset(std::ostream& os, uint32_t offset);
Elliott Hughes28fa76d2012-04-09 17:31:46 -0700184
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700185 // Dumps a one-line summary of thread state (used for operator<<).
186 void ShortDump(std::ostream& os) const;
187
188 // Dumps the detailed thread state and the thread stack (used for SIGQUIT).
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800189 void Dump(std::ostream& os, BacktraceMap* backtrace_map = nullptr) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700190 REQUIRES(!Locks::thread_suspend_count_lock_)
191 SHARED_REQUIRES(Locks::mutator_lock_);
Elliott Hughesa0957642011-09-02 14:27:33 -0700192
Mathieu Chartierc751fdc2014-03-30 15:25:44 -0700193 void DumpJavaStack(std::ostream& os) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700194 REQUIRES(!Locks::thread_suspend_count_lock_)
195 SHARED_REQUIRES(Locks::mutator_lock_);
Mathieu Chartierc751fdc2014-03-30 15:25:44 -0700196
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700197 // Dumps the SIGQUIT per-thread header. 'thread' can be null for a non-attached thread, in which
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700198 // case we use 'tid' to identify the thread, and we'll include as much information as we can.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700199 static void DumpState(std::ostream& os, const Thread* thread, pid_t tid)
Mathieu Chartier90443472015-07-16 20:32:27 -0700200 REQUIRES(!Locks::thread_suspend_count_lock_)
201 SHARED_REQUIRES(Locks::mutator_lock_);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700202
Ian Rogers474b6da2012-09-25 00:20:38 -0700203 ThreadState GetState() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700204 DCHECK_GE(tls32_.state_and_flags.as_struct.state, kTerminated);
205 DCHECK_LE(tls32_.state_and_flags.as_struct.state, kSuspended);
206 return static_cast<ThreadState>(tls32_.state_and_flags.as_struct.state);
Dave Allison0aded082013-11-07 13:15:11 -0800207 }
208
Ian Rogers474b6da2012-09-25 00:20:38 -0700209 ThreadState SetState(ThreadState new_state);
Ian Rogers52673ff2012-06-27 23:25:34 -0700210
Mathieu Chartier90443472015-07-16 20:32:27 -0700211 int GetSuspendCount() const REQUIRES(Locks::thread_suspend_count_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700212 return tls32_.suspend_count;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700213 }
Elliott Hughes038a8062011-09-18 14:12:41 -0700214
Mathieu Chartier90443472015-07-16 20:32:27 -0700215 int GetDebugSuspendCount() const REQUIRES(Locks::thread_suspend_count_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700216 return tls32_.debug_suspend_count;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700217 }
218
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700219 bool IsSuspended() const {
Chris Dearman59cde532013-12-04 18:53:49 -0800220 union StateAndFlags state_and_flags;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700221 state_and_flags.as_int = tls32_.state_and_flags.as_int;
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700222 return state_and_flags.as_struct.state != kRunnable &&
223 (state_and_flags.as_struct.flags & kSuspendRequest) != 0;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700224 }
225
Yu Lieac44242015-06-29 10:50:03 +0800226 bool ModifySuspendCount(Thread* self, int delta, AtomicInteger* suspend_barrier, bool for_debugger)
Mathieu Chartier90443472015-07-16 20:32:27 -0700227 REQUIRES(Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700228
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700229 bool RequestCheckpoint(Closure* function)
Mathieu Chartier90443472015-07-16 20:32:27 -0700230 REQUIRES(Locks::thread_suspend_count_lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700231
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800232 void SetFlipFunction(Closure* function);
233 Closure* GetFlipFunction();
234
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -0700235 gc::accounting::AtomicStack<mirror::Object>* GetThreadLocalMarkStack() {
236 CHECK(kUseReadBarrier);
237 return tlsPtr_.thread_local_mark_stack;
238 }
239 void SetThreadLocalMarkStack(gc::accounting::AtomicStack<mirror::Object>* stack) {
240 CHECK(kUseReadBarrier);
241 tlsPtr_.thread_local_mark_stack = stack;
242 }
243
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700244 // Called when thread detected that the thread_suspend_count_ was non-zero. Gives up share of
245 // mutator_lock_ and waits until it is resumed and thread_suspend_count_ is zero.
Ian Rogers9da7f592012-08-20 17:14:28 -0700246 void FullSuspendCheck()
Mathieu Chartier90443472015-07-16 20:32:27 -0700247 REQUIRES(!Locks::thread_suspend_count_lock_)
248 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700249
250 // Transition from non-runnable to runnable state acquiring share on mutator_lock_.
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700251 ALWAYS_INLINE ThreadState TransitionFromSuspendedToRunnable()
Mathieu Chartier90443472015-07-16 20:32:27 -0700252 REQUIRES(!Locks::thread_suspend_count_lock_)
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700253 SHARED_LOCK_FUNCTION(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700254
255 // Transition from runnable into a state where mutator privileges are denied. Releases share of
256 // mutator lock.
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700257 ALWAYS_INLINE void TransitionFromRunnableToSuspended(ThreadState new_state)
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700258 REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_)
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700259 UNLOCK_FUNCTION(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700260
Ian Rogers0399dde2012-06-06 17:09:28 -0700261 // Once called thread suspension will cause an assertion failure.
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700262 const char* StartAssertNoThreadSuspension(const char* cause) ACQUIRE(Roles::uninterruptible_) {
263 Roles::uninterruptible_.Acquire(); // No-op.
Mathieu Chartier590fee92013-09-13 13:46:47 -0700264 if (kIsDebugBuild) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700265 CHECK(cause != nullptr);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700266 const char* previous_cause = tlsPtr_.last_no_thread_suspension_cause;
267 tls32_.no_thread_suspension++;
268 tlsPtr_.last_no_thread_suspension_cause = cause;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700269 return previous_cause;
270 } else {
271 return nullptr;
272 }
Ian Rogers0399dde2012-06-06 17:09:28 -0700273 }
Ian Rogers52673ff2012-06-27 23:25:34 -0700274
Ian Rogers0399dde2012-06-06 17:09:28 -0700275 // End region where no thread suspension is expected.
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700276 void EndAssertNoThreadSuspension(const char* old_cause) RELEASE(Roles::uninterruptible_) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700277 if (kIsDebugBuild) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700278 CHECK(old_cause != nullptr || tls32_.no_thread_suspension == 1);
279 CHECK_GT(tls32_.no_thread_suspension, 0U);
280 tls32_.no_thread_suspension--;
281 tlsPtr_.last_no_thread_suspension_cause = old_cause;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700282 }
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700283 Roles::uninterruptible_.Release(); // No-op.
Ian Rogers0399dde2012-06-06 17:09:28 -0700284 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700285
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700286 void AssertThreadSuspensionIsAllowable(bool check_locks = true) const;
Ian Rogers0399dde2012-06-06 17:09:28 -0700287
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700288 bool IsDaemon() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700289 return tls32_.daemon;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700290 }
291
Mathieu Chartier14c3bf92015-07-13 14:35:43 -0700292 size_t NumberOfHeldMutexes() const;
293
Mathieu Chartier90443472015-07-16 20:32:27 -0700294 bool HoldsLock(mirror::Object*) const SHARED_REQUIRES(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700295
Elliott Hughes8daa0922011-09-11 13:46:25 -0700296 /*
297 * Changes the priority of this thread to match that of the java.lang.Thread object.
298 *
299 * We map a priority value from 1-10 to Linux "nice" values, where lower
300 * numbers indicate higher priority.
301 */
302 void SetNativePriority(int newPriority);
303
304 /*
305 * Returns the thread priority for the current thread by querying the system.
306 * This is useful when attaching a thread through JNI.
307 *
308 * Returns a value from 1 to 10 (compatible with java.lang.Thread values).
309 */
310 static int GetNativePriority();
311
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700312 uint32_t GetThreadId() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700313 return tls32_.thin_lock_thread_id;
Carl Shapirob5573532011-07-12 18:22:59 -0700314 }
315
Elliott Hughesd92bec42011-09-02 17:04:36 -0700316 pid_t GetTid() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700317 return tls32_.tid;
Elliott Hughesd92bec42011-09-02 17:04:36 -0700318 }
Elliott Hughese27955c2011-08-26 15:21:24 -0700319
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700320 // Returns the java.lang.Thread's name, or null if this Thread* doesn't have a peer.
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700321 mirror::String* GetThreadName(const ScopedObjectAccessAlreadyRunnable& ts) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700322 SHARED_REQUIRES(Locks::mutator_lock_);
Elliott Hughes899e7892012-01-24 14:57:32 -0800323
Elliott Hughesffb465f2012-03-01 18:46:05 -0800324 // Sets 'name' to the java.lang.Thread's name. This requires no transition to managed code,
325 // allocation, or locking.
326 void GetThreadName(std::string& name) const;
327
Elliott Hughes899e7892012-01-24 14:57:32 -0800328 // Sets the thread's name.
Mathieu Chartier90443472015-07-16 20:32:27 -0700329 void SetThreadName(const char* name) SHARED_REQUIRES(Locks::mutator_lock_);
Elliott Hughesfc861622011-10-17 17:57:47 -0700330
Jeff Hao57dac6e2013-08-15 16:36:24 -0700331 // Returns the thread-specific CPU-time clock in microseconds or -1 if unavailable.
332 uint64_t GetCpuMicroTime() const;
333
Mathieu Chartier90443472015-07-16 20:32:27 -0700334 mirror::Object* GetPeer() const SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700335 CHECK(tlsPtr_.jpeer == nullptr);
336 return tlsPtr_.opeer;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700337 }
338
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700339 bool HasPeer() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700340 return tlsPtr_.jpeer != nullptr || tlsPtr_.opeer != nullptr;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700341 }
342
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700343 RuntimeStats* GetStats() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700344 return &tls64_.stats;
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700345 }
346
Elliott Hughes7dc51662012-05-16 14:48:43 -0700347 bool IsStillStarting() const;
348
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700349 bool IsExceptionPending() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700350 return tlsPtr_.exception != nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700351 }
352
Mathieu Chartier90443472015-07-16 20:32:27 -0700353 mirror::Throwable* GetException() const SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700354 return tlsPtr_.exception;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700355 }
356
Andreas Gamped9efea62014-07-21 22:56:08 -0700357 void AssertPendingException() const;
Mathieu Chartier90443472015-07-16 20:32:27 -0700358 void AssertPendingOOMException() const SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700359 void AssertNoPendingException() const;
Mathieu Chartier8d7672e2014-02-25 10:57:16 -0800360 void AssertNoPendingExceptionForNewException(const char* msg) const;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700361
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000362 void SetException(mirror::Throwable* new_exception)
Mathieu Chartier90443472015-07-16 20:32:27 -0700363 SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700364 CHECK(new_exception != nullptr);
Ian Rogers474b6da2012-09-25 00:20:38 -0700365 // TODO: DCHECK(!IsExceptionPending());
Ian Rogersdd7624d2014-03-14 17:43:00 -0700366 tlsPtr_.exception = new_exception;
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700367 }
368
Mathieu Chartier90443472015-07-16 20:32:27 -0700369 void ClearException() SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700370 tlsPtr_.exception = nullptr;
jeffhao94d6df42012-11-26 16:02:12 -0800371 }
372
Ian Rogersbdb03912011-09-14 00:55:44 -0700373 // Find catch block and perform long jump to appropriate exception handle
Mathieu Chartier90443472015-07-16 20:32:27 -0700374 NO_RETURN void QuickDeliverException() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersbdb03912011-09-14 00:55:44 -0700375
376 Context* GetLongJumpContext();
Ian Rogers0399dde2012-06-06 17:09:28 -0700377 void ReleaseLongJumpContext(Context* context) {
Mingyao Yang4dcfc432015-04-21 16:55:22 -0700378 if (tlsPtr_.long_jump_context != nullptr) {
379 // Each QuickExceptionHandler gets a long jump context and uses
380 // it for doing the long jump, after finding catch blocks/doing deoptimization.
381 // Both finding catch blocks and deoptimization can trigger another
382 // exception such as a result of class loading. So there can be nested
383 // cases of exception handling and multiple contexts being used.
384 // ReleaseLongJumpContext tries to save the context in tlsPtr_.long_jump_context
385 // for reuse so there is no need to always allocate a new one each time when
386 // getting a context. Since we only keep one context for reuse, delete the
387 // existing one since the passed in context is yet to be used for longjump.
388 delete tlsPtr_.long_jump_context;
389 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700390 tlsPtr_.long_jump_context = context;
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -0700391 }
392
Andreas Gampe6ec8ebd2014-07-25 13:36:56 -0700393 // Get the current method and dex pc. If there are errors in retrieving the dex pc, this will
394 // abort the runtime iff abort_on_error is true.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700395 ArtMethod* GetCurrentMethod(uint32_t* dex_pc, bool abort_on_error = true) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700396 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700397
Nicolas Geoffray7642cfc2015-02-26 10:56:09 +0000398 // Returns whether the given exception was thrown by the current Java method being executed
399 // (Note that this includes native Java methods).
400 bool IsExceptionThrownByCurrentMethod(mirror::Throwable* exception) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700401 SHARED_REQUIRES(Locks::mutator_lock_);
Nicolas Geoffray7642cfc2015-02-26 10:56:09 +0000402
Mathieu Chartiere401d142015-04-22 13:56:20 -0700403 void SetTopOfStack(ArtMethod** top_method) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700404 tlsPtr_.managed_stack.SetTopQuickFrame(top_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700405 }
406
Jeff Hao11ffc2d2013-02-01 11:52:17 -0800407 void SetTopOfShadowStack(ShadowFrame* top) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700408 tlsPtr_.managed_stack.SetTopShadowFrame(top);
Jeff Hao11ffc2d2013-02-01 11:52:17 -0800409 }
410
Ian Rogers0399dde2012-06-06 17:09:28 -0700411 bool HasManagedStack() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700412 return (tlsPtr_.managed_stack.GetTopQuickFrame() != nullptr) ||
413 (tlsPtr_.managed_stack.GetTopShadowFrame() != nullptr);
Ian Rogersbdb03912011-09-14 00:55:44 -0700414 }
415
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700416 // If 'msg' is null, no detail message is set.
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000417 void ThrowNewException(const char* exception_class_descriptor, const char* msg)
Mathieu Chartiered8990a2015-07-23 14:11:16 -0700418 SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700419
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700420 // If 'msg' is null, no detail message is set. An exception must be pending, and will be
Elliott Hughesa4f94742012-05-29 16:28:38 -0700421 // used as the new exception's cause.
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000422 void ThrowNewWrappedException(const char* exception_class_descriptor, const char* msg)
Mathieu Chartiered8990a2015-07-23 14:11:16 -0700423 SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughesa4f94742012-05-29 16:28:38 -0700424
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000425 void ThrowNewExceptionF(const char* exception_class_descriptor, const char* fmt, ...)
426 __attribute__((format(printf, 3, 4)))
Mathieu Chartiered8990a2015-07-23 14:11:16 -0700427 SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughesa5b897e2011-08-16 11:33:06 -0700428
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000429 void ThrowNewExceptionV(const char* exception_class_descriptor, const char* fmt, va_list ap)
Mathieu Chartiered8990a2015-07-23 14:11:16 -0700430 SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700431
Elliott Hughes2ced6a52011-10-16 18:44:48 -0700432 // OutOfMemoryError is special, because we need to pre-allocate an instance.
Elliott Hughes8a8b9cb2012-04-13 18:29:22 -0700433 // Only the GC should call this.
Mathieu Chartiered8990a2015-07-23 14:11:16 -0700434 void ThrowOutOfMemoryError(const char* msg) SHARED_REQUIRES(Locks::mutator_lock_)
435 REQUIRES(!Roles::uninterruptible_);
Elliott Hughes79082e32011-08-25 12:07:32 -0700436
Elliott Hughesbe759c62011-09-08 19:38:21 -0700437 static void Startup();
Elliott Hughes038a8062011-09-18 14:12:41 -0700438 static void FinishStartup();
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700439 static void Shutdown();
Carl Shapirob5573532011-07-12 18:22:59 -0700440
Ian Rogersb033c752011-07-20 12:22:35 -0700441 // JNI methods
Elliott Hughes69f5bc62011-08-24 09:26:14 -0700442 JNIEnvExt* GetJniEnv() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700443 return tlsPtr_.jni_env;
Ian Rogersb033c752011-07-20 12:22:35 -0700444 }
445
Ian Rogers408f79a2011-08-23 18:22:33 -0700446 // Convert a jobject into a Object*
Mathieu Chartier90443472015-07-16 20:32:27 -0700447 mirror::Object* DecodeJObject(jobject obj) const SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersb033c752011-07-20 12:22:35 -0700448
Mathieu Chartier90443472015-07-16 20:32:27 -0700449 mirror::Object* GetMonitorEnterObject() const SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700450 return tlsPtr_.monitor_enter_object;
451 }
452
Mathieu Chartier90443472015-07-16 20:32:27 -0700453 void SetMonitorEnterObject(mirror::Object* obj) SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700454 tlsPtr_.monitor_enter_object = obj;
455 }
456
Elliott Hughes8daa0922011-09-11 13:46:25 -0700457 // Implements java.lang.Thread.interrupted.
Mathieu Chartier90443472015-07-16 20:32:27 -0700458 bool Interrupted() REQUIRES(!*wait_mutex_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700459 // Implements java.lang.Thread.isInterrupted.
Mathieu Chartier90443472015-07-16 20:32:27 -0700460 bool IsInterrupted() REQUIRES(!*wait_mutex_);
461 bool IsInterruptedLocked() REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700462 return interrupted_;
463 }
Mathieu Chartier90443472015-07-16 20:32:27 -0700464 void Interrupt(Thread* self) REQUIRES(!*wait_mutex_);
465 void SetInterruptedLocked(bool i) REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700466 interrupted_ = i;
467 }
Mathieu Chartier90443472015-07-16 20:32:27 -0700468 void Notify() REQUIRES(!*wait_mutex_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700469
470 private:
Mathieu Chartier90443472015-07-16 20:32:27 -0700471 void NotifyLocked(Thread* self) REQUIRES(wait_mutex_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700472
473 public:
474 Mutex* GetWaitMutex() const LOCK_RETURNED(wait_mutex_) {
475 return wait_mutex_;
476 }
477
Mathieu Chartier90443472015-07-16 20:32:27 -0700478 ConditionVariable* GetWaitConditionVariable() const REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700479 return wait_cond_;
480 }
481
Mathieu Chartier90443472015-07-16 20:32:27 -0700482 Monitor* GetWaitMonitor() const REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700483 return wait_monitor_;
484 }
485
Mathieu Chartier90443472015-07-16 20:32:27 -0700486 void SetWaitMonitor(Monitor* mon) REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700487 wait_monitor_ = mon;
488 }
489
Ian Rogersdd7624d2014-03-14 17:43:00 -0700490 // Waiter link-list support.
491 Thread* GetWaitNext() const {
492 return tlsPtr_.wait_next;
493 }
494
495 void SetWaitNext(Thread* next) {
496 tlsPtr_.wait_next = next;
497 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700498
Ian Rogers68d8b422014-07-17 11:09:10 -0700499 jobject GetClassLoaderOverride() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700500 return tlsPtr_.class_loader_override;
buzbeec143c552011-08-20 17:38:58 -0700501 }
502
Ian Rogers68d8b422014-07-17 11:09:10 -0700503 void SetClassLoaderOverride(jobject class_loader_override);
buzbeec143c552011-08-20 17:38:58 -0700504
Ian Rogersaaa20802011-09-11 21:47:37 -0700505 // Create the internal representation of a stack trace, that is more time
Sebastien Hertzee1d79a2014-02-21 15:46:30 +0100506 // and space efficient to compute than the StackTraceElement[].
507 template<bool kTransactionActive>
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700508 jobject CreateInternalStackTrace(const ScopedObjectAccessAlreadyRunnable& soa) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700509 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersaaa20802011-09-11 21:47:37 -0700510
Elliott Hughes01158d72011-09-19 19:47:10 -0700511 // Convert an internal stack trace representation (returned by CreateInternalStackTrace) to a
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700512 // StackTraceElement[]. If output_array is null, a new array is created, otherwise as many
513 // frames as will fit are written into the given array. If stack_depth is non-null, it's updated
Elliott Hughes01158d72011-09-19 19:47:10 -0700514 // with the number of valid frames in the returned array.
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700515 static jobjectArray InternalStackTraceToStackTraceElementArray(
516 const ScopedObjectAccessAlreadyRunnable& soa, jobject internal,
517 jobjectArray output_array = nullptr, int* stack_depth = nullptr)
Mathieu Chartier90443472015-07-16 20:32:27 -0700518 SHARED_REQUIRES(Locks::mutator_lock_);
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700519
Mingyao Yang99170c62015-07-06 11:10:37 -0700520 bool HasDebuggerShadowFrames() const {
521 return tlsPtr_.frame_id_to_shadow_frame != nullptr;
522 }
523
Mathieu Chartier90443472015-07-16 20:32:27 -0700524 void VisitRoots(RootVisitor* visitor) SHARED_REQUIRES(Locks::mutator_lock_);
Elliott Hughes410c0c82011-09-01 17:58:25 -0700525
Mathieu Chartier90443472015-07-16 20:32:27 -0700526 ALWAYS_INLINE void VerifyStack() SHARED_REQUIRES(Locks::mutator_lock_);
jeffhao25045522012-03-13 19:34:37 -0700527
Elliott Hughesbe759c62011-09-08 19:38:21 -0700528 //
529 // Offsets of various members of native Thread class, used by compiled code.
530 //
531
Ian Rogersdd7624d2014-03-14 17:43:00 -0700532 template<size_t pointer_size>
533 static ThreadOffset<pointer_size> ThinLockIdOffset() {
534 return ThreadOffset<pointer_size>(
535 OFFSETOF_MEMBER(Thread, tls32_) +
536 OFFSETOF_MEMBER(tls_32bit_sized_values, thin_lock_thread_id));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700537 }
538
Ian Rogersdd7624d2014-03-14 17:43:00 -0700539 template<size_t pointer_size>
540 static ThreadOffset<pointer_size> ThreadFlagsOffset() {
541 return ThreadOffset<pointer_size>(
542 OFFSETOF_MEMBER(Thread, tls32_) +
543 OFFSETOF_MEMBER(tls_32bit_sized_values, state_and_flags));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700544 }
545
Ian Rogersdd7624d2014-03-14 17:43:00 -0700546 private:
547 template<size_t pointer_size>
548 static ThreadOffset<pointer_size> ThreadOffsetFromTlsPtr(size_t tls_ptr_offset) {
549 size_t base = OFFSETOF_MEMBER(Thread, tlsPtr_);
550 size_t scale;
551 size_t shrink;
552 if (pointer_size == sizeof(void*)) {
553 scale = 1;
554 shrink = 1;
555 } else if (pointer_size > sizeof(void*)) {
556 scale = pointer_size / sizeof(void*);
557 shrink = 1;
558 } else {
559 DCHECK_GT(sizeof(void*), pointer_size);
560 scale = 1;
561 shrink = sizeof(void*) / pointer_size;
562 }
563 return ThreadOffset<pointer_size>(base + ((tls_ptr_offset * scale) / shrink));
Ian Rogers07ec8e12012-12-01 01:26:51 -0800564 }
565
Ian Rogersdd7624d2014-03-14 17:43:00 -0700566 public:
Jeff Hao848f70a2014-01-15 13:49:50 -0800567 static uint32_t QuickEntryPointOffsetWithSize(size_t quick_entrypoint_offset,
568 size_t pointer_size) {
569 DCHECK(pointer_size == 4 || pointer_size == 8) << pointer_size;
570 if (pointer_size == 4) {
571 return QuickEntryPointOffset<4>(quick_entrypoint_offset).Uint32Value();
572 } else {
573 return QuickEntryPointOffset<8>(quick_entrypoint_offset).Uint32Value();
574 }
575 }
576
Ian Rogersdd7624d2014-03-14 17:43:00 -0700577 template<size_t pointer_size>
578 static ThreadOffset<pointer_size> QuickEntryPointOffset(size_t quick_entrypoint_offset) {
579 return ThreadOffsetFromTlsPtr<pointer_size>(
580 OFFSETOF_MEMBER(tls_ptr_sized_values, quick_entrypoints) + quick_entrypoint_offset);
Elliott Hughesbe759c62011-09-08 19:38:21 -0700581 }
582
Ian Rogersdd7624d2014-03-14 17:43:00 -0700583 template<size_t pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700584 static ThreadOffset<pointer_size> JniEntryPointOffset(size_t jni_entrypoint_offset) {
585 return ThreadOffsetFromTlsPtr<pointer_size>(
586 OFFSETOF_MEMBER(tls_ptr_sized_values, jni_entrypoints) + jni_entrypoint_offset);
Elliott Hughesbe759c62011-09-08 19:38:21 -0700587 }
588
Ian Rogersdd7624d2014-03-14 17:43:00 -0700589 template<size_t pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700590 static ThreadOffset<pointer_size> SelfOffset() {
591 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, self));
592 }
593
594 template<size_t pointer_size>
595 static ThreadOffset<pointer_size> ExceptionOffset() {
596 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, exception));
597 }
598
599 template<size_t pointer_size>
600 static ThreadOffset<pointer_size> PeerOffset() {
601 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, opeer));
602 }
603
604
605 template<size_t pointer_size>
606 static ThreadOffset<pointer_size> CardTableOffset() {
607 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, card_table));
608 }
609
610 template<size_t pointer_size>
611 static ThreadOffset<pointer_size> ThreadSuspendTriggerOffset() {
612 return ThreadOffsetFromTlsPtr<pointer_size>(
613 OFFSETOF_MEMBER(tls_ptr_sized_values, suspend_trigger));
Dave Allisonb373e092014-02-20 16:06:36 -0800614 }
615
Hiroshi Yamauchie01a5202015-03-19 12:35:04 -0700616 template<size_t pointer_size>
617 static ThreadOffset<pointer_size> ThreadLocalPosOffset() {
618 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, thread_local_pos));
619 }
620
621 template<size_t pointer_size>
622 static ThreadOffset<pointer_size> ThreadLocalEndOffset() {
623 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, thread_local_end));
624 }
625
626 template<size_t pointer_size>
627 static ThreadOffset<pointer_size> ThreadLocalObjectsOffset() {
628 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, thread_local_objects));
629 }
630
Hiroshi Yamauchidc412b62015-10-15 12:26:57 -0700631 template<size_t pointer_size>
632 static ThreadOffset<pointer_size> RosAllocRunsOffset() {
633 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
634 rosalloc_runs));
635 }
636
637 template<size_t pointer_size>
638 static ThreadOffset<pointer_size> ThreadLocalAllocStackTopOffset() {
639 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
640 thread_local_alloc_stack_top));
641 }
642
643 template<size_t pointer_size>
644 static ThreadOffset<pointer_size> ThreadLocalAllocStackEndOffset() {
645 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
646 thread_local_alloc_stack_end));
647 }
648
Ian Rogers932746a2011-09-22 18:57:50 -0700649 // Size of stack less any space reserved for stack overflow
jeffhaod7521322012-11-21 15:38:24 -0800650 size_t GetStackSize() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700651 return tlsPtr_.stack_size - (tlsPtr_.stack_end - tlsPtr_.stack_begin);
Ian Rogers932746a2011-09-22 18:57:50 -0700652 }
653
Ian Rogers13735952014-10-08 12:43:28 -0700654 uint8_t* GetStackEndForInterpreter(bool implicit_overflow_check) const {
Nicolas Geoffray535a3fb2014-07-22 15:17:38 +0100655 if (implicit_overflow_check) {
656 // The interpreter needs the extra overflow bytes that stack_end does
657 // not include.
658 return tlsPtr_.stack_end + GetStackOverflowReservedBytes(kRuntimeISA);
659 } else {
660 return tlsPtr_.stack_end;
661 }
662 }
663
Ian Rogers13735952014-10-08 12:43:28 -0700664 uint8_t* GetStackEnd() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700665 return tlsPtr_.stack_end;
jeffhaod7521322012-11-21 15:38:24 -0800666 }
667
Ian Rogers932746a2011-09-22 18:57:50 -0700668 // Set the stack end to that to be used during a stack overflow
Mathieu Chartier90443472015-07-16 20:32:27 -0700669 void SetStackEndForStackOverflow() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers932746a2011-09-22 18:57:50 -0700670
671 // Set the stack end to that to be used during regular execution
Dave Allisonb090a182014-08-14 17:02:48 +0000672 void ResetDefaultStackEnd() {
Ian Rogers932746a2011-09-22 18:57:50 -0700673 // Our stacks grow down, so we want stack_end_ to be near there, but reserving enough room
674 // to throw a StackOverflowError.
Dave Allisonb090a182014-08-14 17:02:48 +0000675 tlsPtr_.stack_end = tlsPtr_.stack_begin + GetStackOverflowReservedBytes(kRuntimeISA);
Ian Rogers932746a2011-09-22 18:57:50 -0700676 }
677
Dave Allisonf9439142014-03-27 15:10:22 -0700678 // Install the protected region for implicit stack checks.
Dave Allison648d7112014-07-25 16:15:27 -0700679 void InstallImplicitProtection();
Dave Allisonf9439142014-03-27 15:10:22 -0700680
Ian Rogers120f1c72012-09-28 17:17:10 -0700681 bool IsHandlingStackOverflow() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700682 return tlsPtr_.stack_end == tlsPtr_.stack_begin;
Ian Rogers120f1c72012-09-28 17:17:10 -0700683 }
684
Ian Rogersdd7624d2014-03-14 17:43:00 -0700685 template<size_t pointer_size>
686 static ThreadOffset<pointer_size> StackEndOffset() {
687 return ThreadOffsetFromTlsPtr<pointer_size>(
688 OFFSETOF_MEMBER(tls_ptr_sized_values, stack_end));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700689 }
690
Ian Rogersdd7624d2014-03-14 17:43:00 -0700691 template<size_t pointer_size>
692 static ThreadOffset<pointer_size> JniEnvOffset() {
693 return ThreadOffsetFromTlsPtr<pointer_size>(
694 OFFSETOF_MEMBER(tls_ptr_sized_values, jni_env));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700695 }
696
Ian Rogersdd7624d2014-03-14 17:43:00 -0700697 template<size_t pointer_size>
698 static ThreadOffset<pointer_size> TopOfManagedStackOffset() {
699 return ThreadOffsetFromTlsPtr<pointer_size>(
700 OFFSETOF_MEMBER(tls_ptr_sized_values, managed_stack) +
701 ManagedStack::TopQuickFrameOffset());
Elliott Hughesbe759c62011-09-08 19:38:21 -0700702 }
703
Ian Rogers0399dde2012-06-06 17:09:28 -0700704 const ManagedStack* GetManagedStack() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700705 return &tlsPtr_.managed_stack;
Ian Rogers0399dde2012-06-06 17:09:28 -0700706 }
707
708 // Linked list recording fragments of managed stack.
709 void PushManagedStackFragment(ManagedStack* fragment) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700710 tlsPtr_.managed_stack.PushManagedStackFragment(fragment);
Ian Rogers0399dde2012-06-06 17:09:28 -0700711 }
712 void PopManagedStackFragment(const ManagedStack& fragment) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700713 tlsPtr_.managed_stack.PopManagedStackFragment(fragment);
Ian Rogers0399dde2012-06-06 17:09:28 -0700714 }
715
716 ShadowFrame* PushShadowFrame(ShadowFrame* new_top_frame) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700717 return tlsPtr_.managed_stack.PushShadowFrame(new_top_frame);
TDYa127de479be2012-05-31 08:03:26 -0700718 }
719
720 ShadowFrame* PopShadowFrame() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700721 return tlsPtr_.managed_stack.PopShadowFrame();
TDYa127de479be2012-05-31 08:03:26 -0700722 }
Logan Chienf7ad17e2012-03-15 03:10:03 +0800723
Ian Rogersdd7624d2014-03-14 17:43:00 -0700724 template<size_t pointer_size>
725 static ThreadOffset<pointer_size> TopShadowFrameOffset() {
726 return ThreadOffsetFromTlsPtr<pointer_size>(
727 OFFSETOF_MEMBER(tls_ptr_sized_values, managed_stack) +
728 ManagedStack::TopShadowFrameOffset());
TDYa127d668a062012-04-13 12:36:57 -0700729 }
730
Ian Rogersef7d42f2014-01-06 12:55:46 -0800731 // Number of references allocated in JNI ShadowFrames on this thread.
Mathieu Chartier90443472015-07-16 20:32:27 -0700732 size_t NumJniShadowFrameReferences() const SHARED_REQUIRES(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700733 return tlsPtr_.managed_stack.NumJniShadowFrameReferences();
Ian Rogers0399dde2012-06-06 17:09:28 -0700734 }
735
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700736 // Number of references in handle scope on this thread.
737 size_t NumHandleReferences();
Ian Rogers0399dde2012-06-06 17:09:28 -0700738
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700739 // Number of references allocated in handle scopes & JNI shadow frames on this thread.
Mathieu Chartier90443472015-07-16 20:32:27 -0700740 size_t NumStackReferences() SHARED_REQUIRES(Locks::mutator_lock_) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700741 return NumHandleReferences() + NumJniShadowFrameReferences();
Andreas Gampec8ccf682014-09-29 20:07:43 -0700742 }
Ian Rogers0399dde2012-06-06 17:09:28 -0700743
744 // Is the given obj in this thread's stack indirect reference table?
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700745 bool HandleScopeContains(jobject obj) const;
Ian Rogers0399dde2012-06-06 17:09:28 -0700746
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700747 void HandleScopeVisitRoots(RootVisitor* visitor, uint32_t thread_id)
Mathieu Chartier90443472015-07-16 20:32:27 -0700748 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700749
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700750 HandleScope* GetTopHandleScope() {
751 return tlsPtr_.top_handle_scope;
Ian Rogers1f539342012-10-03 21:09:42 -0700752 }
753
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700754 void PushHandleScope(HandleScope* handle_scope) {
Ian Rogers59c07062014-10-10 13:03:39 -0700755 DCHECK_EQ(handle_scope->GetLink(), tlsPtr_.top_handle_scope);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700756 tlsPtr_.top_handle_scope = handle_scope;
757 }
758
759 HandleScope* PopHandleScope() {
760 HandleScope* handle_scope = tlsPtr_.top_handle_scope;
761 DCHECK(handle_scope != nullptr);
762 tlsPtr_.top_handle_scope = tlsPtr_.top_handle_scope->GetLink();
763 return handle_scope;
Ian Rogers1f539342012-10-03 21:09:42 -0700764 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700765
Ian Rogersdd7624d2014-03-14 17:43:00 -0700766 template<size_t pointer_size>
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700767 static ThreadOffset<pointer_size> TopHandleScopeOffset() {
768 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
769 top_handle_scope));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700770 }
771
Ian Rogersdd7624d2014-03-14 17:43:00 -0700772 DebugInvokeReq* GetInvokeReq() const {
773 return tlsPtr_.debug_invoke_req;
Elliott Hughes475fc232011-10-25 15:00:35 -0700774 }
775
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100776 SingleStepControl* GetSingleStepControl() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700777 return tlsPtr_.single_step_control;
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100778 }
779
Sebastien Hertz1558b572015-02-25 15:05:59 +0100780 // Indicates whether this thread is ready to invoke a method for debugging. This
781 // is only true if the thread has been suspended by a debug event.
782 bool IsReadyForDebugInvoke() const {
783 return tls32_.ready_for_debug_invoke;
784 }
785
786 void SetReadyForDebugInvoke(bool ready) {
787 tls32_.ready_for_debug_invoke = ready;
788 }
789
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200790 bool IsDebugMethodEntry() const {
791 return tls32_.debug_method_entry_;
792 }
793
794 void SetDebugMethodEntry() {
795 tls32_.debug_method_entry_ = true;
796 }
797
798 void ClearDebugMethodEntry() {
799 tls32_.debug_method_entry_ = false;
800 }
801
Hiroshi Yamauchi00370822015-08-18 14:47:25 -0700802 bool GetIsGcMarking() const {
803 CHECK(kUseReadBarrier);
804 return tls32_.is_gc_marking;
805 }
806
807 void SetIsGcMarking(bool is_marking) {
808 CHECK(kUseReadBarrier);
809 tls32_.is_gc_marking = is_marking;
810 }
811
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -0700812 bool GetWeakRefAccessEnabled() const {
813 CHECK(kUseReadBarrier);
814 return tls32_.weak_ref_access_enabled;
815 }
816
817 void SetWeakRefAccessEnabled(bool enabled) {
818 CHECK(kUseReadBarrier);
819 tls32_.weak_ref_access_enabled = enabled;
820 }
821
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100822 // Activates single step control for debugging. The thread takes the
823 // ownership of the given SingleStepControl*. It is deleted by a call
824 // to DeactivateSingleStepControl or upon thread destruction.
825 void ActivateSingleStepControl(SingleStepControl* ssc);
826
827 // Deactivates single step control for debugging.
828 void DeactivateSingleStepControl();
829
Sebastien Hertz1558b572015-02-25 15:05:59 +0100830 // Sets debug invoke request for debugging. When the thread is resumed,
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200831 // it executes the method described by this request then sends the reply
832 // before suspending itself. The thread takes the ownership of the given
833 // DebugInvokeReq*. It is deleted by a call to ClearDebugInvokeReq.
Sebastien Hertz1558b572015-02-25 15:05:59 +0100834 void SetDebugInvokeReq(DebugInvokeReq* req);
835
836 // Clears debug invoke request for debugging. When the thread completes
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200837 // method invocation, it deletes its debug invoke request and suspends
838 // itself.
Sebastien Hertz1558b572015-02-25 15:05:59 +0100839 void ClearDebugInvokeReq();
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100840
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200841 // Returns the fake exception used to activate deoptimization.
842 static mirror::Throwable* GetDeoptimizationException() {
843 return reinterpret_cast<mirror::Throwable*>(-1);
844 }
845
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700846 // Currently deoptimization invokes verifier which can trigger class loading
847 // and execute Java code, so there might be nested deoptimizations happening.
848 // We need to save the ongoing deoptimization shadow frames and return
849 // values on stacks.
Sebastien Hertz07474662015-08-25 15:12:33 +0000850 void PushDeoptimizationContext(const JValue& return_value, bool is_reference,
851 mirror::Throwable* exception)
852 SHARED_REQUIRES(Locks::mutator_lock_);
853 void PopDeoptimizationContext(JValue* result, mirror::Throwable** exception)
854 SHARED_REQUIRES(Locks::mutator_lock_);
855 void AssertHasDeoptimizationContext()
856 SHARED_REQUIRES(Locks::mutator_lock_);
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700857 void PushStackedShadowFrame(ShadowFrame* sf, StackedShadowFrameType type);
Andreas Gampe639bdd12015-06-03 11:22:45 -0700858 ShadowFrame* PopStackedShadowFrame(StackedShadowFrameType type, bool must_be_present = true);
Andreas Gampe2a0d4ec2014-06-02 22:05:22 -0700859
Mingyao Yang99170c62015-07-06 11:10:37 -0700860 // For debugger, find the shadow frame that corresponds to a frame id.
861 // Or return null if there is none.
862 ShadowFrame* FindDebuggerShadowFrame(size_t frame_id)
863 SHARED_REQUIRES(Locks::mutator_lock_);
864 // For debugger, find the bool array that keeps track of the updated vreg set
865 // for a frame id.
866 bool* GetUpdatedVRegFlags(size_t frame_id) SHARED_REQUIRES(Locks::mutator_lock_);
867 // For debugger, find the shadow frame that corresponds to a frame id. If
868 // one doesn't exist yet, create one and track it in frame_id_to_shadow_frame.
869 ShadowFrame* FindOrCreateDebuggerShadowFrame(size_t frame_id,
870 uint32_t num_vregs,
871 ArtMethod* method,
872 uint32_t dex_pc)
873 SHARED_REQUIRES(Locks::mutator_lock_);
874
875 // Delete the entry that maps from frame_id to shadow_frame.
876 void RemoveDebuggerShadowFrameMapping(size_t frame_id)
877 SHARED_REQUIRES(Locks::mutator_lock_);
878
Ian Rogers62d6c772013-02-27 08:32:07 -0800879 std::deque<instrumentation::InstrumentationStackFrame>* GetInstrumentationStack() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700880 return tlsPtr_.instrumentation_stack;
jeffhaoe343b762011-12-05 16:36:44 -0800881 }
882
Mathieu Chartiere401d142015-04-22 13:56:20 -0700883 std::vector<ArtMethod*>* GetStackTraceSample() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700884 return tlsPtr_.stack_trace_sample;
Jeff Hao5ce4b172013-08-16 16:27:18 -0700885 }
886
Mathieu Chartiere401d142015-04-22 13:56:20 -0700887 void SetStackTraceSample(std::vector<ArtMethod*>* sample) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700888 tlsPtr_.stack_trace_sample = sample;
Jeff Hao5ce4b172013-08-16 16:27:18 -0700889 }
890
891 uint64_t GetTraceClockBase() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700892 return tls64_.trace_clock_base;
Jeff Hao5ce4b172013-08-16 16:27:18 -0700893 }
894
895 void SetTraceClockBase(uint64_t clock_base) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700896 tls64_.trace_clock_base = clock_base;
Jeff Hao5ce4b172013-08-16 16:27:18 -0700897 }
898
Ian Rogers81d425b2012-09-27 16:03:43 -0700899 BaseMutex* GetHeldMutex(LockLevel level) const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700900 return tlsPtr_.held_mutexes[level];
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700901 }
902
Ian Rogers81d425b2012-09-27 16:03:43 -0700903 void SetHeldMutex(LockLevel level, BaseMutex* mutex) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700904 tlsPtr_.held_mutexes[level] = mutex;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700905 }
Elliott Hughesffb465f2012-03-01 18:46:05 -0800906
Mathieu Chartier752a0e62013-06-27 11:03:27 -0700907 void RunCheckpointFunction();
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700908
Yu Lieac44242015-06-29 10:50:03 +0800909 bool PassActiveSuspendBarriers(Thread* self)
Mathieu Chartier90443472015-07-16 20:32:27 -0700910 REQUIRES(!Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +0800911
912 void ClearSuspendBarrier(AtomicInteger* target)
Mathieu Chartier90443472015-07-16 20:32:27 -0700913 REQUIRES(Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +0800914
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700915 bool ReadFlag(ThreadFlag flag) const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700916 return (tls32_.state_and_flags.as_struct.flags & flag) != 0;
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700917 }
918
Jeff Hao9cec2472013-05-14 18:17:06 -0700919 bool TestAllFlags() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700920 return (tls32_.state_and_flags.as_struct.flags != 0);
Jeff Hao9cec2472013-05-14 18:17:06 -0700921 }
922
Ian Rogers8c1b5f72014-07-09 22:02:36 -0700923 void AtomicSetFlag(ThreadFlag flag) {
924 tls32_.state_and_flags.as_atomic_int.FetchAndOrSequentiallyConsistent(flag);
925 }
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700926
Ian Rogers8c1b5f72014-07-09 22:02:36 -0700927 void AtomicClearFlag(ThreadFlag flag) {
928 tls32_.state_and_flags.as_atomic_int.FetchAndAndSequentiallyConsistent(-1 ^ flag);
929 }
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700930
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -0700931 void ResetQuickAllocEntryPointsForThread();
932
Ian Rogersdd7624d2014-03-14 17:43:00 -0700933 // Returns the remaining space in the TLAB.
934 size_t TlabSize() const;
935 // Doesn't check that there is room.
936 mirror::Object* AllocTlab(size_t bytes);
Ian Rogers13735952014-10-08 12:43:28 -0700937 void SetTlab(uint8_t* start, uint8_t* end);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700938 bool HasTlab() const;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800939 uint8_t* GetTlabStart() {
940 return tlsPtr_.thread_local_start;
941 }
942 uint8_t* GetTlabPos() {
943 return tlsPtr_.thread_local_pos;
944 }
Elliott Hughes5d96a712012-06-28 12:24:27 -0700945
Ian Rogersdd7624d2014-03-14 17:43:00 -0700946 // Remove the suspend trigger for this thread by making the suspend_trigger_ TLS value
947 // equal to a valid pointer.
948 // TODO: does this need to atomic? I don't think so.
949 void RemoveSuspendTrigger() {
950 tlsPtr_.suspend_trigger = reinterpret_cast<uintptr_t*>(&tlsPtr_.suspend_trigger);
951 }
952
953 // Trigger a suspend check by making the suspend_trigger_ TLS value an invalid pointer.
954 // The next time a suspend check is done, it will load from the value at this address
955 // and trigger a SIGSEGV.
956 void TriggerSuspend() {
957 tlsPtr_.suspend_trigger = nullptr;
958 }
959
960
961 // Push an object onto the allocation stack.
Mathieu Chartiercb535da2015-01-23 13:50:03 -0800962 bool PushOnThreadLocalAllocationStack(mirror::Object* obj)
Mathieu Chartier90443472015-07-16 20:32:27 -0700963 SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700964
965 // Set the thread local allocation pointers to the given pointers.
Mathieu Chartiercb535da2015-01-23 13:50:03 -0800966 void SetThreadLocalAllocationStack(StackReference<mirror::Object>* start,
967 StackReference<mirror::Object>* end);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700968
969 // Resets the thread local allocation pointers.
970 void RevokeThreadLocalAllocationStack();
971
972 size_t GetThreadLocalBytesAllocated() const {
Mathieu Chartier14cc9be2014-07-11 10:26:37 -0700973 return tlsPtr_.thread_local_end - tlsPtr_.thread_local_start;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700974 }
975
976 size_t GetThreadLocalObjectsAllocated() const {
977 return tlsPtr_.thread_local_objects;
978 }
979
Ian Rogersdd7624d2014-03-14 17:43:00 -0700980 void* GetRosAllocRun(size_t index) const {
981 return tlsPtr_.rosalloc_runs[index];
982 }
983
984 void SetRosAllocRun(size_t index, void* run) {
985 tlsPtr_.rosalloc_runs[index] = run;
986 }
987
Dave Allison648d7112014-07-25 16:15:27 -0700988 void ProtectStack();
989 bool UnprotectStack();
990
991 void NoteSignalBeingHandled() {
992 if (tls32_.handling_signal_) {
993 LOG(FATAL) << "Detected signal while processing a signal";
994 }
995 tls32_.handling_signal_ = true;
996 }
997
998 void NoteSignalHandlerDone() {
999 tls32_.handling_signal_ = false;
1000 }
1001
Dave Allison8ce6b902014-08-26 11:07:58 -07001002 jmp_buf* GetNestedSignalState() {
1003 return tlsPtr_.nested_signal_state;
1004 }
1005
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001006 bool IsSuspendedAtSuspendCheck() const {
1007 return tls32_.suspended_at_suspend_check;
1008 }
1009
Mathieu Chartierd0ad2ee2015-03-31 14:59:59 -07001010 void PushVerifier(verifier::MethodVerifier* verifier);
1011 void PopVerifier(verifier::MethodVerifier* verifier);
Mathieu Chartier12d625f2015-03-13 11:33:37 -07001012
Jeff Hao848f70a2014-01-15 13:49:50 -08001013 void InitStringEntryPoints();
1014
Ian Rogersdd7624d2014-03-14 17:43:00 -07001015 private:
Ian Rogers52673ff2012-06-27 23:25:34 -07001016 explicit Thread(bool daemon);
Mathieu Chartier90443472015-07-16 20:32:27 -07001017 ~Thread() REQUIRES(!Locks::mutator_lock_, !Locks::thread_suspend_count_lock_);
Elliott Hughesc0f09332012-03-26 13:27:06 -07001018 void Destroy();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001019
Ian Rogers365c1022012-06-22 15:05:28 -07001020 void CreatePeer(const char* name, bool as_daemon, jobject thread_group);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001021
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01001022 template<bool kTransactionActive>
1023 void InitPeer(ScopedObjectAccess& soa, jboolean thread_is_daemon, jobject thread_group,
1024 jobject thread_name, jint thread_priority)
Mathieu Chartier90443472015-07-16 20:32:27 -07001025 SHARED_REQUIRES(Locks::mutator_lock_);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01001026
Ian Rogers62d6c772013-02-27 08:32:07 -08001027 // Avoid use, callers should use SetState. Used only by SignalCatcher::HandleSigQuit, ~Thread and
1028 // Dbg::Disconnected.
Ian Rogers474b6da2012-09-25 00:20:38 -07001029 ThreadState SetStateUnsafe(ThreadState new_state) {
1030 ThreadState old_state = GetState();
Mathieu Chartier8ac9c912015-10-01 15:58:41 -07001031 if (old_state == kRunnable && new_state != kRunnable) {
1032 // Need to run pending checkpoint and suspend barriers. Run checkpoints in runnable state in
1033 // case they need to use a ScopedObjectAccess. If we are holding the mutator lock and a SOA
1034 // attempts to TransitionFromSuspendedToRunnable, it results in a deadlock.
1035 TransitionToSuspendedAndRunCheckpoints(new_state);
1036 // Since we transitioned to a suspended state, check the pass barrier requests.
1037 PassActiveSuspendBarriers();
1038 } else {
1039 tls32_.state_and_flags.as_struct.state = new_state;
Yu Lieac44242015-06-29 10:50:03 +08001040 }
Ian Rogersc747cff2012-08-31 18:20:08 -07001041 return old_state;
1042 }
Ian Rogersc747cff2012-08-31 18:20:08 -07001043
Mathieu Chartier90443472015-07-16 20:32:27 -07001044 void VerifyStackImpl() SHARED_REQUIRES(Locks::mutator_lock_);
Ian Rogers04d7aa92013-03-16 14:29:17 -07001045
Mathieu Chartier90443472015-07-16 20:32:27 -07001046 void DumpState(std::ostream& os) const SHARED_REQUIRES(Locks::mutator_lock_);
Christopher Ferris6cff48f2014-01-26 21:36:13 -08001047 void DumpStack(std::ostream& os, BacktraceMap* backtrace_map = nullptr) const
Mathieu Chartier90443472015-07-16 20:32:27 -07001048 REQUIRES(!Locks::thread_suspend_count_lock_)
1049 SHARED_REQUIRES(Locks::mutator_lock_);
Elliott Hughesd92bec42011-09-02 17:04:36 -07001050
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001051 // Out-of-line conveniences for debugging in gdb.
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001052 static Thread* CurrentFromGdb(); // Like Thread::Current.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001053 // Like Thread::Dump(std::cerr).
Mathieu Chartier90443472015-07-16 20:32:27 -07001054 void DumpFromGdb() const SHARED_REQUIRES(Locks::mutator_lock_);
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001055
Elliott Hughes93e74e82011-09-13 11:07:03 -07001056 static void* CreateCallback(void* arg);
1057
Ian Rogerscfaa4552012-11-26 21:00:08 -08001058 void HandleUncaughtExceptions(ScopedObjectAccess& soa)
Mathieu Chartier90443472015-07-16 20:32:27 -07001059 SHARED_REQUIRES(Locks::mutator_lock_);
1060 void RemoveFromThreadGroup(ScopedObjectAccess& soa) SHARED_REQUIRES(Locks::mutator_lock_);
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001061
Andreas Gampe449357d2015-06-01 22:29:51 -07001062 // Initialize a thread.
1063 //
1064 // The third parameter is not mandatory. If given, the thread will use this JNIEnvExt. In case
1065 // Init succeeds, this means the thread takes ownership of it. If Init fails, it is the caller's
1066 // responsibility to destroy the given JNIEnvExt. If the parameter is null, Init will try to
1067 // create a JNIEnvExt on its own (and potentially fail at that stage, indicated by a return value
1068 // of false).
1069 bool Init(ThreadList*, JavaVMExt*, JNIEnvExt* jni_env_ext = nullptr)
Mathieu Chartier90443472015-07-16 20:32:27 -07001070 REQUIRES(Locks::runtime_shutdown_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07001071 void InitCardTable();
Ian Rogersb033c752011-07-20 12:22:35 -07001072 void InitCpu();
Alexei Zavjalov1efa0a92014-02-04 02:08:31 +07001073 void CleanupCpu();
Ian Rogers848871b2013-08-05 10:56:33 -07001074 void InitTlsEntryPoints();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -07001075 void InitTid();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -07001076 void InitPthreadKeySelf();
Ian Rogersf4d4da12014-11-11 16:10:33 -08001077 bool InitStackHwm();
Elliott Hughesbe759c62011-09-08 19:38:21 -07001078
Elliott Hughesd6a23bd2013-07-16 14:19:52 -07001079 void SetUpAlternateSignalStack();
1080 void TearDownAlternateSignalStack();
1081
Mathieu Chartier8ac9c912015-10-01 15:58:41 -07001082 ALWAYS_INLINE void TransitionToSuspendedAndRunCheckpoints(ThreadState new_state)
1083 REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_);
1084
1085 ALWAYS_INLINE void PassActiveSuspendBarriers()
1086 REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_);
1087
Ian Rogers474b6da2012-09-25 00:20:38 -07001088 // 32 bits of atomically changed state and flags. Keeping as 32 bits allows and atomic CAS to
1089 // change from being Suspended to Runnable without a suspend request occurring.
Chris Dearman59cde532013-12-04 18:53:49 -08001090 union PACKED(4) StateAndFlags {
1091 StateAndFlags() {}
Ian Rogersdf1ce912012-11-27 17:07:11 -08001092 struct PACKED(4) {
Ian Rogers30e173f2012-09-26 14:35:03 -07001093 // Bitfield of flag values. Must be changed atomically so that flag values aren't lost. See
1094 // ThreadFlags for bit field meanings.
1095 volatile uint16_t flags;
1096 // Holds the ThreadState. May be changed non-atomically between Suspended (ie not Runnable)
1097 // transitions. Changing to Runnable requires that the suspend_request be part of the atomic
1098 // operation. If a thread is suspended and a suspend_request is present, a thread may not
1099 // change to Runnable as a GC or other operation is in progress.
Ian Rogers01ae5802012-09-28 16:14:01 -07001100 volatile uint16_t state;
Ian Rogers30e173f2012-09-26 14:35:03 -07001101 } as_struct;
Ian Rogersb8e087e2014-07-09 21:12:06 -07001102 AtomicInteger as_atomic_int;
Ian Rogers01ae5802012-09-28 16:14:01 -07001103 volatile int32_t as_int;
Chris Dearman59cde532013-12-04 18:53:49 -08001104
1105 private:
1106 // gcc does not handle struct with volatile member assignments correctly.
1107 // See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47409
1108 DISALLOW_COPY_AND_ASSIGN(StateAndFlags);
Ian Rogers474b6da2012-09-25 00:20:38 -07001109 };
Andreas Gampe575e78c2014-11-03 23:41:03 -08001110 static_assert(sizeof(StateAndFlags) == sizeof(int32_t), "Weird state_and_flags size");
Ian Rogers474b6da2012-09-25 00:20:38 -07001111
Ian Rogersdd7624d2014-03-14 17:43:00 -07001112 static void ThreadExitCallback(void* arg);
Elliott Hughes5d96a712012-06-28 12:24:27 -07001113
Dave Allison0aded082013-11-07 13:15:11 -08001114 // Maximum number of checkpoint functions.
1115 static constexpr uint32_t kMaxCheckpoints = 3;
1116
Yu Lieac44242015-06-29 10:50:03 +08001117 // Maximum number of suspend barriers.
1118 static constexpr uint32_t kMaxSuspendBarriers = 3;
1119
Ian Rogersdd7624d2014-03-14 17:43:00 -07001120 // Has Thread::Startup been called?
1121 static bool is_started_;
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001122
Ian Rogersdd7624d2014-03-14 17:43:00 -07001123 // TLS key used to retrieve the Thread*.
1124 static pthread_key_t pthread_key_self_;
Ian Rogersa32a6fd2012-02-06 20:18:44 -08001125
Ian Rogersdd7624d2014-03-14 17:43:00 -07001126 // Used to notify threads that they should attempt to resume, they will suspend again if
1127 // their suspend count is > 0.
1128 static ConditionVariable* resume_cond_ GUARDED_BY(Locks::thread_suspend_count_lock_);
Dave Allisonb373e092014-02-20 16:06:36 -08001129
Ian Rogersdd7624d2014-03-14 17:43:00 -07001130 /***********************************************************************************************/
1131 // Thread local storage. Fields are grouped by size to enable 32 <-> 64 searching to account for
1132 // pointer size differences. To encourage shorter encoding, more frequently used values appear
1133 // first if possible.
1134 /***********************************************************************************************/
Elliott Hughes6a607ad2012-07-13 20:40:00 -07001135
Zuo Wangf37a88b2014-07-10 04:26:41 -07001136 struct PACKED(4) tls_32bit_sized_values {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001137 // We have no control over the size of 'bool', but want our boolean fields
1138 // to be 4-byte quantities.
1139 typedef uint32_t bool32_t;
Ian Rogers22f454c2012-09-08 11:06:29 -07001140
Ian Rogersdd7624d2014-03-14 17:43:00 -07001141 explicit tls_32bit_sized_values(bool is_daemon) :
1142 suspend_count(0), debug_suspend_count(0), thin_lock_thread_id(0), tid(0),
1143 daemon(is_daemon), throwing_OutOfMemoryError(false), no_thread_suspension(0),
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001144 thread_exit_check_count(0), handling_signal_(false),
Sebastien Hertz07474662015-08-25 15:12:33 +00001145 suspended_at_suspend_check(false), ready_for_debug_invoke(false),
1146 debug_method_entry_(false), is_gc_marking(false), weak_ref_access_enabled(true) {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001147 }
Dave Allisonb373e092014-02-20 16:06:36 -08001148
Ian Rogersdd7624d2014-03-14 17:43:00 -07001149 union StateAndFlags state_and_flags;
Andreas Gampe575e78c2014-11-03 23:41:03 -08001150 static_assert(sizeof(union StateAndFlags) == sizeof(int32_t),
1151 "Size of state_and_flags and int32 are different");
Dave Allisonb373e092014-02-20 16:06:36 -08001152
Ian Rogersdd7624d2014-03-14 17:43:00 -07001153 // A non-zero value is used to tell the current thread to enter a safe point
1154 // at the next poll.
1155 int suspend_count GUARDED_BY(Locks::thread_suspend_count_lock_);
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -07001156
Ian Rogersdd7624d2014-03-14 17:43:00 -07001157 // How much of 'suspend_count_' is by request of the debugger, used to set things right
1158 // when the debugger detaches. Must be <= suspend_count_.
1159 int debug_suspend_count GUARDED_BY(Locks::thread_suspend_count_lock_);
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001160
Ian Rogersdd7624d2014-03-14 17:43:00 -07001161 // Thin lock thread id. This is a small integer used by the thin lock implementation.
1162 // This is not to be confused with the native thread's tid, nor is it the value returned
1163 // by java.lang.Thread.getId --- this is a distinct value, used only for locking. One
1164 // important difference between this id and the ids visible to managed code is that these
1165 // ones get reused (to ensure that they fit in the number of bits available).
1166 uint32_t thin_lock_thread_id;
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001167
Ian Rogersdd7624d2014-03-14 17:43:00 -07001168 // System thread id.
1169 uint32_t tid;
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001170
Ian Rogersdd7624d2014-03-14 17:43:00 -07001171 // Is the thread a daemon?
1172 const bool32_t daemon;
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001173
Ian Rogersdd7624d2014-03-14 17:43:00 -07001174 // A boolean telling us whether we're recursively throwing OOME.
1175 bool32_t throwing_OutOfMemoryError;
1176
1177 // A positive value implies we're in a region where thread suspension isn't expected.
1178 uint32_t no_thread_suspension;
1179
1180 // How many times has our pthread key's destructor been called?
1181 uint32_t thread_exit_check_count;
Sebastien Hertz9f102032014-05-23 08:59:42 +02001182
Dave Allison648d7112014-07-25 16:15:27 -07001183 // True if signal is being handled by this thread.
1184 bool32_t handling_signal_;
1185
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001186 // True if the thread is suspended in FullSuspendCheck(). This is
1187 // used to distinguish runnable threads that are suspended due to
1188 // a normal suspend check from other threads.
1189 bool32_t suspended_at_suspend_check;
Sebastien Hertz1558b572015-02-25 15:05:59 +01001190
1191 // True if the thread has been suspended by a debugger event. This is
1192 // used to invoke method from the debugger which is only allowed when
1193 // the thread is suspended by an event.
1194 bool32_t ready_for_debug_invoke;
Sebastien Hertz9d6bf692015-04-10 12:12:33 +02001195
1196 // True if the thread enters a method. This is used to detect method entry
1197 // event for the debugger.
1198 bool32_t debug_method_entry_;
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001199
Hiroshi Yamauchi00370822015-08-18 14:47:25 -07001200 // True if the GC is in the marking phase. This is used for the CC collector only. This is
1201 // thread local so that we can simplify the logic to check for the fast path of read barriers of
1202 // GC roots.
1203 bool32_t is_gc_marking;
1204
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001205 // True if the thread is allowed to access a weak ref (Reference::GetReferent() and system
1206 // weaks) and to potentially mark an object alive/gray. This is used for concurrent reference
1207 // processing of the CC collector only. This is thread local so that we can enable/disable weak
1208 // ref access by using a checkpoint and avoid a race around the time weak ref access gets
1209 // disabled and concurrent reference processing begins (if weak ref access is disabled during a
1210 // pause, this is not an issue.) Other collectors use Runtime::DisallowNewSystemWeaks() and
1211 // ReferenceProcessor::EnableSlowPath().
1212 bool32_t weak_ref_access_enabled;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001213 } tls32_;
1214
1215 struct PACKED(8) tls_64bit_sized_values {
Sebastien Hertz07474662015-08-25 15:12:33 +00001216 tls_64bit_sized_values() : trace_clock_base(0) {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001217 }
1218
1219 // The clock base used for tracing.
1220 uint64_t trace_clock_base;
1221
Ian Rogersdd7624d2014-03-14 17:43:00 -07001222 RuntimeStats stats;
1223 } tls64_;
1224
1225 struct PACKED(4) tls_ptr_sized_values {
1226 tls_ptr_sized_values() : card_table(nullptr), exception(nullptr), stack_end(nullptr),
Andreas Gampe449357d2015-06-01 22:29:51 -07001227 managed_stack(), suspend_trigger(nullptr), jni_env(nullptr), tmp_jni_env(nullptr),
1228 self(nullptr), opeer(nullptr), jpeer(nullptr), stack_begin(nullptr), stack_size(0),
Ian Rogersdd7624d2014-03-14 17:43:00 -07001229 stack_trace_sample(nullptr), wait_next(nullptr), monitor_enter_object(nullptr),
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001230 top_handle_scope(nullptr), class_loader_override(nullptr), long_jump_context(nullptr),
Ian Rogersdd7624d2014-03-14 17:43:00 -07001231 instrumentation_stack(nullptr), debug_invoke_req(nullptr), single_step_control(nullptr),
Sebastien Hertz07474662015-08-25 15:12:33 +00001232 stacked_shadow_frame_record(nullptr), deoptimization_context_stack(nullptr),
Mingyao Yang99170c62015-07-06 11:10:37 -07001233 frame_id_to_shadow_frame(nullptr), name(nullptr), pthread_self(0),
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001234 last_no_thread_suspension_cause(nullptr), thread_local_start(nullptr),
Ian Rogersdd7624d2014-03-14 17:43:00 -07001235 thread_local_pos(nullptr), thread_local_end(nullptr), thread_local_objects(0),
Ian Rogers7b078e82014-09-10 14:44:24 -07001236 thread_local_alloc_stack_top(nullptr), thread_local_alloc_stack_end(nullptr),
Sebastien Hertzaa50d3a2015-08-25 15:25:41 +02001237 nested_signal_state(nullptr), flip_function(nullptr), method_verifier(nullptr),
1238 thread_local_mark_stack(nullptr) {
Mathieu Chartier12d625f2015-03-13 11:33:37 -07001239 std::fill(held_mutexes, held_mutexes + kLockLevelCount, nullptr);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001240 }
1241
1242 // The biased card table, see CardTable for details.
Ian Rogers13735952014-10-08 12:43:28 -07001243 uint8_t* card_table;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001244
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001245 // The pending exception or null.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001246 mirror::Throwable* exception;
1247
1248 // The end of this thread's stack. This is the lowest safely-addressable address on the stack.
1249 // We leave extra space so there's room for the code that throws StackOverflowError.
Ian Rogers13735952014-10-08 12:43:28 -07001250 uint8_t* stack_end;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001251
1252 // The top of the managed stack often manipulated directly by compiler generated code.
1253 ManagedStack managed_stack;
1254
1255 // In certain modes, setting this to 0 will trigger a SEGV and thus a suspend check. It is
1256 // normally set to the address of itself.
1257 uintptr_t* suspend_trigger;
1258
1259 // Every thread may have an associated JNI environment
1260 JNIEnvExt* jni_env;
1261
Andreas Gampe449357d2015-06-01 22:29:51 -07001262 // Temporary storage to transfer a pre-allocated JNIEnvExt from the creating thread to the
1263 // created thread.
1264 JNIEnvExt* tmp_jni_env;
1265
Ian Rogersdd7624d2014-03-14 17:43:00 -07001266 // Initialized to "this". On certain architectures (such as x86) reading off of Thread::Current
1267 // is easy but getting the address of Thread::Current is hard. This field can be read off of
1268 // Thread::Current to give the address.
1269 Thread* self;
1270
1271 // Our managed peer (an instance of java.lang.Thread). The jobject version is used during thread
1272 // start up, until the thread is registered and the local opeer_ is used.
1273 mirror::Object* opeer;
1274 jobject jpeer;
1275
1276 // The "lowest addressable byte" of the stack.
Ian Rogers13735952014-10-08 12:43:28 -07001277 uint8_t* stack_begin;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001278
1279 // Size of the stack.
1280 size_t stack_size;
1281
Ian Rogersdd7624d2014-03-14 17:43:00 -07001282 // Pointer to previous stack trace captured by sampling profiler.
Mathieu Chartiere401d142015-04-22 13:56:20 -07001283 std::vector<ArtMethod*>* stack_trace_sample;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001284
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001285 // The next thread in the wait set this thread is part of or null if not waiting.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001286 Thread* wait_next;
1287
1288 // If we're blocked in MonitorEnter, this is the object we're trying to lock.
1289 mirror::Object* monitor_enter_object;
1290
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001291 // Top of linked list of handle scopes or null for none.
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001292 HandleScope* top_handle_scope;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001293
1294 // Needed to get the right ClassLoader in JNI_OnLoad, but also
1295 // useful for testing.
Ian Rogers68d8b422014-07-17 11:09:10 -07001296 jobject class_loader_override;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001297
1298 // Thread local, lazily allocated, long jump context. Used to deliver exceptions.
1299 Context* long_jump_context;
1300
1301 // Additional stack used by method instrumentation to store method and return pc values.
1302 // Stored as a pointer since std::deque is not PACKED.
1303 std::deque<instrumentation::InstrumentationStackFrame>* instrumentation_stack;
1304
1305 // JDWP invoke-during-breakpoint support.
1306 DebugInvokeReq* debug_invoke_req;
1307
1308 // JDWP single-stepping support.
1309 SingleStepControl* single_step_control;
1310
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001311 // For gc purpose, a shadow frame record stack that keeps track of:
1312 // 1) shadow frames under construction.
1313 // 2) deoptimization shadow frames.
1314 StackedShadowFrameRecord* stacked_shadow_frame_record;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001315
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001316 // Deoptimization return value record stack.
Sebastien Hertz07474662015-08-25 15:12:33 +00001317 DeoptimizationContextRecord* deoptimization_context_stack;
Andreas Gampe2a0d4ec2014-06-02 22:05:22 -07001318
Mingyao Yang99170c62015-07-06 11:10:37 -07001319 // For debugger, a linked list that keeps the mapping from frame_id to shadow frame.
1320 // Shadow frames may be created before deoptimization happens so that the debugger can
1321 // set local values there first.
1322 FrameIdToShadowFrame* frame_id_to_shadow_frame;
1323
Ian Rogersdd7624d2014-03-14 17:43:00 -07001324 // A cached copy of the java.lang.Thread's name.
1325 std::string* name;
1326
1327 // A cached pthread_t for the pthread underlying this Thread*.
1328 pthread_t pthread_self;
1329
Ian Rogersdd7624d2014-03-14 17:43:00 -07001330 // If no_thread_suspension_ is > 0, what is causing that assertion.
1331 const char* last_no_thread_suspension_cause;
1332
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001333 // Pending checkpoint function or null if non-pending. Installation guarding by
Ian Rogersdd7624d2014-03-14 17:43:00 -07001334 // Locks::thread_suspend_count_lock_.
1335 Closure* checkpoint_functions[kMaxCheckpoints];
1336
Yu Lieac44242015-06-29 10:50:03 +08001337 // Pending barriers that require passing or NULL if non-pending. Installation guarding by
1338 // Locks::thread_suspend_count_lock_.
1339 // They work effectively as art::Barrier, but implemented directly using AtomicInteger and futex
1340 // to avoid additional cost of a mutex and a condition variable, as used in art::Barrier.
1341 AtomicInteger* active_suspend_barriers[kMaxSuspendBarriers];
1342
Ian Rogersdd7624d2014-03-14 17:43:00 -07001343 // Entrypoint function pointers.
1344 // TODO: move this to more of a global offset table model to avoid per-thread duplication.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001345 JniEntryPoints jni_entrypoints;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001346 QuickEntryPoints quick_entrypoints;
1347
1348 // Thread-local allocation pointer.
Ian Rogers13735952014-10-08 12:43:28 -07001349 uint8_t* thread_local_start;
1350 uint8_t* thread_local_pos;
1351 uint8_t* thread_local_end;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001352 size_t thread_local_objects;
1353
Mathieu Chartier0651d412014-04-29 14:37:57 -07001354 // There are RosAlloc::kNumThreadLocalSizeBrackets thread-local size brackets per thread.
Ian Rogerse63db272014-07-15 15:36:11 -07001355 void* rosalloc_runs[kNumRosAllocThreadLocalSizeBrackets];
Ian Rogersdd7624d2014-03-14 17:43:00 -07001356
1357 // Thread-local allocation stack data/routines.
Mathieu Chartiercb535da2015-01-23 13:50:03 -08001358 StackReference<mirror::Object>* thread_local_alloc_stack_top;
1359 StackReference<mirror::Object>* thread_local_alloc_stack_end;
Chao-ying Fu9e369312014-05-21 11:20:52 -07001360
1361 // Support for Mutex lock hierarchy bug detection.
1362 BaseMutex* held_mutexes[kLockLevelCount];
Dave Allison8ce6b902014-08-26 11:07:58 -07001363
1364 // Recorded thread state for nested signals.
1365 jmp_buf* nested_signal_state;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001366
1367 // The function used for thread flip.
1368 Closure* flip_function;
Mathieu Chartier12d625f2015-03-13 11:33:37 -07001369
1370 // Current method verifier, used for root marking.
1371 verifier::MethodVerifier* method_verifier;
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001372
1373 // Thread-local mark stack for the concurrent copying collector.
1374 gc::accounting::AtomicStack<mirror::Object>* thread_local_mark_stack;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001375 } tlsPtr_;
1376
1377 // Guards the 'interrupted_' and 'wait_monitor_' members.
1378 Mutex* wait_mutex_ DEFAULT_MUTEX_ACQUIRED_AFTER;
1379
1380 // Condition variable waited upon during a wait.
1381 ConditionVariable* wait_cond_ GUARDED_BY(wait_mutex_);
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001382 // Pointer to the monitor lock we're currently waiting on or null if not waiting.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001383 Monitor* wait_monitor_ GUARDED_BY(wait_mutex_);
1384
1385 // Thread "interrupted" status; stays raised until queried or thrown.
1386 bool interrupted_ GUARDED_BY(wait_mutex_);
1387
Mathieu Chartiere6da9af2013-12-16 11:54:42 -08001388 friend class Dbg; // For SetStateUnsafe.
Mathieu Chartier15d34022014-02-26 17:16:38 -08001389 friend class gc::collector::SemiSpace; // For getting stack traces.
Mathieu Chartier692fafd2013-11-29 17:24:40 -08001390 friend class Runtime; // For CreatePeer.
Ian Rogers5cf98192014-05-29 21:31:50 -07001391 friend class QuickExceptionHandler; // For dumping the stack.
Mathieu Chartier692fafd2013-11-29 17:24:40 -08001392 friend class ScopedThreadStateChange;
Mathieu Chartier119c6bd2014-05-09 14:11:47 -07001393 friend class StubTest; // For accessing entrypoints.
Mathieu Chartier692fafd2013-11-29 17:24:40 -08001394 friend class ThreadList; // For ~Thread and Destroy.
1395
Andreas Gampe4352b452014-06-04 18:59:01 -07001396 friend class EntrypointsOrderTest; // To test the order of tls entries.
1397
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001398 DISALLOW_COPY_AND_ASSIGN(Thread);
1399};
Ian Rogersbdb03912011-09-14 00:55:44 -07001400
Mathieu Chartier4e2cb092015-07-22 16:17:51 -07001401class SCOPED_CAPABILITY ScopedAssertNoThreadSuspension {
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001402 public:
Mathieu Chartier4e2cb092015-07-22 16:17:51 -07001403 ScopedAssertNoThreadSuspension(Thread* self, const char* cause) ACQUIRE(Roles::uninterruptible_)
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001404 : self_(self), old_cause_(self->StartAssertNoThreadSuspension(cause)) {
1405 }
Mathieu Chartier4e2cb092015-07-22 16:17:51 -07001406 ~ScopedAssertNoThreadSuspension() RELEASE(Roles::uninterruptible_) {
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001407 self_->EndAssertNoThreadSuspension(old_cause_);
1408 }
1409 Thread* Self() {
1410 return self_;
1411 }
1412
1413 private:
1414 Thread* const self_;
Ian Rogersf2247512014-12-02 16:17:08 -08001415 const char* const old_cause_;
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001416};
1417
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001418class ScopedStackedShadowFramePusher {
1419 public:
1420 ScopedStackedShadowFramePusher(Thread* self, ShadowFrame* sf, StackedShadowFrameType type)
1421 : self_(self), type_(type) {
1422 self_->PushStackedShadowFrame(sf, type);
1423 }
1424 ~ScopedStackedShadowFramePusher() {
1425 self_->PopStackedShadowFrame(type_);
1426 }
1427
1428 private:
1429 Thread* const self_;
1430 const StackedShadowFrameType type_;
1431
1432 DISALLOW_COPY_AND_ASSIGN(ScopedStackedShadowFramePusher);
1433};
1434
Elliott Hughes330304d2011-08-12 14:28:05 -07001435std::ostream& operator<<(std::ostream& os, const Thread& thread);
Sebastien Hertzf7958692015-06-09 14:09:14 +02001436std::ostream& operator<<(std::ostream& os, const StackedShadowFrameType& thread);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001437
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001438} // namespace art
1439
Brian Carlstromfc0e3212013-07-17 14:40:12 -07001440#endif // ART_RUNTIME_THREAD_H_