blob: e334764daa47da6e994419f6b4c593bcae4ec555 [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"
Mathieu Chartierbad02672014-08-25 13:08:22 -070030#include "base/allocator.h"
Alex Lighta59dd802014-07-02 16:28:08 -070031#include "compiler_callbacks.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"
Mathieu Chartier83c8ee02014-01-28 14:50:23 -080035#include "object_callbacks.h"
Ian Rogers576ca0c2014-06-06 15:58:22 -070036#include "offsets.h"
Calin Juravlec1b643c2014-05-30 23:44:11 +010037#include "profiler_options.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010038#include "quick/quick_method_frame_info.h"
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070039#include "runtime_stats.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070040#include "safe_map.h"
Carl Shapirob5573532011-07-12 18:22:59 -070041
Carl Shapiro1fb86202011-06-27 17:43:13 -070042namespace art {
43
Ian Rogers1d54e732013-05-02 21:10:01 -070044namespace gc {
45 class Heap;
Ian Rogers576ca0c2014-06-06 15:58:22 -070046} // namespace gc
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080047namespace mirror {
Brian Carlstromea46f952013-07-30 01:26:50 -070048 class ArtMethod;
Ian Rogers1d54e732013-05-02 21:10:01 -070049 class ClassLoader;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +010050 class Array;
Jeff Hao88474b42013-10-23 16:24:40 -070051 template<class T> class ObjectArray;
Ian Rogers1d54e732013-05-02 21:10:01 -070052 template<class T> class PrimitiveArray;
53 typedef PrimitiveArray<int8_t> ByteArray;
54 class String;
55 class Throwable;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080056} // namespace mirror
Mathieu Chartierc528dba2013-11-26 12:00:11 -080057namespace verifier {
Ian Rogers6a3c1fc2014-10-31 00:33:20 -070058 class MethodVerifier;
59} // namespace verifier
Carl Shapiro61e019d2011-07-14 16:53:09 -070060class ClassLinker;
Carl Shapirofc322c72011-07-27 00:20:01 -070061class DexFile;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070062class InternTable;
Ian Rogersb48b9eb2014-02-28 16:20:21 -080063class JavaVMExt;
Elliott Hughesc33a32b2011-10-11 18:18:07 -070064class MonitorList;
Ian Rogersef7d42f2014-01-06 12:55:46 -080065class MonitorPool;
Ian Rogers576ca0c2014-06-06 15:58:22 -070066class NullPointerHandler;
Elliott Hughese27955c2011-08-26 15:21:24 -070067class SignalCatcher;
Ian Rogers576ca0c2014-06-06 15:58:22 -070068class StackOverflowHandler;
69class SuspensionHandler;
Carl Shapiro61e019d2011-07-14 16:53:09 -070070class ThreadList;
jeffhao2692b572011-12-16 15:42:28 -080071class Trace;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +010072class Transaction;
Carl Shapiro61e019d2011-07-14 16:53:09 -070073
Ian Rogers015b1372014-12-04 19:53:52 -080074// 0 if not abort, non-zero if an abort is in progress. Used on fatal exit to prevents recursive
75// aborts. Global declaration allows us to disable some error checking to ensure fatal shutdown
76// makes forward progress.
77extern volatile unsigned int gAborting;
78
Ian Rogerse63db272014-07-15 15:36:11 -070079typedef std::vector<std::pair<std::string, const void*>> RuntimeOptions;
80
Mathieu Chartier661974a2014-01-09 11:23:53 -080081// Not all combinations of flags are valid. You may not visit all roots as well as the new roots
82// (no logical reason to do this). You also may not start logging new roots and stop logging new
83// roots (also no logical reason to do this).
Mathieu Chartier893263b2014-03-04 11:07:42 -080084enum VisitRootFlags : uint8_t {
85 kVisitRootFlagAllRoots = 0x1,
86 kVisitRootFlagNewRoots = 0x2,
87 kVisitRootFlagStartLoggingNewRoots = 0x4,
88 kVisitRootFlagStopLoggingNewRoots = 0x8,
89 kVisitRootFlagClearRootLog = 0x10,
90};
91
Carl Shapiro1fb86202011-06-27 17:43:13 -070092class Runtime {
93 public:
Carl Shapiro61e019d2011-07-14 16:53:09 -070094 // Creates and initializes a new runtime.
Ian Rogerse63db272014-07-15 15:36:11 -070095 static bool Create(const RuntimeOptions& options, bool ignore_unrecognized)
Ian Rogersb726dcb2012-09-05 08:57:23 -070096 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
Brian Carlstrom69b15fb2011-09-03 12:25:21 -070097
Elliott Hughesd9c67be2012-02-02 19:54:06 -080098 bool IsCompiler() const {
Vladimir Marko2b5eaa22013-12-13 13:59:30 +000099 return compiler_callbacks_ != nullptr;
100 }
101
Alex Lighta59dd802014-07-02 16:28:08 -0700102 bool CanRelocate() const {
103 return !IsCompiler() || compiler_callbacks_->IsRelocationPossible();
104 }
105
106 bool ShouldRelocate() const {
107 return must_relocate_ && CanRelocate();
108 }
109
110 bool MustRelocateIfPossible() const {
111 return must_relocate_;
112 }
113
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100114 bool IsDex2OatEnabled() const {
Alex Light64ad14d2014-08-19 14:23:13 -0700115 return dex2oat_enabled_ && IsImageDex2OatEnabled();
116 }
117
118 bool IsImageDex2OatEnabled() const {
119 return image_dex2oat_enabled_;
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100120 }
121
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000122 CompilerCallbacks* GetCompilerCallbacks() {
123 return compiler_callbacks_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800124 }
125
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700126 bool IsZygote() const {
127 return is_zygote_;
128 }
129
Anwar Ghuloum87183592013-08-14 12:12:19 -0700130 bool IsExplicitGcDisabled() const {
131 return is_explicit_gc_disabled_;
132 }
133
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700134 std::string GetCompilerExecutable() const;
Alex Lighta59dd802014-07-02 16:28:08 -0700135 std::string GetPatchoatExecutable() const;
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700136
Brian Carlstrom6449c622014-02-10 23:48:36 -0800137 const std::vector<std::string>& GetCompilerOptions() const {
138 return compiler_options_;
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700139 }
140
Brian Carlstrom6449c622014-02-10 23:48:36 -0800141 const std::vector<std::string>& GetImageCompilerOptions() const {
142 return image_compiler_options_;
Anwar Ghuloum8447d842013-04-30 17:27:40 -0700143 }
144
Brian Carlstrom31d8f522014-09-29 11:22:54 -0700145 const std::string& GetImageLocation() const {
146 return image_location_;
147 }
148
Calin Juravlec1b643c2014-05-30 23:44:11 +0100149 const ProfilerOptions& GetProfilerOptions() const {
150 return profiler_options_;
151 }
152
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700153 // Starts a runtime, which may cause threads to be started and code to run.
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700154 bool Start() UNLOCK_FUNCTION(Locks::mutator_lock_);
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700155
Mathieu Chartier590fee92013-09-13 13:46:47 -0700156 bool IsShuttingDown(Thread* self);
157 bool IsShuttingDownLocked() const EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
Ian Rogers9af209c2012-06-03 20:50:30 -0700158 return shutting_down_;
159 }
160
Ian Rogers120f1c72012-09-28 17:17:10 -0700161 size_t NumberOfThreadsBeingBorn() const EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
162 return threads_being_born_;
163 }
164
165 void StartThreadBirth() EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
166 threads_being_born_++;
167 }
168
169 void EndThreadBirth() EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_);
170
Ian Rogers9af209c2012-06-03 20:50:30 -0700171 bool IsStarted() const {
172 return started_;
173 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700174
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700175 bool IsFinishedStarting() const {
176 return finished_starting_;
177 }
178
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700179 static Runtime* Current() {
180 return instance_;
181 }
Carl Shapiro1fb86202011-06-27 17:43:13 -0700182
Ian Rogers015b1372014-12-04 19:53:52 -0800183 // Aborts semi-cleanly. Used in the implementation of LOG(FATAL), which most callers should
184 // prefer. Not [[noreturn]] due to returning early in the case of recursive aborts.
185 static void Abort() LOCKS_EXCLUDED(Locks::abort_lock_);
Elliott Hughesffe67362011-07-17 12:09:27 -0700186
Ian Rogers365c1022012-06-22 15:05:28 -0700187 // Returns the "main" ThreadGroup, used when attaching user threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700188 jobject GetMainThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700189
190 // Returns the "system" ThreadGroup, used when attaching our internal threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700191 jobject GetSystemThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700192
Brian Carlstromce888532013-10-10 00:32:58 -0700193 // Returns the system ClassLoader which represents the CLASSPATH.
194 jobject GetSystemClassLoader() const;
195
Elliott Hughes462c9442012-03-23 18:47:50 -0700196 // Attaches the calling native thread to the runtime.
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800197 bool AttachCurrentThread(const char* thread_name, bool as_daemon, jobject thread_group,
198 bool create_peer);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700199
Elliott Hughesbf86d042011-08-31 17:53:14 -0700200 void CallExitHook(jint status);
201
Carl Shapiro61e019d2011-07-14 16:53:09 -0700202 // Detaches the current native thread from the runtime.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700203 void DetachCurrentThread() LOCKS_EXCLUDED(Locks::mutator_lock_);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700204
Ian Rogers7b078e82014-09-10 14:44:24 -0700205 void DumpForSigQuit(std::ostream& os);
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800206 void DumpLockHolders(std::ostream& os);
Elliott Hughese27955c2011-08-26 15:21:24 -0700207
Carl Shapiro61e019d2011-07-14 16:53:09 -0700208 ~Runtime();
Carl Shapirob5573532011-07-12 18:22:59 -0700209
Brian Carlstroma004aa92012-02-08 18:05:09 -0800210 const std::string& GetBootClassPathString() const {
211 return boot_class_path_string_;
212 }
213
214 const std::string& GetClassPathString() const {
215 return class_path_string_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700216 }
217
218 ClassLinker* GetClassLinker() const {
Carl Shapiro7a909592011-07-24 19:21:59 -0700219 return class_linker_;
220 }
221
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700222 size_t GetDefaultStackSize() const {
223 return default_stack_size_;
224 }
225
Ian Rogers1d54e732013-05-02 21:10:01 -0700226 gc::Heap* GetHeap() const {
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800227 return heap_;
228 }
229
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700230 InternTable* GetInternTable() const {
Brian Carlstrome8104522013-10-15 21:56:36 -0700231 DCHECK(intern_table_ != NULL);
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700232 return intern_table_;
233 }
234
Elliott Hughes0af55432011-08-17 18:37:28 -0700235 JavaVMExt* GetJavaVM() const {
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700236 return java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700237 }
238
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700239 size_t GetMaxSpinsBeforeThinkLockInflation() const {
240 return max_spins_before_thin_lock_inflation_;
241 }
242
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700243 MonitorList* GetMonitorList() const {
244 return monitor_list_;
245 }
246
Ian Rogersef7d42f2014-01-06 12:55:46 -0800247 MonitorPool* GetMonitorPool() const {
248 return monitor_pool_;
249 }
250
Ian Rogersc0542af2014-09-03 16:16:56 -0700251 // Is the given object the special object used to mark a cleared JNI weak global?
252 bool IsClearedJniWeakGlobal(mirror::Object* obj) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
253
254 // Get the special object used to mark a cleared JNI weak global.
255 mirror::Object* GetClearedJniWeakGlobal() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
256
Hiroshi Yamauchiab088112014-07-14 13:00:14 -0700257 mirror::Throwable* GetPreAllocatedOutOfMemoryError() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes225f5a12012-06-11 11:23:48 -0700258
Ian Rogers63557452014-06-04 16:57:15 -0700259 mirror::Throwable* GetPreAllocatedNoClassDefFoundError()
260 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
261
Elliott Hughes225f5a12012-06-11 11:23:48 -0700262 const std::vector<std::string>& GetProperties() const {
263 return properties_;
264 }
265
Elliott Hughesd92bec42011-09-02 17:04:36 -0700266 ThreadList* GetThreadList() const {
267 return thread_list_;
268 }
269
Brian Carlstrom491ca9e2014-03-02 18:24:38 -0800270 static const char* GetVersion() {
Andreas Gampe2153f932014-06-26 08:09:17 -0700271 return "2.1.0";
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700272 }
273
Mathieu Chartierc11d9b82013-09-19 10:01:59 -0700274 void DisallowNewSystemWeaks() EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
275 void AllowNewSystemWeaks() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
276
Ian Rogers1d54e732013-05-02 21:10:01 -0700277 // Visit all the roots. If only_dirty is true then non-dirty roots won't be visited. If
278 // clean_dirty is true then dirty roots will be marked as non-dirty after visiting.
Mathieu Chartier893263b2014-03-04 11:07:42 -0800279 void VisitRoots(RootCallback* visitor, void* arg, VisitRootFlags flags = kVisitRootFlagAllRoots)
Ian Rogers1d54e732013-05-02 21:10:01 -0700280 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700281
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700282 // Visit all of the roots we can do safely do concurrently.
Mathieu Chartier893263b2014-03-04 11:07:42 -0800283 void VisitConcurrentRoots(RootCallback* visitor, void* arg,
284 VisitRootFlags flags = kVisitRootFlagAllRoots)
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800285 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700286
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700287 // Visit all of the non thread roots, we can do this with mutators unpaused.
Mathieu Chartier83c8ee02014-01-28 14:50:23 -0800288 void VisitNonThreadRoots(RootCallback* visitor, void* arg)
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800289 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700290
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700291 // Visit all other roots which must be done with mutators suspended.
Mathieu Chartier83c8ee02014-01-28 14:50:23 -0800292 void VisitNonConcurrentRoots(RootCallback* visitor, void* arg)
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800293 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700294
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700295 // Sweep system weaks, the system weak is deleted if the visitor return nullptr. Otherwise, the
296 // system weak is updated to be the visitor's returned value.
Mathieu Chartier83c8ee02014-01-28 14:50:23 -0800297 void SweepSystemWeaks(IsMarkedCallback* visitor, void* arg)
Mathieu Chartierad2541a2013-10-25 10:05:23 -0700298 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700299
Mathieu Chartier893263b2014-03-04 11:07:42 -0800300 // Constant roots are the roots which never change after the runtime is initialized, they only
301 // need to be visited once per GC cycle.
302 void VisitConstantRoots(RootCallback* callback, void* arg)
303 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
304
Ian Rogers9af209c2012-06-03 20:50:30 -0700305 // Returns a special method that calls into a trampoline for runtime method resolution
Ian Rogerse63db272014-07-15 15:36:11 -0700306 mirror::ArtMethod* GetResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers9af209c2012-06-03 20:50:30 -0700307
308 bool HasResolutionMethod() const {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700309 return !resolution_method_.IsNull();
Ian Rogers9af209c2012-06-03 20:50:30 -0700310 }
311
Brian Carlstromea46f952013-07-30 01:26:50 -0700312 void SetResolutionMethod(mirror::ArtMethod* method) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700313 resolution_method_ = GcRoot<mirror::ArtMethod>(method);
Ian Rogers9af209c2012-06-03 20:50:30 -0700314 }
315
Brian Carlstromea46f952013-07-30 01:26:50 -0700316 mirror::ArtMethod* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800317
Ian Rogerse63db272014-07-15 15:36:11 -0700318 // Returns a special method that calls into a trampoline for runtime imt conflicts.
319 mirror::ArtMethod* GetImtConflictMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier2d2621a2014-10-23 16:48:06 -0700320 mirror::ArtMethod* GetImtUnimplementedMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jeff Hao88474b42013-10-23 16:24:40 -0700321
322 bool HasImtConflictMethod() const {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700323 return !imt_conflict_method_.IsNull();
Jeff Hao88474b42013-10-23 16:24:40 -0700324 }
325
326 void SetImtConflictMethod(mirror::ArtMethod* method) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700327 imt_conflict_method_ = GcRoot<mirror::ArtMethod>(method);
Jeff Hao88474b42013-10-23 16:24:40 -0700328 }
Mathieu Chartier2d2621a2014-10-23 16:48:06 -0700329 void SetImtUnimplementedMethod(mirror::ArtMethod* method) {
330 imt_unimplemented_method_ = GcRoot<mirror::ArtMethod>(method);
331 }
Jeff Hao88474b42013-10-23 16:24:40 -0700332
333 mirror::ArtMethod* CreateImtConflictMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
334
335 // Returns an imt with every entry set to conflict, used as default imt for all classes.
Hiroshi Yamauchiab088112014-07-14 13:00:14 -0700336 mirror::ObjectArray<mirror::ArtMethod>* GetDefaultImt()
Ian Rogerse63db272014-07-15 15:36:11 -0700337 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Jeff Hao88474b42013-10-23 16:24:40 -0700338
339 bool HasDefaultImt() const {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700340 return !default_imt_.IsNull();
Jeff Hao88474b42013-10-23 16:24:40 -0700341 }
342
343 void SetDefaultImt(mirror::ObjectArray<mirror::ArtMethod>* imt) {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700344 default_imt_ = GcRoot<mirror::ObjectArray<mirror::ArtMethod>>(imt);
Jeff Hao88474b42013-10-23 16:24:40 -0700345 }
346
347 mirror::ObjectArray<mirror::ArtMethod>* CreateDefaultImt(ClassLinker* cl)
348 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
349
Ian Rogersff1ed472011-09-20 13:46:24 -0700350 // Returns a special method that describes all callee saves being spilled to the stack.
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700351 enum CalleeSaveType {
352 kSaveAll,
353 kRefsOnly,
354 kRefsAndArgs,
355 kLastCalleeSaveType // Value used for iteration
356 };
Ian Rogers9af209c2012-06-03 20:50:30 -0700357
358 bool HasCalleeSaveMethod(CalleeSaveType type) const {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700359 return !callee_save_methods_[type].IsNull();
Ian Rogers9af209c2012-06-03 20:50:30 -0700360 }
361
Hiroshi Yamauchiab088112014-07-14 13:00:14 -0700362 mirror::ArtMethod* GetCalleeSaveMethod(CalleeSaveType type)
Ian Rogerse63db272014-07-15 15:36:11 -0700363 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Hiroshi Yamauchiab088112014-07-14 13:00:14 -0700364
365 mirror::ArtMethod* GetCalleeSaveMethodUnchecked(CalleeSaveType type)
Ian Rogerse63db272014-07-15 15:36:11 -0700366 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers9af209c2012-06-03 20:50:30 -0700367
Vladimir Marko7624d252014-05-02 14:40:15 +0100368 QuickMethodFrameInfo GetCalleeSaveMethodFrameInfo(CalleeSaveType type) const {
369 return callee_save_method_frame_infos_[type];
370 }
371
Hiroshi Yamauchiab088112014-07-14 13:00:14 -0700372 QuickMethodFrameInfo GetRuntimeMethodFrameInfo(mirror::ArtMethod* method)
373 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Vladimir Marko7624d252014-05-02 14:40:15 +0100374
Ian Rogers936b37f2014-02-14 00:52:24 -0800375 static size_t GetCalleeSaveMethodOffset(CalleeSaveType type) {
376 return OFFSETOF_MEMBER(Runtime, callee_save_methods_[type]);
377 }
378
Vladimir Marko7624d252014-05-02 14:40:15 +0100379 InstructionSet GetInstructionSet() const {
380 return instruction_set_;
381 }
382
383 void SetInstructionSet(InstructionSet instruction_set);
384
Brian Carlstromea46f952013-07-30 01:26:50 -0700385 void SetCalleeSaveMethod(mirror::ArtMethod* method, CalleeSaveType type);
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700386
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700387 mirror::ArtMethod* CreateCalleeSaveMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersff1ed472011-09-20 13:46:24 -0700388
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700389 int32_t GetStat(int kind);
390
Ian Rogers9af209c2012-06-03 20:50:30 -0700391 RuntimeStats* GetStats() {
392 return &stats_;
393 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700394
395 bool HasStatsEnabled() const {
396 return stats_enabled_;
397 }
398
399 void ResetStats(int kinds);
400
Mathieu Chartier9ef78b52014-09-25 17:03:12 -0700401 void SetStatsEnabled(bool new_state) LOCKS_EXCLUDED(Locks::instrument_entrypoints_lock_,
402 Locks::mutator_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700403
Andreas Gampe6be67ee2014-09-02 21:22:18 -0700404 enum class NativeBridgeAction { // private
405 kUnload,
406 kInitialize
407 };
Narayan Kamath3de95a72014-04-02 12:54:23 +0100408 void PreZygoteFork();
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700409 bool InitZygote();
jgu21a6da74e2014-09-10 06:57:17 -0400410 void DidForkFromZygote(JNIEnv* env, NativeBridgeAction action, const char* isa);
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700411
Ian Rogers9bc54402014-04-17 16:40:01 -0700412 const instrumentation::Instrumentation* GetInstrumentation() const {
413 return &instrumentation_;
414 }
415
Ian Rogers62d6c772013-02-27 08:32:07 -0800416 instrumentation::Instrumentation* GetInstrumentation() {
417 return &instrumentation_;
418 }
jeffhao2692b572011-12-16 15:42:28 -0800419
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800420 bool UseCompileTimeClassPath() const {
421 return use_compile_time_class_path_;
422 }
Ian Rogers9af209c2012-06-03 20:50:30 -0700423
Mathieu Chartiere6da9af2013-12-16 11:54:42 -0800424 void AddMethodVerifier(verifier::MethodVerifier* verifier) LOCKS_EXCLUDED(method_verifier_lock_);
425 void RemoveMethodVerifier(verifier::MethodVerifier* verifier)
426 LOCKS_EXCLUDED(method_verifier_lock_);
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800427
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700428 const std::vector<const DexFile*>& GetCompileTimeClassPath(jobject class_loader);
429 void SetCompileTimeClassPath(jobject class_loader, std::vector<const DexFile*>& class_path);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800430
Calin Juravlec1b643c2014-05-30 23:44:11 +0100431 void StartProfiler(const char* profile_output_filename);
Dave Allison39c3bfb2014-01-28 18:33:52 -0800432 void UpdateProfilerState(int state);
Dave Allison0aded082013-11-07 13:15:11 -0800433
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100434 // Transaction support.
Sebastien Hertzee1d79a2014-02-21 15:46:30 +0100435 bool IsActiveTransaction() const {
436 return preinitialization_transaction_ != nullptr;
437 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100438 void EnterTransactionMode(Transaction* transaction);
439 void ExitTransactionMode();
Fred Shih37f05ef2014-07-16 18:38:08 -0700440 void RecordWriteFieldBoolean(mirror::Object* obj, MemberOffset field_offset, uint8_t value,
441 bool is_volatile) const;
442 void RecordWriteFieldByte(mirror::Object* obj, MemberOffset field_offset, int8_t value,
443 bool is_volatile) const;
444 void RecordWriteFieldChar(mirror::Object* obj, MemberOffset field_offset, uint16_t value,
445 bool is_volatile) const;
446 void RecordWriteFieldShort(mirror::Object* obj, MemberOffset field_offset, int16_t value,
447 bool is_volatile) const;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100448 void RecordWriteField32(mirror::Object* obj, MemberOffset field_offset, uint32_t value,
449 bool is_volatile) const;
450 void RecordWriteField64(mirror::Object* obj, MemberOffset field_offset, uint64_t value,
451 bool is_volatile) const;
452 void RecordWriteFieldReference(mirror::Object* obj, MemberOffset field_offset,
453 mirror::Object* value, bool is_volatile) const;
454 void RecordWriteArray(mirror::Array* array, size_t index, uint64_t value) const
455 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -0700456 void RecordStrongStringInsertion(mirror::String* s) const
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100457 EXCLUSIVE_LOCKS_REQUIRED(Locks::intern_table_lock_);
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -0700458 void RecordWeakStringInsertion(mirror::String* s) const
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100459 EXCLUSIVE_LOCKS_REQUIRED(Locks::intern_table_lock_);
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -0700460 void RecordStrongStringRemoval(mirror::String* s) const
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100461 EXCLUSIVE_LOCKS_REQUIRED(Locks::intern_table_lock_);
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -0700462 void RecordWeakStringRemoval(mirror::String* s) const
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100463 EXCLUSIVE_LOCKS_REQUIRED(Locks::intern_table_lock_);
464
Mathieu Chartier15d34022014-02-26 17:16:38 -0800465 void SetFaultMessage(const std::string& message);
466 // Only read by the signal handler, NO_THREAD_SAFETY_ANALYSIS to prevent lock order violations
467 // with the unexpected_signal_lock_.
468 const std::string& GetFaultMessage() NO_THREAD_SAFETY_ANALYSIS {
469 return fault_message_;
470 }
471
Ian Rogers8afeb852014-04-02 14:55:49 -0700472 void AddCurrentRuntimeFeaturesAsDex2OatArguments(std::vector<std::string>* arg_vector) const;
473
Dave Allisonb373e092014-02-20 16:06:36 -0800474 bool ExplicitStackOverflowChecks() const {
Andreas Gampe928f72b2014-09-09 19:53:48 -0700475 return !implicit_so_checks_;
Dave Allisonb373e092014-02-20 16:06:36 -0800476 }
477
Jeff Hao4a200f52014-04-01 14:58:49 -0700478 bool IsVerificationEnabled() const {
479 return verify_;
480 }
481
Mathieu Chartierda44d772014-04-01 15:01:46 -0700482 bool RunningOnValgrind() const {
483 return running_on_valgrind_;
484 }
485
Jeff Haof00571c2014-05-29 17:29:47 -0700486 void SetTargetSdkVersion(int32_t version) {
487 target_sdk_version_ = version;
488 }
489
490 int32_t GetTargetSdkVersion() const {
491 return target_sdk_version_;
492 }
493
Carl Shapirob5573532011-07-12 18:22:59 -0700494 private:
Elliott Hughes457005c2012-04-16 13:54:25 -0700495 static void InitPlatformSignalHandlers();
Elliott Hughesffe67362011-07-17 12:09:27 -0700496
Elliott Hughesdcc24742011-09-07 14:02:44 -0700497 Runtime();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700498
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700499 void BlockSignals();
500
Ian Rogerse63db272014-07-15 15:36:11 -0700501 bool Init(const RuntimeOptions& options, bool ignore_unrecognized)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700502 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
503 void InitNativeMethods() LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers365c1022012-06-22 15:05:28 -0700504 void InitThreadGroups(Thread* self);
Elliott Hughesff17f1f2012-01-24 18:12:29 -0800505 void RegisterRuntimeNativeMethods(JNIEnv* env);
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700506
Elliott Hughes85d15452011-09-16 17:33:01 -0700507 void StartDaemonThreads();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700508 void StartSignalCatcher();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700509
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800510 // A pointer to the active runtime or NULL.
511 static Runtime* instance_;
512
Ian Rogers8afeb852014-04-02 14:55:49 -0700513 // NOTE: these must match the gc::ProcessState values as they come directly from the framework.
514 static constexpr int kProfileForground = 0;
515 static constexpr int kProfileBackgrouud = 1;
516
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700517 GcRoot<mirror::ArtMethod> callee_save_methods_[kLastCalleeSaveType];
518 GcRoot<mirror::Throwable> pre_allocated_OutOfMemoryError_;
Ian Rogers63557452014-06-04 16:57:15 -0700519 GcRoot<mirror::Throwable> pre_allocated_NoClassDefFoundError_;
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700520 GcRoot<mirror::ArtMethod> resolution_method_;
521 GcRoot<mirror::ArtMethod> imt_conflict_method_;
Mathieu Chartier2d2621a2014-10-23 16:48:06 -0700522 // Unresolved method has the same behavior as the conflict method, it is used by the class linker
523 // for differentiating between unfilled imt slots vs conflict slots in superclasses.
524 GcRoot<mirror::ArtMethod> imt_unimplemented_method_;
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -0700525 GcRoot<mirror::ObjectArray<mirror::ArtMethod>> default_imt_;
Ian Rogers6ed19fd2014-03-20 08:10:17 -0700526
Ian Rogersc0542af2014-09-03 16:16:56 -0700527 // Special sentinel object used to invalid conditions in JNI (cleared weak references) and
528 // JDWP (invalid references).
529 GcRoot<mirror::Object> sentinel_;
530
Vladimir Marko7624d252014-05-02 14:40:15 +0100531 InstructionSet instruction_set_;
532 QuickMethodFrameInfo callee_save_method_frame_infos_[kLastCalleeSaveType];
533
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000534 CompilerCallbacks* compiler_callbacks_;
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700535 bool is_zygote_;
Alex Lighta59dd802014-07-02 16:28:08 -0700536 bool must_relocate_;
Mathieu Chartier069387a2012-06-18 12:01:01 -0700537 bool is_concurrent_gc_enabled_;
Anwar Ghuloum87183592013-08-14 12:12:19 -0700538 bool is_explicit_gc_disabled_;
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100539 bool dex2oat_enabled_;
Alex Light64ad14d2014-08-19 14:23:13 -0700540 bool image_dex2oat_enabled_;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700541
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700542 std::string compiler_executable_;
Alex Lighta59dd802014-07-02 16:28:08 -0700543 std::string patchoat_executable_;
Brian Carlstrom6449c622014-02-10 23:48:36 -0800544 std::vector<std::string> compiler_options_;
545 std::vector<std::string> image_compiler_options_;
Brian Carlstrom31d8f522014-09-29 11:22:54 -0700546 std::string image_location_;
Dragos Sbirlea7467ee02013-06-21 09:20:34 -0700547
Brian Carlstroma004aa92012-02-08 18:05:09 -0800548 std::string boot_class_path_string_;
549 std::string class_path_string_;
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700550 std::vector<std::string> properties_;
551
Brian Carlstromb765be02011-08-17 23:54:10 -0700552 // The default stack size for managed threads created by the runtime.
Elliott Hughesbe759c62011-09-08 19:38:21 -0700553 size_t default_stack_size_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700554
Ian Rogers1d54e732013-05-02 21:10:01 -0700555 gc::Heap* heap_;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800556
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700557 // The number of spins that are done before thread suspension is used to forcibly inflate.
558 size_t max_spins_before_thin_lock_inflation_;
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700559 MonitorList* monitor_list_;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800560 MonitorPool* monitor_pool_;
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700561
Carl Shapirob5573532011-07-12 18:22:59 -0700562 ThreadList* thread_list_;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700563
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700564 InternTable* intern_table_;
565
Brian Carlstromb0460ea2011-07-29 10:08:05 -0700566 ClassLinker* class_linker_;
567
Elliott Hughese27955c2011-08-26 15:21:24 -0700568 SignalCatcher* signal_catcher_;
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700569 std::string stack_trace_file_;
Elliott Hughese27955c2011-08-26 15:21:24 -0700570
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700571 JavaVMExt* java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700572
Mathieu Chartier15d34022014-02-26 17:16:38 -0800573 // Fault message, printed when we get a SIGSEGV.
574 Mutex fault_message_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
575 std::string fault_message_ GUARDED_BY(fault_message_lock_);
576
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800577 // Method verifier set, used so that we can update their GC roots.
Ian Rogers719d1a32014-03-06 12:13:39 -0800578 Mutex method_verifier_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800579 std::set<verifier::MethodVerifier*> method_verifiers_;
580
Ian Rogers120f1c72012-09-28 17:17:10 -0700581 // A non-zero value indicates that a thread has been created but not yet initialized. Guarded by
582 // the shutdown lock so that threads aren't born while we're shutting down.
583 size_t threads_being_born_ GUARDED_BY(Locks::runtime_shutdown_lock_);
584
585 // Waited upon until no threads are being born.
Ian Rogers700a4022014-05-19 16:49:03 -0700586 std::unique_ptr<ConditionVariable> shutdown_cond_ GUARDED_BY(Locks::runtime_shutdown_lock_);
Ian Rogers120f1c72012-09-28 17:17:10 -0700587
588 // Set when runtime shutdown is past the point that new threads may attach.
589 bool shutting_down_ GUARDED_BY(Locks::runtime_shutdown_lock_);
590
591 // The runtime is starting to shutdown but is blocked waiting on shutdown_cond_.
592 bool shutting_down_started_ GUARDED_BY(Locks::runtime_shutdown_lock_);
593
Elliott Hughesdcc24742011-09-07 14:02:44 -0700594 bool started_;
595
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700596 // New flag added which tells us if the runtime has finished starting. If
597 // this flag is set then the Daemon threads are created and the class loader
598 // is created. This flag is needed for knowing if its safe to request CMS.
599 bool finished_starting_;
600
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700601 // Hooks supported by JNI_CreateJavaVM
602 jint (*vfprintf_)(FILE* stream, const char* format, va_list ap);
603 void (*exit_)(jint status);
604 void (*abort_)();
605
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700606 bool stats_enabled_;
607 RuntimeStats stats_;
608
Mathieu Chartierda44d772014-04-01 15:01:46 -0700609 const bool running_on_valgrind_;
610
Dave Allison0aded082013-11-07 13:15:11 -0800611 std::string profile_output_filename_;
Calin Juravlec1b643c2014-05-30 23:44:11 +0100612 ProfilerOptions profiler_options_;
613 bool profiler_started_;
Dave Allison0aded082013-11-07 13:15:11 -0800614
jeffhaob5e81852012-03-12 11:15:45 -0700615 bool method_trace_;
616 std::string method_trace_file_;
617 size_t method_trace_file_size_;
Ian Rogers62d6c772013-02-27 08:32:07 -0800618 instrumentation::Instrumentation instrumentation_;
jeffhao2692b572011-12-16 15:42:28 -0800619
Mathieu Chartierbad02672014-08-25 13:08:22 -0700620 typedef AllocationTrackingSafeMap<jobject, std::vector<const DexFile*>,
621 kAllocatorTagCompileTimeClassPath, JobjectComparator>
622 CompileTimeClassPaths;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800623 CompileTimeClassPaths compile_time_class_paths_;
624 bool use_compile_time_class_path_;
Elliott Hughes131aef82012-01-27 11:53:35 -0800625
Ian Rogers365c1022012-06-22 15:05:28 -0700626 jobject main_thread_group_;
627 jobject system_thread_group_;
628
Brian Carlstromce888532013-10-10 00:32:58 -0700629 // As returned by ClassLoader.getSystemClassLoader().
630 jobject system_class_loader_;
631
Hiroshi Yamauchi2e899a92013-11-22 16:50:12 -0800632 // If true, then we dump the GC cumulative timings on shutdown.
633 bool dump_gc_performance_on_shutdown_;
634
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100635 // Transaction used for pre-initializing classes at compilation time.
Sebastien Hertzee1d79a2014-02-21 15:46:30 +0100636 Transaction* preinitialization_transaction_;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100637
Jeff Hao4a200f52014-04-01 14:58:49 -0700638 // If false, verification is disabled. True by default.
639 bool verify_;
640
Jeff Haof00571c2014-05-29 17:29:47 -0700641 // Specifies target SDK version to allow workarounds for certain API levels.
642 int32_t target_sdk_version_;
643
Dave Allison69dfe512014-07-11 17:11:58 +0000644 // Implicit checks flags.
645 bool implicit_null_checks_; // NullPointer checks are implicit.
646 bool implicit_so_checks_; // StackOverflow checks are implicit.
647 bool implicit_suspend_checks_; // Thread suspension checks are implicit.
648
Calin Juravle07d83c72014-10-22 21:02:23 +0100649 // Whether or not a native bridge has been loaded.
Calin Juravlec8423522014-08-12 20:55:20 +0100650 //
651 // The native bridge allows running native code compiled for a foreign ISA. The way it works is,
652 // if standard dlopen fails to load native library associated with native activity, it calls to
653 // the native bridge to load it and then gets the trampoline for the entry to native activity.
Calin Juravle07d83c72014-10-22 21:02:23 +0100654 //
655 // The option 'native_bridge_library_filename' specifies the name of the native bridge.
656 // When non-empty the native bridge will be loaded from the given file. An empty value means
657 // that there's no native bridge.
658 bool is_native_bridge_loaded_;
Calin Juravlec8423522014-08-12 20:55:20 +0100659
Carl Shapiro61e019d2011-07-14 16:53:09 -0700660 DISALLOW_COPY_AND_ASSIGN(Runtime);
Carl Shapiro1fb86202011-06-27 17:43:13 -0700661};
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700662std::ostream& operator<<(std::ostream& os, const Runtime::CalleeSaveType& rhs);
Carl Shapiro1fb86202011-06-27 17:43:13 -0700663
664} // namespace art
665
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700666#endif // ART_RUNTIME_RUNTIME_H_