blob: 72effded06a8f6e66dac466b52a4f93164ba5f92 [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
17#include <stdio.h>
18#include <stdlib.h>
19#include <sys/stat.h>
Ian Rogers2672a9f2013-09-05 17:24:22 -070020#include <valgrind.h>
Brian Carlstrom7940e442013-07-12 13:46:57 -070021
22#include <fstream>
23#include <iostream>
24#include <sstream>
25#include <string>
26#include <vector>
27
28#include "base/stl_util.h"
29#include "base/stringpiece.h"
30#include "base/timing_logger.h"
31#include "base/unix_file/fd_file.h"
32#include "class_linker.h"
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +000033#include "compiler.h"
Vladimir Marko2b5eaa22013-12-13 13:59:30 +000034#include "compiler_callbacks.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070035#include "dex_file-inl.h"
Chao-ying Fucd8ce662014-03-11 14:57:19 -070036#include "dex/pass_driver.h"
Vladimir Markoc7f83202014-01-24 17:55:18 +000037#include "dex/verification_results.h"
Brian Carlstrom6449c622014-02-10 23:48:36 -080038#include "driver/compiler_callbacks_impl.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070039#include "driver/compiler_driver.h"
Brian Carlstrom6449c622014-02-10 23:48:36 -080040#include "driver/compiler_options.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070041#include "elf_fixup.h"
42#include "elf_stripper.h"
43#include "gc/space/image_space.h"
44#include "gc/space/space-inl.h"
45#include "image_writer.h"
46#include "leb128.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070047#include "mirror/art_method-inl.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070048#include "mirror/class-inl.h"
49#include "mirror/class_loader.h"
50#include "mirror/object-inl.h"
51#include "mirror/object_array-inl.h"
52#include "oat_writer.h"
53#include "object_utils.h"
54#include "os.h"
55#include "runtime.h"
56#include "ScopedLocalRef.h"
57#include "scoped_thread_state_change.h"
Brian Carlstrom7940e442013-07-12 13:46:57 -070058#include "vector_output_stream.h"
59#include "well_known_classes.h"
60#include "zip_archive.h"
61
62namespace art {
63
Brian Carlstrom6449c622014-02-10 23:48:36 -080064static int original_argc;
65static char** original_argv;
66
67static std::string CommandLine() {
68 std::vector<std::string> command;
69 for (int i = 0; i < original_argc; ++i) {
70 command.push_back(original_argv[i]);
71 }
72 return Join(command, ' ');
73}
74
Brian Carlstrom7940e442013-07-12 13:46:57 -070075static void UsageErrorV(const char* fmt, va_list ap) {
76 std::string error;
77 StringAppendV(&error, fmt, ap);
78 LOG(ERROR) << error;
79}
80
81static void UsageError(const char* fmt, ...) {
82 va_list ap;
83 va_start(ap, fmt);
84 UsageErrorV(fmt, ap);
85 va_end(ap);
86}
87
88static void Usage(const char* fmt, ...) {
89 va_list ap;
90 va_start(ap, fmt);
91 UsageErrorV(fmt, ap);
92 va_end(ap);
93
Brian Carlstrom6449c622014-02-10 23:48:36 -080094 UsageError("Command: %s", CommandLine().c_str());
95
Brian Carlstrom7940e442013-07-12 13:46:57 -070096 UsageError("Usage: dex2oat [options]...");
97 UsageError("");
98 UsageError(" --dex-file=<dex-file>: specifies a .dex file to compile.");
99 UsageError(" Example: --dex-file=/system/framework/core.jar");
100 UsageError("");
101 UsageError(" --zip-fd=<file-descriptor>: specifies a file descriptor of a zip file");
102 UsageError(" containing a classes.dex file to compile.");
103 UsageError(" Example: --zip-fd=5");
104 UsageError("");
Brian Carlstrom45602482013-07-21 22:07:55 -0700105 UsageError(" --zip-location=<zip-location>: specifies a symbolic name for the file");
106 UsageError(" corresponding to the file descriptor specified by --zip-fd.");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700107 UsageError(" Example: --zip-location=/system/app/Calculator.apk");
108 UsageError("");
109 UsageError(" --oat-file=<file.oat>: specifies the oat output destination via a filename.");
110 UsageError(" Example: --oat-file=/system/framework/boot.oat");
111 UsageError("");
112 UsageError(" --oat-fd=<number>: specifies the oat output destination via a file descriptor.");
113 UsageError(" Example: --oat-file=/system/framework/boot.oat");
114 UsageError("");
115 UsageError(" --oat-location=<oat-name>: specifies a symbolic name for the file corresponding");
116 UsageError(" to the file descriptor specified by --oat-fd.");
117 UsageError(" Example: --oat-location=/data/dalvik-cache/system@app@Calculator.apk.oat");
118 UsageError("");
119 UsageError(" --oat-symbols=<file.oat>: specifies the oat output destination with full symbols.");
120 UsageError(" Example: --oat-symbols=/symbols/system/framework/boot.oat");
121 UsageError("");
122 UsageError(" --bitcode=<file.bc>: specifies the optional bitcode filename.");
123 UsageError(" Example: --bitcode=/system/framework/boot.bc");
124 UsageError("");
125 UsageError(" --image=<file.art>: specifies the output image filename.");
126 UsageError(" Example: --image=/system/framework/boot.art");
127 UsageError("");
128 UsageError(" --image-classes=<classname-file>: specifies classes to include in an image.");
129 UsageError(" Example: --image=frameworks/base/preloaded-classes");
130 UsageError("");
131 UsageError(" --base=<hex-address>: specifies the base address when creating a boot image.");
132 UsageError(" Example: --base=0x50000000");
133 UsageError("");
134 UsageError(" --boot-image=<file.art>: provide the image file for the boot class path.");
135 UsageError(" Example: --boot-image=/system/framework/boot.art");
Nicolas Geoffray9583fbc2014-02-28 15:21:07 +0000136 UsageError(" Default: $ANDROID_ROOT/system/framework/boot.art");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700137 UsageError("");
138 UsageError(" --android-root=<path>: used to locate libraries for portable linking.");
139 UsageError(" Example: --android-root=out/host/linux-x86");
140 UsageError(" Default: $ANDROID_ROOT");
141 UsageError("");
Ian Rogersbefbd572014-03-06 01:13:39 -0800142 UsageError(" --instruction-set=(arm|mips|x86|x86_64): compile for a particular instruction");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700143 UsageError(" set.");
144 UsageError(" Example: --instruction-set=x86");
145 UsageError(" Default: arm");
146 UsageError("");
Dave Allison70202782013-10-22 17:52:19 -0700147 UsageError(" --instruction-set-features=...,: Specify instruction set features");
148 UsageError(" Example: --instruction-set-features=div");
149 UsageError(" Default: default");
150 UsageError("");
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000151 UsageError(" --compiler-backend=(Quick|Optimizing|Portable): select compiler backend");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700152 UsageError(" set.");
Brian Carlstrom635733d2013-10-30 23:19:31 -0700153 UsageError(" Example: --compiler-backend=Portable");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700154 UsageError(" Default: Quick");
155 UsageError("");
Brian Carlstrom6449c622014-02-10 23:48:36 -0800156 UsageError(" --compiler-filter=(interpret-only|space|balanced|speed|everything): select");
157 UsageError(" compiler filter.");
158 UsageError(" Example: --compiler-filter=everything");
159#if ART_SMALL_MODE
160 UsageError(" Default: interpret-only");
161#else
162 UsageError(" Default: speed");
163#endif
164 UsageError("");
165 UsageError(" --huge-method-max=<method-instruction-count>: the threshold size for a huge");
166 UsageError(" method for compiler filter tuning.");
167 UsageError(" Example: --huge-method-max=%d", CompilerOptions::kDefaultHugeMethodThreshold);
168 UsageError(" Default: %d", CompilerOptions::kDefaultHugeMethodThreshold);
169 UsageError("");
170 UsageError(" --huge-method-max=<method-instruction-count>: threshold size for a huge");
171 UsageError(" method for compiler filter tuning.");
172 UsageError(" Example: --huge-method-max=%d", CompilerOptions::kDefaultHugeMethodThreshold);
173 UsageError(" Default: %d", CompilerOptions::kDefaultHugeMethodThreshold);
174 UsageError("");
175 UsageError(" --large-method-max=<method-instruction-count>: threshold size for a large");
176 UsageError(" method for compiler filter tuning.");
177 UsageError(" Example: --large-method-max=%d", CompilerOptions::kDefaultLargeMethodThreshold);
178 UsageError(" Default: %d", CompilerOptions::kDefaultLargeMethodThreshold);
179 UsageError("");
180 UsageError(" --small-method-max=<method-instruction-count>: threshold size for a small");
181 UsageError(" method for compiler filter tuning.");
182 UsageError(" Example: --small-method-max=%d", CompilerOptions::kDefaultSmallMethodThreshold);
183 UsageError(" Default: %d", CompilerOptions::kDefaultSmallMethodThreshold);
184 UsageError("");
185 UsageError(" --tiny-method-max=<method-instruction-count>: threshold size for a tiny");
186 UsageError(" method for compiler filter tuning.");
187 UsageError(" Example: --tiny-method-max=%d", CompilerOptions::kDefaultTinyMethodThreshold);
188 UsageError(" Default: %d", CompilerOptions::kDefaultTinyMethodThreshold);
189 UsageError("");
190 UsageError(" --num-dex-methods=<method-count>: threshold size for a small dex file for");
191 UsageError(" compiler filter tuning. If the input has fewer than this many methods");
192 UsageError(" and the filter is not interpret-only, overrides the filter to use speed");
193 UsageError(" Example: --num-dex-method=%d", CompilerOptions::kDefaultNumDexMethodsThreshold);
194 UsageError(" Default: %d", CompilerOptions::kDefaultNumDexMethodsThreshold);
195 UsageError("");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700196 UsageError(" --host: used with Portable backend to link against host runtime libraries");
197 UsageError("");
Ian Rogers46398602013-08-20 07:50:36 -0700198 UsageError(" --dump-timing: display a breakdown of where time was spent");
199 UsageError("");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700200 UsageError(" --runtime-arg <argument>: used to specify various arguments for the runtime,");
201 UsageError(" such as initial heap size, maximum heap size, and verbose output.");
202 UsageError(" Use a separate --runtime-arg switch for each argument.");
203 UsageError(" Example: --runtime-arg -Xms256m");
Dave Allison39c3bfb2014-01-28 18:33:52 -0800204 UsageError("");
205 UsageError(" --profile-file=<filename>: specify profiler output file to use for compilation.");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700206 UsageError("");
Chao-ying Fucd8ce662014-03-11 14:57:19 -0700207 UsageError(" --print-pass-names: print a list of pass names");
208 UsageError("");
209 UsageError(" --disable-passes=<pass-names>: disable one or more passes separated by comma.");
210 UsageError(" Example: --disable-passes=UseCount,BBOptimizations");
211 UsageError("");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700212 std::cerr << "See log for usage error information\n";
213 exit(EXIT_FAILURE);
214}
215
216class Dex2Oat {
217 public:
Brian Carlstrom45602482013-07-21 22:07:55 -0700218 static bool Create(Dex2Oat** p_dex2oat,
Brian Carlstrom6449c622014-02-10 23:48:36 -0800219 const Runtime::Options& runtime_options,
220 const CompilerOptions& compiler_options,
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000221 Compiler::Kind compiler_kind,
Brian Carlstrom45602482013-07-21 22:07:55 -0700222 InstructionSet instruction_set,
Dave Allison70202782013-10-22 17:52:19 -0700223 InstructionSetFeatures instruction_set_features,
Brian Carlstrom6449c622014-02-10 23:48:36 -0800224 VerificationResults* verification_results,
225 DexFileToMethodInlinerMap* method_inliner_map,
Brian Carlstrom45602482013-07-21 22:07:55 -0700226 size_t thread_count)
Brian Carlstrom7940e442013-07-12 13:46:57 -0700227 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_) {
Brian Carlstrom6449c622014-02-10 23:48:36 -0800228 CHECK(verification_results != nullptr);
229 CHECK(method_inliner_map != nullptr);
230 UniquePtr<Dex2Oat> dex2oat(new Dex2Oat(&compiler_options,
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000231 compiler_kind,
Brian Carlstrom6449c622014-02-10 23:48:36 -0800232 instruction_set,
233 instruction_set_features,
234 verification_results,
235 method_inliner_map,
236 thread_count));
237 if (!dex2oat->CreateRuntime(runtime_options, instruction_set)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700238 *p_dex2oat = NULL;
239 return false;
240 }
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000241 *p_dex2oat = dex2oat.release();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700242 return true;
243 }
244
245 ~Dex2Oat() {
246 delete runtime_;
Brian Carlstrom65c23bb2014-02-01 22:12:39 -0800247 LogCompletionTime();
248 }
249
250 void LogCompletionTime() {
251 LOG(INFO) << "dex2oat took " << PrettyDuration(NanoTime() - start_ns_)
Brian Carlstrom45602482013-07-21 22:07:55 -0700252 << " (threads: " << thread_count_ << ")";
Brian Carlstrom7940e442013-07-12 13:46:57 -0700253 }
254
255
Brian Carlstrom45602482013-07-21 22:07:55 -0700256 // Reads the class names (java.lang.Object) and returns a set of descriptors (Ljava/lang/Object;)
Brian Carlstrom7940e442013-07-12 13:46:57 -0700257 CompilerDriver::DescriptorSet* ReadImageClassesFromFile(const char* image_classes_filename) {
Brian Carlstrom45602482013-07-21 22:07:55 -0700258 UniquePtr<std::ifstream> image_classes_file(new std::ifstream(image_classes_filename,
259 std::ifstream::in));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700260 if (image_classes_file.get() == NULL) {
261 LOG(ERROR) << "Failed to open image classes file " << image_classes_filename;
262 return NULL;
263 }
264 UniquePtr<CompilerDriver::DescriptorSet> result(ReadImageClasses(*image_classes_file.get()));
265 image_classes_file->close();
266 return result.release();
267 }
268
269 CompilerDriver::DescriptorSet* ReadImageClasses(std::istream& image_classes_stream) {
270 UniquePtr<CompilerDriver::DescriptorSet> image_classes(new CompilerDriver::DescriptorSet);
271 while (image_classes_stream.good()) {
272 std::string dot;
273 std::getline(image_classes_stream, dot);
274 if (StartsWith(dot, "#") || dot.empty()) {
275 continue;
276 }
277 std::string descriptor(DotToDescriptor(dot.c_str()));
278 image_classes->insert(descriptor);
279 }
280 return image_classes.release();
281 }
282
Brian Carlstrom45602482013-07-21 22:07:55 -0700283 // Reads the class names (java.lang.Object) and returns a set of descriptors (Ljava/lang/Object;)
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700284 CompilerDriver::DescriptorSet* ReadImageClassesFromZip(const char* zip_filename,
285 const char* image_classes_filename,
286 std::string* error_msg) {
287 UniquePtr<ZipArchive> zip_archive(ZipArchive::Open(zip_filename, error_msg));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700288 if (zip_archive.get() == NULL) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700289 return NULL;
290 }
Narayan Kamath92572be2013-11-28 14:06:24 +0000291 UniquePtr<ZipEntry> zip_entry(zip_archive->Find(image_classes_filename, error_msg));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700292 if (zip_entry.get() == NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700293 *error_msg = StringPrintf("Failed to find '%s' within '%s': %s", image_classes_filename,
294 zip_filename, error_msg->c_str());
Brian Carlstrom7940e442013-07-12 13:46:57 -0700295 return NULL;
296 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700297 UniquePtr<MemMap> image_classes_file(zip_entry->ExtractToMemMap(image_classes_filename,
298 error_msg));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700299 if (image_classes_file.get() == NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700300 *error_msg = StringPrintf("Failed to extract '%s' from '%s': %s", image_classes_filename,
301 zip_filename, error_msg->c_str());
Brian Carlstrom7940e442013-07-12 13:46:57 -0700302 return NULL;
303 }
304 const std::string image_classes_string(reinterpret_cast<char*>(image_classes_file->Begin()),
305 image_classes_file->Size());
306 std::istringstream image_classes_stream(image_classes_string);
307 return ReadImageClasses(image_classes_stream);
308 }
309
310 const CompilerDriver* CreateOatFile(const std::string& boot_image_option,
Brian Carlstrom7940e442013-07-12 13:46:57 -0700311 const std::string& android_root,
312 bool is_host,
313 const std::vector<const DexFile*>& dex_files,
314 File* oat_file,
315 const std::string& bitcode_filename,
316 bool image,
317 UniquePtr<CompilerDriver::DescriptorSet>& image_classes,
318 bool dump_stats,
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000319 bool dump_passes,
320 TimingLogger& timings,
Dave Allison39c3bfb2014-01-28 18:33:52 -0800321 CumulativeLogger& compiler_phases_timings,
322 std::string profile_file) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700323 // SirtRef and ClassLoader creation needs to come after Runtime::Create
324 jobject class_loader = NULL;
Ian Rogers3f3d22c2013-08-27 18:11:09 -0700325 Thread* self = Thread::Current();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700326 if (!boot_image_option.empty()) {
327 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
328 std::vector<const DexFile*> class_path_files(dex_files);
329 OpenClassPathFiles(runtime_->GetClassPathString(), class_path_files);
Ian Rogers3f3d22c2013-08-27 18:11:09 -0700330 ScopedObjectAccess soa(self);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700331 for (size_t i = 0; i < class_path_files.size(); i++) {
332 class_linker->RegisterDexFile(*class_path_files[i]);
333 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700334 soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader);
335 ScopedLocalRef<jobject> class_loader_local(soa.Env(),
336 soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader));
337 class_loader = soa.Env()->NewGlobalRef(class_loader_local.get());
338 Runtime::Current()->SetCompileTimeClassPath(class_loader, class_path_files);
339 }
340
Brian Carlstrom6449c622014-02-10 23:48:36 -0800341 UniquePtr<CompilerDriver> driver(new CompilerDriver(compiler_options_,
342 verification_results_,
343 method_inliner_map_,
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000344 compiler_kind_,
Brian Carlstrom7940e442013-07-12 13:46:57 -0700345 instruction_set_,
Dave Allison70202782013-10-22 17:52:19 -0700346 instruction_set_features_,
Brian Carlstrom7940e442013-07-12 13:46:57 -0700347 image,
348 image_classes.release(),
349 thread_count_,
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000350 dump_stats,
351 dump_passes,
Dave Allison39c3bfb2014-01-28 18:33:52 -0800352 &compiler_phases_timings,
353 profile_file));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700354
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000355 driver->GetCompiler()->SetBitcodeFileName(*driver.get(), bitcode_filename);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700356
Ian Rogers3d504072014-03-01 09:16:49 -0800357 driver->CompileAll(class_loader, dex_files, &timings);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700358
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700359 timings.NewSplit("dex2oat OatWriter");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700360 std::string image_file_location;
361 uint32_t image_file_location_oat_checksum = 0;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800362 uintptr_t image_file_location_oat_data_begin = 0;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700363 if (!driver->IsImage()) {
Ian Rogersca368cb2013-11-15 15:52:08 -0800364 TimingLogger::ScopedSplit split("Loading image checksum", &timings);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700365 gc::space::ImageSpace* image_space = Runtime::Current()->GetHeap()->GetImageSpace();
366 image_file_location_oat_checksum = image_space->GetImageHeader().GetOatChecksum();
367 image_file_location_oat_data_begin =
Ian Rogersef7d42f2014-01-06 12:55:46 -0800368 reinterpret_cast<uintptr_t>(image_space->GetImageHeader().GetOatDataBegin());
Brian Carlstrom7940e442013-07-12 13:46:57 -0700369 image_file_location = image_space->GetImageFilename();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700370 }
371
Brian Carlstromc50d8e12013-07-23 22:35:16 -0700372 OatWriter oat_writer(dex_files,
373 image_file_location_oat_checksum,
374 image_file_location_oat_data_begin,
375 image_file_location,
Ian Rogersca368cb2013-11-15 15:52:08 -0800376 driver.get(),
377 &timings);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700378
Ian Rogersca368cb2013-11-15 15:52:08 -0800379 TimingLogger::ScopedSplit split("Writing ELF", &timings);
Ian Rogers3d504072014-03-01 09:16:49 -0800380 if (!driver->WriteElf(android_root, is_host, dex_files, &oat_writer, oat_file)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700381 LOG(ERROR) << "Failed to write ELF file " << oat_file->GetPath();
382 return NULL;
383 }
384
385 return driver.release();
386 }
387
388 bool CreateImageFile(const std::string& image_filename,
389 uintptr_t image_base,
390 const std::string& oat_filename,
391 const std::string& oat_location,
392 const CompilerDriver& compiler)
393 LOCKS_EXCLUDED(Locks::mutator_lock_) {
394 uintptr_t oat_data_begin;
395 {
396 // ImageWriter is scoped so it can free memory before doing FixupElf
397 ImageWriter image_writer(compiler);
398 if (!image_writer.Write(image_filename, image_base, oat_filename, oat_location)) {
399 LOG(ERROR) << "Failed to create image file " << image_filename;
400 return false;
401 }
402 oat_data_begin = image_writer.GetOatDataBegin();
403 }
404
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700405 UniquePtr<File> oat_file(OS::OpenFileReadWrite(oat_filename.c_str()));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700406 if (oat_file.get() == NULL) {
407 PLOG(ERROR) << "Failed to open ELF file: " << oat_filename;
408 return false;
409 }
410 if (!ElfFixup::Fixup(oat_file.get(), oat_data_begin)) {
411 LOG(ERROR) << "Failed to fixup ELF file " << oat_file->GetPath();
412 return false;
413 }
414 return true;
415 }
416
417 private:
Brian Carlstrom6449c622014-02-10 23:48:36 -0800418 explicit Dex2Oat(const CompilerOptions* compiler_options,
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000419 Compiler::Kind compiler_kind,
Brian Carlstrom45602482013-07-21 22:07:55 -0700420 InstructionSet instruction_set,
Dave Allison70202782013-10-22 17:52:19 -0700421 InstructionSetFeatures instruction_set_features,
Brian Carlstrom6449c622014-02-10 23:48:36 -0800422 VerificationResults* verification_results,
423 DexFileToMethodInlinerMap* method_inliner_map,
Brian Carlstrom0177fe22013-07-21 12:21:36 -0700424 size_t thread_count)
Brian Carlstrom6449c622014-02-10 23:48:36 -0800425 : compiler_options_(compiler_options),
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000426 compiler_kind_(compiler_kind),
Brian Carlstrom7940e442013-07-12 13:46:57 -0700427 instruction_set_(instruction_set),
Dave Allison70202782013-10-22 17:52:19 -0700428 instruction_set_features_(instruction_set_features),
Brian Carlstrom6449c622014-02-10 23:48:36 -0800429 verification_results_(verification_results),
430 method_inliner_map_(method_inliner_map),
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000431 runtime_(nullptr),
Brian Carlstrom7940e442013-07-12 13:46:57 -0700432 thread_count_(thread_count),
Brian Carlstrom7940e442013-07-12 13:46:57 -0700433 start_ns_(NanoTime()) {
Brian Carlstrom6449c622014-02-10 23:48:36 -0800434 CHECK(compiler_options != nullptr);
435 CHECK(verification_results != nullptr);
436 CHECK(method_inliner_map != nullptr);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700437 }
438
Brian Carlstrom6449c622014-02-10 23:48:36 -0800439 bool CreateRuntime(const Runtime::Options& runtime_options, InstructionSet instruction_set)
Brian Carlstrom7940e442013-07-12 13:46:57 -0700440 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_) {
Brian Carlstrom6449c622014-02-10 23:48:36 -0800441 if (!Runtime::Create(runtime_options, false)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700442 LOG(ERROR) << "Failed to create runtime";
443 return false;
444 }
445 Runtime* runtime = Runtime::Current();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700446 for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
447 Runtime::CalleeSaveType type = Runtime::CalleeSaveType(i);
448 if (!runtime->HasCalleeSaveMethod(type)) {
449 runtime->SetCalleeSaveMethod(runtime->CreateCalleeSaveMethod(instruction_set, type), type);
450 }
451 }
452 runtime->GetClassLinker()->FixupDexCaches(runtime->GetResolutionMethod());
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000453 runtime_ = runtime;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700454 return true;
455 }
456
457 // Appends to dex_files any elements of class_path that it doesn't already
458 // contain. This will open those dex files as necessary.
Brian Carlstrom45602482013-07-21 22:07:55 -0700459 static void OpenClassPathFiles(const std::string& class_path,
460 std::vector<const DexFile*>& dex_files) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700461 std::vector<std::string> parsed;
462 Split(class_path, ':', parsed);
463 // Take Locks::mutator_lock_ so that lock ordering on the ClassLinker::dex_lock_ is maintained.
464 ScopedObjectAccess soa(Thread::Current());
465 for (size_t i = 0; i < parsed.size(); ++i) {
466 if (DexFilesContains(dex_files, parsed[i])) {
467 continue;
468 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700469 std::string error_msg;
470 const DexFile* dex_file = DexFile::Open(parsed[i].c_str(), parsed[i].c_str(), &error_msg);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700471 if (dex_file == NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700472 LOG(WARNING) << "Failed to open dex file '" << parsed[i] << "': " << error_msg;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700473 } else {
474 dex_files.push_back(dex_file);
475 }
476 }
477 }
478
479 // Returns true if dex_files has a dex with the named location.
Brian Carlstrom45602482013-07-21 22:07:55 -0700480 static bool DexFilesContains(const std::vector<const DexFile*>& dex_files,
481 const std::string& location) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700482 for (size_t i = 0; i < dex_files.size(); ++i) {
483 if (dex_files[i]->GetLocation() == location) {
484 return true;
485 }
486 }
487 return false;
488 }
489
Brian Carlstromae7083d2014-02-24 21:56:02 -0800490 const CompilerOptions* const compiler_options_;
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000491 const Compiler::Kind compiler_kind_;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700492
493 const InstructionSet instruction_set_;
Dave Allison70202782013-10-22 17:52:19 -0700494 const InstructionSetFeatures instruction_set_features_;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700495
Brian Carlstromae7083d2014-02-24 21:56:02 -0800496 VerificationResults* const verification_results_;
497 DexFileToMethodInlinerMap* const method_inliner_map_;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700498 Runtime* runtime_;
499 size_t thread_count_;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700500 uint64_t start_ns_;
501
502 DISALLOW_IMPLICIT_CONSTRUCTORS(Dex2Oat);
503};
504
505static bool ParseInt(const char* in, int* out) {
506 char* end;
507 int result = strtol(in, &end, 10);
508 if (in == end || *end != '\0') {
509 return false;
510 }
511 *out = result;
512 return true;
513}
514
Brian Carlstrom3cf59d52013-11-10 21:04:10 -0800515static size_t OpenDexFiles(const std::vector<const char*>& dex_filenames,
516 const std::vector<const char*>& dex_locations,
517 std::vector<const DexFile*>& dex_files) {
518 size_t failure_count = 0;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700519 for (size_t i = 0; i < dex_filenames.size(); i++) {
520 const char* dex_filename = dex_filenames[i];
521 const char* dex_location = dex_locations[i];
Ian Rogers740a11d2014-01-14 10:11:25 -0800522 ATRACE_BEGIN(StringPrintf("Opening dex file '%s'", dex_filenames[i]).c_str());
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700523 std::string error_msg;
Brian Carlstromd5aba592013-11-12 01:52:44 -0800524 if (!OS::FileExists(dex_filename)) {
525 LOG(WARNING) << "Skipping non-existent dex file '" << dex_filename << "'";
526 continue;
527 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700528 const DexFile* dex_file = DexFile::Open(dex_filename, dex_location, &error_msg);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700529 if (dex_file == NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700530 LOG(WARNING) << "Failed to open .dex from file '" << dex_filename << "': " << error_msg;
Brian Carlstrom3cf59d52013-11-10 21:04:10 -0800531 ++failure_count;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700532 } else {
533 dex_files.push_back(dex_file);
534 }
Ian Rogers740a11d2014-01-14 10:11:25 -0800535 ATRACE_END();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700536 }
Brian Carlstrom3cf59d52013-11-10 21:04:10 -0800537 return failure_count;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700538}
539
540// The primary goal of the watchdog is to prevent stuck build servers
541// during development when fatal aborts lead to a cascade of failures
542// that result in a deadlock.
543class WatchDog {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700544// WatchDog defines its own CHECK_PTHREAD_CALL to avoid using Log which uses locks
545#undef CHECK_PTHREAD_CALL
546#define CHECK_WATCH_DOG_PTHREAD_CALL(call, args, what) \
547 do { \
548 int rc = call args; \
549 if (rc != 0) { \
550 errno = rc; \
551 std::string message(# call); \
552 message += " failed for "; \
553 message += reason; \
554 Fatal(message); \
555 } \
556 } while (false)
557
558 public:
Brian Carlstrom93ba8932013-07-17 21:31:49 -0700559 explicit WatchDog(bool is_watch_dog_enabled) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700560 is_watch_dog_enabled_ = is_watch_dog_enabled;
561 if (!is_watch_dog_enabled_) {
562 return;
563 }
564 shutting_down_ = false;
565 const char* reason = "dex2oat watch dog thread startup";
566 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_init, (&mutex_, NULL), reason);
567 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_cond_init, (&cond_, NULL), reason);
568 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_attr_init, (&attr_), reason);
569 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_create, (&pthread_, &attr_, &CallBack, this), reason);
570 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_attr_destroy, (&attr_), reason);
571 }
572 ~WatchDog() {
573 if (!is_watch_dog_enabled_) {
574 return;
575 }
576 const char* reason = "dex2oat watch dog thread shutdown";
577 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_lock, (&mutex_), reason);
578 shutting_down_ = true;
579 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_cond_signal, (&cond_), reason);
580 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_unlock, (&mutex_), reason);
581
582 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_join, (pthread_, NULL), reason);
583
584 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_cond_destroy, (&cond_), reason);
585 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_destroy, (&mutex_), reason);
586 }
587
588 private:
589 static void* CallBack(void* arg) {
590 WatchDog* self = reinterpret_cast<WatchDog*>(arg);
591 ::art::SetThreadName("dex2oat watch dog");
592 self->Wait();
593 return NULL;
594 }
595
596 static void Message(char severity, const std::string& message) {
597 // TODO: Remove when we switch to LOG when we can guarantee it won't prevent shutdown in error
598 // cases.
599 fprintf(stderr, "dex2oat%s %c %d %d %s\n",
600 kIsDebugBuild ? "d" : "",
601 severity,
602 getpid(),
603 GetTid(),
604 message.c_str());
605 }
606
607 static void Warn(const std::string& message) {
608 Message('W', message);
609 }
610
611 static void Fatal(const std::string& message) {
612 Message('F', message);
613 exit(1);
614 }
615
616 void Wait() {
617 bool warning = true;
618 CHECK_GT(kWatchDogTimeoutSeconds, kWatchDogWarningSeconds);
619 // TODO: tune the multiplier for GC verification, the following is just to make the timeout
620 // large.
Mathieu Chartier4e305412014-02-19 10:54:44 -0800621 int64_t multiplier = kVerifyObjectSupport > kVerifyObjectModeFast ? 100 : 1;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700622 timespec warning_ts;
623 InitTimeSpec(true, CLOCK_REALTIME, multiplier * kWatchDogWarningSeconds * 1000, 0, &warning_ts);
624 timespec timeout_ts;
625 InitTimeSpec(true, CLOCK_REALTIME, multiplier * kWatchDogTimeoutSeconds * 1000, 0, &timeout_ts);
626 const char* reason = "dex2oat watch dog thread waiting";
627 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_lock, (&mutex_), reason);
628 while (!shutting_down_) {
629 int rc = TEMP_FAILURE_RETRY(pthread_cond_timedwait(&cond_, &mutex_,
630 warning ? &warning_ts
631 : &timeout_ts));
632 if (rc == ETIMEDOUT) {
633 std::string message(StringPrintf("dex2oat did not finish after %d seconds",
634 warning ? kWatchDogWarningSeconds
635 : kWatchDogTimeoutSeconds));
636 if (warning) {
637 Warn(message.c_str());
638 warning = false;
639 } else {
640 Fatal(message.c_str());
641 }
642 } else if (rc != 0) {
643 std::string message(StringPrintf("pthread_cond_timedwait failed: %s",
644 strerror(errno)));
645 Fatal(message.c_str());
646 }
647 }
648 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_unlock, (&mutex_), reason);
649 }
650
651 // When setting timeouts, keep in mind that the build server may not be as fast as your desktop.
652#if ART_USE_PORTABLE_COMPILER
653 static const unsigned int kWatchDogWarningSeconds = 2 * 60; // 2 minutes.
654 static const unsigned int kWatchDogTimeoutSeconds = 30 * 60; // 25 minutes + buffer.
655#else
656 static const unsigned int kWatchDogWarningSeconds = 1 * 60; // 1 minute.
657 static const unsigned int kWatchDogTimeoutSeconds = 6 * 60; // 5 minutes + buffer.
658#endif
659
660 bool is_watch_dog_enabled_;
661 bool shutting_down_;
662 // TODO: Switch to Mutex when we can guarantee it won't prevent shutdown in error cases.
663 pthread_mutex_t mutex_;
664 pthread_cond_t cond_;
665 pthread_attr_t attr_;
666 pthread_t pthread_;
667};
668const unsigned int WatchDog::kWatchDogWarningSeconds;
669const unsigned int WatchDog::kWatchDogTimeoutSeconds;
670
Dave Allison70202782013-10-22 17:52:19 -0700671// Given a set of instruction features from the build, parse it. The
672// input 'str' is a comma separated list of feature names. Parse it and
673// return the InstructionSetFeatures object.
674static InstructionSetFeatures ParseFeatureList(std::string str) {
675 InstructionSetFeatures result;
676 typedef std::vector<std::string> FeatureList;
677 FeatureList features;
678 Split(str, ',', features);
679 for (FeatureList::iterator i = features.begin(); i != features.end(); i++) {
680 std::string feature = Trim(*i);
681 if (feature == "default") {
682 // Nothing to do.
683 } else if (feature == "div") {
684 // Supports divide instruction.
685 result.SetHasDivideInstruction(true);
686 } else if (feature == "nodiv") {
687 // Turn off support for divide instruction.
688 result.SetHasDivideInstruction(false);
689 } else {
690 Usage("Unknown instruction set feature: '%s'", feature.c_str());
691 }
692 }
693 // others...
694 return result;
695}
696
Brian Carlstrom7940e442013-07-12 13:46:57 -0700697static int dex2oat(int argc, char** argv) {
Brian Carlstrom6449c622014-02-10 23:48:36 -0800698 original_argc = argc;
699 original_argv = argv;
700
Ian Rogers5fe9af72013-11-14 00:17:20 -0800701 TimingLogger timings("compiler", false, false);
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000702 CumulativeLogger compiler_phases_timings("compilation times");
Brian Carlstrom45602482013-07-21 22:07:55 -0700703
Brian Carlstrom7940e442013-07-12 13:46:57 -0700704 InitLogging(argv);
705
706 // Skip over argv[0].
707 argv++;
708 argc--;
709
710 if (argc == 0) {
Brian Carlstrome0948e12013-08-29 09:36:15 -0700711 Usage("No arguments specified");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700712 }
713
714 std::vector<const char*> dex_filenames;
715 std::vector<const char*> dex_locations;
716 int zip_fd = -1;
717 std::string zip_location;
718 std::string oat_filename;
719 std::string oat_symbols;
720 std::string oat_location;
721 int oat_fd = -1;
722 std::string bitcode_filename;
723 const char* image_classes_zip_filename = NULL;
724 const char* image_classes_filename = NULL;
725 std::string image_filename;
726 std::string boot_image_filename;
727 uintptr_t image_base = 0;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700728 std::string android_root;
729 std::vector<const char*> runtime_args;
730 int thread_count = sysconf(_SC_NPROCESSORS_CONF);
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000731 Compiler::Kind compiler_kind = kUsePortableCompiler
732 ? Compiler::kPortable
733 : Compiler::kQuick;
Brian Carlstrom6449c622014-02-10 23:48:36 -0800734 const char* compiler_filter_string = NULL;
735 int huge_method_threshold = CompilerOptions::kDefaultHugeMethodThreshold;
736 int large_method_threshold = CompilerOptions::kDefaultLargeMethodThreshold;
737 int small_method_threshold = CompilerOptions::kDefaultSmallMethodThreshold;
738 int tiny_method_threshold = CompilerOptions::kDefaultTinyMethodThreshold;
739 int num_dex_methods_threshold = CompilerOptions::kDefaultNumDexMethodsThreshold;
Dave Allison70202782013-10-22 17:52:19 -0700740
Brian Carlstrom1bd2ceb2013-11-06 00:29:48 -0800741 // Take the default set of instruction features from the build.
Dave Allison70202782013-10-22 17:52:19 -0700742 InstructionSetFeatures instruction_set_features =
Brian Carlstrom1bd2ceb2013-11-06 00:29:48 -0800743 ParseFeatureList(STRINGIFY(ART_DEFAULT_INSTRUCTION_SET_FEATURES));
Dave Allison70202782013-10-22 17:52:19 -0700744
Brian Carlstrom7940e442013-07-12 13:46:57 -0700745#if defined(__arm__)
746 InstructionSet instruction_set = kThumb2;
Ian Rogersffb939a2014-03-12 11:51:02 -0700747#elif defined(__aarch64__)
748 InstructionSet instruction_set = kArm64;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700749#elif defined(__i386__)
750 InstructionSet instruction_set = kX86;
Ian Rogersffb939a2014-03-12 11:51:02 -0700751#elif defined(__x86_64__)
752 InstructionSet instruction_set = kX86_64;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700753#elif defined(__mips__)
754 InstructionSet instruction_set = kMips;
755#else
Ian Rogersef7d42f2014-01-06 12:55:46 -0800756 InstructionSet instruction_set = kNone;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700757#endif
Dave Allison70202782013-10-22 17:52:19 -0700758
Dave Allison39c3bfb2014-01-28 18:33:52 -0800759 // Profile file to use
760 std::string profile_file;
Dave Allison70202782013-10-22 17:52:19 -0700761
Brian Carlstrom7940e442013-07-12 13:46:57 -0700762 bool is_host = false;
Ian Rogerse732ef12013-10-09 15:22:24 -0700763 bool dump_stats = false;
Ian Rogers46398602013-08-20 07:50:36 -0700764 bool dump_timing = false;
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000765 bool dump_passes = false;
Ian Rogers46398602013-08-20 07:50:36 -0700766 bool dump_slow_timing = kIsDebugBuild;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700767 bool watch_dog_enabled = !kIsTargetBuild;
Mark Mendellae9fd932014-02-10 16:14:35 -0800768 bool generate_gdb_information = kIsDebugBuild;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700769
Brian Carlstrom7940e442013-07-12 13:46:57 -0700770 for (int i = 0; i < argc; i++) {
771 const StringPiece option(argv[i]);
772 bool log_options = false;
773 if (log_options) {
774 LOG(INFO) << "dex2oat: option[" << i << "]=" << argv[i];
775 }
776 if (option.starts_with("--dex-file=")) {
777 dex_filenames.push_back(option.substr(strlen("--dex-file=")).data());
778 } else if (option.starts_with("--dex-location=")) {
779 dex_locations.push_back(option.substr(strlen("--dex-location=")).data());
780 } else if (option.starts_with("--zip-fd=")) {
781 const char* zip_fd_str = option.substr(strlen("--zip-fd=")).data();
782 if (!ParseInt(zip_fd_str, &zip_fd)) {
Brian Carlstrome0948e12013-08-29 09:36:15 -0700783 Usage("Failed to parse --zip-fd argument '%s' as an integer", zip_fd_str);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700784 }
Brian Carlstrom6449c622014-02-10 23:48:36 -0800785 if (zip_fd < 0) {
786 Usage("--zip-fd passed a negative value %d", zip_fd);
787 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700788 } else if (option.starts_with("--zip-location=")) {
789 zip_location = option.substr(strlen("--zip-location=")).data();
790 } else if (option.starts_with("--oat-file=")) {
791 oat_filename = option.substr(strlen("--oat-file=")).data();
792 } else if (option.starts_with("--oat-symbols=")) {
793 oat_symbols = option.substr(strlen("--oat-symbols=")).data();
794 } else if (option.starts_with("--oat-fd=")) {
795 const char* oat_fd_str = option.substr(strlen("--oat-fd=")).data();
796 if (!ParseInt(oat_fd_str, &oat_fd)) {
Brian Carlstrome0948e12013-08-29 09:36:15 -0700797 Usage("Failed to parse --oat-fd argument '%s' as an integer", oat_fd_str);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700798 }
Brian Carlstrom6449c622014-02-10 23:48:36 -0800799 if (oat_fd < 0) {
800 Usage("--oat-fd passed a negative value %d", oat_fd);
801 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700802 } else if (option == "--watch-dog") {
803 watch_dog_enabled = true;
804 } else if (option == "--no-watch-dog") {
805 watch_dog_enabled = false;
Mark Mendellae9fd932014-02-10 16:14:35 -0800806 } else if (option == "--gen-gdb-info") {
807 generate_gdb_information = true;
808 } else if (option == "--no-gen-gdb-info") {
809 generate_gdb_information = false;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700810 } else if (option.starts_with("-j")) {
811 const char* thread_count_str = option.substr(strlen("-j")).data();
812 if (!ParseInt(thread_count_str, &thread_count)) {
Brian Carlstrome0948e12013-08-29 09:36:15 -0700813 Usage("Failed to parse -j argument '%s' as an integer", thread_count_str);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700814 }
815 } else if (option.starts_with("--oat-location=")) {
816 oat_location = option.substr(strlen("--oat-location=")).data();
817 } else if (option.starts_with("--bitcode=")) {
818 bitcode_filename = option.substr(strlen("--bitcode=")).data();
819 } else if (option.starts_with("--image=")) {
820 image_filename = option.substr(strlen("--image=")).data();
821 } else if (option.starts_with("--image-classes=")) {
822 image_classes_filename = option.substr(strlen("--image-classes=")).data();
823 } else if (option.starts_with("--image-classes-zip=")) {
824 image_classes_zip_filename = option.substr(strlen("--image-classes-zip=")).data();
825 } else if (option.starts_with("--base=")) {
826 const char* image_base_str = option.substr(strlen("--base=")).data();
827 char* end;
828 image_base = strtoul(image_base_str, &end, 16);
829 if (end == image_base_str || *end != '\0') {
830 Usage("Failed to parse hexadecimal value for option %s", option.data());
831 }
832 } else if (option.starts_with("--boot-image=")) {
833 boot_image_filename = option.substr(strlen("--boot-image=")).data();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700834 } else if (option.starts_with("--android-root=")) {
835 android_root = option.substr(strlen("--android-root=")).data();
836 } else if (option.starts_with("--instruction-set=")) {
837 StringPiece instruction_set_str = option.substr(strlen("--instruction-set=")).data();
838 if (instruction_set_str == "arm") {
839 instruction_set = kThumb2;
Stuart Monteithb95a5342014-03-12 13:32:32 +0000840 } else if (instruction_set_str == "arm64") {
841 instruction_set = kArm64;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700842 } else if (instruction_set_str == "mips") {
843 instruction_set = kMips;
844 } else if (instruction_set_str == "x86") {
845 instruction_set = kX86;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800846 } else if (instruction_set_str == "x86_64") {
847 instruction_set = kX86_64;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700848 }
Dave Allison70202782013-10-22 17:52:19 -0700849 } else if (option.starts_with("--instruction-set-features=")) {
850 StringPiece str = option.substr(strlen("--instruction-set-features=")).data();
851 instruction_set_features = ParseFeatureList(str.as_string());
Brian Carlstrom7940e442013-07-12 13:46:57 -0700852 } else if (option.starts_with("--compiler-backend=")) {
853 StringPiece backend_str = option.substr(strlen("--compiler-backend=")).data();
854 if (backend_str == "Quick") {
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000855 compiler_kind = Compiler::kQuick;
856 } else if (backend_str == "Optimizing") {
857 compiler_kind = Compiler::kOptimizing;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700858 } else if (backend_str == "Portable") {
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000859 compiler_kind = Compiler::kPortable;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700860 }
Brian Carlstrom6449c622014-02-10 23:48:36 -0800861 } else if (option.starts_with("--compiler-filter=")) {
862 compiler_filter_string = option.substr(strlen("--compiler-filter=")).data();
863 } else if (option.starts_with("--huge-method-max=")) {
864 const char* threshold = option.substr(strlen("--huge-method-max=")).data();
865 if (!ParseInt(threshold, &huge_method_threshold)) {
866 Usage("Failed to parse --huge-method-max '%s' as an integer", threshold);
867 }
868 if (huge_method_threshold < 0) {
869 Usage("--huge-method-max passed a negative value %s", huge_method_threshold);
870 }
871 } else if (option.starts_with("--large-method-max=")) {
872 const char* threshold = option.substr(strlen("--large-method-max=")).data();
873 if (!ParseInt(threshold, &large_method_threshold)) {
874 Usage("Failed to parse --large-method-max '%s' as an integer", threshold);
875 }
876 if (large_method_threshold < 0) {
877 Usage("--large-method-max passed a negative value %s", large_method_threshold);
878 }
879 } else if (option.starts_with("--small-method-max=")) {
880 const char* threshold = option.substr(strlen("--small-method-max=")).data();
881 if (!ParseInt(threshold, &small_method_threshold)) {
882 Usage("Failed to parse --small-method-max '%s' as an integer", threshold);
883 }
884 if (small_method_threshold < 0) {
885 Usage("--small-method-max passed a negative value %s", small_method_threshold);
886 }
887 } else if (option.starts_with("--tiny-method-max=")) {
888 const char* threshold = option.substr(strlen("--tiny-method-max=")).data();
889 if (!ParseInt(threshold, &tiny_method_threshold)) {
890 Usage("Failed to parse --tiny-method-max '%s' as an integer", threshold);
891 }
892 if (tiny_method_threshold < 0) {
893 Usage("--tiny-method-max passed a negative value %s", tiny_method_threshold);
894 }
895 } else if (option.starts_with("--num-dex-methods=")) {
896 const char* threshold = option.substr(strlen("--num-dex-methods=")).data();
897 if (!ParseInt(threshold, &num_dex_methods_threshold)) {
898 Usage("Failed to parse --num-dex-methods '%s' as an integer", threshold);
899 }
900 if (num_dex_methods_threshold < 0) {
901 Usage("--num-dex-methods passed a negative value %s", num_dex_methods_threshold);
902 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700903 } else if (option == "--host") {
904 is_host = true;
905 } else if (option == "--runtime-arg") {
906 if (++i >= argc) {
907 Usage("Missing required argument for --runtime-arg");
908 }
909 if (log_options) {
910 LOG(INFO) << "dex2oat: option[" << i << "]=" << argv[i];
911 }
912 runtime_args.push_back(argv[i]);
Ian Rogers46398602013-08-20 07:50:36 -0700913 } else if (option == "--dump-timing") {
914 dump_timing = true;
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000915 } else if (option == "--dump-passes") {
916 dump_passes = true;
Ian Rogerse732ef12013-10-09 15:22:24 -0700917 } else if (option == "--dump-stats") {
918 dump_stats = true;
Dave Allison39c3bfb2014-01-28 18:33:52 -0800919 } else if (option.starts_with("--profile-file=")) {
920 profile_file = option.substr(strlen("--profile-file=")).data();
921 VLOG(compiler) << "dex2oat: profile file is " << profile_file;
922 } else if (option == "--no-profile-file") {
923 LOG(INFO) << "dex2oat: no profile file supplied (explictly)";
924 // No profile
Chao-ying Fucd8ce662014-03-11 14:57:19 -0700925 } else if (option == "--print-pass-names") {
926 PassDriver::PrintPassNames();
927 } else if (option.starts_with("--disable-passes=")) {
928 std::string disable_passes = option.substr(strlen("--disable-passes=")).data();
929 PassDriver::CreateDefaultPassList(disable_passes);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700930 } else {
Brian Carlstrome0948e12013-08-29 09:36:15 -0700931 Usage("Unknown argument %s", option.data());
Brian Carlstrom7940e442013-07-12 13:46:57 -0700932 }
933 }
934
935 if (oat_filename.empty() && oat_fd == -1) {
936 Usage("Output must be supplied with either --oat-file or --oat-fd");
937 }
938
939 if (!oat_filename.empty() && oat_fd != -1) {
940 Usage("--oat-file should not be used with --oat-fd");
941 }
942
943 if (!oat_symbols.empty() && oat_fd != -1) {
944 Usage("--oat-symbols should not be used with --oat-fd");
945 }
946
947 if (!oat_symbols.empty() && is_host) {
948 Usage("--oat-symbols should not be used with --host");
949 }
950
951 if (oat_fd != -1 && !image_filename.empty()) {
952 Usage("--oat-fd should not be used with --image");
953 }
954
Brian Carlstrom7940e442013-07-12 13:46:57 -0700955 if (android_root.empty()) {
956 const char* android_root_env_var = getenv("ANDROID_ROOT");
957 if (android_root_env_var == NULL) {
958 Usage("--android-root unspecified and ANDROID_ROOT not set");
959 }
960 android_root += android_root_env_var;
961 }
962
963 bool image = (!image_filename.empty());
964 if (!image && boot_image_filename.empty()) {
Nicolas Geoffray9583fbc2014-02-28 15:21:07 +0000965 boot_image_filename += GetAndroidRoot();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700966 boot_image_filename += "/framework/boot.art";
967 }
968 std::string boot_image_option;
969 if (!boot_image_filename.empty()) {
970 boot_image_option += "-Ximage:";
971 boot_image_option += boot_image_filename;
972 }
973
974 if (image_classes_filename != NULL && !image) {
975 Usage("--image-classes should only be used with --image");
976 }
977
978 if (image_classes_filename != NULL && !boot_image_option.empty()) {
979 Usage("--image-classes should not be used with --boot-image");
980 }
981
982 if (image_classes_zip_filename != NULL && image_classes_filename == NULL) {
983 Usage("--image-classes-zip should be used with --image-classes");
984 }
985
986 if (dex_filenames.empty() && zip_fd == -1) {
987 Usage("Input must be supplied with either --dex-file or --zip-fd");
988 }
989
990 if (!dex_filenames.empty() && zip_fd != -1) {
991 Usage("--dex-file should not be used with --zip-fd");
992 }
993
994 if (!dex_filenames.empty() && !zip_location.empty()) {
995 Usage("--dex-file should not be used with --zip-location");
996 }
997
998 if (dex_locations.empty()) {
999 for (size_t i = 0; i < dex_filenames.size(); i++) {
1000 dex_locations.push_back(dex_filenames[i]);
1001 }
1002 } else if (dex_locations.size() != dex_filenames.size()) {
1003 Usage("--dex-location arguments do not match --dex-file arguments");
1004 }
1005
1006 if (zip_fd != -1 && zip_location.empty()) {
1007 Usage("--zip-location should be supplied with --zip-fd");
1008 }
1009
1010 if (boot_image_option.empty()) {
1011 if (image_base == 0) {
Brian Carlstrome0948e12013-08-29 09:36:15 -07001012 Usage("Non-zero --base not specified");
Brian Carlstrom7940e442013-07-12 13:46:57 -07001013 }
1014 }
1015
1016 std::string oat_stripped(oat_filename);
1017 std::string oat_unstripped;
1018 if (!oat_symbols.empty()) {
1019 oat_unstripped += oat_symbols;
1020 } else {
1021 oat_unstripped += oat_filename;
1022 }
1023
Brian Carlstrom6449c622014-02-10 23:48:36 -08001024 if (compiler_filter_string == NULL) {
Stuart Monteithb95a5342014-03-12 13:32:32 +00001025 if (instruction_set == kX86_64 || instruction_set == kArm64) {
1026 // TODO: currently x86-64 and arm64 are only interpreted.
Ian Rogersbefbd572014-03-06 01:13:39 -08001027 compiler_filter_string = "interpret-only";
1028 } else if (image) {
Brian Carlstrom5e754d82014-03-05 10:59:04 -08001029 compiler_filter_string = "speed";
Brian Carlstrom6449c622014-02-10 23:48:36 -08001030 } else {
1031#if ART_SMALL_MODE
1032 compiler_filter_string = "interpret-only";
1033#else
1034 compiler_filter_string = "speed";
1035#endif
1036 }
1037 }
1038 CHECK(compiler_filter_string != nullptr);
1039 CompilerOptions::CompilerFilter compiler_filter = CompilerOptions::kDefaultCompilerFilter;
1040 if (strcmp(compiler_filter_string, "interpret-only") == 0) {
1041 compiler_filter = CompilerOptions::kInterpretOnly;
1042 } else if (strcmp(compiler_filter_string, "space") == 0) {
1043 compiler_filter = CompilerOptions::kSpace;
1044 } else if (strcmp(compiler_filter_string, "balanced") == 0) {
1045 compiler_filter = CompilerOptions::kBalanced;
1046 } else if (strcmp(compiler_filter_string, "speed") == 0) {
1047 compiler_filter = CompilerOptions::kSpeed;
1048 } else if (strcmp(compiler_filter_string, "everything") == 0) {
1049 compiler_filter = CompilerOptions::kEverything;
1050 } else {
1051 Usage("Unknown --compiler-filter value %s", compiler_filter_string);
1052 }
1053
1054 CompilerOptions compiler_options(compiler_filter,
1055 huge_method_threshold,
1056 large_method_threshold,
1057 small_method_threshold,
1058 tiny_method_threshold,
Mark Mendellae9fd932014-02-10 16:14:35 -08001059 num_dex_methods_threshold,
1060 generate_gdb_information
Brian Carlstrom6449c622014-02-10 23:48:36 -08001061#ifdef ART_SEA_IR_MODE
1062 , compiler_options.sea_ir_ = true;
1063#endif
1064 ); // NOLINT(whitespace/parens)
1065
Brian Carlstrom7940e442013-07-12 13:46:57 -07001066 // Done with usage checks, enable watchdog if requested
1067 WatchDog watch_dog(watch_dog_enabled);
1068
1069 // Check early that the result of compilation can be written
1070 UniquePtr<File> oat_file;
1071 bool create_file = !oat_unstripped.empty(); // as opposed to using open file descriptor
1072 if (create_file) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -07001073 oat_file.reset(OS::CreateEmptyFile(oat_unstripped.c_str()));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001074 if (oat_location.empty()) {
1075 oat_location = oat_filename;
1076 }
1077 } else {
1078 oat_file.reset(new File(oat_fd, oat_location));
1079 oat_file->DisableAutoClose();
1080 }
1081 if (oat_file.get() == NULL) {
1082 PLOG(ERROR) << "Failed to create oat file: " << oat_location;
1083 return EXIT_FAILURE;
1084 }
1085 if (create_file && fchmod(oat_file->Fd(), 0644) != 0) {
1086 PLOG(ERROR) << "Failed to make oat file world readable: " << oat_location;
1087 return EXIT_FAILURE;
1088 }
1089
Ian Rogerse6bb3b22013-08-19 21:51:45 -07001090 timings.StartSplit("dex2oat Setup");
Brian Carlstrom6449c622014-02-10 23:48:36 -08001091 LOG(INFO) << "dex2oat: " << CommandLine();
Brian Carlstrom7940e442013-07-12 13:46:57 -07001092
Brian Carlstrom6449c622014-02-10 23:48:36 -08001093 Runtime::Options runtime_options;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001094 std::vector<const DexFile*> boot_class_path;
1095 if (boot_image_option.empty()) {
Brian Carlstrom3cf59d52013-11-10 21:04:10 -08001096 size_t failure_count = OpenDexFiles(dex_filenames, dex_locations, boot_class_path);
1097 if (failure_count > 0) {
1098 LOG(ERROR) << "Failed to open some dex files: " << failure_count;
1099 return EXIT_FAILURE;
1100 }
Brian Carlstrom6449c622014-02-10 23:48:36 -08001101 runtime_options.push_back(std::make_pair("bootclasspath", &boot_class_path));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001102 } else {
Brian Carlstrom6449c622014-02-10 23:48:36 -08001103 runtime_options.push_back(std::make_pair(boot_image_option.c_str(),
1104 reinterpret_cast<void*>(NULL)));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001105 }
Brian Carlstrom7940e442013-07-12 13:46:57 -07001106 for (size_t i = 0; i < runtime_args.size(); i++) {
Brian Carlstrom6449c622014-02-10 23:48:36 -08001107 runtime_options.push_back(std::make_pair(runtime_args[i], reinterpret_cast<void*>(NULL)));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001108 }
1109
Brian Carlstrom6449c622014-02-10 23:48:36 -08001110 VerificationResults verification_results(&compiler_options);
1111 DexFileToMethodInlinerMap method_inliner_map;
1112 CompilerCallbacksImpl callbacks(&verification_results, &method_inliner_map);
1113 runtime_options.push_back(std::make_pair("compilercallbacks", &callbacks));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001114
Brian Carlstrom7940e442013-07-12 13:46:57 -07001115 Dex2Oat* p_dex2oat;
Brian Carlstrom6449c622014-02-10 23:48:36 -08001116 if (!Dex2Oat::Create(&p_dex2oat,
1117 runtime_options,
1118 compiler_options,
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +00001119 compiler_kind,
Brian Carlstrom6449c622014-02-10 23:48:36 -08001120 instruction_set,
1121 instruction_set_features,
1122 &verification_results,
1123 &method_inliner_map,
1124 thread_count)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -07001125 LOG(ERROR) << "Failed to create dex2oat";
1126 return EXIT_FAILURE;
1127 }
1128 UniquePtr<Dex2Oat> dex2oat(p_dex2oat);
1129 // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start,
Ian Rogers3f3d22c2013-08-27 18:11:09 -07001130 // give it away now so that we don't starve GC.
1131 Thread* self = Thread::Current();
1132 self->TransitionFromRunnableToSuspended(kNative);
Ian Rogers0f40ac32013-08-13 22:10:30 -07001133 // If we're doing the image, override the compiler filter to force full compilation. Must be
buzbeefe9ca402013-08-21 09:48:11 -07001134 // done ahead of WellKnownClasses::Init that causes verification. Note: doesn't force
1135 // compilation of class initializers.
Brian Carlstrom7940e442013-07-12 13:46:57 -07001136 // Whilst we're in native take the opportunity to initialize well known classes.
Ian Rogers3f3d22c2013-08-27 18:11:09 -07001137 WellKnownClasses::Init(self->GetJniEnv());
Brian Carlstrom7940e442013-07-12 13:46:57 -07001138
1139 // If --image-classes was specified, calculate the full list of classes to include in the image
1140 UniquePtr<CompilerDriver::DescriptorSet> image_classes(NULL);
1141 if (image_classes_filename != NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001142 std::string error_msg;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001143 if (image_classes_zip_filename != NULL) {
1144 image_classes.reset(dex2oat->ReadImageClassesFromZip(image_classes_zip_filename,
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001145 image_classes_filename,
1146 &error_msg));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001147 } else {
1148 image_classes.reset(dex2oat->ReadImageClassesFromFile(image_classes_filename));
1149 }
1150 if (image_classes.get() == NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001151 LOG(ERROR) << "Failed to create list of image classes from '" << image_classes_filename <<
1152 "': " << error_msg;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001153 return EXIT_FAILURE;
1154 }
1155 }
1156
1157 std::vector<const DexFile*> dex_files;
1158 if (boot_image_option.empty()) {
1159 dex_files = Runtime::Current()->GetClassLinker()->GetBootClassPath();
1160 } else {
1161 if (dex_filenames.empty()) {
Ian Rogers740a11d2014-01-14 10:11:25 -08001162 ATRACE_BEGIN("Opening zip archive from file descriptor");
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001163 std::string error_msg;
1164 UniquePtr<ZipArchive> zip_archive(ZipArchive::OpenFromFd(zip_fd, zip_location.c_str(),
1165 &error_msg));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001166 if (zip_archive.get() == NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001167 LOG(ERROR) << "Failed to open zip from file descriptor for '" << zip_location << "': "
1168 << error_msg;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001169 return EXIT_FAILURE;
1170 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001171 const DexFile* dex_file = DexFile::Open(*zip_archive.get(), zip_location, &error_msg);
Brian Carlstrom7940e442013-07-12 13:46:57 -07001172 if (dex_file == NULL) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001173 LOG(ERROR) << "Failed to open dex from file descriptor for zip file '" << zip_location
1174 << "': " << error_msg;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001175 return EXIT_FAILURE;
1176 }
1177 dex_files.push_back(dex_file);
Ian Rogers740a11d2014-01-14 10:11:25 -08001178 ATRACE_END();
Brian Carlstrom7940e442013-07-12 13:46:57 -07001179 } else {
Brian Carlstrom3cf59d52013-11-10 21:04:10 -08001180 size_t failure_count = OpenDexFiles(dex_filenames, dex_locations, dex_files);
1181 if (failure_count > 0) {
1182 LOG(ERROR) << "Failed to open some dex files: " << failure_count;
1183 return EXIT_FAILURE;
1184 }
Brian Carlstrom7940e442013-07-12 13:46:57 -07001185 }
Brian Carlstromd76e0832013-08-29 15:17:42 -07001186
Brian Carlstromf79fccb2014-02-20 08:55:10 -08001187 const bool kSaveDexInput = false;
1188 if (kSaveDexInput) {
1189 for (size_t i = 0; i < dex_files.size(); ++i) {
1190 const DexFile* dex_file = dex_files[i];
Ian Rogers5180cc12014-02-21 13:34:16 -08001191 std::string tmp_file_name(StringPrintf("/data/local/tmp/dex2oat.%d.%zd.dex", getpid(), i));
Brian Carlstromf79fccb2014-02-20 08:55:10 -08001192 UniquePtr<File> tmp_file(OS::CreateEmptyFile(tmp_file_name.c_str()));
1193 if (tmp_file.get() == nullptr) {
Brian Carlstrom6449c622014-02-10 23:48:36 -08001194 PLOG(ERROR) << "Failed to open file " << tmp_file_name
1195 << ". Try: adb shell chmod 777 /data/local/tmp";
Brian Carlstromf79fccb2014-02-20 08:55:10 -08001196 continue;
1197 }
1198 tmp_file->WriteFully(dex_file->Begin(), dex_file->Size());
1199 LOG(INFO) << "Wrote input to " << tmp_file_name;
1200 }
1201 }
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001202 }
1203 // Ensure opened dex files are writable for dex-to-dex transformations.
1204 for (const auto& dex_file : dex_files) {
1205 if (!dex_file->EnableWrite()) {
1206 PLOG(ERROR) << "Failed to make .dex file writeable '" << dex_file->GetLocation() << "'\n";
Brian Carlstromd76e0832013-08-29 15:17:42 -07001207 }
Brian Carlstrom7940e442013-07-12 13:46:57 -07001208 }
1209
buzbeea024a062013-07-31 10:47:37 -07001210 /*
1211 * If we're not in interpret-only mode, go ahead and compile small applications. Don't
1212 * bother to check if we're doing the image.
1213 */
Brian Carlstrom6449c622014-02-10 23:48:36 -08001214 if (!image && (compiler_options.GetCompilerFilter() != CompilerOptions::kInterpretOnly)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -07001215 size_t num_methods = 0;
1216 for (size_t i = 0; i != dex_files.size(); ++i) {
1217 const DexFile* dex_file = dex_files[i];
1218 CHECK(dex_file != NULL);
1219 num_methods += dex_file->NumMethodIds();
1220 }
Brian Carlstrom6449c622014-02-10 23:48:36 -08001221 if (num_methods <= compiler_options.GetNumDexMethodsThreshold()) {
1222 compiler_options.SetCompilerFilter(CompilerOptions::kSpeed);
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07001223 VLOG(compiler) << "Below method threshold, compiling anyways";
Brian Carlstrom7940e442013-07-12 13:46:57 -07001224 }
1225 }
1226
1227 UniquePtr<const CompilerDriver> compiler(dex2oat->CreateOatFile(boot_image_option,
Brian Carlstrom7940e442013-07-12 13:46:57 -07001228 android_root,
1229 is_host,
1230 dex_files,
1231 oat_file.get(),
1232 bitcode_filename,
1233 image,
1234 image_classes,
1235 dump_stats,
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +00001236 dump_passes,
1237 timings,
Dave Allison39c3bfb2014-01-28 18:33:52 -08001238 compiler_phases_timings,
1239 profile_file));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001240
1241 if (compiler.get() == NULL) {
1242 LOG(ERROR) << "Failed to create oat file: " << oat_location;
1243 return EXIT_FAILURE;
1244 }
1245
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07001246 VLOG(compiler) << "Oat file written successfully (unstripped): " << oat_location;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001247
1248 // Notes on the interleaving of creating the image and oat file to
1249 // ensure the references between the two are correct.
1250 //
1251 // Currently we have a memory layout that looks something like this:
1252 //
1253 // +--------------+
1254 // | image |
1255 // +--------------+
1256 // | boot oat |
1257 // +--------------+
1258 // | alloc spaces |
1259 // +--------------+
1260 //
Brian Carlstrom45602482013-07-21 22:07:55 -07001261 // There are several constraints on the loading of the image and boot.oat.
Brian Carlstrom7940e442013-07-12 13:46:57 -07001262 //
1263 // 1. The image is expected to be loaded at an absolute address and
1264 // contains Objects with absolute pointers within the image.
1265 //
1266 // 2. There are absolute pointers from Methods in the image to their
1267 // code in the oat.
1268 //
1269 // 3. There are absolute pointers from the code in the oat to Methods
1270 // in the image.
1271 //
1272 // 4. There are absolute pointers from code in the oat to other code
1273 // in the oat.
1274 //
1275 // To get this all correct, we go through several steps.
1276 //
1277 // 1. We have already created that oat file above with
1278 // CreateOatFile. Originally this was just our own proprietary file
Brian Carlstrom45602482013-07-21 22:07:55 -07001279 // but now it is contained within an ELF dynamic object (aka an .so
Brian Carlstrom7940e442013-07-12 13:46:57 -07001280 // file). The Compiler returned by CreateOatFile provides
1281 // PatchInformation for references to oat code and Methods that need
1282 // to be update once we know where the oat file will be located
1283 // after the image.
1284 //
1285 // 2. We create the image file. It needs to know where the oat file
1286 // will be loaded after itself. Originally when oat file was simply
1287 // memory mapped so we could predict where its contents were based
1288 // on the file size. Now that it is an ELF file, we need to inspect
1289 // the ELF file to understand the in memory segment layout including
1290 // where the oat header is located within. ImageWriter's
1291 // PatchOatCodeAndMethods uses the PatchInformation from the
1292 // Compiler to touch up absolute references in the oat file.
1293 //
1294 // 3. We fixup the ELF program headers so that dlopen will try to
1295 // load the .so at the desired location at runtime by offsetting the
1296 // Elf32_Phdr.p_vaddr values by the desired base address.
1297 //
1298 if (image) {
Anwar Ghuloum6f28d912013-07-24 15:02:53 -07001299 timings.NewSplit("dex2oat ImageWriter");
Brian Carlstrom7940e442013-07-12 13:46:57 -07001300 bool image_creation_success = dex2oat->CreateImageFile(image_filename,
1301 image_base,
1302 oat_unstripped,
1303 oat_location,
1304 *compiler.get());
Brian Carlstrom7940e442013-07-12 13:46:57 -07001305 if (!image_creation_success) {
1306 return EXIT_FAILURE;
1307 }
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07001308 VLOG(compiler) << "Image written successfully: " << image_filename;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001309 }
1310
1311 if (is_host) {
Ian Rogers46398602013-08-20 07:50:36 -07001312 if (dump_timing || (dump_slow_timing && timings.GetTotalNs() > MsToNs(1000))) {
Ian Rogers5fe9af72013-11-14 00:17:20 -08001313 LOG(INFO) << Dumpable<TimingLogger>(timings);
Brian Carlstrom45602482013-07-21 22:07:55 -07001314 }
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +00001315 if (dump_passes) {
Ian Rogers3d504072014-03-01 09:16:49 -08001316 LOG(INFO) << Dumpable<CumulativeLogger>(*compiler.get()->GetTimingsLogger());
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +00001317 }
Brian Carlstrom7940e442013-07-12 13:46:57 -07001318 return EXIT_SUCCESS;
1319 }
1320
1321 // If we don't want to strip in place, copy from unstripped location to stripped location.
1322 // We need to strip after image creation because FixupElf needs to use .strtab.
1323 if (oat_unstripped != oat_stripped) {
Anwar Ghuloum6f28d912013-07-24 15:02:53 -07001324 timings.NewSplit("dex2oat OatFile copy");
Brian Carlstrom7940e442013-07-12 13:46:57 -07001325 oat_file.reset();
Brian Carlstrom7571e8b2013-08-12 17:04:14 -07001326 UniquePtr<File> in(OS::OpenFileForReading(oat_unstripped.c_str()));
1327 UniquePtr<File> out(OS::CreateEmptyFile(oat_stripped.c_str()));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001328 size_t buffer_size = 8192;
1329 UniquePtr<uint8_t> buffer(new uint8_t[buffer_size]);
1330 while (true) {
1331 int bytes_read = TEMP_FAILURE_RETRY(read(in->Fd(), buffer.get(), buffer_size));
1332 if (bytes_read <= 0) {
1333 break;
1334 }
1335 bool write_ok = out->WriteFully(buffer.get(), bytes_read);
1336 CHECK(write_ok);
1337 }
1338 oat_file.reset(out.release());
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07001339 VLOG(compiler) << "Oat file copied successfully (stripped): " << oat_stripped;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001340 }
1341
Brian Carlstrom7fcba112013-07-22 10:28:48 -07001342#if ART_USE_PORTABLE_COMPILER // We currently only generate symbols on Portable
Anwar Ghuloum6f28d912013-07-24 15:02:53 -07001343 timings.NewSplit("dex2oat ElfStripper");
Brian Carlstrom7940e442013-07-12 13:46:57 -07001344 // Strip unneeded sections for target
1345 off_t seek_actual = lseek(oat_file->Fd(), 0, SEEK_SET);
1346 CHECK_EQ(0, seek_actual);
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001347 std::string error_msg;
1348 CHECK(ElfStripper::Strip(oat_file.get(), &error_msg)) << error_msg;
Anwar Ghuloum6f28d912013-07-24 15:02:53 -07001349
Brian Carlstrom7940e442013-07-12 13:46:57 -07001350
1351 // We wrote the oat file successfully, and want to keep it.
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07001352 VLOG(compiler) << "Oat file written successfully (stripped): " << oat_location;
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001353#endif // ART_USE_PORTABLE_COMPILER
Brian Carlstrom45602482013-07-21 22:07:55 -07001354
Anwar Ghuloum6f28d912013-07-24 15:02:53 -07001355 timings.EndSplit();
1356
Brian Carlstromc6dfdac2013-08-26 18:57:31 -07001357 if (dump_timing || (dump_slow_timing && timings.GetTotalNs() > MsToNs(1000))) {
Ian Rogers5fe9af72013-11-14 00:17:20 -08001358 LOG(INFO) << Dumpable<TimingLogger>(timings);
Brian Carlstrom45602482013-07-21 22:07:55 -07001359 }
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +00001360 if (dump_passes) {
1361 LOG(INFO) << Dumpable<CumulativeLogger>(compiler_phases_timings);
1362 }
Ian Rogers2672a9f2013-09-05 17:24:22 -07001363
1364 // Everything was successfully written, do an explicit exit here to avoid running Runtime
1365 // destructors that take time (bug 10645725) unless we're a debug build or running on valgrind.
Brian Carlstrom6449c622014-02-10 23:48:36 -08001366 if (!kIsDebugBuild && (RUNNING_ON_VALGRIND == 0)) {
Brian Carlstrom65c23bb2014-02-01 22:12:39 -08001367 dex2oat->LogCompletionTime();
Ian Rogers2672a9f2013-09-05 17:24:22 -07001368 exit(EXIT_SUCCESS);
1369 }
1370
Brian Carlstrom7940e442013-07-12 13:46:57 -07001371 return EXIT_SUCCESS;
Brian Carlstrom6449c622014-02-10 23:48:36 -08001372} // NOLINT(readability/fn_size)
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001373} // namespace art
Brian Carlstrom7940e442013-07-12 13:46:57 -07001374
1375int main(int argc, char** argv) {
1376 return art::dex2oat(argc, argv);
1377}