blob: 5db089f3398b42d3922344081295aea581e8dd3b [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
David Srbecky28f6cff2018-10-16 15:07:28 +010020#include <atomic>
Elliott Hughes02b48d12011-09-07 17:15:51 -070021#include <bitset>
Ian Rogers306057f2012-11-26 12:45:53 -080022#include <deque>
Elliott Hughesa0957642011-09-02 14:27:33 -070023#include <iosfwd>
Ian Rogersb033c752011-07-20 12:22:35 -070024#include <list>
Ian Rogers700a4022014-05-19 16:49:03 -070025#include <memory>
Elliott Hughes8daa0922011-09-11 13:46:25 -070026#include <string>
Carl Shapirob5573532011-07-12 18:22:59 -070027
David Sehrc431b9d2018-03-02 12:01:51 -080028#include "base/atomic.h"
Andreas Gampe542451c2016-07-26 09:02:02 -070029#include "base/enums.h"
Andreas Gampe7fbc4a52018-11-28 08:26:47 -080030#include "base/locks.h"
Elliott Hughes76160052012-12-12 16:31:20 -080031#include "base/macros.h"
Alex Light184f0752018-07-13 11:18:22 -070032#include "base/safe_map.h"
Andreas Gampea1ffdba2019-01-04 16:08:51 -080033#include "base/value_object.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"
Alex Lightb7c640d2019-03-20 15:52:13 -070036#include "handle.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070037#include "handle_scope.h"
David Srbecky912f36c2018-09-08 12:22:58 +010038#include "interpreter/interpreter_cache.h"
Ian Rogers306057f2012-11-26 12:45:53 -080039#include "jvalue.h"
Andreas Gampe513061a2017-06-01 09:17:34 -070040#include "managed_stack.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070041#include "offsets.h"
Andreas Gampe217488a2017-09-18 08:34:42 -070042#include "read_barrier_config.h"
Andreas Gampe5a0430d2019-01-04 14:33:57 -080043#include "runtime_globals.h"
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070044#include "runtime_stats.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 {
Igor Murashkin2ffb7032017-11-08 13:35:21 -080053template<class T> class AtomicStack;
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -070054} // namespace accounting
Mathieu Chartier15d34022014-02-26 17:16:38 -080055namespace collector {
Igor Murashkin2ffb7032017-11-08 13:35:21 -080056class SemiSpace;
Mathieu Chartier15d34022014-02-26 17:16:38 -080057} // namespace collector
58} // namespace gc
59
Andreas Gamped77abd92019-01-02 16:10:20 -080060namespace instrumentation {
61struct InstrumentationStackFrame;
62} // namespace instrumentation
63
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080064namespace mirror {
Igor Murashkin2ffb7032017-11-08 13:35:21 -080065class Array;
66class Class;
67class ClassLoader;
68class Object;
69template<class T> class ObjectArray;
70template<class T> class PrimitiveArray;
71typedef PrimitiveArray<int32_t> IntArray;
72class StackTraceElement;
73class String;
74class Throwable;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080075} // namespace mirror
Mathieu Chartier12d625f2015-03-13 11:33:37 -070076
77namespace verifier {
Igor Murashkin2ffb7032017-11-08 13:35:21 -080078class MethodVerifier;
79class VerifierDeps;
Mathieu Chartier12d625f2015-03-13 11:33:37 -070080} // namespace verifier
81
Mathieu Chartiere401d142015-04-22 13:56:20 -070082class ArtMethod;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080083class BaseMutex;
84class ClassLinker;
Ian Rogers7a22fa62013-01-23 12:16:16 -080085class Closure;
Ian Rogersbdb03912011-09-14 00:55:44 -070086class Context;
Ian Rogers1b09b092012-08-20 15:35:52 -070087struct DebugInvokeReq;
Sebastien Hertz07474662015-08-25 15:12:33 +000088class DeoptimizationContextRecord;
Ian Rogers81d425b2012-09-27 16:03:43 -070089class DexFile;
Mingyao Yang99170c62015-07-06 11:10:37 -070090class FrameIdToShadowFrame;
Ian Rogersb48b9eb2014-02-28 16:20:21 -080091class JavaVMExt;
Ian Rogers55256cb2017-12-21 17:07:11 -080092class JNIEnvExt;
Elliott Hughes8daa0922011-09-11 13:46:25 -070093class Monitor;
Andreas Gampe513061a2017-06-01 09:17:34 -070094class RootVisitor;
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -070095class ScopedObjectAccessAlreadyRunnable;
Logan Chienf7ad17e2012-03-15 03:10:03 +080096class ShadowFrame;
Sebastien Hertz597c4f02015-01-26 17:37:14 +010097class SingleStepControl;
Sebastien Hertzf7958692015-06-09 14:09:14 +020098class StackedShadowFrameRecord;
Andreas Gampe0c2313c2019-05-14 09:47:00 -070099enum class SuspendReason : char;
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700100class Thread;
101class ThreadList;
Andreas Gampe513061a2017-06-01 09:17:34 -0700102enum VisitRootFlags : uint8_t;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700103
Alex Light184f0752018-07-13 11:18:22 -0700104// A piece of data that can be held in the CustomTls. The destructor will be called during thread
105// shutdown. The thread the destructor is called on is not necessarily the same thread it was stored
106// on.
107class TLSData {
108 public:
109 virtual ~TLSData() {}
110};
111
Elliott Hughes34e06962012-04-09 13:55:55 -0700112// Thread priorities. These must match the Thread.MIN_PRIORITY,
113// Thread.NORM_PRIORITY, and Thread.MAX_PRIORITY constants.
114enum ThreadPriority {
115 kMinThreadPriority = 1,
116 kNormThreadPriority = 5,
117 kMaxThreadPriority = 10,
118};
119
Ian Rogers474b6da2012-09-25 00:20:38 -0700120enum ThreadFlag {
Ian Rogers50ffee22012-11-20 11:47:44 -0800121 kSuspendRequest = 1, // If set implies that suspend_count_ > 0 and the Thread should enter the
122 // safepoint handler.
Yu Lieac44242015-06-29 10:50:03 +0800123 kCheckpointRequest = 2, // Request that the thread do some checkpoint work and then continue.
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700124 kEmptyCheckpointRequest = 4, // Request that the thread do empty checkpoint and then continue.
125 kActiveSuspendBarrier = 8, // Register that at least 1 suspend barrier needs to be passed.
Ian Rogers474b6da2012-09-25 00:20:38 -0700126};
127
Sebastien Hertzf7958692015-06-09 14:09:14 +0200128enum class StackedShadowFrameType {
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700129 kShadowFrameUnderConstruction,
Andreas Gampe639bdd12015-06-03 11:22:45 -0700130 kDeoptimizationShadowFrame,
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -0700131};
132
Mingyao Yang2ee17902017-08-30 11:37:08 -0700133// The type of method that triggers deoptimization. It contains info on whether
134// the deoptimized method should advance dex_pc.
135enum class DeoptimizationMethodType {
136 kKeepDexPc, // dex pc is required to be kept upon deoptimization.
137 kDefault // dex pc may or may not advance depending on other conditions.
138};
139
Hiroshi Yamauchi7ed9c562016-02-02 15:22:09 -0800140// This should match RosAlloc::kNumThreadLocalSizeBrackets.
141static constexpr size_t kNumRosAllocThreadLocalSizeBracketsInThread = 16;
Ian Rogerse63db272014-07-15 15:36:11 -0700142
Dave Allison648d7112014-07-25 16:15:27 -0700143// Thread's stack layout for implicit stack overflow checks:
144//
145// +---------------------+ <- highest address of stack memory
146// | |
147// . . <- SP
148// | |
149// | |
150// +---------------------+ <- stack_end
151// | |
152// | Gap |
153// | |
154// +---------------------+ <- stack_begin
155// | |
156// | Protected region |
157// | |
158// +---------------------+ <- lowest address of stack memory
159//
160// The stack always grows down in memory. At the lowest address is a region of memory
161// that is set mprotect(PROT_NONE). Any attempt to read/write to this region will
162// result in a segmentation fault signal. At any point, the thread's SP will be somewhere
163// between the stack_end and the highest address in stack memory. An implicit stack
164// overflow check is a read of memory at a certain offset below the current SP (4K typically).
165// If the thread's SP is below the stack_end address this will be a read into the protected
166// region. If the SP is above the stack_end address, the thread is guaranteed to have
167// at least 4K of space. Because stack overflow checks are only performed in generated code,
168// if the thread makes a call out to a native function (through JNI), that native function
169// might only have 4K of memory (if the SP is adjacent to stack_end).
170
Ian Rogersdd7624d2014-03-14 17:43:00 -0700171class Thread {
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700172 public:
Andreas Gampe7ea6f792014-07-14 16:21:44 -0700173 static const size_t kStackOverflowImplicitCheckSize;
Andreas Gampeb486a982017-06-01 13:45:54 -0700174 static constexpr bool kVerifyStack = kIsDebugBuild;
Dave Allisonf9439142014-03-27 15:10:22 -0700175
Elliott Hughes462c9442012-03-23 18:47:50 -0700176 // Creates a new native thread corresponding to the given managed peer.
177 // Used to implement Thread.start.
Ian Rogers52673ff2012-06-27 23:25:34 -0700178 static void CreateNativeThread(JNIEnv* env, jobject peer, size_t stack_size, bool daemon);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700179
Elliott Hughes462c9442012-03-23 18:47:50 -0700180 // Attaches the calling native thread to the runtime, returning the new native peer.
181 // Used to implement JNI AttachCurrentThread and AttachCurrentThreadAsDaemon calls.
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800182 static Thread* Attach(const char* thread_name, bool as_daemon, jobject thread_group,
183 bool create_peer);
Andreas Gampe732b0ac2017-01-18 15:23:39 -0800184 // Attaches the calling native thread to the runtime, returning the new native peer.
185 static Thread* Attach(const char* thread_name, bool as_daemon, jobject thread_peer);
Carl Shapirob5573532011-07-12 18:22:59 -0700186
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700187 // Reset internal state of child thread after fork.
188 void InitAfterFork();
189
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700190 // Get the currently executing thread, frequently referred to as 'self'. This call has reasonably
191 // high cost and so we favor passing self around when possible.
192 // TODO: mark as PURE so the compiler may coalesce and remove?
Ian Rogers02ed4c02013-09-06 13:10:04 -0700193 static Thread* Current();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700194
Ian Rogers7b078e82014-09-10 14:44:24 -0700195 // On a runnable thread, check for pending thread suspension request and handle if pending.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700196 void AllowThreadSuspension() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers7b078e82014-09-10 14:44:24 -0700197
198 // Process pending thread suspension request and handle if pending.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700199 void CheckSuspend() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers7b078e82014-09-10 14:44:24 -0700200
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700201 // Process a pending empty checkpoint if pending.
Hiroshi Yamauchia2224042017-02-08 16:35:45 -0800202 void CheckEmptyCheckpointFromWeakRefAccess(BaseMutex* cond_var_mutex);
203 void CheckEmptyCheckpointFromMutex();
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700204
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700205 static Thread* FromManagedThread(const ScopedObjectAccessAlreadyRunnable& ts,
Mathieu Chartierf5769e12017-01-10 15:54:41 -0800206 ObjPtr<mirror::Object> thread_peer)
Mathieu Chartier90443472015-07-16 20:32:27 -0700207 REQUIRES(Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700208 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700209 static Thread* FromManagedThread(const ScopedObjectAccessAlreadyRunnable& ts, jobject thread)
Mathieu Chartier90443472015-07-16 20:32:27 -0700210 REQUIRES(Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700211 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700212
Elliott Hughes28fa76d2012-04-09 17:31:46 -0700213 // Translates 172 to pAllocArrayFromCode and so on.
Andreas Gampe542451c2016-07-26 09:02:02 -0700214 template<PointerSize size_of_pointers>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700215 static void DumpThreadOffset(std::ostream& os, uint32_t offset);
Elliott Hughes28fa76d2012-04-09 17:31:46 -0700216
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700217 // Dumps a one-line summary of thread state (used for operator<<).
218 void ShortDump(std::ostream& os) const;
219
220 // Dumps the detailed thread state and the thread stack (used for SIGQUIT).
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000221 void Dump(std::ostream& os,
Nicolas Geoffray6ee49712018-03-30 14:39:05 +0000222 bool dump_native_stack = true,
Hiroshi Yamauchi13c16352017-01-31 10:15:08 -0800223 BacktraceMap* backtrace_map = nullptr,
224 bool force_dump_stack = false) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700225 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesa0957642011-09-02 14:27:33 -0700226
Hiroshi Yamauchi02f365f2017-02-03 15:06:00 -0800227 void DumpJavaStack(std::ostream& os,
228 bool check_suspended = true,
229 bool dump_locks = true) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700230 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierc751fdc2014-03-30 15:25:44 -0700231
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700232 // Dumps the SIGQUIT per-thread header. 'thread' can be null for a non-attached thread, in which
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700233 // 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 -0700234 static void DumpState(std::ostream& os, const Thread* thread, pid_t tid)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700235 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesabbe07d2012-06-05 17:42:23 -0700236
Ian Rogers474b6da2012-09-25 00:20:38 -0700237 ThreadState GetState() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700238 DCHECK_GE(tls32_.state_and_flags.as_struct.state, kTerminated);
239 DCHECK_LE(tls32_.state_and_flags.as_struct.state, kSuspended);
240 return static_cast<ThreadState>(tls32_.state_and_flags.as_struct.state);
Dave Allison0aded082013-11-07 13:15:11 -0800241 }
242
Ian Rogers474b6da2012-09-25 00:20:38 -0700243 ThreadState SetState(ThreadState new_state);
Ian Rogers52673ff2012-06-27 23:25:34 -0700244
Mathieu Chartier90443472015-07-16 20:32:27 -0700245 int GetSuspendCount() const REQUIRES(Locks::thread_suspend_count_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700246 return tls32_.suspend_count;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700247 }
Elliott Hughes038a8062011-09-18 14:12:41 -0700248
Alex Light88fd7202017-06-30 08:31:59 -0700249 int GetUserCodeSuspendCount() const REQUIRES(Locks::thread_suspend_count_lock_,
250 Locks::user_code_suspension_lock_) {
251 return tls32_.user_code_suspend_count;
252 }
253
Mathieu Chartier90443472015-07-16 20:32:27 -0700254 int GetDebugSuspendCount() const REQUIRES(Locks::thread_suspend_count_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700255 return tls32_.debug_suspend_count;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700256 }
257
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700258 bool IsSuspended() const {
Chris Dearman59cde532013-12-04 18:53:49 -0800259 union StateAndFlags state_and_flags;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700260 state_and_flags.as_int = tls32_.state_and_flags.as_int;
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700261 return state_and_flags.as_struct.state != kRunnable &&
262 (state_and_flags.as_struct.flags & kSuspendRequest) != 0;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700263 }
264
Hiroshi Yamauchi02e7f1a2016-10-03 15:32:01 -0700265 // If delta > 0 and (this != self or suspend_barrier is not null), this function may temporarily
266 // release thread_suspend_count_lock_ internally.
267 ALWAYS_INLINE
268 bool ModifySuspendCount(Thread* self,
269 int delta,
270 AtomicInteger* suspend_barrier,
Alex Light46f93402017-06-29 11:59:50 -0700271 SuspendReason reason)
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +0200272 WARN_UNUSED
Mathieu Chartier90443472015-07-16 20:32:27 -0700273 REQUIRES(Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700274
Alex Light318afe62018-03-22 16:50:10 -0700275 // Requests a checkpoint closure to run on another thread. The closure will be run when the thread
276 // gets suspended. This will return true if the closure was added and will (eventually) be
277 // executed. It returns false otherwise.
278 //
279 // Since multiple closures can be queued and some closures can delay other threads from running no
280 // closure should attempt to suspend another thread while running.
281 // TODO We should add some debug option that verifies this.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700282 bool RequestCheckpoint(Closure* function)
Mathieu Chartier90443472015-07-16 20:32:27 -0700283 REQUIRES(Locks::thread_suspend_count_lock_);
Alex Lightb1e31a82017-10-04 16:57:36 -0700284
285 // RequestSynchronousCheckpoint releases the thread_list_lock_ as a part of its execution. This is
286 // due to the fact that Thread::Current() needs to go to sleep to allow the targeted thread to
Alex Light318afe62018-03-22 16:50:10 -0700287 // execute the checkpoint for us if it is Runnable. The suspend_state is the state that the thread
288 // will go into while it is awaiting the checkpoint to be run.
289 // NB Passing ThreadState::kRunnable may cause the current thread to wait in a condition variable
290 // while holding the mutator_lock_. Callers should ensure that this will not cause any problems
291 // for the closure or the rest of the system.
292 // NB Since multiple closures can be queued and some closures can delay other threads from running
293 // no closure should attempt to suspend another thread while running.
294 bool RequestSynchronousCheckpoint(Closure* function,
295 ThreadState suspend_state = ThreadState::kWaiting)
Andreas Gampe28c4a232017-06-21 21:21:31 -0700296 REQUIRES_SHARED(Locks::mutator_lock_)
Alex Lightb1e31a82017-10-04 16:57:36 -0700297 RELEASE(Locks::thread_list_lock_)
Andreas Gampe28c4a232017-06-21 21:21:31 -0700298 REQUIRES(!Locks::thread_suspend_count_lock_);
Alex Light318afe62018-03-22 16:50:10 -0700299
Hiroshi Yamauchi30493242016-11-03 13:06:52 -0700300 bool RequestEmptyCheckpoint()
301 REQUIRES(Locks::thread_suspend_count_lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700302
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800303 void SetFlipFunction(Closure* function);
304 Closure* GetFlipFunction();
305
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -0700306 gc::accounting::AtomicStack<mirror::Object>* GetThreadLocalMarkStack() {
307 CHECK(kUseReadBarrier);
308 return tlsPtr_.thread_local_mark_stack;
309 }
310 void SetThreadLocalMarkStack(gc::accounting::AtomicStack<mirror::Object>* stack) {
311 CHECK(kUseReadBarrier);
312 tlsPtr_.thread_local_mark_stack = stack;
313 }
314
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700315 // Called when thread detected that the thread_suspend_count_ was non-zero. Gives up share of
316 // mutator_lock_ and waits until it is resumed and thread_suspend_count_ is zero.
Ian Rogers9da7f592012-08-20 17:14:28 -0700317 void FullSuspendCheck()
Mathieu Chartier90443472015-07-16 20:32:27 -0700318 REQUIRES(!Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700319 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700320
321 // Transition from non-runnable to runnable state acquiring share on mutator_lock_.
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700322 ALWAYS_INLINE ThreadState TransitionFromSuspendedToRunnable()
Mathieu Chartier90443472015-07-16 20:32:27 -0700323 REQUIRES(!Locks::thread_suspend_count_lock_)
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700324 SHARED_LOCK_FUNCTION(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700325
326 // Transition from runnable into a state where mutator privileges are denied. Releases share of
327 // mutator lock.
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700328 ALWAYS_INLINE void TransitionFromRunnableToSuspended(ThreadState new_state)
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700329 REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_)
Mathieu Chartier8ac9c912015-10-01 15:58:41 -0700330 UNLOCK_FUNCTION(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700331
Ian Rogers0399dde2012-06-06 17:09:28 -0700332 // Once called thread suspension will cause an assertion failure.
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700333 const char* StartAssertNoThreadSuspension(const char* cause) ACQUIRE(Roles::uninterruptible_) {
334 Roles::uninterruptible_.Acquire(); // No-op.
Mathieu Chartier590fee92013-09-13 13:46:47 -0700335 if (kIsDebugBuild) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700336 CHECK(cause != nullptr);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700337 const char* previous_cause = tlsPtr_.last_no_thread_suspension_cause;
338 tls32_.no_thread_suspension++;
339 tlsPtr_.last_no_thread_suspension_cause = cause;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700340 return previous_cause;
341 } else {
342 return nullptr;
343 }
Ian Rogers0399dde2012-06-06 17:09:28 -0700344 }
Ian Rogers52673ff2012-06-27 23:25:34 -0700345
Ian Rogers0399dde2012-06-06 17:09:28 -0700346 // End region where no thread suspension is expected.
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700347 void EndAssertNoThreadSuspension(const char* old_cause) RELEASE(Roles::uninterruptible_) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700348 if (kIsDebugBuild) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700349 CHECK(old_cause != nullptr || tls32_.no_thread_suspension == 1);
350 CHECK_GT(tls32_.no_thread_suspension, 0U);
351 tls32_.no_thread_suspension--;
352 tlsPtr_.last_no_thread_suspension_cause = old_cause;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700353 }
Mathieu Chartier4e2cb092015-07-22 16:17:51 -0700354 Roles::uninterruptible_.Release(); // No-op.
Ian Rogers0399dde2012-06-06 17:09:28 -0700355 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700356
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700357 void AssertThreadSuspensionIsAllowable(bool check_locks = true) const;
Ian Rogers0399dde2012-06-06 17:09:28 -0700358
Mathieu Chartier10b218d2016-07-25 17:48:52 -0700359 // Return true if thread suspension is allowable.
360 bool IsThreadSuspensionAllowable() const;
361
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700362 bool IsDaemon() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700363 return tls32_.daemon;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700364 }
365
Mathieu Chartier14c3bf92015-07-13 14:35:43 -0700366 size_t NumberOfHeldMutexes() const;
367
Mathieu Chartierf5769e12017-01-10 15:54:41 -0800368 bool HoldsLock(ObjPtr<mirror::Object> object) const REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes5f791332011-09-15 17:45:30 -0700369
Elliott Hughes8daa0922011-09-11 13:46:25 -0700370 /*
371 * Changes the priority of this thread to match that of the java.lang.Thread object.
372 *
373 * We map a priority value from 1-10 to Linux "nice" values, where lower
374 * numbers indicate higher priority.
375 */
376 void SetNativePriority(int newPriority);
377
378 /*
379 * Returns the thread priority for the current thread by querying the system.
380 * This is useful when attaching a thread through JNI.
381 *
382 * Returns a value from 1 to 10 (compatible with java.lang.Thread values).
383 */
384 static int GetNativePriority();
385
Mathieu Chartier61b3cd42016-04-18 11:43:29 -0700386 // Guaranteed to be non-zero.
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700387 uint32_t GetThreadId() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700388 return tls32_.thin_lock_thread_id;
Carl Shapirob5573532011-07-12 18:22:59 -0700389 }
390
Elliott Hughesd92bec42011-09-02 17:04:36 -0700391 pid_t GetTid() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700392 return tls32_.tid;
Elliott Hughesd92bec42011-09-02 17:04:36 -0700393 }
Elliott Hughese27955c2011-08-26 15:21:24 -0700394
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700395 // Returns the java.lang.Thread's name, or null if this Thread* doesn't have a peer.
Vladimir Marko4617d582019-03-28 13:48:31 +0000396 ObjPtr<mirror::String> GetThreadName() const REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes899e7892012-01-24 14:57:32 -0800397
Elliott Hughesffb465f2012-03-01 18:46:05 -0800398 // Sets 'name' to the java.lang.Thread's name. This requires no transition to managed code,
399 // allocation, or locking.
400 void GetThreadName(std::string& name) const;
401
Elliott Hughes899e7892012-01-24 14:57:32 -0800402 // Sets the thread's name.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700403 void SetThreadName(const char* name) REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesfc861622011-10-17 17:57:47 -0700404
Jeff Hao57dac6e2013-08-15 16:36:24 -0700405 // Returns the thread-specific CPU-time clock in microseconds or -1 if unavailable.
406 uint64_t GetCpuMicroTime() const;
407
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700408 mirror::Object* GetPeer() const REQUIRES_SHARED(Locks::mutator_lock_) {
Nicolas Geoffrayffc8cad2017-02-10 10:59:22 +0000409 DCHECK(Thread::Current() == this) << "Use GetPeerFromOtherThread instead";
Ian Rogersdd7624d2014-03-14 17:43:00 -0700410 CHECK(tlsPtr_.jpeer == nullptr);
411 return tlsPtr_.opeer;
Elliott Hughes8daa0922011-09-11 13:46:25 -0700412 }
Andreas Gampe202f85a2017-02-06 10:23:26 -0800413 // GetPeer is not safe if called on another thread in the middle of the CC thread flip and
414 // the thread's stack may have not been flipped yet and peer may be a from-space (stale) ref.
415 // This function will explicitly mark/forward it.
416 mirror::Object* GetPeerFromOtherThread() const REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes8daa0922011-09-11 13:46:25 -0700417
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700418 bool HasPeer() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700419 return tlsPtr_.jpeer != nullptr || tlsPtr_.opeer != nullptr;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700420 }
421
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700422 RuntimeStats* GetStats() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700423 return &tls64_.stats;
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700424 }
425
Elliott Hughes7dc51662012-05-16 14:48:43 -0700426 bool IsStillStarting() const;
427
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700428 bool IsExceptionPending() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700429 return tlsPtr_.exception != nullptr;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700430 }
431
Alex Light848574c2017-09-25 16:59:39 -0700432 bool IsAsyncExceptionPending() const {
433 return tlsPtr_.async_exception != nullptr;
434 }
435
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700436 mirror::Throwable* GetException() const REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700437 return tlsPtr_.exception;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700438 }
439
Andreas Gamped9efea62014-07-21 22:56:08 -0700440 void AssertPendingException() const;
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700441 void AssertPendingOOMException() const REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700442 void AssertNoPendingException() const;
Mathieu Chartier8d7672e2014-02-25 10:57:16 -0800443 void AssertNoPendingExceptionForNewException(const char* msg) const;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700444
Mathieu Chartier0795f232016-09-27 18:43:30 -0700445 void SetException(ObjPtr<mirror::Throwable> new_exception) REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700446
Alex Light848574c2017-09-25 16:59:39 -0700447 // Set an exception that is asynchronously thrown from a different thread. This will be checked
448 // periodically and might overwrite the current 'Exception'. This can only be called from a
449 // checkpoint.
450 //
451 // The caller should also make sure that the thread has been deoptimized so that the exception
452 // could be detected on back-edges.
453 void SetAsyncException(ObjPtr<mirror::Throwable> new_exception)
454 REQUIRES_SHARED(Locks::mutator_lock_);
455
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700456 void ClearException() REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700457 tlsPtr_.exception = nullptr;
jeffhao94d6df42012-11-26 16:02:12 -0800458 }
459
Alex Light848574c2017-09-25 16:59:39 -0700460 // Move the current async-exception to the main exception. This should be called when the current
461 // thread is ready to deal with any async exceptions. Returns true if there is an async exception
462 // that needs to be dealt with, false otherwise.
463 bool ObserveAsyncException() REQUIRES_SHARED(Locks::mutator_lock_);
464
Ian Rogersbdb03912011-09-14 00:55:44 -0700465 // Find catch block and perform long jump to appropriate exception handle
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700466 NO_RETURN void QuickDeliverException() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersbdb03912011-09-14 00:55:44 -0700467
468 Context* GetLongJumpContext();
Ian Rogers0399dde2012-06-06 17:09:28 -0700469 void ReleaseLongJumpContext(Context* context) {
Mingyao Yang4dcfc432015-04-21 16:55:22 -0700470 if (tlsPtr_.long_jump_context != nullptr) {
Andreas Gampee5d23982019-01-08 10:34:26 -0800471 ReleaseLongJumpContextInternal();
Mingyao Yang4dcfc432015-04-21 16:55:22 -0700472 }
Ian Rogersdd7624d2014-03-14 17:43:00 -0700473 tlsPtr_.long_jump_context = context;
Shih-wei Liao1a18c8c2011-08-14 17:47:36 -0700474 }
475
Andreas Gampe6ec8ebd2014-07-25 13:36:56 -0700476 // Get the current method and dex pc. If there are errors in retrieving the dex pc, this will
477 // abort the runtime iff abort_on_error is true.
Hiroshi Yamauchi02f365f2017-02-03 15:06:00 -0800478 ArtMethod* GetCurrentMethod(uint32_t* dex_pc,
479 bool check_suspended = true,
480 bool abort_on_error = true) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700481 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700482
Nicolas Geoffray7642cfc2015-02-26 10:56:09 +0000483 // Returns whether the given exception was thrown by the current Java method being executed
484 // (Note that this includes native Java methods).
Mathieu Chartierf5769e12017-01-10 15:54:41 -0800485 bool IsExceptionThrownByCurrentMethod(ObjPtr<mirror::Throwable> exception) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700486 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray7642cfc2015-02-26 10:56:09 +0000487
Mathieu Chartiere401d142015-04-22 13:56:20 -0700488 void SetTopOfStack(ArtMethod** top_method) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700489 tlsPtr_.managed_stack.SetTopQuickFrame(top_method);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700490 }
491
Vladimir Marko2196c652017-11-30 16:16:07 +0000492 void SetTopOfStackTagged(ArtMethod** top_method) {
493 tlsPtr_.managed_stack.SetTopQuickFrameTagged(top_method);
494 }
495
Jeff Hao11ffc2d2013-02-01 11:52:17 -0800496 void SetTopOfShadowStack(ShadowFrame* top) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700497 tlsPtr_.managed_stack.SetTopShadowFrame(top);
Jeff Hao11ffc2d2013-02-01 11:52:17 -0800498 }
499
Ian Rogers0399dde2012-06-06 17:09:28 -0700500 bool HasManagedStack() const {
Vladimir Marko2196c652017-11-30 16:16:07 +0000501 return tlsPtr_.managed_stack.HasTopQuickFrame() || tlsPtr_.managed_stack.HasTopShadowFrame();
Ian Rogersbdb03912011-09-14 00:55:44 -0700502 }
503
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700504 // If 'msg' is null, no detail message is set.
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000505 void ThrowNewException(const char* exception_class_descriptor, const char* msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700506 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughes5cb5ad22011-10-02 12:13:39 -0700507
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700508 // If 'msg' is null, no detail message is set. An exception must be pending, and will be
Elliott Hughesa4f94742012-05-29 16:28:38 -0700509 // used as the new exception's cause.
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000510 void ThrowNewWrappedException(const char* exception_class_descriptor, const char* msg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700511 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughesa4f94742012-05-29 16:28:38 -0700512
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000513 void ThrowNewExceptionF(const char* exception_class_descriptor, const char* fmt, ...)
514 __attribute__((format(printf, 3, 4)))
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700515 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughesa5b897e2011-08-16 11:33:06 -0700516
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +0000517 void ThrowNewExceptionV(const char* exception_class_descriptor, const char* fmt, va_list ap)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700518 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
Elliott Hughes4a2b4172011-09-20 17:08:25 -0700519
Elliott Hughes2ced6a52011-10-16 18:44:48 -0700520 // OutOfMemoryError is special, because we need to pre-allocate an instance.
Elliott Hughes8a8b9cb2012-04-13 18:29:22 -0700521 // Only the GC should call this.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700522 void ThrowOutOfMemoryError(const char* msg) REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartiered8990a2015-07-23 14:11:16 -0700523 REQUIRES(!Roles::uninterruptible_);
Elliott Hughes79082e32011-08-25 12:07:32 -0700524
Elliott Hughesbe759c62011-09-08 19:38:21 -0700525 static void Startup();
Elliott Hughes038a8062011-09-18 14:12:41 -0700526 static void FinishStartup();
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700527 static void Shutdown();
Carl Shapirob5573532011-07-12 18:22:59 -0700528
Andreas Gampe56776012018-01-26 17:40:55 -0800529 // Notify this thread's thread-group that this thread has started.
530 // Note: the given thread-group is used as a fast path and verified in debug build. If the value
531 // is null, the thread's thread-group is loaded from the peer.
532 void NotifyThreadGroup(ScopedObjectAccessAlreadyRunnable& soa, jobject thread_group = nullptr)
533 REQUIRES_SHARED(Locks::mutator_lock_);
534
Ian Rogersb033c752011-07-20 12:22:35 -0700535 // JNI methods
Elliott Hughes69f5bc62011-08-24 09:26:14 -0700536 JNIEnvExt* GetJniEnv() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700537 return tlsPtr_.jni_env;
Ian Rogersb033c752011-07-20 12:22:35 -0700538 }
539
Ian Rogers408f79a2011-08-23 18:22:33 -0700540 // Convert a jobject into a Object*
Mathieu Chartierc4f39252016-10-05 18:32:08 -0700541 ObjPtr<mirror::Object> DecodeJObject(jobject obj) const REQUIRES_SHARED(Locks::mutator_lock_);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -0800542 // Checks if the weak global ref has been cleared by the GC without decoding it.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700543 bool IsJWeakCleared(jweak obj) const REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersb033c752011-07-20 12:22:35 -0700544
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700545 mirror::Object* GetMonitorEnterObject() const REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700546 return tlsPtr_.monitor_enter_object;
547 }
548
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700549 void SetMonitorEnterObject(mirror::Object* obj) REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700550 tlsPtr_.monitor_enter_object = obj;
551 }
552
Elliott Hughes8daa0922011-09-11 13:46:25 -0700553 // Implements java.lang.Thread.interrupted.
Nicolas Geoffray365719c2017-03-08 13:11:50 +0000554 bool Interrupted();
Elliott Hughes8daa0922011-09-11 13:46:25 -0700555 // Implements java.lang.Thread.isInterrupted.
Nicolas Geoffray365719c2017-03-08 13:11:50 +0000556 bool IsInterrupted();
Andreas Gampe7fbc4a52018-11-28 08:26:47 -0800557 void Interrupt(Thread* self) REQUIRES(!wait_mutex_);
Nicolas Geoffray365719c2017-03-08 13:11:50 +0000558 void SetInterrupted(bool i) {
Orion Hodson88591fe2018-03-06 13:35:43 +0000559 tls32_.interrupted.store(i, std::memory_order_seq_cst);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700560 }
Andreas Gampe7fbc4a52018-11-28 08:26:47 -0800561 void Notify() REQUIRES(!wait_mutex_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700562
Mathieu Chartier3f7f03c2016-09-26 11:39:52 -0700563 ALWAYS_INLINE void PoisonObjectPointers() {
564 ++poison_object_cookie_;
565 }
566
Mathieu Chartiera59d9b22016-09-26 18:13:17 -0700567 ALWAYS_INLINE static void PoisonObjectPointersIfDebug();
568
Mathieu Chartier3f7f03c2016-09-26 11:39:52 -0700569 ALWAYS_INLINE uintptr_t GetPoisonObjectCookie() const {
570 return poison_object_cookie_;
571 }
572
Charles Mungeraa31f492018-11-01 18:57:38 +0000573 // Parking for 0ns of relative time means an untimed park, negative (though
574 // should be handled in java code) returns immediately
575 void Park(bool is_absolute, int64_t time) REQUIRES_SHARED(Locks::mutator_lock_);
576 void Unpark();
577
Ian Rogersdd7624d2014-03-14 17:43:00 -0700578 private:
Mathieu Chartier90443472015-07-16 20:32:27 -0700579 void NotifyLocked(Thread* self) REQUIRES(wait_mutex_);
Ian Rogersdd7624d2014-03-14 17:43:00 -0700580
581 public:
582 Mutex* GetWaitMutex() const LOCK_RETURNED(wait_mutex_) {
583 return wait_mutex_;
584 }
585
Mathieu Chartier90443472015-07-16 20:32:27 -0700586 ConditionVariable* GetWaitConditionVariable() const REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700587 return wait_cond_;
588 }
589
Mathieu Chartier90443472015-07-16 20:32:27 -0700590 Monitor* GetWaitMonitor() const REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700591 return wait_monitor_;
592 }
593
Mathieu Chartier90443472015-07-16 20:32:27 -0700594 void SetWaitMonitor(Monitor* mon) REQUIRES(wait_mutex_) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700595 wait_monitor_ = mon;
596 }
597
Ian Rogersdd7624d2014-03-14 17:43:00 -0700598 // Waiter link-list support.
599 Thread* GetWaitNext() const {
600 return tlsPtr_.wait_next;
601 }
602
603 void SetWaitNext(Thread* next) {
604 tlsPtr_.wait_next = next;
605 }
Elliott Hughes5f791332011-09-15 17:45:30 -0700606
Ian Rogers68d8b422014-07-17 11:09:10 -0700607 jobject GetClassLoaderOverride() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700608 return tlsPtr_.class_loader_override;
buzbeec143c552011-08-20 17:38:58 -0700609 }
610
Ian Rogers68d8b422014-07-17 11:09:10 -0700611 void SetClassLoaderOverride(jobject class_loader_override);
buzbeec143c552011-08-20 17:38:58 -0700612
Ian Rogersaaa20802011-09-11 21:47:37 -0700613 // Create the internal representation of a stack trace, that is more time
Sebastien Hertzee1d79a2014-02-21 15:46:30 +0100614 // and space efficient to compute than the StackTraceElement[].
615 template<bool kTransactionActive>
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700616 jobject CreateInternalStackTrace(const ScopedObjectAccessAlreadyRunnable& soa) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700617 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersaaa20802011-09-11 21:47:37 -0700618
Elliott Hughes01158d72011-09-19 19:47:10 -0700619 // Convert an internal stack trace representation (returned by CreateInternalStackTrace) to a
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700620 // StackTraceElement[]. If output_array is null, a new array is created, otherwise as many
621 // 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 -0700622 // with the number of valid frames in the returned array.
Mathieu Chartier2b7c4d12014-05-19 10:52:16 -0700623 static jobjectArray InternalStackTraceToStackTraceElementArray(
624 const ScopedObjectAccessAlreadyRunnable& soa, jobject internal,
625 jobjectArray output_array = nullptr, int* stack_depth = nullptr)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700626 REQUIRES_SHARED(Locks::mutator_lock_);
Shih-wei Liao55df06b2011-08-26 14:39:27 -0700627
Andreas Gampefb6b0b12017-12-11 20:47:56 -0800628 jobjectArray CreateAnnotatedStackTrace(const ScopedObjectAccessAlreadyRunnable& soa) const
629 REQUIRES_SHARED(Locks::mutator_lock_);
630
Mingyao Yang99170c62015-07-06 11:10:37 -0700631 bool HasDebuggerShadowFrames() const {
632 return tlsPtr_.frame_id_to_shadow_frame != nullptr;
633 }
634
Andreas Gampe513061a2017-06-01 09:17:34 -0700635 void VisitRoots(RootVisitor* visitor, VisitRootFlags flags)
Andreas Gampe585da952016-12-02 14:52:29 -0800636 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes410c0c82011-09-01 17:58:25 -0700637
Andreas Gampeb486a982017-06-01 13:45:54 -0700638 void VerifyStack() REQUIRES_SHARED(Locks::mutator_lock_) {
639 if (kVerifyStack) {
640 VerifyStackImpl();
641 }
642 }
jeffhao25045522012-03-13 19:34:37 -0700643
Elliott Hughesbe759c62011-09-08 19:38:21 -0700644 //
645 // Offsets of various members of native Thread class, used by compiled code.
646 //
647
Andreas Gampe542451c2016-07-26 09:02:02 -0700648 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100649 static constexpr ThreadOffset<pointer_size> ThinLockIdOffset() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700650 return ThreadOffset<pointer_size>(
651 OFFSETOF_MEMBER(Thread, tls32_) +
652 OFFSETOF_MEMBER(tls_32bit_sized_values, thin_lock_thread_id));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700653 }
654
Andreas Gampe542451c2016-07-26 09:02:02 -0700655 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100656 static constexpr ThreadOffset<pointer_size> InterruptedOffset() {
Nicolas Geoffray365719c2017-03-08 13:11:50 +0000657 return ThreadOffset<pointer_size>(
658 OFFSETOF_MEMBER(Thread, tls32_) +
659 OFFSETOF_MEMBER(tls_32bit_sized_values, interrupted));
660 }
661
662 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100663 static constexpr ThreadOffset<pointer_size> ThreadFlagsOffset() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700664 return ThreadOffset<pointer_size>(
665 OFFSETOF_MEMBER(Thread, tls32_) +
666 OFFSETOF_MEMBER(tls_32bit_sized_values, state_and_flags));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700667 }
668
Andreas Gampe542451c2016-07-26 09:02:02 -0700669 template<PointerSize pointer_size>
David Srbecky28f6cff2018-10-16 15:07:28 +0100670 static constexpr ThreadOffset<pointer_size> UseMterpOffset() {
671 return ThreadOffset<pointer_size>(
672 OFFSETOF_MEMBER(Thread, tls32_) +
673 OFFSETOF_MEMBER(tls_32bit_sized_values, use_mterp));
674 }
675
676 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100677 static constexpr ThreadOffset<pointer_size> IsGcMarkingOffset() {
Roland Levillain7c1559a2015-12-15 10:55:36 +0000678 return ThreadOffset<pointer_size>(
679 OFFSETOF_MEMBER(Thread, tls32_) +
680 OFFSETOF_MEMBER(tls_32bit_sized_values, is_gc_marking));
681 }
682
Igor Murashkinae7ff922016-10-06 14:59:19 -0700683 static constexpr size_t IsGcMarkingSize() {
684 return sizeof(tls32_.is_gc_marking);
685 }
686
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000687 // Deoptimize the Java stack.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700688 void DeoptimizeWithDeoptimizationException(JValue* result) REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffrayb331feb2016-02-05 16:51:53 +0000689
Ian Rogersdd7624d2014-03-14 17:43:00 -0700690 private:
Andreas Gampe542451c2016-07-26 09:02:02 -0700691 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100692 static constexpr ThreadOffset<pointer_size> ThreadOffsetFromTlsPtr(size_t tls_ptr_offset) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700693 size_t base = OFFSETOF_MEMBER(Thread, tlsPtr_);
David Srbecky56de89a2018-10-01 15:32:20 +0100694 size_t scale = (pointer_size > kRuntimePointerSize) ?
695 static_cast<size_t>(pointer_size) / static_cast<size_t>(kRuntimePointerSize) : 1;
696 size_t shrink = (kRuntimePointerSize > pointer_size) ?
697 static_cast<size_t>(kRuntimePointerSize) / static_cast<size_t>(pointer_size) : 1;
Ian Rogersdd7624d2014-03-14 17:43:00 -0700698 return ThreadOffset<pointer_size>(base + ((tls_ptr_offset * scale) / shrink));
Ian Rogers07ec8e12012-12-01 01:26:51 -0800699 }
700
Ian Rogersdd7624d2014-03-14 17:43:00 -0700701 public:
Jeff Hao848f70a2014-01-15 13:49:50 -0800702 static uint32_t QuickEntryPointOffsetWithSize(size_t quick_entrypoint_offset,
Andreas Gampe542451c2016-07-26 09:02:02 -0700703 PointerSize pointer_size) {
704 if (pointer_size == PointerSize::k32) {
705 return QuickEntryPointOffset<PointerSize::k32>(quick_entrypoint_offset).
706 Uint32Value();
Jeff Hao848f70a2014-01-15 13:49:50 -0800707 } else {
Andreas Gampe542451c2016-07-26 09:02:02 -0700708 return QuickEntryPointOffset<PointerSize::k64>(quick_entrypoint_offset).
709 Uint32Value();
Jeff Hao848f70a2014-01-15 13:49:50 -0800710 }
711 }
712
Andreas Gampe542451c2016-07-26 09:02:02 -0700713 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700714 static ThreadOffset<pointer_size> QuickEntryPointOffset(size_t quick_entrypoint_offset) {
715 return ThreadOffsetFromTlsPtr<pointer_size>(
716 OFFSETOF_MEMBER(tls_ptr_sized_values, quick_entrypoints) + quick_entrypoint_offset);
Elliott Hughesbe759c62011-09-08 19:38:21 -0700717 }
718
Andreas Gampe542451c2016-07-26 09:02:02 -0700719 template<PointerSize pointer_size>
Ian Rogersdd7624d2014-03-14 17:43:00 -0700720 static ThreadOffset<pointer_size> JniEntryPointOffset(size_t jni_entrypoint_offset) {
721 return ThreadOffsetFromTlsPtr<pointer_size>(
722 OFFSETOF_MEMBER(tls_ptr_sized_values, jni_entrypoints) + jni_entrypoint_offset);
Elliott Hughesbe759c62011-09-08 19:38:21 -0700723 }
724
Roland Levillain97c46462017-05-11 14:04:03 +0100725 // Return the entry point offset integer value for ReadBarrierMarkRegX, where X is `reg`.
726 template <PointerSize pointer_size>
727 static int32_t ReadBarrierMarkEntryPointsOffset(size_t reg) {
728 // The entry point list defines 30 ReadBarrierMarkRegX entry points.
729 DCHECK_LT(reg, 30u);
730 // The ReadBarrierMarkRegX entry points are ordered by increasing
731 // register number in Thread::tls_Ptr_.quick_entrypoints.
732 return QUICK_ENTRYPOINT_OFFSET(pointer_size, pReadBarrierMarkReg00).Int32Value()
733 + static_cast<size_t>(pointer_size) * reg;
734 }
735
Andreas Gampe542451c2016-07-26 09:02:02 -0700736 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100737 static constexpr ThreadOffset<pointer_size> SelfOffset() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700738 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, self));
739 }
740
Andreas Gampe542451c2016-07-26 09:02:02 -0700741 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100742 static constexpr ThreadOffset<pointer_size> MterpCurrentIBaseOffset() {
buzbee1452bee2015-03-06 14:43:04 -0800743 return ThreadOffsetFromTlsPtr<pointer_size>(
744 OFFSETOF_MEMBER(tls_ptr_sized_values, mterp_current_ibase));
745 }
746
Andreas Gampe542451c2016-07-26 09:02:02 -0700747 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100748 static constexpr ThreadOffset<pointer_size> ExceptionOffset() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700749 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, exception));
750 }
751
Andreas Gampe542451c2016-07-26 09:02:02 -0700752 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100753 static constexpr ThreadOffset<pointer_size> PeerOffset() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700754 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, opeer));
755 }
756
757
Andreas Gampe542451c2016-07-26 09:02:02 -0700758 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100759 static constexpr ThreadOffset<pointer_size> CardTableOffset() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700760 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, card_table));
761 }
762
Andreas Gampe542451c2016-07-26 09:02:02 -0700763 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100764 static constexpr ThreadOffset<pointer_size> ThreadSuspendTriggerOffset() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700765 return ThreadOffsetFromTlsPtr<pointer_size>(
766 OFFSETOF_MEMBER(tls_ptr_sized_values, suspend_trigger));
Dave Allisonb373e092014-02-20 16:06:36 -0800767 }
768
Andreas Gampe542451c2016-07-26 09:02:02 -0700769 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100770 static constexpr ThreadOffset<pointer_size> ThreadLocalPosOffset() {
Andreas Gampe542451c2016-07-26 09:02:02 -0700771 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
772 thread_local_pos));
Hiroshi Yamauchie01a5202015-03-19 12:35:04 -0700773 }
774
Andreas Gampe542451c2016-07-26 09:02:02 -0700775 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100776 static constexpr ThreadOffset<pointer_size> ThreadLocalEndOffset() {
Andreas Gampe542451c2016-07-26 09:02:02 -0700777 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
778 thread_local_end));
Hiroshi Yamauchie01a5202015-03-19 12:35:04 -0700779 }
780
Andreas Gampe542451c2016-07-26 09:02:02 -0700781 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100782 static constexpr ThreadOffset<pointer_size> ThreadLocalObjectsOffset() {
Andreas Gampe542451c2016-07-26 09:02:02 -0700783 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
784 thread_local_objects));
Hiroshi Yamauchie01a5202015-03-19 12:35:04 -0700785 }
786
Andreas Gampe542451c2016-07-26 09:02:02 -0700787 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100788 static constexpr ThreadOffset<pointer_size> RosAllocRunsOffset() {
Hiroshi Yamauchidc412b62015-10-15 12:26:57 -0700789 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
790 rosalloc_runs));
791 }
792
Andreas Gampe542451c2016-07-26 09:02:02 -0700793 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100794 static constexpr ThreadOffset<pointer_size> ThreadLocalAllocStackTopOffset() {
Hiroshi Yamauchidc412b62015-10-15 12:26:57 -0700795 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
796 thread_local_alloc_stack_top));
797 }
798
Andreas Gampe542451c2016-07-26 09:02:02 -0700799 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100800 static constexpr ThreadOffset<pointer_size> ThreadLocalAllocStackEndOffset() {
Hiroshi Yamauchidc412b62015-10-15 12:26:57 -0700801 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
802 thread_local_alloc_stack_end));
803 }
804
Ian Rogers932746a2011-09-22 18:57:50 -0700805 // Size of stack less any space reserved for stack overflow
jeffhaod7521322012-11-21 15:38:24 -0800806 size_t GetStackSize() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700807 return tlsPtr_.stack_size - (tlsPtr_.stack_end - tlsPtr_.stack_begin);
Ian Rogers932746a2011-09-22 18:57:50 -0700808 }
809
Andreas Gampe639b2b12019-01-08 10:32:50 -0800810 ALWAYS_INLINE uint8_t* GetStackEndForInterpreter(bool implicit_overflow_check) const;
Nicolas Geoffray535a3fb2014-07-22 15:17:38 +0100811
Ian Rogers13735952014-10-08 12:43:28 -0700812 uint8_t* GetStackEnd() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700813 return tlsPtr_.stack_end;
jeffhaod7521322012-11-21 15:38:24 -0800814 }
815
Ian Rogers932746a2011-09-22 18:57:50 -0700816 // Set the stack end to that to be used during a stack overflow
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700817 void SetStackEndForStackOverflow() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers932746a2011-09-22 18:57:50 -0700818
819 // Set the stack end to that to be used during regular execution
Andreas Gampe639b2b12019-01-08 10:32:50 -0800820 ALWAYS_INLINE void ResetDefaultStackEnd();
Ian Rogers932746a2011-09-22 18:57:50 -0700821
Ian Rogers120f1c72012-09-28 17:17:10 -0700822 bool IsHandlingStackOverflow() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700823 return tlsPtr_.stack_end == tlsPtr_.stack_begin;
Ian Rogers120f1c72012-09-28 17:17:10 -0700824 }
825
Andreas Gampe542451c2016-07-26 09:02:02 -0700826 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100827 static constexpr ThreadOffset<pointer_size> StackEndOffset() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700828 return ThreadOffsetFromTlsPtr<pointer_size>(
829 OFFSETOF_MEMBER(tls_ptr_sized_values, stack_end));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700830 }
831
Andreas Gampe542451c2016-07-26 09:02:02 -0700832 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100833 static constexpr ThreadOffset<pointer_size> JniEnvOffset() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700834 return ThreadOffsetFromTlsPtr<pointer_size>(
835 OFFSETOF_MEMBER(tls_ptr_sized_values, jni_env));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700836 }
837
Andreas Gampe542451c2016-07-26 09:02:02 -0700838 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100839 static constexpr ThreadOffset<pointer_size> TopOfManagedStackOffset() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700840 return ThreadOffsetFromTlsPtr<pointer_size>(
841 OFFSETOF_MEMBER(tls_ptr_sized_values, managed_stack) +
Vladimir Marko2196c652017-11-30 16:16:07 +0000842 ManagedStack::TaggedTopQuickFrameOffset());
Elliott Hughesbe759c62011-09-08 19:38:21 -0700843 }
844
Ian Rogers0399dde2012-06-06 17:09:28 -0700845 const ManagedStack* GetManagedStack() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700846 return &tlsPtr_.managed_stack;
Ian Rogers0399dde2012-06-06 17:09:28 -0700847 }
848
849 // Linked list recording fragments of managed stack.
850 void PushManagedStackFragment(ManagedStack* fragment) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700851 tlsPtr_.managed_stack.PushManagedStackFragment(fragment);
Ian Rogers0399dde2012-06-06 17:09:28 -0700852 }
853 void PopManagedStackFragment(const ManagedStack& fragment) {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700854 tlsPtr_.managed_stack.PopManagedStackFragment(fragment);
Ian Rogers0399dde2012-06-06 17:09:28 -0700855 }
856
Andreas Gampe513061a2017-06-01 09:17:34 -0700857 ALWAYS_INLINE ShadowFrame* PushShadowFrame(ShadowFrame* new_top_frame);
858 ALWAYS_INLINE ShadowFrame* PopShadowFrame();
Logan Chienf7ad17e2012-03-15 03:10:03 +0800859
Andreas Gampe542451c2016-07-26 09:02:02 -0700860 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100861 static constexpr ThreadOffset<pointer_size> TopShadowFrameOffset() {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700862 return ThreadOffsetFromTlsPtr<pointer_size>(
863 OFFSETOF_MEMBER(tls_ptr_sized_values, managed_stack) +
864 ManagedStack::TopShadowFrameOffset());
TDYa127d668a062012-04-13 12:36:57 -0700865 }
866
Ian Rogers0399dde2012-06-06 17:09:28 -0700867 // Is the given obj in this thread's stack indirect reference table?
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700868 bool HandleScopeContains(jobject obj) const;
Ian Rogers0399dde2012-06-06 17:09:28 -0700869
Hans Boehm0882af22017-08-31 15:21:57 -0700870 void HandleScopeVisitRoots(RootVisitor* visitor, pid_t thread_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700871 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700872
Mathieu Chartiere8a3c572016-10-11 16:52:17 -0700873 BaseHandleScope* GetTopHandleScope() {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700874 return tlsPtr_.top_handle_scope;
Ian Rogers1f539342012-10-03 21:09:42 -0700875 }
876
Mathieu Chartiere8a3c572016-10-11 16:52:17 -0700877 void PushHandleScope(BaseHandleScope* handle_scope) {
Ian Rogers59c07062014-10-10 13:03:39 -0700878 DCHECK_EQ(handle_scope->GetLink(), tlsPtr_.top_handle_scope);
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700879 tlsPtr_.top_handle_scope = handle_scope;
880 }
881
Mathieu Chartiere8a3c572016-10-11 16:52:17 -0700882 BaseHandleScope* PopHandleScope() {
883 BaseHandleScope* handle_scope = tlsPtr_.top_handle_scope;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700884 DCHECK(handle_scope != nullptr);
885 tlsPtr_.top_handle_scope = tlsPtr_.top_handle_scope->GetLink();
886 return handle_scope;
Ian Rogers1f539342012-10-03 21:09:42 -0700887 }
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700888
Andreas Gampe542451c2016-07-26 09:02:02 -0700889 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +0100890 static constexpr ThreadOffset<pointer_size> TopHandleScopeOffset() {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700891 return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values,
892 top_handle_scope));
Elliott Hughesbe759c62011-09-08 19:38:21 -0700893 }
894
Ian Rogersdd7624d2014-03-14 17:43:00 -0700895 DebugInvokeReq* GetInvokeReq() const {
896 return tlsPtr_.debug_invoke_req;
Elliott Hughes475fc232011-10-25 15:00:35 -0700897 }
898
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100899 SingleStepControl* GetSingleStepControl() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -0700900 return tlsPtr_.single_step_control;
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100901 }
902
Sebastien Hertz1558b572015-02-25 15:05:59 +0100903 // Indicates whether this thread is ready to invoke a method for debugging. This
904 // is only true if the thread has been suspended by a debug event.
905 bool IsReadyForDebugInvoke() const {
906 return tls32_.ready_for_debug_invoke;
907 }
908
909 void SetReadyForDebugInvoke(bool ready) {
910 tls32_.ready_for_debug_invoke = ready;
911 }
912
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200913 bool IsDebugMethodEntry() const {
914 return tls32_.debug_method_entry_;
915 }
916
917 void SetDebugMethodEntry() {
918 tls32_.debug_method_entry_ = true;
919 }
920
921 void ClearDebugMethodEntry() {
922 tls32_.debug_method_entry_ = false;
923 }
924
Hiroshi Yamauchi00370822015-08-18 14:47:25 -0700925 bool GetIsGcMarking() const {
926 CHECK(kUseReadBarrier);
927 return tls32_.is_gc_marking;
928 }
929
Mathieu Chartierfe814e82016-11-09 14:32:49 -0800930 void SetIsGcMarkingAndUpdateEntrypoints(bool is_marking);
Hiroshi Yamauchi00370822015-08-18 14:47:25 -0700931
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -0700932 bool GetWeakRefAccessEnabled() const {
933 CHECK(kUseReadBarrier);
934 return tls32_.weak_ref_access_enabled;
935 }
936
937 void SetWeakRefAccessEnabled(bool enabled) {
938 CHECK(kUseReadBarrier);
939 tls32_.weak_ref_access_enabled = enabled;
940 }
941
Hiroshi Yamauchi20a0be02016-02-19 15:44:06 -0800942 uint32_t GetDisableThreadFlipCount() const {
943 CHECK(kUseReadBarrier);
944 return tls32_.disable_thread_flip_count;
945 }
946
947 void IncrementDisableThreadFlipCount() {
948 CHECK(kUseReadBarrier);
949 ++tls32_.disable_thread_flip_count;
950 }
951
952 void DecrementDisableThreadFlipCount() {
953 CHECK(kUseReadBarrier);
954 DCHECK_GT(tls32_.disable_thread_flip_count, 0U);
955 --tls32_.disable_thread_flip_count;
956 }
957
Alex Light185a4612018-10-04 15:54:25 -0700958 // Returns true if the thread is a runtime thread (eg from a ThreadPool).
Alex Lighte9f61032018-09-24 16:04:51 -0700959 bool IsRuntimeThread() const {
960 return is_runtime_thread_;
Calin Juravleccd56952016-12-15 17:57:38 +0000961 }
962
Alex Lighte9f61032018-09-24 16:04:51 -0700963 void SetIsRuntimeThread(bool is_runtime_thread) {
964 is_runtime_thread_ = is_runtime_thread;
Calin Juravleccd56952016-12-15 17:57:38 +0000965 }
966
Orion Hodson01ecfa12019-07-18 12:57:47 +0100967 uint32_t CorePlatformApiCookie() {
968 return core_platform_api_cookie_;
969 }
970
971 void SetCorePlatformApiCookie(uint32_t cookie) {
972 core_platform_api_cookie_ = cookie;
973 }
974
Alex Lighte9f61032018-09-24 16:04:51 -0700975 // Returns true if the thread is allowed to load java classes.
976 bool CanLoadClasses() const;
977
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100978 // Activates single step control for debugging. The thread takes the
979 // ownership of the given SingleStepControl*. It is deleted by a call
980 // to DeactivateSingleStepControl or upon thread destruction.
981 void ActivateSingleStepControl(SingleStepControl* ssc);
982
983 // Deactivates single step control for debugging.
984 void DeactivateSingleStepControl();
985
Sebastien Hertz1558b572015-02-25 15:05:59 +0100986 // Sets debug invoke request for debugging. When the thread is resumed,
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200987 // it executes the method described by this request then sends the reply
988 // before suspending itself. The thread takes the ownership of the given
989 // DebugInvokeReq*. It is deleted by a call to ClearDebugInvokeReq.
Sebastien Hertz1558b572015-02-25 15:05:59 +0100990 void SetDebugInvokeReq(DebugInvokeReq* req);
991
992 // Clears debug invoke request for debugging. When the thread completes
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200993 // method invocation, it deletes its debug invoke request and suspends
994 // itself.
Sebastien Hertz1558b572015-02-25 15:05:59 +0100995 void ClearDebugInvokeReq();
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100996
Sebastien Hertzfd3077e2014-04-23 10:32:43 +0200997 // Returns the fake exception used to activate deoptimization.
998 static mirror::Throwable* GetDeoptimizationException() {
Mathieu Chartier0795f232016-09-27 18:43:30 -0700999 // Note that the mirror::Throwable must be aligned to kObjectAlignment or else it cannot be
1000 // represented by ObjPtr.
1001 return reinterpret_cast<mirror::Throwable*>(0x100);
Sebastien Hertzfd3077e2014-04-23 10:32:43 +02001002 }
1003
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001004 // Currently deoptimization invokes verifier which can trigger class loading
1005 // and execute Java code, so there might be nested deoptimizations happening.
1006 // We need to save the ongoing deoptimization shadow frames and return
1007 // values on stacks.
Nicolas Geoffray73be1e82015-09-17 15:22:56 +01001008 // 'from_code' denotes whether the deoptimization was explicitly made from
1009 // compiled code.
Mingyao Yang2ee17902017-08-30 11:37:08 -07001010 // 'method_type' contains info on whether deoptimization should advance
1011 // dex_pc.
Nicolas Geoffray73be1e82015-09-17 15:22:56 +01001012 void PushDeoptimizationContext(const JValue& return_value,
1013 bool is_reference,
Mingyao Yang2ee17902017-08-30 11:37:08 -07001014 ObjPtr<mirror::Throwable> exception,
Nicolas Geoffray73be1e82015-09-17 15:22:56 +01001015 bool from_code,
Mingyao Yang2ee17902017-08-30 11:37:08 -07001016 DeoptimizationMethodType method_type)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001017 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierf5769e12017-01-10 15:54:41 -08001018 void PopDeoptimizationContext(JValue* result,
1019 ObjPtr<mirror::Throwable>* exception,
Mingyao Yang2ee17902017-08-30 11:37:08 -07001020 bool* from_code,
1021 DeoptimizationMethodType* method_type)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001022 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz07474662015-08-25 15:12:33 +00001023 void AssertHasDeoptimizationContext()
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001024 REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001025 void PushStackedShadowFrame(ShadowFrame* sf, StackedShadowFrameType type);
Andreas Gampe639bdd12015-06-03 11:22:45 -07001026 ShadowFrame* PopStackedShadowFrame(StackedShadowFrameType type, bool must_be_present = true);
Andreas Gampe2a0d4ec2014-06-02 22:05:22 -07001027
Mingyao Yang99170c62015-07-06 11:10:37 -07001028 // For debugger, find the shadow frame that corresponds to a frame id.
1029 // Or return null if there is none.
1030 ShadowFrame* FindDebuggerShadowFrame(size_t frame_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001031 REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yang99170c62015-07-06 11:10:37 -07001032 // For debugger, find the bool array that keeps track of the updated vreg set
1033 // for a frame id.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001034 bool* GetUpdatedVRegFlags(size_t frame_id) REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yang99170c62015-07-06 11:10:37 -07001035 // For debugger, find the shadow frame that corresponds to a frame id. If
1036 // one doesn't exist yet, create one and track it in frame_id_to_shadow_frame.
1037 ShadowFrame* FindOrCreateDebuggerShadowFrame(size_t frame_id,
1038 uint32_t num_vregs,
1039 ArtMethod* method,
1040 uint32_t dex_pc)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001041 REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yang99170c62015-07-06 11:10:37 -07001042
1043 // Delete the entry that maps from frame_id to shadow_frame.
1044 void RemoveDebuggerShadowFrameMapping(size_t frame_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001045 REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yang99170c62015-07-06 11:10:37 -07001046
Ian Rogers62d6c772013-02-27 08:32:07 -08001047 std::deque<instrumentation::InstrumentationStackFrame>* GetInstrumentationStack() {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001048 return tlsPtr_.instrumentation_stack;
jeffhaoe343b762011-12-05 16:36:44 -08001049 }
1050
Mathieu Chartiere401d142015-04-22 13:56:20 -07001051 std::vector<ArtMethod*>* GetStackTraceSample() const {
Andreas Gampe2c19f5b2016-11-28 08:10:18 -08001052 DCHECK(!IsAotCompiler());
Nicolas Geoffray340dafa2016-11-18 16:03:10 +00001053 return tlsPtr_.deps_or_stack_trace_sample.stack_trace_sample;
Jeff Hao5ce4b172013-08-16 16:27:18 -07001054 }
1055
Mathieu Chartiere401d142015-04-22 13:56:20 -07001056 void SetStackTraceSample(std::vector<ArtMethod*>* sample) {
Andreas Gampe2c19f5b2016-11-28 08:10:18 -08001057 DCHECK(!IsAotCompiler());
Nicolas Geoffray340dafa2016-11-18 16:03:10 +00001058 tlsPtr_.deps_or_stack_trace_sample.stack_trace_sample = sample;
1059 }
1060
1061 verifier::VerifierDeps* GetVerifierDeps() const {
Andreas Gampe2c19f5b2016-11-28 08:10:18 -08001062 DCHECK(IsAotCompiler());
Nicolas Geoffray340dafa2016-11-18 16:03:10 +00001063 return tlsPtr_.deps_or_stack_trace_sample.verifier_deps;
1064 }
1065
1066 // It is the responsability of the caller to make sure the verifier_deps
1067 // entry in the thread is cleared before destruction of the actual VerifierDeps
1068 // object, or the thread.
1069 void SetVerifierDeps(verifier::VerifierDeps* verifier_deps) {
Andreas Gampe2c19f5b2016-11-28 08:10:18 -08001070 DCHECK(IsAotCompiler());
Nicolas Geoffraye424c932016-11-23 12:52:01 +00001071 DCHECK(verifier_deps == nullptr || tlsPtr_.deps_or_stack_trace_sample.verifier_deps == nullptr);
Nicolas Geoffray340dafa2016-11-18 16:03:10 +00001072 tlsPtr_.deps_or_stack_trace_sample.verifier_deps = verifier_deps;
Jeff Hao5ce4b172013-08-16 16:27:18 -07001073 }
1074
1075 uint64_t GetTraceClockBase() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001076 return tls64_.trace_clock_base;
Jeff Hao5ce4b172013-08-16 16:27:18 -07001077 }
1078
1079 void SetTraceClockBase(uint64_t clock_base) {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001080 tls64_.trace_clock_base = clock_base;
Jeff Hao5ce4b172013-08-16 16:27:18 -07001081 }
1082
Ian Rogers81d425b2012-09-27 16:03:43 -07001083 BaseMutex* GetHeldMutex(LockLevel level) const {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001084 return tlsPtr_.held_mutexes[level];
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001085 }
1086
Ian Rogers81d425b2012-09-27 16:03:43 -07001087 void SetHeldMutex(LockLevel level, BaseMutex* mutex) {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001088 tlsPtr_.held_mutexes[level] = mutex;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001089 }
Elliott Hughesffb465f2012-03-01 18:46:05 -08001090
Yu Lieac44242015-06-29 10:50:03 +08001091 void ClearSuspendBarrier(AtomicInteger* target)
Mathieu Chartier90443472015-07-16 20:32:27 -07001092 REQUIRES(Locks::thread_suspend_count_lock_);
Yu Lieac44242015-06-29 10:50:03 +08001093
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001094 bool ReadFlag(ThreadFlag flag) const {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001095 return (tls32_.state_and_flags.as_struct.flags & flag) != 0;
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001096 }
1097
Jeff Hao9cec2472013-05-14 18:17:06 -07001098 bool TestAllFlags() const {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001099 return (tls32_.state_and_flags.as_struct.flags != 0);
Jeff Hao9cec2472013-05-14 18:17:06 -07001100 }
1101
Ian Rogers8c1b5f72014-07-09 22:02:36 -07001102 void AtomicSetFlag(ThreadFlag flag) {
Orion Hodson88591fe2018-03-06 13:35:43 +00001103 tls32_.state_and_flags.as_atomic_int.fetch_or(flag, std::memory_order_seq_cst);
Ian Rogers8c1b5f72014-07-09 22:02:36 -07001104 }
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001105
Ian Rogers8c1b5f72014-07-09 22:02:36 -07001106 void AtomicClearFlag(ThreadFlag flag) {
Orion Hodson88591fe2018-03-06 13:35:43 +00001107 tls32_.state_and_flags.as_atomic_int.fetch_and(-1 ^ flag, std::memory_order_seq_cst);
Ian Rogers8c1b5f72014-07-09 22:02:36 -07001108 }
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001109
David Srbecky28f6cff2018-10-16 15:07:28 +01001110 bool UseMterp() const {
1111 return tls32_.use_mterp.load();
1112 }
1113
Mathieu Chartier5ace2012016-11-30 10:15:41 -08001114 void ResetQuickAllocEntryPointsForThread(bool is_marking);
Hiroshi Yamauchi3b4c1892013-09-12 21:33:12 -07001115
Ian Rogersdd7624d2014-03-14 17:43:00 -07001116 // Returns the remaining space in the TLAB.
Mathieu Chartier6bc77742017-04-18 17:46:23 -07001117 size_t TlabSize() const {
1118 return tlsPtr_.thread_local_end - tlsPtr_.thread_local_pos;
1119 }
1120
1121 // Returns the remaining space in the TLAB if we were to expand it to maximum capacity.
1122 size_t TlabRemainingCapacity() const {
1123 return tlsPtr_.thread_local_limit - tlsPtr_.thread_local_pos;
1124 }
1125
1126 // Expand the TLAB by a fixed number of bytes. There must be enough capacity to do so.
1127 void ExpandTlab(size_t bytes) {
1128 tlsPtr_.thread_local_end += bytes;
1129 DCHECK_LE(tlsPtr_.thread_local_end, tlsPtr_.thread_local_limit);
1130 }
1131
Ian Rogersdd7624d2014-03-14 17:43:00 -07001132 // Doesn't check that there is room.
1133 mirror::Object* AllocTlab(size_t bytes);
Mathieu Chartier6bc77742017-04-18 17:46:23 -07001134 void SetTlab(uint8_t* start, uint8_t* end, uint8_t* limit);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001135 bool HasTlab() const;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001136 uint8_t* GetTlabStart() {
1137 return tlsPtr_.thread_local_start;
1138 }
1139 uint8_t* GetTlabPos() {
1140 return tlsPtr_.thread_local_pos;
1141 }
Elliott Hughes5d96a712012-06-28 12:24:27 -07001142
Ian Rogersdd7624d2014-03-14 17:43:00 -07001143 // Remove the suspend trigger for this thread by making the suspend_trigger_ TLS value
1144 // equal to a valid pointer.
1145 // TODO: does this need to atomic? I don't think so.
1146 void RemoveSuspendTrigger() {
1147 tlsPtr_.suspend_trigger = reinterpret_cast<uintptr_t*>(&tlsPtr_.suspend_trigger);
1148 }
1149
1150 // Trigger a suspend check by making the suspend_trigger_ TLS value an invalid pointer.
1151 // The next time a suspend check is done, it will load from the value at this address
1152 // and trigger a SIGSEGV.
1153 void TriggerSuspend() {
1154 tlsPtr_.suspend_trigger = nullptr;
1155 }
1156
1157
1158 // Push an object onto the allocation stack.
Mathieu Chartiercb535da2015-01-23 13:50:03 -08001159 bool PushOnThreadLocalAllocationStack(mirror::Object* obj)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001160 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001161
1162 // Set the thread local allocation pointers to the given pointers.
Mathieu Chartiercb535da2015-01-23 13:50:03 -08001163 void SetThreadLocalAllocationStack(StackReference<mirror::Object>* start,
1164 StackReference<mirror::Object>* end);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001165
1166 // Resets the thread local allocation pointers.
1167 void RevokeThreadLocalAllocationStack();
1168
1169 size_t GetThreadLocalBytesAllocated() const {
Mathieu Chartier14cc9be2014-07-11 10:26:37 -07001170 return tlsPtr_.thread_local_end - tlsPtr_.thread_local_start;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001171 }
1172
1173 size_t GetThreadLocalObjectsAllocated() const {
1174 return tlsPtr_.thread_local_objects;
1175 }
1176
Ian Rogersdd7624d2014-03-14 17:43:00 -07001177 void* GetRosAllocRun(size_t index) const {
1178 return tlsPtr_.rosalloc_runs[index];
1179 }
1180
1181 void SetRosAllocRun(size_t index, void* run) {
1182 tlsPtr_.rosalloc_runs[index] = run;
1183 }
1184
Andreas Gampe2c2d2a02016-03-17 21:27:19 -07001185 bool ProtectStack(bool fatal_on_error = true);
Dave Allison648d7112014-07-25 16:15:27 -07001186 bool UnprotectStack();
1187
buzbee1452bee2015-03-06 14:43:04 -08001188 void SetMterpCurrentIBase(void* ibase) {
1189 tlsPtr_.mterp_current_ibase = ibase;
1190 }
1191
buzbee1452bee2015-03-06 14:43:04 -08001192 const void* GetMterpCurrentIBase() const {
1193 return tlsPtr_.mterp_current_ibase;
1194 }
1195
Josh Gaoefd20cb2017-02-28 16:53:59 -08001196 bool HandlingSignal() const {
1197 return tls32_.handling_signal_;
Dave Allison648d7112014-07-25 16:15:27 -07001198 }
1199
Josh Gaoefd20cb2017-02-28 16:53:59 -08001200 void SetHandlingSignal(bool handling_signal) {
1201 tls32_.handling_signal_ = handling_signal;
Dave Allison8ce6b902014-08-26 11:07:58 -07001202 }
1203
Hiroshi Yamauchiee235822016-08-19 17:03:27 -07001204 bool IsTransitioningToRunnable() const {
1205 return tls32_.is_transitioning_to_runnable;
1206 }
1207
1208 void SetIsTransitioningToRunnable(bool value) {
1209 tls32_.is_transitioning_to_runnable = value;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001210 }
1211
Alex Light3dacdd62019-03-12 15:45:47 +00001212 uint32_t DecrementForceInterpreterCount() REQUIRES(Locks::thread_list_lock_) {
1213 return --tls32_.force_interpreter_count;
1214 }
1215
1216 uint32_t IncrementForceInterpreterCount() REQUIRES(Locks::thread_list_lock_) {
1217 return ++tls32_.force_interpreter_count;
1218 }
1219
1220 void SetForceInterpreterCount(uint32_t value) REQUIRES(Locks::thread_list_lock_) {
1221 tls32_.force_interpreter_count = value;
1222 }
1223
1224 uint32_t ForceInterpreterCount() const {
1225 return tls32_.force_interpreter_count;
1226 }
1227
1228 bool IsForceInterpreter() const {
1229 return tls32_.force_interpreter_count != 0;
1230 }
1231
Vladimir Markobf121912019-06-04 13:49:05 +01001232 bool IncrementMakeVisiblyInitializedCounter() {
1233 tls32_.make_visibly_initialized_counter += 1u;
1234 return tls32_.make_visibly_initialized_counter == kMakeVisiblyInitializedCounterTriggerCount;
1235 }
1236
1237 void ClearMakeVisiblyInitializedCounter() {
1238 tls32_.make_visibly_initialized_counter = 0u;
1239 }
1240
Mathieu Chartierd0ad2ee2015-03-31 14:59:59 -07001241 void PushVerifier(verifier::MethodVerifier* verifier);
1242 void PopVerifier(verifier::MethodVerifier* verifier);
Mathieu Chartier12d625f2015-03-13 11:33:37 -07001243
Jeff Hao848f70a2014-01-15 13:49:50 -08001244 void InitStringEntryPoints();
1245
Mathieu Chartierdfe02f62016-02-01 20:15:11 -08001246 void ModifyDebugDisallowReadBarrier(int8_t delta) {
1247 debug_disallow_read_barrier_ += delta;
1248 }
1249
1250 uint8_t GetDebugDisallowReadBarrierCount() const {
1251 return debug_disallow_read_barrier_;
1252 }
1253
Alex Light184f0752018-07-13 11:18:22 -07001254 // Gets the current TLSData associated with the key or nullptr if there isn't any. Note that users
1255 // do not gain ownership of TLSData and must synchronize with SetCustomTls themselves to prevent
1256 // it from being deleted.
1257 TLSData* GetCustomTLS(const char* key) REQUIRES(!Locks::custom_tls_lock_);
Andreas Gampef26bf2d2017-01-13 16:47:14 -08001258
Alex Light184f0752018-07-13 11:18:22 -07001259 // Sets the tls entry at 'key' to data. The thread takes ownership of the TLSData. The destructor
1260 // will be run when the thread exits or when SetCustomTLS is called again with the same key.
1261 void SetCustomTLS(const char* key, TLSData* data) REQUIRES(!Locks::custom_tls_lock_);
Andreas Gampef26bf2d2017-01-13 16:47:14 -08001262
Calin Juravle97cbc922016-04-15 16:16:35 +01001263 // Returns true if the current thread is the jit sensitive thread.
1264 bool IsJitSensitiveThread() const {
1265 return this == jit_sensitive_thread_;
1266 }
1267
Alex Lighte0b2ce42019-02-21 19:23:42 +00001268 bool IsSystemDaemon() const REQUIRES_SHARED(Locks::mutator_lock_);
1269
Calin Juravle97cbc922016-04-15 16:16:35 +01001270 // Returns true if StrictMode events are traced for the current thread.
Calin Juravleb2771b42016-04-07 17:09:25 +01001271 static bool IsSensitiveThread() {
1272 if (is_sensitive_thread_hook_ != nullptr) {
1273 return (*is_sensitive_thread_hook_)();
1274 }
1275 return false;
1276 }
1277
Mathieu Chartier3768ade2017-05-02 14:04:39 -07001278 // Set to the read barrier marking entrypoints to be non-null.
1279 void SetReadBarrierEntrypoints();
1280
Andreas Gampebad529d2017-02-13 18:52:10 -08001281 static jobject CreateCompileTimePeer(JNIEnv* env,
1282 const char* name,
1283 bool as_daemon,
1284 jobject thread_group)
1285 REQUIRES_SHARED(Locks::mutator_lock_);
1286
David Srbecky912f36c2018-09-08 12:22:58 +01001287 ALWAYS_INLINE InterpreterCache* GetInterpreterCache() {
1288 return &interpreter_cache_;
1289 }
1290
1291 // Clear all thread-local interpreter caches.
1292 //
1293 // Since the caches are keyed by memory pointer to dex instructions, this must be
1294 // called when any dex code is unloaded (before different code gets loaded at the
1295 // same memory location).
1296 //
1297 // If presence of cache entry implies some pre-conditions, this must also be
1298 // called if the pre-conditions might no longer hold true.
1299 static void ClearAllInterpreterCaches();
1300
1301 template<PointerSize pointer_size>
David Srbecky56de89a2018-10-01 15:32:20 +01001302 static constexpr ThreadOffset<pointer_size> InterpreterCacheOffset() {
David Srbecky912f36c2018-09-08 12:22:58 +01001303 return ThreadOffset<pointer_size>(OFFSETOF_MEMBER(Thread, interpreter_cache_));
1304 }
1305
David Srbecky56de89a2018-10-01 15:32:20 +01001306 static constexpr int InterpreterCacheSizeLog2() {
David Srbecky912f36c2018-09-08 12:22:58 +01001307 return WhichPowerOf2(InterpreterCache::kSize);
1308 }
1309
Ian Rogersdd7624d2014-03-14 17:43:00 -07001310 private:
Ian Rogers52673ff2012-06-27 23:25:34 -07001311 explicit Thread(bool daemon);
Mathieu Chartier90443472015-07-16 20:32:27 -07001312 ~Thread() REQUIRES(!Locks::mutator_lock_, !Locks::thread_suspend_count_lock_);
Elliott Hughesc0f09332012-03-26 13:27:06 -07001313 void Destroy();
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001314
David Srbecky28f6cff2018-10-16 15:07:28 +01001315 void NotifyInTheadList()
1316 REQUIRES_SHARED(Locks::thread_list_lock_);
1317
Andreas Gampe732b0ac2017-01-18 15:23:39 -08001318 // Attaches the calling native thread to the runtime, returning the new native peer.
1319 // Used to implement JNI AttachCurrentThread and AttachCurrentThreadAsDaemon calls.
1320 template <typename PeerAction>
1321 static Thread* Attach(const char* thread_name,
1322 bool as_daemon,
1323 PeerAction p);
1324
Ian Rogers365c1022012-06-22 15:05:28 -07001325 void CreatePeer(const char* name, bool as_daemon, jobject thread_group);
Elliott Hughes5fe594f2011-09-08 12:33:17 -07001326
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01001327 template<bool kTransactionActive>
Andreas Gampebad529d2017-02-13 18:52:10 -08001328 static void InitPeer(ScopedObjectAccessAlreadyRunnable& soa,
1329 ObjPtr<mirror::Object> peer,
1330 jboolean thread_is_daemon,
1331 jobject thread_group,
1332 jobject thread_name,
1333 jint thread_priority)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001334 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01001335
Ian Rogers62d6c772013-02-27 08:32:07 -08001336 // Avoid use, callers should use SetState. Used only by SignalCatcher::HandleSigQuit, ~Thread and
Hiroshi Yamauchi98810e32016-05-24 14:55:40 -07001337 // Dbg::ManageDeoptimization.
Ian Rogers474b6da2012-09-25 00:20:38 -07001338 ThreadState SetStateUnsafe(ThreadState new_state) {
1339 ThreadState old_state = GetState();
Mathieu Chartier8ac9c912015-10-01 15:58:41 -07001340 if (old_state == kRunnable && new_state != kRunnable) {
1341 // Need to run pending checkpoint and suspend barriers. Run checkpoints in runnable state in
1342 // case they need to use a ScopedObjectAccess. If we are holding the mutator lock and a SOA
1343 // attempts to TransitionFromSuspendedToRunnable, it results in a deadlock.
1344 TransitionToSuspendedAndRunCheckpoints(new_state);
1345 // Since we transitioned to a suspended state, check the pass barrier requests.
1346 PassActiveSuspendBarriers();
1347 } else {
1348 tls32_.state_and_flags.as_struct.state = new_state;
Yu Lieac44242015-06-29 10:50:03 +08001349 }
Ian Rogersc747cff2012-08-31 18:20:08 -07001350 return old_state;
1351 }
Ian Rogersc747cff2012-08-31 18:20:08 -07001352
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001353 void VerifyStackImpl() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers04d7aa92013-03-16 14:29:17 -07001354
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001355 void DumpState(std::ostream& os) const REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffraya73280d2016-02-15 13:05:16 +00001356 void DumpStack(std::ostream& os,
Nicolas Geoffray6ee49712018-03-30 14:39:05 +00001357 bool dump_native_stack = true,
Hiroshi Yamauchi13c16352017-01-31 10:15:08 -08001358 BacktraceMap* backtrace_map = nullptr,
1359 bool force_dump_stack = false) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001360 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesd92bec42011-09-02 17:04:36 -07001361
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001362 // Out-of-line conveniences for debugging in gdb.
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001363 static Thread* CurrentFromGdb(); // Like Thread::Current.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001364 // Like Thread::Dump(std::cerr).
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001365 void DumpFromGdb() const REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001366
Elliott Hughes93e74e82011-09-13 11:07:03 -07001367 static void* CreateCallback(void* arg);
1368
Andreas Gampe513061a2017-06-01 09:17:34 -07001369 void HandleUncaughtExceptions(ScopedObjectAccessAlreadyRunnable& soa)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001370 REQUIRES_SHARED(Locks::mutator_lock_);
Andreas Gampe513061a2017-06-01 09:17:34 -07001371 void RemoveFromThreadGroup(ScopedObjectAccessAlreadyRunnable& soa)
1372 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesaccd83d2011-10-17 14:25:58 -07001373
Andreas Gampe449357d2015-06-01 22:29:51 -07001374 // Initialize a thread.
1375 //
1376 // The third parameter is not mandatory. If given, the thread will use this JNIEnvExt. In case
1377 // Init succeeds, this means the thread takes ownership of it. If Init fails, it is the caller's
1378 // responsibility to destroy the given JNIEnvExt. If the parameter is null, Init will try to
1379 // create a JNIEnvExt on its own (and potentially fail at that stage, indicated by a return value
1380 // of false).
1381 bool Init(ThreadList*, JavaVMExt*, JNIEnvExt* jni_env_ext = nullptr)
Mathieu Chartier90443472015-07-16 20:32:27 -07001382 REQUIRES(Locks::runtime_shutdown_lock_);
Ian Rogers5d76c432011-10-31 21:42:49 -07001383 void InitCardTable();
Ian Rogersb033c752011-07-20 12:22:35 -07001384 void InitCpu();
Alexei Zavjalov1efa0a92014-02-04 02:08:31 +07001385 void CleanupCpu();
Ian Rogers848871b2013-08-05 10:56:33 -07001386 void InitTlsEntryPoints();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -07001387 void InitTid();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -07001388 void InitPthreadKeySelf();
Ian Rogersf4d4da12014-11-11 16:10:33 -08001389 bool InitStackHwm();
Elliott Hughesbe759c62011-09-08 19:38:21 -07001390
Elliott Hughesd6a23bd2013-07-16 14:19:52 -07001391 void SetUpAlternateSignalStack();
1392 void TearDownAlternateSignalStack();
1393
Mathieu Chartier8ac9c912015-10-01 15:58:41 -07001394 ALWAYS_INLINE void TransitionToSuspendedAndRunCheckpoints(ThreadState new_state)
1395 REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_);
1396
1397 ALWAYS_INLINE void PassActiveSuspendBarriers()
1398 REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_);
1399
Calin Juravle97cbc922016-04-15 16:16:35 +01001400 // Registers the current thread as the jit sensitive thread. Should be called just once.
1401 static void SetJitSensitiveThread() {
1402 if (jit_sensitive_thread_ == nullptr) {
1403 jit_sensitive_thread_ = Thread::Current();
1404 } else {
1405 LOG(WARNING) << "Attempt to set the sensitive thread twice. Tid:"
1406 << Thread::Current()->GetTid();
1407 }
1408 }
1409
Calin Juravleb2771b42016-04-07 17:09:25 +01001410 static void SetSensitiveThreadHook(bool (*is_sensitive_thread_hook)()) {
1411 is_sensitive_thread_hook_ = is_sensitive_thread_hook;
1412 }
1413
Hiroshi Yamauchi02e7f1a2016-10-03 15:32:01 -07001414 bool ModifySuspendCountInternal(Thread* self,
1415 int delta,
1416 AtomicInteger* suspend_barrier,
Alex Light46f93402017-06-29 11:59:50 -07001417 SuspendReason reason)
Sebastien Hertz1c8f4ff2017-04-14 15:05:12 +02001418 WARN_UNUSED
Hiroshi Yamauchi02e7f1a2016-10-03 15:32:01 -07001419 REQUIRES(Locks::thread_suspend_count_lock_);
1420
Alex Lightdf00a1e2017-11-01 09:29:53 -07001421 // Runs a single checkpoint function. If there are no more pending checkpoint functions it will
1422 // clear the kCheckpointRequest flag. The caller is responsible for calling this in a loop until
1423 // the kCheckpointRequest flag is cleared.
Andreas Gampe0a855762016-10-26 13:43:14 -07001424 void RunCheckpointFunction();
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07001425 void RunEmptyCheckpoint();
Andreas Gampe0a855762016-10-26 13:43:14 -07001426
1427 bool PassActiveSuspendBarriers(Thread* self)
1428 REQUIRES(!Locks::thread_suspend_count_lock_);
1429
1430 // Install the protected region for implicit stack checks.
1431 void InstallImplicitProtection();
1432
Andreas Gampe585da952016-12-02 14:52:29 -08001433 template <bool kPrecise>
1434 void VisitRoots(RootVisitor* visitor) REQUIRES_SHARED(Locks::mutator_lock_);
1435
Andreas Gampe2c19f5b2016-11-28 08:10:18 -08001436 static bool IsAotCompiler();
1437
Andreas Gampee5d23982019-01-08 10:34:26 -08001438 void ReleaseLongJumpContextInternal();
1439
Ian Rogers474b6da2012-09-25 00:20:38 -07001440 // 32 bits of atomically changed state and flags. Keeping as 32 bits allows and atomic CAS to
1441 // change from being Suspended to Runnable without a suspend request occurring.
Chris Dearman59cde532013-12-04 18:53:49 -08001442 union PACKED(4) StateAndFlags {
1443 StateAndFlags() {}
Ian Rogersdf1ce912012-11-27 17:07:11 -08001444 struct PACKED(4) {
Ian Rogers30e173f2012-09-26 14:35:03 -07001445 // Bitfield of flag values. Must be changed atomically so that flag values aren't lost. See
1446 // ThreadFlags for bit field meanings.
1447 volatile uint16_t flags;
1448 // Holds the ThreadState. May be changed non-atomically between Suspended (ie not Runnable)
1449 // transitions. Changing to Runnable requires that the suspend_request be part of the atomic
1450 // operation. If a thread is suspended and a suspend_request is present, a thread may not
1451 // change to Runnable as a GC or other operation is in progress.
Ian Rogers01ae5802012-09-28 16:14:01 -07001452 volatile uint16_t state;
Ian Rogers30e173f2012-09-26 14:35:03 -07001453 } as_struct;
Ian Rogersb8e087e2014-07-09 21:12:06 -07001454 AtomicInteger as_atomic_int;
Ian Rogers01ae5802012-09-28 16:14:01 -07001455 volatile int32_t as_int;
Chris Dearman59cde532013-12-04 18:53:49 -08001456
1457 private:
1458 // gcc does not handle struct with volatile member assignments correctly.
1459 // See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47409
1460 DISALLOW_COPY_AND_ASSIGN(StateAndFlags);
Ian Rogers474b6da2012-09-25 00:20:38 -07001461 };
Andreas Gampe575e78c2014-11-03 23:41:03 -08001462 static_assert(sizeof(StateAndFlags) == sizeof(int32_t), "Weird state_and_flags size");
Ian Rogers474b6da2012-09-25 00:20:38 -07001463
Ian Rogersdd7624d2014-03-14 17:43:00 -07001464 static void ThreadExitCallback(void* arg);
Elliott Hughes5d96a712012-06-28 12:24:27 -07001465
Yu Lieac44242015-06-29 10:50:03 +08001466 // Maximum number of suspend barriers.
1467 static constexpr uint32_t kMaxSuspendBarriers = 3;
1468
Ian Rogersdd7624d2014-03-14 17:43:00 -07001469 // Has Thread::Startup been called?
1470 static bool is_started_;
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001471
Ian Rogersdd7624d2014-03-14 17:43:00 -07001472 // TLS key used to retrieve the Thread*.
1473 static pthread_key_t pthread_key_self_;
Ian Rogersa32a6fd2012-02-06 20:18:44 -08001474
Ian Rogersdd7624d2014-03-14 17:43:00 -07001475 // Used to notify threads that they should attempt to resume, they will suspend again if
1476 // their suspend count is > 0.
1477 static ConditionVariable* resume_cond_ GUARDED_BY(Locks::thread_suspend_count_lock_);
Dave Allisonb373e092014-02-20 16:06:36 -08001478
Calin Juravleb2771b42016-04-07 17:09:25 +01001479 // Hook passed by framework which returns true
1480 // when StrictMode events are traced for the current thread.
1481 static bool (*is_sensitive_thread_hook_)();
Calin Juravle97cbc922016-04-15 16:16:35 +01001482 // Stores the jit sensitive thread (which for now is the UI thread).
1483 static Thread* jit_sensitive_thread_;
Calin Juravleb2771b42016-04-07 17:09:25 +01001484
Vladimir Marko9f18fbc2019-07-31 15:06:12 +01001485 static constexpr uint32_t kMakeVisiblyInitializedCounterTriggerCount = 128;
Vladimir Markobf121912019-06-04 13:49:05 +01001486
Ian Rogersdd7624d2014-03-14 17:43:00 -07001487 /***********************************************************************************************/
1488 // Thread local storage. Fields are grouped by size to enable 32 <-> 64 searching to account for
1489 // pointer size differences. To encourage shorter encoding, more frequently used values appear
1490 // first if possible.
1491 /***********************************************************************************************/
Elliott Hughes6a607ad2012-07-13 20:40:00 -07001492
Zuo Wangf37a88b2014-07-10 04:26:41 -07001493 struct PACKED(4) tls_32bit_sized_values {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001494 // We have no control over the size of 'bool', but want our boolean fields
1495 // to be 4-byte quantities.
1496 typedef uint32_t bool32_t;
Ian Rogers22f454c2012-09-08 11:06:29 -07001497
Vladimir Markobf121912019-06-04 13:49:05 +01001498 explicit tls_32bit_sized_values(bool is_daemon)
1499 : suspend_count(0),
1500 debug_suspend_count(0),
1501 thin_lock_thread_id(0),
1502 tid(0),
1503 daemon(is_daemon),
1504 throwing_OutOfMemoryError(false),
1505 no_thread_suspension(0),
1506 thread_exit_check_count(0),
1507 handling_signal_(false),
1508 is_transitioning_to_runnable(false),
1509 ready_for_debug_invoke(false),
1510 debug_method_entry_(false),
1511 is_gc_marking(false),
1512 weak_ref_access_enabled(true),
1513 disable_thread_flip_count(0),
1514 user_code_suspend_count(0),
1515 force_interpreter_count(0),
1516 use_mterp(0),
1517 make_visibly_initialized_counter(0) {}
Dave Allisonb373e092014-02-20 16:06:36 -08001518
Ian Rogersdd7624d2014-03-14 17:43:00 -07001519 union StateAndFlags state_and_flags;
Andreas Gampe575e78c2014-11-03 23:41:03 -08001520 static_assert(sizeof(union StateAndFlags) == sizeof(int32_t),
1521 "Size of state_and_flags and int32 are different");
Dave Allisonb373e092014-02-20 16:06:36 -08001522
Ian Rogersdd7624d2014-03-14 17:43:00 -07001523 // A non-zero value is used to tell the current thread to enter a safe point
1524 // at the next poll.
1525 int suspend_count GUARDED_BY(Locks::thread_suspend_count_lock_);
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -07001526
Ian Rogersdd7624d2014-03-14 17:43:00 -07001527 // How much of 'suspend_count_' is by request of the debugger, used to set things right
1528 // when the debugger detaches. Must be <= suspend_count_.
1529 int debug_suspend_count GUARDED_BY(Locks::thread_suspend_count_lock_);
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001530
Ian Rogersdd7624d2014-03-14 17:43:00 -07001531 // Thin lock thread id. This is a small integer used by the thin lock implementation.
1532 // This is not to be confused with the native thread's tid, nor is it the value returned
1533 // by java.lang.Thread.getId --- this is a distinct value, used only for locking. One
1534 // important difference between this id and the ids visible to managed code is that these
1535 // ones get reused (to ensure that they fit in the number of bits available).
1536 uint32_t thin_lock_thread_id;
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001537
Ian Rogersdd7624d2014-03-14 17:43:00 -07001538 // System thread id.
1539 uint32_t tid;
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001540
Ian Rogersdd7624d2014-03-14 17:43:00 -07001541 // Is the thread a daemon?
1542 const bool32_t daemon;
Hiroshi Yamauchif5b0e202014-02-11 17:02:22 -08001543
Ian Rogersdd7624d2014-03-14 17:43:00 -07001544 // A boolean telling us whether we're recursively throwing OOME.
1545 bool32_t throwing_OutOfMemoryError;
1546
1547 // A positive value implies we're in a region where thread suspension isn't expected.
1548 uint32_t no_thread_suspension;
1549
1550 // How many times has our pthread key's destructor been called?
1551 uint32_t thread_exit_check_count;
Sebastien Hertz9f102032014-05-23 08:59:42 +02001552
Dave Allison648d7112014-07-25 16:15:27 -07001553 // True if signal is being handled by this thread.
1554 bool32_t handling_signal_;
1555
Hiroshi Yamauchiee235822016-08-19 17:03:27 -07001556 // True if the thread is in TransitionFromSuspendedToRunnable(). This is used to distinguish the
1557 // non-runnable threads (eg. kNative, kWaiting) that are about to transition to runnable from
1558 // the rest of them.
1559 bool32_t is_transitioning_to_runnable;
Sebastien Hertz1558b572015-02-25 15:05:59 +01001560
1561 // True if the thread has been suspended by a debugger event. This is
1562 // used to invoke method from the debugger which is only allowed when
1563 // the thread is suspended by an event.
1564 bool32_t ready_for_debug_invoke;
Sebastien Hertz9d6bf692015-04-10 12:12:33 +02001565
1566 // True if the thread enters a method. This is used to detect method entry
1567 // event for the debugger.
1568 bool32_t debug_method_entry_;
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001569
Hiroshi Yamauchi00370822015-08-18 14:47:25 -07001570 // True if the GC is in the marking phase. This is used for the CC collector only. This is
1571 // thread local so that we can simplify the logic to check for the fast path of read barriers of
1572 // GC roots.
1573 bool32_t is_gc_marking;
1574
Nicolas Geoffray365719c2017-03-08 13:11:50 +00001575 // Thread "interrupted" status; stays raised until queried or thrown.
1576 Atomic<bool32_t> interrupted;
1577
Charles Mungeraa31f492018-11-01 18:57:38 +00001578 AtomicInteger park_state_;
1579
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001580 // True if the thread is allowed to access a weak ref (Reference::GetReferent() and system
1581 // weaks) and to potentially mark an object alive/gray. This is used for concurrent reference
1582 // processing of the CC collector only. This is thread local so that we can enable/disable weak
1583 // ref access by using a checkpoint and avoid a race around the time weak ref access gets
1584 // disabled and concurrent reference processing begins (if weak ref access is disabled during a
1585 // pause, this is not an issue.) Other collectors use Runtime::DisallowNewSystemWeaks() and
1586 // ReferenceProcessor::EnableSlowPath().
1587 bool32_t weak_ref_access_enabled;
Hiroshi Yamauchi20a0be02016-02-19 15:44:06 -08001588
1589 // A thread local version of Heap::disable_thread_flip_count_. This keeps track of how many
1590 // levels of (nested) JNI critical sections the thread is in and is used to detect a nested JNI
1591 // critical section enter.
1592 uint32_t disable_thread_flip_count;
Alex Light88fd7202017-06-30 08:31:59 -07001593
Alex Lightcea42152018-09-18 22:51:55 +00001594 // How much of 'suspend_count_' is by request of user code, used to distinguish threads
1595 // suspended by the runtime from those suspended by user code.
Alex Light88fd7202017-06-30 08:31:59 -07001596 // This should have GUARDED_BY(Locks::user_code_suspension_lock_) but auto analysis cannot be
1597 // told that AssertHeld should be good enough.
1598 int user_code_suspend_count GUARDED_BY(Locks::thread_suspend_count_lock_);
David Srbecky28f6cff2018-10-16 15:07:28 +01001599
Alex Light3dacdd62019-03-12 15:45:47 +00001600 // Count of how many times this thread has been forced to interpreter. If this is not 0 the
1601 // thread must remain in interpreted code as much as possible.
1602 uint32_t force_interpreter_count;
1603
David Srbecky28f6cff2018-10-16 15:07:28 +01001604 // True if everything is in the ideal state for fast interpretation.
1605 // False if we need to switch to the C++ interpreter to handle special cases.
1606 std::atomic<bool32_t> use_mterp;
Vladimir Markobf121912019-06-04 13:49:05 +01001607
1608 // Counter for calls to initialize a class that's initialized but not visibly initialized.
1609 // When this reaches kMakeVisiblyInitializedCounterTriggerCount, we call the runtime to
1610 // make initialized classes visibly initialized. This is needed because we usually make
1611 // classes visibly initialized in batches but we do not want to be stuck with a class
1612 // initialized but not visibly initialized for a long time even if no more classes are
1613 // being initialized anymore.
1614 uint32_t make_visibly_initialized_counter;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001615 } tls32_;
1616
1617 struct PACKED(8) tls_64bit_sized_values {
Sebastien Hertz07474662015-08-25 15:12:33 +00001618 tls_64bit_sized_values() : trace_clock_base(0) {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001619 }
1620
1621 // The clock base used for tracing.
1622 uint64_t trace_clock_base;
1623
Ian Rogersdd7624d2014-03-14 17:43:00 -07001624 RuntimeStats stats;
1625 } tls64_;
1626
Andreas Gampe6aa13702015-10-28 10:57:25 -07001627 struct PACKED(sizeof(void*)) tls_ptr_sized_values {
Ian Rogersdd7624d2014-03-14 17:43:00 -07001628 tls_ptr_sized_values() : card_table(nullptr), exception(nullptr), stack_end(nullptr),
Andreas Gampe449357d2015-06-01 22:29:51 -07001629 managed_stack(), suspend_trigger(nullptr), jni_env(nullptr), tmp_jni_env(nullptr),
1630 self(nullptr), opeer(nullptr), jpeer(nullptr), stack_begin(nullptr), stack_size(0),
Nicolas Geoffray340dafa2016-11-18 16:03:10 +00001631 deps_or_stack_trace_sample(), wait_next(nullptr), monitor_enter_object(nullptr),
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07001632 top_handle_scope(nullptr), class_loader_override(nullptr), long_jump_context(nullptr),
Ian Rogersdd7624d2014-03-14 17:43:00 -07001633 instrumentation_stack(nullptr), debug_invoke_req(nullptr), single_step_control(nullptr),
Sebastien Hertz07474662015-08-25 15:12:33 +00001634 stacked_shadow_frame_record(nullptr), deoptimization_context_stack(nullptr),
Mingyao Yang99170c62015-07-06 11:10:37 -07001635 frame_id_to_shadow_frame(nullptr), name(nullptr), pthread_self(0),
Vladimir Marko05846472016-09-14 12:49:57 +01001636 last_no_thread_suspension_cause(nullptr), checkpoint_function(nullptr),
Roland Levillaine71b3542017-01-16 14:58:23 +00001637 thread_local_start(nullptr), thread_local_pos(nullptr), thread_local_end(nullptr),
Mathieu Chartier6bc77742017-04-18 17:46:23 -07001638 thread_local_limit(nullptr),
David Srbecky776f3f72018-10-15 18:03:55 +01001639 thread_local_objects(0), mterp_current_ibase(nullptr), thread_local_alloc_stack_top(nullptr),
Josh Gaoefd20cb2017-02-28 16:53:59 -08001640 thread_local_alloc_stack_end(nullptr),
Alex Light848574c2017-09-25 16:59:39 -07001641 flip_function(nullptr), method_verifier(nullptr), thread_local_mark_stack(nullptr),
1642 async_exception(nullptr) {
Mathieu Chartier12d625f2015-03-13 11:33:37 -07001643 std::fill(held_mutexes, held_mutexes + kLockLevelCount, nullptr);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001644 }
1645
1646 // The biased card table, see CardTable for details.
Ian Rogers13735952014-10-08 12:43:28 -07001647 uint8_t* card_table;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001648
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001649 // The pending exception or null.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001650 mirror::Throwable* exception;
1651
1652 // The end of this thread's stack. This is the lowest safely-addressable address on the stack.
1653 // We leave extra space so there's room for the code that throws StackOverflowError.
Ian Rogers13735952014-10-08 12:43:28 -07001654 uint8_t* stack_end;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001655
1656 // The top of the managed stack often manipulated directly by compiler generated code.
1657 ManagedStack managed_stack;
1658
1659 // In certain modes, setting this to 0 will trigger a SEGV and thus a suspend check. It is
1660 // normally set to the address of itself.
1661 uintptr_t* suspend_trigger;
1662
1663 // Every thread may have an associated JNI environment
1664 JNIEnvExt* jni_env;
1665
Andreas Gampe449357d2015-06-01 22:29:51 -07001666 // Temporary storage to transfer a pre-allocated JNIEnvExt from the creating thread to the
1667 // created thread.
1668 JNIEnvExt* tmp_jni_env;
1669
Ian Rogersdd7624d2014-03-14 17:43:00 -07001670 // Initialized to "this". On certain architectures (such as x86) reading off of Thread::Current
1671 // is easy but getting the address of Thread::Current is hard. This field can be read off of
1672 // Thread::Current to give the address.
1673 Thread* self;
1674
1675 // Our managed peer (an instance of java.lang.Thread). The jobject version is used during thread
1676 // start up, until the thread is registered and the local opeer_ is used.
1677 mirror::Object* opeer;
1678 jobject jpeer;
1679
1680 // The "lowest addressable byte" of the stack.
Ian Rogers13735952014-10-08 12:43:28 -07001681 uint8_t* stack_begin;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001682
1683 // Size of the stack.
1684 size_t stack_size;
1685
Nicolas Geoffray340dafa2016-11-18 16:03:10 +00001686 // Sampling profiler and AOT verification cannot happen on the same run, so we share
1687 // the same entry for the stack trace and the verifier deps.
1688 union DepsOrStackTraceSample {
1689 DepsOrStackTraceSample() {
1690 verifier_deps = nullptr;
1691 stack_trace_sample = nullptr;
1692 }
1693 // Pointer to previous stack trace captured by sampling profiler.
1694 std::vector<ArtMethod*>* stack_trace_sample;
1695 // When doing AOT verification, per-thread VerifierDeps.
1696 verifier::VerifierDeps* verifier_deps;
1697 } deps_or_stack_trace_sample;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001698
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001699 // The next thread in the wait set this thread is part of or null if not waiting.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001700 Thread* wait_next;
1701
1702 // If we're blocked in MonitorEnter, this is the object we're trying to lock.
1703 mirror::Object* monitor_enter_object;
1704
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001705 // Top of linked list of handle scopes or null for none.
Mathieu Chartiere8a3c572016-10-11 16:52:17 -07001706 BaseHandleScope* top_handle_scope;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001707
1708 // Needed to get the right ClassLoader in JNI_OnLoad, but also
1709 // useful for testing.
Ian Rogers68d8b422014-07-17 11:09:10 -07001710 jobject class_loader_override;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001711
1712 // Thread local, lazily allocated, long jump context. Used to deliver exceptions.
1713 Context* long_jump_context;
1714
1715 // Additional stack used by method instrumentation to store method and return pc values.
1716 // Stored as a pointer since std::deque is not PACKED.
1717 std::deque<instrumentation::InstrumentationStackFrame>* instrumentation_stack;
1718
1719 // JDWP invoke-during-breakpoint support.
1720 DebugInvokeReq* debug_invoke_req;
1721
1722 // JDWP single-stepping support.
1723 SingleStepControl* single_step_control;
1724
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001725 // For gc purpose, a shadow frame record stack that keeps track of:
1726 // 1) shadow frames under construction.
1727 // 2) deoptimization shadow frames.
1728 StackedShadowFrameRecord* stacked_shadow_frame_record;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001729
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001730 // Deoptimization return value record stack.
Sebastien Hertz07474662015-08-25 15:12:33 +00001731 DeoptimizationContextRecord* deoptimization_context_stack;
Andreas Gampe2a0d4ec2014-06-02 22:05:22 -07001732
Mingyao Yang99170c62015-07-06 11:10:37 -07001733 // For debugger, a linked list that keeps the mapping from frame_id to shadow frame.
1734 // Shadow frames may be created before deoptimization happens so that the debugger can
1735 // set local values there first.
1736 FrameIdToShadowFrame* frame_id_to_shadow_frame;
1737
Ian Rogersdd7624d2014-03-14 17:43:00 -07001738 // A cached copy of the java.lang.Thread's name.
1739 std::string* name;
1740
1741 // A cached pthread_t for the pthread underlying this Thread*.
1742 pthread_t pthread_self;
1743
Ian Rogersdd7624d2014-03-14 17:43:00 -07001744 // If no_thread_suspension_ is > 0, what is causing that assertion.
1745 const char* last_no_thread_suspension_cause;
1746
Mathieu Chartier952e1e32016-06-13 14:04:02 -07001747 // Pending checkpoint function or null if non-pending. If this checkpoint is set and someone\
1748 // requests another checkpoint, it goes to the checkpoint overflow list.
1749 Closure* checkpoint_function GUARDED_BY(Locks::thread_suspend_count_lock_);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001750
Yu Lieac44242015-06-29 10:50:03 +08001751 // Pending barriers that require passing or NULL if non-pending. Installation guarding by
1752 // Locks::thread_suspend_count_lock_.
1753 // They work effectively as art::Barrier, but implemented directly using AtomicInteger and futex
1754 // to avoid additional cost of a mutex and a condition variable, as used in art::Barrier.
1755 AtomicInteger* active_suspend_barriers[kMaxSuspendBarriers];
1756
Roland Levillaine71b3542017-01-16 14:58:23 +00001757 // Thread-local allocation pointer. Moved here to force alignment for thread_local_pos on ARM.
1758 uint8_t* thread_local_start;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001759
Hiroshi Yamauchi7e1ce282015-12-11 15:46:19 -08001760 // thread_local_pos and thread_local_end must be consecutive for ldrd and are 8 byte aligned for
1761 // potentially better performance.
Ian Rogers13735952014-10-08 12:43:28 -07001762 uint8_t* thread_local_pos;
1763 uint8_t* thread_local_end;
Igor Murashkinaf1e2992016-10-12 17:44:50 -07001764
Mathieu Chartier6bc77742017-04-18 17:46:23 -07001765 // Thread local limit is how much we can expand the thread local buffer to, it is greater or
1766 // equal to thread_local_end.
1767 uint8_t* thread_local_limit;
1768
Vladimir Marko05846472016-09-14 12:49:57 +01001769 size_t thread_local_objects;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001770
Roland Levillaine71b3542017-01-16 14:58:23 +00001771 // Entrypoint function pointers.
1772 // TODO: move this to more of a global offset table model to avoid per-thread duplication.
1773 JniEntryPoints jni_entrypoints;
1774 QuickEntryPoints quick_entrypoints;
1775
David Srbecky776f3f72018-10-15 18:03:55 +01001776 // Mterp jump table base.
buzbee1452bee2015-03-06 14:43:04 -08001777 void* mterp_current_ibase;
buzbee1452bee2015-03-06 14:43:04 -08001778
Mathieu Chartier0651d412014-04-29 14:37:57 -07001779 // There are RosAlloc::kNumThreadLocalSizeBrackets thread-local size brackets per thread.
Hiroshi Yamauchi7ed9c562016-02-02 15:22:09 -08001780 void* rosalloc_runs[kNumRosAllocThreadLocalSizeBracketsInThread];
Ian Rogersdd7624d2014-03-14 17:43:00 -07001781
1782 // Thread-local allocation stack data/routines.
Mathieu Chartiercb535da2015-01-23 13:50:03 -08001783 StackReference<mirror::Object>* thread_local_alloc_stack_top;
1784 StackReference<mirror::Object>* thread_local_alloc_stack_end;
Chao-ying Fu9e369312014-05-21 11:20:52 -07001785
1786 // Support for Mutex lock hierarchy bug detection.
1787 BaseMutex* held_mutexes[kLockLevelCount];
Dave Allison8ce6b902014-08-26 11:07:58 -07001788
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001789 // The function used for thread flip.
1790 Closure* flip_function;
Mathieu Chartier12d625f2015-03-13 11:33:37 -07001791
1792 // Current method verifier, used for root marking.
1793 verifier::MethodVerifier* method_verifier;
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001794
1795 // Thread-local mark stack for the concurrent copying collector.
1796 gc::accounting::AtomicStack<mirror::Object>* thread_local_mark_stack;
Alex Light848574c2017-09-25 16:59:39 -07001797
1798 // The pending async-exception or null.
1799 mirror::Throwable* async_exception;
Ian Rogersdd7624d2014-03-14 17:43:00 -07001800 } tlsPtr_;
1801
Alex Lightbb68fda2018-10-01 13:21:47 -07001802 // Small thread-local cache to be used from the interpreter.
1803 // It is keyed by dex instruction pointer.
1804 // The value is opcode-depended (e.g. field offset).
1805 InterpreterCache interpreter_cache_;
1806
1807 // All fields below this line should not be accessed by native code. This means these fields can
1808 // be modified, rearranged, added or removed without having to modify asm_support.h
1809
Nicolas Geoffray365719c2017-03-08 13:11:50 +00001810 // Guards the 'wait_monitor_' members.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001811 Mutex* wait_mutex_ DEFAULT_MUTEX_ACQUIRED_AFTER;
1812
1813 // Condition variable waited upon during a wait.
1814 ConditionVariable* wait_cond_ GUARDED_BY(wait_mutex_);
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001815 // Pointer to the monitor lock we're currently waiting on or null if not waiting.
Ian Rogersdd7624d2014-03-14 17:43:00 -07001816 Monitor* wait_monitor_ GUARDED_BY(wait_mutex_);
1817
Mathieu Chartierdfe02f62016-02-01 20:15:11 -08001818 // Debug disable read barrier count, only is checked for debug builds and only in the runtime.
1819 uint8_t debug_disallow_read_barrier_ = 0;
1820
Mathieu Chartier3f7f03c2016-09-26 11:39:52 -07001821 // Note that it is not in the packed struct, may not be accessed for cross compilation.
1822 uintptr_t poison_object_cookie_ = 0;
1823
Mathieu Chartier952e1e32016-06-13 14:04:02 -07001824 // Pending extra checkpoints if checkpoint_function_ is already used.
1825 std::list<Closure*> checkpoint_overflow_ GUARDED_BY(Locks::thread_suspend_count_lock_);
1826
Alex Light184f0752018-07-13 11:18:22 -07001827 // Custom TLS field that can be used by plugins or the runtime. Should not be accessed directly by
1828 // compiled code or entrypoints.
1829 SafeMap<std::string, std::unique_ptr<TLSData>> custom_tls_ GUARDED_BY(Locks::custom_tls_lock_);
Andreas Gampef26bf2d2017-01-13 16:47:14 -08001830
Andreas Gampe82372002019-07-24 15:42:09 -07001831#ifndef __BIONIC__
Andreas Gampe2be43062019-07-24 16:52:33 -07001832 __attribute__((tls_model("initial-exec")))
Andreas Gampe82372002019-07-24 15:42:09 -07001833 static thread_local Thread* self_tls_;
1834#endif
1835
Alex Lighte9f61032018-09-24 16:04:51 -07001836 // True if the thread is some form of runtime thread (ex, GC or JIT).
1837 bool is_runtime_thread_;
Calin Juravleccd56952016-12-15 17:57:38 +00001838
Orion Hodson01ecfa12019-07-18 12:57:47 +01001839 // Set during execution of JNI methods that get field and method id's as part of determining if
1840 // the caller is allowed to access all fields and methods in the Core Platform API.
1841 uint32_t core_platform_api_cookie_ = 0;
1842
Mathieu Chartiere6da9af2013-12-16 11:54:42 -08001843 friend class Dbg; // For SetStateUnsafe.
Mathieu Chartier15d34022014-02-26 17:16:38 -08001844 friend class gc::collector::SemiSpace; // For getting stack traces.
Mathieu Chartier692fafd2013-11-29 17:24:40 -08001845 friend class Runtime; // For CreatePeer.
Ian Rogers5cf98192014-05-29 21:31:50 -07001846 friend class QuickExceptionHandler; // For dumping the stack.
Mathieu Chartier692fafd2013-11-29 17:24:40 -08001847 friend class ScopedThreadStateChange;
Mathieu Chartier119c6bd2014-05-09 14:11:47 -07001848 friend class StubTest; // For accessing entrypoints.
Mathieu Chartier692fafd2013-11-29 17:24:40 -08001849 friend class ThreadList; // For ~Thread and Destroy.
1850
Andreas Gampe4352b452014-06-04 18:59:01 -07001851 friend class EntrypointsOrderTest; // To test the order of tls entries.
1852
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001853 DISALLOW_COPY_AND_ASSIGN(Thread);
1854};
Ian Rogersbdb03912011-09-14 00:55:44 -07001855
Mathieu Chartier4e2cb092015-07-22 16:17:51 -07001856class SCOPED_CAPABILITY ScopedAssertNoThreadSuspension {
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001857 public:
Mingyao Yangf26828b2017-07-27 12:49:01 -07001858 ALWAYS_INLINE ScopedAssertNoThreadSuspension(const char* cause,
1859 bool enabled = true)
1860 ACQUIRE(Roles::uninterruptible_)
1861 : enabled_(enabled) {
1862 if (!enabled_) {
1863 return;
1864 }
Mathieu Chartier268764d2016-09-13 12:09:38 -07001865 if (kIsDebugBuild) {
1866 self_ = Thread::Current();
1867 old_cause_ = self_->StartAssertNoThreadSuspension(cause);
1868 } else {
1869 Roles::uninterruptible_.Acquire(); // No-op.
1870 }
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001871 }
Mathieu Chartier268764d2016-09-13 12:09:38 -07001872 ALWAYS_INLINE ~ScopedAssertNoThreadSuspension() RELEASE(Roles::uninterruptible_) {
Mingyao Yangf26828b2017-07-27 12:49:01 -07001873 if (!enabled_) {
1874 return;
1875 }
Mathieu Chartier268764d2016-09-13 12:09:38 -07001876 if (kIsDebugBuild) {
1877 self_->EndAssertNoThreadSuspension(old_cause_);
1878 } else {
1879 Roles::uninterruptible_.Release(); // No-op.
1880 }
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001881 }
1882
1883 private:
Mathieu Chartier268764d2016-09-13 12:09:38 -07001884 Thread* self_;
Mingyao Yangf26828b2017-07-27 12:49:01 -07001885 const bool enabled_;
Mathieu Chartier268764d2016-09-13 12:09:38 -07001886 const char* old_cause_;
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07001887};
1888
Mingyao Yang1f2d3ba2015-05-18 12:12:50 -07001889class ScopedStackedShadowFramePusher {
1890 public:
1891 ScopedStackedShadowFramePusher(Thread* self, ShadowFrame* sf, StackedShadowFrameType type)
1892 : self_(self), type_(type) {
1893 self_->PushStackedShadowFrame(sf, type);
1894 }
1895 ~ScopedStackedShadowFramePusher() {
1896 self_->PopStackedShadowFrame(type_);
1897 }
1898
1899 private:
1900 Thread* const self_;
1901 const StackedShadowFrameType type_;
1902
1903 DISALLOW_COPY_AND_ASSIGN(ScopedStackedShadowFramePusher);
1904};
1905
Mathieu Chartierdfe02f62016-02-01 20:15:11 -08001906// Only works for debug builds.
1907class ScopedDebugDisallowReadBarriers {
1908 public:
1909 explicit ScopedDebugDisallowReadBarriers(Thread* self) : self_(self) {
1910 self_->ModifyDebugDisallowReadBarrier(1);
1911 }
1912 ~ScopedDebugDisallowReadBarriers() {
1913 self_->ModifyDebugDisallowReadBarrier(-1);
1914 }
1915
1916 private:
1917 Thread* const self_;
1918};
1919
Hiroshi Yamauchiee235822016-08-19 17:03:27 -07001920class ScopedTransitioningToRunnable : public ValueObject {
1921 public:
1922 explicit ScopedTransitioningToRunnable(Thread* self)
1923 : self_(self) {
1924 DCHECK_EQ(self, Thread::Current());
1925 if (kUseReadBarrier) {
1926 self_->SetIsTransitioningToRunnable(true);
1927 }
1928 }
1929
1930 ~ScopedTransitioningToRunnable() {
1931 if (kUseReadBarrier) {
1932 self_->SetIsTransitioningToRunnable(false);
1933 }
1934 }
1935
1936 private:
1937 Thread* const self_;
1938};
1939
Andreas Gampe04bbb5b2017-01-19 17:49:03 +00001940class ThreadLifecycleCallback {
1941 public:
1942 virtual ~ThreadLifecycleCallback() {}
1943
1944 virtual void ThreadStart(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) = 0;
1945 virtual void ThreadDeath(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) = 0;
1946};
1947
Alex Lightb7c640d2019-03-20 15:52:13 -07001948// Store an exception from the thread and suppress it for the duration of this object.
1949class ScopedExceptionStorage {
1950 public:
1951 explicit ScopedExceptionStorage(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_);
Alex Light79d6c802019-06-27 15:50:11 +00001952 void SuppressOldException(const char* message = "") REQUIRES_SHARED(Locks::mutator_lock_);
Alex Lightb7c640d2019-03-20 15:52:13 -07001953 ~ScopedExceptionStorage() REQUIRES_SHARED(Locks::mutator_lock_);
1954
1955 private:
1956 Thread* self_;
1957 StackHandleScope<1> hs_;
Alex Light79d6c802019-06-27 15:50:11 +00001958 MutableHandle<mirror::Throwable> excp_;
Alex Lightb7c640d2019-03-20 15:52:13 -07001959};
1960
Elliott Hughes330304d2011-08-12 14:28:05 -07001961std::ostream& operator<<(std::ostream& os, const Thread& thread);
Sebastien Hertzf7958692015-06-09 14:09:14 +02001962std::ostream& operator<<(std::ostream& os, const StackedShadowFrameType& thread);
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001963
Carl Shapiro0e5d75d2011-07-06 18:28:37 -07001964} // namespace art
1965
Brian Carlstromfc0e3212013-07-17 14:40:12 -07001966#endif // ART_RUNTIME_THREAD_H_