blob: d2238aeefa2474731c27ed0de13e1de88c7fcd7c [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
17#ifndef ART_SRC_RUNTIME_H_
18#define ART_SRC_RUNTIME_H_
19
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>
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070024#include <string>
Carl Shapirofc322c72011-07-27 00:20:01 -070025#include <utility>
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070026#include <vector>
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070027
Elliott Hughesa0e18062012-04-13 15:59:59 -070028#include "globals.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070029#include "heap.h"
Elliott Hughes0f3c5532012-03-30 14:51:51 -070030#include "instruction_set.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070031#include "jobject_comparator.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070032#include "macros.h"
Ian Rogers120f1c72012-09-28 17:17:10 -070033#include "locks.h"
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070034#include "runtime_stats.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070035#include "safe_map.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070036#include "stringpiece.h"
Carl Shapirob5573532011-07-12 18:22:59 -070037
Logan Chien971bf3f2012-05-01 15:47:55 +080038#if defined(ART_USE_LLVM_COMPILER)
39#include "compiler_llvm/procedure_linkage_table.h"
40#endif
41
Carl Shapiro1fb86202011-06-27 17:43:13 -070042namespace art {
43
Brian Carlstrom16192862011-09-12 17:50:06 -070044template<class T> class PrimitiveArray;
45typedef PrimitiveArray<int8_t> ByteArray;
Carl Shapiro61e019d2011-07-14 16:53:09 -070046class ClassLinker;
Brian Carlstromaded5f72011-10-07 17:15:04 -070047class ClassLoader;
Carl Shapirofc322c72011-07-27 00:20:01 -070048class DexFile;
Carl Shapiro61e019d2011-07-14 16:53:09 -070049class Heap;
jeffhao725a9572012-11-13 18:20:12 -080050class Instrumentation;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070051class InternTable;
Ian Rogers1b09b092012-08-20 15:35:52 -070052struct JavaVMExt;
Mathieu Chartier66f19252012-09-18 08:57:04 -070053class AbstractMethod;
Elliott Hughesc33a32b2011-10-11 18:18:07 -070054class MonitorList;
Elliott Hughese27955c2011-08-26 15:21:24 -070055class SignalCatcher;
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070056class String;
Carl Shapiro61e019d2011-07-14 16:53:09 -070057class ThreadList;
Elliott Hughes225f5a12012-06-11 11:23:48 -070058class Throwable;
jeffhao2692b572011-12-16 15:42:28 -080059class Trace;
Carl Shapiro61e019d2011-07-14 16:53:09 -070060
Carl Shapiro1fb86202011-06-27 17:43:13 -070061class Runtime {
62 public:
Elliott Hughesf1a5adc2012-02-10 18:09:35 -080063 typedef std::vector<std::pair<std::string, const void*> > Options;
Brian Carlstrom8a436592011-08-15 21:27:23 -070064
65 class ParsedOptions {
66 public:
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070067 // returns null if problem parsing and ignore_unrecognized is false
68 static ParsedOptions* Create(const Options& options, bool ignore_unrecognized);
Brian Carlstrom8a436592011-08-15 21:27:23 -070069
Brian Carlstroma004aa92012-02-08 18:05:09 -080070 const std::vector<const DexFile*>* boot_class_path_;
71 std::string boot_class_path_string_;
72 std::string class_path_string_;
Brian Carlstrom58ae9412011-10-04 00:56:06 -070073 std::string host_prefix_;
Brian Carlstrom223f20f2012-02-04 23:06:55 -080074 std::string image_;
Elliott Hughes515a5bc2011-08-17 11:08:34 -070075 bool check_jni_;
Elliott Hughesa0957642011-09-02 14:27:33 -070076 std::string jni_trace_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -080077 bool is_compiler_;
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -070078 bool is_zygote_;
Mathieu Chartier069387a2012-06-18 12:01:01 -070079 bool is_concurrent_gc_enabled_;
Brian Carlstrom8a436592011-08-15 21:27:23 -070080 size_t heap_initial_size_;
81 size_t heap_maximum_size_;
jeffhaoc1160702011-10-27 15:48:45 -070082 size_t heap_growth_limit_;
Mathieu Chartier0051be62012-10-12 17:47:11 -070083 size_t heap_min_free_;
84 size_t heap_max_free_;
85 double heap_target_utilization_;
Brian Carlstromf734cf52011-08-17 16:28:14 -070086 size_t stack_size_;
Elliott Hughesbb1e8f02011-10-18 14:14:25 -070087 size_t jni_globals_max_;
88 size_t lock_profiling_threshold_;
Elliott Hughes94ce37a2011-10-18 15:07:48 -070089 std::string stack_trace_file_;
jeffhaob5e81852012-03-12 11:15:45 -070090 bool method_trace_;
91 std::string method_trace_file_;
92 size_t method_trace_file_size_;
Elliott Hughesfc861622011-10-17 17:57:47 -070093 bool (*hook_is_sensitive_thread_)();
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070094 jint (*hook_vfprintf_)(FILE* stream, const char* format, va_list ap);
95 void (*hook_exit_)(jint status);
96 void (*hook_abort_)();
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070097 std::vector<std::string> properties_;
98
99 private:
Ian Rogers0cfe1fb2011-08-26 03:29:44 -0700100 ParsedOptions() {}
Brian Carlstrom8a436592011-08-15 21:27:23 -0700101 };
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700102
Carl Shapiro61e019d2011-07-14 16:53:09 -0700103 // Creates and initializes a new runtime.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700104 static bool Create(const Options& options, bool ignore_unrecognized)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700105 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700106
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800107 bool IsCompiler() const {
108 return is_compiler_;
109 }
110
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700111 bool IsZygote() const {
112 return is_zygote_;
113 }
114
Mathieu Chartier069387a2012-06-18 12:01:01 -0700115 bool IsConcurrentGcEnabled() const {
116 return is_concurrent_gc_enabled_;
117 }
118
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700119 const std::string& GetHostPrefix() const {
Elliott Hughes307f75d2011-10-12 18:04:40 -0700120 DCHECK(!IsStarted());
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700121 return host_prefix_;
122 }
123
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700124 // Starts a runtime, which may cause threads to be started and code to run.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700125 void Start() UNLOCK_FUNCTION(Locks::mutator_lock_);
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700126
Ian Rogers120f1c72012-09-28 17:17:10 -0700127 bool IsShuttingDown() const EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
Ian Rogers9af209c2012-06-03 20:50:30 -0700128 return shutting_down_;
129 }
130
Ian Rogers120f1c72012-09-28 17:17:10 -0700131 size_t NumberOfThreadsBeingBorn() const EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
132 return threads_being_born_;
133 }
134
135 void StartThreadBirth() EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_) {
136 threads_being_born_++;
137 }
138
139 void EndThreadBirth() EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_);
140
Ian Rogers9af209c2012-06-03 20:50:30 -0700141 bool IsStarted() const {
142 return started_;
143 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700144
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700145 bool IsFinishedStarting() const {
146 return finished_starting_;
147 }
148
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700149 static Runtime* Current() {
150 return instance_;
151 }
Carl Shapiro1fb86202011-06-27 17:43:13 -0700152
Elliott Hughesffe67362011-07-17 12:09:27 -0700153 // Aborts semi-cleanly. Used in the implementation of LOG(FATAL), which most
154 // callers should prefer.
155 // This isn't marked ((noreturn)) because then gcc will merge multiple calls
156 // in a single function together. This reduces code size slightly, but means
157 // that the native stack trace we get may point at the wrong call site.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700158 static void Abort() LOCKS_EXCLUDED(Locks::abort_lock_);
Elliott Hughesffe67362011-07-17 12:09:27 -0700159
Ian Rogers365c1022012-06-22 15:05:28 -0700160 // Returns the "main" ThreadGroup, used when attaching user threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700161 jobject GetMainThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700162
163 // Returns the "system" ThreadGroup, used when attaching our internal threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700164 jobject GetSystemThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700165
Elliott Hughes462c9442012-03-23 18:47:50 -0700166 // Attaches the calling native thread to the runtime.
Mathieu Chartier664bebf2012-11-12 16:54:11 -0800167 bool AttachCurrentThread(const char* thread_name, bool as_daemon, jobject thread_group,
168 bool create_peer);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700169
Elliott Hughesbf86d042011-08-31 17:53:14 -0700170 void CallExitHook(jint status);
171
Carl Shapiro61e019d2011-07-14 16:53:09 -0700172 // Detaches the current native thread from the runtime.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700173 void DetachCurrentThread() LOCKS_EXCLUDED(Locks::mutator_lock_);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700174
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700175 void DumpForSigQuit(std::ostream& os)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700176 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800177 void DumpLockHolders(std::ostream& os);
Elliott Hughese27955c2011-08-26 15:21:24 -0700178
Carl Shapiro61e019d2011-07-14 16:53:09 -0700179 ~Runtime();
Carl Shapirob5573532011-07-12 18:22:59 -0700180
Brian Carlstroma004aa92012-02-08 18:05:09 -0800181 const std::string& GetBootClassPathString() const {
182 return boot_class_path_string_;
183 }
184
185 const std::string& GetClassPathString() const {
186 return class_path_string_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700187 }
188
189 ClassLinker* GetClassLinker() const {
Carl Shapiro7a909592011-07-24 19:21:59 -0700190 return class_linker_;
191 }
192
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700193 size_t GetDefaultStackSize() const {
194 return default_stack_size_;
195 }
196
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800197 Heap* GetHeap() const {
198 return heap_;
199 }
200
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700201 InternTable* GetInternTable() const {
202 return intern_table_;
203 }
204
Elliott Hughes0af55432011-08-17 18:37:28 -0700205 JavaVMExt* GetJavaVM() const {
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700206 return java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700207 }
208
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700209 MonitorList* GetMonitorList() const {
210 return monitor_list_;
211 }
212
Elliott Hughes225f5a12012-06-11 11:23:48 -0700213 Throwable* GetPreAllocatedOutOfMemoryError() {
214 return pre_allocated_OutOfMemoryError_;
215 }
216
217 const std::vector<std::string>& GetProperties() const {
218 return properties_;
219 }
220
Elliott Hughesd92bec42011-09-02 17:04:36 -0700221 ThreadList* GetThreadList() const {
222 return thread_list_;
223 }
224
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700225 const char* GetVersion() const {
226 return "2.0.0";
227 }
228
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700229 // Force all the roots which can be marked concurrently to be dirty.
230 void DirtyRoots();
231
232 // Visit all the roots.
233 void VisitRoots(Heap::RootVisitor* visitor, void* arg)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700234 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom1f870082011-08-23 16:02:11 -0700235
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700236 // Visit all of the roots we can do safely do concurrently.
237 void VisitConcurrentRoots(Heap::RootVisitor* visitor, void* arg);
238
Mathieu Chartier858f1c52012-10-17 17:45:55 -0700239 // Visit all of the non thread roots, we can do this with mutators unpaused.
240 void VisitNonThreadRoots(Heap::RootVisitor* visitor, void* arg);
241
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -0700242 // Visit all other roots which must be done with mutators suspended.
243 void VisitNonConcurrentRoots(Heap::RootVisitor* visitor, void* arg)
244 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
245
Ian Rogers9af209c2012-06-03 20:50:30 -0700246 bool HasJniDlsymLookupStub() const {
247 return jni_stub_array_ != NULL;
248 }
249
250 ByteArray* GetJniDlsymLookupStub() const {
251 CHECK(HasJniDlsymLookupStub());
252 return jni_stub_array_;
253 }
254
Ian Rogers169c9a72011-11-13 20:13:17 -0800255 void SetJniDlsymLookupStub(ByteArray* jni_stub_array);
Brian Carlstrom16192862011-09-12 17:50:06 -0700256
Ian Rogers9af209c2012-06-03 20:50:30 -0700257 bool HasAbstractMethodErrorStubArray() const {
258 return abstract_method_error_stub_array_ != NULL;
259 }
260
261 ByteArray* GetAbstractMethodErrorStubArray() const {
262 CHECK(abstract_method_error_stub_array_ != NULL);
263 return abstract_method_error_stub_array_;
264 }
265
Brian Carlstrome24fa612011-09-29 00:53:55 -0700266 void SetAbstractMethodErrorStubArray(ByteArray* abstract_method_error_stub_array);
Ian Rogersff1ed472011-09-20 13:46:24 -0700267
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700268 enum TrampolineType {
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700269 kStaticMethod,
270 kUnknownMethod,
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700271 kLastTrampolineMethodType // Value used for iteration
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700272 };
Ian Rogers9af209c2012-06-03 20:50:30 -0700273
274 bool HasResolutionStubArray(TrampolineType type) const {
275 return resolution_stub_array_[type] != NULL;
276 }
277
278 ByteArray* GetResolutionStubArray(TrampolineType type) const {
279 CHECK(HasResolutionStubArray(type));
280 DCHECK_LT(static_cast<int>(type), static_cast<int>(kLastTrampolineMethodType));
281 return resolution_stub_array_[type];
282 }
283
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700284 void SetResolutionStubArray(ByteArray* resolution_stub_array, TrampolineType type);
Ian Rogersad25ac52011-10-04 19:13:33 -0700285
Ian Rogers9af209c2012-06-03 20:50:30 -0700286 // Returns a special method that calls into a trampoline for runtime method resolution
Mathieu Chartier66f19252012-09-18 08:57:04 -0700287 AbstractMethod* GetResolutionMethod() const {
Ian Rogers9af209c2012-06-03 20:50:30 -0700288 CHECK(HasResolutionMethod());
289 return resolution_method_;
290 }
291
292 bool HasResolutionMethod() const {
293 return resolution_method_ != NULL;
294 }
295
Mathieu Chartier66f19252012-09-18 08:57:04 -0700296 void SetResolutionMethod(AbstractMethod* method) {
Ian Rogers9af209c2012-06-03 20:50:30 -0700297 resolution_method_ = method;
298 }
299
Mathieu Chartier66f19252012-09-18 08:57:04 -0700300 AbstractMethod* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers19846512012-02-24 11:42:47 -0800301
Ian Rogersff1ed472011-09-20 13:46:24 -0700302 // Returns a special method that describes all callee saves being spilled to the stack.
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700303 enum CalleeSaveType {
304 kSaveAll,
305 kRefsOnly,
306 kRefsAndArgs,
307 kLastCalleeSaveType // Value used for iteration
308 };
Ian Rogers9af209c2012-06-03 20:50:30 -0700309
310 bool HasCalleeSaveMethod(CalleeSaveType type) const {
Elliott Hughes225f5a12012-06-11 11:23:48 -0700311 return callee_save_methods_[type] != NULL;
Ian Rogers9af209c2012-06-03 20:50:30 -0700312 }
313
Mathieu Chartier66f19252012-09-18 08:57:04 -0700314 AbstractMethod* GetCalleeSaveMethod(CalleeSaveType type) const {
Ian Rogers9af209c2012-06-03 20:50:30 -0700315 CHECK(HasCalleeSaveMethod(type));
Elliott Hughes225f5a12012-06-11 11:23:48 -0700316 return callee_save_methods_[type];
Ian Rogers9af209c2012-06-03 20:50:30 -0700317 }
318
Mathieu Chartier66f19252012-09-18 08:57:04 -0700319 void SetCalleeSaveMethod(AbstractMethod* method, CalleeSaveType type);
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700320
Mathieu Chartier66f19252012-09-18 08:57:04 -0700321 AbstractMethod* CreateCalleeSaveMethod(InstructionSet instruction_set, CalleeSaveType type)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700322 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers9af209c2012-06-03 20:50:30 -0700323
Mathieu Chartier66f19252012-09-18 08:57:04 -0700324 AbstractMethod* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700325 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700326
Mathieu Chartier66f19252012-09-18 08:57:04 -0700327 AbstractMethod* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700328 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersff1ed472011-09-20 13:46:24 -0700329
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700330 int32_t GetStat(int kind);
331
Ian Rogers9af209c2012-06-03 20:50:30 -0700332 RuntimeStats* GetStats() {
333 return &stats_;
334 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700335
336 bool HasStatsEnabled() const {
337 return stats_enabled_;
338 }
339
340 void ResetStats(int kinds);
341
342 void SetStatsEnabled(bool new_state);
343
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700344 void DidForkFromZygote();
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700345 bool PreZygoteFork();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700346
jeffhao725a9572012-11-13 18:20:12 -0800347 void EnableMethodTracing(Trace* trace);
jeffhao2692b572011-12-16 15:42:28 -0800348 void DisableMethodTracing();
jeffhao725a9572012-11-13 18:20:12 -0800349 bool IsMethodTracingActive() const;
350 Instrumentation* GetInstrumentation() const;
jeffhao2692b572011-12-16 15:42:28 -0800351
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800352 bool UseCompileTimeClassPath() const {
353 return use_compile_time_class_path_;
354 }
Ian Rogers9af209c2012-06-03 20:50:30 -0700355
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700356 const std::vector<const DexFile*>& GetCompileTimeClassPath(jobject class_loader);
357 void SetCompileTimeClassPath(jobject class_loader, std::vector<const DexFile*>& class_path);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800358
Carl Shapirob5573532011-07-12 18:22:59 -0700359 private:
Elliott Hughes457005c2012-04-16 13:54:25 -0700360 static void InitPlatformSignalHandlers();
Elliott Hughesffe67362011-07-17 12:09:27 -0700361
Elliott Hughesdcc24742011-09-07 14:02:44 -0700362 Runtime();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700363
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700364 void BlockSignals();
365
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700366 bool Init(const Options& options, bool ignore_unrecognized)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700367 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_);
368 void InitNativeMethods() LOCKS_EXCLUDED(Locks::mutator_lock_);
Ian Rogers365c1022012-06-22 15:05:28 -0700369 void InitThreadGroups(Thread* self);
Elliott Hughesff17f1f2012-01-24 18:12:29 -0800370 void RegisterRuntimeNativeMethods(JNIEnv* env);
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700371
Elliott Hughes85d15452011-09-16 17:33:01 -0700372 void StartDaemonThreads();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700373 void StartSignalCatcher();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700374
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800375 // A pointer to the active runtime or NULL.
376 static Runtime* instance_;
377
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800378 bool is_compiler_;
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700379 bool is_zygote_;
Mathieu Chartier069387a2012-06-18 12:01:01 -0700380 bool is_concurrent_gc_enabled_;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700381
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700382 // The host prefix is used during cross compilation. It is removed
383 // from the start of host paths such as:
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800384 // $ANDROID_PRODUCT_OUT/system/framework/boot.oat
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700385 // to produce target paths such as
Brian Carlstrom47a0d5a2011-10-12 21:20:05 -0700386 // /system/framework/boot.oat
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700387 // Similarly it is prepended to target paths to arrive back at a
388 // host past. In both cases this is necessary because image and oat
389 // files embedded expect paths of dependent files (an image points
390 // to an oat file and an oat files to one or more dex files). These
391 // files contain the expected target path.
392 std::string host_prefix_;
393
Brian Carlstroma004aa92012-02-08 18:05:09 -0800394 std::string boot_class_path_string_;
395 std::string class_path_string_;
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700396 std::vector<std::string> properties_;
397
Brian Carlstromb765be02011-08-17 23:54:10 -0700398 // The default stack size for managed threads created by the runtime.
Elliott Hughesbe759c62011-09-08 19:38:21 -0700399 size_t default_stack_size_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700400
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800401 Heap* heap_;
402
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700403 MonitorList* monitor_list_;
404
Carl Shapirob5573532011-07-12 18:22:59 -0700405 ThreadList* thread_list_;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700406
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700407 InternTable* intern_table_;
408
Brian Carlstromb0460ea2011-07-29 10:08:05 -0700409 ClassLinker* class_linker_;
410
Elliott Hughese27955c2011-08-26 15:21:24 -0700411 SignalCatcher* signal_catcher_;
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700412 std::string stack_trace_file_;
Elliott Hughese27955c2011-08-26 15:21:24 -0700413
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700414 JavaVMExt* java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700415
Elliott Hughes225f5a12012-06-11 11:23:48 -0700416 Throwable* pre_allocated_OutOfMemoryError_;
417
Brian Carlstrom16192862011-09-12 17:50:06 -0700418 ByteArray* jni_stub_array_;
419
Brian Carlstrome24fa612011-09-29 00:53:55 -0700420 ByteArray* abstract_method_error_stub_array_;
421
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700422 ByteArray* resolution_stub_array_[kLastTrampolineMethodType];
Ian Rogersad25ac52011-10-04 19:13:33 -0700423
Mathieu Chartier66f19252012-09-18 08:57:04 -0700424 AbstractMethod* callee_save_methods_[kLastCalleeSaveType];
Ian Rogersff1ed472011-09-20 13:46:24 -0700425
Mathieu Chartier66f19252012-09-18 08:57:04 -0700426 AbstractMethod* resolution_method_;
Ian Rogers19846512012-02-24 11:42:47 -0800427
Brian Carlstromaded5f72011-10-07 17:15:04 -0700428 // As returned by ClassLoader.getSystemClassLoader()
429 ClassLoader* system_class_loader_;
430
Ian Rogers120f1c72012-09-28 17:17:10 -0700431 // A non-zero value indicates that a thread has been created but not yet initialized. Guarded by
432 // the shutdown lock so that threads aren't born while we're shutting down.
433 size_t threads_being_born_ GUARDED_BY(Locks::runtime_shutdown_lock_);
434
435 // Waited upon until no threads are being born.
436 UniquePtr<ConditionVariable> shutdown_cond_ GUARDED_BY(Locks::runtime_shutdown_lock_);
437
438 // Set when runtime shutdown is past the point that new threads may attach.
439 bool shutting_down_ GUARDED_BY(Locks::runtime_shutdown_lock_);
440
441 // The runtime is starting to shutdown but is blocked waiting on shutdown_cond_.
442 bool shutting_down_started_ GUARDED_BY(Locks::runtime_shutdown_lock_);
443
Elliott Hughesdcc24742011-09-07 14:02:44 -0700444 bool started_;
445
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700446 // New flag added which tells us if the runtime has finished starting. If
447 // this flag is set then the Daemon threads are created and the class loader
448 // is created. This flag is needed for knowing if its safe to request CMS.
449 bool finished_starting_;
450
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700451 // Hooks supported by JNI_CreateJavaVM
452 jint (*vfprintf_)(FILE* stream, const char* format, va_list ap);
453 void (*exit_)(jint status);
454 void (*abort_)();
455
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700456 bool stats_enabled_;
457 RuntimeStats stats_;
458
jeffhaob5e81852012-03-12 11:15:45 -0700459 bool method_trace_;
460 std::string method_trace_file_;
461 size_t method_trace_file_size_;
jeffhao725a9572012-11-13 18:20:12 -0800462 Instrumentation* instrumentation_;
jeffhao2692b572011-12-16 15:42:28 -0800463
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700464 typedef SafeMap<jobject, std::vector<const DexFile*>, JobjectComparator> CompileTimeClassPaths;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800465 CompileTimeClassPaths compile_time_class_paths_;
466 bool use_compile_time_class_path_;
Elliott Hughes131aef82012-01-27 11:53:35 -0800467
Ian Rogers365c1022012-06-22 15:05:28 -0700468 jobject main_thread_group_;
469 jobject system_thread_group_;
Logan Chien971bf3f2012-05-01 15:47:55 +0800470#if defined(ART_USE_LLVM_COMPILER)
471 compiler_llvm::ProcedureLinkageTable plt_;
472#endif
Ian Rogers365c1022012-06-22 15:05:28 -0700473
Carl Shapiro61e019d2011-07-14 16:53:09 -0700474 DISALLOW_COPY_AND_ASSIGN(Runtime);
Carl Shapiro1fb86202011-06-27 17:43:13 -0700475};
476
477} // namespace art
478
Carl Shapiro1fb86202011-06-27 17:43:13 -0700479#endif // ART_SRC_RUNTIME_H_