Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 1 | // Copyright 2011 Google Inc. All Rights Reserved. |
| 2 | |
| 3 | #include <stdio.h> |
| 4 | #include <stdlib.h> |
| 5 | |
| 6 | #include <string> |
| 7 | #include <vector> |
| 8 | |
| 9 | #include "class_linker.h" |
| 10 | #include "class_loader.h" |
| 11 | #include "compiler.h" |
| 12 | #include "image_writer.h" |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 13 | #include "oat_writer.h" |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 14 | #include "runtime.h" |
| 15 | #include "stringpiece.h" |
| 16 | |
| 17 | namespace art { |
| 18 | |
| 19 | static void usage() { |
| 20 | fprintf(stderr, |
| 21 | "Usage: dex2oat [options]...\n" |
| 22 | "\n"); |
| 23 | fprintf(stderr, |
Brian Carlstrom | 78128a6 | 2011-09-15 17:21:19 -0700 | [diff] [blame] | 24 | " --dex-file=<dex-file>: specifies a .dex file to compile. At least one .dex\n" |
| 25 | " file must be specified. \n" |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 26 | " Example: --dex-file=/system/framework/core.jar\n" |
| 27 | "\n"); |
| 28 | fprintf(stderr, |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 29 | " --image=<file.art>: specifies the required output image filename.\n" |
Brian Carlstrom | 47a0d5a | 2011-10-12 21:20:05 -0700 | [diff] [blame] | 30 | " Example: --image=/data/art-cache/boot.art\n" |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 31 | "\n"); |
| 32 | // TODO: remove this by inferring from --image |
| 33 | fprintf(stderr, |
| 34 | " --oat=<file.oat>: specifies the required oat filename.\n" |
Brian Carlstrom | 47a0d5a | 2011-10-12 21:20:05 -0700 | [diff] [blame] | 35 | " Example: --image=/data/art-cache/boot.oat\n" |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 36 | "\n"); |
| 37 | fprintf(stderr, |
| 38 | " --base=<hex-address>: specifies the base address when creating a boot image.\n" |
| 39 | " Example: --base=0x50000000\n" |
| 40 | "\n"); |
| 41 | fprintf(stderr, |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 42 | " --boot-image=<file.art>: provide the image file for the boot class path.\n" |
Brian Carlstrom | 47a0d5a | 2011-10-12 21:20:05 -0700 | [diff] [blame] | 43 | " Example: --boot-image=/data/art-cache/boot.art\n" |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 44 | "\n"); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 45 | fprintf(stderr, |
| 46 | " --method may be used to limit compilation to a subset of methods.\n" |
| 47 | " Example: --method=Ljava/lang/Object;<init>()V\n" |
| 48 | "\n"); |
Brian Carlstrom | 1619286 | 2011-09-12 17:50:06 -0700 | [diff] [blame] | 49 | fprintf(stderr, |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 50 | " --host-prefix may be used to translate host paths to target paths during\n" |
| 51 | " cross compilation.\n" |
| 52 | " Example: --host-prefix=out/target/product/crespo\n" |
Brian Carlstrom | 1619286 | 2011-09-12 17:50:06 -0700 | [diff] [blame] | 53 | "\n"); |
Brian Carlstrom | 27ec961 | 2011-09-19 20:20:38 -0700 | [diff] [blame] | 54 | fprintf(stderr, |
| 55 | " -Xms<n> may be used to specify an initial heap size for the runtime used to\n" |
| 56 | " run dex2oat\n" |
| 57 | " Example: -Xms256m\n" |
| 58 | "\n"); |
| 59 | fprintf(stderr, |
| 60 | " -Xmx<n> may be used to specify a maximum heap size for the runtime used to\n" |
| 61 | " run dex2oat\n" |
| 62 | " Example: -Xmx256m\n" |
| 63 | "\n"); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 64 | exit(EXIT_FAILURE); |
| 65 | } |
| 66 | |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 67 | int dex2oat(int argc, char** argv) { |
| 68 | // Skip over argv[0]. |
| 69 | argv++; |
| 70 | argc--; |
| 71 | |
| 72 | if (argc == 0) { |
| 73 | fprintf(stderr, "no arguments specified\n"); |
| 74 | usage(); |
| 75 | } |
| 76 | |
| 77 | std::vector<const char*> dex_filenames; |
| 78 | std::vector<const char*> method_names; |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 79 | std::string oat_filename; |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 80 | const char* image_filename = NULL; |
| 81 | std::string boot_image_option; |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 82 | uintptr_t image_base = 0; |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 83 | std::string host_prefix; |
Brian Carlstrom | 27ec961 | 2011-09-19 20:20:38 -0700 | [diff] [blame] | 84 | const char* Xms = NULL; |
| 85 | const char* Xmx = NULL; |
Brian Carlstrom | 1619286 | 2011-09-12 17:50:06 -0700 | [diff] [blame] | 86 | |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 87 | for (int i = 0; i < argc; i++) { |
| 88 | const StringPiece option(argv[i]); |
Brian Carlstrom | b7bbba4 | 2011-10-13 14:58:47 -0700 | [diff] [blame] | 89 | if (false) { |
| 90 | LOG(INFO) << "dex2oat: option[" << i << "]=" << argv[i]; |
| 91 | } |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 92 | if (option.starts_with("--dex-file=")) { |
| 93 | dex_filenames.push_back(option.substr(strlen("--dex-file=")).data()); |
| 94 | } else if (option.starts_with("--method=")) { |
| 95 | method_names.push_back(option.substr(strlen("--method=")).data()); |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 96 | } else if (option.starts_with("--oat=")) { |
| 97 | oat_filename = option.substr(strlen("--oat=")).data(); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 98 | } else if (option.starts_with("--image=")) { |
| 99 | image_filename = option.substr(strlen("--image=")).data(); |
| 100 | } else if (option.starts_with("--base=")) { |
| 101 | const char* image_base_str = option.substr(strlen("--base=")).data(); |
| 102 | char* end; |
| 103 | image_base = strtoul(image_base_str, &end, 16); |
| 104 | if (end == image_base_str || *end != '\0') { |
Brian Carlstrom | 27ec961 | 2011-09-19 20:20:38 -0700 | [diff] [blame] | 105 | fprintf(stderr, "Failed to parse hexadecimal value for option %s\n", option.data()); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 106 | usage(); |
| 107 | } |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 108 | } else if (option.starts_with("--boot-image=")) { |
| 109 | const char* boot_image_filename = option.substr(strlen("--boot-image=")).data(); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 110 | boot_image_option.clear(); |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 111 | boot_image_option += "-Ximage:"; |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 112 | boot_image_option += boot_image_filename; |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 113 | } else if (option.starts_with("--host-prefix=")) { |
| 114 | host_prefix = option.substr(strlen("--host-prefix=")).data(); |
Brian Carlstrom | 27ec961 | 2011-09-19 20:20:38 -0700 | [diff] [blame] | 115 | } else if (option.starts_with("-Xms")) { |
| 116 | Xms = option.data(); |
| 117 | } else if (option.starts_with("-Xmx")) { |
| 118 | Xmx = option.data(); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 119 | } else { |
| 120 | fprintf(stderr, "unknown argument %s\n", option.data()); |
| 121 | usage(); |
| 122 | } |
| 123 | } |
| 124 | |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 125 | if (oat_filename == NULL) { |
| 126 | fprintf(stderr, "--oat file name not specified\n"); |
| 127 | return EXIT_FAILURE; |
| 128 | } |
| 129 | |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 130 | if (image_filename == NULL && boot_image_option.empty()) { |
| 131 | fprintf(stderr, "Either --image or --boot-image must be specified\n"); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 132 | return EXIT_FAILURE; |
| 133 | } |
| 134 | |
Brian Carlstrom | 78128a6 | 2011-09-15 17:21:19 -0700 | [diff] [blame] | 135 | if (dex_filenames.empty()) { |
| 136 | fprintf(stderr, "no --dex-file values specified\n"); |
| 137 | return EXIT_FAILURE; |
| 138 | } |
| 139 | |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 140 | if (boot_image_option.empty()) { |
| 141 | if (image_base == 0) { |
| 142 | fprintf(stderr, "non-zero --base not specified\n"); |
| 143 | return EXIT_FAILURE; |
| 144 | } |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 145 | } |
| 146 | |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 147 | Runtime::Options options; |
Brian Carlstrom | b7bbba4 | 2011-10-13 14:58:47 -0700 | [diff] [blame] | 148 | std::string boot_class_path_string; |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 149 | if (boot_image_option.empty()) { |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 150 | boot_class_path_string += "-Xbootclasspath:"; |
| 151 | for (size_t i = 0; i < dex_filenames.size()-1; i++) { |
| 152 | boot_class_path_string += dex_filenames[i]; |
| 153 | boot_class_path_string += ":"; |
| 154 | } |
| 155 | boot_class_path_string += dex_filenames[dex_filenames.size()-1]; |
| 156 | options.push_back(std::make_pair(boot_class_path_string.c_str(), reinterpret_cast<void*>(NULL))); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 157 | } else { |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 158 | options.push_back(std::make_pair(boot_image_option.c_str(), reinterpret_cast<void*>(NULL))); |
| 159 | } |
Brian Carlstrom | 27ec961 | 2011-09-19 20:20:38 -0700 | [diff] [blame] | 160 | if (Xms != NULL) { |
| 161 | options.push_back(std::make_pair(Xms, reinterpret_cast<void*>(NULL))); |
| 162 | } |
| 163 | if (Xmx != NULL) { |
| 164 | options.push_back(std::make_pair(Xmx, reinterpret_cast<void*>(NULL))); |
| 165 | } |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 166 | if (!host_prefix.empty()) { |
| 167 | options.push_back(std::make_pair("host-prefix", host_prefix.c_str())); |
| 168 | } |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 169 | UniquePtr<Runtime> runtime(Runtime::Create(options, false)); |
| 170 | if (runtime.get() == NULL) { |
| 171 | fprintf(stderr, "could not create runtime\n"); |
| 172 | return EXIT_FAILURE; |
| 173 | } |
| 174 | ClassLinker* class_linker = runtime->GetClassLinker(); |
| 175 | |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 176 | // If we have an existing boot image, position new space after its oat file |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 177 | if (Heap::GetSpaces().size() > 1) { |
| 178 | Space* last_image_space = Heap::GetSpaces()[Heap::GetSpaces().size()-2]; |
| 179 | CHECK(last_image_space != NULL); |
| 180 | CHECK(last_image_space->IsImageSpace()); |
| 181 | CHECK(!Heap::GetSpaces()[Heap::GetSpaces().size()-1]->IsImageSpace()); |
| 182 | byte* oat_limit_addr = last_image_space->GetImageHeader().GetOatLimitAddr(); |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 183 | image_base = RoundUp(reinterpret_cast<uintptr_t>(oat_limit_addr), kPageSize); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 184 | } |
| 185 | |
| 186 | // ClassLoader creation needs to come after Runtime::Create |
| 187 | const ClassLoader* class_loader; |
| 188 | if (boot_image_option.empty()) { |
| 189 | class_loader = NULL; |
| 190 | } else { |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 191 | std::vector<const DexFile*> dex_files; |
| 192 | DexFile::OpenDexFiles(dex_filenames, dex_files, host_prefix); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 193 | for (size_t i = 0; i < dex_files.size(); i++) { |
| 194 | class_linker->RegisterDexFile(*dex_files[i]); |
| 195 | } |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 196 | class_loader = PathClassLoader::AllocCompileTime(dex_files); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 197 | } |
| 198 | |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 199 | // if we loaded an existing image, we will reuse values from the image roots. |
Brian Carlstrom | 1619286 | 2011-09-12 17:50:06 -0700 | [diff] [blame] | 200 | if (!runtime->HasJniStubArray()) { |
| 201 | runtime->SetJniStubArray(JniCompiler::CreateJniStub(kThumb2)); |
| 202 | } |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 203 | if (!runtime->HasAbstractMethodErrorStubArray()) { |
| 204 | runtime->SetAbstractMethodErrorStubArray(Compiler::CreateAbstractMethodErrorStub(kThumb2)); |
| 205 | } |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 206 | for (int i = 0; i < Runtime::kLastTrampolineMethodType; i++) { |
Ian Rogers | 1cb0a1d | 2011-10-06 15:24:35 -0700 | [diff] [blame] | 207 | Runtime::TrampolineType type = Runtime::TrampolineType(i); |
| 208 | if (!runtime->HasResolutionStubArray(type)) { |
| 209 | runtime->SetResolutionStubArray(Compiler::CreateResolutionStub(kThumb2, type), type); |
| 210 | } |
Ian Rogers | ad25ac5 | 2011-10-04 19:13:33 -0700 | [diff] [blame] | 211 | } |
Ian Rogers | 4f0d07c | 2011-10-06 23:38:47 -0700 | [diff] [blame] | 212 | for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) { |
| 213 | Runtime::CalleeSaveType type = Runtime::CalleeSaveType(i); |
| 214 | if (!runtime->HasCalleeSaveMethod(type)) { |
| 215 | runtime->SetCalleeSaveMethod(runtime->CreateCalleeSaveMethod(kThumb2, type), type); |
| 216 | } |
Ian Rogers | ff1ed47 | 2011-09-20 13:46:24 -0700 | [diff] [blame] | 217 | } |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 218 | Compiler compiler(kThumb2, image_filename != NULL); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 219 | if (method_names.empty()) { |
| 220 | compiler.CompileAll(class_loader); |
| 221 | } else { |
| 222 | for (size_t i = 0; i < method_names.size(); i++) { |
| 223 | // names are actually class_descriptor + name + signature. |
| 224 | // example: Ljava/lang/Object;<init>()V |
| 225 | StringPiece method_name = method_names[i]; |
| 226 | size_t end_of_class_descriptor = method_name.find(';'); |
| 227 | if (end_of_class_descriptor == method_name.npos) { |
| 228 | fprintf(stderr, "could not find class descriptor in method %s\n", method_name.data()); |
| 229 | return EXIT_FAILURE; |
| 230 | } |
| 231 | end_of_class_descriptor++; // want to include ; |
| 232 | std::string class_descriptor = method_name.substr(0, end_of_class_descriptor).ToString(); |
| 233 | size_t end_of_name = method_name.find('(', end_of_class_descriptor); |
| 234 | if (end_of_name == method_name.npos) { |
| 235 | fprintf(stderr, "could not find start of method signature in method %s\n", method_name.data()); |
| 236 | return EXIT_FAILURE; |
| 237 | } |
| 238 | std::string name = method_name.substr(end_of_class_descriptor, |
| 239 | end_of_name - end_of_class_descriptor).ToString(); |
| 240 | std::string signature = method_name.substr(end_of_name).ToString(); |
| 241 | |
| 242 | Class* klass = class_linker->FindClass(class_descriptor, class_loader); |
| 243 | if (klass == NULL) { |
| 244 | fprintf(stderr, "could not find class for descriptor %s in method %s\n", |
| 245 | class_descriptor.c_str(), method_name.data()); |
| 246 | return EXIT_FAILURE; |
| 247 | } |
| 248 | Method* method = klass->FindDirectMethod(name, signature); |
| 249 | if (method == NULL) { |
| 250 | method = klass->FindVirtualMethod(name, signature); |
| 251 | } |
| 252 | if (method == NULL) { |
| 253 | fprintf(stderr, "could not find method %s with signature %s in class %s for method argument %s\n", |
| 254 | name.c_str(), |
| 255 | signature.c_str(), |
| 256 | class_descriptor.c_str(), |
| 257 | method_name.data()); |
| 258 | return EXIT_FAILURE; |
| 259 | } |
| 260 | compiler.CompileOne(method); |
| 261 | } |
| 262 | } |
| 263 | |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 264 | if (!OatWriter::Create(oat_filename, class_loader, compiler)) { |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 265 | fprintf(stderr, "Failed to create oat file %s\n", oat_filename.c_str()); |
| 266 | return EXIT_FAILURE; |
| 267 | } |
| 268 | |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 269 | if (image_filename == NULL) { |
| 270 | return EXIT_SUCCESS; |
| 271 | } |
| 272 | CHECK(compiler.IsImage()); |
| 273 | |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 274 | ImageWriter image_writer; |
Brian Carlstrom | 58ae941 | 2011-10-04 00:56:06 -0700 | [diff] [blame] | 275 | if (!image_writer.Write(image_filename, image_base, oat_filename, host_prefix)) { |
Brian Carlstrom | e24fa61 | 2011-09-29 00:53:55 -0700 | [diff] [blame] | 276 | fprintf(stderr, "Failed to create image file %s\n", image_filename); |
Brian Carlstrom | 69b15fb | 2011-09-03 12:25:21 -0700 | [diff] [blame] | 277 | return EXIT_FAILURE; |
| 278 | } |
| 279 | |
| 280 | return EXIT_SUCCESS; |
| 281 | } |
| 282 | |
| 283 | } // namespace art |
| 284 | |
| 285 | int main(int argc, char** argv) { |
| 286 | return art::dex2oat(argc, argv); |
| 287 | } |