blob: 74b9810481b9d40c62b79a9ce61b4a2338cfe810 [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 Carlstrom578bbdc2011-07-21 14:07:47 -070017#include "runtime.h"
Carl Shapiro1fb86202011-06-27 17:43:13 -070018
Brian Carlstrombd86bcc2013-03-10 20:26:16 -070019// sys/mount.h has to come before linux/fs.h due to redefinition of MS_RDONLY, MS_BIND, etc
20#include <sys/mount.h>
Ian Rogersc5f17732014-06-05 20:48:42 -070021#ifdef __linux__
Brian Carlstrombd86bcc2013-03-10 20:26:16 -070022#include <linux/fs.h>
Hiroshi Yamauchi6ffb9cc2015-08-31 15:14:17 -070023#include <sys/prctl.h>
Ian Rogersc5f17732014-06-05 20:48:42 -070024#endif
Brian Carlstrombd86bcc2013-03-10 20:26:16 -070025
Brian Carlstromdbf05b72011-12-15 00:55:24 -080026#include <signal.h>
Elliott Hughesd06a6c72012-05-30 17:59:06 -070027#include <sys/syscall.h>
Evgenii Stepanov1e133742015-05-20 12:30:59 -070028#include "base/memory_tool.h"
David Sehrd106d9f2016-08-16 19:22:57 -070029#if defined(__APPLE__)
30#include <crt_externs.h> // for _NSGetEnviron
31#endif
Brian Carlstromdbf05b72011-12-15 00:55:24 -080032
Elliott Hughesffe67362011-07-17 12:09:27 -070033#include <cstdio>
34#include <cstdlib>
Brian Carlstrom8a436592011-08-15 21:27:23 -070035#include <limits>
Igor Murashkinaaebaa02015-01-26 10:55:53 -080036#include <memory_representation.h>
Carl Shapiro2ed144c2011-07-26 16:52:08 -070037#include <vector>
Dave Allison39c3bfb2014-01-28 18:33:52 -080038#include <fcntl.h>
Elliott Hughesffe67362011-07-17 12:09:27 -070039
Andreas Gampe9186ced2016-12-12 14:28:21 -080040#include "android-base/strings.h"
41
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -080042#include "JniConstants.h"
43#include "ScopedLocalRef.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010044#include "arch/arm/quick_method_frame_info_arm.h"
Ian Rogers166db042013-07-26 12:05:57 -070045#include "arch/arm/registers_arm.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010046#include "arch/arm64/quick_method_frame_info_arm64.h"
Stuart Monteithb95a5342014-03-12 13:32:32 +000047#include "arch/arm64/registers_arm64.h"
Ian Rogersd582fa42014-11-05 23:46:43 -080048#include "arch/instruction_set_features.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010049#include "arch/mips/quick_method_frame_info_mips.h"
Ian Rogers166db042013-07-26 12:05:57 -070050#include "arch/mips/registers_mips.h"
Andreas Gampe57b34292015-01-14 15:45:59 -080051#include "arch/mips64/quick_method_frame_info_mips64.h"
52#include "arch/mips64/registers_mips64.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010053#include "arch/x86/quick_method_frame_info_x86.h"
Ian Rogers166db042013-07-26 12:05:57 -070054#include "arch/x86/registers_x86.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010055#include "arch/x86_64/quick_method_frame_info_x86_64.h"
Ian Rogersef7d42f2014-01-06 12:55:46 -080056#include "arch/x86_64/registers_x86_64.h"
Mathieu Chartierc7853442015-03-27 14:35:38 -070057#include "art_field-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070058#include "art_method-inl.h"
Ian Rogers1d8cdbc2014-09-22 22:51:09 -070059#include "asm_support.h"
Andreas Gampeb2d18fa2017-06-06 20:46:10 -070060#include "asm_support_check.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080061#include "atomic.h"
Andreas Gampe4585f872015-03-27 23:45:15 -070062#include "base/arena_allocator.h"
Ian Rogersc7dd2952014-10-21 23:31:19 -070063#include "base/dumpable.h"
Andreas Gampe542451c2016-07-26 09:02:02 -070064#include "base/enums.h"
Vladimir Marko637ee0b2015-09-04 12:47:41 +010065#include "base/stl_util.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080066#include "base/systrace.h"
Ian Rogers1d8cdbc2014-09-22 22:51:09 -070067#include "base/unix_file/fd_file.h"
Mingyao Yang063fc772016-08-02 11:02:54 -070068#include "cha.h"
Vladimir Marko3481ba22015-04-13 12:22:36 +010069#include "class_linker-inl.h"
Andreas Gampe4585f872015-03-27 23:45:15 -070070#include "compiler_callbacks.h"
Elliott Hughes3bb81562011-10-21 18:52:59 -070071#include "debugger.h"
Alex Light84d76052014-08-22 17:49:35 -070072#include "elf_file.h"
Ian Rogers6f3dbba2014-10-14 17:41:57 -070073#include "entrypoints/runtime_asm_entrypoints.h"
Alex Lighteb7c1442015-08-31 13:17:42 -070074#include "experimental_flags.h"
Ian Rogers576ca0c2014-06-06 15:58:22 -070075#include "fault_handler.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070076#include "gc/accounting/card_table-inl.h"
77#include "gc/heap.h"
Andreas Gampefda57142016-09-08 20:29:18 -070078#include "gc/scoped_gc_critical_section.h"
Ian Rogerse63db272014-07-15 15:36:11 -070079#include "gc/space/image_space.h"
Mathieu Chartier461687d2015-03-31 12:05:24 -070080#include "gc/space/space-inl.h"
Andreas Gampefda57142016-09-08 20:29:18 -070081#include "gc/system_weak.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -080082#include "handle_scope-inl.h"
Mathieu Chartier4a26f172016-01-26 14:26:18 -080083#include "image-inl.h"
jeffhao725a9572012-11-13 18:20:12 -080084#include "instrumentation.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070085#include "intern_table.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080086#include "interpreter/interpreter.h"
Andreas Gampec15a2f42017-04-21 12:09:39 -070087#include "java_vm_ext.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080088#include "jit/jit.h"
Nicolas Geoffray132d8362016-11-16 09:19:42 +000089#include "jit/jit_code_cache.h"
Elliott Hughesc5f7c912011-08-18 14:00:42 -070090#include "jni_internal.h"
Mathieu Chartierc7853442015-03-27 14:35:38 -070091#include "linear_alloc.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -080092#include "mirror/array.h"
Ian Rogers62d6c772013-02-27 08:32:07 -080093#include "mirror/class-inl.h"
Alex Lightcec2fd42016-11-02 16:32:07 -070094#include "mirror/class_ext.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080095#include "mirror/class_loader.h"
Narayan Kamath000e1882016-10-24 17:14:25 +010096#include "mirror/emulated_stack_frame.h"
Mathieu Chartierdaaf3262015-03-24 13:30:28 -070097#include "mirror/field.h"
Mathieu Chartierfc58af42015-04-16 18:00:39 -070098#include "mirror/method.h"
Narayan Kamathafa48272016-08-03 12:46:58 +010099#include "mirror/method_handle_impl.h"
Orion Hodsonc069a302017-01-18 09:23:12 +0000100#include "mirror/method_handles_lookup.h"
Narayan Kamathafa48272016-08-03 12:46:58 +0100101#include "mirror/method_type.h"
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800102#include "mirror/stack_trace_element.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800103#include "mirror/throwable.h"
Elliott Hughes32d6e1e2011-10-11 14:47:44 -0700104#include "monitor.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800105#include "native/dalvik_system_DexFile.h"
106#include "native/dalvik_system_VMDebug.h"
107#include "native/dalvik_system_VMRuntime.h"
108#include "native/dalvik_system_VMStack.h"
109#include "native/dalvik_system_ZygoteHooks.h"
110#include "native/java_lang_Class.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800111#include "native/java_lang_Object.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800112#include "native/java_lang_String.h"
Jeff Hao848f70a2014-01-15 13:49:50 -0800113#include "native/java_lang_StringFactory.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800114#include "native/java_lang_System.h"
115#include "native/java_lang_Thread.h"
116#include "native/java_lang_Throwable.h"
117#include "native/java_lang_VMClassLoader.h"
Vladimir Markoe00e5592017-02-24 14:58:29 +0000118#include "native/java_lang_Void.h"
Narayan Kamathbd2fed52017-01-25 10:46:54 +0000119#include "native/java_lang_invoke_MethodHandleImpl.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800120#include "native/java_lang_ref_FinalizerReference.h"
121#include "native/java_lang_ref_Reference.h"
122#include "native/java_lang_reflect_Array.h"
123#include "native/java_lang_reflect_Constructor.h"
Neil Fuller0e844392016-09-08 13:43:31 +0100124#include "native/java_lang_reflect_Executable.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800125#include "native/java_lang_reflect_Field.h"
126#include "native/java_lang_reflect_Method.h"
Neil Fuller60458a02016-09-01 15:32:44 +0100127#include "native/java_lang_reflect_Parameter.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800128#include "native/java_lang_reflect_Proxy.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800129#include "native/java_util_concurrent_atomic_AtomicLong.h"
Jeff Hao848f70a2014-01-15 13:49:50 -0800130#include "native/libcore_util_CharsetUtils.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800131#include "native/org_apache_harmony_dalvik_ddmc_DdmServer.h"
132#include "native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.h"
133#include "native/sun_misc_Unsafe.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800134#include "native_bridge_art_interface.h"
Andreas Gampe5dd44d02016-08-02 17:20:03 -0700135#include "native_stack_dump.h"
Brian Carlstrome24fa612011-09-29 00:53:55 -0700136#include "oat_file.h"
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -0700137#include "oat_file_manager.h"
Andreas Gamped482e732017-04-24 17:59:09 -0700138#include "object_callbacks.h"
Alex Light84d76052014-08-22 17:49:35 -0700139#include "os.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800140#include "parsed_options.h"
Calin Juravlec90bc922016-02-24 10:13:09 +0000141#include "jit/profile_saver.h"
Vladimir Marko7624d252014-05-02 14:40:15 +0100142#include "quick/quick_method_frame_info.h"
Ian Rogers53b8b092014-03-13 23:45:53 -0700143#include "reflection.h"
Andreas Gampeac30fa22017-01-18 21:02:36 -0800144#include "runtime_callbacks.h"
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800145#include "runtime_options.h"
146#include "ScopedLocalRef.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -0700147#include "scoped_thread_state_change-inl.h"
Dave Allisoncefcea82014-09-16 10:01:01 -0700148#include "sigchain.h"
Elliott Hughese27955c2011-08-26 15:21:24 -0700149#include "signal_catcher.h"
Elliott Hughes457005c2012-04-16 13:54:25 -0700150#include "signal_set.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700151#include "thread.h"
Elliott Hughes8daa0922011-09-11 13:46:25 -0700152#include "thread_list.h"
Alex Light7233c7e2016-07-28 10:07:45 -0700153#include "ti/agent.h"
jeffhaob5e81852012-03-12 11:15:45 -0700154#include "trace.h"
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100155#include "transaction.h"
Vladimir Marko637ee0b2015-09-04 12:47:41 +0100156#include "utils.h"
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100157#include "vdex_file.h"
Ian Rogers776ac1f2012-04-13 23:36:36 -0700158#include "verifier/method_verifier.h"
Elliott Hugheseac76672012-05-24 21:56:51 -0700159#include "well_known_classes.h"
Carl Shapiro61e019d2011-07-14 16:53:09 -0700160
David Sehrf57589f2016-10-17 10:09:33 -0700161#ifdef ART_TARGET_ANDROID
162#include <android/set_abort_message.h>
163#endif
164
Carl Shapiro1fb86202011-06-27 17:43:13 -0700165namespace art {
166
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700167// If a signal isn't handled properly, enable a handler that attempts to dump the Java stack.
Brian Carlstromb57f1c72014-10-08 13:56:25 -0700168static constexpr bool kEnableJavaStackTraceHandler = false;
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -0700169// Tuned by compiling GmsCore under perf and measuring time spent in DescriptorEquals for class
170// linking.
171static constexpr double kLowMemoryMinLoadFactor = 0.5;
172static constexpr double kLowMemoryMaxLoadFactor = 0.8;
173static constexpr double kNormalMinLoadFactor = 0.4;
174static constexpr double kNormalMaxLoadFactor = 0.7;
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700175Runtime* Runtime::instance_ = nullptr;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700176
Andreas Gampef6a780a2015-04-02 18:51:05 -0700177struct TraceConfig {
178 Trace::TraceMode trace_mode;
179 Trace::TraceOutputMode trace_output_mode;
180 std::string trace_file;
181 size_t trace_file_size;
182};
183
David Sehrd106d9f2016-08-16 19:22:57 -0700184namespace {
185#ifdef __APPLE__
186inline char** GetEnviron() {
187 // When Google Test is built as a framework on MacOS X, the environ variable
188 // is unavailable. Apple's documentation (man environ) recommends using
189 // _NSGetEnviron() instead.
190 return *_NSGetEnviron();
191}
192#else
193// Some POSIX platforms expect you to declare environ. extern "C" makes
194// it reside in the global namespace.
195extern "C" char** environ;
196inline char** GetEnviron() { return environ; }
197#endif
198} // namespace
199
Elliott Hughesdcc24742011-09-07 14:02:44 -0700200Runtime::Runtime()
Mathieu Chartier31000802015-06-14 14:14:37 -0700201 : resolution_method_(nullptr),
202 imt_conflict_method_(nullptr),
203 imt_unimplemented_method_(nullptr),
204 instruction_set_(kNone),
Ian Rogers6ed19fd2014-03-20 08:10:17 -0700205 compiler_callbacks_(nullptr),
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800206 is_zygote_(false),
Alex Lighta59dd802014-07-02 16:28:08 -0700207 must_relocate_(false),
Mathieu Chartier069387a2012-06-18 12:01:01 -0700208 is_concurrent_gc_enabled_(true),
Anwar Ghuloum87183592013-08-14 12:12:19 -0700209 is_explicit_gc_disabled_(false),
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100210 dex2oat_enabled_(true),
Alex Light64ad14d2014-08-19 14:23:13 -0700211 image_dex2oat_enabled_(true),
Elliott Hughes6cf23882012-06-15 15:42:07 -0700212 default_stack_size_(0),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800213 heap_(nullptr),
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700214 max_spins_before_thin_lock_inflation_(Monitor::kDefaultMaxSpinsBeforeThinLockInflation),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800215 monitor_list_(nullptr),
216 monitor_pool_(nullptr),
217 thread_list_(nullptr),
218 intern_table_(nullptr),
219 class_linker_(nullptr),
220 signal_catcher_(nullptr),
Andreas Gampe8228cdf2017-05-30 15:03:54 -0700221 use_tombstoned_traces_(false),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800222 java_vm_(nullptr),
Mathieu Chartier15d34022014-02-26 17:16:38 -0800223 fault_message_lock_("Fault message lock"),
224 fault_message_(""),
Ian Rogers120f1c72012-09-28 17:17:10 -0700225 threads_being_born_(0),
Ian Rogersc604d732012-10-14 16:09:54 -0700226 shutdown_cond_(new ConditionVariable("Runtime shutdown", *Locks::runtime_shutdown_lock_)),
Elliott Hughes6b355752012-01-13 16:49:08 -0800227 shutting_down_(false),
Ian Rogers120f1c72012-09-28 17:17:10 -0700228 shutting_down_started_(false),
Elliott Hughesdcc24742011-09-07 14:02:44 -0700229 started_(false),
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700230 finished_starting_(false),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800231 vfprintf_(nullptr),
232 exit_(nullptr),
233 abort_(nullptr),
jeffhao2692b572011-12-16 15:42:28 -0800234 stats_enabled_(false),
Evgenii Stepanov1e133742015-05-20 12:30:59 -0700235 is_running_on_memory_tool_(RUNNING_ON_MEMORY_TOOL),
Ian Rogers62d6c772013-02-27 08:32:07 -0800236 instrumentation_(),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800237 main_thread_group_(nullptr),
238 system_thread_group_(nullptr),
239 system_class_loader_(nullptr),
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100240 dump_gc_performance_on_shutdown_(false),
Sebastien Hertzee1d79a2014-02-21 15:46:30 +0100241 preinitialization_transaction_(nullptr),
Igor Murashkin7617abd2015-07-10 18:27:47 -0700242 verify_(verifier::VerifyMode::kNone),
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700243 allow_dex_file_fallback_(true),
Dave Allison69dfe512014-07-11 17:11:58 +0000244 target_sdk_version_(0),
245 implicit_null_checks_(false),
246 implicit_so_checks_(false),
Calin Juravle07d83c72014-10-22 21:02:23 +0100247 implicit_suspend_checks_(false),
Calin Juravle01aaf6e2015-06-19 22:05:39 +0100248 no_sig_chain_(false),
Andreas Gampef38a6612016-04-11 08:42:26 -0700249 force_native_bridge_(false),
Narayan Kamath5a2be3f2015-02-16 13:51:51 +0000250 is_native_bridge_loaded_(false),
David Srbeckyf4480162016-03-16 00:06:24 +0000251 is_native_debuggable_(false),
Nicolas Geoffray433b79a2017-01-30 20:54:45 +0000252 is_java_debuggable_(false),
Igor Murashkin158f35c2015-06-10 15:55:30 -0700253 zygote_max_failed_boots_(0),
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -0700254 experimental_flags_(ExperimentalFlags::kNone),
255 oat_file_manager_(nullptr),
Nicolas Geoffray787ae8e2015-11-05 11:32:24 +0000256 is_low_memory_mode_(false),
Andreas Gampea1425a12016-03-11 17:44:04 -0800257 safe_mode_(false),
Andreas Gampef38a6612016-04-11 08:42:26 -0700258 dump_native_stack_on_sig_quit_(true),
Mathieu Chartierf8cb1782016-03-18 18:45:41 -0700259 pruned_dalvik_cache_(false),
260 // Initially assume we perceive jank in case the process state is never updated.
Andreas Gampef38a6612016-04-11 08:42:26 -0700261 process_state_(kProcessStateJankPerceptible),
Andreas Gampeac30fa22017-01-18 21:02:36 -0800262 zygote_no_threads_(false),
263 cha_(nullptr) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -0700264 static_assert(Runtime::kCalleeSaveSize ==
265 static_cast<uint32_t>(CalleeSaveType::kLastCalleeSaveType), "Unexpected size");
266
Ian Rogers1d8cdbc2014-09-22 22:51:09 -0700267 CheckAsmSupportOffsetsAndSizes();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700268 std::fill(callee_save_methods_, callee_save_methods_ + arraysize(callee_save_methods_), 0u);
buzbee1452bee2015-03-06 14:43:04 -0800269 interpreter::CheckInterpreterAsmConstants();
Andreas Gampeac30fa22017-01-18 21:02:36 -0800270 callbacks_.reset(new RuntimeCallbacks());
Nicolas Geoffray4e92c3c2017-05-08 09:34:26 +0100271 for (size_t i = 0; i <= static_cast<size_t>(DeoptimizationKind::kLast); ++i) {
272 deoptimization_counts_[i] = 0u;
273 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700274}
275
Carl Shapiro61e019d2011-07-14 16:53:09 -0700276Runtime::~Runtime() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800277 ScopedTrace trace("Runtime shutdown");
Calin Juravle07d83c72014-10-22 21:02:23 +0100278 if (is_native_bridge_loaded_) {
279 UnloadNativeBridge();
280 }
Calin Juravle31f2c152015-10-23 17:56:15 +0100281
Ian Rogers120f1c72012-09-28 17:17:10 -0700282 Thread* self = Thread::Current();
Mathieu Chartier05d14612015-02-23 15:31:58 -0800283 const bool attach_shutdown_thread = self == nullptr;
284 if (attach_shutdown_thread) {
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800285 CHECK(AttachCurrentThread("Shutdown thread", false, nullptr, false));
286 self = Thread::Current();
287 } else {
288 LOG(WARNING) << "Current thread not detached in Runtime shutdown";
289 }
290
Mathieu Chartier1d495012017-04-11 17:50:00 -0700291 if (dump_gc_performance_on_shutdown_) {
292 // This can't be called from the Heap destructor below because it
293 // could call RosAlloc::InspectAll() which needs the thread_list
294 // to be still alive.
295 heap_->DumpGcPerformanceInfo(LOG_STREAM(INFO));
296 }
297
Calin Juravlea345d312017-03-14 18:45:55 -0700298 if (jit_ != nullptr) {
299 // Stop the profile saver thread before marking the runtime as shutting down.
300 // The saver will try to dump the profiles before being sopped and that
301 // requires holding the mutator lock.
302 jit_->StopProfileSaver();
303 }
304
Ian Rogers120f1c72012-09-28 17:17:10 -0700305 {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800306 ScopedTrace trace2("Wait for shutdown cond");
Ian Rogers120f1c72012-09-28 17:17:10 -0700307 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
308 shutting_down_started_ = true;
309 while (threads_being_born_ > 0) {
Ian Rogersc604d732012-10-14 16:09:54 -0700310 shutdown_cond_->Wait(self);
Ian Rogers120f1c72012-09-28 17:17:10 -0700311 }
312 shutting_down_ = true;
313 }
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800314 // Shutdown and wait for the daemons.
315 CHECK(self != nullptr);
316 if (IsFinishedStarting()) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800317 ScopedTrace trace2("Waiting for Daemons");
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800318 self->ClearException();
319 self->GetJniEnv()->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons,
320 WellKnownClasses::java_lang_Daemons_stop);
321 }
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700322
323 Trace::Shutdown();
324
Andreas Gampe48864112017-01-19 17:23:17 -0800325 // Report death. Clients me require a working thread, still, so do it before GC completes and
326 // all non-daemon threads are done.
327 {
328 ScopedObjectAccess soa(self);
329 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kDeath);
330 }
331
Mathieu Chartier05d14612015-02-23 15:31:58 -0800332 if (attach_shutdown_thread) {
333 DetachCurrentThread();
334 self = nullptr;
335 }
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800336
Mathieu Chartiera6399032012-06-11 18:49:50 -0700337 // Make sure to let the GC complete if it is running.
Mathieu Chartier89a201e2014-05-02 10:27:26 -0700338 heap_->WaitForGcToComplete(gc::kGcCauseBackground, self);
Mathieu Chartier35883cc2012-11-13 14:08:12 -0800339 heap_->DeleteThreadPool();
Mathieu Chartierfb6db4c2016-01-06 17:23:25 -0800340 if (jit_ != nullptr) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800341 ScopedTrace trace2("Delete jit");
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800342 VLOG(jit) << "Deleting jit thread pool";
343 // Delete thread pool before the thread list since we don't want to wait forever on the
344 // JIT compiler threads.
345 jit_->DeleteThreadPool();
346 }
Mathieu Chartiera6399032012-06-11 18:49:50 -0700347
Andreas Gampec4bed162017-05-01 13:46:24 -0700348 // Make sure our internal threads are dead before we start tearing down things they're using.
349 Dbg::StopJdwp();
350 delete signal_catcher_;
351
352 // Make sure all other non-daemon threads have terminated, and all daemon threads are suspended.
353 {
354 ScopedTrace trace2("Delete thread list");
355 thread_list_->ShutDown();
356 }
357
Alex Light7233c7e2016-07-28 10:07:45 -0700358 // TODO Maybe do some locking.
359 for (auto& agent : agents_) {
360 agent.Unload();
361 }
362
Alex Light185d1342016-08-11 10:48:03 -0700363 // TODO Maybe do some locking
364 for (auto& plugin : plugins_) {
365 plugin.Unload();
366 }
367
Andreas Gampec4bed162017-05-01 13:46:24 -0700368 // Finally delete the thread list.
369 delete thread_list_;
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700370
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800371 // Delete the JIT after thread list to ensure that there is no remaining threads which could be
372 // accessing the instrumentation when we delete it.
Mathieu Chartierfb6db4c2016-01-06 17:23:25 -0800373 if (jit_ != nullptr) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800374 VLOG(jit) << "Deleting jit";
375 jit_.reset(nullptr);
376 }
377
Vladimir Marko2beeb822014-10-20 18:13:22 +0100378 // Shutdown the fault manager if it was initialized.
379 fault_manager.Shutdown();
380
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800381 ScopedTrace trace2("Delete state");
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700382 delete monitor_list_;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800383 delete monitor_pool_;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700384 delete class_linker_;
Mingyao Yang063fc772016-08-02 11:02:54 -0700385 delete cha_;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800386 delete heap_;
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700387 delete intern_table_;
Mathieu Chartiere58991b2015-10-13 07:59:34 -0700388 delete oat_file_manager_;
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700389 Thread::Shutdown();
Elliott Hughes7c6169d2012-05-02 16:11:48 -0700390 QuasiAtomic::Shutdown();
Sebastien Hertz4d4adb12013-07-24 16:14:19 +0200391 verifier::MethodVerifier::Shutdown();
Vladimir Marko37cf51f2015-09-22 11:43:46 +0100392
393 // Destroy allocators before shutting down the MemMap because they may use it.
Richard Uhlerda0a69e2016-10-11 15:06:38 +0100394 java_vm_.reset();
Vladimir Marko37cf51f2015-09-22 11:43:46 +0100395 linear_alloc_.reset();
396 low_4gb_arena_pool_.reset();
397 arena_pool_.reset();
Nicolas Geoffray25e04562016-03-01 13:17:58 +0000398 jit_arena_pool_.reset();
Andreas Gampe2ac67d52017-05-11 22:30:38 -0700399 protected_fault_page_.reset();
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700400 MemMap::Shutdown();
Vladimir Marko37cf51f2015-09-22 11:43:46 +0100401
Carl Shapiro4acf4642011-07-26 18:54:13 -0700402 // TODO: acquire a static mutex on Runtime to avoid racing.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800403 CHECK(instance_ == nullptr || instance_ == this);
404 instance_ = nullptr;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700405}
406
Elliott Hughese0918552011-10-28 17:18:29 -0700407struct AbortState {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700408 void Dump(std::ostream& os) const {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000409 if (gAborting > 1) {
410 os << "Runtime aborting --- recursively, so no thread-specific detail!\n";
Andreas Gampe9fd470f2016-11-18 17:21:12 -0800411 DumpRecursiveAbort(os);
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000412 return;
413 }
414 gAborting++;
Elliott Hughese0918552011-10-28 17:18:29 -0700415 os << "Runtime aborting...\n";
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700416 if (Runtime::Current() == nullptr) {
Elliott Hughes6c7d2442012-02-01 18:40:47 -0800417 os << "(Runtime does not yet exist!)\n";
Andreas Gampe6eb6a392016-02-10 20:18:37 -0800418 DumpNativeStack(os, GetTid(), nullptr, " native: ", nullptr);
Elliott Hughes6c7d2442012-02-01 18:40:47 -0800419 return;
420 }
Elliott Hughese0918552011-10-28 17:18:29 -0700421 Thread* self = Thread::Current();
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700422 if (self == nullptr) {
Elliott Hughese0918552011-10-28 17:18:29 -0700423 os << "(Aborting thread was not attached to runtime!)\n";
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700424 DumpKernelStack(os, GetTid(), " kernel: ", false);
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800425 DumpNativeStack(os, GetTid(), nullptr, " native: ", nullptr);
Elliott Hughese0918552011-10-28 17:18:29 -0700426 } else {
Ian Rogers2f7f9b62012-10-10 18:24:05 -0700427 os << "Aborting thread:\n";
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700428 if (Locks::mutator_lock_->IsExclusiveHeld(self) || Locks::mutator_lock_->IsSharedHeld(self)) {
429 DumpThread(os, self);
430 } else {
431 if (Locks::mutator_lock_->SharedTryLock(self)) {
432 DumpThread(os, self);
433 Locks::mutator_lock_->SharedUnlock(self);
434 }
Elliott Hughes899e7892012-01-24 14:57:32 -0800435 }
Elliott Hughese0918552011-10-28 17:18:29 -0700436 }
Ian Rogers2f7f9b62012-10-10 18:24:05 -0700437 DumpAllThreads(os, self);
438 }
439
Ian Rogers7b078e82014-09-10 14:44:24 -0700440 // No thread-safety analysis as we do explicitly test for holding the mutator lock.
Ian Rogersc7dd2952014-10-21 23:31:19 -0700441 void DumpThread(std::ostream& os, Thread* self) const NO_THREAD_SAFETY_ANALYSIS {
Ian Rogers7b078e82014-09-10 14:44:24 -0700442 DCHECK(Locks::mutator_lock_->IsExclusiveHeld(self) || Locks::mutator_lock_->IsSharedHeld(self));
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700443 self->Dump(os);
444 if (self->IsExceptionPending()) {
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000445 mirror::Throwable* exception = self->GetException();
446 os << "Pending exception " << exception->Dump();
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700447 }
448 }
449
Ian Rogersc7dd2952014-10-21 23:31:19 -0700450 void DumpAllThreads(std::ostream& os, Thread* self) const {
Ian Rogers4e14e722014-06-27 17:32:56 -0700451 Runtime* runtime = Runtime::Current();
452 if (runtime != nullptr) {
453 ThreadList* thread_list = runtime->GetThreadList();
454 if (thread_list != nullptr) {
455 bool tll_already_held = Locks::thread_list_lock_->IsExclusiveHeld(self);
456 bool ml_already_held = Locks::mutator_lock_->IsSharedHeld(self);
457 if (!tll_already_held || !ml_already_held) {
458 os << "Dumping all threads without appropriate locks held:"
459 << (!tll_already_held ? " thread list lock" : "")
460 << (!ml_already_held ? " mutator lock" : "")
461 << "\n";
462 }
463 os << "All threads:\n";
Ian Rogers7b078e82014-09-10 14:44:24 -0700464 thread_list->Dump(os);
Ian Rogers4e14e722014-06-27 17:32:56 -0700465 }
Ian Rogers2f7f9b62012-10-10 18:24:05 -0700466 }
Elliott Hughese0918552011-10-28 17:18:29 -0700467 }
Andreas Gampe7afa4542016-11-18 09:51:06 -0800468
469 // For recursive aborts.
470 void DumpRecursiveAbort(std::ostream& os) const NO_THREAD_SAFETY_ANALYSIS {
Andreas Gampe9fd470f2016-11-18 17:21:12 -0800471 // The only thing we'll attempt is dumping the native stack of the current thread. We will only
472 // try this if we haven't exceeded an arbitrary amount of recursions, to recover and actually
473 // die.
474 // Note: as we're using a global counter for the recursive abort detection, there is a potential
475 // race here and it is not OK to just print when the counter is "2" (one from
476 // Runtime::Abort(), one from previous Dump() call). Use a number that seems large enough.
477 static constexpr size_t kOnlyPrintWhenRecursionLessThan = 100u;
478 if (gAborting < kOnlyPrintWhenRecursionLessThan) {
479 gAborting++;
480 DumpNativeStack(os, GetTid());
481 }
Andreas Gampe7afa4542016-11-18 09:51:06 -0800482 }
Elliott Hughese0918552011-10-28 17:18:29 -0700483};
484
Andreas Gampe90a32b12016-10-03 19:47:08 -0700485void Runtime::Abort(const char* msg) {
Andreas Gampe247fc332017-06-22 16:18:24 -0700486 auto old_value = gAborting.fetch_add(1); // set before taking any locks
Brian Carlstrom81b88712012-11-05 19:21:30 -0800487
Andreas Gampe51d80cc2017-06-21 21:05:13 -0700488#ifdef ART_TARGET_ANDROID
Andreas Gampe247fc332017-06-22 16:18:24 -0700489 if (old_value == 0) {
490 // Only set the first abort message.
491 android_set_abort_message(msg);
492 }
493#else
494 UNUSED(old_value);
Andreas Gampe51d80cc2017-06-21 21:05:13 -0700495#endif
496
Elliott Hughes131aef82012-01-27 11:53:35 -0800497 // Ensure that we don't have multiple threads trying to abort at once,
498 // which would result in significantly worse diagnostics.
Ian Rogers50b35e22012-10-04 10:09:15 -0700499 MutexLock mu(Thread::Current(), *Locks::abort_lock_);
Elliott Hughes131aef82012-01-27 11:53:35 -0800500
Elliott Hughesffe67362011-07-17 12:09:27 -0700501 // Get any pending output out of the way.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700502 fflush(nullptr);
Elliott Hughesffe67362011-07-17 12:09:27 -0700503
504 // Many people have difficulty distinguish aborts from crashes,
505 // so be explicit.
Andreas Gampeb67906b2016-11-18 09:30:08 -0800506 // Note: use cerr on the host to print log lines immediately, so we get at least some output
507 // in case of recursive aborts. We lose annotation with the source file and line number
508 // here, which is a minor issue. The same is significantly more complicated on device,
509 // which is why we ignore the issue there.
Elliott Hughese0918552011-10-28 17:18:29 -0700510 AbortState state;
Andreas Gampeb67906b2016-11-18 09:30:08 -0800511 if (kIsTargetBuild) {
512 LOG(FATAL_WITHOUT_ABORT) << Dumpable<AbortState>(state);
513 } else {
514 std::cerr << Dumpable<AbortState>(state);
515 }
Elliott Hughesffe67362011-07-17 12:09:27 -0700516
Andreas Gampe90a32b12016-10-03 19:47:08 -0700517 // Sometimes we dump long messages, and the Android abort message only retains the first line.
518 // In those cases, just log the message again, to avoid logcat limits.
519 if (msg != nullptr && strchr(msg, '\n') != nullptr) {
520 LOG(FATAL_WITHOUT_ABORT) << msg;
521 }
522
Elliott Hughes8593fdb2012-04-21 20:53:44 -0700523 // Call the abort hook if we have one.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700524 if (Runtime::Current() != nullptr && Runtime::Current()->abort_ != nullptr) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700525 LOG(FATAL_WITHOUT_ABORT) << "Calling abort hook...";
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700526 Runtime::Current()->abort_();
527 // notreached
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700528 LOG(FATAL_WITHOUT_ABORT) << "Unexpectedly returned from abort hook!";
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700529 }
530
Elliott Hughesdd623db2013-06-11 11:20:23 -0700531#if defined(__GLIBC__)
Elliott Hughesd06a6c72012-05-30 17:59:06 -0700532 // TODO: we ought to be able to use pthread_kill(3) here (or abort(3),
533 // which POSIX defines in terms of raise(3), which POSIX defines in terms
534 // of pthread_kill(3)). On Linux, though, libcorkscrew can't unwind through
535 // libpthread, which means the stacks we dump would be useless. Calling
536 // tgkill(2) directly avoids that.
537 syscall(__NR_tgkill, getpid(), GetTid(), SIGABRT);
Elliott Hughesdd623db2013-06-11 11:20:23 -0700538 // TODO: LLVM installs it's own SIGABRT handler so exit to be safe... Can we disable that in LLVM?
539 // If not, we could use sigaction(3) before calling tgkill(2) and lose this call to exit(3).
Brian Carlstrom700c8d32012-11-05 10:42:02 -0800540 exit(1);
Elliott Hughesdd623db2013-06-11 11:20:23 -0700541#else
542 abort();
Elliott Hughesd06a6c72012-05-30 17:59:06 -0700543#endif
Elliott Hughesffe67362011-07-17 12:09:27 -0700544 // notreached
545}
546
Narayan Kamath3de95a72014-04-02 12:54:23 +0100547void Runtime::PreZygoteFork() {
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700548 heap_->PreZygoteFork();
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700549}
550
Elliott Hughesbf86d042011-08-31 17:53:14 -0700551void Runtime::CallExitHook(jint status) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700552 if (exit_ != nullptr) {
Elliott Hughes34e06962012-04-09 13:55:55 -0700553 ScopedThreadStateChange tsc(Thread::Current(), kNative);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700554 exit_(status);
555 LOG(WARNING) << "Exit hook returned instead of exiting!";
556 }
557}
558
Mathieu Chartier97509952015-07-13 14:35:43 -0700559void Runtime::SweepSystemWeaks(IsMarkedVisitor* visitor) {
560 GetInternTable()->SweepInternTableWeaks(visitor);
561 GetMonitorList()->SweepMonitorList(visitor);
562 GetJavaVM()->SweepJniWeakGlobals(visitor);
563 GetHeap()->SweepAllocationRecords(visitor);
Nicolas Geoffray132d8362016-11-16 09:19:42 +0000564 if (GetJit() != nullptr) {
565 // Visit JIT literal tables. Objects in these tables are classes and strings
566 // and only classes can be affected by class unloading. The strings always
567 // stay alive as they are strongly interned.
568 // TODO: Move this closer to CleanupClassLoaders, to avoid blocking weak accesses
569 // from mutators. See b/32167580.
570 GetJit()->GetCodeCache()->SweepRootTables(visitor);
571 }
Andreas Gampefda57142016-09-08 20:29:18 -0700572
573 // All other generic system-weak holders.
574 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
575 holder->Sweep(visitor);
576 }
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700577}
578
Vladimir Marko88b2b802015-12-04 14:19:04 +0000579bool Runtime::ParseOptions(const RuntimeOptions& raw_options,
580 bool ignore_unrecognized,
581 RuntimeArgumentMap* runtime_options) {
Andreas Gampe51d80cc2017-06-21 21:05:13 -0700582 InitLogging(/* argv */ nullptr, Abort); // Calls Locks::Init() as a side effect.
Vladimir Marko88b2b802015-12-04 14:19:04 +0000583 bool parsed = ParsedOptions::Parse(raw_options, ignore_unrecognized, runtime_options);
584 if (!parsed) {
585 LOG(ERROR) << "Failed to parse options";
586 return false;
587 }
588 return true;
589}
590
David Sehrf42eb2c2016-10-19 13:20:45 -0700591// Callback to check whether it is safe to call Abort (e.g., to use a call to
592// LOG(FATAL)). It is only safe to call Abort if the runtime has been created,
593// properly initialized, and has not shut down.
594static bool IsSafeToCallAbort() NO_THREAD_SAFETY_ANALYSIS {
595 Runtime* runtime = Runtime::Current();
596 return runtime != nullptr && runtime->IsStarted() && !runtime->IsShuttingDownLocked();
597}
598
Vladimir Marko88b2b802015-12-04 14:19:04 +0000599bool Runtime::Create(RuntimeArgumentMap&& runtime_options) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700600 // TODO: acquire a static mutex on Runtime to avoid racing.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700601 if (Runtime::instance_ != nullptr) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700602 return false;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700603 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700604 instance_ = new Runtime;
David Sehrf42eb2c2016-10-19 13:20:45 -0700605 Locks::SetClientCallback(IsSafeToCallAbort);
Vladimir Marko88b2b802015-12-04 14:19:04 +0000606 if (!instance_->Init(std::move(runtime_options))) {
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700607 // TODO: Currently deleting the instance will abort the runtime on destruction. Now This will
608 // leak memory, instead. Fix the destructor. b/19100793.
609 // delete instance_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700610 instance_ = nullptr;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700611 return false;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700612 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700613 return true;
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700614}
Elliott Hughes0af55432011-08-17 18:37:28 -0700615
Vladimir Marko88b2b802015-12-04 14:19:04 +0000616bool Runtime::Create(const RuntimeOptions& raw_options, bool ignore_unrecognized) {
617 RuntimeArgumentMap runtime_options;
618 return ParseOptions(raw_options, ignore_unrecognized, &runtime_options) &&
619 Create(std::move(runtime_options));
620}
621
Andreas Gampe81c6f8d2015-03-25 17:19:53 -0700622static jobject CreateSystemClassLoader(Runtime* runtime) {
623 if (runtime->IsAotCompiler() && !runtime->GetCompilerCallbacks()->IsBootImage()) {
624 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700625 }
626
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700627 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800628 ClassLinker* cl = Runtime::Current()->GetClassLinker();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700629 auto pointer_size = cl->GetImagePointerSize();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700630
Ian Rogers68d8b422014-07-17 11:09:10 -0700631 StackHandleScope<2> hs(soa.Self());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700632 Handle<mirror::Class> class_loader_class(
Mathieu Chartier0795f232016-09-27 18:43:30 -0700633 hs.NewHandle(soa.Decode<mirror::Class>(WellKnownClasses::java_lang_ClassLoader)));
Ian Rogers7b078e82014-09-10 14:44:24 -0700634 CHECK(cl->EnsureInitialized(soa.Self(), class_loader_class, true, true));
Brian Carlstromaded5f72011-10-07 17:15:04 -0700635
Vladimir Markoba118822017-06-12 15:41:56 +0100636 ArtMethod* getSystemClassLoader = class_loader_class->FindClassMethod(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700637 "getSystemClassLoader", "()Ljava/lang/ClassLoader;", pointer_size);
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700638 CHECK(getSystemClassLoader != nullptr);
Vladimir Markoba118822017-06-12 15:41:56 +0100639 CHECK(getSystemClassLoader->IsStatic());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700640
Andreas Gampe13b27842016-11-07 16:48:23 -0800641 JValue result = InvokeWithJValues(soa,
642 nullptr,
643 jni::EncodeArtMethod(getSystemClassLoader),
644 nullptr);
Brian Carlstromce888532013-10-10 00:32:58 -0700645 JNIEnv* env = soa.Self()->GetJniEnv();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700646 ScopedLocalRef<jobject> system_class_loader(env, soa.AddLocalReference<jobject>(result.GetL()));
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800647 CHECK(system_class_loader.get() != nullptr);
Brian Carlstromce888532013-10-10 00:32:58 -0700648
Ian Rogers68d8b422014-07-17 11:09:10 -0700649 soa.Self()->SetClassLoaderOverride(system_class_loader.get());
Ian Rogers365c1022012-06-22 15:05:28 -0700650
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700651 Handle<mirror::Class> thread_class(
Mathieu Chartier0795f232016-09-27 18:43:30 -0700652 hs.NewHandle(soa.Decode<mirror::Class>(WellKnownClasses::java_lang_Thread)));
Ian Rogers7b078e82014-09-10 14:44:24 -0700653 CHECK(cl->EnsureInitialized(soa.Self(), thread_class, true, true));
Ian Rogers365c1022012-06-22 15:05:28 -0700654
Mathieu Chartierc7853442015-03-27 14:35:38 -0700655 ArtField* contextClassLoader =
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800656 thread_class->FindDeclaredInstanceField("contextClassLoader", "Ljava/lang/ClassLoader;");
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700657 CHECK(contextClassLoader != nullptr);
Ian Rogers365c1022012-06-22 15:05:28 -0700658
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100659 // We can't run in a transaction yet.
Mathieu Chartier0795f232016-09-27 18:43:30 -0700660 contextClassLoader->SetObject<false>(
661 soa.Self()->GetPeer(),
Mathieu Chartier1cc62e42016-10-03 18:01:28 -0700662 soa.Decode<mirror::ClassLoader>(system_class_loader.get()).Ptr());
Brian Carlstromce888532013-10-10 00:32:58 -0700663
664 return env->NewGlobalRef(system_class_loader.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700665}
666
Alex Lighta59dd802014-07-02 16:28:08 -0700667std::string Runtime::GetPatchoatExecutable() const {
668 if (!patchoat_executable_.empty()) {
669 return patchoat_executable_;
670 }
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800671 std::string patchoat_executable(GetAndroidRoot());
672 patchoat_executable += (kIsDebugBuild ? "/bin/patchoatd" : "/bin/patchoat");
673 return patchoat_executable;
Alex Lighta59dd802014-07-02 16:28:08 -0700674}
675
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700676std::string Runtime::GetCompilerExecutable() const {
677 if (!compiler_executable_.empty()) {
678 return compiler_executable_;
679 }
680 std::string compiler_executable(GetAndroidRoot());
681 compiler_executable += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
682 return compiler_executable;
683}
684
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700685bool Runtime::Start() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800686 VLOG(startup) << "Runtime::Start entering";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700687
Calin Juravle01aaf6e2015-06-19 22:05:39 +0100688 CHECK(!no_sig_chain_) << "A started runtime should have sig chain enabled";
689
Hiroshi Yamauchi6ffb9cc2015-08-31 15:14:17 -0700690 // If a debug host build, disable ptrace restriction for debugging and test timeout thread dump.
Hiroshi Yamauchic823eff2015-09-01 16:21:35 -0700691 // Only 64-bit as prctl() may fail in 32 bit userspace on a 64-bit kernel.
Bilyan Borisovbb661c02016-04-04 16:27:32 +0100692#if defined(__linux__) && !defined(ART_TARGET_ANDROID) && defined(__x86_64__)
Hiroshi Yamauchi6ffb9cc2015-08-31 15:14:17 -0700693 if (kIsDebugBuild) {
694 CHECK_EQ(prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY), 0);
695 }
696#endif
697
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700698 // Restore main thread state to kNative as expected by native code.
Ian Rogersa436fde2013-08-27 23:34:06 -0700699 Thread* self = Thread::Current();
Alex Light64ad14d2014-08-19 14:23:13 -0700700
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700701 self->TransitionFromRunnableToSuspended(kNative);
702
Brian Carlstrom5d40f182011-09-26 22:29:18 -0700703 started_ = true;
704
Jeff Haodcdc85b2015-12-04 14:06:18 -0800705 if (!IsImageDex2OatEnabled() || !GetHeap()->HasBootImageSpace()) {
Mathieu Chartiereb175f72014-10-31 11:49:27 -0700706 ScopedObjectAccess soa(self);
Przemyslaw Szczepaniaka2b147e2016-05-12 14:55:48 +0100707 StackHandleScope<2> hs(soa.Self());
708
709 auto class_class(hs.NewHandle<mirror::Class>(mirror::Class::GetJavaLangClass()));
710 auto field_class(hs.NewHandle<mirror::Class>(mirror::Field::StaticClass()));
711
712 class_linker_->EnsureInitialized(soa.Self(), class_class, true, true);
713 // Field class is needed for register_java_net_InetAddress in libcore, b/28153851.
714 class_linker_->EnsureInitialized(soa.Self(), field_class, true, true);
Alex Light64ad14d2014-08-19 14:23:13 -0700715 }
716
Brian Carlstromae826982011-11-09 01:33:42 -0800717 // InitNativeMethods needs to be after started_ so that the classes
718 // it touches will have methods linked to the oat file if necessary.
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800719 {
720 ScopedTrace trace2("InitNativeMethods");
721 InitNativeMethods();
722 }
Brian Carlstromae826982011-11-09 01:33:42 -0800723
Ian Rogers365c1022012-06-22 15:05:28 -0700724 // Initialize well known thread group values that may be accessed threads while attaching.
725 InitThreadGroups(self);
726
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500727 Thread::FinishStartup();
728
Andreas Gampe4471e4f2017-01-30 16:40:49 +0000729 // Create the JIT either if we have to use JIT compilation or save profiling info. This is
730 // done after FinishStartup as the JIT pool needs Java thread peers, which require the main
731 // ThreadGroup to exist.
732 //
733 // TODO(calin): We use the JIT class as a proxy for JIT compilation and for
734 // recoding profiles. Maybe we should consider changing the name to be more clear it's
735 // not only about compiling. b/28295073.
736 if (jit_options_->UseJitCompilation() || jit_options_->GetSaveProfilingInfo()) {
737 std::string error_msg;
738 if (!IsZygote()) {
739 // If we are the zygote then we need to wait until after forking to create the code cache
740 // due to SELinux restrictions on r/w/x memory regions.
741 CreateJit();
742 } else if (jit_options_->UseJitCompilation()) {
743 if (!jit::Jit::LoadCompilerLibrary(&error_msg)) {
744 // Try to load compiler pre zygote to reduce PSS. b/27744947
745 LOG(WARNING) << "Failed to load JIT compiler with error " << error_msg;
746 }
747 }
748 }
749
Andreas Gampe48864112017-01-19 17:23:17 -0800750 // Send the start phase event. We have to wait till here as this is when the main thread peer
751 // has just been generated, important root clinits have been run and JNI is completely functional.
752 {
753 ScopedObjectAccess soa(self);
754 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kStart);
755 }
756
Andreas Gampe81c6f8d2015-03-25 17:19:53 -0700757 system_class_loader_ = CreateSystemClassLoader(this);
jgu21a6da74e2014-09-10 06:57:17 -0400758
Robert Sesekb2267032016-09-13 19:12:57 -0400759 if (!is_zygote_) {
Calin Juravle07d83c72014-10-22 21:02:23 +0100760 if (is_native_bridge_loaded_) {
jgu21a6da74e2014-09-10 06:57:17 -0400761 PreInitializeNativeBridge(".");
762 }
Calin Juravled3e7c6c2016-02-04 19:07:51 +0000763 NativeBridgeAction action = force_native_bridge_
764 ? NativeBridgeAction::kInitialize
765 : NativeBridgeAction::kUnload;
Nicolas Geoffrayba69a512015-11-17 13:50:21 +0000766 InitNonZygoteOrPostFork(self->GetJniEnv(),
Nicolas Geoffrayd66c8622015-12-11 14:59:16 +0000767 /* is_system_server */ false,
Calin Juravled3e7c6c2016-02-04 19:07:51 +0000768 action,
Nicolas Geoffrayba69a512015-11-17 13:50:21 +0000769 GetInstructionSetString(kRuntimeISA));
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700770 }
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700771
Andreas Gampeeafaf572017-01-20 12:34:15 -0800772 // Send the initialized phase event. Send it before starting daemons, as otherwise
773 // sending thread events becomes complicated.
774 {
775 ScopedObjectAccess soa(self);
776 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kInit);
777 }
778
Elliott Hughes85d15452011-09-16 17:33:01 -0700779 StartDaemonThreads();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700780
Yevgeny Rouban35aef2c2014-05-19 16:19:36 +0700781 {
782 ScopedObjectAccess soa(self);
783 self->GetJniEnv()->locals.AssertEmpty();
784 }
Elliott Hughes726079d2011-10-07 18:43:44 -0700785
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800786 VLOG(startup) << "Runtime::Start exiting";
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700787 finished_starting_ = true;
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700788
Andreas Gampe40da2862015-02-27 12:49:04 -0800789 if (trace_config_.get() != nullptr && trace_config_->trace_file != "") {
790 ScopedThreadStateChange tsc(self, kWaitingForMethodTracingStart);
791 Trace::Start(trace_config_->trace_file.c_str(),
792 -1,
793 static_cast<int>(trace_config_->trace_file_size),
794 0,
795 trace_config_->trace_output_mode,
796 trace_config_->trace_mode,
797 0);
798 }
799
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700800 return true;
Elliott Hughes85d15452011-09-16 17:33:01 -0700801}
802
Mathieu Chartier90443472015-07-16 20:32:27 -0700803void Runtime::EndThreadBirth() REQUIRES(Locks::runtime_shutdown_lock_) {
Ian Rogers120f1c72012-09-28 17:17:10 -0700804 DCHECK_GT(threads_being_born_, 0U);
805 threads_being_born_--;
806 if (shutting_down_started_ && threads_being_born_ == 0) {
Ian Rogersc604d732012-10-14 16:09:54 -0700807 shutdown_cond_->Broadcast(Thread::Current());
Ian Rogers120f1c72012-09-28 17:17:10 -0700808 }
809}
810
Nicolas Geoffrayd66c8622015-12-11 14:59:16 +0000811void Runtime::InitNonZygoteOrPostFork(
812 JNIEnv* env, bool is_system_server, NativeBridgeAction action, const char* isa) {
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700813 is_zygote_ = false;
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700814
Calin Juravle07d83c72014-10-22 21:02:23 +0100815 if (is_native_bridge_loaded_) {
816 switch (action) {
817 case NativeBridgeAction::kUnload:
818 UnloadNativeBridge();
819 is_native_bridge_loaded_ = false;
820 break;
Andreas Gampe6be67ee2014-09-02 21:22:18 -0700821
Calin Juravle07d83c72014-10-22 21:02:23 +0100822 case NativeBridgeAction::kInitialize:
823 InitializeNativeBridge(env, isa);
824 break;
825 }
Andreas Gampe6be67ee2014-09-02 21:22:18 -0700826 }
827
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800828 // Create the thread pools.
Mathieu Chartier02b6a782012-10-26 13:51:26 -0700829 heap_->CreateThreadPool();
Hiroshi Yamauchi37670172015-06-10 17:20:54 -0700830 // Reset the gc performance data at zygote fork so that the GCs
831 // before fork aren't attributed to an app.
832 heap_->ResetGcPerformanceInfo();
833
Mathieu Chartierf9c917f2017-03-31 14:49:09 -0700834 // We may want to collect profiling samples for system server, but we never want to JIT there.
835 if ((!is_system_server || !jit_options_->UseJitCompilation()) &&
Calin Juravleffc87072016-04-20 14:22:09 +0100836 !safe_mode_ &&
837 (jit_options_->UseJitCompilation() || jit_options_->GetSaveProfilingInfo()) &&
Mathieu Chartierf9c917f2017-03-31 14:49:09 -0700838 jit_ == nullptr) {
Nicolas Geoffrayba69a512015-11-17 13:50:21 +0000839 // Note that when running ART standalone (not zygote, nor zygote fork),
840 // the jit may have already been created.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800841 CreateJit();
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800842 }
Mathieu Chartier02b6a782012-10-26 13:51:26 -0700843
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700844 StartSignalCatcher();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700845
846 // Start the JDWP thread. If the command-line debugger flags specified "suspend=y",
847 // this will pause the runtime, so we probably want this to come last.
Sebastien Hertzb3b173b2015-02-06 09:16:32 +0100848 Dbg::StartJdwp();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700849}
850
851void Runtime::StartSignalCatcher() {
852 if (!is_zygote_) {
Narayan Kamatheb710332017-05-10 11:48:46 +0100853 signal_catcher_ = new SignalCatcher(stack_trace_file_, use_tombstoned_traces_);
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700854 }
855}
856
Mathieu Chartier590fee92013-09-13 13:46:47 -0700857bool Runtime::IsShuttingDown(Thread* self) {
858 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
859 return IsShuttingDownLocked();
860}
861
Elliott Hughes85d15452011-09-16 17:33:01 -0700862void Runtime::StartDaemonThreads() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800863 ScopedTrace trace(__FUNCTION__);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800864 VLOG(startup) << "Runtime::StartDaemonThreads entering";
Elliott Hughes85d15452011-09-16 17:33:01 -0700865
Elliott Hughes719b3232011-09-25 17:42:19 -0700866 Thread* self = Thread::Current();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700867
868 // Must be in the kNative state for calling native methods.
Ian Rogers50b35e22012-10-04 10:09:15 -0700869 CHECK_EQ(self->GetState(), kNative);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700870
Elliott Hughes719b3232011-09-25 17:42:19 -0700871 JNIEnv* env = self->GetJniEnv();
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700872 env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons,
873 WellKnownClasses::java_lang_Daemons_start);
874 if (env->ExceptionCheck()) {
875 env->ExceptionDescribe();
876 LOG(FATAL) << "Error starting java.lang.Daemons";
877 }
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700878
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800879 VLOG(startup) << "Runtime::StartDaemonThreads exiting";
Carl Shapiro61e019d2011-07-14 16:53:09 -0700880}
881
Jeff Haodcdc85b2015-12-04 14:06:18 -0800882// Attempts to open dex files from image(s). Given the image location, try to find the oat file
883// and open it to get the stored dex file. If the image is the first for a multi-image boot
884// classpath, go on and also open the other images.
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700885static bool OpenDexFilesFromImage(const std::string& image_location,
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700886 std::vector<std::unique_ptr<const DexFile>>* dex_files,
887 size_t* failures) {
888 DCHECK(dex_files != nullptr) << "OpenDexFilesFromImage: out-param is nullptr";
Alex Light84d76052014-08-22 17:49:35 -0700889
Jeff Haodcdc85b2015-12-04 14:06:18 -0800890 // Use a work-list approach, so that we can easily reuse the opening code.
891 std::vector<std::string> image_locations;
892 image_locations.push_back(image_location);
893
894 for (size_t index = 0; index < image_locations.size(); ++index) {
895 std::string system_filename;
896 bool has_system = false;
897 std::string cache_filename_unused;
898 bool dalvik_cache_exists_unused;
899 bool has_cache_unused;
900 bool is_global_cache_unused;
901 bool found_image = gc::space::ImageSpace::FindImageFilename(image_locations[index].c_str(),
902 kRuntimeISA,
903 &system_filename,
904 &has_system,
905 &cache_filename_unused,
906 &dalvik_cache_exists_unused,
907 &has_cache_unused,
908 &is_global_cache_unused);
909
910 if (!found_image || !has_system) {
911 return false;
Alex Light84d76052014-08-22 17:49:35 -0700912 }
Jeff Haodcdc85b2015-12-04 14:06:18 -0800913
914 // We are falling back to non-executable use of the oat file because patching failed, presumably
915 // due to lack of space.
David Brazdilc93b3be2016-09-12 18:49:58 +0100916 std::string vdex_filename =
917 ImageHeader::GetVdexLocationFromImageLocation(system_filename.c_str());
Jeff Haodcdc85b2015-12-04 14:06:18 -0800918 std::string oat_filename =
919 ImageHeader::GetOatLocationFromImageLocation(system_filename.c_str());
920 std::string oat_location =
921 ImageHeader::GetOatLocationFromImageLocation(image_locations[index].c_str());
922 // Note: in the multi-image case, the image location may end in ".jar," and not ".art." Handle
923 // that here.
Andreas Gampe9186ced2016-12-12 14:28:21 -0800924 if (android::base::EndsWith(oat_location, ".jar")) {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800925 oat_location.replace(oat_location.length() - 3, 3, "oat");
Alex Light84d76052014-08-22 17:49:35 -0700926 }
David Brazdilc93b3be2016-09-12 18:49:58 +0100927 std::string error_msg;
928
929 std::unique_ptr<VdexFile> vdex_file(VdexFile::Open(vdex_filename,
930 false /* writable */,
931 false /* low_4gb */,
Nicolas Geoffray4e868fa2017-04-21 17:16:44 +0100932 false, /* unquicken */
David Brazdilc93b3be2016-09-12 18:49:58 +0100933 &error_msg));
934 if (vdex_file.get() == nullptr) {
935 return false;
936 }
Jeff Haodcdc85b2015-12-04 14:06:18 -0800937
938 std::unique_ptr<File> file(OS::OpenFileForReading(oat_filename.c_str()));
939 if (file.get() == nullptr) {
940 return false;
941 }
Brian Carlstromf5b0f2c2016-10-14 01:04:26 -0700942 std::unique_ptr<ElfFile> elf_file(ElfFile::Open(file.get(),
David Brazdilc93b3be2016-09-12 18:49:58 +0100943 false /* writable */,
944 false /* program_header_only */,
945 false /* low_4gb */,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -0800946 &error_msg));
Jeff Haodcdc85b2015-12-04 14:06:18 -0800947 if (elf_file.get() == nullptr) {
948 return false;
949 }
950 std::unique_ptr<const OatFile> oat_file(
David Brazdilc93b3be2016-09-12 18:49:58 +0100951 OatFile::OpenWithElfFile(elf_file.release(),
952 vdex_file.release(),
953 oat_location,
954 nullptr,
955 &error_msg));
Jeff Haodcdc85b2015-12-04 14:06:18 -0800956 if (oat_file == nullptr) {
957 LOG(WARNING) << "Unable to use '" << oat_filename << "' because " << error_msg;
958 return false;
959 }
960
961 for (const OatFile::OatDexFile* oat_dex_file : oat_file->GetOatDexFiles()) {
962 if (oat_dex_file == nullptr) {
963 *failures += 1;
964 continue;
965 }
966 std::unique_ptr<const DexFile> dex_file = oat_dex_file->OpenDexFile(&error_msg);
967 if (dex_file.get() == nullptr) {
968 *failures += 1;
969 } else {
970 dex_files->push_back(std::move(dex_file));
971 }
972 }
973
974 if (index == 0) {
975 // First file. See if this is a multi-image environment, and if so, enqueue the other images.
976 const OatHeader& boot_oat_header = oat_file->GetOatHeader();
Jeff Haof0192c82016-03-28 20:39:50 -0700977 const char* boot_cp = boot_oat_header.GetStoreValueByKey(OatHeader::kBootClassPathKey);
Jeff Haodcdc85b2015-12-04 14:06:18 -0800978 if (boot_cp != nullptr) {
Mathieu Chartier866d8742016-09-21 15:24:18 -0700979 gc::space::ImageSpace::ExtractMultiImageLocations(image_locations[0],
980 boot_cp,
981 &image_locations);
Jeff Haodcdc85b2015-12-04 14:06:18 -0800982 }
983 }
984
985 Runtime::Current()->GetOatFileManager().RegisterOatFile(std::move(oat_file));
Alex Light84d76052014-08-22 17:49:35 -0700986 }
Alex Light84d76052014-08-22 17:49:35 -0700987 return true;
988}
989
990
Alex Light64ad14d2014-08-19 14:23:13 -0700991static size_t OpenDexFiles(const std::vector<std::string>& dex_filenames,
Richard Uhlerc2752592015-01-02 13:28:22 -0800992 const std::vector<std::string>& dex_locations,
Alex Light84d76052014-08-22 17:49:35 -0700993 const std::string& image_location,
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700994 std::vector<std::unique_ptr<const DexFile>>* dex_files) {
995 DCHECK(dex_files != nullptr) << "OpenDexFiles: out-param is nullptr";
Alex Light64ad14d2014-08-19 14:23:13 -0700996 size_t failure_count = 0;
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700997 if (!image_location.empty() && OpenDexFilesFromImage(image_location, dex_files, &failure_count)) {
Alex Light84d76052014-08-22 17:49:35 -0700998 return failure_count;
999 }
1000 failure_count = 0;
Alex Light64ad14d2014-08-19 14:23:13 -07001001 for (size_t i = 0; i < dex_filenames.size(); i++) {
1002 const char* dex_filename = dex_filenames[i].c_str();
Richard Uhlerc2752592015-01-02 13:28:22 -08001003 const char* dex_location = dex_locations[i].c_str();
Aart Bik37d6a3b2016-06-21 18:30:10 -07001004 static constexpr bool kVerifyChecksum = true;
Alex Light64ad14d2014-08-19 14:23:13 -07001005 std::string error_msg;
1006 if (!OS::FileExists(dex_filename)) {
1007 LOG(WARNING) << "Skipping non-existent dex file '" << dex_filename << "'";
1008 continue;
1009 }
Aart Bik37d6a3b2016-06-21 18:30:10 -07001010 if (!DexFile::Open(dex_filename, dex_location, kVerifyChecksum, &error_msg, dex_files)) {
Alex Light64ad14d2014-08-19 14:23:13 -07001011 LOG(WARNING) << "Failed to open .dex from file '" << dex_filename << "': " << error_msg;
1012 ++failure_count;
1013 }
1014 }
1015 return failure_count;
1016}
1017
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001018void Runtime::SetSentinel(mirror::Object* sentinel) {
1019 CHECK(sentinel_.Read() == nullptr);
1020 CHECK(sentinel != nullptr);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08001021 CHECK(!heap_->IsMovableObject(sentinel));
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001022 sentinel_ = GcRoot<mirror::Object>(sentinel);
1023}
1024
Vladimir Marko88b2b802015-12-04 14:19:04 +00001025bool Runtime::Init(RuntimeArgumentMap&& runtime_options_in) {
David Sehrd106d9f2016-08-16 19:22:57 -07001026 // (b/30160149): protect subprocesses from modifications to LD_LIBRARY_PATH, etc.
1027 // Take a snapshot of the environment at the time the runtime was created, for use by Exec, etc.
1028 env_snapshot_.TakeSnapshot();
1029
Vladimir Marko88b2b802015-12-04 14:19:04 +00001030 RuntimeArgumentMap runtime_options(std::move(runtime_options_in));
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001031 ScopedTrace trace(__FUNCTION__);
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001032 CHECK_EQ(sysconf(_SC_PAGE_SIZE), kPageSize);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001033
Mathieu Chartier6e88ef62014-10-14 15:01:24 -07001034 MemMap::Init();
1035
Andreas Gampe5f2a2fc2017-05-18 17:45:07 -07001036 // Try to reserve a dedicated fault page. This is allocated for clobbered registers and sentinels.
1037 // If we cannot reserve it, log a warning.
1038 // Note: We allocate this first to have a good chance of grabbing the page. The address (0xebad..)
1039 // is out-of-the-way enough that it should not collide with boot image mapping.
1040 // Note: Don't request an error message. That will lead to a maps dump in the case of failure,
1041 // leading to logspam.
1042 {
1043 constexpr uintptr_t kSentinelAddr =
1044 RoundDown(static_cast<uintptr_t>(Context::kBadGprBase), kPageSize);
1045 protected_fault_page_.reset(MemMap::MapAnonymous("Sentinel fault page",
1046 reinterpret_cast<uint8_t*>(kSentinelAddr),
1047 kPageSize,
1048 PROT_NONE,
1049 /* low_4g */ true,
1050 /* reuse */ false,
1051 /* error_msg */ nullptr));
1052 if (protected_fault_page_ == nullptr) {
1053 LOG(WARNING) << "Could not reserve sentinel fault page";
1054 } else if (reinterpret_cast<uintptr_t>(protected_fault_page_->Begin()) != kSentinelAddr) {
1055 LOG(WARNING) << "Could not reserve sentinel fault page at the right address.";
1056 protected_fault_page_.reset();
1057 }
1058 }
1059
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001060 using Opt = RuntimeArgumentMap;
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001061 VLOG(startup) << "Runtime::Init -verbose:startup enabled";
Elliott Hughes7ede61e2011-09-14 18:18:06 -07001062
Elliott Hughes7c6169d2012-05-02 16:11:48 -07001063 QuasiAtomic::Startup();
1064
Mathieu Chartiere58991b2015-10-13 07:59:34 -07001065 oat_file_manager_ = new OatFileManager;
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -07001066
Calin Juravleb2771b42016-04-07 17:09:25 +01001067 Thread::SetSensitiveThreadHook(runtime_options.GetOrDefault(Opt::HookIsSensitiveThread));
Andreas Gamped0210e52017-06-23 13:38:09 -07001068 Monitor::Init(runtime_options.GetOrDefault(Opt::LockProfThreshold),
1069 runtime_options.GetOrDefault(Opt::StackDumpLockProfThreshold));
Elliott Hughes32d6e1e2011-10-11 14:47:44 -07001070
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001071 boot_class_path_string_ = runtime_options.ReleaseOrDefault(Opt::BootClassPath);
1072 class_path_string_ = runtime_options.ReleaseOrDefault(Opt::ClassPath);
1073 properties_ = runtime_options.ReleaseOrDefault(Opt::PropertiesList);
Elliott Hughes7ede61e2011-09-14 18:18:06 -07001074
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001075 compiler_callbacks_ = runtime_options.GetOrDefault(Opt::CompilerCallbacksPtr);
1076 patchoat_executable_ = runtime_options.ReleaseOrDefault(Opt::PatchOat);
1077 must_relocate_ = runtime_options.GetOrDefault(Opt::Relocate);
1078 is_zygote_ = runtime_options.Exists(Opt::Zygote);
1079 is_explicit_gc_disabled_ = runtime_options.Exists(Opt::DisableExplicitGC);
1080 dex2oat_enabled_ = runtime_options.GetOrDefault(Opt::Dex2Oat);
1081 image_dex2oat_enabled_ = runtime_options.GetOrDefault(Opt::ImageDex2Oat);
Nicolas Geoffraya73280d2016-02-15 13:05:16 +00001082 dump_native_stack_on_sig_quit_ = runtime_options.GetOrDefault(Opt::DumpNativeStackOnSigQuit);
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -07001083
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001084 vfprintf_ = runtime_options.GetOrDefault(Opt::HookVfprintf);
1085 exit_ = runtime_options.GetOrDefault(Opt::HookExit);
1086 abort_ = runtime_options.GetOrDefault(Opt::HookAbort);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001087
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001088 default_stack_size_ = runtime_options.GetOrDefault(Opt::StackSize);
Narayan Kamatheb710332017-05-10 11:48:46 +01001089 use_tombstoned_traces_ = runtime_options.GetOrDefault(Opt::UseTombstonedTraces);
1090#if !defined(ART_TARGET_ANDROID)
1091 CHECK(!use_tombstoned_traces_)
1092 << "-Xusetombstonedtraces is only supported in an Android environment";
1093#endif
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001094 stack_trace_file_ = runtime_options.ReleaseOrDefault(Opt::StackTraceFile);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001095
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001096 compiler_executable_ = runtime_options.ReleaseOrDefault(Opt::Compiler);
1097 compiler_options_ = runtime_options.ReleaseOrDefault(Opt::CompilerOptions);
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00001098 for (StringPiece option : Runtime::Current()->GetCompilerOptions()) {
1099 if (option.starts_with("--debuggable")) {
1100 SetJavaDebuggable(true);
1101 break;
1102 }
1103 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001104 image_compiler_options_ = runtime_options.ReleaseOrDefault(Opt::ImageCompilerOptions);
1105 image_location_ = runtime_options.GetOrDefault(Opt::Image);
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001106
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001107 max_spins_before_thin_lock_inflation_ =
1108 runtime_options.GetOrDefault(Opt::MaxSpinsBeforeThinLockInflation);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001109
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001110 monitor_list_ = new MonitorList;
Ian Rogersef7d42f2014-01-06 12:55:46 -08001111 monitor_pool_ = MonitorPool::Create();
Mathieu Chartier3fceaf52017-01-22 13:33:40 -08001112 thread_list_ = new ThreadList(runtime_options.GetOrDefault(Opt::ThreadSuspendTimeout));
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001113 intern_table_ = new InternTable;
1114
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001115 verify_ = runtime_options.GetOrDefault(Opt::Verify);
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -07001116 allow_dex_file_fallback_ = !runtime_options.Exists(Opt::NoDexFileFallback);
Logan Chiendd361c92012-04-10 23:40:37 +08001117
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001118 no_sig_chain_ = runtime_options.Exists(Opt::NoSigChain);
Calin Juravled3e7c6c2016-02-04 19:07:51 +00001119 force_native_bridge_ = runtime_options.Exists(Opt::ForceNativeBridge);
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001120
Dmitriy Ivanov785049f2014-07-18 10:08:57 -07001121 Split(runtime_options.GetOrDefault(Opt::CpuAbiList), ',', &cpu_abilist_);
1122
Andreas Gampedd671252015-07-23 14:37:18 -07001123 fingerprint_ = runtime_options.ReleaseOrDefault(Opt::Fingerprint);
1124
Igor Murashkineb6c7c22015-02-04 17:30:43 -08001125 if (runtime_options.GetOrDefault(Opt::Interpret)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001126 GetInstrumentation()->ForceInterpretOnly();
1127 }
1128
Narayan Kamath5a2be3f2015-02-16 13:51:51 +00001129 zygote_max_failed_boots_ = runtime_options.GetOrDefault(Opt::ZygoteMaxFailedBoots);
Alex Lighteb7c1442015-08-31 13:17:42 -07001130 experimental_flags_ = runtime_options.GetOrDefault(Opt::Experimental);
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -07001131 is_low_memory_mode_ = runtime_options.Exists(Opt::LowMemoryMode);
Narayan Kamath5a2be3f2015-02-16 13:51:51 +00001132
Andreas Gampe01fd70b2017-01-25 10:03:08 -08001133 plugins_ = runtime_options.ReleaseOrDefault(Opt::Plugins);
1134 agents_ = runtime_options.ReleaseOrDefault(Opt::AgentPath);
1135 // TODO Add back in -agentlib
1136 // for (auto lib : runtime_options.ReleaseOrDefault(Opt::AgentLib)) {
1137 // agents_.push_back(lib);
1138 // }
1139
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001140 XGcOption xgc_option = runtime_options.GetOrDefault(Opt::GcOption);
1141 heap_ = new gc::Heap(runtime_options.GetOrDefault(Opt::MemoryInitialSize),
1142 runtime_options.GetOrDefault(Opt::HeapGrowthLimit),
1143 runtime_options.GetOrDefault(Opt::HeapMinFree),
1144 runtime_options.GetOrDefault(Opt::HeapMaxFree),
1145 runtime_options.GetOrDefault(Opt::HeapTargetUtilization),
1146 runtime_options.GetOrDefault(Opt::ForegroundHeapGrowthMultiplier),
1147 runtime_options.GetOrDefault(Opt::MemoryMaximumSize),
1148 runtime_options.GetOrDefault(Opt::NonMovingSpaceCapacity),
1149 runtime_options.GetOrDefault(Opt::Image),
1150 runtime_options.GetOrDefault(Opt::ImageInstructionSet),
Hiroshi Yamauchi1b0adbf2016-11-14 17:35:12 -08001151 // Override the collector type to CC if the read barrier config.
1152 kUseReadBarrier ? gc::kCollectorTypeCC : xgc_option.collector_type_,
1153 kUseReadBarrier ? BackgroundGcOption(gc::kCollectorTypeCCBackground)
1154 : runtime_options.GetOrDefault(Opt::BackgroundGc),
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001155 runtime_options.GetOrDefault(Opt::LargeObjectSpace),
1156 runtime_options.GetOrDefault(Opt::LargeObjectThreshold),
1157 runtime_options.GetOrDefault(Opt::ParallelGCThreads),
1158 runtime_options.GetOrDefault(Opt::ConcGCThreads),
1159 runtime_options.Exists(Opt::LowMemoryMode),
1160 runtime_options.GetOrDefault(Opt::LongPauseLogThreshold),
1161 runtime_options.GetOrDefault(Opt::LongGCLogThreshold),
1162 runtime_options.Exists(Opt::IgnoreMaxFootprint),
Hiroshi Yamauchif360ad02015-02-20 11:28:03 -08001163 runtime_options.GetOrDefault(Opt::UseTLAB),
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001164 xgc_option.verify_pre_gc_heap_,
1165 xgc_option.verify_pre_sweeping_heap_,
1166 xgc_option.verify_post_gc_heap_,
1167 xgc_option.verify_pre_gc_rosalloc_,
1168 xgc_option.verify_pre_sweeping_rosalloc_,
1169 xgc_option.verify_post_gc_rosalloc_,
Mathieu Chartier31000802015-06-14 14:14:37 -07001170 xgc_option.gcstress_,
Mathieu Chartier56fe2582016-07-14 13:30:03 -07001171 xgc_option.measure_,
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001172 runtime_options.GetOrDefault(Opt::EnableHSpaceCompactForOOM),
1173 runtime_options.GetOrDefault(Opt::HSpaceCompactForOOMMinIntervalsMs));
Dave Allison3d14eb62014-07-10 01:54:57 +00001174
Jeff Haodcdc85b2015-12-04 14:06:18 -08001175 if (!heap_->HasBootImageSpace() && !allow_dex_file_fallback_) {
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -07001176 LOG(ERROR) << "Dex file fallback disabled, cannot continue without image.";
1177 return false;
1178 }
1179
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001180 dump_gc_performance_on_shutdown_ = runtime_options.Exists(Opt::DumpGCPerformanceOnShutdown);
Dave Allison3d14eb62014-07-10 01:54:57 +00001181
Sebastien Hertz3be6e9d2015-02-05 16:30:58 +01001182 if (runtime_options.Exists(Opt::JdwpOptions)) {
Sebastien Hertzb3b173b2015-02-06 09:16:32 +01001183 Dbg::ConfigureJdwp(runtime_options.GetOrDefault(Opt::JdwpOptions));
Sebastien Hertz3be6e9d2015-02-05 16:30:58 +01001184 }
Andreas Gampeac30fa22017-01-18 21:02:36 -08001185 callbacks_->AddThreadLifecycleCallback(Dbg::GetThreadLifecycleCallback());
1186 callbacks_->AddClassLoadCallback(Dbg::GetClassLoadCallback());
Sebastien Hertz3be6e9d2015-02-05 16:30:58 +01001187
Mathieu Chartier455f67c2015-03-17 13:48:29 -07001188 jit_options_.reset(jit::JitOptions::CreateFromRuntimeArguments(runtime_options));
Mathieu Chartier455f67c2015-03-17 13:48:29 -07001189 if (IsAotCompiler()) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08001190 // If we are already the compiler at this point, we must be dex2oat. Don't create the jit in
1191 // this case.
1192 // If runtime_options doesn't have UseJIT set to true then CreateFromRuntimeArguments returns
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001193 // null and we don't create the jit.
Calin Juravleffc87072016-04-20 14:22:09 +01001194 jit_options_->SetUseJitCompilation(false);
1195 jit_options_->SetSaveProfilingInfo(false);
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08001196 }
1197
Mathieu Chartierc6201fa2015-03-12 10:06:33 -07001198 // Use MemMap arena pool for jit, malloc otherwise. Malloc arenas are faster to allocate but
1199 // can't be trimmed as easily.
Mathieu Chartiere401d142015-04-22 13:56:20 -07001200 const bool use_malloc = IsAotCompiler();
Nicolas Geoffray25e04562016-03-01 13:17:58 +00001201 arena_pool_.reset(new ArenaPool(use_malloc, /* low_4gb */ false));
1202 jit_arena_pool_.reset(
1203 new ArenaPool(/* use_malloc */ false, /* low_4gb */ false, "CompilerMetadata"));
1204
Mathieu Chartier017ed0b2015-09-22 11:04:26 -07001205 if (IsAotCompiler() && Is64BitInstructionSet(kRuntimeISA)) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07001206 // 4gb, no malloc. Explanation in header.
Nicolas Geoffray25e04562016-03-01 13:17:58 +00001207 low_4gb_arena_pool_.reset(new ArenaPool(/* use_malloc */ false, /* low_4gb */ true));
Mathieu Chartierc7853442015-03-27 14:35:38 -07001208 }
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07001209 linear_alloc_.reset(CreateLinearAlloc());
Mathieu Chartierc6201fa2015-03-12 10:06:33 -07001210
Dave Allison3d14eb62014-07-10 01:54:57 +00001211 BlockSignals();
1212 InitPlatformSignalHandlers();
1213
Dave Allison69dfe512014-07-11 17:11:58 +00001214 // Change the implicit checks flags based on runtime architecture.
1215 switch (kRuntimeISA) {
1216 case kArm:
1217 case kThumb2:
1218 case kX86:
Stuart Monteithd5c78f42014-06-11 16:44:46 +01001219 case kArm64:
Dave Allisondfd3b472014-07-16 16:04:32 -07001220 case kX86_64:
Douglas Leung22bb5a22015-07-02 16:42:08 -07001221 case kMips:
1222 case kMips64:
Dave Allison69dfe512014-07-11 17:11:58 +00001223 implicit_null_checks_ = true;
Andreas Gampe928f72b2014-09-09 19:53:48 -07001224 // Installing stack protection does not play well with valgrind.
Evgenii Stepanov1e133742015-05-20 12:30:59 -07001225 implicit_so_checks_ = !(RUNNING_ON_MEMORY_TOOL && kMemoryToolIsValgrind);
Dave Allison69dfe512014-07-11 17:11:58 +00001226 break;
1227 default:
1228 // Keep the defaults.
1229 break;
1230 }
1231
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001232 if (!no_sig_chain_) {
1233 // Dex2Oat's Runtime does not need the signal chain or the fault handler.
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001234 if (implicit_null_checks_ || implicit_so_checks_ || implicit_suspend_checks_) {
1235 fault_manager.Init();
Dave Allison69dfe512014-07-11 17:11:58 +00001236
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001237 // These need to be in a specific order. The null point check handler must be
1238 // after the suspend check and stack overflow check handlers.
1239 //
1240 // Note: the instances attach themselves to the fault manager and are handled by it. The manager
1241 // will delete the instance on Shutdown().
1242 if (implicit_suspend_checks_) {
1243 new SuspensionHandler(&fault_manager);
1244 }
Dave Allison69dfe512014-07-11 17:11:58 +00001245
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001246 if (implicit_so_checks_) {
1247 new StackOverflowHandler(&fault_manager);
1248 }
Dave Allison69dfe512014-07-11 17:11:58 +00001249
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001250 if (implicit_null_checks_) {
1251 new NullPointerHandler(&fault_manager);
1252 }
1253
1254 if (kEnableJavaStackTraceHandler) {
1255 new JavaStackTraceHandler(&fault_manager);
1256 }
Dave Allison69dfe512014-07-11 17:11:58 +00001257 }
1258 }
1259
Richard Uhlerda0a69e2016-10-11 15:06:38 +01001260 std::string error_msg;
1261 java_vm_ = JavaVMExt::Create(this, runtime_options, &error_msg);
1262 if (java_vm_.get() == nullptr) {
1263 LOG(ERROR) << "Could not initialize JavaVMExt: " << error_msg;
1264 return false;
1265 }
Elliott Hughes515a5bc2011-08-17 11:08:34 -07001266
Alex Light185d1342016-08-11 10:48:03 -07001267 // Add the JniEnv handler.
1268 // TODO Refactor this stuff.
1269 java_vm_->AddEnvironmentHook(JNIEnvExt::GetEnvHandler);
1270
Elliott Hughesbe759c62011-09-08 19:38:21 -07001271 Thread::Startup();
Elliott Hughesd92bec42011-09-02 17:04:36 -07001272
Mathieu Chartier664bebf2012-11-12 16:54:11 -08001273 // ClassLinker needs an attached thread, but we can't fully attach a thread without creating
1274 // objects. We can't supply a thread group yet; it will be fixed later. Since we are the main
1275 // thread, we do not get a java peer.
Ian Rogers63557452014-06-04 16:57:15 -07001276 Thread* self = Thread::Attach("main", false, nullptr, false);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001277 CHECK_EQ(self->GetThreadId(), ThreadList::kMainThreadId);
Ian Rogers63557452014-06-04 16:57:15 -07001278 CHECK(self != nullptr);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001279
Calin Juravleccd56952016-12-15 17:57:38 +00001280 self->SetCanCallIntoJava(!IsAotCompiler());
1281
Brian Carlstromf28bc5b2011-10-26 01:15:03 -07001282 // Set us to runnable so tools using a runtime can allocate and GC by default
Ian Rogers120f1c72012-09-28 17:17:10 -07001283 self->TransitionFromSuspendedToRunnable();
Brian Carlstromf28bc5b2011-10-26 01:15:03 -07001284
Ian Rogersa436fde2013-08-27 23:34:06 -07001285 // Now we're attached, we can take the heap locks and validate the heap.
Ian Rogers141d6222012-04-05 12:23:06 -07001286 GetHeap()->EnableObjectValidation();
1287
Ian Rogers1d54e732013-05-02 21:10:01 -07001288 CHECK_GE(GetHeap()->GetContinuousSpaces().size(), 1U);
Mathieu Chartier590fee92013-09-13 13:46:47 -07001289 class_linker_ = new ClassLinker(intern_table_);
Mingyao Yang063fc772016-08-02 11:02:54 -07001290 cha_ = new ClassHierarchyAnalysis;
Jeff Haodcdc85b2015-12-04 14:06:18 -08001291 if (GetHeap()->HasBootImageSpace()) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001292 bool result = class_linker_->InitFromBootImage(&error_msg);
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001293 if (!result) {
1294 LOG(ERROR) << "Could not initialize from image: " << error_msg;
1295 return false;
1296 }
Hiroshi Yamauchibd0fb612014-05-20 13:46:00 -07001297 if (kIsDebugBuild) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08001298 for (auto image_space : GetHeap()->GetBootImageSpaces()) {
1299 image_space->VerifyImageAllocations();
1300 }
Hiroshi Yamauchibd0fb612014-05-20 13:46:00 -07001301 }
Sebastien Hertze6c143f2015-01-13 10:10:40 +01001302 if (boot_class_path_string_.empty()) {
1303 // The bootclasspath is not explicitly specified: construct it from the loaded dex files.
1304 const std::vector<const DexFile*>& boot_class_path = GetClassLinker()->GetBootClassPath();
1305 std::vector<std::string> dex_locations;
1306 dex_locations.reserve(boot_class_path.size());
1307 for (const DexFile* dex_file : boot_class_path) {
1308 dex_locations.push_back(dex_file->GetLocation());
1309 }
Andreas Gampe9186ced2016-12-12 14:28:21 -08001310 boot_class_path_string_ = android::base::Join(dex_locations, ':');
Sebastien Hertze6c143f2015-01-13 10:10:40 +01001311 }
Vladimir Markocac5a7e2016-02-22 10:39:50 +00001312 {
1313 ScopedTrace trace2("AddImageStringsToTable");
1314 GetInternTable()->AddImagesStringsToTable(heap_->GetBootImageSpaces());
1315 }
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00001316 if (IsJavaDebuggable()) {
1317 // Now that we have loaded the boot image, deoptimize its methods if we are running
1318 // debuggable, as the code may have been compiled non-debuggable.
1319 DeoptimizeBootImage();
1320 }
Richard Uhlerc2752592015-01-02 13:28:22 -08001321 } else {
Alex Light64ad14d2014-08-19 14:23:13 -07001322 std::vector<std::string> dex_filenames;
Ian Rogers6f3dbba2014-10-14 17:41:57 -07001323 Split(boot_class_path_string_, ':', &dex_filenames);
Richard Uhlerc2752592015-01-02 13:28:22 -08001324
1325 std::vector<std::string> dex_locations;
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001326 if (!runtime_options.Exists(Opt::BootClassPathLocations)) {
Richard Uhlerc2752592015-01-02 13:28:22 -08001327 dex_locations = dex_filenames;
1328 } else {
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001329 dex_locations = runtime_options.GetOrDefault(Opt::BootClassPathLocations);
Richard Uhlerc2752592015-01-02 13:28:22 -08001330 CHECK_EQ(dex_filenames.size(), dex_locations.size());
1331 }
1332
Richard Uhlerfbef44d2014-12-23 09:48:51 -08001333 std::vector<std::unique_ptr<const DexFile>> boot_class_path;
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001334 if (runtime_options.Exists(Opt::BootClassPathDexList)) {
1335 boot_class_path.swap(*runtime_options.GetOrDefault(Opt::BootClassPathDexList));
1336 } else {
1337 OpenDexFiles(dex_filenames,
1338 dex_locations,
1339 runtime_options.GetOrDefault(Opt::Image),
1340 &boot_class_path);
1341 }
Jeff Haoc7d11882015-02-03 15:08:39 -08001342 instruction_set_ = runtime_options.GetOrDefault(Opt::ImageInstructionSet);
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001343 if (!class_linker_->InitWithoutImage(std::move(boot_class_path), &error_msg)) {
1344 LOG(ERROR) << "Could not initialize without image: " << error_msg;
1345 return false;
1346 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001347
Alex Light64ad14d2014-08-19 14:23:13 -07001348 // TODO: Should we move the following to InitWithoutImage?
Jeff Haoc7d11882015-02-03 15:08:39 -08001349 SetInstructionSet(instruction_set_);
Andreas Gampe8228cdf2017-05-30 15:03:54 -07001350 for (uint32_t i = 0; i < kCalleeSaveSize; i++) {
1351 CalleeSaveType type = CalleeSaveType(i);
Alex Light64ad14d2014-08-19 14:23:13 -07001352 if (!HasCalleeSaveMethod(type)) {
Ian Rogers6a3c1fc2014-10-31 00:33:20 -07001353 SetCalleeSaveMethod(CreateCalleeSaveMethod(), type);
Alex Light64ad14d2014-08-19 14:23:13 -07001354 }
1355 }
Igor Murashkina2cfee32015-01-07 16:37:24 -08001356 }
1357
Ian Rogers63557452014-06-04 16:57:15 -07001358 CHECK(class_linker_ != nullptr);
Ian Rogersc0542af2014-09-03 16:16:56 -07001359
Sameer Abu Asal51a5fb72013-02-19 14:25:01 -08001360 verifier::MethodVerifier::Init();
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001361
Andreas Gampef6a780a2015-04-02 18:51:05 -07001362 if (runtime_options.Exists(Opt::MethodTrace)) {
1363 trace_config_.reset(new TraceConfig());
1364 trace_config_->trace_file = runtime_options.ReleaseOrDefault(Opt::MethodTraceFile);
1365 trace_config_->trace_file_size = runtime_options.ReleaseOrDefault(Opt::MethodTraceFileSize);
1366 trace_config_->trace_mode = Trace::TraceMode::kMethodTracing;
Andreas Gampe40da2862015-02-27 12:49:04 -08001367 trace_config_->trace_output_mode = runtime_options.Exists(Opt::MethodTraceStreaming) ?
1368 Trace::TraceOutputMode::kStreaming :
1369 Trace::TraceOutputMode::kFile;
Andreas Gampef6a780a2015-04-02 18:51:05 -07001370 }
jeffhaob5e81852012-03-12 11:15:45 -07001371
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08001372 // TODO: move this to just be an Trace::Start argument
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001373 Trace::SetDefaultClockSource(runtime_options.GetOrDefault(Opt::ProfileClock));
Dave Allison0aded082013-11-07 13:15:11 -08001374
Ian Rogersa436fde2013-08-27 23:34:06 -07001375 // Pre-allocate an OutOfMemoryError for the double-OOME case.
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +00001376 self->ThrowNewException("Ljava/lang/OutOfMemoryError;",
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08001377 "OutOfMemoryError thrown while trying to throw OutOfMemoryError; "
Elliott Hughes4f55ff62014-10-21 07:36:19 -07001378 "no stack trace available");
Nicolas Geoffray14691c52015-03-05 10:40:17 +00001379 pre_allocated_OutOfMemoryError_ = GcRoot<mirror::Throwable>(self->GetException());
Ian Rogersa436fde2013-08-27 23:34:06 -07001380 self->ClearException();
1381
Ian Rogers63557452014-06-04 16:57:15 -07001382 // Pre-allocate a NoClassDefFoundError for the common case of failing to find a system class
1383 // ahead of checking the application's class loader.
Nicolas Geoffray0aa50ce2015-03-10 11:03:29 +00001384 self->ThrowNewException("Ljava/lang/NoClassDefFoundError;",
Elliott Hughes4f55ff62014-10-21 07:36:19 -07001385 "Class not found using the boot class loader; no stack trace available");
Nicolas Geoffray14691c52015-03-05 10:40:17 +00001386 pre_allocated_NoClassDefFoundError_ = GcRoot<mirror::Throwable>(self->GetException());
Ian Rogers63557452014-06-04 16:57:15 -07001387 self->ClearException();
1388
Alex Light185d1342016-08-11 10:48:03 -07001389 // Runtime initialization is largely done now.
1390 // We load plugins first since that can modify the runtime state slightly.
1391 // Load all plugins
1392 for (auto& plugin : plugins_) {
1393 std::string err;
1394 if (!plugin.Load(&err)) {
1395 LOG(FATAL) << plugin << " failed to load: " << err;
1396 }
1397 }
1398
Andreas Gampe855564b2014-07-25 02:32:19 -07001399 // Look for a native bridge.
Andreas Gampe6be67ee2014-09-02 21:22:18 -07001400 //
1401 // The intended flow here is, in the case of a running system:
1402 //
1403 // Runtime::Init() (zygote):
1404 // LoadNativeBridge -> dlopen from cmd line parameter.
1405 // |
1406 // V
1407 // Runtime::Start() (zygote):
1408 // No-op wrt native bridge.
1409 // |
1410 // | start app
1411 // V
1412 // DidForkFromZygote(action)
1413 // action = kUnload -> dlclose native bridge.
1414 // action = kInitialize -> initialize library
1415 //
1416 //
1417 // The intended flow here is, in the case of a simple dalvikvm call:
1418 //
1419 // Runtime::Init():
1420 // LoadNativeBridge -> dlopen from cmd line parameter.
1421 // |
1422 // V
1423 // Runtime::Start():
1424 // DidForkFromZygote(kInitialize) -> try to initialize any native bridge given.
1425 // No-op wrt native bridge.
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001426 {
1427 std::string native_bridge_file_name = runtime_options.ReleaseOrDefault(Opt::NativeBridge);
1428 is_native_bridge_loaded_ = LoadNativeBridge(native_bridge_file_name);
1429 }
Calin Juravlea68629e2014-08-22 12:53:59 +01001430
Alex Light7233c7e2016-07-28 10:07:45 -07001431 // Startup agents
1432 // TODO Maybe we should start a new thread to run these on. Investigate RI behavior more.
1433 for (auto& agent : agents_) {
1434 // TODO Check err
1435 int res = 0;
1436 std::string err = "";
1437 ti::Agent::LoadError result = agent.Load(&res, &err);
1438 if (result == ti::Agent::kInitializationError) {
1439 LOG(FATAL) << "Unable to initialize agent!";
1440 } else if (result != ti::Agent::kNoError) {
1441 LOG(ERROR) << "Unable to load an agent: " << err;
1442 }
1443 }
Andreas Gampe96eca782017-01-19 19:45:30 -08001444 {
1445 ScopedObjectAccess soa(self);
1446 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kInitialAgents);
1447 }
Alex Light7233c7e2016-07-28 10:07:45 -07001448
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001449 VLOG(startup) << "Runtime::Init exiting";
Mathieu Chartiere401d142015-04-22 13:56:20 -07001450
Carl Shapiro1fb86202011-06-27 17:43:13 -07001451 return true;
1452}
1453
Andreas Gampec4baad22017-01-12 16:59:39 +00001454static bool EnsureJvmtiPlugin(Runtime* runtime,
1455 std::vector<Plugin>* plugins,
1456 std::string* error_msg) {
1457 constexpr const char* plugin_name = kIsDebugBuild ? "libopenjdkjvmtid.so" : "libopenjdkjvmti.so";
1458
1459 // Is the plugin already loaded?
Andreas Gampe96eca782017-01-19 19:45:30 -08001460 for (const Plugin& p : *plugins) {
Andreas Gampec4baad22017-01-12 16:59:39 +00001461 if (p.GetLibrary() == plugin_name) {
1462 return true;
1463 }
1464 }
1465
1466 // Is the process debuggable? Otherwise, do not attempt to load the plugin.
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00001467 if (!runtime->IsJavaDebuggable()) {
Andreas Gampec4baad22017-01-12 16:59:39 +00001468 *error_msg = "Process is not debuggable.";
1469 return false;
1470 }
1471
1472 Plugin new_plugin = Plugin::Create(plugin_name);
1473
Andreas Gampec4baad22017-01-12 16:59:39 +00001474 if (!new_plugin.Load(error_msg)) {
1475 return false;
1476 }
1477
1478 plugins->push_back(std::move(new_plugin));
1479 return true;
1480}
1481
Leonard Mosescueb842212016-10-06 17:26:36 -07001482// Attach a new agent and add it to the list of runtime agents
1483//
1484// TODO: once we decide on the threading model for agents,
1485// revisit this and make sure we're doing this on the right thread
1486// (and we synchronize access to any shared data structures like "agents_")
1487//
1488void Runtime::AttachAgent(const std::string& agent_arg) {
Andreas Gampec4baad22017-01-12 16:59:39 +00001489 std::string error_msg;
1490 if (!EnsureJvmtiPlugin(this, &plugins_, &error_msg)) {
1491 LOG(WARNING) << "Could not load plugin: " << error_msg;
1492 ScopedObjectAccess soa(Thread::Current());
1493 ThrowIOException("%s", error_msg.c_str());
1494 return;
1495 }
1496
Leonard Mosescueb842212016-10-06 17:26:36 -07001497 ti::Agent agent(agent_arg);
1498
1499 int res = 0;
Andreas Gampec4baad22017-01-12 16:59:39 +00001500 ti::Agent::LoadError result = agent.Attach(&res, &error_msg);
Leonard Mosescueb842212016-10-06 17:26:36 -07001501
1502 if (result == ti::Agent::kNoError) {
1503 agents_.push_back(std::move(agent));
1504 } else {
Andreas Gampec4baad22017-01-12 16:59:39 +00001505 LOG(WARNING) << "Agent attach failed (result=" << result << ") : " << error_msg;
Leonard Mosescueb842212016-10-06 17:26:36 -07001506 ScopedObjectAccess soa(Thread::Current());
Andreas Gampec4baad22017-01-12 16:59:39 +00001507 ThrowIOException("%s", error_msg.c_str());
Leonard Mosescueb842212016-10-06 17:26:36 -07001508 }
1509}
1510
Elliott Hughes038a8062011-09-18 14:12:41 -07001511void Runtime::InitNativeMethods() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001512 VLOG(startup) << "Runtime::InitNativeMethods entering";
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001513 Thread* self = Thread::Current();
1514 JNIEnv* env = self->GetJniEnv();
1515
Elliott Hughes418d20f2011-09-22 14:00:39 -07001516 // Must be in the kNative state for calling native methods (JNI_OnLoad code).
Ian Rogers50b35e22012-10-04 10:09:15 -07001517 CHECK_EQ(self->GetState(), kNative);
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001518
Elliott Hughes418d20f2011-09-22 14:00:39 -07001519 // First set up JniConstants, which is used by both the runtime's built-in native
1520 // methods and libcore.
Elliott Hughesfea966e2011-09-22 10:26:20 -07001521 JniConstants::init(env);
1522
Elliott Hughes418d20f2011-09-22 14:00:39 -07001523 // Then set up the native methods provided by the runtime itself.
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001524 RegisterRuntimeNativeMethods(env);
1525
Yi Kong0871cd72015-11-20 16:00:31 +00001526 // Initialize classes used in JNI. The initialization requires runtime native
1527 // methods to be loaded first.
1528 WellKnownClasses::Init(env);
1529
Narayan Kamathd7b3c7f2015-11-18 09:49:10 +00001530 // Then set up libjavacore / libopenjdk, which are just a regular JNI libraries with
Narayan Kamathd1ef4362015-11-12 11:49:06 +00001531 // a regular JNI_OnLoad. Most JNI libraries can just use System.loadLibrary, but
1532 // libcore can't because it's the library that implements System.loadLibrary!
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001533 {
Dmitriy Ivanov44409d32015-11-11 14:18:55 -08001534 std::string error_msg;
Dimitry Ivanov942dc2982016-02-24 13:33:33 -08001535 if (!java_vm_->LoadNativeLibrary(env, "libjavacore.so", nullptr, nullptr, &error_msg)) {
Dmitriy Ivanov44409d32015-11-11 14:18:55 -08001536 LOG(FATAL) << "LoadNativeLibrary failed for \"libjavacore.so\": " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001537 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001538 }
Piotr Jastrzebski8ca90772015-04-24 09:18:00 +01001539 {
Andreas Gampe10edbb12016-01-06 17:59:49 -08001540 constexpr const char* kOpenJdkLibrary = kIsDebugBuild
1541 ? "libopenjdkd.so"
1542 : "libopenjdk.so";
Dmitriy Ivanov3e381722015-11-23 17:40:11 -08001543 std::string error_msg;
Dimitry Ivanov942dc2982016-02-24 13:33:33 -08001544 if (!java_vm_->LoadNativeLibrary(env, kOpenJdkLibrary, nullptr, nullptr, &error_msg)) {
Andreas Gampe10edbb12016-01-06 17:59:49 -08001545 LOG(FATAL) << "LoadNativeLibrary failed for \"" << kOpenJdkLibrary << "\": " << error_msg;
Piotr Jastrzebski8ca90772015-04-24 09:18:00 +01001546 }
Piotr Jastrzebski8ca90772015-04-24 09:18:00 +01001547 }
Ian Rogersef28b142012-11-30 14:22:18 -08001548
1549 // Initialize well known classes that may invoke runtime native methods.
1550 WellKnownClasses::LateInit(env);
1551
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001552 VLOG(startup) << "Runtime::InitNativeMethods exiting";
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001553}
1554
Jean-Philippe Halimica76a1a2016-02-02 19:48:52 +01001555void Runtime::ReclaimArenaPoolMemory() {
1556 arena_pool_->LockReclaimMemory();
1557}
1558
Ian Rogers365c1022012-06-22 15:05:28 -07001559void Runtime::InitThreadGroups(Thread* self) {
1560 JNIEnvExt* env = self->GetJniEnv();
1561 ScopedJniEnvLocalRefState env_state(env);
1562 main_thread_group_ =
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08001563 env->NewGlobalRef(env->GetStaticObjectField(
1564 WellKnownClasses::java_lang_ThreadGroup,
1565 WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup));
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001566 CHECK(main_thread_group_ != nullptr || IsAotCompiler());
Ian Rogers365c1022012-06-22 15:05:28 -07001567 system_thread_group_ =
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08001568 env->NewGlobalRef(env->GetStaticObjectField(
1569 WellKnownClasses::java_lang_ThreadGroup,
1570 WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup));
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001571 CHECK(system_thread_group_ != nullptr || IsAotCompiler());
Brian Carlstrom034f76b2012-08-01 15:51:58 -07001572}
1573
1574jobject Runtime::GetMainThreadGroup() const {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001575 CHECK(main_thread_group_ != nullptr || IsAotCompiler());
Brian Carlstrom034f76b2012-08-01 15:51:58 -07001576 return main_thread_group_;
1577}
1578
1579jobject Runtime::GetSystemThreadGroup() const {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001580 CHECK(system_thread_group_ != nullptr || IsAotCompiler());
Brian Carlstrom034f76b2012-08-01 15:51:58 -07001581 return system_thread_group_;
Ian Rogers365c1022012-06-22 15:05:28 -07001582}
1583
Brian Carlstromce888532013-10-10 00:32:58 -07001584jobject Runtime::GetSystemClassLoader() const {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001585 CHECK(system_class_loader_ != nullptr || IsAotCompiler());
Brian Carlstromce888532013-10-10 00:32:58 -07001586 return system_class_loader_;
1587}
1588
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001589void Runtime::RegisterRuntimeNativeMethods(JNIEnv* env) {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001590 register_dalvik_system_DexFile(env);
1591 register_dalvik_system_VMDebug(env);
1592 register_dalvik_system_VMRuntime(env);
1593 register_dalvik_system_VMStack(env);
1594 register_dalvik_system_ZygoteHooks(env);
1595 register_java_lang_Class(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001596 register_java_lang_Object(env);
Narayan Kamathbd2fed52017-01-25 10:46:54 +00001597 register_java_lang_invoke_MethodHandleImpl(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001598 register_java_lang_ref_FinalizerReference(env);
1599 register_java_lang_reflect_Array(env);
1600 register_java_lang_reflect_Constructor(env);
Neil Fuller0e844392016-09-08 13:43:31 +01001601 register_java_lang_reflect_Executable(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001602 register_java_lang_reflect_Field(env);
1603 register_java_lang_reflect_Method(env);
Neil Fuller60458a02016-09-01 15:32:44 +01001604 register_java_lang_reflect_Parameter(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001605 register_java_lang_reflect_Proxy(env);
1606 register_java_lang_ref_Reference(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001607 register_java_lang_String(env);
Jeff Hao848f70a2014-01-15 13:49:50 -08001608 register_java_lang_StringFactory(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001609 register_java_lang_System(env);
1610 register_java_lang_Thread(env);
1611 register_java_lang_Throwable(env);
1612 register_java_lang_VMClassLoader(env);
Vladimir Markoe00e5592017-02-24 14:58:29 +00001613 register_java_lang_Void(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001614 register_java_util_concurrent_atomic_AtomicLong(env);
Jeff Hao848f70a2014-01-15 13:49:50 -08001615 register_libcore_util_CharsetUtils(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001616 register_org_apache_harmony_dalvik_ddmc_DdmServer(env);
1617 register_org_apache_harmony_dalvik_ddmc_DdmVmInternal(env);
1618 register_sun_misc_Unsafe(env);
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001619}
1620
Nicolas Geoffray4e92c3c2017-05-08 09:34:26 +01001621std::ostream& operator<<(std::ostream& os, const DeoptimizationKind& kind) {
1622 os << GetDeoptimizationKindName(kind);
1623 return os;
1624}
1625
1626void Runtime::DumpDeoptimizations(std::ostream& os) {
1627 for (size_t i = 0; i <= static_cast<size_t>(DeoptimizationKind::kLast); ++i) {
1628 if (deoptimization_counts_[i] != 0) {
1629 os << "Number of "
1630 << GetDeoptimizationKindName(static_cast<DeoptimizationKind>(i))
1631 << " deoptimizations: "
1632 << deoptimization_counts_[i]
1633 << "\n";
1634 }
1635 }
1636}
1637
Elliott Hughesc967f782012-04-16 10:23:15 -07001638void Runtime::DumpForSigQuit(std::ostream& os) {
Elliott Hughescac6cc72011-11-03 20:31:21 -07001639 GetClassLinker()->DumpForSigQuit(os);
1640 GetInternTable()->DumpForSigQuit(os);
Elliott Hughesae80b492012-04-24 10:43:17 -07001641 GetJavaVM()->DumpForSigQuit(os);
Elliott Hughesc967f782012-04-16 10:23:15 -07001642 GetHeap()->DumpForSigQuit(os);
Nicolas Geoffray04680f32016-03-17 11:56:54 +00001643 oat_file_manager_->DumpForSigQuit(os);
Nicolas Geoffrayaee21562015-12-15 16:39:44 +00001644 if (GetJit() != nullptr) {
1645 GetJit()->DumpForSigQuit(os);
1646 } else {
1647 os << "Running non JIT\n";
1648 }
Nicolas Geoffray4e92c3c2017-05-08 09:34:26 +01001649 DumpDeoptimizations(os);
Mathieu Chartierbad02672014-08-25 13:08:22 -07001650 TrackedAllocators::Dump(os);
Elliott Hughes42ee1422011-09-06 12:33:32 -07001651 os << "\n";
Elliott Hughes8daa0922011-09-11 13:46:25 -07001652
Elliott Hughesc967f782012-04-16 10:23:15 -07001653 thread_list_->DumpForSigQuit(os);
Ian Rogers56edc432013-01-18 16:51:51 -08001654 BaseMutex::DumpAll(os);
Andreas Gampea5814f92017-01-18 21:43:16 -08001655
1656 // Inform anyone else who is interested in SigQuit.
1657 {
1658 ScopedObjectAccess soa(Thread::Current());
1659 callbacks_->SigQuit();
1660 }
Elliott Hughese27955c2011-08-26 15:21:24 -07001661}
1662
Elliott Hughes21a5bf22011-12-07 14:35:20 -08001663void Runtime::DumpLockHolders(std::ostream& os) {
Ian Rogersb726dcb2012-09-05 08:57:23 -07001664 uint64_t mutator_lock_owner = Locks::mutator_lock_->GetExclusiveOwnerTid();
Elliott Hughes21a5bf22011-12-07 14:35:20 -08001665 pid_t thread_list_lock_owner = GetThreadList()->GetLockOwner();
1666 pid_t classes_lock_owner = GetClassLinker()->GetClassesLockOwner();
1667 pid_t dex_lock_owner = GetClassLinker()->GetDexLockOwner();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001668 if ((thread_list_lock_owner | classes_lock_owner | dex_lock_owner) != 0) {
1669 os << "Mutator lock exclusive owner tid: " << mutator_lock_owner << "\n"
Elliott Hughes21a5bf22011-12-07 14:35:20 -08001670 << "ThreadList lock owner tid: " << thread_list_lock_owner << "\n"
1671 << "ClassLinker classes lock owner tid: " << classes_lock_owner << "\n"
1672 << "ClassLinker dex lock owner tid: " << dex_lock_owner << "\n";
1673 }
1674}
1675
Mathieu Chartier9ef78b52014-09-25 17:03:12 -07001676void Runtime::SetStatsEnabled(bool new_state) {
1677 Thread* self = Thread::Current();
1678 MutexLock mu(self, *Locks::instrument_entrypoints_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001679 if (new_state == true) {
1680 GetStats()->Clear(~0);
1681 // TODO: wouldn't it make more sense to clear _all_ threads' stats?
Mathieu Chartier9ef78b52014-09-25 17:03:12 -07001682 self->GetStats()->Clear(~0);
1683 if (stats_enabled_ != new_state) {
1684 GetInstrumentation()->InstrumentQuickAllocEntryPointsLocked();
1685 }
1686 } else if (stats_enabled_ != new_state) {
1687 GetInstrumentation()->UninstrumentQuickAllocEntryPointsLocked();
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001688 }
1689 stats_enabled_ = new_state;
1690}
1691
1692void Runtime::ResetStats(int kinds) {
1693 GetStats()->Clear(kinds & 0xffff);
1694 // TODO: wouldn't it make more sense to clear _all_ threads' stats?
1695 Thread::Current()->GetStats()->Clear(kinds >> 16);
1696}
1697
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001698int32_t Runtime::GetStat(int kind) {
1699 RuntimeStats* stats;
1700 if (kind < (1<<16)) {
1701 stats = GetStats();
1702 } else {
1703 stats = Thread::Current()->GetStats();
1704 kind >>= 16;
1705 }
1706 switch (kind) {
1707 case KIND_ALLOCATED_OBJECTS:
1708 return stats->allocated_objects;
1709 case KIND_ALLOCATED_BYTES:
1710 return stats->allocated_bytes;
1711 case KIND_FREED_OBJECTS:
1712 return stats->freed_objects;
1713 case KIND_FREED_BYTES:
1714 return stats->freed_bytes;
1715 case KIND_GC_INVOCATIONS:
1716 return stats->gc_for_alloc_count;
1717 case KIND_CLASS_INIT_COUNT:
1718 return stats->class_init_count;
1719 case KIND_CLASS_INIT_TIME:
1720 // Convert ns to us, reduce to 32 bits.
Elliott Hughes398f64b2012-03-26 18:05:48 -07001721 return static_cast<int>(stats->class_init_time_ns / 1000);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001722 case KIND_EXT_ALLOCATED_OBJECTS:
1723 case KIND_EXT_ALLOCATED_BYTES:
1724 case KIND_EXT_FREED_OBJECTS:
1725 case KIND_EXT_FREED_BYTES:
1726 return 0; // backward compatibility
1727 default:
Elliott Hughes7b9d9962012-04-20 18:48:18 -07001728 LOG(FATAL) << "Unknown statistic " << kind;
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001729 return -1; // unreachable
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001730 }
1731}
1732
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001733void Runtime::BlockSignals() {
Elliott Hughes457005c2012-04-16 13:54:25 -07001734 SignalSet signals;
1735 signals.Add(SIGPIPE);
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001736 // SIGQUIT is used to dump the runtime's state (including stack traces).
Elliott Hughes457005c2012-04-16 13:54:25 -07001737 signals.Add(SIGQUIT);
Elliott Hughes08795042012-04-03 14:48:52 -07001738 // SIGUSR1 is used to initiate a GC.
Elliott Hughes457005c2012-04-16 13:54:25 -07001739 signals.Add(SIGUSR1);
1740 signals.Block();
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001741}
1742
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001743bool Runtime::AttachCurrentThread(const char* thread_name, bool as_daemon, jobject thread_group,
Mathieu Chartier664bebf2012-11-12 16:54:11 -08001744 bool create_peer) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001745 ScopedTrace trace(__FUNCTION__);
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001746 return Thread::Attach(thread_name, as_daemon, thread_group, create_peer) != nullptr;
Carl Shapiro61e019d2011-07-14 16:53:09 -07001747}
1748
Elliott Hughesd92bec42011-09-02 17:04:36 -07001749void Runtime::DetachCurrentThread() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001750 ScopedTrace trace(__FUNCTION__);
Brian Carlstrom4d571432012-05-16 00:21:41 -07001751 Thread* self = Thread::Current();
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001752 if (self == nullptr) {
Brian Carlstrom4d571432012-05-16 00:21:41 -07001753 LOG(FATAL) << "attempting to detach thread that is not attached";
1754 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001755 if (self->HasManagedStack()) {
Elliott Hughes22869a92012-03-27 14:08:24 -07001756 LOG(FATAL) << *Thread::Current() << " attempting to detach while still running code";
1757 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001758 thread_list_->Unregister(self);
Carl Shapiro1fb86202011-06-27 17:43:13 -07001759}
1760
Hiroshi Yamauchiab088112014-07-14 13:00:14 -07001761mirror::Throwable* Runtime::GetPreAllocatedOutOfMemoryError() {
Hiroshi Yamauchi94f7b492014-07-22 18:08:23 -07001762 mirror::Throwable* oome = pre_allocated_OutOfMemoryError_.Read();
Ian Rogers63557452014-06-04 16:57:15 -07001763 if (oome == nullptr) {
Ian Rogersa436fde2013-08-27 23:34:06 -07001764 LOG(ERROR) << "Failed to return pre-allocated OOME";
1765 }
Hiroshi Yamauchiab088112014-07-14 13:00:14 -07001766 return oome;
Ian Rogersa436fde2013-08-27 23:34:06 -07001767}
1768
Ian Rogers63557452014-06-04 16:57:15 -07001769mirror::Throwable* Runtime::GetPreAllocatedNoClassDefFoundError() {
1770 mirror::Throwable* ncdfe = pre_allocated_NoClassDefFoundError_.Read();
1771 if (ncdfe == nullptr) {
1772 LOG(ERROR) << "Failed to return pre-allocated NoClassDefFoundError";
1773 }
1774 return ncdfe;
1775}
1776
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001777void Runtime::VisitConstantRoots(RootVisitor* visitor) {
Mathieu Chartier893263b2014-03-04 11:07:42 -08001778 // Visit the classes held as static in mirror classes, these can be visited concurrently and only
Mathieu Chartier3b05e9b2014-03-25 09:29:43 -07001779 // need to be visited once per GC since they never change.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001780 mirror::Class::VisitRoots(visitor);
Mathieu Chartierfc58af42015-04-16 18:00:39 -07001781 mirror::Constructor::VisitRoots(visitor);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001782 mirror::Reference::VisitRoots(visitor);
Mathieu Chartierfc58af42015-04-16 18:00:39 -07001783 mirror::Method::VisitRoots(visitor);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001784 mirror::StackTraceElement::VisitRoots(visitor);
1785 mirror::String::VisitRoots(visitor);
1786 mirror::Throwable::VisitRoots(visitor);
1787 mirror::Field::VisitRoots(visitor);
Narayan Kamathafa48272016-08-03 12:46:58 +01001788 mirror::MethodType::VisitRoots(visitor);
1789 mirror::MethodHandleImpl::VisitRoots(visitor);
Orion Hodsonc069a302017-01-18 09:23:12 +00001790 mirror::MethodHandlesLookup::VisitRoots(visitor);
Narayan Kamath000e1882016-10-24 17:14:25 +01001791 mirror::EmulatedStackFrame::VisitRoots(visitor);
Alex Lightcec2fd42016-11-02 16:32:07 -07001792 mirror::ClassExt::VisitRoots(visitor);
Mathieu Chartiera25504e2017-04-18 16:14:19 -07001793 mirror::CallSite::VisitRoots(visitor);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001794 // Visit all the primitive array types classes.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001795 mirror::PrimitiveArray<uint8_t>::VisitRoots(visitor); // BooleanArray
1796 mirror::PrimitiveArray<int8_t>::VisitRoots(visitor); // ByteArray
1797 mirror::PrimitiveArray<uint16_t>::VisitRoots(visitor); // CharArray
1798 mirror::PrimitiveArray<double>::VisitRoots(visitor); // DoubleArray
1799 mirror::PrimitiveArray<float>::VisitRoots(visitor); // FloatArray
1800 mirror::PrimitiveArray<int32_t>::VisitRoots(visitor); // IntArray
1801 mirror::PrimitiveArray<int64_t>::VisitRoots(visitor); // LongArray
1802 mirror::PrimitiveArray<int16_t>::VisitRoots(visitor); // ShortArray
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07001803 // Visiting the roots of these ArtMethods is not currently required since all the GcRoots are
1804 // null.
1805 BufferedRootVisitor<16> buffered_visitor(visitor, RootInfo(kRootVMInternal));
Andreas Gampe542451c2016-07-26 09:02:02 -07001806 const PointerSize pointer_size = GetClassLinker()->GetImagePointerSize();
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07001807 if (HasResolutionMethod()) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07001808 resolution_method_->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07001809 }
1810 if (HasImtConflictMethod()) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07001811 imt_conflict_method_->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07001812 }
1813 if (imt_unimplemented_method_ != nullptr) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07001814 imt_unimplemented_method_->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07001815 }
Andreas Gampe8228cdf2017-05-30 15:03:54 -07001816 for (uint32_t i = 0; i < kCalleeSaveSize; ++i) {
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07001817 auto* m = reinterpret_cast<ArtMethod*>(callee_save_methods_[i]);
1818 if (m != nullptr) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07001819 m->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07001820 }
1821 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08001822}
1823
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001824void Runtime::VisitConcurrentRoots(RootVisitor* visitor, VisitRootFlags flags) {
1825 intern_table_->VisitRoots(visitor, flags);
1826 class_linker_->VisitRoots(visitor, flags);
Man Cao1ed11b92015-06-11 22:47:35 -07001827 heap_->VisitAllocationRecords(visitor);
Mathieu Chartier893263b2014-03-04 11:07:42 -08001828 if ((flags & kVisitRootFlagNewRoots) == 0) {
1829 // Guaranteed to have no new roots in the constant roots.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001830 VisitConstantRoots(visitor);
Mathieu Chartier893263b2014-03-04 11:07:42 -08001831 }
Mathieu Chartiera6b1ead2015-10-06 10:32:38 -07001832 Dbg::VisitRoots(visitor);
Mathieu Chartier893263b2014-03-04 11:07:42 -08001833}
1834
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001835void Runtime::VisitTransactionRoots(RootVisitor* visitor) {
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001836 if (preinitialization_transaction_ != nullptr) {
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001837 preinitialization_transaction_->VisitRoots(visitor);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001838 }
1839}
1840
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001841void Runtime::VisitNonThreadRoots(RootVisitor* visitor) {
1842 java_vm_->VisitRoots(visitor);
1843 sentinel_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
1844 pre_allocated_OutOfMemoryError_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001845 pre_allocated_NoClassDefFoundError_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001846 verifier::MethodVerifier::VisitStaticRoots(visitor);
1847 VisitTransactionRoots(visitor);
Brian Carlstrome24fa612011-09-29 00:53:55 -07001848}
1849
Andreas Gampe585da952016-12-02 14:52:29 -08001850void Runtime::VisitNonConcurrentRoots(RootVisitor* visitor, VisitRootFlags flags) {
1851 VisitThreadRoots(visitor, flags);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001852 VisitNonThreadRoots(visitor);
Mathieu Chartier858f1c52012-10-17 17:45:55 -07001853}
1854
Andreas Gampe585da952016-12-02 14:52:29 -08001855void Runtime::VisitThreadRoots(RootVisitor* visitor, VisitRootFlags flags) {
1856 thread_list_->VisitRoots(visitor, flags);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08001857}
1858
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001859void Runtime::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) {
Andreas Gampe585da952016-12-02 14:52:29 -08001860 VisitNonConcurrentRoots(visitor, flags);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001861 VisitConcurrentRoots(visitor, flags);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07001862}
1863
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001864void Runtime::VisitImageRoots(RootVisitor* visitor) {
Mathieu Chartier461687d2015-03-31 12:05:24 -07001865 for (auto* space : GetHeap()->GetContinuousSpaces()) {
1866 if (space->IsImageSpace()) {
1867 auto* image_space = space->AsImageSpace();
1868 const auto& image_header = image_space->GetImageHeader();
Vladimir Markoeca3eda2016-11-09 16:26:44 +00001869 for (int32_t i = 0, size = image_header.GetImageRoots()->GetLength(); i != size; ++i) {
Mathieu Chartier461687d2015-03-31 12:05:24 -07001870 auto* obj = image_header.GetImageRoot(static_cast<ImageHeader::ImageRoot>(i));
1871 if (obj != nullptr) {
1872 auto* after_obj = obj;
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001873 visitor->VisitRoot(&after_obj, RootInfo(kRootStickyClass));
Mathieu Chartier461687d2015-03-31 12:05:24 -07001874 CHECK_EQ(after_obj, obj);
1875 }
1876 }
1877 }
1878 }
1879}
1880
Andreas Gampecc1b5352016-12-01 16:58:38 -08001881static ArtMethod* CreateRuntimeMethod(ClassLinker* class_linker, LinearAlloc* linear_alloc) {
1882 const PointerSize image_pointer_size = class_linker->GetImagePointerSize();
1883 const size_t method_alignment = ArtMethod::Alignment(image_pointer_size);
1884 const size_t method_size = ArtMethod::Size(image_pointer_size);
1885 LengthPrefixedArray<ArtMethod>* method_array = class_linker->AllocArtMethodArray(
1886 Thread::Current(),
1887 linear_alloc,
1888 1);
1889 ArtMethod* method = &method_array->At(0, method_size, method_alignment);
1890 CHECK(method != nullptr);
1891 method->SetDexMethodIndex(DexFile::kDexNoIndex);
1892 CHECK(method->IsRuntimeMethod());
1893 return method;
1894}
1895
Nicolas Geoffray796d6302016-03-13 22:22:31 +00001896ArtMethod* Runtime::CreateImtConflictMethod(LinearAlloc* linear_alloc) {
Mathieu Chartier91288d82016-04-28 09:44:54 -07001897 ClassLinker* const class_linker = GetClassLinker();
Andreas Gampecc1b5352016-12-01 16:58:38 -08001898 ArtMethod* method = CreateRuntimeMethod(class_linker, linear_alloc);
Jeff Hao88474b42013-10-23 16:24:40 -07001899 // When compiling, the code pointer will get set later when the image is loaded.
Andreas Gampe542451c2016-07-26 09:02:02 -07001900 const PointerSize pointer_size = GetInstructionSetPointerSize(instruction_set_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001901 if (IsAotCompiler()) {
Jeff Haoc7d11882015-02-03 15:08:39 -08001902 method->SetEntryPointFromQuickCompiledCodePtrSize(nullptr, pointer_size);
Ian Rogersef7d42f2014-01-06 12:55:46 -08001903 } else {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07001904 method->SetEntryPointFromQuickCompiledCode(GetQuickImtConflictStub());
Ian Rogersef7d42f2014-01-06 12:55:46 -08001905 }
Mathieu Chartier91288d82016-04-28 09:44:54 -07001906 // Create empty conflict table.
1907 method->SetImtConflictTable(class_linker->CreateImtConflictTable(/*count*/0u, linear_alloc),
1908 pointer_size);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001909 return method;
Jeff Hao88474b42013-10-23 16:24:40 -07001910}
1911
Mathieu Chartiere401d142015-04-22 13:56:20 -07001912void Runtime::SetImtConflictMethod(ArtMethod* method) {
1913 CHECK(method != nullptr);
1914 CHECK(method->IsRuntimeMethod());
1915 imt_conflict_method_ = method;
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08001916}
1917
Mathieu Chartiere401d142015-04-22 13:56:20 -07001918ArtMethod* Runtime::CreateResolutionMethod() {
Andreas Gampecc1b5352016-12-01 16:58:38 -08001919 auto* method = CreateRuntimeMethod(GetClassLinker(), GetLinearAlloc());
Jeff Hao58df3272013-04-22 15:28:53 -07001920 // When compiling, the code pointer will get set later when the image is loaded.
Mathieu Chartiere401d142015-04-22 13:56:20 -07001921 if (IsAotCompiler()) {
Andreas Gampe542451c2016-07-26 09:02:02 -07001922 PointerSize pointer_size = GetInstructionSetPointerSize(instruction_set_);
Jeff Haoc7d11882015-02-03 15:08:39 -08001923 method->SetEntryPointFromQuickCompiledCodePtrSize(nullptr, pointer_size);
Ian Rogersef7d42f2014-01-06 12:55:46 -08001924 } else {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07001925 method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionStub());
Ian Rogersef7d42f2014-01-06 12:55:46 -08001926 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07001927 return method;
Ian Rogers19846512012-02-24 11:42:47 -08001928}
1929
Mathieu Chartiere401d142015-04-22 13:56:20 -07001930ArtMethod* Runtime::CreateCalleeSaveMethod() {
Andreas Gampecc1b5352016-12-01 16:58:38 -08001931 auto* method = CreateRuntimeMethod(GetClassLinker(), GetLinearAlloc());
Andreas Gampe542451c2016-07-26 09:02:02 -07001932 PointerSize pointer_size = GetInstructionSetPointerSize(instruction_set_);
Jeff Haoc7d11882015-02-03 15:08:39 -08001933 method->SetEntryPointFromQuickCompiledCodePtrSize(nullptr, pointer_size);
Vladimir Marko7624d252014-05-02 14:40:15 +01001934 DCHECK_NE(instruction_set_, kNone);
Mathieu Chartiere401d142015-04-22 13:56:20 -07001935 DCHECK(method->IsRuntimeMethod());
1936 return method;
Ian Rogersff1ed472011-09-20 13:46:24 -07001937}
1938
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001939void Runtime::DisallowNewSystemWeaks() {
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07001940 CHECK(!kUseReadBarrier);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001941 monitor_list_->DisallowNewMonitors();
Mathieu Chartier14c3bf92015-07-13 14:35:43 -07001942 intern_table_->ChangeWeakRootState(gc::kWeakRootStateNoReadsOrWrites);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001943 java_vm_->DisallowNewWeakGlobals();
Man Cao42c3c332015-06-23 16:38:25 -07001944 heap_->DisallowNewAllocationRecords();
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +00001945 if (GetJit() != nullptr) {
1946 GetJit()->GetCodeCache()->DisallowInlineCacheAccess();
1947 }
Andreas Gampefda57142016-09-08 20:29:18 -07001948
1949 // All other generic system-weak holders.
1950 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
1951 holder->Disallow();
1952 }
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001953}
1954
1955void Runtime::AllowNewSystemWeaks() {
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07001956 CHECK(!kUseReadBarrier);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001957 monitor_list_->AllowNewMonitors();
Mathieu Chartier90ef3db2015-08-04 15:19:41 -07001958 intern_table_->ChangeWeakRootState(gc::kWeakRootStateNormal); // TODO: Do this in the sweeping.
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001959 java_vm_->AllowNewWeakGlobals();
Man Cao42c3c332015-06-23 16:38:25 -07001960 heap_->AllowNewAllocationRecords();
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +00001961 if (GetJit() != nullptr) {
1962 GetJit()->GetCodeCache()->AllowInlineCacheAccess();
1963 }
Andreas Gampefda57142016-09-08 20:29:18 -07001964
1965 // All other generic system-weak holders.
1966 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
1967 holder->Allow();
1968 }
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07001969}
1970
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07001971void Runtime::BroadcastForNewSystemWeaks(bool broadcast_for_checkpoint) {
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07001972 // This is used for the read barrier case that uses the thread-local
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07001973 // Thread::GetWeakRefAccessEnabled() flag and the checkpoint while weak ref access is disabled
1974 // (see ThreadList::RunCheckpoint).
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001975 monitor_list_->BroadcastForNewMonitors();
1976 intern_table_->BroadcastForNewInterns();
1977 java_vm_->BroadcastForNewWeakGlobals();
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07001978 heap_->BroadcastForNewAllocationRecords();
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +00001979 if (GetJit() != nullptr) {
1980 GetJit()->GetCodeCache()->BroadcastForInlineCacheAccess();
1981 }
Andreas Gampefda57142016-09-08 20:29:18 -07001982
1983 // All other generic system-weak holders.
1984 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07001985 holder->Broadcast(broadcast_for_checkpoint);
Andreas Gampefda57142016-09-08 20:29:18 -07001986 }
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07001987}
1988
Vladimir Marko7624d252014-05-02 14:40:15 +01001989void Runtime::SetInstructionSet(InstructionSet instruction_set) {
1990 instruction_set_ = instruction_set;
1991 if ((instruction_set_ == kThumb2) || (instruction_set_ == kArm)) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07001992 for (int i = 0; i != kCalleeSaveSize; ++i) {
Vladimir Marko7624d252014-05-02 14:40:15 +01001993 CalleeSaveType type = static_cast<CalleeSaveType>(i);
1994 callee_save_method_frame_infos_[i] = arm::ArmCalleeSaveMethodFrameInfo(type);
1995 }
1996 } else if (instruction_set_ == kMips) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07001997 for (int i = 0; i != kCalleeSaveSize; ++i) {
Vladimir Marko7624d252014-05-02 14:40:15 +01001998 CalleeSaveType type = static_cast<CalleeSaveType>(i);
1999 callee_save_method_frame_infos_[i] = mips::MipsCalleeSaveMethodFrameInfo(type);
2000 }
Andreas Gampe57b34292015-01-14 15:45:59 -08002001 } else if (instruction_set_ == kMips64) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002002 for (int i = 0; i != kCalleeSaveSize; ++i) {
Andreas Gampe57b34292015-01-14 15:45:59 -08002003 CalleeSaveType type = static_cast<CalleeSaveType>(i);
2004 callee_save_method_frame_infos_[i] = mips64::Mips64CalleeSaveMethodFrameInfo(type);
2005 }
Vladimir Marko7624d252014-05-02 14:40:15 +01002006 } else if (instruction_set_ == kX86) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002007 for (int i = 0; i != kCalleeSaveSize; ++i) {
Vladimir Marko7624d252014-05-02 14:40:15 +01002008 CalleeSaveType type = static_cast<CalleeSaveType>(i);
2009 callee_save_method_frame_infos_[i] = x86::X86CalleeSaveMethodFrameInfo(type);
2010 }
2011 } else if (instruction_set_ == kX86_64) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002012 for (int i = 0; i != kCalleeSaveSize; ++i) {
Vladimir Marko7624d252014-05-02 14:40:15 +01002013 CalleeSaveType type = static_cast<CalleeSaveType>(i);
2014 callee_save_method_frame_infos_[i] = x86_64::X86_64CalleeSaveMethodFrameInfo(type);
2015 }
2016 } else if (instruction_set_ == kArm64) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002017 for (int i = 0; i != kCalleeSaveSize; ++i) {
Vladimir Marko7624d252014-05-02 14:40:15 +01002018 CalleeSaveType type = static_cast<CalleeSaveType>(i);
2019 callee_save_method_frame_infos_[i] = arm64::Arm64CalleeSaveMethodFrameInfo(type);
2020 }
2021 } else {
2022 UNIMPLEMENTED(FATAL) << instruction_set_;
2023 }
2024}
2025
Igor Murashkin8275fba2017-05-02 15:58:02 -07002026void Runtime::ClearInstructionSet() {
2027 instruction_set_ = InstructionSet::kNone;
2028}
2029
Mathieu Chartiere401d142015-04-22 13:56:20 -07002030void Runtime::SetCalleeSaveMethod(ArtMethod* method, CalleeSaveType type) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002031 DCHECK_LT(static_cast<uint32_t>(type), kCalleeSaveSize);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002032 CHECK(method != nullptr);
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002033 callee_save_methods_[static_cast<size_t>(type)] = reinterpret_cast<uintptr_t>(method);
Brian Carlstrome24fa612011-09-29 00:53:55 -07002034}
2035
Igor Murashkin8275fba2017-05-02 15:58:02 -07002036void Runtime::ClearCalleeSaveMethods() {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002037 for (size_t i = 0; i < kCalleeSaveSize; ++i) {
2038 callee_save_methods_[i] = reinterpret_cast<uintptr_t>(nullptr);
Igor Murashkin8275fba2017-05-02 15:58:02 -07002039 }
2040}
2041
Calin Juravle66f55232015-12-08 15:09:10 +00002042void Runtime::RegisterAppInfo(const std::vector<std::string>& code_paths,
Calin Juravle77651c42017-03-03 18:04:02 -08002043 const std::string& profile_output_filename) {
Calin Juravle5e2b9712015-12-18 14:10:00 +02002044 if (jit_.get() == nullptr) {
2045 // We are not JITing. Nothing to do.
2046 return;
Calin Juravle4d77b6a2015-12-01 18:38:09 +00002047 }
Calin Juravle5e2b9712015-12-18 14:10:00 +02002048
2049 VLOG(profiler) << "Register app with " << profile_output_filename
Andreas Gampe9186ced2016-12-12 14:28:21 -08002050 << " " << android::base::Join(code_paths, ':');
Calin Juravle5e2b9712015-12-18 14:10:00 +02002051
2052 if (profile_output_filename.empty()) {
2053 LOG(WARNING) << "JIT profile information will not be recorded: profile filename is empty.";
2054 return;
2055 }
2056 if (!FileExists(profile_output_filename)) {
2057 LOG(WARNING) << "JIT profile information will not be recorded: profile file does not exits.";
2058 return;
2059 }
2060 if (code_paths.empty()) {
2061 LOG(WARNING) << "JIT profile information will not be recorded: code paths is empty.";
2062 return;
2063 }
2064
Calin Juravle77651c42017-03-03 18:04:02 -08002065 jit_->StartProfileSaver(profile_output_filename, code_paths);
Dave Allison0aded082013-11-07 13:15:11 -08002066}
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002067
2068// Transaction support.
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002069void Runtime::EnterTransactionMode(Transaction* transaction) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002070 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002071 DCHECK(transaction != nullptr);
2072 DCHECK(!IsActiveTransaction());
Sebastien Hertzee1d79a2014-02-21 15:46:30 +01002073 preinitialization_transaction_ = transaction;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002074}
2075
2076void Runtime::ExitTransactionMode() {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002077 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002078 DCHECK(IsActiveTransaction());
Sebastien Hertzee1d79a2014-02-21 15:46:30 +01002079 preinitialization_transaction_ = nullptr;
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002080}
2081
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002082bool Runtime::IsTransactionAborted() const {
2083 if (!IsActiveTransaction()) {
2084 return false;
2085 } else {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002086 DCHECK(IsAotCompiler());
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002087 return preinitialization_transaction_->IsAborted();
2088 }
2089}
2090
Sebastien Hertz2fd7e692015-04-02 11:11:19 +02002091void Runtime::AbortTransactionAndThrowAbortError(Thread* self, const std::string& abort_message) {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002092 DCHECK(IsAotCompiler());
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002093 DCHECK(IsActiveTransaction());
Sebastien Hertzbd9cf9f2015-03-03 12:16:13 +01002094 // Throwing an exception may cause its class initialization. If we mark the transaction
2095 // aborted before that, we may warn with a false alarm. Throwing the exception before
2096 // marking the transaction aborted avoids that.
Sebastien Hertzb81e1cd2015-04-28 12:31:41 +02002097 preinitialization_transaction_->ThrowAbortError(self, &abort_message);
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002098 preinitialization_transaction_->Abort(abort_message);
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002099}
2100
Sebastien Hertz2fd7e692015-04-02 11:11:19 +02002101void Runtime::ThrowTransactionAbortError(Thread* self) {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002102 DCHECK(IsAotCompiler());
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002103 DCHECK(IsActiveTransaction());
Sebastien Hertzb81e1cd2015-04-28 12:31:41 +02002104 // Passing nullptr means we rethrow an exception with the earlier transaction abort message.
2105 preinitialization_transaction_->ThrowAbortError(self, nullptr);
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002106}
2107
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002108void Runtime::RecordWriteFieldBoolean(mirror::Object* obj, MemberOffset field_offset,
2109 uint8_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002110 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002111 DCHECK(IsActiveTransaction());
2112 preinitialization_transaction_->RecordWriteFieldBoolean(obj, field_offset, value, is_volatile);
2113}
2114
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002115void Runtime::RecordWriteFieldByte(mirror::Object* obj, MemberOffset field_offset,
2116 int8_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002117 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002118 DCHECK(IsActiveTransaction());
2119 preinitialization_transaction_->RecordWriteFieldByte(obj, field_offset, value, is_volatile);
2120}
2121
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002122void Runtime::RecordWriteFieldChar(mirror::Object* obj, MemberOffset field_offset,
2123 uint16_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002124 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002125 DCHECK(IsActiveTransaction());
2126 preinitialization_transaction_->RecordWriteFieldChar(obj, field_offset, value, is_volatile);
2127}
2128
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002129void Runtime::RecordWriteFieldShort(mirror::Object* obj, MemberOffset field_offset,
2130 int16_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002131 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002132 DCHECK(IsActiveTransaction());
2133 preinitialization_transaction_->RecordWriteFieldShort(obj, field_offset, value, is_volatile);
2134}
2135
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002136void Runtime::RecordWriteField32(mirror::Object* obj, MemberOffset field_offset,
2137 uint32_t value, bool is_volatile) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002138 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002139 DCHECK(IsActiveTransaction());
Sebastien Hertzee1d79a2014-02-21 15:46:30 +01002140 preinitialization_transaction_->RecordWriteField32(obj, field_offset, value, is_volatile);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002141}
2142
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002143void Runtime::RecordWriteField64(mirror::Object* obj, MemberOffset field_offset,
2144 uint64_t value, bool is_volatile) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002145 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002146 DCHECK(IsActiveTransaction());
Sebastien Hertzee1d79a2014-02-21 15:46:30 +01002147 preinitialization_transaction_->RecordWriteField64(obj, field_offset, value, is_volatile);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002148}
2149
Mathieu Chartiera058fdf2016-10-06 15:13:58 -07002150void Runtime::RecordWriteFieldReference(mirror::Object* obj,
2151 MemberOffset field_offset,
2152 ObjPtr<mirror::Object> value,
2153 bool is_volatile) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002154 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002155 DCHECK(IsActiveTransaction());
Mathieu Chartiera058fdf2016-10-06 15:13:58 -07002156 preinitialization_transaction_->RecordWriteFieldReference(obj,
2157 field_offset,
2158 value.Ptr(),
2159 is_volatile);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002160}
2161
2162void Runtime::RecordWriteArray(mirror::Array* array, size_t index, uint64_t value) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002163 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002164 DCHECK(IsActiveTransaction());
Sebastien Hertzee1d79a2014-02-21 15:46:30 +01002165 preinitialization_transaction_->RecordWriteArray(array, index, value);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002166}
2167
Mathieu Chartier9e868092016-10-31 14:58:04 -07002168void Runtime::RecordStrongStringInsertion(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002169 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002170 DCHECK(IsActiveTransaction());
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -07002171 preinitialization_transaction_->RecordStrongStringInsertion(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002172}
2173
Mathieu Chartier9e868092016-10-31 14:58:04 -07002174void Runtime::RecordWeakStringInsertion(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002175 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002176 DCHECK(IsActiveTransaction());
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -07002177 preinitialization_transaction_->RecordWeakStringInsertion(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002178}
2179
Mathieu Chartier9e868092016-10-31 14:58:04 -07002180void Runtime::RecordStrongStringRemoval(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002181 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002182 DCHECK(IsActiveTransaction());
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -07002183 preinitialization_transaction_->RecordStrongStringRemoval(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002184}
2185
Mathieu Chartier9e868092016-10-31 14:58:04 -07002186void Runtime::RecordWeakStringRemoval(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002187 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002188 DCHECK(IsActiveTransaction());
Mathieu Chartiercdfd39f2014-08-29 18:16:58 -07002189 preinitialization_transaction_->RecordWeakStringRemoval(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002190}
Mathieu Chartier15d34022014-02-26 17:16:38 -08002191
Andreas Gampe8a0128a2016-11-28 07:38:35 -08002192void Runtime::RecordResolveString(ObjPtr<mirror::DexCache> dex_cache,
2193 dex::StringIndex string_idx) const {
Mathieu Chartierbb816d62016-09-07 10:17:46 -07002194 DCHECK(IsAotCompiler());
2195 DCHECK(IsActiveTransaction());
2196 preinitialization_transaction_->RecordResolveString(dex_cache, string_idx);
2197}
2198
Mathieu Chartier15d34022014-02-26 17:16:38 -08002199void Runtime::SetFaultMessage(const std::string& message) {
2200 MutexLock mu(Thread::Current(), fault_message_lock_);
2201 fault_message_ = message;
2202}
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08002203
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002204void Runtime::AddCurrentRuntimeFeaturesAsDex2OatArguments(std::vector<std::string>* argv)
Ian Rogers8afeb852014-04-02 14:55:49 -07002205 const {
Nicolas Geoffrayc6b1b932016-03-22 09:52:40 +00002206 if (GetInstrumentation()->InterpretOnly()) {
Nicolas Geoffray49cda062017-04-21 13:08:25 +01002207 argv->push_back("--compiler-filter=quicken");
Ian Rogers9bc54402014-04-17 16:40:01 -07002208 }
2209
Ian Rogers8afeb852014-04-02 14:55:49 -07002210 // Make the dex2oat instruction set match that of the launching runtime. If we have multiple
2211 // architecture support, dex2oat may be compiled as a different instruction-set than that
2212 // currently being executed.
Ian Rogersb9beb2e2014-05-09 16:57:40 -07002213 std::string instruction_set("--instruction-set=");
2214 instruction_set += GetInstructionSetString(kRuntimeISA);
2215 argv->push_back(instruction_set);
Ian Rogers8afeb852014-04-02 14:55:49 -07002216
Ian Rogers6f3dbba2014-10-14 17:41:57 -07002217 std::unique_ptr<const InstructionSetFeatures> features(InstructionSetFeatures::FromCppDefines());
2218 std::string feature_string("--instruction-set-features=");
2219 feature_string += features->GetFeatureString();
2220 argv->push_back(feature_string);
Ian Rogers8afeb852014-04-02 14:55:49 -07002221}
2222
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002223void Runtime::CreateJit() {
Mathieu Chartier455f67c2015-03-17 13:48:29 -07002224 CHECK(!IsAotCompiler());
Calin Juravleaf36e492016-04-27 18:50:45 +01002225 if (kIsDebugBuild && GetInstrumentation()->IsForcedInterpretOnly()) {
2226 DCHECK(!jit_options_->UseJitCompilation());
Hiroshi Yamauchi02d2f292015-04-03 13:35:16 -07002227 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002228 std::string error_msg;
2229 jit_.reset(jit::Jit::Create(jit_options_.get(), &error_msg));
Nicolas Geoffray274fe4a2016-04-12 16:33:24 +01002230 if (jit_.get() == nullptr) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002231 LOG(WARNING) << "Failed to create JIT " << error_msg;
Calin Juravle9545f6d2017-03-16 19:05:09 -07002232 return;
2233 }
2234
2235 // In case we have a profile path passed as a command line argument,
2236 // register the current class path for profiling now. Note that we cannot do
2237 // this before we create the JIT and having it here is the most convenient way.
2238 // This is used when testing profiles with dalvikvm command as there is no
2239 // framework to register the dex files for profiling.
2240 if (jit_options_->GetSaveProfilingInfo() &&
2241 !jit_options_->GetProfileSaverOptions().GetProfilePath().empty()) {
2242 std::vector<std::string> dex_filenames;
2243 Split(class_path_string_, ':', &dex_filenames);
2244 RegisterAppInfo(dex_filenames, jit_options_->GetProfileSaverOptions().GetProfilePath());
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002245 }
2246}
2247
Andreas Gampe4585f872015-03-27 23:45:15 -07002248bool Runtime::CanRelocate() const {
2249 return !IsAotCompiler() || compiler_callbacks_->IsRelocationPossible();
2250}
2251
2252bool Runtime::IsCompilingBootImage() const {
2253 return IsCompiler() && compiler_callbacks_->IsBootImage();
2254}
2255
Mathieu Chartiere401d142015-04-22 13:56:20 -07002256void Runtime::SetResolutionMethod(ArtMethod* method) {
2257 CHECK(method != nullptr);
2258 CHECK(method->IsRuntimeMethod()) << method;
2259 resolution_method_ = method;
2260}
2261
2262void Runtime::SetImtUnimplementedMethod(ArtMethod* method) {
2263 CHECK(method != nullptr);
2264 CHECK(method->IsRuntimeMethod());
2265 imt_unimplemented_method_ = method;
Mathieu Chartier91288d82016-04-28 09:44:54 -07002266}
2267
2268void Runtime::FixupConflictTables() {
2269 // We can only do this after the class linker is created.
Andreas Gampe542451c2016-07-26 09:02:02 -07002270 const PointerSize pointer_size = GetClassLinker()->GetImagePointerSize();
Mathieu Chartier91288d82016-04-28 09:44:54 -07002271 if (imt_unimplemented_method_->GetImtConflictTable(pointer_size) == nullptr) {
2272 imt_unimplemented_method_->SetImtConflictTable(
2273 ClassLinker::CreateImtConflictTable(/*count*/0u, GetLinearAlloc(), pointer_size),
2274 pointer_size);
2275 }
2276 if (imt_conflict_method_->GetImtConflictTable(pointer_size) == nullptr) {
2277 imt_conflict_method_->SetImtConflictTable(
2278 ClassLinker::CreateImtConflictTable(/*count*/0u, GetLinearAlloc(), pointer_size),
2279 pointer_size);
Nicolas Geoffray40c68c62016-03-23 16:35:51 +00002280 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07002281}
2282
Igor Murashkin7617abd2015-07-10 18:27:47 -07002283bool Runtime::IsVerificationEnabled() const {
Igor Murashkindf707e42016-02-02 16:56:50 -08002284 return verify_ == verifier::VerifyMode::kEnable ||
2285 verify_ == verifier::VerifyMode::kSoftFail;
Igor Murashkin7617abd2015-07-10 18:27:47 -07002286}
2287
2288bool Runtime::IsVerificationSoftFail() const {
2289 return verify_ == verifier::VerifyMode::kSoftFail;
2290}
2291
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002292bool Runtime::IsAsyncDeoptimizeable(uintptr_t code) const {
2293 // We only support async deopt (ie the compiled code is not explicitly asking for
2294 // deopt, but something else like the debugger) in debuggable JIT code.
2295 // We could look at the oat file where `code` is being defined,
2296 // and check whether it's been compiled debuggable, but we decided to
2297 // only rely on the JIT for debuggable apps.
2298 return IsJavaDebuggable() &&
2299 GetJit() != nullptr &&
2300 GetJit()->GetCodeCache()->ContainsPc(reinterpret_cast<const void*>(code));
Mingyao Yangf711f2c2016-05-23 12:29:39 -07002301}
2302
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07002303LinearAlloc* Runtime::CreateLinearAlloc() {
Mathieu Chartierc3fcd412015-09-25 16:54:59 -07002304 // For 64 bit compilers, it needs to be in low 4GB in the case where we are cross compiling for a
2305 // 32 bit target. In this case, we have 32 bit pointers in the dex cache arrays which can't hold
2306 // when we have 64 bit ArtMethod pointers.
Mathieu Chartier017ed0b2015-09-22 11:04:26 -07002307 return (IsAotCompiler() && Is64BitInstructionSet(kRuntimeISA))
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07002308 ? new LinearAlloc(low_4gb_arena_pool_.get())
2309 : new LinearAlloc(arena_pool_.get());
2310}
2311
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -07002312double Runtime::GetHashTableMinLoadFactor() const {
2313 return is_low_memory_mode_ ? kLowMemoryMinLoadFactor : kNormalMinLoadFactor;
2314}
2315
2316double Runtime::GetHashTableMaxLoadFactor() const {
2317 return is_low_memory_mode_ ? kLowMemoryMaxLoadFactor : kNormalMaxLoadFactor;
2318}
2319
Mathieu Chartierf8cb1782016-03-18 18:45:41 -07002320void Runtime::UpdateProcessState(ProcessState process_state) {
2321 ProcessState old_process_state = process_state_;
2322 process_state_ = process_state;
2323 GetHeap()->UpdateProcessState(old_process_state, process_state);
2324}
2325
Calin Juravle97cbc922016-04-15 16:16:35 +01002326void Runtime::RegisterSensitiveThread() const {
2327 Thread::SetJitSensitiveThread();
2328}
2329
Calin Juravleffc87072016-04-20 14:22:09 +01002330// Returns true if JIT compilations are enabled. GetJit() will be not null in this case.
2331bool Runtime::UseJitCompilation() const {
2332 return (jit_ != nullptr) && jit_->UseJitCompilation();
2333}
2334
David Sehrd106d9f2016-08-16 19:22:57 -07002335void Runtime::EnvSnapshot::TakeSnapshot() {
2336 char** env = GetEnviron();
2337 for (size_t i = 0; env[i] != nullptr; ++i) {
2338 name_value_pairs_.emplace_back(new std::string(env[i]));
2339 }
2340 // The strings in name_value_pairs_ retain ownership of the c_str, but we assign pointers
2341 // for quick use by GetSnapshot. This avoids allocation and copying cost at Exec.
2342 c_env_vector_.reset(new char*[name_value_pairs_.size() + 1]);
2343 for (size_t i = 0; env[i] != nullptr; ++i) {
2344 c_env_vector_[i] = const_cast<char*>(name_value_pairs_[i]->c_str());
2345 }
2346 c_env_vector_[name_value_pairs_.size()] = nullptr;
2347}
2348
2349char** Runtime::EnvSnapshot::GetSnapshot() const {
2350 return c_env_vector_.get();
2351}
2352
Andreas Gampefda57142016-09-08 20:29:18 -07002353void Runtime::AddSystemWeakHolder(gc::AbstractSystemWeakHolder* holder) {
2354 gc::ScopedGCCriticalSection gcs(Thread::Current(),
2355 gc::kGcCauseAddRemoveSystemWeakHolder,
2356 gc::kCollectorTypeAddRemoveSystemWeakHolder);
Andreas Gampe1f648592017-01-13 10:46:01 -08002357 // Note: The ScopedGCCriticalSection also ensures that the rest of the function is in
2358 // a critical section.
Andreas Gampefda57142016-09-08 20:29:18 -07002359 system_weak_holders_.push_back(holder);
2360}
2361
2362void Runtime::RemoveSystemWeakHolder(gc::AbstractSystemWeakHolder* holder) {
2363 gc::ScopedGCCriticalSection gcs(Thread::Current(),
2364 gc::kGcCauseAddRemoveSystemWeakHolder,
2365 gc::kCollectorTypeAddRemoveSystemWeakHolder);
2366 auto it = std::find(system_weak_holders_.begin(), system_weak_holders_.end(), holder);
2367 if (it != system_weak_holders_.end()) {
2368 system_weak_holders_.erase(it);
2369 }
2370}
2371
Andreas Gampeac30fa22017-01-18 21:02:36 -08002372RuntimeCallbacks* Runtime::GetRuntimeCallbacks() {
2373 return callbacks_.get();
2374}
2375
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002376// Used to patch boot image method entry point to interpreter bridge.
2377class UpdateEntryPointsClassVisitor : public ClassVisitor {
2378 public:
2379 explicit UpdateEntryPointsClassVisitor(instrumentation::Instrumentation* instrumentation)
2380 : instrumentation_(instrumentation) {}
2381
2382 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES(Locks::mutator_lock_) {
2383 auto pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
2384 for (auto& m : klass->GetMethods(pointer_size)) {
2385 const void* code = m.GetEntryPointFromQuickCompiledCode();
2386 if (Runtime::Current()->GetHeap()->IsInBootImageOatFile(code) &&
2387 !m.IsNative() &&
2388 !m.IsProxyMethod()) {
2389 instrumentation_->UpdateMethodsCodeForJavaDebuggable(&m, GetQuickToInterpreterBridge());
2390 }
2391 }
2392 return true;
2393 }
2394
2395 private:
2396 instrumentation::Instrumentation* const instrumentation_;
2397};
2398
2399void Runtime::SetJavaDebuggable(bool value) {
2400 is_java_debuggable_ = value;
2401 // Do not call DeoptimizeBootImage just yet, the runtime may still be starting up.
2402}
2403
2404void Runtime::DeoptimizeBootImage() {
2405 // If we've already started and we are setting this runtime to debuggable,
2406 // we patch entry points of methods in boot image to interpreter bridge, as
2407 // boot image code may be AOT compiled as not debuggable.
2408 if (!GetInstrumentation()->IsForcedInterpretOnly()) {
2409 ScopedObjectAccess soa(Thread::Current());
2410 UpdateEntryPointsClassVisitor visitor(GetInstrumentation());
2411 GetClassLinker()->VisitClasses(&visitor);
2412 }
2413}
2414
Carl Shapiro1fb86202011-06-27 17:43:13 -07002415} // namespace art