blob: f5443c822db70dc6b9f91938fd15f230a5e4fc16 [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
Andreas Gampe8cf9cb32017-07-19 09:28:38 -070026#include <fcntl.h>
Brian Carlstromdbf05b72011-12-15 00:55:24 -080027#include <signal.h>
Elliott Hughesd06a6c72012-05-30 17:59:06 -070028#include <sys/syscall.h>
Andreas Gampe8cf9cb32017-07-19 09:28:38 -070029
David Sehrd106d9f2016-08-16 19:22:57 -070030#if defined(__APPLE__)
31#include <crt_externs.h> // for _NSGetEnviron
32#endif
Brian Carlstromdbf05b72011-12-15 00:55:24 -080033
Elliott Hughesffe67362011-07-17 12:09:27 -070034#include <cstdio>
35#include <cstdlib>
Brian Carlstrom8a436592011-08-15 21:27:23 -070036#include <limits>
Mathieu Chartierada33d72018-12-17 13:17:30 -080037#include <thread>
Carl Shapiro2ed144c2011-07-26 16:52:08 -070038#include <vector>
Elliott Hughesffe67362011-07-17 12:09:27 -070039
Andreas Gampe9186ced2016-12-12 14:28:21 -080040#include "android-base/strings.h"
41
Chang Xing605fe242017-07-20 15:57:21 -070042#include "aot_class_linker.h"
Ian Rogers166db042013-07-26 12:05:57 -070043#include "arch/arm/registers_arm.h"
Stuart Monteithb95a5342014-03-12 13:32:32 +000044#include "arch/arm64/registers_arm64.h"
Andreas Gampee5d23982019-01-08 10:34:26 -080045#include "arch/context.h"
Ian Rogersd582fa42014-11-05 23:46:43 -080046#include "arch/instruction_set_features.h"
Ian Rogers166db042013-07-26 12:05:57 -070047#include "arch/mips/registers_mips.h"
Andreas Gampe57b34292015-01-14 15:45:59 -080048#include "arch/mips64/registers_mips64.h"
Ian Rogers166db042013-07-26 12:05:57 -070049#include "arch/x86/registers_x86.h"
Ian Rogersef7d42f2014-01-06 12:55:46 -080050#include "arch/x86_64/registers_x86_64.h"
Mathieu Chartierc7853442015-03-27 14:35:38 -070051#include "art_field-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070052#include "art_method-inl.h"
Ian Rogers1d8cdbc2014-09-22 22:51:09 -070053#include "asm_support.h"
Andreas Gampe39b378c2017-12-07 15:44:13 -080054#include "base/aborting.h"
Andreas Gampe4585f872015-03-27 23:45:15 -070055#include "base/arena_allocator.h"
David Sehrc431b9d2018-03-02 12:01:51 -080056#include "base/atomic.h"
Ian Rogersc7dd2952014-10-21 23:31:19 -070057#include "base/dumpable.h"
Andreas Gampe542451c2016-07-26 09:02:02 -070058#include "base/enums.h"
David Sehr891a50e2017-10-27 17:01:07 -070059#include "base/file_utils.h"
David Sehr3215fff2018-04-03 17:10:12 -070060#include "base/malloc_arena_pool.h"
61#include "base/mem_map_arena_pool.h"
Andreas Gampe8cf9cb32017-07-19 09:28:38 -070062#include "base/memory_tool.h"
David Sehrc431b9d2018-03-02 12:01:51 -080063#include "base/mutex.h"
64#include "base/os.h"
65#include "base/quasi_atomic.h"
David Brazdil2bb2fbd2018-11-13 18:24:26 +000066#include "base/sdk_version.h"
Vladimir Marko637ee0b2015-09-04 12:47:41 +010067#include "base/stl_util.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080068#include "base/systrace.h"
Ian Rogers1d8cdbc2014-09-22 22:51:09 -070069#include "base/unix_file/fd_file.h"
David Sehrc431b9d2018-03-02 12:01:51 -080070#include "base/utils.h"
Vladimir Marko3481ba22015-04-13 12:22:36 +010071#include "class_linker-inl.h"
Vladimir Marko679730e2018-05-25 15:06:48 +010072#include "class_root.h"
Andreas Gampe4585f872015-03-27 23:45:15 -070073#include "compiler_callbacks.h"
Elliott Hughes3bb81562011-10-21 18:52:59 -070074#include "debugger.h"
David Sehr013fd802018-01-11 22:55:24 -080075#include "dex/art_dex_file_loader.h"
David Sehr9e734c72018-01-04 17:56:19 -080076#include "dex/dex_file_loader.h"
Alex Light84d76052014-08-22 17:49:35 -070077#include "elf_file.h"
Ian Rogers6f3dbba2014-10-14 17:41:57 -070078#include "entrypoints/runtime_asm_entrypoints.h"
Alex Lighteb7c1442015-08-31 13:17:42 -070079#include "experimental_flags.h"
Ian Rogers576ca0c2014-06-06 15:58:22 -070080#include "fault_handler.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070081#include "gc/accounting/card_table-inl.h"
82#include "gc/heap.h"
Andreas Gampefda57142016-09-08 20:29:18 -070083#include "gc/scoped_gc_critical_section.h"
Ian Rogerse63db272014-07-15 15:36:11 -070084#include "gc/space/image_space.h"
Mathieu Chartier461687d2015-03-31 12:05:24 -070085#include "gc/space/space-inl.h"
Andreas Gampefda57142016-09-08 20:29:18 -070086#include "gc/system_weak.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -080087#include "handle_scope-inl.h"
Andreas Gampeaa120012018-03-28 16:23:24 -070088#include "hidden_api.h"
Mathieu Chartier4a26f172016-01-26 14:26:18 -080089#include "image-inl.h"
jeffhao725a9572012-11-13 18:20:12 -080090#include "instrumentation.h"
Mathieu Chartier74ccee62018-10-10 10:30:29 -070091#include "intern_table-inl.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080092#include "interpreter/interpreter.h"
93#include "jit/jit.h"
Nicolas Geoffray132d8362016-11-16 09:19:42 +000094#include "jit/jit_code_cache.h"
Steven Morelande431e272017-07-18 16:53:49 -070095#include "jit/profile_saver.h"
Vladimir Markoa3ad0cd2018-05-04 10:06:38 +010096#include "jni/java_vm_ext.h"
97#include "jni/jni_internal.h"
Mathieu Chartierc7853442015-03-27 14:35:38 -070098#include "linear_alloc.h"
Andreas Gampe8cf9cb32017-07-19 09:28:38 -070099#include "memory_representation.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800100#include "mirror/array.h"
Andreas Gampe70f5fd02018-10-24 19:58:37 -0700101#include "mirror/class-alloc-inl.h"
Ian Rogers62d6c772013-02-27 08:32:07 -0800102#include "mirror/class-inl.h"
Alex Lightcec2fd42016-11-02 16:32:07 -0700103#include "mirror/class_ext.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800104#include "mirror/class_loader.h"
Narayan Kamath000e1882016-10-24 17:14:25 +0100105#include "mirror/emulated_stack_frame.h"
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700106#include "mirror/field.h"
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700107#include "mirror/method.h"
Narayan Kamathafa48272016-08-03 12:46:58 +0100108#include "mirror/method_handle_impl.h"
Orion Hodsonc069a302017-01-18 09:23:12 +0000109#include "mirror/method_handles_lookup.h"
Narayan Kamathafa48272016-08-03 12:46:58 +0100110#include "mirror/method_type.h"
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800111#include "mirror/stack_trace_element.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800112#include "mirror/throwable.h"
Orion Hodson928033d2018-02-07 05:30:54 +0000113#include "mirror/var_handle.h"
Elliott Hughes32d6e1e2011-10-11 14:47:44 -0700114#include "monitor.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800115#include "native/dalvik_system_DexFile.h"
116#include "native/dalvik_system_VMDebug.h"
117#include "native/dalvik_system_VMRuntime.h"
118#include "native/dalvik_system_VMStack.h"
119#include "native/dalvik_system_ZygoteHooks.h"
120#include "native/java_lang_Class.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800121#include "native/java_lang_Object.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800122#include "native/java_lang_String.h"
Jeff Hao848f70a2014-01-15 13:49:50 -0800123#include "native/java_lang_StringFactory.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800124#include "native/java_lang_System.h"
125#include "native/java_lang_Thread.h"
126#include "native/java_lang_Throwable.h"
127#include "native/java_lang_VMClassLoader.h"
Narayan Kamathbd2fed52017-01-25 10:46:54 +0000128#include "native/java_lang_invoke_MethodHandleImpl.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800129#include "native/java_lang_ref_FinalizerReference.h"
130#include "native/java_lang_ref_Reference.h"
131#include "native/java_lang_reflect_Array.h"
132#include "native/java_lang_reflect_Constructor.h"
Neil Fuller0e844392016-09-08 13:43:31 +0100133#include "native/java_lang_reflect_Executable.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800134#include "native/java_lang_reflect_Field.h"
135#include "native/java_lang_reflect_Method.h"
Neil Fuller60458a02016-09-01 15:32:44 +0100136#include "native/java_lang_reflect_Parameter.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800137#include "native/java_lang_reflect_Proxy.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800138#include "native/java_util_concurrent_atomic_AtomicLong.h"
Jeff Hao848f70a2014-01-15 13:49:50 -0800139#include "native/libcore_util_CharsetUtils.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800140#include "native/org_apache_harmony_dalvik_ddmc_DdmServer.h"
141#include "native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.h"
142#include "native/sun_misc_Unsafe.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800143#include "native_bridge_art_interface.h"
Andreas Gampe5dd44d02016-08-02 17:20:03 -0700144#include "native_stack_dump.h"
Andreas Gampe373a9b52017-10-18 09:01:57 -0700145#include "nativehelper/scoped_local_ref.h"
Brian Carlstrome24fa612011-09-29 00:53:55 -0700146#include "oat_file.h"
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -0700147#include "oat_file_manager.h"
Andreas Gamped482e732017-04-24 17:59:09 -0700148#include "object_callbacks.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800149#include "parsed_options.h"
Vladimir Marko7624d252014-05-02 14:40:15 +0100150#include "quick/quick_method_frame_info.h"
Ian Rogers53b8b092014-03-13 23:45:53 -0700151#include "reflection.h"
Andreas Gampeac30fa22017-01-18 21:02:36 -0800152#include "runtime_callbacks.h"
Orion Hodson26ef34c2017-11-01 13:32:41 +0000153#include "runtime_intrinsics.h"
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800154#include "runtime_options.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -0700155#include "scoped_thread_state_change-inl.h"
Dave Allisoncefcea82014-09-16 10:01:01 -0700156#include "sigchain.h"
Elliott Hughese27955c2011-08-26 15:21:24 -0700157#include "signal_catcher.h"
Elliott Hughes457005c2012-04-16 13:54:25 -0700158#include "signal_set.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700159#include "thread.h"
Elliott Hughes8daa0922011-09-11 13:46:25 -0700160#include "thread_list.h"
Alex Light7233c7e2016-07-28 10:07:45 -0700161#include "ti/agent.h"
jeffhaob5e81852012-03-12 11:15:45 -0700162#include "trace.h"
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100163#include "transaction.h"
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100164#include "vdex_file.h"
Ian Rogers776ac1f2012-04-13 23:36:36 -0700165#include "verifier/method_verifier.h"
Elliott Hugheseac76672012-05-24 21:56:51 -0700166#include "well_known_classes.h"
Carl Shapiro61e019d2011-07-14 16:53:09 -0700167
David Sehrf57589f2016-10-17 10:09:33 -0700168#ifdef ART_TARGET_ANDROID
169#include <android/set_abort_message.h>
170#endif
171
David Srbecky50b47432018-10-18 12:26:34 +0100172// Static asserts to check the values of generated assembly-support macros.
173#define ASM_DEFINE(NAME, EXPR) static_assert((NAME) == (EXPR), "Unexpected value of " #NAME);
174#include "asm_defines.def"
175#undef ASM_DEFINE
176
Carl Shapiro1fb86202011-06-27 17:43:13 -0700177namespace art {
178
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700179// If a signal isn't handled properly, enable a handler that attempts to dump the Java stack.
Brian Carlstromb57f1c72014-10-08 13:56:25 -0700180static constexpr bool kEnableJavaStackTraceHandler = false;
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -0700181// Tuned by compiling GmsCore under perf and measuring time spent in DescriptorEquals for class
182// linking.
183static constexpr double kLowMemoryMinLoadFactor = 0.5;
184static constexpr double kLowMemoryMaxLoadFactor = 0.8;
185static constexpr double kNormalMinLoadFactor = 0.4;
186static constexpr double kNormalMaxLoadFactor = 0.7;
Mathieu Chartier11c273d2017-10-15 20:54:45 -0700187
188// Extra added to the default heap growth multiplier. Used to adjust the GC ergonomics for the read
189// barrier config.
190static constexpr double kExtraDefaultHeapGrowthMultiplier = kUseReadBarrier ? 1.0 : 0.0;
191
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700192Runtime* Runtime::instance_ = nullptr;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700193
Andreas Gampef6a780a2015-04-02 18:51:05 -0700194struct TraceConfig {
195 Trace::TraceMode trace_mode;
196 Trace::TraceOutputMode trace_output_mode;
197 std::string trace_file;
198 size_t trace_file_size;
199};
200
David Sehrd106d9f2016-08-16 19:22:57 -0700201namespace {
Andreas Gampea2fed082019-02-01 09:34:43 -0800202
David Sehrd106d9f2016-08-16 19:22:57 -0700203#ifdef __APPLE__
204inline char** GetEnviron() {
205 // When Google Test is built as a framework on MacOS X, the environ variable
206 // is unavailable. Apple's documentation (man environ) recommends using
207 // _NSGetEnviron() instead.
208 return *_NSGetEnviron();
209}
210#else
211// Some POSIX platforms expect you to declare environ. extern "C" makes
212// it reside in the global namespace.
213extern "C" char** environ;
214inline char** GetEnviron() { return environ; }
215#endif
Andreas Gampea2fed082019-02-01 09:34:43 -0800216
217void CheckConstants() {
218 CHECK_EQ(mirror::Array::kFirstElementOffset, mirror::Array::FirstElementOffset());
219}
220
David Sehrd106d9f2016-08-16 19:22:57 -0700221} // namespace
222
Elliott Hughesdcc24742011-09-07 14:02:44 -0700223Runtime::Runtime()
Mathieu Chartier31000802015-06-14 14:14:37 -0700224 : resolution_method_(nullptr),
225 imt_conflict_method_(nullptr),
226 imt_unimplemented_method_(nullptr),
Vladimir Marko33bff252017-11-01 14:35:42 +0000227 instruction_set_(InstructionSet::kNone),
Ian Rogers6ed19fd2014-03-20 08:10:17 -0700228 compiler_callbacks_(nullptr),
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800229 is_zygote_(false),
Alex Lighta59dd802014-07-02 16:28:08 -0700230 must_relocate_(false),
Mathieu Chartier069387a2012-06-18 12:01:01 -0700231 is_concurrent_gc_enabled_(true),
Anwar Ghuloum87183592013-08-14 12:12:19 -0700232 is_explicit_gc_disabled_(false),
Alex Light64ad14d2014-08-19 14:23:13 -0700233 image_dex2oat_enabled_(true),
Elliott Hughes6cf23882012-06-15 15:42:07 -0700234 default_stack_size_(0),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800235 heap_(nullptr),
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700236 max_spins_before_thin_lock_inflation_(Monitor::kDefaultMaxSpinsBeforeThinLockInflation),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800237 monitor_list_(nullptr),
238 monitor_pool_(nullptr),
239 thread_list_(nullptr),
240 intern_table_(nullptr),
241 class_linker_(nullptr),
242 signal_catcher_(nullptr),
243 java_vm_(nullptr),
Mathieu Chartierada33d72018-12-17 13:17:30 -0800244 thread_pool_ref_count_(0u),
Andreas Gampe44f67602018-11-28 08:27:27 -0800245 fault_message_(nullptr),
Ian Rogers120f1c72012-09-28 17:17:10 -0700246 threads_being_born_(0),
Ian Rogersc604d732012-10-14 16:09:54 -0700247 shutdown_cond_(new ConditionVariable("Runtime shutdown", *Locks::runtime_shutdown_lock_)),
Elliott Hughes6b355752012-01-13 16:49:08 -0800248 shutting_down_(false),
Ian Rogers120f1c72012-09-28 17:17:10 -0700249 shutting_down_started_(false),
Elliott Hughesdcc24742011-09-07 14:02:44 -0700250 started_(false),
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700251 finished_starting_(false),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800252 vfprintf_(nullptr),
253 exit_(nullptr),
254 abort_(nullptr),
jeffhao2692b572011-12-16 15:42:28 -0800255 stats_enabled_(false),
Roland Levillain05e34f42018-05-24 13:19:05 +0000256 is_running_on_memory_tool_(kRunningOnMemoryTool),
Ian Rogers62d6c772013-02-27 08:32:07 -0800257 instrumentation_(),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800258 main_thread_group_(nullptr),
259 system_thread_group_(nullptr),
260 system_class_loader_(nullptr),
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100261 dump_gc_performance_on_shutdown_(false),
Chang Xing605fe242017-07-20 15:57:21 -0700262 preinitialization_transactions_(),
Igor Murashkin7617abd2015-07-10 18:27:47 -0700263 verify_(verifier::VerifyMode::kNone),
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700264 allow_dex_file_fallback_(true),
David Brazdil2bb2fbd2018-11-13 18:24:26 +0000265 target_sdk_version_(static_cast<uint32_t>(SdkVersion::kUnset)),
Dave Allison69dfe512014-07-11 17:11:58 +0000266 implicit_null_checks_(false),
267 implicit_so_checks_(false),
Calin Juravle07d83c72014-10-22 21:02:23 +0100268 implicit_suspend_checks_(false),
Calin Juravle01aaf6e2015-06-19 22:05:39 +0100269 no_sig_chain_(false),
Andreas Gampef38a6612016-04-11 08:42:26 -0700270 force_native_bridge_(false),
Narayan Kamath5a2be3f2015-02-16 13:51:51 +0000271 is_native_bridge_loaded_(false),
David Srbeckyf4480162016-03-16 00:06:24 +0000272 is_native_debuggable_(false),
Alex Light7919db92017-11-29 09:00:55 -0800273 async_exceptions_thrown_(false),
Alex Light0aa7a5a2018-10-10 15:58:14 +0000274 non_standard_exits_enabled_(false),
Nicolas Geoffray433b79a2017-01-30 20:54:45 +0000275 is_java_debuggable_(false),
Igor Murashkin158f35c2015-06-10 15:55:30 -0700276 zygote_max_failed_boots_(0),
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -0700277 experimental_flags_(ExperimentalFlags::kNone),
278 oat_file_manager_(nullptr),
Nicolas Geoffray787ae8e2015-11-05 11:32:24 +0000279 is_low_memory_mode_(false),
Andreas Gampea1425a12016-03-11 17:44:04 -0800280 safe_mode_(false),
David Brazdilf50ac102018-10-17 18:00:06 +0100281 hidden_api_policy_(hiddenapi::EnforcementPolicy::kDisabled),
David Brazdile7681822018-12-14 16:25:33 +0000282 core_platform_api_policy_(hiddenapi::EnforcementPolicy::kJustWarn),
David Brazdilee7d2fd2018-01-20 17:25:23 +0000283 dedupe_hidden_api_warnings_(true),
Mathew Inwood1fd97f22018-04-03 15:32:32 +0100284 hidden_api_access_event_log_rate_(0),
Nicolas Geoffray6ee49712018-03-30 14:39:05 +0000285 dump_native_stack_on_sig_quit_(true),
Mathieu Chartierf8cb1782016-03-18 18:45:41 -0700286 pruned_dalvik_cache_(false),
287 // Initially assume we perceive jank in case the process state is never updated.
Andreas Gampef38a6612016-04-11 08:42:26 -0700288 process_state_(kProcessStateJankPerceptible),
Andreas Gampe0b0ffc12018-08-01 14:41:27 -0700289 zygote_no_threads_(false),
290 verifier_logging_threshold_ms_(100) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -0700291 static_assert(Runtime::kCalleeSaveSize ==
292 static_cast<uint32_t>(CalleeSaveType::kLastCalleeSaveType), "Unexpected size");
Andreas Gampea2fed082019-02-01 09:34:43 -0800293 CheckConstants();
Andreas Gampe8228cdf2017-05-30 15:03:54 -0700294
Mathieu Chartiere401d142015-04-22 13:56:20 -0700295 std::fill(callee_save_methods_, callee_save_methods_ + arraysize(callee_save_methods_), 0u);
buzbee1452bee2015-03-06 14:43:04 -0800296 interpreter::CheckInterpreterAsmConstants();
Andreas Gampeac30fa22017-01-18 21:02:36 -0800297 callbacks_.reset(new RuntimeCallbacks());
Nicolas Geoffray4e92c3c2017-05-08 09:34:26 +0100298 for (size_t i = 0; i <= static_cast<size_t>(DeoptimizationKind::kLast); ++i) {
299 deoptimization_counts_[i] = 0u;
300 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700301}
302
Carl Shapiro61e019d2011-07-14 16:53:09 -0700303Runtime::~Runtime() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800304 ScopedTrace trace("Runtime shutdown");
Calin Juravle07d83c72014-10-22 21:02:23 +0100305 if (is_native_bridge_loaded_) {
306 UnloadNativeBridge();
307 }
Calin Juravle31f2c152015-10-23 17:56:15 +0100308
Ian Rogers120f1c72012-09-28 17:17:10 -0700309 Thread* self = Thread::Current();
Mathieu Chartier05d14612015-02-23 15:31:58 -0800310 const bool attach_shutdown_thread = self == nullptr;
311 if (attach_shutdown_thread) {
Alex Lightb6f34642018-01-04 11:01:48 -0800312 // We can only create a peer if the runtime is actually started. This is only not true during
Alex Lighte44ee0c2018-01-08 10:26:17 -0800313 // some tests. If there is extreme memory pressure the allocation of the thread peer can fail.
314 // In this case we will just try again without allocating a peer so that shutdown can continue.
315 // Very few things are actually capable of distinguishing between the peer & peerless states so
316 // this should be fine.
317 bool thread_attached = AttachCurrentThread("Shutdown thread",
Andreas Gampe98ea9d92018-10-19 14:06:15 -0700318 /* as_daemon= */ false,
Alex Lighte44ee0c2018-01-08 10:26:17 -0800319 GetSystemThreadGroup(),
Andreas Gampe98ea9d92018-10-19 14:06:15 -0700320 /* create_peer= */ IsStarted());
Alex Lighte44ee0c2018-01-08 10:26:17 -0800321 if (UNLIKELY(!thread_attached)) {
322 LOG(WARNING) << "Failed to attach shutdown thread. Trying again without a peer.";
323 CHECK(AttachCurrentThread("Shutdown thread (no java peer)",
Andreas Gampe98ea9d92018-10-19 14:06:15 -0700324 /* as_daemon= */ false,
325 /* thread_group=*/ nullptr,
326 /* create_peer= */ false));
Alex Lighte44ee0c2018-01-08 10:26:17 -0800327 }
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800328 self = Thread::Current();
329 } else {
330 LOG(WARNING) << "Current thread not detached in Runtime shutdown";
331 }
332
Mathieu Chartier1d495012017-04-11 17:50:00 -0700333 if (dump_gc_performance_on_shutdown_) {
Albert Mingkun Yang6e0d3252018-12-10 15:22:45 +0000334 heap_->CalculatePreGcWeightedAllocatedBytes();
Albert Mingkun Yang2d7329b2018-11-30 19:58:18 +0000335 uint64_t process_cpu_end_time = ProcessCpuNanoTime();
Mathieu Chartierb0042b82017-12-13 13:50:36 -0800336 ScopedLogSeverity sls(LogSeverity::INFO);
Mathieu Chartier1d495012017-04-11 17:50:00 -0700337 // This can't be called from the Heap destructor below because it
338 // could call RosAlloc::InspectAll() which needs the thread_list
339 // to be still alive.
340 heap_->DumpGcPerformanceInfo(LOG_STREAM(INFO));
Albert Mingkun Yangd6e178e2018-11-19 12:58:30 +0000341
Albert Mingkun Yang2d7329b2018-11-30 19:58:18 +0000342 uint64_t process_cpu_time = process_cpu_end_time - heap_->GetProcessCpuStartTime();
Albert Mingkun Yangd6e178e2018-11-19 12:58:30 +0000343 uint64_t gc_cpu_time = heap_->GetTotalGcCpuTime();
344 float ratio = static_cast<float>(gc_cpu_time) / process_cpu_time;
345 LOG_STREAM(INFO) << "GC CPU time " << PrettyDuration(gc_cpu_time)
346 << " out of process CPU time " << PrettyDuration(process_cpu_time)
347 << " (" << ratio << ")"
348 << "\n";
Albert Mingkun Yang6e0d3252018-12-10 15:22:45 +0000349 double pre_gc_weighted_allocated_bytes =
350 heap_->GetPreGcWeightedAllocatedBytes() / process_cpu_time;
Albert Mingkun Yang1c0ae842019-01-11 16:52:24 +0000351 // Here we don't use process_cpu_time for normalization, because VM shutdown is not a real
352 // GC. Both numerator and denominator take into account until the end of the last GC,
353 // instead of the whole process life time like pre_gc_weighted_allocated_bytes.
Albert Mingkun Yang6e0d3252018-12-10 15:22:45 +0000354 double post_gc_weighted_allocated_bytes =
Albert Mingkun Yang1c0ae842019-01-11 16:52:24 +0000355 heap_->GetPostGcWeightedAllocatedBytes() /
356 (heap_->GetPostGCLastProcessCpuTime() - heap_->GetProcessCpuStartTime());
Albert Mingkun Yang6e0d3252018-12-10 15:22:45 +0000357
Albert Mingkun Yang16bd6ac2018-12-19 17:55:23 +0000358 LOG_STREAM(INFO) << "Average bytes allocated at GC start, weighted by CPU time between GCs: "
359 << static_cast<uint64_t>(pre_gc_weighted_allocated_bytes)
Albert Mingkun Yang6e0d3252018-12-10 15:22:45 +0000360 << " (" << PrettySize(pre_gc_weighted_allocated_bytes) << ")";
Albert Mingkun Yang16bd6ac2018-12-19 17:55:23 +0000361 LOG_STREAM(INFO) << "Average bytes allocated at GC end, weighted by CPU time between GCs: "
362 << static_cast<uint64_t>(post_gc_weighted_allocated_bytes)
Albert Mingkun Yang6e0d3252018-12-10 15:22:45 +0000363 << " (" << PrettySize(post_gc_weighted_allocated_bytes) << ")"
Albert Mingkun Yang2d7329b2018-11-30 19:58:18 +0000364 << "\n";
Mathieu Chartier1d495012017-04-11 17:50:00 -0700365 }
366
Mathieu Chartierada33d72018-12-17 13:17:30 -0800367 WaitForThreadPoolWorkersToStart();
368
Calin Juravlea345d312017-03-14 18:45:55 -0700369 if (jit_ != nullptr) {
Mathieu Chartier93c21ba2018-12-10 13:08:30 -0800370 // Wait for the workers to be created since there can't be any threads attaching during
371 // shutdown.
372 jit_->WaitForWorkersToBeCreated();
Calin Juravlea345d312017-03-14 18:45:55 -0700373 // Stop the profile saver thread before marking the runtime as shutting down.
374 // The saver will try to dump the profiles before being sopped and that
375 // requires holding the mutator lock.
376 jit_->StopProfileSaver();
377 }
378
Ian Rogers120f1c72012-09-28 17:17:10 -0700379 {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800380 ScopedTrace trace2("Wait for shutdown cond");
Ian Rogers120f1c72012-09-28 17:17:10 -0700381 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
382 shutting_down_started_ = true;
383 while (threads_being_born_ > 0) {
Ian Rogersc604d732012-10-14 16:09:54 -0700384 shutdown_cond_->Wait(self);
Ian Rogers120f1c72012-09-28 17:17:10 -0700385 }
386 shutting_down_ = true;
387 }
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800388 // Shutdown and wait for the daemons.
389 CHECK(self != nullptr);
390 if (IsFinishedStarting()) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800391 ScopedTrace trace2("Waiting for Daemons");
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800392 self->ClearException();
393 self->GetJniEnv()->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons,
394 WellKnownClasses::java_lang_Daemons_stop);
395 }
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700396
397 Trace::Shutdown();
398
Andreas Gampe48864112017-01-19 17:23:17 -0800399 // Report death. Clients me require a working thread, still, so do it before GC completes and
400 // all non-daemon threads are done.
401 {
402 ScopedObjectAccess soa(self);
403 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kDeath);
404 }
405
Mathieu Chartier05d14612015-02-23 15:31:58 -0800406 if (attach_shutdown_thread) {
407 DetachCurrentThread();
408 self = nullptr;
409 }
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800410
Mathieu Chartiera6399032012-06-11 18:49:50 -0700411 // Make sure to let the GC complete if it is running.
Mathieu Chartier89a201e2014-05-02 10:27:26 -0700412 heap_->WaitForGcToComplete(gc::kGcCauseBackground, self);
Mathieu Chartier35883cc2012-11-13 14:08:12 -0800413 heap_->DeleteThreadPool();
Mathieu Chartierfb6db4c2016-01-06 17:23:25 -0800414 if (jit_ != nullptr) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800415 ScopedTrace trace2("Delete jit");
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800416 VLOG(jit) << "Deleting jit thread pool";
417 // Delete thread pool before the thread list since we don't want to wait forever on the
418 // JIT compiler threads.
419 jit_->DeleteThreadPool();
420 }
Mathieu Chartierada33d72018-12-17 13:17:30 -0800421 DeleteThreadPool();
422 CHECK(thread_pool_ == nullptr);
Mathieu Chartiera6399032012-06-11 18:49:50 -0700423
Andreas Gampec4bed162017-05-01 13:46:24 -0700424 // Make sure our internal threads are dead before we start tearing down things they're using.
Alex Light40320712017-12-14 11:52:04 -0800425 GetRuntimeCallbacks()->StopDebugger();
Andreas Gampec4bed162017-05-01 13:46:24 -0700426 delete signal_catcher_;
427
428 // Make sure all other non-daemon threads have terminated, and all daemon threads are suspended.
429 {
430 ScopedTrace trace2("Delete thread list");
431 thread_list_->ShutDown();
432 }
433
Alex Light7233c7e2016-07-28 10:07:45 -0700434 // TODO Maybe do some locking.
435 for (auto& agent : agents_) {
Andreas Gampeaadcbc62017-12-28 14:05:42 -0800436 agent->Unload();
Alex Light7233c7e2016-07-28 10:07:45 -0700437 }
438
Alex Light185d1342016-08-11 10:48:03 -0700439 // TODO Maybe do some locking
440 for (auto& plugin : plugins_) {
441 plugin.Unload();
442 }
443
Andreas Gampec4bed162017-05-01 13:46:24 -0700444 // Finally delete the thread list.
445 delete thread_list_;
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700446
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800447 // Delete the JIT after thread list to ensure that there is no remaining threads which could be
448 // accessing the instrumentation when we delete it.
Mathieu Chartierfb6db4c2016-01-06 17:23:25 -0800449 if (jit_ != nullptr) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800450 VLOG(jit) << "Deleting jit";
451 jit_.reset(nullptr);
Orion Hodsonad28f5e2018-10-17 09:08:17 +0100452 jit_code_cache_.reset(nullptr);
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800453 }
454
Vladimir Marko2beeb822014-10-20 18:13:22 +0100455 // Shutdown the fault manager if it was initialized.
456 fault_manager.Shutdown();
457
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800458 ScopedTrace trace2("Delete state");
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700459 delete monitor_list_;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800460 delete monitor_pool_;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700461 delete class_linker_;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800462 delete heap_;
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700463 delete intern_table_;
Mathieu Chartiere58991b2015-10-13 07:59:34 -0700464 delete oat_file_manager_;
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700465 Thread::Shutdown();
Elliott Hughes7c6169d2012-05-02 16:11:48 -0700466 QuasiAtomic::Shutdown();
Sebastien Hertz4d4adb12013-07-24 16:14:19 +0200467 verifier::MethodVerifier::Shutdown();
Vladimir Marko37cf51f2015-09-22 11:43:46 +0100468
469 // Destroy allocators before shutting down the MemMap because they may use it.
Richard Uhlerda0a69e2016-10-11 15:06:38 +0100470 java_vm_.reset();
Vladimir Marko37cf51f2015-09-22 11:43:46 +0100471 linear_alloc_.reset();
472 low_4gb_arena_pool_.reset();
473 arena_pool_.reset();
Nicolas Geoffray25e04562016-03-01 13:17:58 +0000474 jit_arena_pool_.reset();
Vladimir Markoc34bebf2018-08-16 16:12:49 +0100475 protected_fault_page_.Reset();
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700476 MemMap::Shutdown();
Vladimir Marko37cf51f2015-09-22 11:43:46 +0100477
Carl Shapiro4acf4642011-07-26 18:54:13 -0700478 // TODO: acquire a static mutex on Runtime to avoid racing.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800479 CHECK(instance_ == nullptr || instance_ == this);
480 instance_ = nullptr;
Andreas Gampedb48a792017-09-08 22:18:30 -0700481
482 // Well-known classes must be deleted or it is impossible to successfully start another Runtime
483 // instance. We rely on a small initialization order issue in Runtime::Start() that requires
484 // elements of WellKnownClasses to be null, see b/65500943.
485 WellKnownClasses::Clear();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700486}
487
Elliott Hughese0918552011-10-28 17:18:29 -0700488struct AbortState {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700489 void Dump(std::ostream& os) const {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000490 if (gAborting > 1) {
491 os << "Runtime aborting --- recursively, so no thread-specific detail!\n";
Andreas Gampe9fd470f2016-11-18 17:21:12 -0800492 DumpRecursiveAbort(os);
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000493 return;
494 }
495 gAborting++;
Elliott Hughese0918552011-10-28 17:18:29 -0700496 os << "Runtime aborting...\n";
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700497 if (Runtime::Current() == nullptr) {
Elliott Hughes6c7d2442012-02-01 18:40:47 -0800498 os << "(Runtime does not yet exist!)\n";
Andreas Gampe6eb6a392016-02-10 20:18:37 -0800499 DumpNativeStack(os, GetTid(), nullptr, " native: ", nullptr);
Elliott Hughes6c7d2442012-02-01 18:40:47 -0800500 return;
501 }
Elliott Hughese0918552011-10-28 17:18:29 -0700502 Thread* self = Thread::Current();
Andreas Gampea3f78fe2017-09-05 09:31:04 -0700503
504 // Dump all threads first and then the aborting thread. While this is counter the logical flow,
505 // it improves the chance of relevant data surviving in the Android logs.
506
507 DumpAllThreads(os, self);
508
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700509 if (self == nullptr) {
Elliott Hughese0918552011-10-28 17:18:29 -0700510 os << "(Aborting thread was not attached to runtime!)\n";
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700511 DumpKernelStack(os, GetTid(), " kernel: ", false);
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800512 DumpNativeStack(os, GetTid(), nullptr, " native: ", nullptr);
Elliott Hughese0918552011-10-28 17:18:29 -0700513 } else {
Ian Rogers2f7f9b62012-10-10 18:24:05 -0700514 os << "Aborting thread:\n";
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700515 if (Locks::mutator_lock_->IsExclusiveHeld(self) || Locks::mutator_lock_->IsSharedHeld(self)) {
516 DumpThread(os, self);
517 } else {
518 if (Locks::mutator_lock_->SharedTryLock(self)) {
519 DumpThread(os, self);
520 Locks::mutator_lock_->SharedUnlock(self);
521 }
Elliott Hughes899e7892012-01-24 14:57:32 -0800522 }
Elliott Hughese0918552011-10-28 17:18:29 -0700523 }
Ian Rogers2f7f9b62012-10-10 18:24:05 -0700524 }
525
Ian Rogers7b078e82014-09-10 14:44:24 -0700526 // No thread-safety analysis as we do explicitly test for holding the mutator lock.
Ian Rogersc7dd2952014-10-21 23:31:19 -0700527 void DumpThread(std::ostream& os, Thread* self) const NO_THREAD_SAFETY_ANALYSIS {
Ian Rogers7b078e82014-09-10 14:44:24 -0700528 DCHECK(Locks::mutator_lock_->IsExclusiveHeld(self) || Locks::mutator_lock_->IsSharedHeld(self));
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700529 self->Dump(os);
530 if (self->IsExceptionPending()) {
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000531 mirror::Throwable* exception = self->GetException();
532 os << "Pending exception " << exception->Dump();
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700533 }
534 }
535
Ian Rogersc7dd2952014-10-21 23:31:19 -0700536 void DumpAllThreads(std::ostream& os, Thread* self) const {
Ian Rogers4e14e722014-06-27 17:32:56 -0700537 Runtime* runtime = Runtime::Current();
538 if (runtime != nullptr) {
539 ThreadList* thread_list = runtime->GetThreadList();
540 if (thread_list != nullptr) {
541 bool tll_already_held = Locks::thread_list_lock_->IsExclusiveHeld(self);
542 bool ml_already_held = Locks::mutator_lock_->IsSharedHeld(self);
543 if (!tll_already_held || !ml_already_held) {
544 os << "Dumping all threads without appropriate locks held:"
545 << (!tll_already_held ? " thread list lock" : "")
546 << (!ml_already_held ? " mutator lock" : "")
547 << "\n";
548 }
549 os << "All threads:\n";
Ian Rogers7b078e82014-09-10 14:44:24 -0700550 thread_list->Dump(os);
Ian Rogers4e14e722014-06-27 17:32:56 -0700551 }
Ian Rogers2f7f9b62012-10-10 18:24:05 -0700552 }
Elliott Hughese0918552011-10-28 17:18:29 -0700553 }
Andreas Gampe7afa4542016-11-18 09:51:06 -0800554
555 // For recursive aborts.
556 void DumpRecursiveAbort(std::ostream& os) const NO_THREAD_SAFETY_ANALYSIS {
Andreas Gampe9fd470f2016-11-18 17:21:12 -0800557 // The only thing we'll attempt is dumping the native stack of the current thread. We will only
558 // try this if we haven't exceeded an arbitrary amount of recursions, to recover and actually
559 // die.
560 // Note: as we're using a global counter for the recursive abort detection, there is a potential
561 // race here and it is not OK to just print when the counter is "2" (one from
562 // Runtime::Abort(), one from previous Dump() call). Use a number that seems large enough.
563 static constexpr size_t kOnlyPrintWhenRecursionLessThan = 100u;
564 if (gAborting < kOnlyPrintWhenRecursionLessThan) {
565 gAborting++;
566 DumpNativeStack(os, GetTid());
567 }
Andreas Gampe7afa4542016-11-18 09:51:06 -0800568 }
Elliott Hughese0918552011-10-28 17:18:29 -0700569};
570
Andreas Gampe90a32b12016-10-03 19:47:08 -0700571void Runtime::Abort(const char* msg) {
Andreas Gampe247fc332017-06-22 16:18:24 -0700572 auto old_value = gAborting.fetch_add(1); // set before taking any locks
Brian Carlstrom81b88712012-11-05 19:21:30 -0800573
Andreas Gampe89036a32018-12-06 13:05:20 -0800574 // Only set the first abort message.
Andreas Gampe247fc332017-06-22 16:18:24 -0700575 if (old_value == 0) {
Andreas Gampe0ffbe5f2017-06-21 21:05:13 -0700576#ifdef ART_TARGET_ANDROID
Andreas Gampe89036a32018-12-06 13:05:20 -0800577 android_set_abort_message(msg);
578#else
579 // Set the runtime fault message in case our unexpected-signal code will run.
580 Runtime* current = Runtime::Current();
581 if (current != nullptr) {
582 current->SetFaultMessage(msg);
583 }
Andreas Gampe0ffbe5f2017-06-21 21:05:13 -0700584#endif
Andreas Gampe89036a32018-12-06 13:05:20 -0800585 }
Andreas Gampe0ffbe5f2017-06-21 21:05:13 -0700586
Elliott Hughes131aef82012-01-27 11:53:35 -0800587 // Ensure that we don't have multiple threads trying to abort at once,
588 // which would result in significantly worse diagnostics.
Ian Rogers50b35e22012-10-04 10:09:15 -0700589 MutexLock mu(Thread::Current(), *Locks::abort_lock_);
Elliott Hughes131aef82012-01-27 11:53:35 -0800590
Elliott Hughesffe67362011-07-17 12:09:27 -0700591 // Get any pending output out of the way.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700592 fflush(nullptr);
Elliott Hughesffe67362011-07-17 12:09:27 -0700593
594 // Many people have difficulty distinguish aborts from crashes,
595 // so be explicit.
Andreas Gampeb67906b2016-11-18 09:30:08 -0800596 // Note: use cerr on the host to print log lines immediately, so we get at least some output
597 // in case of recursive aborts. We lose annotation with the source file and line number
598 // here, which is a minor issue. The same is significantly more complicated on device,
599 // which is why we ignore the issue there.
Elliott Hughese0918552011-10-28 17:18:29 -0700600 AbortState state;
Andreas Gampeb67906b2016-11-18 09:30:08 -0800601 if (kIsTargetBuild) {
602 LOG(FATAL_WITHOUT_ABORT) << Dumpable<AbortState>(state);
603 } else {
604 std::cerr << Dumpable<AbortState>(state);
605 }
Elliott Hughesffe67362011-07-17 12:09:27 -0700606
Andreas Gampe90a32b12016-10-03 19:47:08 -0700607 // Sometimes we dump long messages, and the Android abort message only retains the first line.
608 // In those cases, just log the message again, to avoid logcat limits.
609 if (msg != nullptr && strchr(msg, '\n') != nullptr) {
610 LOG(FATAL_WITHOUT_ABORT) << msg;
611 }
612
Elliott Hughes8593fdb2012-04-21 20:53:44 -0700613 // Call the abort hook if we have one.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700614 if (Runtime::Current() != nullptr && Runtime::Current()->abort_ != nullptr) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700615 LOG(FATAL_WITHOUT_ABORT) << "Calling abort hook...";
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700616 Runtime::Current()->abort_();
617 // notreached
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700618 LOG(FATAL_WITHOUT_ABORT) << "Unexpectedly returned from abort hook!";
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700619 }
620
Elliott Hughesdd623db2013-06-11 11:20:23 -0700621 abort();
Elliott Hughesffe67362011-07-17 12:09:27 -0700622 // notreached
623}
624
Narayan Kamath3de95a72014-04-02 12:54:23 +0100625void Runtime::PreZygoteFork() {
Nicolas Geoffrayce9ed362018-11-29 03:19:28 +0000626 if (GetJit() != nullptr) {
627 GetJit()->PreZygoteFork();
628 }
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700629 heap_->PreZygoteFork();
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700630}
631
Nicolas Geoffrayce9ed362018-11-29 03:19:28 +0000632void Runtime::PostZygoteFork() {
633 if (GetJit() != nullptr) {
634 GetJit()->PostZygoteFork();
635 }
636}
637
Elliott Hughesbf86d042011-08-31 17:53:14 -0700638void Runtime::CallExitHook(jint status) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700639 if (exit_ != nullptr) {
Elliott Hughes34e06962012-04-09 13:55:55 -0700640 ScopedThreadStateChange tsc(Thread::Current(), kNative);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700641 exit_(status);
642 LOG(WARNING) << "Exit hook returned instead of exiting!";
643 }
644}
645
Mathieu Chartier97509952015-07-13 14:35:43 -0700646void Runtime::SweepSystemWeaks(IsMarkedVisitor* visitor) {
647 GetInternTable()->SweepInternTableWeaks(visitor);
648 GetMonitorList()->SweepMonitorList(visitor);
649 GetJavaVM()->SweepJniWeakGlobals(visitor);
650 GetHeap()->SweepAllocationRecords(visitor);
Nicolas Geoffray132d8362016-11-16 09:19:42 +0000651 if (GetJit() != nullptr) {
652 // Visit JIT literal tables. Objects in these tables are classes and strings
653 // and only classes can be affected by class unloading. The strings always
654 // stay alive as they are strongly interned.
655 // TODO: Move this closer to CleanupClassLoaders, to avoid blocking weak accesses
656 // from mutators. See b/32167580.
657 GetJit()->GetCodeCache()->SweepRootTables(visitor);
658 }
Andreas Gampefda57142016-09-08 20:29:18 -0700659
660 // All other generic system-weak holders.
661 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
662 holder->Sweep(visitor);
663 }
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700664}
665
Vladimir Marko88b2b802015-12-04 14:19:04 +0000666bool Runtime::ParseOptions(const RuntimeOptions& raw_options,
667 bool ignore_unrecognized,
668 RuntimeArgumentMap* runtime_options) {
David Sehrc431b9d2018-03-02 12:01:51 -0800669 Locks::Init();
Andreas Gampe98ea9d92018-10-19 14:06:15 -0700670 InitLogging(/* argv= */ nullptr, Abort); // Calls Locks::Init() as a side effect.
Vladimir Marko88b2b802015-12-04 14:19:04 +0000671 bool parsed = ParsedOptions::Parse(raw_options, ignore_unrecognized, runtime_options);
672 if (!parsed) {
673 LOG(ERROR) << "Failed to parse options";
674 return false;
675 }
676 return true;
677}
678
David Sehrf42eb2c2016-10-19 13:20:45 -0700679// Callback to check whether it is safe to call Abort (e.g., to use a call to
680// LOG(FATAL)). It is only safe to call Abort if the runtime has been created,
681// properly initialized, and has not shut down.
682static bool IsSafeToCallAbort() NO_THREAD_SAFETY_ANALYSIS {
683 Runtime* runtime = Runtime::Current();
684 return runtime != nullptr && runtime->IsStarted() && !runtime->IsShuttingDownLocked();
685}
686
Vladimir Marko88b2b802015-12-04 14:19:04 +0000687bool Runtime::Create(RuntimeArgumentMap&& runtime_options) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700688 // TODO: acquire a static mutex on Runtime to avoid racing.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700689 if (Runtime::instance_ != nullptr) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700690 return false;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700691 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700692 instance_ = new Runtime;
David Sehrf42eb2c2016-10-19 13:20:45 -0700693 Locks::SetClientCallback(IsSafeToCallAbort);
Vladimir Marko88b2b802015-12-04 14:19:04 +0000694 if (!instance_->Init(std::move(runtime_options))) {
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700695 // TODO: Currently deleting the instance will abort the runtime on destruction. Now This will
696 // leak memory, instead. Fix the destructor. b/19100793.
697 // delete instance_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700698 instance_ = nullptr;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700699 return false;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700700 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700701 return true;
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700702}
Elliott Hughes0af55432011-08-17 18:37:28 -0700703
Vladimir Marko88b2b802015-12-04 14:19:04 +0000704bool Runtime::Create(const RuntimeOptions& raw_options, bool ignore_unrecognized) {
705 RuntimeArgumentMap runtime_options;
706 return ParseOptions(raw_options, ignore_unrecognized, &runtime_options) &&
707 Create(std::move(runtime_options));
708}
709
Andreas Gampe81c6f8d2015-03-25 17:19:53 -0700710static jobject CreateSystemClassLoader(Runtime* runtime) {
711 if (runtime->IsAotCompiler() && !runtime->GetCompilerCallbacks()->IsBootImage()) {
712 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700713 }
714
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700715 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800716 ClassLinker* cl = Runtime::Current()->GetClassLinker();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700717 auto pointer_size = cl->GetImagePointerSize();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700718
Ian Rogers68d8b422014-07-17 11:09:10 -0700719 StackHandleScope<2> hs(soa.Self());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700720 Handle<mirror::Class> class_loader_class(
Mathieu Chartier0795f232016-09-27 18:43:30 -0700721 hs.NewHandle(soa.Decode<mirror::Class>(WellKnownClasses::java_lang_ClassLoader)));
Ian Rogers7b078e82014-09-10 14:44:24 -0700722 CHECK(cl->EnsureInitialized(soa.Self(), class_loader_class, true, true));
Brian Carlstromaded5f72011-10-07 17:15:04 -0700723
Vladimir Markoba118822017-06-12 15:41:56 +0100724 ArtMethod* getSystemClassLoader = class_loader_class->FindClassMethod(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700725 "getSystemClassLoader", "()Ljava/lang/ClassLoader;", pointer_size);
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700726 CHECK(getSystemClassLoader != nullptr);
Vladimir Markoba118822017-06-12 15:41:56 +0100727 CHECK(getSystemClassLoader->IsStatic());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700728
Andreas Gampe13b27842016-11-07 16:48:23 -0800729 JValue result = InvokeWithJValues(soa,
730 nullptr,
731 jni::EncodeArtMethod(getSystemClassLoader),
732 nullptr);
Brian Carlstromce888532013-10-10 00:32:58 -0700733 JNIEnv* env = soa.Self()->GetJniEnv();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700734 ScopedLocalRef<jobject> system_class_loader(env, soa.AddLocalReference<jobject>(result.GetL()));
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800735 CHECK(system_class_loader.get() != nullptr);
Brian Carlstromce888532013-10-10 00:32:58 -0700736
Ian Rogers68d8b422014-07-17 11:09:10 -0700737 soa.Self()->SetClassLoaderOverride(system_class_loader.get());
Ian Rogers365c1022012-06-22 15:05:28 -0700738
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700739 Handle<mirror::Class> thread_class(
Mathieu Chartier0795f232016-09-27 18:43:30 -0700740 hs.NewHandle(soa.Decode<mirror::Class>(WellKnownClasses::java_lang_Thread)));
Ian Rogers7b078e82014-09-10 14:44:24 -0700741 CHECK(cl->EnsureInitialized(soa.Self(), thread_class, true, true));
Ian Rogers365c1022012-06-22 15:05:28 -0700742
Mathieu Chartierc7853442015-03-27 14:35:38 -0700743 ArtField* contextClassLoader =
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800744 thread_class->FindDeclaredInstanceField("contextClassLoader", "Ljava/lang/ClassLoader;");
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700745 CHECK(contextClassLoader != nullptr);
Ian Rogers365c1022012-06-22 15:05:28 -0700746
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100747 // We can't run in a transaction yet.
Mathieu Chartier0795f232016-09-27 18:43:30 -0700748 contextClassLoader->SetObject<false>(
749 soa.Self()->GetPeer(),
Mathieu Chartier1cc62e42016-10-03 18:01:28 -0700750 soa.Decode<mirror::ClassLoader>(system_class_loader.get()).Ptr());
Brian Carlstromce888532013-10-10 00:32:58 -0700751
752 return env->NewGlobalRef(system_class_loader.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700753}
754
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700755std::string Runtime::GetCompilerExecutable() const {
756 if (!compiler_executable_.empty()) {
757 return compiler_executable_;
758 }
759 std::string compiler_executable(GetAndroidRoot());
760 compiler_executable += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
761 return compiler_executable;
762}
763
Vladimir Markodcfcce42018-06-27 10:00:28 +0000764void Runtime::RunRootClinits(Thread* self) {
765 class_linker_->RunRootClinits(self);
766
767 GcRoot<mirror::Throwable>* exceptions[] = {
768 &pre_allocated_OutOfMemoryError_when_throwing_exception_,
769 // &pre_allocated_OutOfMemoryError_when_throwing_oome_, // Same class as above.
770 // &pre_allocated_OutOfMemoryError_when_handling_stack_overflow_, // Same class as above.
771 &pre_allocated_NoClassDefFoundError_,
772 };
773 for (GcRoot<mirror::Throwable>* exception : exceptions) {
774 StackHandleScope<1> hs(self);
775 Handle<mirror::Class> klass = hs.NewHandle<mirror::Class>(exception->Read()->GetClass());
776 class_linker_->EnsureInitialized(self, klass, true, true);
777 self->AssertNoPendingException();
778 }
779}
780
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700781bool Runtime::Start() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800782 VLOG(startup) << "Runtime::Start entering";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700783
Calin Juravle01aaf6e2015-06-19 22:05:39 +0100784 CHECK(!no_sig_chain_) << "A started runtime should have sig chain enabled";
785
Hiroshi Yamauchi6ffb9cc2015-08-31 15:14:17 -0700786 // If a debug host build, disable ptrace restriction for debugging and test timeout thread dump.
Hiroshi Yamauchic823eff2015-09-01 16:21:35 -0700787 // Only 64-bit as prctl() may fail in 32 bit userspace on a 64-bit kernel.
Bilyan Borisovbb661c02016-04-04 16:27:32 +0100788#if defined(__linux__) && !defined(ART_TARGET_ANDROID) && defined(__x86_64__)
Hiroshi Yamauchi6ffb9cc2015-08-31 15:14:17 -0700789 if (kIsDebugBuild) {
790 CHECK_EQ(prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY), 0);
791 }
792#endif
793
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700794 // Restore main thread state to kNative as expected by native code.
Ian Rogersa436fde2013-08-27 23:34:06 -0700795 Thread* self = Thread::Current();
Alex Light64ad14d2014-08-19 14:23:13 -0700796
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700797 self->TransitionFromRunnableToSuspended(kNative);
798
David Srbeckycb4f09e2018-10-21 08:45:22 +0100799 DoAndMaybeSwitchInterpreter([=](){ started_ = true; });
Brian Carlstrom5d40f182011-09-26 22:29:18 -0700800
Jeff Haodcdc85b2015-12-04 14:06:18 -0800801 if (!IsImageDex2OatEnabled() || !GetHeap()->HasBootImageSpace()) {
Mathieu Chartiereb175f72014-10-31 11:49:27 -0700802 ScopedObjectAccess soa(self);
Przemyslaw Szczepaniaka2b147e2016-05-12 14:55:48 +0100803 StackHandleScope<2> hs(soa.Self());
804
Vladimir Marko679730e2018-05-25 15:06:48 +0100805 ObjPtr<mirror::ObjectArray<mirror::Class>> class_roots = GetClassLinker()->GetClassRoots();
806 auto class_class(hs.NewHandle<mirror::Class>(GetClassRoot<mirror::Class>(class_roots)));
807 auto field_class(hs.NewHandle<mirror::Class>(GetClassRoot<mirror::Field>(class_roots)));
Przemyslaw Szczepaniaka2b147e2016-05-12 14:55:48 +0100808
809 class_linker_->EnsureInitialized(soa.Self(), class_class, true, true);
Vladimir Markodcfcce42018-06-27 10:00:28 +0000810 self->AssertNoPendingException();
Przemyslaw Szczepaniaka2b147e2016-05-12 14:55:48 +0100811 // Field class is needed for register_java_net_InetAddress in libcore, b/28153851.
812 class_linker_->EnsureInitialized(soa.Self(), field_class, true, true);
Vladimir Markodcfcce42018-06-27 10:00:28 +0000813 self->AssertNoPendingException();
Alex Light64ad14d2014-08-19 14:23:13 -0700814 }
815
Brian Carlstromae826982011-11-09 01:33:42 -0800816 // InitNativeMethods needs to be after started_ so that the classes
817 // it touches will have methods linked to the oat file if necessary.
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800818 {
819 ScopedTrace trace2("InitNativeMethods");
820 InitNativeMethods();
821 }
Brian Carlstromae826982011-11-09 01:33:42 -0800822
Orion Hodson26ef34c2017-11-01 13:32:41 +0000823 // IntializeIntrinsics needs to be called after the WellKnownClasses::Init in InitNativeMethods
824 // because in checking the invocation types of intrinsic methods ArtMethod::GetInvokeType()
825 // needs the SignaturePolymorphic annotation class which is initialized in WellKnownClasses::Init.
826 InitializeIntrinsics();
827
Ian Rogers365c1022012-06-22 15:05:28 -0700828 // Initialize well known thread group values that may be accessed threads while attaching.
829 InitThreadGroups(self);
830
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500831 Thread::FinishStartup();
832
Andreas Gampe4471e4f2017-01-30 16:40:49 +0000833 // Create the JIT either if we have to use JIT compilation or save profiling info. This is
834 // done after FinishStartup as the JIT pool needs Java thread peers, which require the main
835 // ThreadGroup to exist.
836 //
837 // TODO(calin): We use the JIT class as a proxy for JIT compilation and for
838 // recoding profiles. Maybe we should consider changing the name to be more clear it's
839 // not only about compiling. b/28295073.
Andreas Gampe83e20492018-11-07 11:12:26 -0800840 if (jit_options_->UseJitCompilation() || jit_options_->GetSaveProfilingInfo()) {
Orion Hodsonad28f5e2018-10-17 09:08:17 +0100841 // Try to load compiler pre zygote to reduce PSS. b/27744947
Andreas Gampe4471e4f2017-01-30 16:40:49 +0000842 std::string error_msg;
Nicolas Geoffraya7edd0d2018-11-07 03:18:16 +0000843 if (!jit::Jit::LoadCompilerLibrary(&error_msg)) {
Orion Hodsonad28f5e2018-10-17 09:08:17 +0100844 LOG(WARNING) << "Failed to load JIT compiler with error " << error_msg;
Andreas Gampe4471e4f2017-01-30 16:40:49 +0000845 }
Nicolas Geoffray7a2c7c22018-11-20 10:03:13 +0000846 CreateJitCodeCache(/*rwx_memory_allowed=*/true);
847 CreateJit();
Andreas Gampe4471e4f2017-01-30 16:40:49 +0000848 }
849
Andreas Gampe48864112017-01-19 17:23:17 -0800850 // Send the start phase event. We have to wait till here as this is when the main thread peer
851 // has just been generated, important root clinits have been run and JNI is completely functional.
852 {
853 ScopedObjectAccess soa(self);
854 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kStart);
855 }
856
Andreas Gampe81c6f8d2015-03-25 17:19:53 -0700857 system_class_loader_ = CreateSystemClassLoader(this);
jgu21a6da74e2014-09-10 06:57:17 -0400858
Robert Sesekb2267032016-09-13 19:12:57 -0400859 if (!is_zygote_) {
Calin Juravle07d83c72014-10-22 21:02:23 +0100860 if (is_native_bridge_loaded_) {
jgu21a6da74e2014-09-10 06:57:17 -0400861 PreInitializeNativeBridge(".");
862 }
Calin Juravled3e7c6c2016-02-04 19:07:51 +0000863 NativeBridgeAction action = force_native_bridge_
864 ? NativeBridgeAction::kInitialize
865 : NativeBridgeAction::kUnload;
Nicolas Geoffrayba69a512015-11-17 13:50:21 +0000866 InitNonZygoteOrPostFork(self->GetJniEnv(),
Andreas Gampe98ea9d92018-10-19 14:06:15 -0700867 /* is_system_server= */ false,
Calin Juravled3e7c6c2016-02-04 19:07:51 +0000868 action,
Nicolas Geoffrayba69a512015-11-17 13:50:21 +0000869 GetInstructionSetString(kRuntimeISA));
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700870 }
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700871
Nicolas Geoffrayc08c1072019-02-21 10:15:28 +0000872 // Send the initialized phase event. Send it before starting daemons, as otherwise
873 // sending thread events becomes complicated.
Andreas Gampeeafaf572017-01-20 12:34:15 -0800874 {
875 ScopedObjectAccess soa(self);
876 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kInit);
877 }
878
Nicolas Geoffrayc08c1072019-02-21 10:15:28 +0000879 StartDaemonThreads();
880
Yevgeny Rouban35aef2c2014-05-19 16:19:36 +0700881 {
882 ScopedObjectAccess soa(self);
Ian Rogers55256cb2017-12-21 17:07:11 -0800883 self->GetJniEnv()->AssertLocalsEmpty();
Yevgeny Rouban35aef2c2014-05-19 16:19:36 +0700884 }
Elliott Hughes726079d2011-10-07 18:43:44 -0700885
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800886 VLOG(startup) << "Runtime::Start exiting";
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700887 finished_starting_ = true;
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700888
Andreas Gampe40da2862015-02-27 12:49:04 -0800889 if (trace_config_.get() != nullptr && trace_config_->trace_file != "") {
890 ScopedThreadStateChange tsc(self, kWaitingForMethodTracingStart);
891 Trace::Start(trace_config_->trace_file.c_str(),
Andreas Gampe40da2862015-02-27 12:49:04 -0800892 static_cast<int>(trace_config_->trace_file_size),
893 0,
894 trace_config_->trace_output_mode,
895 trace_config_->trace_mode,
896 0);
897 }
898
Calin Juravle2bce0762018-02-20 16:03:34 -0800899 // In case we have a profile path passed as a command line argument,
900 // register the current class path for profiling now. Note that we cannot do
901 // this before we create the JIT and having it here is the most convenient way.
902 // This is used when testing profiles with dalvikvm command as there is no
903 // framework to register the dex files for profiling.
904 if (jit_.get() != nullptr && jit_options_->GetSaveProfilingInfo() &&
905 !jit_options_->GetProfileSaverOptions().GetProfilePath().empty()) {
906 std::vector<std::string> dex_filenames;
907 Split(class_path_string_, ':', &dex_filenames);
908 RegisterAppInfo(dex_filenames, jit_options_->GetProfileSaverOptions().GetProfilePath());
909 }
910
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700911 return true;
Elliott Hughes85d15452011-09-16 17:33:01 -0700912}
913
Mathieu Chartier90443472015-07-16 20:32:27 -0700914void Runtime::EndThreadBirth() REQUIRES(Locks::runtime_shutdown_lock_) {
Ian Rogers120f1c72012-09-28 17:17:10 -0700915 DCHECK_GT(threads_being_born_, 0U);
916 threads_being_born_--;
917 if (shutting_down_started_ && threads_being_born_ == 0) {
Ian Rogersc604d732012-10-14 16:09:54 -0700918 shutdown_cond_->Broadcast(Thread::Current());
Ian Rogers120f1c72012-09-28 17:17:10 -0700919 }
920}
921
Nicolas Geoffrayd66c8622015-12-11 14:59:16 +0000922void Runtime::InitNonZygoteOrPostFork(
Calin Juravle016fcbe22018-05-03 19:47:35 -0700923 JNIEnv* env,
924 bool is_system_server,
925 NativeBridgeAction action,
926 const char* isa,
927 bool profile_system_server) {
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700928 is_zygote_ = false;
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700929
Calin Juravle07d83c72014-10-22 21:02:23 +0100930 if (is_native_bridge_loaded_) {
931 switch (action) {
932 case NativeBridgeAction::kUnload:
933 UnloadNativeBridge();
934 is_native_bridge_loaded_ = false;
935 break;
Andreas Gampe6be67ee2014-09-02 21:22:18 -0700936
Calin Juravle07d83c72014-10-22 21:02:23 +0100937 case NativeBridgeAction::kInitialize:
938 InitializeNativeBridge(env, isa);
939 break;
940 }
Andreas Gampe6be67ee2014-09-02 21:22:18 -0700941 }
942
Calin Juravle016fcbe22018-05-03 19:47:35 -0700943 if (is_system_server) {
Calin Juravle016fcbe22018-05-03 19:47:35 -0700944 jit_options_->SetSaveProfilingInfo(profile_system_server);
945 if (profile_system_server) {
946 jit_options_->SetWaitForJitNotificationsToSaveProfile(false);
947 VLOG(profiler) << "Enabling system server profiles";
948 }
949 }
Orion Hodsonad28f5e2018-10-17 09:08:17 +0100950
Orion Hodsonad28f5e2018-10-17 09:08:17 +0100951 // Create the thread pools.
952 heap_->CreateThreadPool();
Mathieu Chartierada33d72018-12-17 13:17:30 -0800953 {
954 ScopedTrace timing("CreateThreadPool");
955 constexpr size_t kStackSize = 64 * KB;
956 constexpr size_t kMaxRuntimeWorkers = 4u;
957 const size_t num_workers =
958 std::min(static_cast<size_t>(std::thread::hardware_concurrency()), kMaxRuntimeWorkers);
959 MutexLock mu(Thread::Current(), *Locks::runtime_thread_pool_lock_);
960 CHECK(thread_pool_ == nullptr);
961 thread_pool_.reset(new ThreadPool("Runtime", num_workers, /*create_peers=*/false, kStackSize));
962 thread_pool_->StartWorkers(Thread::Current());
963 }
964
Orion Hodsonad28f5e2018-10-17 09:08:17 +0100965 // Reset the gc performance data at zygote fork so that the GCs
966 // before fork aren't attributed to an app.
967 heap_->ResetGcPerformanceInfo();
968
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700969 StartSignalCatcher();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700970
971 // Start the JDWP thread. If the command-line debugger flags specified "suspend=y",
Alex Light40320712017-12-14 11:52:04 -0800972 // this will pause the runtime (in the internal debugger implementation), so we probably want
973 // this to come last.
974 ScopedObjectAccess soa(Thread::Current());
975 GetRuntimeCallbacks()->StartDebugger();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700976}
977
978void Runtime::StartSignalCatcher() {
979 if (!is_zygote_) {
Andreas Gampe53af0402018-05-03 10:40:37 -0700980 signal_catcher_ = new SignalCatcher();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700981 }
982}
983
Mathieu Chartier590fee92013-09-13 13:46:47 -0700984bool Runtime::IsShuttingDown(Thread* self) {
985 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
986 return IsShuttingDownLocked();
987}
988
Elliott Hughes85d15452011-09-16 17:33:01 -0700989void Runtime::StartDaemonThreads() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800990 ScopedTrace trace(__FUNCTION__);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800991 VLOG(startup) << "Runtime::StartDaemonThreads entering";
Elliott Hughes85d15452011-09-16 17:33:01 -0700992
Elliott Hughes719b3232011-09-25 17:42:19 -0700993 Thread* self = Thread::Current();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700994
995 // Must be in the kNative state for calling native methods.
Ian Rogers50b35e22012-10-04 10:09:15 -0700996 CHECK_EQ(self->GetState(), kNative);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700997
Elliott Hughes719b3232011-09-25 17:42:19 -0700998 JNIEnv* env = self->GetJniEnv();
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700999 env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons,
1000 WellKnownClasses::java_lang_Daemons_start);
1001 if (env->ExceptionCheck()) {
1002 env->ExceptionDescribe();
1003 LOG(FATAL) << "Error starting java.lang.Daemons";
1004 }
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -07001005
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001006 VLOG(startup) << "Runtime::StartDaemonThreads exiting";
Carl Shapiro61e019d2011-07-14 16:53:09 -07001007}
1008
Nicolas Geoffray99fc9382019-02-20 13:17:27 +00001009static size_t OpenBootDexFiles(ArrayRef<const std::string> dex_filenames,
1010 ArrayRef<const std::string> dex_locations,
1011 std::vector<std::unique_ptr<const DexFile>>* dex_files) {
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001012 DCHECK(dex_files != nullptr) << "OpenDexFiles: out-param is nullptr";
Alex Light64ad14d2014-08-19 14:23:13 -07001013 size_t failure_count = 0;
David Sehr013fd802018-01-11 22:55:24 -08001014 const ArtDexFileLoader dex_file_loader;
Alex Light64ad14d2014-08-19 14:23:13 -07001015 for (size_t i = 0; i < dex_filenames.size(); i++) {
1016 const char* dex_filename = dex_filenames[i].c_str();
Richard Uhlerc2752592015-01-02 13:28:22 -08001017 const char* dex_location = dex_locations[i].c_str();
Aart Bik37d6a3b2016-06-21 18:30:10 -07001018 static constexpr bool kVerifyChecksum = true;
Alex Light64ad14d2014-08-19 14:23:13 -07001019 std::string error_msg;
1020 if (!OS::FileExists(dex_filename)) {
1021 LOG(WARNING) << "Skipping non-existent dex file '" << dex_filename << "'";
1022 continue;
1023 }
Nicolas Geoffray99fc9382019-02-20 13:17:27 +00001024 // In the case we're not using the default boot image, we don't have support yet
1025 // on reading vdex files of boot classpath. So just assume all boot classpath
1026 // dex files have been verified (this should always be the case as the default boot
1027 // image has been generated at build time).
1028 bool verify = Runtime::Current()->IsVerificationEnabled() &&
1029 (kIsDebugBuild || Runtime::Current()->IsUsingDefaultBootImageLocation());
David Sehr013fd802018-01-11 22:55:24 -08001030 if (!dex_file_loader.Open(dex_filename,
1031 dex_location,
Nicolas Geoffray99fc9382019-02-20 13:17:27 +00001032 verify,
David Sehr013fd802018-01-11 22:55:24 -08001033 kVerifyChecksum,
1034 &error_msg,
1035 dex_files)) {
Alex Light64ad14d2014-08-19 14:23:13 -07001036 LOG(WARNING) << "Failed to open .dex from file '" << dex_filename << "': " << error_msg;
1037 ++failure_count;
1038 }
1039 }
1040 return failure_count;
1041}
1042
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001043void Runtime::SetSentinel(mirror::Object* sentinel) {
1044 CHECK(sentinel_.Read() == nullptr);
1045 CHECK(sentinel != nullptr);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08001046 CHECK(!heap_->IsMovableObject(sentinel));
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001047 sentinel_ = GcRoot<mirror::Object>(sentinel);
1048}
1049
Roland Levillain0e155592018-11-05 18:31:49 +00001050GcRoot<mirror::Object> Runtime::GetSentinel() {
1051 return sentinel_;
1052}
1053
Vladimir Markodcfcce42018-06-27 10:00:28 +00001054static inline void CreatePreAllocatedException(Thread* self,
1055 Runtime* runtime,
1056 GcRoot<mirror::Throwable>* exception,
1057 const char* exception_class_descriptor,
1058 const char* msg)
Vladimir Markoc13fbd82018-06-04 16:16:28 +01001059 REQUIRES_SHARED(Locks::mutator_lock_) {
1060 DCHECK_EQ(self, Thread::Current());
Vladimir Markodcfcce42018-06-27 10:00:28 +00001061 ClassLinker* class_linker = runtime->GetClassLinker();
1062 // Allocate an object without initializing the class to allow non-trivial Throwable.<clinit>().
1063 ObjPtr<mirror::Class> klass = class_linker->FindSystemClass(self, exception_class_descriptor);
1064 CHECK(klass != nullptr);
1065 gc::AllocatorType allocator_type = runtime->GetHeap()->GetCurrentAllocator();
1066 ObjPtr<mirror::Throwable> exception_object = ObjPtr<mirror::Throwable>::DownCast(
Andreas Gampe98ea9d92018-10-19 14:06:15 -07001067 klass->Alloc</* kIsInstrumented= */ true>(self, allocator_type));
Vladimir Markodcfcce42018-06-27 10:00:28 +00001068 CHECK(exception_object != nullptr);
1069 *exception = GcRoot<mirror::Throwable>(exception_object);
1070 // Initialize the "detailMessage" field.
1071 ObjPtr<mirror::String> message = mirror::String::AllocFromModifiedUtf8(self, msg);
1072 CHECK(message != nullptr);
1073 ObjPtr<mirror::Class> throwable = GetClassRoot<mirror::Throwable>(class_linker);
1074 ArtField* detailMessageField =
1075 throwable->FindDeclaredInstanceField("detailMessage", "Ljava/lang/String;");
1076 CHECK(detailMessageField != nullptr);
Andreas Gampe98ea9d92018-10-19 14:06:15 -07001077 detailMessageField->SetObject</* kTransactionActive= */ false>(exception->Read(), message);
Vladimir Markoc13fbd82018-06-04 16:16:28 +01001078}
1079
Vladimir Marko88b2b802015-12-04 14:19:04 +00001080bool Runtime::Init(RuntimeArgumentMap&& runtime_options_in) {
David Sehrd106d9f2016-08-16 19:22:57 -07001081 // (b/30160149): protect subprocesses from modifications to LD_LIBRARY_PATH, etc.
1082 // Take a snapshot of the environment at the time the runtime was created, for use by Exec, etc.
1083 env_snapshot_.TakeSnapshot();
1084
Andreas Gampe25419b52018-02-08 21:30:26 -08001085 using Opt = RuntimeArgumentMap;
1086 Opt runtime_options(std::move(runtime_options_in));
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001087 ScopedTrace trace(__FUNCTION__);
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001088 CHECK_EQ(sysconf(_SC_PAGE_SIZE), kPageSize);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001089
Andreas Gampe25419b52018-02-08 21:30:26 -08001090 // Early override for logging output.
1091 if (runtime_options.Exists(Opt::UseStderrLogger)) {
1092 android::base::SetLogger(android::base::StderrLogger);
1093 }
1094
Mathieu Chartier6e88ef62014-10-14 15:01:24 -07001095 MemMap::Init();
1096
Andreas Gampe5f2a2fc2017-05-18 17:45:07 -07001097 // Try to reserve a dedicated fault page. This is allocated for clobbered registers and sentinels.
1098 // If we cannot reserve it, log a warning.
1099 // Note: We allocate this first to have a good chance of grabbing the page. The address (0xebad..)
1100 // is out-of-the-way enough that it should not collide with boot image mapping.
1101 // Note: Don't request an error message. That will lead to a maps dump in the case of failure,
1102 // leading to logspam.
1103 {
1104 constexpr uintptr_t kSentinelAddr =
1105 RoundDown(static_cast<uintptr_t>(Context::kBadGprBase), kPageSize);
Vladimir Markoc34bebf2018-08-16 16:12:49 +01001106 protected_fault_page_ = MemMap::MapAnonymous("Sentinel fault page",
1107 reinterpret_cast<uint8_t*>(kSentinelAddr),
1108 kPageSize,
1109 PROT_NONE,
Vladimir Marko11306592018-10-26 14:22:59 +01001110 /*low_4gb=*/ true,
1111 /*reuse=*/ false,
1112 /*reservation=*/ nullptr,
1113 /*error_msg=*/ nullptr);
Vladimir Markoc34bebf2018-08-16 16:12:49 +01001114 if (!protected_fault_page_.IsValid()) {
Andreas Gampe5f2a2fc2017-05-18 17:45:07 -07001115 LOG(WARNING) << "Could not reserve sentinel fault page";
Vladimir Markoc34bebf2018-08-16 16:12:49 +01001116 } else if (reinterpret_cast<uintptr_t>(protected_fault_page_.Begin()) != kSentinelAddr) {
Andreas Gampe5f2a2fc2017-05-18 17:45:07 -07001117 LOG(WARNING) << "Could not reserve sentinel fault page at the right address.";
Vladimir Markoc34bebf2018-08-16 16:12:49 +01001118 protected_fault_page_.Reset();
Andreas Gampe5f2a2fc2017-05-18 17:45:07 -07001119 }
1120 }
1121
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001122 VLOG(startup) << "Runtime::Init -verbose:startup enabled";
Elliott Hughes7ede61e2011-09-14 18:18:06 -07001123
Elliott Hughes7c6169d2012-05-02 16:11:48 -07001124 QuasiAtomic::Startup();
1125
Mathieu Chartiere58991b2015-10-13 07:59:34 -07001126 oat_file_manager_ = new OatFileManager;
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -07001127
Calin Juravleb2771b42016-04-07 17:09:25 +01001128 Thread::SetSensitiveThreadHook(runtime_options.GetOrDefault(Opt::HookIsSensitiveThread));
Andreas Gamped0210e52017-06-23 13:38:09 -07001129 Monitor::Init(runtime_options.GetOrDefault(Opt::LockProfThreshold),
1130 runtime_options.GetOrDefault(Opt::StackDumpLockProfThreshold));
Elliott Hughes32d6e1e2011-10-11 14:47:44 -07001131
Vladimir Marko91f10322018-12-07 18:04:10 +00001132 image_location_ = runtime_options.GetOrDefault(Opt::Image);
Nicolas Geoffray144f82c2019-02-21 09:43:18 +00001133 {
1134 std::string error_msg;
1135 is_using_default_boot_image_location_ =
1136 (image_location_.compare(GetDefaultBootImageLocation(&error_msg)) == 0);
1137 }
1138
Vladimir Marko91f10322018-12-07 18:04:10 +00001139 SetInstructionSet(runtime_options.GetOrDefault(Opt::ImageInstructionSet));
1140 boot_class_path_ = runtime_options.ReleaseOrDefault(Opt::BootClassPath);
1141 boot_class_path_locations_ = runtime_options.ReleaseOrDefault(Opt::BootClassPathLocations);
1142 DCHECK(boot_class_path_locations_.empty() ||
1143 boot_class_path_locations_.size() == boot_class_path_.size());
1144 if (boot_class_path_.empty()) {
1145 // Try to extract the boot class path from the system boot image.
1146 if (image_location_.empty()) {
1147 LOG(ERROR) << "Empty boot class path, cannot continue without image.";
1148 return false;
1149 }
1150 std::string system_oat_filename = ImageHeader::GetOatLocationFromImageLocation(
1151 GetSystemImageFilename(image_location_.c_str(), instruction_set_));
1152 std::string system_oat_location = ImageHeader::GetOatLocationFromImageLocation(image_location_);
1153 std::string error_msg;
1154 std::unique_ptr<OatFile> oat_file(OatFile::Open(/*zip_fd=*/ -1,
1155 system_oat_filename,
1156 system_oat_location,
1157 /*executable=*/ false,
1158 /*low_4gb=*/ false,
1159 /*abs_dex_location=*/ nullptr,
1160 /*reservation=*/ nullptr,
1161 &error_msg));
1162 if (oat_file == nullptr) {
1163 LOG(ERROR) << "Could not open boot oat file for extracting boot class path: " << error_msg;
1164 return false;
1165 }
1166 const OatHeader& oat_header = oat_file->GetOatHeader();
1167 const char* oat_boot_class_path = oat_header.GetStoreValueByKey(OatHeader::kBootClassPathKey);
1168 if (oat_boot_class_path != nullptr) {
1169 Split(oat_boot_class_path, ':', &boot_class_path_);
1170 }
1171 if (boot_class_path_.empty()) {
1172 LOG(ERROR) << "Boot class path missing from boot image oat file " << oat_file->GetLocation();
1173 return false;
1174 }
1175 }
1176
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001177 class_path_string_ = runtime_options.ReleaseOrDefault(Opt::ClassPath);
1178 properties_ = runtime_options.ReleaseOrDefault(Opt::PropertiesList);
Elliott Hughes7ede61e2011-09-14 18:18:06 -07001179
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001180 compiler_callbacks_ = runtime_options.GetOrDefault(Opt::CompilerCallbacksPtr);
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001181 must_relocate_ = runtime_options.GetOrDefault(Opt::Relocate);
1182 is_zygote_ = runtime_options.Exists(Opt::Zygote);
1183 is_explicit_gc_disabled_ = runtime_options.Exists(Opt::DisableExplicitGC);
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001184 image_dex2oat_enabled_ = runtime_options.GetOrDefault(Opt::ImageDex2Oat);
Nicolas Geoffray6ee49712018-03-30 14:39:05 +00001185 dump_native_stack_on_sig_quit_ = runtime_options.GetOrDefault(Opt::DumpNativeStackOnSigQuit);
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -07001186
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001187 vfprintf_ = runtime_options.GetOrDefault(Opt::HookVfprintf);
1188 exit_ = runtime_options.GetOrDefault(Opt::HookExit);
1189 abort_ = runtime_options.GetOrDefault(Opt::HookAbort);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001190
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001191 default_stack_size_ = runtime_options.GetOrDefault(Opt::StackSize);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001192
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001193 compiler_executable_ = runtime_options.ReleaseOrDefault(Opt::Compiler);
1194 compiler_options_ = runtime_options.ReleaseOrDefault(Opt::CompilerOptions);
Vladimir Marko72101082019-02-05 16:16:30 +00001195 for (const std::string& option : Runtime::Current()->GetCompilerOptions()) {
1196 if (option == "--debuggable") {
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00001197 SetJavaDebuggable(true);
1198 break;
1199 }
1200 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001201 image_compiler_options_ = runtime_options.ReleaseOrDefault(Opt::ImageCompilerOptions);
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001202
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001203 max_spins_before_thin_lock_inflation_ =
1204 runtime_options.GetOrDefault(Opt::MaxSpinsBeforeThinLockInflation);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001205
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001206 monitor_list_ = new MonitorList;
Ian Rogersef7d42f2014-01-06 12:55:46 -08001207 monitor_pool_ = MonitorPool::Create();
Mathieu Chartier3fceaf52017-01-22 13:33:40 -08001208 thread_list_ = new ThreadList(runtime_options.GetOrDefault(Opt::ThreadSuspendTimeout));
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001209 intern_table_ = new InternTable;
1210
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001211 verify_ = runtime_options.GetOrDefault(Opt::Verify);
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -07001212 allow_dex_file_fallback_ = !runtime_options.Exists(Opt::NoDexFileFallback);
Logan Chiendd361c92012-04-10 23:40:37 +08001213
David Brazdila7db0262018-01-16 17:13:35 +00001214 target_sdk_version_ = runtime_options.GetOrDefault(Opt::TargetSdkVersion);
1215
David Brazdilad666272018-02-06 20:30:59 +00001216 // Check whether to enforce hidden API access checks. The checks are disabled
1217 // by default and we only enable them if:
1218 // (a) runtime was started with a flag that enables the checks, or
1219 // (b) Zygote forked a new process that is not exempt (see ZygoteHooks).
Mathew Inwood597d7f62018-03-22 11:36:47 +00001220 bool do_hidden_api_checks = runtime_options.Exists(Opt::HiddenApiChecks);
1221 DCHECK(!is_zygote_ || !do_hidden_api_checks);
1222 // TODO pass the actual enforcement policy in, rather than just a single bit.
1223 // As is, we're encoding some logic here about which specific policy to use, which would be better
1224 // controlled by the framework.
1225 hidden_api_policy_ = do_hidden_api_checks
David Brazdilf50ac102018-10-17 18:00:06 +01001226 ? hiddenapi::EnforcementPolicy::kEnabled
1227 : hiddenapi::EnforcementPolicy::kDisabled;
David Brazdil3e0fa0a2018-01-15 18:41:44 +00001228
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001229 no_sig_chain_ = runtime_options.Exists(Opt::NoSigChain);
Calin Juravled3e7c6c2016-02-04 19:07:51 +00001230 force_native_bridge_ = runtime_options.Exists(Opt::ForceNativeBridge);
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001231
Dmitriy Ivanov785049f2014-07-18 10:08:57 -07001232 Split(runtime_options.GetOrDefault(Opt::CpuAbiList), ',', &cpu_abilist_);
1233
Andreas Gampedd671252015-07-23 14:37:18 -07001234 fingerprint_ = runtime_options.ReleaseOrDefault(Opt::Fingerprint);
1235
Igor Murashkineb6c7c22015-02-04 17:30:43 -08001236 if (runtime_options.GetOrDefault(Opt::Interpret)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001237 GetInstrumentation()->ForceInterpretOnly();
1238 }
1239
Narayan Kamath5a2be3f2015-02-16 13:51:51 +00001240 zygote_max_failed_boots_ = runtime_options.GetOrDefault(Opt::ZygoteMaxFailedBoots);
Alex Lighteb7c1442015-08-31 13:17:42 -07001241 experimental_flags_ = runtime_options.GetOrDefault(Opt::Experimental);
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -07001242 is_low_memory_mode_ = runtime_options.Exists(Opt::LowMemoryMode);
Mathieu Chartierc42cb0e2017-10-13 11:35:00 -07001243 madvise_random_access_ = runtime_options.GetOrDefault(Opt::MadviseRandomAccess);
Narayan Kamath5a2be3f2015-02-16 13:51:51 +00001244
Andreas Gampe01fd70b2017-01-25 10:03:08 -08001245 plugins_ = runtime_options.ReleaseOrDefault(Opt::Plugins);
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001246 agent_specs_ = runtime_options.ReleaseOrDefault(Opt::AgentPath);
Andreas Gampe01fd70b2017-01-25 10:03:08 -08001247 // TODO Add back in -agentlib
1248 // for (auto lib : runtime_options.ReleaseOrDefault(Opt::AgentLib)) {
1249 // agents_.push_back(lib);
1250 // }
1251
Mathieu Chartier11c273d2017-10-15 20:54:45 -07001252 float foreground_heap_growth_multiplier;
1253 if (is_low_memory_mode_ && !runtime_options.Exists(Opt::ForegroundHeapGrowthMultiplier)) {
1254 // If low memory mode, use 1.0 as the multiplier by default.
1255 foreground_heap_growth_multiplier = 1.0f;
1256 } else {
1257 foreground_heap_growth_multiplier =
1258 runtime_options.GetOrDefault(Opt::ForegroundHeapGrowthMultiplier) +
1259 kExtraDefaultHeapGrowthMultiplier;
1260 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001261 XGcOption xgc_option = runtime_options.GetOrDefault(Opt::GcOption);
Albert Mingkun Yang0b4d1462018-11-29 13:25:35 +00001262
1263 // Generational CC collection is currently only compatible with Baker read barriers.
1264 bool use_generational_cc = kUseBakerReadBarrier && xgc_option.generational_cc;
1265
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001266 heap_ = new gc::Heap(runtime_options.GetOrDefault(Opt::MemoryInitialSize),
1267 runtime_options.GetOrDefault(Opt::HeapGrowthLimit),
1268 runtime_options.GetOrDefault(Opt::HeapMinFree),
1269 runtime_options.GetOrDefault(Opt::HeapMaxFree),
1270 runtime_options.GetOrDefault(Opt::HeapTargetUtilization),
Mathieu Chartier11c273d2017-10-15 20:54:45 -07001271 foreground_heap_growth_multiplier,
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001272 runtime_options.GetOrDefault(Opt::MemoryMaximumSize),
1273 runtime_options.GetOrDefault(Opt::NonMovingSpaceCapacity),
Vladimir Marko91f10322018-12-07 18:04:10 +00001274 GetBootClassPath(),
1275 GetBootClassPathLocations(),
1276 image_location_,
1277 instruction_set_,
Hiroshi Yamauchi1b0adbf2016-11-14 17:35:12 -08001278 // Override the collector type to CC if the read barrier config.
1279 kUseReadBarrier ? gc::kCollectorTypeCC : xgc_option.collector_type_,
1280 kUseReadBarrier ? BackgroundGcOption(gc::kCollectorTypeCCBackground)
1281 : runtime_options.GetOrDefault(Opt::BackgroundGc),
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001282 runtime_options.GetOrDefault(Opt::LargeObjectSpace),
1283 runtime_options.GetOrDefault(Opt::LargeObjectThreshold),
1284 runtime_options.GetOrDefault(Opt::ParallelGCThreads),
1285 runtime_options.GetOrDefault(Opt::ConcGCThreads),
1286 runtime_options.Exists(Opt::LowMemoryMode),
1287 runtime_options.GetOrDefault(Opt::LongPauseLogThreshold),
1288 runtime_options.GetOrDefault(Opt::LongGCLogThreshold),
1289 runtime_options.Exists(Opt::IgnoreMaxFootprint),
Hiroshi Yamauchif360ad02015-02-20 11:28:03 -08001290 runtime_options.GetOrDefault(Opt::UseTLAB),
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001291 xgc_option.verify_pre_gc_heap_,
1292 xgc_option.verify_pre_sweeping_heap_,
1293 xgc_option.verify_post_gc_heap_,
1294 xgc_option.verify_pre_gc_rosalloc_,
1295 xgc_option.verify_pre_sweeping_rosalloc_,
1296 xgc_option.verify_post_gc_rosalloc_,
Mathieu Chartier31000802015-06-14 14:14:37 -07001297 xgc_option.gcstress_,
Mathieu Chartier56fe2582016-07-14 13:30:03 -07001298 xgc_option.measure_,
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001299 runtime_options.GetOrDefault(Opt::EnableHSpaceCompactForOOM),
Albert Mingkun Yang0b4d1462018-11-29 13:25:35 +00001300 use_generational_cc,
Albert Mingkun Yangde94ea72018-11-16 10:15:49 +00001301 runtime_options.GetOrDefault(Opt::HSpaceCompactForOOMMinIntervalsMs),
1302 runtime_options.Exists(Opt::DumpRegionInfoBeforeGC),
1303 runtime_options.Exists(Opt::DumpRegionInfoAfterGC));
Dave Allison3d14eb62014-07-10 01:54:57 +00001304
Jeff Haodcdc85b2015-12-04 14:06:18 -08001305 if (!heap_->HasBootImageSpace() && !allow_dex_file_fallback_) {
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -07001306 LOG(ERROR) << "Dex file fallback disabled, cannot continue without image.";
1307 return false;
1308 }
1309
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001310 dump_gc_performance_on_shutdown_ = runtime_options.Exists(Opt::DumpGCPerformanceOnShutdown);
Dave Allison3d14eb62014-07-10 01:54:57 +00001311
Alex Light40320712017-12-14 11:52:04 -08001312 jdwp_options_ = runtime_options.GetOrDefault(Opt::JdwpOptions);
Alex Lightbaac7e42018-06-08 15:30:11 +00001313 jdwp_provider_ = CanonicalizeJdwpProvider(runtime_options.GetOrDefault(Opt::JdwpProvider),
1314 IsJavaDebuggable());
Alex Light40320712017-12-14 11:52:04 -08001315 switch (jdwp_provider_) {
1316 case JdwpProvider::kNone: {
Alex Light230fa942018-03-08 14:07:02 -08001317 VLOG(jdwp) << "Disabling all JDWP support.";
Alex Lightb06bd682018-01-29 13:26:45 -08001318 if (!jdwp_options_.empty()) {
1319 bool has_transport = jdwp_options_.find("transport") != std::string::npos;
1320 const char* transport_internal = !has_transport ? "transport=dt_android_adb," : "";
1321 std::string adb_connection_args =
1322 std::string(" -XjdwpProvider:adbconnection -XjdwpOptions:") + jdwp_options_;
1323 LOG(WARNING) << "Jdwp options given when jdwp is disabled! You probably want to enable "
1324 << "jdwp with one of:" << std::endl
1325 << " -XjdwpProvider:internal "
1326 << "-XjdwpOptions:" << transport_internal << jdwp_options_ << std::endl
1327 << " -Xplugin:libopenjdkjvmti" << (kIsDebugBuild ? "d" : "") << ".so "
1328 << "-agentpath:libjdwp.so=" << jdwp_options_ << std::endl
1329 << (has_transport ? "" : adb_connection_args);
1330 }
Alex Light40320712017-12-14 11:52:04 -08001331 break;
1332 }
1333 case JdwpProvider::kInternal: {
1334 if (runtime_options.Exists(Opt::JdwpOptions)) {
1335 JDWP::JdwpOptions ops;
1336 if (!JDWP::ParseJdwpOptions(runtime_options.GetOrDefault(Opt::JdwpOptions), &ops)) {
1337 LOG(ERROR) << "failed to parse jdwp options!";
1338 return false;
1339 }
1340 Dbg::ConfigureJdwp(ops);
1341 }
1342 break;
1343 }
Alex Lightfbf96702017-12-14 13:27:13 -08001344 case JdwpProvider::kAdbConnection: {
1345 constexpr const char* plugin_name = kIsDebugBuild ? "libadbconnectiond.so"
1346 : "libadbconnection.so";
1347 plugins_.push_back(Plugin::Create(plugin_name));
Alex Lightbaac7e42018-06-08 15:30:11 +00001348 break;
1349 }
1350 case JdwpProvider::kUnset: {
1351 LOG(FATAL) << "Illegal jdwp provider " << jdwp_provider_ << " was not filtered out!";
Alex Lightfbf96702017-12-14 13:27:13 -08001352 }
Sebastien Hertz3be6e9d2015-02-05 16:30:58 +01001353 }
Andreas Gampeac30fa22017-01-18 21:02:36 -08001354 callbacks_->AddThreadLifecycleCallback(Dbg::GetThreadLifecycleCallback());
1355 callbacks_->AddClassLoadCallback(Dbg::GetClassLoadCallback());
Sebastien Hertz3be6e9d2015-02-05 16:30:58 +01001356
Mathieu Chartier455f67c2015-03-17 13:48:29 -07001357 jit_options_.reset(jit::JitOptions::CreateFromRuntimeArguments(runtime_options));
Mathieu Chartier455f67c2015-03-17 13:48:29 -07001358 if (IsAotCompiler()) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08001359 // If we are already the compiler at this point, we must be dex2oat. Don't create the jit in
1360 // this case.
1361 // If runtime_options doesn't have UseJIT set to true then CreateFromRuntimeArguments returns
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001362 // null and we don't create the jit.
Calin Juravleffc87072016-04-20 14:22:09 +01001363 jit_options_->SetUseJitCompilation(false);
1364 jit_options_->SetSaveProfilingInfo(false);
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08001365 }
1366
Mathieu Chartierc6201fa2015-03-12 10:06:33 -07001367 // Use MemMap arena pool for jit, malloc otherwise. Malloc arenas are faster to allocate but
1368 // can't be trimmed as easily.
Mathieu Chartiere401d142015-04-22 13:56:20 -07001369 const bool use_malloc = IsAotCompiler();
David Sehr3215fff2018-04-03 17:10:12 -07001370 if (use_malloc) {
1371 arena_pool_.reset(new MallocArenaPool());
1372 jit_arena_pool_.reset(new MallocArenaPool());
1373 } else {
Andreas Gampe98ea9d92018-10-19 14:06:15 -07001374 arena_pool_.reset(new MemMapArenaPool(/* low_4gb= */ false));
1375 jit_arena_pool_.reset(new MemMapArenaPool(/* low_4gb= */ false, "CompilerMetadata"));
David Sehr3215fff2018-04-03 17:10:12 -07001376 }
Nicolas Geoffray25e04562016-03-01 13:17:58 +00001377
Mathieu Chartier017ed0b2015-09-22 11:04:26 -07001378 if (IsAotCompiler() && Is64BitInstructionSet(kRuntimeISA)) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07001379 // 4gb, no malloc. Explanation in header.
Andreas Gampe98ea9d92018-10-19 14:06:15 -07001380 low_4gb_arena_pool_.reset(new MemMapArenaPool(/* low_4gb= */ true));
Mathieu Chartierc7853442015-03-27 14:35:38 -07001381 }
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07001382 linear_alloc_.reset(CreateLinearAlloc());
Mathieu Chartierc6201fa2015-03-12 10:06:33 -07001383
Dave Allison3d14eb62014-07-10 01:54:57 +00001384 BlockSignals();
1385 InitPlatformSignalHandlers();
1386
Dave Allison69dfe512014-07-11 17:11:58 +00001387 // Change the implicit checks flags based on runtime architecture.
1388 switch (kRuntimeISA) {
Vladimir Marko33bff252017-11-01 14:35:42 +00001389 case InstructionSet::kArm:
1390 case InstructionSet::kThumb2:
1391 case InstructionSet::kX86:
1392 case InstructionSet::kArm64:
1393 case InstructionSet::kX86_64:
1394 case InstructionSet::kMips:
1395 case InstructionSet::kMips64:
Dave Allison69dfe512014-07-11 17:11:58 +00001396 implicit_null_checks_ = true;
Roland Levillain05e34f42018-05-24 13:19:05 +00001397 // Historical note: Installing stack protection was not playing well with Valgrind.
1398 implicit_so_checks_ = true;
Dave Allison69dfe512014-07-11 17:11:58 +00001399 break;
1400 default:
1401 // Keep the defaults.
1402 break;
1403 }
1404
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001405 if (!no_sig_chain_) {
1406 // Dex2Oat's Runtime does not need the signal chain or the fault handler.
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001407 if (implicit_null_checks_ || implicit_so_checks_ || implicit_suspend_checks_) {
1408 fault_manager.Init();
Dave Allison69dfe512014-07-11 17:11:58 +00001409
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001410 // These need to be in a specific order. The null point check handler must be
1411 // after the suspend check and stack overflow check handlers.
1412 //
Roland Levillain05e34f42018-05-24 13:19:05 +00001413 // Note: the instances attach themselves to the fault manager and are handled by it. The
1414 // manager will delete the instance on Shutdown().
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001415 if (implicit_suspend_checks_) {
1416 new SuspensionHandler(&fault_manager);
1417 }
Dave Allison69dfe512014-07-11 17:11:58 +00001418
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001419 if (implicit_so_checks_) {
1420 new StackOverflowHandler(&fault_manager);
1421 }
Dave Allison69dfe512014-07-11 17:11:58 +00001422
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001423 if (implicit_null_checks_) {
1424 new NullPointerHandler(&fault_manager);
1425 }
1426
1427 if (kEnableJavaStackTraceHandler) {
1428 new JavaStackTraceHandler(&fault_manager);
1429 }
Dave Allison69dfe512014-07-11 17:11:58 +00001430 }
1431 }
1432
Andreas Gampe0b0ffc12018-08-01 14:41:27 -07001433 verifier_logging_threshold_ms_ = runtime_options.GetOrDefault(Opt::VerifierLoggingThreshold);
1434
Richard Uhlerda0a69e2016-10-11 15:06:38 +01001435 std::string error_msg;
1436 java_vm_ = JavaVMExt::Create(this, runtime_options, &error_msg);
1437 if (java_vm_.get() == nullptr) {
1438 LOG(ERROR) << "Could not initialize JavaVMExt: " << error_msg;
1439 return false;
1440 }
Elliott Hughes515a5bc2011-08-17 11:08:34 -07001441
Alex Light185d1342016-08-11 10:48:03 -07001442 // Add the JniEnv handler.
1443 // TODO Refactor this stuff.
1444 java_vm_->AddEnvironmentHook(JNIEnvExt::GetEnvHandler);
1445
Elliott Hughesbe759c62011-09-08 19:38:21 -07001446 Thread::Startup();
Elliott Hughesd92bec42011-09-02 17:04:36 -07001447
Mathieu Chartier664bebf2012-11-12 16:54:11 -08001448 // ClassLinker needs an attached thread, but we can't fully attach a thread without creating
1449 // objects. We can't supply a thread group yet; it will be fixed later. Since we are the main
1450 // thread, we do not get a java peer.
Ian Rogers63557452014-06-04 16:57:15 -07001451 Thread* self = Thread::Attach("main", false, nullptr, false);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001452 CHECK_EQ(self->GetThreadId(), ThreadList::kMainThreadId);
Ian Rogers63557452014-06-04 16:57:15 -07001453 CHECK(self != nullptr);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001454
Alex Lighte9f61032018-09-24 16:04:51 -07001455 self->SetIsRuntimeThread(IsAotCompiler());
Calin Juravleccd56952016-12-15 17:57:38 +00001456
Brian Carlstromf28bc5b2011-10-26 01:15:03 -07001457 // Set us to runnable so tools using a runtime can allocate and GC by default
Ian Rogers120f1c72012-09-28 17:17:10 -07001458 self->TransitionFromSuspendedToRunnable();
Brian Carlstromf28bc5b2011-10-26 01:15:03 -07001459
Ian Rogersa436fde2013-08-27 23:34:06 -07001460 // Now we're attached, we can take the heap locks and validate the heap.
Ian Rogers141d6222012-04-05 12:23:06 -07001461 GetHeap()->EnableObjectValidation();
1462
Ian Rogers1d54e732013-05-02 21:10:01 -07001463 CHECK_GE(GetHeap()->GetContinuousSpaces().size(), 1U);
Chang Xing605fe242017-07-20 15:57:21 -07001464 if (UNLIKELY(IsAotCompiler())) {
1465 class_linker_ = new AotClassLinker(intern_table_);
1466 } else {
1467 class_linker_ = new ClassLinker(intern_table_);
1468 }
Jeff Haodcdc85b2015-12-04 14:06:18 -08001469 if (GetHeap()->HasBootImageSpace()) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001470 bool result = class_linker_->InitFromBootImage(&error_msg);
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001471 if (!result) {
1472 LOG(ERROR) << "Could not initialize from image: " << error_msg;
1473 return false;
1474 }
Hiroshi Yamauchibd0fb612014-05-20 13:46:00 -07001475 if (kIsDebugBuild) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08001476 for (auto image_space : GetHeap()->GetBootImageSpaces()) {
1477 image_space->VerifyImageAllocations();
1478 }
Hiroshi Yamauchibd0fb612014-05-20 13:46:00 -07001479 }
Vladimir Markocac5a7e2016-02-22 10:39:50 +00001480 {
1481 ScopedTrace trace2("AddImageStringsToTable");
Mathieu Chartier74ccee62018-10-10 10:30:29 -07001482 for (gc::space::ImageSpace* image_space : heap_->GetBootImageSpaces()) {
1483 GetInternTable()->AddImageStringsToTable(image_space, VoidFunctor());
1484 }
Vladimir Markocac5a7e2016-02-22 10:39:50 +00001485 }
Vladimir Marko0ace5632018-12-14 11:11:47 +00001486 if (heap_->GetBootImageSpaces().size() != GetBootClassPath().size()) {
1487 // The boot image did not contain all boot class path components. Load the rest.
1488 DCHECK_LT(heap_->GetBootImageSpaces().size(), GetBootClassPath().size());
1489 size_t start = heap_->GetBootImageSpaces().size();
1490 DCHECK_LT(start, GetBootClassPath().size());
1491 std::vector<std::unique_ptr<const DexFile>> extra_boot_class_path;
1492 if (runtime_options.Exists(Opt::BootClassPathDexList)) {
1493 extra_boot_class_path.swap(*runtime_options.GetOrDefault(Opt::BootClassPathDexList));
1494 } else {
Nicolas Geoffray99fc9382019-02-20 13:17:27 +00001495 OpenBootDexFiles(ArrayRef<const std::string>(GetBootClassPath()).SubArray(start),
1496 ArrayRef<const std::string>(GetBootClassPathLocations()).SubArray(start),
1497 &extra_boot_class_path);
Vladimir Marko0ace5632018-12-14 11:11:47 +00001498 }
1499 class_linker_->AddExtraBootDexFiles(self, std::move(extra_boot_class_path));
1500 }
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00001501 if (IsJavaDebuggable()) {
1502 // Now that we have loaded the boot image, deoptimize its methods if we are running
1503 // debuggable, as the code may have been compiled non-debuggable.
Nicolas Geoffray226805d2018-12-14 10:59:02 +00001504 ScopedThreadSuspension sts(self, ThreadState::kNative);
1505 ScopedSuspendAll ssa(__FUNCTION__);
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00001506 DeoptimizeBootImage();
1507 }
Richard Uhlerc2752592015-01-02 13:28:22 -08001508 } else {
Richard Uhlerfbef44d2014-12-23 09:48:51 -08001509 std::vector<std::unique_ptr<const DexFile>> boot_class_path;
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001510 if (runtime_options.Exists(Opt::BootClassPathDexList)) {
1511 boot_class_path.swap(*runtime_options.GetOrDefault(Opt::BootClassPathDexList));
1512 } else {
Nicolas Geoffray99fc9382019-02-20 13:17:27 +00001513 OpenBootDexFiles(ArrayRef<const std::string>(GetBootClassPath()),
1514 ArrayRef<const std::string>(GetBootClassPathLocations()),
1515 &boot_class_path);
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001516 }
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001517 if (!class_linker_->InitWithoutImage(std::move(boot_class_path), &error_msg)) {
1518 LOG(ERROR) << "Could not initialize without image: " << error_msg;
1519 return false;
1520 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001521
Alex Light64ad14d2014-08-19 14:23:13 -07001522 // TODO: Should we move the following to InitWithoutImage?
Jeff Haoc7d11882015-02-03 15:08:39 -08001523 SetInstructionSet(instruction_set_);
Andreas Gampe8228cdf2017-05-30 15:03:54 -07001524 for (uint32_t i = 0; i < kCalleeSaveSize; i++) {
1525 CalleeSaveType type = CalleeSaveType(i);
Alex Light64ad14d2014-08-19 14:23:13 -07001526 if (!HasCalleeSaveMethod(type)) {
Ian Rogers6a3c1fc2014-10-31 00:33:20 -07001527 SetCalleeSaveMethod(CreateCalleeSaveMethod(), type);
Alex Light64ad14d2014-08-19 14:23:13 -07001528 }
1529 }
Igor Murashkina2cfee32015-01-07 16:37:24 -08001530 }
1531
Ian Rogers63557452014-06-04 16:57:15 -07001532 CHECK(class_linker_ != nullptr);
Ian Rogersc0542af2014-09-03 16:16:56 -07001533
Sameer Abu Asal51a5fb72013-02-19 14:25:01 -08001534 verifier::MethodVerifier::Init();
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001535
Andreas Gampef6a780a2015-04-02 18:51:05 -07001536 if (runtime_options.Exists(Opt::MethodTrace)) {
1537 trace_config_.reset(new TraceConfig());
1538 trace_config_->trace_file = runtime_options.ReleaseOrDefault(Opt::MethodTraceFile);
1539 trace_config_->trace_file_size = runtime_options.ReleaseOrDefault(Opt::MethodTraceFileSize);
1540 trace_config_->trace_mode = Trace::TraceMode::kMethodTracing;
Andreas Gampe40da2862015-02-27 12:49:04 -08001541 trace_config_->trace_output_mode = runtime_options.Exists(Opt::MethodTraceStreaming) ?
1542 Trace::TraceOutputMode::kStreaming :
1543 Trace::TraceOutputMode::kFile;
Andreas Gampef6a780a2015-04-02 18:51:05 -07001544 }
jeffhaob5e81852012-03-12 11:15:45 -07001545
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08001546 // TODO: move this to just be an Trace::Start argument
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001547 Trace::SetDefaultClockSource(runtime_options.GetOrDefault(Opt::ProfileClock));
Dave Allison0aded082013-11-07 13:15:11 -08001548
Vladimir Markoc13fbd82018-06-04 16:16:28 +01001549 if (GetHeap()->HasBootImageSpace()) {
1550 const ImageHeader& image_header = GetHeap()->GetBootImageSpaces()[0]->GetImageHeader();
1551 pre_allocated_OutOfMemoryError_when_throwing_exception_ = GcRoot<mirror::Throwable>(
1552 image_header.GetImageRoot(ImageHeader::kOomeWhenThrowingException)->AsThrowable());
1553 DCHECK(pre_allocated_OutOfMemoryError_when_throwing_exception_.Read()->GetClass()
1554 ->DescriptorEquals("Ljava/lang/OutOfMemoryError;"));
1555 pre_allocated_OutOfMemoryError_when_throwing_oome_ = GcRoot<mirror::Throwable>(
1556 image_header.GetImageRoot(ImageHeader::kOomeWhenThrowingOome)->AsThrowable());
1557 DCHECK(pre_allocated_OutOfMemoryError_when_throwing_oome_.Read()->GetClass()
1558 ->DescriptorEquals("Ljava/lang/OutOfMemoryError;"));
1559 pre_allocated_OutOfMemoryError_when_handling_stack_overflow_ = GcRoot<mirror::Throwable>(
1560 image_header.GetImageRoot(ImageHeader::kOomeWhenHandlingStackOverflow)->AsThrowable());
1561 DCHECK(pre_allocated_OutOfMemoryError_when_handling_stack_overflow_.Read()->GetClass()
1562 ->DescriptorEquals("Ljava/lang/OutOfMemoryError;"));
1563 pre_allocated_NoClassDefFoundError_ = GcRoot<mirror::Throwable>(
1564 image_header.GetImageRoot(ImageHeader::kNoClassDefFoundError)->AsThrowable());
1565 DCHECK(pre_allocated_NoClassDefFoundError_.Read()->GetClass()
1566 ->DescriptorEquals("Ljava/lang/NoClassDefFoundError;"));
1567 } else {
1568 // Pre-allocate an OutOfMemoryError for the case when we fail to
1569 // allocate the exception to be thrown.
Vladimir Markodcfcce42018-06-27 10:00:28 +00001570 CreatePreAllocatedException(self,
1571 this,
1572 &pre_allocated_OutOfMemoryError_when_throwing_exception_,
1573 "Ljava/lang/OutOfMemoryError;",
1574 "OutOfMemoryError thrown while trying to throw an exception; "
1575 "no stack trace available");
Vladimir Markoc13fbd82018-06-04 16:16:28 +01001576 // Pre-allocate an OutOfMemoryError for the double-OOME case.
Vladimir Markodcfcce42018-06-27 10:00:28 +00001577 CreatePreAllocatedException(self,
1578 this,
1579 &pre_allocated_OutOfMemoryError_when_throwing_oome_,
1580 "Ljava/lang/OutOfMemoryError;",
1581 "OutOfMemoryError thrown while trying to throw OutOfMemoryError; "
1582 "no stack trace available");
Vladimir Markoc13fbd82018-06-04 16:16:28 +01001583 // Pre-allocate an OutOfMemoryError for the case when we fail to
1584 // allocate while handling a stack overflow.
Vladimir Markodcfcce42018-06-27 10:00:28 +00001585 CreatePreAllocatedException(self,
1586 this,
1587 &pre_allocated_OutOfMemoryError_when_handling_stack_overflow_,
1588 "Ljava/lang/OutOfMemoryError;",
1589 "OutOfMemoryError thrown while trying to handle a stack overflow; "
1590 "no stack trace available");
Ian Rogersa436fde2013-08-27 23:34:06 -07001591
Vladimir Markoc13fbd82018-06-04 16:16:28 +01001592 // Pre-allocate a NoClassDefFoundError for the common case of failing to find a system class
1593 // ahead of checking the application's class loader.
Vladimir Markodcfcce42018-06-27 10:00:28 +00001594 CreatePreAllocatedException(self,
1595 this,
1596 &pre_allocated_NoClassDefFoundError_,
1597 "Ljava/lang/NoClassDefFoundError;",
1598 "Class not found using the boot class loader; "
1599 "no stack trace available");
Vladimir Markoc13fbd82018-06-04 16:16:28 +01001600 }
Ian Rogers63557452014-06-04 16:57:15 -07001601
Alex Light185d1342016-08-11 10:48:03 -07001602 // Runtime initialization is largely done now.
1603 // We load plugins first since that can modify the runtime state slightly.
1604 // Load all plugins
Nicolas Geoffray226805d2018-12-14 10:59:02 +00001605 {
1606 // The init method of plugins expect the state of the thread to be non runnable.
1607 ScopedThreadSuspension sts(self, ThreadState::kNative);
1608 for (auto& plugin : plugins_) {
1609 std::string err;
1610 if (!plugin.Load(&err)) {
1611 LOG(FATAL) << plugin << " failed to load: " << err;
1612 }
Alex Light185d1342016-08-11 10:48:03 -07001613 }
1614 }
1615
Andreas Gampe855564b2014-07-25 02:32:19 -07001616 // Look for a native bridge.
Andreas Gampe6be67ee2014-09-02 21:22:18 -07001617 //
1618 // The intended flow here is, in the case of a running system:
1619 //
1620 // Runtime::Init() (zygote):
1621 // LoadNativeBridge -> dlopen from cmd line parameter.
1622 // |
1623 // V
1624 // Runtime::Start() (zygote):
1625 // No-op wrt native bridge.
1626 // |
1627 // | start app
1628 // V
1629 // DidForkFromZygote(action)
1630 // action = kUnload -> dlclose native bridge.
1631 // action = kInitialize -> initialize library
1632 //
1633 //
1634 // The intended flow here is, in the case of a simple dalvikvm call:
1635 //
1636 // Runtime::Init():
1637 // LoadNativeBridge -> dlopen from cmd line parameter.
1638 // |
1639 // V
1640 // Runtime::Start():
1641 // DidForkFromZygote(kInitialize) -> try to initialize any native bridge given.
1642 // No-op wrt native bridge.
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001643 {
1644 std::string native_bridge_file_name = runtime_options.ReleaseOrDefault(Opt::NativeBridge);
1645 is_native_bridge_loaded_ = LoadNativeBridge(native_bridge_file_name);
1646 }
Calin Juravlea68629e2014-08-22 12:53:59 +01001647
Alex Light7233c7e2016-07-28 10:07:45 -07001648 // Startup agents
1649 // TODO Maybe we should start a new thread to run these on. Investigate RI behavior more.
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001650 for (auto& agent_spec : agent_specs_) {
Alex Light7233c7e2016-07-28 10:07:45 -07001651 // TODO Check err
1652 int res = 0;
1653 std::string err = "";
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001654 ti::LoadError error;
1655 std::unique_ptr<ti::Agent> agent = agent_spec.Load(&res, &error, &err);
1656
1657 if (agent != nullptr) {
1658 agents_.push_back(std::move(agent));
1659 continue;
Alex Light7233c7e2016-07-28 10:07:45 -07001660 }
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001661
1662 switch (error) {
1663 case ti::LoadError::kInitializationError:
1664 LOG(FATAL) << "Unable to initialize agent!";
1665 UNREACHABLE();
1666
1667 case ti::LoadError::kLoadingError:
1668 LOG(ERROR) << "Unable to load an agent: " << err;
1669 continue;
1670
1671 case ti::LoadError::kNoError:
1672 break;
1673 }
1674 LOG(FATAL) << "Unreachable";
1675 UNREACHABLE();
Alex Light7233c7e2016-07-28 10:07:45 -07001676 }
Andreas Gampe96eca782017-01-19 19:45:30 -08001677 {
1678 ScopedObjectAccess soa(self);
1679 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kInitialAgents);
1680 }
Alex Light7233c7e2016-07-28 10:07:45 -07001681
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001682 VLOG(startup) << "Runtime::Init exiting";
Mathieu Chartiere401d142015-04-22 13:56:20 -07001683
Nicolas Geoffray66ff8a82018-02-28 13:27:55 +00001684 // Set OnlyUseSystemOatFiles only after boot classpath has been set up.
1685 if (runtime_options.Exists(Opt::OnlyUseSystemOatFiles)) {
1686 oat_file_manager_->SetOnlyUseSystemOatFiles();
1687 }
1688
Carl Shapiro1fb86202011-06-27 17:43:13 -07001689 return true;
1690}
1691
Andreas Gampec4baad22017-01-12 16:59:39 +00001692static bool EnsureJvmtiPlugin(Runtime* runtime,
1693 std::vector<Plugin>* plugins,
1694 std::string* error_msg) {
1695 constexpr const char* plugin_name = kIsDebugBuild ? "libopenjdkjvmtid.so" : "libopenjdkjvmti.so";
1696
1697 // Is the plugin already loaded?
Andreas Gampe96eca782017-01-19 19:45:30 -08001698 for (const Plugin& p : *plugins) {
Andreas Gampec4baad22017-01-12 16:59:39 +00001699 if (p.GetLibrary() == plugin_name) {
1700 return true;
1701 }
1702 }
1703
Alex Lightf889c702018-02-23 15:25:45 -08001704 // TODO Rename Dbg::IsJdwpAllowed is IsDebuggingAllowed.
1705 DCHECK(Dbg::IsJdwpAllowed() || !runtime->IsJavaDebuggable())
1706 << "Being debuggable requires that jdwp (i.e. debugging) is allowed.";
Alex Light2ce6fc82017-12-18 16:42:36 -08001707 // Is the process debuggable? Otherwise, do not attempt to load the plugin unless we are
1708 // specifically allowed.
Alex Lightf889c702018-02-23 15:25:45 -08001709 if (!Dbg::IsJdwpAllowed()) {
1710 *error_msg = "Process is not allowed to load openjdkjvmti plugin. Process must be debuggable";
Andreas Gampec4baad22017-01-12 16:59:39 +00001711 return false;
1712 }
1713
1714 Plugin new_plugin = Plugin::Create(plugin_name);
1715
Andreas Gampec4baad22017-01-12 16:59:39 +00001716 if (!new_plugin.Load(error_msg)) {
1717 return false;
1718 }
1719
1720 plugins->push_back(std::move(new_plugin));
1721 return true;
1722}
1723
Leonard Mosescueb842212016-10-06 17:26:36 -07001724// Attach a new agent and add it to the list of runtime agents
1725//
1726// TODO: once we decide on the threading model for agents,
1727// revisit this and make sure we're doing this on the right thread
1728// (and we synchronize access to any shared data structures like "agents_")
1729//
Alex Lightf889c702018-02-23 15:25:45 -08001730void Runtime::AttachAgent(JNIEnv* env, const std::string& agent_arg, jobject class_loader) {
Andreas Gampec4baad22017-01-12 16:59:39 +00001731 std::string error_msg;
Alex Lightf889c702018-02-23 15:25:45 -08001732 if (!EnsureJvmtiPlugin(this, &plugins_, &error_msg)) {
Andreas Gampec4baad22017-01-12 16:59:39 +00001733 LOG(WARNING) << "Could not load plugin: " << error_msg;
1734 ScopedObjectAccess soa(Thread::Current());
1735 ThrowIOException("%s", error_msg.c_str());
1736 return;
1737 }
1738
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001739 ti::AgentSpec agent_spec(agent_arg);
Leonard Mosescueb842212016-10-06 17:26:36 -07001740
1741 int res = 0;
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001742 ti::LoadError error;
Andreas Gampe7b38e692017-12-28 19:18:28 -08001743 std::unique_ptr<ti::Agent> agent = agent_spec.Attach(env, class_loader, &res, &error, &error_msg);
Leonard Mosescueb842212016-10-06 17:26:36 -07001744
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001745 if (agent != nullptr) {
Leonard Mosescueb842212016-10-06 17:26:36 -07001746 agents_.push_back(std::move(agent));
1747 } else {
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001748 LOG(WARNING) << "Agent attach failed (result=" << error << ") : " << error_msg;
Leonard Mosescueb842212016-10-06 17:26:36 -07001749 ScopedObjectAccess soa(Thread::Current());
Andreas Gampec4baad22017-01-12 16:59:39 +00001750 ThrowIOException("%s", error_msg.c_str());
Leonard Mosescueb842212016-10-06 17:26:36 -07001751 }
1752}
1753
Elliott Hughes038a8062011-09-18 14:12:41 -07001754void Runtime::InitNativeMethods() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001755 VLOG(startup) << "Runtime::InitNativeMethods entering";
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001756 Thread* self = Thread::Current();
1757 JNIEnv* env = self->GetJniEnv();
1758
Elliott Hughes418d20f2011-09-22 14:00:39 -07001759 // Must be in the kNative state for calling native methods (JNI_OnLoad code).
Ian Rogers50b35e22012-10-04 10:09:15 -07001760 CHECK_EQ(self->GetState(), kNative);
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001761
Andreas Gamped863be72017-09-12 12:02:28 -07001762 // Set up the native methods provided by the runtime itself.
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001763 RegisterRuntimeNativeMethods(env);
1764
Yi Kong0871cd72015-11-20 16:00:31 +00001765 // Initialize classes used in JNI. The initialization requires runtime native
1766 // methods to be loaded first.
1767 WellKnownClasses::Init(env);
1768
Narayan Kamathd7b3c7f2015-11-18 09:49:10 +00001769 // Then set up libjavacore / libopenjdk, which are just a regular JNI libraries with
Narayan Kamathd1ef4362015-11-12 11:49:06 +00001770 // a regular JNI_OnLoad. Most JNI libraries can just use System.loadLibrary, but
1771 // libcore can't because it's the library that implements System.loadLibrary!
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001772 {
Dmitriy Ivanov44409d32015-11-11 14:18:55 -08001773 std::string error_msg;
Nicolas Geoffray107ce792019-01-26 01:06:17 +00001774 if (!java_vm_->LoadNativeLibrary(
1775 env, "libjavacore.so", nullptr, WellKnownClasses::java_lang_Object, &error_msg)) {
Dmitriy Ivanov44409d32015-11-11 14:18:55 -08001776 LOG(FATAL) << "LoadNativeLibrary failed for \"libjavacore.so\": " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001777 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001778 }
Piotr Jastrzebski8ca90772015-04-24 09:18:00 +01001779 {
Andreas Gampe10edbb12016-01-06 17:59:49 -08001780 constexpr const char* kOpenJdkLibrary = kIsDebugBuild
1781 ? "libopenjdkd.so"
1782 : "libopenjdk.so";
Dmitriy Ivanov3e381722015-11-23 17:40:11 -08001783 std::string error_msg;
Nicolas Geoffray107ce792019-01-26 01:06:17 +00001784 if (!java_vm_->LoadNativeLibrary(
1785 env, kOpenJdkLibrary, nullptr, WellKnownClasses::java_lang_Object, &error_msg)) {
Andreas Gampe10edbb12016-01-06 17:59:49 -08001786 LOG(FATAL) << "LoadNativeLibrary failed for \"" << kOpenJdkLibrary << "\": " << error_msg;
Piotr Jastrzebski8ca90772015-04-24 09:18:00 +01001787 }
Piotr Jastrzebski8ca90772015-04-24 09:18:00 +01001788 }
Ian Rogersef28b142012-11-30 14:22:18 -08001789
1790 // Initialize well known classes that may invoke runtime native methods.
1791 WellKnownClasses::LateInit(env);
1792
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001793 VLOG(startup) << "Runtime::InitNativeMethods exiting";
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001794}
1795
Jean-Philippe Halimica76a1a2016-02-02 19:48:52 +01001796void Runtime::ReclaimArenaPoolMemory() {
1797 arena_pool_->LockReclaimMemory();
1798}
1799
Ian Rogers365c1022012-06-22 15:05:28 -07001800void Runtime::InitThreadGroups(Thread* self) {
1801 JNIEnvExt* env = self->GetJniEnv();
1802 ScopedJniEnvLocalRefState env_state(env);
1803 main_thread_group_ =
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08001804 env->NewGlobalRef(env->GetStaticObjectField(
1805 WellKnownClasses::java_lang_ThreadGroup,
1806 WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup));
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001807 CHECK(main_thread_group_ != nullptr || IsAotCompiler());
Ian Rogers365c1022012-06-22 15:05:28 -07001808 system_thread_group_ =
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08001809 env->NewGlobalRef(env->GetStaticObjectField(
1810 WellKnownClasses::java_lang_ThreadGroup,
1811 WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup));
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001812 CHECK(system_thread_group_ != nullptr || IsAotCompiler());
Brian Carlstrom034f76b2012-08-01 15:51:58 -07001813}
1814
1815jobject Runtime::GetMainThreadGroup() const {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001816 CHECK(main_thread_group_ != nullptr || IsAotCompiler());
Brian Carlstrom034f76b2012-08-01 15:51:58 -07001817 return main_thread_group_;
1818}
1819
1820jobject Runtime::GetSystemThreadGroup() const {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001821 CHECK(system_thread_group_ != nullptr || IsAotCompiler());
Brian Carlstrom034f76b2012-08-01 15:51:58 -07001822 return system_thread_group_;
Ian Rogers365c1022012-06-22 15:05:28 -07001823}
1824
Brian Carlstromce888532013-10-10 00:32:58 -07001825jobject Runtime::GetSystemClassLoader() const {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001826 CHECK(system_class_loader_ != nullptr || IsAotCompiler());
Brian Carlstromce888532013-10-10 00:32:58 -07001827 return system_class_loader_;
1828}
1829
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001830void Runtime::RegisterRuntimeNativeMethods(JNIEnv* env) {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001831 register_dalvik_system_DexFile(env);
1832 register_dalvik_system_VMDebug(env);
1833 register_dalvik_system_VMRuntime(env);
1834 register_dalvik_system_VMStack(env);
1835 register_dalvik_system_ZygoteHooks(env);
1836 register_java_lang_Class(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001837 register_java_lang_Object(env);
Narayan Kamathbd2fed52017-01-25 10:46:54 +00001838 register_java_lang_invoke_MethodHandleImpl(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001839 register_java_lang_ref_FinalizerReference(env);
1840 register_java_lang_reflect_Array(env);
1841 register_java_lang_reflect_Constructor(env);
Neil Fuller0e844392016-09-08 13:43:31 +01001842 register_java_lang_reflect_Executable(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001843 register_java_lang_reflect_Field(env);
1844 register_java_lang_reflect_Method(env);
Neil Fuller60458a02016-09-01 15:32:44 +01001845 register_java_lang_reflect_Parameter(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001846 register_java_lang_reflect_Proxy(env);
1847 register_java_lang_ref_Reference(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001848 register_java_lang_String(env);
Jeff Hao848f70a2014-01-15 13:49:50 -08001849 register_java_lang_StringFactory(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001850 register_java_lang_System(env);
1851 register_java_lang_Thread(env);
1852 register_java_lang_Throwable(env);
1853 register_java_lang_VMClassLoader(env);
1854 register_java_util_concurrent_atomic_AtomicLong(env);
Jeff Hao848f70a2014-01-15 13:49:50 -08001855 register_libcore_util_CharsetUtils(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001856 register_org_apache_harmony_dalvik_ddmc_DdmServer(env);
1857 register_org_apache_harmony_dalvik_ddmc_DdmVmInternal(env);
1858 register_sun_misc_Unsafe(env);
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001859}
1860
Nicolas Geoffray4e92c3c2017-05-08 09:34:26 +01001861std::ostream& operator<<(std::ostream& os, const DeoptimizationKind& kind) {
1862 os << GetDeoptimizationKindName(kind);
1863 return os;
1864}
1865
1866void Runtime::DumpDeoptimizations(std::ostream& os) {
1867 for (size_t i = 0; i <= static_cast<size_t>(DeoptimizationKind::kLast); ++i) {
1868 if (deoptimization_counts_[i] != 0) {
1869 os << "Number of "
1870 << GetDeoptimizationKindName(static_cast<DeoptimizationKind>(i))
1871 << " deoptimizations: "
1872 << deoptimization_counts_[i]
1873 << "\n";
1874 }
1875 }
1876}
1877
Elliott Hughesc967f782012-04-16 10:23:15 -07001878void Runtime::DumpForSigQuit(std::ostream& os) {
Elliott Hughescac6cc72011-11-03 20:31:21 -07001879 GetClassLinker()->DumpForSigQuit(os);
1880 GetInternTable()->DumpForSigQuit(os);
Elliott Hughesae80b492012-04-24 10:43:17 -07001881 GetJavaVM()->DumpForSigQuit(os);
Elliott Hughesc967f782012-04-16 10:23:15 -07001882 GetHeap()->DumpForSigQuit(os);
Nicolas Geoffray04680f32016-03-17 11:56:54 +00001883 oat_file_manager_->DumpForSigQuit(os);
Nicolas Geoffrayaee21562015-12-15 16:39:44 +00001884 if (GetJit() != nullptr) {
1885 GetJit()->DumpForSigQuit(os);
1886 } else {
1887 os << "Running non JIT\n";
1888 }
Nicolas Geoffray4e92c3c2017-05-08 09:34:26 +01001889 DumpDeoptimizations(os);
Mathieu Chartierbad02672014-08-25 13:08:22 -07001890 TrackedAllocators::Dump(os);
Elliott Hughes42ee1422011-09-06 12:33:32 -07001891 os << "\n";
Elliott Hughes8daa0922011-09-11 13:46:25 -07001892
Elliott Hughesc967f782012-04-16 10:23:15 -07001893 thread_list_->DumpForSigQuit(os);
Ian Rogers56edc432013-01-18 16:51:51 -08001894 BaseMutex::DumpAll(os);
Andreas Gampea5814f92017-01-18 21:43:16 -08001895
1896 // Inform anyone else who is interested in SigQuit.
1897 {
1898 ScopedObjectAccess soa(Thread::Current());
1899 callbacks_->SigQuit();
1900 }
Elliott Hughese27955c2011-08-26 15:21:24 -07001901}
1902
Elliott Hughes21a5bf22011-12-07 14:35:20 -08001903void Runtime::DumpLockHolders(std::ostream& os) {
Ian Rogersb726dcb2012-09-05 08:57:23 -07001904 uint64_t mutator_lock_owner = Locks::mutator_lock_->GetExclusiveOwnerTid();
Elliott Hughes21a5bf22011-12-07 14:35:20 -08001905 pid_t thread_list_lock_owner = GetThreadList()->GetLockOwner();
1906 pid_t classes_lock_owner = GetClassLinker()->GetClassesLockOwner();
1907 pid_t dex_lock_owner = GetClassLinker()->GetDexLockOwner();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001908 if ((thread_list_lock_owner | classes_lock_owner | dex_lock_owner) != 0) {
1909 os << "Mutator lock exclusive owner tid: " << mutator_lock_owner << "\n"
Elliott Hughes21a5bf22011-12-07 14:35:20 -08001910 << "ThreadList lock owner tid: " << thread_list_lock_owner << "\n"
1911 << "ClassLinker classes lock owner tid: " << classes_lock_owner << "\n"
1912 << "ClassLinker dex lock owner tid: " << dex_lock_owner << "\n";
1913 }
1914}
1915
Mathieu Chartier9ef78b52014-09-25 17:03:12 -07001916void Runtime::SetStatsEnabled(bool new_state) {
1917 Thread* self = Thread::Current();
1918 MutexLock mu(self, *Locks::instrument_entrypoints_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001919 if (new_state == true) {
1920 GetStats()->Clear(~0);
1921 // TODO: wouldn't it make more sense to clear _all_ threads' stats?
Mathieu Chartier9ef78b52014-09-25 17:03:12 -07001922 self->GetStats()->Clear(~0);
1923 if (stats_enabled_ != new_state) {
1924 GetInstrumentation()->InstrumentQuickAllocEntryPointsLocked();
1925 }
1926 } else if (stats_enabled_ != new_state) {
1927 GetInstrumentation()->UninstrumentQuickAllocEntryPointsLocked();
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001928 }
1929 stats_enabled_ = new_state;
1930}
1931
1932void Runtime::ResetStats(int kinds) {
1933 GetStats()->Clear(kinds & 0xffff);
1934 // TODO: wouldn't it make more sense to clear _all_ threads' stats?
1935 Thread::Current()->GetStats()->Clear(kinds >> 16);
1936}
1937
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001938int32_t Runtime::GetStat(int kind) {
1939 RuntimeStats* stats;
1940 if (kind < (1<<16)) {
1941 stats = GetStats();
1942 } else {
1943 stats = Thread::Current()->GetStats();
1944 kind >>= 16;
1945 }
1946 switch (kind) {
1947 case KIND_ALLOCATED_OBJECTS:
1948 return stats->allocated_objects;
1949 case KIND_ALLOCATED_BYTES:
1950 return stats->allocated_bytes;
1951 case KIND_FREED_OBJECTS:
1952 return stats->freed_objects;
1953 case KIND_FREED_BYTES:
1954 return stats->freed_bytes;
1955 case KIND_GC_INVOCATIONS:
1956 return stats->gc_for_alloc_count;
1957 case KIND_CLASS_INIT_COUNT:
1958 return stats->class_init_count;
1959 case KIND_CLASS_INIT_TIME:
1960 // Convert ns to us, reduce to 32 bits.
Elliott Hughes398f64b2012-03-26 18:05:48 -07001961 return static_cast<int>(stats->class_init_time_ns / 1000);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001962 case KIND_EXT_ALLOCATED_OBJECTS:
1963 case KIND_EXT_ALLOCATED_BYTES:
1964 case KIND_EXT_FREED_OBJECTS:
1965 case KIND_EXT_FREED_BYTES:
1966 return 0; // backward compatibility
1967 default:
Elliott Hughes7b9d9962012-04-20 18:48:18 -07001968 LOG(FATAL) << "Unknown statistic " << kind;
Elliott Hughesc1896c92018-11-29 11:33:18 -08001969 UNREACHABLE();
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001970 }
1971}
1972
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001973void Runtime::BlockSignals() {
Elliott Hughes457005c2012-04-16 13:54:25 -07001974 SignalSet signals;
1975 signals.Add(SIGPIPE);
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001976 // SIGQUIT is used to dump the runtime's state (including stack traces).
Elliott Hughes457005c2012-04-16 13:54:25 -07001977 signals.Add(SIGQUIT);
Elliott Hughes08795042012-04-03 14:48:52 -07001978 // SIGUSR1 is used to initiate a GC.
Elliott Hughes457005c2012-04-16 13:54:25 -07001979 signals.Add(SIGUSR1);
1980 signals.Block();
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001981}
1982
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001983bool Runtime::AttachCurrentThread(const char* thread_name, bool as_daemon, jobject thread_group,
Mathieu Chartier664bebf2012-11-12 16:54:11 -08001984 bool create_peer) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001985 ScopedTrace trace(__FUNCTION__);
Andreas Gampe56776012018-01-26 17:40:55 -08001986 Thread* self = Thread::Attach(thread_name, as_daemon, thread_group, create_peer);
1987 // Run ThreadGroup.add to notify the group that this thread is now started.
1988 if (self != nullptr && create_peer && !IsAotCompiler()) {
1989 ScopedObjectAccess soa(self);
1990 self->NotifyThreadGroup(soa, thread_group);
1991 }
1992 return self != nullptr;
Carl Shapiro61e019d2011-07-14 16:53:09 -07001993}
1994
Elliott Hughesd92bec42011-09-02 17:04:36 -07001995void Runtime::DetachCurrentThread() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001996 ScopedTrace trace(__FUNCTION__);
Brian Carlstrom4d571432012-05-16 00:21:41 -07001997 Thread* self = Thread::Current();
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001998 if (self == nullptr) {
Brian Carlstrom4d571432012-05-16 00:21:41 -07001999 LOG(FATAL) << "attempting to detach thread that is not attached";
2000 }
Ian Rogers0399dde2012-06-06 17:09:28 -07002001 if (self->HasManagedStack()) {
Elliott Hughes22869a92012-03-27 14:08:24 -07002002 LOG(FATAL) << *Thread::Current() << " attempting to detach while still running code";
2003 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002004 thread_list_->Unregister(self);
Carl Shapiro1fb86202011-06-27 17:43:13 -07002005}
2006
Roland Levillain7b0e8442018-04-11 18:27:47 +01002007mirror::Throwable* Runtime::GetPreAllocatedOutOfMemoryErrorWhenThrowingException() {
2008 mirror::Throwable* oome = pre_allocated_OutOfMemoryError_when_throwing_exception_.Read();
Ian Rogers63557452014-06-04 16:57:15 -07002009 if (oome == nullptr) {
Roland Levillain7b0e8442018-04-11 18:27:47 +01002010 LOG(ERROR) << "Failed to return pre-allocated OOME-when-throwing-exception";
2011 }
2012 return oome;
2013}
2014
2015mirror::Throwable* Runtime::GetPreAllocatedOutOfMemoryErrorWhenThrowingOOME() {
2016 mirror::Throwable* oome = pre_allocated_OutOfMemoryError_when_throwing_oome_.Read();
2017 if (oome == nullptr) {
2018 LOG(ERROR) << "Failed to return pre-allocated OOME-when-throwing-OOME";
2019 }
2020 return oome;
2021}
2022
2023mirror::Throwable* Runtime::GetPreAllocatedOutOfMemoryErrorWhenHandlingStackOverflow() {
2024 mirror::Throwable* oome = pre_allocated_OutOfMemoryError_when_handling_stack_overflow_.Read();
2025 if (oome == nullptr) {
2026 LOG(ERROR) << "Failed to return pre-allocated OOME-when-handling-stack-overflow";
Ian Rogersa436fde2013-08-27 23:34:06 -07002027 }
Hiroshi Yamauchiab088112014-07-14 13:00:14 -07002028 return oome;
Ian Rogersa436fde2013-08-27 23:34:06 -07002029}
2030
Ian Rogers63557452014-06-04 16:57:15 -07002031mirror::Throwable* Runtime::GetPreAllocatedNoClassDefFoundError() {
2032 mirror::Throwable* ncdfe = pre_allocated_NoClassDefFoundError_.Read();
2033 if (ncdfe == nullptr) {
2034 LOG(ERROR) << "Failed to return pre-allocated NoClassDefFoundError";
2035 }
2036 return ncdfe;
2037}
2038
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002039void Runtime::VisitConstantRoots(RootVisitor* visitor) {
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002040 // Visiting the roots of these ArtMethods is not currently required since all the GcRoots are
2041 // null.
2042 BufferedRootVisitor<16> buffered_visitor(visitor, RootInfo(kRootVMInternal));
Andreas Gampe542451c2016-07-26 09:02:02 -07002043 const PointerSize pointer_size = GetClassLinker()->GetImagePointerSize();
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002044 if (HasResolutionMethod()) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07002045 resolution_method_->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002046 }
2047 if (HasImtConflictMethod()) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07002048 imt_conflict_method_->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002049 }
2050 if (imt_unimplemented_method_ != nullptr) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07002051 imt_unimplemented_method_->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002052 }
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002053 for (uint32_t i = 0; i < kCalleeSaveSize; ++i) {
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002054 auto* m = reinterpret_cast<ArtMethod*>(callee_save_methods_[i]);
2055 if (m != nullptr) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07002056 m->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002057 }
2058 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08002059}
2060
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002061void Runtime::VisitConcurrentRoots(RootVisitor* visitor, VisitRootFlags flags) {
2062 intern_table_->VisitRoots(visitor, flags);
2063 class_linker_->VisitRoots(visitor, flags);
Man Cao1ed11b92015-06-11 22:47:35 -07002064 heap_->VisitAllocationRecords(visitor);
Mathieu Chartier893263b2014-03-04 11:07:42 -08002065 if ((flags & kVisitRootFlagNewRoots) == 0) {
2066 // Guaranteed to have no new roots in the constant roots.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002067 VisitConstantRoots(visitor);
Mathieu Chartier893263b2014-03-04 11:07:42 -08002068 }
Mathieu Chartiera6b1ead2015-10-06 10:32:38 -07002069 Dbg::VisitRoots(visitor);
Mathieu Chartier893263b2014-03-04 11:07:42 -08002070}
2071
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002072void Runtime::VisitTransactionRoots(RootVisitor* visitor) {
Chang Xing605fe242017-07-20 15:57:21 -07002073 for (auto& transaction : preinitialization_transactions_) {
2074 transaction->VisitRoots(visitor);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08002075 }
2076}
2077
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002078void Runtime::VisitNonThreadRoots(RootVisitor* visitor) {
2079 java_vm_->VisitRoots(visitor);
2080 sentinel_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Roland Levillain7b0e8442018-04-11 18:27:47 +01002081 pre_allocated_OutOfMemoryError_when_throwing_exception_
2082 .VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
2083 pre_allocated_OutOfMemoryError_when_throwing_oome_
2084 .VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
2085 pre_allocated_OutOfMemoryError_when_handling_stack_overflow_
2086 .VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002087 pre_allocated_NoClassDefFoundError_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Vladimir Markof75613c2018-06-05 12:51:04 +01002088 VisitImageRoots(visitor);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002089 verifier::MethodVerifier::VisitStaticRoots(visitor);
2090 VisitTransactionRoots(visitor);
Brian Carlstrome24fa612011-09-29 00:53:55 -07002091}
2092
Andreas Gampe585da952016-12-02 14:52:29 -08002093void Runtime::VisitNonConcurrentRoots(RootVisitor* visitor, VisitRootFlags flags) {
2094 VisitThreadRoots(visitor, flags);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002095 VisitNonThreadRoots(visitor);
Mathieu Chartier858f1c52012-10-17 17:45:55 -07002096}
2097
Andreas Gampe585da952016-12-02 14:52:29 -08002098void Runtime::VisitThreadRoots(RootVisitor* visitor, VisitRootFlags flags) {
2099 thread_list_->VisitRoots(visitor, flags);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08002100}
2101
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002102void Runtime::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) {
Andreas Gampe585da952016-12-02 14:52:29 -08002103 VisitNonConcurrentRoots(visitor, flags);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002104 VisitConcurrentRoots(visitor, flags);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07002105}
2106
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002107void Runtime::VisitImageRoots(RootVisitor* visitor) {
Mathieu Chartier461687d2015-03-31 12:05:24 -07002108 for (auto* space : GetHeap()->GetContinuousSpaces()) {
2109 if (space->IsImageSpace()) {
2110 auto* image_space = space->AsImageSpace();
2111 const auto& image_header = image_space->GetImageHeader();
Vladimir Markoeca3eda2016-11-09 16:26:44 +00002112 for (int32_t i = 0, size = image_header.GetImageRoots()->GetLength(); i != size; ++i) {
Vladimir Markoc13fbd82018-06-04 16:16:28 +01002113 mirror::Object* obj =
2114 image_header.GetImageRoot(static_cast<ImageHeader::ImageRoot>(i)).Ptr();
Mathieu Chartier461687d2015-03-31 12:05:24 -07002115 if (obj != nullptr) {
Vladimir Markoc13fbd82018-06-04 16:16:28 +01002116 mirror::Object* after_obj = obj;
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002117 visitor->VisitRoot(&after_obj, RootInfo(kRootStickyClass));
Mathieu Chartier461687d2015-03-31 12:05:24 -07002118 CHECK_EQ(after_obj, obj);
2119 }
2120 }
2121 }
2122 }
2123}
2124
Andreas Gampecc1b5352016-12-01 16:58:38 -08002125static ArtMethod* CreateRuntimeMethod(ClassLinker* class_linker, LinearAlloc* linear_alloc) {
2126 const PointerSize image_pointer_size = class_linker->GetImagePointerSize();
2127 const size_t method_alignment = ArtMethod::Alignment(image_pointer_size);
2128 const size_t method_size = ArtMethod::Size(image_pointer_size);
2129 LengthPrefixedArray<ArtMethod>* method_array = class_linker->AllocArtMethodArray(
2130 Thread::Current(),
2131 linear_alloc,
2132 1);
2133 ArtMethod* method = &method_array->At(0, method_size, method_alignment);
2134 CHECK(method != nullptr);
Andreas Gampee2abbc62017-09-15 11:59:26 -07002135 method->SetDexMethodIndex(dex::kDexNoIndex);
Andreas Gampecc1b5352016-12-01 16:58:38 -08002136 CHECK(method->IsRuntimeMethod());
2137 return method;
2138}
2139
Nicolas Geoffray796d6302016-03-13 22:22:31 +00002140ArtMethod* Runtime::CreateImtConflictMethod(LinearAlloc* linear_alloc) {
Mathieu Chartier91288d82016-04-28 09:44:54 -07002141 ClassLinker* const class_linker = GetClassLinker();
Andreas Gampecc1b5352016-12-01 16:58:38 -08002142 ArtMethod* method = CreateRuntimeMethod(class_linker, linear_alloc);
Jeff Hao88474b42013-10-23 16:24:40 -07002143 // When compiling, the code pointer will get set later when the image is loaded.
Andreas Gampe542451c2016-07-26 09:02:02 -07002144 const PointerSize pointer_size = GetInstructionSetPointerSize(instruction_set_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002145 if (IsAotCompiler()) {
Jeff Haoc7d11882015-02-03 15:08:39 -08002146 method->SetEntryPointFromQuickCompiledCodePtrSize(nullptr, pointer_size);
Ian Rogersef7d42f2014-01-06 12:55:46 -08002147 } else {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07002148 method->SetEntryPointFromQuickCompiledCode(GetQuickImtConflictStub());
Ian Rogersef7d42f2014-01-06 12:55:46 -08002149 }
Mathieu Chartier91288d82016-04-28 09:44:54 -07002150 // Create empty conflict table.
Andreas Gampe98ea9d92018-10-19 14:06:15 -07002151 method->SetImtConflictTable(class_linker->CreateImtConflictTable(/*count=*/0u, linear_alloc),
Mathieu Chartier91288d82016-04-28 09:44:54 -07002152 pointer_size);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002153 return method;
Jeff Hao88474b42013-10-23 16:24:40 -07002154}
2155
Mathieu Chartiere401d142015-04-22 13:56:20 -07002156void Runtime::SetImtConflictMethod(ArtMethod* method) {
2157 CHECK(method != nullptr);
2158 CHECK(method->IsRuntimeMethod());
2159 imt_conflict_method_ = method;
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002160}
2161
Mathieu Chartiere401d142015-04-22 13:56:20 -07002162ArtMethod* Runtime::CreateResolutionMethod() {
Andreas Gampecc1b5352016-12-01 16:58:38 -08002163 auto* method = CreateRuntimeMethod(GetClassLinker(), GetLinearAlloc());
Jeff Hao58df3272013-04-22 15:28:53 -07002164 // When compiling, the code pointer will get set later when the image is loaded.
Mathieu Chartiere401d142015-04-22 13:56:20 -07002165 if (IsAotCompiler()) {
Andreas Gampe542451c2016-07-26 09:02:02 -07002166 PointerSize pointer_size = GetInstructionSetPointerSize(instruction_set_);
Jeff Haoc7d11882015-02-03 15:08:39 -08002167 method->SetEntryPointFromQuickCompiledCodePtrSize(nullptr, pointer_size);
Ian Rogersef7d42f2014-01-06 12:55:46 -08002168 } else {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07002169 method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionStub());
Ian Rogersef7d42f2014-01-06 12:55:46 -08002170 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07002171 return method;
Ian Rogers19846512012-02-24 11:42:47 -08002172}
2173
Mathieu Chartiere401d142015-04-22 13:56:20 -07002174ArtMethod* Runtime::CreateCalleeSaveMethod() {
Andreas Gampecc1b5352016-12-01 16:58:38 -08002175 auto* method = CreateRuntimeMethod(GetClassLinker(), GetLinearAlloc());
Andreas Gampe542451c2016-07-26 09:02:02 -07002176 PointerSize pointer_size = GetInstructionSetPointerSize(instruction_set_);
Jeff Haoc7d11882015-02-03 15:08:39 -08002177 method->SetEntryPointFromQuickCompiledCodePtrSize(nullptr, pointer_size);
Vladimir Marko33bff252017-11-01 14:35:42 +00002178 DCHECK_NE(instruction_set_, InstructionSet::kNone);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002179 DCHECK(method->IsRuntimeMethod());
2180 return method;
Ian Rogersff1ed472011-09-20 13:46:24 -07002181}
2182
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002183void Runtime::DisallowNewSystemWeaks() {
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07002184 CHECK(!kUseReadBarrier);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002185 monitor_list_->DisallowNewMonitors();
Mathieu Chartier14c3bf92015-07-13 14:35:43 -07002186 intern_table_->ChangeWeakRootState(gc::kWeakRootStateNoReadsOrWrites);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002187 java_vm_->DisallowNewWeakGlobals();
Man Cao42c3c332015-06-23 16:38:25 -07002188 heap_->DisallowNewAllocationRecords();
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +00002189 if (GetJit() != nullptr) {
2190 GetJit()->GetCodeCache()->DisallowInlineCacheAccess();
2191 }
Andreas Gampefda57142016-09-08 20:29:18 -07002192
2193 // All other generic system-weak holders.
2194 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
2195 holder->Disallow();
2196 }
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002197}
2198
2199void Runtime::AllowNewSystemWeaks() {
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07002200 CHECK(!kUseReadBarrier);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002201 monitor_list_->AllowNewMonitors();
Mathieu Chartier90ef3db2015-08-04 15:19:41 -07002202 intern_table_->ChangeWeakRootState(gc::kWeakRootStateNormal); // TODO: Do this in the sweeping.
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002203 java_vm_->AllowNewWeakGlobals();
Man Cao42c3c332015-06-23 16:38:25 -07002204 heap_->AllowNewAllocationRecords();
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +00002205 if (GetJit() != nullptr) {
2206 GetJit()->GetCodeCache()->AllowInlineCacheAccess();
2207 }
Andreas Gampefda57142016-09-08 20:29:18 -07002208
2209 // All other generic system-weak holders.
2210 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
2211 holder->Allow();
2212 }
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002213}
2214
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07002215void Runtime::BroadcastForNewSystemWeaks(bool broadcast_for_checkpoint) {
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07002216 // This is used for the read barrier case that uses the thread-local
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07002217 // Thread::GetWeakRefAccessEnabled() flag and the checkpoint while weak ref access is disabled
2218 // (see ThreadList::RunCheckpoint).
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07002219 monitor_list_->BroadcastForNewMonitors();
2220 intern_table_->BroadcastForNewInterns();
2221 java_vm_->BroadcastForNewWeakGlobals();
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07002222 heap_->BroadcastForNewAllocationRecords();
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +00002223 if (GetJit() != nullptr) {
2224 GetJit()->GetCodeCache()->BroadcastForInlineCacheAccess();
2225 }
Andreas Gampefda57142016-09-08 20:29:18 -07002226
2227 // All other generic system-weak holders.
2228 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07002229 holder->Broadcast(broadcast_for_checkpoint);
Andreas Gampefda57142016-09-08 20:29:18 -07002230 }
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07002231}
2232
Vladimir Marko7624d252014-05-02 14:40:15 +01002233void Runtime::SetInstructionSet(InstructionSet instruction_set) {
2234 instruction_set_ = instruction_set;
Vladimir Markod3083dd2018-05-17 08:43:47 +01002235 switch (instruction_set) {
2236 case InstructionSet::kThumb2:
2237 // kThumb2 is the same as kArm, use the canonical value.
2238 instruction_set_ = InstructionSet::kArm;
2239 break;
2240 case InstructionSet::kArm:
2241 case InstructionSet::kArm64:
2242 case InstructionSet::kMips:
2243 case InstructionSet::kMips64:
2244 case InstructionSet::kX86:
2245 case InstructionSet::kX86_64:
2246 break;
2247 default:
2248 UNIMPLEMENTED(FATAL) << instruction_set_;
2249 UNREACHABLE();
Vladimir Marko7624d252014-05-02 14:40:15 +01002250 }
2251}
2252
Igor Murashkin8275fba2017-05-02 15:58:02 -07002253void Runtime::ClearInstructionSet() {
2254 instruction_set_ = InstructionSet::kNone;
2255}
2256
Mathieu Chartiere401d142015-04-22 13:56:20 -07002257void Runtime::SetCalleeSaveMethod(ArtMethod* method, CalleeSaveType type) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002258 DCHECK_LT(static_cast<uint32_t>(type), kCalleeSaveSize);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002259 CHECK(method != nullptr);
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002260 callee_save_methods_[static_cast<size_t>(type)] = reinterpret_cast<uintptr_t>(method);
Brian Carlstrome24fa612011-09-29 00:53:55 -07002261}
2262
Igor Murashkin8275fba2017-05-02 15:58:02 -07002263void Runtime::ClearCalleeSaveMethods() {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002264 for (size_t i = 0; i < kCalleeSaveSize; ++i) {
2265 callee_save_methods_[i] = reinterpret_cast<uintptr_t>(nullptr);
Igor Murashkin8275fba2017-05-02 15:58:02 -07002266 }
2267}
2268
Calin Juravle66f55232015-12-08 15:09:10 +00002269void Runtime::RegisterAppInfo(const std::vector<std::string>& code_paths,
Calin Juravle77651c42017-03-03 18:04:02 -08002270 const std::string& profile_output_filename) {
Calin Juravle5e2b9712015-12-18 14:10:00 +02002271 if (jit_.get() == nullptr) {
2272 // We are not JITing. Nothing to do.
2273 return;
Calin Juravle4d77b6a2015-12-01 18:38:09 +00002274 }
Calin Juravle5e2b9712015-12-18 14:10:00 +02002275
2276 VLOG(profiler) << "Register app with " << profile_output_filename
Andreas Gampe9186ced2016-12-12 14:28:21 -08002277 << " " << android::base::Join(code_paths, ':');
Calin Juravle5e2b9712015-12-18 14:10:00 +02002278
2279 if (profile_output_filename.empty()) {
2280 LOG(WARNING) << "JIT profile information will not be recorded: profile filename is empty.";
2281 return;
2282 }
Andreas Gampe98ea9d92018-10-19 14:06:15 -07002283 if (!OS::FileExists(profile_output_filename.c_str(), /*check_file_type=*/ false)) {
Calin Juravle5e2b9712015-12-18 14:10:00 +02002284 LOG(WARNING) << "JIT profile information will not be recorded: profile file does not exits.";
2285 return;
2286 }
2287 if (code_paths.empty()) {
2288 LOG(WARNING) << "JIT profile information will not be recorded: code paths is empty.";
2289 return;
2290 }
2291
Calin Juravle77651c42017-03-03 18:04:02 -08002292 jit_->StartProfileSaver(profile_output_filename, code_paths);
Dave Allison0aded082013-11-07 13:15:11 -08002293}
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002294
2295// Transaction support.
Chang Xing605fe242017-07-20 15:57:21 -07002296bool Runtime::IsActiveTransaction() const {
2297 return !preinitialization_transactions_.empty() && !GetTransaction()->IsRollingBack();
2298}
2299
Chang Xing16d1dd82017-07-20 17:56:26 -07002300void Runtime::EnterTransactionMode() {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002301 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002302 DCHECK(!IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002303 preinitialization_transactions_.push_back(std::make_unique<Transaction>());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002304}
2305
Chang Xing5a906fc2017-07-26 15:01:16 -07002306void Runtime::EnterTransactionMode(bool strict, mirror::Class* root) {
Chang Xingcade5c32017-07-20 17:56:26 -07002307 DCHECK(IsAotCompiler());
Chang Xing605fe242017-07-20 15:57:21 -07002308 preinitialization_transactions_.push_back(std::make_unique<Transaction>(strict, root));
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002309}
2310
2311void Runtime::ExitTransactionMode() {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002312 DCHECK(IsAotCompiler());
Chang Xing605fe242017-07-20 15:57:21 -07002313 DCHECK(IsActiveTransaction());
2314 preinitialization_transactions_.pop_back();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002315}
2316
Chang Xing16d1dd82017-07-20 17:56:26 -07002317void Runtime::RollbackAndExitTransactionMode() {
2318 DCHECK(IsAotCompiler());
2319 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002320 preinitialization_transactions_.back()->Rollback();
2321 preinitialization_transactions_.pop_back();
Chang Xing16d1dd82017-07-20 17:56:26 -07002322}
2323
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002324bool Runtime::IsTransactionAborted() const {
2325 if (!IsActiveTransaction()) {
2326 return false;
2327 } else {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002328 DCHECK(IsAotCompiler());
Chang Xing605fe242017-07-20 15:57:21 -07002329 return GetTransaction()->IsAborted();
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002330 }
2331}
2332
Chang Xing605fe242017-07-20 15:57:21 -07002333void Runtime::RollbackAllTransactions() {
2334 // If transaction is aborted, all transactions will be kept in the list.
2335 // Rollback and exit all of them.
2336 while (IsActiveTransaction()) {
2337 RollbackAndExitTransactionMode();
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002338 }
2339}
2340
Chang Xing5a906fc2017-07-26 15:01:16 -07002341bool Runtime::IsActiveStrictTransactionMode() const {
Chang Xing605fe242017-07-20 15:57:21 -07002342 return IsActiveTransaction() && GetTransaction()->IsStrict();
2343}
2344
2345const std::unique_ptr<Transaction>& Runtime::GetTransaction() const {
2346 DCHECK(!preinitialization_transactions_.empty());
2347 return preinitialization_transactions_.back();
Chang Xing5a906fc2017-07-26 15:01:16 -07002348}
2349
Sebastien Hertz2fd7e692015-04-02 11:11:19 +02002350void Runtime::AbortTransactionAndThrowAbortError(Thread* self, const std::string& abort_message) {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002351 DCHECK(IsAotCompiler());
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002352 DCHECK(IsActiveTransaction());
Sebastien Hertzbd9cf9f2015-03-03 12:16:13 +01002353 // Throwing an exception may cause its class initialization. If we mark the transaction
2354 // aborted before that, we may warn with a false alarm. Throwing the exception before
2355 // marking the transaction aborted avoids that.
Chang Xing605fe242017-07-20 15:57:21 -07002356 // But now the transaction can be nested, and abort the transaction will relax the constraints
2357 // for constructing stack trace.
2358 GetTransaction()->Abort(abort_message);
2359 GetTransaction()->ThrowAbortError(self, &abort_message);
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002360}
2361
Sebastien Hertz2fd7e692015-04-02 11:11:19 +02002362void Runtime::ThrowTransactionAbortError(Thread* self) {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002363 DCHECK(IsAotCompiler());
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002364 DCHECK(IsActiveTransaction());
Sebastien Hertzb81e1cd2015-04-28 12:31:41 +02002365 // Passing nullptr means we rethrow an exception with the earlier transaction abort message.
Chang Xing605fe242017-07-20 15:57:21 -07002366 GetTransaction()->ThrowAbortError(self, nullptr);
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002367}
2368
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002369void Runtime::RecordWriteFieldBoolean(mirror::Object* obj, MemberOffset field_offset,
2370 uint8_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002371 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002372 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002373 GetTransaction()->RecordWriteFieldBoolean(obj, field_offset, value, is_volatile);
Fred Shih37f05ef2014-07-16 18:38:08 -07002374}
2375
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002376void Runtime::RecordWriteFieldByte(mirror::Object* obj, MemberOffset field_offset,
2377 int8_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002378 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002379 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002380 GetTransaction()->RecordWriteFieldByte(obj, field_offset, value, is_volatile);
Fred Shih37f05ef2014-07-16 18:38:08 -07002381}
2382
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002383void Runtime::RecordWriteFieldChar(mirror::Object* obj, MemberOffset field_offset,
2384 uint16_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002385 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002386 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002387 GetTransaction()->RecordWriteFieldChar(obj, field_offset, value, is_volatile);
Fred Shih37f05ef2014-07-16 18:38:08 -07002388}
2389
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002390void Runtime::RecordWriteFieldShort(mirror::Object* obj, MemberOffset field_offset,
2391 int16_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002392 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002393 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002394 GetTransaction()->RecordWriteFieldShort(obj, field_offset, value, is_volatile);
Fred Shih37f05ef2014-07-16 18:38:08 -07002395}
2396
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002397void Runtime::RecordWriteField32(mirror::Object* obj, MemberOffset field_offset,
2398 uint32_t value, bool is_volatile) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002399 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002400 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002401 GetTransaction()->RecordWriteField32(obj, field_offset, value, is_volatile);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002402}
2403
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002404void Runtime::RecordWriteField64(mirror::Object* obj, MemberOffset field_offset,
2405 uint64_t value, bool is_volatile) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002406 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002407 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002408 GetTransaction()->RecordWriteField64(obj, field_offset, value, is_volatile);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002409}
2410
Mathieu Chartiera058fdf2016-10-06 15:13:58 -07002411void Runtime::RecordWriteFieldReference(mirror::Object* obj,
2412 MemberOffset field_offset,
2413 ObjPtr<mirror::Object> value,
2414 bool is_volatile) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002415 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002416 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002417 GetTransaction()->RecordWriteFieldReference(obj,
Mathieu Chartiera058fdf2016-10-06 15:13:58 -07002418 field_offset,
2419 value.Ptr(),
2420 is_volatile);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002421}
2422
2423void Runtime::RecordWriteArray(mirror::Array* array, size_t index, uint64_t value) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002424 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002425 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002426 GetTransaction()->RecordWriteArray(array, index, value);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002427}
2428
Mathieu Chartier9e868092016-10-31 14:58:04 -07002429void Runtime::RecordStrongStringInsertion(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002430 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002431 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002432 GetTransaction()->RecordStrongStringInsertion(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002433}
2434
Mathieu Chartier9e868092016-10-31 14:58:04 -07002435void Runtime::RecordWeakStringInsertion(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002436 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002437 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002438 GetTransaction()->RecordWeakStringInsertion(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002439}
2440
Mathieu Chartier9e868092016-10-31 14:58:04 -07002441void Runtime::RecordStrongStringRemoval(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002442 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002443 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002444 GetTransaction()->RecordStrongStringRemoval(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002445}
2446
Mathieu Chartier9e868092016-10-31 14:58:04 -07002447void Runtime::RecordWeakStringRemoval(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002448 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002449 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002450 GetTransaction()->RecordWeakStringRemoval(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002451}
Mathieu Chartier15d34022014-02-26 17:16:38 -08002452
Andreas Gampe8a0128a2016-11-28 07:38:35 -08002453void Runtime::RecordResolveString(ObjPtr<mirror::DexCache> dex_cache,
2454 dex::StringIndex string_idx) const {
Mathieu Chartierbb816d62016-09-07 10:17:46 -07002455 DCHECK(IsAotCompiler());
2456 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002457 GetTransaction()->RecordResolveString(dex_cache, string_idx);
Mathieu Chartierbb816d62016-09-07 10:17:46 -07002458}
2459
Mathieu Chartier15d34022014-02-26 17:16:38 -08002460void Runtime::SetFaultMessage(const std::string& message) {
Andreas Gampe44f67602018-11-28 08:27:27 -08002461 std::string* new_msg = new std::string(message);
2462 std::string* cur_msg = fault_message_.exchange(new_msg);
2463 delete cur_msg;
2464}
2465
2466std::string Runtime::GetFaultMessage() {
2467 // Retrieve the message. Temporarily replace with null so that SetFaultMessage will not delete
2468 // the string in parallel.
2469 std::string* cur_msg = fault_message_.exchange(nullptr);
2470
2471 // Make a copy of the string.
2472 std::string ret = cur_msg == nullptr ? "" : *cur_msg;
2473
2474 // Put the message back if it hasn't been updated.
2475 std::string* null_str = nullptr;
2476 if (!fault_message_.compare_exchange_strong(null_str, cur_msg)) {
2477 // Already replaced.
2478 delete cur_msg;
2479 }
2480
2481 return ret;
Mathieu Chartier15d34022014-02-26 17:16:38 -08002482}
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08002483
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002484void Runtime::AddCurrentRuntimeFeaturesAsDex2OatArguments(std::vector<std::string>* argv)
Ian Rogers8afeb852014-04-02 14:55:49 -07002485 const {
Nicolas Geoffrayc6b1b932016-03-22 09:52:40 +00002486 if (GetInstrumentation()->InterpretOnly()) {
Nicolas Geoffray49cda062017-04-21 13:08:25 +01002487 argv->push_back("--compiler-filter=quicken");
Ian Rogers9bc54402014-04-17 16:40:01 -07002488 }
2489
Ian Rogers8afeb852014-04-02 14:55:49 -07002490 // Make the dex2oat instruction set match that of the launching runtime. If we have multiple
2491 // architecture support, dex2oat may be compiled as a different instruction-set than that
2492 // currently being executed.
Ian Rogersb9beb2e2014-05-09 16:57:40 -07002493 std::string instruction_set("--instruction-set=");
2494 instruction_set += GetInstructionSetString(kRuntimeISA);
2495 argv->push_back(instruction_set);
Ian Rogers8afeb852014-04-02 14:55:49 -07002496
xueliang.zhong7f88c1a2018-11-06 11:42:41 +00002497 if (InstructionSetFeatures::IsRuntimeDetectionSupported()) {
2498 argv->push_back("--instruction-set-features=runtime");
2499 } else {
2500 std::unique_ptr<const InstructionSetFeatures> features(
2501 InstructionSetFeatures::FromCppDefines());
2502 std::string feature_string("--instruction-set-features=");
2503 feature_string += features->GetFeatureString();
2504 argv->push_back(feature_string);
2505 }
Ian Rogers8afeb852014-04-02 14:55:49 -07002506}
2507
Orion Hodsonad28f5e2018-10-17 09:08:17 +01002508void Runtime::CreateJitCodeCache(bool rwx_memory_allowed) {
Calin Juravleaf36e492016-04-27 18:50:45 +01002509 if (kIsDebugBuild && GetInstrumentation()->IsForcedInterpretOnly()) {
2510 DCHECK(!jit_options_->UseJitCompilation());
Hiroshi Yamauchi02d2f292015-04-03 13:35:16 -07002511 }
Orion Hodsonad28f5e2018-10-17 09:08:17 +01002512
Andreas Gampe83e20492018-11-07 11:12:26 -08002513 if (!jit_options_->UseJitCompilation() && !jit_options_->GetSaveProfilingInfo()) {
Calin Juravle9545f6d2017-03-16 19:05:09 -07002514 return;
2515 }
Orion Hodsonad28f5e2018-10-17 09:08:17 +01002516
Orion Hodsonad28f5e2018-10-17 09:08:17 +01002517 std::string error_msg;
2518 bool profiling_only = !jit_options_->UseJitCompilation();
Nicolas Geoffray7a2c7c22018-11-20 10:03:13 +00002519 jit_code_cache_.reset(jit::JitCodeCache::Create(profiling_only,
2520 rwx_memory_allowed,
2521 IsZygote(),
Orion Hodsonad28f5e2018-10-17 09:08:17 +01002522 &error_msg));
2523 if (jit_code_cache_.get() == nullptr) {
2524 LOG(WARNING) << "Failed to create JIT Code Cache: " << error_msg;
2525 }
2526}
2527
2528void Runtime::CreateJit() {
Andreas Gampe83e20492018-11-07 11:12:26 -08002529 DCHECK(jit_ == nullptr);
Orion Hodsonad28f5e2018-10-17 09:08:17 +01002530 if (jit_code_cache_.get() == nullptr) {
Andreas Gampe83e20492018-11-07 11:12:26 -08002531 if (!IsSafeMode()) {
2532 LOG(WARNING) << "Missing code cache, cannot create JIT.";
2533 }
2534 return;
2535 }
2536 if (IsSafeMode()) {
2537 LOG(INFO) << "Not creating JIT because of SafeMode.";
2538 jit_code_cache_.reset();
Orion Hodsonad28f5e2018-10-17 09:08:17 +01002539 return;
2540 }
2541
2542 jit::Jit* jit = jit::Jit::Create(jit_code_cache_.get(), jit_options_.get());
2543 DoAndMaybeSwitchInterpreter([=](){ jit_.reset(jit); });
2544 if (jit == nullptr) {
2545 LOG(WARNING) << "Failed to allocate JIT";
2546 // Release JIT code cache resources (several MB of memory).
Andreas Gampe83e20492018-11-07 11:12:26 -08002547 jit_code_cache_.reset();
Nicolas Geoffrayce9ed362018-11-29 03:19:28 +00002548 } else {
2549 jit->CreateThreadPool();
Orion Hodsonad28f5e2018-10-17 09:08:17 +01002550 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002551}
2552
Andreas Gampe4585f872015-03-27 23:45:15 -07002553bool Runtime::CanRelocate() const {
Vladimir Marko4df2d802018-09-27 16:42:44 +00002554 return !IsAotCompiler();
Andreas Gampe4585f872015-03-27 23:45:15 -07002555}
2556
2557bool Runtime::IsCompilingBootImage() const {
2558 return IsCompiler() && compiler_callbacks_->IsBootImage();
2559}
2560
Mathieu Chartiere401d142015-04-22 13:56:20 -07002561void Runtime::SetResolutionMethod(ArtMethod* method) {
2562 CHECK(method != nullptr);
2563 CHECK(method->IsRuntimeMethod()) << method;
2564 resolution_method_ = method;
2565}
2566
2567void Runtime::SetImtUnimplementedMethod(ArtMethod* method) {
2568 CHECK(method != nullptr);
2569 CHECK(method->IsRuntimeMethod());
2570 imt_unimplemented_method_ = method;
Mathieu Chartier91288d82016-04-28 09:44:54 -07002571}
2572
2573void Runtime::FixupConflictTables() {
2574 // We can only do this after the class linker is created.
Andreas Gampe542451c2016-07-26 09:02:02 -07002575 const PointerSize pointer_size = GetClassLinker()->GetImagePointerSize();
Mathieu Chartier91288d82016-04-28 09:44:54 -07002576 if (imt_unimplemented_method_->GetImtConflictTable(pointer_size) == nullptr) {
2577 imt_unimplemented_method_->SetImtConflictTable(
Andreas Gampe98ea9d92018-10-19 14:06:15 -07002578 ClassLinker::CreateImtConflictTable(/*count=*/0u, GetLinearAlloc(), pointer_size),
Mathieu Chartier91288d82016-04-28 09:44:54 -07002579 pointer_size);
2580 }
2581 if (imt_conflict_method_->GetImtConflictTable(pointer_size) == nullptr) {
2582 imt_conflict_method_->SetImtConflictTable(
Andreas Gampe98ea9d92018-10-19 14:06:15 -07002583 ClassLinker::CreateImtConflictTable(/*count=*/0u, GetLinearAlloc(), pointer_size),
Mathieu Chartier91288d82016-04-28 09:44:54 -07002584 pointer_size);
Nicolas Geoffray40c68c62016-03-23 16:35:51 +00002585 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07002586}
2587
Nicolas Geoffray68bf3902017-09-07 14:40:48 +01002588void Runtime::DisableVerifier() {
2589 verify_ = verifier::VerifyMode::kNone;
2590}
2591
Igor Murashkin7617abd2015-07-10 18:27:47 -07002592bool Runtime::IsVerificationEnabled() const {
Igor Murashkindf707e42016-02-02 16:56:50 -08002593 return verify_ == verifier::VerifyMode::kEnable ||
2594 verify_ == verifier::VerifyMode::kSoftFail;
Igor Murashkin7617abd2015-07-10 18:27:47 -07002595}
2596
2597bool Runtime::IsVerificationSoftFail() const {
2598 return verify_ == verifier::VerifyMode::kSoftFail;
2599}
2600
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002601bool Runtime::IsAsyncDeoptimizeable(uintptr_t code) const {
2602 // We only support async deopt (ie the compiled code is not explicitly asking for
2603 // deopt, but something else like the debugger) in debuggable JIT code.
2604 // We could look at the oat file where `code` is being defined,
2605 // and check whether it's been compiled debuggable, but we decided to
2606 // only rely on the JIT for debuggable apps.
2607 return IsJavaDebuggable() &&
2608 GetJit() != nullptr &&
2609 GetJit()->GetCodeCache()->ContainsPc(reinterpret_cast<const void*>(code));
Mingyao Yangf711f2c2016-05-23 12:29:39 -07002610}
2611
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07002612LinearAlloc* Runtime::CreateLinearAlloc() {
Mathieu Chartierc3fcd412015-09-25 16:54:59 -07002613 // For 64 bit compilers, it needs to be in low 4GB in the case where we are cross compiling for a
2614 // 32 bit target. In this case, we have 32 bit pointers in the dex cache arrays which can't hold
2615 // when we have 64 bit ArtMethod pointers.
Mathieu Chartier017ed0b2015-09-22 11:04:26 -07002616 return (IsAotCompiler() && Is64BitInstructionSet(kRuntimeISA))
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07002617 ? new LinearAlloc(low_4gb_arena_pool_.get())
2618 : new LinearAlloc(arena_pool_.get());
2619}
2620
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -07002621double Runtime::GetHashTableMinLoadFactor() const {
2622 return is_low_memory_mode_ ? kLowMemoryMinLoadFactor : kNormalMinLoadFactor;
2623}
2624
2625double Runtime::GetHashTableMaxLoadFactor() const {
2626 return is_low_memory_mode_ ? kLowMemoryMaxLoadFactor : kNormalMaxLoadFactor;
2627}
2628
Mathieu Chartierf8cb1782016-03-18 18:45:41 -07002629void Runtime::UpdateProcessState(ProcessState process_state) {
2630 ProcessState old_process_state = process_state_;
2631 process_state_ = process_state;
2632 GetHeap()->UpdateProcessState(old_process_state, process_state);
2633}
2634
Calin Juravle97cbc922016-04-15 16:16:35 +01002635void Runtime::RegisterSensitiveThread() const {
2636 Thread::SetJitSensitiveThread();
2637}
2638
Calin Juravleffc87072016-04-20 14:22:09 +01002639// Returns true if JIT compilations are enabled. GetJit() will be not null in this case.
2640bool Runtime::UseJitCompilation() const {
2641 return (jit_ != nullptr) && jit_->UseJitCompilation();
2642}
2643
David Sehrd106d9f2016-08-16 19:22:57 -07002644void Runtime::EnvSnapshot::TakeSnapshot() {
2645 char** env = GetEnviron();
2646 for (size_t i = 0; env[i] != nullptr; ++i) {
2647 name_value_pairs_.emplace_back(new std::string(env[i]));
2648 }
2649 // The strings in name_value_pairs_ retain ownership of the c_str, but we assign pointers
2650 // for quick use by GetSnapshot. This avoids allocation and copying cost at Exec.
2651 c_env_vector_.reset(new char*[name_value_pairs_.size() + 1]);
2652 for (size_t i = 0; env[i] != nullptr; ++i) {
2653 c_env_vector_[i] = const_cast<char*>(name_value_pairs_[i]->c_str());
2654 }
2655 c_env_vector_[name_value_pairs_.size()] = nullptr;
2656}
2657
2658char** Runtime::EnvSnapshot::GetSnapshot() const {
2659 return c_env_vector_.get();
2660}
2661
Andreas Gampefda57142016-09-08 20:29:18 -07002662void Runtime::AddSystemWeakHolder(gc::AbstractSystemWeakHolder* holder) {
2663 gc::ScopedGCCriticalSection gcs(Thread::Current(),
2664 gc::kGcCauseAddRemoveSystemWeakHolder,
2665 gc::kCollectorTypeAddRemoveSystemWeakHolder);
Andreas Gampe1f648592017-01-13 10:46:01 -08002666 // Note: The ScopedGCCriticalSection also ensures that the rest of the function is in
2667 // a critical section.
Andreas Gampefda57142016-09-08 20:29:18 -07002668 system_weak_holders_.push_back(holder);
2669}
2670
2671void Runtime::RemoveSystemWeakHolder(gc::AbstractSystemWeakHolder* holder) {
2672 gc::ScopedGCCriticalSection gcs(Thread::Current(),
2673 gc::kGcCauseAddRemoveSystemWeakHolder,
2674 gc::kCollectorTypeAddRemoveSystemWeakHolder);
2675 auto it = std::find(system_weak_holders_.begin(), system_weak_holders_.end(), holder);
2676 if (it != system_weak_holders_.end()) {
2677 system_weak_holders_.erase(it);
2678 }
2679}
2680
Andreas Gampeac30fa22017-01-18 21:02:36 -08002681RuntimeCallbacks* Runtime::GetRuntimeCallbacks() {
2682 return callbacks_.get();
2683}
2684
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002685// Used to patch boot image method entry point to interpreter bridge.
2686class UpdateEntryPointsClassVisitor : public ClassVisitor {
2687 public:
2688 explicit UpdateEntryPointsClassVisitor(instrumentation::Instrumentation* instrumentation)
2689 : instrumentation_(instrumentation) {}
2690
Roland Levillainbbc6e7e2018-08-24 16:58:47 +01002691 bool operator()(ObjPtr<mirror::Class> klass) override REQUIRES(Locks::mutator_lock_) {
Nicolas Geoffray226805d2018-12-14 10:59:02 +00002692 DCHECK(Locks::mutator_lock_->IsExclusiveHeld(Thread::Current()));
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002693 auto pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
2694 for (auto& m : klass->GetMethods(pointer_size)) {
2695 const void* code = m.GetEntryPointFromQuickCompiledCode();
2696 if (Runtime::Current()->GetHeap()->IsInBootImageOatFile(code) &&
2697 !m.IsNative() &&
2698 !m.IsProxyMethod()) {
2699 instrumentation_->UpdateMethodsCodeForJavaDebuggable(&m, GetQuickToInterpreterBridge());
2700 }
2701 }
2702 return true;
2703 }
2704
2705 private:
2706 instrumentation::Instrumentation* const instrumentation_;
2707};
2708
2709void Runtime::SetJavaDebuggable(bool value) {
2710 is_java_debuggable_ = value;
2711 // Do not call DeoptimizeBootImage just yet, the runtime may still be starting up.
2712}
2713
2714void Runtime::DeoptimizeBootImage() {
2715 // If we've already started and we are setting this runtime to debuggable,
2716 // we patch entry points of methods in boot image to interpreter bridge, as
2717 // boot image code may be AOT compiled as not debuggable.
2718 if (!GetInstrumentation()->IsForcedInterpretOnly()) {
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002719 UpdateEntryPointsClassVisitor visitor(GetInstrumentation());
2720 GetClassLinker()->VisitClasses(&visitor);
Nicolas Geoffray226805d2018-12-14 10:59:02 +00002721 jit::Jit* jit = GetJit();
2722 if (jit != nullptr) {
2723 // Code JITted by the zygote is not compiled debuggable.
2724 jit->GetCodeCache()->ClearEntryPointsInZygoteExecSpace();
2725 }
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002726 }
2727}
Mathieu Chartierada33d72018-12-17 13:17:30 -08002728
2729Runtime::ScopedThreadPoolUsage::ScopedThreadPoolUsage()
2730 : thread_pool_(Runtime::Current()->AcquireThreadPool()) {}
2731
2732Runtime::ScopedThreadPoolUsage::~ScopedThreadPoolUsage() {
2733 Runtime::Current()->ReleaseThreadPool();
2734}
2735
2736bool Runtime::DeleteThreadPool() {
2737 // Make sure workers are started to prevent thread shutdown errors.
2738 WaitForThreadPoolWorkersToStart();
2739 std::unique_ptr<ThreadPool> thread_pool;
2740 {
2741 MutexLock mu(Thread::Current(), *Locks::runtime_thread_pool_lock_);
2742 if (thread_pool_ref_count_ == 0) {
2743 thread_pool = std::move(thread_pool_);
2744 }
2745 }
2746 return thread_pool != nullptr;
2747}
2748
2749ThreadPool* Runtime::AcquireThreadPool() {
2750 MutexLock mu(Thread::Current(), *Locks::runtime_thread_pool_lock_);
2751 ++thread_pool_ref_count_;
2752 return thread_pool_.get();
2753}
2754
2755void Runtime::ReleaseThreadPool() {
2756 MutexLock mu(Thread::Current(), *Locks::runtime_thread_pool_lock_);
2757 CHECK_GT(thread_pool_ref_count_, 0u);
2758 --thread_pool_ref_count_;
2759}
2760
2761void Runtime::WaitForThreadPoolWorkersToStart() {
2762 // Need to make sure workers are created before deleting the pool.
2763 ScopedThreadPoolUsage stpu;
2764 if (stpu.GetThreadPool() != nullptr) {
2765 stpu.GetThreadPool()->WaitForWorkersToBeCreated();
2766 }
2767}
2768
Carl Shapiro1fb86202011-06-27 17:43:13 -07002769} // namespace art