blob: 0a37cd7a7a95509a404dcb8eb16be74ed5361aa3 [file] [log] [blame]
Brian Carlstrom7940e442013-07-12 13:46:57 -07001/*
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 */
16
Andreas Gamped687e372015-04-28 23:16:03 -070017#include <inttypes.h>
Brian Carlstrom7940e442013-07-12 13:46:57 -070018#include <stdio.h>
19#include <stdlib.h>
20#include <sys/stat.h>
Evgenii Stepanov1e133742015-05-20 12:30:59 -070021#include "base/memory_tool.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070022
23#include <fstream>
24#include <iostream>
Andreas Gampe67f02822016-06-24 21:05:23 -070025#include <limits>
Brian Carlstrom7940e442013-07-12 13:46:57 -070026#include <sstream>
27#include <string>
Andreas Gampeb1fcead2015-04-20 18:53:51 -070028#include <unordered_set>
Brian Carlstrom7940e442013-07-12 13:46:57 -070029#include <vector>
30
Vladimir Markof94b7812014-06-05 15:48:04 +010031#if defined(__linux__) && defined(__arm__)
32#include <sys/personality.h>
33#include <sys/utsname.h>
34#endif
35
Andreas Gampe46ee31b2016-12-14 10:11:49 -080036#include "android-base/stringprintf.h"
Andreas Gampe9186ced2016-12-12 14:28:21 -080037#include "android-base/strings.h"
38
Ian Rogersd582fa42014-11-05 23:46:43 -080039#include "arch/instruction_set_features.h"
Andreas Gampec5a3ea72015-01-13 16:41:53 -080040#include "arch/mips/instruction_set_features_mips.h"
David Srbecky4fda4eb2016-02-05 13:34:46 +000041#include "art_method-inl.h"
Andreas Gampe8228cdf2017-05-30 15:03:54 -070042#include "base/callee_save_type.h"
Ian Rogersc7dd2952014-10-21 23:31:19 -070043#include "base/dumpable.h"
Andreas Gampe794ad762015-02-23 08:12:24 -080044#include "base/macros.h"
Calin Juravle2e2db782016-02-23 12:00:03 +000045#include "base/scoped_flock.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070046#include "base/stl_util.h"
47#include "base/stringpiece.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010048#include "base/time_utils.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070049#include "base/timing_logger.h"
50#include "base/unix_file/fd_file.h"
51#include "class_linker.h"
Calin Juravle1ce70852017-06-28 10:59:03 -070052#include "class_loader_context.h"
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +000053#include "compiler.h"
Vladimir Marko2b5eaa22013-12-13 13:59:30 +000054#include "compiler_callbacks.h"
David Srbecky09c2a6b2016-03-11 17:11:44 +000055#include "debug/elf_debug_writer.h"
David Srbecky4fda4eb2016-02-05 13:34:46 +000056#include "debug/method_debug_info.h"
David Srbecky4fda4eb2016-02-05 13:34:46 +000057#include "dex/quick_compiler_callbacks.h"
58#include "dex/verification_results.h"
Andreas Gampe7b565912017-03-20 15:48:52 -070059#include "dex2oat_return_codes.h"
David Srbecky4fda4eb2016-02-05 13:34:46 +000060#include "dex_file-inl.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070061#include "driver/compiler_driver.h"
Brian Carlstrom6449c622014-02-10 23:48:36 -080062#include "driver/compiler_options.h"
Andreas Gampe88ec7f42014-11-05 10:18:32 -080063#include "elf_file.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070064#include "gc/space/image_space.h"
65#include "gc/space/space-inl.h"
Mathieu Chartier72041a02017-07-14 18:23:25 -070066#include "gc/verification.h"
Andreas Gampe2969bcd2015-03-09 12:57:41 -070067#include "interpreter/unstarted_runtime.h"
Mathieu Chartier72041a02017-07-14 18:23:25 -070068#include "java_vm_ext.h"
Calin Juravle33083d62017-01-18 15:29:12 -080069#include "jit/profile_compilation_info.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070070#include "leb128.h"
David Brazdil5d5a36b2016-09-14 15:34:10 +010071#include "linker/buffered_output_stream.h"
Vladimir Marko74527972016-11-29 15:57:32 +000072#include "linker/elf_writer.h"
73#include "linker/elf_writer_quick.h"
David Brazdil5d5a36b2016-09-14 15:34:10 +010074#include "linker/file_output_stream.h"
Vladimir Marko74527972016-11-29 15:57:32 +000075#include "linker/image_writer.h"
Vladimir Marko944da602016-02-19 12:27:55 +000076#include "linker/multi_oat_relative_patcher.h"
Vladimir Marko74527972016-11-29 15:57:32 +000077#include "linker/oat_writer.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070078#include "mirror/class-inl.h"
79#include "mirror/class_loader.h"
80#include "mirror/object-inl.h"
81#include "mirror/object_array-inl.h"
Steven Morelande431e272017-07-18 16:53:49 -070082#include "nativehelper/ScopedLocalRef.h"
Andreas Gampe2ff3b972017-06-05 18:14:53 -070083#include "oat_file.h"
Jeff Haob11ffb72016-04-07 15:40:54 -070084#include "oat_file_assistant.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070085#include "os.h"
86#include "runtime.h"
Vladimir Marko49b0f452015-12-10 13:49:19 +000087#include "runtime_options.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070088#include "scoped_thread_state_change-inl.h"
Alex Light53cb16b2014-06-12 11:26:29 -070089#include "utils.h"
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +000090#include "vdex_file.h"
David Brazdilca3c8c32016-09-06 14:04:48 +010091#include "verifier/verifier_deps.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070092#include "well_known_classes.h"
93#include "zip_archive.h"
94
95namespace art {
96
Andreas Gampe46ee31b2016-12-14 10:11:49 -080097using android::base::StringAppendV;
98using android::base::StringPrintf;
99
Andreas Gampee1459ae2016-06-29 09:36:30 -0700100static constexpr size_t kDefaultMinDexFilesForSwap = 2;
101static constexpr size_t kDefaultMinDexFileCumulativeSizeForSwap = 20 * MB;
102
Mathieu Chartier010126f2017-07-15 15:44:18 -0700103// Compiler filter override for very large apps.
104static constexpr CompilerFilter::Filter kLargeAppFilter = CompilerFilter::kVerify;
105
Brian Carlstrom6449c622014-02-10 23:48:36 -0800106static int original_argc;
107static char** original_argv;
108
109static std::string CommandLine() {
110 std::vector<std::string> command;
111 for (int i = 0; i < original_argc; ++i) {
112 command.push_back(original_argv[i]);
113 }
Andreas Gampe9186ced2016-12-12 14:28:21 -0800114 return android::base::Join(command, ' ');
Brian Carlstrom6449c622014-02-10 23:48:36 -0800115}
116
Andreas Gampe046c7062015-05-18 23:22:54 -0700117// A stripped version. Remove some less essential parameters. If we see a "--zip-fd=" parameter, be
118// even more aggressive. There won't be much reasonable data here for us in that case anyways (the
119// locations are all staged).
120static std::string StrippedCommandLine() {
121 std::vector<std::string> command;
122
Calin Juravle07c6d722017-06-07 17:06:12 +0000123 // Do a pre-pass to look for zip-fd and the compiler filter.
Andreas Gampe046c7062015-05-18 23:22:54 -0700124 bool saw_zip_fd = false;
Calin Juravle07c6d722017-06-07 17:06:12 +0000125 bool saw_compiler_filter = false;
Andreas Gampe046c7062015-05-18 23:22:54 -0700126 for (int i = 0; i < original_argc; ++i) {
Andreas Gampe9186ced2016-12-12 14:28:21 -0800127 if (android::base::StartsWith(original_argv[i], "--zip-fd=")) {
Andreas Gampe046c7062015-05-18 23:22:54 -0700128 saw_zip_fd = true;
Andreas Gampe046c7062015-05-18 23:22:54 -0700129 }
Calin Juravle07c6d722017-06-07 17:06:12 +0000130 if (android::base::StartsWith(original_argv[i], "--compiler-filter=")) {
131 saw_compiler_filter = true;
Calin Juravle07c6d722017-06-07 17:06:12 +0000132 }
Andreas Gampe046c7062015-05-18 23:22:54 -0700133 }
134
135 // Now filter out things.
136 for (int i = 0; i < original_argc; ++i) {
137 // All runtime-arg parameters are dropped.
138 if (strcmp(original_argv[i], "--runtime-arg") == 0) {
139 i++; // Drop the next part, too.
140 continue;
141 }
142
143 // Any instruction-setXXX is dropped.
Andreas Gampe9186ced2016-12-12 14:28:21 -0800144 if (android::base::StartsWith(original_argv[i], "--instruction-set")) {
Andreas Gampe046c7062015-05-18 23:22:54 -0700145 continue;
146 }
147
148 // The boot image is dropped.
Andreas Gampe9186ced2016-12-12 14:28:21 -0800149 if (android::base::StartsWith(original_argv[i], "--boot-image=")) {
Andreas Gampe046c7062015-05-18 23:22:54 -0700150 continue;
151 }
152
Mathieu Chartier97590cc2016-02-03 15:50:29 -0800153 // The image format is dropped.
Andreas Gampe9186ced2016-12-12 14:28:21 -0800154 if (android::base::StartsWith(original_argv[i], "--image-format=")) {
Mathieu Chartier97590cc2016-02-03 15:50:29 -0800155 continue;
156 }
157
Andreas Gampe046c7062015-05-18 23:22:54 -0700158 // This should leave any dex-file and oat-file options, describing what we compiled.
159
160 // However, we prefer to drop this when we saw --zip-fd.
161 if (saw_zip_fd) {
Mathieu Chartiera90c7722015-10-29 15:41:36 -0700162 // Drop anything --zip-X, --dex-X, --oat-X, --swap-X, or --app-image-X
Andreas Gampe9186ced2016-12-12 14:28:21 -0800163 if (android::base::StartsWith(original_argv[i], "--zip-") ||
164 android::base::StartsWith(original_argv[i], "--dex-") ||
165 android::base::StartsWith(original_argv[i], "--oat-") ||
166 android::base::StartsWith(original_argv[i], "--swap-") ||
167 android::base::StartsWith(original_argv[i], "--app-image-")) {
Andreas Gampe046c7062015-05-18 23:22:54 -0700168 continue;
169 }
170 }
171
172 command.push_back(original_argv[i]);
173 }
174
Calin Juravle07c6d722017-06-07 17:06:12 +0000175 if (!saw_compiler_filter) {
176 command.push_back("--compiler-filter=" +
177 CompilerFilter::NameOfFilter(CompilerFilter::kDefaultCompilerFilter));
178 }
179
Andreas Gampe046c7062015-05-18 23:22:54 -0700180 // Construct the final output.
181 if (command.size() <= 1U) {
182 // It seems only "/system/bin/dex2oat" is left, or not even that. Use a pretty line.
183 return "Starting dex2oat.";
184 }
Andreas Gampe9186ced2016-12-12 14:28:21 -0800185 return android::base::Join(command, ' ');
Andreas Gampe046c7062015-05-18 23:22:54 -0700186}
187
Brian Carlstrom7940e442013-07-12 13:46:57 -0700188static void UsageErrorV(const char* fmt, va_list ap) {
189 std::string error;
190 StringAppendV(&error, fmt, ap);
191 LOG(ERROR) << error;
192}
193
194static void UsageError(const char* fmt, ...) {
195 va_list ap;
196 va_start(ap, fmt);
197 UsageErrorV(fmt, ap);
198 va_end(ap);
199}
200
Andreas Gampe794ad762015-02-23 08:12:24 -0800201NO_RETURN static void Usage(const char* fmt, ...) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700202 va_list ap;
203 va_start(ap, fmt);
204 UsageErrorV(fmt, ap);
205 va_end(ap);
206
Brian Carlstrom6449c622014-02-10 23:48:36 -0800207 UsageError("Command: %s", CommandLine().c_str());
208
Brian Carlstrom7940e442013-07-12 13:46:57 -0700209 UsageError("Usage: dex2oat [options]...");
210 UsageError("");
Jean-Philippe Halimi3d329d72015-03-23 14:09:48 +0100211 UsageError(" -j<number>: specifies the number of threads used for compilation.");
212 UsageError(" Default is the number of detected hardware threads available on the");
213 UsageError(" host system.");
214 UsageError(" Example: -j12");
215 UsageError("");
Richard Uhlere934df22015-03-17 11:26:16 -0700216 UsageError(" --dex-file=<dex-file>: specifies a .dex, .jar, or .apk file to compile.");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700217 UsageError(" Example: --dex-file=/system/framework/core.jar");
218 UsageError("");
Richard Uhlere934df22015-03-17 11:26:16 -0700219 UsageError(" --dex-location=<dex-location>: specifies an alternative dex location to");
220 UsageError(" encode in the oat file for the corresponding --dex-file argument.");
221 UsageError(" Example: --dex-file=/home/build/out/system/framework/core.jar");
222 UsageError(" --dex-location=/system/framework/core.jar");
223 UsageError("");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700224 UsageError(" --zip-fd=<file-descriptor>: specifies a file descriptor of a zip file");
225 UsageError(" containing a classes.dex file to compile.");
226 UsageError(" Example: --zip-fd=5");
227 UsageError("");
Brian Carlstrom45602482013-07-21 22:07:55 -0700228 UsageError(" --zip-location=<zip-location>: specifies a symbolic name for the file");
229 UsageError(" corresponding to the file descriptor specified by --zip-fd.");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700230 UsageError(" Example: --zip-location=/system/app/Calculator.apk");
231 UsageError("");
Jeff Haodcdc85b2015-12-04 14:06:18 -0800232 UsageError(" --oat-file=<file.oat>: specifies an oat output destination via a filename.");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700233 UsageError(" Example: --oat-file=/system/framework/boot.oat");
234 UsageError("");
235 UsageError(" --oat-fd=<number>: specifies the oat output destination via a file descriptor.");
Wonil Kim9cb554a2014-04-28 11:26:55 +0900236 UsageError(" Example: --oat-fd=6");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700237 UsageError("");
Shubham Ajmera66205322017-10-06 11:18:51 -0700238 UsageError(" --input-vdex-fd=<number>: specifies the vdex input source via a file descriptor.");
239 UsageError(" Example: --input-vdex-fd=6");
240 UsageError("");
241 UsageError(" --output-vdex-fd=<number>: specifies the vdex output destination via a file");
242 UsageError(" descriptor.");
243 UsageError(" Example: --output-vdex-fd=6");
244 UsageError("");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700245 UsageError(" --oat-location=<oat-name>: specifies a symbolic name for the file corresponding");
246 UsageError(" to the file descriptor specified by --oat-fd.");
247 UsageError(" Example: --oat-location=/data/dalvik-cache/system@app@Calculator.apk.oat");
248 UsageError("");
Jeff Haodcdc85b2015-12-04 14:06:18 -0800249 UsageError(" --oat-symbols=<file.oat>: specifies an oat output destination with full symbols.");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700250 UsageError(" Example: --oat-symbols=/symbols/system/framework/boot.oat");
251 UsageError("");
Jeff Haodcdc85b2015-12-04 14:06:18 -0800252 UsageError(" --image=<file.art>: specifies an output image filename.");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700253 UsageError(" Example: --image=/system/framework/boot.art");
254 UsageError("");
Mathieu Chartiera6e81ed2016-02-25 13:52:10 -0800255 UsageError(" --image-format=(uncompressed|lz4|lz4hc):");
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800256 UsageError(" Which format to store the image.");
257 UsageError(" Example: --image-format=lz4");
258 UsageError(" Default: uncompressed");
259 UsageError("");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700260 UsageError(" --image-classes=<classname-file>: specifies classes to include in an image.");
261 UsageError(" Example: --image=frameworks/base/preloaded-classes");
262 UsageError("");
263 UsageError(" --base=<hex-address>: specifies the base address when creating a boot image.");
264 UsageError(" Example: --base=0x50000000");
265 UsageError("");
266 UsageError(" --boot-image=<file.art>: provide the image file for the boot class path.");
Kevin Brodsky64fff412015-11-24 14:24:34 +0000267 UsageError(" Do not include the arch as part of the name, it is added automatically.");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700268 UsageError(" Example: --boot-image=/system/framework/boot.art");
Kevin Brodsky64fff412015-11-24 14:24:34 +0000269 UsageError(" (specifies /system/framework/<arch>/boot.art as the image file)");
Nicolas Geoffray9583fbc2014-02-28 15:21:07 +0000270 UsageError(" Default: $ANDROID_ROOT/system/framework/boot.art");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700271 UsageError("");
272 UsageError(" --android-root=<path>: used to locate libraries for portable linking.");
273 UsageError(" Example: --android-root=out/host/linux-x86");
274 UsageError(" Default: $ANDROID_ROOT");
275 UsageError("");
Andreas Gampe57b34292015-01-14 15:45:59 -0800276 UsageError(" --instruction-set=(arm|arm64|mips|mips64|x86|x86_64): compile for a particular");
Alex Light53cb16b2014-06-12 11:26:29 -0700277 UsageError(" instruction set.");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700278 UsageError(" Example: --instruction-set=x86");
279 UsageError(" Default: arm");
280 UsageError("");
Dave Allison70202782013-10-22 17:52:19 -0700281 UsageError(" --instruction-set-features=...,: Specify instruction set features");
282 UsageError(" Example: --instruction-set-features=div");
283 UsageError(" Default: default");
284 UsageError("");
Igor Murashkin46774762014-10-22 11:37:02 -0700285 UsageError(" --compile-pic: Force indirect use of code, methods, and classes");
286 UsageError(" Default: disabled");
287 UsageError("");
Elliott Hughes956af0f2014-12-11 14:34:28 -0800288 UsageError(" --compiler-backend=(Quick|Optimizing): select compiler backend");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700289 UsageError(" set.");
Elliott Hughes956af0f2014-12-11 14:34:28 -0800290 UsageError(" Example: --compiler-backend=Optimizing");
Nicolas Geoffray409e8092015-10-01 10:32:19 +0100291 UsageError(" Default: Optimizing");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700292 UsageError("");
Nicolas Geoffray88157ef2014-09-12 10:29:53 +0100293 UsageError(" --compiler-filter="
Nicolas Geoffray49cda062017-04-21 13:08:25 +0100294 "(assume-verified"
295 "|extract"
296 "|verify"
297 "|quicken"
Andreas Gampe29d38e72016-03-23 15:31:51 +0000298 "|space-profile"
Nicolas Geoffray88157ef2014-09-12 10:29:53 +0100299 "|space"
Andreas Gampe29d38e72016-03-23 15:31:51 +0000300 "|speed-profile"
Nicolas Geoffray88157ef2014-09-12 10:29:53 +0100301 "|speed"
Andreas Gampe29d38e72016-03-23 15:31:51 +0000302 "|everything-profile"
303 "|everything):");
Jeff Hao4a200f52014-04-01 14:58:49 -0700304 UsageError(" select compiler filter.");
Brian Carlstrom6449c622014-02-10 23:48:36 -0800305 UsageError(" Example: --compiler-filter=everything");
Brian Carlstrom6449c622014-02-10 23:48:36 -0800306 UsageError(" Default: speed");
Brian Carlstrom6449c622014-02-10 23:48:36 -0800307 UsageError("");
Brian Carlstrom6449c622014-02-10 23:48:36 -0800308 UsageError(" --huge-method-max=<method-instruction-count>: threshold size for a huge");
309 UsageError(" method for compiler filter tuning.");
310 UsageError(" Example: --huge-method-max=%d", CompilerOptions::kDefaultHugeMethodThreshold);
311 UsageError(" Default: %d", CompilerOptions::kDefaultHugeMethodThreshold);
312 UsageError("");
313 UsageError(" --large-method-max=<method-instruction-count>: threshold size for a large");
314 UsageError(" method for compiler filter tuning.");
315 UsageError(" Example: --large-method-max=%d", CompilerOptions::kDefaultLargeMethodThreshold);
316 UsageError(" Default: %d", CompilerOptions::kDefaultLargeMethodThreshold);
317 UsageError("");
318 UsageError(" --small-method-max=<method-instruction-count>: threshold size for a small");
319 UsageError(" method for compiler filter tuning.");
320 UsageError(" Example: --small-method-max=%d", CompilerOptions::kDefaultSmallMethodThreshold);
321 UsageError(" Default: %d", CompilerOptions::kDefaultSmallMethodThreshold);
322 UsageError("");
323 UsageError(" --tiny-method-max=<method-instruction-count>: threshold size for a tiny");
324 UsageError(" method for compiler filter tuning.");
325 UsageError(" Example: --tiny-method-max=%d", CompilerOptions::kDefaultTinyMethodThreshold);
326 UsageError(" Default: %d", CompilerOptions::kDefaultTinyMethodThreshold);
327 UsageError("");
328 UsageError(" --num-dex-methods=<method-count>: threshold size for a small dex file for");
329 UsageError(" compiler filter tuning. If the input has fewer than this many methods");
Mathieu Chartier1cc7e8b2016-03-16 14:29:17 -0700330 UsageError(" and the filter is not interpret-only or verify-none or verify-at-runtime, ");
331 UsageError(" overrides the filter to use speed");
Brian Carlstrom6449c622014-02-10 23:48:36 -0800332 UsageError(" Example: --num-dex-method=%d", CompilerOptions::kDefaultNumDexMethodsThreshold);
333 UsageError(" Default: %d", CompilerOptions::kDefaultNumDexMethodsThreshold);
334 UsageError("");
Calin Juravleec748352015-07-29 13:52:12 +0100335 UsageError(" --inline-max-code-units=<code-units-count>: the maximum code units that a method");
336 UsageError(" can have to be considered for inlining. A zero value will disable inlining.");
Roland Levillaina215b952015-08-07 11:38:32 +0100337 UsageError(" Honored only by Optimizing. Has priority over the --compiler-filter option.");
338 UsageError(" Intended for development/experimental use.");
Calin Juravleec748352015-07-29 13:52:12 +0100339 UsageError(" Example: --inline-max-code-units=%d",
340 CompilerOptions::kDefaultInlineMaxCodeUnits);
341 UsageError(" Default: %d", CompilerOptions::kDefaultInlineMaxCodeUnits);
342 UsageError("");
Ian Rogers46398602013-08-20 07:50:36 -0700343 UsageError(" --dump-timing: display a breakdown of where time was spent");
344 UsageError("");
David Srbecky8363c772015-05-28 16:12:43 +0100345 UsageError(" -g");
346 UsageError(" --generate-debug-info: Generate debug information for native debugging,");
347 UsageError(" such as stack unwinding information, ELF symbols and DWARF sections.");
David Srbecky346dc992016-03-13 22:00:07 +0000348 UsageError(" If used without --debuggable, it will be best-effort only.");
David Srbecky3e09eeb2016-01-12 14:54:03 +0000349 UsageError(" This option does not affect the generated code. (disabled by default)");
Alex Light78382fa2014-06-06 15:45:32 -0700350 UsageError("");
David Srbecky8363c772015-05-28 16:12:43 +0100351 UsageError(" --no-generate-debug-info: Do not generate debug information for native debugging.");
David Srbecky8dc73242015-04-12 11:40:39 +0100352 UsageError("");
David Srbecky5b1c2ca2016-01-25 17:32:41 +0000353 UsageError(" --generate-mini-debug-info: Generate minimal amount of LZMA-compressed");
354 UsageError(" debug information necessary to print backtraces. (disabled by default)");
355 UsageError("");
David Srbecky346dc992016-03-13 22:00:07 +0000356 UsageError(" --no-generate-mini-debug-info: Do not generate backtrace info.");
David Srbecky5b1c2ca2016-01-25 17:32:41 +0000357 UsageError("");
Alexey Alexandrovab40c112016-09-19 09:33:49 -0700358 UsageError(" --generate-build-id: Generate GNU-compatible linker build ID ELF section with");
359 UsageError(" SHA-1 of the file content (and thus stable across identical builds)");
360 UsageError("");
361 UsageError(" --no-generate-build-id: Do not generate the build ID ELF section.");
362 UsageError("");
David Srbecky3e09eeb2016-01-12 14:54:03 +0000363 UsageError(" --debuggable: Produce code debuggable with Java debugger.");
David Srbecky0cf44932015-12-09 14:09:59 +0000364 UsageError("");
Mathieu Chartierd1ab1bd2017-08-04 10:21:50 -0700365 UsageError(" --avoid-storing-invocation: Avoid storing the invocation args in the key value");
366 UsageError(" store. Used to test determinism with different args.");
367 UsageError("");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700368 UsageError(" --runtime-arg <argument>: used to specify various arguments for the runtime,");
369 UsageError(" such as initial heap size, maximum heap size, and verbose output.");
370 UsageError(" Use a separate --runtime-arg switch for each argument.");
371 UsageError(" Example: --runtime-arg -Xms256m");
Jeff Hao4a200f52014-04-01 14:58:49 -0700372 UsageError("");
Dave Allisond6ed6422014-04-09 23:36:15 +0000373 UsageError(" --profile-file=<filename>: specify profiler output file to use for compilation.");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700374 UsageError("");
Calin Juravle877fd962016-01-05 14:29:29 +0000375 UsageError(" --profile-file-fd=<number>: same as --profile-file but accepts a file descriptor.");
376 UsageError(" Cannot be used together with --profile-file.");
377 UsageError("");
Roland Levillainf5bea5e2017-05-02 12:46:07 +0100378 UsageError(" --swap-file=<file-name>: specifies a file to use for swap.");
Andreas Gampee21dc3d2014-12-08 16:59:43 -0800379 UsageError(" Example: --swap-file=/data/tmp/swap.001");
380 UsageError("");
Roland Levillainf5bea5e2017-05-02 12:46:07 +0100381 UsageError(" --swap-fd=<file-descriptor>: specifies a file to use for swap (by descriptor).");
Andreas Gampee21dc3d2014-12-08 16:59:43 -0800382 UsageError(" Example: --swap-fd=10");
383 UsageError("");
Roland Levillainf5bea5e2017-05-02 12:46:07 +0100384 UsageError(" --swap-dex-size-threshold=<size>: specifies the minimum total dex file size in");
Andreas Gampee1459ae2016-06-29 09:36:30 -0700385 UsageError(" bytes to allow the use of swap.");
386 UsageError(" Example: --swap-dex-size-threshold=1000000");
387 UsageError(" Default: %zu", kDefaultMinDexFileCumulativeSizeForSwap);
388 UsageError("");
Roland Levillainf5bea5e2017-05-02 12:46:07 +0100389 UsageError(" --swap-dex-count-threshold=<count>: specifies the minimum number of dex files to");
Andreas Gampee1459ae2016-06-29 09:36:30 -0700390 UsageError(" allow the use of swap.");
391 UsageError(" Example: --swap-dex-count-threshold=10");
392 UsageError(" Default: %zu", kDefaultMinDexFilesForSwap);
393 UsageError("");
Roland Levillainf5bea5e2017-05-02 12:46:07 +0100394 UsageError(" --very-large-app-threshold=<size>: specifies the minimum total dex file size in");
Mathieu Chartier010126f2017-07-15 15:44:18 -0700395 UsageError(" bytes to consider the input \"very large\" and reduce compilation done.");
Andreas Gampe67f02822016-06-24 21:05:23 -0700396 UsageError(" Example: --very-large-app-threshold=100000000");
397 UsageError("");
Mathieu Chartiera90c7722015-10-29 15:41:36 -0700398 UsageError(" --app-image-fd=<file-descriptor>: specify output file descriptor for app image.");
399 UsageError(" Example: --app-image-fd=10");
400 UsageError("");
401 UsageError(" --app-image-file=<file-name>: specify a file name for app image.");
402 UsageError(" Example: --app-image-file=/data/dalvik-cache/system@app@Calculator.apk.art");
403 UsageError("");
Jeff Haodcdc85b2015-12-04 14:06:18 -0800404 UsageError(" --multi-image: specify that separate oat and image files be generated for each "
405 "input dex file.");
406 UsageError("");
Roland Levillaineb2c7412016-01-28 14:37:01 +0000407 UsageError(" --force-determinism: force the compiler to emit a deterministic output.");
Roland Levillaineb2c7412016-01-28 14:37:01 +0000408 UsageError("");
Roland Levillainf5bea5e2017-05-02 12:46:07 +0100409 UsageError(" --dump-cfg=<cfg-file>: dump control-flow graphs (CFGs) to specified file.");
410 UsageError(" Example: --dump-cfg=output.cfg");
411 UsageError("");
412 UsageError(" --dump-cfg-append: when dumping CFGs to an existing file, append new CFG data to");
413 UsageError(" existing data (instead of overwriting existing data with new data, which is");
414 UsageError(" the default behavior). This option is only meaningful when used with");
415 UsageError(" --dump-cfg.");
416 UsageError("");
Jeff Hao16d48432017-04-05 17:05:46 -0700417 UsageError(" --classpath-dir=<directory-path>: directory used to resolve relative class paths.");
418 UsageError("");
Calin Juravle1ce70852017-06-28 10:59:03 -0700419 UsageError(" --class-loader-context=<string spec>: a string specifying the intended");
420 UsageError(" runtime loading context for the compiled dex files.");
Jeff Haoc23b0c02017-07-27 18:19:38 -0700421 UsageError("");
Calin Juravle1ce70852017-06-28 10:59:03 -0700422 UsageError(" It describes how the class loader chain should be built in order to ensure");
423 UsageError(" classes are resolved during dex2aot as they would be resolved at runtime.");
424 UsageError(" This spec will be encoded in the oat file. If at runtime the dex file is");
425 UsageError(" loaded in a different context, the oat file will be rejected.");
Jeff Haoc23b0c02017-07-27 18:19:38 -0700426 UsageError("");
Calin Juravle1ce70852017-06-28 10:59:03 -0700427 UsageError(" The chain is interpreted in the natural 'parent order', meaning that class");
428 UsageError(" loader 'i+1' will be the parent of class loader 'i'.");
Calin Juravlec79470d2017-07-12 17:37:42 -0700429 UsageError(" The compilation sources will be appended to the classpath of the first class");
430 UsageError(" loader.");
Jeff Haoc23b0c02017-07-27 18:19:38 -0700431 UsageError("");
Calin Juravlec79470d2017-07-12 17:37:42 -0700432 UsageError(" E.g. if the context is 'PCL[lib1.dex];DLC[lib2.dex]' and ");
433 UsageError(" --dex-file=src.dex then dex2oat will setup a PathClassLoader with classpath ");
434 UsageError(" 'lib1.dex:src.dex' and set its parent to a DelegateLastClassLoader with ");
435 UsageError(" classpath 'lib2.dex'.");
Calin Juravle1ce70852017-06-28 10:59:03 -0700436 UsageError(" ");
437 UsageError(" Note that the compiler will be tolerant if the source dex files specified");
438 UsageError(" with --dex-file are found in the classpath. The source dex files will be");
439 UsageError(" removed from any class loader's classpath possibly resulting in empty");
440 UsageError(" class loaders.");
Jeff Haoc23b0c02017-07-27 18:19:38 -0700441 UsageError("");
Calin Juravlec79470d2017-07-12 17:37:42 -0700442 UsageError(" Example: --class-loader-context=PCL[lib1.dex:lib2.dex];DLC[lib3.dex]");
Calin Juravle1ce70852017-06-28 10:59:03 -0700443 UsageError("");
Jeff Haoc23b0c02017-07-27 18:19:38 -0700444 UsageError(" --dirty-image-objects=<directory-path>: list of known dirty objects in the image.");
445 UsageError(" The image writer will group them together.");
446 UsageError("");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700447 std::cerr << "See log for usage error information\n";
448 exit(EXIT_FAILURE);
449}
450
Brian Carlstrom7940e442013-07-12 13:46:57 -0700451// The primary goal of the watchdog is to prevent stuck build servers
452// during development when fatal aborts lead to a cascade of failures
453// that result in a deadlock.
454class WatchDog {
Brian Carlstrom95b033b2014-12-03 22:29:37 -0800455// WatchDog defines its own CHECK_PTHREAD_CALL to avoid using LOG which uses locks
Brian Carlstrom7940e442013-07-12 13:46:57 -0700456#undef CHECK_PTHREAD_CALL
457#define CHECK_WATCH_DOG_PTHREAD_CALL(call, args, what) \
458 do { \
459 int rc = call args; \
460 if (rc != 0) { \
461 errno = rc; \
462 std::string message(# call); \
463 message += " failed for "; \
464 message += reason; \
465 Fatal(message); \
466 } \
467 } while (false)
468
469 public:
Andreas Gampe2e8a2562017-01-18 20:39:02 -0800470 explicit WatchDog(int64_t timeout_in_milliseconds)
471 : timeout_in_milliseconds_(timeout_in_milliseconds),
472 shutting_down_(false) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700473 const char* reason = "dex2oat watch dog thread startup";
Kenny Root51316382014-05-13 14:59:37 -0700474 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_init, (&mutex_, nullptr), reason);
Mathieu Chartierdbf44402017-02-22 16:07:23 -0800475#ifndef __APPLE__
476 pthread_condattr_t condattr;
liulvping8f7101e2017-01-16 15:14:43 +0800477 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_condattr_init, (&condattr), reason);
478 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_condattr_setclock, (&condattr, CLOCK_MONOTONIC), reason);
479 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_cond_init, (&cond_, &condattr), reason);
480 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_condattr_destroy, (&condattr), reason);
Mathieu Chartierdbf44402017-02-22 16:07:23 -0800481#endif
Brian Carlstrom7940e442013-07-12 13:46:57 -0700482 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_attr_init, (&attr_), reason);
483 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_create, (&pthread_, &attr_, &CallBack, this), reason);
484 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_attr_destroy, (&attr_), reason);
485 }
486 ~WatchDog() {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700487 const char* reason = "dex2oat watch dog thread shutdown";
488 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_lock, (&mutex_), reason);
489 shutting_down_ = true;
490 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_cond_signal, (&cond_), reason);
491 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_unlock, (&mutex_), reason);
492
Kenny Root51316382014-05-13 14:59:37 -0700493 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_join, (pthread_, nullptr), reason);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700494
495 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_cond_destroy, (&cond_), reason);
496 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_destroy, (&mutex_), reason);
497 }
498
Andreas Gampe2e8a2562017-01-18 20:39:02 -0800499 // TODO: tune the multiplier for GC verification, the following is just to make the timeout
500 // large.
501 static constexpr int64_t kWatchdogVerifyMultiplier =
502 kVerifyObjectSupport > kVerifyObjectModeFast ? 100 : 1;
503
504 // When setting timeouts, keep in mind that the build server may not be as fast as your
505 // desktop. Debug builds are slower so they have larger timeouts.
506 static constexpr int64_t kWatchdogSlowdownFactor = kIsDebugBuild ? 5U : 1U;
507
508 // 9.5 minutes scaled by kSlowdownFactor. This is slightly smaller than the Package Manager
509 // watchdog (PackageManagerService.WATCHDOG_TIMEOUT, 10 minutes), so that dex2oat will abort
510 // itself before that watchdog would take down the system server.
511 static constexpr int64_t kWatchDogTimeoutSeconds = kWatchdogSlowdownFactor * (9 * 60 + 30);
512
513 static constexpr int64_t kDefaultWatchdogTimeoutInMS =
514 kWatchdogVerifyMultiplier * kWatchDogTimeoutSeconds * 1000;
515
Brian Carlstrom7940e442013-07-12 13:46:57 -0700516 private:
517 static void* CallBack(void* arg) {
518 WatchDog* self = reinterpret_cast<WatchDog*>(arg);
519 ::art::SetThreadName("dex2oat watch dog");
520 self->Wait();
Kenny Root51316382014-05-13 14:59:37 -0700521 return nullptr;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700522 }
523
Andreas Gampe794ad762015-02-23 08:12:24 -0800524 NO_RETURN static void Fatal(const std::string& message) {
Andreas Gamped687e372015-04-28 23:16:03 -0700525 // TODO: When we can guarantee it won't prevent shutdown in error cases, move to LOG. However,
526 // it's rather easy to hang in unwinding.
527 // LogLine also avoids ART logging lock issues, as it's really only a wrapper around
528 // logcat logging or stderr output.
Andreas Gampe3fec9ac2016-09-13 10:47:28 -0700529 android::base::LogMessage::LogLine(__FILE__,
530 __LINE__,
531 android::base::LogId::DEFAULT,
532 LogSeverity::FATAL,
533 message.c_str());
Andreas Gampe48fde372017-06-06 07:43:46 -0700534 // If we're on the host, try to dump all threads to get a sense of what's going on. This is
535 // restricted to the host as the dump may itself go bad.
536 // TODO: Use a double watchdog timeout, so we can enable this on-device.
537 if (!kIsTargetBuild && Runtime::Current() != nullptr) {
Andreas Gampecd607312017-06-05 17:03:05 -0700538 Runtime::Current()->AttachCurrentThread("Watchdog thread attached for dumping",
539 true,
540 nullptr,
541 false);
542 Runtime::Current()->DumpForSigQuit(std::cerr);
543 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700544 exit(1);
545 }
546
547 void Wait() {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700548 timespec timeout_ts;
Mathieu Chartierdbf44402017-02-22 16:07:23 -0800549#if defined(__APPLE__)
550 InitTimeSpec(true, CLOCK_REALTIME, timeout_in_milliseconds_, 0, &timeout_ts);
551#else
liulvping8f7101e2017-01-16 15:14:43 +0800552 InitTimeSpec(true, CLOCK_MONOTONIC, timeout_in_milliseconds_, 0, &timeout_ts);
Mathieu Chartierdbf44402017-02-22 16:07:23 -0800553#endif
Brian Carlstrom7940e442013-07-12 13:46:57 -0700554 const char* reason = "dex2oat watch dog thread waiting";
555 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_lock, (&mutex_), reason);
556 while (!shutting_down_) {
Brian Carlstrom95b033b2014-12-03 22:29:37 -0800557 int rc = TEMP_FAILURE_RETRY(pthread_cond_timedwait(&cond_, &mutex_, &timeout_ts));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700558 if (rc == ETIMEDOUT) {
Andreas Gamped687e372015-04-28 23:16:03 -0700559 Fatal(StringPrintf("dex2oat did not finish after %" PRId64 " seconds",
Andreas Gampe2e8a2562017-01-18 20:39:02 -0800560 timeout_in_milliseconds_/1000));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700561 } else if (rc != 0) {
562 std::string message(StringPrintf("pthread_cond_timedwait failed: %s",
563 strerror(errno)));
564 Fatal(message.c_str());
565 }
566 }
567 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_unlock, (&mutex_), reason);
568 }
569
Brian Carlstrom7940e442013-07-12 13:46:57 -0700570 // TODO: Switch to Mutex when we can guarantee it won't prevent shutdown in error cases.
571 pthread_mutex_t mutex_;
572 pthread_cond_t cond_;
573 pthread_attr_t attr_;
574 pthread_t pthread_;
Andreas Gampef45d61c2017-06-07 10:29:33 -0700575
576 const int64_t timeout_in_milliseconds_;
577 bool shutting_down_;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700578};
Brian Carlstrom7940e442013-07-12 13:46:57 -0700579
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800580class Dex2Oat FINAL {
581 public:
582 explicit Dex2Oat(TimingLogger* timings) :
Nicolas Geoffray409e8092015-10-01 10:32:19 +0100583 compiler_kind_(Compiler::kOptimizing),
Artem Serovba6b6792016-08-15 14:22:07 +0100584 instruction_set_(kRuntimeISA == kArm ? kThumb2 : kRuntimeISA),
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800585 // Take the default set of instruction features from the build.
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000586 image_file_location_oat_checksum_(0),
587 image_file_location_oat_data_begin_(0),
588 image_patch_delta_(0),
589 key_value_store_(nullptr),
Andreas Gampe3f30e122015-09-17 14:03:21 -0700590 verification_results_(nullptr),
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800591 runtime_(nullptr),
592 thread_count_(sysconf(_SC_NPROCESSORS_CONF)),
593 start_ns_(NanoTime()),
Andreas Gampec560fc02014-07-16 09:57:39 -0700594 start_cputime_ns_(ProcessCpuNanoTime()),
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800595 oat_fd_(-1),
Nicolas Geoffraya6a448a2016-11-10 10:49:40 +0000596 input_vdex_fd_(-1),
597 output_vdex_fd_(-1),
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +0000598 input_vdex_file_(nullptr),
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800599 zip_fd_(-1),
600 image_base_(0U),
601 image_classes_zip_filename_(nullptr),
602 image_classes_filename_(nullptr),
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800603 image_storage_mode_(ImageHeader::kStorageModeUncompressed),
Andreas Gampe4bf3ae92014-11-11 13:28:29 -0800604 compiled_classes_zip_filename_(nullptr),
605 compiled_classes_filename_(nullptr),
Andreas Gampe70bef0d2015-04-15 02:37:28 -0700606 compiled_methods_zip_filename_(nullptr),
607 compiled_methods_filename_(nullptr),
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -0700608 passes_to_run_filename_(nullptr),
Mathieu Chartierff0baff2017-08-02 23:04:19 -0700609 dirty_image_objects_filename_(nullptr),
Jeff Hao436183f2016-01-12 16:36:50 -0800610 multi_image_(false),
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800611 is_host_(false),
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000612 elf_writers_(),
613 oat_writers_(),
614 rodata_(),
Vladimir Marko10c13562015-11-25 14:33:36 +0000615 image_writer_(nullptr),
Andreas Gampe3f30e122015-09-17 14:03:21 -0700616 driver_(nullptr),
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000617 opened_dex_files_maps_(),
618 opened_dex_files_(),
Vladimir Marko47496c22016-01-27 16:15:08 +0000619 no_inline_from_dex_files_(),
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800620 dump_stats_(false),
621 dump_passes_(false),
622 dump_timing_(false),
623 dump_slow_timing_(kIsDebugBuild),
Mathieu Chartierd1ab1bd2017-08-04 10:21:50 -0700624 avoid_storing_invocation_(false),
Calin Juravle2e2db782016-02-23 12:00:03 +0000625 swap_fd_(kInvalidFd),
Mathieu Chartierfbc31082016-01-24 11:59:56 -0800626 app_image_fd_(kInvalidFd),
Calin Juravle2e2db782016-02-23 12:00:03 +0000627 profile_file_fd_(kInvalidFd),
Andreas Gampeace0dc12016-01-20 13:33:13 -0800628 timings_(timings),
Calin Juravle2e2db782016-02-23 12:00:03 +0000629 force_determinism_(false)
630 {}
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800631
632 ~Dex2Oat() {
Richard Uhlerfbef44d2014-12-23 09:48:51 -0800633 // Log completion time before deleting the runtime_, because this accesses
634 // the runtime.
635 LogCompletionTime();
636
Vladimir Marko307dac92015-10-20 11:20:09 +0100637 if (!kIsDebugBuild && !(RUNNING_ON_MEMORY_TOOL && kMemoryToolDetectsLeaks)) {
638 // We want to just exit on non-debug builds, not bringing the runtime down
639 // in an orderly fashion. So release the following fields.
640 driver_.release();
641 image_writer_.release();
642 for (std::unique_ptr<const DexFile>& dex_file : opened_dex_files_) {
643 dex_file.release();
644 }
Vladimir Marko9bdf1082016-01-21 12:15:52 +0000645 for (std::unique_ptr<MemMap>& map : opened_dex_files_maps_) {
646 map.release();
647 }
David Brazdil7b49e6c2016-09-01 11:06:18 +0100648 for (std::unique_ptr<File>& vdex_file : vdex_files_) {
649 vdex_file.release();
650 }
Jeff Haodcdc85b2015-12-04 14:06:18 -0800651 for (std::unique_ptr<File>& oat_file : oat_files_) {
652 oat_file.release();
653 }
Vladimir Marko307dac92015-10-20 11:20:09 +0100654 runtime_.release();
655 verification_results_.release();
656 key_value_store_.release();
Vladimir Markof94b7812014-06-05 15:48:04 +0100657 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700658 }
659
Roland Levillain9ec5e222015-08-17 20:18:41 +0100660 struct ParserOptions {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800661 std::vector<const char*> oat_symbols;
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800662 std::string boot_image_filename;
Andreas Gampe2e8a2562017-01-18 20:39:02 -0800663 int64_t watch_dog_timeout_in_ms = -1;
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800664 bool watch_dog_enabled = true;
Nicolas Geoffray1412dfa2015-03-20 14:48:13 +0000665 bool requested_specific_compiler = false;
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800666 std::string error_msg;
Roland Levillain9ec5e222015-08-17 20:18:41 +0100667 };
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800668
Roland Levillain9ec5e222015-08-17 20:18:41 +0100669 void ParseZipFd(const StringPiece& option) {
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000670 ParseUintOption(option, "--zip-fd", &zip_fd_, Usage);
Roland Levillain9ec5e222015-08-17 20:18:41 +0100671 }
672
Nicolas Geoffraya6a448a2016-11-10 10:49:40 +0000673 void ParseInputVdexFd(const StringPiece& option) {
674 // Note that the input vdex fd might be -1.
675 ParseIntOption(option, "--input-vdex-fd", &input_vdex_fd_, Usage);
676 }
677
678 void ParseOutputVdexFd(const StringPiece& option) {
679 ParseUintOption(option, "--output-vdex-fd", &output_vdex_fd_, Usage);
David Brazdil7b49e6c2016-09-01 11:06:18 +0100680 }
681
Roland Levillain9ec5e222015-08-17 20:18:41 +0100682 void ParseOatFd(const StringPiece& option) {
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000683 ParseUintOption(option, "--oat-fd", &oat_fd_, Usage);
Roland Levillain9ec5e222015-08-17 20:18:41 +0100684 }
685
Calin Juravle877fd962016-01-05 14:29:29 +0000686 void ParseFdForCollection(const StringPiece& option,
687 const char* arg_name,
688 std::vector<uint32_t>* fds) {
689 uint32_t fd;
690 ParseUintOption(option, arg_name, &fd, Usage);
691 fds->push_back(fd);
692 }
693
Roland Levillain9ec5e222015-08-17 20:18:41 +0100694 void ParseJ(const StringPiece& option) {
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000695 ParseUintOption(option, "-j", &thread_count_, Usage, /* is_long_option */ false);
Roland Levillain9ec5e222015-08-17 20:18:41 +0100696 }
697
698 void ParseBase(const StringPiece& option) {
699 DCHECK(option.starts_with("--base="));
700 const char* image_base_str = option.substr(strlen("--base=")).data();
701 char* end;
702 image_base_ = strtoul(image_base_str, &end, 16);
703 if (end == image_base_str || *end != '\0') {
704 Usage("Failed to parse hexadecimal value for option %s", option.data());
705 }
706 }
707
708 void ParseInstructionSet(const StringPiece& option) {
709 DCHECK(option.starts_with("--instruction-set="));
710 StringPiece instruction_set_str = option.substr(strlen("--instruction-set=")).data();
711 // StringPiece is not necessarily zero-terminated, so need to make a copy and ensure it.
712 std::unique_ptr<char[]> buf(new char[instruction_set_str.length() + 1]);
713 strncpy(buf.get(), instruction_set_str.data(), instruction_set_str.length());
714 buf.get()[instruction_set_str.length()] = 0;
715 instruction_set_ = GetInstructionSetFromString(buf.get());
716 // arm actually means thumb2.
717 if (instruction_set_ == InstructionSet::kArm) {
718 instruction_set_ = InstructionSet::kThumb2;
719 }
720 }
721
Shubham Ajmera188b2bf2017-09-20 15:53:35 -0700722 bool VerifyProfileData() {
723 return profile_compilation_info_->VerifyProfileData(dex_files_);
724 }
725
Roland Levillain9ec5e222015-08-17 20:18:41 +0100726 void ParseInstructionSetVariant(const StringPiece& option, ParserOptions* parser_options) {
727 DCHECK(option.starts_with("--instruction-set-variant="));
728 StringPiece str = option.substr(strlen("--instruction-set-variant=")).data();
Andreas Gampe0415b4e2015-01-06 15:17:07 -0800729 instruction_set_features_ = InstructionSetFeatures::FromVariant(
730 instruction_set_, str.as_string(), &parser_options->error_msg);
Roland Levillain9ec5e222015-08-17 20:18:41 +0100731 if (instruction_set_features_.get() == nullptr) {
732 Usage("%s", parser_options->error_msg.c_str());
733 }
734 }
735
736 void ParseInstructionSetFeatures(const StringPiece& option, ParserOptions* parser_options) {
737 DCHECK(option.starts_with("--instruction-set-features="));
738 StringPiece str = option.substr(strlen("--instruction-set-features=")).data();
Andreas Gampe0415b4e2015-01-06 15:17:07 -0800739 if (instruction_set_features_ == nullptr) {
740 instruction_set_features_ = InstructionSetFeatures::FromVariant(
741 instruction_set_, "default", &parser_options->error_msg);
Roland Levillain9ec5e222015-08-17 20:18:41 +0100742 if (instruction_set_features_.get() == nullptr) {
743 Usage("Problem initializing default instruction set features variant: %s",
744 parser_options->error_msg.c_str());
Brian Carlstrom7940e442013-07-12 13:46:57 -0700745 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800746 }
Andreas Gampe0415b4e2015-01-06 15:17:07 -0800747 instruction_set_features_ =
Roland Levillain9ec5e222015-08-17 20:18:41 +0100748 instruction_set_features_->AddFeaturesFromString(str.as_string(),
Andreas Gampe0415b4e2015-01-06 15:17:07 -0800749 &parser_options->error_msg);
750 if (instruction_set_features_ == nullptr) {
Roland Levillain9ec5e222015-08-17 20:18:41 +0100751 Usage("Error parsing '%s': %s", option.data(), parser_options->error_msg.c_str());
752 }
753 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800754
Roland Levillain9ec5e222015-08-17 20:18:41 +0100755 void ParseCompilerBackend(const StringPiece& option, ParserOptions* parser_options) {
756 DCHECK(option.starts_with("--compiler-backend="));
757 parser_options->requested_specific_compiler = true;
758 StringPiece backend_str = option.substr(strlen("--compiler-backend=")).data();
759 if (backend_str == "Quick") {
760 compiler_kind_ = Compiler::kQuick;
761 } else if (backend_str == "Optimizing") {
762 compiler_kind_ = Compiler::kOptimizing;
763 } else {
764 Usage("Unknown compiler backend: %s", backend_str.data());
765 }
766 }
767
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800768 void ParseImageFormat(const StringPiece& option) {
769 const StringPiece substr("--image-format=");
770 DCHECK(option.starts_with(substr));
771 const StringPiece format_str = option.substr(substr.length());
772 if (format_str == "lz4") {
773 image_storage_mode_ = ImageHeader::kStorageModeLZ4;
Mathieu Chartiera6e81ed2016-02-25 13:52:10 -0800774 } else if (format_str == "lz4hc") {
775 image_storage_mode_ = ImageHeader::kStorageModeLZ4HC;
Mathieu Chartierceb07b32015-12-10 09:33:21 -0800776 } else if (format_str == "uncompressed") {
777 image_storage_mode_ = ImageHeader::kStorageModeUncompressed;
778 } else {
779 Usage("Unknown image format: %s", format_str.data());
780 }
781 }
782
Jeff Hao436183f2016-01-12 16:36:50 -0800783 void ProcessOptions(ParserOptions* parser_options) {
Vladimir Markoaad75c62016-10-03 08:46:48 +0000784 compiler_options_->boot_image_ = !image_filenames_.empty();
785 compiler_options_->app_image_ = app_image_fd_ != -1 || !app_image_file_name_.empty();
Mathieu Chartiera90c7722015-10-29 15:41:36 -0700786
Roland Levillain2b03a1f2017-06-06 16:09:59 +0100787 if (IsBootImage() && image_filenames_.size() == 1) {
788 const std::string& boot_image_filename = image_filenames_[0];
789 compiler_options_->core_image_ = CompilerDriver::IsCoreImageFilename(boot_image_filename);
790 }
791
Mathieu Chartiera90c7722015-10-29 15:41:36 -0700792 if (IsAppImage() && IsBootImage()) {
793 Usage("Can't have both --image and (--app-image-fd or --app-image-file)");
794 }
795
Jeff Haodcdc85b2015-12-04 14:06:18 -0800796 if (oat_filenames_.empty() && oat_fd_ == -1) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800797 Usage("Output must be supplied with either --oat-file or --oat-fd");
798 }
799
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +0000800 if (input_vdex_fd_ != -1 && !input_vdex_.empty()) {
801 Usage("Can't have both --input-vdex-fd and --input-vdex");
802 }
803
Nicolas Geoffray4e868fa2017-04-21 17:16:44 +0100804 if (output_vdex_fd_ != -1 && !output_vdex_.empty()) {
805 Usage("Can't have both --output-vdex-fd and --output-vdex");
806 }
807
Jeff Haodcdc85b2015-12-04 14:06:18 -0800808 if (!oat_filenames_.empty() && oat_fd_ != -1) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800809 Usage("--oat-file should not be used with --oat-fd");
810 }
811
Nicolas Geoffraya6a448a2016-11-10 10:49:40 +0000812 if ((output_vdex_fd_ == -1) != (oat_fd_ == -1)) {
David Brazdil7b49e6c2016-09-01 11:06:18 +0100813 Usage("VDEX and OAT output must be specified either with one --oat-filename "
Nicolas Geoffraya6a448a2016-11-10 10:49:40 +0000814 "or with --oat-fd and --output-vdex-fd file descriptors");
David Brazdil7b49e6c2016-09-01 11:06:18 +0100815 }
816
Roland Levillain9ec5e222015-08-17 20:18:41 +0100817 if (!parser_options->oat_symbols.empty() && oat_fd_ != -1) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800818 Usage("--oat-symbols should not be used with --oat-fd");
819 }
820
Roland Levillain9ec5e222015-08-17 20:18:41 +0100821 if (!parser_options->oat_symbols.empty() && is_host_) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800822 Usage("--oat-symbols should not be used with --host");
823 }
824
Nicolas Geoffraya6a448a2016-11-10 10:49:40 +0000825 if (output_vdex_fd_ != -1 && !image_filenames_.empty()) {
826 Usage("--output-vdex-fd should not be used with --image");
David Brazdil7b49e6c2016-09-01 11:06:18 +0100827 }
828
Jeff Haodcdc85b2015-12-04 14:06:18 -0800829 if (oat_fd_ != -1 && !image_filenames_.empty()) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800830 Usage("--oat-fd should not be used with --image");
831 }
832
Jeff Haodcdc85b2015-12-04 14:06:18 -0800833 if (!parser_options->oat_symbols.empty() &&
834 parser_options->oat_symbols.size() != oat_filenames_.size()) {
835 Usage("--oat-file arguments do not match --oat-symbols arguments");
836 }
837
838 if (!image_filenames_.empty() && image_filenames_.size() != oat_filenames_.size()) {
839 Usage("--oat-file arguments do not match --image arguments");
840 }
841
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800842 if (android_root_.empty()) {
843 const char* android_root_env_var = getenv("ANDROID_ROOT");
844 if (android_root_env_var == nullptr) {
845 Usage("--android-root unspecified and ANDROID_ROOT not set");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700846 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800847 android_root_ += android_root_env_var;
848 }
849
Vladimir Markoaad75c62016-10-03 08:46:48 +0000850 if (!IsBootImage() && parser_options->boot_image_filename.empty()) {
Roland Levillain9ec5e222015-08-17 20:18:41 +0100851 parser_options->boot_image_filename += android_root_;
852 parser_options->boot_image_filename += "/framework/boot.art";
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800853 }
Roland Levillain9ec5e222015-08-17 20:18:41 +0100854 if (!parser_options->boot_image_filename.empty()) {
Vladimir Marko49b0f452015-12-10 13:49:19 +0000855 boot_image_filename_ = parser_options->boot_image_filename;
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800856 }
857
Mathieu Chartiera90c7722015-10-29 15:41:36 -0700858 if (image_classes_filename_ != nullptr && !IsBootImage()) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800859 Usage("--image-classes should only be used with --image");
860 }
861
Vladimir Marko49b0f452015-12-10 13:49:19 +0000862 if (image_classes_filename_ != nullptr && !boot_image_filename_.empty()) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800863 Usage("--image-classes should not be used with --boot-image");
864 }
865
866 if (image_classes_zip_filename_ != nullptr && image_classes_filename_ == nullptr) {
867 Usage("--image-classes-zip should be used with --image-classes");
868 }
869
Mathieu Chartiera90c7722015-10-29 15:41:36 -0700870 if (compiled_classes_filename_ != nullptr && !IsBootImage()) {
Andreas Gampe4bf3ae92014-11-11 13:28:29 -0800871 Usage("--compiled-classes should only be used with --image");
872 }
873
Vladimir Marko49b0f452015-12-10 13:49:19 +0000874 if (compiled_classes_filename_ != nullptr && !boot_image_filename_.empty()) {
Andreas Gampe4bf3ae92014-11-11 13:28:29 -0800875 Usage("--compiled-classes should not be used with --boot-image");
876 }
877
878 if (compiled_classes_zip_filename_ != nullptr && compiled_classes_filename_ == nullptr) {
879 Usage("--compiled-classes-zip should be used with --compiled-classes");
880 }
881
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800882 if (dex_filenames_.empty() && zip_fd_ == -1) {
883 Usage("Input must be supplied with either --dex-file or --zip-fd");
884 }
885
886 if (!dex_filenames_.empty() && zip_fd_ != -1) {
887 Usage("--dex-file should not be used with --zip-fd");
888 }
889
890 if (!dex_filenames_.empty() && !zip_location_.empty()) {
891 Usage("--dex-file should not be used with --zip-location");
892 }
893
894 if (dex_locations_.empty()) {
895 for (const char* dex_file_name : dex_filenames_) {
896 dex_locations_.push_back(dex_file_name);
897 }
898 } else if (dex_locations_.size() != dex_filenames_.size()) {
899 Usage("--dex-location arguments do not match --dex-file arguments");
900 }
901
Jeff Haodcdc85b2015-12-04 14:06:18 -0800902 if (!dex_filenames_.empty() && !oat_filenames_.empty()) {
903 if (oat_filenames_.size() != 1 && oat_filenames_.size() != dex_filenames_.size()) {
904 Usage("--oat-file arguments must be singular or match --dex-file arguments");
905 }
906 }
907
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800908 if (zip_fd_ != -1 && zip_location_.empty()) {
909 Usage("--zip-location should be supplied with --zip-fd");
910 }
911
Vladimir Marko49b0f452015-12-10 13:49:19 +0000912 if (boot_image_filename_.empty()) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800913 if (image_base_ == 0) {
914 Usage("Non-zero --base not specified");
915 }
916 }
917
Mathieu Chartiera8077802016-03-16 19:08:31 -0700918 const bool have_profile_file = !profile_file_.empty();
919 const bool have_profile_fd = profile_file_fd_ != kInvalidFd;
920 if (have_profile_file && have_profile_fd) {
Calin Juravle2e2db782016-02-23 12:00:03 +0000921 Usage("Profile file should not be specified with both --profile-file-fd and --profile-file");
Calin Juravle998c2162015-12-21 15:39:33 +0200922 }
923
Mathieu Chartierf70fe3d2017-06-21 15:24:02 -0700924 if (have_profile_file || have_profile_fd) {
925 if (compiled_classes_filename_ != nullptr ||
926 compiled_classes_zip_filename_ != nullptr ||
927 image_classes_filename_ != nullptr ||
928 image_classes_zip_filename_ != nullptr) {
929 Usage("Profile based image creation is not supported with image or compiled classes");
930 }
931 }
932
Roland Levillain9ec5e222015-08-17 20:18:41 +0100933 if (!parser_options->oat_symbols.empty()) {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800934 oat_unstripped_ = std::move(parser_options->oat_symbols);
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800935 }
936
937 // If no instruction set feature was given, use the default one for the target
938 // instruction set.
939 if (instruction_set_features_.get() == nullptr) {
Andreas Gampe0415b4e2015-01-06 15:17:07 -0800940 instruction_set_features_ = InstructionSetFeatures::FromVariant(
941 instruction_set_, "default", &parser_options->error_msg);
Ian Rogersd582fa42014-11-05 23:46:43 -0800942 if (instruction_set_features_.get() == nullptr) {
943 Usage("Problem initializing default instruction set features variant: %s",
Roland Levillain9ec5e222015-08-17 20:18:41 +0100944 parser_options->error_msg.c_str());
Ian Rogersd582fa42014-11-05 23:46:43 -0800945 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800946 }
947
948 if (instruction_set_ == kRuntimeISA) {
949 std::unique_ptr<const InstructionSetFeatures> runtime_features(
950 InstructionSetFeatures::FromCppDefines());
951 if (!instruction_set_features_->Equals(runtime_features.get())) {
952 LOG(WARNING) << "Mismatch between dex2oat instruction set features ("
953 << *instruction_set_features_ << ") and those of dex2oat executable ("
954 << *runtime_features <<") for the command line:\n"
955 << CommandLine();
956 }
957 }
958
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000959 if (compiler_options_->inline_max_code_units_ == CompilerOptions::kUnsetInlineMaxCodeUnits) {
Nicolas Geoffrayf6d46682017-02-28 17:41:45 +0000960 compiler_options_->inline_max_code_units_ = CompilerOptions::kDefaultInlineMaxCodeUnits;
Roland Levillaina215b952015-08-07 11:38:32 +0100961 }
962
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800963 // Checks are all explicit until we know the architecture.
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800964 // Set the compilation target's implicit checks options.
965 switch (instruction_set_) {
966 case kArm:
967 case kThumb2:
968 case kArm64:
969 case kX86:
970 case kX86_64:
Douglas Leung22bb5a22015-07-02 16:42:08 -0700971 case kMips:
972 case kMips64:
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +0000973 compiler_options_->implicit_null_checks_ = true;
974 compiler_options_->implicit_so_checks_ = true;
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800975 break;
976
977 default:
978 // Defaults are correct.
979 break;
980 }
981
Jeff Hao436183f2016-01-12 16:36:50 -0800982 if (!IsBootImage() && multi_image_) {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800983 Usage("--multi-image can only be used when creating boot images");
984 }
Jeff Hao436183f2016-01-12 16:36:50 -0800985 if (IsBootImage() && multi_image_ && image_filenames_.size() > 1) {
Jeff Haodcdc85b2015-12-04 14:06:18 -0800986 Usage("--multi-image cannot be used with multiple image names");
987 }
988
989 // For now, if we're on the host and compile the boot image, *always* use multiple image files.
990 if (!kIsTargetBuild && IsBootImage()) {
991 if (image_filenames_.size() == 1) {
Jeff Hao436183f2016-01-12 16:36:50 -0800992 multi_image_ = true;
Jeff Haodcdc85b2015-12-04 14:06:18 -0800993 }
994 }
995
Andreas Gampe88ec7f42014-11-05 10:18:32 -0800996 // Done with usage checks, enable watchdog if requested
Roland Levillain9ec5e222015-08-17 20:18:41 +0100997 if (parser_options->watch_dog_enabled) {
Andreas Gampe2e8a2562017-01-18 20:39:02 -0800998 int64_t timeout = parser_options->watch_dog_timeout_in_ms > 0
999 ? parser_options->watch_dog_timeout_in_ms
1000 : WatchDog::kDefaultWatchdogTimeoutInMS;
1001 watchdog_.reset(new WatchDog(timeout));
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001002 }
1003
1004 // Fill some values into the key-value store for the oat header.
1005 key_value_store_.reset(new SafeMap<std::string, std::string>());
Andreas Gampeace0dc12016-01-20 13:33:13 -08001006
Roland Levillainb81e9e92017-04-20 17:35:32 +01001007 // Automatically force determinism for the boot image in a host build if read barriers
1008 // are enabled, or if the default GC is CMS or MS. When the default GC is CMS
1009 // (Concurrent Mark-Sweep), the GC is switched to a non-concurrent one by passing the
1010 // option `-Xgc:nonconcurrent` (see below).
Hiroshi Yamauchi6af53482016-01-29 15:38:58 -08001011 if (!kIsTargetBuild && IsBootImage()) {
1012 if (SupportsDeterministicCompilation()) {
1013 force_determinism_ = true;
1014 } else {
1015 LOG(WARNING) << "Deterministic compilation is disabled.";
1016 }
Andreas Gampeace0dc12016-01-20 13:33:13 -08001017 }
1018 compiler_options_->force_determinism_ = force_determinism_;
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07001019
1020 if (passes_to_run_filename_ != nullptr) {
1021 passes_to_run_.reset(ReadCommentedInputFromFile<std::vector<std::string>>(
1022 passes_to_run_filename_,
1023 nullptr)); // No post-processing.
1024 if (passes_to_run_.get() == nullptr) {
1025 Usage("Failed to read list of passes to run.");
1026 }
1027 }
1028 compiler_options_->passes_to_run_ = passes_to_run_.get();
Roland Levillain9ec5e222015-08-17 20:18:41 +01001029 }
1030
Hiroshi Yamauchi6af53482016-01-29 15:38:58 -08001031 static bool SupportsDeterministicCompilation() {
Roland Levillainb81e9e92017-04-20 17:35:32 +01001032 return (kUseReadBarrier ||
1033 gc::kCollectorTypeDefault == gc::kCollectorTypeCMS ||
1034 gc::kCollectorTypeDefault == gc::kCollectorTypeMS);
Hiroshi Yamauchi6af53482016-01-29 15:38:58 -08001035 }
1036
Jeff Hao436183f2016-01-12 16:36:50 -08001037 void ExpandOatAndImageFilenames() {
1038 std::string base_oat = oat_filenames_[0];
1039 size_t last_oat_slash = base_oat.rfind('/');
1040 if (last_oat_slash == std::string::npos) {
1041 Usage("--multi-image used with unusable oat filename %s", base_oat.c_str());
1042 }
1043 // We also need to honor path components that were encoded through '@'. Otherwise the loading
1044 // code won't be able to find the images.
1045 if (base_oat.find('@', last_oat_slash) != std::string::npos) {
1046 last_oat_slash = base_oat.rfind('@');
1047 }
1048 base_oat = base_oat.substr(0, last_oat_slash + 1);
1049
1050 std::string base_img = image_filenames_[0];
1051 size_t last_img_slash = base_img.rfind('/');
1052 if (last_img_slash == std::string::npos) {
1053 Usage("--multi-image used with unusable image filename %s", base_img.c_str());
1054 }
1055 // We also need to honor path components that were encoded through '@'. Otherwise the loading
1056 // code won't be able to find the images.
1057 if (base_img.find('@', last_img_slash) != std::string::npos) {
1058 last_img_slash = base_img.rfind('@');
1059 }
1060
1061 // Get the prefix, which is the primary image name (without path components). Strip the
1062 // extension.
1063 std::string prefix = base_img.substr(last_img_slash + 1);
1064 if (prefix.rfind('.') != std::string::npos) {
1065 prefix = prefix.substr(0, prefix.rfind('.'));
1066 }
1067 if (!prefix.empty()) {
1068 prefix = prefix + "-";
1069 }
1070
1071 base_img = base_img.substr(0, last_img_slash + 1);
1072
1073 // Note: we have some special case here for our testing. We have to inject the differentiating
1074 // parts for the different core images.
1075 std::string infix; // Empty infix by default.
1076 {
1077 // Check the first name.
1078 std::string dex_file = oat_filenames_[0];
1079 size_t last_dex_slash = dex_file.rfind('/');
1080 if (last_dex_slash != std::string::npos) {
1081 dex_file = dex_file.substr(last_dex_slash + 1);
1082 }
1083 size_t last_dex_dot = dex_file.rfind('.');
1084 if (last_dex_dot != std::string::npos) {
1085 dex_file = dex_file.substr(0, last_dex_dot);
1086 }
Andreas Gampe9186ced2016-12-12 14:28:21 -08001087 if (android::base::StartsWith(dex_file, "core-")) {
Jeff Hao436183f2016-01-12 16:36:50 -08001088 infix = dex_file.substr(strlen("core"));
1089 }
1090 }
1091
bowen_lai8bd36c02016-10-12 13:28:55 +08001092 std::string base_symbol_oat;
1093 if (!oat_unstripped_.empty()) {
1094 base_symbol_oat = oat_unstripped_[0];
1095 size_t last_symbol_oat_slash = base_symbol_oat.rfind('/');
1096 if (last_symbol_oat_slash == std::string::npos) {
1097 Usage("--multi-image used with unusable symbol filename %s", base_symbol_oat.c_str());
1098 }
1099 base_symbol_oat = base_symbol_oat.substr(0, last_symbol_oat_slash + 1);
1100 }
1101
1102 const size_t num_expanded_files = 2 + (base_symbol_oat.empty() ? 0 : 1);
1103 char_backing_storage_.reserve((dex_locations_.size() - 1) * num_expanded_files);
Ben Gruvera0fc3262016-09-30 13:10:42 -07001104
Jeff Hao436183f2016-01-12 16:36:50 -08001105 // Now create the other names. Use a counted loop to skip the first one.
1106 for (size_t i = 1; i < dex_locations_.size(); ++i) {
1107 // TODO: Make everything properly std::string.
1108 std::string image_name = CreateMultiImageName(dex_locations_[i], prefix, infix, ".art");
1109 char_backing_storage_.push_back(base_img + image_name);
1110 image_filenames_.push_back((char_backing_storage_.end() - 1)->c_str());
1111
1112 std::string oat_name = CreateMultiImageName(dex_locations_[i], prefix, infix, ".oat");
1113 char_backing_storage_.push_back(base_oat + oat_name);
1114 oat_filenames_.push_back((char_backing_storage_.end() - 1)->c_str());
bowen_lai8bd36c02016-10-12 13:28:55 +08001115
1116 if (!base_symbol_oat.empty()) {
1117 char_backing_storage_.push_back(base_symbol_oat + oat_name);
1118 oat_unstripped_.push_back((char_backing_storage_.end() - 1)->c_str());
1119 }
Jeff Hao436183f2016-01-12 16:36:50 -08001120 }
1121 }
1122
Andreas Gampe8994a042015-12-30 19:03:17 +00001123 // Modify the input string in the following way:
1124 // 0) Assume input is /a/b/c.d
1125 // 1) Strip the path -> c.d
1126 // 2) Inject prefix p -> pc.d
1127 // 3) Inject infix i -> pci.d
1128 // 4) Replace suffix with s if it's "jar" -> d == "jar" -> pci.s
Jeff Haodcdc85b2015-12-04 14:06:18 -08001129 static std::string CreateMultiImageName(std::string in,
Andreas Gampe8994a042015-12-30 19:03:17 +00001130 const std::string& prefix,
Jeff Haodcdc85b2015-12-04 14:06:18 -08001131 const std::string& infix,
Andreas Gampe8994a042015-12-30 19:03:17 +00001132 const char* replace_suffix) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08001133 size_t last_dex_slash = in.rfind('/');
1134 if (last_dex_slash != std::string::npos) {
1135 in = in.substr(last_dex_slash + 1);
1136 }
Andreas Gampe8994a042015-12-30 19:03:17 +00001137 if (!prefix.empty()) {
1138 in = prefix + in;
1139 }
Jeff Haodcdc85b2015-12-04 14:06:18 -08001140 if (!infix.empty()) {
1141 // Inject infix.
1142 size_t last_dot = in.rfind('.');
1143 if (last_dot != std::string::npos) {
1144 in.insert(last_dot, infix);
1145 }
1146 }
Andreas Gampe9186ced2016-12-12 14:28:21 -08001147 if (android::base::EndsWith(in, ".jar")) {
Andreas Gampe8994a042015-12-30 19:03:17 +00001148 in = in.substr(0, in.length() - strlen(".jar")) +
1149 (replace_suffix != nullptr ? replace_suffix : "");
Jeff Haodcdc85b2015-12-04 14:06:18 -08001150 }
1151 return in;
1152 }
1153
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +00001154 void InsertCompileOptions(int argc, char** argv) {
Roland Levillain9ec5e222015-08-17 20:18:41 +01001155 std::ostringstream oss;
Mathieu Chartierd1ab1bd2017-08-04 10:21:50 -07001156 if (!avoid_storing_invocation_) {
1157 for (int i = 0; i < argc; ++i) {
1158 if (i > 0) {
1159 oss << ' ';
1160 }
1161 oss << argv[i];
Roland Levillain9ec5e222015-08-17 20:18:41 +01001162 }
Mathieu Chartierd1ab1bd2017-08-04 10:21:50 -07001163 key_value_store_->Put(OatHeader::kDex2OatCmdLineKey, oss.str());
1164 oss.str(""); // Reset.
Roland Levillain9ec5e222015-08-17 20:18:41 +01001165 }
Roland Levillain9ec5e222015-08-17 20:18:41 +01001166 oss << kRuntimeISA;
1167 key_value_store_->Put(OatHeader::kDex2OatHostKey, oss.str());
1168 key_value_store_->Put(
1169 OatHeader::kPicKey,
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +00001170 compiler_options_->compile_pic_ ? OatHeader::kTrueValue : OatHeader::kFalseValue);
Roland Levillain9ec5e222015-08-17 20:18:41 +01001171 key_value_store_->Put(
1172 OatHeader::kDebuggableKey,
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +00001173 compiler_options_->debuggable_ ? OatHeader::kTrueValue : OatHeader::kFalseValue);
David Srbecky5d950762016-03-07 20:47:29 +00001174 key_value_store_->Put(
1175 OatHeader::kNativeDebuggableKey,
David Srbecky346dc992016-03-13 22:00:07 +00001176 compiler_options_->GetNativeDebuggable() ? OatHeader::kTrueValue : OatHeader::kFalseValue);
Andreas Gampe29d38e72016-03-23 15:31:51 +00001177 key_value_store_->Put(OatHeader::kCompilerFilter,
1178 CompilerFilter::NameOfFilter(compiler_options_->GetCompilerFilter()));
Andreas Gampef8cd8902017-01-18 16:05:01 -08001179 key_value_store_->Put(OatHeader::kConcurrentCopying,
1180 kUseReadBarrier ? OatHeader::kTrueValue : OatHeader::kFalseValue);
Roland Levillain9ec5e222015-08-17 20:18:41 +01001181 }
1182
1183 // Parse the arguments from the command line. In case of an unrecognized option or impossible
1184 // values/combinations, a usage error will be displayed and exit() is called. Thus, if the method
1185 // returns, arguments have been successfully parsed.
1186 void ParseArgs(int argc, char** argv) {
1187 original_argc = argc;
1188 original_argv = argv;
1189
Andreas Gampe51d80cc2017-06-21 21:05:13 -07001190 InitLogging(argv, Runtime::Abort);
Roland Levillain9ec5e222015-08-17 20:18:41 +01001191
1192 // Skip over argv[0].
1193 argv++;
1194 argc--;
1195
1196 if (argc == 0) {
1197 Usage("No arguments specified");
1198 }
1199
1200 std::unique_ptr<ParserOptions> parser_options(new ParserOptions());
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +00001201 compiler_options_.reset(new CompilerOptions());
Roland Levillain9ec5e222015-08-17 20:18:41 +01001202
1203 for (int i = 0; i < argc; i++) {
1204 const StringPiece option(argv[i]);
1205 const bool log_options = false;
1206 if (log_options) {
1207 LOG(INFO) << "dex2oat: option[" << i << "]=" << argv[i];
1208 }
1209 if (option.starts_with("--dex-file=")) {
1210 dex_filenames_.push_back(option.substr(strlen("--dex-file=")).data());
1211 } else if (option.starts_with("--dex-location=")) {
1212 dex_locations_.push_back(option.substr(strlen("--dex-location=")).data());
1213 } else if (option.starts_with("--zip-fd=")) {
1214 ParseZipFd(option);
1215 } else if (option.starts_with("--zip-location=")) {
1216 zip_location_ = option.substr(strlen("--zip-location=")).data();
Nicolas Geoffraya6a448a2016-11-10 10:49:40 +00001217 } else if (option.starts_with("--input-vdex-fd=")) {
1218 ParseInputVdexFd(option);
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00001219 } else if (option.starts_with("--input-vdex=")) {
1220 input_vdex_ = option.substr(strlen("--input-vdex=")).data();
Nicolas Geoffray4e868fa2017-04-21 17:16:44 +01001221 } else if (option.starts_with("--output-vdex=")) {
1222 output_vdex_ = option.substr(strlen("--output-vdex=")).data();
Nicolas Geoffraya6a448a2016-11-10 10:49:40 +00001223 } else if (option.starts_with("--output-vdex-fd=")) {
1224 ParseOutputVdexFd(option);
Roland Levillain9ec5e222015-08-17 20:18:41 +01001225 } else if (option.starts_with("--oat-file=")) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08001226 oat_filenames_.push_back(option.substr(strlen("--oat-file=")).data());
Roland Levillain9ec5e222015-08-17 20:18:41 +01001227 } else if (option.starts_with("--oat-symbols=")) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08001228 parser_options->oat_symbols.push_back(option.substr(strlen("--oat-symbols=")).data());
Roland Levillain9ec5e222015-08-17 20:18:41 +01001229 } else if (option.starts_with("--oat-fd=")) {
1230 ParseOatFd(option);
David Brazdil7b49e6c2016-09-01 11:06:18 +01001231 } else if (option.starts_with("--oat-location=")) {
1232 oat_location_ = option.substr(strlen("--oat-location=")).data();
Roland Levillain9ec5e222015-08-17 20:18:41 +01001233 } else if (option == "--watch-dog") {
1234 parser_options->watch_dog_enabled = true;
1235 } else if (option == "--no-watch-dog") {
1236 parser_options->watch_dog_enabled = false;
Andreas Gampe2e8a2562017-01-18 20:39:02 -08001237 } else if (option.starts_with("--watchdog-timeout=")) {
1238 ParseIntOption(option,
1239 "--watchdog-timeout",
1240 &parser_options->watch_dog_timeout_in_ms,
1241 Usage);
Roland Levillain9ec5e222015-08-17 20:18:41 +01001242 } else if (option.starts_with("-j")) {
1243 ParseJ(option);
Roland Levillain9ec5e222015-08-17 20:18:41 +01001244 } else if (option.starts_with("--image=")) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08001245 image_filenames_.push_back(option.substr(strlen("--image=")).data());
Roland Levillain9ec5e222015-08-17 20:18:41 +01001246 } else if (option.starts_with("--image-classes=")) {
1247 image_classes_filename_ = option.substr(strlen("--image-classes=")).data();
1248 } else if (option.starts_with("--image-classes-zip=")) {
1249 image_classes_zip_filename_ = option.substr(strlen("--image-classes-zip=")).data();
Mathieu Chartierceb07b32015-12-10 09:33:21 -08001250 } else if (option.starts_with("--image-format=")) {
1251 ParseImageFormat(option);
Roland Levillain9ec5e222015-08-17 20:18:41 +01001252 } else if (option.starts_with("--compiled-classes=")) {
1253 compiled_classes_filename_ = option.substr(strlen("--compiled-classes=")).data();
1254 } else if (option.starts_with("--compiled-classes-zip=")) {
1255 compiled_classes_zip_filename_ = option.substr(strlen("--compiled-classes-zip=")).data();
1256 } else if (option.starts_with("--compiled-methods=")) {
1257 compiled_methods_filename_ = option.substr(strlen("--compiled-methods=")).data();
1258 } else if (option.starts_with("--compiled-methods-zip=")) {
1259 compiled_methods_zip_filename_ = option.substr(strlen("--compiled-methods-zip=")).data();
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07001260 } else if (option.starts_with("--run-passes=")) {
1261 passes_to_run_filename_ = option.substr(strlen("--run-passes=")).data();
Roland Levillain9ec5e222015-08-17 20:18:41 +01001262 } else if (option.starts_with("--base=")) {
1263 ParseBase(option);
1264 } else if (option.starts_with("--boot-image=")) {
1265 parser_options->boot_image_filename = option.substr(strlen("--boot-image=")).data();
1266 } else if (option.starts_with("--android-root=")) {
1267 android_root_ = option.substr(strlen("--android-root=")).data();
1268 } else if (option.starts_with("--instruction-set=")) {
1269 ParseInstructionSet(option);
1270 } else if (option.starts_with("--instruction-set-variant=")) {
1271 ParseInstructionSetVariant(option, parser_options.get());
1272 } else if (option.starts_with("--instruction-set-features=")) {
1273 ParseInstructionSetFeatures(option, parser_options.get());
1274 } else if (option.starts_with("--compiler-backend=")) {
1275 ParseCompilerBackend(option, parser_options.get());
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +00001276 } else if (option.starts_with("--profile-file=")) {
Calin Juravle2e2db782016-02-23 12:00:03 +00001277 profile_file_ = option.substr(strlen("--profile-file=")).ToString();
Calin Juravle877fd962016-01-05 14:29:29 +00001278 } else if (option.starts_with("--profile-file-fd=")) {
Calin Juravle2e2db782016-02-23 12:00:03 +00001279 ParseUintOption(option, "--profile-file-fd", &profile_file_fd_, Usage);
Roland Levillain9ec5e222015-08-17 20:18:41 +01001280 } else if (option == "--host") {
1281 is_host_ = true;
1282 } else if (option == "--runtime-arg") {
1283 if (++i >= argc) {
1284 Usage("Missing required argument for --runtime-arg");
1285 }
1286 if (log_options) {
1287 LOG(INFO) << "dex2oat: option[" << i << "]=" << argv[i];
1288 }
1289 runtime_args_.push_back(argv[i]);
1290 } else if (option == "--dump-timing") {
1291 dump_timing_ = true;
1292 } else if (option == "--dump-passes") {
1293 dump_passes_ = true;
Roland Levillain9ec5e222015-08-17 20:18:41 +01001294 } else if (option == "--dump-stats") {
1295 dump_stats_ = true;
Mathieu Chartierd1ab1bd2017-08-04 10:21:50 -07001296 } else if (option == "--avoid-storing-invocation") {
1297 avoid_storing_invocation_ = true;
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +00001298 } else if (option.starts_with("--swap-file=")) {
1299 swap_file_name_ = option.substr(strlen("--swap-file=")).data();
1300 } else if (option.starts_with("--swap-fd=")) {
Mathieu Chartiera90c7722015-10-29 15:41:36 -07001301 ParseUintOption(option, "--swap-fd", &swap_fd_, Usage);
Andreas Gampee1459ae2016-06-29 09:36:30 -07001302 } else if (option.starts_with("--swap-dex-size-threshold=")) {
1303 ParseUintOption(option,
1304 "--swap-dex-size-threshold",
1305 &min_dex_file_cumulative_size_for_swap_,
1306 Usage);
1307 } else if (option.starts_with("--swap-dex-count-threshold=")) {
1308 ParseUintOption(option,
1309 "--swap-dex-count-threshold",
1310 &min_dex_files_for_swap_,
1311 Usage);
Andreas Gampe67f02822016-06-24 21:05:23 -07001312 } else if (option.starts_with("--very-large-app-threshold=")) {
1313 ParseUintOption(option,
1314 "--very-large-app-threshold",
1315 &very_large_threshold_,
1316 Usage);
Mathieu Chartiera90c7722015-10-29 15:41:36 -07001317 } else if (option.starts_with("--app-image-file=")) {
1318 app_image_file_name_ = option.substr(strlen("--app-image-file=")).data();
1319 } else if (option.starts_with("--app-image-fd=")) {
1320 ParseUintOption(option, "--app-image-fd", &app_image_fd_, Usage);
Jeff Haodcdc85b2015-12-04 14:06:18 -08001321 } else if (option == "--multi-image") {
Jeff Hao436183f2016-01-12 16:36:50 -08001322 multi_image_ = true;
Jeff Haodcdc85b2015-12-04 14:06:18 -08001323 } else if (option.starts_with("--no-inline-from=")) {
1324 no_inline_from_string_ = option.substr(strlen("--no-inline-from=")).data();
Andreas Gampeace0dc12016-01-20 13:33:13 -08001325 } else if (option == "--force-determinism") {
Hiroshi Yamauchi6af53482016-01-29 15:38:58 -08001326 if (!SupportsDeterministicCompilation()) {
Roland Levillainb81e9e92017-04-20 17:35:32 +01001327 Usage("Option --force-determinism requires read barriers or a CMS/MS garbage collector");
Roland Levillaineb2c7412016-01-28 14:37:01 +00001328 }
Andreas Gampeace0dc12016-01-20 13:33:13 -08001329 force_determinism_ = true;
Jeff Hao16d48432017-04-05 17:05:46 -07001330 } else if (option.starts_with("--classpath-dir=")) {
1331 classpath_dir_ = option.substr(strlen("--classpath-dir=")).data();
Calin Juravle1ce70852017-06-28 10:59:03 -07001332 } else if (option.starts_with("--class-loader-context=")) {
1333 class_loader_context_ = ClassLoaderContext::Create(
1334 option.substr(strlen("--class-loader-context=")).data());
Calin Juravle19915892017-08-03 17:10:36 +00001335 if (class_loader_context_ == nullptr) {
Calin Juravle1ce70852017-06-28 10:59:03 -07001336 Usage("Option --class-loader-context has an incorrect format: %s", option.data());
1337 }
Jeff Haoc23b0c02017-07-27 18:19:38 -07001338 } else if (option.starts_with("--dirty-image-objects=")) {
1339 dirty_image_objects_filename_ = option.substr(strlen("--dirty-image-objects=")).data();
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +00001340 } else if (!compiler_options_->ParseCompilerOption(option, Usage)) {
Roland Levillain9ec5e222015-08-17 20:18:41 +01001341 Usage("Unknown argument %s", option.data());
1342 }
1343 }
1344
Jeff Hao436183f2016-01-12 16:36:50 -08001345 ProcessOptions(parser_options.get());
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001346
1347 // Insert some compiler things.
Nicolas Geoffrayabbb0f72015-10-29 18:55:58 +00001348 InsertCompileOptions(argc, argv);
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001349 }
1350
Jeff Haodcdc85b2015-12-04 14:06:18 -08001351 // Check whether the oat output files are writable, and open them for later. Also open a swap
1352 // file, if a name is given.
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001353 bool OpenFile() {
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001354 // Prune non-existent dex files now so that we don't create empty oat files for multi-image.
1355 PruneNonExistentDexFiles();
1356
Jeff Hao436183f2016-01-12 16:36:50 -08001357 // Expand oat and image filenames for multi image.
1358 if (IsBootImage() && multi_image_) {
1359 ExpandOatAndImageFilenames();
1360 }
1361
David Brazdil7b49e6c2016-09-01 11:06:18 +01001362 // OAT and VDEX file handling
David Brazdil7b49e6c2016-09-01 11:06:18 +01001363 if (oat_fd_ == -1) {
1364 DCHECK(!oat_filenames_.empty());
Jeff Haodcdc85b2015-12-04 14:06:18 -08001365 for (const char* oat_filename : oat_filenames_) {
1366 std::unique_ptr<File> oat_file(OS::CreateEmptyFile(oat_filename));
Calin Juravleb09be722017-09-25 16:42:48 -07001367 if (oat_file == nullptr) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08001368 PLOG(ERROR) << "Failed to create oat file: " << oat_filename;
1369 return false;
1370 }
David Brazdil7b49e6c2016-09-01 11:06:18 +01001371 if (fchmod(oat_file->Fd(), 0644) != 0) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08001372 PLOG(ERROR) << "Failed to make oat file world readable: " << oat_filename;
1373 oat_file->Erase();
1374 return false;
1375 }
1376 oat_files_.push_back(std::move(oat_file));
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00001377 DCHECK_EQ(input_vdex_fd_, -1);
1378 if (!input_vdex_.empty()) {
1379 std::string error_msg;
Richard Uhlerb8ab63a2017-01-31 11:27:37 +00001380 input_vdex_file_ = VdexFile::Open(input_vdex_,
1381 /* writable */ false,
1382 /* low_4gb */ false,
Nicolas Geoffray1cfea7a2017-05-24 14:44:38 +01001383 DoEagerUnquickeningOfVdex(),
Richard Uhlerb8ab63a2017-01-31 11:27:37 +00001384 &error_msg);
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00001385 }
David Brazdil7b49e6c2016-09-01 11:06:18 +01001386
Nicolas Geoffraya6a448a2016-11-10 10:49:40 +00001387 DCHECK_EQ(output_vdex_fd_, -1);
Nicolas Geoffray4e868fa2017-04-21 17:16:44 +01001388 std::string vdex_filename = output_vdex_.empty()
1389 ? ReplaceFileExtension(oat_filename, "vdex")
1390 : output_vdex_;
1391 if (vdex_filename == input_vdex_ && output_vdex_.empty()) {
Nicolas Geoffray81f57d12016-12-20 13:17:09 +00001392 update_input_vdex_ = true;
1393 std::unique_ptr<File> vdex_file(OS::OpenFileReadWrite(vdex_filename.c_str()));
1394 vdex_files_.push_back(std::move(vdex_file));
1395 } else {
1396 std::unique_ptr<File> vdex_file(OS::CreateEmptyFile(vdex_filename.c_str()));
Calin Juravleb09be722017-09-25 16:42:48 -07001397 if (vdex_file == nullptr) {
Nicolas Geoffray81f57d12016-12-20 13:17:09 +00001398 PLOG(ERROR) << "Failed to open vdex file: " << vdex_filename;
1399 return false;
1400 }
1401 if (fchmod(vdex_file->Fd(), 0644) != 0) {
1402 PLOG(ERROR) << "Failed to make vdex file world readable: " << vdex_filename;
1403 vdex_file->Erase();
1404 return false;
1405 }
1406 vdex_files_.push_back(std::move(vdex_file));
David Brazdil7b49e6c2016-09-01 11:06:18 +01001407 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001408 }
1409 } else {
David Brazdil7b49e6c2016-09-01 11:06:18 +01001410 std::unique_ptr<File> oat_file(new File(oat_fd_, oat_location_, /* check_usage */ true));
Calin Juravleb09be722017-09-25 16:42:48 -07001411 if (oat_file == nullptr) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08001412 PLOG(ERROR) << "Failed to create oat file: " << oat_location_;
1413 return false;
1414 }
David Brazdil7b49e6c2016-09-01 11:06:18 +01001415 oat_file->DisableAutoClose();
1416 if (oat_file->SetLength(0) != 0) {
1417 PLOG(WARNING) << "Truncating oat file " << oat_location_ << " failed.";
Calin Juravleb09be722017-09-25 16:42:48 -07001418 oat_file->Erase();
1419 return false;
David Brazdil7b49e6c2016-09-01 11:06:18 +01001420 }
1421 oat_files_.push_back(std::move(oat_file));
1422
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00001423 if (input_vdex_fd_ != -1) {
1424 struct stat s;
1425 int rc = TEMP_FAILURE_RETRY(fstat(input_vdex_fd_, &s));
1426 if (rc == -1) {
1427 PLOG(WARNING) << "Failed getting length of vdex file";
1428 } else {
1429 std::string error_msg;
Richard Uhlerb8ab63a2017-01-31 11:27:37 +00001430 input_vdex_file_ = VdexFile::Open(input_vdex_fd_,
1431 s.st_size,
1432 "vdex",
1433 /* writable */ false,
1434 /* low_4gb */ false,
Nicolas Geoffray1cfea7a2017-05-24 14:44:38 +01001435 DoEagerUnquickeningOfVdex(),
Richard Uhlerb8ab63a2017-01-31 11:27:37 +00001436 &error_msg);
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00001437 // If there's any problem with the passed vdex, just warn and proceed
1438 // without it.
1439 if (input_vdex_file_ == nullptr) {
Richard Uhlerb8ab63a2017-01-31 11:27:37 +00001440 PLOG(WARNING) << "Failed opening vdex file: " << error_msg;
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00001441 }
1442 }
1443 }
1444
Nicolas Geoffraya6a448a2016-11-10 10:49:40 +00001445 DCHECK_NE(output_vdex_fd_, -1);
David Brazdil7b49e6c2016-09-01 11:06:18 +01001446 std::string vdex_location = ReplaceFileExtension(oat_location_, "vdex");
Nicolas Geoffraya6a448a2016-11-10 10:49:40 +00001447 std::unique_ptr<File> vdex_file(new File(output_vdex_fd_, vdex_location, /* check_usage */ true));
Calin Juravleb09be722017-09-25 16:42:48 -07001448 if (vdex_file == nullptr) {
David Brazdil7b49e6c2016-09-01 11:06:18 +01001449 PLOG(ERROR) << "Failed to create vdex file: " << vdex_location;
Jeff Haodcdc85b2015-12-04 14:06:18 -08001450 return false;
1451 }
David Brazdil7b49e6c2016-09-01 11:06:18 +01001452 vdex_file->DisableAutoClose();
Nicolas Geoffray81f57d12016-12-20 13:17:09 +00001453 if (input_vdex_file_ != nullptr && output_vdex_fd_ == input_vdex_fd_) {
1454 update_input_vdex_ = true;
1455 } else {
1456 if (vdex_file->SetLength(0) != 0) {
1457 PLOG(ERROR) << "Truncating vdex file " << vdex_location << " failed.";
Calin Juravleb09be722017-09-25 16:42:48 -07001458 vdex_file->Erase();
Nicolas Geoffray81f57d12016-12-20 13:17:09 +00001459 return false;
1460 }
David Brazdil7b49e6c2016-09-01 11:06:18 +01001461 }
1462 vdex_files_.push_back(std::move(vdex_file));
1463
Jeff Haodcdc85b2015-12-04 14:06:18 -08001464 oat_filenames_.push_back(oat_location_.c_str());
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001465 }
Andreas Gampee21dc3d2014-12-08 16:59:43 -08001466
Nicolas Geoffray36930ec2017-05-09 13:23:34 +01001467 // If we're updating in place a vdex file, be defensive and put an invalid vdex magic in case
1468 // dex2oat gets killed.
1469 // Note: we're only invalidating the magic data in the file, as dex2oat needs the rest of
1470 // the information to remain valid.
1471 if (update_input_vdex_) {
Vladimir Marko74527972016-11-29 15:57:32 +00001472 std::unique_ptr<linker::BufferedOutputStream> vdex_out =
1473 std::make_unique<linker::BufferedOutputStream>(
1474 std::make_unique<linker::FileOutputStream>(vdex_files_.back().get()));
Nicolas Geoffray36930ec2017-05-09 13:23:34 +01001475 if (!vdex_out->WriteFully(&VdexFile::Header::kVdexInvalidMagic,
1476 arraysize(VdexFile::Header::kVdexInvalidMagic))) {
1477 PLOG(ERROR) << "Failed to invalidate vdex header. File: " << vdex_out->GetLocation();
1478 return false;
1479 }
1480
1481 if (!vdex_out->Flush()) {
1482 PLOG(ERROR) << "Failed to flush stream after invalidating header of vdex file."
1483 << " File: " << vdex_out->GetLocation();
1484 return false;
1485 }
1486 }
1487
David Brazdil7b49e6c2016-09-01 11:06:18 +01001488 // Swap file handling
Andreas Gampee21dc3d2014-12-08 16:59:43 -08001489 //
1490 // If the swap fd is not -1, we assume this is the file descriptor of an open but unlinked file
1491 // that we can use for swap.
1492 //
1493 // If the swap fd is -1 and we have a swap-file string, open the given file as a swap file. We
1494 // will immediately unlink to satisfy the swap fd assumption.
1495 if (swap_fd_ == -1 && !swap_file_name_.empty()) {
1496 std::unique_ptr<File> swap_file(OS::CreateEmptyFile(swap_file_name_.c_str()));
1497 if (swap_file.get() == nullptr) {
1498 PLOG(ERROR) << "Failed to create swap file: " << swap_file_name_;
1499 return false;
1500 }
1501 swap_fd_ = swap_file->Fd();
1502 swap_file->MarkUnchecked(); // We don't we to track this, it will be unlinked immediately.
1503 swap_file->DisableAutoClose(); // We'll handle it ourselves, the File object will be
1504 // released immediately.
1505 unlink(swap_file_name_.c_str());
1506 }
Jeff Hao436183f2016-01-12 16:36:50 -08001507
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001508 return true;
1509 }
1510
David Brazdil7b49e6c2016-09-01 11:06:18 +01001511 void EraseOutputFiles() {
1512 for (auto& files : { &vdex_files_, &oat_files_ }) {
1513 for (size_t i = 0; i < files->size(); ++i) {
1514 if ((*files)[i].get() != nullptr) {
1515 (*files)[i]->Erase();
1516 (*files)[i].reset();
1517 }
1518 }
Jeff Haodcdc85b2015-12-04 14:06:18 -08001519 }
Andreas Gampea650e702014-12-03 14:28:02 -08001520 }
1521
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08001522 void LoadClassProfileDescriptors() {
Mathieu Chartierf70fe3d2017-06-21 15:24:02 -07001523 if (profile_compilation_info_ != nullptr && IsImage()) {
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08001524 Runtime* runtime = Runtime::Current();
1525 CHECK(runtime != nullptr);
Mathieu Chartier0b490842016-05-25 15:05:59 -07001526 // Filter out class path classes since we don't want to include these in the image.
Mathieu Chartier4f342b02017-07-21 17:12:39 -07001527 image_classes_.reset(
1528 new std::unordered_set<std::string>(
1529 profile_compilation_info_->GetClassDescriptors(dex_files_)));
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08001530 VLOG(compiler) << "Loaded " << image_classes_->size()
1531 << " image class descriptors from profile";
1532 if (VLOG_IS_ON(compiler)) {
1533 for (const std::string& s : *image_classes_) {
1534 LOG(INFO) << "Image class " << s;
1535 }
1536 }
1537 }
1538 }
1539
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001540 // Set up the environment for compilation. Includes starting the runtime and loading/opening the
1541 // boot class path.
Andreas Gampef7882972017-03-20 16:35:24 -07001542 dex2oat::ReturnCode Setup() {
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001543 TimingLogger::ScopedTiming t("dex2oat Setup", timings_);
Vladimir Marko49b0f452015-12-10 13:49:19 +00001544
Jeff Haoc23b0c02017-07-27 18:19:38 -07001545 if (!PrepareImageClasses() || !PrepareCompiledClasses() || !PrepareCompiledMethods() ||
1546 !PrepareDirtyObjects()) {
Andreas Gampef7882972017-03-20 16:35:24 -07001547 return dex2oat::ReturnCode::kOther;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001548 }
Brian Carlstromd76e0832013-08-29 15:17:42 -07001549
Mathieu Chartiere01b6f62017-07-19 16:55:04 -07001550 // Verification results are null since we don't know if we will need them yet as the compler
1551 // filter may change.
Andreas Gampe4585f872015-03-27 23:45:15 -07001552 callbacks_.reset(new QuickCompilerCallbacks(
Mathieu Chartiera90c7722015-10-29 15:41:36 -07001553 IsBootImage() ?
Andreas Gampe4585f872015-03-27 23:45:15 -07001554 CompilerCallbacks::CallbackMode::kCompileBootImage :
1555 CompilerCallbacks::CallbackMode::kCompileApp));
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001556
Vladimir Marko49b0f452015-12-10 13:49:19 +00001557 RuntimeArgumentMap runtime_options;
Mathieu Chartier46331a62017-07-21 09:49:10 -07001558 if (!PrepareRuntimeOptions(&runtime_options, callbacks_.get())) {
Andreas Gampef7882972017-03-20 16:35:24 -07001559 return dex2oat::ReturnCode::kOther;
Andreas Gampe1d00add2015-02-27 19:35:46 -08001560 }
1561
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001562 CreateOatWriters();
1563 if (!AddDexFileSources()) {
Andreas Gampef7882972017-03-20 16:35:24 -07001564 return dex2oat::ReturnCode::kOther;
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001565 }
1566
1567 if (IsBootImage() && image_filenames_.size() > 1) {
1568 // If we're compiling the boot image, store the boot classpath into the Key-Value store.
1569 // We need this for the multi-image case.
Mathieu Chartier866d8742016-09-21 15:24:18 -07001570 key_value_store_->Put(OatHeader::kBootClassPathKey,
1571 gc::space::ImageSpace::GetMultiImageBootClassPath(dex_locations_,
1572 oat_filenames_,
1573 image_filenames_));
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001574 }
1575
1576 if (!IsBootImage()) {
1577 // When compiling an app, create the runtime early to retrieve
1578 // the image location key needed for the oat header.
1579 if (!CreateRuntime(std::move(runtime_options))) {
Andreas Gampef7882972017-03-20 16:35:24 -07001580 return dex2oat::ReturnCode::kCreateRuntime;
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001581 }
1582
Andreas Gampe29d38e72016-03-23 15:31:51 +00001583 if (CompilerFilter::DependsOnImageChecksum(compiler_options_->GetCompilerFilter())) {
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001584 TimingLogger::ScopedTiming t3("Loading image checksum", timings_);
1585 std::vector<gc::space::ImageSpace*> image_spaces =
1586 Runtime::Current()->GetHeap()->GetBootImageSpaces();
Richard Uhlerbc26b722017-03-10 14:27:10 +00001587 image_file_location_oat_checksum_ = image_spaces[0]->GetImageHeader().GetOatChecksum();
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001588 image_file_location_oat_data_begin_ =
1589 reinterpret_cast<uintptr_t>(image_spaces[0]->GetImageHeader().GetOatDataBegin());
1590 image_patch_delta_ = image_spaces[0]->GetImageHeader().GetPatchDelta();
1591 // Store the boot image filename(s).
1592 std::vector<std::string> image_filenames;
1593 for (const gc::space::ImageSpace* image_space : image_spaces) {
1594 image_filenames.push_back(image_space->GetImageFilename());
1595 }
Andreas Gampe9186ced2016-12-12 14:28:21 -08001596 std::string image_file_location = android::base::Join(image_filenames, ':');
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001597 if (!image_file_location.empty()) {
1598 key_value_store_->Put(OatHeader::kImageLocationKey, image_file_location);
1599 }
Andreas Gampe29d38e72016-03-23 15:31:51 +00001600 } else {
1601 image_file_location_oat_checksum_ = 0u;
1602 image_file_location_oat_data_begin_ = 0u;
1603 image_patch_delta_ = 0;
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001604 }
1605
1606 // Open dex files for class path.
Calin Juravle19915892017-08-03 17:10:36 +00001607
Calin Juravle1ce70852017-06-28 10:59:03 -07001608 if (class_loader_context_ == nullptr) {
Calin Juravle19915892017-08-03 17:10:36 +00001609 // If no context was specified use the default one (which is an empty PathClassLoader).
1610 class_loader_context_ = std::unique_ptr<ClassLoaderContext>(ClassLoaderContext::Default());
Jeff Haof0192c82016-03-28 20:39:50 -07001611 }
Calin Juravle19915892017-08-03 17:10:36 +00001612
Calin Juravle1ce70852017-06-28 10:59:03 -07001613 DCHECK_EQ(oat_writers_.size(), 1u);
1614
1615 // Note: Ideally we would reject context where the source dex files are also
1616 // specified in the classpath (as it doesn't make sense). However this is currently
1617 // needed for non-prebuild tests and benchmarks which expects on the fly compilation.
1618 // Also, for secondary dex files we do not have control on the actual classpath.
1619 // Instead of aborting, remove all the source location from the context classpaths.
1620 if (class_loader_context_->RemoveLocationsFromClassPaths(
1621 oat_writers_[0]->GetSourceLocations())) {
1622 LOG(WARNING) << "The source files to be compiled are also in the classpath.";
1623 }
1624
1625 // We need to open the dex files before encoding the context in the oat file.
1626 // (because the encoding adds the dex checksum...)
1627 // TODO(calin): consider redesigning this so we don't have to open the dex files before
1628 // creating the actual class loader.
1629 if (!class_loader_context_->OpenDexFiles(runtime_->GetInstructionSet(), classpath_dir_)) {
1630 // Do not abort if we couldn't open files from the classpath. They might be
1631 // apks without dex files and right now are opening flow will fail them.
1632 LOG(WARNING) << "Failed to open classpath dex files";
1633 }
1634
1635 // Store the class loader context in the oat header.
1636 key_value_store_->Put(OatHeader::kClassPathKey,
1637 class_loader_context_->EncodeContextForOatFile(classpath_dir_));
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001638 }
1639
1640 // Now that we have finalized key_value_store_, start writing the oat file.
Andreas Gampec7ae55d2015-09-15 20:04:54 -07001641 {
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001642 TimingLogger::ScopedTiming t_dex("Writing and opening dex files", timings_);
1643 rodata_.reserve(oat_writers_.size());
1644 for (size_t i = 0, size = oat_writers_.size(); i != size; ++i) {
1645 rodata_.push_back(elf_writers_[i]->StartRoData());
1646 // Unzip or copy dex files straight to the oat file.
1647 std::unique_ptr<MemMap> opened_dex_files_map;
1648 std::vector<std::unique_ptr<const DexFile>> opened_dex_files;
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00001649 // No need to verify the dex file for:
Mathieu Chartier11b3df32017-02-21 13:41:54 -08001650 // 1) Dexlayout since it does the verification. It also may not pass the verification since
1651 // we don't update the dex checksum.
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00001652 // 2) when we have a vdex file, which means it was already verified.
Mathieu Chartier11b3df32017-02-21 13:41:54 -08001653 const bool verify = !DoDexLayoutOptimizations() && (input_vdex_file_ == nullptr);
David Brazdil7b49e6c2016-09-01 11:06:18 +01001654 if (!oat_writers_[i]->WriteAndOpenDexFiles(
1655 kIsVdexEnabled ? vdex_files_[i].get() : oat_files_[i].get(),
1656 rodata_.back(),
1657 instruction_set_,
1658 instruction_set_features_.get(),
1659 key_value_store_.get(),
Jeff Hao042e8982016-10-19 11:17:11 -07001660 verify,
Nicolas Geoffray81f57d12016-12-20 13:17:09 +00001661 update_input_vdex_,
David Brazdil7b49e6c2016-09-01 11:06:18 +01001662 &opened_dex_files_map,
1663 &opened_dex_files)) {
Andreas Gampef7882972017-03-20 16:35:24 -07001664 return dex2oat::ReturnCode::kOther;
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001665 }
1666 dex_files_per_oat_file_.push_back(MakeNonOwningPointerVector(opened_dex_files));
1667 if (opened_dex_files_map != nullptr) {
1668 opened_dex_files_maps_.push_back(std::move(opened_dex_files_map));
1669 for (std::unique_ptr<const DexFile>& dex_file : opened_dex_files) {
Vladimir Marko944da602016-02-19 12:27:55 +00001670 dex_file_oat_index_map_.emplace(dex_file.get(), i);
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001671 opened_dex_files_.push_back(std::move(dex_file));
1672 }
1673 } else {
1674 DCHECK(opened_dex_files.empty());
1675 }
1676 }
1677 }
1678
1679 dex_files_ = MakeNonOwningPointerVector(opened_dex_files_);
Andreas Gampe7386da42016-06-08 18:18:47 -07001680
Mathieu Chartiere01b6f62017-07-19 16:55:04 -07001681 // If we need to downgrade the compiler-filter for size reasons.
1682 if (!IsBootImage() && IsVeryLarge(dex_files_)) {
Mathieu Chartier8cce65a2017-08-17 00:06:39 -07001683 // Disable app image to make sure dex2oat unloading is enabled.
1684 compiler_options_->DisableAppImage();
1685
Mathieu Chartier72041a02017-07-14 18:23:25 -07001686 // If we need to downgrade the compiler-filter for size reasons, do that early before we read
1687 // it below for creating verification callbacks.
Mathieu Chartiere01b6f62017-07-19 16:55:04 -07001688 if (!CompilerFilter::IsAsGoodAs(kLargeAppFilter, compiler_options_->GetCompilerFilter())) {
1689 LOG(INFO) << "Very large app, downgrading to verify.";
1690 // Note: this change won't be reflected in the key-value store, as that had to be
1691 // finalized before loading the dex files. This setup is currently required
1692 // to get the size from the DexFile objects.
1693 // TODO: refactor. b/29790079
1694 compiler_options_->SetCompilerFilter(kLargeAppFilter);
1695 }
1696 }
1697
1698 if (CompilerFilter::IsAnyCompilationEnabled(compiler_options_->GetCompilerFilter())) {
1699 // Only modes with compilation require verification results, do this here instead of when we
1700 // create the compilation callbacks since the compilation mode may have been changed by the
1701 // very large app logic.
1702 // Avoiding setting the verification results saves RAM by not adding the dex files later in
1703 // the function.
1704 verification_results_.reset(new VerificationResults(compiler_options_.get()));
1705 callbacks_->SetVerificationResults(verification_results_.get());
1706 }
1707
Andreas Gampe7386da42016-06-08 18:18:47 -07001708 // We had to postpone the swap decision till now, as this is the point when we actually
1709 // know about the dex files we're going to use.
1710
1711 // Make sure that we didn't create the driver, yet.
1712 CHECK(driver_ == nullptr);
1713 // If we use a swap file, ensure we are above the threshold to make it necessary.
1714 if (swap_fd_ != -1) {
1715 if (!UseSwap(IsBootImage(), dex_files_)) {
1716 close(swap_fd_);
1717 swap_fd_ = -1;
1718 VLOG(compiler) << "Decided to run without swap.";
1719 } else {
1720 LOG(INFO) << "Large app, accepted running with swap.";
1721 }
1722 }
1723 // Note that dex2oat won't close the swap_fd_. The compiler driver's swap space will do that.
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001724 if (IsBootImage()) {
1725 // For boot image, pass opened dex files to the Runtime::Create().
1726 // Note: Runtime acquires ownership of these dex files.
1727 runtime_options.Set(RuntimeArgumentMap::BootClassPathDexList, &opened_dex_files_);
Vladimir Marko49b0f452015-12-10 13:49:19 +00001728 if (!CreateRuntime(std::move(runtime_options))) {
Andreas Gampef7882972017-03-20 16:35:24 -07001729 return dex2oat::ReturnCode::kOther;
Andreas Gampec7ae55d2015-09-15 20:04:54 -07001730 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001731 }
1732
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001733 // If we're doing the image, override the compiler filter to force full compilation. Must be
1734 // done ahead of WellKnownClasses::Init that causes verification. Note: doesn't force
1735 // compilation of class initializers.
1736 // Whilst we're in native take the opportunity to initialize well known classes.
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001737 Thread* self = Thread::Current();
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001738 WellKnownClasses::Init(self->GetJniEnv());
1739
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001740 if (!IsBootImage()) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001741 constexpr bool kSaveDexInput = false;
1742 if (kSaveDexInput) {
Vladimir Marko49b0f452015-12-10 13:49:19 +00001743 SaveDexInput();
Brian Carlstromf79fccb2014-02-20 08:55:10 -08001744 }
1745 }
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001746
1747 // Ensure opened dex files are writable for dex-to-dex transformations.
1748 for (const std::unique_ptr<MemMap>& map : opened_dex_files_maps_) {
1749 if (!map->Protect(PROT_READ | PROT_WRITE)) {
1750 PLOG(ERROR) << "Failed to make .dex files writeable.";
Andreas Gampef7882972017-03-20 16:35:24 -07001751 return dex2oat::ReturnCode::kOther;
Vladimir Marko919f5532016-01-20 19:13:01 +00001752 }
Vladimir Marko9bdf1082016-01-21 12:15:52 +00001753 }
1754
Mathieu Chartier72041a02017-07-14 18:23:25 -07001755 // Verification results are only required for modes that have any compilation. Avoid
1756 // adding the dex files if possible to prevent allocating large arrays.
1757 if (verification_results_ != nullptr) {
1758 for (const auto& dex_file : dex_files_) {
1759 // Pre-register dex files so that we can access verification results without locks during
1760 // compilation and verification.
Mathieu Chartier0733dc82017-07-17 14:05:28 -07001761 verification_results_->AddDexFile(dex_file);
1762 }
Andreas Gampe22f8e5c2014-07-09 11:38:21 -07001763 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001764
Andreas Gampef7882972017-03-20 16:35:24 -07001765 return dex2oat::ReturnCode::kNoFailure;
Andreas Gampe22f8e5c2014-07-09 11:38:21 -07001766 }
Andreas Gampe22f8e5c2014-07-09 11:38:21 -07001767
Mathieu Chartierfbc31082016-01-24 11:59:56 -08001768 // If we need to keep the oat file open for the image writer.
1769 bool ShouldKeepOatFileOpen() const {
1770 return IsImage() && oat_fd_ != kInvalidFd;
1771 }
1772
Mathieu Chartier72041a02017-07-14 18:23:25 -07001773 // Doesn't return the class loader since it's not meant to be used for image compilation.
1774 void CompileDexFilesIndividually() {
1775 CHECK(!IsImage()) << "Not supported with image";
1776 for (const DexFile* dex_file : dex_files_) {
1777 std::vector<const DexFile*> dex_files(1u, dex_file);
1778 VLOG(compiler) << "Compiling " << dex_file->GetLocation();
1779 jobject class_loader = CompileDexFiles(dex_files);
1780 CHECK(class_loader != nullptr);
1781 ScopedObjectAccess soa(Thread::Current());
1782 // Unload class loader to free RAM.
1783 jweak weak_class_loader = soa.Env()->vm->AddWeakGlobalRef(
1784 soa.Self(),
1785 soa.Decode<mirror::ClassLoader>(class_loader));
1786 soa.Env()->vm->DeleteGlobalRef(soa.Self(), class_loader);
1787 runtime_->GetHeap()->CollectGarbage(/*clear_soft_references*/ true);
1788 ObjPtr<mirror::ClassLoader> decoded_weak = soa.Decode<mirror::ClassLoader>(weak_class_loader);
1789 if (decoded_weak != nullptr) {
1790 LOG(FATAL) << "Failed to unload class loader, path from root set: "
1791 << runtime_->GetHeap()->GetVerification()->FirstPathFromRootSet(decoded_weak);
1792 }
1793 VLOG(compiler) << "Unloaded classloader";
1794 }
1795 }
1796
1797 bool ShouldCompileDexFilesIndividually() const {
Nicolas Geoffraya6fc7872017-08-14 11:29:22 +01001798 // Compile individually if we are:
1799 // 1. not building an image,
1800 // 2. not verifying a vdex file,
1801 // 3. using multidex,
1802 // 4. not doing any AOT compilation.
1803 // This means extract, no-vdex verify, and quicken, will use the individual compilation
1804 // mode (to reduce RAM used by the compiler).
Mathieu Chartier72041a02017-07-14 18:23:25 -07001805 return !IsImage() &&
Nicolas Geoffraya6fc7872017-08-14 11:29:22 +01001806 !update_input_vdex_ &&
Mathieu Chartier72041a02017-07-14 18:23:25 -07001807 dex_files_.size() > 1 &&
Mathieu Chartier6a2b67b2017-08-08 15:09:29 -07001808 !CompilerFilter::IsAotCompilationEnabled(compiler_options_->GetCompilerFilter());
Mathieu Chartier72041a02017-07-14 18:23:25 -07001809 }
1810
1811 // Set up and create the compiler driver and then invoke it to compile all the dex files.
1812 jobject Compile() {
1813 ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
1814
Andreas Gampe88ec7f42014-11-05 10:18:32 -08001815 TimingLogger::ScopedTiming t("dex2oat Compile", timings_);
1816 compiler_phases_timings_.reset(new CumulativeLogger("compilation times"));
Vladimir Markof4da6752014-08-01 19:04:18 +01001817
Vladimir Marko47496c22016-01-27 16:15:08 +00001818 // Find the dex files we should not inline from.
Vladimir Marko47496c22016-01-27 16:15:08 +00001819 std::vector<std::string> no_inline_filters;
1820 Split(no_inline_from_string_, ',', &no_inline_filters);
Jeff Haodcdc85b2015-12-04 14:06:18 -08001821
1822 // For now, on the host always have core-oj removed.
Vladimir Marko47496c22016-01-27 16:15:08 +00001823 const std::string core_oj = "core-oj";
1824 if (!kIsTargetBuild && !ContainsElement(no_inline_filters, core_oj)) {
1825 no_inline_filters.push_back(core_oj);
Jeff Haodcdc85b2015-12-04 14:06:18 -08001826 }
1827
Vladimir Marko47496c22016-01-27 16:15:08 +00001828 if (!no_inline_filters.empty()) {
Calin Juravle1ce70852017-06-28 10:59:03 -07001829 std::vector<const DexFile*> class_path_files;
1830 if (!IsBootImage()) {
1831 // The class loader context is used only for apps.
1832 class_path_files = class_loader_context_->FlattenOpenedDexFiles();
1833 }
1834
Jeff Haodcdc85b2015-12-04 14:06:18 -08001835 std::vector<const std::vector<const DexFile*>*> dex_file_vectors = {
1836 &class_linker->GetBootClassPath(),
1837 &class_path_files,
1838 &dex_files_
1839 };
1840 for (const std::vector<const DexFile*>* dex_file_vector : dex_file_vectors) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08001841 for (const DexFile* dex_file : *dex_file_vector) {
Vladimir Marko47496c22016-01-27 16:15:08 +00001842 for (const std::string& filter : no_inline_filters) {
1843 // Use dex_file->GetLocation() rather than dex_file->GetBaseLocation(). This
Calin Juravlea308a322017-07-18 16:51:51 -07001844 // allows tests to specify <test-dexfile>!classes2.dex if needed but if the
Vladimir Marko47496c22016-01-27 16:15:08 +00001845 // base location passes the StartsWith() test, so do all extra locations.
1846 std::string dex_location = dex_file->GetLocation();
1847 if (filter.find('/') == std::string::npos) {
1848 // The filter does not contain the path. Remove the path from dex_location as well.
1849 size_t last_slash = dex_file->GetLocation().rfind('/');
1850 if (last_slash != std::string::npos) {
1851 dex_location = dex_location.substr(last_slash + 1);
1852 }
1853 }
1854
Andreas Gampe9186ced2016-12-12 14:28:21 -08001855 if (android::base::StartsWith(dex_location, filter.c_str())) {
Vladimir Marko47496c22016-01-27 16:15:08 +00001856 VLOG(compiler) << "Disabling inlining from " << dex_file->GetLocation();
1857 no_inline_from_dex_files_.push_back(dex_file);
1858 break;
Jeff Haodcdc85b2015-12-04 14:06:18 -08001859 }
1860 }
Jeff Haodcdc85b2015-12-04 14:06:18 -08001861 }
Vladimir Marko47496c22016-01-27 16:15:08 +00001862 }
1863 if (!no_inline_from_dex_files_.empty()) {
1864 compiler_options_->no_inline_from_ = &no_inline_from_dex_files_;
Jeff Haodcdc85b2015-12-04 14:06:18 -08001865 }
1866 }
1867
Vladimir Marko307dac92015-10-20 11:20:09 +01001868 driver_.reset(new CompilerDriver(compiler_options_.get(),
1869 verification_results_.get(),
Vladimir Marko307dac92015-10-20 11:20:09 +01001870 compiler_kind_,
1871 instruction_set_,
1872 instruction_set_features_.get(),
Vladimir Marko307dac92015-10-20 11:20:09 +01001873 image_classes_.release(),
1874 compiled_classes_.release(),
Wojciech Staszkiewicz62534792016-08-09 14:30:55 -07001875 compiled_methods_.release(),
Vladimir Marko307dac92015-10-20 11:20:09 +01001876 thread_count_,
1877 dump_stats_,
1878 dump_passes_,
Vladimir Marko307dac92015-10-20 11:20:09 +01001879 compiler_phases_timings_.get(),
1880 swap_fd_,
Calin Juravle998c2162015-12-21 15:39:33 +02001881 profile_compilation_info_.get()));
Vladimir Markod1eaf0d2015-10-29 12:18:29 +00001882 driver_->SetDexFilesForOatFile(dex_files_);
Nicolas Geoffray486dda02017-09-11 14:15:52 +01001883 if (!IsBootImage()) {
1884 driver_->SetClasspathDexFiles(class_loader_context_->FlattenOpenedDexFiles());
1885 }
Nicolas Geoffray1cfea7a2017-05-24 14:44:38 +01001886
Mathieu Chartier9e050df2017-08-09 10:05:47 -07001887 const bool compile_individually = ShouldCompileDexFilesIndividually();
1888 if (compile_individually) {
1889 // Set the compiler driver in the callbacks so that we can avoid re-verification. This not
1890 // only helps performance but also prevents reverifying quickened bytecodes. Attempting
1891 // verify quickened bytecode causes verification failures.
1892 // Only set the compiler filter if we are doing separate compilation since there is a bit
1893 // of overhead when checking if a class was previously verified.
1894 callbacks_->SetDoesClassUnloading(true, driver_.get());
1895 }
1896
Nicolas Geoffray1cfea7a2017-05-24 14:44:38 +01001897 // Setup vdex for compilation.
1898 if (!DoEagerUnquickeningOfVdex() && input_vdex_file_ != nullptr) {
1899 callbacks_->SetVerifierDeps(
1900 new verifier::VerifierDeps(dex_files_, input_vdex_file_->GetVerifierDepsData()));
1901
1902 // TODO: we unquicken unconditionally, as we don't know
1903 // if the boot image has changed. How exactly we'll know is under
1904 // experimentation.
1905 TimingLogger::ScopedTiming time_unquicken("Unquicken", timings_);
1906 VdexFile::Unquicken(dex_files_, input_vdex_file_->GetQuickeningInfo());
Mathieu Chartier72041a02017-07-14 18:23:25 -07001907 } else {
1908 // Create the main VerifierDeps, here instead of in the compiler since we want to aggregate
1909 // the results for all the dex files, not just the results for the current dex file.
1910 callbacks_->SetVerifierDeps(new verifier::VerifierDeps(dex_files_));
Nicolas Geoffray1cfea7a2017-05-24 14:44:38 +01001911 }
Mathieu Chartier72041a02017-07-14 18:23:25 -07001912 // Invoke the compilation.
Mathieu Chartier9e050df2017-08-09 10:05:47 -07001913 if (compile_individually) {
Mathieu Chartier72041a02017-07-14 18:23:25 -07001914 CompileDexFilesIndividually();
1915 // Return a null classloader since we already freed released it.
1916 return nullptr;
1917 }
1918 return CompileDexFiles(dex_files_);
1919 }
1920
1921 // Create the class loader, use it to compile, and return.
1922 jobject CompileDexFiles(const std::vector<const DexFile*>& dex_files) {
1923 ClassLinker* const class_linker = Runtime::Current()->GetClassLinker();
1924
1925 jobject class_loader = nullptr;
1926 if (!IsBootImage()) {
1927 class_loader = class_loader_context_->CreateClassLoader(dex_files_);
1928 }
1929
1930 // Register dex caches and key them to the class loader so that they only unload when the
1931 // class loader unloads.
1932 for (const auto& dex_file : dex_files) {
1933 ScopedObjectAccess soa(Thread::Current());
1934 // Registering the dex cache adds a strong root in the class loader that prevents the dex
1935 // cache from being unloaded early.
1936 ObjPtr<mirror::DexCache> dex_cache = class_linker->RegisterDexFile(
1937 *dex_file,
1938 soa.Decode<mirror::ClassLoader>(class_loader));
1939 if (dex_cache == nullptr) {
1940 soa.Self()->AssertPendingException();
1941 LOG(FATAL) << "Failed to register dex file " << dex_file->GetLocation() << " "
1942 << soa.Self()->GetException()->Dump();
1943 }
1944 }
1945 driver_->CompileAll(class_loader, dex_files, timings_);
1946 return class_loader;
Vladimir Markof4da6752014-08-01 19:04:18 +01001947 }
1948
Jeff Hao436183f2016-01-12 16:36:50 -08001949 // Notes on the interleaving of creating the images and oat files to
Brian Carlstrom7940e442013-07-12 13:46:57 -07001950 // ensure the references between the two are correct.
1951 //
1952 // Currently we have a memory layout that looks something like this:
1953 //
1954 // +--------------+
Jeff Hao436183f2016-01-12 16:36:50 -08001955 // | images |
Brian Carlstrom7940e442013-07-12 13:46:57 -07001956 // +--------------+
Jeff Hao436183f2016-01-12 16:36:50 -08001957 // | oat files |
Brian Carlstrom7940e442013-07-12 13:46:57 -07001958 // +--------------+
1959 // | alloc spaces |
1960 // +--------------+
1961 //
Jeff Hao436183f2016-01-12 16:36:50 -08001962 // There are several constraints on the loading of the images and oat files.
Brian Carlstrom7940e442013-07-12 13:46:57 -07001963 //
Jeff Hao436183f2016-01-12 16:36:50 -08001964 // 1. The images are expected to be loaded at an absolute address and
1965 // contain Objects with absolute pointers within the images.
Brian Carlstrom7940e442013-07-12 13:46:57 -07001966 //
Jeff Hao436183f2016-01-12 16:36:50 -08001967 // 2. There are absolute pointers from Methods in the images to their
1968 // code in the oat files.
Brian Carlstrom7940e442013-07-12 13:46:57 -07001969 //
Jeff Hao436183f2016-01-12 16:36:50 -08001970 // 3. There are absolute pointers from the code in the oat files to Methods
1971 // in the images.
Brian Carlstrom7940e442013-07-12 13:46:57 -07001972 //
Jeff Hao436183f2016-01-12 16:36:50 -08001973 // 4. There are absolute pointers from code in the oat files to other code
1974 // in the oat files.
Brian Carlstrom7940e442013-07-12 13:46:57 -07001975 //
1976 // To get this all correct, we go through several steps.
1977 //
Jeff Hao436183f2016-01-12 16:36:50 -08001978 // 1. We prepare offsets for all data in the oat files and calculate
Vladimir Markof4da6752014-08-01 19:04:18 +01001979 // the oat data size and code size. During this stage, we also set
1980 // oat code offsets in methods for use by the image writer.
Brian Carlstrom7940e442013-07-12 13:46:57 -07001981 //
Jeff Hao436183f2016-01-12 16:36:50 -08001982 // 2. We prepare offsets for the objects in the images and calculate
1983 // the image sizes.
Vladimir Markof4da6752014-08-01 19:04:18 +01001984 //
Jeff Hao436183f2016-01-12 16:36:50 -08001985 // 3. We create the oat files. Originally this was just our own proprietary
Vladimir Markof4da6752014-08-01 19:04:18 +01001986 // file but now it is contained within an ELF dynamic object (aka an .so
Jeff Hao436183f2016-01-12 16:36:50 -08001987 // file). Since we know the image sizes and oat data sizes and code sizes we
Vladimir Markof4da6752014-08-01 19:04:18 +01001988 // can prepare the ELF headers and we then know the ELF memory segment
1989 // layout and we can now resolve all references. The compiler provides
1990 // LinkerPatch information in each CompiledMethod and we resolve these,
1991 // using the layout information and image object locations provided by
1992 // image writer, as we're writing the method code.
1993 //
Jeff Hao436183f2016-01-12 16:36:50 -08001994 // 4. We create the image files. They need to know where the oat files
1995 // will be loaded after itself. Originally oat files were simply
1996 // memory mapped so we could predict where their contents were based
1997 // on the file size. Now that they are ELF files, we need to inspect
1998 // the ELF files to understand the in memory segment layout including
Vladimir Markof4da6752014-08-01 19:04:18 +01001999 // where the oat header is located within.
2000 // TODO: We could just remember this information from step 3.
Brian Carlstrom7940e442013-07-12 13:46:57 -07002001 //
Vladimir Markof4da6752014-08-01 19:04:18 +01002002 // 5. We fixup the ELF program headers so that dlopen will try to
Brian Carlstrom7940e442013-07-12 13:46:57 -07002003 // load the .so at the desired location at runtime by offsetting the
2004 // Elf32_Phdr.p_vaddr values by the desired base address.
Vladimir Markof4da6752014-08-01 19:04:18 +01002005 // TODO: Do this in step 3. We already know the layout there.
2006 //
2007 // Steps 1.-3. are done by the CreateOatFile() above, steps 4.-5.
2008 // are done by the CreateImageFile() below.
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002009
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002010 // Write out the generated code part. Calls the OatWriter and ElfBuilder. Also prepares the
2011 // ImageWriter, if necessary.
Andreas Gampe10e477d2014-11-19 12:57:42 -08002012 // Note: Flushing (and closing) the file is the caller's responsibility, except for the failure
2013 // case (when the file will be explicitly erased).
David Brazdil7b49e6c2016-09-01 11:06:18 +01002014 bool WriteOutputFiles() {
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002015 TimingLogger::ScopedTiming t("dex2oat Oat", timings_);
2016
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002017 // Sync the data to the file, in case we did dex2dex transformations.
2018 for (const std::unique_ptr<MemMap>& map : opened_dex_files_maps_) {
2019 if (!map->Sync()) {
2020 PLOG(ERROR) << "Failed to Sync() dex2dex output. Map: " << map->GetName();
2021 return false;
2022 }
2023 }
Mathieu Chartierda5b28a2015-11-05 08:03:47 -08002024
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002025 if (IsImage()) {
Vladimir Markoaad75c62016-10-03 08:46:48 +00002026 if (IsAppImage() && image_base_ == 0) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08002027 gc::Heap* const heap = Runtime::Current()->GetHeap();
2028 for (gc::space::ImageSpace* image_space : heap->GetBootImageSpaces()) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08002029 image_base_ = std::max(image_base_, RoundUp(
2030 reinterpret_cast<uintptr_t>(image_space->GetImageHeader().GetOatFileEnd()),
2031 kPageSize));
2032 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08002033 // The non moving space is right after the oat file. Put the preferred app image location
2034 // right after the non moving space so that we ideally get a continuous immune region for
2035 // the GC.
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08002036 // Use the default non moving space capacity since dex2oat does not have a separate non-
2037 // moving space. This means the runtime's non moving space space size will be as large
2038 // as the growth limit for dex2oat, but smaller in the zygote.
2039 const size_t non_moving_space_capacity = gc::Heap::kDefaultNonMovingSpaceCapacity;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08002040 image_base_ += non_moving_space_capacity;
Mathieu Chartierda5b28a2015-11-05 08:03:47 -08002041 VLOG(compiler) << "App image base=" << reinterpret_cast<void*>(image_base_);
2042 }
2043
Vladimir Marko74527972016-11-29 15:57:32 +00002044 image_writer_.reset(new linker::ImageWriter(*driver_,
2045 image_base_,
2046 compiler_options_->GetCompilePic(),
2047 IsAppImage(),
2048 image_storage_mode_,
2049 oat_filenames_,
2050 dex_file_oat_index_map_,
2051 dirty_image_objects_.get()));
Mathieu Chartierda5b28a2015-11-05 08:03:47 -08002052
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002053 // We need to prepare method offsets in the image address space for direct method patching.
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002054 TimingLogger::ScopedTiming t2("dex2oat Prepare image address space", timings_);
2055 if (!image_writer_->PrepareImageAddressSpace()) {
2056 LOG(ERROR) << "Failed to prepare image address space.";
2057 return false;
2058 }
2059 }
2060
Nicolas Geoffray4acefd32016-10-24 13:14:58 +01002061 // Initialize the writers with the compiler driver, image writer, and their
2062 // dex files. The writers were created without those being there yet.
2063 for (size_t i = 0, size = oat_files_.size(); i != size; ++i) {
Vladimir Marko74527972016-11-29 15:57:32 +00002064 std::unique_ptr<linker::OatWriter>& oat_writer = oat_writers_[i];
Nicolas Geoffray4acefd32016-10-24 13:14:58 +01002065 std::vector<const DexFile*>& dex_files = dex_files_per_oat_file_[i];
2066 oat_writer->Initialize(driver_.get(), image_writer_.get(), dex_files);
2067 }
2068
David Brazdil5d5a36b2016-09-14 15:34:10 +01002069 {
2070 TimingLogger::ScopedTiming t2("dex2oat Write VDEX", timings_);
2071 DCHECK(IsBootImage() || oat_files_.size() == 1u);
Nicolas Geoffray6bb7f1b2016-11-03 10:52:49 +00002072 verifier::VerifierDeps* verifier_deps = callbacks_->GetVerifierDeps();
David Brazdil5d5a36b2016-09-14 15:34:10 +01002073 for (size_t i = 0, size = oat_files_.size(); i != size; ++i) {
2074 File* vdex_file = vdex_files_[i].get();
Vladimir Marko74527972016-11-29 15:57:32 +00002075 std::unique_ptr<linker::BufferedOutputStream> vdex_out =
2076 std::make_unique<linker::BufferedOutputStream>(
2077 std::make_unique<linker::FileOutputStream>(vdex_file));
David Brazdil5d5a36b2016-09-14 15:34:10 +01002078
Nicolas Geoffray6bb7f1b2016-11-03 10:52:49 +00002079 if (!oat_writers_[i]->WriteVerifierDeps(vdex_out.get(), verifier_deps)) {
David Brazdil5d5a36b2016-09-14 15:34:10 +01002080 LOG(ERROR) << "Failed to write verifier dependencies into VDEX " << vdex_file->GetPath();
2081 return false;
2082 }
2083
Nicolas Geoffray4acefd32016-10-24 13:14:58 +01002084 if (!oat_writers_[i]->WriteQuickeningInfo(vdex_out.get())) {
2085 LOG(ERROR) << "Failed to write quickening info into VDEX " << vdex_file->GetPath();
2086 return false;
2087 }
2088
Nicolas Geoffrayf54e5df2016-12-01 10:45:08 +00002089 // VDEX finalized, seek back to the beginning and write checksums and the header.
2090 if (!oat_writers_[i]->WriteChecksumsAndVdexHeader(vdex_out.get())) {
David Brazdil5d5a36b2016-09-14 15:34:10 +01002091 LOG(ERROR) << "Failed to write vdex header into VDEX " << vdex_file->GetPath();
2092 return false;
2093 }
2094 }
2095 }
2096
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002097 {
2098 TimingLogger::ScopedTiming t2("dex2oat Write ELF", timings_);
Nicolas Geoffray4acefd32016-10-24 13:14:58 +01002099 linker::MultiOatRelativePatcher patcher(instruction_set_, instruction_set_features_.get());
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002100 for (size_t i = 0, size = oat_files_.size(); i != size; ++i) {
Vladimir Marko74527972016-11-29 15:57:32 +00002101 std::unique_ptr<linker::ElfWriter>& elf_writer = elf_writers_[i];
2102 std::unique_ptr<linker::OatWriter>& oat_writer = oat_writers_[i];
Vladimir Marko944da602016-02-19 12:27:55 +00002103
Nicolas Geoffray4acefd32016-10-24 13:14:58 +01002104 oat_writer->PrepareLayout(&patcher);
Vladimir Marko944da602016-02-19 12:27:55 +00002105
2106 size_t rodata_size = oat_writer->GetOatHeader().GetExecutableOffset();
David Brazdil7b49e6c2016-09-01 11:06:18 +01002107 size_t text_size = oat_writer->GetOatSize() - rodata_size;
Vladimir Markoaad75c62016-10-03 08:46:48 +00002108 elf_writer->PrepareDynamicSection(rodata_size,
2109 text_size,
2110 oat_writer->GetBssSize(),
Vladimir Marko0eb882b2017-05-15 13:39:18 +01002111 oat_writer->GetBssMethodsOffset(),
Vladimir Markoaad75c62016-10-03 08:46:48 +00002112 oat_writer->GetBssRootsOffset());
Vladimir Marko944da602016-02-19 12:27:55 +00002113
2114 if (IsImage()) {
2115 // Update oat layout.
2116 DCHECK(image_writer_ != nullptr);
2117 DCHECK_LT(i, oat_filenames_.size());
2118 image_writer_->UpdateOatFileLayout(i,
2119 elf_writer->GetLoadedSize(),
2120 oat_writer->GetOatDataOffset(),
David Brazdil7b49e6c2016-09-01 11:06:18 +01002121 oat_writer->GetOatSize());
Vladimir Marko944da602016-02-19 12:27:55 +00002122 }
Richard Uhlerbc26b722017-03-10 14:27:10 +00002123
2124 if (IsBootImage()) {
2125 // Have the image_file_location_oat_checksum_ for boot oat files
2126 // depend on the contents of all the boot oat files. This way only
2127 // the primary image checksum needs to be checked to determine
2128 // whether any of the images are out of date.
2129 image_file_location_oat_checksum_ ^= oat_writer->GetOatHeader().GetChecksum();
2130 }
Vladimir Marko944da602016-02-19 12:27:55 +00002131 }
2132
2133 for (size_t i = 0, size = oat_files_.size(); i != size; ++i) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08002134 std::unique_ptr<File>& oat_file = oat_files_[i];
Vladimir Marko74527972016-11-29 15:57:32 +00002135 std::unique_ptr<linker::ElfWriter>& elf_writer = elf_writers_[i];
2136 std::unique_ptr<linker::OatWriter>& oat_writer = oat_writers_[i];
Vladimir Marko10c13562015-11-25 14:33:36 +00002137
David Srbecky0c4572e2016-01-22 19:19:25 +00002138 // We need to mirror the layout of the ELF file in the compressed debug-info.
Vladimir Marko944da602016-02-19 12:27:55 +00002139 // Therefore PrepareDebugInfo() relies on the SetLoadedSectionSizes() call further above.
2140 elf_writer->PrepareDebugInfo(oat_writer->GetMethodDebugInfo());
David Srbecky0c4572e2016-01-22 19:19:25 +00002141
Vladimir Marko74527972016-11-29 15:57:32 +00002142 linker::OutputStream*& rodata = rodata_[i];
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002143 DCHECK(rodata != nullptr);
Jeff Haodcdc85b2015-12-04 14:06:18 -08002144 if (!oat_writer->WriteRodata(rodata)) {
2145 LOG(ERROR) << "Failed to write .rodata section to the ELF file " << oat_file->GetPath();
2146 return false;
2147 }
2148 elf_writer->EndRoData(rodata);
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002149 rodata = nullptr;
Vladimir Marko10c13562015-11-25 14:33:36 +00002150
Vladimir Marko74527972016-11-29 15:57:32 +00002151 linker::OutputStream* text = elf_writer->StartText();
Jeff Haodcdc85b2015-12-04 14:06:18 -08002152 if (!oat_writer->WriteCode(text)) {
2153 LOG(ERROR) << "Failed to write .text section to the ELF file " << oat_file->GetPath();
2154 return false;
2155 }
2156 elf_writer->EndText(text);
Vladimir Marko10c13562015-11-25 14:33:36 +00002157
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002158 if (!oat_writer->WriteHeader(elf_writer->GetStream(),
2159 image_file_location_oat_checksum_,
2160 image_file_location_oat_data_begin_,
2161 image_patch_delta_)) {
2162 LOG(ERROR) << "Failed to write oat header to the ELF file " << oat_file->GetPath();
2163 return false;
2164 }
2165
Vladimir Marko944da602016-02-19 12:27:55 +00002166 if (IsImage()) {
2167 // Update oat header information.
2168 DCHECK(image_writer_ != nullptr);
2169 DCHECK_LT(i, oat_filenames_.size());
2170 image_writer_->UpdateOatFileHeader(i, oat_writer->GetOatHeader());
2171 }
2172
Jeff Haodcdc85b2015-12-04 14:06:18 -08002173 elf_writer->WriteDynamicSection();
2174 elf_writer->WriteDebugInfo(oat_writer->GetMethodDebugInfo());
Vladimir Marko10c13562015-11-25 14:33:36 +00002175
Jeff Haodcdc85b2015-12-04 14:06:18 -08002176 if (!elf_writer->End()) {
2177 LOG(ERROR) << "Failed to write ELF file " << oat_file->GetPath();
2178 return false;
2179 }
2180
David Brazdil7b49e6c2016-09-01 11:06:18 +01002181 if (!FlushOutputFile(&vdex_files_[i]) || !FlushOutputFile(&oat_files_[i])) {
2182 return false;
Jeff Haodcdc85b2015-12-04 14:06:18 -08002183 }
2184
Jeff Haodcdc85b2015-12-04 14:06:18 -08002185 VLOG(compiler) << "Oat file written successfully: " << oat_filenames_[i];
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002186
2187 oat_writer.reset();
2188 elf_writer.reset();
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002189 }
2190 }
2191
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002192 return true;
Brian Carlstrom7940e442013-07-12 13:46:57 -07002193 }
2194
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002195 // If we are compiling an image, invoke the image creation routine. Else just skip.
2196 bool HandleImage() {
Mathieu Chartiera90c7722015-10-29 15:41:36 -07002197 if (IsImage()) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002198 TimingLogger::ScopedTiming t("dex2oat ImageWriter", timings_);
2199 if (!CreateImageFile()) {
2200 return false;
2201 }
Jeff Haodcdc85b2015-12-04 14:06:18 -08002202 VLOG(compiler) << "Images written successfully";
Brian Carlstrom45602482013-07-21 22:07:55 -07002203 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002204 return true;
2205 }
2206
Jeff Haodcdc85b2015-12-04 14:06:18 -08002207 // Create a copy from stripped to unstripped.
2208 bool CopyStrippedToUnstripped() {
2209 for (size_t i = 0; i < oat_unstripped_.size(); ++i) {
2210 // If we don't want to strip in place, copy from stripped location to unstripped location.
2211 // We need to strip after image creation because FixupElf needs to use .strtab.
2212 if (strcmp(oat_unstripped_[i], oat_filenames_[i]) != 0) {
2213 // If the oat file is still open, flush it.
2214 if (oat_files_[i].get() != nullptr && oat_files_[i]->IsOpened()) {
David Brazdil7b49e6c2016-09-01 11:06:18 +01002215 if (!FlushCloseOutputFile(&oat_files_[i])) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08002216 return false;
2217 }
2218 }
2219
2220 TimingLogger::ScopedTiming t("dex2oat OatFile copy", timings_);
2221 std::unique_ptr<File> in(OS::OpenFileForReading(oat_filenames_[i]));
2222 std::unique_ptr<File> out(OS::CreateEmptyFile(oat_unstripped_[i]));
Vladimir Markob55cc6d2016-10-17 15:25:10 +01002223 int64_t in_length = in->GetLength();
2224 if (in_length < 0) {
2225 PLOG(ERROR) << "Failed to get the length of oat file: " << in->GetPath();
2226 return false;
2227 }
2228 if (!out->Copy(in.get(), 0, in_length)) {
2229 PLOG(ERROR) << "Failed to copy oat file to file: " << out->GetPath();
2230 return false;
Jeff Haodcdc85b2015-12-04 14:06:18 -08002231 }
2232 if (out->FlushCloseOrErase() != 0) {
2233 PLOG(ERROR) << "Failed to flush and close copied oat file: " << oat_unstripped_[i];
2234 return false;
2235 }
2236 VLOG(compiler) << "Oat file copied successfully (unstripped): " << oat_unstripped_[i];
2237 }
2238 }
2239 return true;
2240 }
2241
David Brazdil7b49e6c2016-09-01 11:06:18 +01002242 bool FlushOutputFile(std::unique_ptr<File>* file) {
2243 if (file->get() != nullptr) {
2244 if (file->get()->Flush() != 0) {
2245 PLOG(ERROR) << "Failed to flush output file: " << file->get()->GetPath();
2246 return false;
2247 }
2248 }
2249 return true;
2250 }
2251
2252 bool FlushCloseOutputFile(std::unique_ptr<File>* file) {
2253 if (file->get() != nullptr) {
2254 std::unique_ptr<File> tmp(file->release());
2255 if (tmp->FlushCloseOrErase() != 0) {
2256 PLOG(ERROR) << "Failed to flush and close output file: " << tmp->GetPath();
2257 return false;
2258 }
2259 }
2260 return true;
2261 }
2262
2263 bool FlushOutputFiles() {
2264 TimingLogger::ScopedTiming t2("dex2oat Flush Output Files", timings_);
2265 for (auto& files : { &vdex_files_, &oat_files_ }) {
2266 for (size_t i = 0; i < files->size(); ++i) {
2267 if (!FlushOutputFile(&(*files)[i])) {
Andreas Gampe10e477d2014-11-19 12:57:42 -08002268 return false;
Andreas Gampe4303ba92014-11-06 01:00:46 -08002269 }
Andreas Gampe4303ba92014-11-06 01:00:46 -08002270 }
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +00002271 }
Andreas Gampe10e477d2014-11-19 12:57:42 -08002272 return true;
2273 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002274
David Brazdil7b49e6c2016-09-01 11:06:18 +01002275 bool FlushCloseOutputFiles() {
Jeff Haodcdc85b2015-12-04 14:06:18 -08002276 bool result = true;
David Brazdil7b49e6c2016-09-01 11:06:18 +01002277 for (auto& files : { &vdex_files_, &oat_files_ }) {
2278 for (size_t i = 0; i < files->size(); ++i) {
2279 result &= FlushCloseOutputFile(&(*files)[i]);
2280 }
Jeff Haodcdc85b2015-12-04 14:06:18 -08002281 }
2282 return result;
2283 }
2284
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002285 void DumpTiming() {
2286 if (dump_timing_ || (dump_slow_timing_ && timings_->GetTotalNs() > MsToNs(1000))) {
2287 LOG(INFO) << Dumpable<TimingLogger>(*timings_);
2288 }
2289 if (dump_passes_) {
2290 LOG(INFO) << Dumpable<CumulativeLogger>(*driver_->GetTimingsLogger());
2291 }
2292 }
2293
Andreas Gampe10e477d2014-11-19 12:57:42 -08002294 bool IsImage() const {
Mathieu Chartiera90c7722015-10-29 15:41:36 -07002295 return IsAppImage() || IsBootImage();
2296 }
2297
2298 bool IsAppImage() const {
Vladimir Markoaad75c62016-10-03 08:46:48 +00002299 return compiler_options_->IsAppImage();
Mathieu Chartiera90c7722015-10-29 15:41:36 -07002300 }
2301
2302 bool IsBootImage() const {
Vladimir Markoaad75c62016-10-03 08:46:48 +00002303 return compiler_options_->IsBootImage();
Andreas Gampe10e477d2014-11-19 12:57:42 -08002304 }
2305
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002306 bool IsHost() const {
2307 return is_host_;
2308 }
2309
Mathieu Chartier11b3df32017-02-21 13:41:54 -08002310 bool UseProfile() const {
Mathieu Chartierd0af56c2017-02-17 12:56:25 -08002311 return profile_file_fd_ != -1 || !profile_file_.empty();
Calin Juravle998c2162015-12-21 15:39:33 +02002312 }
2313
Mathieu Chartier11b3df32017-02-21 13:41:54 -08002314 bool DoProfileGuidedOptimizations() const {
Nicolas Geoffray49cda062017-04-21 13:08:25 +01002315 return UseProfile();
Mathieu Chartier11b3df32017-02-21 13:41:54 -08002316 }
2317
2318 bool DoDexLayoutOptimizations() const {
2319 return DoProfileGuidedOptimizations();
2320 }
2321
Igor Murashkin545412b2017-08-17 15:26:54 -07002322 bool DoOatLayoutOptimizations() const {
2323 return DoProfileGuidedOptimizations();
2324 }
2325
Nicolas Geoffray1cfea7a2017-05-24 14:44:38 +01002326 bool DoEagerUnquickeningOfVdex() const {
2327 // DexLayout can invalidate the vdex metadata, so we need to unquicken
2328 // the vdex file eagerly, before passing it to dexlayout.
2329 return DoDexLayoutOptimizations();
2330 }
2331
Calin Juravle2e2db782016-02-23 12:00:03 +00002332 bool LoadProfile() {
Mathieu Chartier11b3df32017-02-21 13:41:54 -08002333 DCHECK(UseProfile());
Calin Juravlee6f87cc2017-05-24 17:41:05 -07002334 // TODO(calin): We should be using the runtime arena pool (instead of the
2335 // default profile arena). However the setup logic is messy and needs
2336 // cleaning up before that (e.g. the oat writers are created before the
2337 // runtime).
Calin Juravle2e2db782016-02-23 12:00:03 +00002338 profile_compilation_info_.reset(new ProfileCompilationInfo());
Narayan Kamatha3d27eb2017-05-11 13:50:59 +01002339 ScopedFlock profile_file;
Calin Juravle2e2db782016-02-23 12:00:03 +00002340 std::string error;
2341 if (profile_file_fd_ != -1) {
Narayan Kamatha3d27eb2017-05-11 13:50:59 +01002342 profile_file = LockedFile::DupOf(profile_file_fd_, "profile",
2343 true /* read_only_mode */, &error);
Andreas Gampe29d38e72016-03-23 15:31:51 +00002344 } else if (profile_file_ != "") {
Narayan Kamatha3d27eb2017-05-11 13:50:59 +01002345 profile_file = LockedFile::Open(profile_file_.c_str(), O_RDONLY, true, &error);
Calin Juravle998c2162015-12-21 15:39:33 +02002346 }
Calin Juravle877fd962016-01-05 14:29:29 +00002347
Narayan Kamatha3d27eb2017-05-11 13:50:59 +01002348 // Return early if we're unable to obtain a lock on the profile.
2349 if (profile_file.get() == nullptr) {
2350 LOG(ERROR) << "Cannot lock profiles: " << error;
2351 return false;
2352 }
2353
2354 if (!profile_compilation_info_->Load(profile_file->Fd())) {
Calin Juravle2e2db782016-02-23 12:00:03 +00002355 profile_compilation_info_.reset(nullptr);
Narayan Kamatha3d27eb2017-05-11 13:50:59 +01002356 return false;
Calin Juravle2e2db782016-02-23 12:00:03 +00002357 }
Calin Juravle877fd962016-01-05 14:29:29 +00002358
Narayan Kamatha3d27eb2017-05-11 13:50:59 +01002359 return true;
Calin Juravle998c2162015-12-21 15:39:33 +02002360 }
2361
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002362 private:
Andreas Gampee1459ae2016-06-29 09:36:30 -07002363 bool UseSwap(bool is_image, const std::vector<const DexFile*>& dex_files) {
2364 if (is_image) {
2365 // Don't use swap, we know generation should succeed, and we don't want to slow it down.
2366 return false;
2367 }
2368 if (dex_files.size() < min_dex_files_for_swap_) {
2369 // If there are less dex files than the threshold, assume it's gonna be fine.
2370 return false;
2371 }
2372 size_t dex_files_size = 0;
2373 for (const auto* dex_file : dex_files) {
2374 dex_files_size += dex_file->GetHeader().file_size_;
2375 }
2376 return dex_files_size >= min_dex_file_cumulative_size_for_swap_;
2377 }
2378
Andreas Gampe67f02822016-06-24 21:05:23 -07002379 bool IsVeryLarge(std::vector<const DexFile*>& dex_files) {
2380 size_t dex_files_size = 0;
2381 for (const auto* dex_file : dex_files) {
2382 dex_files_size += dex_file->GetHeader().file_size_;
2383 }
2384 return dex_files_size >= very_large_threshold_;
2385 }
2386
Vladimir Marko49b0f452015-12-10 13:49:19 +00002387 bool PrepareImageClasses() {
2388 // If --image-classes was specified, calculate the full list of classes to include in the image.
2389 if (image_classes_filename_ != nullptr) {
2390 image_classes_ =
2391 ReadClasses(image_classes_zip_filename_, image_classes_filename_, "image");
2392 if (image_classes_ == nullptr) {
2393 return false;
2394 }
2395 } else if (IsBootImage()) {
2396 image_classes_.reset(new std::unordered_set<std::string>);
2397 }
2398 return true;
2399 }
2400
2401 bool PrepareCompiledClasses() {
2402 // If --compiled-classes was specified, calculate the full list of classes to compile in the
2403 // image.
2404 if (compiled_classes_filename_ != nullptr) {
2405 compiled_classes_ =
2406 ReadClasses(compiled_classes_zip_filename_, compiled_classes_filename_, "compiled");
2407 if (compiled_classes_ == nullptr) {
2408 return false;
2409 }
2410 } else {
2411 compiled_classes_.reset(nullptr); // By default compile everything.
2412 }
2413 return true;
2414 }
2415
2416 static std::unique_ptr<std::unordered_set<std::string>> ReadClasses(const char* zip_filename,
2417 const char* classes_filename,
2418 const char* tag) {
2419 std::unique_ptr<std::unordered_set<std::string>> classes;
2420 std::string error_msg;
2421 if (zip_filename != nullptr) {
2422 classes.reset(ReadImageClassesFromZip(zip_filename, classes_filename, &error_msg));
2423 } else {
2424 classes.reset(ReadImageClassesFromFile(classes_filename));
2425 }
2426 if (classes == nullptr) {
2427 LOG(ERROR) << "Failed to create list of " << tag << " classes from '"
2428 << classes_filename << "': " << error_msg;
2429 }
2430 return classes;
2431 }
2432
2433 bool PrepareCompiledMethods() {
2434 // If --compiled-methods was specified, read the methods to compile from the given file(s).
2435 if (compiled_methods_filename_ != nullptr) {
2436 std::string error_msg;
2437 if (compiled_methods_zip_filename_ != nullptr) {
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002438 compiled_methods_.reset(ReadCommentedInputFromZip<std::unordered_set<std::string>>(
2439 compiled_methods_zip_filename_,
2440 compiled_methods_filename_,
2441 nullptr, // No post-processing.
2442 &error_msg));
Vladimir Marko49b0f452015-12-10 13:49:19 +00002443 } else {
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002444 compiled_methods_.reset(ReadCommentedInputFromFile<std::unordered_set<std::string>>(
2445 compiled_methods_filename_,
2446 nullptr)); // No post-processing.
Vladimir Marko49b0f452015-12-10 13:49:19 +00002447 }
2448 if (compiled_methods_.get() == nullptr) {
2449 LOG(ERROR) << "Failed to create list of compiled methods from '"
2450 << compiled_methods_filename_ << "': " << error_msg;
2451 return false;
2452 }
2453 } else {
2454 compiled_methods_.reset(nullptr); // By default compile everything.
2455 }
2456 return true;
2457 }
2458
Jeff Haoc23b0c02017-07-27 18:19:38 -07002459 bool PrepareDirtyObjects() {
2460 if (dirty_image_objects_filename_ != nullptr) {
2461 dirty_image_objects_.reset(ReadCommentedInputFromFile<std::unordered_set<std::string>>(
2462 dirty_image_objects_filename_,
2463 nullptr));
2464 if (dirty_image_objects_ == nullptr) {
2465 LOG(ERROR) << "Failed to create list of dirty objects from '"
2466 << dirty_image_objects_filename_ << "'";
2467 return false;
2468 }
2469 } else {
2470 dirty_image_objects_.reset(nullptr);
2471 }
2472 return true;
2473 }
2474
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002475 void PruneNonExistentDexFiles() {
2476 DCHECK_EQ(dex_filenames_.size(), dex_locations_.size());
2477 size_t kept = 0u;
2478 for (size_t i = 0, size = dex_filenames_.size(); i != size; ++i) {
2479 if (!OS::FileExists(dex_filenames_[i])) {
2480 LOG(WARNING) << "Skipping non-existent dex file '" << dex_filenames_[i] << "'";
2481 } else {
2482 dex_filenames_[kept] = dex_filenames_[i];
2483 dex_locations_[kept] = dex_locations_[i];
2484 ++kept;
2485 }
2486 }
2487 dex_filenames_.resize(kept);
2488 dex_locations_.resize(kept);
2489 }
2490
2491 bool AddDexFileSources() {
2492 TimingLogger::ScopedTiming t2("AddDexFileSources", timings_);
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00002493 if (input_vdex_file_ != nullptr) {
2494 DCHECK_EQ(oat_writers_.size(), 1u);
2495 const std::string& name = zip_location_.empty() ? dex_locations_[0] : zip_location_;
2496 DCHECK(!name.empty());
2497 if (!oat_writers_[0]->AddVdexDexFilesSource(*input_vdex_file_.get(), name.c_str())) {
2498 return false;
2499 }
2500 } else if (zip_fd_ != -1) {
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002501 DCHECK_EQ(oat_writers_.size(), 1u);
Andreas Gampe43e10b02016-07-15 17:17:34 -07002502 if (!oat_writers_[0]->AddZippedDexFilesSource(File(zip_fd_, /* check_usage */ false),
2503 zip_location_.c_str())) {
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002504 return false;
2505 }
2506 } else if (oat_writers_.size() > 1u) {
2507 // Multi-image.
2508 DCHECK_EQ(oat_writers_.size(), dex_filenames_.size());
2509 DCHECK_EQ(oat_writers_.size(), dex_locations_.size());
2510 for (size_t i = 0, size = oat_writers_.size(); i != size; ++i) {
2511 if (!oat_writers_[i]->AddDexFileSource(dex_filenames_[i], dex_locations_[i])) {
2512 return false;
2513 }
2514 }
2515 } else {
2516 DCHECK_EQ(oat_writers_.size(), 1u);
2517 DCHECK_EQ(dex_filenames_.size(), dex_locations_.size());
2518 DCHECK_NE(dex_filenames_.size(), 0u);
2519 for (size_t i = 0; i != dex_filenames_.size(); ++i) {
2520 if (!oat_writers_[0]->AddDexFileSource(dex_filenames_[i], dex_locations_[i])) {
2521 return false;
2522 }
2523 }
2524 }
2525 return true;
2526 }
2527
2528 void CreateOatWriters() {
2529 TimingLogger::ScopedTiming t2("CreateOatWriters", timings_);
2530 elf_writers_.reserve(oat_files_.size());
2531 oat_writers_.reserve(oat_files_.size());
2532 for (const std::unique_ptr<File>& oat_file : oat_files_) {
Vladimir Marko74527972016-11-29 15:57:32 +00002533 elf_writers_.emplace_back(linker::CreateElfWriterQuick(instruction_set_,
2534 instruction_set_features_.get(),
2535 compiler_options_.get(),
2536 oat_file.get()));
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002537 elf_writers_.back()->Start();
Igor Murashkin545412b2017-08-17 15:26:54 -07002538 const bool do_oat_writer_layout = DoDexLayoutOptimizations() || DoOatLayoutOptimizations();
Vladimir Marko74527972016-11-29 15:57:32 +00002539 oat_writers_.emplace_back(new linker::OatWriter(
Igor Murashkin545412b2017-08-17 15:26:54 -07002540 IsBootImage(),
2541 timings_,
2542 do_oat_writer_layout ? profile_compilation_info_.get() : nullptr));
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002543 }
2544 }
2545
Vladimir Marko49b0f452015-12-10 13:49:19 +00002546 void SaveDexInput() {
2547 for (size_t i = 0; i < dex_files_.size(); ++i) {
2548 const DexFile* dex_file = dex_files_[i];
2549 std::string tmp_file_name(StringPrintf("/data/local/tmp/dex2oat.%d.%zd.dex",
2550 getpid(), i));
2551 std::unique_ptr<File> tmp_file(OS::CreateEmptyFile(tmp_file_name.c_str()));
2552 if (tmp_file.get() == nullptr) {
2553 PLOG(ERROR) << "Failed to open file " << tmp_file_name
2554 << ". Try: adb shell chmod 777 /data/local/tmp";
2555 continue;
2556 }
2557 // This is just dumping files for debugging. Ignore errors, and leave remnants.
2558 UNUSED(tmp_file->WriteFully(dex_file->Begin(), dex_file->Size()));
2559 UNUSED(tmp_file->Flush());
2560 UNUSED(tmp_file->Close());
2561 LOG(INFO) << "Wrote input to " << tmp_file_name;
2562 }
2563 }
2564
Mathieu Chartier46331a62017-07-21 09:49:10 -07002565 bool PrepareRuntimeOptions(RuntimeArgumentMap* runtime_options,
2566 QuickCompilerCallbacks* callbacks) {
Vladimir Marko49b0f452015-12-10 13:49:19 +00002567 RuntimeOptions raw_options;
2568 if (boot_image_filename_.empty()) {
2569 std::string boot_class_path = "-Xbootclasspath:";
Andreas Gampe9186ced2016-12-12 14:28:21 -08002570 boot_class_path += android::base::Join(dex_filenames_, ':');
Vladimir Marko49b0f452015-12-10 13:49:19 +00002571 raw_options.push_back(std::make_pair(boot_class_path, nullptr));
2572 std::string boot_class_path_locations = "-Xbootclasspath-locations:";
Andreas Gampe9186ced2016-12-12 14:28:21 -08002573 boot_class_path_locations += android::base::Join(dex_locations_, ':');
Vladimir Marko49b0f452015-12-10 13:49:19 +00002574 raw_options.push_back(std::make_pair(boot_class_path_locations, nullptr));
2575 } else {
2576 std::string boot_image_option = "-Ximage:";
2577 boot_image_option += boot_image_filename_;
2578 raw_options.push_back(std::make_pair(boot_image_option, nullptr));
2579 }
2580 for (size_t i = 0; i < runtime_args_.size(); i++) {
2581 raw_options.push_back(std::make_pair(runtime_args_[i], nullptr));
2582 }
2583
Mathieu Chartier46331a62017-07-21 09:49:10 -07002584 raw_options.push_back(std::make_pair("compilercallbacks", callbacks));
Vladimir Marko49b0f452015-12-10 13:49:19 +00002585 raw_options.push_back(
2586 std::make_pair("imageinstructionset", GetInstructionSetString(instruction_set_)));
2587
2588 // Only allow no boot image for the runtime if we're compiling one. When we compile an app,
2589 // we don't want fallback mode, it will abort as we do not push a boot classpath (it might
2590 // have been stripped in preopting, anyways).
2591 if (!IsBootImage()) {
2592 raw_options.push_back(std::make_pair("-Xno-dex-file-fallback", nullptr));
2593 }
Andreas Gampec8e35202017-04-28 15:47:12 -07002594 // Never allow implicit image compilation.
2595 raw_options.push_back(std::make_pair("-Xnoimage-dex2oat", nullptr));
Vladimir Marko49b0f452015-12-10 13:49:19 +00002596 // Disable libsigchain. We don't don't need it during compilation and it prevents us
2597 // from getting a statically linked version of dex2oat (because of dlsym and RTLD_NEXT).
2598 raw_options.push_back(std::make_pair("-Xno-sig-chain", nullptr));
Lin Zang97f3f7d2016-01-13 10:25:00 +08002599 // Disable Hspace compaction to save heap size virtual space.
2600 // Only need disable Hspace for OOM becasue background collector is equal to
2601 // foreground collector by default for dex2oat.
2602 raw_options.push_back(std::make_pair("-XX:DisableHSpaceCompactForOOM", nullptr));
Vladimir Marko49b0f452015-12-10 13:49:19 +00002603
Andreas Gampeace0dc12016-01-20 13:33:13 -08002604 if (compiler_options_->IsForceDeterminism()) {
Roland Levillainb81e9e92017-04-20 17:35:32 +01002605 // If we're asked to be deterministic, ensure non-concurrent GC for determinism.
2606 //
2607 // Note that with read barriers, this option is ignored, because Runtime::Init
2608 // overrides the foreground GC to be gc::kCollectorTypeCC when instantiating
2609 // gc::Heap. This is fine, as concurrent GC requests are not honored in dex2oat,
2610 // which uses an unstarted runtime.
Andreas Gampeace0dc12016-01-20 13:33:13 -08002611 raw_options.push_back(std::make_pair("-Xgc:nonconcurrent", nullptr));
Roland Levillainb81e9e92017-04-20 17:35:32 +01002612
Nicolas Geoffray7acddd82017-05-03 15:04:55 +01002613 // The default LOS implementation (map) is not deterministic. So disable it.
2614 raw_options.push_back(std::make_pair("-XX:LargeObjectSpace=disabled", nullptr));
Andreas Gampeace0dc12016-01-20 13:33:13 -08002615
2616 // We also need to turn off the nonmoving space. For that, we need to disable HSpace
2617 // compaction (done above) and ensure that neither foreground nor background collectors
2618 // are concurrent.
Roland Levillainb81e9e92017-04-20 17:35:32 +01002619 //
2620 // Likewise, this option is ignored with read barriers because Runtime::Init
2621 // overrides the background GC to be gc::kCollectorTypeCCBackground, but that's
2622 // fine too, for the same reason (see above).
Andreas Gampeace0dc12016-01-20 13:33:13 -08002623 raw_options.push_back(std::make_pair("-XX:BackgroundGC=nonconcurrent", nullptr));
2624
2625 // To make identity hashcode deterministic, set a known seed.
2626 mirror::Object::SetHashCodeSeed(987654321U);
2627 }
2628
Vladimir Marko49b0f452015-12-10 13:49:19 +00002629 if (!Runtime::ParseOptions(raw_options, false, runtime_options)) {
2630 LOG(ERROR) << "Failed to parse runtime options";
2631 return false;
2632 }
2633 return true;
2634 }
2635
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002636 // Create a runtime necessary for compilation.
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002637 bool CreateRuntime(RuntimeArgumentMap&& runtime_options) {
2638 TimingLogger::ScopedTiming t_runtime("Create runtime", timings_);
Vladimir Marko49b0f452015-12-10 13:49:19 +00002639 if (!Runtime::Create(std::move(runtime_options))) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002640 LOG(ERROR) << "Failed to create runtime";
2641 return false;
2642 }
Andreas Gampe49c144d2016-11-14 10:11:16 -08002643
2644 // Runtime::Init will rename this thread to be "main". Prefer "dex2oat" so that "top" and
2645 // "ps -a" don't change to non-descript "main."
2646 SetThreadName(kIsDebugBuild ? "dex2oatd" : "dex2oat");
2647
Vladimir Marko307dac92015-10-20 11:20:09 +01002648 runtime_.reset(Runtime::Current());
2649 runtime_->SetInstructionSet(instruction_set_);
Andreas Gampe8228cdf2017-05-30 15:03:54 -07002650 for (uint32_t i = 0; i < static_cast<uint32_t>(CalleeSaveType::kLastCalleeSaveType); ++i) {
2651 CalleeSaveType type = CalleeSaveType(i);
Vladimir Marko307dac92015-10-20 11:20:09 +01002652 if (!runtime_->HasCalleeSaveMethod(type)) {
2653 runtime_->SetCalleeSaveMethod(runtime_->CreateCalleeSaveMethod(), type);
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002654 }
2655 }
Andreas Gampe2969bcd2015-03-09 12:57:41 -07002656
2657 // Initialize maps for unstarted runtime. This needs to be here, as running clinits needs this
2658 // set up.
Andreas Gampe799681b2015-05-15 19:24:12 -07002659 interpreter::UnstartedRuntime::Initialize();
Andreas Gampe2969bcd2015-03-09 12:57:41 -07002660
Vladimir Marko307dac92015-10-20 11:20:09 +01002661 runtime_->GetClassLinker()->RunRootClinits();
Andreas Gampe2969bcd2015-03-09 12:57:41 -07002662
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002663 // Runtime::Create acquired the mutator_lock_ that is normally given away when we
2664 // Runtime::Start, give it away now so that we don't starve GC.
2665 Thread* self = Thread::Current();
2666 self->TransitionFromRunnableToSuspended(kNative);
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002667
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002668 return true;
Vladimir Marko919f5532016-01-20 19:13:01 +00002669 }
2670
Jeff Haodcdc85b2015-12-04 14:06:18 -08002671 // Let the ImageWriter write the image files. If we do not compile PIC, also fix up the oat files.
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002672 bool CreateImageFile()
Mathieu Chartier90443472015-07-16 20:32:27 -07002673 REQUIRES(!Locks::mutator_lock_) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002674 CHECK(image_writer_ != nullptr);
Jeff Haodcdc85b2015-12-04 14:06:18 -08002675 if (!IsBootImage()) {
Mathieu Chartierfbc31082016-01-24 11:59:56 -08002676 CHECK(image_filenames_.empty());
Jeff Haodcdc85b2015-12-04 14:06:18 -08002677 image_filenames_.push_back(app_image_file_name_.c_str());
2678 }
Mathieu Chartierfbc31082016-01-24 11:59:56 -08002679 if (!image_writer_->Write(app_image_fd_,
2680 image_filenames_,
Vladimir Marko944da602016-02-19 12:27:55 +00002681 oat_filenames_)) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08002682 LOG(ERROR) << "Failure during image file creation";
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002683 return false;
2684 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002685
Jeff Haodcdc85b2015-12-04 14:06:18 -08002686 // We need the OatDataBegin entries.
Vladimir Marko944da602016-02-19 12:27:55 +00002687 dchecked_vector<uintptr_t> oat_data_begins;
2688 for (size_t i = 0, size = oat_filenames_.size(); i != size; ++i) {
2689 oat_data_begins.push_back(image_writer_->GetOatDataBegin(i));
Jeff Haodcdc85b2015-12-04 14:06:18 -08002690 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002691 // Destroy ImageWriter before doing FixupElf.
2692 image_writer_.reset();
2693
Vladimir Marko944da602016-02-19 12:27:55 +00002694 for (size_t i = 0, size = oat_filenames_.size(); i != size; ++i) {
2695 const char* oat_filename = oat_filenames_[i];
Jeff Haodcdc85b2015-12-04 14:06:18 -08002696 // Do not fix up the ELF file if we are --compile-pic or compiling the app image
2697 if (!compiler_options_->GetCompilePic() && IsBootImage()) {
2698 std::unique_ptr<File> oat_file(OS::OpenFileReadWrite(oat_filename));
2699 if (oat_file.get() == nullptr) {
2700 PLOG(ERROR) << "Failed to open ELF file: " << oat_filename;
2701 return false;
2702 }
Andreas Gampe4303ba92014-11-06 01:00:46 -08002703
Vladimir Marko74527972016-11-29 15:57:32 +00002704 if (!linker::ElfWriter::Fixup(oat_file.get(), oat_data_begins[i])) {
Jeff Haodcdc85b2015-12-04 14:06:18 -08002705 oat_file->Erase();
2706 LOG(ERROR) << "Failed to fixup ELF file " << oat_file->GetPath();
2707 return false;
2708 }
2709
2710 if (oat_file->FlushCloseOrErase()) {
2711 PLOG(ERROR) << "Failed to flush and close fixed ELF file " << oat_file->GetPath();
2712 return false;
2713 }
Andreas Gampe4303ba92014-11-06 01:00:46 -08002714 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002715 }
2716
2717 return true;
2718 }
2719
2720 // Reads the class names (java.lang.Object) and returns a set of descriptors (Ljava/lang/Object;)
Andreas Gampeb1fcead2015-04-20 18:53:51 -07002721 static std::unordered_set<std::string>* ReadImageClassesFromFile(
2722 const char* image_classes_filename) {
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002723 std::function<std::string(const char*)> process = DotToDescriptor;
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002724 return ReadCommentedInputFromFile<std::unordered_set<std::string>>(image_classes_filename,
2725 &process);
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002726 }
2727
2728 // Reads the class names (java.lang.Object) and returns a set of descriptors (Ljava/lang/Object;)
Andreas Gampeb1fcead2015-04-20 18:53:51 -07002729 static std::unordered_set<std::string>* ReadImageClassesFromZip(
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002730 const char* zip_filename,
2731 const char* image_classes_filename,
2732 std::string* error_msg) {
2733 std::function<std::string(const char*)> process = DotToDescriptor;
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002734 return ReadCommentedInputFromZip<std::unordered_set<std::string>>(zip_filename,
2735 image_classes_filename,
2736 &process,
2737 error_msg);
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002738 }
2739
2740 // Read lines from the given file, dropping comments and empty lines. Post-process each line with
2741 // the given function.
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002742 template <typename T>
2743 static T* ReadCommentedInputFromFile(
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002744 const char* input_filename, std::function<std::string(const char*)>* process) {
2745 std::unique_ptr<std::ifstream> input_file(new std::ifstream(input_filename, std::ifstream::in));
2746 if (input_file.get() == nullptr) {
2747 LOG(ERROR) << "Failed to open input file " << input_filename;
2748 return nullptr;
2749 }
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002750 std::unique_ptr<T> result(
2751 ReadCommentedInputStream<T>(*input_file, process));
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002752 input_file->close();
2753 return result.release();
2754 }
2755
2756 // Read lines from the given file from the given zip file, dropping comments and empty lines.
2757 // Post-process each line with the given function.
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002758 template <typename T>
2759 static T* ReadCommentedInputFromZip(
Andreas Gampeb1fcead2015-04-20 18:53:51 -07002760 const char* zip_filename,
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002761 const char* input_filename,
2762 std::function<std::string(const char*)>* process,
Andreas Gampeb1fcead2015-04-20 18:53:51 -07002763 std::string* error_msg) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002764 std::unique_ptr<ZipArchive> zip_archive(ZipArchive::Open(zip_filename, error_msg));
2765 if (zip_archive.get() == nullptr) {
2766 return nullptr;
2767 }
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002768 std::unique_ptr<ZipEntry> zip_entry(zip_archive->Find(input_filename, error_msg));
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002769 if (zip_entry.get() == nullptr) {
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002770 *error_msg = StringPrintf("Failed to find '%s' within '%s': %s", input_filename,
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002771 zip_filename, error_msg->c_str());
2772 return nullptr;
2773 }
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002774 std::unique_ptr<MemMap> input_file(zip_entry->ExtractToMemMap(zip_filename,
2775 input_filename,
2776 error_msg));
2777 if (input_file.get() == nullptr) {
2778 *error_msg = StringPrintf("Failed to extract '%s' from '%s': %s", input_filename,
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002779 zip_filename, error_msg->c_str());
2780 return nullptr;
2781 }
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002782 const std::string input_string(reinterpret_cast<char*>(input_file->Begin()),
2783 input_file->Size());
2784 std::istringstream input_stream(input_string);
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002785 return ReadCommentedInputStream<T>(input_stream, process);
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002786 }
2787
2788 // Read lines from the given stream, dropping comments and empty lines. Post-process each line
2789 // with the given function.
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002790 template <typename T>
2791 static T* ReadCommentedInputStream(
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002792 std::istream& in_stream,
2793 std::function<std::string(const char*)>* process) {
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002794 std::unique_ptr<T> output(new T());
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002795 while (in_stream.good()) {
2796 std::string dot;
2797 std::getline(in_stream, dot);
Andreas Gampe9186ced2016-12-12 14:28:21 -08002798 if (android::base::StartsWith(dot, "#") || dot.empty()) {
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002799 continue;
2800 }
2801 if (process != nullptr) {
2802 std::string descriptor((*process)(dot.c_str()));
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002803 output->insert(output->end(), descriptor);
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002804 } else {
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002805 output->insert(output->end(), dot);
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002806 }
2807 }
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002808 return output.release();
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002809 }
2810
Mathieu Chartier49285c52014-12-02 15:43:48 -08002811 void LogCompletionTime() {
Andreas Gampe1d00add2015-02-27 19:35:46 -08002812 // Note: when creation of a runtime fails, e.g., when trying to compile an app but when there
2813 // is no image, there won't be a Runtime::Current().
Brian Carlstroma11a34c2015-03-06 08:44:45 -08002814 // Note: driver creation can fail when loading an invalid dex file.
Andreas Gampec560fc02014-07-16 09:57:39 -07002815 LOG(INFO) << "dex2oat took "
2816 << PrettyDuration(NanoTime() - start_ns_)
Andreas Gampecc967752016-12-12 13:49:00 -08002817 << " (" << PrettyDuration(ProcessCpuNanoTime() - start_cputime_ns_) << " cpu)"
Mathieu Chartierab972ef2014-12-03 17:38:22 -08002818 << " (threads: " << thread_count_ << ") "
Andreas Gampe3f30e122015-09-17 14:03:21 -07002819 << ((Runtime::Current() != nullptr && driver_ != nullptr) ?
Andreas Gampe1d00add2015-02-27 19:35:46 -08002820 driver_->GetMemoryUsageString(kIsDebugBuild || VLOG_IS_ON(compiler)) :
2821 "");
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002822 }
2823
Jeff Haodcdc85b2015-12-04 14:06:18 -08002824 std::string StripIsaFrom(const char* image_filename, InstructionSet isa) {
2825 std::string res(image_filename);
2826 size_t last_slash = res.rfind('/');
2827 if (last_slash == std::string::npos || last_slash == 0) {
2828 return res;
2829 }
2830 size_t penultimate_slash = res.rfind('/', last_slash - 1);
2831 if (penultimate_slash == std::string::npos) {
2832 return res;
2833 }
2834 // Check that the string in-between is the expected one.
2835 if (res.substr(penultimate_slash + 1, last_slash - penultimate_slash - 1) !=
2836 GetInstructionSetString(isa)) {
2837 LOG(WARNING) << "Unexpected string when trying to strip isa: " << res;
2838 return res;
2839 }
2840 return res.substr(0, penultimate_slash) + res.substr(last_slash);
2841 }
2842
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002843 std::unique_ptr<CompilerOptions> compiler_options_;
2844 Compiler::Kind compiler_kind_;
2845
2846 InstructionSet instruction_set_;
2847 std::unique_ptr<const InstructionSetFeatures> instruction_set_features_;
2848
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002849 uint32_t image_file_location_oat_checksum_;
2850 uintptr_t image_file_location_oat_data_begin_;
2851 int32_t image_patch_delta_;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002852 std::unique_ptr<SafeMap<std::string, std::string> > key_value_store_;
2853
Vladimir Marko307dac92015-10-20 11:20:09 +01002854 std::unique_ptr<VerificationResults> verification_results_;
Andreas Gampe3f30e122015-09-17 14:03:21 -07002855
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002856 std::unique_ptr<QuickCompilerCallbacks> callbacks_;
2857
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002858 std::unique_ptr<Runtime> runtime_;
2859
Calin Juravle1ce70852017-06-28 10:59:03 -07002860 // The spec describing how the class loader should be setup for compilation.
2861 std::unique_ptr<ClassLoaderContext> class_loader_context_;
Richard Uhlerfbef44d2014-12-23 09:48:51 -08002862
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002863 size_t thread_count_;
2864 uint64_t start_ns_;
Andreas Gampec560fc02014-07-16 09:57:39 -07002865 uint64_t start_cputime_ns_;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002866 std::unique_ptr<WatchDog> watchdog_;
Jeff Haodcdc85b2015-12-04 14:06:18 -08002867 std::vector<std::unique_ptr<File>> oat_files_;
David Brazdil7b49e6c2016-09-01 11:06:18 +01002868 std::vector<std::unique_ptr<File>> vdex_files_;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002869 std::string oat_location_;
Jeff Haodcdc85b2015-12-04 14:06:18 -08002870 std::vector<const char*> oat_filenames_;
2871 std::vector<const char*> oat_unstripped_;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002872 int oat_fd_;
Nicolas Geoffraya6a448a2016-11-10 10:49:40 +00002873 int input_vdex_fd_;
2874 int output_vdex_fd_;
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00002875 std::string input_vdex_;
Nicolas Geoffray4e868fa2017-04-21 17:16:44 +01002876 std::string output_vdex_;
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00002877 std::unique_ptr<VdexFile> input_vdex_file_;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002878 std::vector<const char*> dex_filenames_;
2879 std::vector<const char*> dex_locations_;
2880 int zip_fd_;
2881 std::string zip_location_;
Vladimir Marko49b0f452015-12-10 13:49:19 +00002882 std::string boot_image_filename_;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002883 std::vector<const char*> runtime_args_;
Jeff Haodcdc85b2015-12-04 14:06:18 -08002884 std::vector<const char*> image_filenames_;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002885 uintptr_t image_base_;
2886 const char* image_classes_zip_filename_;
2887 const char* image_classes_filename_;
Mathieu Chartierceb07b32015-12-10 09:33:21 -08002888 ImageHeader::StorageMode image_storage_mode_;
Andreas Gampe4bf3ae92014-11-11 13:28:29 -08002889 const char* compiled_classes_zip_filename_;
2890 const char* compiled_classes_filename_;
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002891 const char* compiled_methods_zip_filename_;
2892 const char* compiled_methods_filename_;
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002893 const char* passes_to_run_filename_;
Jeff Haoc23b0c02017-07-27 18:19:38 -07002894 const char* dirty_image_objects_filename_;
Andreas Gampeb1fcead2015-04-20 18:53:51 -07002895 std::unique_ptr<std::unordered_set<std::string>> image_classes_;
2896 std::unique_ptr<std::unordered_set<std::string>> compiled_classes_;
Andreas Gampe70bef0d2015-04-15 02:37:28 -07002897 std::unique_ptr<std::unordered_set<std::string>> compiled_methods_;
Jeff Haoc23b0c02017-07-27 18:19:38 -07002898 std::unique_ptr<std::unordered_set<std::string>> dirty_image_objects_;
Wojciech Staszkiewicz5319d3c2016-08-01 17:48:59 -07002899 std::unique_ptr<std::vector<std::string>> passes_to_run_;
Jeff Hao436183f2016-01-12 16:36:50 -08002900 bool multi_image_;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002901 bool is_host_;
2902 std::string android_root_;
Mathieu Chartier0b490842016-05-25 15:05:59 -07002903 // Dex files we are compiling, does not include the class path dex files.
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002904 std::vector<const DexFile*> dex_files_;
Jeff Haodcdc85b2015-12-04 14:06:18 -08002905 std::string no_inline_from_string_;
Andreas Gampe3f30e122015-09-17 14:03:21 -07002906
Vladimir Marko74527972016-11-29 15:57:32 +00002907 std::vector<std::unique_ptr<linker::ElfWriter>> elf_writers_;
2908 std::vector<std::unique_ptr<linker::OatWriter>> oat_writers_;
2909 std::vector<linker::OutputStream*> rodata_;
2910 std::vector<std::unique_ptr<linker::OutputStream>> vdex_out_;
2911 std::unique_ptr<linker::ImageWriter> image_writer_;
Vladimir Marko307dac92015-10-20 11:20:09 +01002912 std::unique_ptr<CompilerDriver> driver_;
Andreas Gampe3f30e122015-09-17 14:03:21 -07002913
Vladimir Marko9bdf1082016-01-21 12:15:52 +00002914 std::vector<std::unique_ptr<MemMap>> opened_dex_files_maps_;
2915 std::vector<std::unique_ptr<const DexFile>> opened_dex_files_;
2916
Calin Juravle1ce70852017-06-28 10:59:03 -07002917 // Note that this might contain pointers owned by class_loader_context_.
Vladimir Marko47496c22016-01-27 16:15:08 +00002918 std::vector<const DexFile*> no_inline_from_dex_files_;
2919
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002920 bool dump_stats_;
2921 bool dump_passes_;
2922 bool dump_timing_;
2923 bool dump_slow_timing_;
Mathieu Chartierd1ab1bd2017-08-04 10:21:50 -07002924 bool avoid_storing_invocation_;
Andreas Gampee21dc3d2014-12-08 16:59:43 -08002925 std::string swap_file_name_;
2926 int swap_fd_;
Andreas Gampee1459ae2016-06-29 09:36:30 -07002927 size_t min_dex_files_for_swap_ = kDefaultMinDexFilesForSwap;
2928 size_t min_dex_file_cumulative_size_for_swap_ = kDefaultMinDexFileCumulativeSizeForSwap;
Andreas Gampe67f02822016-06-24 21:05:23 -07002929 size_t very_large_threshold_ = std::numeric_limits<size_t>::max();
Mathieu Chartiera90c7722015-10-29 15:41:36 -07002930 std::string app_image_file_name_;
2931 int app_image_fd_;
Calin Juravle2e2db782016-02-23 12:00:03 +00002932 std::string profile_file_;
2933 int profile_file_fd_;
Calin Juravle998c2162015-12-21 15:39:33 +02002934 std::unique_ptr<ProfileCompilationInfo> profile_compilation_info_;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002935 TimingLogger* timings_;
2936 std::unique_ptr<CumulativeLogger> compiler_phases_timings_;
Jeff Haodcdc85b2015-12-04 14:06:18 -08002937 std::vector<std::vector<const DexFile*>> dex_files_per_oat_file_;
Vladimir Marko944da602016-02-19 12:27:55 +00002938 std::unordered_map<const DexFile*, size_t> dex_file_oat_index_map_;
Jeff Haodcdc85b2015-12-04 14:06:18 -08002939
2940 // Backing storage.
2941 std::vector<std::string> char_backing_storage_;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002942
Andreas Gampeace0dc12016-01-20 13:33:13 -08002943 // See CompilerOptions.force_determinism_.
2944 bool force_determinism_;
2945
Jeff Hao16d48432017-04-05 17:05:46 -07002946 // Directory of relative classpaths.
2947 std::string classpath_dir_;
2948
Nicolas Geoffray81f57d12016-12-20 13:17:09 +00002949 // Whether the given input vdex is also the output.
2950 bool update_input_vdex_ = false;
2951
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002952 DISALLOW_IMPLICIT_CONSTRUCTORS(Dex2Oat);
2953};
2954
Andreas Gampe88ec7f42014-11-05 10:18:32 -08002955static void b13564922() {
2956#if defined(__linux__) && defined(__arm__)
2957 int major, minor;
2958 struct utsname uts;
2959 if (uname(&uts) != -1 &&
2960 sscanf(uts.release, "%d.%d", &major, &minor) == 2 &&
2961 ((major < 3) || ((major == 3) && (minor < 4)))) {
2962 // Kernels before 3.4 don't handle the ASLR well and we can run out of address
2963 // space (http://b/13564922). Work around the issue by inhibiting further mmap() randomization.
2964 int old_personality = personality(0xffffffff);
2965 if ((old_personality & ADDR_NO_RANDOMIZE) == 0) {
2966 int new_personality = personality(old_personality | ADDR_NO_RANDOMIZE);
2967 if (new_personality == -1) {
2968 LOG(WARNING) << "personality(. | ADDR_NO_RANDOMIZE) failed.";
2969 }
2970 }
2971 }
2972#endif
2973}
2974
Mathieu Chartier72041a02017-07-14 18:23:25 -07002975class ScopedGlobalRef {
2976 public:
2977 explicit ScopedGlobalRef(jobject obj) : obj_(obj) {}
2978 ~ScopedGlobalRef() {
2979 if (obj_ != nullptr) {
2980 ScopedObjectAccess soa(Thread::Current());
2981 soa.Env()->vm->DeleteGlobalRef(soa.Self(), obj_);
2982 }
2983 }
2984
2985 private:
2986 jobject obj_;
2987};
2988
Andreas Gampe7b565912017-03-20 15:48:52 -07002989static dex2oat::ReturnCode CompileImage(Dex2Oat& dex2oat) {
Mathieu Chartierc5dd3192015-12-09 16:38:30 -08002990 dex2oat.LoadClassProfileDescriptors();
Mathieu Chartier9e050df2017-08-09 10:05:47 -07002991 // Keep the class loader that was used for compilation live for the rest of the compilation
2992 // process.
Mathieu Chartier72041a02017-07-14 18:23:25 -07002993 ScopedGlobalRef class_loader(dex2oat.Compile());
Andreas Gampe10e477d2014-11-19 12:57:42 -08002994
David Brazdil7b49e6c2016-09-01 11:06:18 +01002995 if (!dex2oat.WriteOutputFiles()) {
2996 dex2oat.EraseOutputFiles();
Andreas Gampe7b565912017-03-20 15:48:52 -07002997 return dex2oat::ReturnCode::kOther;
Andreas Gampe10e477d2014-11-19 12:57:42 -08002998 }
2999
Mathieu Chartierfbc31082016-01-24 11:59:56 -08003000 // Flush boot.oat. We always expect the output file by name, and it will be re-opened from the
3001 // unstripped name. Do not close the file if we are compiling the image with an oat fd since the
3002 // image writer will require this fd to generate the image.
3003 if (dex2oat.ShouldKeepOatFileOpen()) {
David Brazdil7b49e6c2016-09-01 11:06:18 +01003004 if (!dex2oat.FlushOutputFiles()) {
3005 dex2oat.EraseOutputFiles();
Andreas Gampe7b565912017-03-20 15:48:52 -07003006 return dex2oat::ReturnCode::kOther;
Mathieu Chartierfbc31082016-01-24 11:59:56 -08003007 }
David Brazdil7b49e6c2016-09-01 11:06:18 +01003008 } else if (!dex2oat.FlushCloseOutputFiles()) {
Andreas Gampe7b565912017-03-20 15:48:52 -07003009 return dex2oat::ReturnCode::kOther;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003010 }
3011
Jeff Haodcdc85b2015-12-04 14:06:18 -08003012 // Creates the boot.art and patches the oat files.
Andreas Gampe10e477d2014-11-19 12:57:42 -08003013 if (!dex2oat.HandleImage()) {
Andreas Gampe7b565912017-03-20 15:48:52 -07003014 return dex2oat::ReturnCode::kOther;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003015 }
3016
3017 // When given --host, finish early without stripping.
3018 if (dex2oat.IsHost()) {
Mathieu Chartier00bf2602017-03-02 10:14:08 -08003019 if (!dex2oat.FlushCloseOutputFiles()) {
Andreas Gampe7b565912017-03-20 15:48:52 -07003020 return dex2oat::ReturnCode::kOther;
Mathieu Chartier00bf2602017-03-02 10:14:08 -08003021 }
Andreas Gampe10e477d2014-11-19 12:57:42 -08003022 dex2oat.DumpTiming();
Andreas Gampe7b565912017-03-20 15:48:52 -07003023 return dex2oat::ReturnCode::kNoFailure;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003024 }
3025
Jeff Haodcdc85b2015-12-04 14:06:18 -08003026 // Copy stripped to unstripped location, if necessary.
3027 if (!dex2oat.CopyStrippedToUnstripped()) {
Andreas Gampe7b565912017-03-20 15:48:52 -07003028 return dex2oat::ReturnCode::kOther;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003029 }
3030
Jeff Haodcdc85b2015-12-04 14:06:18 -08003031 // FlushClose again, as stripping might have re-opened the oat files.
David Brazdil7b49e6c2016-09-01 11:06:18 +01003032 if (!dex2oat.FlushCloseOutputFiles()) {
Andreas Gampe7b565912017-03-20 15:48:52 -07003033 return dex2oat::ReturnCode::kOther;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003034 }
3035
3036 dex2oat.DumpTiming();
Andreas Gampe7b565912017-03-20 15:48:52 -07003037 return dex2oat::ReturnCode::kNoFailure;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003038}
3039
Andreas Gampe7b565912017-03-20 15:48:52 -07003040static dex2oat::ReturnCode CompileApp(Dex2Oat& dex2oat) {
Mathieu Chartier9e050df2017-08-09 10:05:47 -07003041 // Keep the class loader that was used for compilation live for the rest of the compilation
3042 // process.
Mathieu Chartier72041a02017-07-14 18:23:25 -07003043 ScopedGlobalRef class_loader(dex2oat.Compile());
Andreas Gampe10e477d2014-11-19 12:57:42 -08003044
David Brazdil7b49e6c2016-09-01 11:06:18 +01003045 if (!dex2oat.WriteOutputFiles()) {
3046 dex2oat.EraseOutputFiles();
Andreas Gampe7b565912017-03-20 15:48:52 -07003047 return dex2oat::ReturnCode::kOther;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003048 }
3049
Jeff Haodcdc85b2015-12-04 14:06:18 -08003050 // Do not close the oat files here. We might have gotten the output file by file descriptor,
Andreas Gampe10e477d2014-11-19 12:57:42 -08003051 // which we would lose.
Andreas Gampe10e477d2014-11-19 12:57:42 -08003052
3053 // When given --host, finish early without stripping.
3054 if (dex2oat.IsHost()) {
David Brazdil7b49e6c2016-09-01 11:06:18 +01003055 if (!dex2oat.FlushCloseOutputFiles()) {
Andreas Gampe7b565912017-03-20 15:48:52 -07003056 return dex2oat::ReturnCode::kOther;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003057 }
3058
3059 dex2oat.DumpTiming();
Andreas Gampe7b565912017-03-20 15:48:52 -07003060 return dex2oat::ReturnCode::kNoFailure;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003061 }
3062
Jeff Haodcdc85b2015-12-04 14:06:18 -08003063 // Copy stripped to unstripped location, if necessary. This will implicitly flush & close the
3064 // stripped versions. If this is given, we expect to be able to open writable files by name.
3065 if (!dex2oat.CopyStrippedToUnstripped()) {
Andreas Gampe7b565912017-03-20 15:48:52 -07003066 return dex2oat::ReturnCode::kOther;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003067 }
3068
Jeff Haodcdc85b2015-12-04 14:06:18 -08003069 // Flush and close the files.
David Brazdil7b49e6c2016-09-01 11:06:18 +01003070 if (!dex2oat.FlushCloseOutputFiles()) {
Andreas Gampe7b565912017-03-20 15:48:52 -07003071 return dex2oat::ReturnCode::kOther;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003072 }
3073
3074 dex2oat.DumpTiming();
Andreas Gampe7b565912017-03-20 15:48:52 -07003075 return dex2oat::ReturnCode::kNoFailure;
Andreas Gampe10e477d2014-11-19 12:57:42 -08003076}
3077
Andreas Gampe7b565912017-03-20 15:48:52 -07003078static dex2oat::ReturnCode Dex2oat(int argc, char** argv) {
Andreas Gampe88ec7f42014-11-05 10:18:32 -08003079 b13564922();
3080
3081 TimingLogger timings("compiler", false, false);
3082
Roland Levillain5c7e2602016-02-23 18:08:53 +00003083 // Allocate `dex2oat` on the heap instead of on the stack, as Clang
3084 // might produce a stack frame too large for this function or for
3085 // functions inlining it (such as main), that would not fit the
3086 // requirements of the `-Wframe-larger-than` option.
Andreas Gampe8bdda5a2017-06-08 15:30:36 -07003087 std::unique_ptr<Dex2Oat> dex2oat = std::make_unique<Dex2Oat>(&timings);
Andreas Gampe88ec7f42014-11-05 10:18:32 -08003088
3089 // Parse arguments. Argument mistakes will lead to exit(EXIT_FAILURE) in UsageError.
Roland Levillain5c7e2602016-02-23 18:08:53 +00003090 dex2oat->ParseArgs(argc, argv);
Andreas Gampe88ec7f42014-11-05 10:18:32 -08003091
Calin Juravleb077e152016-02-18 18:47:37 +00003092 // If needed, process profile information for profile guided compilation.
Calin Juravle998c2162015-12-21 15:39:33 +02003093 // This operation involves I/O.
Mathieu Chartier11b3df32017-02-21 13:41:54 -08003094 if (dex2oat->UseProfile()) {
Calin Juravleb077e152016-02-18 18:47:37 +00003095 if (!dex2oat->LoadProfile()) {
3096 LOG(ERROR) << "Failed to process profile file";
Andreas Gampe7b565912017-03-20 15:48:52 -07003097 return dex2oat::ReturnCode::kOther;
Calin Juravle998c2162015-12-21 15:39:33 +02003098 }
3099 }
3100
Nicolas Geoffrayb0bbe8e2016-11-19 10:42:37 +00003101 art::MemMap::Init(); // For ZipEntry::ExtractToMemMap, and vdex.
3102
Vladimir Marko9bdf1082016-01-21 12:15:52 +00003103 // Check early that the result of compilation can be written
Roland Levillain5c7e2602016-02-23 18:08:53 +00003104 if (!dex2oat->OpenFile()) {
Andreas Gampe7b565912017-03-20 15:48:52 -07003105 return dex2oat::ReturnCode::kOther;
Vladimir Marko9bdf1082016-01-21 12:15:52 +00003106 }
3107
Andreas Gampe046c7062015-05-18 23:22:54 -07003108 // Print the complete line when any of the following is true:
3109 // 1) Debug build
3110 // 2) Compiling an image
3111 // 3) Compiling with --host
3112 // 4) Compiling on the host (not a target build)
3113 // Otherwise, print a stripped command line.
Roland Levillain5c7e2602016-02-23 18:08:53 +00003114 if (kIsDebugBuild || dex2oat->IsBootImage() || dex2oat->IsHost() || !kIsTargetBuild) {
Andreas Gampe046c7062015-05-18 23:22:54 -07003115 LOG(INFO) << CommandLine();
3116 } else {
3117 LOG(INFO) << StrippedCommandLine();
3118 }
Andreas Gampe88ec7f42014-11-05 10:18:32 -08003119
Andreas Gampef7882972017-03-20 16:35:24 -07003120 dex2oat::ReturnCode setup_code = dex2oat->Setup();
3121 if (setup_code != dex2oat::ReturnCode::kNoFailure) {
David Brazdil7b49e6c2016-09-01 11:06:18 +01003122 dex2oat->EraseOutputFiles();
Andreas Gampef7882972017-03-20 16:35:24 -07003123 return setup_code;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08003124 }
3125
Shubham Ajmera188b2bf2017-09-20 15:53:35 -07003126 // TODO: Due to the cyclic dependencies, profile loading and verifying are
3127 // being done separately. Refactor and place the two next to each other.
3128 // If verification fails, we don't abort the compilation and instead log an
3129 // error.
3130 // TODO(b/62602192, b/65260586): We should consider aborting compilation when
3131 // the profile verification fails.
3132 // Note: If dex2oat fails, installd will remove the oat files causing the app
3133 // to fallback to apk with possible in-memory extraction. We want to avoid
3134 // that, and thus we're lenient towards profile corruptions.
3135 if (dex2oat->UseProfile()) {
3136 dex2oat->VerifyProfileData();
3137 }
3138
Wojciech Staszkiewicz529827d2016-09-15 10:30:30 -07003139 // Helps debugging on device. Can be used to determine which dalvikvm instance invoked a dex2oat
3140 // instance. Used by tools/bisection_search/bisection_search.py.
Wojciech Staszkiewicz0a4c75f2016-09-13 12:06:36 -07003141 VLOG(compiler) << "Running dex2oat (parent PID = " << getppid() << ")";
3142
Andreas Gampe7b565912017-03-20 15:48:52 -07003143 dex2oat::ReturnCode result;
Roland Levillain5c7e2602016-02-23 18:08:53 +00003144 if (dex2oat->IsImage()) {
3145 result = CompileImage(*dex2oat);
Andreas Gampe10e477d2014-11-19 12:57:42 -08003146 } else {
Roland Levillain5c7e2602016-02-23 18:08:53 +00003147 result = CompileApp(*dex2oat);
Andreas Gampe88ec7f42014-11-05 10:18:32 -08003148 }
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003149
Mathieu Chartier673ed3d2015-08-28 14:56:43 -07003150 return result;
Andreas Gampe88ec7f42014-11-05 10:18:32 -08003151}
Brian Carlstrom7934ac22013-07-26 10:54:15 -07003152} // namespace art
Brian Carlstrom7940e442013-07-12 13:46:57 -07003153
3154int main(int argc, char** argv) {
Andreas Gampe7b565912017-03-20 15:48:52 -07003155 int result = static_cast<int>(art::Dex2oat(argc, argv));
Andreas Gampe88ec7f42014-11-05 10:18:32 -08003156 // Everything was done, do an explicit exit here to avoid running Runtime destructors that take
3157 // time (bug 10645725) unless we're a debug build or running on valgrind. Note: The Dex2Oat class
3158 // should not destruct the runtime in this case.
Evgenii Stepanov1e133742015-05-20 12:30:59 -07003159 if (!art::kIsDebugBuild && (RUNNING_ON_MEMORY_TOOL == 0)) {
Andreas Gampee286b642017-04-13 12:20:42 -07003160 _exit(result);
Andreas Gampe88ec7f42014-11-05 10:18:32 -08003161 }
3162 return result;
Brian Carlstrom7940e442013-07-12 13:46:57 -07003163}