blob: b80b6a6600fac19636b1505961a5a8918af8aa70 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070016
17#include "compiler.h"
18
Elliott Hughesd9c67be2012-02-02 19:54:06 -080019#include <vector>
20
Elliott Hughesb3bd5f02012-03-08 21:05:27 -080021#include <dlfcn.h>
Elliott Hughesd9c67be2012-02-02 19:54:06 -080022#include <unistd.h>
Brian Carlstrom27ec9612011-09-19 20:20:38 -070023
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070024#include "class_linker.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070025#include "class_loader.h"
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070026#include "dex_cache.h"
Brian Carlstrom9baa4ae2011-09-01 21:14:14 -070027#include "jni_internal.h"
Logan Chien4dd96f52012-02-29 01:26:58 +080028#include "oat_compilation_unit.h"
Brian Carlstrom3320cf42011-10-04 14:58:28 -070029#include "oat_file.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070030#include "oat/runtime/stub.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080031#include "object_utils.h"
Brian Carlstrom1f870082011-08-23 16:02:11 -070032#include "runtime.h"
Elliott Hughesb3bd5f02012-03-08 21:05:27 -080033#include "space.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070034#include "scoped_thread_state_change.h"
35#include "ScopedLocalRef.h"
Brian Carlstrom3320cf42011-10-04 14:58:28 -070036#include "stl_util.h"
Elliott Hughes601a1232012-02-02 17:47:38 -080037#include "timing_logger.h"
Ian Rogers776ac1f2012-04-13 23:36:36 -070038#include "verifier/method_verifier.h"
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070039
Elliott Hughes059d5c12012-03-12 17:39:18 -070040#if defined(__APPLE__)
41#include <mach-o/dyld.h>
42#endif
43
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -070044namespace art {
45
Ian Rogers996cc582012-02-14 22:23:29 -080046static double Percentage(size_t x, size_t y) {
Elliott Hughes398f64b2012-03-26 18:05:48 -070047 return 100.0 * (static_cast<double>(x)) / (static_cast<double>(x + y));
Ian Rogers996cc582012-02-14 22:23:29 -080048}
49
50static void DumpStat(size_t x, size_t y, const char* str) {
51 if (x == 0 && y == 0) {
52 return;
53 }
54 LOG(INFO) << Percentage(x, y) << "% of " << str << " for " << (x + y) << " cases";
55}
56
Ian Rogersc8b306f2012-02-17 21:34:44 -080057class AOTCompilationStats {
58 public:
Ian Rogersca190662012-06-26 15:45:57 -070059 AOTCompilationStats()
60 : stats_lock_("AOT compilation statistics lock"),
61 types_in_dex_cache_(0), types_not_in_dex_cache_(0),
62 strings_in_dex_cache_(0), strings_not_in_dex_cache_(0),
63 resolved_types_(0), unresolved_types_(0),
64 resolved_instance_fields_(0), unresolved_instance_fields_(0),
65 resolved_local_static_fields_(0), resolved_static_fields_(0), unresolved_static_fields_(0) {
Ian Rogers2ed3b952012-03-17 11:49:39 -070066 for (size_t i = 0; i <= kMaxInvokeType; i++) {
Ian Rogersc8b306f2012-02-17 21:34:44 -080067 resolved_methods_[i] = 0;
68 unresolved_methods_[i] = 0;
Ian Rogers2ed3b952012-03-17 11:49:39 -070069 virtual_made_direct_[i] = 0;
70 direct_calls_to_boot_[i] = 0;
71 direct_methods_to_boot_[i] = 0;
Elliott Hughesb25c3f62012-03-26 16:35:06 -070072 }
Ian Rogersc8b306f2012-02-17 21:34:44 -080073 }
74
75 void Dump() {
76 DumpStat(types_in_dex_cache_, types_not_in_dex_cache_, "types known to be in dex cache");
77 DumpStat(strings_in_dex_cache_, strings_not_in_dex_cache_, "strings known to be in dex cache");
78 DumpStat(resolved_types_, unresolved_types_, "types resolved");
79 DumpStat(resolved_instance_fields_, unresolved_instance_fields_, "instance fields resolved");
80 DumpStat(resolved_local_static_fields_ + resolved_static_fields_, unresolved_static_fields_,
81 "static fields resolved");
82 DumpStat(resolved_local_static_fields_, resolved_static_fields_ + unresolved_static_fields_,
83 "static fields local to a class");
84
Ian Rogers2ed3b952012-03-17 11:49:39 -070085 for (size_t i = 0; i <= kMaxInvokeType; i++) {
Ian Rogersc8b306f2012-02-17 21:34:44 -080086 std::ostringstream oss;
Ian Rogers2ed3b952012-03-17 11:49:39 -070087 oss << static_cast<InvokeType>(i) << " methods were AOT resolved";
Ian Rogersc8b306f2012-02-17 21:34:44 -080088 DumpStat(resolved_methods_[i], unresolved_methods_[i], oss.str().c_str());
Ian Rogers2ed3b952012-03-17 11:49:39 -070089 if (virtual_made_direct_[i] > 0) {
90 std::ostringstream oss2;
91 oss2 << static_cast<InvokeType>(i) << " methods made direct";
92 DumpStat(virtual_made_direct_[i],
93 resolved_methods_[i] + unresolved_methods_[i] - virtual_made_direct_[i],
94 oss2.str().c_str());
95 }
96 if (direct_calls_to_boot_[i] > 0) {
97 std::ostringstream oss2;
98 oss2 << static_cast<InvokeType>(i) << " method calls are direct into boot";
99 DumpStat(direct_calls_to_boot_[i],
100 resolved_methods_[i] + unresolved_methods_[i] - direct_calls_to_boot_[i],
101 oss2.str().c_str());
102 }
103 if (direct_methods_to_boot_[i] > 0) {
104 std::ostringstream oss2;
105 oss2 << static_cast<InvokeType>(i) << " method calls have methods in boot";
106 DumpStat(direct_methods_to_boot_[i],
107 resolved_methods_[i] + unresolved_methods_[i] - direct_methods_to_boot_[i],
108 oss2.str().c_str());
109 }
Ian Rogersc8b306f2012-02-17 21:34:44 -0800110 }
111 }
Ian Rogers996cc582012-02-14 22:23:29 -0800112
113// Allow lossy statistics in non-debug builds
114#ifndef NDEBUG
115#define STATS_LOCK() MutexLock mu(stats_lock_)
116#else
117#define STATS_LOCK()
118#endif
119
Ian Rogersc8b306f2012-02-17 21:34:44 -0800120 void TypeInDexCache() {
121 STATS_LOCK();
122 types_in_dex_cache_++;
Ian Rogers996cc582012-02-14 22:23:29 -0800123 }
Ian Rogers996cc582012-02-14 22:23:29 -0800124
Ian Rogersc8b306f2012-02-17 21:34:44 -0800125 void TypeNotInDexCache() {
126 STATS_LOCK();
127 types_not_in_dex_cache_++;
Ian Rogers996cc582012-02-14 22:23:29 -0800128 }
Ian Rogersc8b306f2012-02-17 21:34:44 -0800129
130 void StringInDexCache() {
131 STATS_LOCK();
132 strings_in_dex_cache_++;
133 }
134
135 void StringNotInDexCache() {
136 STATS_LOCK();
137 strings_not_in_dex_cache_++;
138 }
139
140 void TypeDoesntNeedAccessCheck() {
141 STATS_LOCK();
142 resolved_types_++;
143 }
144
145 void TypeNeedsAccessCheck() {
146 STATS_LOCK();
147 unresolved_types_++;
148 }
149
150 void ResolvedInstanceField() {
151 STATS_LOCK();
152 resolved_instance_fields_++;
153 }
154
Elliott Hughesb25c3f62012-03-26 16:35:06 -0700155 void UnresolvedInstanceField() {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800156 STATS_LOCK();
157 unresolved_instance_fields_++;
158 }
159
160 void ResolvedLocalStaticField() {
161 STATS_LOCK();
162 resolved_local_static_fields_++;
163 }
164
165 void ResolvedStaticField() {
166 STATS_LOCK();
167 resolved_static_fields_++;
168 }
169
170 void UnresolvedStaticField() {
171 STATS_LOCK();
172 unresolved_static_fields_++;
173 }
174
175 void ResolvedMethod(InvokeType type) {
176 DCHECK_LE(type, kMaxInvokeType);
177 STATS_LOCK();
178 resolved_methods_[type]++;
179 }
180
181 void UnresolvedMethod(InvokeType type) {
182 DCHECK_LE(type, kMaxInvokeType);
183 STATS_LOCK();
184 unresolved_methods_[type]++;
185 }
186
Ian Rogers2ed3b952012-03-17 11:49:39 -0700187 void VirtualMadeDirect(InvokeType type) {
188 DCHECK_LE(type, kMaxInvokeType);
Ian Rogersfb6adba2012-03-04 21:51:51 -0800189 STATS_LOCK();
Ian Rogers2ed3b952012-03-17 11:49:39 -0700190 virtual_made_direct_[type]++;
Ian Rogersfb6adba2012-03-04 21:51:51 -0800191 }
Ian Rogers2ed3b952012-03-17 11:49:39 -0700192
193 void DirectCallsToBoot(InvokeType type) {
194 DCHECK_LE(type, kMaxInvokeType);
195 STATS_LOCK();
196 direct_calls_to_boot_[type]++;
197 }
198
199 void DirectMethodsToBoot(InvokeType type) {
200 DCHECK_LE(type, kMaxInvokeType);
201 STATS_LOCK();
202 direct_methods_to_boot_[type]++;
203 }
204
Ian Rogersc8b306f2012-02-17 21:34:44 -0800205 private:
206 Mutex stats_lock_;
207
208 size_t types_in_dex_cache_;
209 size_t types_not_in_dex_cache_;
210
211 size_t strings_in_dex_cache_;
212 size_t strings_not_in_dex_cache_;
213
214 size_t resolved_types_;
215 size_t unresolved_types_;
216
217 size_t resolved_instance_fields_;
218 size_t unresolved_instance_fields_;
219
220 size_t resolved_local_static_fields_;
221 size_t resolved_static_fields_;
222 size_t unresolved_static_fields_;
223
224 size_t resolved_methods_[kMaxInvokeType + 1];
225 size_t unresolved_methods_[kMaxInvokeType + 1];
Ian Rogers2ed3b952012-03-17 11:49:39 -0700226 size_t virtual_made_direct_[kMaxInvokeType + 1];
227 size_t direct_calls_to_boot_[kMaxInvokeType + 1];
228 size_t direct_methods_to_boot_[kMaxInvokeType + 1];
Ian Rogersc8b306f2012-02-17 21:34:44 -0800229
Elliott Hughesb25c3f62012-03-26 16:35:06 -0700230 DISALLOW_COPY_AND_ASSIGN(AOTCompilationStats);
Ian Rogersc8b306f2012-02-17 21:34:44 -0800231};
Ian Rogers996cc582012-02-14 22:23:29 -0800232
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800233static std::string MakeCompilerSoName(InstructionSet instruction_set) {
234 // TODO: is the ARM/Thumb2 instruction set distinction really buying us anything,
235 // or just causing hassle like this?
236 if (instruction_set == kThumb2) {
237 instruction_set = kArm;
238 }
239
Brian Carlstrom5644f002012-06-27 23:05:17 -0700240 // Lower case the instruction set, because that's what we do in the build system.
Elliott Hughes6fcce302012-06-19 16:54:19 -0700241 std::string instruction_set_name(ToStr<InstructionSet>(instruction_set).str());
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800242 for (size_t i = 0; i < instruction_set_name.size(); ++i) {
Brian Carlstrom5644f002012-06-27 23:05:17 -0700243 instruction_set_name[i] = tolower(instruction_set_name[i]);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800244 }
Elliott Hughes059d5c12012-03-12 17:39:18 -0700245
246 // Bad things happen if we pull in the libartd-compiler to a libart dex2oat or vice versa,
247 // because we end up with both libart and libartd in the same address space!
Elliott Hughes67d92002012-03-26 15:08:51 -0700248 const char* suffix = (kIsDebugBuild ? "d" : "");
Elliott Hughes059d5c12012-03-12 17:39:18 -0700249
250 // Work out the filename for the compiler library.
Shih-wei Liaoe94d9b22012-05-22 09:01:24 -0700251#if defined(ART_USE_LLVM_COMPILER)
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800252 std::string library_name(StringPrintf("art%s-compiler-llvm", suffix));
Shih-wei Liaoe94d9b22012-05-22 09:01:24 -0700253#elif defined(ART_USE_GREENLAND_COMPILER)
254 std::string library_name(StringPrintf("art%s-compiler-greenland", suffix));
255#else
256 std::string library_name(StringPrintf("art%s-compiler-%s", suffix, instruction_set_name.c_str()));
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800257#endif
Elliott Hughes059d5c12012-03-12 17:39:18 -0700258 std::string filename(StringPrintf(OS_SHARED_LIB_FORMAT_STR, library_name.c_str()));
259
260#if defined(__APPLE__)
261 // On Linux, dex2oat will have been built with an RPATH of $ORIGIN/../lib, so dlopen(3) will find
262 // the .so by itself. On Mac OS, there isn't really an equivalent, so we have to manually do the
263 // same work.
Elliott Hughes059d5c12012-03-12 17:39:18 -0700264 uint32_t executable_path_length = 0;
Elliott Hughes448e93c2012-03-28 22:30:06 -0700265 _NSGetExecutablePath(NULL, &executable_path_length);
266 std::string path(executable_path_length, static_cast<char>(0));
267 CHECK_EQ(_NSGetExecutablePath(&path[0], &executable_path_length), 0);
Elliott Hughes059d5c12012-03-12 17:39:18 -0700268
269 // Strip the "/dex2oat".
270 size_t last_slash = path.find_last_of('/');
271 CHECK_NE(last_slash, std::string::npos) << path;
272 path.resize(last_slash);
273
274 // Strip the "/bin".
275 last_slash = path.find_last_of('/');
276 path.resize(last_slash);
277
278 filename = path + "/lib/" + filename;
279#endif
280 return filename;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800281}
282
Elliott Hughes46f060a2012-03-09 17:36:50 -0800283template<typename Fn>
284static Fn FindFunction(const std::string& compiler_so_name, void* library, const char* name) {
285 Fn fn = reinterpret_cast<Fn>(dlsym(library, name));
286 if (fn == NULL) {
287 LOG(FATAL) << "Couldn't find \"" << name << "\" in compiler library " << compiler_so_name << ": " << dlerror();
288 }
Elliott Hughes059d5c12012-03-12 17:39:18 -0700289 VLOG(compiler) << "Found \"" << name << "\" at " << reinterpret_cast<void*>(fn);
Elliott Hughes46f060a2012-03-09 17:36:50 -0800290 return fn;
291}
292
Elliott Hughes5523ee02012-02-03 18:18:34 -0800293Compiler::Compiler(InstructionSet instruction_set, bool image, size_t thread_count,
Brian Carlstromba0668e2012-03-26 13:14:07 -0700294 bool support_debugging, const std::set<std::string>* image_classes,
295 bool dump_stats, bool dump_timings)
Brian Carlstromaded5f72011-10-07 17:15:04 -0700296 : instruction_set_(instruction_set),
Elliott Hughesc225caa2012-02-03 15:43:37 -0800297 compiled_classes_lock_("compiled classes lock"),
298 compiled_methods_lock_("compiled method lock"),
299 compiled_invoke_stubs_lock_("compiled invoke stubs lock"),
Logan Chien7a2a23a2012-06-06 11:01:00 +0800300#if defined(ART_USE_LLVM_COMPILER)
301 compiled_proxy_stubs_lock_("compiled proxy stubs lock"),
302#endif
Brian Carlstromaded5f72011-10-07 17:15:04 -0700303 image_(image),
Elliott Hughes5523ee02012-02-03 18:18:34 -0800304 thread_count_(thread_count),
Elliott Hughesde6e4cf2012-02-27 14:46:06 -0800305 support_debugging_(support_debugging),
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700306 start_ns_(0),
Ian Rogersc8b306f2012-02-17 21:34:44 -0800307 stats_(new AOTCompilationStats),
Brian Carlstromba0668e2012-03-26 13:14:07 -0700308 dump_stats_(dump_stats),
309 dump_timings_(dump_timings),
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800310 image_classes_(image_classes),
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800311 compiler_library_(NULL),
Elliott Hughes46f060a2012-03-09 17:36:50 -0800312 compiler_(NULL),
Elliott Hughes6f4976c2012-03-13 21:19:01 -0700313 compiler_context_(NULL),
Elliott Hughes46f060a2012-03-09 17:36:50 -0800314 jni_compiler_(NULL),
Logan Chien971bf3f2012-05-01 15:47:55 +0800315 create_invoke_stub_(NULL)
316{
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800317 std::string compiler_so_name(MakeCompilerSoName(instruction_set_));
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800318 compiler_library_ = dlopen(compiler_so_name.c_str(), RTLD_LAZY);
319 if (compiler_library_ == NULL) {
320 LOG(FATAL) << "Couldn't find compiler library " << compiler_so_name << ": " << dlerror();
321 }
322 VLOG(compiler) << "dlopen(\"" << compiler_so_name << "\", RTLD_LAZY) returned " << compiler_library_;
323
Shih-wei Liaoe94d9b22012-05-22 09:01:24 -0700324#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_GREENLAND_COMPILER)
Logan Chien106b2a02012-03-18 04:41:38 +0800325 // Initialize compiler_context_
326 typedef void (*InitCompilerContextFn)(Compiler&);
327
328 InitCompilerContextFn init_compiler_context =
329 FindFunction<void (*)(Compiler&)>(compiler_so_name,
330 compiler_library_,
331 "ArtInitCompilerContext");
332
333 init_compiler_context(*this);
buzbee692be802012-08-29 15:52:59 -0700334#elif defined(ART_USE_QUICK_COMPILER)
335 // Initialize compiler_context_
336 typedef void (*InitCompilerContextFn)(Compiler&);
337
338 InitCompilerContextFn init_compiler_context =
339 FindFunction<void (*)(Compiler&)>(compiler_so_name,
340 compiler_library_,
341 "ArtInitQuickCompilerContext");
342
343 init_compiler_context(*this);
Logan Chien106b2a02012-03-18 04:41:38 +0800344#endif
345
Elliott Hughes3fa1b7e2012-03-13 17:06:22 -0700346 compiler_ = FindFunction<CompilerFn>(compiler_so_name, compiler_library_, "ArtCompileMethod");
Elliott Hughes46f060a2012-03-09 17:36:50 -0800347 jni_compiler_ = FindFunction<JniCompilerFn>(compiler_so_name, compiler_library_, "ArtJniCompileMethod");
348 create_invoke_stub_ = FindFunction<CreateInvokeStubFn>(compiler_so_name, compiler_library_, "ArtCreateInvokeStub");
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800349
Logan Chienf7015fd2012-03-18 01:19:37 +0800350#if defined(ART_USE_LLVM_COMPILER)
Logan Chien7a2a23a2012-06-06 11:01:00 +0800351 create_proxy_stub_ = FindFunction<CreateProxyStubFn>(
352 compiler_so_name, compiler_library_, "ArtCreateProxyStub");
Logan Chienf7015fd2012-03-18 01:19:37 +0800353#endif
354
Brian Carlstrom25c33252011-09-18 15:58:35 -0700355 CHECK(!Runtime::Current()->IsStarted());
Brian Carlstromae826982011-11-09 01:33:42 -0800356 if (!image_) {
357 CHECK(image_classes_ == NULL);
358 }
Shih-wei Liaoc486c112011-09-13 16:43:52 -0700359}
360
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700361Compiler::~Compiler() {
Elliott Hughesc225caa2012-02-03 15:43:37 -0800362 {
363 MutexLock mu(compiled_classes_lock_);
364 STLDeleteValues(&compiled_classes_);
365 }
366 {
367 MutexLock mu(compiled_methods_lock_);
368 STLDeleteValues(&compiled_methods_);
369 }
370 {
371 MutexLock mu(compiled_invoke_stubs_lock_);
372 STLDeleteValues(&compiled_invoke_stubs_);
Elliott Hughesbb551fa2012-01-25 16:35:29 -0800373 }
Brian Carlstromd06dfe72012-06-06 22:15:39 -0700374#if defined(ART_USE_LLVM_COMPILER)
Brian Carlstromf5822582012-03-19 22:34:31 -0700375 {
Logan Chien7a2a23a2012-06-06 11:01:00 +0800376 MutexLock mu(compiled_proxy_stubs_lock_);
377 STLDeleteValues(&compiled_proxy_stubs_);
378 }
Brian Carlstromd06dfe72012-06-06 22:15:39 -0700379#endif
Logan Chien7a2a23a2012-06-06 11:01:00 +0800380 {
Brian Carlstromf5822582012-03-19 22:34:31 -0700381 MutexLock mu(compiled_methods_lock_);
382 STLDeleteElements(&code_to_patch_);
383 }
384 {
385 MutexLock mu(compiled_methods_lock_);
386 STLDeleteElements(&methods_to_patch_);
387 }
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800388#if defined(ART_USE_LLVM_COMPILER)
Logan Chien971bf3f2012-05-01 15:47:55 +0800389 // Uninitialize compiler_context_
390 typedef void (*UninitCompilerContextFn)(Compiler&);
391
392 std::string compiler_so_name(MakeCompilerSoName(instruction_set_));
393
394 UninitCompilerContextFn uninit_compiler_context =
395 FindFunction<void (*)(Compiler&)>(compiler_so_name,
396 compiler_library_,
397 "ArtUnInitCompilerContext");
398
399 uninit_compiler_context(*this);
buzbee692be802012-08-29 15:52:59 -0700400#elif defined(ART_USE_QUICK_COMPILER)
401 // Uninitialize compiler_context_
402 typedef void (*UninitCompilerContextFn)(Compiler&);
403
404 std::string compiler_so_name(MakeCompilerSoName(instruction_set_));
405
406 UninitCompilerContextFn uninit_compiler_context =
407 FindFunction<void (*)(Compiler&)>(compiler_so_name,
408 compiler_library_,
409 "ArtUnInitQuickCompilerContext");
410
411 uninit_compiler_context(*this);
Shih-wei Liaoc4c98812012-03-10 21:55:51 -0800412#endif
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800413 if (compiler_library_ != NULL) {
414 VLOG(compiler) << "dlclose(" << compiler_library_ << ")";
buzbeeca7a5e42012-08-20 11:12:18 -0700415#if !defined(ART_USE_QUICK_COMPILER)
416 /*
417 * FIXME: Temporary workaround
418 * Apparently, llvm is adding dctors to atexit, but if we unload
419 * the library here the code will no longer be around at exit time
420 * and we die a flaming death in __cxa_finalize(). Apparently, some
421 * dlclose() implementations will scan the atexit list on unload and
422 * handle any associated with the soon-to-be-unloaded library.
423 * However, this is not required by POSIX and we don't do it.
424 * See: http://b/issue?id=4998315
425 * What's the right thing to do here?
426 */
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800427 dlclose(compiler_library_);
buzbeeca7a5e42012-08-20 11:12:18 -0700428#endif
Elliott Hughesb3bd5f02012-03-08 21:05:27 -0800429 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700430}
431
Ian Rogers1cb0a1d2011-10-06 15:24:35 -0700432ByteArray* Compiler::CreateResolutionStub(InstructionSet instruction_set,
433 Runtime::TrampolineType type) {
jeffhao7fbee072012-08-24 17:56:54 -0700434 switch (instruction_set) {
435 case kArm:
436 case kThumb2:
437 return arm::ArmCreateResolutionTrampoline(type);
438 case kMips:
439 return mips::MipsCreateResolutionTrampoline(type);
440 case kX86:
441 return x86::X86CreateResolutionTrampoline(type);
442 default:
443 LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
444 return NULL;
Ian Rogersad25ac52011-10-04 19:13:33 -0700445 }
446}
447
Elliott Hughes8add92d2012-01-18 18:18:43 -0800448ByteArray* Compiler::CreateJniDlsymLookupStub(InstructionSet instruction_set) {
Ian Rogers169c9a72011-11-13 20:13:17 -0800449 switch (instruction_set) {
450 case kArm:
451 case kThumb2:
Elliott Hughes8add92d2012-01-18 18:18:43 -0800452 return arm::CreateJniDlsymLookupStub();
jeffhao7fbee072012-08-24 17:56:54 -0700453 case kMips:
454 return mips::CreateJniDlsymLookupStub();
Ian Rogers169c9a72011-11-13 20:13:17 -0800455 case kX86:
Elliott Hughes8add92d2012-01-18 18:18:43 -0800456 return x86::CreateJniDlsymLookupStub();
Ian Rogers169c9a72011-11-13 20:13:17 -0800457 default:
Ian Rogers49c48942012-03-11 15:15:37 -0700458 LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
Ian Rogers169c9a72011-11-13 20:13:17 -0800459 return NULL;
460 }
461}
462
Ian Rogersad25ac52011-10-04 19:13:33 -0700463ByteArray* Compiler::CreateAbstractMethodErrorStub(InstructionSet instruction_set) {
jeffhao7fbee072012-08-24 17:56:54 -0700464 switch (instruction_set) {
465 case kArm:
466 case kThumb2:
467 return arm::CreateAbstractMethodErrorStub();
468 case kMips:
469 return mips::CreateAbstractMethodErrorStub();
470 case kX86:
471 return x86::CreateAbstractMethodErrorStub();
472 default:
473 LOG(FATAL) << "Unknown InstructionSet: " << instruction_set;
474 return NULL;
Ian Rogersad25ac52011-10-04 19:13:33 -0700475 }
476}
477
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700478void Compiler::CompileAll(jobject class_loader,
Brian Carlstromae826982011-11-09 01:33:42 -0800479 const std::vector<const DexFile*>& dex_files) {
Brian Carlstrom25c33252011-09-18 15:58:35 -0700480 DCHECK(!Runtime::Current()->IsStarted());
Brian Carlstromae826982011-11-09 01:33:42 -0800481
Elliott Hughes601a1232012-02-02 17:47:38 -0800482 TimingLogger timings("compiler");
483
484 PreCompile(class_loader, dex_files, timings);
485
Brian Carlstromae826982011-11-09 01:33:42 -0800486 Compile(class_loader, dex_files);
Elliott Hughes601a1232012-02-02 17:47:38 -0800487 timings.AddSplit("Compile");
488
Brian Carlstromae826982011-11-09 01:33:42 -0800489 PostCompile(class_loader, dex_files);
Elliott Hughes601a1232012-02-02 17:47:38 -0800490 timings.AddSplit("PostCompile");
491
Brian Carlstromba0668e2012-03-26 13:14:07 -0700492 if (dump_timings_ && timings.GetTotalNs() > MsToNs(1000)) {
Elliott Hughes601a1232012-02-02 17:47:38 -0800493 timings.Dump();
494 }
Ian Rogers996cc582012-02-14 22:23:29 -0800495
Brian Carlstromba0668e2012-03-26 13:14:07 -0700496 if (dump_stats_) {
497 stats_->Dump();
498 }
Brian Carlstrom8a487412011-08-29 20:08:52 -0700499}
500
Brian Carlstrom3320cf42011-10-04 14:58:28 -0700501void Compiler::CompileOne(const Method* method) {
Brian Carlstrom25c33252011-09-18 15:58:35 -0700502 DCHECK(!Runtime::Current()->IsStarted());
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700503 Thread* self = Thread::Current();
504 jobject class_loader;
505 const DexCache* dex_cache;
506 const DexFile* dex_file;
507 {
508 ScopedObjectAccessUnchecked soa(self);
509 ScopedLocalRef<jobject>
510 local_class_loader(soa.Env(),
511 soa.AddLocalReference<jobject>(method->GetDeclaringClass()->GetClassLoader()));
512 class_loader = soa.Env()->NewGlobalRef(local_class_loader.get());
513 // Find the dex_file
514 dex_cache = method->GetDeclaringClass()->GetDexCache();
515 dex_file = &Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
516 }
517 self->TransitionFromRunnableToSuspended(kNative);
Brian Carlstromae826982011-11-09 01:33:42 -0800518
Brian Carlstromae826982011-11-09 01:33:42 -0800519 std::vector<const DexFile*> dex_files;
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700520 dex_files.push_back(dex_file);
Brian Carlstromae826982011-11-09 01:33:42 -0800521
Elliott Hughes601a1232012-02-02 17:47:38 -0800522 TimingLogger timings("CompileOne");
523 PreCompile(class_loader, dex_files, timings);
Brian Carlstromae826982011-11-09 01:33:42 -0800524
Ian Rogers0571d352011-11-03 19:51:38 -0700525 uint32_t method_idx = method->GetDexMethodIndex();
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700526 const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset());
Ian Rogers08f753d2012-08-24 14:35:25 -0700527 CompileMethod(code_item, method->GetAccessFlags(), method->GetInvokeType(),
528 method_idx, class_loader, *dex_file);
Brian Carlstromae826982011-11-09 01:33:42 -0800529
530 PostCompile(class_loader, dex_files);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700531
532 self->GetJniEnv()->DeleteGlobalRef(class_loader);
533
534 self->TransitionFromSuspendedToRunnable();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700535}
536
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700537void Compiler::Resolve(jobject class_loader, const std::vector<const DexFile*>& dex_files,
538 TimingLogger& timings) {
Brian Carlstromae826982011-11-09 01:33:42 -0800539 for (size_t i = 0; i != dex_files.size(); ++i) {
540 const DexFile* dex_file = dex_files[i];
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700541 CHECK(dex_file != NULL);
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800542 ResolveDexFile(class_loader, *dex_file, timings);
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700543 }
544}
545
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700546void Compiler::PreCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files,
547 TimingLogger& timings) {
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800548 Resolve(class_loader, dex_files, timings);
Elliott Hughes601a1232012-02-02 17:47:38 -0800549
Brian Carlstromae826982011-11-09 01:33:42 -0800550 Verify(class_loader, dex_files);
Elliott Hughes601a1232012-02-02 17:47:38 -0800551 timings.AddSplit("PreCompile.Verify");
552
Brian Carlstromae826982011-11-09 01:33:42 -0800553 InitializeClassesWithoutClinit(class_loader, dex_files);
Elliott Hughes601a1232012-02-02 17:47:38 -0800554 timings.AddSplit("PreCompile.InitializeClassesWithoutClinit");
Brian Carlstromae826982011-11-09 01:33:42 -0800555}
556
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700557void Compiler::PostCompile(jobject class_loader, const std::vector<const DexFile*>& dex_files) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -0800558 SetGcMaps(class_loader, dex_files);
Brian Carlstromae826982011-11-09 01:33:42 -0800559}
560
561bool Compiler::IsImageClass(const std::string& descriptor) const {
562 if (image_classes_ == NULL) {
563 return true;
564 }
565 return image_classes_->find(descriptor) != image_classes_->end();
566}
567
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700568bool Compiler::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file,
Ian Rogers996cc582012-02-14 22:23:29 -0800569 uint32_t type_idx) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700570 ScopedObjectAccess soa(Thread::Current());
571 DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800572 if (!IsImage()) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800573 stats_->TypeNotInDexCache();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800574 return false;
575 }
Ian Rogers1bddec32012-02-04 12:27:34 -0800576 Class* resolved_class = dex_cache->GetResolvedType(type_idx);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800577 if (resolved_class == NULL) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800578 stats_->TypeNotInDexCache();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800579 return false;
580 }
Ian Rogers996cc582012-02-14 22:23:29 -0800581 bool result = IsImageClass(ClassHelper(resolved_class).GetDescriptor());
582 if (result) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800583 stats_->TypeInDexCache();
Ian Rogers996cc582012-02-14 22:23:29 -0800584 } else {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800585 stats_->TypeNotInDexCache();
Ian Rogers996cc582012-02-14 22:23:29 -0800586 }
587 return result;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800588}
589
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700590bool Compiler::CanAssumeStringIsPresentInDexCache(const DexFile& dex_file,
Ian Rogers996cc582012-02-14 22:23:29 -0800591 uint32_t string_idx) {
Ian Rogers1bddec32012-02-04 12:27:34 -0800592 // TODO: Add support for loading strings referenced by image_classes_
593 // See also Compiler::ResolveDexFile
594
595 // The following is a test saying that if we're building the image without a restricted set of
596 // image classes then we can assume the string is present in the dex cache if it is there now
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700597 bool result = IsImage() && image_classes_ == NULL;
598 if (result) {
599 ScopedObjectAccess soa(Thread::Current());
600 DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
601 result = dex_cache->GetResolvedString(string_idx) != NULL;
602 }
Ian Rogers996cc582012-02-14 22:23:29 -0800603 if (result) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800604 stats_->StringInDexCache();
Ian Rogers996cc582012-02-14 22:23:29 -0800605 } else {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800606 stats_->StringNotInDexCache();
Ian Rogers996cc582012-02-14 22:23:29 -0800607 }
608 return result;
Ian Rogers1bddec32012-02-04 12:27:34 -0800609}
610
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700611bool Compiler::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
612 uint32_t type_idx) {
613 ScopedObjectAccess soa(Thread::Current());
614 DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
Ian Rogers1bddec32012-02-04 12:27:34 -0800615 // Get type from dex cache assuming it was populated by the verifier
616 Class* resolved_class = dex_cache->GetResolvedType(type_idx);
617 if (resolved_class == NULL) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800618 stats_->TypeNeedsAccessCheck();
Ian Rogers1bddec32012-02-04 12:27:34 -0800619 return false; // Unknown class needs access checks.
620 }
621 const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
622 Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
623 if (referrer_class == NULL) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800624 stats_->TypeNeedsAccessCheck();
Ian Rogers1bddec32012-02-04 12:27:34 -0800625 return false; // Incomplete referrer knowledge needs access check.
626 }
627 // Perform access check, will return true if access is ok or false if we're going to have to
628 // check this at runtime (for example for class loaders).
Ian Rogers996cc582012-02-14 22:23:29 -0800629 bool result = referrer_class->CanAccess(resolved_class);
630 if (result) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800631 stats_->TypeDoesntNeedAccessCheck();
Ian Rogers996cc582012-02-14 22:23:29 -0800632 } else {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800633 stats_->TypeNeedsAccessCheck();
Ian Rogers996cc582012-02-14 22:23:29 -0800634 }
635 return result;
Ian Rogers1bddec32012-02-04 12:27:34 -0800636}
637
638bool Compiler::CanAccessInstantiableTypeWithoutChecks(uint32_t referrer_idx,
Ian Rogers1bddec32012-02-04 12:27:34 -0800639 const DexFile& dex_file,
Ian Rogers996cc582012-02-14 22:23:29 -0800640 uint32_t type_idx) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700641 ScopedObjectAccess soa(Thread::Current());
642 DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
Ian Rogers1bddec32012-02-04 12:27:34 -0800643 // Get type from dex cache assuming it was populated by the verifier.
644 Class* resolved_class = dex_cache->GetResolvedType(type_idx);
645 if (resolved_class == NULL) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800646 stats_->TypeNeedsAccessCheck();
Ian Rogers1bddec32012-02-04 12:27:34 -0800647 return false; // Unknown class needs access checks.
648 }
649 const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
650 Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
651 if (referrer_class == NULL) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800652 stats_->TypeNeedsAccessCheck();
Ian Rogers1bddec32012-02-04 12:27:34 -0800653 return false; // Incomplete referrer knowledge needs access check.
654 }
655 // Perform access and instantiable checks, will return true if access is ok or false if we're
656 // going to have to check this at runtime (for example for class loaders).
Ian Rogers996cc582012-02-14 22:23:29 -0800657 bool result = referrer_class->CanAccess(resolved_class) && resolved_class->IsInstantiable();
658 if (result) {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800659 stats_->TypeDoesntNeedAccessCheck();
Ian Rogers996cc582012-02-14 22:23:29 -0800660 } else {
Ian Rogersc8b306f2012-02-17 21:34:44 -0800661 stats_->TypeNeedsAccessCheck();
Ian Rogers996cc582012-02-14 22:23:29 -0800662 }
663 return result;
Ian Rogers1bddec32012-02-04 12:27:34 -0800664}
665
Ian Rogers08f753d2012-08-24 14:35:25 -0700666static Class* ComputeCompilingMethodsClass(ScopedObjectAccess& soa,
667 OatCompilationUnit* mUnit)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700668 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700669 DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
670 ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
671 const DexFile::MethodId& referrer_method_id = mUnit->dex_file_->GetMethodId(mUnit->method_idx_);
672 return mUnit->class_linker_->ResolveType(*mUnit->dex_file_, referrer_method_id.class_idx_,
673 dex_cache, class_loader);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800674}
675
Ian Rogers08f753d2012-08-24 14:35:25 -0700676static Field* ComputeFieldReferencedFromCompilingMethod(ScopedObjectAccess& soa,
677 OatCompilationUnit* mUnit,
678 uint32_t field_idx)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700679 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700680 DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
681 ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
682 return mUnit->class_linker_->ResolveField(*mUnit->dex_file_, field_idx, dex_cache,
683 class_loader, false);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800684}
685
Ian Rogers08f753d2012-08-24 14:35:25 -0700686static Method* ComputeMethodReferencedFromCompilingMethod(ScopedObjectAccess& soa,
687 OatCompilationUnit* mUnit,
688 uint32_t method_idx,
689 InvokeType type)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700690 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700691 DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
692 ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
693 return mUnit->class_linker_->ResolveMethod(*mUnit->dex_file_, method_idx, dex_cache,
jeffhaoc0228b82012-08-29 18:15:05 -0700694 class_loader, NULL, type);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800695}
696
Logan Chien4dd96f52012-02-29 01:26:58 +0800697bool Compiler::ComputeInstanceFieldInfo(uint32_t field_idx, OatCompilationUnit* mUnit,
jeffhao8cd6dda2012-02-22 10:15:34 -0800698 int& field_offset, bool& is_volatile, bool is_put) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700699 ScopedObjectAccess soa(Thread::Current());
Ian Rogers08f753d2012-08-24 14:35:25 -0700700 // Conservative defaults.
Ian Rogers1bddec32012-02-04 12:27:34 -0800701 field_offset = -1;
702 is_volatile = true;
Ian Rogers08f753d2012-08-24 14:35:25 -0700703 // Try to resolve field and ignore if an Incompatible Class Change Error (ie is static).
704 Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
705 if (resolved_field != NULL && !resolved_field->IsStatic()) {
706 Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
Ian Rogerse2645d32012-04-11 14:42:42 -0700707 if (referrer_class != NULL) {
708 Class* fields_class = resolved_field->GetDeclaringClass();
709 bool access_ok = referrer_class->CanAccess(fields_class) &&
710 referrer_class->CanAccessMember(fields_class,
711 resolved_field->GetAccessFlags());
712 if (!access_ok) {
713 // The referring class can't access the resolved field, this may occur as a result of a
714 // protected field being made public by a sub-class. Resort to the dex file to determine
715 // the correct class for the access check.
716 const DexFile& dex_file = mUnit->class_linker_->FindDexFile(referrer_class->GetDexCache());
717 Class* dex_fields_class = mUnit->class_linker_->ResolveType(dex_file,
718 dex_file.GetFieldId(field_idx).class_idx_,
719 referrer_class);
720 access_ok = referrer_class->CanAccess(dex_fields_class) &&
721 referrer_class->CanAccessMember(dex_fields_class,
722 resolved_field->GetAccessFlags());
723 }
724 bool is_write_to_final_from_wrong_class = is_put && resolved_field->IsFinal() &&
725 fields_class != referrer_class;
726 if (access_ok && !is_write_to_final_from_wrong_class) {
727 field_offset = resolved_field->GetOffset().Int32Value();
728 is_volatile = resolved_field->IsVolatile();
729 stats_->ResolvedInstanceField();
730 return true; // Fast path.
731 }
Ian Rogers1bddec32012-02-04 12:27:34 -0800732 }
733 }
734 // Clean up any exception left by field/type resolution
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700735 if (soa.Self()->IsExceptionPending()) {
736 soa.Self()->ClearException();
Ian Rogers1bddec32012-02-04 12:27:34 -0800737 }
Ian Rogersc8b306f2012-02-17 21:34:44 -0800738 stats_->UnresolvedInstanceField();
Ian Rogers1bddec32012-02-04 12:27:34 -0800739 return false; // Incomplete knowledge needs slow path.
740}
741
Logan Chien4dd96f52012-02-29 01:26:58 +0800742bool Compiler::ComputeStaticFieldInfo(uint32_t field_idx, OatCompilationUnit* mUnit,
Ian Rogers1bddec32012-02-04 12:27:34 -0800743 int& field_offset, int& ssb_index,
jeffhao8cd6dda2012-02-22 10:15:34 -0800744 bool& is_referrers_class, bool& is_volatile, bool is_put) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700745 ScopedObjectAccess soa(Thread::Current());
Ian Rogers08f753d2012-08-24 14:35:25 -0700746 // Conservative defaults.
Ian Rogers1bddec32012-02-04 12:27:34 -0800747 field_offset = -1;
748 ssb_index = -1;
749 is_referrers_class = false;
750 is_volatile = true;
Ian Rogers08f753d2012-08-24 14:35:25 -0700751 // Try to resolve field and ignore if an Incompatible Class Change Error (ie isn't static).
752 Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
753 if (resolved_field != NULL && resolved_field->IsStatic()) {
754 Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
Ian Rogers1bddec32012-02-04 12:27:34 -0800755 if (referrer_class != NULL) {
jeffhao8cd6dda2012-02-22 10:15:34 -0800756 Class* fields_class = resolved_field->GetDeclaringClass();
757 if (fields_class == referrer_class) {
Ian Rogers1bddec32012-02-04 12:27:34 -0800758 is_referrers_class = true; // implies no worrying about class initialization
759 field_offset = resolved_field->GetOffset().Int32Value();
760 is_volatile = resolved_field->IsVolatile();
Ian Rogersc8b306f2012-02-17 21:34:44 -0800761 stats_->ResolvedLocalStaticField();
Ian Rogers1bddec32012-02-04 12:27:34 -0800762 return true; // fast path
763 } else {
Ian Rogerse2645d32012-04-11 14:42:42 -0700764 bool access_ok = referrer_class->CanAccess(fields_class) &&
765 referrer_class->CanAccessMember(fields_class,
766 resolved_field->GetAccessFlags());
767 if (!access_ok) {
768 // The referring class can't access the resolved field, this may occur as a result of a
769 // protected field being made public by a sub-class. Resort to the dex file to determine
770 // the correct class for the access check. Don't change the field's class as that is
771 // used to identify the SSB.
772 const DexFile& dex_file = mUnit->class_linker_->FindDexFile(referrer_class->GetDexCache());
773 Class* dex_fields_class =
774 mUnit->class_linker_->ResolveType(dex_file,
775 dex_file.GetFieldId(field_idx).class_idx_,
776 referrer_class);
777 access_ok = referrer_class->CanAccess(dex_fields_class) &&
778 referrer_class->CanAccessMember(dex_fields_class,
779 resolved_field->GetAccessFlags());
780 }
jeffhao8cd6dda2012-02-22 10:15:34 -0800781 bool is_write_to_final_from_wrong_class = is_put && resolved_field->IsFinal();
Ian Rogerse2645d32012-04-11 14:42:42 -0700782 if (access_ok && !is_write_to_final_from_wrong_class) {
Ian Rogers1bddec32012-02-04 12:27:34 -0800783 // We have the resolved field, we must make it into a ssbIndex for the referrer
784 // in its static storage base (which may fail if it doesn't have a slot for it)
Ian Rogers4103ad22012-02-06 09:18:25 -0800785 // TODO: for images we can elide the static storage base null check
786 // if we know there's a non-null entry in the image
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700787 DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
788 if (fields_class->GetDexCache() == dex_cache) {
Ian Rogers4103ad22012-02-06 09:18:25 -0800789 // common case where the dex cache of both the referrer and the field are the same,
790 // no need to search the dex file
791 ssb_index = fields_class->GetDexTypeIndex();
792 field_offset = resolved_field->GetOffset().Int32Value();
793 is_volatile = resolved_field->IsVolatile();
Ian Rogersc8b306f2012-02-17 21:34:44 -0800794 stats_->ResolvedStaticField();
Ian Rogers4103ad22012-02-06 09:18:25 -0800795 return true;
796 }
Ian Rogerse2645d32012-04-11 14:42:42 -0700797 // Search dex file for localized ssb index, may fail if field's class is a parent
798 // of the class mentioned in the dex file and there is no dex cache entry.
Ian Rogers1bddec32012-02-04 12:27:34 -0800799 std::string descriptor(FieldHelper(resolved_field).GetDeclaringClassDescriptor());
800 const DexFile::StringId* string_id =
Logan Chien4dd96f52012-02-29 01:26:58 +0800801 mUnit->dex_file_->FindStringId(descriptor);
Ian Rogers1bddec32012-02-04 12:27:34 -0800802 if (string_id != NULL) {
803 const DexFile::TypeId* type_id =
Logan Chien4dd96f52012-02-29 01:26:58 +0800804 mUnit->dex_file_->FindTypeId(mUnit->dex_file_->GetIndexForStringId(*string_id));
Elliott Hughesb25c3f62012-03-26 16:35:06 -0700805 if (type_id != NULL) {
Ian Rogers1bddec32012-02-04 12:27:34 -0800806 // medium path, needs check of static storage base being initialized
Logan Chien4dd96f52012-02-29 01:26:58 +0800807 ssb_index = mUnit->dex_file_->GetIndexForTypeId(*type_id);
Ian Rogers1bddec32012-02-04 12:27:34 -0800808 field_offset = resolved_field->GetOffset().Int32Value();
809 is_volatile = resolved_field->IsVolatile();
Ian Rogersc8b306f2012-02-17 21:34:44 -0800810 stats_->ResolvedStaticField();
Ian Rogers1bddec32012-02-04 12:27:34 -0800811 return true;
812 }
813 }
814 }
815 }
816 }
817 }
818 // Clean up any exception left by field/type resolution
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700819 if (soa.Self()->IsExceptionPending()) {
820 soa.Self()->ClearException();
Ian Rogers1bddec32012-02-04 12:27:34 -0800821 }
Ian Rogersc8b306f2012-02-17 21:34:44 -0800822 stats_->UnresolvedStaticField();
Ian Rogers1bddec32012-02-04 12:27:34 -0800823 return false; // Incomplete knowledge needs slow path.
824}
825
Ian Rogers2ed3b952012-03-17 11:49:39 -0700826void Compiler::GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type, Method* method,
827 uintptr_t& direct_code, uintptr_t& direct_method) {
828 direct_code = 0;
829 direct_method = 0;
830 if (sharp_type != kStatic && sharp_type != kDirect) {
831 return;
832 }
Ian Rogers2ed3b952012-03-17 11:49:39 -0700833 bool method_code_in_boot = method->GetDeclaringClass()->GetClassLoader() == NULL;
834 if (!method_code_in_boot) {
835 return;
836 }
837 bool has_clinit_trampoline = method->IsStatic() && !method->GetDeclaringClass()->IsInitialized();
838 if (has_clinit_trampoline) {
839 return;
840 }
841 stats_->DirectCallsToBoot(type);
842 stats_->DirectMethodsToBoot(type);
Ian Rogers3fa13792012-03-18 15:53:45 -0700843 bool compiling_boot = Runtime::Current()->GetHeap()->GetSpaces().size() == 1;
844 if (compiling_boot) {
Brian Carlstrom0637e272012-03-20 01:07:52 -0700845 const bool kSupportBootImageFixup = true;
Ian Rogers3fa13792012-03-18 15:53:45 -0700846 if (kSupportBootImageFixup) {
847 MethodHelper mh(method);
848 if (IsImageClass(mh.GetDeclaringClassDescriptor())) {
Brian Carlstrom0637e272012-03-20 01:07:52 -0700849 // We can only branch directly to Methods that are resolved in the DexCache.
850 // Otherwise we won't invoke the resolution trampoline.
Ian Rogers3fa13792012-03-18 15:53:45 -0700851 direct_method = -1;
Brian Carlstrom0637e272012-03-20 01:07:52 -0700852 direct_code = -1;
Ian Rogers3fa13792012-03-18 15:53:45 -0700853 }
Ian Rogers3fa13792012-03-18 15:53:45 -0700854 }
855 } else {
Mathieu Chartierb062fdd2012-07-03 09:51:48 -0700856 if (Runtime::Current()->GetHeap()->FindSpaceFromObject(method)->IsImageSpace()) {
Ian Rogers3fa13792012-03-18 15:53:45 -0700857 direct_method = reinterpret_cast<uintptr_t>(method);
858 }
859 direct_code = reinterpret_cast<uintptr_t>(method->GetCode());
Ian Rogers2ed3b952012-03-17 11:49:39 -0700860 }
Ian Rogers2ed3b952012-03-17 11:49:39 -0700861}
862
Ian Rogersfb6adba2012-03-04 21:51:51 -0800863bool Compiler::ComputeInvokeInfo(uint32_t method_idx, OatCompilationUnit* mUnit, InvokeType& type,
Ian Rogers2ed3b952012-03-17 11:49:39 -0700864 int& vtable_idx, uintptr_t& direct_code,
865 uintptr_t& direct_method) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700866 ScopedObjectAccess soa(Thread::Current());
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800867 vtable_idx = -1;
Ian Rogers2ed3b952012-03-17 11:49:39 -0700868 direct_code = 0;
869 direct_method = 0;
Ian Rogers08f753d2012-08-24 14:35:25 -0700870 Method* resolved_method =
871 ComputeMethodReferencedFromCompilingMethod(soa, mUnit, method_idx, type);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800872 if (resolved_method != NULL) {
Ian Rogers08f753d2012-08-24 14:35:25 -0700873 // Don't try to fast-path if we don't understand the caller's class or this appears to be an
874 // Incompatible Class Change Error.
875 Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
876 bool icce = resolved_method->CheckIncompatibleClassChange(type);
877 if (referrer_class != NULL && !icce) {
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800878 Class* methods_class = resolved_method->GetDeclaringClass();
879 if (!referrer_class->CanAccess(methods_class) ||
880 !referrer_class->CanAccessMember(methods_class,
Ian Rogers996cc582012-02-14 22:23:29 -0800881 resolved_method->GetAccessFlags())) {
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800882 // The referring class can't access the resolved method, this may occur as a result of a
883 // protected method being made public by implementing an interface that re-declares the
Ian Rogers08f753d2012-08-24 14:35:25 -0700884 // method public. Resort to the dex file to determine the correct class for the access
885 // check.
Logan Chien4dd96f52012-02-29 01:26:58 +0800886 const DexFile& dex_file = mUnit->class_linker_->FindDexFile(referrer_class->GetDexCache());
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800887 methods_class =
Logan Chien4dd96f52012-02-29 01:26:58 +0800888 mUnit->class_linker_->ResolveType(dex_file,
889 dex_file.GetMethodId(method_idx).class_idx_,
890 referrer_class);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800891 }
892 if (referrer_class->CanAccess(methods_class) &&
893 referrer_class->CanAccessMember(methods_class,
894 resolved_method->GetAccessFlags())) {
895 vtable_idx = resolved_method->GetMethodIndex();
Ian Rogersf320b632012-03-13 18:47:47 -0700896 const bool kEnableSharpening = true;
Ian Rogers2ed3b952012-03-17 11:49:39 -0700897 // Sharpen a virtual call into a direct call when the target is known.
898 bool can_sharpen = type == kVirtual && (resolved_method->IsFinal() ||
Ian Rogers08f753d2012-08-24 14:35:25 -0700899 methods_class->IsFinal());
900 // Ensure the vtable index will be correct to dispatch in the vtable of the super class.
jeffhao4155fcd2012-03-21 11:42:12 -0700901 can_sharpen = can_sharpen || (type == kSuper && referrer_class != methods_class &&
Ian Rogers08f753d2012-08-24 14:35:25 -0700902 referrer_class->IsSubClass(methods_class) &&
903 vtable_idx < methods_class->GetVTable()->GetLength() &&
904 methods_class->GetVTable()->Get(vtable_idx) == resolved_method);
Ian Rogers2ed3b952012-03-17 11:49:39 -0700905 if (kEnableSharpening && can_sharpen) {
906 stats_->ResolvedMethod(type);
Ian Rogersfb6adba2012-03-04 21:51:51 -0800907 // Sharpen a virtual call into a direct call. The method_idx is into referrer's
908 // dex cache, check that this resolved method is where we expect it.
909 CHECK(referrer_class->GetDexCache()->GetResolvedMethod(method_idx) == resolved_method)
Ian Rogers08f753d2012-08-24 14:35:25 -0700910 << PrettyMethod(resolved_method);
Ian Rogers2ed3b952012-03-17 11:49:39 -0700911 stats_->VirtualMadeDirect(type);
912 GetCodeAndMethodForDirectCall(type, kDirect, resolved_method, direct_code, direct_method);
913 type = kDirect;
914 return true;
915 } else if (type == kSuper) {
Ian Rogers08f753d2012-08-24 14:35:25 -0700916 // Unsharpened super calls are suspicious so go slow-path.
Ian Rogers2ed3b952012-03-17 11:49:39 -0700917 } else {
918 stats_->ResolvedMethod(type);
919 GetCodeAndMethodForDirectCall(type, type, resolved_method, direct_code, direct_method);
920 return true;
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800921 }
922 }
923 }
924 }
925 // Clean up any exception left by method/type resolution
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700926 if (soa.Self()->IsExceptionPending()) {
927 soa.Self()->ClearException();
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800928 }
Ian Rogersc8b306f2012-02-17 21:34:44 -0800929 stats_->UnresolvedMethod(type);
Ian Rogersa32a6fd2012-02-06 20:18:44 -0800930 return false; // Incomplete knowledge needs slow path.
931}
932
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700933void Compiler::AddCodePatch(const DexFile* dex_file,
Brian Carlstromf5822582012-03-19 22:34:31 -0700934 uint32_t referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700935 InvokeType referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700936 uint32_t target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700937 InvokeType target_invoke_type,
Ian Rogers3fa13792012-03-18 15:53:45 -0700938 size_t literal_offset) {
939 MutexLock mu(compiled_methods_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700940 code_to_patch_.push_back(new PatchInformation(dex_file,
Brian Carlstromf5822582012-03-19 22:34:31 -0700941 referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700942 referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700943 target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700944 target_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700945 literal_offset));
Ian Rogers3fa13792012-03-18 15:53:45 -0700946}
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700947void Compiler::AddMethodPatch(const DexFile* dex_file,
Brian Carlstromf5822582012-03-19 22:34:31 -0700948 uint32_t referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700949 InvokeType referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700950 uint32_t target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700951 InvokeType target_invoke_type,
Ian Rogers3fa13792012-03-18 15:53:45 -0700952 size_t literal_offset) {
953 MutexLock mu(compiled_methods_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700954 methods_to_patch_.push_back(new PatchInformation(dex_file,
Brian Carlstromf5822582012-03-19 22:34:31 -0700955 referrer_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700956 referrer_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700957 target_method_idx,
Ian Rogers08f753d2012-08-24 14:35:25 -0700958 target_invoke_type,
Brian Carlstromf5822582012-03-19 22:34:31 -0700959 literal_offset));
Ian Rogers3fa13792012-03-18 15:53:45 -0700960}
961
Ian Rogers0399dde2012-06-06 17:09:28 -0700962class CompilationContext {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800963 public:
Ian Rogers0399dde2012-06-06 17:09:28 -0700964 CompilationContext(ClassLinker* class_linker,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700965 jobject class_loader,
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800966 Compiler* compiler,
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800967 const DexFile* dex_file)
968 : class_linker_(class_linker),
969 class_loader_(class_loader),
970 compiler_(compiler),
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800971 dex_file_(dex_file) {}
972
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700973 ClassLinker* GetClassLinker() const {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800974 CHECK(class_linker_ != NULL);
975 return class_linker_;
976 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700977
978 jobject GetClassLoader() const {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800979 return class_loader_;
980 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700981
982 Compiler* GetCompiler() const {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800983 CHECK(compiler_ != NULL);
984 return compiler_;
985 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700986
987 const DexFile* GetDexFile() const {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -0800988 CHECK(dex_file_ != NULL);
989 return dex_file_;
990 }
991
992 private:
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700993 ClassLinker* const class_linker_;
994 const jobject class_loader_;
995 Compiler* const compiler_;
996 const DexFile* const dex_file_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -0800997};
998
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700999typedef void Callback(const CompilationContext* context, size_t index);
1000
1001static void ForAll(CompilationContext* context, size_t begin, size_t end, Callback callback,
1002 size_t thread_count);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001003
1004class WorkerThread {
1005 public:
Ian Rogers0399dde2012-06-06 17:09:28 -07001006 WorkerThread(CompilationContext* context, size_t begin, size_t end, Callback callback, size_t stripe, bool spawn)
Elliott Hughes1e409252012-02-06 11:21:27 -08001007 : spawn_(spawn), context_(context), begin_(begin), end_(end), callback_(callback), stripe_(stripe) {
1008 if (spawn_) {
Elliott Hughesbf1b4572012-05-24 19:11:39 -07001009 // Mac OS stacks are only 512KiB. Make sure we have the same stack size on all platforms.
1010 pthread_attr_t attr;
1011 CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new compiler worker thread");
1012 CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, 1*MB), "new compiler worker thread");
1013 CHECK_PTHREAD_CALL(pthread_create, (&pthread_, &attr, &Go, this), "new compiler worker thread");
1014 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new compiler worker thread");
Elliott Hughes1e409252012-02-06 11:21:27 -08001015 }
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001016 }
1017
1018 ~WorkerThread() {
Elliott Hughes1e409252012-02-06 11:21:27 -08001019 if (spawn_) {
1020 CHECK_PTHREAD_CALL(pthread_join, (pthread_, NULL), "compiler worker shutdown");
1021 }
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001022 }
1023
1024 private:
Ian Rogersb726dcb2012-09-05 08:57:23 -07001025 static void* Go(void* arg) LOCKS_EXCLUDED(Locks::mutator_lock_) {
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001026 WorkerThread* worker = reinterpret_cast<WorkerThread*>(arg);
1027 Runtime* runtime = Runtime::Current();
Elliott Hughes1e409252012-02-06 11:21:27 -08001028 if (worker->spawn_) {
Elliott Hughes462c9442012-03-23 18:47:50 -07001029 runtime->AttachCurrentThread("Compiler Worker", true, NULL);
Elliott Hughes1e409252012-02-06 11:21:27 -08001030 }
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001031 worker->Run();
Elliott Hughes1e409252012-02-06 11:21:27 -08001032 if (worker->spawn_) {
Elliott Hughes1e409252012-02-06 11:21:27 -08001033 runtime->DetachCurrentThread();
1034 }
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001035 return NULL;
1036 }
1037
Ian Rogersb726dcb2012-09-05 08:57:23 -07001038 void Go() LOCKS_EXCLUDED(Locks::mutator_lock_) {
Elliott Hughes1e409252012-02-06 11:21:27 -08001039 Go(this);
1040 }
1041
Ian Rogersb726dcb2012-09-05 08:57:23 -07001042 void Run() LOCKS_EXCLUDED(Locks::mutator_lock_) {
Brian Carlstrom64277f32012-03-26 23:53:34 -07001043 Thread* self = Thread::Current();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001044 for (size_t i = begin_; i < end_; i += stripe_) {
1045 callback_(context_, i);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001046 self->AssertNoPendingException();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001047 }
1048 }
1049
1050 pthread_t pthread_;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001051 // Was this thread spawned or is it the main thread?
1052 const bool spawn_;
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001053
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001054 const CompilationContext* const context_;
1055 const size_t begin_;
1056 const size_t end_;
Ian Rogers1b09b092012-08-20 15:35:52 -07001057 Callback* callback_;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001058 const size_t stripe_;
Elliott Hughes1e409252012-02-06 11:21:27 -08001059
Ian Rogers0399dde2012-06-06 17:09:28 -07001060 friend void ForAll(CompilationContext*, size_t, size_t, Callback, size_t);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001061};
1062
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001063static void ForAll(CompilationContext* context, size_t begin, size_t end, Callback callback,
1064 size_t thread_count)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001065 LOCKS_EXCLUDED(Locks::mutator_lock_) {
Brian Carlstrom64277f32012-03-26 23:53:34 -07001066 Thread* self = Thread::Current();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001067 self->AssertNoPendingException();
Elliott Hughes1e409252012-02-06 11:21:27 -08001068 CHECK_GT(thread_count, 0U);
Elliott Hughes81d91512012-02-03 16:38:43 -08001069
Elliott Hughes1e409252012-02-06 11:21:27 -08001070 std::vector<WorkerThread*> threads;
Elliott Hughes81d91512012-02-03 16:38:43 -08001071 for (size_t i = 0; i < thread_count; ++i) {
Elliott Hughes1e409252012-02-06 11:21:27 -08001072 threads.push_back(new WorkerThread(context, begin + i, end, callback, thread_count, (i != 0)));
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001073 }
Elliott Hughes1e409252012-02-06 11:21:27 -08001074 threads[0]->Go();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001075
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001076 // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
1077 // thread destructor's called below perform join).
1078 {
Ian Rogersb726dcb2012-09-05 08:57:23 -07001079 MutexLock mu(*Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001080 CHECK_NE(self->GetState(), kRunnable);
1081 }
Elliott Hughes81d91512012-02-03 16:38:43 -08001082 STLDeleteElements(&threads);
1083}
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001084
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001085// Return true if the class should be skipped during compilation. We
1086// never skip classes in the boot class loader. However, if we have a
1087// non-boot class loader and we can resolve the class in the boot
1088// class loader, we do skip the class. This happens if an app bundles
1089// classes found in the boot classpath. Since at runtime we will
1090// select the class from the boot classpath, do not attempt to resolve
1091// or compile it now.
1092static bool SkipClass(ClassLoader* class_loader,
1093 const DexFile& dex_file,
1094 const DexFile::ClassDef& class_def)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001095 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001096 if (class_loader == NULL) {
1097 return false;
1098 }
1099 const char* descriptor = dex_file.GetClassDescriptor(class_def);
1100 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1101 Class* klass = class_linker->FindClass(descriptor, NULL);
1102 if (klass == NULL) {
1103 Thread* self = Thread::Current();
1104 CHECK(self->IsExceptionPending());
1105 self->ClearException();
1106 return false;
1107 }
1108 return true;
1109}
1110
1111static void ResolveClassFieldsAndMethods(const CompilationContext* context, size_t class_def_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001112 LOCKS_EXCLUDED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001113 ScopedObjectAccess soa(Thread::Current());
1114 ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001115 const DexFile& dex_file = *context->GetDexFile();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001116
1117 // Method and Field are the worst. We can't resolve without either
1118 // context from the code use (to disambiguate virtual vs direct
1119 // method and instance vs static field) or from class
1120 // definitions. While the compiler will resolve what it can as it
1121 // needs it, here we try to resolve fields and methods used in class
1122 // definitions, since many of them many never be referenced by
1123 // generated code.
1124 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001125 if (SkipClass(class_loader, dex_file, class_def)) {
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001126 return;
1127 }
1128
1129 // Note the class_data pointer advances through the headers,
1130 // static fields, instance fields, direct methods, and virtual
1131 // methods.
1132 const byte* class_data = dex_file.GetClassData(class_def);
1133 if (class_data == NULL) {
1134 // empty class such as a marker interface
1135 return;
1136 }
Brian Carlstrom5ead0952011-11-28 22:55:52 -08001137 Thread* self = Thread::Current();
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001138 ClassLinker* class_linker = context->GetClassLinker();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001139 DexCache* dex_cache = class_linker->FindDexCache(dex_file);
1140 ClassDataItemIterator it(dex_file, class_data);
1141 while (it.HasNextStaticField()) {
1142 Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001143 class_loader, true);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001144 if (field == NULL) {
1145 CHECK(self->IsExceptionPending());
1146 self->ClearException();
1147 }
1148 it.Next();
1149 }
1150 while (it.HasNextInstanceField()) {
1151 Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001152 class_loader, false);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001153 if (field == NULL) {
1154 CHECK(self->IsExceptionPending());
1155 self->ClearException();
1156 }
1157 it.Next();
1158 }
1159 while (it.HasNextDirectMethod()) {
1160 Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
jeffhaoc0228b82012-08-29 18:15:05 -07001161 class_loader, NULL, it.GetMethodInvokeType(class_def));
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001162 if (method == NULL) {
1163 CHECK(self->IsExceptionPending());
1164 self->ClearException();
1165 }
1166 it.Next();
1167 }
1168 while (it.HasNextVirtualMethod()) {
1169 Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
jeffhaoc0228b82012-08-29 18:15:05 -07001170 class_loader, NULL, it.GetMethodInvokeType(class_def));
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001171 if (method == NULL) {
1172 CHECK(self->IsExceptionPending());
1173 self->ClearException();
1174 }
1175 it.Next();
1176 }
1177 DCHECK(!it.HasNext());
1178}
1179
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001180static void ResolveType(const CompilationContext* context, size_t type_idx)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001181 LOCKS_EXCLUDED(Locks::mutator_lock_) {
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001182 // Class derived values are more complicated, they require the linker and loader.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001183 ScopedObjectAccess soa(Thread::Current());
1184 ClassLinker* class_linker = context->GetClassLinker();
1185 const DexFile& dex_file = *context->GetDexFile();
1186 DexCache* dex_cache = class_linker->FindDexCache(dex_file);
1187 ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
1188 Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
1189
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001190 if (klass == NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001191 CHECK(soa.Self()->IsExceptionPending());
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001192 Thread::Current()->ClearException();
1193 }
1194}
1195
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001196void Compiler::ResolveDexFile(jobject class_loader, const DexFile& dex_file,
1197 TimingLogger& timings) {
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001198 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1199
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001200 // TODO: we could resolve strings here, although the string table is largely filled with class
1201 // and method names.
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001202
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001203 CompilationContext context(class_linker, class_loader, this, &dex_file);
1204 ForAll(&context, 0, dex_file.NumTypeIds(), ResolveType, thread_count_);
Elliott Hughesff738062012-02-03 15:00:42 -08001205 timings.AddSplit("Resolve " + dex_file.GetLocation() + " Types");
Brian Carlstrom845490b2011-09-19 15:56:53 -07001206
Elliott Hughes5523ee02012-02-03 18:18:34 -08001207 ForAll(&context, 0, dex_file.NumClassDefs(), ResolveClassFieldsAndMethods, thread_count_);
Elliott Hughesff738062012-02-03 15:00:42 -08001208 timings.AddSplit("Resolve " + dex_file.GetLocation() + " MethodsAndFields");
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001209}
1210
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001211void Compiler::Verify(jobject class_loader, const std::vector<const DexFile*>& dex_files) {
Brian Carlstromae826982011-11-09 01:33:42 -08001212 for (size_t i = 0; i != dex_files.size(); ++i) {
1213 const DexFile* dex_file = dex_files[i];
jeffhao98eacac2011-09-14 16:11:53 -07001214 CHECK(dex_file != NULL);
1215 VerifyDexFile(class_loader, *dex_file);
1216 }
1217}
1218
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001219static void VerifyClass(const CompilationContext* context, size_t class_def_index)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001220 LOCKS_EXCLUDED(Locks::mutator_lock_) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001221 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001222 const DexFile::ClassDef& class_def = context->GetDexFile()->GetClassDef(class_def_index);
1223 const char* descriptor = context->GetDexFile()->GetClassDescriptor(class_def);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001224 Class* klass =
1225 context->GetClassLinker()->FindClass(descriptor,
1226 soa.Decode<ClassLoader*>(context->GetClassLoader()));
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001227 if (klass == NULL) {
1228 Thread* self = Thread::Current();
1229 CHECK(self->IsExceptionPending());
1230 self->ClearException();
jeffhaof56197c2012-03-05 18:01:54 -08001231
1232 /*
1233 * At compile time, we can still structurally verify the class even if FindClass fails.
1234 * This is to ensure the class is structurally sound for compilation. An unsound class
1235 * will be rejected by the verifier and later skipped during compilation in the compiler.
1236 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001237 DexCache* dex_cache = context->GetClassLinker()->FindDexCache(*context->GetDexFile());
jeffhaof56197c2012-03-05 18:01:54 -08001238 std::string error_msg;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001239 if (verifier::MethodVerifier::VerifyClass(context->GetDexFile(),
1240 dex_cache,
1241 soa.Decode<ClassLoader*>(context->GetClassLoader()),
1242 class_def_index, error_msg) ==
1243 verifier::MethodVerifier::kHardFailure) {
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001244 const DexFile::ClassDef& class_def = context->GetDexFile()->GetClassDef(class_def_index);
jeffhaof56197c2012-03-05 18:01:54 -08001245 LOG(ERROR) << "Verification failed on class "
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001246 << PrettyDescriptor(context->GetDexFile()->GetClassDescriptor(class_def))
jeffhaof56197c2012-03-05 18:01:54 -08001247 << " because: " << error_msg;
1248 }
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001249 return;
1250 }
1251 CHECK(klass->IsResolved()) << PrettyClass(klass);
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001252 context->GetClassLinker()->VerifyClass(klass);
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001253
1254 if (klass->IsErroneous()) {
1255 // ClassLinker::VerifyClass throws, which isn't useful in the compiler.
1256 CHECK(Thread::Current()->IsExceptionPending());
1257 Thread::Current()->ClearException();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001258 }
1259
Ian Rogers9ffb0392012-09-10 11:56:50 -07001260 CHECK(klass->IsCompileTimeVerified() || klass->IsErroneous())
1261 << PrettyDescriptor(klass) << ": state=" << klass->GetStatus();
Elliott Hughesd9c67be2012-02-02 19:54:06 -08001262 CHECK(!Thread::Current()->IsExceptionPending()) << PrettyTypeOf(Thread::Current()->GetException());
1263}
1264
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001265void Compiler::VerifyDexFile(jobject class_loader, const DexFile& dex_file) {
jeffhaob4df5142011-09-19 20:25:32 -07001266 dex_file.ChangePermissions(PROT_READ | PROT_WRITE);
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07001267
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001268 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001269 jobject dex_cache;
1270 {
1271 ScopedObjectAccess soa(Thread::Current());
1272 ScopedLocalRef<jobject>
1273 dex_cache_local(soa.Env(),
1274 soa.AddLocalReference<jobject>(class_linker->FindDexCache(dex_file)));
1275 dex_cache = soa.Env()->NewGlobalRef(dex_cache_local.get());
1276 }
1277 CompilationContext context(class_linker, class_loader, this, &dex_file);
Elliott Hughes5523ee02012-02-03 18:18:34 -08001278 ForAll(&context, 0, dex_file.NumClassDefs(), VerifyClass, thread_count_);
Elliott Hughesd9cdfe92011-10-06 16:09:04 -07001279
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001280 Thread::Current()->GetJniEnv()->DeleteGlobalRef(dex_cache);
jeffhaob4df5142011-09-19 20:25:32 -07001281 dex_file.ChangePermissions(PROT_READ);
Brian Carlstroma5a97a22011-09-15 14:08:49 -07001282}
1283
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001284void Compiler::InitializeClassesWithoutClinit(jobject class_loader,
Brian Carlstromae826982011-11-09 01:33:42 -08001285 const std::vector<const DexFile*>& dex_files) {
1286 for (size_t i = 0; i != dex_files.size(); ++i) {
1287 const DexFile* dex_file = dex_files[i];
Brian Carlstroma5a97a22011-09-15 14:08:49 -07001288 CHECK(dex_file != NULL);
1289 InitializeClassesWithoutClinit(class_loader, *dex_file);
1290 }
1291}
1292
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001293void Compiler::InitializeClassesWithoutClinit(jobject jni_class_loader, const DexFile& dex_file) {
1294 ScopedObjectAccess soa(Thread::Current());
1295 ClassLoader* class_loader = soa.Decode<ClassLoader*>(jni_class_loader);
Brian Carlstroma5a97a22011-09-15 14:08:49 -07001296 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Brian Carlstromffca45d2011-09-16 12:10:49 -07001297 for (size_t class_def_index = 0; class_def_index < dex_file.NumClassDefs(); class_def_index++) {
1298 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
Brian Carlstroma5a97a22011-09-15 14:08:49 -07001299 const char* descriptor = dex_file.GetClassDescriptor(class_def);
1300 Class* klass = class_linker->FindClass(descriptor, class_loader);
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001301 if (klass != NULL) {
jeffhao1ac29442012-03-26 11:37:32 -07001302 if (klass->IsVerified()) {
1303 // Only try to initialize classes that were successfully verified.
Ian Rogers0045a292012-03-31 21:08:41 -07001304 bool compiling_boot = Runtime::Current()->GetHeap()->GetSpaces().size() == 1;
1305 bool can_init_static_fields = compiling_boot &&
1306 IsImageClass(descriptor);
1307 class_linker->EnsureInitialized(klass, false, can_init_static_fields);
jeffhao1ac29442012-03-26 11:37:32 -07001308 }
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001309 // record the final class status if necessary
1310 Class::Status status = klass->GetStatus();
1311 ClassReference ref(&dex_file, class_def_index);
1312 CompiledClass* compiled_class = GetCompiledClass(ref);
1313 if (compiled_class == NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001314 MutexLock mu(compiled_classes_lock_);
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001315 compiled_class = new CompiledClass(status);
Elliott Hughesa0e18062012-04-13 15:59:59 -07001316 compiled_classes_.Put(ref, compiled_class);
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001317 } else {
1318 DCHECK_EQ(status, compiled_class->GetStatus());
1319 }
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001320 }
1321 // clear any class not found or verification exceptions
1322 Thread::Current()->ClearException();
Brian Carlstromffca45d2011-09-16 12:10:49 -07001323 }
1324
1325 DexCache* dex_cache = class_linker->FindDexCache(dex_file);
1326 for (size_t type_idx = 0; type_idx < dex_cache->NumResolvedTypes(); type_idx++) {
1327 Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
Brian Carlstrom27ec9612011-09-19 20:20:38 -07001328 if (klass == NULL) {
1329 Thread::Current()->ClearException();
1330 } else if (klass->IsInitialized()) {
Brian Carlstromffca45d2011-09-16 12:10:49 -07001331 dex_cache->GetInitializedStaticStorage()->Set(type_idx, klass);
1332 }
jeffhao98eacac2011-09-14 16:11:53 -07001333 }
1334}
1335
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001336// TODO: This class shares some implementation with WorkerThread. We don't want
1337// to perturb the non-LLVM side at the same time. Staging the refactoring for
1338// the future.
1339class DexFilesWorkerThread {
1340 public:
Ian Rogers0399dde2012-06-06 17:09:28 -07001341 DexFilesWorkerThread(CompilationContext *worker_context, Callback class_callback,
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001342 const std::vector<const DexFile*>& dex_files,
1343 volatile int32_t* shared_class_index, bool spawn)
1344 : spawn_(spawn), worker_context_(worker_context),
1345 class_callback_(class_callback), dex_files_(dex_files),
1346 context_(NULL), shared_class_index_(shared_class_index) {
1347 if (spawn_) {
TDYa1278cea5fd2012-05-29 22:22:32 -07001348 pthread_attr_t attr;
1349 CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new compiler worker thread");
TDYa12761b409c2012-06-05 23:54:30 -07001350 CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, 1*MB), "new compiler worker thread");
TDYa1278cea5fd2012-05-29 22:22:32 -07001351 CHECK_PTHREAD_CALL(pthread_create, (&pthread_, &attr, &Go, this), "new compiler worker thread");
1352 CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new compiler worker thread");
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001353 }
1354 }
1355
1356 ~DexFilesWorkerThread() {
1357 if (spawn_) {
1358 CHECK_PTHREAD_CALL(pthread_join, (pthread_, NULL), "compiler worker shutdown");
1359 }
1360 delete context_;
1361 }
1362
1363 private:
1364 static void* Go(void* arg) {
1365 DexFilesWorkerThread* worker = reinterpret_cast<DexFilesWorkerThread*>(arg);
1366 Runtime* runtime = Runtime::Current();
1367 if (worker->spawn_) {
1368 runtime->AttachCurrentThread("Compiler Worker", true, NULL);
1369 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001370 {
1371 ScopedObjectAccess soa(Thread::Current());
1372 worker->Run();
1373 }
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001374 if (worker->spawn_) {
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001375 runtime->DetachCurrentThread();
1376 }
1377 return NULL;
1378 }
1379
1380 void Go() {
1381 Go(this);
1382 }
1383
1384 void SwitchToDexFile(size_t dex_file_index) {
Elliott Hughesa21039c2012-06-21 12:09:25 -07001385 CHECK_LT(dex_file_index, dex_files_.size());
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001386
1387 const DexFile* dex_file = dex_files_[dex_file_index];
1388 CHECK(dex_file != NULL);
1389
1390 // Destroy the old context
1391 delete context_;
1392
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001393 // TODO: Add a callback to let the client specify the class_linker in the context for the
1394 // current working dex file.
Ian Rogers0399dde2012-06-06 17:09:28 -07001395 context_ = new CompilationContext(/* class_linker */NULL,
1396 worker_context_->GetClassLoader(),
1397 worker_context_->GetCompiler(),
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001398 dex_file);
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001399
1400 CHECK(context_ != NULL);
1401 }
1402
1403 void Run() {
1404 Thread* self = Thread::Current();
1405 size_t cur_dex_file_index = 0;
1406 size_t class_index_base = 0;
1407
1408 SwitchToDexFile(0);
1409
1410 while (true) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001411 size_t class_index = static_cast<size_t>(android_atomic_inc(shared_class_index_));
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001412
1413 const DexFile* dex_file;
1414 do {
1415 dex_file = dex_files_[cur_dex_file_index];
1416
1417 if (class_index < (class_index_base + dex_file->NumClassDefs())) {
1418 break;
1419 }
1420 class_index_base += dex_file->NumClassDefs();
1421
1422 cur_dex_file_index++;
1423 } while (cur_dex_file_index < dex_files_.size());
1424
1425 if (cur_dex_file_index >= dex_files_.size()) {
1426 return;
1427 }
1428
1429 if (dex_file != context_->GetDexFile()) {
1430 SwitchToDexFile(cur_dex_file_index);
1431 }
1432
1433 class_index -= class_index_base;
1434 class_callback_(context_, class_index);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001435 self->AssertNoPendingException();
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001436 }
1437 }
1438
1439 pthread_t pthread_;
1440 bool spawn_;
1441
Ian Rogers0399dde2012-06-06 17:09:28 -07001442 CompilationContext* worker_context_;
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001443 Callback* class_callback_;
1444 const std::vector<const DexFile*>& dex_files_;
1445
Ian Rogers0399dde2012-06-06 17:09:28 -07001446 CompilationContext* context_;
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001447 volatile int32_t* shared_class_index_;
1448
Ian Rogers0399dde2012-06-06 17:09:28 -07001449 friend void ForClassesInAllDexFiles(CompilationContext*,
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001450 const std::vector<const DexFile*>&,
1451 Callback, size_t);
1452};
1453
Ian Rogers0399dde2012-06-06 17:09:28 -07001454void ForClassesInAllDexFiles(CompilationContext* worker_context,
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001455 const std::vector<const DexFile*>& dex_files,
1456 Callback class_callback, size_t thread_count) {
1457 Thread* self = Thread::Current();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001458 self->AssertNoPendingException();
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001459 CHECK_GT(thread_count, 0U);
1460
1461 std::vector<DexFilesWorkerThread*> threads;
1462 volatile int32_t shared_class_index = 0;
1463
1464 for (size_t i = 0; i < thread_count; ++i) {
1465 threads.push_back(new DexFilesWorkerThread(worker_context, class_callback,
1466 dex_files, &shared_class_index,
1467 /* spawn */ (i != 0)));
1468 }
1469 threads[0]->Go();
1470
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001471 // Ensure we're suspended while we're blocked waiting for the other threads to finish (worker
1472 // thread destructor's called below perform join).
1473 {
Ian Rogersb726dcb2012-09-05 08:57:23 -07001474 MutexLock mu(*Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001475 CHECK_NE(self->GetState(), kRunnable);
1476 }
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001477 STLDeleteElements(&threads);
1478}
1479
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001480void Compiler::Compile(jobject class_loader, const std::vector<const DexFile*>& dex_files) {
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001481#if defined(ART_USE_LLVM_COMPILER)
1482 if (dex_files.size() <= 0) {
1483 return; // No dex file
1484 }
Ian Rogersc05f85a2012-08-14 15:39:34 -07001485 CompilationContext context(NULL, class_loader, this, NULL);
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001486 ForClassesInAllDexFiles(&context, dex_files, Compiler::CompileClass, thread_count_);
1487#else
Brian Carlstromae826982011-11-09 01:33:42 -08001488 for (size_t i = 0; i != dex_files.size(); ++i) {
1489 const DexFile* dex_file = dex_files[i];
Brian Carlstrom83db7722011-08-26 17:32:56 -07001490 CHECK(dex_file != NULL);
1491 CompileDexFile(class_loader, *dex_file);
1492 }
Shih-wei Liao90dc30f2012-04-23 02:03:30 -07001493#endif
Brian Carlstrom83db7722011-08-26 17:32:56 -07001494}
1495
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001496void Compiler::CompileClass(const CompilationContext* context, size_t class_def_index) {
1497 jobject class_loader = context->GetClassLoader();
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001498 const DexFile& dex_file = *context->GetDexFile();
Elliott Hughesc225caa2012-02-03 15:43:37 -08001499 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001500 {
1501 ScopedObjectAccess soa(Thread::Current());
1502 ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
1503 if (SkipClass(class_loader, dex_file, class_def)) {
1504 return;
1505 }
Brian Carlstrom5ead0952011-11-28 22:55:52 -08001506 }
jeffhaod1224c72012-02-29 13:43:08 -08001507 ClassReference ref(&dex_file, class_def_index);
1508 // Skip compiling classes with generic verifier failures since they will still fail at runtime
Ian Rogers776ac1f2012-04-13 23:36:36 -07001509 if (verifier::MethodVerifier::IsClassRejected(ref)) {
jeffhaod1224c72012-02-29 13:43:08 -08001510 return;
1511 }
Ian Rogers0571d352011-11-03 19:51:38 -07001512 const byte* class_data = dex_file.GetClassData(class_def);
1513 if (class_data == NULL) {
1514 // empty class, probably a marker interface
1515 return;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001516 }
Ian Rogers0571d352011-11-03 19:51:38 -07001517 ClassDataItemIterator it(dex_file, class_data);
1518 // Skip fields
1519 while (it.HasNextStaticField()) {
1520 it.Next();
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001521 }
Ian Rogers0571d352011-11-03 19:51:38 -07001522 while (it.HasNextInstanceField()) {
1523 it.Next();
1524 }
1525 // Compile direct methods
Brian Carlstrom68adbe42012-05-11 17:18:08 -07001526 int64_t previous_direct_method_idx = -1;
Ian Rogers0571d352011-11-03 19:51:38 -07001527 while (it.HasNextDirectMethod()) {
Brian Carlstrom6f29d0e2012-05-11 15:50:29 -07001528 uint32_t method_idx = it.GetMemberIndex();
1529 if (method_idx == previous_direct_method_idx) {
1530 // smali can create dex files with two encoded_methods sharing the same method_idx
1531 // http://code.google.com/p/smali/issues/detail?id=119
1532 it.Next();
1533 continue;
1534 }
1535 previous_direct_method_idx = method_idx;
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001536 context->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
Ian Rogers08f753d2012-08-24 14:35:25 -07001537 it.GetMethodInvokeType(class_def), method_idx,
1538 class_loader, dex_file);
Ian Rogers0571d352011-11-03 19:51:38 -07001539 it.Next();
1540 }
1541 // Compile virtual methods
Brian Carlstrom68adbe42012-05-11 17:18:08 -07001542 int64_t previous_virtual_method_idx = -1;
Ian Rogers0571d352011-11-03 19:51:38 -07001543 while (it.HasNextVirtualMethod()) {
Brian Carlstrom6f29d0e2012-05-11 15:50:29 -07001544 uint32_t method_idx = it.GetMemberIndex();
1545 if (method_idx == previous_virtual_method_idx) {
1546 // smali can create dex files with two encoded_methods sharing the same method_idx
1547 // http://code.google.com/p/smali/issues/detail?id=119
1548 it.Next();
1549 continue;
1550 }
1551 previous_virtual_method_idx = method_idx;
Brian Carlstrom731b2ab2012-03-06 16:53:35 -08001552 context->GetCompiler()->CompileMethod(it.GetMethodCodeItem(), it.GetMemberAccessFlags(),
Ian Rogers08f753d2012-08-24 14:35:25 -07001553 it.GetMethodInvokeType(class_def), method_idx,
1554 class_loader, dex_file);
Ian Rogers0571d352011-11-03 19:51:38 -07001555 it.Next();
1556 }
1557 DCHECK(!it.HasNext());
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001558}
1559
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001560void Compiler::CompileDexFile(jobject class_loader, const DexFile& dex_file) {
1561 CompilationContext context(NULL, class_loader, this, &dex_file);
Elliott Hughes5523ee02012-02-03 18:18:34 -08001562 ForAll(&context, 0, dex_file.NumClassDefs(), Compiler::CompileClass, thread_count_);
Elliott Hughesc225caa2012-02-03 15:43:37 -08001563}
1564
Elliott Hughesa0e18062012-04-13 15:59:59 -07001565static std::string MakeInvokeStubKey(bool is_static, const char* shorty) {
1566 std::string key(shorty);
1567 if (is_static) {
1568 key += "$"; // Must not be a shorty type character.
1569 }
1570 return key;
1571}
1572
Ian Rogersa3760aa2011-11-14 14:32:37 -08001573void Compiler::CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags,
Ian Rogers08f753d2012-08-24 14:35:25 -07001574 InvokeType invoke_type, uint32_t method_idx, jobject class_loader,
Ian Rogersa3760aa2011-11-14 14:32:37 -08001575 const DexFile& dex_file) {
Elliott Hughesf09afe82011-10-16 14:24:21 -07001576 CompiledMethod* compiled_method = NULL;
Elliott Hughesbb551fa2012-01-25 16:35:29 -08001577 uint64_t start_ns = NanoTime();
Logan Chien4dd96f52012-02-29 01:26:58 +08001578
Ian Rogers169c9a72011-11-13 20:13:17 -08001579 if ((access_flags & kAccNative) != 0) {
Ian Rogers57b86d42012-03-27 16:05:41 -07001580 compiled_method = (*jni_compiler_)(*this, access_flags, method_idx, dex_file);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001581 CHECK(compiled_method != NULL);
Ian Rogers169c9a72011-11-13 20:13:17 -08001582 } else if ((access_flags & kAccAbstract) != 0) {
Brian Carlstrom2cc022b2011-08-25 10:05:39 -07001583 } else {
Ian Rogers08f753d2012-08-24 14:35:25 -07001584 compiled_method = (*compiler_)(*this, code_item, access_flags, invoke_type, method_idx,
1585 class_loader, dex_file);
Elliott Hughesbb551fa2012-01-25 16:35:29 -08001586 CHECK(compiled_method != NULL) << PrettyMethod(method_idx, dex_file);
1587 }
Ian Rogers3bb17a62012-01-27 23:56:44 -08001588 uint64_t duration_ns = NanoTime() - start_ns;
buzbee5abfa3e2012-01-31 17:01:43 -08001589 if (duration_ns > MsToNs(100)) {
Elliott Hughesbb551fa2012-01-25 16:35:29 -08001590 LOG(WARNING) << "Compilation of " << PrettyMethod(method_idx, dex_file)
Ian Rogers3bb17a62012-01-27 23:56:44 -08001591 << " took " << PrettyDuration(duration_ns);
Elliott Hughesf09afe82011-10-16 14:24:21 -07001592 }
1593
1594 if (compiled_method != NULL) {
Ian Rogers0571d352011-11-03 19:51:38 -07001595 MethodReference ref(&dex_file, method_idx);
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001596 CHECK(GetCompiledMethod(ref) == NULL) << PrettyMethod(method_idx, dex_file);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001597 {
1598 MutexLock mu(compiled_methods_lock_);
1599 compiled_methods_.Put(ref, compiled_method);
1600 }
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001601 DCHECK(GetCompiledMethod(ref) != NULL) << PrettyMethod(method_idx, dex_file);
Brian Carlstrom2cc022b2011-08-25 10:05:39 -07001602 }
Brian Carlstrom9baa4ae2011-09-01 21:14:14 -07001603
Ian Rogers45619fc2012-02-29 11:15:25 -08001604 uint32_t shorty_len;
1605 const char* shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx), &shorty_len);
Ian Rogers169c9a72011-11-13 20:13:17 -08001606 bool is_static = (access_flags & kAccStatic) != 0;
Elliott Hughesa0e18062012-04-13 15:59:59 -07001607 std::string key(MakeInvokeStubKey(is_static, shorty));
1608 const CompiledInvokeStub* compiled_invoke_stub = FindInvokeStub(key);
Ian Rogers0571d352011-11-03 19:51:38 -07001609 if (compiled_invoke_stub == NULL) {
Shih-wei Liaoc4c98812012-03-10 21:55:51 -08001610 compiled_invoke_stub = (*create_invoke_stub_)(*this, is_static, shorty, shorty_len);
Ian Rogers0571d352011-11-03 19:51:38 -07001611 CHECK(compiled_invoke_stub != NULL);
Elliott Hughesa0e18062012-04-13 15:59:59 -07001612 InsertInvokeStub(key, compiled_invoke_stub);
Ian Rogers2c8f6532011-09-02 17:16:34 -07001613 }
Logan Chien7a2a23a2012-06-06 11:01:00 +08001614
1615#if defined(ART_USE_LLVM_COMPILER)
1616 if (!is_static) {
1617 const CompiledInvokeStub* compiled_proxy_stub = FindProxyStub(shorty);
1618 if (compiled_proxy_stub == NULL) {
1619 compiled_proxy_stub = (*create_proxy_stub_)(*this, shorty, shorty_len);
1620 CHECK(compiled_proxy_stub != NULL);
1621 InsertProxyStub(shorty, compiled_proxy_stub);
1622 }
1623 }
1624#endif
1625
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001626 if (Thread::Current()->IsExceptionPending()) {
1627 ScopedObjectAccess soa(Thread::Current());
1628 LOG(FATAL) << "Unexpected exception compiling: " << PrettyMethod(method_idx, dex_file) << "\n"
1629 << Thread::Current()->GetException()->Dump();
1630 }
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001631}
1632
Elliott Hughesa0e18062012-04-13 15:59:59 -07001633const CompiledInvokeStub* Compiler::FindInvokeStub(bool is_static, const char* shorty) const {
1634 const std::string key(MakeInvokeStubKey(is_static, shorty));
1635 return FindInvokeStub(key);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001636}
1637
Elliott Hughesa0e18062012-04-13 15:59:59 -07001638const CompiledInvokeStub* Compiler::FindInvokeStub(const std::string& key) const {
Elliott Hughesc225caa2012-02-03 15:43:37 -08001639 MutexLock mu(compiled_invoke_stubs_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -07001640 InvokeStubTable::const_iterator it = compiled_invoke_stubs_.find(key);
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001641 if (it == compiled_invoke_stubs_.end()) {
1642 return NULL;
Ian Rogers0571d352011-11-03 19:51:38 -07001643 } else {
1644 DCHECK(it->second != NULL);
1645 return it->second;
1646 }
1647}
1648
Elliott Hughesa0e18062012-04-13 15:59:59 -07001649void Compiler::InsertInvokeStub(const std::string& key,
Ian Rogers0571d352011-11-03 19:51:38 -07001650 const CompiledInvokeStub* compiled_invoke_stub) {
Elliott Hughesc225caa2012-02-03 15:43:37 -08001651 MutexLock mu(compiled_invoke_stubs_lock_);
Elliott Hughesa0e18062012-04-13 15:59:59 -07001652 InvokeStubTable::iterator it = compiled_invoke_stubs_.find(key);
1653 if (it != compiled_invoke_stubs_.end()) {
1654 // Someone else won the race.
1655 delete compiled_invoke_stub;
1656 } else {
1657 compiled_invoke_stubs_.Put(key, compiled_invoke_stub);
1658 }
Ian Rogers0571d352011-11-03 19:51:38 -07001659}
1660
Logan Chien7a2a23a2012-06-06 11:01:00 +08001661#if defined(ART_USE_LLVM_COMPILER)
1662const CompiledInvokeStub* Compiler::FindProxyStub(const char* shorty) const {
1663 MutexLock mu(compiled_proxy_stubs_lock_);
1664 ProxyStubTable::const_iterator it = compiled_proxy_stubs_.find(shorty);
1665 if (it == compiled_proxy_stubs_.end()) {
1666 return NULL;
1667 } else {
1668 DCHECK(it->second != NULL);
1669 return it->second;
1670 }
1671}
1672
1673void Compiler::InsertProxyStub(const char* shorty,
1674 const CompiledInvokeStub* compiled_proxy_stub) {
1675 MutexLock mu(compiled_proxy_stubs_lock_);
1676 InvokeStubTable::iterator it = compiled_proxy_stubs_.find(shorty);
1677 if (it != compiled_proxy_stubs_.end()) {
1678 // Someone else won the race.
1679 delete compiled_proxy_stub;
1680 } else {
1681 compiled_proxy_stubs_.Put(shorty, compiled_proxy_stub);
1682 }
1683}
1684#endif
1685
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001686CompiledClass* Compiler::GetCompiledClass(ClassReference ref) const {
Elliott Hughesc225caa2012-02-03 15:43:37 -08001687 MutexLock mu(compiled_classes_lock_);
Brian Carlstrom0755ec52012-01-11 15:19:46 -08001688 ClassTable::const_iterator it = compiled_classes_.find(ref);
1689 if (it == compiled_classes_.end()) {
1690 return NULL;
1691 }
1692 CHECK(it->second != NULL);
1693 return it->second;
1694}
1695
Ian Rogers0571d352011-11-03 19:51:38 -07001696CompiledMethod* Compiler::GetCompiledMethod(MethodReference ref) const {
Elliott Hughesc225caa2012-02-03 15:43:37 -08001697 MutexLock mu(compiled_methods_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -07001698 MethodTable::const_iterator it = compiled_methods_.find(ref);
1699 if (it == compiled_methods_.end()) {
1700 return NULL;
Brian Carlstrom3320cf42011-10-04 14:58:28 -07001701 }
1702 CHECK(it->second != NULL);
1703 return it->second;
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001704}
1705
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001706void Compiler::SetGcMaps(jobject class_loader, const std::vector<const DexFile*>& dex_files) {
Brian Carlstrome7d856b2012-01-11 18:10:55 -08001707 for (size_t i = 0; i != dex_files.size(); ++i) {
1708 const DexFile* dex_file = dex_files[i];
1709 CHECK(dex_file != NULL);
1710 SetGcMapsDexFile(class_loader, *dex_file);
1711 }
1712}
1713
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001714void Compiler::SetGcMapsDexFile(jobject jni_class_loader, const DexFile& dex_file) {
1715 ScopedObjectAccess soa(Thread::Current());
1716 ClassLoader* class_loader = soa.Decode<ClassLoader*>(jni_class_loader);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08001717 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
1718 DexCache* dex_cache = class_linker->FindDexCache(dex_file);
1719 for (size_t class_def_index = 0; class_def_index < dex_file.NumClassDefs(); class_def_index++) {
1720 const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
1721 const char* descriptor = dex_file.GetClassDescriptor(class_def);
1722 Class* klass = class_linker->FindClass(descriptor, class_loader);
1723 if (klass == NULL || !klass->IsVerified()) {
1724 Thread::Current()->ClearException();
1725 continue;
1726 }
1727 const byte* class_data = dex_file.GetClassData(class_def);
1728 if (class_data == NULL) {
1729 // empty class such as a marker interface
1730 continue;
1731 }
1732 ClassDataItemIterator it(dex_file, class_data);
1733 while (it.HasNextStaticField()) {
1734 it.Next();
1735 }
1736 while (it.HasNextInstanceField()) {
1737 it.Next();
1738 }
1739 while (it.HasNextDirectMethod()) {
1740 Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
jeffhaoc0228b82012-08-29 18:15:05 -07001741 class_loader, NULL, it.GetMethodInvokeType(class_def));
Brian Carlstrome7d856b2012-01-11 18:10:55 -08001742 SetGcMapsMethod(dex_file, method);
1743 it.Next();
1744 }
1745 while (it.HasNextVirtualMethod()) {
1746 Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
jeffhaoc0228b82012-08-29 18:15:05 -07001747 class_loader, NULL, it.GetMethodInvokeType(class_def));
Brian Carlstrome7d856b2012-01-11 18:10:55 -08001748 SetGcMapsMethod(dex_file, method);
1749 it.Next();
1750 }
1751 }
1752}
1753
1754void Compiler::SetGcMapsMethod(const DexFile& dex_file, Method* method) {
1755 if (method == NULL) {
1756 Thread::Current()->ClearException();
1757 return;
1758 }
1759 uint16_t method_idx = method->GetDexMethodIndex();
1760 MethodReference ref(&dex_file, method_idx);
1761 CompiledMethod* compiled_method = GetCompiledMethod(ref);
1762 if (compiled_method == NULL) {
1763 return;
1764 }
Ian Rogers776ac1f2012-04-13 23:36:36 -07001765 const std::vector<uint8_t>* gc_map = verifier::MethodVerifier::GetGcMap(ref);
Brian Carlstrome7d856b2012-01-11 18:10:55 -08001766 if (gc_map == NULL) {
1767 return;
1768 }
1769 compiled_method->SetGcMap(*gc_map);
1770}
1771
buzbee2cfc6392012-05-07 14:51:40 -07001772#if defined(ART_USE_LLVM_COMPILER) || defined(ART_USE_QUICK_COMPILER)
Logan Chien8b977d32012-02-21 19:14:55 +08001773void Compiler::SetBitcodeFileName(std::string const& filename) {
Logan Chien106b2a02012-03-18 04:41:38 +08001774 typedef void (*SetBitcodeFileNameFn)(Compiler&, std::string const&);
1775
1776 SetBitcodeFileNameFn set_bitcode_file_name =
1777 FindFunction<SetBitcodeFileNameFn>(MakeCompilerSoName(instruction_set_),
1778 compiler_library_,
1779 "compilerLLVMSetBitcodeFileName");
1780
1781 set_bitcode_file_name(*this, filename);
Logan Chien8b977d32012-02-21 19:14:55 +08001782}
buzbee2cfc6392012-05-07 14:51:40 -07001783#endif
Logan Chienf7015fd2012-03-18 01:19:37 +08001784
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -07001785} // namespace art