Elliott Hughes | 8d768a9 | 2011-09-14 16:35:25 -0700 | [diff] [blame] | 1 | /* |
| 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 Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 16 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 17 | #ifndef ART_RUNTIME_THREAD_H_ |
| 18 | #define ART_RUNTIME_THREAD_H_ |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 19 | |
Elliott Hughes | 02b48d1 | 2011-09-07 17:15:51 -0700 | [diff] [blame] | 20 | #include <bitset> |
Ian Rogers | 306057f | 2012-11-26 12:45:53 -0800 | [diff] [blame] | 21 | #include <deque> |
Elliott Hughes | a095764 | 2011-09-02 14:27:33 -0700 | [diff] [blame] | 22 | #include <iosfwd> |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 23 | #include <list> |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 24 | #include <memory> |
Dave Allison | 8ce6b90 | 2014-08-26 11:07:58 -0700 | [diff] [blame] | 25 | #include <setjmp.h> |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 26 | #include <string> |
Carl Shapiro | b557353 | 2011-07-12 18:22:59 -0700 | [diff] [blame] | 27 | |
Mingyao Yang | 4dcfc43 | 2015-04-21 16:55:22 -0700 | [diff] [blame] | 28 | #include "arch/context.h" |
Ian Rogers | d582fa4 | 2014-11-05 23:46:43 -0800 | [diff] [blame] | 29 | #include "arch/instruction_set.h" |
Ian Rogers | b8e087e | 2014-07-09 21:12:06 -0700 | [diff] [blame] | 30 | #include "atomic.h" |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 31 | #include "base/enums.h" |
Elliott Hughes | 7616005 | 2012-12-12 16:31:20 -0800 | [diff] [blame] | 32 | #include "base/macros.h" |
Ian Rogers | 719d1a3 | 2014-03-06 12:13:39 -0800 | [diff] [blame] | 33 | #include "base/mutex.h" |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 34 | #include "entrypoints/jni/jni_entrypoints.h" |
Ian Rogers | 7655f29 | 2013-07-29 11:07:13 -0700 | [diff] [blame] | 35 | #include "entrypoints/quick/quick_entrypoints.h" |
Andreas Gampe | 2c19f5b | 2016-11-28 08:10:18 -0800 | [diff] [blame] | 36 | #include "gc_root.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 37 | #include "globals.h" |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 38 | #include "handle_scope.h" |
Elliott Hughes | 956af0f | 2014-12-11 14:34:28 -0800 | [diff] [blame] | 39 | #include "instrumentation.h" |
Ian Rogers | 306057f | 2012-11-26 12:45:53 -0800 | [diff] [blame] | 40 | #include "jvalue.h" |
Mathieu Chartier | 83c8ee0 | 2014-01-28 14:50:23 -0800 | [diff] [blame] | 41 | #include "object_callbacks.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 42 | #include "offsets.h" |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 43 | #include "runtime_stats.h" |
Elliott Hughes | 68e7652 | 2011-10-05 13:22:16 -0700 | [diff] [blame] | 44 | #include "stack.h" |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 45 | #include "thread_state.h" |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 46 | |
Christopher Ferris | 6cff48f | 2014-01-26 21:36:13 -0800 | [diff] [blame] | 47 | class BacktraceMap; |
| 48 | |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 49 | namespace art { |
| 50 | |
Mathieu Chartier | 15d3402 | 2014-02-26 17:16:38 -0800 | [diff] [blame] | 51 | namespace gc { |
Hiroshi Yamauchi | 0b71357 | 2015-06-16 18:29:23 -0700 | [diff] [blame] | 52 | namespace accounting { |
| 53 | template<class T> class AtomicStack; |
| 54 | } // namespace accounting |
Mathieu Chartier | 15d3402 | 2014-02-26 17:16:38 -0800 | [diff] [blame] | 55 | namespace collector { |
Mingyao Yang | 98d1cc8 | 2014-05-15 17:02:16 -0700 | [diff] [blame] | 56 | class SemiSpace; |
Mathieu Chartier | 15d3402 | 2014-02-26 17:16:38 -0800 | [diff] [blame] | 57 | } // namespace collector |
| 58 | } // namespace gc |
| 59 | |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 60 | namespace mirror { |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 61 | class Array; |
| 62 | class Class; |
| 63 | class ClassLoader; |
| 64 | class Object; |
| 65 | template<class T> class ObjectArray; |
| 66 | template<class T> class PrimitiveArray; |
| 67 | typedef PrimitiveArray<int32_t> IntArray; |
| 68 | class StackTraceElement; |
Vladimir Marko | 80afd02 | 2015-05-19 18:08:00 +0100 | [diff] [blame] | 69 | class String; |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 70 | class Throwable; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 71 | } // namespace mirror |
Mathieu Chartier | 12d625f | 2015-03-13 11:33:37 -0700 | [diff] [blame] | 72 | |
| 73 | namespace verifier { |
Nicolas Geoffray | 340dafa | 2016-11-18 16:03:10 +0000 | [diff] [blame] | 74 | class MethodVerifier; |
| 75 | class VerifierDeps; |
Mathieu Chartier | 12d625f | 2015-03-13 11:33:37 -0700 | [diff] [blame] | 76 | } // namespace verifier |
| 77 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 78 | class ArtMethod; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 79 | class BaseMutex; |
| 80 | class ClassLinker; |
Ian Rogers | 7a22fa6 | 2013-01-23 12:16:16 -0800 | [diff] [blame] | 81 | class Closure; |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 82 | class Context; |
Ian Rogers | 1b09b09 | 2012-08-20 15:35:52 -0700 | [diff] [blame] | 83 | struct DebugInvokeReq; |
Sebastien Hertz | 0747466 | 2015-08-25 15:12:33 +0000 | [diff] [blame] | 84 | class DeoptimizationContextRecord; |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 85 | class DexFile; |
Mingyao Yang | 99170c6 | 2015-07-06 11:10:37 -0700 | [diff] [blame] | 86 | class FrameIdToShadowFrame; |
Ian Rogers | b48b9eb | 2014-02-28 16:20:21 -0800 | [diff] [blame] | 87 | class JavaVMExt; |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 88 | struct JNIEnvExt; |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 89 | class Monitor; |
Mathieu Chartier | 2b7c4d1 | 2014-05-19 10:52:16 -0700 | [diff] [blame] | 90 | class ScopedObjectAccessAlreadyRunnable; |
Logan Chien | f7ad17e | 2012-03-15 03:10:03 +0800 | [diff] [blame] | 91 | class ShadowFrame; |
Sebastien Hertz | 597c4f0 | 2015-01-26 17:37:14 +0100 | [diff] [blame] | 92 | class SingleStepControl; |
Sebastien Hertz | f795869 | 2015-06-09 14:09:14 +0200 | [diff] [blame] | 93 | class StackedShadowFrameRecord; |
Brian Carlstrom | 40381fb | 2011-10-19 14:13:40 -0700 | [diff] [blame] | 94 | class Thread; |
| 95 | class ThreadList; |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 96 | |
Elliott Hughes | 34e0696 | 2012-04-09 13:55:55 -0700 | [diff] [blame] | 97 | // Thread priorities. These must match the Thread.MIN_PRIORITY, |
| 98 | // Thread.NORM_PRIORITY, and Thread.MAX_PRIORITY constants. |
| 99 | enum ThreadPriority { |
| 100 | kMinThreadPriority = 1, |
| 101 | kNormThreadPriority = 5, |
| 102 | kMaxThreadPriority = 10, |
| 103 | }; |
| 104 | |
Ian Rogers | 474b6da | 2012-09-25 00:20:38 -0700 | [diff] [blame] | 105 | enum ThreadFlag { |
Ian Rogers | 50ffee2 | 2012-11-20 11:47:44 -0800 | [diff] [blame] | 106 | kSuspendRequest = 1, // If set implies that suspend_count_ > 0 and the Thread should enter the |
| 107 | // safepoint handler. |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 108 | kCheckpointRequest = 2, // Request that the thread do some checkpoint work and then continue. |
Hiroshi Yamauchi | 3049324 | 2016-11-03 13:06:52 -0700 | [diff] [blame] | 109 | kEmptyCheckpointRequest = 4, // Request that the thread do empty checkpoint and then continue. |
| 110 | kActiveSuspendBarrier = 8, // Register that at least 1 suspend barrier needs to be passed. |
Ian Rogers | 474b6da | 2012-09-25 00:20:38 -0700 | [diff] [blame] | 111 | }; |
| 112 | |
Sebastien Hertz | f795869 | 2015-06-09 14:09:14 +0200 | [diff] [blame] | 113 | enum class StackedShadowFrameType { |
Mingyao Yang | 1f2d3ba | 2015-05-18 12:12:50 -0700 | [diff] [blame] | 114 | kShadowFrameUnderConstruction, |
Andreas Gampe | 639bdd1 | 2015-06-03 11:22:45 -0700 | [diff] [blame] | 115 | kDeoptimizationShadowFrame, |
Mingyao Yang | 1f2d3ba | 2015-05-18 12:12:50 -0700 | [diff] [blame] | 116 | }; |
| 117 | |
Hiroshi Yamauchi | 7ed9c56 | 2016-02-02 15:22:09 -0800 | [diff] [blame] | 118 | // This should match RosAlloc::kNumThreadLocalSizeBrackets. |
| 119 | static constexpr size_t kNumRosAllocThreadLocalSizeBracketsInThread = 16; |
Ian Rogers | e63db27 | 2014-07-15 15:36:11 -0700 | [diff] [blame] | 120 | |
Dave Allison | 648d711 | 2014-07-25 16:15:27 -0700 | [diff] [blame] | 121 | // Thread's stack layout for implicit stack overflow checks: |
| 122 | // |
| 123 | // +---------------------+ <- highest address of stack memory |
| 124 | // | | |
| 125 | // . . <- SP |
| 126 | // | | |
| 127 | // | | |
| 128 | // +---------------------+ <- stack_end |
| 129 | // | | |
| 130 | // | Gap | |
| 131 | // | | |
| 132 | // +---------------------+ <- stack_begin |
| 133 | // | | |
| 134 | // | Protected region | |
| 135 | // | | |
| 136 | // +---------------------+ <- lowest address of stack memory |
| 137 | // |
| 138 | // The stack always grows down in memory. At the lowest address is a region of memory |
| 139 | // that is set mprotect(PROT_NONE). Any attempt to read/write to this region will |
| 140 | // result in a segmentation fault signal. At any point, the thread's SP will be somewhere |
| 141 | // between the stack_end and the highest address in stack memory. An implicit stack |
| 142 | // overflow check is a read of memory at a certain offset below the current SP (4K typically). |
| 143 | // If the thread's SP is below the stack_end address this will be a read into the protected |
| 144 | // region. If the SP is above the stack_end address, the thread is guaranteed to have |
| 145 | // at least 4K of space. Because stack overflow checks are only performed in generated code, |
| 146 | // if the thread makes a call out to a native function (through JNI), that native function |
| 147 | // might only have 4K of memory (if the SP is adjacent to stack_end). |
| 148 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 149 | class Thread { |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 150 | public: |
Andreas Gampe | 7ea6f79 | 2014-07-14 16:21:44 -0700 | [diff] [blame] | 151 | static const size_t kStackOverflowImplicitCheckSize; |
Dave Allison | f943914 | 2014-03-27 15:10:22 -0700 | [diff] [blame] | 152 | |
Elliott Hughes | 462c944 | 2012-03-23 18:47:50 -0700 | [diff] [blame] | 153 | // Creates a new native thread corresponding to the given managed peer. |
| 154 | // Used to implement Thread.start. |
Ian Rogers | 52673ff | 2012-06-27 23:25:34 -0700 | [diff] [blame] | 155 | static void CreateNativeThread(JNIEnv* env, jobject peer, size_t stack_size, bool daemon); |
Carl Shapiro | 61e019d | 2011-07-14 16:53:09 -0700 | [diff] [blame] | 156 | |
Elliott Hughes | 462c944 | 2012-03-23 18:47:50 -0700 | [diff] [blame] | 157 | // Attaches the calling native thread to the runtime, returning the new native peer. |
| 158 | // Used to implement JNI AttachCurrentThread and AttachCurrentThreadAsDaemon calls. |
Mathieu Chartier | 664bebf | 2012-11-12 16:54:11 -0800 | [diff] [blame] | 159 | static Thread* Attach(const char* thread_name, bool as_daemon, jobject thread_group, |
| 160 | bool create_peer); |
Carl Shapiro | b557353 | 2011-07-12 18:22:59 -0700 | [diff] [blame] | 161 | |
Brian Carlstrom | caabb1b | 2011-10-11 18:09:13 -0700 | [diff] [blame] | 162 | // Reset internal state of child thread after fork. |
| 163 | void InitAfterFork(); |
| 164 | |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 165 | // Get the currently executing thread, frequently referred to as 'self'. This call has reasonably |
| 166 | // high cost and so we favor passing self around when possible. |
| 167 | // TODO: mark as PURE so the compiler may coalesce and remove? |
Ian Rogers | 02ed4c0 | 2013-09-06 13:10:04 -0700 | [diff] [blame] | 168 | static Thread* Current(); |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 169 | |
Ian Rogers | 7b078e8 | 2014-09-10 14:44:24 -0700 | [diff] [blame] | 170 | // On a runnable thread, check for pending thread suspension request and handle if pending. |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 171 | void AllowThreadSuspension() REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | 7b078e8 | 2014-09-10 14:44:24 -0700 | [diff] [blame] | 172 | |
| 173 | // Process pending thread suspension request and handle if pending. |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 174 | void CheckSuspend() REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | 7b078e8 | 2014-09-10 14:44:24 -0700 | [diff] [blame] | 175 | |
Hiroshi Yamauchi | 3049324 | 2016-11-03 13:06:52 -0700 | [diff] [blame] | 176 | // Process a pending empty checkpoint if pending. |
| 177 | void CheckEmptyCheckpoint() REQUIRES_SHARED(Locks::mutator_lock_); |
| 178 | |
Mathieu Chartier | 2b7c4d1 | 2014-05-19 10:52:16 -0700 | [diff] [blame] | 179 | static Thread* FromManagedThread(const ScopedObjectAccessAlreadyRunnable& ts, |
Mathieu Chartier | f5769e1 | 2017-01-10 15:54:41 -0800 | [diff] [blame] | 180 | ObjPtr<mirror::Object> thread_peer) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 181 | REQUIRES(Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 182 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mathieu Chartier | 2b7c4d1 | 2014-05-19 10:52:16 -0700 | [diff] [blame] | 183 | static Thread* FromManagedThread(const ScopedObjectAccessAlreadyRunnable& ts, jobject thread) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 184 | REQUIRES(Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 185 | REQUIRES_SHARED(Locks::mutator_lock_); |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 186 | |
Elliott Hughes | 28fa76d | 2012-04-09 17:31:46 -0700 | [diff] [blame] | 187 | // Translates 172 to pAllocArrayFromCode and so on. |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 188 | template<PointerSize size_of_pointers> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 189 | static void DumpThreadOffset(std::ostream& os, uint32_t offset); |
Elliott Hughes | 28fa76d | 2012-04-09 17:31:46 -0700 | [diff] [blame] | 190 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 191 | // Dumps a one-line summary of thread state (used for operator<<). |
| 192 | void ShortDump(std::ostream& os) const; |
| 193 | |
| 194 | // Dumps the detailed thread state and the thread stack (used for SIGQUIT). |
Nicolas Geoffray | a73280d | 2016-02-15 13:05:16 +0000 | [diff] [blame] | 195 | void Dump(std::ostream& os, |
| 196 | bool dump_native_stack = true, |
| 197 | BacktraceMap* backtrace_map = nullptr) const |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 198 | REQUIRES(!Locks::thread_suspend_count_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 199 | REQUIRES_SHARED(Locks::mutator_lock_); |
Elliott Hughes | a095764 | 2011-09-02 14:27:33 -0700 | [diff] [blame] | 200 | |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 201 | void DumpJavaStack(std::ostream& os) const |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 202 | REQUIRES(!Locks::thread_suspend_count_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 203 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mathieu Chartier | c751fdc | 2014-03-30 15:25:44 -0700 | [diff] [blame] | 204 | |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 205 | // Dumps the SIGQUIT per-thread header. 'thread' can be null for a non-attached thread, in which |
Elliott Hughes | abbe07d | 2012-06-05 17:42:23 -0700 | [diff] [blame] | 206 | // case we use 'tid' to identify the thread, and we'll include as much information as we can. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 207 | static void DumpState(std::ostream& os, const Thread* thread, pid_t tid) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 208 | REQUIRES(!Locks::thread_suspend_count_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 209 | REQUIRES_SHARED(Locks::mutator_lock_); |
Elliott Hughes | abbe07d | 2012-06-05 17:42:23 -0700 | [diff] [blame] | 210 | |
Ian Rogers | 474b6da | 2012-09-25 00:20:38 -0700 | [diff] [blame] | 211 | ThreadState GetState() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 212 | DCHECK_GE(tls32_.state_and_flags.as_struct.state, kTerminated); |
| 213 | DCHECK_LE(tls32_.state_and_flags.as_struct.state, kSuspended); |
| 214 | return static_cast<ThreadState>(tls32_.state_and_flags.as_struct.state); |
Dave Allison | 0aded08 | 2013-11-07 13:15:11 -0800 | [diff] [blame] | 215 | } |
| 216 | |
Ian Rogers | 474b6da | 2012-09-25 00:20:38 -0700 | [diff] [blame] | 217 | ThreadState SetState(ThreadState new_state); |
Ian Rogers | 52673ff | 2012-06-27 23:25:34 -0700 | [diff] [blame] | 218 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 219 | int GetSuspendCount() const REQUIRES(Locks::thread_suspend_count_lock_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 220 | return tls32_.suspend_count; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 221 | } |
Elliott Hughes | 038a806 | 2011-09-18 14:12:41 -0700 | [diff] [blame] | 222 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 223 | int GetDebugSuspendCount() const REQUIRES(Locks::thread_suspend_count_lock_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 224 | return tls32_.debug_suspend_count; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 225 | } |
| 226 | |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 227 | bool IsSuspended() const { |
Chris Dearman | 59cde53 | 2013-12-04 18:53:49 -0800 | [diff] [blame] | 228 | union StateAndFlags state_and_flags; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 229 | state_and_flags.as_int = tls32_.state_and_flags.as_int; |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 230 | return state_and_flags.as_struct.state != kRunnable && |
| 231 | (state_and_flags.as_struct.flags & kSuspendRequest) != 0; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 232 | } |
| 233 | |
Hiroshi Yamauchi | 02e7f1a | 2016-10-03 15:32:01 -0700 | [diff] [blame] | 234 | // If delta > 0 and (this != self or suspend_barrier is not null), this function may temporarily |
| 235 | // release thread_suspend_count_lock_ internally. |
| 236 | ALWAYS_INLINE |
| 237 | bool ModifySuspendCount(Thread* self, |
| 238 | int delta, |
| 239 | AtomicInteger* suspend_barrier, |
| 240 | bool for_debugger) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 241 | REQUIRES(Locks::thread_suspend_count_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 242 | |
Ian Rogers | d9c4fc9 | 2013-10-01 19:45:43 -0700 | [diff] [blame] | 243 | bool RequestCheckpoint(Closure* function) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 244 | REQUIRES(Locks::thread_suspend_count_lock_); |
Andreas Gampe | e9f6712 | 2016-10-27 19:21:23 -0700 | [diff] [blame] | 245 | void RequestSynchronousCheckpoint(Closure* function) |
| 246 | REQUIRES(!Locks::thread_suspend_count_lock_, !Locks::thread_list_lock_); |
Hiroshi Yamauchi | 3049324 | 2016-11-03 13:06:52 -0700 | [diff] [blame] | 247 | bool RequestEmptyCheckpoint() |
| 248 | REQUIRES(Locks::thread_suspend_count_lock_); |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 249 | |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 250 | void SetFlipFunction(Closure* function); |
| 251 | Closure* GetFlipFunction(); |
| 252 | |
Hiroshi Yamauchi | 0b71357 | 2015-06-16 18:29:23 -0700 | [diff] [blame] | 253 | gc::accounting::AtomicStack<mirror::Object>* GetThreadLocalMarkStack() { |
| 254 | CHECK(kUseReadBarrier); |
| 255 | return tlsPtr_.thread_local_mark_stack; |
| 256 | } |
| 257 | void SetThreadLocalMarkStack(gc::accounting::AtomicStack<mirror::Object>* stack) { |
| 258 | CHECK(kUseReadBarrier); |
| 259 | tlsPtr_.thread_local_mark_stack = stack; |
| 260 | } |
| 261 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 262 | // Called when thread detected that the thread_suspend_count_ was non-zero. Gives up share of |
| 263 | // mutator_lock_ and waits until it is resumed and thread_suspend_count_ is zero. |
Ian Rogers | 9da7f59 | 2012-08-20 17:14:28 -0700 | [diff] [blame] | 264 | void FullSuspendCheck() |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 265 | REQUIRES(!Locks::thread_suspend_count_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 266 | REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 267 | |
| 268 | // Transition from non-runnable to runnable state acquiring share on mutator_lock_. |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 269 | ALWAYS_INLINE ThreadState TransitionFromSuspendedToRunnable() |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 270 | REQUIRES(!Locks::thread_suspend_count_lock_) |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 271 | SHARED_LOCK_FUNCTION(Locks::mutator_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 272 | |
| 273 | // Transition from runnable into a state where mutator privileges are denied. Releases share of |
| 274 | // mutator lock. |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 275 | ALWAYS_INLINE void TransitionFromRunnableToSuspended(ThreadState new_state) |
Mathieu Chartier | 4e2cb09 | 2015-07-22 16:17:51 -0700 | [diff] [blame] | 276 | REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_) |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 277 | UNLOCK_FUNCTION(Locks::mutator_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 278 | |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 279 | // Once called thread suspension will cause an assertion failure. |
Mathieu Chartier | 4e2cb09 | 2015-07-22 16:17:51 -0700 | [diff] [blame] | 280 | const char* StartAssertNoThreadSuspension(const char* cause) ACQUIRE(Roles::uninterruptible_) { |
| 281 | Roles::uninterruptible_.Acquire(); // No-op. |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 282 | if (kIsDebugBuild) { |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 283 | CHECK(cause != nullptr); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 284 | const char* previous_cause = tlsPtr_.last_no_thread_suspension_cause; |
| 285 | tls32_.no_thread_suspension++; |
| 286 | tlsPtr_.last_no_thread_suspension_cause = cause; |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 287 | return previous_cause; |
| 288 | } else { |
| 289 | return nullptr; |
| 290 | } |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 291 | } |
Ian Rogers | 52673ff | 2012-06-27 23:25:34 -0700 | [diff] [blame] | 292 | |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 293 | // End region where no thread suspension is expected. |
Mathieu Chartier | 4e2cb09 | 2015-07-22 16:17:51 -0700 | [diff] [blame] | 294 | void EndAssertNoThreadSuspension(const char* old_cause) RELEASE(Roles::uninterruptible_) { |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 295 | if (kIsDebugBuild) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 296 | CHECK(old_cause != nullptr || tls32_.no_thread_suspension == 1); |
| 297 | CHECK_GT(tls32_.no_thread_suspension, 0U); |
| 298 | tls32_.no_thread_suspension--; |
| 299 | tlsPtr_.last_no_thread_suspension_cause = old_cause; |
Mathieu Chartier | 590fee9 | 2013-09-13 13:46:47 -0700 | [diff] [blame] | 300 | } |
Mathieu Chartier | 4e2cb09 | 2015-07-22 16:17:51 -0700 | [diff] [blame] | 301 | Roles::uninterruptible_.Release(); // No-op. |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 302 | } |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 303 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 304 | void AssertThreadSuspensionIsAllowable(bool check_locks = true) const; |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 305 | |
Mathieu Chartier | 10b218d | 2016-07-25 17:48:52 -0700 | [diff] [blame] | 306 | // Return true if thread suspension is allowable. |
| 307 | bool IsThreadSuspensionAllowable() const; |
| 308 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 309 | bool IsDaemon() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 310 | return tls32_.daemon; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 311 | } |
| 312 | |
Mathieu Chartier | 14c3bf9 | 2015-07-13 14:35:43 -0700 | [diff] [blame] | 313 | size_t NumberOfHeldMutexes() const; |
| 314 | |
Mathieu Chartier | f5769e1 | 2017-01-10 15:54:41 -0800 | [diff] [blame] | 315 | bool HoldsLock(ObjPtr<mirror::Object> object) const REQUIRES_SHARED(Locks::mutator_lock_); |
Elliott Hughes | 5f79133 | 2011-09-15 17:45:30 -0700 | [diff] [blame] | 316 | |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 317 | /* |
| 318 | * Changes the priority of this thread to match that of the java.lang.Thread object. |
| 319 | * |
| 320 | * We map a priority value from 1-10 to Linux "nice" values, where lower |
| 321 | * numbers indicate higher priority. |
| 322 | */ |
| 323 | void SetNativePriority(int newPriority); |
| 324 | |
| 325 | /* |
| 326 | * Returns the thread priority for the current thread by querying the system. |
| 327 | * This is useful when attaching a thread through JNI. |
| 328 | * |
| 329 | * Returns a value from 1 to 10 (compatible with java.lang.Thread values). |
| 330 | */ |
| 331 | static int GetNativePriority(); |
| 332 | |
Mathieu Chartier | 61b3cd4 | 2016-04-18 11:43:29 -0700 | [diff] [blame] | 333 | // Guaranteed to be non-zero. |
Ian Rogers | d9c4fc9 | 2013-10-01 19:45:43 -0700 | [diff] [blame] | 334 | uint32_t GetThreadId() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 335 | return tls32_.thin_lock_thread_id; |
Carl Shapiro | b557353 | 2011-07-12 18:22:59 -0700 | [diff] [blame] | 336 | } |
| 337 | |
Elliott Hughes | d92bec4 | 2011-09-02 17:04:36 -0700 | [diff] [blame] | 338 | pid_t GetTid() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 339 | return tls32_.tid; |
Elliott Hughes | d92bec4 | 2011-09-02 17:04:36 -0700 | [diff] [blame] | 340 | } |
Elliott Hughes | e27955c | 2011-08-26 15:21:24 -0700 | [diff] [blame] | 341 | |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 342 | // Returns the java.lang.Thread's name, or null if this Thread* doesn't have a peer. |
Andreas Gampe | 08883de | 2016-11-08 13:20:52 -0800 | [diff] [blame] | 343 | mirror::String* GetThreadName() const REQUIRES_SHARED(Locks::mutator_lock_); |
Elliott Hughes | 899e789 | 2012-01-24 14:57:32 -0800 | [diff] [blame] | 344 | |
Elliott Hughes | ffb465f | 2012-03-01 18:46:05 -0800 | [diff] [blame] | 345 | // Sets 'name' to the java.lang.Thread's name. This requires no transition to managed code, |
| 346 | // allocation, or locking. |
| 347 | void GetThreadName(std::string& name) const; |
| 348 | |
Elliott Hughes | 899e789 | 2012-01-24 14:57:32 -0800 | [diff] [blame] | 349 | // Sets the thread's name. |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 350 | void SetThreadName(const char* name) REQUIRES_SHARED(Locks::mutator_lock_); |
Elliott Hughes | fc86162 | 2011-10-17 17:57:47 -0700 | [diff] [blame] | 351 | |
Jeff Hao | 57dac6e | 2013-08-15 16:36:24 -0700 | [diff] [blame] | 352 | // Returns the thread-specific CPU-time clock in microseconds or -1 if unavailable. |
| 353 | uint64_t GetCpuMicroTime() const; |
| 354 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 355 | mirror::Object* GetPeer() const REQUIRES_SHARED(Locks::mutator_lock_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 356 | CHECK(tlsPtr_.jpeer == nullptr); |
| 357 | return tlsPtr_.opeer; |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 358 | } |
| 359 | |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 360 | bool HasPeer() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 361 | return tlsPtr_.jpeer != nullptr || tlsPtr_.opeer != nullptr; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 362 | } |
| 363 | |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 364 | RuntimeStats* GetStats() { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 365 | return &tls64_.stats; |
Elliott Hughes | 9d5ccec | 2011-09-19 13:19:50 -0700 | [diff] [blame] | 366 | } |
| 367 | |
Elliott Hughes | 7dc5166 | 2012-05-16 14:48:43 -0700 | [diff] [blame] | 368 | bool IsStillStarting() const; |
| 369 | |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 370 | bool IsExceptionPending() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 371 | return tlsPtr_.exception != nullptr; |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 372 | } |
| 373 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 374 | mirror::Throwable* GetException() const REQUIRES_SHARED(Locks::mutator_lock_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 375 | return tlsPtr_.exception; |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 376 | } |
| 377 | |
Andreas Gampe | d9efea6 | 2014-07-21 22:56:08 -0700 | [diff] [blame] | 378 | void AssertPendingException() const; |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 379 | void AssertPendingOOMException() const REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 380 | void AssertNoPendingException() const; |
Mathieu Chartier | 8d7672e | 2014-02-25 10:57:16 -0800 | [diff] [blame] | 381 | void AssertNoPendingExceptionForNewException(const char* msg) const; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 382 | |
Mathieu Chartier | 0795f23 | 2016-09-27 18:43:30 -0700 | [diff] [blame] | 383 | void SetException(ObjPtr<mirror::Throwable> new_exception) REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 384 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 385 | void ClearException() REQUIRES_SHARED(Locks::mutator_lock_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 386 | tlsPtr_.exception = nullptr; |
jeffhao | 94d6df4 | 2012-11-26 16:02:12 -0800 | [diff] [blame] | 387 | } |
| 388 | |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 389 | // Find catch block and perform long jump to appropriate exception handle |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 390 | NO_RETURN void QuickDeliverException() REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 391 | |
| 392 | Context* GetLongJumpContext(); |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 393 | void ReleaseLongJumpContext(Context* context) { |
Mingyao Yang | 4dcfc43 | 2015-04-21 16:55:22 -0700 | [diff] [blame] | 394 | if (tlsPtr_.long_jump_context != nullptr) { |
| 395 | // Each QuickExceptionHandler gets a long jump context and uses |
| 396 | // it for doing the long jump, after finding catch blocks/doing deoptimization. |
| 397 | // Both finding catch blocks and deoptimization can trigger another |
| 398 | // exception such as a result of class loading. So there can be nested |
| 399 | // cases of exception handling and multiple contexts being used. |
| 400 | // ReleaseLongJumpContext tries to save the context in tlsPtr_.long_jump_context |
| 401 | // for reuse so there is no need to always allocate a new one each time when |
| 402 | // getting a context. Since we only keep one context for reuse, delete the |
| 403 | // existing one since the passed in context is yet to be used for longjump. |
| 404 | delete tlsPtr_.long_jump_context; |
| 405 | } |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 406 | tlsPtr_.long_jump_context = context; |
Shih-wei Liao | 1a18c8c | 2011-08-14 17:47:36 -0700 | [diff] [blame] | 407 | } |
| 408 | |
Andreas Gampe | 6ec8ebd | 2014-07-25 13:36:56 -0700 | [diff] [blame] | 409 | // Get the current method and dex pc. If there are errors in retrieving the dex pc, this will |
| 410 | // abort the runtime iff abort_on_error is true. |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 411 | ArtMethod* GetCurrentMethod(uint32_t* dex_pc, bool abort_on_error = true) const |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 412 | REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 413 | |
Nicolas Geoffray | 7642cfc | 2015-02-26 10:56:09 +0000 | [diff] [blame] | 414 | // Returns whether the given exception was thrown by the current Java method being executed |
| 415 | // (Note that this includes native Java methods). |
Mathieu Chartier | f5769e1 | 2017-01-10 15:54:41 -0800 | [diff] [blame] | 416 | bool IsExceptionThrownByCurrentMethod(ObjPtr<mirror::Throwable> exception) const |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 417 | REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | 7642cfc | 2015-02-26 10:56:09 +0000 | [diff] [blame] | 418 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 419 | void SetTopOfStack(ArtMethod** top_method) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 420 | tlsPtr_.managed_stack.SetTopQuickFrame(top_method); |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 421 | } |
| 422 | |
Jeff Hao | 11ffc2d | 2013-02-01 11:52:17 -0800 | [diff] [blame] | 423 | void SetTopOfShadowStack(ShadowFrame* top) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 424 | tlsPtr_.managed_stack.SetTopShadowFrame(top); |
Jeff Hao | 11ffc2d | 2013-02-01 11:52:17 -0800 | [diff] [blame] | 425 | } |
| 426 | |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 427 | bool HasManagedStack() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 428 | return (tlsPtr_.managed_stack.GetTopQuickFrame() != nullptr) || |
| 429 | (tlsPtr_.managed_stack.GetTopShadowFrame() != nullptr); |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 430 | } |
| 431 | |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 432 | // If 'msg' is null, no detail message is set. |
Nicolas Geoffray | 0aa50ce | 2015-03-10 11:03:29 +0000 | [diff] [blame] | 433 | void ThrowNewException(const char* exception_class_descriptor, const char* msg) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 434 | REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); |
Elliott Hughes | 5cb5ad2 | 2011-10-02 12:13:39 -0700 | [diff] [blame] | 435 | |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 436 | // If 'msg' is null, no detail message is set. An exception must be pending, and will be |
Elliott Hughes | a4f9474 | 2012-05-29 16:28:38 -0700 | [diff] [blame] | 437 | // used as the new exception's cause. |
Nicolas Geoffray | 0aa50ce | 2015-03-10 11:03:29 +0000 | [diff] [blame] | 438 | void ThrowNewWrappedException(const char* exception_class_descriptor, const char* msg) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 439 | REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); |
Elliott Hughes | a4f9474 | 2012-05-29 16:28:38 -0700 | [diff] [blame] | 440 | |
Nicolas Geoffray | 0aa50ce | 2015-03-10 11:03:29 +0000 | [diff] [blame] | 441 | void ThrowNewExceptionF(const char* exception_class_descriptor, const char* fmt, ...) |
| 442 | __attribute__((format(printf, 3, 4))) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 443 | REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); |
Elliott Hughes | a5b897e | 2011-08-16 11:33:06 -0700 | [diff] [blame] | 444 | |
Nicolas Geoffray | 0aa50ce | 2015-03-10 11:03:29 +0000 | [diff] [blame] | 445 | void ThrowNewExceptionV(const char* exception_class_descriptor, const char* fmt, va_list ap) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 446 | REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_); |
Elliott Hughes | 4a2b417 | 2011-09-20 17:08:25 -0700 | [diff] [blame] | 447 | |
Elliott Hughes | 2ced6a5 | 2011-10-16 18:44:48 -0700 | [diff] [blame] | 448 | // OutOfMemoryError is special, because we need to pre-allocate an instance. |
Elliott Hughes | 8a8b9cb | 2012-04-13 18:29:22 -0700 | [diff] [blame] | 449 | // Only the GC should call this. |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 450 | void ThrowOutOfMemoryError(const char* msg) REQUIRES_SHARED(Locks::mutator_lock_) |
Mathieu Chartier | ed8990a | 2015-07-23 14:11:16 -0700 | [diff] [blame] | 451 | REQUIRES(!Roles::uninterruptible_); |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 452 | |
Elliott Hughes | be759c6 | 2011-09-08 19:38:21 -0700 | [diff] [blame] | 453 | static void Startup(); |
Elliott Hughes | 038a806 | 2011-09-18 14:12:41 -0700 | [diff] [blame] | 454 | static void FinishStartup(); |
Elliott Hughes | c1674ed | 2011-08-25 18:09:09 -0700 | [diff] [blame] | 455 | static void Shutdown(); |
Carl Shapiro | b557353 | 2011-07-12 18:22:59 -0700 | [diff] [blame] | 456 | |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 457 | // JNI methods |
Elliott Hughes | 69f5bc6 | 2011-08-24 09:26:14 -0700 | [diff] [blame] | 458 | JNIEnvExt* GetJniEnv() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 459 | return tlsPtr_.jni_env; |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 460 | } |
| 461 | |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 462 | // Convert a jobject into a Object* |
Mathieu Chartier | c4f3925 | 2016-10-05 18:32:08 -0700 | [diff] [blame] | 463 | ObjPtr<mirror::Object> DecodeJObject(jobject obj) const REQUIRES_SHARED(Locks::mutator_lock_); |
Hiroshi Yamauchi | 04302db | 2015-11-11 23:45:34 -0800 | [diff] [blame] | 464 | // Checks if the weak global ref has been cleared by the GC without decoding it. |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 465 | bool IsJWeakCleared(jweak obj) const REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 466 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 467 | mirror::Object* GetMonitorEnterObject() const REQUIRES_SHARED(Locks::mutator_lock_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 468 | return tlsPtr_.monitor_enter_object; |
| 469 | } |
| 470 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 471 | void SetMonitorEnterObject(mirror::Object* obj) REQUIRES_SHARED(Locks::mutator_lock_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 472 | tlsPtr_.monitor_enter_object = obj; |
| 473 | } |
| 474 | |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 475 | // Implements java.lang.Thread.interrupted. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 476 | bool Interrupted() REQUIRES(!*wait_mutex_); |
Elliott Hughes | 8daa092 | 2011-09-11 13:46:25 -0700 | [diff] [blame] | 477 | // Implements java.lang.Thread.isInterrupted. |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 478 | bool IsInterrupted() REQUIRES(!*wait_mutex_); |
| 479 | bool IsInterruptedLocked() REQUIRES(wait_mutex_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 480 | return interrupted_; |
| 481 | } |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 482 | void Interrupt(Thread* self) REQUIRES(!*wait_mutex_); |
| 483 | void SetInterruptedLocked(bool i) REQUIRES(wait_mutex_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 484 | interrupted_ = i; |
| 485 | } |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 486 | void Notify() REQUIRES(!*wait_mutex_); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 487 | |
Mathieu Chartier | 3f7f03c | 2016-09-26 11:39:52 -0700 | [diff] [blame] | 488 | ALWAYS_INLINE void PoisonObjectPointers() { |
| 489 | ++poison_object_cookie_; |
| 490 | } |
| 491 | |
Mathieu Chartier | a59d9b2 | 2016-09-26 18:13:17 -0700 | [diff] [blame] | 492 | ALWAYS_INLINE static void PoisonObjectPointersIfDebug(); |
| 493 | |
Mathieu Chartier | 3f7f03c | 2016-09-26 11:39:52 -0700 | [diff] [blame] | 494 | ALWAYS_INLINE uintptr_t GetPoisonObjectCookie() const { |
| 495 | return poison_object_cookie_; |
| 496 | } |
| 497 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 498 | private: |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 499 | void NotifyLocked(Thread* self) REQUIRES(wait_mutex_); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 500 | |
| 501 | public: |
| 502 | Mutex* GetWaitMutex() const LOCK_RETURNED(wait_mutex_) { |
| 503 | return wait_mutex_; |
| 504 | } |
| 505 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 506 | ConditionVariable* GetWaitConditionVariable() const REQUIRES(wait_mutex_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 507 | return wait_cond_; |
| 508 | } |
| 509 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 510 | Monitor* GetWaitMonitor() const REQUIRES(wait_mutex_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 511 | return wait_monitor_; |
| 512 | } |
| 513 | |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 514 | void SetWaitMonitor(Monitor* mon) REQUIRES(wait_mutex_) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 515 | wait_monitor_ = mon; |
| 516 | } |
| 517 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 518 | // Waiter link-list support. |
| 519 | Thread* GetWaitNext() const { |
| 520 | return tlsPtr_.wait_next; |
| 521 | } |
| 522 | |
| 523 | void SetWaitNext(Thread* next) { |
| 524 | tlsPtr_.wait_next = next; |
| 525 | } |
Elliott Hughes | 5f79133 | 2011-09-15 17:45:30 -0700 | [diff] [blame] | 526 | |
Ian Rogers | 68d8b42 | 2014-07-17 11:09:10 -0700 | [diff] [blame] | 527 | jobject GetClassLoaderOverride() { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 528 | return tlsPtr_.class_loader_override; |
buzbee | c143c55 | 2011-08-20 17:38:58 -0700 | [diff] [blame] | 529 | } |
| 530 | |
Ian Rogers | 68d8b42 | 2014-07-17 11:09:10 -0700 | [diff] [blame] | 531 | void SetClassLoaderOverride(jobject class_loader_override); |
buzbee | c143c55 | 2011-08-20 17:38:58 -0700 | [diff] [blame] | 532 | |
Ian Rogers | aaa2080 | 2011-09-11 21:47:37 -0700 | [diff] [blame] | 533 | // Create the internal representation of a stack trace, that is more time |
Sebastien Hertz | ee1d79a | 2014-02-21 15:46:30 +0100 | [diff] [blame] | 534 | // and space efficient to compute than the StackTraceElement[]. |
| 535 | template<bool kTransactionActive> |
Mathieu Chartier | 2b7c4d1 | 2014-05-19 10:52:16 -0700 | [diff] [blame] | 536 | jobject CreateInternalStackTrace(const ScopedObjectAccessAlreadyRunnable& soa) const |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 537 | REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | aaa2080 | 2011-09-11 21:47:37 -0700 | [diff] [blame] | 538 | |
Elliott Hughes | 01158d7 | 2011-09-19 19:47:10 -0700 | [diff] [blame] | 539 | // Convert an internal stack trace representation (returned by CreateInternalStackTrace) to a |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 540 | // StackTraceElement[]. If output_array is null, a new array is created, otherwise as many |
| 541 | // frames as will fit are written into the given array. If stack_depth is non-null, it's updated |
Elliott Hughes | 01158d7 | 2011-09-19 19:47:10 -0700 | [diff] [blame] | 542 | // with the number of valid frames in the returned array. |
Mathieu Chartier | 2b7c4d1 | 2014-05-19 10:52:16 -0700 | [diff] [blame] | 543 | static jobjectArray InternalStackTraceToStackTraceElementArray( |
| 544 | const ScopedObjectAccessAlreadyRunnable& soa, jobject internal, |
| 545 | jobjectArray output_array = nullptr, int* stack_depth = nullptr) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 546 | REQUIRES_SHARED(Locks::mutator_lock_); |
Shih-wei Liao | 55df06b | 2011-08-26 14:39:27 -0700 | [diff] [blame] | 547 | |
Mingyao Yang | 99170c6 | 2015-07-06 11:10:37 -0700 | [diff] [blame] | 548 | bool HasDebuggerShadowFrames() const { |
| 549 | return tlsPtr_.frame_id_to_shadow_frame != nullptr; |
| 550 | } |
| 551 | |
Andreas Gampe | 585da95 | 2016-12-02 14:52:29 -0800 | [diff] [blame] | 552 | void VisitRoots(RootVisitor* visitor, VisitRootFlags flags = kVisitRootFlagAllRoots) |
| 553 | REQUIRES_SHARED(Locks::mutator_lock_); |
Elliott Hughes | 410c0c8 | 2011-09-01 17:58:25 -0700 | [diff] [blame] | 554 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 555 | ALWAYS_INLINE void VerifyStack() REQUIRES_SHARED(Locks::mutator_lock_); |
jeffhao | 2504552 | 2012-03-13 19:34:37 -0700 | [diff] [blame] | 556 | |
Elliott Hughes | be759c6 | 2011-09-08 19:38:21 -0700 | [diff] [blame] | 557 | // |
| 558 | // Offsets of various members of native Thread class, used by compiled code. |
| 559 | // |
| 560 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 561 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 562 | static ThreadOffset<pointer_size> ThinLockIdOffset() { |
| 563 | return ThreadOffset<pointer_size>( |
| 564 | OFFSETOF_MEMBER(Thread, tls32_) + |
| 565 | OFFSETOF_MEMBER(tls_32bit_sized_values, thin_lock_thread_id)); |
Elliott Hughes | be759c6 | 2011-09-08 19:38:21 -0700 | [diff] [blame] | 566 | } |
| 567 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 568 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 569 | static ThreadOffset<pointer_size> ThreadFlagsOffset() { |
| 570 | return ThreadOffset<pointer_size>( |
| 571 | OFFSETOF_MEMBER(Thread, tls32_) + |
| 572 | OFFSETOF_MEMBER(tls_32bit_sized_values, state_and_flags)); |
Elliott Hughes | be759c6 | 2011-09-08 19:38:21 -0700 | [diff] [blame] | 573 | } |
| 574 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 575 | template<PointerSize pointer_size> |
Roland Levillain | 7c1559a | 2015-12-15 10:55:36 +0000 | [diff] [blame] | 576 | static ThreadOffset<pointer_size> IsGcMarkingOffset() { |
| 577 | return ThreadOffset<pointer_size>( |
| 578 | OFFSETOF_MEMBER(Thread, tls32_) + |
| 579 | OFFSETOF_MEMBER(tls_32bit_sized_values, is_gc_marking)); |
| 580 | } |
| 581 | |
Igor Murashkin | ae7ff92 | 2016-10-06 14:59:19 -0700 | [diff] [blame] | 582 | static constexpr size_t IsGcMarkingSize() { |
| 583 | return sizeof(tls32_.is_gc_marking); |
| 584 | } |
| 585 | |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 586 | // Deoptimize the Java stack. |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 587 | void DeoptimizeWithDeoptimizationException(JValue* result) REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | b331feb | 2016-02-05 16:51:53 +0000 | [diff] [blame] | 588 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 589 | private: |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 590 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 591 | static ThreadOffset<pointer_size> ThreadOffsetFromTlsPtr(size_t tls_ptr_offset) { |
| 592 | size_t base = OFFSETOF_MEMBER(Thread, tlsPtr_); |
| 593 | size_t scale; |
| 594 | size_t shrink; |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 595 | if (pointer_size == kRuntimePointerSize) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 596 | scale = 1; |
| 597 | shrink = 1; |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 598 | } else if (pointer_size > kRuntimePointerSize) { |
| 599 | scale = static_cast<size_t>(pointer_size) / static_cast<size_t>(kRuntimePointerSize); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 600 | shrink = 1; |
| 601 | } else { |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 602 | DCHECK_GT(kRuntimePointerSize, pointer_size); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 603 | scale = 1; |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 604 | shrink = static_cast<size_t>(kRuntimePointerSize) / static_cast<size_t>(pointer_size); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 605 | } |
| 606 | return ThreadOffset<pointer_size>(base + ((tls_ptr_offset * scale) / shrink)); |
Ian Rogers | 07ec8e1 | 2012-12-01 01:26:51 -0800 | [diff] [blame] | 607 | } |
| 608 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 609 | public: |
Jeff Hao | 848f70a | 2014-01-15 13:49:50 -0800 | [diff] [blame] | 610 | static uint32_t QuickEntryPointOffsetWithSize(size_t quick_entrypoint_offset, |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 611 | PointerSize pointer_size) { |
| 612 | if (pointer_size == PointerSize::k32) { |
| 613 | return QuickEntryPointOffset<PointerSize::k32>(quick_entrypoint_offset). |
| 614 | Uint32Value(); |
Jeff Hao | 848f70a | 2014-01-15 13:49:50 -0800 | [diff] [blame] | 615 | } else { |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 616 | return QuickEntryPointOffset<PointerSize::k64>(quick_entrypoint_offset). |
| 617 | Uint32Value(); |
Jeff Hao | 848f70a | 2014-01-15 13:49:50 -0800 | [diff] [blame] | 618 | } |
| 619 | } |
| 620 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 621 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 622 | static ThreadOffset<pointer_size> QuickEntryPointOffset(size_t quick_entrypoint_offset) { |
| 623 | return ThreadOffsetFromTlsPtr<pointer_size>( |
| 624 | OFFSETOF_MEMBER(tls_ptr_sized_values, quick_entrypoints) + quick_entrypoint_offset); |
Elliott Hughes | be759c6 | 2011-09-08 19:38:21 -0700 | [diff] [blame] | 625 | } |
| 626 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 627 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 628 | static ThreadOffset<pointer_size> JniEntryPointOffset(size_t jni_entrypoint_offset) { |
| 629 | return ThreadOffsetFromTlsPtr<pointer_size>( |
| 630 | OFFSETOF_MEMBER(tls_ptr_sized_values, jni_entrypoints) + jni_entrypoint_offset); |
Elliott Hughes | be759c6 | 2011-09-08 19:38:21 -0700 | [diff] [blame] | 631 | } |
| 632 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 633 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 634 | static ThreadOffset<pointer_size> SelfOffset() { |
| 635 | return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, self)); |
| 636 | } |
| 637 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 638 | template<PointerSize pointer_size> |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 639 | static ThreadOffset<pointer_size> MterpCurrentIBaseOffset() { |
| 640 | return ThreadOffsetFromTlsPtr<pointer_size>( |
| 641 | OFFSETOF_MEMBER(tls_ptr_sized_values, mterp_current_ibase)); |
| 642 | } |
| 643 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 644 | template<PointerSize pointer_size> |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 645 | static ThreadOffset<pointer_size> MterpDefaultIBaseOffset() { |
| 646 | return ThreadOffsetFromTlsPtr<pointer_size>( |
| 647 | OFFSETOF_MEMBER(tls_ptr_sized_values, mterp_default_ibase)); |
| 648 | } |
| 649 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 650 | template<PointerSize pointer_size> |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 651 | static ThreadOffset<pointer_size> MterpAltIBaseOffset() { |
| 652 | return ThreadOffsetFromTlsPtr<pointer_size>( |
| 653 | OFFSETOF_MEMBER(tls_ptr_sized_values, mterp_alt_ibase)); |
| 654 | } |
| 655 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 656 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 657 | static ThreadOffset<pointer_size> ExceptionOffset() { |
| 658 | return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, exception)); |
| 659 | } |
| 660 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 661 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 662 | static ThreadOffset<pointer_size> PeerOffset() { |
| 663 | return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, opeer)); |
| 664 | } |
| 665 | |
| 666 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 667 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 668 | static ThreadOffset<pointer_size> CardTableOffset() { |
| 669 | return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, card_table)); |
| 670 | } |
| 671 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 672 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 673 | static ThreadOffset<pointer_size> ThreadSuspendTriggerOffset() { |
| 674 | return ThreadOffsetFromTlsPtr<pointer_size>( |
| 675 | OFFSETOF_MEMBER(tls_ptr_sized_values, suspend_trigger)); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 676 | } |
| 677 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 678 | template<PointerSize pointer_size> |
Hiroshi Yamauchi | e01a520 | 2015-03-19 12:35:04 -0700 | [diff] [blame] | 679 | static ThreadOffset<pointer_size> ThreadLocalPosOffset() { |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 680 | return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, |
| 681 | thread_local_pos)); |
Hiroshi Yamauchi | e01a520 | 2015-03-19 12:35:04 -0700 | [diff] [blame] | 682 | } |
| 683 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 684 | template<PointerSize pointer_size> |
Hiroshi Yamauchi | e01a520 | 2015-03-19 12:35:04 -0700 | [diff] [blame] | 685 | static ThreadOffset<pointer_size> ThreadLocalEndOffset() { |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 686 | return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, |
| 687 | thread_local_end)); |
Hiroshi Yamauchi | e01a520 | 2015-03-19 12:35:04 -0700 | [diff] [blame] | 688 | } |
| 689 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 690 | template<PointerSize pointer_size> |
Hiroshi Yamauchi | e01a520 | 2015-03-19 12:35:04 -0700 | [diff] [blame] | 691 | static ThreadOffset<pointer_size> ThreadLocalObjectsOffset() { |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 692 | return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, |
| 693 | thread_local_objects)); |
Hiroshi Yamauchi | e01a520 | 2015-03-19 12:35:04 -0700 | [diff] [blame] | 694 | } |
| 695 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 696 | template<PointerSize pointer_size> |
Hiroshi Yamauchi | dc412b6 | 2015-10-15 12:26:57 -0700 | [diff] [blame] | 697 | static ThreadOffset<pointer_size> RosAllocRunsOffset() { |
| 698 | return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, |
| 699 | rosalloc_runs)); |
| 700 | } |
| 701 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 702 | template<PointerSize pointer_size> |
Hiroshi Yamauchi | dc412b6 | 2015-10-15 12:26:57 -0700 | [diff] [blame] | 703 | static ThreadOffset<pointer_size> ThreadLocalAllocStackTopOffset() { |
| 704 | return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, |
| 705 | thread_local_alloc_stack_top)); |
| 706 | } |
| 707 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 708 | template<PointerSize pointer_size> |
Hiroshi Yamauchi | dc412b6 | 2015-10-15 12:26:57 -0700 | [diff] [blame] | 709 | static ThreadOffset<pointer_size> ThreadLocalAllocStackEndOffset() { |
| 710 | return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, |
| 711 | thread_local_alloc_stack_end)); |
| 712 | } |
| 713 | |
Ian Rogers | 932746a | 2011-09-22 18:57:50 -0700 | [diff] [blame] | 714 | // Size of stack less any space reserved for stack overflow |
jeffhao | d752132 | 2012-11-21 15:38:24 -0800 | [diff] [blame] | 715 | size_t GetStackSize() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 716 | return tlsPtr_.stack_size - (tlsPtr_.stack_end - tlsPtr_.stack_begin); |
Ian Rogers | 932746a | 2011-09-22 18:57:50 -0700 | [diff] [blame] | 717 | } |
| 718 | |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 719 | uint8_t* GetStackEndForInterpreter(bool implicit_overflow_check) const { |
Nicolas Geoffray | 535a3fb | 2014-07-22 15:17:38 +0100 | [diff] [blame] | 720 | if (implicit_overflow_check) { |
| 721 | // The interpreter needs the extra overflow bytes that stack_end does |
| 722 | // not include. |
| 723 | return tlsPtr_.stack_end + GetStackOverflowReservedBytes(kRuntimeISA); |
| 724 | } else { |
| 725 | return tlsPtr_.stack_end; |
| 726 | } |
| 727 | } |
| 728 | |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 729 | uint8_t* GetStackEnd() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 730 | return tlsPtr_.stack_end; |
jeffhao | d752132 | 2012-11-21 15:38:24 -0800 | [diff] [blame] | 731 | } |
| 732 | |
Ian Rogers | 932746a | 2011-09-22 18:57:50 -0700 | [diff] [blame] | 733 | // Set the stack end to that to be used during a stack overflow |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 734 | void SetStackEndForStackOverflow() REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | 932746a | 2011-09-22 18:57:50 -0700 | [diff] [blame] | 735 | |
| 736 | // Set the stack end to that to be used during regular execution |
Dave Allison | b090a18 | 2014-08-14 17:02:48 +0000 | [diff] [blame] | 737 | void ResetDefaultStackEnd() { |
Ian Rogers | 932746a | 2011-09-22 18:57:50 -0700 | [diff] [blame] | 738 | // Our stacks grow down, so we want stack_end_ to be near there, but reserving enough room |
| 739 | // to throw a StackOverflowError. |
Dave Allison | b090a18 | 2014-08-14 17:02:48 +0000 | [diff] [blame] | 740 | tlsPtr_.stack_end = tlsPtr_.stack_begin + GetStackOverflowReservedBytes(kRuntimeISA); |
Ian Rogers | 932746a | 2011-09-22 18:57:50 -0700 | [diff] [blame] | 741 | } |
| 742 | |
Ian Rogers | 120f1c7 | 2012-09-28 17:17:10 -0700 | [diff] [blame] | 743 | bool IsHandlingStackOverflow() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 744 | return tlsPtr_.stack_end == tlsPtr_.stack_begin; |
Ian Rogers | 120f1c7 | 2012-09-28 17:17:10 -0700 | [diff] [blame] | 745 | } |
| 746 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 747 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 748 | static ThreadOffset<pointer_size> StackEndOffset() { |
| 749 | return ThreadOffsetFromTlsPtr<pointer_size>( |
| 750 | OFFSETOF_MEMBER(tls_ptr_sized_values, stack_end)); |
Elliott Hughes | be759c6 | 2011-09-08 19:38:21 -0700 | [diff] [blame] | 751 | } |
| 752 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 753 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 754 | static ThreadOffset<pointer_size> JniEnvOffset() { |
| 755 | return ThreadOffsetFromTlsPtr<pointer_size>( |
| 756 | OFFSETOF_MEMBER(tls_ptr_sized_values, jni_env)); |
Elliott Hughes | be759c6 | 2011-09-08 19:38:21 -0700 | [diff] [blame] | 757 | } |
| 758 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 759 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 760 | static ThreadOffset<pointer_size> TopOfManagedStackOffset() { |
| 761 | return ThreadOffsetFromTlsPtr<pointer_size>( |
| 762 | OFFSETOF_MEMBER(tls_ptr_sized_values, managed_stack) + |
| 763 | ManagedStack::TopQuickFrameOffset()); |
Elliott Hughes | be759c6 | 2011-09-08 19:38:21 -0700 | [diff] [blame] | 764 | } |
| 765 | |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 766 | const ManagedStack* GetManagedStack() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 767 | return &tlsPtr_.managed_stack; |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 768 | } |
| 769 | |
| 770 | // Linked list recording fragments of managed stack. |
| 771 | void PushManagedStackFragment(ManagedStack* fragment) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 772 | tlsPtr_.managed_stack.PushManagedStackFragment(fragment); |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 773 | } |
| 774 | void PopManagedStackFragment(const ManagedStack& fragment) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 775 | tlsPtr_.managed_stack.PopManagedStackFragment(fragment); |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 776 | } |
| 777 | |
| 778 | ShadowFrame* PushShadowFrame(ShadowFrame* new_top_frame) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 779 | return tlsPtr_.managed_stack.PushShadowFrame(new_top_frame); |
TDYa127 | de479be | 2012-05-31 08:03:26 -0700 | [diff] [blame] | 780 | } |
| 781 | |
| 782 | ShadowFrame* PopShadowFrame() { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 783 | return tlsPtr_.managed_stack.PopShadowFrame(); |
TDYa127 | de479be | 2012-05-31 08:03:26 -0700 | [diff] [blame] | 784 | } |
Logan Chien | f7ad17e | 2012-03-15 03:10:03 +0800 | [diff] [blame] | 785 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 786 | template<PointerSize pointer_size> |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 787 | static ThreadOffset<pointer_size> TopShadowFrameOffset() { |
| 788 | return ThreadOffsetFromTlsPtr<pointer_size>( |
| 789 | OFFSETOF_MEMBER(tls_ptr_sized_values, managed_stack) + |
| 790 | ManagedStack::TopShadowFrameOffset()); |
TDYa127 | d668a06 | 2012-04-13 12:36:57 -0700 | [diff] [blame] | 791 | } |
| 792 | |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 793 | // Is the given obj in this thread's stack indirect reference table? |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 794 | bool HandleScopeContains(jobject obj) const; |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 795 | |
Mathieu Chartier | bb87e0f | 2015-04-03 11:21:55 -0700 | [diff] [blame] | 796 | void HandleScopeVisitRoots(RootVisitor* visitor, uint32_t thread_id) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 797 | REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | 0399dde | 2012-06-06 17:09:28 -0700 | [diff] [blame] | 798 | |
Mathieu Chartier | e8a3c57 | 2016-10-11 16:52:17 -0700 | [diff] [blame] | 799 | BaseHandleScope* GetTopHandleScope() { |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 800 | return tlsPtr_.top_handle_scope; |
Ian Rogers | 1f53934 | 2012-10-03 21:09:42 -0700 | [diff] [blame] | 801 | } |
| 802 | |
Mathieu Chartier | e8a3c57 | 2016-10-11 16:52:17 -0700 | [diff] [blame] | 803 | void PushHandleScope(BaseHandleScope* handle_scope) { |
Ian Rogers | 59c0706 | 2014-10-10 13:03:39 -0700 | [diff] [blame] | 804 | DCHECK_EQ(handle_scope->GetLink(), tlsPtr_.top_handle_scope); |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 805 | tlsPtr_.top_handle_scope = handle_scope; |
| 806 | } |
| 807 | |
Mathieu Chartier | e8a3c57 | 2016-10-11 16:52:17 -0700 | [diff] [blame] | 808 | BaseHandleScope* PopHandleScope() { |
| 809 | BaseHandleScope* handle_scope = tlsPtr_.top_handle_scope; |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 810 | DCHECK(handle_scope != nullptr); |
| 811 | tlsPtr_.top_handle_scope = tlsPtr_.top_handle_scope->GetLink(); |
| 812 | return handle_scope; |
Ian Rogers | 1f53934 | 2012-10-03 21:09:42 -0700 | [diff] [blame] | 813 | } |
Brian Carlstrom | 40381fb | 2011-10-19 14:13:40 -0700 | [diff] [blame] | 814 | |
Andreas Gampe | 542451c | 2016-07-26 09:02:02 -0700 | [diff] [blame] | 815 | template<PointerSize pointer_size> |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 816 | static ThreadOffset<pointer_size> TopHandleScopeOffset() { |
| 817 | return ThreadOffsetFromTlsPtr<pointer_size>(OFFSETOF_MEMBER(tls_ptr_sized_values, |
| 818 | top_handle_scope)); |
Elliott Hughes | be759c6 | 2011-09-08 19:38:21 -0700 | [diff] [blame] | 819 | } |
| 820 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 821 | DebugInvokeReq* GetInvokeReq() const { |
| 822 | return tlsPtr_.debug_invoke_req; |
Elliott Hughes | 475fc23 | 2011-10-25 15:00:35 -0700 | [diff] [blame] | 823 | } |
| 824 | |
Sebastien Hertz | 61b7f1b | 2013-11-15 15:59:30 +0100 | [diff] [blame] | 825 | SingleStepControl* GetSingleStepControl() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 826 | return tlsPtr_.single_step_control; |
Sebastien Hertz | 61b7f1b | 2013-11-15 15:59:30 +0100 | [diff] [blame] | 827 | } |
| 828 | |
Sebastien Hertz | 1558b57 | 2015-02-25 15:05:59 +0100 | [diff] [blame] | 829 | // Indicates whether this thread is ready to invoke a method for debugging. This |
| 830 | // is only true if the thread has been suspended by a debug event. |
| 831 | bool IsReadyForDebugInvoke() const { |
| 832 | return tls32_.ready_for_debug_invoke; |
| 833 | } |
| 834 | |
| 835 | void SetReadyForDebugInvoke(bool ready) { |
| 836 | tls32_.ready_for_debug_invoke = ready; |
| 837 | } |
| 838 | |
Sebastien Hertz | 9d6bf69 | 2015-04-10 12:12:33 +0200 | [diff] [blame] | 839 | bool IsDebugMethodEntry() const { |
| 840 | return tls32_.debug_method_entry_; |
| 841 | } |
| 842 | |
| 843 | void SetDebugMethodEntry() { |
| 844 | tls32_.debug_method_entry_ = true; |
| 845 | } |
| 846 | |
| 847 | void ClearDebugMethodEntry() { |
| 848 | tls32_.debug_method_entry_ = false; |
| 849 | } |
| 850 | |
Hiroshi Yamauchi | 0037082 | 2015-08-18 14:47:25 -0700 | [diff] [blame] | 851 | bool GetIsGcMarking() const { |
| 852 | CHECK(kUseReadBarrier); |
| 853 | return tls32_.is_gc_marking; |
| 854 | } |
| 855 | |
Mathieu Chartier | fe814e8 | 2016-11-09 14:32:49 -0800 | [diff] [blame] | 856 | void SetIsGcMarkingAndUpdateEntrypoints(bool is_marking); |
Hiroshi Yamauchi | 0037082 | 2015-08-18 14:47:25 -0700 | [diff] [blame] | 857 | |
Hiroshi Yamauchi | 0b71357 | 2015-06-16 18:29:23 -0700 | [diff] [blame] | 858 | bool GetWeakRefAccessEnabled() const { |
| 859 | CHECK(kUseReadBarrier); |
| 860 | return tls32_.weak_ref_access_enabled; |
| 861 | } |
| 862 | |
| 863 | void SetWeakRefAccessEnabled(bool enabled) { |
| 864 | CHECK(kUseReadBarrier); |
| 865 | tls32_.weak_ref_access_enabled = enabled; |
| 866 | } |
| 867 | |
Hiroshi Yamauchi | 20a0be0 | 2016-02-19 15:44:06 -0800 | [diff] [blame] | 868 | uint32_t GetDisableThreadFlipCount() const { |
| 869 | CHECK(kUseReadBarrier); |
| 870 | return tls32_.disable_thread_flip_count; |
| 871 | } |
| 872 | |
| 873 | void IncrementDisableThreadFlipCount() { |
| 874 | CHECK(kUseReadBarrier); |
| 875 | ++tls32_.disable_thread_flip_count; |
| 876 | } |
| 877 | |
| 878 | void DecrementDisableThreadFlipCount() { |
| 879 | CHECK(kUseReadBarrier); |
| 880 | DCHECK_GT(tls32_.disable_thread_flip_count, 0U); |
| 881 | --tls32_.disable_thread_flip_count; |
| 882 | } |
| 883 | |
Calin Juravle | ccd5695 | 2016-12-15 17:57:38 +0000 | [diff] [blame] | 884 | // Returns true if the thread is allowed to call into java. |
| 885 | bool CanCallIntoJava() const { |
| 886 | return can_call_into_java_; |
| 887 | } |
| 888 | |
| 889 | void SetCanCallIntoJava(bool can_call_into_java) { |
| 890 | can_call_into_java_ = can_call_into_java; |
| 891 | } |
| 892 | |
Sebastien Hertz | 597c4f0 | 2015-01-26 17:37:14 +0100 | [diff] [blame] | 893 | // Activates single step control for debugging. The thread takes the |
| 894 | // ownership of the given SingleStepControl*. It is deleted by a call |
| 895 | // to DeactivateSingleStepControl or upon thread destruction. |
| 896 | void ActivateSingleStepControl(SingleStepControl* ssc); |
| 897 | |
| 898 | // Deactivates single step control for debugging. |
| 899 | void DeactivateSingleStepControl(); |
| 900 | |
Sebastien Hertz | 1558b57 | 2015-02-25 15:05:59 +0100 | [diff] [blame] | 901 | // Sets debug invoke request for debugging. When the thread is resumed, |
Sebastien Hertz | cbc5064 | 2015-06-01 17:33:12 +0200 | [diff] [blame] | 902 | // it executes the method described by this request then sends the reply |
| 903 | // before suspending itself. The thread takes the ownership of the given |
| 904 | // DebugInvokeReq*. It is deleted by a call to ClearDebugInvokeReq. |
Sebastien Hertz | 1558b57 | 2015-02-25 15:05:59 +0100 | [diff] [blame] | 905 | void SetDebugInvokeReq(DebugInvokeReq* req); |
| 906 | |
| 907 | // Clears debug invoke request for debugging. When the thread completes |
Sebastien Hertz | cbc5064 | 2015-06-01 17:33:12 +0200 | [diff] [blame] | 908 | // method invocation, it deletes its debug invoke request and suspends |
| 909 | // itself. |
Sebastien Hertz | 1558b57 | 2015-02-25 15:05:59 +0100 | [diff] [blame] | 910 | void ClearDebugInvokeReq(); |
Sebastien Hertz | 597c4f0 | 2015-01-26 17:37:14 +0100 | [diff] [blame] | 911 | |
Sebastien Hertz | fd3077e | 2014-04-23 10:32:43 +0200 | [diff] [blame] | 912 | // Returns the fake exception used to activate deoptimization. |
| 913 | static mirror::Throwable* GetDeoptimizationException() { |
Mathieu Chartier | 0795f23 | 2016-09-27 18:43:30 -0700 | [diff] [blame] | 914 | // Note that the mirror::Throwable must be aligned to kObjectAlignment or else it cannot be |
| 915 | // represented by ObjPtr. |
| 916 | return reinterpret_cast<mirror::Throwable*>(0x100); |
Sebastien Hertz | fd3077e | 2014-04-23 10:32:43 +0200 | [diff] [blame] | 917 | } |
| 918 | |
Mingyao Yang | 1f2d3ba | 2015-05-18 12:12:50 -0700 | [diff] [blame] | 919 | // Currently deoptimization invokes verifier which can trigger class loading |
| 920 | // and execute Java code, so there might be nested deoptimizations happening. |
| 921 | // We need to save the ongoing deoptimization shadow frames and return |
| 922 | // values on stacks. |
Nicolas Geoffray | 73be1e8 | 2015-09-17 15:22:56 +0100 | [diff] [blame] | 923 | // 'from_code' denotes whether the deoptimization was explicitly made from |
| 924 | // compiled code. |
| 925 | void PushDeoptimizationContext(const JValue& return_value, |
| 926 | bool is_reference, |
| 927 | bool from_code, |
Mathieu Chartier | f5769e1 | 2017-01-10 15:54:41 -0800 | [diff] [blame] | 928 | ObjPtr<mirror::Throwable> exception) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 929 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mathieu Chartier | f5769e1 | 2017-01-10 15:54:41 -0800 | [diff] [blame] | 930 | void PopDeoptimizationContext(JValue* result, |
| 931 | ObjPtr<mirror::Throwable>* exception, |
| 932 | bool* from_code) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 933 | REQUIRES_SHARED(Locks::mutator_lock_); |
Sebastien Hertz | 0747466 | 2015-08-25 15:12:33 +0000 | [diff] [blame] | 934 | void AssertHasDeoptimizationContext() |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 935 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mingyao Yang | 1f2d3ba | 2015-05-18 12:12:50 -0700 | [diff] [blame] | 936 | void PushStackedShadowFrame(ShadowFrame* sf, StackedShadowFrameType type); |
Andreas Gampe | 639bdd1 | 2015-06-03 11:22:45 -0700 | [diff] [blame] | 937 | ShadowFrame* PopStackedShadowFrame(StackedShadowFrameType type, bool must_be_present = true); |
Andreas Gampe | 2a0d4ec | 2014-06-02 22:05:22 -0700 | [diff] [blame] | 938 | |
Mingyao Yang | 99170c6 | 2015-07-06 11:10:37 -0700 | [diff] [blame] | 939 | // For debugger, find the shadow frame that corresponds to a frame id. |
| 940 | // Or return null if there is none. |
| 941 | ShadowFrame* FindDebuggerShadowFrame(size_t frame_id) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 942 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mingyao Yang | 99170c6 | 2015-07-06 11:10:37 -0700 | [diff] [blame] | 943 | // For debugger, find the bool array that keeps track of the updated vreg set |
| 944 | // for a frame id. |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 945 | bool* GetUpdatedVRegFlags(size_t frame_id) REQUIRES_SHARED(Locks::mutator_lock_); |
Mingyao Yang | 99170c6 | 2015-07-06 11:10:37 -0700 | [diff] [blame] | 946 | // For debugger, find the shadow frame that corresponds to a frame id. If |
| 947 | // one doesn't exist yet, create one and track it in frame_id_to_shadow_frame. |
| 948 | ShadowFrame* FindOrCreateDebuggerShadowFrame(size_t frame_id, |
| 949 | uint32_t num_vregs, |
| 950 | ArtMethod* method, |
| 951 | uint32_t dex_pc) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 952 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mingyao Yang | 99170c6 | 2015-07-06 11:10:37 -0700 | [diff] [blame] | 953 | |
| 954 | // Delete the entry that maps from frame_id to shadow_frame. |
| 955 | void RemoveDebuggerShadowFrameMapping(size_t frame_id) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 956 | REQUIRES_SHARED(Locks::mutator_lock_); |
Mingyao Yang | 99170c6 | 2015-07-06 11:10:37 -0700 | [diff] [blame] | 957 | |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 958 | std::deque<instrumentation::InstrumentationStackFrame>* GetInstrumentationStack() { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 959 | return tlsPtr_.instrumentation_stack; |
jeffhao | e343b76 | 2011-12-05 16:36:44 -0800 | [diff] [blame] | 960 | } |
| 961 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 962 | std::vector<ArtMethod*>* GetStackTraceSample() const { |
Andreas Gampe | 2c19f5b | 2016-11-28 08:10:18 -0800 | [diff] [blame] | 963 | DCHECK(!IsAotCompiler()); |
Nicolas Geoffray | 340dafa | 2016-11-18 16:03:10 +0000 | [diff] [blame] | 964 | return tlsPtr_.deps_or_stack_trace_sample.stack_trace_sample; |
Jeff Hao | 5ce4b17 | 2013-08-16 16:27:18 -0700 | [diff] [blame] | 965 | } |
| 966 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame] | 967 | void SetStackTraceSample(std::vector<ArtMethod*>* sample) { |
Andreas Gampe | 2c19f5b | 2016-11-28 08:10:18 -0800 | [diff] [blame] | 968 | DCHECK(!IsAotCompiler()); |
Nicolas Geoffray | 340dafa | 2016-11-18 16:03:10 +0000 | [diff] [blame] | 969 | tlsPtr_.deps_or_stack_trace_sample.stack_trace_sample = sample; |
| 970 | } |
| 971 | |
| 972 | verifier::VerifierDeps* GetVerifierDeps() const { |
Andreas Gampe | 2c19f5b | 2016-11-28 08:10:18 -0800 | [diff] [blame] | 973 | DCHECK(IsAotCompiler()); |
Nicolas Geoffray | 340dafa | 2016-11-18 16:03:10 +0000 | [diff] [blame] | 974 | return tlsPtr_.deps_or_stack_trace_sample.verifier_deps; |
| 975 | } |
| 976 | |
| 977 | // It is the responsability of the caller to make sure the verifier_deps |
| 978 | // entry in the thread is cleared before destruction of the actual VerifierDeps |
| 979 | // object, or the thread. |
| 980 | void SetVerifierDeps(verifier::VerifierDeps* verifier_deps) { |
Andreas Gampe | 2c19f5b | 2016-11-28 08:10:18 -0800 | [diff] [blame] | 981 | DCHECK(IsAotCompiler()); |
Nicolas Geoffray | e424c93 | 2016-11-23 12:52:01 +0000 | [diff] [blame] | 982 | DCHECK(verifier_deps == nullptr || tlsPtr_.deps_or_stack_trace_sample.verifier_deps == nullptr); |
Nicolas Geoffray | 340dafa | 2016-11-18 16:03:10 +0000 | [diff] [blame] | 983 | tlsPtr_.deps_or_stack_trace_sample.verifier_deps = verifier_deps; |
Jeff Hao | 5ce4b17 | 2013-08-16 16:27:18 -0700 | [diff] [blame] | 984 | } |
| 985 | |
| 986 | uint64_t GetTraceClockBase() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 987 | return tls64_.trace_clock_base; |
Jeff Hao | 5ce4b17 | 2013-08-16 16:27:18 -0700 | [diff] [blame] | 988 | } |
| 989 | |
| 990 | void SetTraceClockBase(uint64_t clock_base) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 991 | tls64_.trace_clock_base = clock_base; |
Jeff Hao | 5ce4b17 | 2013-08-16 16:27:18 -0700 | [diff] [blame] | 992 | } |
| 993 | |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 994 | BaseMutex* GetHeldMutex(LockLevel level) const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 995 | return tlsPtr_.held_mutexes[level]; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 996 | } |
| 997 | |
Ian Rogers | 81d425b | 2012-09-27 16:03:43 -0700 | [diff] [blame] | 998 | void SetHeldMutex(LockLevel level, BaseMutex* mutex) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 999 | tlsPtr_.held_mutexes[level] = mutex; |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1000 | } |
Elliott Hughes | ffb465f | 2012-03-01 18:46:05 -0800 | [diff] [blame] | 1001 | |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 1002 | void ClearSuspendBarrier(AtomicInteger* target) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 1003 | REQUIRES(Locks::thread_suspend_count_lock_); |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 1004 | |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1005 | bool ReadFlag(ThreadFlag flag) const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1006 | return (tls32_.state_and_flags.as_struct.flags & flag) != 0; |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1007 | } |
| 1008 | |
Jeff Hao | 9cec247 | 2013-05-14 18:17:06 -0700 | [diff] [blame] | 1009 | bool TestAllFlags() const { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1010 | return (tls32_.state_and_flags.as_struct.flags != 0); |
Jeff Hao | 9cec247 | 2013-05-14 18:17:06 -0700 | [diff] [blame] | 1011 | } |
| 1012 | |
Ian Rogers | 8c1b5f7 | 2014-07-09 22:02:36 -0700 | [diff] [blame] | 1013 | void AtomicSetFlag(ThreadFlag flag) { |
| 1014 | tls32_.state_and_flags.as_atomic_int.FetchAndOrSequentiallyConsistent(flag); |
| 1015 | } |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1016 | |
Ian Rogers | 8c1b5f7 | 2014-07-09 22:02:36 -0700 | [diff] [blame] | 1017 | void AtomicClearFlag(ThreadFlag flag) { |
| 1018 | tls32_.state_and_flags.as_atomic_int.FetchAndAndSequentiallyConsistent(-1 ^ flag); |
| 1019 | } |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1020 | |
Mathieu Chartier | 5ace201 | 2016-11-30 10:15:41 -0800 | [diff] [blame] | 1021 | void ResetQuickAllocEntryPointsForThread(bool is_marking); |
Hiroshi Yamauchi | 3b4c189 | 2013-09-12 21:33:12 -0700 | [diff] [blame] | 1022 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1023 | // Returns the remaining space in the TLAB. |
| 1024 | size_t TlabSize() const; |
| 1025 | // Doesn't check that there is room. |
| 1026 | mirror::Object* AllocTlab(size_t bytes); |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 1027 | void SetTlab(uint8_t* start, uint8_t* end); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1028 | bool HasTlab() const; |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 1029 | uint8_t* GetTlabStart() { |
| 1030 | return tlsPtr_.thread_local_start; |
| 1031 | } |
| 1032 | uint8_t* GetTlabPos() { |
| 1033 | return tlsPtr_.thread_local_pos; |
| 1034 | } |
Elliott Hughes | 5d96a71 | 2012-06-28 12:24:27 -0700 | [diff] [blame] | 1035 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1036 | // Remove the suspend trigger for this thread by making the suspend_trigger_ TLS value |
| 1037 | // equal to a valid pointer. |
| 1038 | // TODO: does this need to atomic? I don't think so. |
| 1039 | void RemoveSuspendTrigger() { |
| 1040 | tlsPtr_.suspend_trigger = reinterpret_cast<uintptr_t*>(&tlsPtr_.suspend_trigger); |
| 1041 | } |
| 1042 | |
| 1043 | // Trigger a suspend check by making the suspend_trigger_ TLS value an invalid pointer. |
| 1044 | // The next time a suspend check is done, it will load from the value at this address |
| 1045 | // and trigger a SIGSEGV. |
| 1046 | void TriggerSuspend() { |
| 1047 | tlsPtr_.suspend_trigger = nullptr; |
| 1048 | } |
| 1049 | |
| 1050 | |
| 1051 | // Push an object onto the allocation stack. |
Mathieu Chartier | cb535da | 2015-01-23 13:50:03 -0800 | [diff] [blame] | 1052 | bool PushOnThreadLocalAllocationStack(mirror::Object* obj) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 1053 | REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1054 | |
| 1055 | // Set the thread local allocation pointers to the given pointers. |
Mathieu Chartier | cb535da | 2015-01-23 13:50:03 -0800 | [diff] [blame] | 1056 | void SetThreadLocalAllocationStack(StackReference<mirror::Object>* start, |
| 1057 | StackReference<mirror::Object>* end); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1058 | |
| 1059 | // Resets the thread local allocation pointers. |
| 1060 | void RevokeThreadLocalAllocationStack(); |
| 1061 | |
| 1062 | size_t GetThreadLocalBytesAllocated() const { |
Mathieu Chartier | 14cc9be | 2014-07-11 10:26:37 -0700 | [diff] [blame] | 1063 | return tlsPtr_.thread_local_end - tlsPtr_.thread_local_start; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1064 | } |
| 1065 | |
| 1066 | size_t GetThreadLocalObjectsAllocated() const { |
| 1067 | return tlsPtr_.thread_local_objects; |
| 1068 | } |
| 1069 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1070 | void* GetRosAllocRun(size_t index) const { |
| 1071 | return tlsPtr_.rosalloc_runs[index]; |
| 1072 | } |
| 1073 | |
| 1074 | void SetRosAllocRun(size_t index, void* run) { |
| 1075 | tlsPtr_.rosalloc_runs[index] = run; |
| 1076 | } |
| 1077 | |
Andreas Gampe | 2c2d2a0 | 2016-03-17 21:27:19 -0700 | [diff] [blame] | 1078 | bool ProtectStack(bool fatal_on_error = true); |
Dave Allison | 648d711 | 2014-07-25 16:15:27 -0700 | [diff] [blame] | 1079 | bool UnprotectStack(); |
| 1080 | |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 1081 | void SetMterpDefaultIBase(void* ibase) { |
| 1082 | tlsPtr_.mterp_default_ibase = ibase; |
| 1083 | } |
| 1084 | |
| 1085 | void SetMterpCurrentIBase(void* ibase) { |
| 1086 | tlsPtr_.mterp_current_ibase = ibase; |
| 1087 | } |
| 1088 | |
| 1089 | void SetMterpAltIBase(void* ibase) { |
| 1090 | tlsPtr_.mterp_alt_ibase = ibase; |
| 1091 | } |
| 1092 | |
| 1093 | const void* GetMterpDefaultIBase() const { |
| 1094 | return tlsPtr_.mterp_default_ibase; |
| 1095 | } |
| 1096 | |
| 1097 | const void* GetMterpCurrentIBase() const { |
| 1098 | return tlsPtr_.mterp_current_ibase; |
| 1099 | } |
| 1100 | |
| 1101 | const void* GetMterpAltIBase() const { |
| 1102 | return tlsPtr_.mterp_alt_ibase; |
| 1103 | } |
| 1104 | |
Nicolas Geoffray | e8e1127 | 2016-06-28 18:08:46 +0100 | [diff] [blame] | 1105 | // Notify that a signal is being handled. This is to protect us from doing recursive |
| 1106 | // NPE handling after a SIGSEGV. |
Dave Allison | 648d711 | 2014-07-25 16:15:27 -0700 | [diff] [blame] | 1107 | void NoteSignalBeingHandled() { |
| 1108 | if (tls32_.handling_signal_) { |
| 1109 | LOG(FATAL) << "Detected signal while processing a signal"; |
| 1110 | } |
| 1111 | tls32_.handling_signal_ = true; |
| 1112 | } |
| 1113 | |
| 1114 | void NoteSignalHandlerDone() { |
| 1115 | tls32_.handling_signal_ = false; |
| 1116 | } |
| 1117 | |
Dave Allison | 8ce6b90 | 2014-08-26 11:07:58 -0700 | [diff] [blame] | 1118 | jmp_buf* GetNestedSignalState() { |
| 1119 | return tlsPtr_.nested_signal_state; |
| 1120 | } |
| 1121 | |
Hiroshi Yamauchi | ee23582 | 2016-08-19 17:03:27 -0700 | [diff] [blame] | 1122 | bool IsTransitioningToRunnable() const { |
| 1123 | return tls32_.is_transitioning_to_runnable; |
| 1124 | } |
| 1125 | |
| 1126 | void SetIsTransitioningToRunnable(bool value) { |
| 1127 | tls32_.is_transitioning_to_runnable = value; |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 1128 | } |
| 1129 | |
Mathieu Chartier | d0ad2ee | 2015-03-31 14:59:59 -0700 | [diff] [blame] | 1130 | void PushVerifier(verifier::MethodVerifier* verifier); |
| 1131 | void PopVerifier(verifier::MethodVerifier* verifier); |
Mathieu Chartier | 12d625f | 2015-03-13 11:33:37 -0700 | [diff] [blame] | 1132 | |
Jeff Hao | 848f70a | 2014-01-15 13:49:50 -0800 | [diff] [blame] | 1133 | void InitStringEntryPoints(); |
| 1134 | |
Mathieu Chartier | dfe02f6 | 2016-02-01 20:15:11 -0800 | [diff] [blame] | 1135 | void ModifyDebugDisallowReadBarrier(int8_t delta) { |
| 1136 | debug_disallow_read_barrier_ += delta; |
| 1137 | } |
| 1138 | |
| 1139 | uint8_t GetDebugDisallowReadBarrierCount() const { |
| 1140 | return debug_disallow_read_barrier_; |
| 1141 | } |
| 1142 | |
Andreas Gampe | f26bf2d | 2017-01-13 16:47:14 -0800 | [diff] [blame] | 1143 | const void* GetCustomTLS() const { |
| 1144 | return custom_tls_; |
| 1145 | } |
| 1146 | |
| 1147 | void SetCustomTLS(const void* data) { |
| 1148 | custom_tls_ = data; |
| 1149 | } |
| 1150 | |
Calin Juravle | 97cbc92 | 2016-04-15 16:16:35 +0100 | [diff] [blame] | 1151 | // Returns true if the current thread is the jit sensitive thread. |
| 1152 | bool IsJitSensitiveThread() const { |
| 1153 | return this == jit_sensitive_thread_; |
| 1154 | } |
| 1155 | |
| 1156 | // Returns true if StrictMode events are traced for the current thread. |
Calin Juravle | b2771b4 | 2016-04-07 17:09:25 +0100 | [diff] [blame] | 1157 | static bool IsSensitiveThread() { |
| 1158 | if (is_sensitive_thread_hook_ != nullptr) { |
| 1159 | return (*is_sensitive_thread_hook_)(); |
| 1160 | } |
| 1161 | return false; |
| 1162 | } |
| 1163 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1164 | private: |
Ian Rogers | 52673ff | 2012-06-27 23:25:34 -0700 | [diff] [blame] | 1165 | explicit Thread(bool daemon); |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 1166 | ~Thread() REQUIRES(!Locks::mutator_lock_, !Locks::thread_suspend_count_lock_); |
Elliott Hughes | c0f0933 | 2012-03-26 13:27:06 -0700 | [diff] [blame] | 1167 | void Destroy(); |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 1168 | |
Ian Rogers | 365c102 | 2012-06-22 15:05:28 -0700 | [diff] [blame] | 1169 | void CreatePeer(const char* name, bool as_daemon, jobject thread_group); |
Elliott Hughes | 5fe594f | 2011-09-08 12:33:17 -0700 | [diff] [blame] | 1170 | |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 1171 | template<bool kTransactionActive> |
| 1172 | void InitPeer(ScopedObjectAccess& soa, jboolean thread_is_daemon, jobject thread_group, |
| 1173 | jobject thread_name, jint thread_priority) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 1174 | REQUIRES_SHARED(Locks::mutator_lock_); |
Sebastien Hertz | d2fe10a | 2014-01-15 10:20:56 +0100 | [diff] [blame] | 1175 | |
Ian Rogers | 62d6c77 | 2013-02-27 08:32:07 -0800 | [diff] [blame] | 1176 | // Avoid use, callers should use SetState. Used only by SignalCatcher::HandleSigQuit, ~Thread and |
Hiroshi Yamauchi | 98810e3 | 2016-05-24 14:55:40 -0700 | [diff] [blame] | 1177 | // Dbg::ManageDeoptimization. |
Ian Rogers | 474b6da | 2012-09-25 00:20:38 -0700 | [diff] [blame] | 1178 | ThreadState SetStateUnsafe(ThreadState new_state) { |
| 1179 | ThreadState old_state = GetState(); |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 1180 | if (old_state == kRunnable && new_state != kRunnable) { |
| 1181 | // Need to run pending checkpoint and suspend barriers. Run checkpoints in runnable state in |
| 1182 | // case they need to use a ScopedObjectAccess. If we are holding the mutator lock and a SOA |
| 1183 | // attempts to TransitionFromSuspendedToRunnable, it results in a deadlock. |
| 1184 | TransitionToSuspendedAndRunCheckpoints(new_state); |
| 1185 | // Since we transitioned to a suspended state, check the pass barrier requests. |
| 1186 | PassActiveSuspendBarriers(); |
| 1187 | } else { |
| 1188 | tls32_.state_and_flags.as_struct.state = new_state; |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 1189 | } |
Ian Rogers | c747cff | 2012-08-31 18:20:08 -0700 | [diff] [blame] | 1190 | return old_state; |
| 1191 | } |
Ian Rogers | c747cff | 2012-08-31 18:20:08 -0700 | [diff] [blame] | 1192 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 1193 | void VerifyStackImpl() REQUIRES_SHARED(Locks::mutator_lock_); |
Ian Rogers | 04d7aa9 | 2013-03-16 14:29:17 -0700 | [diff] [blame] | 1194 | |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 1195 | void DumpState(std::ostream& os) const REQUIRES_SHARED(Locks::mutator_lock_); |
Nicolas Geoffray | a73280d | 2016-02-15 13:05:16 +0000 | [diff] [blame] | 1196 | void DumpStack(std::ostream& os, |
| 1197 | bool dump_native_stack = true, |
| 1198 | BacktraceMap* backtrace_map = nullptr) const |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 1199 | REQUIRES(!Locks::thread_suspend_count_lock_) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 1200 | REQUIRES_SHARED(Locks::mutator_lock_); |
Elliott Hughes | d92bec4 | 2011-09-02 17:04:36 -0700 | [diff] [blame] | 1201 | |
Elliott Hughes | accd83d | 2011-10-17 14:25:58 -0700 | [diff] [blame] | 1202 | // Out-of-line conveniences for debugging in gdb. |
Brian Carlstrom | 7934ac2 | 2013-07-26 10:54:15 -0700 | [diff] [blame] | 1203 | static Thread* CurrentFromGdb(); // Like Thread::Current. |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 1204 | // Like Thread::Dump(std::cerr). |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 1205 | void DumpFromGdb() const REQUIRES_SHARED(Locks::mutator_lock_); |
Elliott Hughes | accd83d | 2011-10-17 14:25:58 -0700 | [diff] [blame] | 1206 | |
Elliott Hughes | 93e74e8 | 2011-09-13 11:07:03 -0700 | [diff] [blame] | 1207 | static void* CreateCallback(void* arg); |
| 1208 | |
Ian Rogers | cfaa455 | 2012-11-26 21:00:08 -0800 | [diff] [blame] | 1209 | void HandleUncaughtExceptions(ScopedObjectAccess& soa) |
Andreas Gampe | bdf7f1c | 2016-08-30 16:38:47 -0700 | [diff] [blame] | 1210 | REQUIRES_SHARED(Locks::mutator_lock_); |
| 1211 | void RemoveFromThreadGroup(ScopedObjectAccess& soa) REQUIRES_SHARED(Locks::mutator_lock_); |
Elliott Hughes | accd83d | 2011-10-17 14:25:58 -0700 | [diff] [blame] | 1212 | |
Andreas Gampe | 449357d | 2015-06-01 22:29:51 -0700 | [diff] [blame] | 1213 | // Initialize a thread. |
| 1214 | // |
| 1215 | // The third parameter is not mandatory. If given, the thread will use this JNIEnvExt. In case |
| 1216 | // Init succeeds, this means the thread takes ownership of it. If Init fails, it is the caller's |
| 1217 | // responsibility to destroy the given JNIEnvExt. If the parameter is null, Init will try to |
| 1218 | // create a JNIEnvExt on its own (and potentially fail at that stage, indicated by a return value |
| 1219 | // of false). |
| 1220 | bool Init(ThreadList*, JavaVMExt*, JNIEnvExt* jni_env_ext = nullptr) |
Mathieu Chartier | 9044347 | 2015-07-16 20:32:27 -0700 | [diff] [blame] | 1221 | REQUIRES(Locks::runtime_shutdown_lock_); |
Ian Rogers | 5d76c43 | 2011-10-31 21:42:49 -0700 | [diff] [blame] | 1222 | void InitCardTable(); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 1223 | void InitCpu(); |
Alexei Zavjalov | 1efa0a9 | 2014-02-04 02:08:31 +0700 | [diff] [blame] | 1224 | void CleanupCpu(); |
Ian Rogers | 848871b | 2013-08-05 10:56:33 -0700 | [diff] [blame] | 1225 | void InitTlsEntryPoints(); |
Brian Carlstrom | caabb1b | 2011-10-11 18:09:13 -0700 | [diff] [blame] | 1226 | void InitTid(); |
Brian Carlstrom | caabb1b | 2011-10-11 18:09:13 -0700 | [diff] [blame] | 1227 | void InitPthreadKeySelf(); |
Ian Rogers | f4d4da1 | 2014-11-11 16:10:33 -0800 | [diff] [blame] | 1228 | bool InitStackHwm(); |
Elliott Hughes | be759c6 | 2011-09-08 19:38:21 -0700 | [diff] [blame] | 1229 | |
Elliott Hughes | d6a23bd | 2013-07-16 14:19:52 -0700 | [diff] [blame] | 1230 | void SetUpAlternateSignalStack(); |
| 1231 | void TearDownAlternateSignalStack(); |
| 1232 | |
Mathieu Chartier | 8ac9c91 | 2015-10-01 15:58:41 -0700 | [diff] [blame] | 1233 | ALWAYS_INLINE void TransitionToSuspendedAndRunCheckpoints(ThreadState new_state) |
| 1234 | REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_); |
| 1235 | |
| 1236 | ALWAYS_INLINE void PassActiveSuspendBarriers() |
| 1237 | REQUIRES(!Locks::thread_suspend_count_lock_, !Roles::uninterruptible_); |
| 1238 | |
Calin Juravle | 97cbc92 | 2016-04-15 16:16:35 +0100 | [diff] [blame] | 1239 | // Registers the current thread as the jit sensitive thread. Should be called just once. |
| 1240 | static void SetJitSensitiveThread() { |
| 1241 | if (jit_sensitive_thread_ == nullptr) { |
| 1242 | jit_sensitive_thread_ = Thread::Current(); |
| 1243 | } else { |
| 1244 | LOG(WARNING) << "Attempt to set the sensitive thread twice. Tid:" |
| 1245 | << Thread::Current()->GetTid(); |
| 1246 | } |
| 1247 | } |
| 1248 | |
Calin Juravle | b2771b4 | 2016-04-07 17:09:25 +0100 | [diff] [blame] | 1249 | static void SetSensitiveThreadHook(bool (*is_sensitive_thread_hook)()) { |
| 1250 | is_sensitive_thread_hook_ = is_sensitive_thread_hook; |
| 1251 | } |
| 1252 | |
Hiroshi Yamauchi | 02e7f1a | 2016-10-03 15:32:01 -0700 | [diff] [blame] | 1253 | bool ModifySuspendCountInternal(Thread* self, |
| 1254 | int delta, |
| 1255 | AtomicInteger* suspend_barrier, |
| 1256 | bool for_debugger) |
| 1257 | REQUIRES(Locks::thread_suspend_count_lock_); |
| 1258 | |
Andreas Gampe | 0a85576 | 2016-10-26 13:43:14 -0700 | [diff] [blame] | 1259 | void RunCheckpointFunction(); |
Hiroshi Yamauchi | 3049324 | 2016-11-03 13:06:52 -0700 | [diff] [blame] | 1260 | void RunEmptyCheckpoint(); |
Andreas Gampe | 0a85576 | 2016-10-26 13:43:14 -0700 | [diff] [blame] | 1261 | |
| 1262 | bool PassActiveSuspendBarriers(Thread* self) |
| 1263 | REQUIRES(!Locks::thread_suspend_count_lock_); |
| 1264 | |
| 1265 | // Install the protected region for implicit stack checks. |
| 1266 | void InstallImplicitProtection(); |
| 1267 | |
Andreas Gampe | 585da95 | 2016-12-02 14:52:29 -0800 | [diff] [blame] | 1268 | template <bool kPrecise> |
| 1269 | void VisitRoots(RootVisitor* visitor) REQUIRES_SHARED(Locks::mutator_lock_); |
| 1270 | |
Andreas Gampe | 2c19f5b | 2016-11-28 08:10:18 -0800 | [diff] [blame] | 1271 | static bool IsAotCompiler(); |
| 1272 | |
Ian Rogers | 474b6da | 2012-09-25 00:20:38 -0700 | [diff] [blame] | 1273 | // 32 bits of atomically changed state and flags. Keeping as 32 bits allows and atomic CAS to |
| 1274 | // change from being Suspended to Runnable without a suspend request occurring. |
Chris Dearman | 59cde53 | 2013-12-04 18:53:49 -0800 | [diff] [blame] | 1275 | union PACKED(4) StateAndFlags { |
| 1276 | StateAndFlags() {} |
Ian Rogers | df1ce91 | 2012-11-27 17:07:11 -0800 | [diff] [blame] | 1277 | struct PACKED(4) { |
Ian Rogers | 30e173f | 2012-09-26 14:35:03 -0700 | [diff] [blame] | 1278 | // Bitfield of flag values. Must be changed atomically so that flag values aren't lost. See |
| 1279 | // ThreadFlags for bit field meanings. |
| 1280 | volatile uint16_t flags; |
| 1281 | // Holds the ThreadState. May be changed non-atomically between Suspended (ie not Runnable) |
| 1282 | // transitions. Changing to Runnable requires that the suspend_request be part of the atomic |
| 1283 | // operation. If a thread is suspended and a suspend_request is present, a thread may not |
| 1284 | // change to Runnable as a GC or other operation is in progress. |
Ian Rogers | 01ae580 | 2012-09-28 16:14:01 -0700 | [diff] [blame] | 1285 | volatile uint16_t state; |
Ian Rogers | 30e173f | 2012-09-26 14:35:03 -0700 | [diff] [blame] | 1286 | } as_struct; |
Ian Rogers | b8e087e | 2014-07-09 21:12:06 -0700 | [diff] [blame] | 1287 | AtomicInteger as_atomic_int; |
Ian Rogers | 01ae580 | 2012-09-28 16:14:01 -0700 | [diff] [blame] | 1288 | volatile int32_t as_int; |
Chris Dearman | 59cde53 | 2013-12-04 18:53:49 -0800 | [diff] [blame] | 1289 | |
| 1290 | private: |
| 1291 | // gcc does not handle struct with volatile member assignments correctly. |
| 1292 | // See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47409 |
| 1293 | DISALLOW_COPY_AND_ASSIGN(StateAndFlags); |
Ian Rogers | 474b6da | 2012-09-25 00:20:38 -0700 | [diff] [blame] | 1294 | }; |
Andreas Gampe | 575e78c | 2014-11-03 23:41:03 -0800 | [diff] [blame] | 1295 | static_assert(sizeof(StateAndFlags) == sizeof(int32_t), "Weird state_and_flags size"); |
Ian Rogers | 474b6da | 2012-09-25 00:20:38 -0700 | [diff] [blame] | 1296 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1297 | static void ThreadExitCallback(void* arg); |
Elliott Hughes | 5d96a71 | 2012-06-28 12:24:27 -0700 | [diff] [blame] | 1298 | |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 1299 | // Maximum number of suspend barriers. |
| 1300 | static constexpr uint32_t kMaxSuspendBarriers = 3; |
| 1301 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1302 | // Has Thread::Startup been called? |
| 1303 | static bool is_started_; |
Mathieu Chartier | 858f1c5 | 2012-10-17 17:45:55 -0700 | [diff] [blame] | 1304 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1305 | // TLS key used to retrieve the Thread*. |
| 1306 | static pthread_key_t pthread_key_self_; |
Ian Rogers | a32a6fd | 2012-02-06 20:18:44 -0800 | [diff] [blame] | 1307 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1308 | // Used to notify threads that they should attempt to resume, they will suspend again if |
| 1309 | // their suspend count is > 0. |
| 1310 | static ConditionVariable* resume_cond_ GUARDED_BY(Locks::thread_suspend_count_lock_); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 1311 | |
Calin Juravle | b2771b4 | 2016-04-07 17:09:25 +0100 | [diff] [blame] | 1312 | // Hook passed by framework which returns true |
| 1313 | // when StrictMode events are traced for the current thread. |
| 1314 | static bool (*is_sensitive_thread_hook_)(); |
Calin Juravle | 97cbc92 | 2016-04-15 16:16:35 +0100 | [diff] [blame] | 1315 | // Stores the jit sensitive thread (which for now is the UI thread). |
| 1316 | static Thread* jit_sensitive_thread_; |
Calin Juravle | b2771b4 | 2016-04-07 17:09:25 +0100 | [diff] [blame] | 1317 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1318 | /***********************************************************************************************/ |
| 1319 | // Thread local storage. Fields are grouped by size to enable 32 <-> 64 searching to account for |
| 1320 | // pointer size differences. To encourage shorter encoding, more frequently used values appear |
| 1321 | // first if possible. |
| 1322 | /***********************************************************************************************/ |
Elliott Hughes | 6a607ad | 2012-07-13 20:40:00 -0700 | [diff] [blame] | 1323 | |
Zuo Wang | f37a88b | 2014-07-10 04:26:41 -0700 | [diff] [blame] | 1324 | struct PACKED(4) tls_32bit_sized_values { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1325 | // We have no control over the size of 'bool', but want our boolean fields |
| 1326 | // to be 4-byte quantities. |
| 1327 | typedef uint32_t bool32_t; |
Ian Rogers | 22f454c | 2012-09-08 11:06:29 -0700 | [diff] [blame] | 1328 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1329 | explicit tls_32bit_sized_values(bool is_daemon) : |
| 1330 | suspend_count(0), debug_suspend_count(0), thin_lock_thread_id(0), tid(0), |
| 1331 | daemon(is_daemon), throwing_OutOfMemoryError(false), no_thread_suspension(0), |
Mingyao Yang | 1f2d3ba | 2015-05-18 12:12:50 -0700 | [diff] [blame] | 1332 | thread_exit_check_count(0), handling_signal_(false), |
Hiroshi Yamauchi | ee23582 | 2016-08-19 17:03:27 -0700 | [diff] [blame] | 1333 | is_transitioning_to_runnable(false), ready_for_debug_invoke(false), |
Hiroshi Yamauchi | 20a0be0 | 2016-02-19 15:44:06 -0800 | [diff] [blame] | 1334 | debug_method_entry_(false), is_gc_marking(false), weak_ref_access_enabled(true), |
| 1335 | disable_thread_flip_count(0) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1336 | } |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 1337 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1338 | union StateAndFlags state_and_flags; |
Andreas Gampe | 575e78c | 2014-11-03 23:41:03 -0800 | [diff] [blame] | 1339 | static_assert(sizeof(union StateAndFlags) == sizeof(int32_t), |
| 1340 | "Size of state_and_flags and int32 are different"); |
Dave Allison | b373e09 | 2014-02-20 16:06:36 -0800 | [diff] [blame] | 1341 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1342 | // A non-zero value is used to tell the current thread to enter a safe point |
| 1343 | // at the next poll. |
| 1344 | int suspend_count GUARDED_BY(Locks::thread_suspend_count_lock_); |
Hiroshi Yamauchi | cf58d4a | 2013-09-26 14:21:22 -0700 | [diff] [blame] | 1345 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1346 | // How much of 'suspend_count_' is by request of the debugger, used to set things right |
| 1347 | // when the debugger detaches. Must be <= suspend_count_. |
| 1348 | int debug_suspend_count GUARDED_BY(Locks::thread_suspend_count_lock_); |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 1349 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1350 | // Thin lock thread id. This is a small integer used by the thin lock implementation. |
| 1351 | // This is not to be confused with the native thread's tid, nor is it the value returned |
| 1352 | // by java.lang.Thread.getId --- this is a distinct value, used only for locking. One |
| 1353 | // important difference between this id and the ids visible to managed code is that these |
| 1354 | // ones get reused (to ensure that they fit in the number of bits available). |
| 1355 | uint32_t thin_lock_thread_id; |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 1356 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1357 | // System thread id. |
| 1358 | uint32_t tid; |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 1359 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1360 | // Is the thread a daemon? |
| 1361 | const bool32_t daemon; |
Hiroshi Yamauchi | f5b0e20 | 2014-02-11 17:02:22 -0800 | [diff] [blame] | 1362 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1363 | // A boolean telling us whether we're recursively throwing OOME. |
| 1364 | bool32_t throwing_OutOfMemoryError; |
| 1365 | |
| 1366 | // A positive value implies we're in a region where thread suspension isn't expected. |
| 1367 | uint32_t no_thread_suspension; |
| 1368 | |
| 1369 | // How many times has our pthread key's destructor been called? |
| 1370 | uint32_t thread_exit_check_count; |
Sebastien Hertz | 9f10203 | 2014-05-23 08:59:42 +0200 | [diff] [blame] | 1371 | |
Dave Allison | 648d711 | 2014-07-25 16:15:27 -0700 | [diff] [blame] | 1372 | // True if signal is being handled by this thread. |
| 1373 | bool32_t handling_signal_; |
| 1374 | |
Hiroshi Yamauchi | ee23582 | 2016-08-19 17:03:27 -0700 | [diff] [blame] | 1375 | // True if the thread is in TransitionFromSuspendedToRunnable(). This is used to distinguish the |
| 1376 | // non-runnable threads (eg. kNative, kWaiting) that are about to transition to runnable from |
| 1377 | // the rest of them. |
| 1378 | bool32_t is_transitioning_to_runnable; |
Sebastien Hertz | 1558b57 | 2015-02-25 15:05:59 +0100 | [diff] [blame] | 1379 | |
| 1380 | // True if the thread has been suspended by a debugger event. This is |
| 1381 | // used to invoke method from the debugger which is only allowed when |
| 1382 | // the thread is suspended by an event. |
| 1383 | bool32_t ready_for_debug_invoke; |
Sebastien Hertz | 9d6bf69 | 2015-04-10 12:12:33 +0200 | [diff] [blame] | 1384 | |
| 1385 | // True if the thread enters a method. This is used to detect method entry |
| 1386 | // event for the debugger. |
| 1387 | bool32_t debug_method_entry_; |
Hiroshi Yamauchi | 0b71357 | 2015-06-16 18:29:23 -0700 | [diff] [blame] | 1388 | |
Hiroshi Yamauchi | 0037082 | 2015-08-18 14:47:25 -0700 | [diff] [blame] | 1389 | // True if the GC is in the marking phase. This is used for the CC collector only. This is |
| 1390 | // thread local so that we can simplify the logic to check for the fast path of read barriers of |
| 1391 | // GC roots. |
| 1392 | bool32_t is_gc_marking; |
| 1393 | |
Hiroshi Yamauchi | 0b71357 | 2015-06-16 18:29:23 -0700 | [diff] [blame] | 1394 | // True if the thread is allowed to access a weak ref (Reference::GetReferent() and system |
| 1395 | // weaks) and to potentially mark an object alive/gray. This is used for concurrent reference |
| 1396 | // processing of the CC collector only. This is thread local so that we can enable/disable weak |
| 1397 | // ref access by using a checkpoint and avoid a race around the time weak ref access gets |
| 1398 | // disabled and concurrent reference processing begins (if weak ref access is disabled during a |
| 1399 | // pause, this is not an issue.) Other collectors use Runtime::DisallowNewSystemWeaks() and |
| 1400 | // ReferenceProcessor::EnableSlowPath(). |
| 1401 | bool32_t weak_ref_access_enabled; |
Hiroshi Yamauchi | 20a0be0 | 2016-02-19 15:44:06 -0800 | [diff] [blame] | 1402 | |
| 1403 | // A thread local version of Heap::disable_thread_flip_count_. This keeps track of how many |
| 1404 | // levels of (nested) JNI critical sections the thread is in and is used to detect a nested JNI |
| 1405 | // critical section enter. |
| 1406 | uint32_t disable_thread_flip_count; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1407 | } tls32_; |
| 1408 | |
| 1409 | struct PACKED(8) tls_64bit_sized_values { |
Sebastien Hertz | 0747466 | 2015-08-25 15:12:33 +0000 | [diff] [blame] | 1410 | tls_64bit_sized_values() : trace_clock_base(0) { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1411 | } |
| 1412 | |
| 1413 | // The clock base used for tracing. |
| 1414 | uint64_t trace_clock_base; |
| 1415 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1416 | RuntimeStats stats; |
| 1417 | } tls64_; |
| 1418 | |
Andreas Gampe | 6aa1370 | 2015-10-28 10:57:25 -0700 | [diff] [blame] | 1419 | struct PACKED(sizeof(void*)) tls_ptr_sized_values { |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1420 | tls_ptr_sized_values() : card_table(nullptr), exception(nullptr), stack_end(nullptr), |
Andreas Gampe | 449357d | 2015-06-01 22:29:51 -0700 | [diff] [blame] | 1421 | managed_stack(), suspend_trigger(nullptr), jni_env(nullptr), tmp_jni_env(nullptr), |
| 1422 | self(nullptr), opeer(nullptr), jpeer(nullptr), stack_begin(nullptr), stack_size(0), |
Nicolas Geoffray | 340dafa | 2016-11-18 16:03:10 +0000 | [diff] [blame] | 1423 | deps_or_stack_trace_sample(), wait_next(nullptr), monitor_enter_object(nullptr), |
Mathieu Chartier | eb8167a | 2014-05-07 15:43:14 -0700 | [diff] [blame] | 1424 | top_handle_scope(nullptr), class_loader_override(nullptr), long_jump_context(nullptr), |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1425 | instrumentation_stack(nullptr), debug_invoke_req(nullptr), single_step_control(nullptr), |
Sebastien Hertz | 0747466 | 2015-08-25 15:12:33 +0000 | [diff] [blame] | 1426 | stacked_shadow_frame_record(nullptr), deoptimization_context_stack(nullptr), |
Mingyao Yang | 99170c6 | 2015-07-06 11:10:37 -0700 | [diff] [blame] | 1427 | frame_id_to_shadow_frame(nullptr), name(nullptr), pthread_self(0), |
Vladimir Marko | 0584647 | 2016-09-14 12:49:57 +0100 | [diff] [blame] | 1428 | last_no_thread_suspension_cause(nullptr), checkpoint_function(nullptr), |
Roland Levillain | e71b354 | 2017-01-16 14:58:23 +0000 | [diff] [blame] | 1429 | thread_local_start(nullptr), thread_local_pos(nullptr), thread_local_end(nullptr), |
Vladimir Marko | 0584647 | 2016-09-14 12:49:57 +0100 | [diff] [blame] | 1430 | thread_local_objects(0), mterp_current_ibase(nullptr), mterp_default_ibase(nullptr), |
| 1431 | mterp_alt_ibase(nullptr), thread_local_alloc_stack_top(nullptr), |
| 1432 | thread_local_alloc_stack_end(nullptr), nested_signal_state(nullptr), |
| 1433 | flip_function(nullptr), method_verifier(nullptr), thread_local_mark_stack(nullptr) { |
Mathieu Chartier | 12d625f | 2015-03-13 11:33:37 -0700 | [diff] [blame] | 1434 | std::fill(held_mutexes, held_mutexes + kLockLevelCount, nullptr); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1435 | } |
| 1436 | |
| 1437 | // The biased card table, see CardTable for details. |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 1438 | uint8_t* card_table; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1439 | |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 1440 | // The pending exception or null. |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1441 | mirror::Throwable* exception; |
| 1442 | |
| 1443 | // The end of this thread's stack. This is the lowest safely-addressable address on the stack. |
| 1444 | // We leave extra space so there's room for the code that throws StackOverflowError. |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 1445 | uint8_t* stack_end; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1446 | |
| 1447 | // The top of the managed stack often manipulated directly by compiler generated code. |
| 1448 | ManagedStack managed_stack; |
| 1449 | |
| 1450 | // In certain modes, setting this to 0 will trigger a SEGV and thus a suspend check. It is |
| 1451 | // normally set to the address of itself. |
| 1452 | uintptr_t* suspend_trigger; |
| 1453 | |
| 1454 | // Every thread may have an associated JNI environment |
| 1455 | JNIEnvExt* jni_env; |
| 1456 | |
Andreas Gampe | 449357d | 2015-06-01 22:29:51 -0700 | [diff] [blame] | 1457 | // Temporary storage to transfer a pre-allocated JNIEnvExt from the creating thread to the |
| 1458 | // created thread. |
| 1459 | JNIEnvExt* tmp_jni_env; |
| 1460 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1461 | // Initialized to "this". On certain architectures (such as x86) reading off of Thread::Current |
| 1462 | // is easy but getting the address of Thread::Current is hard. This field can be read off of |
| 1463 | // Thread::Current to give the address. |
| 1464 | Thread* self; |
| 1465 | |
| 1466 | // Our managed peer (an instance of java.lang.Thread). The jobject version is used during thread |
| 1467 | // start up, until the thread is registered and the local opeer_ is used. |
| 1468 | mirror::Object* opeer; |
| 1469 | jobject jpeer; |
| 1470 | |
| 1471 | // The "lowest addressable byte" of the stack. |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 1472 | uint8_t* stack_begin; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1473 | |
| 1474 | // Size of the stack. |
| 1475 | size_t stack_size; |
| 1476 | |
Nicolas Geoffray | 340dafa | 2016-11-18 16:03:10 +0000 | [diff] [blame] | 1477 | // Sampling profiler and AOT verification cannot happen on the same run, so we share |
| 1478 | // the same entry for the stack trace and the verifier deps. |
| 1479 | union DepsOrStackTraceSample { |
| 1480 | DepsOrStackTraceSample() { |
| 1481 | verifier_deps = nullptr; |
| 1482 | stack_trace_sample = nullptr; |
| 1483 | } |
| 1484 | // Pointer to previous stack trace captured by sampling profiler. |
| 1485 | std::vector<ArtMethod*>* stack_trace_sample; |
| 1486 | // When doing AOT verification, per-thread VerifierDeps. |
| 1487 | verifier::VerifierDeps* verifier_deps; |
| 1488 | } deps_or_stack_trace_sample; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1489 | |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 1490 | // The next thread in the wait set this thread is part of or null if not waiting. |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1491 | Thread* wait_next; |
| 1492 | |
| 1493 | // If we're blocked in MonitorEnter, this is the object we're trying to lock. |
| 1494 | mirror::Object* monitor_enter_object; |
| 1495 | |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 1496 | // Top of linked list of handle scopes or null for none. |
Mathieu Chartier | e8a3c57 | 2016-10-11 16:52:17 -0700 | [diff] [blame] | 1497 | BaseHandleScope* top_handle_scope; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1498 | |
| 1499 | // Needed to get the right ClassLoader in JNI_OnLoad, but also |
| 1500 | // useful for testing. |
Ian Rogers | 68d8b42 | 2014-07-17 11:09:10 -0700 | [diff] [blame] | 1501 | jobject class_loader_override; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1502 | |
| 1503 | // Thread local, lazily allocated, long jump context. Used to deliver exceptions. |
| 1504 | Context* long_jump_context; |
| 1505 | |
| 1506 | // Additional stack used by method instrumentation to store method and return pc values. |
| 1507 | // Stored as a pointer since std::deque is not PACKED. |
| 1508 | std::deque<instrumentation::InstrumentationStackFrame>* instrumentation_stack; |
| 1509 | |
| 1510 | // JDWP invoke-during-breakpoint support. |
| 1511 | DebugInvokeReq* debug_invoke_req; |
| 1512 | |
| 1513 | // JDWP single-stepping support. |
| 1514 | SingleStepControl* single_step_control; |
| 1515 | |
Mingyao Yang | 1f2d3ba | 2015-05-18 12:12:50 -0700 | [diff] [blame] | 1516 | // For gc purpose, a shadow frame record stack that keeps track of: |
| 1517 | // 1) shadow frames under construction. |
| 1518 | // 2) deoptimization shadow frames. |
| 1519 | StackedShadowFrameRecord* stacked_shadow_frame_record; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1520 | |
Mingyao Yang | 1f2d3ba | 2015-05-18 12:12:50 -0700 | [diff] [blame] | 1521 | // Deoptimization return value record stack. |
Sebastien Hertz | 0747466 | 2015-08-25 15:12:33 +0000 | [diff] [blame] | 1522 | DeoptimizationContextRecord* deoptimization_context_stack; |
Andreas Gampe | 2a0d4ec | 2014-06-02 22:05:22 -0700 | [diff] [blame] | 1523 | |
Mingyao Yang | 99170c6 | 2015-07-06 11:10:37 -0700 | [diff] [blame] | 1524 | // For debugger, a linked list that keeps the mapping from frame_id to shadow frame. |
| 1525 | // Shadow frames may be created before deoptimization happens so that the debugger can |
| 1526 | // set local values there first. |
| 1527 | FrameIdToShadowFrame* frame_id_to_shadow_frame; |
| 1528 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1529 | // A cached copy of the java.lang.Thread's name. |
| 1530 | std::string* name; |
| 1531 | |
| 1532 | // A cached pthread_t for the pthread underlying this Thread*. |
| 1533 | pthread_t pthread_self; |
| 1534 | |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1535 | // If no_thread_suspension_ is > 0, what is causing that assertion. |
| 1536 | const char* last_no_thread_suspension_cause; |
| 1537 | |
Mathieu Chartier | 952e1e3 | 2016-06-13 14:04:02 -0700 | [diff] [blame] | 1538 | // Pending checkpoint function or null if non-pending. If this checkpoint is set and someone\ |
| 1539 | // requests another checkpoint, it goes to the checkpoint overflow list. |
| 1540 | Closure* checkpoint_function GUARDED_BY(Locks::thread_suspend_count_lock_); |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1541 | |
Yu Li | eac4424 | 2015-06-29 10:50:03 +0800 | [diff] [blame] | 1542 | // Pending barriers that require passing or NULL if non-pending. Installation guarding by |
| 1543 | // Locks::thread_suspend_count_lock_. |
| 1544 | // They work effectively as art::Barrier, but implemented directly using AtomicInteger and futex |
| 1545 | // to avoid additional cost of a mutex and a condition variable, as used in art::Barrier. |
| 1546 | AtomicInteger* active_suspend_barriers[kMaxSuspendBarriers]; |
| 1547 | |
Roland Levillain | e71b354 | 2017-01-16 14:58:23 +0000 | [diff] [blame] | 1548 | // Thread-local allocation pointer. Moved here to force alignment for thread_local_pos on ARM. |
| 1549 | uint8_t* thread_local_start; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1550 | |
Hiroshi Yamauchi | 7e1ce28 | 2015-12-11 15:46:19 -0800 | [diff] [blame] | 1551 | // thread_local_pos and thread_local_end must be consecutive for ldrd and are 8 byte aligned for |
| 1552 | // potentially better performance. |
Ian Rogers | 1373595 | 2014-10-08 12:43:28 -0700 | [diff] [blame] | 1553 | uint8_t* thread_local_pos; |
| 1554 | uint8_t* thread_local_end; |
Igor Murashkin | af1e299 | 2016-10-12 17:44:50 -0700 | [diff] [blame] | 1555 | |
Vladimir Marko | 0584647 | 2016-09-14 12:49:57 +0100 | [diff] [blame] | 1556 | size_t thread_local_objects; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1557 | |
Roland Levillain | e71b354 | 2017-01-16 14:58:23 +0000 | [diff] [blame] | 1558 | // Entrypoint function pointers. |
| 1559 | // TODO: move this to more of a global offset table model to avoid per-thread duplication. |
| 1560 | JniEntryPoints jni_entrypoints; |
| 1561 | QuickEntryPoints quick_entrypoints; |
| 1562 | |
buzbee | 1452bee | 2015-03-06 14:43:04 -0800 | [diff] [blame] | 1563 | // Mterp jump table bases. |
| 1564 | void* mterp_current_ibase; |
| 1565 | void* mterp_default_ibase; |
| 1566 | void* mterp_alt_ibase; |
| 1567 | |
Mathieu Chartier | 0651d41 | 2014-04-29 14:37:57 -0700 | [diff] [blame] | 1568 | // There are RosAlloc::kNumThreadLocalSizeBrackets thread-local size brackets per thread. |
Hiroshi Yamauchi | 7ed9c56 | 2016-02-02 15:22:09 -0800 | [diff] [blame] | 1569 | void* rosalloc_runs[kNumRosAllocThreadLocalSizeBracketsInThread]; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1570 | |
| 1571 | // Thread-local allocation stack data/routines. |
Mathieu Chartier | cb535da | 2015-01-23 13:50:03 -0800 | [diff] [blame] | 1572 | StackReference<mirror::Object>* thread_local_alloc_stack_top; |
| 1573 | StackReference<mirror::Object>* thread_local_alloc_stack_end; |
Chao-ying Fu | 9e36931 | 2014-05-21 11:20:52 -0700 | [diff] [blame] | 1574 | |
| 1575 | // Support for Mutex lock hierarchy bug detection. |
| 1576 | BaseMutex* held_mutexes[kLockLevelCount]; |
Dave Allison | 8ce6b90 | 2014-08-26 11:07:58 -0700 | [diff] [blame] | 1577 | |
| 1578 | // Recorded thread state for nested signals. |
| 1579 | jmp_buf* nested_signal_state; |
Hiroshi Yamauchi | 2cd334a | 2015-01-09 14:03:35 -0800 | [diff] [blame] | 1580 | |
| 1581 | // The function used for thread flip. |
| 1582 | Closure* flip_function; |
Mathieu Chartier | 12d625f | 2015-03-13 11:33:37 -0700 | [diff] [blame] | 1583 | |
| 1584 | // Current method verifier, used for root marking. |
| 1585 | verifier::MethodVerifier* method_verifier; |
Hiroshi Yamauchi | 0b71357 | 2015-06-16 18:29:23 -0700 | [diff] [blame] | 1586 | |
| 1587 | // Thread-local mark stack for the concurrent copying collector. |
| 1588 | gc::accounting::AtomicStack<mirror::Object>* thread_local_mark_stack; |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1589 | } tlsPtr_; |
| 1590 | |
| 1591 | // Guards the 'interrupted_' and 'wait_monitor_' members. |
| 1592 | Mutex* wait_mutex_ DEFAULT_MUTEX_ACQUIRED_AFTER; |
| 1593 | |
| 1594 | // Condition variable waited upon during a wait. |
| 1595 | ConditionVariable* wait_cond_ GUARDED_BY(wait_mutex_); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 1596 | // Pointer to the monitor lock we're currently waiting on or null if not waiting. |
Ian Rogers | dd7624d | 2014-03-14 17:43:00 -0700 | [diff] [blame] | 1597 | Monitor* wait_monitor_ GUARDED_BY(wait_mutex_); |
| 1598 | |
| 1599 | // Thread "interrupted" status; stays raised until queried or thrown. |
| 1600 | bool interrupted_ GUARDED_BY(wait_mutex_); |
| 1601 | |
Mathieu Chartier | dfe02f6 | 2016-02-01 20:15:11 -0800 | [diff] [blame] | 1602 | // Debug disable read barrier count, only is checked for debug builds and only in the runtime. |
| 1603 | uint8_t debug_disallow_read_barrier_ = 0; |
| 1604 | |
Mathieu Chartier | 3f7f03c | 2016-09-26 11:39:52 -0700 | [diff] [blame] | 1605 | // Note that it is not in the packed struct, may not be accessed for cross compilation. |
| 1606 | uintptr_t poison_object_cookie_ = 0; |
| 1607 | |
Mathieu Chartier | 952e1e3 | 2016-06-13 14:04:02 -0700 | [diff] [blame] | 1608 | // Pending extra checkpoints if checkpoint_function_ is already used. |
| 1609 | std::list<Closure*> checkpoint_overflow_ GUARDED_BY(Locks::thread_suspend_count_lock_); |
| 1610 | |
Andreas Gampe | f26bf2d | 2017-01-13 16:47:14 -0800 | [diff] [blame] | 1611 | // Custom TLS field that can be used by plugins. |
| 1612 | // TODO: Generalize once we have more plugins. |
| 1613 | const void* custom_tls_; |
| 1614 | |
Calin Juravle | ccd5695 | 2016-12-15 17:57:38 +0000 | [diff] [blame] | 1615 | // True if the thread is allowed to call back into java (for e.g. during class resolution). |
| 1616 | // By default this is true. |
| 1617 | bool can_call_into_java_; |
| 1618 | |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 1619 | friend class Dbg; // For SetStateUnsafe. |
Mathieu Chartier | 15d3402 | 2014-02-26 17:16:38 -0800 | [diff] [blame] | 1620 | friend class gc::collector::SemiSpace; // For getting stack traces. |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 1621 | friend class Runtime; // For CreatePeer. |
Ian Rogers | 5cf9819 | 2014-05-29 21:31:50 -0700 | [diff] [blame] | 1622 | friend class QuickExceptionHandler; // For dumping the stack. |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 1623 | friend class ScopedThreadStateChange; |
Mathieu Chartier | 119c6bd | 2014-05-09 14:11:47 -0700 | [diff] [blame] | 1624 | friend class StubTest; // For accessing entrypoints. |
Mathieu Chartier | 692fafd | 2013-11-29 17:24:40 -0800 | [diff] [blame] | 1625 | friend class ThreadList; // For ~Thread and Destroy. |
| 1626 | |
Andreas Gampe | 4352b45 | 2014-06-04 18:59:01 -0700 | [diff] [blame] | 1627 | friend class EntrypointsOrderTest; // To test the order of tls entries. |
| 1628 | |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 1629 | DISALLOW_COPY_AND_ASSIGN(Thread); |
| 1630 | }; |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 1631 | |
Mathieu Chartier | 4e2cb09 | 2015-07-22 16:17:51 -0700 | [diff] [blame] | 1632 | class SCOPED_CAPABILITY ScopedAssertNoThreadSuspension { |
Mathieu Chartier | 2d5f39e | 2014-09-19 17:52:37 -0700 | [diff] [blame] | 1633 | public: |
Andreas Gampe | ea47ff8 | 2016-11-03 08:20:17 -0700 | [diff] [blame] | 1634 | ALWAYS_INLINE explicit ScopedAssertNoThreadSuspension(const char* cause) |
| 1635 | ACQUIRE(Roles::uninterruptible_) { |
Mathieu Chartier | 268764d | 2016-09-13 12:09:38 -0700 | [diff] [blame] | 1636 | if (kIsDebugBuild) { |
| 1637 | self_ = Thread::Current(); |
| 1638 | old_cause_ = self_->StartAssertNoThreadSuspension(cause); |
| 1639 | } else { |
| 1640 | Roles::uninterruptible_.Acquire(); // No-op. |
| 1641 | } |
Mathieu Chartier | 2d5f39e | 2014-09-19 17:52:37 -0700 | [diff] [blame] | 1642 | } |
Mathieu Chartier | 268764d | 2016-09-13 12:09:38 -0700 | [diff] [blame] | 1643 | ALWAYS_INLINE ~ScopedAssertNoThreadSuspension() RELEASE(Roles::uninterruptible_) { |
| 1644 | if (kIsDebugBuild) { |
| 1645 | self_->EndAssertNoThreadSuspension(old_cause_); |
| 1646 | } else { |
| 1647 | Roles::uninterruptible_.Release(); // No-op. |
| 1648 | } |
Mathieu Chartier | 2d5f39e | 2014-09-19 17:52:37 -0700 | [diff] [blame] | 1649 | } |
| 1650 | |
| 1651 | private: |
Mathieu Chartier | 268764d | 2016-09-13 12:09:38 -0700 | [diff] [blame] | 1652 | Thread* self_; |
| 1653 | const char* old_cause_; |
Mathieu Chartier | 2d5f39e | 2014-09-19 17:52:37 -0700 | [diff] [blame] | 1654 | }; |
| 1655 | |
Mingyao Yang | 1f2d3ba | 2015-05-18 12:12:50 -0700 | [diff] [blame] | 1656 | class ScopedStackedShadowFramePusher { |
| 1657 | public: |
| 1658 | ScopedStackedShadowFramePusher(Thread* self, ShadowFrame* sf, StackedShadowFrameType type) |
| 1659 | : self_(self), type_(type) { |
| 1660 | self_->PushStackedShadowFrame(sf, type); |
| 1661 | } |
| 1662 | ~ScopedStackedShadowFramePusher() { |
| 1663 | self_->PopStackedShadowFrame(type_); |
| 1664 | } |
| 1665 | |
| 1666 | private: |
| 1667 | Thread* const self_; |
| 1668 | const StackedShadowFrameType type_; |
| 1669 | |
| 1670 | DISALLOW_COPY_AND_ASSIGN(ScopedStackedShadowFramePusher); |
| 1671 | }; |
| 1672 | |
Mathieu Chartier | dfe02f6 | 2016-02-01 20:15:11 -0800 | [diff] [blame] | 1673 | // Only works for debug builds. |
| 1674 | class ScopedDebugDisallowReadBarriers { |
| 1675 | public: |
| 1676 | explicit ScopedDebugDisallowReadBarriers(Thread* self) : self_(self) { |
| 1677 | self_->ModifyDebugDisallowReadBarrier(1); |
| 1678 | } |
| 1679 | ~ScopedDebugDisallowReadBarriers() { |
| 1680 | self_->ModifyDebugDisallowReadBarrier(-1); |
| 1681 | } |
| 1682 | |
| 1683 | private: |
| 1684 | Thread* const self_; |
| 1685 | }; |
| 1686 | |
Hiroshi Yamauchi | ee23582 | 2016-08-19 17:03:27 -0700 | [diff] [blame] | 1687 | class ScopedTransitioningToRunnable : public ValueObject { |
| 1688 | public: |
| 1689 | explicit ScopedTransitioningToRunnable(Thread* self) |
| 1690 | : self_(self) { |
| 1691 | DCHECK_EQ(self, Thread::Current()); |
| 1692 | if (kUseReadBarrier) { |
| 1693 | self_->SetIsTransitioningToRunnable(true); |
| 1694 | } |
| 1695 | } |
| 1696 | |
| 1697 | ~ScopedTransitioningToRunnable() { |
| 1698 | if (kUseReadBarrier) { |
| 1699 | self_->SetIsTransitioningToRunnable(false); |
| 1700 | } |
| 1701 | } |
| 1702 | |
| 1703 | private: |
| 1704 | Thread* const self_; |
| 1705 | }; |
| 1706 | |
Andreas Gampe | 04bbb5b | 2017-01-19 17:49:03 +0000 | [diff] [blame^] | 1707 | class ThreadLifecycleCallback { |
| 1708 | public: |
| 1709 | virtual ~ThreadLifecycleCallback() {} |
| 1710 | |
| 1711 | virtual void ThreadStart(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) = 0; |
| 1712 | virtual void ThreadDeath(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) = 0; |
| 1713 | }; |
| 1714 | |
Elliott Hughes | 330304d | 2011-08-12 14:28:05 -0700 | [diff] [blame] | 1715 | std::ostream& operator<<(std::ostream& os, const Thread& thread); |
Sebastien Hertz | f795869 | 2015-06-09 14:09:14 +0200 | [diff] [blame] | 1716 | std::ostream& operator<<(std::ostream& os, const StackedShadowFrameType& thread); |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 1717 | |
Carl Shapiro | 0e5d75d | 2011-07-06 18:28:37 -0700 | [diff] [blame] | 1718 | } // namespace art |
| 1719 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 1720 | #endif // ART_RUNTIME_THREAD_H_ |