blob: ad796f8e10b81615e0f9b38f8cd799070d892ced [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.");
Wonil Kim9cb554a2014-04-28 11:26:55 +0900113 UsageError(" Example: --oat-fd=6");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700114 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("");
Stuart Monteith04ae1632014-04-11 11:16:58 +0100142 UsageError(" --instruction-set=(arm|arm64|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("");
Jeff Hao4a200f52014-04-01 14:58:49 -0700156 UsageError(" --compiler-filter=(verify-none|interpret-only|space|balanced|speed|everything):");
157 UsageError(" select compiler filter.");
Brian Carlstrom6449c622014-02-10 23:48:36 -0800158 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");
Jeff Hao4a200f52014-04-01 14:58:49 -0700192 UsageError(" and the filter is not interpret-only or verify-none, overrides the");
193 UsageError(" filter to use speed");
Brian Carlstrom6449c622014-02-10 23:48:36 -0800194 UsageError(" Example: --num-dex-method=%d", CompilerOptions::kDefaultNumDexMethodsThreshold);
195 UsageError(" Default: %d", CompilerOptions::kDefaultNumDexMethodsThreshold);
196 UsageError("");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700197 UsageError(" --host: used with Portable backend to link against host runtime libraries");
198 UsageError("");
Ian Rogers46398602013-08-20 07:50:36 -0700199 UsageError(" --dump-timing: display a breakdown of where time was spent");
200 UsageError("");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700201 UsageError(" --runtime-arg <argument>: used to specify various arguments for the runtime,");
202 UsageError(" such as initial heap size, maximum heap size, and verbose output.");
203 UsageError(" Use a separate --runtime-arg switch for each argument.");
204 UsageError(" Example: --runtime-arg -Xms256m");
Jeff Hao4a200f52014-04-01 14:58:49 -0700205 UsageError("");
Dave Allisond6ed6422014-04-09 23:36:15 +0000206 UsageError(" --profile-file=<filename>: specify profiler output file to use for compilation.");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700207 UsageError("");
Chao-ying Fucd8ce662014-03-11 14:57:19 -0700208 UsageError(" --print-pass-names: print a list of pass names");
209 UsageError("");
210 UsageError(" --disable-passes=<pass-names>: disable one or more passes separated by comma.");
211 UsageError(" Example: --disable-passes=UseCount,BBOptimizations");
212 UsageError("");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700213 std::cerr << "See log for usage error information\n";
214 exit(EXIT_FAILURE);
215}
216
217class Dex2Oat {
218 public:
Brian Carlstrom45602482013-07-21 22:07:55 -0700219 static bool Create(Dex2Oat** p_dex2oat,
Brian Carlstrom6449c622014-02-10 23:48:36 -0800220 const Runtime::Options& runtime_options,
221 const CompilerOptions& compiler_options,
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000222 Compiler::Kind compiler_kind,
Brian Carlstrom45602482013-07-21 22:07:55 -0700223 InstructionSet instruction_set,
Dave Allison70202782013-10-22 17:52:19 -0700224 InstructionSetFeatures instruction_set_features,
Brian Carlstrom6449c622014-02-10 23:48:36 -0800225 VerificationResults* verification_results,
226 DexFileToMethodInlinerMap* method_inliner_map,
Brian Carlstrom45602482013-07-21 22:07:55 -0700227 size_t thread_count)
Brian Carlstrom7940e442013-07-12 13:46:57 -0700228 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_) {
Brian Carlstrom6449c622014-02-10 23:48:36 -0800229 CHECK(verification_results != nullptr);
230 CHECK(method_inliner_map != nullptr);
231 UniquePtr<Dex2Oat> dex2oat(new Dex2Oat(&compiler_options,
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000232 compiler_kind,
Brian Carlstrom6449c622014-02-10 23:48:36 -0800233 instruction_set,
234 instruction_set_features,
235 verification_results,
236 method_inliner_map,
237 thread_count));
238 if (!dex2oat->CreateRuntime(runtime_options, instruction_set)) {
Kenny Root51316382014-05-13 14:59:37 -0700239 *p_dex2oat = nullptr;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700240 return false;
241 }
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000242 *p_dex2oat = dex2oat.release();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700243 return true;
244 }
245
246 ~Dex2Oat() {
247 delete runtime_;
Brian Carlstrom65c23bb2014-02-01 22:12:39 -0800248 LogCompletionTime();
249 }
250
251 void LogCompletionTime() {
252 LOG(INFO) << "dex2oat took " << PrettyDuration(NanoTime() - start_ns_)
Brian Carlstrom45602482013-07-21 22:07:55 -0700253 << " (threads: " << thread_count_ << ")";
Brian Carlstrom7940e442013-07-12 13:46:57 -0700254 }
255
256
Brian Carlstrom45602482013-07-21 22:07:55 -0700257 // Reads the class names (java.lang.Object) and returns a set of descriptors (Ljava/lang/Object;)
Brian Carlstrom7940e442013-07-12 13:46:57 -0700258 CompilerDriver::DescriptorSet* ReadImageClassesFromFile(const char* image_classes_filename) {
Brian Carlstrom45602482013-07-21 22:07:55 -0700259 UniquePtr<std::ifstream> image_classes_file(new std::ifstream(image_classes_filename,
260 std::ifstream::in));
Kenny Root51316382014-05-13 14:59:37 -0700261 if (image_classes_file.get() == nullptr) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700262 LOG(ERROR) << "Failed to open image classes file " << image_classes_filename;
Kenny Root51316382014-05-13 14:59:37 -0700263 return nullptr;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700264 }
265 UniquePtr<CompilerDriver::DescriptorSet> result(ReadImageClasses(*image_classes_file.get()));
266 image_classes_file->close();
267 return result.release();
268 }
269
270 CompilerDriver::DescriptorSet* ReadImageClasses(std::istream& image_classes_stream) {
271 UniquePtr<CompilerDriver::DescriptorSet> image_classes(new CompilerDriver::DescriptorSet);
272 while (image_classes_stream.good()) {
273 std::string dot;
274 std::getline(image_classes_stream, dot);
275 if (StartsWith(dot, "#") || dot.empty()) {
276 continue;
277 }
278 std::string descriptor(DotToDescriptor(dot.c_str()));
279 image_classes->insert(descriptor);
280 }
281 return image_classes.release();
282 }
283
Brian Carlstrom45602482013-07-21 22:07:55 -0700284 // Reads the class names (java.lang.Object) and returns a set of descriptors (Ljava/lang/Object;)
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700285 CompilerDriver::DescriptorSet* ReadImageClassesFromZip(const char* zip_filename,
286 const char* image_classes_filename,
287 std::string* error_msg) {
288 UniquePtr<ZipArchive> zip_archive(ZipArchive::Open(zip_filename, error_msg));
Kenny Root51316382014-05-13 14:59:37 -0700289 if (zip_archive.get() == nullptr) {
290 return nullptr;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700291 }
Narayan Kamath92572be2013-11-28 14:06:24 +0000292 UniquePtr<ZipEntry> zip_entry(zip_archive->Find(image_classes_filename, error_msg));
Kenny Root51316382014-05-13 14:59:37 -0700293 if (zip_entry.get() == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700294 *error_msg = StringPrintf("Failed to find '%s' within '%s': %s", image_classes_filename,
295 zip_filename, error_msg->c_str());
Kenny Root51316382014-05-13 14:59:37 -0700296 return nullptr;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700297 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700298 UniquePtr<MemMap> image_classes_file(zip_entry->ExtractToMemMap(image_classes_filename,
299 error_msg));
Kenny Root51316382014-05-13 14:59:37 -0700300 if (image_classes_file.get() == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700301 *error_msg = StringPrintf("Failed to extract '%s' from '%s': %s", image_classes_filename,
302 zip_filename, error_msg->c_str());
Kenny Root51316382014-05-13 14:59:37 -0700303 return nullptr;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700304 }
305 const std::string image_classes_string(reinterpret_cast<char*>(image_classes_file->Begin()),
306 image_classes_file->Size());
307 std::istringstream image_classes_stream(image_classes_string);
308 return ReadImageClasses(image_classes_stream);
309 }
310
311 const CompilerDriver* CreateOatFile(const std::string& boot_image_option,
Brian Carlstrom7940e442013-07-12 13:46:57 -0700312 const std::string& android_root,
313 bool is_host,
314 const std::vector<const DexFile*>& dex_files,
315 File* oat_file,
316 const std::string& bitcode_filename,
317 bool image,
318 UniquePtr<CompilerDriver::DescriptorSet>& image_classes,
319 bool dump_stats,
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000320 bool dump_passes,
321 TimingLogger& timings,
Dave Allison39c3bfb2014-01-28 18:33:52 -0800322 CumulativeLogger& compiler_phases_timings,
323 std::string profile_file) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700324 // Handle and ClassLoader creation needs to come after Runtime::Create
Kenny Root51316382014-05-13 14:59:37 -0700325 jobject class_loader = nullptr;
Ian Rogers3f3d22c2013-08-27 18:11:09 -0700326 Thread* self = Thread::Current();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700327 if (!boot_image_option.empty()) {
328 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
329 std::vector<const DexFile*> class_path_files(dex_files);
330 OpenClassPathFiles(runtime_->GetClassPathString(), class_path_files);
Ian Rogers3f3d22c2013-08-27 18:11:09 -0700331 ScopedObjectAccess soa(self);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700332 for (size_t i = 0; i < class_path_files.size(); i++) {
333 class_linker->RegisterDexFile(*class_path_files[i]);
334 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700335 soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader);
336 ScopedLocalRef<jobject> class_loader_local(soa.Env(),
337 soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader));
338 class_loader = soa.Env()->NewGlobalRef(class_loader_local.get());
339 Runtime::Current()->SetCompileTimeClassPath(class_loader, class_path_files);
340 }
341
Brian Carlstrom6449c622014-02-10 23:48:36 -0800342 UniquePtr<CompilerDriver> driver(new CompilerDriver(compiler_options_,
343 verification_results_,
344 method_inliner_map_,
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000345 compiler_kind_,
Brian Carlstrom7940e442013-07-12 13:46:57 -0700346 instruction_set_,
Dave Allison70202782013-10-22 17:52:19 -0700347 instruction_set_features_,
Brian Carlstrom7940e442013-07-12 13:46:57 -0700348 image,
349 image_classes.release(),
350 thread_count_,
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000351 dump_stats,
352 dump_passes,
Dave Allison39c3bfb2014-01-28 18:33:52 -0800353 &compiler_phases_timings,
354 profile_file));
Brian Carlstrom7940e442013-07-12 13:46:57 -0700355
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000356 driver->GetCompiler()->SetBitcodeFileName(*driver.get(), bitcode_filename);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700357
Ian Rogers3d504072014-03-01 09:16:49 -0800358 driver->CompileAll(class_loader, dex_files, &timings);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700359
Anwar Ghuloum6f28d912013-07-24 15:02:53 -0700360 timings.NewSplit("dex2oat OatWriter");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700361 std::string image_file_location;
362 uint32_t image_file_location_oat_checksum = 0;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800363 uintptr_t image_file_location_oat_data_begin = 0;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700364 if (!driver->IsImage()) {
Ian Rogersca368cb2013-11-15 15:52:08 -0800365 TimingLogger::ScopedSplit split("Loading image checksum", &timings);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700366 gc::space::ImageSpace* image_space = Runtime::Current()->GetHeap()->GetImageSpace();
367 image_file_location_oat_checksum = image_space->GetImageHeader().GetOatChecksum();
368 image_file_location_oat_data_begin =
Ian Rogersef7d42f2014-01-06 12:55:46 -0800369 reinterpret_cast<uintptr_t>(image_space->GetImageHeader().GetOatDataBegin());
Brian Carlstrom7940e442013-07-12 13:46:57 -0700370 image_file_location = image_space->GetImageFilename();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700371 }
372
Brian Carlstromc50d8e12013-07-23 22:35:16 -0700373 OatWriter oat_writer(dex_files,
374 image_file_location_oat_checksum,
375 image_file_location_oat_data_begin,
376 image_file_location,
Ian Rogersca368cb2013-11-15 15:52:08 -0800377 driver.get(),
378 &timings);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700379
Ian Rogersca368cb2013-11-15 15:52:08 -0800380 TimingLogger::ScopedSplit split("Writing ELF", &timings);
Ian Rogers3d504072014-03-01 09:16:49 -0800381 if (!driver->WriteElf(android_root, is_host, dex_files, &oat_writer, oat_file)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700382 LOG(ERROR) << "Failed to write ELF file " << oat_file->GetPath();
Kenny Root51316382014-05-13 14:59:37 -0700383 return nullptr;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700384 }
385
386 return driver.release();
387 }
388
389 bool CreateImageFile(const std::string& image_filename,
390 uintptr_t image_base,
391 const std::string& oat_filename,
392 const std::string& oat_location,
393 const CompilerDriver& compiler)
394 LOCKS_EXCLUDED(Locks::mutator_lock_) {
395 uintptr_t oat_data_begin;
396 {
397 // ImageWriter is scoped so it can free memory before doing FixupElf
398 ImageWriter image_writer(compiler);
399 if (!image_writer.Write(image_filename, image_base, oat_filename, oat_location)) {
400 LOG(ERROR) << "Failed to create image file " << image_filename;
401 return false;
402 }
403 oat_data_begin = image_writer.GetOatDataBegin();
404 }
405
Brian Carlstrom7571e8b2013-08-12 17:04:14 -0700406 UniquePtr<File> oat_file(OS::OpenFileReadWrite(oat_filename.c_str()));
Kenny Root51316382014-05-13 14:59:37 -0700407 if (oat_file.get() == nullptr) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700408 PLOG(ERROR) << "Failed to open ELF file: " << oat_filename;
409 return false;
410 }
411 if (!ElfFixup::Fixup(oat_file.get(), oat_data_begin)) {
412 LOG(ERROR) << "Failed to fixup ELF file " << oat_file->GetPath();
413 return false;
414 }
415 return true;
416 }
417
418 private:
Brian Carlstrom6449c622014-02-10 23:48:36 -0800419 explicit Dex2Oat(const CompilerOptions* compiler_options,
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000420 Compiler::Kind compiler_kind,
Brian Carlstrom45602482013-07-21 22:07:55 -0700421 InstructionSet instruction_set,
Dave Allison70202782013-10-22 17:52:19 -0700422 InstructionSetFeatures instruction_set_features,
Brian Carlstrom6449c622014-02-10 23:48:36 -0800423 VerificationResults* verification_results,
424 DexFileToMethodInlinerMap* method_inliner_map,
Brian Carlstrom0177fe22013-07-21 12:21:36 -0700425 size_t thread_count)
Brian Carlstrom6449c622014-02-10 23:48:36 -0800426 : compiler_options_(compiler_options),
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000427 compiler_kind_(compiler_kind),
Brian Carlstrom7940e442013-07-12 13:46:57 -0700428 instruction_set_(instruction_set),
Dave Allison70202782013-10-22 17:52:19 -0700429 instruction_set_features_(instruction_set_features),
Brian Carlstrom6449c622014-02-10 23:48:36 -0800430 verification_results_(verification_results),
431 method_inliner_map_(method_inliner_map),
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000432 runtime_(nullptr),
Brian Carlstrom7940e442013-07-12 13:46:57 -0700433 thread_count_(thread_count),
Brian Carlstrom7940e442013-07-12 13:46:57 -0700434 start_ns_(NanoTime()) {
Brian Carlstrom6449c622014-02-10 23:48:36 -0800435 CHECK(compiler_options != nullptr);
436 CHECK(verification_results != nullptr);
437 CHECK(method_inliner_map != nullptr);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700438 }
439
Brian Carlstrom6449c622014-02-10 23:48:36 -0800440 bool CreateRuntime(const Runtime::Options& runtime_options, InstructionSet instruction_set)
Brian Carlstrom7940e442013-07-12 13:46:57 -0700441 SHARED_TRYLOCK_FUNCTION(true, Locks::mutator_lock_) {
Brian Carlstrom6449c622014-02-10 23:48:36 -0800442 if (!Runtime::Create(runtime_options, false)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700443 LOG(ERROR) << "Failed to create runtime";
444 return false;
445 }
446 Runtime* runtime = Runtime::Current();
Vladimir Marko7624d252014-05-02 14:40:15 +0100447 runtime->SetInstructionSet(instruction_set);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700448 for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
449 Runtime::CalleeSaveType type = Runtime::CalleeSaveType(i);
450 if (!runtime->HasCalleeSaveMethod(type)) {
Vladimir Marko7624d252014-05-02 14:40:15 +0100451 runtime->SetCalleeSaveMethod(runtime->CreateCalleeSaveMethod(type), type);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700452 }
453 }
454 runtime->GetClassLinker()->FixupDexCaches(runtime->GetResolutionMethod());
Vladimir Marko2b5eaa22013-12-13 13:59:30 +0000455 runtime_ = runtime;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700456 return true;
457 }
458
459 // Appends to dex_files any elements of class_path that it doesn't already
460 // contain. This will open those dex files as necessary.
Brian Carlstrom45602482013-07-21 22:07:55 -0700461 static void OpenClassPathFiles(const std::string& class_path,
462 std::vector<const DexFile*>& dex_files) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700463 std::vector<std::string> parsed;
464 Split(class_path, ':', parsed);
465 // Take Locks::mutator_lock_ so that lock ordering on the ClassLinker::dex_lock_ is maintained.
466 ScopedObjectAccess soa(Thread::Current());
467 for (size_t i = 0; i < parsed.size(); ++i) {
468 if (DexFilesContains(dex_files, parsed[i])) {
469 continue;
470 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700471 std::string error_msg;
472 const DexFile* dex_file = DexFile::Open(parsed[i].c_str(), parsed[i].c_str(), &error_msg);
Kenny Root51316382014-05-13 14:59:37 -0700473 if (dex_file == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700474 LOG(WARNING) << "Failed to open dex file '" << parsed[i] << "': " << error_msg;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700475 } else {
476 dex_files.push_back(dex_file);
477 }
478 }
479 }
480
481 // Returns true if dex_files has a dex with the named location.
Brian Carlstrom45602482013-07-21 22:07:55 -0700482 static bool DexFilesContains(const std::vector<const DexFile*>& dex_files,
483 const std::string& location) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700484 for (size_t i = 0; i < dex_files.size(); ++i) {
485 if (dex_files[i]->GetLocation() == location) {
486 return true;
487 }
488 }
489 return false;
490 }
491
Brian Carlstromae7083d2014-02-24 21:56:02 -0800492 const CompilerOptions* const compiler_options_;
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000493 const Compiler::Kind compiler_kind_;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700494
495 const InstructionSet instruction_set_;
Dave Allison70202782013-10-22 17:52:19 -0700496 const InstructionSetFeatures instruction_set_features_;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700497
Brian Carlstromae7083d2014-02-24 21:56:02 -0800498 VerificationResults* const verification_results_;
499 DexFileToMethodInlinerMap* const method_inliner_map_;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700500 Runtime* runtime_;
501 size_t thread_count_;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700502 uint64_t start_ns_;
503
504 DISALLOW_IMPLICIT_CONSTRUCTORS(Dex2Oat);
505};
506
507static bool ParseInt(const char* in, int* out) {
508 char* end;
509 int result = strtol(in, &end, 10);
510 if (in == end || *end != '\0') {
511 return false;
512 }
513 *out = result;
514 return true;
515}
516
Brian Carlstrom3cf59d52013-11-10 21:04:10 -0800517static size_t OpenDexFiles(const std::vector<const char*>& dex_filenames,
518 const std::vector<const char*>& dex_locations,
519 std::vector<const DexFile*>& dex_files) {
520 size_t failure_count = 0;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700521 for (size_t i = 0; i < dex_filenames.size(); i++) {
522 const char* dex_filename = dex_filenames[i];
523 const char* dex_location = dex_locations[i];
Ian Rogers740a11d2014-01-14 10:11:25 -0800524 ATRACE_BEGIN(StringPrintf("Opening dex file '%s'", dex_filenames[i]).c_str());
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700525 std::string error_msg;
Brian Carlstromd5aba592013-11-12 01:52:44 -0800526 if (!OS::FileExists(dex_filename)) {
527 LOG(WARNING) << "Skipping non-existent dex file '" << dex_filename << "'";
528 continue;
529 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700530 const DexFile* dex_file = DexFile::Open(dex_filename, dex_location, &error_msg);
Kenny Root51316382014-05-13 14:59:37 -0700531 if (dex_file == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700532 LOG(WARNING) << "Failed to open .dex from file '" << dex_filename << "': " << error_msg;
Brian Carlstrom3cf59d52013-11-10 21:04:10 -0800533 ++failure_count;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700534 } else {
535 dex_files.push_back(dex_file);
536 }
Ian Rogers740a11d2014-01-14 10:11:25 -0800537 ATRACE_END();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700538 }
Brian Carlstrom3cf59d52013-11-10 21:04:10 -0800539 return failure_count;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700540}
541
542// The primary goal of the watchdog is to prevent stuck build servers
543// during development when fatal aborts lead to a cascade of failures
544// that result in a deadlock.
545class WatchDog {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700546// WatchDog defines its own CHECK_PTHREAD_CALL to avoid using Log which uses locks
547#undef CHECK_PTHREAD_CALL
548#define CHECK_WATCH_DOG_PTHREAD_CALL(call, args, what) \
549 do { \
550 int rc = call args; \
551 if (rc != 0) { \
552 errno = rc; \
553 std::string message(# call); \
554 message += " failed for "; \
555 message += reason; \
556 Fatal(message); \
557 } \
558 } while (false)
559
560 public:
Brian Carlstrom93ba8932013-07-17 21:31:49 -0700561 explicit WatchDog(bool is_watch_dog_enabled) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700562 is_watch_dog_enabled_ = is_watch_dog_enabled;
563 if (!is_watch_dog_enabled_) {
564 return;
565 }
566 shutting_down_ = false;
567 const char* reason = "dex2oat watch dog thread startup";
Kenny Root51316382014-05-13 14:59:37 -0700568 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_init, (&mutex_, nullptr), reason);
569 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_cond_init, (&cond_, nullptr), reason);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700570 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_attr_init, (&attr_), reason);
571 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_create, (&pthread_, &attr_, &CallBack, this), reason);
572 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_attr_destroy, (&attr_), reason);
573 }
574 ~WatchDog() {
575 if (!is_watch_dog_enabled_) {
576 return;
577 }
578 const char* reason = "dex2oat watch dog thread shutdown";
579 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_lock, (&mutex_), reason);
580 shutting_down_ = true;
581 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_cond_signal, (&cond_), reason);
582 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_unlock, (&mutex_), reason);
583
Kenny Root51316382014-05-13 14:59:37 -0700584 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_join, (pthread_, nullptr), reason);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700585
586 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_cond_destroy, (&cond_), reason);
587 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_destroy, (&mutex_), reason);
588 }
589
590 private:
591 static void* CallBack(void* arg) {
592 WatchDog* self = reinterpret_cast<WatchDog*>(arg);
593 ::art::SetThreadName("dex2oat watch dog");
594 self->Wait();
Kenny Root51316382014-05-13 14:59:37 -0700595 return nullptr;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700596 }
597
598 static void Message(char severity, const std::string& message) {
599 // TODO: Remove when we switch to LOG when we can guarantee it won't prevent shutdown in error
600 // cases.
601 fprintf(stderr, "dex2oat%s %c %d %d %s\n",
602 kIsDebugBuild ? "d" : "",
603 severity,
604 getpid(),
605 GetTid(),
606 message.c_str());
607 }
608
609 static void Warn(const std::string& message) {
610 Message('W', message);
611 }
612
613 static void Fatal(const std::string& message) {
614 Message('F', message);
615 exit(1);
616 }
617
618 void Wait() {
619 bool warning = true;
620 CHECK_GT(kWatchDogTimeoutSeconds, kWatchDogWarningSeconds);
621 // TODO: tune the multiplier for GC verification, the following is just to make the timeout
622 // large.
Mathieu Chartier4e305412014-02-19 10:54:44 -0800623 int64_t multiplier = kVerifyObjectSupport > kVerifyObjectModeFast ? 100 : 1;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700624 timespec warning_ts;
625 InitTimeSpec(true, CLOCK_REALTIME, multiplier * kWatchDogWarningSeconds * 1000, 0, &warning_ts);
626 timespec timeout_ts;
627 InitTimeSpec(true, CLOCK_REALTIME, multiplier * kWatchDogTimeoutSeconds * 1000, 0, &timeout_ts);
628 const char* reason = "dex2oat watch dog thread waiting";
629 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_lock, (&mutex_), reason);
630 while (!shutting_down_) {
631 int rc = TEMP_FAILURE_RETRY(pthread_cond_timedwait(&cond_, &mutex_,
632 warning ? &warning_ts
633 : &timeout_ts));
634 if (rc == ETIMEDOUT) {
635 std::string message(StringPrintf("dex2oat did not finish after %d seconds",
636 warning ? kWatchDogWarningSeconds
637 : kWatchDogTimeoutSeconds));
638 if (warning) {
639 Warn(message.c_str());
640 warning = false;
641 } else {
642 Fatal(message.c_str());
643 }
644 } else if (rc != 0) {
645 std::string message(StringPrintf("pthread_cond_timedwait failed: %s",
646 strerror(errno)));
647 Fatal(message.c_str());
648 }
649 }
650 CHECK_WATCH_DOG_PTHREAD_CALL(pthread_mutex_unlock, (&mutex_), reason);
651 }
652
653 // When setting timeouts, keep in mind that the build server may not be as fast as your desktop.
654#if ART_USE_PORTABLE_COMPILER
655 static const unsigned int kWatchDogWarningSeconds = 2 * 60; // 2 minutes.
656 static const unsigned int kWatchDogTimeoutSeconds = 30 * 60; // 25 minutes + buffer.
657#else
658 static const unsigned int kWatchDogWarningSeconds = 1 * 60; // 1 minute.
659 static const unsigned int kWatchDogTimeoutSeconds = 6 * 60; // 5 minutes + buffer.
660#endif
661
662 bool is_watch_dog_enabled_;
663 bool shutting_down_;
664 // TODO: Switch to Mutex when we can guarantee it won't prevent shutdown in error cases.
665 pthread_mutex_t mutex_;
666 pthread_cond_t cond_;
667 pthread_attr_t attr_;
668 pthread_t pthread_;
669};
670const unsigned int WatchDog::kWatchDogWarningSeconds;
671const unsigned int WatchDog::kWatchDogTimeoutSeconds;
672
Dave Allison70202782013-10-22 17:52:19 -0700673// Given a set of instruction features from the build, parse it. The
674// input 'str' is a comma separated list of feature names. Parse it and
675// return the InstructionSetFeatures object.
676static InstructionSetFeatures ParseFeatureList(std::string str) {
677 InstructionSetFeatures result;
678 typedef std::vector<std::string> FeatureList;
679 FeatureList features;
680 Split(str, ',', features);
681 for (FeatureList::iterator i = features.begin(); i != features.end(); i++) {
682 std::string feature = Trim(*i);
683 if (feature == "default") {
684 // Nothing to do.
685 } else if (feature == "div") {
686 // Supports divide instruction.
687 result.SetHasDivideInstruction(true);
688 } else if (feature == "nodiv") {
689 // Turn off support for divide instruction.
690 result.SetHasDivideInstruction(false);
Vladimir Marko674744e2014-04-24 15:18:26 +0100691 } else if (feature == "lpae") {
692 // Supports Large Physical Address Extension.
693 result.SetHasLpae(true);
694 } else if (feature == "nolpae") {
695 // Turn off support for Large Physical Address Extension.
696 result.SetHasLpae(false);
Dave Allison70202782013-10-22 17:52:19 -0700697 } else {
698 Usage("Unknown instruction set feature: '%s'", feature.c_str());
699 }
700 }
701 // others...
702 return result;
703}
704
Brian Carlstrom7940e442013-07-12 13:46:57 -0700705static int dex2oat(int argc, char** argv) {
Brian Carlstrom6449c622014-02-10 23:48:36 -0800706 original_argc = argc;
707 original_argv = argv;
708
Ian Rogers5fe9af72013-11-14 00:17:20 -0800709 TimingLogger timings("compiler", false, false);
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000710 CumulativeLogger compiler_phases_timings("compilation times");
Brian Carlstrom45602482013-07-21 22:07:55 -0700711
Brian Carlstrom7940e442013-07-12 13:46:57 -0700712 InitLogging(argv);
713
714 // Skip over argv[0].
715 argv++;
716 argc--;
717
718 if (argc == 0) {
Brian Carlstrome0948e12013-08-29 09:36:15 -0700719 Usage("No arguments specified");
Brian Carlstrom7940e442013-07-12 13:46:57 -0700720 }
721
722 std::vector<const char*> dex_filenames;
723 std::vector<const char*> dex_locations;
724 int zip_fd = -1;
725 std::string zip_location;
726 std::string oat_filename;
727 std::string oat_symbols;
728 std::string oat_location;
729 int oat_fd = -1;
730 std::string bitcode_filename;
Kenny Root51316382014-05-13 14:59:37 -0700731 const char* image_classes_zip_filename = nullptr;
732 const char* image_classes_filename = nullptr;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700733 std::string image_filename;
734 std::string boot_image_filename;
735 uintptr_t image_base = 0;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700736 std::string android_root;
737 std::vector<const char*> runtime_args;
738 int thread_count = sysconf(_SC_NPROCESSORS_CONF);
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000739 Compiler::Kind compiler_kind = kUsePortableCompiler
740 ? Compiler::kPortable
741 : Compiler::kQuick;
Kenny Root51316382014-05-13 14:59:37 -0700742 const char* compiler_filter_string = nullptr;
Brian Carlstrom6449c622014-02-10 23:48:36 -0800743 int huge_method_threshold = CompilerOptions::kDefaultHugeMethodThreshold;
744 int large_method_threshold = CompilerOptions::kDefaultLargeMethodThreshold;
745 int small_method_threshold = CompilerOptions::kDefaultSmallMethodThreshold;
746 int tiny_method_threshold = CompilerOptions::kDefaultTinyMethodThreshold;
747 int num_dex_methods_threshold = CompilerOptions::kDefaultNumDexMethodsThreshold;
Dave Allison70202782013-10-22 17:52:19 -0700748
Brian Carlstrom1bd2ceb2013-11-06 00:29:48 -0800749 // Take the default set of instruction features from the build.
Dave Allison70202782013-10-22 17:52:19 -0700750 InstructionSetFeatures instruction_set_features =
Ian Rogers8afeb852014-04-02 14:55:49 -0700751 ParseFeatureList(Runtime::GetDefaultInstructionSetFeatures());
Dave Allison70202782013-10-22 17:52:19 -0700752
Andreas Gampe91268c12014-04-03 17:50:24 -0700753 InstructionSet instruction_set = kRuntimeISA;
Dave Allison70202782013-10-22 17:52:19 -0700754
Dave Allison39c3bfb2014-01-28 18:33:52 -0800755 // Profile file to use
756 std::string profile_file;
Dave Allison70202782013-10-22 17:52:19 -0700757
Brian Carlstrom7940e442013-07-12 13:46:57 -0700758 bool is_host = false;
Ian Rogerse732ef12013-10-09 15:22:24 -0700759 bool dump_stats = false;
Ian Rogers46398602013-08-20 07:50:36 -0700760 bool dump_timing = false;
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000761 bool dump_passes = false;
Ian Rogers46398602013-08-20 07:50:36 -0700762 bool dump_slow_timing = kIsDebugBuild;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700763 bool watch_dog_enabled = !kIsTargetBuild;
Mark Mendellae9fd932014-02-10 16:14:35 -0800764 bool generate_gdb_information = kIsDebugBuild;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700765
Brian Carlstrom7940e442013-07-12 13:46:57 -0700766 for (int i = 0; i < argc; i++) {
767 const StringPiece option(argv[i]);
Ian Rogersb9beb2e2014-05-09 16:57:40 -0700768 const bool log_options = false;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700769 if (log_options) {
770 LOG(INFO) << "dex2oat: option[" << i << "]=" << argv[i];
771 }
772 if (option.starts_with("--dex-file=")) {
773 dex_filenames.push_back(option.substr(strlen("--dex-file=")).data());
774 } else if (option.starts_with("--dex-location=")) {
775 dex_locations.push_back(option.substr(strlen("--dex-location=")).data());
776 } else if (option.starts_with("--zip-fd=")) {
777 const char* zip_fd_str = option.substr(strlen("--zip-fd=")).data();
778 if (!ParseInt(zip_fd_str, &zip_fd)) {
Brian Carlstrome0948e12013-08-29 09:36:15 -0700779 Usage("Failed to parse --zip-fd argument '%s' as an integer", zip_fd_str);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700780 }
Brian Carlstrom6449c622014-02-10 23:48:36 -0800781 if (zip_fd < 0) {
782 Usage("--zip-fd passed a negative value %d", zip_fd);
783 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700784 } else if (option.starts_with("--zip-location=")) {
785 zip_location = option.substr(strlen("--zip-location=")).data();
786 } else if (option.starts_with("--oat-file=")) {
787 oat_filename = option.substr(strlen("--oat-file=")).data();
788 } else if (option.starts_with("--oat-symbols=")) {
789 oat_symbols = option.substr(strlen("--oat-symbols=")).data();
790 } else if (option.starts_with("--oat-fd=")) {
791 const char* oat_fd_str = option.substr(strlen("--oat-fd=")).data();
792 if (!ParseInt(oat_fd_str, &oat_fd)) {
Brian Carlstrome0948e12013-08-29 09:36:15 -0700793 Usage("Failed to parse --oat-fd argument '%s' as an integer", oat_fd_str);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700794 }
Brian Carlstrom6449c622014-02-10 23:48:36 -0800795 if (oat_fd < 0) {
796 Usage("--oat-fd passed a negative value %d", oat_fd);
797 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700798 } else if (option == "--watch-dog") {
799 watch_dog_enabled = true;
800 } else if (option == "--no-watch-dog") {
801 watch_dog_enabled = false;
Mark Mendellae9fd932014-02-10 16:14:35 -0800802 } else if (option == "--gen-gdb-info") {
803 generate_gdb_information = true;
804 } else if (option == "--no-gen-gdb-info") {
805 generate_gdb_information = false;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700806 } else if (option.starts_with("-j")) {
807 const char* thread_count_str = option.substr(strlen("-j")).data();
808 if (!ParseInt(thread_count_str, &thread_count)) {
Brian Carlstrome0948e12013-08-29 09:36:15 -0700809 Usage("Failed to parse -j argument '%s' as an integer", thread_count_str);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700810 }
811 } else if (option.starts_with("--oat-location=")) {
812 oat_location = option.substr(strlen("--oat-location=")).data();
813 } else if (option.starts_with("--bitcode=")) {
814 bitcode_filename = option.substr(strlen("--bitcode=")).data();
815 } else if (option.starts_with("--image=")) {
816 image_filename = option.substr(strlen("--image=")).data();
817 } else if (option.starts_with("--image-classes=")) {
818 image_classes_filename = option.substr(strlen("--image-classes=")).data();
819 } else if (option.starts_with("--image-classes-zip=")) {
820 image_classes_zip_filename = option.substr(strlen("--image-classes-zip=")).data();
821 } else if (option.starts_with("--base=")) {
822 const char* image_base_str = option.substr(strlen("--base=")).data();
823 char* end;
824 image_base = strtoul(image_base_str, &end, 16);
825 if (end == image_base_str || *end != '\0') {
826 Usage("Failed to parse hexadecimal value for option %s", option.data());
827 }
828 } else if (option.starts_with("--boot-image=")) {
829 boot_image_filename = option.substr(strlen("--boot-image=")).data();
Brian Carlstrom7940e442013-07-12 13:46:57 -0700830 } else if (option.starts_with("--android-root=")) {
831 android_root = option.substr(strlen("--android-root=")).data();
832 } else if (option.starts_with("--instruction-set=")) {
833 StringPiece instruction_set_str = option.substr(strlen("--instruction-set=")).data();
834 if (instruction_set_str == "arm") {
835 instruction_set = kThumb2;
Stuart Monteithb95a5342014-03-12 13:32:32 +0000836 } else if (instruction_set_str == "arm64") {
837 instruction_set = kArm64;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700838 } else if (instruction_set_str == "mips") {
839 instruction_set = kMips;
840 } else if (instruction_set_str == "x86") {
841 instruction_set = kX86;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800842 } else if (instruction_set_str == "x86_64") {
843 instruction_set = kX86_64;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700844 }
Dave Allison70202782013-10-22 17:52:19 -0700845 } else if (option.starts_with("--instruction-set-features=")) {
846 StringPiece str = option.substr(strlen("--instruction-set-features=")).data();
847 instruction_set_features = ParseFeatureList(str.as_string());
Brian Carlstrom7940e442013-07-12 13:46:57 -0700848 } else if (option.starts_with("--compiler-backend=")) {
849 StringPiece backend_str = option.substr(strlen("--compiler-backend=")).data();
850 if (backend_str == "Quick") {
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000851 compiler_kind = Compiler::kQuick;
852 } else if (backend_str == "Optimizing") {
853 compiler_kind = Compiler::kOptimizing;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700854 } else if (backend_str == "Portable") {
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +0000855 compiler_kind = Compiler::kPortable;
Brian Carlstrom7940e442013-07-12 13:46:57 -0700856 }
Brian Carlstrom6449c622014-02-10 23:48:36 -0800857 } else if (option.starts_with("--compiler-filter=")) {
858 compiler_filter_string = option.substr(strlen("--compiler-filter=")).data();
859 } else if (option.starts_with("--huge-method-max=")) {
860 const char* threshold = option.substr(strlen("--huge-method-max=")).data();
861 if (!ParseInt(threshold, &huge_method_threshold)) {
862 Usage("Failed to parse --huge-method-max '%s' as an integer", threshold);
863 }
864 if (huge_method_threshold < 0) {
865 Usage("--huge-method-max passed a negative value %s", huge_method_threshold);
866 }
867 } else if (option.starts_with("--large-method-max=")) {
868 const char* threshold = option.substr(strlen("--large-method-max=")).data();
869 if (!ParseInt(threshold, &large_method_threshold)) {
870 Usage("Failed to parse --large-method-max '%s' as an integer", threshold);
871 }
872 if (large_method_threshold < 0) {
873 Usage("--large-method-max passed a negative value %s", large_method_threshold);
874 }
875 } else if (option.starts_with("--small-method-max=")) {
876 const char* threshold = option.substr(strlen("--small-method-max=")).data();
877 if (!ParseInt(threshold, &small_method_threshold)) {
878 Usage("Failed to parse --small-method-max '%s' as an integer", threshold);
879 }
880 if (small_method_threshold < 0) {
881 Usage("--small-method-max passed a negative value %s", small_method_threshold);
882 }
883 } else if (option.starts_with("--tiny-method-max=")) {
884 const char* threshold = option.substr(strlen("--tiny-method-max=")).data();
885 if (!ParseInt(threshold, &tiny_method_threshold)) {
886 Usage("Failed to parse --tiny-method-max '%s' as an integer", threshold);
887 }
888 if (tiny_method_threshold < 0) {
889 Usage("--tiny-method-max passed a negative value %s", tiny_method_threshold);
890 }
891 } else if (option.starts_with("--num-dex-methods=")) {
892 const char* threshold = option.substr(strlen("--num-dex-methods=")).data();
893 if (!ParseInt(threshold, &num_dex_methods_threshold)) {
894 Usage("Failed to parse --num-dex-methods '%s' as an integer", threshold);
895 }
896 if (num_dex_methods_threshold < 0) {
897 Usage("--num-dex-methods passed a negative value %s", num_dex_methods_threshold);
898 }
Brian Carlstrom7940e442013-07-12 13:46:57 -0700899 } else if (option == "--host") {
900 is_host = true;
901 } else if (option == "--runtime-arg") {
902 if (++i >= argc) {
903 Usage("Missing required argument for --runtime-arg");
904 }
905 if (log_options) {
906 LOG(INFO) << "dex2oat: option[" << i << "]=" << argv[i];
907 }
908 runtime_args.push_back(argv[i]);
Ian Rogers46398602013-08-20 07:50:36 -0700909 } else if (option == "--dump-timing") {
910 dump_timing = true;
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +0000911 } else if (option == "--dump-passes") {
912 dump_passes = true;
Ian Rogerse732ef12013-10-09 15:22:24 -0700913 } else if (option == "--dump-stats") {
914 dump_stats = true;
Dave Allison39c3bfb2014-01-28 18:33:52 -0800915 } else if (option.starts_with("--profile-file=")) {
916 profile_file = option.substr(strlen("--profile-file=")).data();
917 VLOG(compiler) << "dex2oat: profile file is " << profile_file;
918 } else if (option == "--no-profile-file") {
Dave Allison39c3bfb2014-01-28 18:33:52 -0800919 // No profile
Chao-ying Fucd8ce662014-03-11 14:57:19 -0700920 } else if (option == "--print-pass-names") {
921 PassDriver::PrintPassNames();
922 } else if (option.starts_with("--disable-passes=")) {
923 std::string disable_passes = option.substr(strlen("--disable-passes=")).data();
924 PassDriver::CreateDefaultPassList(disable_passes);
Brian Carlstrom7940e442013-07-12 13:46:57 -0700925 } else {
Brian Carlstrome0948e12013-08-29 09:36:15 -0700926 Usage("Unknown argument %s", option.data());
Brian Carlstrom7940e442013-07-12 13:46:57 -0700927 }
928 }
929
930 if (oat_filename.empty() && oat_fd == -1) {
931 Usage("Output must be supplied with either --oat-file or --oat-fd");
932 }
933
934 if (!oat_filename.empty() && oat_fd != -1) {
935 Usage("--oat-file should not be used with --oat-fd");
936 }
937
938 if (!oat_symbols.empty() && oat_fd != -1) {
939 Usage("--oat-symbols should not be used with --oat-fd");
940 }
941
942 if (!oat_symbols.empty() && is_host) {
943 Usage("--oat-symbols should not be used with --host");
944 }
945
946 if (oat_fd != -1 && !image_filename.empty()) {
947 Usage("--oat-fd should not be used with --image");
948 }
949
Brian Carlstrom7940e442013-07-12 13:46:57 -0700950 if (android_root.empty()) {
951 const char* android_root_env_var = getenv("ANDROID_ROOT");
Kenny Root51316382014-05-13 14:59:37 -0700952 if (android_root_env_var == nullptr) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700953 Usage("--android-root unspecified and ANDROID_ROOT not set");
954 }
955 android_root += android_root_env_var;
956 }
957
958 bool image = (!image_filename.empty());
959 if (!image && boot_image_filename.empty()) {
Nicolas Geoffray9583fbc2014-02-28 15:21:07 +0000960 boot_image_filename += GetAndroidRoot();
Brian Carlstrom3ac05bb2014-05-13 19:31:38 -0700961 boot_image_filename += "/framework/boot.art";
Brian Carlstrom7940e442013-07-12 13:46:57 -0700962 }
963 std::string boot_image_option;
964 if (!boot_image_filename.empty()) {
965 boot_image_option += "-Ximage:";
966 boot_image_option += boot_image_filename;
967 }
968
Kenny Root51316382014-05-13 14:59:37 -0700969 if (image_classes_filename != nullptr && !image) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700970 Usage("--image-classes should only be used with --image");
971 }
972
Kenny Root51316382014-05-13 14:59:37 -0700973 if (image_classes_filename != nullptr && !boot_image_option.empty()) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700974 Usage("--image-classes should not be used with --boot-image");
975 }
976
Kenny Root51316382014-05-13 14:59:37 -0700977 if (image_classes_zip_filename != nullptr && image_classes_filename == nullptr) {
Brian Carlstrom7940e442013-07-12 13:46:57 -0700978 Usage("--image-classes-zip should be used with --image-classes");
979 }
980
981 if (dex_filenames.empty() && zip_fd == -1) {
982 Usage("Input must be supplied with either --dex-file or --zip-fd");
983 }
984
985 if (!dex_filenames.empty() && zip_fd != -1) {
986 Usage("--dex-file should not be used with --zip-fd");
987 }
988
989 if (!dex_filenames.empty() && !zip_location.empty()) {
990 Usage("--dex-file should not be used with --zip-location");
991 }
992
993 if (dex_locations.empty()) {
994 for (size_t i = 0; i < dex_filenames.size(); i++) {
995 dex_locations.push_back(dex_filenames[i]);
996 }
997 } else if (dex_locations.size() != dex_filenames.size()) {
998 Usage("--dex-location arguments do not match --dex-file arguments");
999 }
1000
1001 if (zip_fd != -1 && zip_location.empty()) {
1002 Usage("--zip-location should be supplied with --zip-fd");
1003 }
1004
1005 if (boot_image_option.empty()) {
1006 if (image_base == 0) {
Brian Carlstrome0948e12013-08-29 09:36:15 -07001007 Usage("Non-zero --base not specified");
Brian Carlstrom7940e442013-07-12 13:46:57 -07001008 }
1009 }
1010
1011 std::string oat_stripped(oat_filename);
1012 std::string oat_unstripped;
1013 if (!oat_symbols.empty()) {
1014 oat_unstripped += oat_symbols;
1015 } else {
1016 oat_unstripped += oat_filename;
1017 }
1018
Kenny Root51316382014-05-13 14:59:37 -07001019 if (compiler_filter_string == nullptr) {
Zheng Xu9e06c8c2014-05-06 18:06:07 +01001020 if (instruction_set == kX86_64 || instruction_set == kMips) {
Ian Rogers7ca278b2014-05-01 12:24:37 -07001021 // TODO: implement/fix compilers for these architectures.
Ian Rogersbefbd572014-03-06 01:13:39 -08001022 compiler_filter_string = "interpret-only";
1023 } else if (image) {
Brian Carlstrom5e754d82014-03-05 10:59:04 -08001024 compiler_filter_string = "speed";
Brian Carlstrom6449c622014-02-10 23:48:36 -08001025 } else {
1026#if ART_SMALL_MODE
1027 compiler_filter_string = "interpret-only";
1028#else
1029 compiler_filter_string = "speed";
1030#endif
1031 }
1032 }
1033 CHECK(compiler_filter_string != nullptr);
1034 CompilerOptions::CompilerFilter compiler_filter = CompilerOptions::kDefaultCompilerFilter;
Jeff Hao4a200f52014-04-01 14:58:49 -07001035 if (strcmp(compiler_filter_string, "verify-none") == 0) {
1036 compiler_filter = CompilerOptions::kVerifyNone;
1037 } else if (strcmp(compiler_filter_string, "interpret-only") == 0) {
Brian Carlstrom6449c622014-02-10 23:48:36 -08001038 compiler_filter = CompilerOptions::kInterpretOnly;
1039 } else if (strcmp(compiler_filter_string, "space") == 0) {
1040 compiler_filter = CompilerOptions::kSpace;
1041 } else if (strcmp(compiler_filter_string, "balanced") == 0) {
1042 compiler_filter = CompilerOptions::kBalanced;
1043 } else if (strcmp(compiler_filter_string, "speed") == 0) {
1044 compiler_filter = CompilerOptions::kSpeed;
1045 } else if (strcmp(compiler_filter_string, "everything") == 0) {
1046 compiler_filter = CompilerOptions::kEverything;
1047 } else {
1048 Usage("Unknown --compiler-filter value %s", compiler_filter_string);
1049 }
1050
1051 CompilerOptions compiler_options(compiler_filter,
1052 huge_method_threshold,
1053 large_method_threshold,
1054 small_method_threshold,
1055 tiny_method_threshold,
Mark Mendellae9fd932014-02-10 16:14:35 -08001056 num_dex_methods_threshold,
Dave Allisond6ed6422014-04-09 23:36:15 +00001057 generate_gdb_information
Brian Carlstrom6449c622014-02-10 23:48:36 -08001058#ifdef ART_SEA_IR_MODE
1059 , compiler_options.sea_ir_ = true;
1060#endif
1061 ); // NOLINT(whitespace/parens)
1062
Brian Carlstrom7940e442013-07-12 13:46:57 -07001063 // Done with usage checks, enable watchdog if requested
1064 WatchDog watch_dog(watch_dog_enabled);
1065
1066 // Check early that the result of compilation can be written
1067 UniquePtr<File> oat_file;
1068 bool create_file = !oat_unstripped.empty(); // as opposed to using open file descriptor
1069 if (create_file) {
Brian Carlstrom7571e8b2013-08-12 17:04:14 -07001070 oat_file.reset(OS::CreateEmptyFile(oat_unstripped.c_str()));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001071 if (oat_location.empty()) {
1072 oat_location = oat_filename;
1073 }
1074 } else {
1075 oat_file.reset(new File(oat_fd, oat_location));
1076 oat_file->DisableAutoClose();
1077 }
Kenny Root51316382014-05-13 14:59:37 -07001078 if (oat_file.get() == nullptr) {
Brian Carlstrom7940e442013-07-12 13:46:57 -07001079 PLOG(ERROR) << "Failed to create oat file: " << oat_location;
1080 return EXIT_FAILURE;
1081 }
1082 if (create_file && fchmod(oat_file->Fd(), 0644) != 0) {
1083 PLOG(ERROR) << "Failed to make oat file world readable: " << oat_location;
1084 return EXIT_FAILURE;
1085 }
1086
Ian Rogerse6bb3b22013-08-19 21:51:45 -07001087 timings.StartSplit("dex2oat Setup");
Brian Carlstrom09881a82014-04-18 17:44:01 -07001088 LOG(INFO) << CommandLine();
Brian Carlstrom7940e442013-07-12 13:46:57 -07001089
Brian Carlstrom6449c622014-02-10 23:48:36 -08001090 Runtime::Options runtime_options;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001091 std::vector<const DexFile*> boot_class_path;
1092 if (boot_image_option.empty()) {
Brian Carlstrom3cf59d52013-11-10 21:04:10 -08001093 size_t failure_count = OpenDexFiles(dex_filenames, dex_locations, boot_class_path);
1094 if (failure_count > 0) {
1095 LOG(ERROR) << "Failed to open some dex files: " << failure_count;
1096 return EXIT_FAILURE;
1097 }
Brian Carlstrom6449c622014-02-10 23:48:36 -08001098 runtime_options.push_back(std::make_pair("bootclasspath", &boot_class_path));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001099 } else {
Kenny Root51316382014-05-13 14:59:37 -07001100 runtime_options.push_back(std::make_pair(boot_image_option.c_str(), nullptr));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001101 }
Brian Carlstrom7940e442013-07-12 13:46:57 -07001102 for (size_t i = 0; i < runtime_args.size(); i++) {
Kenny Root51316382014-05-13 14:59:37 -07001103 runtime_options.push_back(std::make_pair(runtime_args[i], nullptr));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001104 }
1105
Brian Carlstrom6449c622014-02-10 23:48:36 -08001106 VerificationResults verification_results(&compiler_options);
1107 DexFileToMethodInlinerMap method_inliner_map;
1108 CompilerCallbacksImpl callbacks(&verification_results, &method_inliner_map);
1109 runtime_options.push_back(std::make_pair("compilercallbacks", &callbacks));
Narayan Kamath11d9f062014-04-23 20:24:57 +01001110 runtime_options.push_back(
1111 std::make_pair("imageinstructionset",
1112 reinterpret_cast<const void*>(GetInstructionSetString(instruction_set))));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001113
Brian Carlstrom7940e442013-07-12 13:46:57 -07001114 Dex2Oat* p_dex2oat;
Brian Carlstrom6449c622014-02-10 23:48:36 -08001115 if (!Dex2Oat::Create(&p_dex2oat,
1116 runtime_options,
1117 compiler_options,
Nicolas Geoffrayb34f69a2014-03-07 15:28:39 +00001118 compiler_kind,
Brian Carlstrom6449c622014-02-10 23:48:36 -08001119 instruction_set,
1120 instruction_set_features,
1121 &verification_results,
1122 &method_inliner_map,
1123 thread_count)) {
Brian Carlstrom7940e442013-07-12 13:46:57 -07001124 LOG(ERROR) << "Failed to create dex2oat";
1125 return EXIT_FAILURE;
1126 }
1127 UniquePtr<Dex2Oat> dex2oat(p_dex2oat);
1128 // Runtime::Create acquired the mutator_lock_ that is normally given away when we Runtime::Start,
Ian Rogers3f3d22c2013-08-27 18:11:09 -07001129 // give it away now so that we don't starve GC.
1130 Thread* self = Thread::Current();
1131 self->TransitionFromRunnableToSuspended(kNative);
Ian Rogers0f40ac32013-08-13 22:10:30 -07001132 // If we're doing the image, override the compiler filter to force full compilation. Must be
buzbeefe9ca402013-08-21 09:48:11 -07001133 // done ahead of WellKnownClasses::Init that causes verification. Note: doesn't force
1134 // compilation of class initializers.
Brian Carlstrom7940e442013-07-12 13:46:57 -07001135 // Whilst we're in native take the opportunity to initialize well known classes.
Ian Rogers3f3d22c2013-08-27 18:11:09 -07001136 WellKnownClasses::Init(self->GetJniEnv());
Brian Carlstrom7940e442013-07-12 13:46:57 -07001137
1138 // If --image-classes was specified, calculate the full list of classes to include in the image
Kenny Rootd5185342014-05-13 14:47:05 -07001139 UniquePtr<CompilerDriver::DescriptorSet> image_classes(nullptr);
1140 if (image_classes_filename != nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001141 std::string error_msg;
Kenny Rootd5185342014-05-13 14:47:05 -07001142 if (image_classes_zip_filename != nullptr) {
Brian Carlstrom7940e442013-07-12 13:46:57 -07001143 image_classes.reset(dex2oat->ReadImageClassesFromZip(image_classes_zip_filename,
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001144 image_classes_filename,
1145 &error_msg));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001146 } else {
1147 image_classes.reset(dex2oat->ReadImageClassesFromFile(image_classes_filename));
1148 }
Kenny Rootd5185342014-05-13 14:47:05 -07001149 if (image_classes.get() == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001150 LOG(ERROR) << "Failed to create list of image classes from '" << image_classes_filename <<
1151 "': " << error_msg;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001152 return EXIT_FAILURE;
1153 }
Kenny Rootd5185342014-05-13 14:47:05 -07001154 } else if (image) {
1155 image_classes.reset(new CompilerDriver::DescriptorSet);
Brian Carlstrom7940e442013-07-12 13:46:57 -07001156 }
1157
1158 std::vector<const DexFile*> dex_files;
1159 if (boot_image_option.empty()) {
1160 dex_files = Runtime::Current()->GetClassLinker()->GetBootClassPath();
1161 } else {
1162 if (dex_filenames.empty()) {
Ian Rogers740a11d2014-01-14 10:11:25 -08001163 ATRACE_BEGIN("Opening zip archive from file descriptor");
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001164 std::string error_msg;
1165 UniquePtr<ZipArchive> zip_archive(ZipArchive::OpenFromFd(zip_fd, zip_location.c_str(),
1166 &error_msg));
Kenny Root51316382014-05-13 14:59:37 -07001167 if (zip_archive.get() == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001168 LOG(ERROR) << "Failed to open zip from file descriptor for '" << zip_location << "': "
1169 << error_msg;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001170 return EXIT_FAILURE;
1171 }
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001172 const DexFile* dex_file = DexFile::Open(*zip_archive.get(), zip_location, &error_msg);
Kenny Root51316382014-05-13 14:59:37 -07001173 if (dex_file == nullptr) {
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001174 LOG(ERROR) << "Failed to open dex from file descriptor for zip file '" << zip_location
1175 << "': " << error_msg;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001176 return EXIT_FAILURE;
1177 }
1178 dex_files.push_back(dex_file);
Ian Rogers740a11d2014-01-14 10:11:25 -08001179 ATRACE_END();
Brian Carlstrom7940e442013-07-12 13:46:57 -07001180 } else {
Brian Carlstrom3cf59d52013-11-10 21:04:10 -08001181 size_t failure_count = OpenDexFiles(dex_filenames, dex_locations, dex_files);
1182 if (failure_count > 0) {
1183 LOG(ERROR) << "Failed to open some dex files: " << failure_count;
1184 return EXIT_FAILURE;
1185 }
Brian Carlstrom7940e442013-07-12 13:46:57 -07001186 }
Brian Carlstromd76e0832013-08-29 15:17:42 -07001187
Brian Carlstromf79fccb2014-02-20 08:55:10 -08001188 const bool kSaveDexInput = false;
1189 if (kSaveDexInput) {
1190 for (size_t i = 0; i < dex_files.size(); ++i) {
1191 const DexFile* dex_file = dex_files[i];
Ian Rogers5180cc12014-02-21 13:34:16 -08001192 std::string tmp_file_name(StringPrintf("/data/local/tmp/dex2oat.%d.%zd.dex", getpid(), i));
Brian Carlstromf79fccb2014-02-20 08:55:10 -08001193 UniquePtr<File> tmp_file(OS::CreateEmptyFile(tmp_file_name.c_str()));
1194 if (tmp_file.get() == nullptr) {
Brian Carlstrom6449c622014-02-10 23:48:36 -08001195 PLOG(ERROR) << "Failed to open file " << tmp_file_name
1196 << ". Try: adb shell chmod 777 /data/local/tmp";
Brian Carlstromf79fccb2014-02-20 08:55:10 -08001197 continue;
1198 }
1199 tmp_file->WriteFully(dex_file->Begin(), dex_file->Size());
1200 LOG(INFO) << "Wrote input to " << tmp_file_name;
1201 }
1202 }
Brian Carlstrom2ec65202014-03-03 15:16:37 -08001203 }
1204 // Ensure opened dex files are writable for dex-to-dex transformations.
1205 for (const auto& dex_file : dex_files) {
1206 if (!dex_file->EnableWrite()) {
1207 PLOG(ERROR) << "Failed to make .dex file writeable '" << dex_file->GetLocation() << "'\n";
Brian Carlstromd76e0832013-08-29 15:17:42 -07001208 }
Brian Carlstrom7940e442013-07-12 13:46:57 -07001209 }
1210
buzbeea024a062013-07-31 10:47:37 -07001211 /*
Jeff Hao4a200f52014-04-01 14:58:49 -07001212 * If we're not in interpret-only or verify-none mode, go ahead and compile small applications.
1213 * Don't bother to check if we're doing the image.
buzbeea024a062013-07-31 10:47:37 -07001214 */
Jeff Hao4a200f52014-04-01 14:58:49 -07001215 if (!image && compiler_options.IsCompilationEnabled()) {
Brian Carlstrom7940e442013-07-12 13:46:57 -07001216 size_t num_methods = 0;
1217 for (size_t i = 0; i != dex_files.size(); ++i) {
1218 const DexFile* dex_file = dex_files[i];
Kenny Root51316382014-05-13 14:59:37 -07001219 CHECK(dex_file != nullptr);
Brian Carlstrom7940e442013-07-12 13:46:57 -07001220 num_methods += dex_file->NumMethodIds();
1221 }
Brian Carlstrom6449c622014-02-10 23:48:36 -08001222 if (num_methods <= compiler_options.GetNumDexMethodsThreshold()) {
1223 compiler_options.SetCompilerFilter(CompilerOptions::kSpeed);
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07001224 VLOG(compiler) << "Below method threshold, compiling anyways";
Brian Carlstrom7940e442013-07-12 13:46:57 -07001225 }
1226 }
1227
1228 UniquePtr<const CompilerDriver> compiler(dex2oat->CreateOatFile(boot_image_option,
Brian Carlstrom7940e442013-07-12 13:46:57 -07001229 android_root,
1230 is_host,
1231 dex_files,
1232 oat_file.get(),
1233 bitcode_filename,
1234 image,
1235 image_classes,
1236 dump_stats,
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +00001237 dump_passes,
1238 timings,
Dave Allison39c3bfb2014-01-28 18:33:52 -08001239 compiler_phases_timings,
1240 profile_file));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001241
Kenny Root51316382014-05-13 14:59:37 -07001242 if (compiler.get() == nullptr) {
Brian Carlstrom7940e442013-07-12 13:46:57 -07001243 LOG(ERROR) << "Failed to create oat file: " << oat_location;
1244 return EXIT_FAILURE;
1245 }
1246
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07001247 VLOG(compiler) << "Oat file written successfully (unstripped): " << oat_location;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001248
1249 // Notes on the interleaving of creating the image and oat file to
1250 // ensure the references between the two are correct.
1251 //
1252 // Currently we have a memory layout that looks something like this:
1253 //
1254 // +--------------+
1255 // | image |
1256 // +--------------+
1257 // | boot oat |
1258 // +--------------+
1259 // | alloc spaces |
1260 // +--------------+
1261 //
Brian Carlstrom45602482013-07-21 22:07:55 -07001262 // There are several constraints on the loading of the image and boot.oat.
Brian Carlstrom7940e442013-07-12 13:46:57 -07001263 //
1264 // 1. The image is expected to be loaded at an absolute address and
1265 // contains Objects with absolute pointers within the image.
1266 //
1267 // 2. There are absolute pointers from Methods in the image to their
1268 // code in the oat.
1269 //
1270 // 3. There are absolute pointers from the code in the oat to Methods
1271 // in the image.
1272 //
1273 // 4. There are absolute pointers from code in the oat to other code
1274 // in the oat.
1275 //
1276 // To get this all correct, we go through several steps.
1277 //
1278 // 1. We have already created that oat file above with
1279 // CreateOatFile. Originally this was just our own proprietary file
Brian Carlstrom45602482013-07-21 22:07:55 -07001280 // but now it is contained within an ELF dynamic object (aka an .so
Brian Carlstrom7940e442013-07-12 13:46:57 -07001281 // file). The Compiler returned by CreateOatFile provides
1282 // PatchInformation for references to oat code and Methods that need
1283 // to be update once we know where the oat file will be located
1284 // after the image.
1285 //
1286 // 2. We create the image file. It needs to know where the oat file
1287 // will be loaded after itself. Originally when oat file was simply
1288 // memory mapped so we could predict where its contents were based
1289 // on the file size. Now that it is an ELF file, we need to inspect
1290 // the ELF file to understand the in memory segment layout including
1291 // where the oat header is located within. ImageWriter's
1292 // PatchOatCodeAndMethods uses the PatchInformation from the
1293 // Compiler to touch up absolute references in the oat file.
1294 //
1295 // 3. We fixup the ELF program headers so that dlopen will try to
1296 // load the .so at the desired location at runtime by offsetting the
1297 // Elf32_Phdr.p_vaddr values by the desired base address.
1298 //
1299 if (image) {
Anwar Ghuloum6f28d912013-07-24 15:02:53 -07001300 timings.NewSplit("dex2oat ImageWriter");
Brian Carlstrom7940e442013-07-12 13:46:57 -07001301 bool image_creation_success = dex2oat->CreateImageFile(image_filename,
1302 image_base,
1303 oat_unstripped,
1304 oat_location,
1305 *compiler.get());
Brian Carlstrom7940e442013-07-12 13:46:57 -07001306 if (!image_creation_success) {
1307 return EXIT_FAILURE;
1308 }
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07001309 VLOG(compiler) << "Image written successfully: " << image_filename;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001310 }
1311
1312 if (is_host) {
Ian Rogers46398602013-08-20 07:50:36 -07001313 if (dump_timing || (dump_slow_timing && timings.GetTotalNs() > MsToNs(1000))) {
Ian Rogers5fe9af72013-11-14 00:17:20 -08001314 LOG(INFO) << Dumpable<TimingLogger>(timings);
Brian Carlstrom45602482013-07-21 22:07:55 -07001315 }
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +00001316 if (dump_passes) {
Ian Rogers3d504072014-03-01 09:16:49 -08001317 LOG(INFO) << Dumpable<CumulativeLogger>(*compiler.get()->GetTimingsLogger());
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +00001318 }
Brian Carlstrom7940e442013-07-12 13:46:57 -07001319 return EXIT_SUCCESS;
1320 }
1321
1322 // If we don't want to strip in place, copy from unstripped location to stripped location.
1323 // We need to strip after image creation because FixupElf needs to use .strtab.
1324 if (oat_unstripped != oat_stripped) {
Anwar Ghuloum6f28d912013-07-24 15:02:53 -07001325 timings.NewSplit("dex2oat OatFile copy");
Brian Carlstrom7940e442013-07-12 13:46:57 -07001326 oat_file.reset();
Brian Carlstrom7571e8b2013-08-12 17:04:14 -07001327 UniquePtr<File> in(OS::OpenFileForReading(oat_unstripped.c_str()));
1328 UniquePtr<File> out(OS::CreateEmptyFile(oat_stripped.c_str()));
Brian Carlstrom7940e442013-07-12 13:46:57 -07001329 size_t buffer_size = 8192;
1330 UniquePtr<uint8_t> buffer(new uint8_t[buffer_size]);
1331 while (true) {
1332 int bytes_read = TEMP_FAILURE_RETRY(read(in->Fd(), buffer.get(), buffer_size));
1333 if (bytes_read <= 0) {
1334 break;
1335 }
1336 bool write_ok = out->WriteFully(buffer.get(), bytes_read);
1337 CHECK(write_ok);
1338 }
1339 oat_file.reset(out.release());
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07001340 VLOG(compiler) << "Oat file copied successfully (stripped): " << oat_stripped;
Brian Carlstrom7940e442013-07-12 13:46:57 -07001341 }
1342
Brian Carlstrom7fcba112013-07-22 10:28:48 -07001343#if ART_USE_PORTABLE_COMPILER // We currently only generate symbols on Portable
Anwar Ghuloum6f28d912013-07-24 15:02:53 -07001344 timings.NewSplit("dex2oat ElfStripper");
Brian Carlstrom7940e442013-07-12 13:46:57 -07001345 // Strip unneeded sections for target
1346 off_t seek_actual = lseek(oat_file->Fd(), 0, SEEK_SET);
1347 CHECK_EQ(0, seek_actual);
Ian Rogers8d31bbd2013-10-13 10:44:14 -07001348 std::string error_msg;
1349 CHECK(ElfStripper::Strip(oat_file.get(), &error_msg)) << error_msg;
Anwar Ghuloum6f28d912013-07-24 15:02:53 -07001350
Brian Carlstrom7940e442013-07-12 13:46:57 -07001351
1352 // We wrote the oat file successfully, and want to keep it.
Anwar Ghuloum75a43f12013-08-13 17:22:14 -07001353 VLOG(compiler) << "Oat file written successfully (stripped): " << oat_location;
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001354#endif // ART_USE_PORTABLE_COMPILER
Brian Carlstrom45602482013-07-21 22:07:55 -07001355
Anwar Ghuloum6f28d912013-07-24 15:02:53 -07001356 timings.EndSplit();
1357
Brian Carlstromc6dfdac2013-08-26 18:57:31 -07001358 if (dump_timing || (dump_slow_timing && timings.GetTotalNs() > MsToNs(1000))) {
Ian Rogers5fe9af72013-11-14 00:17:20 -08001359 LOG(INFO) << Dumpable<TimingLogger>(timings);
Brian Carlstrom45602482013-07-21 22:07:55 -07001360 }
Nicolas Geoffrayea3fa0b2014-02-10 11:59:41 +00001361 if (dump_passes) {
1362 LOG(INFO) << Dumpable<CumulativeLogger>(compiler_phases_timings);
1363 }
Ian Rogers2672a9f2013-09-05 17:24:22 -07001364
1365 // Everything was successfully written, do an explicit exit here to avoid running Runtime
1366 // destructors that take time (bug 10645725) unless we're a debug build or running on valgrind.
Brian Carlstrom6449c622014-02-10 23:48:36 -08001367 if (!kIsDebugBuild && (RUNNING_ON_VALGRIND == 0)) {
Brian Carlstrom65c23bb2014-02-01 22:12:39 -08001368 dex2oat->LogCompletionTime();
Ian Rogers2672a9f2013-09-05 17:24:22 -07001369 exit(EXIT_SUCCESS);
1370 }
1371
Brian Carlstrom7940e442013-07-12 13:46:57 -07001372 return EXIT_SUCCESS;
Brian Carlstrom6449c622014-02-10 23:48:36 -08001373} // NOLINT(readability/fn_size)
Brian Carlstrom7934ac22013-07-26 10:54:15 -07001374} // namespace art
Brian Carlstrom7940e442013-07-12 13:46:57 -07001375
1376int main(int argc, char** argv) {
1377 return art::dex2oat(argc, argv);
1378}