blob: 544dcf417306601108b26edb6ede2394ec53c72a [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"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070031#include "macros.h"
Elliott Hughes9d5ccec2011-09-19 13:19:50 -070032#include "runtime_stats.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070033#include "safe_map.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070034#include "stringpiece.h"
Carl Shapirob5573532011-07-12 18:22:59 -070035
Logan Chien971bf3f2012-05-01 15:47:55 +080036#if defined(ART_USE_LLVM_COMPILER)
37#include "compiler_llvm/procedure_linkage_table.h"
38#endif
39
Carl Shapiro1fb86202011-06-27 17:43:13 -070040namespace art {
41
Brian Carlstrom16192862011-09-12 17:50:06 -070042template<class T> class PrimitiveArray;
43typedef PrimitiveArray<int8_t> ByteArray;
Carl Shapiro61e019d2011-07-14 16:53:09 -070044class ClassLinker;
Brian Carlstromaded5f72011-10-07 17:15:04 -070045class ClassLoader;
Carl Shapirofc322c72011-07-27 00:20:01 -070046class DexFile;
Carl Shapiro61e019d2011-07-14 16:53:09 -070047class Heap;
Elliott Hughescf4c6c42011-09-01 15:16:42 -070048class InternTable;
Elliott Hughesc5f7c912011-08-18 14:00:42 -070049class JavaVMExt;
Ian Rogersff1ed472011-09-20 13:46:24 -070050class Method;
Elliott Hughesc33a32b2011-10-11 18:18:07 -070051class MonitorList;
Elliott Hughese27955c2011-08-26 15:21:24 -070052class SignalCatcher;
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070053class String;
Carl Shapiro61e019d2011-07-14 16:53:09 -070054class ThreadList;
Elliott Hughes225f5a12012-06-11 11:23:48 -070055class Throwable;
jeffhao2692b572011-12-16 15:42:28 -080056class Trace;
Carl Shapiro61e019d2011-07-14 16:53:09 -070057
Carl Shapiro1fb86202011-06-27 17:43:13 -070058class Runtime {
59 public:
Elliott Hughesf1a5adc2012-02-10 18:09:35 -080060 typedef std::vector<std::pair<std::string, const void*> > Options;
Brian Carlstrom8a436592011-08-15 21:27:23 -070061
62 class ParsedOptions {
63 public:
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070064 // returns null if problem parsing and ignore_unrecognized is false
65 static ParsedOptions* Create(const Options& options, bool ignore_unrecognized);
Brian Carlstrom8a436592011-08-15 21:27:23 -070066
Brian Carlstroma004aa92012-02-08 18:05:09 -080067 const std::vector<const DexFile*>* boot_class_path_;
68 std::string boot_class_path_string_;
69 std::string class_path_string_;
Brian Carlstrom58ae9412011-10-04 00:56:06 -070070 std::string host_prefix_;
Brian Carlstrom223f20f2012-02-04 23:06:55 -080071 std::string image_;
Elliott Hughes515a5bc2011-08-17 11:08:34 -070072 bool check_jni_;
Elliott Hughesa0957642011-09-02 14:27:33 -070073 std::string jni_trace_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -080074 bool is_compiler_;
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -070075 bool is_zygote_;
Mathieu Chartier069387a2012-06-18 12:01:01 -070076 bool is_concurrent_gc_enabled_;
Brian Carlstrom8a436592011-08-15 21:27:23 -070077 size_t heap_initial_size_;
78 size_t heap_maximum_size_;
jeffhaoc1160702011-10-27 15:48:45 -070079 size_t heap_growth_limit_;
Brian Carlstromf734cf52011-08-17 16:28:14 -070080 size_t stack_size_;
Elliott Hughesbb1e8f02011-10-18 14:14:25 -070081 size_t jni_globals_max_;
82 size_t lock_profiling_threshold_;
Elliott Hughes94ce37a2011-10-18 15:07:48 -070083 std::string stack_trace_file_;
jeffhaob5e81852012-03-12 11:15:45 -070084 bool method_trace_;
85 std::string method_trace_file_;
86 size_t method_trace_file_size_;
Elliott Hughesfc861622011-10-17 17:57:47 -070087 bool (*hook_is_sensitive_thread_)();
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070088 jint (*hook_vfprintf_)(FILE* stream, const char* format, va_list ap);
89 void (*hook_exit_)(jint status);
90 void (*hook_abort_)();
Brian Carlstrom6ea095a2011-08-16 15:26:54 -070091 std::vector<std::string> properties_;
92
93 private:
Ian Rogers0cfe1fb2011-08-26 03:29:44 -070094 ParsedOptions() {}
Brian Carlstrom8a436592011-08-15 21:27:23 -070095 };
Carl Shapiro2ed144c2011-07-26 16:52:08 -070096
Carl Shapiro61e019d2011-07-14 16:53:09 -070097 // Creates and initializes a new runtime.
Carl Shapiro2ed144c2011-07-26 16:52:08 -070098 static Runtime* Create(const Options& options, bool ignore_unrecognized);
Brian Carlstrom69b15fb2011-09-03 12:25:21 -070099
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800100 bool IsCompiler() const {
101 return is_compiler_;
102 }
103
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700104 bool IsZygote() const {
105 return is_zygote_;
106 }
107
Mathieu Chartier069387a2012-06-18 12:01:01 -0700108 bool IsConcurrentGcEnabled() const {
109 return is_concurrent_gc_enabled_;
110 }
111
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700112 const std::string& GetHostPrefix() const {
Elliott Hughes307f75d2011-10-12 18:04:40 -0700113 DCHECK(!IsStarted());
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700114 return host_prefix_;
115 }
116
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700117 // Starts a runtime, which may cause threads to be started and code to run.
118 void Start();
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700119
Ian Rogers9af209c2012-06-03 20:50:30 -0700120 bool IsShuttingDown() const {
121 return shutting_down_;
122 }
123
124 bool IsStarted() const {
125 return started_;
126 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700127
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700128 bool IsFinishedStarting() const {
129 return finished_starting_;
130 }
131
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700132 static Runtime* Current() {
133 return instance_;
134 }
Carl Shapiro1fb86202011-06-27 17:43:13 -0700135
Elliott Hughesffe67362011-07-17 12:09:27 -0700136 // Aborts semi-cleanly. Used in the implementation of LOG(FATAL), which most
137 // callers should prefer.
138 // This isn't marked ((noreturn)) because then gcc will merge multiple calls
139 // in a single function together. This reduces code size slightly, but means
140 // that the native stack trace we get may point at the wrong call site.
Elliott Hughes8593fdb2012-04-21 20:53:44 -0700141 static void Abort();
Elliott Hughesffe67362011-07-17 12:09:27 -0700142
Ian Rogers365c1022012-06-22 15:05:28 -0700143 // Returns the "main" ThreadGroup, used when attaching user threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700144 jobject GetMainThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700145
146 // Returns the "system" ThreadGroup, used when attaching our internal threads.
Brian Carlstrom034f76b2012-08-01 15:51:58 -0700147 jobject GetSystemThreadGroup() const;
Ian Rogers365c1022012-06-22 15:05:28 -0700148
Elliott Hughes462c9442012-03-23 18:47:50 -0700149 // Attaches the calling native thread to the runtime.
Ian Rogers365c1022012-06-22 15:05:28 -0700150 void AttachCurrentThread(const char* thread_name, bool as_daemon, jobject thread_group);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700151
Elliott Hughesbf86d042011-08-31 17:53:14 -0700152 void CallExitHook(jint status);
153
Carl Shapiro61e019d2011-07-14 16:53:09 -0700154 // Detaches the current native thread from the runtime.
Elliott Hughesd92bec42011-09-02 17:04:36 -0700155 void DetachCurrentThread();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700156
Elliott Hughesc967f782012-04-16 10:23:15 -0700157 void DumpForSigQuit(std::ostream& os);
Elliott Hughes21a5bf22011-12-07 14:35:20 -0800158 void DumpLockHolders(std::ostream& os);
Elliott Hughese27955c2011-08-26 15:21:24 -0700159
Carl Shapiro61e019d2011-07-14 16:53:09 -0700160 ~Runtime();
Carl Shapirob5573532011-07-12 18:22:59 -0700161
Brian Carlstroma004aa92012-02-08 18:05:09 -0800162 const std::string& GetBootClassPathString() const {
163 return boot_class_path_string_;
164 }
165
166 const std::string& GetClassPathString() const {
167 return class_path_string_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700168 }
169
170 ClassLinker* GetClassLinker() const {
Carl Shapiro7a909592011-07-24 19:21:59 -0700171 return class_linker_;
172 }
173
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700174 size_t GetDefaultStackSize() const {
175 return default_stack_size_;
176 }
177
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800178 Heap* GetHeap() const {
179 return heap_;
180 }
181
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700182 InternTable* GetInternTable() const {
183 return intern_table_;
184 }
185
Elliott Hughes0af55432011-08-17 18:37:28 -0700186 JavaVMExt* GetJavaVM() const {
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700187 return java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700188 }
189
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700190 MonitorList* GetMonitorList() const {
191 return monitor_list_;
192 }
193
Elliott Hughes225f5a12012-06-11 11:23:48 -0700194 Throwable* GetPreAllocatedOutOfMemoryError() {
195 return pre_allocated_OutOfMemoryError_;
196 }
197
198 const std::vector<std::string>& GetProperties() const {
199 return properties_;
200 }
201
Elliott Hughesd92bec42011-09-02 17:04:36 -0700202 ThreadList* GetThreadList() const {
203 return thread_list_;
204 }
205
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700206 const char* GetVersion() const {
207 return "2.0.0";
208 }
209
Elliott Hughes410c0c82011-09-01 17:58:25 -0700210 void VisitRoots(Heap::RootVisitor* visitor, void* arg) const;
Brian Carlstrom1f870082011-08-23 16:02:11 -0700211
Ian Rogers9af209c2012-06-03 20:50:30 -0700212 bool HasJniDlsymLookupStub() const {
213 return jni_stub_array_ != NULL;
214 }
215
216 ByteArray* GetJniDlsymLookupStub() const {
217 CHECK(HasJniDlsymLookupStub());
218 return jni_stub_array_;
219 }
220
Ian Rogers169c9a72011-11-13 20:13:17 -0800221 void SetJniDlsymLookupStub(ByteArray* jni_stub_array);
Brian Carlstrom16192862011-09-12 17:50:06 -0700222
Ian Rogers9af209c2012-06-03 20:50:30 -0700223 bool HasAbstractMethodErrorStubArray() const {
224 return abstract_method_error_stub_array_ != NULL;
225 }
226
227 ByteArray* GetAbstractMethodErrorStubArray() const {
228 CHECK(abstract_method_error_stub_array_ != NULL);
229 return abstract_method_error_stub_array_;
230 }
231
Brian Carlstrome24fa612011-09-29 00:53:55 -0700232 void SetAbstractMethodErrorStubArray(ByteArray* abstract_method_error_stub_array);
Ian Rogersff1ed472011-09-20 13:46:24 -0700233
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700234 enum TrampolineType {
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700235 kStaticMethod,
236 kUnknownMethod,
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700237 kLastTrampolineMethodType // Value used for iteration
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700238 };
Ian Rogers9af209c2012-06-03 20:50:30 -0700239
240 bool HasResolutionStubArray(TrampolineType type) const {
241 return resolution_stub_array_[type] != NULL;
242 }
243
244 ByteArray* GetResolutionStubArray(TrampolineType type) const {
245 CHECK(HasResolutionStubArray(type));
246 DCHECK_LT(static_cast<int>(type), static_cast<int>(kLastTrampolineMethodType));
247 return resolution_stub_array_[type];
248 }
249
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700250 void SetResolutionStubArray(ByteArray* resolution_stub_array, TrampolineType type);
Ian Rogersad25ac52011-10-04 19:13:33 -0700251
Ian Rogers9af209c2012-06-03 20:50:30 -0700252 // Returns a special method that calls into a trampoline for runtime method resolution
253 Method* GetResolutionMethod() const {
254 CHECK(HasResolutionMethod());
255 return resolution_method_;
256 }
257
258 bool HasResolutionMethod() const {
259 return resolution_method_ != NULL;
260 }
261
262 void SetResolutionMethod(Method* method) {
263 resolution_method_ = method;
264 }
265
Ian Rogers19846512012-02-24 11:42:47 -0800266 Method* CreateResolutionMethod();
Ian Rogers19846512012-02-24 11:42:47 -0800267
Ian Rogersff1ed472011-09-20 13:46:24 -0700268 // Returns a special method that describes all callee saves being spilled to the stack.
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700269 enum CalleeSaveType {
270 kSaveAll,
271 kRefsOnly,
272 kRefsAndArgs,
273 kLastCalleeSaveType // Value used for iteration
274 };
Ian Rogers9af209c2012-06-03 20:50:30 -0700275
276 bool HasCalleeSaveMethod(CalleeSaveType type) const {
Elliott Hughes225f5a12012-06-11 11:23:48 -0700277 return callee_save_methods_[type] != NULL;
Ian Rogers9af209c2012-06-03 20:50:30 -0700278 }
279
280 Method* GetCalleeSaveMethod(CalleeSaveType type) const {
281 CHECK(HasCalleeSaveMethod(type));
Elliott Hughes225f5a12012-06-11 11:23:48 -0700282 return callee_save_methods_[type];
Ian Rogers9af209c2012-06-03 20:50:30 -0700283 }
284
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700285 void SetCalleeSaveMethod(Method* method, CalleeSaveType type);
286
Ian Rogers9af209c2012-06-03 20:50:30 -0700287 Method* CreateCalleeSaveMethod(InstructionSet instruction_set, CalleeSaveType type);
288
Brian Carlstromae826982011-11-09 01:33:42 -0800289 Method* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set);
290 Method* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set);
Ian Rogersff1ed472011-09-20 13:46:24 -0700291
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700292 int32_t GetStat(int kind);
293
Ian Rogers9af209c2012-06-03 20:50:30 -0700294 RuntimeStats* GetStats() {
295 return &stats_;
296 }
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700297
298 bool HasStatsEnabled() const {
299 return stats_enabled_;
300 }
301
302 void ResetStats(int kinds);
303
304 void SetStatsEnabled(bool new_state);
305
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700306 void DidForkFromZygote();
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700307 bool PreZygoteFork();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700308
jeffhao2692b572011-12-16 15:42:28 -0800309 void EnableMethodTracing(Trace* tracer);
310 void DisableMethodTracing();
Ian Rogers9af209c2012-06-03 20:50:30 -0700311
312 bool IsMethodTracingActive() const {
313 return tracer_ != NULL;
314 }
315
316 Trace* GetTracer() const {
317 CHECK(IsMethodTracingActive());
318 return tracer_;
319 }
jeffhao2692b572011-12-16 15:42:28 -0800320
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800321 bool UseCompileTimeClassPath() const {
322 return use_compile_time_class_path_;
323 }
Ian Rogers9af209c2012-06-03 20:50:30 -0700324
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800325 const std::vector<const DexFile*>& GetCompileTimeClassPath(const ClassLoader* class_loader);
326 void SetCompileTimeClassPath(const ClassLoader* class_loader, std::vector<const DexFile*>& class_path);
327
Carl Shapirob5573532011-07-12 18:22:59 -0700328 private:
Elliott Hughes457005c2012-04-16 13:54:25 -0700329 static void InitPlatformSignalHandlers();
Elliott Hughesffe67362011-07-17 12:09:27 -0700330
Elliott Hughesdcc24742011-09-07 14:02:44 -0700331 Runtime();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700332
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700333 void BlockSignals();
334
Brian Carlstrom8a436592011-08-15 21:27:23 -0700335 bool Init(const Options& options, bool ignore_unrecognized);
Elliott Hughes038a8062011-09-18 14:12:41 -0700336 void InitNativeMethods();
Ian Rogers365c1022012-06-22 15:05:28 -0700337 void InitThreadGroups(Thread* self);
Elliott Hughesff17f1f2012-01-24 18:12:29 -0800338 void RegisterRuntimeNativeMethods(JNIEnv* env);
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700339
Elliott Hughes85d15452011-09-16 17:33:01 -0700340 void StartDaemonThreads();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700341 void StartSignalCatcher();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700342
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800343 // A pointer to the active runtime or NULL.
344 static Runtime* instance_;
345
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800346 bool is_compiler_;
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700347 bool is_zygote_;
Mathieu Chartier069387a2012-06-18 12:01:01 -0700348 bool is_concurrent_gc_enabled_;
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700349
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700350 // The host prefix is used during cross compilation. It is removed
351 // from the start of host paths such as:
Brian Carlstrom29e7ac72011-12-05 23:42:57 -0800352 // $ANDROID_PRODUCT_OUT/system/framework/boot.oat
Brian Carlstrom34f426c2011-10-04 12:58:02 -0700353 // to produce target paths such as
Brian Carlstrom47a0d5a2011-10-12 21:20:05 -0700354 // /system/framework/boot.oat
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700355 // Similarly it is prepended to target paths to arrive back at a
356 // host past. In both cases this is necessary because image and oat
357 // files embedded expect paths of dependent files (an image points
358 // to an oat file and an oat files to one or more dex files). These
359 // files contain the expected target path.
360 std::string host_prefix_;
361
Brian Carlstroma004aa92012-02-08 18:05:09 -0800362 std::string boot_class_path_string_;
363 std::string class_path_string_;
Elliott Hughes7ede61e2011-09-14 18:18:06 -0700364 std::vector<std::string> properties_;
365
Brian Carlstromb765be02011-08-17 23:54:10 -0700366 // The default stack size for managed threads created by the runtime.
Elliott Hughesbe759c62011-09-08 19:38:21 -0700367 size_t default_stack_size_;
Brian Carlstromb765be02011-08-17 23:54:10 -0700368
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800369 Heap* heap_;
370
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700371 MonitorList* monitor_list_;
372
Carl Shapirob5573532011-07-12 18:22:59 -0700373 ThreadList* thread_list_;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700374
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700375 InternTable* intern_table_;
376
Brian Carlstromb0460ea2011-07-29 10:08:05 -0700377 ClassLinker* class_linker_;
378
Elliott Hughese27955c2011-08-26 15:21:24 -0700379 SignalCatcher* signal_catcher_;
Elliott Hughes94ce37a2011-10-18 15:07:48 -0700380 std::string stack_trace_file_;
Elliott Hughese27955c2011-08-26 15:21:24 -0700381
Elliott Hughesc5f7c912011-08-18 14:00:42 -0700382 JavaVMExt* java_vm_;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700383
Elliott Hughes225f5a12012-06-11 11:23:48 -0700384 Throwable* pre_allocated_OutOfMemoryError_;
385
Brian Carlstrom16192862011-09-12 17:50:06 -0700386 ByteArray* jni_stub_array_;
387
Brian Carlstrome24fa612011-09-29 00:53:55 -0700388 ByteArray* abstract_method_error_stub_array_;
389
Ian Rogers4f0d07c2011-10-06 23:38:47 -0700390 ByteArray* resolution_stub_array_[kLastTrampolineMethodType];
Ian Rogersad25ac52011-10-04 19:13:33 -0700391
Elliott Hughes225f5a12012-06-11 11:23:48 -0700392 Method* callee_save_methods_[kLastCalleeSaveType];
Ian Rogersff1ed472011-09-20 13:46:24 -0700393
Ian Rogers19846512012-02-24 11:42:47 -0800394 Method* resolution_method_;
395
Brian Carlstromaded5f72011-10-07 17:15:04 -0700396 // As returned by ClassLoader.getSystemClassLoader()
397 ClassLoader* system_class_loader_;
398
Elliott Hughes6b355752012-01-13 16:49:08 -0800399 bool shutting_down_;
Elliott Hughesdcc24742011-09-07 14:02:44 -0700400 bool started_;
401
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700402 // New flag added which tells us if the runtime has finished starting. If
403 // this flag is set then the Daemon threads are created and the class loader
404 // is created. This flag is needed for knowing if its safe to request CMS.
405 bool finished_starting_;
406
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700407 // Hooks supported by JNI_CreateJavaVM
408 jint (*vfprintf_)(FILE* stream, const char* format, va_list ap);
409 void (*exit_)(jint status);
410 void (*abort_)();
411
Elliott Hughes9d5ccec2011-09-19 13:19:50 -0700412 bool stats_enabled_;
413 RuntimeStats stats_;
414
jeffhaob5e81852012-03-12 11:15:45 -0700415 bool method_trace_;
416 std::string method_trace_file_;
417 size_t method_trace_file_size_;
jeffhao2692b572011-12-16 15:42:28 -0800418 Trace* tracer_;
419
Elliott Hughesa0e18062012-04-13 15:59:59 -0700420 typedef SafeMap<const ClassLoader*, std::vector<const DexFile*> > CompileTimeClassPaths;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800421 CompileTimeClassPaths compile_time_class_paths_;
422 bool use_compile_time_class_path_;
Elliott Hughes131aef82012-01-27 11:53:35 -0800423
Ian Rogers365c1022012-06-22 15:05:28 -0700424 jobject main_thread_group_;
425 jobject system_thread_group_;
Logan Chien971bf3f2012-05-01 15:47:55 +0800426#if defined(ART_USE_LLVM_COMPILER)
427 compiler_llvm::ProcedureLinkageTable plt_;
428#endif
Ian Rogers365c1022012-06-22 15:05:28 -0700429
Carl Shapiro61e019d2011-07-14 16:53:09 -0700430 DISALLOW_COPY_AND_ASSIGN(Runtime);
Carl Shapiro1fb86202011-06-27 17:43:13 -0700431};
432
433} // namespace art
434
Carl Shapiro1fb86202011-06-27 17:43:13 -0700435#endif // ART_SRC_RUNTIME_H_