blob: 7cb87abe3072a26efad574ce2882c91d9281b08d [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
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 Shapiro1fb86202011-06-27 17:43:13 -070016
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_RUNTIME_H_
18#define ART_RUNTIME_RUNTIME_H_
Carl Shapiro1fb86202011-06-27 17:43:13 -070019
Elliott Hughesa0e18062012-04-13 15:59:59 -070020#include <jni.h>
Elliott Hughesc5f7c912011-08-18 14:00:42 -070021#include <stdio.h>
22
Elliott Hughese27955c2011-08-26 15:21:24 -070023#include <iosfwd>
Hiroshi Yamauchi799eb3a2014-07-18 15:38:17 -070024#include <set>
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070025#include <string>
Carl Shapirofc322c72011-07-27 00:20:01 -070026#include <utility>
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070027#include <vector>
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070028
Ian Rogersd582fa42014-11-05 23:46:43 -080029#include "arch/instruction_set.h"
Andreas Gampe794ad762015-02-23 08:12:24 -080030#include "base/macros.h"
Alex Lighteb7c1442015-08-31 13:17:42 -070031#include "experimental_flags.h"
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -070032#include "gc_root.h"
Ian Rogers62d6c772013-02-27 08:32:07 -080033#include "instrumentation.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070034#include "jobject_comparator.h"
Jeff Hao848f70a2014-01-15 13:49:50 -080035#include "method_reference.h"
Mathieu Chartier8778c522016-10-04 19:06:30 -070036#include "obj_ptr.h"
Mathieu Chartier83c8ee02014-01-28 14:50:23 -080037#include "object_callbacks.h"
Ian Rogers576ca0c2014-06-06 15:58:22 -070038#include "offsets.h"
Mathieu Chartierf8cb1782016-03-18 18:45:41 -070039#include "process_state.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010040#include "quick/quick_method_frame_info.h"
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070041#include "runtime_stats.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070042#include "safe_map.h"
Carl Shapirob5573532011-07-12 18:22:59 -070043
Carl Shapiro1fb86202011-06-27 17:43:13 -070044namespace art {
45
Ian Rogers1d54e732013-05-02 21:10:01 -070046namespace gc {
Andreas Gampefda57142016-09-08 20:29:18 -070047 class AbstractSystemWeakHolder;
Ian Rogers1d54e732013-05-02 21:10:01 -070048 class Heap;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -080049 namespace collector {
50 class GarbageCollector;
51 } // namespace collector
Ian Rogers576ca0c2014-06-06 15:58:22 -070052} // namespace gc
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080053
54namespace jit {
55 class Jit;
56 class JitOptions;
57} // namespace jit
58
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080059namespace mirror {
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +010060 class Array;
Mathieu Chartierbb816d62016-09-07 10:17:46 -070061 class ClassLoader;
62 class DexCache;
Jeff Hao88474b42013-10-23 16:24:40 -070063 template<class T> class ObjectArray;
Ian Rogers1d54e732013-05-02 21:10:01 -070064 template<class T> class PrimitiveArray;
65 typedef PrimitiveArray<int8_t> ByteArray;
66 class String;
67 class Throwable;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080068} // namespace mirror
Alex Light7233c7e2016-07-28 10:07:45 -070069namespace ti {
70 class Agent;
71} // namespace ti
Mathieu Chartierc528dba2013-11-26 12:00:11 -080072namespace verifier {
Ian Rogers6a3c1fc2014-10-31 00:33:20 -070073 class MethodVerifier;
Igor Murashkin7617abd2015-07-10 18:27:47 -070074 enum class VerifyMode : int8_t;
Ian Rogers6a3c1fc2014-10-31 00:33:20 -070075} // namespace verifier
Mathieu Chartiere401d142015-04-22 13:56:20 -070076class ArenaPool;
77class ArtMethod;
Carl Shapiro61e019d2011-07-14 16:53:09 -070078class ClassLinker;
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -080079class Closure;
Mathieu Chartiere401d142015-04-22 13:56:20 -070080class CompilerCallbacks;
Carl Shapirofc322c72011-07-27 00:20:01 -070081class DexFile;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070082class InternTable;
Ian Rogersb48b9eb2014-02-28 16:20:21 -080083class JavaVMExt;
Mathieu Chartiere401d142015-04-22 13:56:20 -070084class LinearAlloc;
Elliott Hughesc33a32b2011-10-11 18:18:07 -070085class MonitorList;
Ian Rogersef7d42f2014-01-06 12:55:46 -080086class MonitorPool;
Ian Rogers576ca0c2014-06-06 15:58:22 -070087class NullPointerHandler;
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -070088class OatFileManager;
Alex Light185d1342016-08-11 10:48:03 -070089class Plugin;
Vladimir Marko88b2b802015-12-04 14:19:04 +000090struct RuntimeArgumentMap;
Elliott Hughese27955c2011-08-26 15:21:24 -070091class SignalCatcher;
Ian Rogers576ca0c2014-06-06 15:58:22 -070092class StackOverflowHandler;
93class SuspensionHandler;
Carl Shapiro61e019d2011-07-14 16:53:09 -070094class ThreadList;
jeffhao2692b572011-12-16 15:42:28 -080095class Trace;
Andreas Gampef6a780a2015-04-02 18:51:05 -070096struct TraceConfig;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +010097class Transaction;
Carl Shapiro61e019d2011-07-14 16:53:09 -070098
Ian Rogerse63db272014-07-15 15:36:11 -070099typedef std::vector<std::pair<std::string, const void*>> RuntimeOptions;
100
Mathieu Chartier661974a2014-01-09 11:23:53 -0800101// Not all combinations of flags are valid. You may not visit all roots as well as the new roots
102// (no logical reason to do this). You also may not start logging new roots and stop logging new
103// roots (also no logical reason to do this).
Mathieu Chartier893263b2014-03-04 11:07:42 -0800104enum VisitRootFlags : uint8_t {
105 kVisitRootFlagAllRoots = 0x1,
106 kVisitRootFlagNewRoots = 0x2,
107 kVisitRootFlagStartLoggingNewRoots = 0x4,
108 kVisitRootFlagStopLoggingNewRoots = 0x8,
109 kVisitRootFlagClearRootLog = 0x10,
Mathieu Chartier4edd8472015-06-01 10:47:36 -0700110 // Non moving means we can have optimizations where we don't visit some roots if they are
111 // definitely reachable from another location. E.g. ArtMethod and ArtField roots.
112 kVisitRootFlagNonMoving = 0x20,
Mathieu Chartier893263b2014-03-04 11:07:42 -0800113};
114
Carl Shapiro1fb86202011-06-27 17:43:13 -0700115class Runtime {
116 public:
Vladimir Marko88b2b802015-12-04 14:19:04 +0000117 // Parse raw runtime options.
118 static bool ParseOptions(const RuntimeOptions& raw_options,
119 bool ignore_unrecognized,
120 RuntimeArgumentMap* runtime_options);
121
Carl Shapiro61e019d2011-07-14 16:53:09 -0700122 // Creates and initializes a new runtime.
Vladimir Marko88b2b802015-12-04 14:19:04 +0000123 static bool Create(RuntimeArgumentMap&& runtime_options)
124 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
125
126 // Creates and initializes a new runtime.
127 static bool Create(const RuntimeOptions& raw_options, bool ignore_unrecognized)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700128 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700129
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800130 // IsAotCompiler for compilers that don't have a running runtime. Only dex2oat currently.
131 bool IsAotCompiler() const {
Calin Juravleffc87072016-04-20 14:22:09 +0100132 return !UseJitCompilation() && IsCompiler();
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800133 }
134
135 // IsCompiler is any runtime which has a running compiler, either dex2oat or JIT.
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800136 bool IsCompiler() const {
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000137 return compiler_callbacks_ != nullptr;
138 }
139
Andreas Gampe4585f872015-03-27 23:45:15 -0700140 // If a compiler, are we compiling a boot image?
141 bool IsCompilingBootImage() const;
142
143 bool CanRelocate() const;
Alex Lighta59dd802014-07-02 16:28:08 -0700144
145 bool ShouldRelocate() const {
146 return must_relocate_ && CanRelocate();
147 }
148
149 bool MustRelocateIfPossible() const {
150 return must_relocate_;
151 }
152
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100153 bool IsDex2OatEnabled() const {
Alex Light64ad14d2014-08-19 14:23:13 -0700154 return dex2oat_enabled_ && IsImageDex2OatEnabled();
155 }
156
157 bool IsImageDex2OatEnabled() const {
158 return image_dex2oat_enabled_;
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100159 }
160
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000161 CompilerCallbacks* GetCompilerCallbacks() {
162 return compiler_callbacks_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800163 }
164
Mathieu Chartier07ddb6f2015-11-05 11:16:34 -0800165 void SetCompilerCallbacks(CompilerCallbacks* callbacks) {
166 CHECK(callbacks != nullptr);
167 compiler_callbacks_ = callbacks;
168 }
169
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700170 bool IsZygote() const {
171 return is_zygote_;
172 }
173
Anwar Ghuloum87183592013-08-14 12:12:19 -0700174 bool IsExplicitGcDisabled() const {
175 return is_explicit_gc_disabled_;
176 }
177
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700178 std::string GetCompilerExecutable() const;
Alex Lighta59dd802014-07-02 16:28:08 -0700179 std::string GetPatchoatExecutable() const;
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700180
Brian Carlstrom6449c622014-02-10 23:48:36 -0800181 const std::vector<std::string>& GetCompilerOptions() const {
182 return compiler_options_;
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700183 }
184
Andreas Gamped2abbc92014-12-19 09:53:27 -0800185 void AddCompilerOption(std::string option) {
186 compiler_options_.push_back(option);
187 }
188
Brian Carlstrom6449c622014-02-10 23:48:36 -0800189 const std::vector<std::string>& GetImageCompilerOptions() const {
190 return image_compiler_options_;
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700191 }
192
Brian Carlstrom31d8f522014-09-29 11:22:54 -0700193 const std::string& GetImageLocation() const {
194 return image_location_;
195 }
196
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700197 // Starts a runtime, which may cause threads to be started and code to run.
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700198 bool Start() UNLOCK_FUNCTION(Locks::mutator_lock_);
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700199
Mathieu Chartier590fee92013-09-13 13:46:47 -0700200 bool IsShuttingDown(Thread* self);
Mathieu Chartier90443472015-07-16 20:32:27 -0700201 bool IsShuttingDownLocked() const REQUIRES(Locks::runtime_shutdown_lock_) {
Ian Rogers9af209c2012-06-03 20:50:30 -0700202 return shutting_down_;
203 }
204
Mathieu Chartier90443472015-07-16 20:32:27 -0700205 size_t NumberOfThreadsBeingBorn() const REQUIRES(Locks::runtime_shutdown_lock_) {
Ian Rogers120f1c72012-09-28 17:17:10 -0700206 return threads_being_born_;
207 }
208
Mathieu Chartier90443472015-07-16 20:32:27 -0700209 void StartThreadBirth() REQUIRES(Locks::runtime_shutdown_lock_) {
Ian Rogers120f1c72012-09-28 17:17:10 -0700210 threads_being_born_++;
211 }
212
Mathieu Chartier90443472015-07-16 20:32:27 -0700213 void EndThreadBirth() REQUIRES(Locks::runtime_shutdown_lock_);
Ian Rogers120f1c72012-09-28 17:17:10 -0700214
Ian Rogers9af209c2012-06-03 20:50:30 -0700215 bool IsStarted() const {
216 return started_;
217 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700218
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700219 bool IsFinishedStarting() const {
220 return finished_starting_;
221 }
222
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700223 static Runtime* Current() {
224 return instance_;
225 }
Carl Shapiro1fb86202011-06-27 17:43:13 -0700226
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000227 // Aborts semi-cleanly. Used in the implementation of LOG(FATAL), which most
228 // callers should prefer.
Andreas Gampe90a32b12016-10-03 19:47:08 -0700229 NO_RETURN static void Abort(const char* msg) REQUIRES(!Locks::abort_lock_);
Elliott Hughesffe67362011-07-17 12:09:27 -0700230
Ian Rogers365c1022012-06-22 15:05:28 -0700231 // Returns the "main" ThreadGroup, used when attaching user threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700232 jobject GetMainThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700233
234 // Returns the "system" ThreadGroup, used when attaching our internal threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700235 jobject GetSystemThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700236
Brian Carlstromce888532013-10-10 00:32:58 -0700237 // Returns the system ClassLoader which represents the CLASSPATH.
238 jobject GetSystemClassLoader() const;
239
Elliott Hughes462c9442012-03-23 18:47:50 -0700240 // Attaches the calling native thread to the runtime.
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700241 bool AttachCurrentThread(const char* thread_name, bool as_daemon, jobject thread_group,
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800242 bool create_peer);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700243
Elliott Hughesbf86d042011-08-31 17:53:14 -0700244 void CallExitHook(jint status);
245
Carl Shapiro61e019d2011-07-14 16:53:09 -0700246 // Detaches the current native thread from the runtime.
Mathieu Chartier90443472015-07-16 20:32:27 -0700247 void DetachCurrentThread() REQUIRES(!Locks::mutator_lock_);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700248
Ian Rogers7b078e82014-09-10 14:44:24 -0700249 void DumpForSigQuit(std::ostream& os);
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800250 void DumpLockHolders(std::ostream& os);
Elliott Hughese27955c2011-08-26 15:21:24 -0700251
Carl Shapiro61e019d2011-07-14 16:53:09 -0700252 ~Runtime();
Carl Shapirob5573532011-07-12 18:22:59 -0700253
Brian Carlstroma004aa92012-02-08 18:05:09 -0800254 const std::string& GetBootClassPathString() const {
255 return boot_class_path_string_;
256 }
257
258 const std::string& GetClassPathString() const {
259 return class_path_string_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700260 }
261
262 ClassLinker* GetClassLinker() const {
Carl Shapiro7a909592011-07-24 19:21:59 -0700263 return class_linker_;
264 }
265
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700266 size_t GetDefaultStackSize() const {
267 return default_stack_size_;
268 }
269
Ian Rogers1d54e732013-05-02 21:10:01 -0700270 gc::Heap* GetHeap() const {
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800271 return heap_;
272 }
273
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700274 InternTable* GetInternTable() const {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700275 DCHECK(intern_table_ != nullptr);
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700276 return intern_table_;
277 }
278
Elliott Hughes0af55432011-08-17 18:37:28 -0700279 JavaVMExt* GetJavaVM() const {
Richard Uhlerda0a69e2016-10-11 15:06:38 +0100280 return java_vm_.get();
Elliott Hughesf2682d52011-08-15 16:37:04 -0700281 }
282
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700283 size_t GetMaxSpinsBeforeThinkLockInflation() const {
284 return max_spins_before_thin_lock_inflation_;
285 }
286
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700287 MonitorList* GetMonitorList() const {
288 return monitor_list_;
289 }
290
Ian Rogersef7d42f2014-01-06 12:55:46 -0800291 MonitorPool* GetMonitorPool() const {
292 return monitor_pool_;
293 }
294
Ian Rogersc0542af2014-09-03 16:16:56 -0700295 // Is the given object the special object used to mark a cleared JNI weak global?
Mathieu Chartier8778c522016-10-04 19:06:30 -0700296 bool IsClearedJniWeakGlobal(ObjPtr<mirror::Object> obj) REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersc0542af2014-09-03 16:16:56 -0700297
298 // Get the special object used to mark a cleared JNI weak global.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700299 mirror::Object* GetClearedJniWeakGlobal() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersc0542af2014-09-03 16:16:56 -0700300
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700301 mirror::Throwable* GetPreAllocatedOutOfMemoryError() REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes225f5a12012-06-11 11:23:48 -0700302
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700303 mirror::Throwable* GetPreAllocatedNoClassDefFoundError()
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700304 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers63557452014-06-04 16:57:15 -0700305
Elliott Hughes225f5a12012-06-11 11:23:48 -0700306 const std::vector<std::string>& GetProperties() const {
307 return properties_;
308 }
309
Elliott Hughesd92bec42011-09-02 17:04:36 -0700310 ThreadList* GetThreadList() const {
311 return thread_list_;
312 }
313
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800314 static const char* GetVersion() {
Andreas Gampe2153f932014-06-26 08:09:17 -0700315 return "2.1.0";
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700316 }
317
Narayan Kamath25352fc2016-08-03 12:46:58 +0100318 bool IsMethodHandlesEnabled() const {
319 return experimental_flags_ & ExperimentalFlags::kMethodHandles;
320 }
321
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700322 void DisallowNewSystemWeaks() REQUIRES_SHARED(Locks::mutator_lock_);
323 void AllowNewSystemWeaks() REQUIRES_SHARED(Locks::mutator_lock_);
324 void BroadcastForNewSystemWeaks() REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -0700325
Ian Rogers1d54e732013-05-02 21:10:01 -0700326 // Visit all the roots. If only_dirty is true then non-dirty roots won't be visited. If
327 // clean_dirty is true then dirty roots will be marked as non-dirty after visiting.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700328 void VisitRoots(RootVisitor* visitor, VisitRootFlags flags = kVisitRootFlagAllRoots)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700329 REQUIRES_SHARED(Locks::mutator_lock_);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700330
Mathieu Chartier461687d2015-03-31 12:05:24 -0700331 // Visit image roots, only used for hprof since the GC uses the image space mod union table
332 // instead.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700333 void VisitImageRoots(RootVisitor* visitor) REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier461687d2015-03-31 12:05:24 -0700334
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700335 // Visit all of the roots we can do safely do concurrently.
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700336 void VisitConcurrentRoots(RootVisitor* visitor,
337 VisitRootFlags flags = kVisitRootFlagAllRoots)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700338 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700339
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700340 // Visit all of the non thread roots, we can do this with mutators unpaused.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700341 void VisitNonThreadRoots(RootVisitor* visitor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700342 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700343
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700344 void VisitTransactionRoots(RootVisitor* visitor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700345 REQUIRES_SHARED(Locks::mutator_lock_);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800346
347 // Visit all of the thread roots.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700348 void VisitThreadRoots(RootVisitor* visitor) REQUIRES_SHARED(Locks::mutator_lock_);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800349
350 // Flip thread roots from from-space refs to to-space refs.
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700351 size_t FlipThreadRoots(Closure* thread_flip_visitor, Closure* flip_callback,
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800352 gc::collector::GarbageCollector* collector)
Mathieu Chartier90443472015-07-16 20:32:27 -0700353 REQUIRES(!Locks::mutator_lock_);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -0800354
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700355 // Visit all other roots which must be done with mutators suspended.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700356 void VisitNonConcurrentRoots(RootVisitor* visitor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700357 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700358
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700359 // Sweep system weaks, the system weak is deleted if the visitor return null. Otherwise, the
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700360 // system weak is updated to be the visitor's returned value.
Mathieu Chartier97509952015-07-13 14:35:43 -0700361 void SweepSystemWeaks(IsMarkedVisitor* visitor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700362 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700363
Mathieu Chartier893263b2014-03-04 11:07:42 -0800364 // Constant roots are the roots which never change after the runtime is initialized, they only
365 // need to be visited once per GC cycle.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700366 void VisitConstantRoots(RootVisitor* visitor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700367 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier893263b2014-03-04 11:07:42 -0800368
Ian Rogers9af209c2012-06-03 20:50:30 -0700369 // Returns a special method that calls into a trampoline for runtime method resolution
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800370 ArtMethod* GetResolutionMethod();
Ian Rogers9af209c2012-06-03 20:50:30 -0700371
372 bool HasResolutionMethod() const {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700373 return resolution_method_ != nullptr;
Ian Rogers9af209c2012-06-03 20:50:30 -0700374 }
375
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700376 void SetResolutionMethod(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers9af209c2012-06-03 20:50:30 -0700377
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700378 ArtMethod* CreateResolutionMethod() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800379
Ian Rogerse63db272014-07-15 15:36:11 -0700380 // Returns a special method that calls into a trampoline for runtime imt conflicts.
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800381 ArtMethod* GetImtConflictMethod();
382 ArtMethod* GetImtUnimplementedMethod();
Jeff Hao88474b42013-10-23 16:24:40 -0700383
384 bool HasImtConflictMethod() const {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700385 return imt_conflict_method_ != nullptr;
Jeff Hao88474b42013-10-23 16:24:40 -0700386 }
387
Mathieu Chartiere42888f2016-04-14 10:49:19 -0700388 void FixupConflictTables();
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700389 void SetImtConflictMethod(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_);
390 void SetImtUnimplementedMethod(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_);
Jeff Hao88474b42013-10-23 16:24:40 -0700391
Nicolas Geoffray796d6302016-03-13 22:22:31 +0000392 ArtMethod* CreateImtConflictMethod(LinearAlloc* linear_alloc)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700393 REQUIRES_SHARED(Locks::mutator_lock_);
Jeff Hao88474b42013-10-23 16:24:40 -0700394
Ian Rogersff1ed472011-09-20 13:46:24 -0700395 // Returns a special method that describes all callee saves being spilled to the stack.
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700396 enum CalleeSaveType {
Vladimir Markofd36f1f2016-08-03 18:49:58 +0100397 kSaveAllCalleeSaves, // All callee-save registers.
398 kSaveRefsOnly, // Only those callee-save registers that can hold references.
399 kSaveRefsAndArgs, // References (see above) and arguments (usually caller-save registers).
400 kSaveEverything, // All registers, including both callee-save and caller-save.
401 kLastCalleeSaveType // Value used for iteration
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700402 };
Ian Rogers9af209c2012-06-03 20:50:30 -0700403
404 bool HasCalleeSaveMethod(CalleeSaveType type) const {
Mathieu Chartiere401d142015-04-22 13:56:20 -0700405 return callee_save_methods_[type] != 0u;
Ian Rogers9af209c2012-06-03 20:50:30 -0700406 }
407
Mathieu Chartiere401d142015-04-22 13:56:20 -0700408 ArtMethod* GetCalleeSaveMethod(CalleeSaveType type)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700409 REQUIRES_SHARED(Locks::mutator_lock_);
Hiroshi Yamauchiab088112014-07-14 13:00:14 -0700410
Mathieu Chartiere401d142015-04-22 13:56:20 -0700411 ArtMethod* GetCalleeSaveMethodUnchecked(CalleeSaveType type)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700412 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers9af209c2012-06-03 20:50:30 -0700413
Vladimir Marko7624d252014-05-02 14:40:15 +0100414 QuickMethodFrameInfo GetCalleeSaveMethodFrameInfo(CalleeSaveType type) const {
415 return callee_save_method_frame_infos_[type];
416 }
417
Mathieu Chartiere401d142015-04-22 13:56:20 -0700418 QuickMethodFrameInfo GetRuntimeMethodFrameInfo(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700419 REQUIRES_SHARED(Locks::mutator_lock_);
Vladimir Marko7624d252014-05-02 14:40:15 +0100420
Ian Rogers936b37f2014-02-14 00:52:24 -0800421 static size_t GetCalleeSaveMethodOffset(CalleeSaveType type) {
422 return OFFSETOF_MEMBER(Runtime, callee_save_methods_[type]);
423 }
424
Vladimir Marko7624d252014-05-02 14:40:15 +0100425 InstructionSet GetInstructionSet() const {
426 return instruction_set_;
427 }
428
429 void SetInstructionSet(InstructionSet instruction_set);
430
Mathieu Chartiere401d142015-04-22 13:56:20 -0700431 void SetCalleeSaveMethod(ArtMethod* method, CalleeSaveType type);
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700432
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700433 ArtMethod* CreateCalleeSaveMethod() REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersff1ed472011-09-20 13:46:24 -0700434
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700435 int32_t GetStat(int kind);
436
Ian Rogers9af209c2012-06-03 20:50:30 -0700437 RuntimeStats* GetStats() {
438 return &stats_;
439 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700440
441 bool HasStatsEnabled() const {
442 return stats_enabled_;
443 }
444
445 void ResetStats(int kinds);
446
Mathieu Chartier90443472015-07-16 20:32:27 -0700447 void SetStatsEnabled(bool new_state)
448 REQUIRES(!Locks::instrument_entrypoints_lock_, !Locks::mutator_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700449
Andreas Gampe6be67ee2014-09-02 21:22:18 -0700450 enum class NativeBridgeAction { // private
451 kUnload,
452 kInitialize
453 };
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800454
455 jit::Jit* GetJit() {
456 return jit_.get();
457 }
Calin Juravleffc87072016-04-20 14:22:09 +0100458
459 // Returns true if JIT compilations are enabled. GetJit() will be not null in this case.
460 bool UseJitCompilation() const;
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800461
Narayan Kamath3de95a72014-04-02 12:54:23 +0100462 void PreZygoteFork();
Nicolas Geoffrayd66c8622015-12-11 14:59:16 +0000463 void InitNonZygoteOrPostFork(
464 JNIEnv* env, bool is_system_server, NativeBridgeAction action, const char* isa);
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700465
Ian Rogers9bc54402014-04-17 16:40:01 -0700466 const instrumentation::Instrumentation* GetInstrumentation() const {
467 return &instrumentation_;
468 }
469
Ian Rogers62d6c772013-02-27 08:32:07 -0800470 instrumentation::Instrumentation* GetInstrumentation() {
471 return &instrumentation_;
472 }
jeffhao2692b572011-12-16 15:42:28 -0800473
Calin Juravle66f55232015-12-08 15:09:10 +0000474 void RegisterAppInfo(const std::vector<std::string>& code_paths,
Calin Juravlec90bc922016-02-24 10:13:09 +0000475 const std::string& profile_output_filename,
476 const std::string& foreign_dex_profile_path,
477 const std::string& app_dir);
478 void NotifyDexLoaded(const std::string& dex_location);
Dave Allison0aded082013-11-07 13:15:11 -0800479
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100480 // Transaction support.
Sebastien Hertzee1d79a2014-02-21 15:46:30 +0100481 bool IsActiveTransaction() const {
482 return preinitialization_transaction_ != nullptr;
483 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100484 void EnterTransactionMode(Transaction* transaction);
485 void ExitTransactionMode();
Sebastien Hertz1c80bec2015-02-03 11:58:06 +0100486 bool IsTransactionAborted() const;
487
Sebastien Hertz2fd7e692015-04-02 11:11:19 +0200488 void AbortTransactionAndThrowAbortError(Thread* self, const std::string& abort_message)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700489 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz2fd7e692015-04-02 11:11:19 +0200490 void ThrowTransactionAbortError(Thread* self)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700491 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz1c80bec2015-02-03 11:58:06 +0100492
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700493 void RecordWriteFieldBoolean(mirror::Object* obj, MemberOffset field_offset, uint8_t value,
Fred Shih37f05ef2014-07-16 18:38:08 -0700494 bool is_volatile) const;
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700495 void RecordWriteFieldByte(mirror::Object* obj, MemberOffset field_offset, int8_t value,
Fred Shih37f05ef2014-07-16 18:38:08 -0700496 bool is_volatile) const;
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700497 void RecordWriteFieldChar(mirror::Object* obj, MemberOffset field_offset, uint16_t value,
Fred Shih37f05ef2014-07-16 18:38:08 -0700498 bool is_volatile) const;
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700499 void RecordWriteFieldShort(mirror::Object* obj, MemberOffset field_offset, int16_t value,
Fred Shih37f05ef2014-07-16 18:38:08 -0700500 bool is_volatile) const;
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700501 void RecordWriteField32(mirror::Object* obj, MemberOffset field_offset, uint32_t value,
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100502 bool is_volatile) const;
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700503 void RecordWriteField64(mirror::Object* obj, MemberOffset field_offset, uint64_t value,
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100504 bool is_volatile) const;
Mathieu Chartiera058fdf2016-10-06 15:13:58 -0700505 void RecordWriteFieldReference(mirror::Object* obj,
506 MemberOffset field_offset,
507 ObjPtr<mirror::Object> value,
508 bool is_volatile) const
509 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100510 void RecordWriteArray(mirror::Array* array, size_t index, uint64_t value) const
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700511 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -0700512 void RecordStrongStringInsertion(mirror::String* s) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700513 REQUIRES(Locks::intern_table_lock_);
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -0700514 void RecordWeakStringInsertion(mirror::String* s) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700515 REQUIRES(Locks::intern_table_lock_);
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -0700516 void RecordStrongStringRemoval(mirror::String* s) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700517 REQUIRES(Locks::intern_table_lock_);
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -0700518 void RecordWeakStringRemoval(mirror::String* s) const
Mathieu Chartier90443472015-07-16 20:32:27 -0700519 REQUIRES(Locks::intern_table_lock_);
Mathieu Chartierbb816d62016-09-07 10:17:46 -0700520 void RecordResolveString(mirror::DexCache* dex_cache, uint32_t string_idx) const
521 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100522
Mathieu Chartier90443472015-07-16 20:32:27 -0700523 void SetFaultMessage(const std::string& message) REQUIRES(!fault_message_lock_);
Mathieu Chartier15d34022014-02-26 17:16:38 -0800524 // Only read by the signal handler, NO_THREAD_SAFETY_ANALYSIS to prevent lock order violations
525 // with the unexpected_signal_lock_.
526 const std::string& GetFaultMessage() NO_THREAD_SAFETY_ANALYSIS {
527 return fault_message_;
528 }
529
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700530 void AddCurrentRuntimeFeaturesAsDex2OatArguments(std::vector<std::string>* arg_vector) const;
Ian Rogers8afeb852014-04-02 14:55:49 -0700531
Dave Allisonb373e092014-02-20 16:06:36 -0800532 bool ExplicitStackOverflowChecks() const {
Andreas Gampe928f72b2014-09-09 19:53:48 -0700533 return !implicit_so_checks_;
Dave Allisonb373e092014-02-20 16:06:36 -0800534 }
535
Igor Murashkin7617abd2015-07-10 18:27:47 -0700536 bool IsVerificationEnabled() const;
537 bool IsVerificationSoftFail() const;
Jeff Hao4a200f52014-04-01 14:58:49 -0700538
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700539 bool IsDexFileFallbackEnabled() const {
540 return allow_dex_file_fallback_;
541 }
542
Dmitriy Ivanov785049f2014-07-18 10:08:57 -0700543 const std::vector<std::string>& GetCpuAbilist() const {
544 return cpu_abilist_;
545 }
546
Evgenii Stepanov1e133742015-05-20 12:30:59 -0700547 bool IsRunningOnMemoryTool() const {
548 return is_running_on_memory_tool_;
Mathieu Chartierda44d772014-04-01 15:01:46 -0700549 }
550
Jeff Haof00571c2014-05-29 17:29:47 -0700551 void SetTargetSdkVersion(int32_t version) {
552 target_sdk_version_ = version;
553 }
554
555 int32_t GetTargetSdkVersion() const {
556 return target_sdk_version_;
557 }
558
Narayan Kamath5a2be3f2015-02-16 13:51:51 +0000559 uint32_t GetZygoteMaxFailedBoots() const {
560 return zygote_max_failed_boots_;
561 }
562
Alex Lighteb7c1442015-08-31 13:17:42 -0700563 bool AreExperimentalFlagsEnabled(ExperimentalFlags flags) {
564 return (experimental_flags_ & flags) != ExperimentalFlags::kNone;
Igor Murashkin158f35c2015-06-10 15:55:30 -0700565 }
566
Mathieu Chartier455f67c2015-03-17 13:48:29 -0700567 // Create the JIT and instrumentation and code cache.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800568 void CreateJit();
569
Mathieu Chartier9b34b242015-03-09 11:30:17 -0700570 ArenaPool* GetArenaPool() {
571 return arena_pool_.get();
572 }
Nicolas Geoffray25e04562016-03-01 13:17:58 +0000573 ArenaPool* GetJitArenaPool() {
574 return jit_arena_pool_.get();
575 }
Mathieu Chartier9b34b242015-03-09 11:30:17 -0700576 const ArenaPool* GetArenaPool() const {
577 return arena_pool_.get();
578 }
Jean-Philippe Halimica76a1a2016-02-02 19:48:52 +0100579
580 void ReclaimArenaPoolMemory();
581
Mathieu Chartierc7853442015-03-27 14:35:38 -0700582 LinearAlloc* GetLinearAlloc() {
583 return linear_alloc_.get();
584 }
Mathieu Chartier9b34b242015-03-09 11:30:17 -0700585
Mathieu Chartier455f67c2015-03-17 13:48:29 -0700586 jit::JitOptions* GetJITOptions() {
587 return jit_options_.get();
588 }
589
Nicolas Geoffray7a4d0152015-07-10 17:29:39 +0100590 bool IsDebuggable() const;
591
David Srbeckyf4480162016-03-16 00:06:24 +0000592 bool IsNativeDebuggable() const {
593 return is_native_debuggable_;
594 }
595
596 void SetNativeDebuggable(bool value) {
597 is_native_debuggable_ = value;
598 }
599
Andreas Gampedd671252015-07-23 14:37:18 -0700600 // Returns the build fingerprint, if set. Otherwise an empty string is returned.
601 std::string GetFingerprint() {
602 return fingerprint_;
603 }
604
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700605 // Called from class linker.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700606 void SetSentinel(mirror::Object* sentinel) REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700607
Mathieu Chartier951ec2c2015-09-22 08:50:05 -0700608 // Create a normal LinearAlloc or low 4gb version if we are 64 bit AOT compiler.
609 LinearAlloc* CreateLinearAlloc();
610
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -0700611 OatFileManager& GetOatFileManager() const {
612 DCHECK(oat_file_manager_ != nullptr);
Mathieu Chartiere58991b2015-10-13 07:59:34 -0700613 return *oat_file_manager_;
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -0700614 }
615
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -0700616 double GetHashTableMinLoadFactor() const;
617 double GetHashTableMaxLoadFactor() const;
618
Nicolas Geoffray787ae8e2015-11-05 11:32:24 +0000619 void SetSafeMode(bool mode) {
620 safe_mode_ = mode;
621 }
622
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000623 bool GetDumpNativeStackOnSigQuit() const {
624 return dump_native_stack_on_sig_quit_;
625 }
626
Andreas Gampea1425a12016-03-11 17:44:04 -0800627 bool GetPrunedDalvikCache() const {
628 return pruned_dalvik_cache_;
629 }
630
631 void SetPrunedDalvikCache(bool pruned) {
632 pruned_dalvik_cache_ = pruned;
633 }
634
Mathieu Chartierf8cb1782016-03-18 18:45:41 -0700635 void UpdateProcessState(ProcessState process_state);
636
637 // Returns true if we currently care about long mutator pause.
638 bool InJankPerceptibleProcessState() const {
639 return process_state_ == kProcessStateJankPerceptible;
640 }
641
Calin Juravle97cbc922016-04-15 16:16:35 +0100642 void RegisterSensitiveThread() const;
643
Andreas Gampef38a6612016-04-11 08:42:26 -0700644 void SetZygoteNoThreadSection(bool val) {
645 zygote_no_threads_ = val;
646 }
647
648 bool IsZygoteNoThreadSection() const {
649 return zygote_no_threads_;
650 }
651
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700652 // Returns if the code can be deoptimized. Code may be compiled with some
653 // optimization that makes it impossible to deoptimize.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700654 bool IsDeoptimizeable(uintptr_t code) const REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yangf711f2c2016-05-23 12:29:39 -0700655
David Sehrd106d9f2016-08-16 19:22:57 -0700656 // Returns a saved copy of the environment (getenv/setenv values).
657 // Used by Fork to protect against overwriting LD_LIBRARY_PATH, etc.
658 char** GetEnvSnapshot() const {
659 return env_snapshot_.GetSnapshot();
660 }
661
Andreas Gampefda57142016-09-08 20:29:18 -0700662 void AddSystemWeakHolder(gc::AbstractSystemWeakHolder* holder);
663 void RemoveSystemWeakHolder(gc::AbstractSystemWeakHolder* holder);
664
David Sehrf57589f2016-10-17 10:09:33 -0700665 NO_RETURN
666 static void Aborter(const char* abort_message);
667
Carl Shapirob5573532011-07-12 18:22:59 -0700668 private:
Elliott Hughes457005c2012-04-16 13:54:25 -0700669 static void InitPlatformSignalHandlers();
Elliott Hughesffe67362011-07-17 12:09:27 -0700670
Elliott Hughesdcc24742011-09-07 14:02:44 -0700671 Runtime();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700672
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700673 void BlockSignals();
674
Vladimir Marko88b2b802015-12-04 14:19:04 +0000675 bool Init(RuntimeArgumentMap&& runtime_options)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700676 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
Mathieu Chartier90443472015-07-16 20:32:27 -0700677 void InitNativeMethods() REQUIRES(!Locks::mutator_lock_);
Ian Rogers365c1022012-06-22 15:05:28 -0700678 void InitThreadGroups(Thread* self);
Elliott Hughesff17f1f2012-01-24 18:12:29 -0800679 void RegisterRuntimeNativeMethods(JNIEnv* env);
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700680
Elliott Hughes85d15452011-09-16 17:33:01 -0700681 void StartDaemonThreads();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700682 void StartSignalCatcher();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700683
Calin Juravle31f2c152015-10-23 17:56:15 +0100684 void MaybeSaveJitProfilingInfo();
685
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700686 // A pointer to the active runtime or null.
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800687 static Runtime* instance_;
688
Ian Rogers8afeb852014-04-02 14:55:49 -0700689 // NOTE: these must match the gc::ProcessState values as they come directly from the framework.
690 static constexpr int kProfileForground = 0;
Calin Juravle31f2c152015-10-23 17:56:15 +0100691 static constexpr int kProfileBackground = 1;
Ian Rogers8afeb852014-04-02 14:55:49 -0700692
Mathieu Chartiere401d142015-04-22 13:56:20 -0700693 // 64 bit so that we can share the same asm offsets for both 32 and 64 bits.
694 uint64_t callee_save_methods_[kLastCalleeSaveType];
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700695 GcRoot<mirror::Throwable> pre_allocated_OutOfMemoryError_;
Ian Rogers63557452014-06-04 16:57:15 -0700696 GcRoot<mirror::Throwable> pre_allocated_NoClassDefFoundError_;
Mathieu Chartiere401d142015-04-22 13:56:20 -0700697 ArtMethod* resolution_method_;
698 ArtMethod* imt_conflict_method_;
Mathieu Chartier2d2621a2014-10-23 16:48:06 -0700699 // Unresolved method has the same behavior as the conflict method, it is used by the class linker
700 // for differentiating between unfilled imt slots vs conflict slots in superclasses.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700701 ArtMethod* imt_unimplemented_method_;
Ian Rogers6ed19fd2014-03-20 08:10:17 -0700702
Ian Rogersc0542af2014-09-03 16:16:56 -0700703 // Special sentinel object used to invalid conditions in JNI (cleared weak references) and
704 // JDWP (invalid references).
705 GcRoot<mirror::Object> sentinel_;
706
Vladimir Marko7624d252014-05-02 14:40:15 +0100707 InstructionSet instruction_set_;
708 QuickMethodFrameInfo callee_save_method_frame_infos_[kLastCalleeSaveType];
709
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000710 CompilerCallbacks* compiler_callbacks_;
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700711 bool is_zygote_;
Alex Lighta59dd802014-07-02 16:28:08 -0700712 bool must_relocate_;
Mathieu Chartier069387a2012-06-18 12:01:01 -0700713 bool is_concurrent_gc_enabled_;
Anwar Ghuloum87183592013-08-14 12:12:19 -0700714 bool is_explicit_gc_disabled_;
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100715 bool dex2oat_enabled_;
Alex Light64ad14d2014-08-19 14:23:13 -0700716 bool image_dex2oat_enabled_;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700717
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700718 std::string compiler_executable_;
Alex Lighta59dd802014-07-02 16:28:08 -0700719 std::string patchoat_executable_;
Brian Carlstrom6449c622014-02-10 23:48:36 -0800720 std::vector<std::string> compiler_options_;
721 std::vector<std::string> image_compiler_options_;
Brian Carlstrom31d8f522014-09-29 11:22:54 -0700722 std::string image_location_;
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700723
Brian Carlstroma004aa92012-02-08 18:05:09 -0800724 std::string boot_class_path_string_;
725 std::string class_path_string_;
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700726 std::vector<std::string> properties_;
727
Alex Light7233c7e2016-07-28 10:07:45 -0700728 std::vector<ti::Agent> agents_;
Alex Light185d1342016-08-11 10:48:03 -0700729 std::vector<Plugin> plugins_;
Alex Light7233c7e2016-07-28 10:07:45 -0700730
Brian Carlstromb765be02011-08-17 23:54:10 -0700731 // The default stack size for managed threads created by the runtime.
Elliott Hughesbe759c62011-09-08 19:38:21 -0700732 size_t default_stack_size_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700733
Ian Rogers1d54e732013-05-02 21:10:01 -0700734 gc::Heap* heap_;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800735
Nicolas Geoffray25e04562016-03-01 13:17:58 +0000736 std::unique_ptr<ArenaPool> jit_arena_pool_;
Mathieu Chartier9b34b242015-03-09 11:30:17 -0700737 std::unique_ptr<ArenaPool> arena_pool_;
Mathieu Chartierc7853442015-03-27 14:35:38 -0700738 // Special low 4gb pool for compiler linear alloc. We need ArtFields to be in low 4gb if we are
739 // compiling using a 32 bit image on a 64 bit compiler in case we resolve things in the image
740 // since the field arrays are int arrays in this case.
741 std::unique_ptr<ArenaPool> low_4gb_arena_pool_;
742
743 // Shared linear alloc for now.
744 std::unique_ptr<LinearAlloc> linear_alloc_;
Mathieu Chartier9b34b242015-03-09 11:30:17 -0700745
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700746 // The number of spins that are done before thread suspension is used to forcibly inflate.
747 size_t max_spins_before_thin_lock_inflation_;
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700748 MonitorList* monitor_list_;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800749 MonitorPool* monitor_pool_;
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700750
Carl Shapirob5573532011-07-12 18:22:59 -0700751 ThreadList* thread_list_;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700752
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700753 InternTable* intern_table_;
754
Brian Carlstromb0460ea2011-07-29 10:08:05 -0700755 ClassLinker* class_linker_;
756
Elliott Hughese27955c2011-08-26 15:21:24 -0700757 SignalCatcher* signal_catcher_;
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700758 std::string stack_trace_file_;
Elliott Hughese27955c2011-08-26 15:21:24 -0700759
Richard Uhlerda0a69e2016-10-11 15:06:38 +0100760 std::unique_ptr<JavaVMExt> java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700761
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800762 std::unique_ptr<jit::Jit> jit_;
763 std::unique_ptr<jit::JitOptions> jit_options_;
764
Mathieu Chartier15d34022014-02-26 17:16:38 -0800765 // Fault message, printed when we get a SIGSEGV.
766 Mutex fault_message_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
767 std::string fault_message_ GUARDED_BY(fault_message_lock_);
768
Ian Rogers120f1c72012-09-28 17:17:10 -0700769 // A non-zero value indicates that a thread has been created but not yet initialized. Guarded by
770 // the shutdown lock so that threads aren't born while we're shutting down.
771 size_t threads_being_born_ GUARDED_BY(Locks::runtime_shutdown_lock_);
772
773 // Waited upon until no threads are being born.
Ian Rogers700a4022014-05-19 16:49:03 -0700774 std::unique_ptr<ConditionVariable> shutdown_cond_ GUARDED_BY(Locks::runtime_shutdown_lock_);
Ian Rogers120f1c72012-09-28 17:17:10 -0700775
776 // Set when runtime shutdown is past the point that new threads may attach.
777 bool shutting_down_ GUARDED_BY(Locks::runtime_shutdown_lock_);
778
779 // The runtime is starting to shutdown but is blocked waiting on shutdown_cond_.
780 bool shutting_down_started_ GUARDED_BY(Locks::runtime_shutdown_lock_);
781
Elliott Hughesdcc24742011-09-07 14:02:44 -0700782 bool started_;
783
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700784 // New flag added which tells us if the runtime has finished starting. If
785 // this flag is set then the Daemon threads are created and the class loader
786 // is created. This flag is needed for knowing if its safe to request CMS.
787 bool finished_starting_;
788
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700789 // Hooks supported by JNI_CreateJavaVM
790 jint (*vfprintf_)(FILE* stream, const char* format, va_list ap);
791 void (*exit_)(jint status);
792 void (*abort_)();
793
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700794 bool stats_enabled_;
795 RuntimeStats stats_;
796
Evgenii Stepanov1e133742015-05-20 12:30:59 -0700797 const bool is_running_on_memory_tool_;
Mathieu Chartierda44d772014-04-01 15:01:46 -0700798
Andreas Gampef6a780a2015-04-02 18:51:05 -0700799 std::unique_ptr<TraceConfig> trace_config_;
800
Ian Rogers62d6c772013-02-27 08:32:07 -0800801 instrumentation::Instrumentation instrumentation_;
jeffhao2692b572011-12-16 15:42:28 -0800802
Ian Rogers365c1022012-06-22 15:05:28 -0700803 jobject main_thread_group_;
804 jobject system_thread_group_;
805
Brian Carlstromce888532013-10-10 00:32:58 -0700806 // As returned by ClassLoader.getSystemClassLoader().
807 jobject system_class_loader_;
808
Hiroshi Yamauchi2e899a92013-11-22 16:50:12 -0800809 // If true, then we dump the GC cumulative timings on shutdown.
810 bool dump_gc_performance_on_shutdown_;
811
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100812 // Transaction used for pre-initializing classes at compilation time.
Sebastien Hertzee1d79a2014-02-21 15:46:30 +0100813 Transaction* preinitialization_transaction_;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100814
Igor Murashkin7617abd2015-07-10 18:27:47 -0700815 // If kNone, verification is disabled. kEnable by default.
816 verifier::VerifyMode verify_;
Jeff Hao4a200f52014-04-01 14:58:49 -0700817
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700818 // If true, the runtime may use dex files directly with the interpreter if an oat file is not
819 // available/usable.
820 bool allow_dex_file_fallback_;
821
Dmitriy Ivanov785049f2014-07-18 10:08:57 -0700822 // List of supported cpu abis.
823 std::vector<std::string> cpu_abilist_;
824
Jeff Haof00571c2014-05-29 17:29:47 -0700825 // Specifies target SDK version to allow workarounds for certain API levels.
826 int32_t target_sdk_version_;
827
Dave Allison69dfe512014-07-11 17:11:58 +0000828 // Implicit checks flags.
829 bool implicit_null_checks_; // NullPointer checks are implicit.
830 bool implicit_so_checks_; // StackOverflow checks are implicit.
831 bool implicit_suspend_checks_; // Thread suspension checks are implicit.
832
Calin Juravle01aaf6e2015-06-19 22:05:39 +0100833 // Whether or not the sig chain (and implicitly the fault handler) should be
834 // disabled. Tools like dex2oat or patchoat don't need them. This enables
835 // building a statically link version of dex2oat.
836 bool no_sig_chain_;
837
Calin Juravled3e7c6c2016-02-04 19:07:51 +0000838 // Force the use of native bridge even if the app ISA matches the runtime ISA.
839 bool force_native_bridge_;
840
Calin Juravle07d83c72014-10-22 21:02:23 +0100841 // Whether or not a native bridge has been loaded.
Calin Juravlec8423522014-08-12 20:55:20 +0100842 //
843 // The native bridge allows running native code compiled for a foreign ISA. The way it works is,
844 // if standard dlopen fails to load native library associated with native activity, it calls to
845 // the native bridge to load it and then gets the trampoline for the entry to native activity.
Calin Juravle07d83c72014-10-22 21:02:23 +0100846 //
847 // The option 'native_bridge_library_filename' specifies the name of the native bridge.
848 // When non-empty the native bridge will be loaded from the given file. An empty value means
849 // that there's no native bridge.
850 bool is_native_bridge_loaded_;
Calin Juravlec8423522014-08-12 20:55:20 +0100851
David Srbeckyf4480162016-03-16 00:06:24 +0000852 // Whether we are running under native debugger.
853 bool is_native_debuggable_;
854
Narayan Kamath5a2be3f2015-02-16 13:51:51 +0000855 // The maximum number of failed boots we allow before pruning the dalvik cache
856 // and trying again. This option is only inspected when we're running as a
857 // zygote.
858 uint32_t zygote_max_failed_boots_;
859
Igor Murashkin158f35c2015-06-10 15:55:30 -0700860 // Enable experimental opcodes that aren't fully specified yet. The intent is to
861 // eventually publish them as public-usable opcodes, but they aren't ready yet.
862 //
863 // Experimental opcodes should not be used by other production code.
Alex Lighteb7c1442015-08-31 13:17:42 -0700864 ExperimentalFlags experimental_flags_;
Igor Murashkin158f35c2015-06-10 15:55:30 -0700865
Andreas Gampedd671252015-07-23 14:37:18 -0700866 // Contains the build fingerprint, if given as a parameter.
867 std::string fingerprint_;
868
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -0700869 // Oat file manager, keeps track of what oat files are open.
Mathieu Chartiere58991b2015-10-13 07:59:34 -0700870 OatFileManager* oat_file_manager_;
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -0700871
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -0700872 // Whether or not we are on a low RAM device.
873 bool is_low_memory_mode_;
874
Nicolas Geoffray787ae8e2015-11-05 11:32:24 +0000875 // Whether the application should run in safe mode, that is, interpreter only.
876 bool safe_mode_;
877
Nicolas Geoffraya73280d2016-02-15 13:05:16 +0000878 // Whether threads should dump their native stack on SIGQUIT.
879 bool dump_native_stack_on_sig_quit_;
880
Andreas Gampea1425a12016-03-11 17:44:04 -0800881 // Whether the dalvik cache was pruned when initializing the runtime.
882 bool pruned_dalvik_cache_;
883
Mathieu Chartierf8cb1782016-03-18 18:45:41 -0700884 // Whether or not we currently care about pause times.
885 ProcessState process_state_;
886
Andreas Gampef38a6612016-04-11 08:42:26 -0700887 // Whether zygote code is in a section that should not start threads.
888 bool zygote_no_threads_;
889
David Sehrd106d9f2016-08-16 19:22:57 -0700890 // Saved environment.
891 class EnvSnapshot {
892 public:
893 EnvSnapshot() = default;
894 void TakeSnapshot();
895 char** GetSnapshot() const;
896
897 private:
898 std::unique_ptr<char*[]> c_env_vector_;
899 std::vector<std::unique_ptr<std::string>> name_value_pairs_;
900
901 DISALLOW_COPY_AND_ASSIGN(EnvSnapshot);
902 } env_snapshot_;
903
Andreas Gampefda57142016-09-08 20:29:18 -0700904 // Generic system-weak holders.
905 std::vector<gc::AbstractSystemWeakHolder*> system_weak_holders_;
906
Carl Shapiro61e019d2011-07-14 16:53:09 -0700907 DISALLOW_COPY_AND_ASSIGN(Runtime);
Carl Shapiro1fb86202011-06-27 17:43:13 -0700908};
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700909std::ostream& operator<<(std::ostream& os, const Runtime::CalleeSaveType& rhs);
Carl Shapiro1fb86202011-06-27 17:43:13 -0700910
911} // namespace art
912
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700913#endif // ART_RUNTIME_RUNTIME_H_