blob: f86b7a054eca7b2f8361de3d3e01bcc9add698b0 [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>
Carl Shapiro2ed144c2011-07-26 16:52:08 -070037#include <vector>
Elliott Hughesffe67362011-07-17 12:09:27 -070038
Andreas Gampe9186ced2016-12-12 14:28:21 -080039#include "android-base/strings.h"
40
Chang Xing605fe242017-07-20 15:57:21 -070041#include "aot_class_linker.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010042#include "arch/arm/quick_method_frame_info_arm.h"
Ian Rogers166db042013-07-26 12:05:57 -070043#include "arch/arm/registers_arm.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010044#include "arch/arm64/quick_method_frame_info_arm64.h"
Stuart Monteithb95a5342014-03-12 13:32:32 +000045#include "arch/arm64/registers_arm64.h"
Ian Rogersd582fa42014-11-05 23:46:43 -080046#include "arch/instruction_set_features.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010047#include "arch/mips/quick_method_frame_info_mips.h"
Ian Rogers166db042013-07-26 12:05:57 -070048#include "arch/mips/registers_mips.h"
Andreas Gampe57b34292015-01-14 15:45:59 -080049#include "arch/mips64/quick_method_frame_info_mips64.h"
50#include "arch/mips64/registers_mips64.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010051#include "arch/x86/quick_method_frame_info_x86.h"
Ian Rogers166db042013-07-26 12:05:57 -070052#include "arch/x86/registers_x86.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010053#include "arch/x86_64/quick_method_frame_info_x86_64.h"
Ian Rogersef7d42f2014-01-06 12:55:46 -080054#include "arch/x86_64/registers_x86_64.h"
Mathieu Chartierc7853442015-03-27 14:35:38 -070055#include "art_field-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070056#include "art_method-inl.h"
Ian Rogers1d8cdbc2014-09-22 22:51:09 -070057#include "asm_support.h"
Andreas Gampeb2d18fa2017-06-06 20:46:10 -070058#include "asm_support_check.h"
Andreas Gampe39b378c2017-12-07 15:44:13 -080059#include "base/aborting.h"
Andreas Gampe4585f872015-03-27 23:45:15 -070060#include "base/arena_allocator.h"
David Sehrc431b9d2018-03-02 12:01:51 -080061#include "base/atomic.h"
Ian Rogersc7dd2952014-10-21 23:31:19 -070062#include "base/dumpable.h"
Andreas Gampe542451c2016-07-26 09:02:02 -070063#include "base/enums.h"
David Sehr891a50e2017-10-27 17:01:07 -070064#include "base/file_utils.h"
David Sehr3215fff2018-04-03 17:10:12 -070065#include "base/malloc_arena_pool.h"
66#include "base/mem_map_arena_pool.h"
Andreas Gampe8cf9cb32017-07-19 09:28:38 -070067#include "base/memory_tool.h"
David Sehrc431b9d2018-03-02 12:01:51 -080068#include "base/mutex.h"
69#include "base/os.h"
70#include "base/quasi_atomic.h"
Vladimir Marko637ee0b2015-09-04 12:47:41 +010071#include "base/stl_util.h"
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -080072#include "base/systrace.h"
Ian Rogers1d8cdbc2014-09-22 22:51:09 -070073#include "base/unix_file/fd_file.h"
David Sehrc431b9d2018-03-02 12:01:51 -080074#include "base/utils.h"
Vladimir Marko3481ba22015-04-13 12:22:36 +010075#include "class_linker-inl.h"
Andreas Gampe4585f872015-03-27 23:45:15 -070076#include "compiler_callbacks.h"
Elliott Hughes3bb81562011-10-21 18:52:59 -070077#include "debugger.h"
David Sehr013fd802018-01-11 22:55:24 -080078#include "dex/art_dex_file_loader.h"
David Sehr9e734c72018-01-04 17:56:19 -080079#include "dex/dex_file_loader.h"
Alex Light84d76052014-08-22 17:49:35 -070080#include "elf_file.h"
Ian Rogers6f3dbba2014-10-14 17:41:57 -070081#include "entrypoints/runtime_asm_entrypoints.h"
Alex Lighteb7c1442015-08-31 13:17:42 -070082#include "experimental_flags.h"
Ian Rogers576ca0c2014-06-06 15:58:22 -070083#include "fault_handler.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070084#include "gc/accounting/card_table-inl.h"
85#include "gc/heap.h"
Andreas Gampefda57142016-09-08 20:29:18 -070086#include "gc/scoped_gc_critical_section.h"
Ian Rogerse63db272014-07-15 15:36:11 -070087#include "gc/space/image_space.h"
Mathieu Chartier461687d2015-03-31 12:05:24 -070088#include "gc/space/space-inl.h"
Andreas Gampefda57142016-09-08 20:29:18 -070089#include "gc/system_weak.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -080090#include "handle_scope-inl.h"
Andreas Gampeaa120012018-03-28 16:23:24 -070091#include "hidden_api.h"
Mathieu Chartier4a26f172016-01-26 14:26:18 -080092#include "image-inl.h"
jeffhao725a9572012-11-13 18:20:12 -080093#include "instrumentation.h"
Elliott Hughescf4c6c42011-09-01 15:16:42 -070094#include "intern_table.h"
Mathieu Chartiere5f13e52015-02-24 09:37:21 -080095#include "interpreter/interpreter.h"
96#include "jit/jit.h"
Nicolas Geoffray132d8362016-11-16 09:19:42 +000097#include "jit/jit_code_cache.h"
Steven Morelande431e272017-07-18 16:53:49 -070098#include "jit/profile_saver.h"
Vladimir Markoa3ad0cd2018-05-04 10:06:38 +010099#include "jni/java_vm_ext.h"
100#include "jni/jni_internal.h"
Mathieu Chartierc7853442015-03-27 14:35:38 -0700101#include "linear_alloc.h"
Andreas Gampe8cf9cb32017-07-19 09:28:38 -0700102#include "memory_representation.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800103#include "mirror/array.h"
Ian Rogers62d6c772013-02-27 08:32:07 -0800104#include "mirror/class-inl.h"
Alex Lightcec2fd42016-11-02 16:32:07 -0700105#include "mirror/class_ext.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800106#include "mirror/class_loader.h"
Narayan Kamath000e1882016-10-24 17:14:25 +0100107#include "mirror/emulated_stack_frame.h"
Mathieu Chartierdaaf3262015-03-24 13:30:28 -0700108#include "mirror/field.h"
Mathieu Chartierfc58af42015-04-16 18:00:39 -0700109#include "mirror/method.h"
Narayan Kamathafa48272016-08-03 12:46:58 +0100110#include "mirror/method_handle_impl.h"
Orion Hodsonc069a302017-01-18 09:23:12 +0000111#include "mirror/method_handles_lookup.h"
Narayan Kamathafa48272016-08-03 12:46:58 +0100112#include "mirror/method_type.h"
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800113#include "mirror/stack_trace_element.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800114#include "mirror/throwable.h"
Orion Hodson928033d2018-02-07 05:30:54 +0000115#include "mirror/var_handle.h"
Elliott Hughes32d6e1e2011-10-11 14:47:44 -0700116#include "monitor.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800117#include "native/dalvik_system_DexFile.h"
118#include "native/dalvik_system_VMDebug.h"
119#include "native/dalvik_system_VMRuntime.h"
120#include "native/dalvik_system_VMStack.h"
121#include "native/dalvik_system_ZygoteHooks.h"
122#include "native/java_lang_Class.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800123#include "native/java_lang_Object.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800124#include "native/java_lang_String.h"
Jeff Hao848f70a2014-01-15 13:49:50 -0800125#include "native/java_lang_StringFactory.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800126#include "native/java_lang_System.h"
127#include "native/java_lang_Thread.h"
128#include "native/java_lang_Throwable.h"
129#include "native/java_lang_VMClassLoader.h"
Narayan Kamathbd2fed52017-01-25 10:46:54 +0000130#include "native/java_lang_invoke_MethodHandleImpl.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800131#include "native/java_lang_ref_FinalizerReference.h"
132#include "native/java_lang_ref_Reference.h"
133#include "native/java_lang_reflect_Array.h"
134#include "native/java_lang_reflect_Constructor.h"
Neil Fuller0e844392016-09-08 13:43:31 +0100135#include "native/java_lang_reflect_Executable.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800136#include "native/java_lang_reflect_Field.h"
137#include "native/java_lang_reflect_Method.h"
Neil Fuller60458a02016-09-01 15:32:44 +0100138#include "native/java_lang_reflect_Parameter.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800139#include "native/java_lang_reflect_Proxy.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800140#include "native/java_util_concurrent_atomic_AtomicLong.h"
Jeff Hao848f70a2014-01-15 13:49:50 -0800141#include "native/libcore_util_CharsetUtils.h"
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800142#include "native/org_apache_harmony_dalvik_ddmc_DdmServer.h"
143#include "native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.h"
144#include "native/sun_misc_Unsafe.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800145#include "native_bridge_art_interface.h"
Andreas Gampe5dd44d02016-08-02 17:20:03 -0700146#include "native_stack_dump.h"
Andreas Gampe373a9b52017-10-18 09:01:57 -0700147#include "nativehelper/scoped_local_ref.h"
Brian Carlstrome24fa612011-09-29 00:53:55 -0700148#include "oat_file.h"
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -0700149#include "oat_file_manager.h"
Andreas Gamped482e732017-04-24 17:59:09 -0700150#include "object_callbacks.h"
Brian Carlstrom02c5f4d2015-01-30 10:18:03 -0800151#include "parsed_options.h"
Vladimir Marko7624d252014-05-02 14:40:15 +0100152#include "quick/quick_method_frame_info.h"
Ian Rogers53b8b092014-03-13 23:45:53 -0700153#include "reflection.h"
Andreas Gampeac30fa22017-01-18 21:02:36 -0800154#include "runtime_callbacks.h"
Orion Hodson26ef34c2017-11-01 13:32:41 +0000155#include "runtime_intrinsics.h"
Igor Murashkinaaebaa02015-01-26 10:55:53 -0800156#include "runtime_options.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -0700157#include "scoped_thread_state_change-inl.h"
Dave Allisoncefcea82014-09-16 10:01:01 -0700158#include "sigchain.h"
Elliott Hughese27955c2011-08-26 15:21:24 -0700159#include "signal_catcher.h"
Elliott Hughes457005c2012-04-16 13:54:25 -0700160#include "signal_set.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -0700161#include "thread.h"
Elliott Hughes8daa0922011-09-11 13:46:25 -0700162#include "thread_list.h"
Alex Light7233c7e2016-07-28 10:07:45 -0700163#include "ti/agent.h"
jeffhaob5e81852012-03-12 11:15:45 -0700164#include "trace.h"
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100165#include "transaction.h"
Vladimir Marko97d7e1c2016-10-04 14:44:28 +0100166#include "vdex_file.h"
Ian Rogers776ac1f2012-04-13 23:36:36 -0700167#include "verifier/method_verifier.h"
Elliott Hugheseac76672012-05-24 21:56:51 -0700168#include "well_known_classes.h"
Carl Shapiro61e019d2011-07-14 16:53:09 -0700169
David Sehrf57589f2016-10-17 10:09:33 -0700170#ifdef ART_TARGET_ANDROID
171#include <android/set_abort_message.h>
172#endif
173
Carl Shapiro1fb86202011-06-27 17:43:13 -0700174namespace art {
175
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700176// If a signal isn't handled properly, enable a handler that attempts to dump the Java stack.
Brian Carlstromb57f1c72014-10-08 13:56:25 -0700177static constexpr bool kEnableJavaStackTraceHandler = false;
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -0700178// Tuned by compiling GmsCore under perf and measuring time spent in DescriptorEquals for class
179// linking.
180static constexpr double kLowMemoryMinLoadFactor = 0.5;
181static constexpr double kLowMemoryMaxLoadFactor = 0.8;
182static constexpr double kNormalMinLoadFactor = 0.4;
183static constexpr double kNormalMaxLoadFactor = 0.7;
Mathieu Chartier11c273d2017-10-15 20:54:45 -0700184
185// Extra added to the default heap growth multiplier. Used to adjust the GC ergonomics for the read
186// barrier config.
187static constexpr double kExtraDefaultHeapGrowthMultiplier = kUseReadBarrier ? 1.0 : 0.0;
188
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700189Runtime* Runtime::instance_ = nullptr;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700190
Andreas Gampef6a780a2015-04-02 18:51:05 -0700191struct TraceConfig {
192 Trace::TraceMode trace_mode;
193 Trace::TraceOutputMode trace_output_mode;
194 std::string trace_file;
195 size_t trace_file_size;
196};
197
David Sehrd106d9f2016-08-16 19:22:57 -0700198namespace {
199#ifdef __APPLE__
200inline char** GetEnviron() {
201 // When Google Test is built as a framework on MacOS X, the environ variable
202 // is unavailable. Apple's documentation (man environ) recommends using
203 // _NSGetEnviron() instead.
204 return *_NSGetEnviron();
205}
206#else
207// Some POSIX platforms expect you to declare environ. extern "C" makes
208// it reside in the global namespace.
209extern "C" char** environ;
210inline char** GetEnviron() { return environ; }
211#endif
212} // namespace
213
Elliott Hughesdcc24742011-09-07 14:02:44 -0700214Runtime::Runtime()
Mathieu Chartier31000802015-06-14 14:14:37 -0700215 : resolution_method_(nullptr),
216 imt_conflict_method_(nullptr),
217 imt_unimplemented_method_(nullptr),
Vladimir Marko33bff252017-11-01 14:35:42 +0000218 instruction_set_(InstructionSet::kNone),
Ian Rogers6ed19fd2014-03-20 08:10:17 -0700219 compiler_callbacks_(nullptr),
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800220 is_zygote_(false),
Alex Lighta59dd802014-07-02 16:28:08 -0700221 must_relocate_(false),
Mathieu Chartier069387a2012-06-18 12:01:01 -0700222 is_concurrent_gc_enabled_(true),
Anwar Ghuloum87183592013-08-14 12:12:19 -0700223 is_explicit_gc_disabled_(false),
Nicolas Geoffray4fcdc942014-07-22 10:48:00 +0100224 dex2oat_enabled_(true),
Alex Light64ad14d2014-08-19 14:23:13 -0700225 image_dex2oat_enabled_(true),
Elliott Hughes6cf23882012-06-15 15:42:07 -0700226 default_stack_size_(0),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800227 heap_(nullptr),
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700228 max_spins_before_thin_lock_inflation_(Monitor::kDefaultMaxSpinsBeforeThinLockInflation),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800229 monitor_list_(nullptr),
230 monitor_pool_(nullptr),
231 thread_list_(nullptr),
232 intern_table_(nullptr),
233 class_linker_(nullptr),
234 signal_catcher_(nullptr),
235 java_vm_(nullptr),
Mathieu Chartier15d34022014-02-26 17:16:38 -0800236 fault_message_lock_("Fault message lock"),
237 fault_message_(""),
Ian Rogers120f1c72012-09-28 17:17:10 -0700238 threads_being_born_(0),
Ian Rogersc604d732012-10-14 16:09:54 -0700239 shutdown_cond_(new ConditionVariable("Runtime shutdown", *Locks::runtime_shutdown_lock_)),
Elliott Hughes6b355752012-01-13 16:49:08 -0800240 shutting_down_(false),
Ian Rogers120f1c72012-09-28 17:17:10 -0700241 shutting_down_started_(false),
Elliott Hughesdcc24742011-09-07 14:02:44 -0700242 started_(false),
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700243 finished_starting_(false),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800244 vfprintf_(nullptr),
245 exit_(nullptr),
246 abort_(nullptr),
jeffhao2692b572011-12-16 15:42:28 -0800247 stats_enabled_(false),
Evgenii Stepanov1e133742015-05-20 12:30:59 -0700248 is_running_on_memory_tool_(RUNNING_ON_MEMORY_TOOL),
Ian Rogers62d6c772013-02-27 08:32:07 -0800249 instrumentation_(),
Ian Rogersef7d42f2014-01-06 12:55:46 -0800250 main_thread_group_(nullptr),
251 system_thread_group_(nullptr),
252 system_class_loader_(nullptr),
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100253 dump_gc_performance_on_shutdown_(false),
Chang Xing605fe242017-07-20 15:57:21 -0700254 preinitialization_transactions_(),
Igor Murashkin7617abd2015-07-10 18:27:47 -0700255 verify_(verifier::VerifyMode::kNone),
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700256 allow_dex_file_fallback_(true),
David Brazdila7db0262018-01-16 17:13:35 +0000257 target_sdk_version_(kUnsetSdkVersion),
Dave Allison69dfe512014-07-11 17:11:58 +0000258 implicit_null_checks_(false),
259 implicit_so_checks_(false),
Calin Juravle07d83c72014-10-22 21:02:23 +0100260 implicit_suspend_checks_(false),
Calin Juravle01aaf6e2015-06-19 22:05:39 +0100261 no_sig_chain_(false),
Andreas Gampef38a6612016-04-11 08:42:26 -0700262 force_native_bridge_(false),
Narayan Kamath5a2be3f2015-02-16 13:51:51 +0000263 is_native_bridge_loaded_(false),
David Srbeckyf4480162016-03-16 00:06:24 +0000264 is_native_debuggable_(false),
Alex Light7919db92017-11-29 09:00:55 -0800265 async_exceptions_thrown_(false),
Nicolas Geoffray433b79a2017-01-30 20:54:45 +0000266 is_java_debuggable_(false),
Igor Murashkin158f35c2015-06-10 15:55:30 -0700267 zygote_max_failed_boots_(0),
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -0700268 experimental_flags_(ExperimentalFlags::kNone),
269 oat_file_manager_(nullptr),
Nicolas Geoffray787ae8e2015-11-05 11:32:24 +0000270 is_low_memory_mode_(false),
Andreas Gampea1425a12016-03-11 17:44:04 -0800271 safe_mode_(false),
Mathew Inwood597d7f62018-03-22 11:36:47 +0000272 hidden_api_policy_(hiddenapi::EnforcementPolicy::kNoChecks),
David Brazdilee7d2fd2018-01-20 17:25:23 +0000273 pending_hidden_api_warning_(false),
274 dedupe_hidden_api_warnings_(true),
David Brazdil92265222018-02-02 11:21:40 +0000275 always_set_hidden_api_warning_flag_(false),
Mathew Inwood1fd97f22018-04-03 15:32:32 +0100276 hidden_api_access_event_log_rate_(0),
Nicolas Geoffray6ee49712018-03-30 14:39:05 +0000277 dump_native_stack_on_sig_quit_(true),
Mathieu Chartierf8cb1782016-03-18 18:45:41 -0700278 pruned_dalvik_cache_(false),
279 // Initially assume we perceive jank in case the process state is never updated.
Andreas Gampef38a6612016-04-11 08:42:26 -0700280 process_state_(kProcessStateJankPerceptible),
Andreas Gampec1ac9ee2017-07-24 22:35:49 -0700281 zygote_no_threads_(false) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -0700282 static_assert(Runtime::kCalleeSaveSize ==
283 static_cast<uint32_t>(CalleeSaveType::kLastCalleeSaveType), "Unexpected size");
284
Ian Rogers1d8cdbc2014-09-22 22:51:09 -0700285 CheckAsmSupportOffsetsAndSizes();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700286 std::fill(callee_save_methods_, callee_save_methods_ + arraysize(callee_save_methods_), 0u);
buzbee1452bee2015-03-06 14:43:04 -0800287 interpreter::CheckInterpreterAsmConstants();
Andreas Gampeac30fa22017-01-18 21:02:36 -0800288 callbacks_.reset(new RuntimeCallbacks());
Nicolas Geoffray4e92c3c2017-05-08 09:34:26 +0100289 for (size_t i = 0; i <= static_cast<size_t>(DeoptimizationKind::kLast); ++i) {
290 deoptimization_counts_[i] = 0u;
291 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700292}
293
Carl Shapiro61e019d2011-07-14 16:53:09 -0700294Runtime::~Runtime() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800295 ScopedTrace trace("Runtime shutdown");
Calin Juravle07d83c72014-10-22 21:02:23 +0100296 if (is_native_bridge_loaded_) {
297 UnloadNativeBridge();
298 }
Calin Juravle31f2c152015-10-23 17:56:15 +0100299
Ian Rogers120f1c72012-09-28 17:17:10 -0700300 Thread* self = Thread::Current();
Mathieu Chartier05d14612015-02-23 15:31:58 -0800301 const bool attach_shutdown_thread = self == nullptr;
302 if (attach_shutdown_thread) {
Alex Lightb6f34642018-01-04 11:01:48 -0800303 // 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 -0800304 // some tests. If there is extreme memory pressure the allocation of the thread peer can fail.
305 // In this case we will just try again without allocating a peer so that shutdown can continue.
306 // Very few things are actually capable of distinguishing between the peer & peerless states so
307 // this should be fine.
308 bool thread_attached = AttachCurrentThread("Shutdown thread",
309 /* as_daemon */ false,
310 GetSystemThreadGroup(),
311 /* Create peer */ IsStarted());
312 if (UNLIKELY(!thread_attached)) {
313 LOG(WARNING) << "Failed to attach shutdown thread. Trying again without a peer.";
314 CHECK(AttachCurrentThread("Shutdown thread (no java peer)",
315 /* as_daemon */ false,
316 /* thread_group*/ nullptr,
317 /* Create peer */ false));
318 }
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800319 self = Thread::Current();
320 } else {
321 LOG(WARNING) << "Current thread not detached in Runtime shutdown";
322 }
323
Mathieu Chartier1d495012017-04-11 17:50:00 -0700324 if (dump_gc_performance_on_shutdown_) {
Mathieu Chartierb0042b82017-12-13 13:50:36 -0800325 ScopedLogSeverity sls(LogSeverity::INFO);
Mathieu Chartier1d495012017-04-11 17:50:00 -0700326 // This can't be called from the Heap destructor below because it
327 // could call RosAlloc::InspectAll() which needs the thread_list
328 // to be still alive.
329 heap_->DumpGcPerformanceInfo(LOG_STREAM(INFO));
330 }
331
Calin Juravlea345d312017-03-14 18:45:55 -0700332 if (jit_ != nullptr) {
333 // Stop the profile saver thread before marking the runtime as shutting down.
334 // The saver will try to dump the profiles before being sopped and that
335 // requires holding the mutator lock.
336 jit_->StopProfileSaver();
337 }
338
Ian Rogers120f1c72012-09-28 17:17:10 -0700339 {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800340 ScopedTrace trace2("Wait for shutdown cond");
Ian Rogers120f1c72012-09-28 17:17:10 -0700341 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
342 shutting_down_started_ = true;
343 while (threads_being_born_ > 0) {
Ian Rogersc604d732012-10-14 16:09:54 -0700344 shutdown_cond_->Wait(self);
Ian Rogers120f1c72012-09-28 17:17:10 -0700345 }
346 shutting_down_ = true;
347 }
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800348 // Shutdown and wait for the daemons.
349 CHECK(self != nullptr);
350 if (IsFinishedStarting()) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800351 ScopedTrace trace2("Waiting for Daemons");
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800352 self->ClearException();
353 self->GetJniEnv()->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons,
354 WellKnownClasses::java_lang_Daemons_stop);
355 }
Mathieu Chartier673ed3d2015-08-28 14:56:43 -0700356
357 Trace::Shutdown();
358
Andreas Gampe48864112017-01-19 17:23:17 -0800359 // Report death. Clients me require a working thread, still, so do it before GC completes and
360 // all non-daemon threads are done.
361 {
362 ScopedObjectAccess soa(self);
363 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kDeath);
364 }
365
Mathieu Chartier05d14612015-02-23 15:31:58 -0800366 if (attach_shutdown_thread) {
367 DetachCurrentThread();
368 self = nullptr;
369 }
Mathieu Chartiercef50f02014-12-09 17:38:52 -0800370
Mathieu Chartiera6399032012-06-11 18:49:50 -0700371 // Make sure to let the GC complete if it is running.
Mathieu Chartier89a201e2014-05-02 10:27:26 -0700372 heap_->WaitForGcToComplete(gc::kGcCauseBackground, self);
Mathieu Chartier35883cc2012-11-13 14:08:12 -0800373 heap_->DeleteThreadPool();
Mathieu Chartierfb6db4c2016-01-06 17:23:25 -0800374 if (jit_ != nullptr) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800375 ScopedTrace trace2("Delete jit");
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800376 VLOG(jit) << "Deleting jit thread pool";
377 // Delete thread pool before the thread list since we don't want to wait forever on the
378 // JIT compiler threads.
379 jit_->DeleteThreadPool();
380 }
Mathieu Chartiera6399032012-06-11 18:49:50 -0700381
Andreas Gampec4bed162017-05-01 13:46:24 -0700382 // Make sure our internal threads are dead before we start tearing down things they're using.
Alex Light40320712017-12-14 11:52:04 -0800383 GetRuntimeCallbacks()->StopDebugger();
Andreas Gampec4bed162017-05-01 13:46:24 -0700384 delete signal_catcher_;
385
386 // Make sure all other non-daemon threads have terminated, and all daemon threads are suspended.
387 {
388 ScopedTrace trace2("Delete thread list");
389 thread_list_->ShutDown();
390 }
391
Alex Light7233c7e2016-07-28 10:07:45 -0700392 // TODO Maybe do some locking.
393 for (auto& agent : agents_) {
Andreas Gampeaadcbc62017-12-28 14:05:42 -0800394 agent->Unload();
Alex Light7233c7e2016-07-28 10:07:45 -0700395 }
396
Alex Light185d1342016-08-11 10:48:03 -0700397 // TODO Maybe do some locking
398 for (auto& plugin : plugins_) {
399 plugin.Unload();
400 }
401
Andreas Gampec4bed162017-05-01 13:46:24 -0700402 // Finally delete the thread list.
403 delete thread_list_;
Elliott Hughes5fe594f2011-09-08 12:33:17 -0700404
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800405 // Delete the JIT after thread list to ensure that there is no remaining threads which could be
406 // accessing the instrumentation when we delete it.
Mathieu Chartierfb6db4c2016-01-06 17:23:25 -0800407 if (jit_ != nullptr) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800408 VLOG(jit) << "Deleting jit";
409 jit_.reset(nullptr);
410 }
411
Vladimir Marko2beeb822014-10-20 18:13:22 +0100412 // Shutdown the fault manager if it was initialized.
413 fault_manager.Shutdown();
414
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800415 ScopedTrace trace2("Delete state");
Elliott Hughesc33a32b2011-10-11 18:18:07 -0700416 delete monitor_list_;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800417 delete monitor_pool_;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700418 delete class_linker_;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800419 delete heap_;
Elliott Hughescf4c6c42011-09-01 15:16:42 -0700420 delete intern_table_;
Mathieu Chartiere58991b2015-10-13 07:59:34 -0700421 delete oat_file_manager_;
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700422 Thread::Shutdown();
Elliott Hughes7c6169d2012-05-02 16:11:48 -0700423 QuasiAtomic::Shutdown();
Sebastien Hertz4d4adb12013-07-24 16:14:19 +0200424 verifier::MethodVerifier::Shutdown();
Vladimir Marko37cf51f2015-09-22 11:43:46 +0100425
426 // Destroy allocators before shutting down the MemMap because they may use it.
Richard Uhlerda0a69e2016-10-11 15:06:38 +0100427 java_vm_.reset();
Vladimir Marko37cf51f2015-09-22 11:43:46 +0100428 linear_alloc_.reset();
429 low_4gb_arena_pool_.reset();
430 arena_pool_.reset();
Nicolas Geoffray25e04562016-03-01 13:17:58 +0000431 jit_arena_pool_.reset();
Andreas Gampe2ac67d52017-05-11 22:30:38 -0700432 protected_fault_page_.reset();
Mathieu Chartier6e88ef62014-10-14 15:01:24 -0700433 MemMap::Shutdown();
Vladimir Marko37cf51f2015-09-22 11:43:46 +0100434
Carl Shapiro4acf4642011-07-26 18:54:13 -0700435 // TODO: acquire a static mutex on Runtime to avoid racing.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800436 CHECK(instance_ == nullptr || instance_ == this);
437 instance_ = nullptr;
Andreas Gampedb48a792017-09-08 22:18:30 -0700438
439 // Well-known classes must be deleted or it is impossible to successfully start another Runtime
440 // instance. We rely on a small initialization order issue in Runtime::Start() that requires
441 // elements of WellKnownClasses to be null, see b/65500943.
442 WellKnownClasses::Clear();
Carl Shapiro61e019d2011-07-14 16:53:09 -0700443}
444
Elliott Hughese0918552011-10-28 17:18:29 -0700445struct AbortState {
Ian Rogersc7dd2952014-10-21 23:31:19 -0700446 void Dump(std::ostream& os) const {
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000447 if (gAborting > 1) {
448 os << "Runtime aborting --- recursively, so no thread-specific detail!\n";
Andreas Gampe9fd470f2016-11-18 17:21:12 -0800449 DumpRecursiveAbort(os);
Nicolas Geoffraydb978712014-12-09 13:33:38 +0000450 return;
451 }
452 gAborting++;
Elliott Hughese0918552011-10-28 17:18:29 -0700453 os << "Runtime aborting...\n";
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700454 if (Runtime::Current() == nullptr) {
Elliott Hughes6c7d2442012-02-01 18:40:47 -0800455 os << "(Runtime does not yet exist!)\n";
Andreas Gampe6eb6a392016-02-10 20:18:37 -0800456 DumpNativeStack(os, GetTid(), nullptr, " native: ", nullptr);
Elliott Hughes6c7d2442012-02-01 18:40:47 -0800457 return;
458 }
Elliott Hughese0918552011-10-28 17:18:29 -0700459 Thread* self = Thread::Current();
Andreas Gampea3f78fe2017-09-05 09:31:04 -0700460
461 // Dump all threads first and then the aborting thread. While this is counter the logical flow,
462 // it improves the chance of relevant data surviving in the Android logs.
463
464 DumpAllThreads(os, self);
465
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700466 if (self == nullptr) {
Elliott Hughese0918552011-10-28 17:18:29 -0700467 os << "(Aborting thread was not attached to runtime!)\n";
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700468 DumpKernelStack(os, GetTid(), " kernel: ", false);
Christopher Ferris6cff48f2014-01-26 21:36:13 -0800469 DumpNativeStack(os, GetTid(), nullptr, " native: ", nullptr);
Elliott Hughese0918552011-10-28 17:18:29 -0700470 } else {
Ian Rogers2f7f9b62012-10-10 18:24:05 -0700471 os << "Aborting thread:\n";
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700472 if (Locks::mutator_lock_->IsExclusiveHeld(self) || Locks::mutator_lock_->IsSharedHeld(self)) {
473 DumpThread(os, self);
474 } else {
475 if (Locks::mutator_lock_->SharedTryLock(self)) {
476 DumpThread(os, self);
477 Locks::mutator_lock_->SharedUnlock(self);
478 }
Elliott Hughes899e7892012-01-24 14:57:32 -0800479 }
Elliott Hughese0918552011-10-28 17:18:29 -0700480 }
Ian Rogers2f7f9b62012-10-10 18:24:05 -0700481 }
482
Ian Rogers7b078e82014-09-10 14:44:24 -0700483 // No thread-safety analysis as we do explicitly test for holding the mutator lock.
Ian Rogersc7dd2952014-10-21 23:31:19 -0700484 void DumpThread(std::ostream& os, Thread* self) const NO_THREAD_SAFETY_ANALYSIS {
Ian Rogers7b078e82014-09-10 14:44:24 -0700485 DCHECK(Locks::mutator_lock_->IsExclusiveHeld(self) || Locks::mutator_lock_->IsSharedHeld(self));
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700486 self->Dump(os);
487 if (self->IsExceptionPending()) {
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000488 mirror::Throwable* exception = self->GetException();
489 os << "Pending exception " << exception->Dump();
Mathieu Chartierc7a966d2014-04-10 18:06:32 -0700490 }
491 }
492
Ian Rogersc7dd2952014-10-21 23:31:19 -0700493 void DumpAllThreads(std::ostream& os, Thread* self) const {
Ian Rogers4e14e722014-06-27 17:32:56 -0700494 Runtime* runtime = Runtime::Current();
495 if (runtime != nullptr) {
496 ThreadList* thread_list = runtime->GetThreadList();
497 if (thread_list != nullptr) {
498 bool tll_already_held = Locks::thread_list_lock_->IsExclusiveHeld(self);
499 bool ml_already_held = Locks::mutator_lock_->IsSharedHeld(self);
500 if (!tll_already_held || !ml_already_held) {
501 os << "Dumping all threads without appropriate locks held:"
502 << (!tll_already_held ? " thread list lock" : "")
503 << (!ml_already_held ? " mutator lock" : "")
504 << "\n";
505 }
506 os << "All threads:\n";
Ian Rogers7b078e82014-09-10 14:44:24 -0700507 thread_list->Dump(os);
Ian Rogers4e14e722014-06-27 17:32:56 -0700508 }
Ian Rogers2f7f9b62012-10-10 18:24:05 -0700509 }
Elliott Hughese0918552011-10-28 17:18:29 -0700510 }
Andreas Gampe7afa4542016-11-18 09:51:06 -0800511
512 // For recursive aborts.
513 void DumpRecursiveAbort(std::ostream& os) const NO_THREAD_SAFETY_ANALYSIS {
Andreas Gampe9fd470f2016-11-18 17:21:12 -0800514 // The only thing we'll attempt is dumping the native stack of the current thread. We will only
515 // try this if we haven't exceeded an arbitrary amount of recursions, to recover and actually
516 // die.
517 // Note: as we're using a global counter for the recursive abort detection, there is a potential
518 // race here and it is not OK to just print when the counter is "2" (one from
519 // Runtime::Abort(), one from previous Dump() call). Use a number that seems large enough.
520 static constexpr size_t kOnlyPrintWhenRecursionLessThan = 100u;
521 if (gAborting < kOnlyPrintWhenRecursionLessThan) {
522 gAborting++;
523 DumpNativeStack(os, GetTid());
524 }
Andreas Gampe7afa4542016-11-18 09:51:06 -0800525 }
Elliott Hughese0918552011-10-28 17:18:29 -0700526};
527
Andreas Gampe90a32b12016-10-03 19:47:08 -0700528void Runtime::Abort(const char* msg) {
Andreas Gampe247fc332017-06-22 16:18:24 -0700529 auto old_value = gAborting.fetch_add(1); // set before taking any locks
Brian Carlstrom81b88712012-11-05 19:21:30 -0800530
Andreas Gampe51d80cc2017-06-21 21:05:13 -0700531#ifdef ART_TARGET_ANDROID
Andreas Gampe247fc332017-06-22 16:18:24 -0700532 if (old_value == 0) {
533 // Only set the first abort message.
534 android_set_abort_message(msg);
535 }
536#else
537 UNUSED(old_value);
Andreas Gampe51d80cc2017-06-21 21:05:13 -0700538#endif
539
Andreas Gampe0ffbe5f2017-06-21 21:05:13 -0700540#ifdef ART_TARGET_ANDROID
541 android_set_abort_message(msg);
542#endif
543
Elliott Hughes131aef82012-01-27 11:53:35 -0800544 // Ensure that we don't have multiple threads trying to abort at once,
545 // which would result in significantly worse diagnostics.
Ian Rogers50b35e22012-10-04 10:09:15 -0700546 MutexLock mu(Thread::Current(), *Locks::abort_lock_);
Elliott Hughes131aef82012-01-27 11:53:35 -0800547
Elliott Hughesffe67362011-07-17 12:09:27 -0700548 // Get any pending output out of the way.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700549 fflush(nullptr);
Elliott Hughesffe67362011-07-17 12:09:27 -0700550
551 // Many people have difficulty distinguish aborts from crashes,
552 // so be explicit.
Andreas Gampeb67906b2016-11-18 09:30:08 -0800553 // Note: use cerr on the host to print log lines immediately, so we get at least some output
554 // in case of recursive aborts. We lose annotation with the source file and line number
555 // here, which is a minor issue. The same is significantly more complicated on device,
556 // which is why we ignore the issue there.
Elliott Hughese0918552011-10-28 17:18:29 -0700557 AbortState state;
Andreas Gampeb67906b2016-11-18 09:30:08 -0800558 if (kIsTargetBuild) {
559 LOG(FATAL_WITHOUT_ABORT) << Dumpable<AbortState>(state);
560 } else {
561 std::cerr << Dumpable<AbortState>(state);
562 }
Elliott Hughesffe67362011-07-17 12:09:27 -0700563
Andreas Gampe90a32b12016-10-03 19:47:08 -0700564 // Sometimes we dump long messages, and the Android abort message only retains the first line.
565 // In those cases, just log the message again, to avoid logcat limits.
566 if (msg != nullptr && strchr(msg, '\n') != nullptr) {
567 LOG(FATAL_WITHOUT_ABORT) << msg;
568 }
569
Elliott Hughes8593fdb2012-04-21 20:53:44 -0700570 // Call the abort hook if we have one.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700571 if (Runtime::Current() != nullptr && Runtime::Current()->abort_ != nullptr) {
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700572 LOG(FATAL_WITHOUT_ABORT) << "Calling abort hook...";
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700573 Runtime::Current()->abort_();
574 // notreached
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700575 LOG(FATAL_WITHOUT_ABORT) << "Unexpectedly returned from abort hook!";
Brian Carlstrom6ea095a2011-08-16 15:26:54 -0700576 }
577
Elliott Hughesdd623db2013-06-11 11:20:23 -0700578 abort();
Elliott Hughesffe67362011-07-17 12:09:27 -0700579 // notreached
580}
581
Narayan Kamath3de95a72014-04-02 12:54:23 +0100582void Runtime::PreZygoteFork() {
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700583 heap_->PreZygoteFork();
Mathieu Chartiercc236d72012-07-20 10:29:05 -0700584}
585
Elliott Hughesbf86d042011-08-31 17:53:14 -0700586void Runtime::CallExitHook(jint status) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700587 if (exit_ != nullptr) {
Elliott Hughes34e06962012-04-09 13:55:55 -0700588 ScopedThreadStateChange tsc(Thread::Current(), kNative);
Elliott Hughesbf86d042011-08-31 17:53:14 -0700589 exit_(status);
590 LOG(WARNING) << "Exit hook returned instead of exiting!";
591 }
592}
593
Mathieu Chartier97509952015-07-13 14:35:43 -0700594void Runtime::SweepSystemWeaks(IsMarkedVisitor* visitor) {
595 GetInternTable()->SweepInternTableWeaks(visitor);
596 GetMonitorList()->SweepMonitorList(visitor);
597 GetJavaVM()->SweepJniWeakGlobals(visitor);
598 GetHeap()->SweepAllocationRecords(visitor);
Nicolas Geoffray132d8362016-11-16 09:19:42 +0000599 if (GetJit() != nullptr) {
600 // Visit JIT literal tables. Objects in these tables are classes and strings
601 // and only classes can be affected by class unloading. The strings always
602 // stay alive as they are strongly interned.
603 // TODO: Move this closer to CleanupClassLoaders, to avoid blocking weak accesses
604 // from mutators. See b/32167580.
605 GetJit()->GetCodeCache()->SweepRootTables(visitor);
606 }
Andreas Gampefda57142016-09-08 20:29:18 -0700607
608 // All other generic system-weak holders.
609 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
610 holder->Sweep(visitor);
611 }
Mathieu Chartier6aa3df92013-09-17 15:17:28 -0700612}
613
Vladimir Marko88b2b802015-12-04 14:19:04 +0000614bool Runtime::ParseOptions(const RuntimeOptions& raw_options,
615 bool ignore_unrecognized,
616 RuntimeArgumentMap* runtime_options) {
David Sehrc431b9d2018-03-02 12:01:51 -0800617 Locks::Init();
Andreas Gampe51d80cc2017-06-21 21:05:13 -0700618 InitLogging(/* argv */ nullptr, Abort); // Calls Locks::Init() as a side effect.
Vladimir Marko88b2b802015-12-04 14:19:04 +0000619 bool parsed = ParsedOptions::Parse(raw_options, ignore_unrecognized, runtime_options);
620 if (!parsed) {
621 LOG(ERROR) << "Failed to parse options";
622 return false;
623 }
624 return true;
625}
626
David Sehrf42eb2c2016-10-19 13:20:45 -0700627// Callback to check whether it is safe to call Abort (e.g., to use a call to
628// LOG(FATAL)). It is only safe to call Abort if the runtime has been created,
629// properly initialized, and has not shut down.
630static bool IsSafeToCallAbort() NO_THREAD_SAFETY_ANALYSIS {
631 Runtime* runtime = Runtime::Current();
632 return runtime != nullptr && runtime->IsStarted() && !runtime->IsShuttingDownLocked();
633}
634
Vladimir Marko88b2b802015-12-04 14:19:04 +0000635bool Runtime::Create(RuntimeArgumentMap&& runtime_options) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700636 // TODO: acquire a static mutex on Runtime to avoid racing.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700637 if (Runtime::instance_ != nullptr) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700638 return false;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700639 }
Elliott Hughesdcc24742011-09-07 14:02:44 -0700640 instance_ = new Runtime;
David Sehrf42eb2c2016-10-19 13:20:45 -0700641 Locks::SetClientCallback(IsSafeToCallAbort);
Vladimir Marko88b2b802015-12-04 14:19:04 +0000642 if (!instance_->Init(std::move(runtime_options))) {
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -0700643 // TODO: Currently deleting the instance will abort the runtime on destruction. Now This will
644 // leak memory, instead. Fix the destructor. b/19100793.
645 // delete instance_;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700646 instance_ = nullptr;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700647 return false;
Carl Shapiro61e019d2011-07-14 16:53:09 -0700648 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700649 return true;
Brian Carlstrom69b15fb2011-09-03 12:25:21 -0700650}
Elliott Hughes0af55432011-08-17 18:37:28 -0700651
Vladimir Marko88b2b802015-12-04 14:19:04 +0000652bool Runtime::Create(const RuntimeOptions& raw_options, bool ignore_unrecognized) {
653 RuntimeArgumentMap runtime_options;
654 return ParseOptions(raw_options, ignore_unrecognized, &runtime_options) &&
655 Create(std::move(runtime_options));
656}
657
Andreas Gampe81c6f8d2015-03-25 17:19:53 -0700658static jobject CreateSystemClassLoader(Runtime* runtime) {
659 if (runtime->IsAotCompiler() && !runtime->GetCompilerCallbacks()->IsBootImage()) {
660 return nullptr;
Brian Carlstromaded5f72011-10-07 17:15:04 -0700661 }
662
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700663 ScopedObjectAccess soa(Thread::Current());
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800664 ClassLinker* cl = Runtime::Current()->GetClassLinker();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700665 auto pointer_size = cl->GetImagePointerSize();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700666
Ian Rogers68d8b422014-07-17 11:09:10 -0700667 StackHandleScope<2> hs(soa.Self());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700668 Handle<mirror::Class> class_loader_class(
Mathieu Chartier0795f232016-09-27 18:43:30 -0700669 hs.NewHandle(soa.Decode<mirror::Class>(WellKnownClasses::java_lang_ClassLoader)));
Ian Rogers7b078e82014-09-10 14:44:24 -0700670 CHECK(cl->EnsureInitialized(soa.Self(), class_loader_class, true, true));
Brian Carlstromaded5f72011-10-07 17:15:04 -0700671
Vladimir Markoba118822017-06-12 15:41:56 +0100672 ArtMethod* getSystemClassLoader = class_loader_class->FindClassMethod(
Mathieu Chartiere401d142015-04-22 13:56:20 -0700673 "getSystemClassLoader", "()Ljava/lang/ClassLoader;", pointer_size);
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700674 CHECK(getSystemClassLoader != nullptr);
Vladimir Markoba118822017-06-12 15:41:56 +0100675 CHECK(getSystemClassLoader->IsStatic());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700676
Andreas Gampe13b27842016-11-07 16:48:23 -0800677 JValue result = InvokeWithJValues(soa,
678 nullptr,
679 jni::EncodeArtMethod(getSystemClassLoader),
680 nullptr);
Brian Carlstromce888532013-10-10 00:32:58 -0700681 JNIEnv* env = soa.Self()->GetJniEnv();
Mathieu Chartiere401d142015-04-22 13:56:20 -0700682 ScopedLocalRef<jobject> system_class_loader(env, soa.AddLocalReference<jobject>(result.GetL()));
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800683 CHECK(system_class_loader.get() != nullptr);
Brian Carlstromce888532013-10-10 00:32:58 -0700684
Ian Rogers68d8b422014-07-17 11:09:10 -0700685 soa.Self()->SetClassLoaderOverride(system_class_loader.get());
Ian Rogers365c1022012-06-22 15:05:28 -0700686
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700687 Handle<mirror::Class> thread_class(
Mathieu Chartier0795f232016-09-27 18:43:30 -0700688 hs.NewHandle(soa.Decode<mirror::Class>(WellKnownClasses::java_lang_Thread)));
Ian Rogers7b078e82014-09-10 14:44:24 -0700689 CHECK(cl->EnsureInitialized(soa.Self(), thread_class, true, true));
Ian Rogers365c1022012-06-22 15:05:28 -0700690
Mathieu Chartierc7853442015-03-27 14:35:38 -0700691 ArtField* contextClassLoader =
Mathieu Chartierc528dba2013-11-26 12:00:11 -0800692 thread_class->FindDeclaredInstanceField("contextClassLoader", "Ljava/lang/ClassLoader;");
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700693 CHECK(contextClassLoader != nullptr);
Ian Rogers365c1022012-06-22 15:05:28 -0700694
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +0100695 // We can't run in a transaction yet.
Mathieu Chartier0795f232016-09-27 18:43:30 -0700696 contextClassLoader->SetObject<false>(
697 soa.Self()->GetPeer(),
Mathieu Chartier1cc62e42016-10-03 18:01:28 -0700698 soa.Decode<mirror::ClassLoader>(system_class_loader.get()).Ptr());
Brian Carlstromce888532013-10-10 00:32:58 -0700699
700 return env->NewGlobalRef(system_class_loader.get());
Brian Carlstromaded5f72011-10-07 17:15:04 -0700701}
702
Alex Lighta59dd802014-07-02 16:28:08 -0700703std::string Runtime::GetPatchoatExecutable() const {
704 if (!patchoat_executable_.empty()) {
705 return patchoat_executable_;
706 }
Andreas Gampe277ccbd2014-11-03 21:36:10 -0800707 std::string patchoat_executable(GetAndroidRoot());
708 patchoat_executable += (kIsDebugBuild ? "/bin/patchoatd" : "/bin/patchoat");
709 return patchoat_executable;
Alex Lighta59dd802014-07-02 16:28:08 -0700710}
711
Tsu Chiang Chuang12e6d742014-05-22 10:22:25 -0700712std::string Runtime::GetCompilerExecutable() const {
713 if (!compiler_executable_.empty()) {
714 return compiler_executable_;
715 }
716 std::string compiler_executable(GetAndroidRoot());
717 compiler_executable += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
718 return compiler_executable;
719}
720
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700721bool Runtime::Start() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800722 VLOG(startup) << "Runtime::Start entering";
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700723
Calin Juravle01aaf6e2015-06-19 22:05:39 +0100724 CHECK(!no_sig_chain_) << "A started runtime should have sig chain enabled";
725
Hiroshi Yamauchi6ffb9cc2015-08-31 15:14:17 -0700726 // If a debug host build, disable ptrace restriction for debugging and test timeout thread dump.
Hiroshi Yamauchic823eff2015-09-01 16:21:35 -0700727 // Only 64-bit as prctl() may fail in 32 bit userspace on a 64-bit kernel.
Bilyan Borisovbb661c02016-04-04 16:27:32 +0100728#if defined(__linux__) && !defined(ART_TARGET_ANDROID) && defined(__x86_64__)
Hiroshi Yamauchi6ffb9cc2015-08-31 15:14:17 -0700729 if (kIsDebugBuild) {
730 CHECK_EQ(prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY), 0);
731 }
732#endif
733
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700734 // Restore main thread state to kNative as expected by native code.
Ian Rogersa436fde2013-08-27 23:34:06 -0700735 Thread* self = Thread::Current();
Alex Light64ad14d2014-08-19 14:23:13 -0700736
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700737 self->TransitionFromRunnableToSuspended(kNative);
738
Brian Carlstrom5d40f182011-09-26 22:29:18 -0700739 started_ = true;
740
Jeff Haodcdc85b2015-12-04 14:06:18 -0800741 if (!IsImageDex2OatEnabled() || !GetHeap()->HasBootImageSpace()) {
Mathieu Chartiereb175f72014-10-31 11:49:27 -0700742 ScopedObjectAccess soa(self);
Przemyslaw Szczepaniaka2b147e2016-05-12 14:55:48 +0100743 StackHandleScope<2> hs(soa.Self());
744
745 auto class_class(hs.NewHandle<mirror::Class>(mirror::Class::GetJavaLangClass()));
746 auto field_class(hs.NewHandle<mirror::Class>(mirror::Field::StaticClass()));
747
748 class_linker_->EnsureInitialized(soa.Self(), class_class, true, true);
749 // Field class is needed for register_java_net_InetAddress in libcore, b/28153851.
750 class_linker_->EnsureInitialized(soa.Self(), field_class, true, true);
Alex Light64ad14d2014-08-19 14:23:13 -0700751 }
752
Brian Carlstromae826982011-11-09 01:33:42 -0800753 // InitNativeMethods needs to be after started_ so that the classes
754 // it touches will have methods linked to the oat file if necessary.
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800755 {
756 ScopedTrace trace2("InitNativeMethods");
757 InitNativeMethods();
758 }
Brian Carlstromae826982011-11-09 01:33:42 -0800759
Orion Hodson26ef34c2017-11-01 13:32:41 +0000760 // IntializeIntrinsics needs to be called after the WellKnownClasses::Init in InitNativeMethods
761 // because in checking the invocation types of intrinsic methods ArtMethod::GetInvokeType()
762 // needs the SignaturePolymorphic annotation class which is initialized in WellKnownClasses::Init.
763 InitializeIntrinsics();
764
Ian Rogers365c1022012-06-22 15:05:28 -0700765 // Initialize well known thread group values that may be accessed threads while attaching.
766 InitThreadGroups(self);
767
Jesse Wilson9a6bae82011-11-14 14:57:30 -0500768 Thread::FinishStartup();
769
Andreas Gampe4471e4f2017-01-30 16:40:49 +0000770 // Create the JIT either if we have to use JIT compilation or save profiling info. This is
771 // done after FinishStartup as the JIT pool needs Java thread peers, which require the main
772 // ThreadGroup to exist.
773 //
774 // TODO(calin): We use the JIT class as a proxy for JIT compilation and for
775 // recoding profiles. Maybe we should consider changing the name to be more clear it's
776 // not only about compiling. b/28295073.
777 if (jit_options_->UseJitCompilation() || jit_options_->GetSaveProfilingInfo()) {
778 std::string error_msg;
779 if (!IsZygote()) {
780 // If we are the zygote then we need to wait until after forking to create the code cache
781 // due to SELinux restrictions on r/w/x memory regions.
782 CreateJit();
783 } else if (jit_options_->UseJitCompilation()) {
784 if (!jit::Jit::LoadCompilerLibrary(&error_msg)) {
785 // Try to load compiler pre zygote to reduce PSS. b/27744947
786 LOG(WARNING) << "Failed to load JIT compiler with error " << error_msg;
787 }
788 }
789 }
790
Andreas Gampe48864112017-01-19 17:23:17 -0800791 // Send the start phase event. We have to wait till here as this is when the main thread peer
792 // has just been generated, important root clinits have been run and JNI is completely functional.
793 {
794 ScopedObjectAccess soa(self);
795 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kStart);
796 }
797
Andreas Gampe81c6f8d2015-03-25 17:19:53 -0700798 system_class_loader_ = CreateSystemClassLoader(this);
jgu21a6da74e2014-09-10 06:57:17 -0400799
Robert Sesekb2267032016-09-13 19:12:57 -0400800 if (!is_zygote_) {
Calin Juravle07d83c72014-10-22 21:02:23 +0100801 if (is_native_bridge_loaded_) {
jgu21a6da74e2014-09-10 06:57:17 -0400802 PreInitializeNativeBridge(".");
803 }
Calin Juravled3e7c6c2016-02-04 19:07:51 +0000804 NativeBridgeAction action = force_native_bridge_
805 ? NativeBridgeAction::kInitialize
806 : NativeBridgeAction::kUnload;
Nicolas Geoffrayba69a512015-11-17 13:50:21 +0000807 InitNonZygoteOrPostFork(self->GetJniEnv(),
Nicolas Geoffrayd66c8622015-12-11 14:59:16 +0000808 /* is_system_server */ false,
Calin Juravled3e7c6c2016-02-04 19:07:51 +0000809 action,
Nicolas Geoffrayba69a512015-11-17 13:50:21 +0000810 GetInstructionSetString(kRuntimeISA));
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700811 }
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700812
Andreas Gampeeafaf572017-01-20 12:34:15 -0800813 // Send the initialized phase event. Send it before starting daemons, as otherwise
814 // sending thread events becomes complicated.
815 {
816 ScopedObjectAccess soa(self);
817 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kInit);
818 }
819
Elliott Hughes85d15452011-09-16 17:33:01 -0700820 StartDaemonThreads();
Brian Carlstrom0a5b14d2011-09-27 13:29:15 -0700821
Yevgeny Rouban35aef2c2014-05-19 16:19:36 +0700822 {
823 ScopedObjectAccess soa(self);
Ian Rogers55256cb2017-12-21 17:07:11 -0800824 self->GetJniEnv()->AssertLocalsEmpty();
Yevgeny Rouban35aef2c2014-05-19 16:19:36 +0700825 }
Elliott Hughes726079d2011-10-07 18:43:44 -0700826
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800827 VLOG(startup) << "Runtime::Start exiting";
Mathieu Chartier7664f5c2012-06-08 18:15:32 -0700828 finished_starting_ = true;
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700829
Andreas Gampe40da2862015-02-27 12:49:04 -0800830 if (trace_config_.get() != nullptr && trace_config_->trace_file != "") {
831 ScopedThreadStateChange tsc(self, kWaitingForMethodTracingStart);
832 Trace::Start(trace_config_->trace_file.c_str(),
Andreas Gampe40da2862015-02-27 12:49:04 -0800833 static_cast<int>(trace_config_->trace_file_size),
834 0,
835 trace_config_->trace_output_mode,
836 trace_config_->trace_mode,
837 0);
838 }
839
Calin Juravle2bce0762018-02-20 16:03:34 -0800840 // In case we have a profile path passed as a command line argument,
841 // register the current class path for profiling now. Note that we cannot do
842 // this before we create the JIT and having it here is the most convenient way.
843 // This is used when testing profiles with dalvikvm command as there is no
844 // framework to register the dex files for profiling.
845 if (jit_.get() != nullptr && jit_options_->GetSaveProfilingInfo() &&
846 !jit_options_->GetProfileSaverOptions().GetProfilePath().empty()) {
847 std::vector<std::string> dex_filenames;
848 Split(class_path_string_, ':', &dex_filenames);
849 RegisterAppInfo(dex_filenames, jit_options_->GetProfileSaverOptions().GetProfilePath());
850 }
851
Brian Carlstrombd86bcc2013-03-10 20:26:16 -0700852 return true;
Elliott Hughes85d15452011-09-16 17:33:01 -0700853}
854
Mathieu Chartier90443472015-07-16 20:32:27 -0700855void Runtime::EndThreadBirth() REQUIRES(Locks::runtime_shutdown_lock_) {
Ian Rogers120f1c72012-09-28 17:17:10 -0700856 DCHECK_GT(threads_being_born_, 0U);
857 threads_being_born_--;
858 if (shutting_down_started_ && threads_being_born_ == 0) {
Ian Rogersc604d732012-10-14 16:09:54 -0700859 shutdown_cond_->Broadcast(Thread::Current());
Ian Rogers120f1c72012-09-28 17:17:10 -0700860 }
861}
862
Nicolas Geoffrayd66c8622015-12-11 14:59:16 +0000863void Runtime::InitNonZygoteOrPostFork(
864 JNIEnv* env, bool is_system_server, NativeBridgeAction action, const char* isa) {
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700865 is_zygote_ = false;
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700866
Calin Juravle07d83c72014-10-22 21:02:23 +0100867 if (is_native_bridge_loaded_) {
868 switch (action) {
869 case NativeBridgeAction::kUnload:
870 UnloadNativeBridge();
871 is_native_bridge_loaded_ = false;
872 break;
Andreas Gampe6be67ee2014-09-02 21:22:18 -0700873
Calin Juravle07d83c72014-10-22 21:02:23 +0100874 case NativeBridgeAction::kInitialize:
875 InitializeNativeBridge(env, isa);
876 break;
877 }
Andreas Gampe6be67ee2014-09-02 21:22:18 -0700878 }
879
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800880 // Create the thread pools.
Mathieu Chartier02b6a782012-10-26 13:51:26 -0700881 heap_->CreateThreadPool();
Hiroshi Yamauchi37670172015-06-10 17:20:54 -0700882 // Reset the gc performance data at zygote fork so that the GCs
883 // before fork aren't attributed to an app.
884 heap_->ResetGcPerformanceInfo();
885
Mathieu Chartierf9c917f2017-03-31 14:49:09 -0700886 // We may want to collect profiling samples for system server, but we never want to JIT there.
887 if ((!is_system_server || !jit_options_->UseJitCompilation()) &&
Calin Juravleffc87072016-04-20 14:22:09 +0100888 !safe_mode_ &&
889 (jit_options_->UseJitCompilation() || jit_options_->GetSaveProfilingInfo()) &&
Mathieu Chartierf9c917f2017-03-31 14:49:09 -0700890 jit_ == nullptr) {
Nicolas Geoffrayba69a512015-11-17 13:50:21 +0000891 // Note that when running ART standalone (not zygote, nor zygote fork),
892 // the jit may have already been created.
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800893 CreateJit();
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800894 }
Mathieu Chartier02b6a782012-10-26 13:51:26 -0700895
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700896 StartSignalCatcher();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700897
898 // Start the JDWP thread. If the command-line debugger flags specified "suspend=y",
Alex Light40320712017-12-14 11:52:04 -0800899 // this will pause the runtime (in the internal debugger implementation), so we probably want
900 // this to come last.
901 ScopedObjectAccess soa(Thread::Current());
902 GetRuntimeCallbacks()->StartDebugger();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700903}
904
905void Runtime::StartSignalCatcher() {
906 if (!is_zygote_) {
Andreas Gampe53af0402018-05-03 10:40:37 -0700907 signal_catcher_ = new SignalCatcher();
Brian Carlstromcaabb1b2011-10-11 18:09:13 -0700908 }
909}
910
Mathieu Chartier590fee92013-09-13 13:46:47 -0700911bool Runtime::IsShuttingDown(Thread* self) {
912 MutexLock mu(self, *Locks::runtime_shutdown_lock_);
913 return IsShuttingDownLocked();
914}
915
Elliott Hughes85d15452011-09-16 17:33:01 -0700916void Runtime::StartDaemonThreads() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -0800917 ScopedTrace trace(__FUNCTION__);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800918 VLOG(startup) << "Runtime::StartDaemonThreads entering";
Elliott Hughes85d15452011-09-16 17:33:01 -0700919
Elliott Hughes719b3232011-09-25 17:42:19 -0700920 Thread* self = Thread::Current();
Brian Carlstromaded5f72011-10-07 17:15:04 -0700921
922 // Must be in the kNative state for calling native methods.
Ian Rogers50b35e22012-10-04 10:09:15 -0700923 CHECK_EQ(self->GetState(), kNative);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700924
Elliott Hughes719b3232011-09-25 17:42:19 -0700925 JNIEnv* env = self->GetJniEnv();
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700926 env->CallStaticVoidMethod(WellKnownClasses::java_lang_Daemons,
927 WellKnownClasses::java_lang_Daemons_start);
928 if (env->ExceptionCheck()) {
929 env->ExceptionDescribe();
930 LOG(FATAL) << "Error starting java.lang.Daemons";
931 }
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -0700932
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800933 VLOG(startup) << "Runtime::StartDaemonThreads exiting";
Carl Shapiro61e019d2011-07-14 16:53:09 -0700934}
935
Jeff Haodcdc85b2015-12-04 14:06:18 -0800936// Attempts to open dex files from image(s). Given the image location, try to find the oat file
937// and open it to get the stored dex file. If the image is the first for a multi-image boot
938// classpath, go on and also open the other images.
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700939static bool OpenDexFilesFromImage(const std::string& image_location,
Igor Murashkinb1d8c312015-08-04 11:18:43 -0700940 std::vector<std::unique_ptr<const DexFile>>* dex_files,
941 size_t* failures) {
942 DCHECK(dex_files != nullptr) << "OpenDexFilesFromImage: out-param is nullptr";
Alex Light84d76052014-08-22 17:49:35 -0700943
Jeff Haodcdc85b2015-12-04 14:06:18 -0800944 // Use a work-list approach, so that we can easily reuse the opening code.
945 std::vector<std::string> image_locations;
946 image_locations.push_back(image_location);
947
948 for (size_t index = 0; index < image_locations.size(); ++index) {
949 std::string system_filename;
950 bool has_system = false;
951 std::string cache_filename_unused;
952 bool dalvik_cache_exists_unused;
953 bool has_cache_unused;
954 bool is_global_cache_unused;
955 bool found_image = gc::space::ImageSpace::FindImageFilename(image_locations[index].c_str(),
956 kRuntimeISA,
957 &system_filename,
958 &has_system,
959 &cache_filename_unused,
960 &dalvik_cache_exists_unused,
961 &has_cache_unused,
962 &is_global_cache_unused);
963
964 if (!found_image || !has_system) {
965 return false;
Alex Light84d76052014-08-22 17:49:35 -0700966 }
Jeff Haodcdc85b2015-12-04 14:06:18 -0800967
968 // We are falling back to non-executable use of the oat file because patching failed, presumably
969 // due to lack of space.
David Brazdilc93b3be2016-09-12 18:49:58 +0100970 std::string vdex_filename =
971 ImageHeader::GetVdexLocationFromImageLocation(system_filename.c_str());
Jeff Haodcdc85b2015-12-04 14:06:18 -0800972 std::string oat_filename =
973 ImageHeader::GetOatLocationFromImageLocation(system_filename.c_str());
974 std::string oat_location =
975 ImageHeader::GetOatLocationFromImageLocation(image_locations[index].c_str());
976 // Note: in the multi-image case, the image location may end in ".jar," and not ".art." Handle
977 // that here.
Andreas Gampe9186ced2016-12-12 14:28:21 -0800978 if (android::base::EndsWith(oat_location, ".jar")) {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800979 oat_location.replace(oat_location.length() - 3, 3, "oat");
Alex Light84d76052014-08-22 17:49:35 -0700980 }
David Brazdilc93b3be2016-09-12 18:49:58 +0100981 std::string error_msg;
982
983 std::unique_ptr<VdexFile> vdex_file(VdexFile::Open(vdex_filename,
984 false /* writable */,
985 false /* low_4gb */,
Nicolas Geoffray4e868fa2017-04-21 17:16:44 +0100986 false, /* unquicken */
David Brazdilc93b3be2016-09-12 18:49:58 +0100987 &error_msg));
988 if (vdex_file.get() == nullptr) {
989 return false;
990 }
Jeff Haodcdc85b2015-12-04 14:06:18 -0800991
992 std::unique_ptr<File> file(OS::OpenFileForReading(oat_filename.c_str()));
993 if (file.get() == nullptr) {
994 return false;
995 }
Brian Carlstromf5b0f2c2016-10-14 01:04:26 -0700996 std::unique_ptr<ElfFile> elf_file(ElfFile::Open(file.get(),
David Brazdilc93b3be2016-09-12 18:49:58 +0100997 false /* writable */,
998 false /* program_header_only */,
999 false /* low_4gb */,
Mathieu Chartier0b4cbd02016-03-08 16:49:58 -08001000 &error_msg));
Jeff Haodcdc85b2015-12-04 14:06:18 -08001001 if (elf_file.get() == nullptr) {
1002 return false;
1003 }
1004 std::unique_ptr<const OatFile> oat_file(
Nicolas Geoffray30025092018-04-19 14:43:29 +01001005 OatFile::OpenWithElfFile(/* zip_fd */ -1,
1006 elf_file.release(),
David Brazdilc93b3be2016-09-12 18:49:58 +01001007 vdex_file.release(),
1008 oat_location,
1009 nullptr,
1010 &error_msg));
Jeff Haodcdc85b2015-12-04 14:06:18 -08001011 if (oat_file == nullptr) {
1012 LOG(WARNING) << "Unable to use '" << oat_filename << "' because " << error_msg;
1013 return false;
1014 }
1015
1016 for (const OatFile::OatDexFile* oat_dex_file : oat_file->GetOatDexFiles()) {
1017 if (oat_dex_file == nullptr) {
1018 *failures += 1;
1019 continue;
1020 }
1021 std::unique_ptr<const DexFile> dex_file = oat_dex_file->OpenDexFile(&error_msg);
1022 if (dex_file.get() == nullptr) {
1023 *failures += 1;
1024 } else {
1025 dex_files->push_back(std::move(dex_file));
1026 }
1027 }
1028
1029 if (index == 0) {
1030 // First file. See if this is a multi-image environment, and if so, enqueue the other images.
1031 const OatHeader& boot_oat_header = oat_file->GetOatHeader();
Jeff Haof0192c82016-03-28 20:39:50 -07001032 const char* boot_cp = boot_oat_header.GetStoreValueByKey(OatHeader::kBootClassPathKey);
Jeff Haodcdc85b2015-12-04 14:06:18 -08001033 if (boot_cp != nullptr) {
Mathieu Chartier866d8742016-09-21 15:24:18 -07001034 gc::space::ImageSpace::ExtractMultiImageLocations(image_locations[0],
1035 boot_cp,
1036 &image_locations);
Jeff Haodcdc85b2015-12-04 14:06:18 -08001037 }
1038 }
1039
1040 Runtime::Current()->GetOatFileManager().RegisterOatFile(std::move(oat_file));
Alex Light84d76052014-08-22 17:49:35 -07001041 }
Alex Light84d76052014-08-22 17:49:35 -07001042 return true;
1043}
1044
1045
Alex Light64ad14d2014-08-19 14:23:13 -07001046static size_t OpenDexFiles(const std::vector<std::string>& dex_filenames,
Richard Uhlerc2752592015-01-02 13:28:22 -08001047 const std::vector<std::string>& dex_locations,
Alex Light84d76052014-08-22 17:49:35 -07001048 const std::string& image_location,
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001049 std::vector<std::unique_ptr<const DexFile>>* dex_files) {
1050 DCHECK(dex_files != nullptr) << "OpenDexFiles: out-param is nullptr";
Alex Light64ad14d2014-08-19 14:23:13 -07001051 size_t failure_count = 0;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001052 if (!image_location.empty() && OpenDexFilesFromImage(image_location, dex_files, &failure_count)) {
Alex Light84d76052014-08-22 17:49:35 -07001053 return failure_count;
1054 }
David Sehr013fd802018-01-11 22:55:24 -08001055 const ArtDexFileLoader dex_file_loader;
Alex Light84d76052014-08-22 17:49:35 -07001056 failure_count = 0;
Alex Light64ad14d2014-08-19 14:23:13 -07001057 for (size_t i = 0; i < dex_filenames.size(); i++) {
1058 const char* dex_filename = dex_filenames[i].c_str();
Richard Uhlerc2752592015-01-02 13:28:22 -08001059 const char* dex_location = dex_locations[i].c_str();
Aart Bik37d6a3b2016-06-21 18:30:10 -07001060 static constexpr bool kVerifyChecksum = true;
Alex Light64ad14d2014-08-19 14:23:13 -07001061 std::string error_msg;
1062 if (!OS::FileExists(dex_filename)) {
1063 LOG(WARNING) << "Skipping non-existent dex file '" << dex_filename << "'";
1064 continue;
1065 }
David Sehr013fd802018-01-11 22:55:24 -08001066 if (!dex_file_loader.Open(dex_filename,
1067 dex_location,
1068 Runtime::Current()->IsVerificationEnabled(),
1069 kVerifyChecksum,
1070 &error_msg,
1071 dex_files)) {
Alex Light64ad14d2014-08-19 14:23:13 -07001072 LOG(WARNING) << "Failed to open .dex from file '" << dex_filename << "': " << error_msg;
1073 ++failure_count;
1074 }
1075 }
1076 return failure_count;
1077}
1078
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001079void Runtime::SetSentinel(mirror::Object* sentinel) {
1080 CHECK(sentinel_.Read() == nullptr);
1081 CHECK(sentinel != nullptr);
Hiroshi Yamauchi04302db2015-11-11 23:45:34 -08001082 CHECK(!heap_->IsMovableObject(sentinel));
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07001083 sentinel_ = GcRoot<mirror::Object>(sentinel);
1084}
1085
Vladimir Marko88b2b802015-12-04 14:19:04 +00001086bool Runtime::Init(RuntimeArgumentMap&& runtime_options_in) {
David Sehrd106d9f2016-08-16 19:22:57 -07001087 // (b/30160149): protect subprocesses from modifications to LD_LIBRARY_PATH, etc.
1088 // Take a snapshot of the environment at the time the runtime was created, for use by Exec, etc.
1089 env_snapshot_.TakeSnapshot();
1090
Andreas Gampe25419b52018-02-08 21:30:26 -08001091 using Opt = RuntimeArgumentMap;
1092 Opt runtime_options(std::move(runtime_options_in));
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001093 ScopedTrace trace(__FUNCTION__);
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001094 CHECK_EQ(sysconf(_SC_PAGE_SIZE), kPageSize);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001095
Andreas Gampe25419b52018-02-08 21:30:26 -08001096 // Early override for logging output.
1097 if (runtime_options.Exists(Opt::UseStderrLogger)) {
1098 android::base::SetLogger(android::base::StderrLogger);
1099 }
1100
Mathieu Chartier6e88ef62014-10-14 15:01:24 -07001101 MemMap::Init();
1102
Andreas Gampe5f2a2fc2017-05-18 17:45:07 -07001103 // Try to reserve a dedicated fault page. This is allocated for clobbered registers and sentinels.
1104 // If we cannot reserve it, log a warning.
1105 // Note: We allocate this first to have a good chance of grabbing the page. The address (0xebad..)
1106 // is out-of-the-way enough that it should not collide with boot image mapping.
1107 // Note: Don't request an error message. That will lead to a maps dump in the case of failure,
1108 // leading to logspam.
1109 {
1110 constexpr uintptr_t kSentinelAddr =
1111 RoundDown(static_cast<uintptr_t>(Context::kBadGprBase), kPageSize);
1112 protected_fault_page_.reset(MemMap::MapAnonymous("Sentinel fault page",
1113 reinterpret_cast<uint8_t*>(kSentinelAddr),
1114 kPageSize,
1115 PROT_NONE,
1116 /* low_4g */ true,
1117 /* reuse */ false,
1118 /* error_msg */ nullptr));
1119 if (protected_fault_page_ == nullptr) {
1120 LOG(WARNING) << "Could not reserve sentinel fault page";
1121 } else if (reinterpret_cast<uintptr_t>(protected_fault_page_->Begin()) != kSentinelAddr) {
1122 LOG(WARNING) << "Could not reserve sentinel fault page at the right address.";
1123 protected_fault_page_.reset();
1124 }
1125 }
1126
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001127 VLOG(startup) << "Runtime::Init -verbose:startup enabled";
Elliott Hughes7ede61e2011-09-14 18:18:06 -07001128
Elliott Hughes7c6169d2012-05-02 16:11:48 -07001129 QuasiAtomic::Startup();
1130
Mathieu Chartiere58991b2015-10-13 07:59:34 -07001131 oat_file_manager_ = new OatFileManager;
Mathieu Chartierf9c6fc62015-10-07 11:44:05 -07001132
Calin Juravleb2771b42016-04-07 17:09:25 +01001133 Thread::SetSensitiveThreadHook(runtime_options.GetOrDefault(Opt::HookIsSensitiveThread));
Andreas Gamped0210e52017-06-23 13:38:09 -07001134 Monitor::Init(runtime_options.GetOrDefault(Opt::LockProfThreshold),
1135 runtime_options.GetOrDefault(Opt::StackDumpLockProfThreshold));
Elliott Hughes32d6e1e2011-10-11 14:47:44 -07001136
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001137 boot_class_path_string_ = runtime_options.ReleaseOrDefault(Opt::BootClassPath);
1138 class_path_string_ = runtime_options.ReleaseOrDefault(Opt::ClassPath);
1139 properties_ = runtime_options.ReleaseOrDefault(Opt::PropertiesList);
Elliott Hughes7ede61e2011-09-14 18:18:06 -07001140
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001141 compiler_callbacks_ = runtime_options.GetOrDefault(Opt::CompilerCallbacksPtr);
1142 patchoat_executable_ = runtime_options.ReleaseOrDefault(Opt::PatchOat);
1143 must_relocate_ = runtime_options.GetOrDefault(Opt::Relocate);
1144 is_zygote_ = runtime_options.Exists(Opt::Zygote);
1145 is_explicit_gc_disabled_ = runtime_options.Exists(Opt::DisableExplicitGC);
1146 dex2oat_enabled_ = runtime_options.GetOrDefault(Opt::Dex2Oat);
1147 image_dex2oat_enabled_ = runtime_options.GetOrDefault(Opt::ImageDex2Oat);
Nicolas Geoffray6ee49712018-03-30 14:39:05 +00001148 dump_native_stack_on_sig_quit_ = runtime_options.GetOrDefault(Opt::DumpNativeStackOnSigQuit);
Elliott Hughes9ca7a1f2011-10-11 14:29:52 -07001149
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001150 vfprintf_ = runtime_options.GetOrDefault(Opt::HookVfprintf);
1151 exit_ = runtime_options.GetOrDefault(Opt::HookExit);
1152 abort_ = runtime_options.GetOrDefault(Opt::HookAbort);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001153
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001154 default_stack_size_ = runtime_options.GetOrDefault(Opt::StackSize);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001155
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001156 compiler_executable_ = runtime_options.ReleaseOrDefault(Opt::Compiler);
1157 compiler_options_ = runtime_options.ReleaseOrDefault(Opt::CompilerOptions);
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00001158 for (StringPiece option : Runtime::Current()->GetCompilerOptions()) {
1159 if (option.starts_with("--debuggable")) {
1160 SetJavaDebuggable(true);
1161 break;
1162 }
1163 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001164 image_compiler_options_ = runtime_options.ReleaseOrDefault(Opt::ImageCompilerOptions);
1165 image_location_ = runtime_options.GetOrDefault(Opt::Image);
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001166
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001167 max_spins_before_thin_lock_inflation_ =
1168 runtime_options.GetOrDefault(Opt::MaxSpinsBeforeThinLockInflation);
Ian Rogersd9c4fc92013-10-01 19:45:43 -07001169
Elliott Hughesc33a32b2011-10-11 18:18:07 -07001170 monitor_list_ = new MonitorList;
Ian Rogersef7d42f2014-01-06 12:55:46 -08001171 monitor_pool_ = MonitorPool::Create();
Mathieu Chartier3fceaf52017-01-22 13:33:40 -08001172 thread_list_ = new ThreadList(runtime_options.GetOrDefault(Opt::ThreadSuspendTimeout));
Elliott Hughescf4c6c42011-09-01 15:16:42 -07001173 intern_table_ = new InternTable;
1174
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001175 verify_ = runtime_options.GetOrDefault(Opt::Verify);
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -07001176 allow_dex_file_fallback_ = !runtime_options.Exists(Opt::NoDexFileFallback);
Logan Chiendd361c92012-04-10 23:40:37 +08001177
David Brazdila7db0262018-01-16 17:13:35 +00001178 target_sdk_version_ = runtime_options.GetOrDefault(Opt::TargetSdkVersion);
1179
David Brazdilad666272018-02-06 20:30:59 +00001180 // Check whether to enforce hidden API access checks. The checks are disabled
1181 // by default and we only enable them if:
1182 // (a) runtime was started with a flag that enables the checks, or
1183 // (b) Zygote forked a new process that is not exempt (see ZygoteHooks).
Mathew Inwood597d7f62018-03-22 11:36:47 +00001184 bool do_hidden_api_checks = runtime_options.Exists(Opt::HiddenApiChecks);
1185 DCHECK(!is_zygote_ || !do_hidden_api_checks);
1186 // TODO pass the actual enforcement policy in, rather than just a single bit.
1187 // As is, we're encoding some logic here about which specific policy to use, which would be better
1188 // controlled by the framework.
1189 hidden_api_policy_ = do_hidden_api_checks
1190 ? hiddenapi::EnforcementPolicy::kBlacklistOnly
1191 : hiddenapi::EnforcementPolicy::kNoChecks;
David Brazdil3e0fa0a2018-01-15 18:41:44 +00001192
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001193 no_sig_chain_ = runtime_options.Exists(Opt::NoSigChain);
Calin Juravled3e7c6c2016-02-04 19:07:51 +00001194 force_native_bridge_ = runtime_options.Exists(Opt::ForceNativeBridge);
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001195
Dmitriy Ivanov785049f2014-07-18 10:08:57 -07001196 Split(runtime_options.GetOrDefault(Opt::CpuAbiList), ',', &cpu_abilist_);
1197
Andreas Gampedd671252015-07-23 14:37:18 -07001198 fingerprint_ = runtime_options.ReleaseOrDefault(Opt::Fingerprint);
1199
Igor Murashkineb6c7c22015-02-04 17:30:43 -08001200 if (runtime_options.GetOrDefault(Opt::Interpret)) {
Ian Rogers62d6c772013-02-27 08:32:07 -08001201 GetInstrumentation()->ForceInterpretOnly();
1202 }
1203
Narayan Kamath5a2be3f2015-02-16 13:51:51 +00001204 zygote_max_failed_boots_ = runtime_options.GetOrDefault(Opt::ZygoteMaxFailedBoots);
Alex Lighteb7c1442015-08-31 13:17:42 -07001205 experimental_flags_ = runtime_options.GetOrDefault(Opt::Experimental);
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -07001206 is_low_memory_mode_ = runtime_options.Exists(Opt::LowMemoryMode);
Mathieu Chartierc42cb0e2017-10-13 11:35:00 -07001207 madvise_random_access_ = runtime_options.GetOrDefault(Opt::MadviseRandomAccess);
Narayan Kamath5a2be3f2015-02-16 13:51:51 +00001208
Andreas Gampe01fd70b2017-01-25 10:03:08 -08001209 plugins_ = runtime_options.ReleaseOrDefault(Opt::Plugins);
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001210 agent_specs_ = runtime_options.ReleaseOrDefault(Opt::AgentPath);
Andreas Gampe01fd70b2017-01-25 10:03:08 -08001211 // TODO Add back in -agentlib
1212 // for (auto lib : runtime_options.ReleaseOrDefault(Opt::AgentLib)) {
1213 // agents_.push_back(lib);
1214 // }
1215
Mathieu Chartier11c273d2017-10-15 20:54:45 -07001216 float foreground_heap_growth_multiplier;
1217 if (is_low_memory_mode_ && !runtime_options.Exists(Opt::ForegroundHeapGrowthMultiplier)) {
1218 // If low memory mode, use 1.0 as the multiplier by default.
1219 foreground_heap_growth_multiplier = 1.0f;
1220 } else {
1221 foreground_heap_growth_multiplier =
1222 runtime_options.GetOrDefault(Opt::ForegroundHeapGrowthMultiplier) +
1223 kExtraDefaultHeapGrowthMultiplier;
1224 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001225 XGcOption xgc_option = runtime_options.GetOrDefault(Opt::GcOption);
1226 heap_ = new gc::Heap(runtime_options.GetOrDefault(Opt::MemoryInitialSize),
1227 runtime_options.GetOrDefault(Opt::HeapGrowthLimit),
1228 runtime_options.GetOrDefault(Opt::HeapMinFree),
1229 runtime_options.GetOrDefault(Opt::HeapMaxFree),
1230 runtime_options.GetOrDefault(Opt::HeapTargetUtilization),
Mathieu Chartier11c273d2017-10-15 20:54:45 -07001231 foreground_heap_growth_multiplier,
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001232 runtime_options.GetOrDefault(Opt::MemoryMaximumSize),
1233 runtime_options.GetOrDefault(Opt::NonMovingSpaceCapacity),
1234 runtime_options.GetOrDefault(Opt::Image),
1235 runtime_options.GetOrDefault(Opt::ImageInstructionSet),
Hiroshi Yamauchi1b0adbf2016-11-14 17:35:12 -08001236 // Override the collector type to CC if the read barrier config.
1237 kUseReadBarrier ? gc::kCollectorTypeCC : xgc_option.collector_type_,
1238 kUseReadBarrier ? BackgroundGcOption(gc::kCollectorTypeCCBackground)
1239 : runtime_options.GetOrDefault(Opt::BackgroundGc),
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001240 runtime_options.GetOrDefault(Opt::LargeObjectSpace),
1241 runtime_options.GetOrDefault(Opt::LargeObjectThreshold),
1242 runtime_options.GetOrDefault(Opt::ParallelGCThreads),
1243 runtime_options.GetOrDefault(Opt::ConcGCThreads),
1244 runtime_options.Exists(Opt::LowMemoryMode),
1245 runtime_options.GetOrDefault(Opt::LongPauseLogThreshold),
1246 runtime_options.GetOrDefault(Opt::LongGCLogThreshold),
1247 runtime_options.Exists(Opt::IgnoreMaxFootprint),
Hiroshi Yamauchif360ad02015-02-20 11:28:03 -08001248 runtime_options.GetOrDefault(Opt::UseTLAB),
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001249 xgc_option.verify_pre_gc_heap_,
1250 xgc_option.verify_pre_sweeping_heap_,
1251 xgc_option.verify_post_gc_heap_,
1252 xgc_option.verify_pre_gc_rosalloc_,
1253 xgc_option.verify_pre_sweeping_rosalloc_,
1254 xgc_option.verify_post_gc_rosalloc_,
Mathieu Chartier31000802015-06-14 14:14:37 -07001255 xgc_option.gcstress_,
Mathieu Chartier56fe2582016-07-14 13:30:03 -07001256 xgc_option.measure_,
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001257 runtime_options.GetOrDefault(Opt::EnableHSpaceCompactForOOM),
1258 runtime_options.GetOrDefault(Opt::HSpaceCompactForOOMMinIntervalsMs));
Dave Allison3d14eb62014-07-10 01:54:57 +00001259
Jeff Haodcdc85b2015-12-04 14:06:18 -08001260 if (!heap_->HasBootImageSpace() && !allow_dex_file_fallback_) {
Jean Christophe Beyler24e04aa2014-09-12 12:03:25 -07001261 LOG(ERROR) << "Dex file fallback disabled, cannot continue without image.";
1262 return false;
1263 }
1264
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001265 dump_gc_performance_on_shutdown_ = runtime_options.Exists(Opt::DumpGCPerformanceOnShutdown);
Dave Allison3d14eb62014-07-10 01:54:57 +00001266
Alex Light40320712017-12-14 11:52:04 -08001267 jdwp_options_ = runtime_options.GetOrDefault(Opt::JdwpOptions);
1268 jdwp_provider_ = runtime_options.GetOrDefault(Opt::JdwpProvider);
1269 switch (jdwp_provider_) {
1270 case JdwpProvider::kNone: {
Alex Light230fa942018-03-08 14:07:02 -08001271 VLOG(jdwp) << "Disabling all JDWP support.";
Alex Lightb06bd682018-01-29 13:26:45 -08001272 if (!jdwp_options_.empty()) {
1273 bool has_transport = jdwp_options_.find("transport") != std::string::npos;
1274 const char* transport_internal = !has_transport ? "transport=dt_android_adb," : "";
1275 std::string adb_connection_args =
1276 std::string(" -XjdwpProvider:adbconnection -XjdwpOptions:") + jdwp_options_;
1277 LOG(WARNING) << "Jdwp options given when jdwp is disabled! You probably want to enable "
1278 << "jdwp with one of:" << std::endl
1279 << " -XjdwpProvider:internal "
1280 << "-XjdwpOptions:" << transport_internal << jdwp_options_ << std::endl
1281 << " -Xplugin:libopenjdkjvmti" << (kIsDebugBuild ? "d" : "") << ".so "
1282 << "-agentpath:libjdwp.so=" << jdwp_options_ << std::endl
1283 << (has_transport ? "" : adb_connection_args);
1284 }
Alex Light40320712017-12-14 11:52:04 -08001285 break;
1286 }
1287 case JdwpProvider::kInternal: {
1288 if (runtime_options.Exists(Opt::JdwpOptions)) {
1289 JDWP::JdwpOptions ops;
1290 if (!JDWP::ParseJdwpOptions(runtime_options.GetOrDefault(Opt::JdwpOptions), &ops)) {
1291 LOG(ERROR) << "failed to parse jdwp options!";
1292 return false;
1293 }
1294 Dbg::ConfigureJdwp(ops);
1295 }
1296 break;
1297 }
Alex Lightfbf96702017-12-14 13:27:13 -08001298 case JdwpProvider::kAdbConnection: {
1299 constexpr const char* plugin_name = kIsDebugBuild ? "libadbconnectiond.so"
1300 : "libadbconnection.so";
1301 plugins_.push_back(Plugin::Create(plugin_name));
1302 }
Sebastien Hertz3be6e9d2015-02-05 16:30:58 +01001303 }
Andreas Gampeac30fa22017-01-18 21:02:36 -08001304 callbacks_->AddThreadLifecycleCallback(Dbg::GetThreadLifecycleCallback());
1305 callbacks_->AddClassLoadCallback(Dbg::GetClassLoadCallback());
Sebastien Hertz3be6e9d2015-02-05 16:30:58 +01001306
Mathieu Chartier455f67c2015-03-17 13:48:29 -07001307 jit_options_.reset(jit::JitOptions::CreateFromRuntimeArguments(runtime_options));
Mathieu Chartier455f67c2015-03-17 13:48:29 -07001308 if (IsAotCompiler()) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08001309 // If we are already the compiler at this point, we must be dex2oat. Don't create the jit in
1310 // this case.
1311 // If runtime_options doesn't have UseJIT set to true then CreateFromRuntimeArguments returns
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001312 // null and we don't create the jit.
Calin Juravleffc87072016-04-20 14:22:09 +01001313 jit_options_->SetUseJitCompilation(false);
1314 jit_options_->SetSaveProfilingInfo(false);
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08001315 }
1316
Mathieu Chartierc6201fa2015-03-12 10:06:33 -07001317 // Use MemMap arena pool for jit, malloc otherwise. Malloc arenas are faster to allocate but
1318 // can't be trimmed as easily.
Mathieu Chartiere401d142015-04-22 13:56:20 -07001319 const bool use_malloc = IsAotCompiler();
David Sehr3215fff2018-04-03 17:10:12 -07001320 if (use_malloc) {
1321 arena_pool_.reset(new MallocArenaPool());
1322 jit_arena_pool_.reset(new MallocArenaPool());
1323 } else {
1324 arena_pool_.reset(new MemMapArenaPool(/* low_4gb */ false));
1325 jit_arena_pool_.reset(new MemMapArenaPool(/* low_4gb */ false, "CompilerMetadata"));
1326 }
Nicolas Geoffray25e04562016-03-01 13:17:58 +00001327
Mathieu Chartier017ed0b2015-09-22 11:04:26 -07001328 if (IsAotCompiler() && Is64BitInstructionSet(kRuntimeISA)) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07001329 // 4gb, no malloc. Explanation in header.
David Sehr3215fff2018-04-03 17:10:12 -07001330 low_4gb_arena_pool_.reset(new MemMapArenaPool(/* low_4gb */ true));
Mathieu Chartierc7853442015-03-27 14:35:38 -07001331 }
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07001332 linear_alloc_.reset(CreateLinearAlloc());
Mathieu Chartierc6201fa2015-03-12 10:06:33 -07001333
Dave Allison3d14eb62014-07-10 01:54:57 +00001334 BlockSignals();
1335 InitPlatformSignalHandlers();
1336
Dave Allison69dfe512014-07-11 17:11:58 +00001337 // Change the implicit checks flags based on runtime architecture.
1338 switch (kRuntimeISA) {
Vladimir Marko33bff252017-11-01 14:35:42 +00001339 case InstructionSet::kArm:
1340 case InstructionSet::kThumb2:
1341 case InstructionSet::kX86:
1342 case InstructionSet::kArm64:
1343 case InstructionSet::kX86_64:
1344 case InstructionSet::kMips:
1345 case InstructionSet::kMips64:
Dave Allison69dfe512014-07-11 17:11:58 +00001346 implicit_null_checks_ = true;
Andreas Gampe928f72b2014-09-09 19:53:48 -07001347 // Installing stack protection does not play well with valgrind.
Evgenii Stepanov1e133742015-05-20 12:30:59 -07001348 implicit_so_checks_ = !(RUNNING_ON_MEMORY_TOOL && kMemoryToolIsValgrind);
Dave Allison69dfe512014-07-11 17:11:58 +00001349 break;
1350 default:
1351 // Keep the defaults.
1352 break;
1353 }
1354
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001355 if (!no_sig_chain_) {
1356 // Dex2Oat's Runtime does not need the signal chain or the fault handler.
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001357 if (implicit_null_checks_ || implicit_so_checks_ || implicit_suspend_checks_) {
1358 fault_manager.Init();
Dave Allison69dfe512014-07-11 17:11:58 +00001359
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001360 // These need to be in a specific order. The null point check handler must be
1361 // after the suspend check and stack overflow check handlers.
1362 //
1363 // Note: the instances attach themselves to the fault manager and are handled by it. The manager
1364 // will delete the instance on Shutdown().
1365 if (implicit_suspend_checks_) {
1366 new SuspensionHandler(&fault_manager);
1367 }
Dave Allison69dfe512014-07-11 17:11:58 +00001368
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001369 if (implicit_so_checks_) {
1370 new StackOverflowHandler(&fault_manager);
1371 }
Dave Allison69dfe512014-07-11 17:11:58 +00001372
Calin Juravle01aaf6e2015-06-19 22:05:39 +01001373 if (implicit_null_checks_) {
1374 new NullPointerHandler(&fault_manager);
1375 }
1376
1377 if (kEnableJavaStackTraceHandler) {
1378 new JavaStackTraceHandler(&fault_manager);
1379 }
Dave Allison69dfe512014-07-11 17:11:58 +00001380 }
1381 }
1382
Richard Uhlerda0a69e2016-10-11 15:06:38 +01001383 std::string error_msg;
1384 java_vm_ = JavaVMExt::Create(this, runtime_options, &error_msg);
1385 if (java_vm_.get() == nullptr) {
1386 LOG(ERROR) << "Could not initialize JavaVMExt: " << error_msg;
1387 return false;
1388 }
Elliott Hughes515a5bc2011-08-17 11:08:34 -07001389
Alex Light185d1342016-08-11 10:48:03 -07001390 // Add the JniEnv handler.
1391 // TODO Refactor this stuff.
1392 java_vm_->AddEnvironmentHook(JNIEnvExt::GetEnvHandler);
1393
Elliott Hughesbe759c62011-09-08 19:38:21 -07001394 Thread::Startup();
Elliott Hughesd92bec42011-09-02 17:04:36 -07001395
Mathieu Chartier664bebf2012-11-12 16:54:11 -08001396 // ClassLinker needs an attached thread, but we can't fully attach a thread without creating
1397 // objects. We can't supply a thread group yet; it will be fixed later. Since we are the main
1398 // thread, we do not get a java peer.
Ian Rogers63557452014-06-04 16:57:15 -07001399 Thread* self = Thread::Attach("main", false, nullptr, false);
Ian Rogersdd7624d2014-03-14 17:43:00 -07001400 CHECK_EQ(self->GetThreadId(), ThreadList::kMainThreadId);
Ian Rogers63557452014-06-04 16:57:15 -07001401 CHECK(self != nullptr);
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001402
Calin Juravleccd56952016-12-15 17:57:38 +00001403 self->SetCanCallIntoJava(!IsAotCompiler());
1404
Brian Carlstromf28bc5b2011-10-26 01:15:03 -07001405 // Set us to runnable so tools using a runtime can allocate and GC by default
Ian Rogers120f1c72012-09-28 17:17:10 -07001406 self->TransitionFromSuspendedToRunnable();
Brian Carlstromf28bc5b2011-10-26 01:15:03 -07001407
Ian Rogersa436fde2013-08-27 23:34:06 -07001408 // Now we're attached, we can take the heap locks and validate the heap.
Ian Rogers141d6222012-04-05 12:23:06 -07001409 GetHeap()->EnableObjectValidation();
1410
Ian Rogers1d54e732013-05-02 21:10:01 -07001411 CHECK_GE(GetHeap()->GetContinuousSpaces().size(), 1U);
Chang Xing605fe242017-07-20 15:57:21 -07001412 if (UNLIKELY(IsAotCompiler())) {
1413 class_linker_ = new AotClassLinker(intern_table_);
1414 } else {
1415 class_linker_ = new ClassLinker(intern_table_);
1416 }
Jeff Haodcdc85b2015-12-04 14:06:18 -08001417 if (GetHeap()->HasBootImageSpace()) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001418 bool result = class_linker_->InitFromBootImage(&error_msg);
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001419 if (!result) {
1420 LOG(ERROR) << "Could not initialize from image: " << error_msg;
1421 return false;
1422 }
Hiroshi Yamauchibd0fb612014-05-20 13:46:00 -07001423 if (kIsDebugBuild) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08001424 for (auto image_space : GetHeap()->GetBootImageSpaces()) {
1425 image_space->VerifyImageAllocations();
1426 }
Hiroshi Yamauchibd0fb612014-05-20 13:46:00 -07001427 }
Sebastien Hertze6c143f2015-01-13 10:10:40 +01001428 if (boot_class_path_string_.empty()) {
1429 // The bootclasspath is not explicitly specified: construct it from the loaded dex files.
1430 const std::vector<const DexFile*>& boot_class_path = GetClassLinker()->GetBootClassPath();
1431 std::vector<std::string> dex_locations;
1432 dex_locations.reserve(boot_class_path.size());
1433 for (const DexFile* dex_file : boot_class_path) {
1434 dex_locations.push_back(dex_file->GetLocation());
1435 }
Andreas Gampe9186ced2016-12-12 14:28:21 -08001436 boot_class_path_string_ = android::base::Join(dex_locations, ':');
Sebastien Hertze6c143f2015-01-13 10:10:40 +01001437 }
Vladimir Markocac5a7e2016-02-22 10:39:50 +00001438 {
1439 ScopedTrace trace2("AddImageStringsToTable");
1440 GetInternTable()->AddImagesStringsToTable(heap_->GetBootImageSpaces());
1441 }
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00001442 if (IsJavaDebuggable()) {
1443 // Now that we have loaded the boot image, deoptimize its methods if we are running
1444 // debuggable, as the code may have been compiled non-debuggable.
1445 DeoptimizeBootImage();
1446 }
Richard Uhlerc2752592015-01-02 13:28:22 -08001447 } else {
Alex Light64ad14d2014-08-19 14:23:13 -07001448 std::vector<std::string> dex_filenames;
Ian Rogers6f3dbba2014-10-14 17:41:57 -07001449 Split(boot_class_path_string_, ':', &dex_filenames);
Richard Uhlerc2752592015-01-02 13:28:22 -08001450
1451 std::vector<std::string> dex_locations;
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001452 if (!runtime_options.Exists(Opt::BootClassPathLocations)) {
Richard Uhlerc2752592015-01-02 13:28:22 -08001453 dex_locations = dex_filenames;
1454 } else {
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001455 dex_locations = runtime_options.GetOrDefault(Opt::BootClassPathLocations);
Richard Uhlerc2752592015-01-02 13:28:22 -08001456 CHECK_EQ(dex_filenames.size(), dex_locations.size());
1457 }
1458
Richard Uhlerfbef44d2014-12-23 09:48:51 -08001459 std::vector<std::unique_ptr<const DexFile>> boot_class_path;
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001460 if (runtime_options.Exists(Opt::BootClassPathDexList)) {
1461 boot_class_path.swap(*runtime_options.GetOrDefault(Opt::BootClassPathDexList));
1462 } else {
1463 OpenDexFiles(dex_filenames,
1464 dex_locations,
1465 runtime_options.GetOrDefault(Opt::Image),
1466 &boot_class_path);
1467 }
Jeff Haoc7d11882015-02-03 15:08:39 -08001468 instruction_set_ = runtime_options.GetOrDefault(Opt::ImageInstructionSet);
Andreas Gampe3db9c5d2015-11-17 11:52:46 -08001469 if (!class_linker_->InitWithoutImage(std::move(boot_class_path), &error_msg)) {
1470 LOG(ERROR) << "Could not initialize without image: " << error_msg;
1471 return false;
1472 }
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001473
Alex Light64ad14d2014-08-19 14:23:13 -07001474 // TODO: Should we move the following to InitWithoutImage?
Jeff Haoc7d11882015-02-03 15:08:39 -08001475 SetInstructionSet(instruction_set_);
Andreas Gampe8228cdf2017-05-30 15:03:54 -07001476 for (uint32_t i = 0; i < kCalleeSaveSize; i++) {
1477 CalleeSaveType type = CalleeSaveType(i);
Alex Light64ad14d2014-08-19 14:23:13 -07001478 if (!HasCalleeSaveMethod(type)) {
Ian Rogers6a3c1fc2014-10-31 00:33:20 -07001479 SetCalleeSaveMethod(CreateCalleeSaveMethod(), type);
Alex Light64ad14d2014-08-19 14:23:13 -07001480 }
1481 }
Igor Murashkina2cfee32015-01-07 16:37:24 -08001482 }
1483
Ian Rogers63557452014-06-04 16:57:15 -07001484 CHECK(class_linker_ != nullptr);
Ian Rogersc0542af2014-09-03 16:16:56 -07001485
Sameer Abu Asal51a5fb72013-02-19 14:25:01 -08001486 verifier::MethodVerifier::Init();
Brian Carlstrom6ea095a2011-08-16 15:26:54 -07001487
Andreas Gampef6a780a2015-04-02 18:51:05 -07001488 if (runtime_options.Exists(Opt::MethodTrace)) {
1489 trace_config_.reset(new TraceConfig());
1490 trace_config_->trace_file = runtime_options.ReleaseOrDefault(Opt::MethodTraceFile);
1491 trace_config_->trace_file_size = runtime_options.ReleaseOrDefault(Opt::MethodTraceFileSize);
1492 trace_config_->trace_mode = Trace::TraceMode::kMethodTracing;
Andreas Gampe40da2862015-02-27 12:49:04 -08001493 trace_config_->trace_output_mode = runtime_options.Exists(Opt::MethodTraceStreaming) ?
1494 Trace::TraceOutputMode::kStreaming :
1495 Trace::TraceOutputMode::kFile;
Andreas Gampef6a780a2015-04-02 18:51:05 -07001496 }
jeffhaob5e81852012-03-12 11:15:45 -07001497
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08001498 // TODO: move this to just be an Trace::Start argument
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001499 Trace::SetDefaultClockSource(runtime_options.GetOrDefault(Opt::ProfileClock));
Dave Allison0aded082013-11-07 13:15:11 -08001500
Roland Levillain7b0e8442018-04-11 18:27:47 +01001501 // Pre-allocate an OutOfMemoryError for the case when we fail to
1502 // allocate the exception to be thrown.
1503 InitPreAllocatedException(self,
1504 &Runtime::pre_allocated_OutOfMemoryError_when_throwing_exception_,
1505 "Ljava/lang/OutOfMemoryError;",
1506 "OutOfMemoryError thrown while trying to throw an exception; "
1507 "no stack trace available");
Ian Rogersa436fde2013-08-27 23:34:06 -07001508 // Pre-allocate an OutOfMemoryError for the double-OOME case.
Roland Levillain7b0e8442018-04-11 18:27:47 +01001509 InitPreAllocatedException(self,
1510 &Runtime::pre_allocated_OutOfMemoryError_when_throwing_oome_,
1511 "Ljava/lang/OutOfMemoryError;",
1512 "OutOfMemoryError thrown while trying to throw OutOfMemoryError; "
1513 "no stack trace available");
1514 // Pre-allocate an OutOfMemoryError for the case when we fail to
1515 // allocate while handling a stack overflow.
1516 InitPreAllocatedException(self,
1517 &Runtime::pre_allocated_OutOfMemoryError_when_handling_stack_overflow_,
1518 "Ljava/lang/OutOfMemoryError;",
1519 "OutOfMemoryError thrown while trying to handle a stack overflow; "
1520 "no stack trace available");
Ian Rogersa436fde2013-08-27 23:34:06 -07001521
Ian Rogers63557452014-06-04 16:57:15 -07001522 // Pre-allocate a NoClassDefFoundError for the common case of failing to find a system class
1523 // ahead of checking the application's class loader.
Roland Levillain7b0e8442018-04-11 18:27:47 +01001524 InitPreAllocatedException(self,
1525 &Runtime::pre_allocated_NoClassDefFoundError_,
1526 "Ljava/lang/NoClassDefFoundError;",
1527 "Class not found using the boot class loader; "
1528 "no stack trace available");
Ian Rogers63557452014-06-04 16:57:15 -07001529
Alex Light185d1342016-08-11 10:48:03 -07001530 // Runtime initialization is largely done now.
1531 // We load plugins first since that can modify the runtime state slightly.
1532 // Load all plugins
1533 for (auto& plugin : plugins_) {
1534 std::string err;
1535 if (!plugin.Load(&err)) {
1536 LOG(FATAL) << plugin << " failed to load: " << err;
1537 }
1538 }
1539
Andreas Gampe855564b2014-07-25 02:32:19 -07001540 // Look for a native bridge.
Andreas Gampe6be67ee2014-09-02 21:22:18 -07001541 //
1542 // The intended flow here is, in the case of a running system:
1543 //
1544 // Runtime::Init() (zygote):
1545 // LoadNativeBridge -> dlopen from cmd line parameter.
1546 // |
1547 // V
1548 // Runtime::Start() (zygote):
1549 // No-op wrt native bridge.
1550 // |
1551 // | start app
1552 // V
1553 // DidForkFromZygote(action)
1554 // action = kUnload -> dlclose native bridge.
1555 // action = kInitialize -> initialize library
1556 //
1557 //
1558 // The intended flow here is, in the case of a simple dalvikvm call:
1559 //
1560 // Runtime::Init():
1561 // LoadNativeBridge -> dlopen from cmd line parameter.
1562 // |
1563 // V
1564 // Runtime::Start():
1565 // DidForkFromZygote(kInitialize) -> try to initialize any native bridge given.
1566 // No-op wrt native bridge.
Igor Murashkinaaebaa02015-01-26 10:55:53 -08001567 {
1568 std::string native_bridge_file_name = runtime_options.ReleaseOrDefault(Opt::NativeBridge);
1569 is_native_bridge_loaded_ = LoadNativeBridge(native_bridge_file_name);
1570 }
Calin Juravlea68629e2014-08-22 12:53:59 +01001571
Alex Light7233c7e2016-07-28 10:07:45 -07001572 // Startup agents
1573 // TODO Maybe we should start a new thread to run these on. Investigate RI behavior more.
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001574 for (auto& agent_spec : agent_specs_) {
Alex Light7233c7e2016-07-28 10:07:45 -07001575 // TODO Check err
1576 int res = 0;
1577 std::string err = "";
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001578 ti::LoadError error;
1579 std::unique_ptr<ti::Agent> agent = agent_spec.Load(&res, &error, &err);
1580
1581 if (agent != nullptr) {
1582 agents_.push_back(std::move(agent));
1583 continue;
Alex Light7233c7e2016-07-28 10:07:45 -07001584 }
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001585
1586 switch (error) {
1587 case ti::LoadError::kInitializationError:
1588 LOG(FATAL) << "Unable to initialize agent!";
1589 UNREACHABLE();
1590
1591 case ti::LoadError::kLoadingError:
1592 LOG(ERROR) << "Unable to load an agent: " << err;
1593 continue;
1594
1595 case ti::LoadError::kNoError:
1596 break;
1597 }
1598 LOG(FATAL) << "Unreachable";
1599 UNREACHABLE();
Alex Light7233c7e2016-07-28 10:07:45 -07001600 }
Andreas Gampe96eca782017-01-19 19:45:30 -08001601 {
1602 ScopedObjectAccess soa(self);
1603 callbacks_->NextRuntimePhase(RuntimePhaseCallback::RuntimePhase::kInitialAgents);
1604 }
Alex Light7233c7e2016-07-28 10:07:45 -07001605
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001606 VLOG(startup) << "Runtime::Init exiting";
Mathieu Chartiere401d142015-04-22 13:56:20 -07001607
Nicolas Geoffray66ff8a82018-02-28 13:27:55 +00001608 // Set OnlyUseSystemOatFiles only after boot classpath has been set up.
1609 if (runtime_options.Exists(Opt::OnlyUseSystemOatFiles)) {
1610 oat_file_manager_->SetOnlyUseSystemOatFiles();
1611 }
1612
Carl Shapiro1fb86202011-06-27 17:43:13 -07001613 return true;
1614}
1615
Andreas Gampec4baad22017-01-12 16:59:39 +00001616static bool EnsureJvmtiPlugin(Runtime* runtime,
1617 std::vector<Plugin>* plugins,
1618 std::string* error_msg) {
1619 constexpr const char* plugin_name = kIsDebugBuild ? "libopenjdkjvmtid.so" : "libopenjdkjvmti.so";
1620
1621 // Is the plugin already loaded?
Andreas Gampe96eca782017-01-19 19:45:30 -08001622 for (const Plugin& p : *plugins) {
Andreas Gampec4baad22017-01-12 16:59:39 +00001623 if (p.GetLibrary() == plugin_name) {
1624 return true;
1625 }
1626 }
1627
Alex Lightf889c702018-02-23 15:25:45 -08001628 // TODO Rename Dbg::IsJdwpAllowed is IsDebuggingAllowed.
1629 DCHECK(Dbg::IsJdwpAllowed() || !runtime->IsJavaDebuggable())
1630 << "Being debuggable requires that jdwp (i.e. debugging) is allowed.";
Alex Light2ce6fc82017-12-18 16:42:36 -08001631 // Is the process debuggable? Otherwise, do not attempt to load the plugin unless we are
1632 // specifically allowed.
Alex Lightf889c702018-02-23 15:25:45 -08001633 if (!Dbg::IsJdwpAllowed()) {
1634 *error_msg = "Process is not allowed to load openjdkjvmti plugin. Process must be debuggable";
Andreas Gampec4baad22017-01-12 16:59:39 +00001635 return false;
1636 }
1637
1638 Plugin new_plugin = Plugin::Create(plugin_name);
1639
Andreas Gampec4baad22017-01-12 16:59:39 +00001640 if (!new_plugin.Load(error_msg)) {
1641 return false;
1642 }
1643
1644 plugins->push_back(std::move(new_plugin));
1645 return true;
1646}
1647
Leonard Mosescueb842212016-10-06 17:26:36 -07001648// Attach a new agent and add it to the list of runtime agents
1649//
1650// TODO: once we decide on the threading model for agents,
1651// revisit this and make sure we're doing this on the right thread
1652// (and we synchronize access to any shared data structures like "agents_")
1653//
Alex Lightf889c702018-02-23 15:25:45 -08001654void Runtime::AttachAgent(JNIEnv* env, const std::string& agent_arg, jobject class_loader) {
Andreas Gampec4baad22017-01-12 16:59:39 +00001655 std::string error_msg;
Alex Lightf889c702018-02-23 15:25:45 -08001656 if (!EnsureJvmtiPlugin(this, &plugins_, &error_msg)) {
Andreas Gampec4baad22017-01-12 16:59:39 +00001657 LOG(WARNING) << "Could not load plugin: " << error_msg;
1658 ScopedObjectAccess soa(Thread::Current());
1659 ThrowIOException("%s", error_msg.c_str());
1660 return;
1661 }
1662
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001663 ti::AgentSpec agent_spec(agent_arg);
Leonard Mosescueb842212016-10-06 17:26:36 -07001664
1665 int res = 0;
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001666 ti::LoadError error;
Andreas Gampe7b38e692017-12-28 19:18:28 -08001667 std::unique_ptr<ti::Agent> agent = agent_spec.Attach(env, class_loader, &res, &error, &error_msg);
Leonard Mosescueb842212016-10-06 17:26:36 -07001668
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001669 if (agent != nullptr) {
Leonard Mosescueb842212016-10-06 17:26:36 -07001670 agents_.push_back(std::move(agent));
1671 } else {
Andreas Gampeaadcbc62017-12-28 14:05:42 -08001672 LOG(WARNING) << "Agent attach failed (result=" << error << ") : " << error_msg;
Leonard Mosescueb842212016-10-06 17:26:36 -07001673 ScopedObjectAccess soa(Thread::Current());
Andreas Gampec4baad22017-01-12 16:59:39 +00001674 ThrowIOException("%s", error_msg.c_str());
Leonard Mosescueb842212016-10-06 17:26:36 -07001675 }
1676}
1677
Roland Levillain7b0e8442018-04-11 18:27:47 +01001678void Runtime::InitPreAllocatedException(Thread* self,
1679 GcRoot<mirror::Throwable> Runtime::* exception,
1680 const char* exception_class_descriptor,
1681 const char* msg) {
1682 DCHECK_EQ(self, Thread::Current());
1683 self->ThrowNewException(exception_class_descriptor, msg);
1684 this->*exception = GcRoot<mirror::Throwable>(self->GetException());
1685 self->ClearException();
1686}
1687
Elliott Hughes038a8062011-09-18 14:12:41 -07001688void Runtime::InitNativeMethods() {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001689 VLOG(startup) << "Runtime::InitNativeMethods entering";
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001690 Thread* self = Thread::Current();
1691 JNIEnv* env = self->GetJniEnv();
1692
Elliott Hughes418d20f2011-09-22 14:00:39 -07001693 // Must be in the kNative state for calling native methods (JNI_OnLoad code).
Ian Rogers50b35e22012-10-04 10:09:15 -07001694 CHECK_EQ(self->GetState(), kNative);
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001695
Andreas Gamped863be72017-09-12 12:02:28 -07001696 // Set up the native methods provided by the runtime itself.
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001697 RegisterRuntimeNativeMethods(env);
1698
Yi Kong0871cd72015-11-20 16:00:31 +00001699 // Initialize classes used in JNI. The initialization requires runtime native
1700 // methods to be loaded first.
1701 WellKnownClasses::Init(env);
1702
Narayan Kamathd7b3c7f2015-11-18 09:49:10 +00001703 // Then set up libjavacore / libopenjdk, which are just a regular JNI libraries with
Narayan Kamathd1ef4362015-11-12 11:49:06 +00001704 // a regular JNI_OnLoad. Most JNI libraries can just use System.loadLibrary, but
1705 // libcore can't because it's the library that implements System.loadLibrary!
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001706 {
Dmitriy Ivanov44409d32015-11-11 14:18:55 -08001707 std::string error_msg;
Andreas Gampe473191c2017-12-28 16:55:31 -08001708 if (!java_vm_->LoadNativeLibrary(env, "libjavacore.so", nullptr, &error_msg)) {
Dmitriy Ivanov44409d32015-11-11 14:18:55 -08001709 LOG(FATAL) << "LoadNativeLibrary failed for \"libjavacore.so\": " << error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001710 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001711 }
Piotr Jastrzebski8ca90772015-04-24 09:18:00 +01001712 {
Andreas Gampe10edbb12016-01-06 17:59:49 -08001713 constexpr const char* kOpenJdkLibrary = kIsDebugBuild
1714 ? "libopenjdkd.so"
1715 : "libopenjdk.so";
Dmitriy Ivanov3e381722015-11-23 17:40:11 -08001716 std::string error_msg;
Andreas Gampe473191c2017-12-28 16:55:31 -08001717 if (!java_vm_->LoadNativeLibrary(env, kOpenJdkLibrary, nullptr, &error_msg)) {
Andreas Gampe10edbb12016-01-06 17:59:49 -08001718 LOG(FATAL) << "LoadNativeLibrary failed for \"" << kOpenJdkLibrary << "\": " << error_msg;
Piotr Jastrzebski8ca90772015-04-24 09:18:00 +01001719 }
Piotr Jastrzebski8ca90772015-04-24 09:18:00 +01001720 }
Ian Rogersef28b142012-11-30 14:22:18 -08001721
1722 // Initialize well known classes that may invoke runtime native methods.
1723 WellKnownClasses::LateInit(env);
1724
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08001725 VLOG(startup) << "Runtime::InitNativeMethods exiting";
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001726}
1727
Jean-Philippe Halimica76a1a2016-02-02 19:48:52 +01001728void Runtime::ReclaimArenaPoolMemory() {
1729 arena_pool_->LockReclaimMemory();
1730}
1731
Ian Rogers365c1022012-06-22 15:05:28 -07001732void Runtime::InitThreadGroups(Thread* self) {
1733 JNIEnvExt* env = self->GetJniEnv();
1734 ScopedJniEnvLocalRefState env_state(env);
1735 main_thread_group_ =
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08001736 env->NewGlobalRef(env->GetStaticObjectField(
1737 WellKnownClasses::java_lang_ThreadGroup,
1738 WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup));
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001739 CHECK(main_thread_group_ != nullptr || IsAotCompiler());
Ian Rogers365c1022012-06-22 15:05:28 -07001740 system_thread_group_ =
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08001741 env->NewGlobalRef(env->GetStaticObjectField(
1742 WellKnownClasses::java_lang_ThreadGroup,
1743 WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup));
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001744 CHECK(system_thread_group_ != nullptr || IsAotCompiler());
Brian Carlstrom034f76b2012-08-01 15:51:58 -07001745}
1746
1747jobject Runtime::GetMainThreadGroup() const {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001748 CHECK(main_thread_group_ != nullptr || IsAotCompiler());
Brian Carlstrom034f76b2012-08-01 15:51:58 -07001749 return main_thread_group_;
1750}
1751
1752jobject Runtime::GetSystemThreadGroup() const {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001753 CHECK(system_thread_group_ != nullptr || IsAotCompiler());
Brian Carlstrom034f76b2012-08-01 15:51:58 -07001754 return system_thread_group_;
Ian Rogers365c1022012-06-22 15:05:28 -07001755}
1756
Brian Carlstromce888532013-10-10 00:32:58 -07001757jobject Runtime::GetSystemClassLoader() const {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001758 CHECK(system_class_loader_ != nullptr || IsAotCompiler());
Brian Carlstromce888532013-10-10 00:32:58 -07001759 return system_class_loader_;
1760}
1761
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001762void Runtime::RegisterRuntimeNativeMethods(JNIEnv* env) {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001763 register_dalvik_system_DexFile(env);
1764 register_dalvik_system_VMDebug(env);
1765 register_dalvik_system_VMRuntime(env);
1766 register_dalvik_system_VMStack(env);
1767 register_dalvik_system_ZygoteHooks(env);
1768 register_java_lang_Class(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001769 register_java_lang_Object(env);
Narayan Kamathbd2fed52017-01-25 10:46:54 +00001770 register_java_lang_invoke_MethodHandleImpl(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001771 register_java_lang_ref_FinalizerReference(env);
1772 register_java_lang_reflect_Array(env);
1773 register_java_lang_reflect_Constructor(env);
Neil Fuller0e844392016-09-08 13:43:31 +01001774 register_java_lang_reflect_Executable(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001775 register_java_lang_reflect_Field(env);
1776 register_java_lang_reflect_Method(env);
Neil Fuller60458a02016-09-01 15:32:44 +01001777 register_java_lang_reflect_Parameter(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001778 register_java_lang_reflect_Proxy(env);
1779 register_java_lang_ref_Reference(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001780 register_java_lang_String(env);
Jeff Hao848f70a2014-01-15 13:49:50 -08001781 register_java_lang_StringFactory(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001782 register_java_lang_System(env);
1783 register_java_lang_Thread(env);
1784 register_java_lang_Throwable(env);
1785 register_java_lang_VMClassLoader(env);
1786 register_java_util_concurrent_atomic_AtomicLong(env);
Jeff Hao848f70a2014-01-15 13:49:50 -08001787 register_libcore_util_CharsetUtils(env);
Andreas Gampe277ccbd2014-11-03 21:36:10 -08001788 register_org_apache_harmony_dalvik_ddmc_DdmServer(env);
1789 register_org_apache_harmony_dalvik_ddmc_DdmVmInternal(env);
1790 register_sun_misc_Unsafe(env);
Elliott Hughesad7c2a32011-08-31 11:58:10 -07001791}
1792
Nicolas Geoffray4e92c3c2017-05-08 09:34:26 +01001793std::ostream& operator<<(std::ostream& os, const DeoptimizationKind& kind) {
1794 os << GetDeoptimizationKindName(kind);
1795 return os;
1796}
1797
1798void Runtime::DumpDeoptimizations(std::ostream& os) {
1799 for (size_t i = 0; i <= static_cast<size_t>(DeoptimizationKind::kLast); ++i) {
1800 if (deoptimization_counts_[i] != 0) {
1801 os << "Number of "
1802 << GetDeoptimizationKindName(static_cast<DeoptimizationKind>(i))
1803 << " deoptimizations: "
1804 << deoptimization_counts_[i]
1805 << "\n";
1806 }
1807 }
1808}
1809
Elliott Hughesc967f782012-04-16 10:23:15 -07001810void Runtime::DumpForSigQuit(std::ostream& os) {
Elliott Hughescac6cc72011-11-03 20:31:21 -07001811 GetClassLinker()->DumpForSigQuit(os);
1812 GetInternTable()->DumpForSigQuit(os);
Elliott Hughesae80b492012-04-24 10:43:17 -07001813 GetJavaVM()->DumpForSigQuit(os);
Elliott Hughesc967f782012-04-16 10:23:15 -07001814 GetHeap()->DumpForSigQuit(os);
Nicolas Geoffray04680f32016-03-17 11:56:54 +00001815 oat_file_manager_->DumpForSigQuit(os);
Nicolas Geoffrayaee21562015-12-15 16:39:44 +00001816 if (GetJit() != nullptr) {
1817 GetJit()->DumpForSigQuit(os);
1818 } else {
1819 os << "Running non JIT\n";
1820 }
Nicolas Geoffray4e92c3c2017-05-08 09:34:26 +01001821 DumpDeoptimizations(os);
Mathieu Chartierbad02672014-08-25 13:08:22 -07001822 TrackedAllocators::Dump(os);
Elliott Hughes42ee1422011-09-06 12:33:32 -07001823 os << "\n";
Elliott Hughes8daa0922011-09-11 13:46:25 -07001824
Elliott Hughesc967f782012-04-16 10:23:15 -07001825 thread_list_->DumpForSigQuit(os);
Ian Rogers56edc432013-01-18 16:51:51 -08001826 BaseMutex::DumpAll(os);
Andreas Gampea5814f92017-01-18 21:43:16 -08001827
1828 // Inform anyone else who is interested in SigQuit.
1829 {
1830 ScopedObjectAccess soa(Thread::Current());
1831 callbacks_->SigQuit();
1832 }
Elliott Hughese27955c2011-08-26 15:21:24 -07001833}
1834
Elliott Hughes21a5bf22011-12-07 14:35:20 -08001835void Runtime::DumpLockHolders(std::ostream& os) {
Ian Rogersb726dcb2012-09-05 08:57:23 -07001836 uint64_t mutator_lock_owner = Locks::mutator_lock_->GetExclusiveOwnerTid();
Elliott Hughes21a5bf22011-12-07 14:35:20 -08001837 pid_t thread_list_lock_owner = GetThreadList()->GetLockOwner();
1838 pid_t classes_lock_owner = GetClassLinker()->GetClassesLockOwner();
1839 pid_t dex_lock_owner = GetClassLinker()->GetDexLockOwner();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001840 if ((thread_list_lock_owner | classes_lock_owner | dex_lock_owner) != 0) {
1841 os << "Mutator lock exclusive owner tid: " << mutator_lock_owner << "\n"
Elliott Hughes21a5bf22011-12-07 14:35:20 -08001842 << "ThreadList lock owner tid: " << thread_list_lock_owner << "\n"
1843 << "ClassLinker classes lock owner tid: " << classes_lock_owner << "\n"
1844 << "ClassLinker dex lock owner tid: " << dex_lock_owner << "\n";
1845 }
1846}
1847
Mathieu Chartier9ef78b52014-09-25 17:03:12 -07001848void Runtime::SetStatsEnabled(bool new_state) {
1849 Thread* self = Thread::Current();
1850 MutexLock mu(self, *Locks::instrument_entrypoints_lock_);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001851 if (new_state == true) {
1852 GetStats()->Clear(~0);
1853 // TODO: wouldn't it make more sense to clear _all_ threads' stats?
Mathieu Chartier9ef78b52014-09-25 17:03:12 -07001854 self->GetStats()->Clear(~0);
1855 if (stats_enabled_ != new_state) {
1856 GetInstrumentation()->InstrumentQuickAllocEntryPointsLocked();
1857 }
1858 } else if (stats_enabled_ != new_state) {
1859 GetInstrumentation()->UninstrumentQuickAllocEntryPointsLocked();
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001860 }
1861 stats_enabled_ = new_state;
1862}
1863
1864void Runtime::ResetStats(int kinds) {
1865 GetStats()->Clear(kinds & 0xffff);
1866 // TODO: wouldn't it make more sense to clear _all_ threads' stats?
1867 Thread::Current()->GetStats()->Clear(kinds >> 16);
1868}
1869
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001870int32_t Runtime::GetStat(int kind) {
1871 RuntimeStats* stats;
1872 if (kind < (1<<16)) {
1873 stats = GetStats();
1874 } else {
1875 stats = Thread::Current()->GetStats();
1876 kind >>= 16;
1877 }
1878 switch (kind) {
1879 case KIND_ALLOCATED_OBJECTS:
1880 return stats->allocated_objects;
1881 case KIND_ALLOCATED_BYTES:
1882 return stats->allocated_bytes;
1883 case KIND_FREED_OBJECTS:
1884 return stats->freed_objects;
1885 case KIND_FREED_BYTES:
1886 return stats->freed_bytes;
1887 case KIND_GC_INVOCATIONS:
1888 return stats->gc_for_alloc_count;
1889 case KIND_CLASS_INIT_COUNT:
1890 return stats->class_init_count;
1891 case KIND_CLASS_INIT_TIME:
1892 // Convert ns to us, reduce to 32 bits.
Elliott Hughes398f64b2012-03-26 18:05:48 -07001893 return static_cast<int>(stats->class_init_time_ns / 1000);
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001894 case KIND_EXT_ALLOCATED_OBJECTS:
1895 case KIND_EXT_ALLOCATED_BYTES:
1896 case KIND_EXT_FREED_OBJECTS:
1897 case KIND_EXT_FREED_BYTES:
1898 return 0; // backward compatibility
1899 default:
Elliott Hughes7b9d9962012-04-20 18:48:18 -07001900 LOG(FATAL) << "Unknown statistic " << kind;
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001901 return -1; // unreachable
Elliott Hughes9d5ccec2011-09-19 13:19:50 -07001902 }
1903}
1904
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001905void Runtime::BlockSignals() {
Elliott Hughes457005c2012-04-16 13:54:25 -07001906 SignalSet signals;
1907 signals.Add(SIGPIPE);
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001908 // SIGQUIT is used to dump the runtime's state (including stack traces).
Elliott Hughes457005c2012-04-16 13:54:25 -07001909 signals.Add(SIGQUIT);
Elliott Hughes08795042012-04-03 14:48:52 -07001910 // SIGUSR1 is used to initiate a GC.
Elliott Hughes457005c2012-04-16 13:54:25 -07001911 signals.Add(SIGUSR1);
1912 signals.Block();
Elliott Hughesc1674ed2011-08-25 18:09:09 -07001913}
1914
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001915bool Runtime::AttachCurrentThread(const char* thread_name, bool as_daemon, jobject thread_group,
Mathieu Chartier664bebf2012-11-12 16:54:11 -08001916 bool create_peer) {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001917 ScopedTrace trace(__FUNCTION__);
Andreas Gampe56776012018-01-26 17:40:55 -08001918 Thread* self = Thread::Attach(thread_name, as_daemon, thread_group, create_peer);
1919 // Run ThreadGroup.add to notify the group that this thread is now started.
1920 if (self != nullptr && create_peer && !IsAotCompiler()) {
1921 ScopedObjectAccess soa(self);
1922 self->NotifyThreadGroup(soa, thread_group);
1923 }
1924 return self != nullptr;
Carl Shapiro61e019d2011-07-14 16:53:09 -07001925}
1926
Elliott Hughesd92bec42011-09-02 17:04:36 -07001927void Runtime::DetachCurrentThread() {
Mathieu Chartier32ce2ad2016-03-04 14:58:03 -08001928 ScopedTrace trace(__FUNCTION__);
Brian Carlstrom4d571432012-05-16 00:21:41 -07001929 Thread* self = Thread::Current();
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001930 if (self == nullptr) {
Brian Carlstrom4d571432012-05-16 00:21:41 -07001931 LOG(FATAL) << "attempting to detach thread that is not attached";
1932 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001933 if (self->HasManagedStack()) {
Elliott Hughes22869a92012-03-27 14:08:24 -07001934 LOG(FATAL) << *Thread::Current() << " attempting to detach while still running code";
1935 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001936 thread_list_->Unregister(self);
Carl Shapiro1fb86202011-06-27 17:43:13 -07001937}
1938
Roland Levillain7b0e8442018-04-11 18:27:47 +01001939mirror::Throwable* Runtime::GetPreAllocatedOutOfMemoryErrorWhenThrowingException() {
1940 mirror::Throwable* oome = pre_allocated_OutOfMemoryError_when_throwing_exception_.Read();
Ian Rogers63557452014-06-04 16:57:15 -07001941 if (oome == nullptr) {
Roland Levillain7b0e8442018-04-11 18:27:47 +01001942 LOG(ERROR) << "Failed to return pre-allocated OOME-when-throwing-exception";
1943 }
1944 return oome;
1945}
1946
1947mirror::Throwable* Runtime::GetPreAllocatedOutOfMemoryErrorWhenThrowingOOME() {
1948 mirror::Throwable* oome = pre_allocated_OutOfMemoryError_when_throwing_oome_.Read();
1949 if (oome == nullptr) {
1950 LOG(ERROR) << "Failed to return pre-allocated OOME-when-throwing-OOME";
1951 }
1952 return oome;
1953}
1954
1955mirror::Throwable* Runtime::GetPreAllocatedOutOfMemoryErrorWhenHandlingStackOverflow() {
1956 mirror::Throwable* oome = pre_allocated_OutOfMemoryError_when_handling_stack_overflow_.Read();
1957 if (oome == nullptr) {
1958 LOG(ERROR) << "Failed to return pre-allocated OOME-when-handling-stack-overflow";
Ian Rogersa436fde2013-08-27 23:34:06 -07001959 }
Hiroshi Yamauchiab088112014-07-14 13:00:14 -07001960 return oome;
Ian Rogersa436fde2013-08-27 23:34:06 -07001961}
1962
Ian Rogers63557452014-06-04 16:57:15 -07001963mirror::Throwable* Runtime::GetPreAllocatedNoClassDefFoundError() {
1964 mirror::Throwable* ncdfe = pre_allocated_NoClassDefFoundError_.Read();
1965 if (ncdfe == nullptr) {
1966 LOG(ERROR) << "Failed to return pre-allocated NoClassDefFoundError";
1967 }
1968 return ncdfe;
1969}
1970
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001971void Runtime::VisitConstantRoots(RootVisitor* visitor) {
Mathieu Chartier893263b2014-03-04 11:07:42 -08001972 // Visit the classes held as static in mirror classes, these can be visited concurrently and only
Mathieu Chartier3b05e9b2014-03-25 09:29:43 -07001973 // need to be visited once per GC since they never change.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001974 mirror::Class::VisitRoots(visitor);
Mathieu Chartierfc58af42015-04-16 18:00:39 -07001975 mirror::Constructor::VisitRoots(visitor);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001976 mirror::Reference::VisitRoots(visitor);
Mathieu Chartierfc58af42015-04-16 18:00:39 -07001977 mirror::Method::VisitRoots(visitor);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001978 mirror::StackTraceElement::VisitRoots(visitor);
1979 mirror::String::VisitRoots(visitor);
1980 mirror::Throwable::VisitRoots(visitor);
1981 mirror::Field::VisitRoots(visitor);
Narayan Kamathafa48272016-08-03 12:46:58 +01001982 mirror::MethodType::VisitRoots(visitor);
1983 mirror::MethodHandleImpl::VisitRoots(visitor);
Orion Hodsonc069a302017-01-18 09:23:12 +00001984 mirror::MethodHandlesLookup::VisitRoots(visitor);
Narayan Kamath000e1882016-10-24 17:14:25 +01001985 mirror::EmulatedStackFrame::VisitRoots(visitor);
Alex Lightcec2fd42016-11-02 16:32:07 -07001986 mirror::ClassExt::VisitRoots(visitor);
Mathieu Chartiera25504e2017-04-18 16:14:19 -07001987 mirror::CallSite::VisitRoots(visitor);
Orion Hodson928033d2018-02-07 05:30:54 +00001988 mirror::VarHandle::VisitRoots(visitor);
1989 mirror::FieldVarHandle::VisitRoots(visitor);
1990 mirror::ArrayElementVarHandle::VisitRoots(visitor);
1991 mirror::ByteArrayViewVarHandle::VisitRoots(visitor);
1992 mirror::ByteBufferViewVarHandle::VisitRoots(visitor);
Mathieu Chartierc528dba2013-11-26 12:00:11 -08001993 // Visit all the primitive array types classes.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07001994 mirror::PrimitiveArray<uint8_t>::VisitRoots(visitor); // BooleanArray
1995 mirror::PrimitiveArray<int8_t>::VisitRoots(visitor); // ByteArray
1996 mirror::PrimitiveArray<uint16_t>::VisitRoots(visitor); // CharArray
1997 mirror::PrimitiveArray<double>::VisitRoots(visitor); // DoubleArray
1998 mirror::PrimitiveArray<float>::VisitRoots(visitor); // FloatArray
1999 mirror::PrimitiveArray<int32_t>::VisitRoots(visitor); // IntArray
2000 mirror::PrimitiveArray<int64_t>::VisitRoots(visitor); // LongArray
2001 mirror::PrimitiveArray<int16_t>::VisitRoots(visitor); // ShortArray
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002002 // Visiting the roots of these ArtMethods is not currently required since all the GcRoots are
2003 // null.
2004 BufferedRootVisitor<16> buffered_visitor(visitor, RootInfo(kRootVMInternal));
Andreas Gampe542451c2016-07-26 09:02:02 -07002005 const PointerSize pointer_size = GetClassLinker()->GetImagePointerSize();
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002006 if (HasResolutionMethod()) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07002007 resolution_method_->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002008 }
2009 if (HasImtConflictMethod()) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07002010 imt_conflict_method_->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002011 }
2012 if (imt_unimplemented_method_ != nullptr) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07002013 imt_unimplemented_method_->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002014 }
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002015 for (uint32_t i = 0; i < kCalleeSaveSize; ++i) {
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002016 auto* m = reinterpret_cast<ArtMethod*>(callee_save_methods_[i]);
2017 if (m != nullptr) {
Mathieu Chartier1147b9b2015-09-14 18:50:08 -07002018 m->VisitRoots(buffered_visitor, pointer_size);
Mathieu Chartiere3b034a2015-05-31 14:29:23 -07002019 }
2020 }
Mathieu Chartier893263b2014-03-04 11:07:42 -08002021}
2022
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002023void Runtime::VisitConcurrentRoots(RootVisitor* visitor, VisitRootFlags flags) {
2024 intern_table_->VisitRoots(visitor, flags);
2025 class_linker_->VisitRoots(visitor, flags);
Man Cao1ed11b92015-06-11 22:47:35 -07002026 heap_->VisitAllocationRecords(visitor);
Mathieu Chartier893263b2014-03-04 11:07:42 -08002027 if ((flags & kVisitRootFlagNewRoots) == 0) {
2028 // Guaranteed to have no new roots in the constant roots.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002029 VisitConstantRoots(visitor);
Mathieu Chartier893263b2014-03-04 11:07:42 -08002030 }
Mathieu Chartiera6b1ead2015-10-06 10:32:38 -07002031 Dbg::VisitRoots(visitor);
Mathieu Chartier893263b2014-03-04 11:07:42 -08002032}
2033
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002034void Runtime::VisitTransactionRoots(RootVisitor* visitor) {
Chang Xing605fe242017-07-20 15:57:21 -07002035 for (auto& transaction : preinitialization_transactions_) {
2036 transaction->VisitRoots(visitor);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08002037 }
2038}
2039
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002040void Runtime::VisitNonThreadRoots(RootVisitor* visitor) {
2041 java_vm_->VisitRoots(visitor);
2042 sentinel_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Roland Levillain7b0e8442018-04-11 18:27:47 +01002043 pre_allocated_OutOfMemoryError_when_throwing_exception_
2044 .VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
2045 pre_allocated_OutOfMemoryError_when_throwing_oome_
2046 .VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
2047 pre_allocated_OutOfMemoryError_when_handling_stack_overflow_
2048 .VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002049 pre_allocated_NoClassDefFoundError_.VisitRootIfNonNull(visitor, RootInfo(kRootVMInternal));
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002050 verifier::MethodVerifier::VisitStaticRoots(visitor);
2051 VisitTransactionRoots(visitor);
Brian Carlstrome24fa612011-09-29 00:53:55 -07002052}
2053
Andreas Gampe585da952016-12-02 14:52:29 -08002054void Runtime::VisitNonConcurrentRoots(RootVisitor* visitor, VisitRootFlags flags) {
2055 VisitThreadRoots(visitor, flags);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002056 VisitNonThreadRoots(visitor);
Mathieu Chartier858f1c52012-10-17 17:45:55 -07002057}
2058
Andreas Gampe585da952016-12-02 14:52:29 -08002059void Runtime::VisitThreadRoots(RootVisitor* visitor, VisitRootFlags flags) {
2060 thread_list_->VisitRoots(visitor, flags);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08002061}
2062
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002063void Runtime::VisitRoots(RootVisitor* visitor, VisitRootFlags flags) {
Andreas Gampe585da952016-12-02 14:52:29 -08002064 VisitNonConcurrentRoots(visitor, flags);
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002065 VisitConcurrentRoots(visitor, flags);
Mathieu Chartier9ebae1f2012-10-15 17:38:16 -07002066}
2067
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002068void Runtime::VisitImageRoots(RootVisitor* visitor) {
Mathieu Chartier461687d2015-03-31 12:05:24 -07002069 for (auto* space : GetHeap()->GetContinuousSpaces()) {
2070 if (space->IsImageSpace()) {
2071 auto* image_space = space->AsImageSpace();
2072 const auto& image_header = image_space->GetImageHeader();
Vladimir Markoeca3eda2016-11-09 16:26:44 +00002073 for (int32_t i = 0, size = image_header.GetImageRoots()->GetLength(); i != size; ++i) {
Mathieu Chartier461687d2015-03-31 12:05:24 -07002074 auto* obj = image_header.GetImageRoot(static_cast<ImageHeader::ImageRoot>(i));
2075 if (obj != nullptr) {
2076 auto* after_obj = obj;
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -07002077 visitor->VisitRoot(&after_obj, RootInfo(kRootStickyClass));
Mathieu Chartier461687d2015-03-31 12:05:24 -07002078 CHECK_EQ(after_obj, obj);
2079 }
2080 }
2081 }
2082 }
2083}
2084
Andreas Gampecc1b5352016-12-01 16:58:38 -08002085static ArtMethod* CreateRuntimeMethod(ClassLinker* class_linker, LinearAlloc* linear_alloc) {
2086 const PointerSize image_pointer_size = class_linker->GetImagePointerSize();
2087 const size_t method_alignment = ArtMethod::Alignment(image_pointer_size);
2088 const size_t method_size = ArtMethod::Size(image_pointer_size);
2089 LengthPrefixedArray<ArtMethod>* method_array = class_linker->AllocArtMethodArray(
2090 Thread::Current(),
2091 linear_alloc,
2092 1);
2093 ArtMethod* method = &method_array->At(0, method_size, method_alignment);
2094 CHECK(method != nullptr);
Andreas Gampee2abbc62017-09-15 11:59:26 -07002095 method->SetDexMethodIndex(dex::kDexNoIndex);
Andreas Gampecc1b5352016-12-01 16:58:38 -08002096 CHECK(method->IsRuntimeMethod());
2097 return method;
2098}
2099
Nicolas Geoffray796d6302016-03-13 22:22:31 +00002100ArtMethod* Runtime::CreateImtConflictMethod(LinearAlloc* linear_alloc) {
Mathieu Chartier91288d82016-04-28 09:44:54 -07002101 ClassLinker* const class_linker = GetClassLinker();
Andreas Gampecc1b5352016-12-01 16:58:38 -08002102 ArtMethod* method = CreateRuntimeMethod(class_linker, linear_alloc);
Jeff Hao88474b42013-10-23 16:24:40 -07002103 // When compiling, the code pointer will get set later when the image is loaded.
Andreas Gampe542451c2016-07-26 09:02:02 -07002104 const PointerSize pointer_size = GetInstructionSetPointerSize(instruction_set_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002105 if (IsAotCompiler()) {
Jeff Haoc7d11882015-02-03 15:08:39 -08002106 method->SetEntryPointFromQuickCompiledCodePtrSize(nullptr, pointer_size);
Ian Rogersef7d42f2014-01-06 12:55:46 -08002107 } else {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07002108 method->SetEntryPointFromQuickCompiledCode(GetQuickImtConflictStub());
Ian Rogersef7d42f2014-01-06 12:55:46 -08002109 }
Mathieu Chartier91288d82016-04-28 09:44:54 -07002110 // Create empty conflict table.
2111 method->SetImtConflictTable(class_linker->CreateImtConflictTable(/*count*/0u, linear_alloc),
2112 pointer_size);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002113 return method;
Jeff Hao88474b42013-10-23 16:24:40 -07002114}
2115
Mathieu Chartiere401d142015-04-22 13:56:20 -07002116void Runtime::SetImtConflictMethod(ArtMethod* method) {
2117 CHECK(method != nullptr);
2118 CHECK(method->IsRuntimeMethod());
2119 imt_conflict_method_ = method;
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002120}
2121
Mathieu Chartiere401d142015-04-22 13:56:20 -07002122ArtMethod* Runtime::CreateResolutionMethod() {
Andreas Gampecc1b5352016-12-01 16:58:38 -08002123 auto* method = CreateRuntimeMethod(GetClassLinker(), GetLinearAlloc());
Jeff Hao58df3272013-04-22 15:28:53 -07002124 // When compiling, the code pointer will get set later when the image is loaded.
Mathieu Chartiere401d142015-04-22 13:56:20 -07002125 if (IsAotCompiler()) {
Andreas Gampe542451c2016-07-26 09:02:02 -07002126 PointerSize pointer_size = GetInstructionSetPointerSize(instruction_set_);
Jeff Haoc7d11882015-02-03 15:08:39 -08002127 method->SetEntryPointFromQuickCompiledCodePtrSize(nullptr, pointer_size);
Ian Rogersef7d42f2014-01-06 12:55:46 -08002128 } else {
Ian Rogers6f3dbba2014-10-14 17:41:57 -07002129 method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionStub());
Ian Rogersef7d42f2014-01-06 12:55:46 -08002130 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07002131 return method;
Ian Rogers19846512012-02-24 11:42:47 -08002132}
2133
Mathieu Chartiere401d142015-04-22 13:56:20 -07002134ArtMethod* Runtime::CreateCalleeSaveMethod() {
Andreas Gampecc1b5352016-12-01 16:58:38 -08002135 auto* method = CreateRuntimeMethod(GetClassLinker(), GetLinearAlloc());
Andreas Gampe542451c2016-07-26 09:02:02 -07002136 PointerSize pointer_size = GetInstructionSetPointerSize(instruction_set_);
Jeff Haoc7d11882015-02-03 15:08:39 -08002137 method->SetEntryPointFromQuickCompiledCodePtrSize(nullptr, pointer_size);
Vladimir Marko33bff252017-11-01 14:35:42 +00002138 DCHECK_NE(instruction_set_, InstructionSet::kNone);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002139 DCHECK(method->IsRuntimeMethod());
2140 return method;
Ian Rogersff1ed472011-09-20 13:46:24 -07002141}
2142
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002143void Runtime::DisallowNewSystemWeaks() {
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07002144 CHECK(!kUseReadBarrier);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002145 monitor_list_->DisallowNewMonitors();
Mathieu Chartier14c3bf92015-07-13 14:35:43 -07002146 intern_table_->ChangeWeakRootState(gc::kWeakRootStateNoReadsOrWrites);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002147 java_vm_->DisallowNewWeakGlobals();
Man Cao42c3c332015-06-23 16:38:25 -07002148 heap_->DisallowNewAllocationRecords();
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +00002149 if (GetJit() != nullptr) {
2150 GetJit()->GetCodeCache()->DisallowInlineCacheAccess();
2151 }
Andreas Gampefda57142016-09-08 20:29:18 -07002152
2153 // All other generic system-weak holders.
2154 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
2155 holder->Disallow();
2156 }
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002157}
2158
2159void Runtime::AllowNewSystemWeaks() {
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07002160 CHECK(!kUseReadBarrier);
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002161 monitor_list_->AllowNewMonitors();
Mathieu Chartier90ef3db2015-08-04 15:19:41 -07002162 intern_table_->ChangeWeakRootState(gc::kWeakRootStateNormal); // TODO: Do this in the sweeping.
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002163 java_vm_->AllowNewWeakGlobals();
Man Cao42c3c332015-06-23 16:38:25 -07002164 heap_->AllowNewAllocationRecords();
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +00002165 if (GetJit() != nullptr) {
2166 GetJit()->GetCodeCache()->AllowInlineCacheAccess();
2167 }
Andreas Gampefda57142016-09-08 20:29:18 -07002168
2169 // All other generic system-weak holders.
2170 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
2171 holder->Allow();
2172 }
Mathieu Chartierc11d9b82013-09-19 10:01:59 -07002173}
2174
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07002175void Runtime::BroadcastForNewSystemWeaks(bool broadcast_for_checkpoint) {
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07002176 // This is used for the read barrier case that uses the thread-local
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07002177 // Thread::GetWeakRefAccessEnabled() flag and the checkpoint while weak ref access is disabled
2178 // (see ThreadList::RunCheckpoint).
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07002179 monitor_list_->BroadcastForNewMonitors();
2180 intern_table_->BroadcastForNewInterns();
2181 java_vm_->BroadcastForNewWeakGlobals();
Hiroshi Yamauchifdbd13c2015-09-02 16:16:58 -07002182 heap_->BroadcastForNewAllocationRecords();
Nicolas Geoffraye51ca8b2016-11-22 14:49:31 +00002183 if (GetJit() != nullptr) {
2184 GetJit()->GetCodeCache()->BroadcastForInlineCacheAccess();
2185 }
Andreas Gampefda57142016-09-08 20:29:18 -07002186
2187 // All other generic system-weak holders.
2188 for (gc::AbstractSystemWeakHolder* holder : system_weak_holders_) {
Hiroshi Yamauchi30493242016-11-03 13:06:52 -07002189 holder->Broadcast(broadcast_for_checkpoint);
Andreas Gampefda57142016-09-08 20:29:18 -07002190 }
Hiroshi Yamauchi0b713572015-06-16 18:29:23 -07002191}
2192
Vladimir Marko7624d252014-05-02 14:40:15 +01002193void Runtime::SetInstructionSet(InstructionSet instruction_set) {
2194 instruction_set_ = instruction_set;
Vladimir Marko33bff252017-11-01 14:35:42 +00002195 if ((instruction_set_ == InstructionSet::kThumb2) || (instruction_set_ == InstructionSet::kArm)) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002196 for (int i = 0; i != kCalleeSaveSize; ++i) {
Vladimir Marko7624d252014-05-02 14:40:15 +01002197 CalleeSaveType type = static_cast<CalleeSaveType>(i);
2198 callee_save_method_frame_infos_[i] = arm::ArmCalleeSaveMethodFrameInfo(type);
2199 }
Vladimir Marko33bff252017-11-01 14:35:42 +00002200 } else if (instruction_set_ == InstructionSet::kMips) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002201 for (int i = 0; i != kCalleeSaveSize; ++i) {
Vladimir Marko7624d252014-05-02 14:40:15 +01002202 CalleeSaveType type = static_cast<CalleeSaveType>(i);
2203 callee_save_method_frame_infos_[i] = mips::MipsCalleeSaveMethodFrameInfo(type);
2204 }
Vladimir Marko33bff252017-11-01 14:35:42 +00002205 } else if (instruction_set_ == InstructionSet::kMips64) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002206 for (int i = 0; i != kCalleeSaveSize; ++i) {
Andreas Gampe57b34292015-01-14 15:45:59 -08002207 CalleeSaveType type = static_cast<CalleeSaveType>(i);
2208 callee_save_method_frame_infos_[i] = mips64::Mips64CalleeSaveMethodFrameInfo(type);
2209 }
Vladimir Marko33bff252017-11-01 14:35:42 +00002210 } else if (instruction_set_ == InstructionSet::kX86) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002211 for (int i = 0; i != kCalleeSaveSize; ++i) {
Vladimir Marko7624d252014-05-02 14:40:15 +01002212 CalleeSaveType type = static_cast<CalleeSaveType>(i);
2213 callee_save_method_frame_infos_[i] = x86::X86CalleeSaveMethodFrameInfo(type);
2214 }
Vladimir Marko33bff252017-11-01 14:35:42 +00002215 } else if (instruction_set_ == InstructionSet::kX86_64) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002216 for (int i = 0; i != kCalleeSaveSize; ++i) {
Vladimir Marko7624d252014-05-02 14:40:15 +01002217 CalleeSaveType type = static_cast<CalleeSaveType>(i);
2218 callee_save_method_frame_infos_[i] = x86_64::X86_64CalleeSaveMethodFrameInfo(type);
2219 }
Vladimir Marko33bff252017-11-01 14:35:42 +00002220 } else if (instruction_set_ == InstructionSet::kArm64) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002221 for (int i = 0; i != kCalleeSaveSize; ++i) {
Vladimir Marko7624d252014-05-02 14:40:15 +01002222 CalleeSaveType type = static_cast<CalleeSaveType>(i);
2223 callee_save_method_frame_infos_[i] = arm64::Arm64CalleeSaveMethodFrameInfo(type);
2224 }
2225 } else {
2226 UNIMPLEMENTED(FATAL) << instruction_set_;
2227 }
2228}
2229
Igor Murashkin8275fba2017-05-02 15:58:02 -07002230void Runtime::ClearInstructionSet() {
2231 instruction_set_ = InstructionSet::kNone;
2232}
2233
Mathieu Chartiere401d142015-04-22 13:56:20 -07002234void Runtime::SetCalleeSaveMethod(ArtMethod* method, CalleeSaveType type) {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002235 DCHECK_LT(static_cast<uint32_t>(type), kCalleeSaveSize);
Mathieu Chartiere401d142015-04-22 13:56:20 -07002236 CHECK(method != nullptr);
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002237 callee_save_methods_[static_cast<size_t>(type)] = reinterpret_cast<uintptr_t>(method);
Brian Carlstrome24fa612011-09-29 00:53:55 -07002238}
2239
Igor Murashkin8275fba2017-05-02 15:58:02 -07002240void Runtime::ClearCalleeSaveMethods() {
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002241 for (size_t i = 0; i < kCalleeSaveSize; ++i) {
2242 callee_save_methods_[i] = reinterpret_cast<uintptr_t>(nullptr);
Igor Murashkin8275fba2017-05-02 15:58:02 -07002243 }
2244}
2245
Calin Juravle66f55232015-12-08 15:09:10 +00002246void Runtime::RegisterAppInfo(const std::vector<std::string>& code_paths,
Calin Juravle77651c42017-03-03 18:04:02 -08002247 const std::string& profile_output_filename) {
Calin Juravle5e2b9712015-12-18 14:10:00 +02002248 if (jit_.get() == nullptr) {
2249 // We are not JITing. Nothing to do.
2250 return;
Calin Juravle4d77b6a2015-12-01 18:38:09 +00002251 }
Calin Juravle5e2b9712015-12-18 14:10:00 +02002252
2253 VLOG(profiler) << "Register app with " << profile_output_filename
Andreas Gampe9186ced2016-12-12 14:28:21 -08002254 << " " << android::base::Join(code_paths, ':');
Calin Juravle5e2b9712015-12-18 14:10:00 +02002255
2256 if (profile_output_filename.empty()) {
2257 LOG(WARNING) << "JIT profile information will not be recorded: profile filename is empty.";
2258 return;
2259 }
David Sehrc431b9d2018-03-02 12:01:51 -08002260 if (!OS::FileExists(profile_output_filename.c_str(), false /*check_file_type*/)) {
Calin Juravle5e2b9712015-12-18 14:10:00 +02002261 LOG(WARNING) << "JIT profile information will not be recorded: profile file does not exits.";
2262 return;
2263 }
2264 if (code_paths.empty()) {
2265 LOG(WARNING) << "JIT profile information will not be recorded: code paths is empty.";
2266 return;
2267 }
2268
Calin Juravle77651c42017-03-03 18:04:02 -08002269 jit_->StartProfileSaver(profile_output_filename, code_paths);
Dave Allison0aded082013-11-07 13:15:11 -08002270}
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002271
2272// Transaction support.
Chang Xing605fe242017-07-20 15:57:21 -07002273bool Runtime::IsActiveTransaction() const {
2274 return !preinitialization_transactions_.empty() && !GetTransaction()->IsRollingBack();
2275}
2276
Chang Xing16d1dd82017-07-20 17:56:26 -07002277void Runtime::EnterTransactionMode() {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002278 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002279 DCHECK(!IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002280 preinitialization_transactions_.push_back(std::make_unique<Transaction>());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002281}
2282
Chang Xing5a906fc2017-07-26 15:01:16 -07002283void Runtime::EnterTransactionMode(bool strict, mirror::Class* root) {
Chang Xingcade5c32017-07-20 17:56:26 -07002284 DCHECK(IsAotCompiler());
Chang Xing605fe242017-07-20 15:57:21 -07002285 preinitialization_transactions_.push_back(std::make_unique<Transaction>(strict, root));
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002286}
2287
2288void Runtime::ExitTransactionMode() {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002289 DCHECK(IsAotCompiler());
Chang Xing605fe242017-07-20 15:57:21 -07002290 DCHECK(IsActiveTransaction());
2291 preinitialization_transactions_.pop_back();
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002292}
2293
Chang Xing16d1dd82017-07-20 17:56:26 -07002294void Runtime::RollbackAndExitTransactionMode() {
2295 DCHECK(IsAotCompiler());
2296 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002297 preinitialization_transactions_.back()->Rollback();
2298 preinitialization_transactions_.pop_back();
Chang Xing16d1dd82017-07-20 17:56:26 -07002299}
2300
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002301bool Runtime::IsTransactionAborted() const {
2302 if (!IsActiveTransaction()) {
2303 return false;
2304 } else {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002305 DCHECK(IsAotCompiler());
Chang Xing605fe242017-07-20 15:57:21 -07002306 return GetTransaction()->IsAborted();
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002307 }
2308}
2309
Chang Xing605fe242017-07-20 15:57:21 -07002310void Runtime::RollbackAllTransactions() {
2311 // If transaction is aborted, all transactions will be kept in the list.
2312 // Rollback and exit all of them.
2313 while (IsActiveTransaction()) {
2314 RollbackAndExitTransactionMode();
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002315 }
2316}
2317
Chang Xing5a906fc2017-07-26 15:01:16 -07002318bool Runtime::IsActiveStrictTransactionMode() const {
Chang Xing605fe242017-07-20 15:57:21 -07002319 return IsActiveTransaction() && GetTransaction()->IsStrict();
2320}
2321
2322const std::unique_ptr<Transaction>& Runtime::GetTransaction() const {
2323 DCHECK(!preinitialization_transactions_.empty());
2324 return preinitialization_transactions_.back();
Chang Xing5a906fc2017-07-26 15:01:16 -07002325}
2326
Sebastien Hertz2fd7e692015-04-02 11:11:19 +02002327void Runtime::AbortTransactionAndThrowAbortError(Thread* self, const std::string& abort_message) {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002328 DCHECK(IsAotCompiler());
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002329 DCHECK(IsActiveTransaction());
Sebastien Hertzbd9cf9f2015-03-03 12:16:13 +01002330 // Throwing an exception may cause its class initialization. If we mark the transaction
2331 // aborted before that, we may warn with a false alarm. Throwing the exception before
2332 // marking the transaction aborted avoids that.
Chang Xing605fe242017-07-20 15:57:21 -07002333 // But now the transaction can be nested, and abort the transaction will relax the constraints
2334 // for constructing stack trace.
2335 GetTransaction()->Abort(abort_message);
2336 GetTransaction()->ThrowAbortError(self, &abort_message);
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002337}
2338
Sebastien Hertz2fd7e692015-04-02 11:11:19 +02002339void Runtime::ThrowTransactionAbortError(Thread* self) {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002340 DCHECK(IsAotCompiler());
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002341 DCHECK(IsActiveTransaction());
Sebastien Hertzb81e1cd2015-04-28 12:31:41 +02002342 // Passing nullptr means we rethrow an exception with the earlier transaction abort message.
Chang Xing605fe242017-07-20 15:57:21 -07002343 GetTransaction()->ThrowAbortError(self, nullptr);
Sebastien Hertz1c80bec2015-02-03 11:58:06 +01002344}
2345
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002346void Runtime::RecordWriteFieldBoolean(mirror::Object* obj, MemberOffset field_offset,
2347 uint8_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002348 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002349 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002350 GetTransaction()->RecordWriteFieldBoolean(obj, field_offset, value, is_volatile);
Fred Shih37f05ef2014-07-16 18:38:08 -07002351}
2352
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002353void Runtime::RecordWriteFieldByte(mirror::Object* obj, MemberOffset field_offset,
2354 int8_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002355 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002356 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002357 GetTransaction()->RecordWriteFieldByte(obj, field_offset, value, is_volatile);
Fred Shih37f05ef2014-07-16 18:38:08 -07002358}
2359
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002360void Runtime::RecordWriteFieldChar(mirror::Object* obj, MemberOffset field_offset,
2361 uint16_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002362 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002363 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002364 GetTransaction()->RecordWriteFieldChar(obj, field_offset, value, is_volatile);
Fred Shih37f05ef2014-07-16 18:38:08 -07002365}
2366
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002367void Runtime::RecordWriteFieldShort(mirror::Object* obj, MemberOffset field_offset,
2368 int16_t value, bool is_volatile) const {
Mathieu Chartier184c9dc2015-03-05 13:20:54 -08002369 DCHECK(IsAotCompiler());
Fred Shih37f05ef2014-07-16 18:38:08 -07002370 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002371 GetTransaction()->RecordWriteFieldShort(obj, field_offset, value, is_volatile);
Fred Shih37f05ef2014-07-16 18:38:08 -07002372}
2373
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002374void Runtime::RecordWriteField32(mirror::Object* obj, MemberOffset field_offset,
2375 uint32_t value, bool is_volatile) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002376 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002377 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002378 GetTransaction()->RecordWriteField32(obj, field_offset, value, is_volatile);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002379}
2380
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002381void Runtime::RecordWriteField64(mirror::Object* obj, MemberOffset field_offset,
2382 uint64_t value, bool is_volatile) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002383 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002384 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002385 GetTransaction()->RecordWriteField64(obj, field_offset, value, is_volatile);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002386}
2387
Mathieu Chartiera058fdf2016-10-06 15:13:58 -07002388void Runtime::RecordWriteFieldReference(mirror::Object* obj,
2389 MemberOffset field_offset,
2390 ObjPtr<mirror::Object> value,
2391 bool is_volatile) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002392 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002393 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002394 GetTransaction()->RecordWriteFieldReference(obj,
Mathieu Chartiera058fdf2016-10-06 15:13:58 -07002395 field_offset,
2396 value.Ptr(),
2397 is_volatile);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002398}
2399
2400void Runtime::RecordWriteArray(mirror::Array* array, size_t index, uint64_t value) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002401 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002402 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002403 GetTransaction()->RecordWriteArray(array, index, value);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002404}
2405
Mathieu Chartier9e868092016-10-31 14:58:04 -07002406void Runtime::RecordStrongStringInsertion(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002407 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002408 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002409 GetTransaction()->RecordStrongStringInsertion(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002410}
2411
Mathieu Chartier9e868092016-10-31 14:58:04 -07002412void Runtime::RecordWeakStringInsertion(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002413 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002414 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002415 GetTransaction()->RecordWeakStringInsertion(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002416}
2417
Mathieu Chartier9e868092016-10-31 14:58:04 -07002418void Runtime::RecordStrongStringRemoval(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002419 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002420 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002421 GetTransaction()->RecordStrongStringRemoval(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002422}
2423
Mathieu Chartier9e868092016-10-31 14:58:04 -07002424void Runtime::RecordWeakStringRemoval(ObjPtr<mirror::String> s) const {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002425 DCHECK(IsAotCompiler());
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002426 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002427 GetTransaction()->RecordWeakStringRemoval(s);
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01002428}
Mathieu Chartier15d34022014-02-26 17:16:38 -08002429
Andreas Gampe8a0128a2016-11-28 07:38:35 -08002430void Runtime::RecordResolveString(ObjPtr<mirror::DexCache> dex_cache,
2431 dex::StringIndex string_idx) const {
Mathieu Chartierbb816d62016-09-07 10:17:46 -07002432 DCHECK(IsAotCompiler());
2433 DCHECK(IsActiveTransaction());
Chang Xing605fe242017-07-20 15:57:21 -07002434 GetTransaction()->RecordResolveString(dex_cache, string_idx);
Mathieu Chartierbb816d62016-09-07 10:17:46 -07002435}
2436
Mathieu Chartier15d34022014-02-26 17:16:38 -08002437void Runtime::SetFaultMessage(const std::string& message) {
2438 MutexLock mu(Thread::Current(), fault_message_lock_);
2439 fault_message_ = message;
2440}
Brian Carlstrom491ca9e2014-03-02 18:24:38 -08002441
Igor Murashkinb1d8c312015-08-04 11:18:43 -07002442void Runtime::AddCurrentRuntimeFeaturesAsDex2OatArguments(std::vector<std::string>* argv)
Ian Rogers8afeb852014-04-02 14:55:49 -07002443 const {
Nicolas Geoffrayc6b1b932016-03-22 09:52:40 +00002444 if (GetInstrumentation()->InterpretOnly()) {
Nicolas Geoffray49cda062017-04-21 13:08:25 +01002445 argv->push_back("--compiler-filter=quicken");
Ian Rogers9bc54402014-04-17 16:40:01 -07002446 }
2447
Ian Rogers8afeb852014-04-02 14:55:49 -07002448 // Make the dex2oat instruction set match that of the launching runtime. If we have multiple
2449 // architecture support, dex2oat may be compiled as a different instruction-set than that
2450 // currently being executed.
Ian Rogersb9beb2e2014-05-09 16:57:40 -07002451 std::string instruction_set("--instruction-set=");
2452 instruction_set += GetInstructionSetString(kRuntimeISA);
2453 argv->push_back(instruction_set);
Ian Rogers8afeb852014-04-02 14:55:49 -07002454
Ian Rogers6f3dbba2014-10-14 17:41:57 -07002455 std::unique_ptr<const InstructionSetFeatures> features(InstructionSetFeatures::FromCppDefines());
2456 std::string feature_string("--instruction-set-features=");
2457 feature_string += features->GetFeatureString();
2458 argv->push_back(feature_string);
Ian Rogers8afeb852014-04-02 14:55:49 -07002459}
2460
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002461void Runtime::CreateJit() {
Mathieu Chartier455f67c2015-03-17 13:48:29 -07002462 CHECK(!IsAotCompiler());
Calin Juravleaf36e492016-04-27 18:50:45 +01002463 if (kIsDebugBuild && GetInstrumentation()->IsForcedInterpretOnly()) {
2464 DCHECK(!jit_options_->UseJitCompilation());
Hiroshi Yamauchi02d2f292015-04-03 13:35:16 -07002465 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002466 std::string error_msg;
2467 jit_.reset(jit::Jit::Create(jit_options_.get(), &error_msg));
Nicolas Geoffray274fe4a2016-04-12 16:33:24 +01002468 if (jit_.get() == nullptr) {
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002469 LOG(WARNING) << "Failed to create JIT " << error_msg;
Calin Juravle9545f6d2017-03-16 19:05:09 -07002470 return;
2471 }
Mathieu Chartiere5f13e52015-02-24 09:37:21 -08002472}
2473
Andreas Gampe4585f872015-03-27 23:45:15 -07002474bool Runtime::CanRelocate() const {
2475 return !IsAotCompiler() || compiler_callbacks_->IsRelocationPossible();
2476}
2477
2478bool Runtime::IsCompilingBootImage() const {
2479 return IsCompiler() && compiler_callbacks_->IsBootImage();
2480}
2481
Mathieu Chartiere401d142015-04-22 13:56:20 -07002482void Runtime::SetResolutionMethod(ArtMethod* method) {
2483 CHECK(method != nullptr);
2484 CHECK(method->IsRuntimeMethod()) << method;
2485 resolution_method_ = method;
2486}
2487
2488void Runtime::SetImtUnimplementedMethod(ArtMethod* method) {
2489 CHECK(method != nullptr);
2490 CHECK(method->IsRuntimeMethod());
2491 imt_unimplemented_method_ = method;
Mathieu Chartier91288d82016-04-28 09:44:54 -07002492}
2493
2494void Runtime::FixupConflictTables() {
2495 // We can only do this after the class linker is created.
Andreas Gampe542451c2016-07-26 09:02:02 -07002496 const PointerSize pointer_size = GetClassLinker()->GetImagePointerSize();
Mathieu Chartier91288d82016-04-28 09:44:54 -07002497 if (imt_unimplemented_method_->GetImtConflictTable(pointer_size) == nullptr) {
2498 imt_unimplemented_method_->SetImtConflictTable(
2499 ClassLinker::CreateImtConflictTable(/*count*/0u, GetLinearAlloc(), pointer_size),
2500 pointer_size);
2501 }
2502 if (imt_conflict_method_->GetImtConflictTable(pointer_size) == nullptr) {
2503 imt_conflict_method_->SetImtConflictTable(
2504 ClassLinker::CreateImtConflictTable(/*count*/0u, GetLinearAlloc(), pointer_size),
2505 pointer_size);
Nicolas Geoffray40c68c62016-03-23 16:35:51 +00002506 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07002507}
2508
Nicolas Geoffray68bf3902017-09-07 14:40:48 +01002509void Runtime::DisableVerifier() {
2510 verify_ = verifier::VerifyMode::kNone;
2511}
2512
Igor Murashkin7617abd2015-07-10 18:27:47 -07002513bool Runtime::IsVerificationEnabled() const {
Igor Murashkindf707e42016-02-02 16:56:50 -08002514 return verify_ == verifier::VerifyMode::kEnable ||
2515 verify_ == verifier::VerifyMode::kSoftFail;
Igor Murashkin7617abd2015-07-10 18:27:47 -07002516}
2517
2518bool Runtime::IsVerificationSoftFail() const {
2519 return verify_ == verifier::VerifyMode::kSoftFail;
2520}
2521
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002522bool Runtime::IsAsyncDeoptimizeable(uintptr_t code) const {
2523 // We only support async deopt (ie the compiled code is not explicitly asking for
2524 // deopt, but something else like the debugger) in debuggable JIT code.
2525 // We could look at the oat file where `code` is being defined,
2526 // and check whether it's been compiled debuggable, but we decided to
2527 // only rely on the JIT for debuggable apps.
2528 return IsJavaDebuggable() &&
2529 GetJit() != nullptr &&
2530 GetJit()->GetCodeCache()->ContainsPc(reinterpret_cast<const void*>(code));
Mingyao Yangf711f2c2016-05-23 12:29:39 -07002531}
2532
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07002533LinearAlloc* Runtime::CreateLinearAlloc() {
Mathieu Chartierc3fcd412015-09-25 16:54:59 -07002534 // For 64 bit compilers, it needs to be in low 4GB in the case where we are cross compiling for a
2535 // 32 bit target. In this case, we have 32 bit pointers in the dex cache arrays which can't hold
2536 // when we have 64 bit ArtMethod pointers.
Mathieu Chartier017ed0b2015-09-22 11:04:26 -07002537 return (IsAotCompiler() && Is64BitInstructionSet(kRuntimeISA))
Mathieu Chartier951ec2c2015-09-22 08:50:05 -07002538 ? new LinearAlloc(low_4gb_arena_pool_.get())
2539 : new LinearAlloc(arena_pool_.get());
2540}
2541
Mathieu Chartier32cc9ee2015-10-15 09:19:15 -07002542double Runtime::GetHashTableMinLoadFactor() const {
2543 return is_low_memory_mode_ ? kLowMemoryMinLoadFactor : kNormalMinLoadFactor;
2544}
2545
2546double Runtime::GetHashTableMaxLoadFactor() const {
2547 return is_low_memory_mode_ ? kLowMemoryMaxLoadFactor : kNormalMaxLoadFactor;
2548}
2549
Mathieu Chartierf8cb1782016-03-18 18:45:41 -07002550void Runtime::UpdateProcessState(ProcessState process_state) {
2551 ProcessState old_process_state = process_state_;
2552 process_state_ = process_state;
2553 GetHeap()->UpdateProcessState(old_process_state, process_state);
2554}
2555
Calin Juravle97cbc922016-04-15 16:16:35 +01002556void Runtime::RegisterSensitiveThread() const {
2557 Thread::SetJitSensitiveThread();
2558}
2559
Calin Juravleffc87072016-04-20 14:22:09 +01002560// Returns true if JIT compilations are enabled. GetJit() will be not null in this case.
2561bool Runtime::UseJitCompilation() const {
2562 return (jit_ != nullptr) && jit_->UseJitCompilation();
2563}
2564
David Sehrd106d9f2016-08-16 19:22:57 -07002565void Runtime::EnvSnapshot::TakeSnapshot() {
2566 char** env = GetEnviron();
2567 for (size_t i = 0; env[i] != nullptr; ++i) {
2568 name_value_pairs_.emplace_back(new std::string(env[i]));
2569 }
2570 // The strings in name_value_pairs_ retain ownership of the c_str, but we assign pointers
2571 // for quick use by GetSnapshot. This avoids allocation and copying cost at Exec.
2572 c_env_vector_.reset(new char*[name_value_pairs_.size() + 1]);
2573 for (size_t i = 0; env[i] != nullptr; ++i) {
2574 c_env_vector_[i] = const_cast<char*>(name_value_pairs_[i]->c_str());
2575 }
2576 c_env_vector_[name_value_pairs_.size()] = nullptr;
2577}
2578
2579char** Runtime::EnvSnapshot::GetSnapshot() const {
2580 return c_env_vector_.get();
2581}
2582
Andreas Gampefda57142016-09-08 20:29:18 -07002583void Runtime::AddSystemWeakHolder(gc::AbstractSystemWeakHolder* holder) {
2584 gc::ScopedGCCriticalSection gcs(Thread::Current(),
2585 gc::kGcCauseAddRemoveSystemWeakHolder,
2586 gc::kCollectorTypeAddRemoveSystemWeakHolder);
Andreas Gampe1f648592017-01-13 10:46:01 -08002587 // Note: The ScopedGCCriticalSection also ensures that the rest of the function is in
2588 // a critical section.
Andreas Gampefda57142016-09-08 20:29:18 -07002589 system_weak_holders_.push_back(holder);
2590}
2591
2592void Runtime::RemoveSystemWeakHolder(gc::AbstractSystemWeakHolder* holder) {
2593 gc::ScopedGCCriticalSection gcs(Thread::Current(),
2594 gc::kGcCauseAddRemoveSystemWeakHolder,
2595 gc::kCollectorTypeAddRemoveSystemWeakHolder);
2596 auto it = std::find(system_weak_holders_.begin(), system_weak_holders_.end(), holder);
2597 if (it != system_weak_holders_.end()) {
2598 system_weak_holders_.erase(it);
2599 }
2600}
2601
Andreas Gampeac30fa22017-01-18 21:02:36 -08002602RuntimeCallbacks* Runtime::GetRuntimeCallbacks() {
2603 return callbacks_.get();
2604}
2605
Nicolas Geoffray433b79a2017-01-30 20:54:45 +00002606// Used to patch boot image method entry point to interpreter bridge.
2607class UpdateEntryPointsClassVisitor : public ClassVisitor {
2608 public:
2609 explicit UpdateEntryPointsClassVisitor(instrumentation::Instrumentation* instrumentation)
2610 : instrumentation_(instrumentation) {}
2611
2612 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES(Locks::mutator_lock_) {
2613 auto pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
2614 for (auto& m : klass->GetMethods(pointer_size)) {
2615 const void* code = m.GetEntryPointFromQuickCompiledCode();
2616 if (Runtime::Current()->GetHeap()->IsInBootImageOatFile(code) &&
2617 !m.IsNative() &&
2618 !m.IsProxyMethod()) {
2619 instrumentation_->UpdateMethodsCodeForJavaDebuggable(&m, GetQuickToInterpreterBridge());
2620 }
2621 }
2622 return true;
2623 }
2624
2625 private:
2626 instrumentation::Instrumentation* const instrumentation_;
2627};
2628
2629void Runtime::SetJavaDebuggable(bool value) {
2630 is_java_debuggable_ = value;
2631 // Do not call DeoptimizeBootImage just yet, the runtime may still be starting up.
2632}
2633
2634void Runtime::DeoptimizeBootImage() {
2635 // If we've already started and we are setting this runtime to debuggable,
2636 // we patch entry points of methods in boot image to interpreter bridge, as
2637 // boot image code may be AOT compiled as not debuggable.
2638 if (!GetInstrumentation()->IsForcedInterpretOnly()) {
2639 ScopedObjectAccess soa(Thread::Current());
2640 UpdateEntryPointsClassVisitor visitor(GetInstrumentation());
2641 GetClassLinker()->VisitClasses(&visitor);
2642 }
2643}
Carl Shapiro1fb86202011-06-27 17:43:13 -07002644} // namespace art