blob: 166ed217d02596bf332f15d0c4f4c721a83cd4ce [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"
Andreas Gampe542451c2016-07-26 09:02:02 -070031#include "base/enums.h"
Elliott Hughes76160052012-12-12 16:31:20 -080032#include "base/macros.h"
Ian Rogers719d1a32014-03-06 12:13:39 -080033#include "base/mutex.h"
Ian Rogers848871b2013-08-05 10:56:33 -070034#include "entrypoints/jni/jni_entrypoints.h"
Ian Rogers7655f292013-07-29 11:07:13 -070035#include "entrypoints/quick/quick_entrypoints.h"
Andreas Gampe2c19f5b2016-11-28 08:10:18 -080036#include "gc_root.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070037#include "globals.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070038#include "handle_scope.h"
Elliott Hughes956af0f2014-12-11 14:34:28 -080039#include "instrumentation.h"
Ian Rogers306057f2012-11-26 12:45:53 -080040#include "jvalue.h"
Mathieu Chartier83c8ee02014-01-28 14:50:23 -080041#include "object_callbacks.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070042#include "offsets.h"
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070043#include "runtime_stats.h"
Elliott Hughes68e76522011-10-05 13:22:16 -070044#include "stack.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080045#include "thread_state.h"
Ian Rogersb033c752011-07-20 12:22:35 -070046
Christopher Ferris6cff48f2014-01-26 21:36:13 -080047class BacktraceMap;
48
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070049namespace art {
50
Mathieu Chartier15d34022014-02-26 17:16:38 -080051namespace gc {
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -070052namespace accounting {
53 template<class T> class AtomicStack;
54} // namespace accounting
Mathieu Chartier15d34022014-02-26 17:16:38 -080055namespace collector {
Mingyao Yang98d1cc82014-05-15 17:02:16 -070056 class SemiSpace;
Mathieu Chartier15d34022014-02-26 17:16:38 -080057} // namespace collector
58} // namespace gc
59
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080060namespace mirror {
Ian Rogers848871b2013-08-05 10:56:33 -070061 class Array;
62 class Class;
63 class ClassLoader;
64 class Object;
65 template<class T> class ObjectArray;
66 template<class T> class PrimitiveArray;
67 typedef PrimitiveArray<int32_t> IntArray;
68 class StackTraceElement;
Vladimir Marko80afd022015-05-19 18:08:00 +010069 class String;
Ian Rogers848871b2013-08-05 10:56:33 -070070 class Throwable;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080071} // namespace mirror
Mathieu Chartier12d625f2015-03-13 11:33:37 -070072
73namespace verifier {
Nicolas Geoffray340dafa2016-11-18 16:03:10 +000074 class MethodVerifier;
75 class VerifierDeps;
Mathieu Chartier12d625f2015-03-13 11:33:37 -070076} // namespace verifier
77
Mathieu Chartiere401d142015-04-22 13:56:20 -070078class ArtMethod;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080079class BaseMutex;
80class ClassLinker;
Ian Rogers7a22fa62013-01-23 12:16:16 -080081class Closure;
Ian Rogersbdb03912011-09-14 00:55:44 -070082class Context;
Ian Rogers1b09b092012-08-20 15:35:52 -070083struct DebugInvokeReq;
Sebastien Hertz07474662015-08-25 15:12:33 +000084class DeoptimizationContextRecord;
Ian Rogers81d425b2012-09-27 16:03:43 -070085class DexFile;
Mingyao Yang99170c62015-07-06 11:10:37 -070086class FrameIdToShadowFrame;
Ian Rogersb48b9eb2014-02-28 16:20:21 -080087class JavaVMExt;
Ian Rogers81d425b2012-09-27 16:03:43 -070088struct JNIEnvExt;
Elliott Hughes8daa0922011-09-11 13:46:25 -070089class Monitor;
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -070090class ScopedObjectAccessAlreadyRunnable;
Logan Chienf7ad17e2012-03-15 03:10:03 +080091class ShadowFrame;
Sebastien Hertz597c4f02015-01-26 17:37:14 +010092class SingleStepControl;
Sebastien Hertzf7958692015-06-09 14:09:14 +020093class StackedShadowFrameRecord;
Brian Carlstrom40381fb2011-10-19 14:13:40 -070094class Thread;
95class ThreadList;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -070096
Elliott Hughes34e06962012-04-09 13:55:55 -070097// Thread priorities. These must match the Thread.MIN_PRIORITY,
98// Thread.NORM_PRIORITY, and Thread.MAX_PRIORITY constants.
99enum ThreadPriority {
100 kMinThreadPriority = 1,
101 kNormThreadPriority = 5,
102 kMaxThreadPriority = 10,
103};
104
Ian Rogers474b6da2012-09-25 00:20:38 -0700105enum ThreadFlag {
Ian Rogers50ffee22012-11-20 11:47:44 -0800106 kSuspendRequest = 1, // If set implies that suspend_count_ > 0 and the Thread should enter the
107 // safepoint handler.
Yu Lieac44242015-06-29 10:50:03 +0800108 kCheckpointRequest = 2, // Request that the thread do some checkpoint work and then continue.
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700109 kEmptyCheckpointRequest = 4, // Request that the thread do empty checkpoint and then continue.
110 kActiveSuspendBarrier = 8, // Register that at least 1 suspend barrier needs to be passed.
Ian Rogers474b6da2012-09-25 00:20:38 -0700111};
112
Sebastien Hertzf7958692015-06-09 14:09:14 +0200113enum class StackedShadowFrameType {
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700114 kShadowFrameUnderConstruction,
Andreas Gampe639bdd12015-06-03 11:22:45 -0700115 kDeoptimizationShadowFrame,
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700116};
117
Hiroshi Yamauchi7ed9c562016-02-02 15:22:09 -0800118// This should match RosAlloc::kNumThreadLocalSizeBrackets.
119static constexpr size_t kNumRosAllocThreadLocalSizeBracketsInThread = 16;
Ian Rogerse63db272014-07-15 15:36:11 -0700120
Dave Allison648d7112014-07-25 16:15:27 -0700121// Thread's stack layout for implicit stack overflow checks:
122//
123// +---------------------+ <- highest address of stack memory
124// | |
125// . . <- SP
126// | |
127// | |
128// +---------------------+ <- stack_end
129// | |
130// | Gap |
131// | |
132// +---------------------+ <- stack_begin
133// | |
134// | Protected region |
135// | |
136// +---------------------+ <- lowest address of stack memory
137//
138// The stack always grows down in memory. At the lowest address is a region of memory
139// that is set mprotect(PROT_NONE). Any attempt to read/write to this region will
140// result in a segmentation fault signal. At any point, the thread's SP will be somewhere
141// between the stack_end and the highest address in stack memory. An implicit stack
142// overflow check is a read of memory at a certain offset below the current SP (4K typically).
143// If the thread's SP is below the stack_end address this will be a read into the protected
144// region. If the SP is above the stack_end address, the thread is guaranteed to have
145// at least 4K of space. Because stack overflow checks are only performed in generated code,
146// if the thread makes a call out to a native function (through JNI), that native function
147// might only have 4K of memory (if the SP is adjacent to stack_end).
148
Ian Rogersdd7624d2014-03-14 17:43:00 -0700149class Thread {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700150 public:
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700151 static const size_t kStackOverflowImplicitCheckSize;
Dave Allisonf9439142014-03-27 15:10:22 -0700152
Elliott Hughes462c9442012-03-23 18:47:50 -0700153 // Creates a new native thread corresponding to the given managed peer.
154 // Used to implement Thread.start.
Ian Rogers52673ff2012-06-27 23:25:34 -0700155 static void CreateNativeThread(JNIEnv* env, jobject peer, size_t stack_size, bool daemon);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700156
Elliott Hughes462c9442012-03-23 18:47:50 -0700157 // Attaches the calling native thread to the runtime, returning the new native peer.
158 // Used to implement JNI AttachCurrentThread and AttachCurrentThreadAsDaemon calls.
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800159 static Thread* Attach(const char* thread_name, bool as_daemon, jobject thread_group,
160 bool create_peer);
Carl Shapirob5573532011-07-12 18:22:59 -0700161
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700162 // Reset internal state of child thread after fork.
163 void InitAfterFork();
164
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700165 // Get the currently executing thread, frequently referred to as 'self'. This call has reasonably
166 // high cost and so we favor passing self around when possible.
167 // TODO: mark as PURE so the compiler may coalesce and remove?
Ian Rogers02ed4c02013-09-06 13:10:04 -0700168 static Thread* Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700169
Ian Rogers7b078e82014-09-10 14:44:24 -0700170 // On a runnable thread, check for pending thread suspension request and handle if pending.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700171 void AllowThreadSuspension() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers7b078e82014-09-10 14:44:24 -0700172
173 // Process pending thread suspension request and handle if pending.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700174 void CheckSuspend() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers7b078e82014-09-10 14:44:24 -0700175
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700176 // Process a pending empty checkpoint if pending.
177 void CheckEmptyCheckpoint() REQUIRES_SHARED(Locks::mutator_lock_);
178
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700179 static Thread* FromManagedThread(const ScopedObjectAccessAlreadyRunnable& ts,
Mathieu Chartierf5769e12017-01-10 15:54:41 -0800180 ObjPtr<mirror::Object> thread_peer)
Mathieu Chartier90443472015-07-16 20:32:27 -0700181 REQUIRES(Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700182 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700183 static Thread* FromManagedThread(const ScopedObjectAccessAlreadyRunnable& ts, jobject thread)
Mathieu Chartier90443472015-07-16 20:32:27 -0700184 REQUIRES(Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700185 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700186
Elliott Hughes28fa76d2012-04-09 17:31:46 -0700187 // Translates 172 to pAllocArrayFromCode and so on.
Andreas Gampe542451c2016-07-26 09:02:02 -0700188 template<PointerSize size_of_pointers>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700189 static void DumpThreadOffset(std::ostream& os, uint32_t offset);
Elliott Hughes28fa76d2012-04-09 17:31:46 -0700190
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700191 // Dumps a one-line summary of thread state (used for operator<<).
192 void ShortDump(std::ostream& os) const;
193
194 // Dumps the detailed thread state and the thread stack (used for SIGQUIT).
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000195 void Dump(std::ostream& os,
196 bool dump_native_stack = true,
197 BacktraceMap* backtrace_map = nullptr) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700198 REQUIRES(!Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700199 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesa0957642011-09-02 14:27:33 -0700200
Mathieu Chartierc751fdc2014-03-30 15:25:44 -0700201 void DumpJavaStack(std::ostream& os) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700202 REQUIRES(!Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700203 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierc751fdc2014-03-30 15:25:44 -0700204
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700205 // Dumps the SIGQUIT per-thread header. 'thread' can be null for a non-attached thread, in which
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700206 // 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 -0700207 static void DumpState(std::ostream& os, const Thread* thread, pid_t tid)
Mathieu Chartier90443472015-07-16 20:32:27 -0700208 REQUIRES(!Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700209 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700210
Ian Rogers474b6da2012-09-25 00:20:38 -0700211 ThreadState GetState() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700212 DCHECK_GE(tls32_.state_and_flags.as_struct.state, kTerminated);
213 DCHECK_LE(tls32_.state_and_flags.as_struct.state, kSuspended);
214 return static_cast<ThreadState>(tls32_.state_and_flags.as_struct.state);
Dave Allison0aded082013-11-07 13:15:11 -0800215 }
216
Ian Rogers474b6da2012-09-25 00:20:38 -0700217 ThreadState SetState(ThreadState new_state);
Ian Rogers52673ff2012-06-27 23:25:34 -0700218
Mathieu Chartier90443472015-07-16 20:32:27 -0700219 int GetSuspendCount() const REQUIRES(Locks::thread_suspend_count_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700220 return tls32_.suspend_count;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700221 }
Elliott Hughes038a8062011-09-18 14:12:41 -0700222
Mathieu Chartier90443472015-07-16 20:32:27 -0700223 int GetDebugSuspendCount() const REQUIRES(Locks::thread_suspend_count_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700224 return tls32_.debug_suspend_count;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700225 }
226
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700227 bool IsSuspended() const {
Chris Dearman59cde532013-12-04 18:53:49 -0800228 union StateAndFlags state_and_flags;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700229 state_and_flags.as_int = tls32_.state_and_flags.as_int;
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700230 return state_and_flags.as_struct.state != kRunnable &&
231 (state_and_flags.as_struct.flags & kSuspendRequest) != 0;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700232 }
233
Hiroshi Yamauchi02e7f1a2016-10-03 15:32:01 -0700234 // If delta > 0 and (this != self or suspend_barrier is not null), this function may temporarily
235 // release thread_suspend_count_lock_ internally.
236 ALWAYS_INLINE
237 bool ModifySuspendCount(Thread* self,
238 int delta,
239 AtomicInteger* suspend_barrier,
240 bool for_debugger)
Mathieu Chartier90443472015-07-16 20:32:27 -0700241 REQUIRES(Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700242
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700243 bool RequestCheckpoint(Closure* function)
Mathieu Chartier90443472015-07-16 20:32:27 -0700244 REQUIRES(Locks::thread_suspend_count_lock_);
Andreas Gampee9f67122016-10-27 19:21:23 -0700245 void RequestSynchronousCheckpoint(Closure* function)
246 REQUIRES(!Locks::thread_suspend_count_lock_, !Locks::thread_list_lock_);
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700247 bool RequestEmptyCheckpoint()
248 REQUIRES(Locks::thread_suspend_count_lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700249
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800250 void SetFlipFunction(Closure* function);
251 Closure* GetFlipFunction();
252
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -0700253 gc::accounting::AtomicStack<mirror::Object>* GetThreadLocalMarkStack() {
254 CHECK(kUseReadBarrier);
255 return tlsPtr_.thread_local_mark_stack;
256 }
257 void SetThreadLocalMarkStack(gc::accounting::AtomicStack<mirror::Object>* stack) {
258 CHECK(kUseReadBarrier);
259 tlsPtr_.thread_local_mark_stack = stack;
260 }
261
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700262 // Called when thread detected that the thread_suspend_count_ was non-zero. Gives up share of
263 // mutator_lock_ and waits until it is resumed and thread_suspend_count_ is zero.
Ian Rogers9da7f592012-08-20 17:14:28 -0700264 void FullSuspendCheck()
Mathieu Chartier90443472015-07-16 20:32:27 -0700265 REQUIRES(!Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700266 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700267
268 // Transition from non-runnable to runnable state acquiring share on mutator_lock_.
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700269 ALWAYS_INLINE ThreadState TransitionFromSuspendedToRunnable()
Mathieu Chartier90443472015-07-16 20:32:27 -0700270 REQUIRES(!Locks::thread_suspend_count_lock_)
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700271 SHARED_LOCK_FUNCTION(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700272
273 // Transition from runnable into a state where mutator privileges are denied. Releases share of
274 // mutator lock.
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700275 ALWAYS_INLINE void TransitionFromRunnableToSuspended(ThreadState new_state)
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700276 REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_)
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700277 UNLOCK_FUNCTION(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700278
Ian Rogers0399dde2012-06-06 17:09:28 -0700279 // Once called thread suspension will cause an assertion failure.
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700280 const char* StartAssertNoThreadSuspension(const char* cause) ACQUIRE(Roles::uninterruptible_) {
281 Roles::uninterruptible_.Acquire(); // No-op.
Mathieu Chartier590fee92013-09-13 13:46:47 -0700282 if (kIsDebugBuild) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700283 CHECK(cause != nullptr);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700284 const char* previous_cause = tlsPtr_.last_no_thread_suspension_cause;
285 tls32_.no_thread_suspension++;
286 tlsPtr_.last_no_thread_suspension_cause = cause;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700287 return previous_cause;
288 } else {
289 return nullptr;
290 }
Ian Rogers0399dde2012-06-06 17:09:28 -0700291 }
Ian Rogers52673ff2012-06-27 23:25:34 -0700292
Ian Rogers0399dde2012-06-06 17:09:28 -0700293 // End region where no thread suspension is expected.
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700294 void EndAssertNoThreadSuspension(const char* old_cause) RELEASE(Roles::uninterruptible_) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700295 if (kIsDebugBuild) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700296 CHECK(old_cause != nullptr || tls32_.no_thread_suspension == 1);
297 CHECK_GT(tls32_.no_thread_suspension, 0U);
298 tls32_.no_thread_suspension--;
299 tlsPtr_.last_no_thread_suspension_cause = old_cause;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700300 }
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700301 Roles::uninterruptible_.Release(); // No-op.
Ian Rogers0399dde2012-06-06 17:09:28 -0700302 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700303
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700304 void AssertThreadSuspensionIsAllowable(bool check_locks = true) const;
Ian Rogers0399dde2012-06-06 17:09:28 -0700305
Mathieu Chartier10b218d2016-07-25 17:48:52 -0700306 // Return true if thread suspension is allowable.
307 bool IsThreadSuspensionAllowable() const;
308
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700309 bool IsDaemon() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700310 return tls32_.daemon;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700311 }
312
Mathieu Chartier14c3bf92015-07-13 14:35:43 -0700313 size_t NumberOfHeldMutexes() const;
314
Mathieu Chartierf5769e12017-01-10 15:54:41 -0800315 bool HoldsLock(ObjPtr<mirror::Object> object) const REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700316
Elliott Hughes8daa0922011-09-11 13:46:25 -0700317 /*
318 * Changes the priority of this thread to match that of the java.lang.Thread object.
319 *
320 * We map a priority value from 1-10 to Linux "nice" values, where lower
321 * numbers indicate higher priority.
322 */
323 void SetNativePriority(int newPriority);
324
325 /*
326 * Returns the thread priority for the current thread by querying the system.
327 * This is useful when attaching a thread through JNI.
328 *
329 * Returns a value from 1 to 10 (compatible with java.lang.Thread values).
330 */
331 static int GetNativePriority();
332
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700333 // Guaranteed to be non-zero.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700334 uint32_t GetThreadId() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700335 return tls32_.thin_lock_thread_id;
Carl Shapirob5573532011-07-12 18:22:59 -0700336 }
337
Elliott Hughesd92bec42011-09-02 17:04:36 -0700338 pid_t GetTid() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700339 return tls32_.tid;
Elliott Hughesd92bec42011-09-02 17:04:36 -0700340 }
Elliott Hughese27955c2011-08-26 15:21:24 -0700341
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700342 // Returns the java.lang.Thread's name, or null if this Thread* doesn't have a peer.
Andreas Gampe08883de2016-11-08 13:20:52 -0800343 mirror::String* GetThreadName() const REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes899e7892012-01-24 14:57:32 -0800344
Elliott Hughesffb465f2012-03-01 18:46:05 -0800345 // Sets 'name' to the java.lang.Thread's name. This requires no transition to managed code,
346 // allocation, or locking.
347 void GetThreadName(std::string& name) const;
348
Elliott Hughes899e7892012-01-24 14:57:32 -0800349 // Sets the thread's name.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700350 void SetThreadName(const char* name) REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesfc861622011-10-17 17:57:47 -0700351
Jeff Hao57dac6e2013-08-15 16:36:24 -0700352 // Returns the thread-specific CPU-time clock in microseconds or -1 if unavailable.
353 uint64_t GetCpuMicroTime() const;
354
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700355 mirror::Object* GetPeer() const REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700356 CHECK(tlsPtr_.jpeer == nullptr);
357 return tlsPtr_.opeer;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700358 }
359
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700360 bool HasPeer() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700361 return tlsPtr_.jpeer != nullptr || tlsPtr_.opeer != nullptr;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700362 }
363
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700364 RuntimeStats* GetStats() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700365 return &tls64_.stats;
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700366 }
367
Elliott Hughes7dc51662012-05-16 14:48:43 -0700368 bool IsStillStarting() const;
369
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700370 bool IsExceptionPending() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700371 return tlsPtr_.exception != nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700372 }
373
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700374 mirror::Throwable* GetException() const REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700375 return tlsPtr_.exception;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700376 }
377
Andreas Gamped9efea62014-07-21 22:56:08 -0700378 void AssertPendingException() const;
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700379 void AssertPendingOOMException() const REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700380 void AssertNoPendingException() const;
Mathieu Chartier8d7672e2014-02-25 10:57:16 -0800381 void AssertNoPendingExceptionForNewException(const char* msg) const;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700382
Mathieu Chartier0795f232016-09-27 18:43:30 -0700383 void SetException(ObjPtr<mirror::Throwable> new_exception) REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700384
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700385 void ClearException() REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700386 tlsPtr_.exception = nullptr;
jeffhao94d6df42012-11-26 16:02:12 -0800387 }
388
Ian Rogersbdb03912011-09-14 00:55:44 -0700389 // Find catch block and perform long jump to appropriate exception handle
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700390 NO_RETURN void QuickDeliverException() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersbdb03912011-09-14 00:55:44 -0700391
392 Context* GetLongJumpContext();
Ian Rogers0399dde2012-06-06 17:09:28 -0700393 void ReleaseLongJumpContext(Context* context) {
Mingyao Yang4dcfc432015-04-21 16:55:22 -0700394 if (tlsPtr_.long_jump_context != nullptr) {
395 // Each QuickExceptionHandler gets a long jump context and uses
396 // it for doing the long jump, after finding catch blocks/doing deoptimization.
397 // Both finding catch blocks and deoptimization can trigger another
398 // exception such as a result of class loading. So there can be nested
399 // cases of exception handling and multiple contexts being used.
400 // ReleaseLongJumpContext tries to save the context in tlsPtr_.long_jump_context
401 // for reuse so there is no need to always allocate a new one each time when
402 // getting a context. Since we only keep one context for reuse, delete the
403 // existing one since the passed in context is yet to be used for longjump.
404 delete tlsPtr_.long_jump_context;
405 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700406 tlsPtr_.long_jump_context = context;
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -0700407 }
408
Andreas Gampe6ec8ebd2014-07-25 13:36:56 -0700409 // Get the current method and dex pc. If there are errors in retrieving the dex pc, this will
410 // abort the runtime iff abort_on_error is true.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700411 ArtMethod* GetCurrentMethod(uint32_t* dex_pc, bool abort_on_error = true) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700412 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700413
Nicolas Geoffray7642cfc2015-02-26 10:56:09 +0000414 // Returns whether the given exception was thrown by the current Java method being executed
415 // (Note that this includes native Java methods).
Mathieu Chartierf5769e12017-01-10 15:54:41 -0800416 bool IsExceptionThrownByCurrentMethod(ObjPtr<mirror::Throwable> exception) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700417 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray7642cfc2015-02-26 10:56:09 +0000418
Mathieu Chartiere401d142015-04-22 13:56:20 -0700419 void SetTopOfStack(ArtMethod** top_method) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700420 tlsPtr_.managed_stack.SetTopQuickFrame(top_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700421 }
422
Jeff Hao11ffc2d2013-02-01 11:52:17 -0800423 void SetTopOfShadowStack(ShadowFrame* top) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700424 tlsPtr_.managed_stack.SetTopShadowFrame(top);
Jeff Hao11ffc2d2013-02-01 11:52:17 -0800425 }
426
Ian Rogers0399dde2012-06-06 17:09:28 -0700427 bool HasManagedStack() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700428 return (tlsPtr_.managed_stack.GetTopQuickFrame() != nullptr) ||
429 (tlsPtr_.managed_stack.GetTopShadowFrame() != nullptr);
Ian Rogersbdb03912011-09-14 00:55:44 -0700430 }
431
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700432 // If 'msg' is null, no detail message is set.
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000433 void ThrowNewException(const char* exception_class_descriptor, const char* msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700434 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700435
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700436 // If 'msg' is null, no detail message is set. An exception must be pending, and will be
Elliott Hughesa4f94742012-05-29 16:28:38 -0700437 // used as the new exception's cause.
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000438 void ThrowNewWrappedException(const char* exception_class_descriptor, const char* msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700439 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughesa4f94742012-05-29 16:28:38 -0700440
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000441 void ThrowNewExceptionF(const char* exception_class_descriptor, const char* fmt, ...)
442 __attribute__((format(printf, 3, 4)))
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700443 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughesa5b897e2011-08-16 11:33:06 -0700444
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000445 void ThrowNewExceptionV(const char* exception_class_descriptor, const char* fmt, va_list ap)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700446 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700447
Elliott Hughes2ced6a52011-10-16 18:44:48 -0700448 // OutOfMemoryError is special, because we need to pre-allocate an instance.
Elliott Hughes8a8b9cb2012-04-13 18:29:22 -0700449 // Only the GC should call this.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700450 void ThrowOutOfMemoryError(const char* msg) REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartiered8990a2015-07-23 14:11:16 -0700451 REQUIRES(!Roles::uninterruptible_);
Elliott Hughes79082e32011-08-25 12:07:32 -0700452
Elliott Hughesbe759c62011-09-08 19:38:21 -0700453 static void Startup();
Elliott Hughes038a8062011-09-18 14:12:41 -0700454 static void FinishStartup();
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700455 static void Shutdown();
Carl Shapirob5573532011-07-12 18:22:59 -0700456
Ian Rogersb033c752011-07-20 12:22:35 -0700457 // JNI methods
Elliott Hughes69f5bc62011-08-24 09:26:14 -0700458 JNIEnvExt* GetJniEnv() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700459 return tlsPtr_.jni_env;
Ian Rogersb033c752011-07-20 12:22:35 -0700460 }
461
Ian Rogers408f79a2011-08-23 18:22:33 -0700462 // Convert a jobject into a Object*
Mathieu Chartierc4f39252016-10-05 18:32:08 -0700463 ObjPtr<mirror::Object> DecodeJObject(jobject obj) const REQUIRES_SHARED(Locks::mutator_lock_);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -0800464 // Checks if the weak global ref has been cleared by the GC without decoding it.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700465 bool IsJWeakCleared(jweak obj) const REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersb033c752011-07-20 12:22:35 -0700466
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700467 mirror::Object* GetMonitorEnterObject() const REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700468 return tlsPtr_.monitor_enter_object;
469 }
470
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700471 void SetMonitorEnterObject(mirror::Object* obj) REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700472 tlsPtr_.monitor_enter_object = obj;
473 }
474
Elliott Hughes8daa0922011-09-11 13:46:25 -0700475 // Implements java.lang.Thread.interrupted.
Mathieu Chartier90443472015-07-16 20:32:27 -0700476 bool Interrupted() REQUIRES(!*wait_mutex_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700477 // Implements java.lang.Thread.isInterrupted.
Mathieu Chartier90443472015-07-16 20:32:27 -0700478 bool IsInterrupted() REQUIRES(!*wait_mutex_);
479 bool IsInterruptedLocked() REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700480 return interrupted_;
481 }
Mathieu Chartier90443472015-07-16 20:32:27 -0700482 void Interrupt(Thread* self) REQUIRES(!*wait_mutex_);
483 void SetInterruptedLocked(bool i) REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700484 interrupted_ = i;
485 }
Mathieu Chartier90443472015-07-16 20:32:27 -0700486 void Notify() REQUIRES(!*wait_mutex_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700487
Mathieu Chartier3f7f03c2016-09-26 11:39:52 -0700488 ALWAYS_INLINE void PoisonObjectPointers() {
489 ++poison_object_cookie_;
490 }
491
Mathieu Chartiera59d9b22016-09-26 18:13:17 -0700492 ALWAYS_INLINE static void PoisonObjectPointersIfDebug();
493
Mathieu Chartier3f7f03c2016-09-26 11:39:52 -0700494 ALWAYS_INLINE uintptr_t GetPoisonObjectCookie() const {
495 return poison_object_cookie_;
496 }
497
Ian Rogersdd7624d2014-03-14 17:43:00 -0700498 private:
Mathieu Chartier90443472015-07-16 20:32:27 -0700499 void NotifyLocked(Thread* self) REQUIRES(wait_mutex_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700500
501 public:
502 Mutex* GetWaitMutex() const LOCK_RETURNED(wait_mutex_) {
503 return wait_mutex_;
504 }
505
Mathieu Chartier90443472015-07-16 20:32:27 -0700506 ConditionVariable* GetWaitConditionVariable() const REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700507 return wait_cond_;
508 }
509
Mathieu Chartier90443472015-07-16 20:32:27 -0700510 Monitor* GetWaitMonitor() const REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700511 return wait_monitor_;
512 }
513
Mathieu Chartier90443472015-07-16 20:32:27 -0700514 void SetWaitMonitor(Monitor* mon) REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700515 wait_monitor_ = mon;
516 }
517
Ian Rogersdd7624d2014-03-14 17:43:00 -0700518 // Waiter link-list support.
519 Thread* GetWaitNext() const {
520 return tlsPtr_.wait_next;
521 }
522
523 void SetWaitNext(Thread* next) {
524 tlsPtr_.wait_next = next;
525 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700526
Ian Rogers68d8b422014-07-17 11:09:10 -0700527 jobject GetClassLoaderOverride() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700528 return tlsPtr_.class_loader_override;
buzbeec143c552011-08-20 17:38:58 -0700529 }
530
Ian Rogers68d8b422014-07-17 11:09:10 -0700531 void SetClassLoaderOverride(jobject class_loader_override);
buzbeec143c552011-08-20 17:38:58 -0700532
Ian Rogersaaa20802011-09-11 21:47:37 -0700533 // Create the internal representation of a stack trace, that is more time
Sebastien Hertzee1d79a2014-02-21 15:46:30 +0100534 // and space efficient to compute than the StackTraceElement[].
535 template<bool kTransactionActive>
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700536 jobject CreateInternalStackTrace(const ScopedObjectAccessAlreadyRunnable& soa) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700537 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersaaa20802011-09-11 21:47:37 -0700538
Elliott Hughes01158d72011-09-19 19:47:10 -0700539 // Convert an internal stack trace representation (returned by CreateInternalStackTrace) to a
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700540 // StackTraceElement[]. If output_array is null, a new array is created, otherwise as many
541 // 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 -0700542 // with the number of valid frames in the returned array.
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700543 static jobjectArray InternalStackTraceToStackTraceElementArray(
544 const ScopedObjectAccessAlreadyRunnable& soa, jobject internal,
545 jobjectArray output_array = nullptr, int* stack_depth = nullptr)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700546 REQUIRES_SHARED(Locks::mutator_lock_);
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700547
Mingyao Yang99170c62015-07-06 11:10:37 -0700548 bool HasDebuggerShadowFrames() const {
549 return tlsPtr_.frame_id_to_shadow_frame != nullptr;
550 }
551
Andreas Gampe585da952016-12-02 14:52:29 -0800552 void VisitRoots(RootVisitor* visitor, VisitRootFlags flags = kVisitRootFlagAllRoots)
553 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes410c0c82011-09-01 17:58:25 -0700554
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700555 ALWAYS_INLINE void VerifyStack() REQUIRES_SHARED(Locks::mutator_lock_);
jeffhao25045522012-03-13 19:34:37 -0700556
Elliott Hughesbe759c62011-09-08 19:38:21 -0700557 //
558 // Offsets of various members of native Thread class, used by compiled code.
559 //
560
Andreas Gampe542451c2016-07-26 09:02:02 -0700561 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700562 static ThreadOffset<pointer_size> ThinLockIdOffset() {
563 return ThreadOffset<pointer_size>(
564 OFFSETOF_MEMBER(Thread, tls32_) +
565 OFFSETOF_MEMBER(tls_32bit_sized_values, thin_lock_thread_id));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700566 }
567
Andreas Gampe542451c2016-07-26 09:02:02 -0700568 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700569 static ThreadOffset<pointer_size> ThreadFlagsOffset() {
570 return ThreadOffset<pointer_size>(
571 OFFSETOF_MEMBER(Thread, tls32_) +
572 OFFSETOF_MEMBER(tls_32bit_sized_values, state_and_flags));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700573 }
574
Andreas Gampe542451c2016-07-26 09:02:02 -0700575 template<PointerSize pointer_size>
Roland Levillain7c1559a2015-12-15 10:55:36 +0000576 static ThreadOffset<pointer_size> IsGcMarkingOffset() {
577 return ThreadOffset<pointer_size>(
578 OFFSETOF_MEMBER(Thread, tls32_) +
579 OFFSETOF_MEMBER(tls_32bit_sized_values, is_gc_marking));
580 }
581
Igor Murashkinae7ff922016-10-06 14:59:19 -0700582 static constexpr size_t IsGcMarkingSize() {
583 return sizeof(tls32_.is_gc_marking);
584 }
585
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000586 // Deoptimize the Java stack.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700587 void DeoptimizeWithDeoptimizationException(JValue* result) REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000588
Ian Rogersdd7624d2014-03-14 17:43:00 -0700589 private:
Andreas Gampe542451c2016-07-26 09:02:02 -0700590 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700591 static ThreadOffset<pointer_size> ThreadOffsetFromTlsPtr(size_t tls_ptr_offset) {
592 size_t base = OFFSETOF_MEMBER(Thread, tlsPtr_);
593 size_t scale;
594 size_t shrink;
Andreas Gampe542451c2016-07-26 09:02:02 -0700595 if (pointer_size == kRuntimePointerSize) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700596 scale = 1;
597 shrink = 1;
Andreas Gampe542451c2016-07-26 09:02:02 -0700598 } else if (pointer_size > kRuntimePointerSize) {
599 scale = static_cast<size_t>(pointer_size) / static_cast<size_t>(kRuntimePointerSize);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700600 shrink = 1;
601 } else {
Andreas Gampe542451c2016-07-26 09:02:02 -0700602 DCHECK_GT(kRuntimePointerSize, pointer_size);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700603 scale = 1;
Andreas Gampe542451c2016-07-26 09:02:02 -0700604 shrink = static_cast<size_t>(kRuntimePointerSize) / static_cast<size_t>(pointer_size);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700605 }
606 return ThreadOffset<pointer_size>(base + ((tls_ptr_offset * scale) / shrink));
Ian Rogers07ec8e12012-12-01 01:26:51 -0800607 }
608
Ian Rogersdd7624d2014-03-14 17:43:00 -0700609 public:
Jeff Hao848f70a2014-01-15 13:49:50 -0800610 static uint32_t QuickEntryPointOffsetWithSize(size_t quick_entrypoint_offset,
Andreas Gampe542451c2016-07-26 09:02:02 -0700611 PointerSize pointer_size) {
612 if (pointer_size == PointerSize::k32) {
613 return QuickEntryPointOffset<PointerSize::k32>(quick_entrypoint_offset).
614 Uint32Value();
Jeff Hao848f70a2014-01-15 13:49:50 -0800615 } else {
Andreas Gampe542451c2016-07-26 09:02:02 -0700616 return QuickEntryPointOffset<PointerSize::k64>(quick_entrypoint_offset).
617 Uint32Value();
Jeff Hao848f70a2014-01-15 13:49:50 -0800618 }
619 }
620
Andreas Gampe542451c2016-07-26 09:02:02 -0700621 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700622 static ThreadOffset<pointer_size> QuickEntryPointOffset(size_t quick_entrypoint_offset) {
623 return ThreadOffsetFromTlsPtr<pointer_size>(
624 OFFSETOF_MEMBER(tls_ptr_sized_values, quick_entrypoints) + quick_entrypoint_offset);
Elliott Hughesbe759c62011-09-08 19:38:21 -0700625 }
626
Andreas Gampe542451c2016-07-26 09:02:02 -0700627 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700628 static ThreadOffset<pointer_size> JniEntryPointOffset(size_t jni_entrypoint_offset) {
629 return ThreadOffsetFromTlsPtr<pointer_size>(
630 OFFSETOF_MEMBER(tls_ptr_sized_values, jni_entrypoints) + jni_entrypoint_offset);
Elliott Hughesbe759c62011-09-08 19:38:21 -0700631 }
632
Andreas Gampe542451c2016-07-26 09:02:02 -0700633 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700634 static ThreadOffset<pointer_size> SelfOffset() {
635 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, self));
636 }
637
Andreas Gampe542451c2016-07-26 09:02:02 -0700638 template<PointerSize pointer_size>
buzbee1452bee2015-03-06 14:43:04 -0800639 static ThreadOffset<pointer_size> MterpCurrentIBaseOffset() {
640 return ThreadOffsetFromTlsPtr<pointer_size>(
641 OFFSETOF_MEMBER(tls_ptr_sized_values, mterp_current_ibase));
642 }
643
Andreas Gampe542451c2016-07-26 09:02:02 -0700644 template<PointerSize pointer_size>
buzbee1452bee2015-03-06 14:43:04 -0800645 static ThreadOffset<pointer_size> MterpDefaultIBaseOffset() {
646 return ThreadOffsetFromTlsPtr<pointer_size>(
647 OFFSETOF_MEMBER(tls_ptr_sized_values, mterp_default_ibase));
648 }
649
Andreas Gampe542451c2016-07-26 09:02:02 -0700650 template<PointerSize pointer_size>
buzbee1452bee2015-03-06 14:43:04 -0800651 static ThreadOffset<pointer_size> MterpAltIBaseOffset() {
652 return ThreadOffsetFromTlsPtr<pointer_size>(
653 OFFSETOF_MEMBER(tls_ptr_sized_values, mterp_alt_ibase));
654 }
655
Andreas Gampe542451c2016-07-26 09:02:02 -0700656 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700657 static ThreadOffset<pointer_size> ExceptionOffset() {
658 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, exception));
659 }
660
Andreas Gampe542451c2016-07-26 09:02:02 -0700661 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700662 static ThreadOffset<pointer_size> PeerOffset() {
663 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, opeer));
664 }
665
666
Andreas Gampe542451c2016-07-26 09:02:02 -0700667 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700668 static ThreadOffset<pointer_size> CardTableOffset() {
669 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, card_table));
670 }
671
Andreas Gampe542451c2016-07-26 09:02:02 -0700672 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700673 static ThreadOffset<pointer_size> ThreadSuspendTriggerOffset() {
674 return ThreadOffsetFromTlsPtr<pointer_size>(
675 OFFSETOF_MEMBER(tls_ptr_sized_values, suspend_trigger));
Dave Allisonb373e092014-02-20 16:06:36 -0800676 }
677
Andreas Gampe542451c2016-07-26 09:02:02 -0700678 template<PointerSize pointer_size>
Hiroshi Yamauchie01a5202015-03-19 12:35:04 -0700679 static ThreadOffset<pointer_size> ThreadLocalPosOffset() {
Andreas Gampe542451c2016-07-26 09:02:02 -0700680 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
681 thread_local_pos));
Hiroshi Yamauchie01a5202015-03-19 12:35:04 -0700682 }
683
Andreas Gampe542451c2016-07-26 09:02:02 -0700684 template<PointerSize pointer_size>
Hiroshi Yamauchie01a5202015-03-19 12:35:04 -0700685 static ThreadOffset<pointer_size> ThreadLocalEndOffset() {
Andreas Gampe542451c2016-07-26 09:02:02 -0700686 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
687 thread_local_end));
Hiroshi Yamauchie01a5202015-03-19 12:35:04 -0700688 }
689
Andreas Gampe542451c2016-07-26 09:02:02 -0700690 template<PointerSize pointer_size>
Hiroshi Yamauchie01a5202015-03-19 12:35:04 -0700691 static ThreadOffset<pointer_size> ThreadLocalObjectsOffset() {
Andreas Gampe542451c2016-07-26 09:02:02 -0700692 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
693 thread_local_objects));
Hiroshi Yamauchie01a5202015-03-19 12:35:04 -0700694 }
695
Andreas Gampe542451c2016-07-26 09:02:02 -0700696 template<PointerSize pointer_size>
Hiroshi Yamauchidc412b62015-10-15 12:26:57 -0700697 static ThreadOffset<pointer_size> RosAllocRunsOffset() {
698 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
699 rosalloc_runs));
700 }
701
Andreas Gampe542451c2016-07-26 09:02:02 -0700702 template<PointerSize pointer_size>
Hiroshi Yamauchidc412b62015-10-15 12:26:57 -0700703 static ThreadOffset<pointer_size> ThreadLocalAllocStackTopOffset() {
704 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
705 thread_local_alloc_stack_top));
706 }
707
Andreas Gampe542451c2016-07-26 09:02:02 -0700708 template<PointerSize pointer_size>
Hiroshi Yamauchidc412b62015-10-15 12:26:57 -0700709 static ThreadOffset<pointer_size> ThreadLocalAllocStackEndOffset() {
710 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
711 thread_local_alloc_stack_end));
712 }
713
Ian Rogers932746a2011-09-22 18:57:50 -0700714 // Size of stack less any space reserved for stack overflow
jeffhaod7521322012-11-21 15:38:24 -0800715 size_t GetStackSize() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700716 return tlsPtr_.stack_size - (tlsPtr_.stack_end - tlsPtr_.stack_begin);
Ian Rogers932746a2011-09-22 18:57:50 -0700717 }
718
Ian Rogers13735952014-10-08 12:43:28 -0700719 uint8_t* GetStackEndForInterpreter(bool implicit_overflow_check) const {
Nicolas Geoffray535a3fb2014-07-22 15:17:38 +0100720 if (implicit_overflow_check) {
721 // The interpreter needs the extra overflow bytes that stack_end does
722 // not include.
723 return tlsPtr_.stack_end + GetStackOverflowReservedBytes(kRuntimeISA);
724 } else {
725 return tlsPtr_.stack_end;
726 }
727 }
728
Ian Rogers13735952014-10-08 12:43:28 -0700729 uint8_t* GetStackEnd() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700730 return tlsPtr_.stack_end;
jeffhaod7521322012-11-21 15:38:24 -0800731 }
732
Ian Rogers932746a2011-09-22 18:57:50 -0700733 // Set the stack end to that to be used during a stack overflow
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700734 void SetStackEndForStackOverflow() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers932746a2011-09-22 18:57:50 -0700735
736 // Set the stack end to that to be used during regular execution
Dave Allisonb090a182014-08-14 17:02:48 +0000737 void ResetDefaultStackEnd() {
Ian Rogers932746a2011-09-22 18:57:50 -0700738 // Our stacks grow down, so we want stack_end_ to be near there, but reserving enough room
739 // to throw a StackOverflowError.
Dave Allisonb090a182014-08-14 17:02:48 +0000740 tlsPtr_.stack_end = tlsPtr_.stack_begin + GetStackOverflowReservedBytes(kRuntimeISA);
Ian Rogers932746a2011-09-22 18:57:50 -0700741 }
742
Ian Rogers120f1c72012-09-28 17:17:10 -0700743 bool IsHandlingStackOverflow() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700744 return tlsPtr_.stack_end == tlsPtr_.stack_begin;
Ian Rogers120f1c72012-09-28 17:17:10 -0700745 }
746
Andreas Gampe542451c2016-07-26 09:02:02 -0700747 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700748 static ThreadOffset<pointer_size> StackEndOffset() {
749 return ThreadOffsetFromTlsPtr<pointer_size>(
750 OFFSETOF_MEMBER(tls_ptr_sized_values, stack_end));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700751 }
752
Andreas Gampe542451c2016-07-26 09:02:02 -0700753 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700754 static ThreadOffset<pointer_size> JniEnvOffset() {
755 return ThreadOffsetFromTlsPtr<pointer_size>(
756 OFFSETOF_MEMBER(tls_ptr_sized_values, jni_env));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700757 }
758
Andreas Gampe542451c2016-07-26 09:02:02 -0700759 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700760 static ThreadOffset<pointer_size> TopOfManagedStackOffset() {
761 return ThreadOffsetFromTlsPtr<pointer_size>(
762 OFFSETOF_MEMBER(tls_ptr_sized_values, managed_stack) +
763 ManagedStack::TopQuickFrameOffset());
Elliott Hughesbe759c62011-09-08 19:38:21 -0700764 }
765
Ian Rogers0399dde2012-06-06 17:09:28 -0700766 const ManagedStack* GetManagedStack() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700767 return &tlsPtr_.managed_stack;
Ian Rogers0399dde2012-06-06 17:09:28 -0700768 }
769
770 // Linked list recording fragments of managed stack.
771 void PushManagedStackFragment(ManagedStack* fragment) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700772 tlsPtr_.managed_stack.PushManagedStackFragment(fragment);
Ian Rogers0399dde2012-06-06 17:09:28 -0700773 }
774 void PopManagedStackFragment(const ManagedStack& fragment) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700775 tlsPtr_.managed_stack.PopManagedStackFragment(fragment);
Ian Rogers0399dde2012-06-06 17:09:28 -0700776 }
777
778 ShadowFrame* PushShadowFrame(ShadowFrame* new_top_frame) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700779 return tlsPtr_.managed_stack.PushShadowFrame(new_top_frame);
TDYa127de479be2012-05-31 08:03:26 -0700780 }
781
782 ShadowFrame* PopShadowFrame() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700783 return tlsPtr_.managed_stack.PopShadowFrame();
TDYa127de479be2012-05-31 08:03:26 -0700784 }
Logan Chienf7ad17e2012-03-15 03:10:03 +0800785
Andreas Gampe542451c2016-07-26 09:02:02 -0700786 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700787 static ThreadOffset<pointer_size> TopShadowFrameOffset() {
788 return ThreadOffsetFromTlsPtr<pointer_size>(
789 OFFSETOF_MEMBER(tls_ptr_sized_values, managed_stack) +
790 ManagedStack::TopShadowFrameOffset());
TDYa127d668a062012-04-13 12:36:57 -0700791 }
792
Ian Rogers0399dde2012-06-06 17:09:28 -0700793 // Is the given obj in this thread's stack indirect reference table?
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700794 bool HandleScopeContains(jobject obj) const;
Ian Rogers0399dde2012-06-06 17:09:28 -0700795
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700796 void HandleScopeVisitRoots(RootVisitor* visitor, uint32_t thread_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700797 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700798
Mathieu Chartiere8a3c572016-10-11 16:52:17 -0700799 BaseHandleScope* GetTopHandleScope() {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700800 return tlsPtr_.top_handle_scope;
Ian Rogers1f539342012-10-03 21:09:42 -0700801 }
802
Mathieu Chartiere8a3c572016-10-11 16:52:17 -0700803 void PushHandleScope(BaseHandleScope* handle_scope) {
Ian Rogers59c07062014-10-10 13:03:39 -0700804 DCHECK_EQ(handle_scope->GetLink(), tlsPtr_.top_handle_scope);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700805 tlsPtr_.top_handle_scope = handle_scope;
806 }
807
Mathieu Chartiere8a3c572016-10-11 16:52:17 -0700808 BaseHandleScope* PopHandleScope() {
809 BaseHandleScope* handle_scope = tlsPtr_.top_handle_scope;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700810 DCHECK(handle_scope != nullptr);
811 tlsPtr_.top_handle_scope = tlsPtr_.top_handle_scope->GetLink();
812 return handle_scope;
Ian Rogers1f539342012-10-03 21:09:42 -0700813 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700814
Andreas Gampe542451c2016-07-26 09:02:02 -0700815 template<PointerSize pointer_size>
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700816 static ThreadOffset<pointer_size> TopHandleScopeOffset() {
817 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
818 top_handle_scope));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700819 }
820
Ian Rogersdd7624d2014-03-14 17:43:00 -0700821 DebugInvokeReq* GetInvokeReq() const {
822 return tlsPtr_.debug_invoke_req;
Elliott Hughes475fc232011-10-25 15:00:35 -0700823 }
824
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100825 SingleStepControl* GetSingleStepControl() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700826 return tlsPtr_.single_step_control;
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100827 }
828
Sebastien Hertz1558b572015-02-25 15:05:59 +0100829 // Indicates whether this thread is ready to invoke a method for debugging. This
830 // is only true if the thread has been suspended by a debug event.
831 bool IsReadyForDebugInvoke() const {
832 return tls32_.ready_for_debug_invoke;
833 }
834
835 void SetReadyForDebugInvoke(bool ready) {
836 tls32_.ready_for_debug_invoke = ready;
837 }
838
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200839 bool IsDebugMethodEntry() const {
840 return tls32_.debug_method_entry_;
841 }
842
843 void SetDebugMethodEntry() {
844 tls32_.debug_method_entry_ = true;
845 }
846
847 void ClearDebugMethodEntry() {
848 tls32_.debug_method_entry_ = false;
849 }
850
Hiroshi Yamauchi00370822015-08-18 14:47:25 -0700851 bool GetIsGcMarking() const {
852 CHECK(kUseReadBarrier);
853 return tls32_.is_gc_marking;
854 }
855
Mathieu Chartierfe814e82016-11-09 14:32:49 -0800856 void SetIsGcMarkingAndUpdateEntrypoints(bool is_marking);
Hiroshi Yamauchi00370822015-08-18 14:47:25 -0700857
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -0700858 bool GetWeakRefAccessEnabled() const {
859 CHECK(kUseReadBarrier);
860 return tls32_.weak_ref_access_enabled;
861 }
862
863 void SetWeakRefAccessEnabled(bool enabled) {
864 CHECK(kUseReadBarrier);
865 tls32_.weak_ref_access_enabled = enabled;
866 }
867
Hiroshi Yamauchi20a0be02016-02-19 15:44:06 -0800868 uint32_t GetDisableThreadFlipCount() const {
869 CHECK(kUseReadBarrier);
870 return tls32_.disable_thread_flip_count;
871 }
872
873 void IncrementDisableThreadFlipCount() {
874 CHECK(kUseReadBarrier);
875 ++tls32_.disable_thread_flip_count;
876 }
877
878 void DecrementDisableThreadFlipCount() {
879 CHECK(kUseReadBarrier);
880 DCHECK_GT(tls32_.disable_thread_flip_count, 0U);
881 --tls32_.disable_thread_flip_count;
882 }
883
Calin Juravleccd56952016-12-15 17:57:38 +0000884 // Returns true if the thread is allowed to call into java.
885 bool CanCallIntoJava() const {
886 return can_call_into_java_;
887 }
888
889 void SetCanCallIntoJava(bool can_call_into_java) {
890 can_call_into_java_ = can_call_into_java;
891 }
892
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100893 // Activates single step control for debugging. The thread takes the
894 // ownership of the given SingleStepControl*. It is deleted by a call
895 // to DeactivateSingleStepControl or upon thread destruction.
896 void ActivateSingleStepControl(SingleStepControl* ssc);
897
898 // Deactivates single step control for debugging.
899 void DeactivateSingleStepControl();
900
Sebastien Hertz1558b572015-02-25 15:05:59 +0100901 // Sets debug invoke request for debugging. When the thread is resumed,
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200902 // it executes the method described by this request then sends the reply
903 // before suspending itself. The thread takes the ownership of the given
904 // DebugInvokeReq*. It is deleted by a call to ClearDebugInvokeReq.
Sebastien Hertz1558b572015-02-25 15:05:59 +0100905 void SetDebugInvokeReq(DebugInvokeReq* req);
906
907 // Clears debug invoke request for debugging. When the thread completes
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200908 // method invocation, it deletes its debug invoke request and suspends
909 // itself.
Sebastien Hertz1558b572015-02-25 15:05:59 +0100910 void ClearDebugInvokeReq();
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100911
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200912 // Returns the fake exception used to activate deoptimization.
913 static mirror::Throwable* GetDeoptimizationException() {
Mathieu Chartier0795f232016-09-27 18:43:30 -0700914 // Note that the mirror::Throwable must be aligned to kObjectAlignment or else it cannot be
915 // represented by ObjPtr.
916 return reinterpret_cast<mirror::Throwable*>(0x100);
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200917 }
918
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700919 // Currently deoptimization invokes verifier which can trigger class loading
920 // and execute Java code, so there might be nested deoptimizations happening.
921 // We need to save the ongoing deoptimization shadow frames and return
922 // values on stacks.
Nicolas Geoffray73be1e82015-09-17 15:22:56 +0100923 // 'from_code' denotes whether the deoptimization was explicitly made from
924 // compiled code.
925 void PushDeoptimizationContext(const JValue& return_value,
926 bool is_reference,
927 bool from_code,
Mathieu Chartierf5769e12017-01-10 15:54:41 -0800928 ObjPtr<mirror::Throwable> exception)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700929 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierf5769e12017-01-10 15:54:41 -0800930 void PopDeoptimizationContext(JValue* result,
931 ObjPtr<mirror::Throwable>* exception,
932 bool* from_code)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700933 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz07474662015-08-25 15:12:33 +0000934 void AssertHasDeoptimizationContext()
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700935 REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700936 void PushStackedShadowFrame(ShadowFrame* sf, StackedShadowFrameType type);
Andreas Gampe639bdd12015-06-03 11:22:45 -0700937 ShadowFrame* PopStackedShadowFrame(StackedShadowFrameType type, bool must_be_present = true);
Andreas Gampe2a0d4ec2014-06-02 22:05:22 -0700938
Mingyao Yang99170c62015-07-06 11:10:37 -0700939 // For debugger, find the shadow frame that corresponds to a frame id.
940 // Or return null if there is none.
941 ShadowFrame* FindDebuggerShadowFrame(size_t frame_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700942 REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yang99170c62015-07-06 11:10:37 -0700943 // For debugger, find the bool array that keeps track of the updated vreg set
944 // for a frame id.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700945 bool* GetUpdatedVRegFlags(size_t frame_id) REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yang99170c62015-07-06 11:10:37 -0700946 // For debugger, find the shadow frame that corresponds to a frame id. If
947 // one doesn't exist yet, create one and track it in frame_id_to_shadow_frame.
948 ShadowFrame* FindOrCreateDebuggerShadowFrame(size_t frame_id,
949 uint32_t num_vregs,
950 ArtMethod* method,
951 uint32_t dex_pc)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700952 REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yang99170c62015-07-06 11:10:37 -0700953
954 // Delete the entry that maps from frame_id to shadow_frame.
955 void RemoveDebuggerShadowFrameMapping(size_t frame_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700956 REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yang99170c62015-07-06 11:10:37 -0700957
Ian Rogers62d6c772013-02-27 08:32:07 -0800958 std::deque<instrumentation::InstrumentationStackFrame>* GetInstrumentationStack() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700959 return tlsPtr_.instrumentation_stack;
jeffhaoe343b762011-12-05 16:36:44 -0800960 }
961
Mathieu Chartiere401d142015-04-22 13:56:20 -0700962 std::vector<ArtMethod*>* GetStackTraceSample() const {
Andreas Gampe2c19f5b2016-11-28 08:10:18 -0800963 DCHECK(!IsAotCompiler());
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000964 return tlsPtr_.deps_or_stack_trace_sample.stack_trace_sample;
Jeff Hao5ce4b172013-08-16 16:27:18 -0700965 }
966
Mathieu Chartiere401d142015-04-22 13:56:20 -0700967 void SetStackTraceSample(std::vector<ArtMethod*>* sample) {
Andreas Gampe2c19f5b2016-11-28 08:10:18 -0800968 DCHECK(!IsAotCompiler());
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000969 tlsPtr_.deps_or_stack_trace_sample.stack_trace_sample = sample;
970 }
971
972 verifier::VerifierDeps* GetVerifierDeps() const {
Andreas Gampe2c19f5b2016-11-28 08:10:18 -0800973 DCHECK(IsAotCompiler());
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000974 return tlsPtr_.deps_or_stack_trace_sample.verifier_deps;
975 }
976
977 // It is the responsability of the caller to make sure the verifier_deps
978 // entry in the thread is cleared before destruction of the actual VerifierDeps
979 // object, or the thread.
980 void SetVerifierDeps(verifier::VerifierDeps* verifier_deps) {
Andreas Gampe2c19f5b2016-11-28 08:10:18 -0800981 DCHECK(IsAotCompiler());
Nicolas Geoffraye424c932016-11-23 12:52:01 +0000982 DCHECK(verifier_deps == nullptr || tlsPtr_.deps_or_stack_trace_sample.verifier_deps == nullptr);
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000983 tlsPtr_.deps_or_stack_trace_sample.verifier_deps = verifier_deps;
Jeff Hao5ce4b172013-08-16 16:27:18 -0700984 }
985
986 uint64_t GetTraceClockBase() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700987 return tls64_.trace_clock_base;
Jeff Hao5ce4b172013-08-16 16:27:18 -0700988 }
989
990 void SetTraceClockBase(uint64_t clock_base) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700991 tls64_.trace_clock_base = clock_base;
Jeff Hao5ce4b172013-08-16 16:27:18 -0700992 }
993
Ian Rogers81d425b2012-09-27 16:03:43 -0700994 BaseMutex* GetHeldMutex(LockLevel level) const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700995 return tlsPtr_.held_mutexes[level];
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700996 }
997
Ian Rogers81d425b2012-09-27 16:03:43 -0700998 void SetHeldMutex(LockLevel level, BaseMutex* mutex) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700999 tlsPtr_.held_mutexes[level] = mutex;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001000 }
Elliott Hughesffb465f2012-03-01 18:46:05 -08001001
Yu Lieac44242015-06-29 10:50:03 +08001002 void ClearSuspendBarrier(AtomicInteger* target)
Mathieu Chartier90443472015-07-16 20:32:27 -07001003 REQUIRES(Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +08001004
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001005 bool ReadFlag(ThreadFlag flag) const {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001006 return (tls32_.state_and_flags.as_struct.flags & flag) != 0;
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001007 }
1008
Jeff Hao9cec2472013-05-14 18:17:06 -07001009 bool TestAllFlags() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001010 return (tls32_.state_and_flags.as_struct.flags != 0);
Jeff Hao9cec2472013-05-14 18:17:06 -07001011 }
1012
Ian Rogers8c1b5f72014-07-09 22:02:36 -07001013 void AtomicSetFlag(ThreadFlag flag) {
1014 tls32_.state_and_flags.as_atomic_int.FetchAndOrSequentiallyConsistent(flag);
1015 }
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001016
Ian Rogers8c1b5f72014-07-09 22:02:36 -07001017 void AtomicClearFlag(ThreadFlag flag) {
1018 tls32_.state_and_flags.as_atomic_int.FetchAndAndSequentiallyConsistent(-1 ^ flag);
1019 }
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001020
Mathieu Chartier5ace2012016-11-30 10:15:41 -08001021 void ResetQuickAllocEntryPointsForThread(bool is_marking);
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -07001022
Ian Rogersdd7624d2014-03-14 17:43:00 -07001023 // Returns the remaining space in the TLAB.
1024 size_t TlabSize() const;
1025 // Doesn't check that there is room.
1026 mirror::Object* AllocTlab(size_t bytes);
Ian Rogers13735952014-10-08 12:43:28 -07001027 void SetTlab(uint8_t* start, uint8_t* end);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001028 bool HasTlab() const;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001029 uint8_t* GetTlabStart() {
1030 return tlsPtr_.thread_local_start;
1031 }
1032 uint8_t* GetTlabPos() {
1033 return tlsPtr_.thread_local_pos;
1034 }
Elliott Hughes5d96a712012-06-28 12:24:27 -07001035
Ian Rogersdd7624d2014-03-14 17:43:00 -07001036 // Remove the suspend trigger for this thread by making the suspend_trigger_ TLS value
1037 // equal to a valid pointer.
1038 // TODO: does this need to atomic? I don't think so.
1039 void RemoveSuspendTrigger() {
1040 tlsPtr_.suspend_trigger = reinterpret_cast<uintptr_t*>(&tlsPtr_.suspend_trigger);
1041 }
1042
1043 // Trigger a suspend check by making the suspend_trigger_ TLS value an invalid pointer.
1044 // The next time a suspend check is done, it will load from the value at this address
1045 // and trigger a SIGSEGV.
1046 void TriggerSuspend() {
1047 tlsPtr_.suspend_trigger = nullptr;
1048 }
1049
1050
1051 // Push an object onto the allocation stack.
Mathieu Chartiercb535da2015-01-23 13:50:03 -08001052 bool PushOnThreadLocalAllocationStack(mirror::Object* obj)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001053 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001054
1055 // Set the thread local allocation pointers to the given pointers.
Mathieu Chartiercb535da2015-01-23 13:50:03 -08001056 void SetThreadLocalAllocationStack(StackReference<mirror::Object>* start,
1057 StackReference<mirror::Object>* end);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001058
1059 // Resets the thread local allocation pointers.
1060 void RevokeThreadLocalAllocationStack();
1061
1062 size_t GetThreadLocalBytesAllocated() const {
Mathieu Chartier14cc9be2014-07-11 10:26:37 -07001063 return tlsPtr_.thread_local_end - tlsPtr_.thread_local_start;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001064 }
1065
1066 size_t GetThreadLocalObjectsAllocated() const {
1067 return tlsPtr_.thread_local_objects;
1068 }
1069
Ian Rogersdd7624d2014-03-14 17:43:00 -07001070 void* GetRosAllocRun(size_t index) const {
1071 return tlsPtr_.rosalloc_runs[index];
1072 }
1073
1074 void SetRosAllocRun(size_t index, void* run) {
1075 tlsPtr_.rosalloc_runs[index] = run;
1076 }
1077
Andreas Gampe2c2d2a02016-03-17 21:27:19 -07001078 bool ProtectStack(bool fatal_on_error = true);
Dave Allison648d7112014-07-25 16:15:27 -07001079 bool UnprotectStack();
1080
buzbee1452bee2015-03-06 14:43:04 -08001081 void SetMterpDefaultIBase(void* ibase) {
1082 tlsPtr_.mterp_default_ibase = ibase;
1083 }
1084
1085 void SetMterpCurrentIBase(void* ibase) {
1086 tlsPtr_.mterp_current_ibase = ibase;
1087 }
1088
1089 void SetMterpAltIBase(void* ibase) {
1090 tlsPtr_.mterp_alt_ibase = ibase;
1091 }
1092
1093 const void* GetMterpDefaultIBase() const {
1094 return tlsPtr_.mterp_default_ibase;
1095 }
1096
1097 const void* GetMterpCurrentIBase() const {
1098 return tlsPtr_.mterp_current_ibase;
1099 }
1100
1101 const void* GetMterpAltIBase() const {
1102 return tlsPtr_.mterp_alt_ibase;
1103 }
1104
Nicolas Geoffraye8e11272016-06-28 18:08:46 +01001105 // Notify that a signal is being handled. This is to protect us from doing recursive
1106 // NPE handling after a SIGSEGV.
Dave Allison648d7112014-07-25 16:15:27 -07001107 void NoteSignalBeingHandled() {
1108 if (tls32_.handling_signal_) {
1109 LOG(FATAL) << "Detected signal while processing a signal";
1110 }
1111 tls32_.handling_signal_ = true;
1112 }
1113
1114 void NoteSignalHandlerDone() {
1115 tls32_.handling_signal_ = false;
1116 }
1117
Dave Allison8ce6b902014-08-26 11:07:58 -07001118 jmp_buf* GetNestedSignalState() {
1119 return tlsPtr_.nested_signal_state;
1120 }
1121
Hiroshi Yamauchiee235822016-08-19 17:03:27 -07001122 bool IsTransitioningToRunnable() const {
1123 return tls32_.is_transitioning_to_runnable;
1124 }
1125
1126 void SetIsTransitioningToRunnable(bool value) {
1127 tls32_.is_transitioning_to_runnable = value;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001128 }
1129
Mathieu Chartierd0ad2ee2015-03-31 14:59:59 -07001130 void PushVerifier(verifier::MethodVerifier* verifier);
1131 void PopVerifier(verifier::MethodVerifier* verifier);
Mathieu Chartier12d625f2015-03-13 11:33:37 -07001132
Jeff Hao848f70a2014-01-15 13:49:50 -08001133 void InitStringEntryPoints();
1134
Mathieu Chartierdfe02f62016-02-01 20:15:11 -08001135 void ModifyDebugDisallowReadBarrier(int8_t delta) {
1136 debug_disallow_read_barrier_ += delta;
1137 }
1138
1139 uint8_t GetDebugDisallowReadBarrierCount() const {
1140 return debug_disallow_read_barrier_;
1141 }
1142
Andreas Gampef26bf2d2017-01-13 16:47:14 -08001143 const void* GetCustomTLS() const {
1144 return custom_tls_;
1145 }
1146
1147 void SetCustomTLS(const void* data) {
1148 custom_tls_ = data;
1149 }
1150
Calin Juravle97cbc922016-04-15 16:16:35 +01001151 // Returns true if the current thread is the jit sensitive thread.
1152 bool IsJitSensitiveThread() const {
1153 return this == jit_sensitive_thread_;
1154 }
1155
1156 // Returns true if StrictMode events are traced for the current thread.
Calin Juravleb2771b42016-04-07 17:09:25 +01001157 static bool IsSensitiveThread() {
1158 if (is_sensitive_thread_hook_ != nullptr) {
1159 return (*is_sensitive_thread_hook_)();
1160 }
1161 return false;
1162 }
1163
Ian Rogersdd7624d2014-03-14 17:43:00 -07001164 private:
Ian Rogers52673ff2012-06-27 23:25:34 -07001165 explicit Thread(bool daemon);
Mathieu Chartier90443472015-07-16 20:32:27 -07001166 ~Thread() REQUIRES(!Locks::mutator_lock_, !Locks::thread_suspend_count_lock_);
Elliott Hughesc0f09332012-03-26 13:27:06 -07001167 void Destroy();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001168
Ian Rogers365c1022012-06-22 15:05:28 -07001169 void CreatePeer(const char* name, bool as_daemon, jobject thread_group);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001170
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01001171 template<bool kTransactionActive>
1172 void InitPeer(ScopedObjectAccess& soa, jboolean thread_is_daemon, jobject thread_group,
1173 jobject thread_name, jint thread_priority)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001174 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01001175
Ian Rogers62d6c772013-02-27 08:32:07 -08001176 // Avoid use, callers should use SetState. Used only by SignalCatcher::HandleSigQuit, ~Thread and
Hiroshi Yamauchi98810e32016-05-24 14:55:40 -07001177 // Dbg::ManageDeoptimization.
Ian Rogers474b6da2012-09-25 00:20:38 -07001178 ThreadState SetStateUnsafe(ThreadState new_state) {
1179 ThreadState old_state = GetState();
Mathieu Chartier8ac9c912015-10-01 15:58:41 -07001180 if (old_state == kRunnable && new_state != kRunnable) {
1181 // Need to run pending checkpoint and suspend barriers. Run checkpoints in runnable state in
1182 // case they need to use a ScopedObjectAccess. If we are holding the mutator lock and a SOA
1183 // attempts to TransitionFromSuspendedToRunnable, it results in a deadlock.
1184 TransitionToSuspendedAndRunCheckpoints(new_state);
1185 // Since we transitioned to a suspended state, check the pass barrier requests.
1186 PassActiveSuspendBarriers();
1187 } else {
1188 tls32_.state_and_flags.as_struct.state = new_state;
Yu Lieac44242015-06-29 10:50:03 +08001189 }
Ian Rogersc747cff2012-08-31 18:20:08 -07001190 return old_state;
1191 }
Ian Rogersc747cff2012-08-31 18:20:08 -07001192
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001193 void VerifyStackImpl() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers04d7aa92013-03-16 14:29:17 -07001194
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001195 void DumpState(std::ostream& os) const REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffraya73280d2016-02-15 13:05:16 +00001196 void DumpStack(std::ostream& os,
1197 bool dump_native_stack = true,
1198 BacktraceMap* backtrace_map = nullptr) const
Mathieu Chartier90443472015-07-16 20:32:27 -07001199 REQUIRES(!Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001200 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesd92bec42011-09-02 17:04:36 -07001201
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001202 // Out-of-line conveniences for debugging in gdb.
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001203 static Thread* CurrentFromGdb(); // Like Thread::Current.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001204 // Like Thread::Dump(std::cerr).
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001205 void DumpFromGdb() const REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001206
Elliott Hughes93e74e82011-09-13 11:07:03 -07001207 static void* CreateCallback(void* arg);
1208
Ian Rogerscfaa4552012-11-26 21:00:08 -08001209 void HandleUncaughtExceptions(ScopedObjectAccess& soa)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001210 REQUIRES_SHARED(Locks::mutator_lock_);
1211 void RemoveFromThreadGroup(ScopedObjectAccess& soa) REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001212
Andreas Gampe449357d2015-06-01 22:29:51 -07001213 // Initialize a thread.
1214 //
1215 // The third parameter is not mandatory. If given, the thread will use this JNIEnvExt. In case
1216 // Init succeeds, this means the thread takes ownership of it. If Init fails, it is the caller's
1217 // responsibility to destroy the given JNIEnvExt. If the parameter is null, Init will try to
1218 // create a JNIEnvExt on its own (and potentially fail at that stage, indicated by a return value
1219 // of false).
1220 bool Init(ThreadList*, JavaVMExt*, JNIEnvExt* jni_env_ext = nullptr)
Mathieu Chartier90443472015-07-16 20:32:27 -07001221 REQUIRES(Locks::runtime_shutdown_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07001222 void InitCardTable();
Ian Rogersb033c752011-07-20 12:22:35 -07001223 void InitCpu();
Alexei Zavjalov1efa0a92014-02-04 02:08:31 +07001224 void CleanupCpu();
Ian Rogers848871b2013-08-05 10:56:33 -07001225 void InitTlsEntryPoints();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -07001226 void InitTid();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -07001227 void InitPthreadKeySelf();
Ian Rogersf4d4da12014-11-11 16:10:33 -08001228 bool InitStackHwm();
Elliott Hughesbe759c62011-09-08 19:38:21 -07001229
Elliott Hughesd6a23bd2013-07-16 14:19:52 -07001230 void SetUpAlternateSignalStack();
1231 void TearDownAlternateSignalStack();
1232
Mathieu Chartier8ac9c912015-10-01 15:58:41 -07001233 ALWAYS_INLINE void TransitionToSuspendedAndRunCheckpoints(ThreadState new_state)
1234 REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_);
1235
1236 ALWAYS_INLINE void PassActiveSuspendBarriers()
1237 REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_);
1238
Calin Juravle97cbc922016-04-15 16:16:35 +01001239 // Registers the current thread as the jit sensitive thread. Should be called just once.
1240 static void SetJitSensitiveThread() {
1241 if (jit_sensitive_thread_ == nullptr) {
1242 jit_sensitive_thread_ = Thread::Current();
1243 } else {
1244 LOG(WARNING) << "Attempt to set the sensitive thread twice. Tid:"
1245 << Thread::Current()->GetTid();
1246 }
1247 }
1248
Calin Juravleb2771b42016-04-07 17:09:25 +01001249 static void SetSensitiveThreadHook(bool (*is_sensitive_thread_hook)()) {
1250 is_sensitive_thread_hook_ = is_sensitive_thread_hook;
1251 }
1252
Hiroshi Yamauchi02e7f1a2016-10-03 15:32:01 -07001253 bool ModifySuspendCountInternal(Thread* self,
1254 int delta,
1255 AtomicInteger* suspend_barrier,
1256 bool for_debugger)
1257 REQUIRES(Locks::thread_suspend_count_lock_);
1258
Andreas Gampe0a855762016-10-26 13:43:14 -07001259 void RunCheckpointFunction();
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07001260 void RunEmptyCheckpoint();
Andreas Gampe0a855762016-10-26 13:43:14 -07001261
1262 bool PassActiveSuspendBarriers(Thread* self)
1263 REQUIRES(!Locks::thread_suspend_count_lock_);
1264
1265 // Install the protected region for implicit stack checks.
1266 void InstallImplicitProtection();
1267
Andreas Gampe585da952016-12-02 14:52:29 -08001268 template <bool kPrecise>
1269 void VisitRoots(RootVisitor* visitor) REQUIRES_SHARED(Locks::mutator_lock_);
1270
Andreas Gampe2c19f5b2016-11-28 08:10:18 -08001271 static bool IsAotCompiler();
1272
Ian Rogers474b6da2012-09-25 00:20:38 -07001273 // 32 bits of atomically changed state and flags. Keeping as 32 bits allows and atomic CAS to
1274 // change from being Suspended to Runnable without a suspend request occurring.
Chris Dearman59cde532013-12-04 18:53:49 -08001275 union PACKED(4) StateAndFlags {
1276 StateAndFlags() {}
Ian Rogersdf1ce912012-11-27 17:07:11 -08001277 struct PACKED(4) {
Ian Rogers30e173f2012-09-26 14:35:03 -07001278 // Bitfield of flag values. Must be changed atomically so that flag values aren't lost. See
1279 // ThreadFlags for bit field meanings.
1280 volatile uint16_t flags;
1281 // Holds the ThreadState. May be changed non-atomically between Suspended (ie not Runnable)
1282 // transitions. Changing to Runnable requires that the suspend_request be part of the atomic
1283 // operation. If a thread is suspended and a suspend_request is present, a thread may not
1284 // change to Runnable as a GC or other operation is in progress.
Ian Rogers01ae5802012-09-28 16:14:01 -07001285 volatile uint16_t state;
Ian Rogers30e173f2012-09-26 14:35:03 -07001286 } as_struct;
Ian Rogersb8e087e2014-07-09 21:12:06 -07001287 AtomicInteger as_atomic_int;
Ian Rogers01ae5802012-09-28 16:14:01 -07001288 volatile int32_t as_int;
Chris Dearman59cde532013-12-04 18:53:49 -08001289
1290 private:
1291 // gcc does not handle struct with volatile member assignments correctly.
1292 // See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47409
1293 DISALLOW_COPY_AND_ASSIGN(StateAndFlags);
Ian Rogers474b6da2012-09-25 00:20:38 -07001294 };
Andreas Gampe575e78c2014-11-03 23:41:03 -08001295 static_assert(sizeof(StateAndFlags) == sizeof(int32_t), "Weird state_and_flags size");
Ian Rogers474b6da2012-09-25 00:20:38 -07001296
Ian Rogersdd7624d2014-03-14 17:43:00 -07001297 static void ThreadExitCallback(void* arg);
Elliott Hughes5d96a712012-06-28 12:24:27 -07001298
Yu Lieac44242015-06-29 10:50:03 +08001299 // Maximum number of suspend barriers.
1300 static constexpr uint32_t kMaxSuspendBarriers = 3;
1301
Ian Rogersdd7624d2014-03-14 17:43:00 -07001302 // Has Thread::Startup been called?
1303 static bool is_started_;
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001304
Ian Rogersdd7624d2014-03-14 17:43:00 -07001305 // TLS key used to retrieve the Thread*.
1306 static pthread_key_t pthread_key_self_;
Ian Rogersa32a6fd2012-02-06 20:18:44 -08001307
Ian Rogersdd7624d2014-03-14 17:43:00 -07001308 // Used to notify threads that they should attempt to resume, they will suspend again if
1309 // their suspend count is > 0.
1310 static ConditionVariable* resume_cond_ GUARDED_BY(Locks::thread_suspend_count_lock_);
Dave Allisonb373e092014-02-20 16:06:36 -08001311
Calin Juravleb2771b42016-04-07 17:09:25 +01001312 // Hook passed by framework which returns true
1313 // when StrictMode events are traced for the current thread.
1314 static bool (*is_sensitive_thread_hook_)();
Calin Juravle97cbc922016-04-15 16:16:35 +01001315 // Stores the jit sensitive thread (which for now is the UI thread).
1316 static Thread* jit_sensitive_thread_;
Calin Juravleb2771b42016-04-07 17:09:25 +01001317
Ian Rogersdd7624d2014-03-14 17:43:00 -07001318 /***********************************************************************************************/
1319 // Thread local storage. Fields are grouped by size to enable 32 <-> 64 searching to account for
1320 // pointer size differences. To encourage shorter encoding, more frequently used values appear
1321 // first if possible.
1322 /***********************************************************************************************/
Elliott Hughes6a607ad2012-07-13 20:40:00 -07001323
Zuo Wangf37a88b2014-07-10 04:26:41 -07001324 struct PACKED(4) tls_32bit_sized_values {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001325 // We have no control over the size of 'bool', but want our boolean fields
1326 // to be 4-byte quantities.
1327 typedef uint32_t bool32_t;
Ian Rogers22f454c2012-09-08 11:06:29 -07001328
Ian Rogersdd7624d2014-03-14 17:43:00 -07001329 explicit tls_32bit_sized_values(bool is_daemon) :
1330 suspend_count(0), debug_suspend_count(0), thin_lock_thread_id(0), tid(0),
1331 daemon(is_daemon), throwing_OutOfMemoryError(false), no_thread_suspension(0),
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001332 thread_exit_check_count(0), handling_signal_(false),
Hiroshi Yamauchiee235822016-08-19 17:03:27 -07001333 is_transitioning_to_runnable(false), ready_for_debug_invoke(false),
Hiroshi Yamauchi20a0be02016-02-19 15:44:06 -08001334 debug_method_entry_(false), is_gc_marking(false), weak_ref_access_enabled(true),
1335 disable_thread_flip_count(0) {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001336 }
Dave Allisonb373e092014-02-20 16:06:36 -08001337
Ian Rogersdd7624d2014-03-14 17:43:00 -07001338 union StateAndFlags state_and_flags;
Andreas Gampe575e78c2014-11-03 23:41:03 -08001339 static_assert(sizeof(union StateAndFlags) == sizeof(int32_t),
1340 "Size of state_and_flags and int32 are different");
Dave Allisonb373e092014-02-20 16:06:36 -08001341
Ian Rogersdd7624d2014-03-14 17:43:00 -07001342 // A non-zero value is used to tell the current thread to enter a safe point
1343 // at the next poll.
1344 int suspend_count GUARDED_BY(Locks::thread_suspend_count_lock_);
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -07001345
Ian Rogersdd7624d2014-03-14 17:43:00 -07001346 // How much of 'suspend_count_' is by request of the debugger, used to set things right
1347 // when the debugger detaches. Must be <= suspend_count_.
1348 int debug_suspend_count GUARDED_BY(Locks::thread_suspend_count_lock_);
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001349
Ian Rogersdd7624d2014-03-14 17:43:00 -07001350 // Thin lock thread id. This is a small integer used by the thin lock implementation.
1351 // This is not to be confused with the native thread's tid, nor is it the value returned
1352 // by java.lang.Thread.getId --- this is a distinct value, used only for locking. One
1353 // important difference between this id and the ids visible to managed code is that these
1354 // ones get reused (to ensure that they fit in the number of bits available).
1355 uint32_t thin_lock_thread_id;
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001356
Ian Rogersdd7624d2014-03-14 17:43:00 -07001357 // System thread id.
1358 uint32_t tid;
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001359
Ian Rogersdd7624d2014-03-14 17:43:00 -07001360 // Is the thread a daemon?
1361 const bool32_t daemon;
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001362
Ian Rogersdd7624d2014-03-14 17:43:00 -07001363 // A boolean telling us whether we're recursively throwing OOME.
1364 bool32_t throwing_OutOfMemoryError;
1365
1366 // A positive value implies we're in a region where thread suspension isn't expected.
1367 uint32_t no_thread_suspension;
1368
1369 // How many times has our pthread key's destructor been called?
1370 uint32_t thread_exit_check_count;
Sebastien Hertz9f102032014-05-23 08:59:42 +02001371
Dave Allison648d7112014-07-25 16:15:27 -07001372 // True if signal is being handled by this thread.
1373 bool32_t handling_signal_;
1374
Hiroshi Yamauchiee235822016-08-19 17:03:27 -07001375 // True if the thread is in TransitionFromSuspendedToRunnable(). This is used to distinguish the
1376 // non-runnable threads (eg. kNative, kWaiting) that are about to transition to runnable from
1377 // the rest of them.
1378 bool32_t is_transitioning_to_runnable;
Sebastien Hertz1558b572015-02-25 15:05:59 +01001379
1380 // True if the thread has been suspended by a debugger event. This is
1381 // used to invoke method from the debugger which is only allowed when
1382 // the thread is suspended by an event.
1383 bool32_t ready_for_debug_invoke;
Sebastien Hertz9d6bf692015-04-10 12:12:33 +02001384
1385 // True if the thread enters a method. This is used to detect method entry
1386 // event for the debugger.
1387 bool32_t debug_method_entry_;
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001388
Hiroshi Yamauchi00370822015-08-18 14:47:25 -07001389 // True if the GC is in the marking phase. This is used for the CC collector only. This is
1390 // thread local so that we can simplify the logic to check for the fast path of read barriers of
1391 // GC roots.
1392 bool32_t is_gc_marking;
1393
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001394 // True if the thread is allowed to access a weak ref (Reference::GetReferent() and system
1395 // weaks) and to potentially mark an object alive/gray. This is used for concurrent reference
1396 // processing of the CC collector only. This is thread local so that we can enable/disable weak
1397 // ref access by using a checkpoint and avoid a race around the time weak ref access gets
1398 // disabled and concurrent reference processing begins (if weak ref access is disabled during a
1399 // pause, this is not an issue.) Other collectors use Runtime::DisallowNewSystemWeaks() and
1400 // ReferenceProcessor::EnableSlowPath().
1401 bool32_t weak_ref_access_enabled;
Hiroshi Yamauchi20a0be02016-02-19 15:44:06 -08001402
1403 // A thread local version of Heap::disable_thread_flip_count_. This keeps track of how many
1404 // levels of (nested) JNI critical sections the thread is in and is used to detect a nested JNI
1405 // critical section enter.
1406 uint32_t disable_thread_flip_count;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001407 } tls32_;
1408
1409 struct PACKED(8) tls_64bit_sized_values {
Sebastien Hertz07474662015-08-25 15:12:33 +00001410 tls_64bit_sized_values() : trace_clock_base(0) {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001411 }
1412
1413 // The clock base used for tracing.
1414 uint64_t trace_clock_base;
1415
Ian Rogersdd7624d2014-03-14 17:43:00 -07001416 RuntimeStats stats;
1417 } tls64_;
1418
Andreas Gampe6aa13702015-10-28 10:57:25 -07001419 struct PACKED(sizeof(void*)) tls_ptr_sized_values {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001420 tls_ptr_sized_values() : card_table(nullptr), exception(nullptr), stack_end(nullptr),
Andreas Gampe449357d2015-06-01 22:29:51 -07001421 managed_stack(), suspend_trigger(nullptr), jni_env(nullptr), tmp_jni_env(nullptr),
1422 self(nullptr), opeer(nullptr), jpeer(nullptr), stack_begin(nullptr), stack_size(0),
Nicolas Geoffray340dafa2016-11-18 16:03:10 +00001423 deps_or_stack_trace_sample(), wait_next(nullptr), monitor_enter_object(nullptr),
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001424 top_handle_scope(nullptr), class_loader_override(nullptr), long_jump_context(nullptr),
Ian Rogersdd7624d2014-03-14 17:43:00 -07001425 instrumentation_stack(nullptr), debug_invoke_req(nullptr), single_step_control(nullptr),
Sebastien Hertz07474662015-08-25 15:12:33 +00001426 stacked_shadow_frame_record(nullptr), deoptimization_context_stack(nullptr),
Mingyao Yang99170c62015-07-06 11:10:37 -07001427 frame_id_to_shadow_frame(nullptr), name(nullptr), pthread_self(0),
Vladimir Marko05846472016-09-14 12:49:57 +01001428 last_no_thread_suspension_cause(nullptr), checkpoint_function(nullptr),
Roland Levillaine71b3542017-01-16 14:58:23 +00001429 thread_local_start(nullptr), thread_local_pos(nullptr), thread_local_end(nullptr),
Vladimir Marko05846472016-09-14 12:49:57 +01001430 thread_local_objects(0), mterp_current_ibase(nullptr), mterp_default_ibase(nullptr),
1431 mterp_alt_ibase(nullptr), thread_local_alloc_stack_top(nullptr),
1432 thread_local_alloc_stack_end(nullptr), nested_signal_state(nullptr),
1433 flip_function(nullptr), method_verifier(nullptr), thread_local_mark_stack(nullptr) {
Mathieu Chartier12d625f2015-03-13 11:33:37 -07001434 std::fill(held_mutexes, held_mutexes + kLockLevelCount, nullptr);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001435 }
1436
1437 // The biased card table, see CardTable for details.
Ian Rogers13735952014-10-08 12:43:28 -07001438 uint8_t* card_table;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001439
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001440 // The pending exception or null.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001441 mirror::Throwable* exception;
1442
1443 // The end of this thread's stack. This is the lowest safely-addressable address on the stack.
1444 // We leave extra space so there's room for the code that throws StackOverflowError.
Ian Rogers13735952014-10-08 12:43:28 -07001445 uint8_t* stack_end;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001446
1447 // The top of the managed stack often manipulated directly by compiler generated code.
1448 ManagedStack managed_stack;
1449
1450 // In certain modes, setting this to 0 will trigger a SEGV and thus a suspend check. It is
1451 // normally set to the address of itself.
1452 uintptr_t* suspend_trigger;
1453
1454 // Every thread may have an associated JNI environment
1455 JNIEnvExt* jni_env;
1456
Andreas Gampe449357d2015-06-01 22:29:51 -07001457 // Temporary storage to transfer a pre-allocated JNIEnvExt from the creating thread to the
1458 // created thread.
1459 JNIEnvExt* tmp_jni_env;
1460
Ian Rogersdd7624d2014-03-14 17:43:00 -07001461 // Initialized to "this". On certain architectures (such as x86) reading off of Thread::Current
1462 // is easy but getting the address of Thread::Current is hard. This field can be read off of
1463 // Thread::Current to give the address.
1464 Thread* self;
1465
1466 // Our managed peer (an instance of java.lang.Thread). The jobject version is used during thread
1467 // start up, until the thread is registered and the local opeer_ is used.
1468 mirror::Object* opeer;
1469 jobject jpeer;
1470
1471 // The "lowest addressable byte" of the stack.
Ian Rogers13735952014-10-08 12:43:28 -07001472 uint8_t* stack_begin;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001473
1474 // Size of the stack.
1475 size_t stack_size;
1476
Nicolas Geoffray340dafa2016-11-18 16:03:10 +00001477 // Sampling profiler and AOT verification cannot happen on the same run, so we share
1478 // the same entry for the stack trace and the verifier deps.
1479 union DepsOrStackTraceSample {
1480 DepsOrStackTraceSample() {
1481 verifier_deps = nullptr;
1482 stack_trace_sample = nullptr;
1483 }
1484 // Pointer to previous stack trace captured by sampling profiler.
1485 std::vector<ArtMethod*>* stack_trace_sample;
1486 // When doing AOT verification, per-thread VerifierDeps.
1487 verifier::VerifierDeps* verifier_deps;
1488 } deps_or_stack_trace_sample;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001489
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001490 // The next thread in the wait set this thread is part of or null if not waiting.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001491 Thread* wait_next;
1492
1493 // If we're blocked in MonitorEnter, this is the object we're trying to lock.
1494 mirror::Object* monitor_enter_object;
1495
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001496 // Top of linked list of handle scopes or null for none.
Mathieu Chartiere8a3c572016-10-11 16:52:17 -07001497 BaseHandleScope* top_handle_scope;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001498
1499 // Needed to get the right ClassLoader in JNI_OnLoad, but also
1500 // useful for testing.
Ian Rogers68d8b422014-07-17 11:09:10 -07001501 jobject class_loader_override;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001502
1503 // Thread local, lazily allocated, long jump context. Used to deliver exceptions.
1504 Context* long_jump_context;
1505
1506 // Additional stack used by method instrumentation to store method and return pc values.
1507 // Stored as a pointer since std::deque is not PACKED.
1508 std::deque<instrumentation::InstrumentationStackFrame>* instrumentation_stack;
1509
1510 // JDWP invoke-during-breakpoint support.
1511 DebugInvokeReq* debug_invoke_req;
1512
1513 // JDWP single-stepping support.
1514 SingleStepControl* single_step_control;
1515
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001516 // For gc purpose, a shadow frame record stack that keeps track of:
1517 // 1) shadow frames under construction.
1518 // 2) deoptimization shadow frames.
1519 StackedShadowFrameRecord* stacked_shadow_frame_record;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001520
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001521 // Deoptimization return value record stack.
Sebastien Hertz07474662015-08-25 15:12:33 +00001522 DeoptimizationContextRecord* deoptimization_context_stack;
Andreas Gampe2a0d4ec2014-06-02 22:05:22 -07001523
Mingyao Yang99170c62015-07-06 11:10:37 -07001524 // For debugger, a linked list that keeps the mapping from frame_id to shadow frame.
1525 // Shadow frames may be created before deoptimization happens so that the debugger can
1526 // set local values there first.
1527 FrameIdToShadowFrame* frame_id_to_shadow_frame;
1528
Ian Rogersdd7624d2014-03-14 17:43:00 -07001529 // A cached copy of the java.lang.Thread's name.
1530 std::string* name;
1531
1532 // A cached pthread_t for the pthread underlying this Thread*.
1533 pthread_t pthread_self;
1534
Ian Rogersdd7624d2014-03-14 17:43:00 -07001535 // If no_thread_suspension_ is > 0, what is causing that assertion.
1536 const char* last_no_thread_suspension_cause;
1537
Mathieu Chartier952e1e32016-06-13 14:04:02 -07001538 // Pending checkpoint function or null if non-pending. If this checkpoint is set and someone\
1539 // requests another checkpoint, it goes to the checkpoint overflow list.
1540 Closure* checkpoint_function GUARDED_BY(Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001541
Yu Lieac44242015-06-29 10:50:03 +08001542 // Pending barriers that require passing or NULL if non-pending. Installation guarding by
1543 // Locks::thread_suspend_count_lock_.
1544 // They work effectively as art::Barrier, but implemented directly using AtomicInteger and futex
1545 // to avoid additional cost of a mutex and a condition variable, as used in art::Barrier.
1546 AtomicInteger* active_suspend_barriers[kMaxSuspendBarriers];
1547
Roland Levillaine71b3542017-01-16 14:58:23 +00001548 // Thread-local allocation pointer. Moved here to force alignment for thread_local_pos on ARM.
1549 uint8_t* thread_local_start;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001550
Hiroshi Yamauchi7e1ce282015-12-11 15:46:19 -08001551 // thread_local_pos and thread_local_end must be consecutive for ldrd and are 8 byte aligned for
1552 // potentially better performance.
Ian Rogers13735952014-10-08 12:43:28 -07001553 uint8_t* thread_local_pos;
1554 uint8_t* thread_local_end;
Igor Murashkinaf1e2992016-10-12 17:44:50 -07001555
Vladimir Marko05846472016-09-14 12:49:57 +01001556 size_t thread_local_objects;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001557
Roland Levillaine71b3542017-01-16 14:58:23 +00001558 // Entrypoint function pointers.
1559 // TODO: move this to more of a global offset table model to avoid per-thread duplication.
1560 JniEntryPoints jni_entrypoints;
1561 QuickEntryPoints quick_entrypoints;
1562
buzbee1452bee2015-03-06 14:43:04 -08001563 // Mterp jump table bases.
1564 void* mterp_current_ibase;
1565 void* mterp_default_ibase;
1566 void* mterp_alt_ibase;
1567
Mathieu Chartier0651d412014-04-29 14:37:57 -07001568 // There are RosAlloc::kNumThreadLocalSizeBrackets thread-local size brackets per thread.
Hiroshi Yamauchi7ed9c562016-02-02 15:22:09 -08001569 void* rosalloc_runs[kNumRosAllocThreadLocalSizeBracketsInThread];
Ian Rogersdd7624d2014-03-14 17:43:00 -07001570
1571 // Thread-local allocation stack data/routines.
Mathieu Chartiercb535da2015-01-23 13:50:03 -08001572 StackReference<mirror::Object>* thread_local_alloc_stack_top;
1573 StackReference<mirror::Object>* thread_local_alloc_stack_end;
Chao-ying Fu9e369312014-05-21 11:20:52 -07001574
1575 // Support for Mutex lock hierarchy bug detection.
1576 BaseMutex* held_mutexes[kLockLevelCount];
Dave Allison8ce6b902014-08-26 11:07:58 -07001577
1578 // Recorded thread state for nested signals.
1579 jmp_buf* nested_signal_state;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001580
1581 // The function used for thread flip.
1582 Closure* flip_function;
Mathieu Chartier12d625f2015-03-13 11:33:37 -07001583
1584 // Current method verifier, used for root marking.
1585 verifier::MethodVerifier* method_verifier;
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001586
1587 // Thread-local mark stack for the concurrent copying collector.
1588 gc::accounting::AtomicStack<mirror::Object>* thread_local_mark_stack;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001589 } tlsPtr_;
1590
1591 // Guards the 'interrupted_' and 'wait_monitor_' members.
1592 Mutex* wait_mutex_ DEFAULT_MUTEX_ACQUIRED_AFTER;
1593
1594 // Condition variable waited upon during a wait.
1595 ConditionVariable* wait_cond_ GUARDED_BY(wait_mutex_);
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001596 // Pointer to the monitor lock we're currently waiting on or null if not waiting.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001597 Monitor* wait_monitor_ GUARDED_BY(wait_mutex_);
1598
1599 // Thread "interrupted" status; stays raised until queried or thrown.
1600 bool interrupted_ GUARDED_BY(wait_mutex_);
1601
Mathieu Chartierdfe02f62016-02-01 20:15:11 -08001602 // Debug disable read barrier count, only is checked for debug builds and only in the runtime.
1603 uint8_t debug_disallow_read_barrier_ = 0;
1604
Mathieu Chartier3f7f03c2016-09-26 11:39:52 -07001605 // Note that it is not in the packed struct, may not be accessed for cross compilation.
1606 uintptr_t poison_object_cookie_ = 0;
1607
Mathieu Chartier952e1e32016-06-13 14:04:02 -07001608 // Pending extra checkpoints if checkpoint_function_ is already used.
1609 std::list<Closure*> checkpoint_overflow_ GUARDED_BY(Locks::thread_suspend_count_lock_);
1610
Andreas Gampef26bf2d2017-01-13 16:47:14 -08001611 // Custom TLS field that can be used by plugins.
1612 // TODO: Generalize once we have more plugins.
1613 const void* custom_tls_;
1614
Calin Juravleccd56952016-12-15 17:57:38 +00001615 // True if the thread is allowed to call back into java (for e.g. during class resolution).
1616 // By default this is true.
1617 bool can_call_into_java_;
1618
Mathieu Chartiere6da9af2013-12-16 11:54:42 -08001619 friend class Dbg; // For SetStateUnsafe.
Mathieu Chartier15d34022014-02-26 17:16:38 -08001620 friend class gc::collector::SemiSpace; // For getting stack traces.
Mathieu Chartier692fafd2013-11-29 17:24:40 -08001621 friend class Runtime; // For CreatePeer.
Ian Rogers5cf98192014-05-29 21:31:50 -07001622 friend class QuickExceptionHandler; // For dumping the stack.
Mathieu Chartier692fafd2013-11-29 17:24:40 -08001623 friend class ScopedThreadStateChange;
Mathieu Chartier119c6bd2014-05-09 14:11:47 -07001624 friend class StubTest; // For accessing entrypoints.
Mathieu Chartier692fafd2013-11-29 17:24:40 -08001625 friend class ThreadList; // For ~Thread and Destroy.
1626
Andreas Gampe4352b452014-06-04 18:59:01 -07001627 friend class EntrypointsOrderTest; // To test the order of tls entries.
1628
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001629 DISALLOW_COPY_AND_ASSIGN(Thread);
1630};
Ian Rogersbdb03912011-09-14 00:55:44 -07001631
Mathieu Chartier4e2cb092015-07-22 16:17:51 -07001632class SCOPED_CAPABILITY ScopedAssertNoThreadSuspension {
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001633 public:
Andreas Gampeea47ff82016-11-03 08:20:17 -07001634 ALWAYS_INLINE explicit ScopedAssertNoThreadSuspension(const char* cause)
1635 ACQUIRE(Roles::uninterruptible_) {
Mathieu Chartier268764d2016-09-13 12:09:38 -07001636 if (kIsDebugBuild) {
1637 self_ = Thread::Current();
1638 old_cause_ = self_->StartAssertNoThreadSuspension(cause);
1639 } else {
1640 Roles::uninterruptible_.Acquire(); // No-op.
1641 }
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001642 }
Mathieu Chartier268764d2016-09-13 12:09:38 -07001643 ALWAYS_INLINE ~ScopedAssertNoThreadSuspension() RELEASE(Roles::uninterruptible_) {
1644 if (kIsDebugBuild) {
1645 self_->EndAssertNoThreadSuspension(old_cause_);
1646 } else {
1647 Roles::uninterruptible_.Release(); // No-op.
1648 }
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001649 }
1650
1651 private:
Mathieu Chartier268764d2016-09-13 12:09:38 -07001652 Thread* self_;
1653 const char* old_cause_;
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001654};
1655
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001656class ScopedStackedShadowFramePusher {
1657 public:
1658 ScopedStackedShadowFramePusher(Thread* self, ShadowFrame* sf, StackedShadowFrameType type)
1659 : self_(self), type_(type) {
1660 self_->PushStackedShadowFrame(sf, type);
1661 }
1662 ~ScopedStackedShadowFramePusher() {
1663 self_->PopStackedShadowFrame(type_);
1664 }
1665
1666 private:
1667 Thread* const self_;
1668 const StackedShadowFrameType type_;
1669
1670 DISALLOW_COPY_AND_ASSIGN(ScopedStackedShadowFramePusher);
1671};
1672
Mathieu Chartierdfe02f62016-02-01 20:15:11 -08001673// Only works for debug builds.
1674class ScopedDebugDisallowReadBarriers {
1675 public:
1676 explicit ScopedDebugDisallowReadBarriers(Thread* self) : self_(self) {
1677 self_->ModifyDebugDisallowReadBarrier(1);
1678 }
1679 ~ScopedDebugDisallowReadBarriers() {
1680 self_->ModifyDebugDisallowReadBarrier(-1);
1681 }
1682
1683 private:
1684 Thread* const self_;
1685};
1686
Hiroshi Yamauchiee235822016-08-19 17:03:27 -07001687class ScopedTransitioningToRunnable : public ValueObject {
1688 public:
1689 explicit ScopedTransitioningToRunnable(Thread* self)
1690 : self_(self) {
1691 DCHECK_EQ(self, Thread::Current());
1692 if (kUseReadBarrier) {
1693 self_->SetIsTransitioningToRunnable(true);
1694 }
1695 }
1696
1697 ~ScopedTransitioningToRunnable() {
1698 if (kUseReadBarrier) {
1699 self_->SetIsTransitioningToRunnable(false);
1700 }
1701 }
1702
1703 private:
1704 Thread* const self_;
1705};
1706
Andreas Gampe04bbb5b2017-01-19 17:49:03 +00001707class ThreadLifecycleCallback {
1708 public:
1709 virtual ~ThreadLifecycleCallback() {}
1710
1711 virtual void ThreadStart(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) = 0;
1712 virtual void ThreadDeath(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) = 0;
1713};
1714
Elliott Hughes330304d2011-08-12 14:28:05 -07001715std::ostream& operator<<(std::ostream& os, const Thread& thread);
Sebastien Hertzf7958692015-06-09 14:09:14 +02001716std::ostream& operator<<(std::ostream& os, const StackedShadowFrameType& thread);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001717
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001718} // namespace art
1719
Brian Carlstromfc0e3212013-07-17 14:40:12 -07001720#endif // ART_RUNTIME_THREAD_H_